@ouro.bot/cli 0.1.0-alpha.490 → 0.1.0-alpha.491

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_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.491",
+      "changes": [
+        "Two live-runtime bugs Slugger surfaced during MCP roundtrip: (1) MCP `send_message` returned blank or raw `<think>` content instead of an actual reply when minimax-style models emitted only reasoning. The shared-turn runner now strips closed AND unclosed `<think>...</think>` blocks before returning, and when nothing remains it returns a clear diagnostic (`agent produced reasoning but no final answer this turn — try again`) plus emits a `senses.shared_turn_only_reasoning` warn-level nerve event so operators can see how often it's happening. (2) The `rest` tool's fresh-pending-work gate fired on every rest call within a turn because `hasFreshPendingWork(options)` reads from the turn-start snapshot of `pendingMessages` and never updates — once pending was non-empty, the agent could be told 'fresh work arrived' indefinitely even after surfacing or processing the items. The gate is now once-per-turn: the first rest call hits it, gets the message, the agent does whatever it needs, the next rest call passes. Emits `engine.fresh_work_gate_fired` info-level event the one time it fires. Both bugs reproduced as regression tests that fail without the fix.",
+        "New `trip_update_leg` tool to round out the trip ledger. The original Step 4 followup on substrate#35 listed `trip_ensure / trip_get / trip_update_leg / trip_attach_evidence` — the previous PR (#609) shipped `trip_upsert` instead of `trip_update_leg`, which forced the agent to re-emit the entire trip record to change one leg field. `trip_update_leg` updates specific fields of an existing leg in place: pass `tripId`, `legId`, a JSON object of field updates, and `updatedAt`. Identity-changing updates (`legId`, `kind`) and empty updates objects are rejected with operational error messages. Existing evidence is preserved unless the agent explicitly overwrites it. Emits a `trips.leg_updated` nerve event with the field list. Tool registry now at 74 tools (up from 73).",
+        "New `docs/trip-ledger.md` covering what the ledger actually is, why Slugger said it needed to exist (gap between mail body and travel doc — no authoritative source for cross-checks), the discriminated TripLeg union (lodging / flight / train / ground-transport / rental-car / ferry / event), the non-optional TripEvidence shape with `discoveryMethod`, the trust shape (per-agent keys, private key returned exactly once, hosted side never sees plaintext), the seven harness tools, on-disk layout for both harness and hosted sides, and an explicit answer to 'is this travel-specific or generalizable infra?' (current shape is travel-specific by design; the *pattern* is general and would be lifted to a shared abstraction the next time we build a per-agent encrypted record service)."
+      ]
+    },
     {
       "version": "0.1.0-alpha.490",
       "changes": [

package/dist/heart/core.js

@@ -180,6 +180,29 @@ function getProviderDisplayLabel(facing = "human") {
     };
     return providerLabelBuilders[provider]();
 }
+/**
+ * Strip <think>...</think> blocks for the violation-detection check at the
+ * end of a streaming turn. Used to tell legitimate text-only responses
+ * apart from the MiniMax-M2.7 "only thinking, no tool call" violation
+ * shape. Mirrors the more thorough stripThinkBlocks helper in
+ * senses/shared-turn.ts (which is for operator-facing output) — kept
+ * inline here to avoid pulling senses/ into the core module's import graph.
+ */
+function stripThinkBlocksForViolationCheck(input) {
+    let out = input;
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
 function hasFreshPendingWork(options) {
     const pendingMessages = options?.pendingMessages;
     if (!Array.isArray(pendingMessages))
@@ -545,6 +568,21 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let sawQuerySession = false;
     let sawBridgeManage = false;
     let sawExternalStateQuery = false;
+    // Once-per-turn flag for the fresh-work rest gate. Without this, an agent
+    // that called rest, was told "fresh work arrived", processed the items,
+    // and called rest again would get the same message forever — the gate
+    // condition is read from the turn-start snapshot of pendingMessages,
+    // 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.
+    let noToolCallRetries = 0;
+    const NO_TOOL_CALL_MAX_RETRIES = 2;
     const toolLoopState = (0, tool_loop_1.createToolLoopState)();
     const toolFrictionLedger = (0, tool_friction_1.createToolFrictionLedger)();
     const finishTerminalProviderError = (error, classification) => {
@@ -751,14 +789,53 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             if (hasPhaseAnnotation) {
                 msg.phase = isSoleSettle ? "settle" : "commentary";
             }
+            // Detect the MiniMax "only-thinking, no tool call" violation: no tool
+            // calls returned, and the content is empty after stripping
+            // <think>...</think> blocks. This is a narrow check — legitimate
+            // content-only responses (text without think tags, or text outside
+            // think tags) still flow through the original "no tool calls →
+            // accept as-is" path so existing channels and tests are unaffected.
+            const onlyThinkContent = !result.toolCalls.length
+                && typeof result.content === "string"
+                && stripThinkBlocksForViolationCheck(result.content).length === 0
+                && result.content.length > 0;
             if (!result.toolCalls.length) {
-                // No tool calls — accept response as-is.
-                // (Kick detection disabled; tool_choice: required + settle
-                // is the primary loop control. See src/heart/kicks.ts to re-enable.)
+                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
+                    // call. Retry with a corrective nudge up to NO_TOOL_CALL_MAX_RETRIES
+                    // times. After cap, accept as-is (the readback path strips think
+                    // tags and surfaces a clear diagnostic).
+                    noToolCallRetries++;
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "engine",
+                        event: "engine.no_tool_call_retry",
+                        message: "model returned only <think> content with no tool call despite tool_choice=required; retrying with corrective nudge",
+                        meta: {
+                            attempt: noToolCallRetries,
+                            cap: NO_TOOL_CALL_MAX_RETRIES,
+                            provider: providerRuntime.id,
+                            model: providerRuntime.model,
+                            contentLength: result.content.length,
+                        },
+                    });
+                    messages.push(msg);
+                    messages.push({
+                        role: "user",
+                        content: isInnerDialog
+                            ? "no tool was called this turn. you must end every turn by calling rest (or surface, ponder, observe). emit the tool call now."
+                            : "no tool was called this turn. you must end every turn by calling settle with your answer (or ponder/observe). emit the tool call now.",
+                    });
+                    continue;
+                }
+                // Legitimate text-only response, or cap reached — accept as-is.
                 messages.push(msg);
                 done = true;
             }
             else {
+                // Reset the retry counter on any successful tool call.
+                noToolCallRetries = 0;
                 // Check for settle sole call: intercept before tool execution
                 if (isSoleSettle) {
                     /* v8 ignore next -- defensive: JSON.parse catch for malformed settle args @preserve */
@@ -896,12 +973,20 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
                         continue;
                     }
-                    if (hasFreshPendingWork(options)) {
+                    if (hasFreshPendingWork(options) && !freshWorkGateFired) {
+                        freshWorkGateFired = true;
                         callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), false);
                         messages.push(msg);
                         const gateMessage = "fresh work arrived for me this turn — inspect the pending messages above and take the next concrete action before you rest.";
                         messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: gateMessage });
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, gateMessage);
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "info",
+                            component: "engine",
+                            event: "engine.fresh_work_gate_fired",
+                            message: "rest deferred once because pending work arrived this turn; agent has been notified",
+                            meta: { pendingCount: options.pendingMessages.length },
+                        });
                         continue;
                     }
                     callbacks.onToolEnd("rest", (0, tools_1.summarizeArgs)("rest", restArgs), true);

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

