@ouro.bot/cli 0.1.0-alpha.638 → 0.1.0-alpha.640

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.640",
+      "changes": [
+        "Reject text-only private-return queued acknowledgements unless ponder created packet-backed return work."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.639",
+      "changes": [
+        "Rollback safety guard: ouro rollback now validates the target installed @ouro.bot/cli package payload before flipping CurrentVersion, and refuses cached runtimes whose shipped assets contain blocked removed user-facing failure text so old local versions cannot resurrect the removed BlueBubbles live-turn timeout notice."
+      ]
+    },
     {
       "version": "0.1.0-alpha.638",
       "changes": [

package/dist/heart/core.js

@@ -298,12 +298,18 @@ function messageContentText(content) {
         .filter(Boolean)
         .join("\n");
 }
+function isHarnessCorrectiveUserText(text) {
+    return text.startsWith("no tool was called this turn. you must end every turn")
+        || text.startsWith("private-return acknowledgement claimed work was queued, but no ponder packet was created this turn.");
+}
 function latestUserMessageText(messages) {
     for (let i = messages.length - 1; i >= 0; i -= 1) {
         const message = messages[i];
         if (message?.role !== "user")
             continue;
         const text = messageContentText(message.content).trim();
+        if (isHarnessCorrectiveUserText(text))
+            continue;
         if (text.length > 0)
             return text;
     }
@@ -675,12 +681,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     // which doesn't update mid-turn. The agent only needs to be told once;
     // after that, repeated rest attempts mean they've acknowledged.
     let freshWorkGateFired = false;
-    // Counter for "no tool call returned despite tool_choice=required" violations.
-    // MiniMax reasoning models occasionally emit only a <think>...</think>
-    // block and stop, without any tool call — even when tool_choice is set to
-    // "required". This is a provider-level violation; the harness retries with
-    // a corrective nudge up to a small cap rather than silently accepting an
-    // empty turn.
+    // Counter for no-tool-call violations. MiniMax reasoning models occasionally
+    // emit only a <think>...</think> block and stop, without any tool call — even
+    // when tool_choice is set to "required". Private-return requests also need
+    // a hard no-tool guard: a text-only "queued" acknowledgement is false unless
+    // a ponder packet created the return obligation in this turn.
     let noToolCallRetries = 0;
     const NO_TOOL_CALL_MAX_RETRIES = 2;
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
@@ -938,7 +943,60 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 && typeof result.content === "string"
                 && stripThinkBlocksForViolationCheck(result.content).length === 0
                 && result.content.length > 0;
+            const privateReturnTextAckRetryError = !result.toolCalls.length
+                ? privateReturnMissingPonderError({
+                    latestUserRequest: latestUserMessageText(messages),
+                    answer: stripThinkBlocksForViolationCheck(result.content),
+                    sawPonder,
+                })
+                : null;
             if (!result.toolCalls.length) {
+                if (privateReturnTextAckRetryError) {
+                    callbacks.onClearText?.();
+                    if (noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
+                        noToolCallRetries++;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "engine",
+                            event: "engine.no_tool_call_retry",
+                            message: "model returned a text-only private-return acknowledgement without ponder; retrying with corrective nudge",
+                            meta: {
+                                attempt: noToolCallRetries,
+                                cap: NO_TOOL_CALL_MAX_RETRIES,
+                                provider: providerRuntime.id,
+                                model: providerRuntime.model,
+                                reason: "private_return_missing_ponder",
+                                contentLength: result.content.length,
+                            },
+                        });
+                        messages.push(msg);
+                        messages.push({
+                            role: "user",
+                            content: `${privateReturnTextAckRetryError} Emit the ponder(action=create, ...) tool call now, or ask a blocking clarification without saying the private work is queued.`,
+                        });
+                        continue;
+                    }
+                    const blockedAnswer = "I could not start the private pass. No private-attention packet was created, so no return work was queued.";
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "engine",
+                        event: "engine.private_return_missing_ponder_blocked",
+                        message: "private-return text acknowledgement skipped ponder through the retry cap; failing closed",
+                        meta: {
+                            cap: NO_TOOL_CALL_MAX_RETRIES,
+                            provider: providerRuntime.id,
+                            model: providerRuntime.model,
+                            contentLength: result.content.length,
+                        },
+                    });
+                    msg.content = blockedAnswer;
+                    messages.push(msg);
+                    callbacks.onTextChunk(blockedAnswer);
+                    completion = { answer: blockedAnswer, intent: "blocked" };
+                    outcome = "blocked";
+                    done = true;
+                    continue;
+                }
                 if (onlyThinkContent && toolChoiceRequired && noToolCallRetries < NO_TOOL_CALL_MAX_RETRIES) {
                     // Provider-level violation: tool_choice was required, model emitted
                     // only a <think>...</think> block (or empty content) with no tool

package/dist/heart/daemon/cli-defaults.js

@@ -719,6 +719,7 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
             });
         },
         installCliVersion: async (version) => { (0, ouro_version_manager_1.installVersion)(version, {}); },
