@ouro.bot/cli 0.1.0-alpha.764 → 0.1.0-alpha.766

package/changelog.json

@@ -1,6 +1,21 @@
 {
   "_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.766",
+      "changes": [
+        "Keep Sanctuary status summaries grounded in successful current reads and stale-care-safe evidence.",
+        "Render Butler Telegram replies without literal bold markers while preserving commands and data.",
+        "Keep the packaged visibility contract clear of retired module markers."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.765",
+      "changes": [
+        "Require configured turn-local reads before accepting either tool-based or plain-text terminal responses, and fail closed at the bounded provider-turn cap when those reads never run.",
+        "Give Telegram concise phone-native plain-text response guidance instead of Teams Markdown guidance."
+      ]
+    },
     {
       "version": "0.1.0-alpha.764",
       "changes": [

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

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.764",
+  "runtimeVersion": "0.1.0-alpha.766",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-08-30T00:00:00.000Z"
 }

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.764</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.766</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/core.js

@@ -569,6 +569,11 @@ function toolResultIndicatesFailure(content) {
         || normalized.startsWith("blocked:")
         || normalized.startsWith("rejected:");
 }
+function requiredToolResultSucceeded(name, content, validate) {
+    if (toolResultIndicatesFailure(content))
+        return false;
+    return validate?.(name, content) ?? true;
+}
 function effectFingerprint(name, rawArguments) {
     let args;
     try {
@@ -1122,6 +1127,18 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let providerIterations = 0;
     const requiredToolCallNames = [...new Set(options?.requiredToolCalls?.names ?? [])];
     const dispatchedRequiredToolCalls = new Set();
+    const pendingRequiredToolCalls = () => {
+        const missing = requiredToolCallNames.filter((name) => !dispatchedRequiredToolCalls.has(name));
+        return missing.length > 0
+            ? { missing, message: `${options.requiredToolCalls.retryMessage} Missing required tool calls: ${missing.join(", ")}.` }
+            : null;
+    };
+    const queueRequiredCorrection = (message, limitContext) => {
+        if (providerIterations >= exports.MAX_PROVIDER_ITERATIONS)
+            throw new Error(`provider iteration limit exhausted at response ${exports.MAX_PROVIDER_ITERATIONS} ${limitContext}`);
+        messages.push({ role: "user", content: message });
+        providerRuntime.resetTurnState(messages);
+    };
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
     const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
     const finishTerminalProviderError = (error, classification) => {
@@ -1520,6 +1537,28 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     });
                     continue;
                 }
+                const requiredToolCallsGate = pendingRequiredToolCalls();
+                if (requiredToolCallsGate) {
+                    streamCallbackBuffer?.discard();
+                    callbacks.onClearText?.();
+                    queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "engine",
+                        event: "engine.required_tool_calls_pending",
+                        message: "terminal response rejected until required tool handlers dispatch",
+                        meta: { missingToolNames: requiredToolCallsGate.missing },
+                    });
+                    continue;
+                }
+                const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(String(msg.content ?? ""));
+                if (requiredAnswerRejection) {
+                    streamCallbackBuffer?.discard();
+                    callbacks.onClearText?.();
+                    queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported terminal answer rejected after required reads", meta: { answerLength: String(msg.content ?? "").length } });
+                    continue;
+                }
                 if (privateReturnTextAckRetryError) {
                     streamCallbackBuffer?.discard();
                     callbacks.onClearText?.();
@@ -1722,21 +1761,18 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 if (isSoleSettle) {
                     const settleArgs = validatedCallArguments.get(result.toolCalls[0]);
                     callbacks.onToolStart("settle", settleArgs);
-                    const missingRequiredToolCalls = requiredToolCallNames.filter((name) => !dispatchedRequiredToolCalls.has(name));
-                    if (missingRequiredToolCalls.length > 0) {
+                    const requiredToolCallsGate = pendingRequiredToolCalls();
+                    if (requiredToolCallsGate) {
                         streamCallbackBuffer?.discard();
                         callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
                         callbacks.onClearText?.();
-                        pushGenerated(msg);
-                        const gateMessage = `${options.requiredToolCalls.retryMessage} Missing required tool calls: ${missingRequiredToolCalls.join(", ")}.`;
-                        pushGenerated({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                        queueRequiredCorrection(requiredToolCallsGate.message, "before required tool calls completed");
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "engine",
                             event: "engine.required_tool_calls_pending",
                             message: "settle rejected until required tool handlers dispatch",
-                            meta: { missingToolNames: missingRequiredToolCalls },
+                            meta: { missingToolNames: requiredToolCallsGate.missing },
                         });
                         continue;
                     }
@@ -1755,6 +1791,15 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     // Extract answer from the tool call arguments.
                     // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
                     const { answer, intent } = parseSettlePayload(result.toolCalls[0].arguments);
+                    const requiredAnswerRejection = options?.requiredToolCalls?.validateTerminalAnswer?.(answer);
+                    if (requiredAnswerRejection) {
+                        streamCallbackBuffer?.discard();
+                        callbacks.onToolEnd("settle", (0, tools_1.summarizeArgs)("settle", settleArgs), false);
+                        callbacks.onClearText?.();
+                        queueRequiredCorrection(requiredAnswerRejection, "before required terminal answer validation completed");
+                        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.required_tool_answer_rejected", message: "unsupported settle answer rejected after required reads", meta: { answerLength: answer.length } });
+                        continue;
+                    }
                     // Private-runtime settle: no CompletionMetadata, "(settled)" ack
                     if (isPrivateRuntimeChannel) {
                         streamCallbackBuffer?.discard();
@@ -2266,7 +2311,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         const execToolFn = options?.execTool ?? tools_1.execTool;
                         const routineActionSelection = approvalCalls.find((entry) => entry.call.id === tc.id)?.routineActionSelection;
                         const executionToolContext = routineActionSelection && augmentedToolContext ? { ...augmentedToolContext, routineActionSelection } : augmentedToolContext;
-                        if (requiredToolCallNames.includes(tc.name))
+                        if (requiredToolCallNames.includes(tc.name) && !options?.requiredToolCalls?.requireSuccessfulResults)
                             dispatchedRequiredToolCalls.add(tc.name);
                         toolResult = await execToolFn(tc.name, args, executionToolContext);
                         success = true;
@@ -2276,6 +2321,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         success = false;
                         augmentedToolContext?.habitSession?.recordError?.(toolResult);
                     }
+                    if (success && requiredToolCallNames.includes(tc.name) && options?.requiredToolCalls?.requireSuccessfulResults
+                        && requiredToolResultSucceeded(tc.name, toolResult, options.requiredToolCalls.validateRequiredToolResult))
+                        dispatchedRequiredToolCalls.add(tc.name);
                     if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
                         unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
                     }

package/dist/mind/prompt.js

@@ -410,6 +410,9 @@ function runtimeInfoSection(channel, options) {
     else if (channel === "mcp") {
         lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend in a sense session. the user can see our conversation. if the dev-tool user asks a direct question, requests stop/pause/confirmation, or the work is complete, i answer with settle. during an active browser/tool/task flow, process comments are feedback to absorb; i keep using tools instead of settling for status. if friction appears, i first look for ad-hoc repairs with the tools i already have. if the friction reveals a harness gap, i create or revise a ponder packet and keep working. ponder does not create an outward deferral by itself.");
     }
+    else if (channel === "telegram") {
+        lines.push("i am responding in Telegram. i keep replies concise and phone-native. i do not use markdown. i do not introduce myself on boot.");
+    }
     else if (channel === "bluebubbles") {
         lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
         lines.push("during an active browser/tool/task flow, process comments from my friend are feedback to absorb, not a reason to settle. i speak once if useful, then keep working until complete, blocked, asked to stop/pause, or confirmation is required. timeout/recovery state is internal, not iMessage copy.");

package/dist/repertoire/tools-continuity.js

@@ -45,6 +45,24 @@ const presence_1 = require("../arc/presence");
 const intentions_1 = require("../arc/intentions");
 const steward_policy_1 = require("../heart/steward-policy");
 const await_parser_1 = require("../heart/awaiting/await-parser");
+function presentCare(care) {
+    const staleAt = care.nextCheckAt ? Date.parse(care.nextCheckAt) : Number.NaN;
+    if (care.kind !== "system" || !["active", "watching"].includes(care.status) || care.nextCheckAt === null)
+        return care;
+    if (Number.isFinite(staleAt) && staleAt >= Date.now())
+        return care;
+    return {
+        id: care.id,
+        kind: care.kind,
+        status: care.status,
+        salience: care.salience,
+        steward: care.steward,
+        evidenceStatus: "stale",
+        recheckRequired: true,
+        staleAt: care.nextCheckAt,
+        lastAssessedAt: care.updatedAt,
+    };
+}
 exports.continuityToolDefinitions = [
     // ── Continuity tools ──────────────────────────────────────────────
     {
@@ -308,7 +326,7 @@ exports.continuityToolDefinitions = [
         },
         handler: (a) => {
             const agentRoot = (0, identity_1.getAgentRoot)();
-            const cares = a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot);
+            const cares = (a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot)).map(presentCare);
             (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
             return JSON.stringify(cares, null, 2);
         },

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

@@ -2,8 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanctuaryFullVisibilityRequiredToolCalls = sanctuaryFullVisibilityRequiredToolCalls;
 const runtime_1 = require("../nerves/runtime");
-const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers"];
+const REQUIRED_TOOL_NAMES = ["query_active_work", "query_cares", "unraid_get_system", "unraid_list_containers", "unraid_get_storage", "sanctuary_get_download_queue"];
 const WHOLE_STATUS_REQUESTS = new Set(["what are you working on", "what's going on with sanctuary"]);
+function unsupportedCurrentClaim(answer) {
+    const unsupported = answer.replace(/docker\.img/giu, "docker image").split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((sentence) => {
+        if (!/docker image(?: disk)?/iu.test(sentence))
+            return false;
+        const uncertaintyOnly = /\b(?:cannot|can't|unable to) (?:currently )?(?:verify|measure)\b|\b(?:unknown|unverified)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|measurement)\b/iu.test(sentence);
+        const stateClaim = /\b\d+(?:\.\d+)?\s*%|\bfull\b|\b(?:no|out of) space\b|\bwrites? (?:will |may )?fail\b|\b(?:healthy|unhealthy|running|stopped)\b/iu.test(sentence);
+        return stateClaim || !uncertaintyOnly;
+    });
+    if (unsupported)
+        return "No current Butler tool measures Docker image utilization. Do not report a Docker image percentage or full state as current; say that the stale care needs a fresh authoritative check.";
+    const unsupportedProviderClaim = answer.split(/[,;!?\n]|(?<!\d)\.(?!\d)/u).some((clause) => {
+        const explicitlyUnverified = /\b(?:cannot|can't|unable to) (?:currently )?(?:verify|confirm)|\b(?:unknown|unverified|stale|historical|previous|prior)\b|\bneeds? (?:a )?(?:fresh |authoritative )*(?:check|verification)\b/iu.test(clause);
+        if (explicitlyUnverified)
+            return false;
+        if (/\b(?:Astraweb|Usenet provider|download provider|(?:block|prepaid|download|provider) credit)\b/iu.test(clause))
+            return true;
+        return /\bSABnzbd\b/iu.test(clause) && /\b(?:auth(?:entication)?|authenticated|credentials?)\b/iu.test(clause);
+    });
+    return unsupportedProviderClaim ? "The current queue read does not prove provider credit or authentication status. Do not report Astraweb, block-credit, or authentication failure as current; say that the provider needs a fresh authoritative check." : undefined;
+}
+function successfulCurrentResult(name, result) {
+    if (Buffer.byteLength(result, "utf8") > 1_000_000)
+        return false;
+    if (name === "query_active_work")
+        return result.trimStart().startsWith("this is my current top-level live world-state.");
+    try {
+        const parsed = JSON.parse(result);
+        if (name === "query_cares")
+            return Array.isArray(parsed);
+        if (name === "sanctuary_get_download_queue") {
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                return false;
+            const queue = parsed;
+            const exactKeys = ["observedAt", "paused", "queuedJobs", "stateDigest", "status"];
+            return JSON.stringify(Object.keys(queue).sort()) === JSON.stringify(exactKeys)
+                && typeof queue.paused === "boolean"
+                && typeof queue.status === "string" && Buffer.byteLength(queue.status, "utf8") <= 64
+                && Number.isSafeInteger(queue.queuedJobs) && Number(queue.queuedJobs) >= 0 && Number(queue.queuedJobs) <= 1_000_000
+                && typeof queue.observedAt === "string" && Number.isFinite(Date.parse(queue.observedAt)) && new Date(queue.observedAt).toISOString() === queue.observedAt
+                && typeof queue.stateDigest === "string" && /^[a-f0-9]{64}$/u.test(queue.stateDigest);
+        }
+        return !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && parsed.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
 function sanctuaryFullVisibilityRequiredToolCalls(request, advertisedToolNames) {
     const normalized = request.normalize("NFKC").trim().toLocaleLowerCase("en-US").replaceAll("’", "'").replace(/[?!.\s]+$/gu, "");
     if (!WHOLE_STATUS_REQUESTS.has(normalized) || !REQUIRED_TOOL_NAMES.every((name) => advertisedToolNames.includes(name)))
@@ -11,6 +58,9 @@ function sanctuaryFullVisibilityRequiredToolCalls(request, advertisedToolNames)
     (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.sanctuary_full_visibility_reads_required", message: "required current Sanctuary visibility reads", meta: { toolCount: REQUIRED_TOOL_NAMES.length } });
     return {
         names: REQUIRED_TOOL_NAMES,
-        retryMessage: "Before answering, read current active work, cares, system health, and service state. Then give Ari one compact household summary; do not ask him to choose a status slice.",
+        retryMessage: "Before answering, read current active work, cares, system health, service state, storage, and the download queue. Current tool facts outrank care history; a stale care is a recheck item, not a present-tense fact. Then give Ari one compact household summary; do not ask him to choose a status slice.",
+        requireSuccessfulResults: true,
+        validateRequiredToolResult: successfulCurrentResult,
+        validateTerminalAnswer: unsupportedCurrentClaim,
     };
 }

package/dist/senses/telegram-effect-adapter.js

@@ -76,6 +76,12 @@ function preparedTexts(effect) {
         return [requireText(effect.text, "Telegram text")];
     return [effect.text?.trim() || null];
 }
+function telegramPlainText(text) {
+    return text.replace(/(^|[\s([{])\*\*([\p{L}\p{N}][^*\n]*?)\*\*(?=$|[\s.,;!?)\]}])/gmu, "$1$2");
+}
+function presentTelegramEffect(authorClass, effect) {
+    return authorClass === "butler" && effect.kind === "text" ? { ...effect, text: telegramPlainText(effect.text) } : effect;
+}
 function assertEffectTarget(target, effect, idempotencyKey) {
     if (target.kind === "admission_gate") {
         if (effect.kind !== "admission_ack" || effect.text !== exports.FIXED_ADMISSION_ACKNOWLEDGEMENT || idempotencyKey !== `ack:${target.admissionId}`) {
@@ -425,11 +431,12 @@ function createTelegramAuthorizedEffectExecutor(options) {
         if (input.signal?.aborted)
             throw input.signal.reason;
         barrier();
-        const authorization = await options.authorize({ phase: "prepare", ...input });
+        const presentedInput = { ...input, effect: presentTelegramEffect(input.authorClass, input.effect) };
+        const authorization = await options.authorize({ phase: "prepare", ...presentedInput });
         if (!authorization.allowed)
             throw new Error(`Telegram effect authorization denied: ${authorization.reason}`);
         const store = getStore();
-        const prepared = prepareTelegramEffect(store, { ...input, authorization });
+        const prepared = prepareTelegramEffect(store, { ...presentedInput, authorization });
         try {
             const executed = await executeTelegramEffect(store, prepared.id, options.api, async (artifact) => {
                 if (input.signal?.aborted)

package/npm-shrinkwrap.json

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