@@ -2938,6 +2938,14 @@ async function executeConnectBlueBubbles(agent, deps) {
     const port = parseOptionalPort(await promptInput("Local webhook port [18790]: "), 18790, "BlueBubbles webhook port");
     const webhookPath = normalizeWebhookPath(await promptInput("Local webhook path [/bluebubbles-webhook]: "), "/bluebubbles-webhook");
     const requestTimeoutMs = parseOptionalPositiveInteger(await promptInput("Request timeout ms [30000]: "), 30000, "BlueBubbles request timeout");
+    // Capture the operator's known iMessage handles so the BB ingest path can
+    // filter group-chat echoes whose `isFromMe` flag was lost or never set.
+    // Without this, the agent would ingest its own outbound message as inbound
+    // and reply to itself ("Slugger talking to himself" in groups).
+    const ownHandlesRaw = (await promptInput("Your iMessage handle(s) — phone(s) and/or email(s) BlueBubbles attributes to your sent messages (comma-separated; needed for the group self-talk filter; blank to skip): ")).trim();
+    const ownHandles = ownHandlesRaw
+        ? ownHandlesRaw.split(",").map((h) => h.trim()).filter((h) => h.length > 0)
+        : [];
     const machineId = currentMachineId(deps);
     const progress = createHumanCommandProgress(deps, "connect bluebubbles");
     let stored;
@@ -2956,6 +2964,7 @@ async function executeConnectBlueBubbles(agent, deps) {
                 serverUrl,
                 password,
                 accountId: "default",
+                ownHandles,
             },
             bluebubblesChannel: {
                 port,
@@ -2984,6 +2993,7 @@ async function executeConnectBlueBubbles(agent, deps) {
             `Stored: ${stored.itemPath}`,
             "agent.json: senses.bluebubbles.enabled = true",
             `Runtime: ${daemonApply}`,
+            `ownHandles: ${ownHandles.length > 0 ? ownHandles.join(", ") : "(none — group self-talk filter inactive)"}`,
             "secret was not printed",
             ...(syncSummary ? [syncSummary] : []),
         ],

package/dist/repertoire/tools-trip.js

@@ -248,6 +248,82 @@ exports.tripToolDefinitions = [
         },
         summaryKeys: ["tripId", "legId"],
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "trip_update_leg",
+                description: "Update specific fields of an existing leg in a trip. Pass tripId, legId, and a JSON object of field updates (e.g. {status:\"cancelled\", confirmationCode:\"PNR123\"}). Existing evidence is preserved unless explicitly overwritten. Use this instead of trip_upsert when you only need to change one leg without re-emitting the whole record. The leg's `kind` cannot be changed (changing kind means a new leg).",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        tripId: { type: "string", description: "Canonical trip id." },
+                        legId: { type: "string", description: "Leg id within the trip." },
+                        updates: { type: "string", description: "JSON object of leg fields to update. Cannot include `legId` or `kind`. Common fields: status, confirmationCode, vendor, amount, checkInDate, checkOutDate, departureTime, arrivalTime, etc." },
+                        updatedAt: { type: "string", description: "ISO timestamp for the update. Used both for the leg's updatedAt and the trip's updatedAt." },
+                    },
+                    required: ["tripId", "legId", "updates", "updatedAt"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (!trustAllowsTripAccess(ctx))
+                return "trip ledger is private; this tool is only available in trusted contexts.";
+            const tripId = args.tripId;
+            const legId = args.legId;
+            const updatedAt = args.updatedAt;
+            if (typeof tripId !== "string" || tripId.length === 0)
+                return "tripId is required.";
+            if (typeof legId !== "string" || legId.length === 0)
+                return "legId is required.";
+            if (typeof updatedAt !== "string" || updatedAt.length === 0)
+                return "updatedAt is required.";
+            try {
+                const updates = parseJsonArg(args.updates, "updates");
+                if (!isRecord(updates))
+                    return "updates must be a JSON object.";
+                // Reject identity-changing fields — those would silently break referential integrity.
+                if ("legId" in updates)
+                    return "updates cannot change legId; create a new leg instead.";
+                if ("kind" in updates)
+                    return "updates cannot change kind; create a new leg instead.";
+                if (Object.keys(updates).length === 0)
+                    return "updates cannot be empty — pass at least one field.";
+                const trip = (0, store_1.readTripRecord)((0, identity_1.getAgentName)(), tripId);
+                const legIndex = trip.legs.findIndex((leg) => leg.legId === legId);
+                if (legIndex === -1)
+                    return `leg ${legId} not found in trip ${tripId}.`;
+                const leg = trip.legs[legIndex];
+                const updatedLeg = {
+                    ...leg,
+                    ...updates,
+                    legId: leg.legId,
+                    kind: leg.kind,
+                    updatedAt,
+                };
+                const updated = {
+                    ...trip,
+                    legs: [...trip.legs.slice(0, legIndex), updatedLeg, ...trip.legs.slice(legIndex + 1)],
+                    updatedAt,
+                };
+                (0, store_1.upsertTripRecord)((0, identity_1.getAgentName)(), updated);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "trips",
+                    event: "trips.leg_updated",
+                    message: "trip leg fields updated",
+                    meta: { agentId: (0, identity_1.getAgentName)(), tripId, legId, fields: Object.keys(updates) },
+                });
+                const fieldList = Object.keys(updates).join(", ");
+                return `leg ${legId} updated in ${tripId}: ${fieldList}.`;
+            }
+            catch (error) {
+                if (error instanceof store_1.TripNotFoundError)
+                    return error.message;
+                return `update failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from parseJsonArg/store */ String(error)}`;
+            }
+        },
+        summaryKeys: ["tripId", "legId"],
+    },
     {
         tool: {
             type: "function",

package/dist/senses/shared-turn.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripThinkBlocks = stripThinkBlocks;
 exports.runSenseTurn = runSenseTurn;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -59,6 +60,29 @@ const pipeline_1 = require("./pipeline");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const runtime_1 = require("../nerves/runtime");
 const RESPONSE_CAP = 50_000;
+/**
+ * Strip MiniMax-style `<think>...</think>` reasoning blocks from a response
+ * string. Handles unclosed open tags (treats everything from `<think>` to
+ * end of string as reasoning) and multiple blocks in sequence. Returns the
+ * trimmed remainder.
+ */
+function stripThinkBlocks(input) {
+    let out = input;
+    // Closed blocks first (greedy match removed by repeatedly slicing the leftmost pair).
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            // Unclosed — drop everything from <think> onward.
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
 /**
  * Run a single agent turn through the inbound pipeline.
  * Caller provides channel, session key, friend, and message;
@@ -191,6 +215,25 @@ async function runSenseTurn(options) {
     else {
         finalResponse = responseText;
     }
+    // Strip MiniMax-style <think>...</think> blocks from the final response.
+    // When a reasoning-style model emits only a think block and no final answer
+    // (no settle tool call, no post-think text), the readback path above
+    // surfaces the raw saved assistant content — which includes the think tags
+    // and renders as empty (or as raw reasoning) on MCP/CLI clients. Strip
+    // here so the caller sees the actual delivered text. If only reasoning
+    // 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) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.shared_turn_only_reasoning",
+            message: "agent produced only <think> reasoning with no final answer — likely a model that closed the think tag without continuing",
+            meta: { agentName, channel, sessionKey, friendId },
+        });
+        finalResponse = "(agent produced reasoning but no final answer this turn — try again, or check the session transcript for the trace)";
+    }
     // Cap response length
     if (finalResponse.length > RESPONSE_CAP) {
         finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";

package/package.json

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