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

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.492",
+      "changes": [
+        "Engine-level fix for the actual root cause of Slugger's empty-reply MCP bug (PR #611's strip+retry was the right shape, but missed the deepest layer). MiniMax-M2.7 occasionally emits an assistant message with BOTH inline `<think>...</think>` reasoning AND tool_calls. When that combination is replayed in a subsequent turn, MiniMax rejects with error 2013 ('tool result's tool id not found') and stalls the entire session — every subsequent turn fails the same way, the failover layer fires repeatedly suggesting a provider switch, and the agent's own answer never reaches the operator. Slugger's session was stuck for 11 unanswered user messages because of this exact loop.",
+        "The fix has two halves and an AX rule: (1) **Persist-time strip** — runAgent now strips `<think>` blocks from the assistant message's persisted `content` before saving, while preserving the original reasoning trace on `_inline_reasoning` for audit. New `engine.inline_reasoning_stripped` info-level nerve event fires when this happens. (2) **Load-time repair** — `sanitizeProviderMessages` self-heals existing sessions that were saved before (1) by stripping the same blocks at load time. (3) **AX rule: full agent awareness, no silent fixes**. When the load-time repair runs, the synthetic tool-result that fills in for the missing tool result is an **explanatory** one — it tells the agent specifically: \"your previous tool call's result was lost because the assistant message had inline reasoning blocks the provider rejected; the harness has stripped them; your reasoning trace is preserved out-of-band; if the work needs to be done, retry the tool call now.\" Tool calls whose parent didn't have stripped reasoning still get a generic-but-improved \"this tool call's result was lost — possible causes [...]; retry if needed\" message instead of the old vague \"interrupted (previous turn timed out)\" line. The agent always sees what happened and what to do next.",
+        "Also: the no-tool-call retry path (added in #611's last commit) now uses the same shared `stripThinkBlocksForViolationCheck` helper so the violation-detection logic is consistent. Three regression tests cover the full path: persist-time strip preserves `_inline_reasoning`, load-time repair produces the explanatory tool-result message, generic orphans get the generic message, and unclosed `<think>` tags drop everything from the open tag onward."
+      ]
+    },
+    {
+      "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))
@@ -380,10 +403,13 @@ function repairOrphanedToolCalls(messages) {
         }
         const missing = asst.tool_calls.filter((tc) => !resultIds.has(tc.id));
         if (missing.length > 0) {
+            // AX rule: the agent must see what happened. Don't say "interrupted"
+            // — that's vague. Tell them the result was lost, possible causes,
+            // and what to do next.
             const syntheticResults = missing.map((tc) => ({
                 role: "tool",
                 tool_call_id: tc.id,
-                content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+                content: "error: this tool call's result was lost — the previous turn ended before the tool finished (provider rejection, daemon interrupt, or the tool itself errored). if the work needs to be done, retry the tool call now.",
             }));
             let insertAt = i + 1;
             while (insertAt < messages.length && messages[insertAt].role === "tool")
@@ -545,6 +571,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) => {
@@ -726,8 +767,36 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             const msg = {
                 role: "assistant",
             };
-            if (result.content)
-                msg.content = result.content;
+            // Persist assistant content WITHOUT inline <think>...</think> blocks.
+            // Reasoning content already routed through onReasoningChunk for live
+            // surfacing and persisted separately as `_reasoning_items` for
+            // providers that support a reasoning channel; saving it inline AND
+            // alongside tool_calls causes MiniMax to reject the replayed turn
+            // with "tool result's tool id not found" (error code 2013) because
+            // it can't reconcile reasoning-with-tools in the same assistant
+            // message. Strip aggressively at persist so the next replay is
+            // clean; preserve the original reasoning trace on the message via
+            // `_inline_reasoning` so debug/audit paths can still see it.
+            if (result.content) {
+                const stripped = stripThinkBlocksForViolationCheck(result.content);
+                if (stripped.length > 0)
+                    msg.content = stripped;
+                if (stripped.length !== result.content.length) {
+                    msg._inline_reasoning = result.content;
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "info",
+                        component: "engine",
+                        event: "engine.inline_reasoning_stripped",
+                        message: "stripped inline <think> blocks from persisted assistant message; preserved on _inline_reasoning",
+                        meta: {
+                            provider: providerRuntime.id,
+                            model: providerRuntime.model,
+                            originalLength: result.content.length,
+                            strippedLength: stripped.length,
+                        },
+                    });
+                }
+            }
             if (result.toolCalls.length)
                 msg.tool_calls = result.toolCalls.map((tc) => ({
                     id: tc.id,
@@ -751,14 +820,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 +1004,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/heart/session-events.js

@@ -334,7 +334,7 @@ function repairSessionMessages(messages) {
     });
     return result.map(toProviderMessage);
 }
-function repairToolCallSequences(messages) {
+function repairToolCallSequences(messages, inlineReasoningStrippedCallIds = new Set()) {
     const normalized = messages.map(normalizeMessage);
     const validCallIds = new Set();
     for (const msg of normalized) {
@@ -381,7 +381,7 @@ function repairToolCallSequences(messages) {
             continue;
         const syntheticResults = missing.map((toolCall) => ({
             role: "tool",
-            content: "error: tool call was interrupted (previous turn timed out or was aborted)",
+            content: buildSyntheticToolResultMessage(toolCall.id, inlineReasoningStrippedCallIds),
             name: null,
             toolCallId: toolCall.id,
             toolCalls: [],
@@ -460,6 +460,105 @@ function migrateToolNames(messages) {
     }
     return safeMessages.map(normalizeMessage).map(toProviderMessage);
 }
+/**
+ * Strip inline `<think>...</think>` blocks from a string. Mirrors the
+ * helper at senses/shared-turn.ts (operator-facing) and core.ts
+ * (live-turn) — kept inline here because session-events.ts is the load-
+ * time repair path and needs its own copy to avoid sense/heart import
+ * cycles. If the close tag is missing, drops everything from the open
+ * tag onward.
+ */
+function stripInlineThinkBlocks(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();
+}
+/**
+ * Strip inline `<think>` content from any assistant message that ALSO has
+ * tool_calls. MiniMax-style models persist think-content + tool_calls on
+ * the same assistant turn; replaying that combination triggers MiniMax
+ * error 2013 ("tool result's tool id not found") and stalls the session.
+ *
+ * AX requirement: the agent MUST see that this happened. We don't silently
+ * paper over their previous turn — we strip for replay correctness AND
+ * collect the affected tool_call_ids in `inlineReasoningStrippedCallIds`
+ * so the downstream synthetic-tool-result repair can produce an
+ * explanatory message addressed to those specific calls. The agent sees:
+ * "your previous tool call's result was lost because the assistant message
+ * had inline reasoning blocks the provider couldn't replay — here's what
+ * happened, retry if needed." Full awareness, no silent corrections.
+ *
+ * This load-time repair self-heals existing sessions that were saved
+ * before the persist-time strip in core.ts landed.
+ */
+function repairInlineReasoningOnReplay(messages, inlineReasoningStrippedCallIds) {
+    let repaired = 0;
+    const result = messages.map((msg) => {
+        if (msg.role !== "assistant")
+            return msg;
+        const a = msg;
+        if (!a.tool_calls || a.tool_calls.length === 0)
+            return msg;
+        if (typeof a.content !== "string")
+            return msg;
+        if (!a.content.includes("<think>"))
+            return msg;
+        const stripped = stripInlineThinkBlocks(a.content);
+        repaired++;
+        for (const tc of a.tool_calls)
+            inlineReasoningStrippedCallIds.add(tc.id);
+        return { ...a, content: stripped.length > 0 ? stripped : null };
+    });
+    if (repaired > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            event: "mind.session_inline_reasoning_repair",
+            component: "mind",
+            message: "stripped inline <think> blocks from assistant messages with tool_calls so replay is valid; agent will see explanatory tool-result messages",
+            meta: { repaired, affectedCallIds: inlineReasoningStrippedCallIds.size },
+        });
+    }
+    return result;
+}
+/**
+ * Compose the synthetic tool-result message the agent sees when their
+ * previous turn's tool call has no matching tool result. The default
+ * message tells the agent what happened (turn ended early, result lost)
+ * and what to do (retry if the work isn't done). When the parent
+ * assistant message had inline `<think>` reasoning that the provider
+ * rejected, the message is more specific so the agent can adjust.
+ *
+ * AX rule: every repair must produce a message the agent can read and
+ * act on. Silent strips are never OK.
+ */
+function buildSyntheticToolResultMessage(toolCallId, inlineReasoningStrippedCallIds) {
+    if (inlineReasoningStrippedCallIds.has(toolCallId)) {
+        return [
+            "error: this tool call's result was lost.",
+            "your previous assistant turn included inline `<think>...</think>` reasoning alongside tool_calls,",
+            "and the provider (likely MiniMax) rejects that combination on replay (error 2013).",
+            "the harness has stripped the inline reasoning from the persisted content so the next replay is valid;",
+            "your reasoning trace itself is preserved out-of-band and not lost.",
+            "if the underlying work still needs to be done, retry the tool call now —",
+            "the call may not have run, or it ran but the result didn't reach you.",
+        ].join(" ");
+    }
+    return [
+        "error: this tool call's result was lost — the previous turn ended before the tool finished",
+        "(provider rejection, daemon interrupt, or the tool itself errored).",
+        "if the work needs to be done, retry the tool call now.",
+    ].join(" ");
+}
 function sanitizeProviderMessages(messages) {
     const safeMessages = messages.filter((message) => Boolean(message) && typeof message === "object");
     const normalized = safeMessages.map(normalizeMessage);
@@ -473,7 +572,12 @@ function sanitizeProviderMessages(messages) {
             meta: { violations },
         });
     }
-    return canonicalizeSystemMessageSequence(migrateToolNames(repairToolCallSequences(repairSessionMessages(normalized.map(toProviderMessage)))));
+    // Track which tool_call_ids belonged to assistant messages whose inline
+    // reasoning we just stripped. The synthetic-tool-result repair downstream
+    // uses this set to produce an explanatory message for those calls so the
+    // agent has full awareness of what happened.
+    const inlineReasoningStrippedCallIds = new Set();
+    return canonicalizeSystemMessageSequence(migrateToolNames(repairToolCallSequences(repairInlineReasoningOnReplay(repairSessionMessages(normalized.map(toProviderMessage)), inlineReasoningStrippedCallIds), inlineReasoningStrippedCallIds)));
 }
 function stampIngressTime(msg) {
     msg._ingressAt = new Date().toISOString();

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.492",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",