@ouro.bot/cli 0.1.0-alpha.759 → 0.1.0-alpha.760

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_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.760",
+      "changes": [
+        "Force exact repeated requests to retry unresolved matching effects and fail closed instead of accepting stale text."
+      ]
+    },
     {
       "version": "0.1.0-alpha.759",
       "changes": [

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

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.759",
+  "runtimeVersion": "0.1.0-alpha.760",
   "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.759</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.760</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/core.js

@@ -558,14 +558,35 @@ function isHarnessCorrectiveUserText(text) {
         || text.startsWith("private-return acknowledgement claimed work was queued, but no ponder packet was created this turn.")
         || text.startsWith("this exact request previously reached a tool that is advertised again now.");
 }
-function claimsCurrentToolFailure(text) {
-    const normalized = text.replace(/\s+/g, " ").trim().toLowerCase();
-    return /\b(?:still|currently|now)\s+(?:down|offline|unavailable|broken|failing|unreachable)\b/.test(normalized)
-        || /\b(?:runtime|tool|service|server|system|lane)\b.{0,40}\b(?:is|remains?|seems?)\s+(?:still\s+)?(?:down|offline|unavailable|broken|failing|unreachable)\b/.test(normalized)
-        || /\b(?:i|we)\s+(?:can(?:not|'t)|could(?:not|n't)|am unable to|are unable to)\s+(?:call|use|access|reach|run|change)\b/.test(normalized)
-        || /\b(?:already\s+)?tried\b.{0,80}\b(?:failed|failure|error|down|offline|unavailable)\b/.test(normalized);
+function toolResultIndicatesFailure(content) {
+    const normalized = content.trim().toLowerCase();
+    return normalized.startsWith("error:")
+        || normalized.startsWith("invalid tool arguments:")
+        || normalized.startsWith("unknown:")
+        || normalized.startsWith("relationship authorization required:")
+        || normalized.startsWith("orientation hold:")
+        || normalized.startsWith("commerce authority required:")
+        || normalized.startsWith("blocked:")
+        || normalized.startsWith("rejected:");
 }
-function historicalFailedToolsForExactRepeatedRequest(messages) {
+function effectFingerprint(name, rawArguments) {
+    let args;
+    try {
+        const parsed = JSON.parse(rawArguments);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        args = { ...parsed };
+    }
+    catch {
+        return null;
+    }
+    const profile = (0, tools_1.riskProfileForToolName)(name, args);
+    if (!profile || profile.mutates === "none")
+        return null;
+    delete args.expectedVersion;
+    return (0, tool_arguments_1.digestJson)({ name, args });
+}
+function historicalFailedEffectsForExactRepeatedRequest(messages) {
     const userRequests = [];
     for (let index = 0; index < messages.length; index += 1) {
         const message = messages[index];
@@ -582,32 +603,34 @@ function historicalFailedToolsForExactRepeatedRequest(messages) {
     const prior = userRequests.slice(0, -1).find((request) => request.text === current.text);
     if (!prior)
         return [];
-    const namesByCallId = new Map();
-    const failedNames = new Set();
+    const effectsByCallId = new Map();
+    const failedEffects = new Map();
     for (let index = prior.index + 1; index < current.index; index += 1) {
         const message = messages[index];
         if (message?.role === "assistant" && Array.isArray(message.tool_calls)) {
             for (const call of message.tool_calls) {
-                if (call.type === "function" && call.id && call.function.name) {
-                    namesByCallId.set(call.id, call.function.name);
-                }
+                if (call.type !== "function" || !call.id || !call.function.name)
+                    continue;
+                const fingerprint = effectFingerprint(call.function.name, call.function.arguments);
+                if (fingerprint)
+                    effectsByCallId.set(call.id, { name: call.function.name, fingerprint });
             }
             continue;
         }
         if (message?.role !== "tool")
             continue;
-        const content = messageContentText(message.content).trim().toLowerCase();
-        const name = namesByCallId.get(message.tool_call_id);
-        if (!name)
+        const content = messageContentText(message.content);
+        const effect = effectsByCallId.get(message.tool_call_id);
+        if (!effect)
             continue;
-        if (content.startsWith("error:") || content.startsWith("invalid tool arguments:")) {
-            failedNames.add(name);
+        if (toolResultIndicatesFailure(content)) {
+            failedEffects.set(effect.fingerprint, effect);
         }
         else {
-            failedNames.delete(name);
+            failedEffects.delete(effect.fingerprint);
         }
     }
-    return [...failedNames];
+    return [...failedEffects.values()];
 }
 function latestUserMessageText(messages) {
     for (let i = messages.length - 1; i >= 0; i -= 1) {
@@ -1094,8 +1117,8 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // a ponder packet created the return obligation in this turn.
     let noToolCallRetries = 0;
     const NO_TOOL_CALL_MAX_RETRIES = 2;
-    const historicalFailedToolNames = historicalFailedToolsForExactRepeatedRequest(messages);
-    let historicalToolFailureRetryIssued = false;
+    let unresolvedHistoricalEffects = historicalFailedEffectsForExactRepeatedRequest(messages);
+    let historicalToolFailureRetries = 0;
     let providerIterations = 0;
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
     const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
@@ -1200,7 +1223,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         const ordinaryActiveTools = relationshipToolNames
             ? unscopedOrdinaryActiveTools.filter((tool) => relationshipToolNames.includes(tool.function.name))
             : unscopedOrdinaryActiveTools;
-        const activeTools = options?.toolProfile === "sanctuary-health-private"
+        const candidateActiveTools = options?.toolProfile === "sanctuary-health-private"
             ? (() => {
                 const sendTools = baseTools.filter((tool) => tool.function.name === "send_message");
                 if (channel !== "inner" || sendTools.length !== 1 || baseTools.length !== 1) {
@@ -1209,6 +1232,14 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 return [sendTools[0], tools_1.restTool];
             })()
             : ordinaryActiveTools;
+        const candidateToolNames = new Set(candidateActiveTools.map((tool) => tool.function.name));
+        const forcedHistoricalToolNames = new Set(unresolvedHistoricalEffects
+            .map((effect) => effect.name)
+            .filter((name) => candidateToolNames.has(name)));
+        const forcingHistoricalEffect = forcedHistoricalToolNames.size > 0;
+        const activeTools = forcingHistoricalEffect
+            ? candidateActiveTools.filter((tool) => forcedHistoricalToolNames.has(tool.function.name))
+            : candidateActiveTools;
         const activeToolNames = new Set(activeTools.map((tool) => tool.function.name));
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
@@ -1262,7 +1293,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         callbacks: turnCallbackBufferRef.current?.callbacks ?? callbacks,
                         signal,
                         traceId,
-                        toolChoiceRequired,
+                        toolChoiceRequired: forcingHistoricalEffect || toolChoiceRequired,
                         reasoningEffort: currentReasoningEffort,
                         eagerSettleStreaming: true,
                         systemPrompt: structuredSystemPrompt,
@@ -1445,29 +1476,45 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 })
                 : null;
             if (!result.toolCalls.length) {
-                const retryableHistoricalTools = historicalToolFailureRetryIssued
-                    ? []
-                    : historicalFailedToolNames.filter((name) => activeToolNames.has(name));
-                const responseClaimsCurrentToolFailure = claimsCurrentToolFailure(messageContentText(msg.content));
-                if (retryableHistoricalTools.length > 0 && responseClaimsCurrentToolFailure) {
-                    historicalToolFailureRetryIssued = true;
+                if (forcingHistoricalEffect) {
                     streamCallbackBuffer?.discard();
                     callbacks.onClearText?.();
+                    const retryableHistoricalTools = [...forcedHistoricalToolNames];
+                    if (historicalToolFailureRetries >= NO_TOOL_CALL_MAX_RETRIES) {
+                        const blockedAnswer = `I could not complete the unresolved ${retryableHistoricalTools.join(", ")} effect because the provider repeatedly returned no tool call. I did not treat the requested change as complete.`;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.historical_tool_failure_retry",
+                            message: "unresolved historical effect exhausted deterministic tool-call retries; failing closed",
+                            meta: { provider: providerRuntime.id, model: providerRuntime.model, toolNames: retryableHistoricalTools, cap: NO_TOOL_CALL_MAX_RETRIES },
+                        });
+                        msg.content = blockedAnswer;
+                        pushGenerated(msg);
+                        callbacks.onTextChunk(blockedAnswer);
+                        completion = { answer: blockedAnswer, intent: "blocked" };
+                        outcome = "blocked";
+                        done = true;
+                        continue;
+                    }
+                    historicalToolFailureRetries += 1;
                     (0, runtime_1.emitNervesEvent)({
                         level: "warn",
                         component: "engine",
                         event: "engine.historical_tool_failure_retry",
-                        message: "text-only response borrowed a historical failure for a currently advertised tool; retrying the exact repeated request",
+                        message: "unresolved historical effect returned no tool call; forcing another exact-effect attempt",
                         meta: {
                             provider: providerRuntime.id,
                             model: providerRuntime.model,
                             toolNames: retryableHistoricalTools,
+                            attempt: historicalToolFailureRetries,
+                            cap: NO_TOOL_CALL_MAX_RETRIES,
                         },
                     });
                     pushGenerated(msg);
                     messages.push({
                         role: "user",
-                        content: `this exact request previously reached a tool that is advertised again now. The latest recorded result for ${retryableHistoricalTools.join(", ")} was a historical failure; that does not prove current unavailability. Re-evaluate whether the requested effect is still unsatisfied. If it is, call the currently advertised tool before reporting a current failure. Do not repeat an effect that already succeeded.`,
+                        content: `this exact request previously reached a tool that is advertised again now. Its unresolved historical effect is through ${retryableHistoricalTools.join(", ")}. Only that tool is available now. Read current state if needed, then retry the exact failed effect. Do not report completion until the effect succeeds.`,
                     });
                     continue;
                 }
@@ -1939,6 +1986,17 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         continue;
                     }
                     const args = validatedCallArguments.get(tc);
+                    const currentEffectFingerprint = effectFingerprint(tc.name, tc.arguments);
+                    if (forcingHistoricalEffect
+                        && currentEffectFingerprint
+                        && !unresolvedHistoricalEffects.some((effect) => effect.fingerprint === currentEffectFingerprint)) {
+                        const rejection = "rejected: this turn is retrying an unresolved historical effect, and these mutation arguments do not match it. Read current state or retry the exact failed effect.";
+                        callbacks.onToolStart(tc.name, args);
+                        callbacks.onToolEnd(tc.name, (0, tools_1.summarizeArgs)(tc.name, args), false);
+                        pushGenerated({ role: "tool", tool_call_id: tc.id, content: rejection });
+                        providerRuntime.appendToolOutput(tc.id, rejection);
+                        continue;
+                    }
                     if (tc.name === "send_message" && args.friendId === "self") {
                         const latestUserText = latestUserMessageText(messages);
                         if (!isPrivateRuntimeChannel && looksLikePrivateReturnRequest(latestUserText)) {
@@ -2196,6 +2254,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         success = false;
                         augmentedToolContext?.habitSession?.recordError?.(toolResult);
                     }
+                    if (success && currentEffectFingerprint && !toolResultIndicatesFailure(toolResult)) {
+                        unresolvedHistoricalEffects = unresolvedHistoricalEffects.filter((effect) => effect.fingerprint !== currentEffectFingerprint);
+                    }
                     const resolvedRiskProfile = (0, tools_1.resolveToolDefinition)(tc.name)?.riskProfile;
                     const toolRiskProfile = typeof resolvedRiskProfile === "function" ? resolvedRiskProfile(args) : resolvedRiskProfile;
                     options?.toolBoundaryObserver?.({

package/npm-shrinkwrap.json

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