+        validateCliVersionForActivation: (version) => (0, ouro_version_manager_1.validateInstalledVersionForActivation)(version, {}),
         activateCliVersion: (version) => {
             (0, ouro_version_manager_1.activateVersion)(version, {});
             // Same self-prune as ensureCurrentVersionInstalled — fires from the

package/dist/heart/daemon/cli-exec.js

@@ -6112,6 +6112,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                     return message;
                 }
             }
+            const validation = deps.validateCliVersionForActivation?.(command.version);
+            if (validation && !validation.ok) {
+                const message = `refusing to roll back to ${command.version}: ${validation.message}`;
+                return returnCliFailure(deps, message);
+            }
             deps.activateCliVersion(command.version);
         }
         else {
@@ -6122,6 +6127,11 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 deps.writeStdout(message);
                 return message;
             }
+            const validation = deps.validateCliVersionForActivation?.(previousVersion);
+            if (validation && !validation.ok) {
+                const message = `refusing to roll back to ${previousVersion}: ${validation.message}`;
+                return returnCliFailure(deps, message);
+            }
             deps.activateCliVersion(previousVersion);
             command = { ...command, version: previousVersion };
         }

package/dist/heart/versioning/ouro-version-manager.js

@@ -39,6 +39,7 @@ exports.getCurrentVersion = getCurrentVersion;
 exports.getPreviousVersion = getPreviousVersion;
 exports.buildChangelogCommand = buildChangelogCommand;
 exports.listInstalledVersions = listInstalledVersions;
+exports.validateInstalledVersionForActivation = validateInstalledVersionForActivation;
 exports.installVersion = installVersion;
 exports.activateVersion = activateVersion;
 exports.compareCliVersions = compareCliVersions;
@@ -51,6 +52,31 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 /** Maximum number of installed CLI versions to retain after pruning. */
 exports.DEFAULT_RETAIN_VERSIONS = 5;
+const INSTALLED_RUNTIME_PACKAGE_PAYLOAD_PATHS = [
+    "assets",
+    "dist",
+    "RepairGuide.ouro",
+    "SerpentGuide.ouro",
+    "skills",
+    "changelog.json",
+    "package.json",
+];
+const INSTALLED_RUNTIME_TEXT_EXTENSIONS = new Set([
+    ".cjs",
+    ".css",
+    ".html",
+    ".js",
+    ".json",
+    ".md",
+    ".mjs",
+    ".txt",
+]);
+const BLOCKED_INSTALLED_RUNTIME_TEXT_SIGNATURES = [
+    {
+        label: "removed BlueBubbles timeout notice",
+        base64: "bGl2ZSBpTWVzc2FnZSB0dXJuIHRpbWVkIG91dDsgSSBjYXB0dXJlZCBpdCBmb3IgcmVjb3ZlcnkgaW5zdGVhZCBvZiBzaWxlbnRseSBoYW5naW5n",
+    },
+];
 function getOuroCliHome(homeDir) {
     /* v8 ignore next -- dep default: tests always inject @preserve */
     const home = homeDir ?? os.homedir();
@@ -98,6 +124,94 @@ function listInstalledVersions(deps) {
         return [];
     }
 }
