@ouro.bot/cli 0.1.0-alpha.505 → 0.1.0-alpha.507

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.507",
+      "changes": [
+        "Drop the second of two consecutive assistant messages with byte-identical content in `repairSessionMessages`. The existing back-to-back-assistant repair concatenated content with `\\n\\n`, which produced visible duplicate text on the surface when the second message was a retry/double-persist artifact (a common shape when a turn is interrupted mid-save and re-emitted).",
+        "Behavior change is narrow: trim-equality only, both sides must have non-empty content, and the second assistant must not have its own tool_calls. Different content still concatenates (legitimate continuation). Empty-content assistants still concatenate (the existing test case for null+undefined is preserved). Emits `mind.session_duplicate_assistant_dropped` (info) with the count so #622 (nerves-review) can show how often it fires in real traffic. 2 new tests cover the dedup path and the no-false-positive case (different content concatenates as before)."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.506",
+      "changes": [
+        "Detect duplicate tool_call_id across assistant messages in `validateSessionMessages`. MiniMax-M2.7 emits canonical tool_call ids of the form `call_function_<hash>_<n>` and reuses the same id across turns when the same function gets called — which causes provider rejections on replay because tool_call_id is supposed to be unique per request. The session sanitize pass already had position-aware orphan detection (#613) and inline-reasoning strip (#612); this adds the third member of the family — collision detection.",
+        "New exported `detectDuplicateToolCallIds(messages)` returns `{ id, indices }[]` for each tool_call_id that appears in multiple assistant messages. Same-message duplicates (one assistant calling the same id twice) are not flagged — those are a legitimate parallel-call shape. `validateSessionMessages` now folds collisions into its violations list with a message that calls out MiniMax specifically so operators reading nerves know what they're looking at.",
+        "Detection only — no rewriting yet, since rewriting tool_call_ids and the matching tool_results requires careful pairing logic that risks regression. The collision is visible to operators via the `mind.session_invariant_violation` nerves event the sanitize pass already emits when violations are present, and the existing `nerves-review` CLI from #622 makes it filterable. 3 new tests cover collision detection, single-message parallel-call shape (no false positive), and the all-distinct happy path."
+      ]
+    },
     {
       "version": "0.1.0-alpha.505",
       "changes": [

package/dist/heart/session-events.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeContinuityState = normalizeContinuityState;
 exports.validateSessionMessages = validateSessionMessages;
+exports.detectDuplicateToolCallIds = detectDuplicateToolCallIds;
 exports.repairSessionMessages = repairSessionMessages;
 exports.migrateToolNames = migrateToolNames;
 exports.sanitizeProviderMessages = sanitizeProviderMessages;
@@ -305,26 +306,86 @@ function validateSessionMessages(messages) {
         sawToolResultSincePrevAssistant = false;
         prevNonToolRole = msg.role;
     }
+    for (const collision of detectDuplicateToolCallIds(messages)) {
+        violations.push(`duplicate tool_call_id '${collision.id}' across assistant messages at indices ${collision.indices.join(", ")} — provider may reject (MiniMax canonicalizes call_function_<hash>_<n> across turns)`);
+    }
     return violations;
 }
+/**
+ * Detect tool_call_ids that appear in more than one assistant message
+ * within the conversation. MiniMax-M2.7 in particular emits canonical
+ * ids of the form `call_function_<hash>_<n>` and reuses the same id
+ * across turns when the same function is called — which causes provider
+ * rejections on replay because tool_call_id is supposed to be unique
+ * per request. We don't (yet) rewrite these here; this function exists
+ * so the sanitize pipeline can surface the collision through nerves
+ * (`mind.session_invariant_violation`) and operators can decide.
+ *
+ * Same-message duplicates (one assistant calling the same id twice)
+ * are not collisions — they're a legitimate parallel call shape and
+ * would be handled by the assistant's own emit logic. We only flag
+ * cross-message reuse.
+ */
+function detectDuplicateToolCallIds(messages) {
+    const idsByFirstIndex = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        const msg = normalizeMessage(messages[i]);
+        if (msg.role !== "assistant")
+            continue;
+        const seenInThisMessage = new Set();
+        for (const call of msg.toolCalls) {
+            if (!call.id || seenInThisMessage.has(call.id))
+                continue;
+            seenInThisMessage.add(call.id);
+            const indices = idsByFirstIndex.get(call.id) ?? [];
+            indices.push(i);
+            idsByFirstIndex.set(call.id, indices);
+        }
+    }
+    const collisions = [];
+    for (const [id, indices] of idsByFirstIndex) {
+        if (indices.length > 1)
+            collisions.push({ id, indices });
+    }
+    return collisions;
+}
 function repairSessionMessages(messages) {
     const normalized = messages.map(normalizeMessage);
     const violations = validateSessionMessages(messages);
     if (violations.length === 0)
         return normalized.map(toProviderMessage);
     const result = [];
+    let duplicateAssistantsDropped = 0;
     for (const msg of normalized) {
         if (msg.role === "assistant" && result.length > 0) {
             const prev = result[result.length - 1];
             if (prev.role === "assistant" && prev.toolCalls.length === 0) {
                 const prevContent = contentText(prev.content);
                 const curContent = contentText(msg.content);
+                // Drop the second of two consecutive assistants when the content is
+                // byte-identical (after trim) — that's a retry/double-persist artifact,
+                // not legitimate continuation. Concatenating them produced visible
+                // duplicate text in surfaces. Empty strings still concatenate (could
+                // be "" + real content).
+                if (prevContent.trim().length > 0 && prevContent.trim() === curContent.trim() && msg.toolCalls.length === 0) {
+                    duplicateAssistantsDropped += 1;
+                    continue;
+                }
                 prev.content = `${prevContent}\n\n${curContent}`;
                 continue;
             }
         }
         result.push(msg);
     }
+    if (duplicateAssistantsDropped > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_duplicate_assistant_dropped",
+            component: "mind",
+            message: "dropped consecutive assistant messages with identical content (retry/double-persist artifact)",
+            meta: { count: duplicateAssistantsDropped },
+        });
+    }
     (0, runtime_1.emitNervesEvent)({
         level: "info",
         event: "mind.session_invariant_repair",

package/dist/mind/context.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSessionMessages = exports.repairSessionMessages = exports.migrateToolNames = void 0;
+exports.validateSessionMessages = exports.repairSessionMessages = exports.migrateToolNames = exports.detectDuplicateToolCallIds = void 0;
 exports.trimMessages = trimMessages;
 exports.saveSession = saveSession;
 exports.appendSyntheticAssistantMessage = appendSyntheticAssistantMessage;
@@ -50,6 +50,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const token_estimate_1 = require("./token-estimate");
 var session_events_2 = require("../heart/session-events");
+Object.defineProperty(exports, "detectDuplicateToolCallIds", { enumerable: true, get: function () { return session_events_2.detectDuplicateToolCallIds; } });
 Object.defineProperty(exports, "migrateToolNames", { enumerable: true, get: function () { return session_events_2.migrateToolNames; } });
 Object.defineProperty(exports, "repairSessionMessages", { enumerable: true, get: function () { return session_events_2.repairSessionMessages; } });
 Object.defineProperty(exports, "validateSessionMessages", { enumerable: true, get: function () { return session_events_2.validateSessionMessages; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.505",
+  "version": "0.1.0-alpha.507",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -37,8 +37,7 @@
     "lint": "eslint src/",
     "release:preflight": "node scripts/release-preflight.cjs",
     "release:smoke": "node scripts/release-smoke.cjs",
-    "audit:nerves": "npm run build && node dist/nerves/coverage/cli-main.js",
-    "session:stats": "npm run build && node dist/heart/session-stats-cli-main.js"
+    "audit:nerves": "npm run build && node dist/nerves/coverage/cli-main.js"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",