+function validateInstalledVersionForActivation(version, deps = {}) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore start -- dep defaults: tests inject @preserve */
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const readdirSync = deps.readdirSync ?? ((p, opts) => fs.readdirSync(p, opts));
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    /* v8 ignore stop */
+    const packageRoot = path.join(cliHome, "versions", version, "node_modules", "@ouro.bot", "cli");
+    const packageJsonPath = path.join(packageRoot, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        const message = `installed runtime ${version} is missing its @ouro.bot/cli package; run 'ouro up' to restore the current release`;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.cli_version_activation_blocked",
+            message: "blocked CLI version activation",
+            meta: { version, packageRoot, reason: "missing-package" },
+            level: "warn",
+        });
+        return { ok: false, version, packageRoot, violations: ["missing @ouro.bot/cli package"], message };
+    }
+    const violations = findBlockedInstalledRuntimePayloadText(packageRoot, { existsSync, readdirSync, readFileSync });
+    if (violations.length === 0) {
+        return { ok: true, version, packageRoot, violations, message: "installed runtime package passed activation guard" };
+    }
+    const message = `installed runtime ${version} contains blocked package assets (${violations.join(", ")}); run 'ouro up' to stay on the current release`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_version_activation_blocked",
+        message: "blocked CLI version activation",
+        meta: { version, packageRoot, reason: "blocked-package-assets", violations },
+        level: "warn",
+    });
+    return { ok: false, version, packageRoot, violations, message };
+}
+function findBlockedInstalledRuntimePayloadText(packageRoot, deps) {
+    const violations = [];
+    const blockedText = BLOCKED_INSTALLED_RUNTIME_TEXT_SIGNATURES.map((signature) => ({
+        label: signature.label,
+        text: Buffer.from(signature.base64, "base64").toString("utf8"),
+    }));
+    for (const payloadPath of INSTALLED_RUNTIME_PACKAGE_PAYLOAD_PATHS) {
+        const absolutePath = path.join(packageRoot, payloadPath);
+        if (!deps.existsSync(absolutePath))
+            continue;
+        collectBlockedTextViolations(packageRoot, absolutePath, payloadPath, blockedText, deps, violations);
+    }
+    return violations.sort();
+}
+function collectBlockedTextViolations(packageRoot, absolutePath, relativePath, blockedText, deps, violations) {
+    let entries = null;
+    try {
+        entries = deps.readdirSync(absolutePath, { withFileTypes: true });
+    }
+    catch {
+        entries = null;
+    }
+    if (entries !== null) {
+        for (const entry of entries) {
+            const childRelativePath = `${relativePath}/${entry.name}`;
+            if (entry.isDirectory()) {
+                collectBlockedTextViolations(packageRoot, path.join(absolutePath, entry.name), childRelativePath, blockedText, deps, violations);
+            }
+            else if (entry.isFile()) {
+                inspectInstalledRuntimePayloadFile(packageRoot, childRelativePath, blockedText, deps, violations);
+            }
+        }
+        return;
+    }
+    inspectInstalledRuntimePayloadFile(packageRoot, relativePath, blockedText, deps, violations);
+}
+function inspectInstalledRuntimePayloadFile(packageRoot, relativePath, blockedText, deps, violations) {
+    if (!INSTALLED_RUNTIME_TEXT_EXTENSIONS.has(path.extname(relativePath)))
+        return;
+    let content = "";
+    try {
+        content = deps.readFileSync(path.join(packageRoot, relativePath), "utf8");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error);
+        violations.push(`${relativePath} could not be inspected: ${reason}`);
+        return;
+    }
+    for (const blocked of blockedText) {
+        if (content.includes(blocked.text)) {
+            violations.push(`${relativePath} contains ${blocked.label}`);
+        }
+    }
+}
 function installVersion(version, deps) {
     const cliHome = getOuroCliHome(deps.homeDir);
     /* v8 ignore start -- dep defaults: tests always inject @preserve */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.638",
+  "version": "0.1.0-alpha.640",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",