@ouro.bot/cli 0.1.0-alpha.609 → 0.1.0-alpha.611

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.611",
+      "changes": [
+        "BlueBubbles recovery: stale captured inbound sidecars are now marked superseded when the chat session has already advanced, preventing old iMessage recovery entries from keeping runtime health in warn or replaying obsolete chat turns."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.610",
+      "changes": [
+        "Fix the inner-dialog rest loop incident: skip empty rest-only assistant turns when deriving checkpoints, surface meaningful tool-only actions in thoughts/status output, compact idle heartbeat rest triplets, and avoid stale session repair churn during active-session scans."
+      ]
+    },
     {
       "version": "0.1.0-alpha.609",
       "changes": [

package/dist/heart/daemon/thoughts.js

@@ -344,12 +344,79 @@ function extractSettleAnswer(messages) {
     }
     return "";
 }
+function parseToolArguments(argumentsValue) {
+    if (!argumentsValue)
+        return {};
+    try {
+        const parsed = JSON.parse(argumentsValue);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toolArgumentText(args, keys) {
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+function truncateToolSummary(summary) {
+    if (summary.length <= 220)
+        return summary;
+    return `${summary.slice(0, 217)}...`;
+}
+function summarizeToolAction(name, argumentsValue) {
+    if (!name)
+        return null;
+    const args = parseToolArguments(argumentsValue);
+    if (name === "surface") {
+        const message = toolArgumentText(args, ["message", "text", "content"]);
+        return message ? `surfaced: ${message}` : null;
+    }
+    if (name === "ponder") {
+        const thought = toolArgumentText(args, ["summary", "question", "topic", "prompt"]);
+        return thought ? `pondered: ${thought}` : null;
+    }
+    if (name === "diary_write") {
+        const note = toolArgumentText(args, ["text", "content", "note", "entry"]);
+        return note ? `diary: ${note}` : null;
+    }
+    if (name === "let_go") {
+        const reason = toolArgumentText(args, ["reason", "note", "status"]);
+        return reason ? `let go: ${reason}` : null;
+    }
+    if (name === "rest") {
+        const note = toolArgumentText(args, ["note", "status"]);
+        return note ? `rested: ${note}` : null;
+    }
+    return null;
+}
+function extractToolActionSummary(messages) {
+    for (let k = messages.length - 1; k >= 0; k--) {
+        const msg = messages[k];
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (let i = msg.tool_calls.length - 1; i >= 0; i--) {
+            const toolFunction = extractToolFunction(msg.tool_calls[i]);
+            const summary = summarizeToolAction(toolFunction?.name, toolFunction?.arguments);
+            if (summary)
+                return truncateToolSummary(summary);
+        }
+    }
+    return "";
+}
 function extractThoughtResponseFromMessages(messages) {
     const assistantMsgs = messages.filter((message) => message.role === "assistant");
     const lastAssistant = assistantMsgs.reverse().find((message) => contentToText(message.content).trim().length > 0);
     return lastAssistant
         ? contentToText(lastAssistant.content).trim()
-        : extractSettleAnswer(messages);
+        : extractSettleAnswer(messages) || extractToolActionSummary(messages);
 }
 function parseInnerDialogSession(sessionPath) {
     (0, runtime_1.emitNervesEvent)({

package/dist/heart/session-activity.js

@@ -56,7 +56,7 @@ function resolveFriendName(friendId, friendsDir, agentName) {
         return friendId;
     }
 }
-function parseFriendActivity(sessionPath) {
+function parseFriendActivity(sessionPath, activeThresholdMs, nowMs) {
     let mtimeMs;
     try {
         mtimeMs = fs.statSync(sessionPath).mtimeMs;
@@ -64,6 +64,9 @@ function parseFriendActivity(sessionPath) {
     catch {
         return null;
     }
+    if (Number.isFinite(activeThresholdMs) && nowMs - mtimeMs > activeThresholdMs) {
+        return null;
+    }
     const envelope = (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
     const chronology = envelope ? (0, session_events_1.deriveSessionChronology)(envelope.events) : null;
     const explicit = envelope?.state.lastFriendActivityAt;
@@ -152,7 +155,7 @@ function listSessionActivity(query) {
                     continue;
                 }
                 const sessionPath = path.join(channelPath, keyFile);
-                const activity = parseFriendActivity(sessionPath);
+                const activity = parseFriendActivity(sessionPath, activeThresholdMs, nowMs);
                 if (!activity)
                     continue;
                 if (nowMs - activity.lastActivityMs > activeThresholdMs)

package/dist/mind/context.js

@@ -54,6 +54,7 @@ Object.defineProperty(exports, "detectDuplicateToolCallIds", { enumerable: true,
 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; } });
+const IDLE_REST_ONLY_KEEP_TURNS = 20;
 function buildTrimmableBlocks(messages) {
     const blocks = [];
     let i = 0;
@@ -95,6 +96,89 @@ function getSystemMessageIndices(messages) {
 function buildTrimmedMessages(messages, kept) {
     return messages.filter((m, idx) => m.role === "system" || kept.has(idx));
 }
+function messageContentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function toolCallName(toolCall) {
+    return toolCall.function.name;
+}
+function toolCallId(toolCall) {
+    return toolCall.id;
+}
+function isIdleHeartbeatRestUserMessage(message) {
+    if (message.role !== "user")
+        return false;
+    const text = messageContentToText(message.content);
+    return text.includes("...time passing. anything stirring?")
+        && !text.includes("[pending from ")
+        && !text.includes("## task:");
+}
+function isEmptyRestOnlyAssistantMessage(message) {
+    if (message.role !== "assistant")
+        return null;
+    if (messageContentToText(message.content).trim())
+        return null;
+    if (!Array.isArray(message.tool_calls) || message.tool_calls.length !== 1)
+        return null;
+    const onlyToolCall = message.tool_calls[0];
+    if (toolCallName(onlyToolCall) !== "rest")
+        return null;
+    return toolCallId(onlyToolCall);
+}
+function isMatchingToolResult(message, toolId) {
+    return message.tool_call_id === toolId;
+}
+function compactIdleRestOnlyTurns(messages, keepTurns = IDLE_REST_ONLY_KEEP_TURNS) {
+    const blocks = [];
+    let i = 0;
+    while (i < messages.length - 2) {
+        const userMessage = messages[i];
+        const assistantMessage = messages[i + 1];
+        const toolMessage = messages[i + 2];
+        const restToolId = isIdleHeartbeatRestUserMessage(userMessage)
+            ? isEmptyRestOnlyAssistantMessage(assistantMessage)
+            : null;
+        if (restToolId && isMatchingToolResult(toolMessage, restToolId)) {
+            blocks.push({ start: i, end: i + 2 });
+            i += 3;
+            continue;
+        }
+        i++;
+    }
+    if (blocks.length <= keepTurns)
+        return messages;
+    const drop = new Set();
+    for (const block of blocks.slice(0, blocks.length - keepTurns)) {
+        for (let index = block.start; index <= block.end; index++) {
+            drop.add(index);
+        }
+    }
+    const compacted = messages.filter((_message, index) => !drop.has(index));
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.session_idle_rest_compaction",
+        message: "compacted old idle rest-only inner turns",
+        meta: {
+            removedTurns: blocks.length - keepTurns,
+            keptTurns: keepTurns,
+            removedMessages: drop.size,
+            originalCount: messages.length,
+            finalCount: compacted.length,
+        },
+    });
+    return compacted;
+}
 function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     const targetTokens = Math.floor(maxTokens * (1 - contextMargin / 100));
     const estimatedBefore = (0, token_estimate_1.estimateTokensForMessages)(messages);
@@ -284,9 +368,10 @@ function postTurnTrim(messages, usage, hooks) {
         }
     }
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
-    const currentIngressTimes = messages.map(session_events_1.getIngressTime);
     const currentMessages = (0, session_events_1.sanitizeProviderMessages)(messages);
-    const trimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
+    const currentIngressTimes = currentMessages.map(session_events_1.getIngressTime);
+    const tokenTrimmedMessages = trimMessages(currentMessages, maxTokens, contextMargin, usage?.input_tokens);
+    const trimmedMessages = compactIdleRestOnlyTurns(tokenTrimmedMessages);
     messages.splice(0, messages.length, ...trimmedMessages);
     return { currentMessages, trimmedMessages, currentIngressTimes, maxTokens, contextMargin };
 }

package/dist/senses/bluebubbles/index.js

@@ -1514,7 +1514,11 @@ function listPendingCapturedInboundMessages(agentName) {
         seenMessageGuids.add(entry.messageGuid);
         return true;
     })
-        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid));
+        .filter((entry) => {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid))
+            return false;
+        return !markCapturedInboundSuperseded(agentName, entry);
+    });
 }
 function listPendingRecoveryEntries(agentName) {
     const pendingByGuid = new Map();
@@ -1546,6 +1550,67 @@ function parseTimestampMs(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : null;
 }
+function eventRecordedAtMs(event) {
+    return parseTimestampMs(event.time?.recordedAt ?? undefined);
+}
+function blueBubblesSessionPathsForKey(agentName, sessionKey) {
+    const sessionsRoot = path.join((0, identity_1.getAgentRoot)(agentName), "state", "sessions");
+    const fileName = `${(0, config_1.sanitizeKey)(sessionKey)}.json`;
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return friendDirs
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(sessionsRoot, entry.name, "bluebubbles", fileName))
+        .filter((filePath) => {
+        try {
+            return fs.statSync(filePath).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function hasNewerBlueBubblesSessionActivity(agentName, sessionKey, recordedAt) {
+    const recordedAtMs = parseTimestampMs(recordedAt);
+    if (recordedAtMs === null)
+        return false;
+    for (const sessionFilePath of blueBubblesSessionPathsForKey(agentName, sessionKey)) {
+        const session = (0, context_1.loadSession)(sessionFilePath);
+        for (const event of session?.events ?? []) {
+            if (event.role === "system")
+                continue;
+            const nextRecordedAtMs = eventRecordedAtMs(event);
+            if (nextRecordedAtMs !== null && nextRecordedAtMs > recordedAtMs) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function markCapturedInboundSuperseded(agentName, entry) {
+    if (!entry.messageGuid.trim())
+        return false;
+    if (!hasNewerBlueBubblesSessionActivity(agentName, entry.sessionKey, entry.recordedAt))
+        return false;
+    (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, inboundEntryToRecoveryEvent(entry), entry.source, "recovery-superseded");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_recovery_skip",
+        message: "skipped stale captured bluebubbles recovery because the session already advanced",
+        meta: {
+            messageGuid: entry.messageGuid,
+            sessionKey: entry.sessionKey,
+            source: entry.source,
+            dedupeReason: "session_superseded",
+        },
+    });
+    return true;
+}
 function resolveBlueBubblesCatchUpSince(previousState, nowMs = Date.now()) {
     if (previousState.upstreamStatus === "error") {
         return nowMs - BLUEBUBBLES_RECOVERY_CATCHUP_LOOKBACK_MS;

package/dist/senses/inner-dialog.js

@@ -183,13 +183,10 @@ function contentToText(content) {
         .join("\n");
     return text.trim();
 }
-function deriveResumeCheckpoint(messages) {
-    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
-    if (!lastAssistant)
-        return "no prior checkpoint recorded";
-    const assistantText = contentToText(lastAssistant.content);
+function checkpointTextFromAssistantContent(content) {
+    const assistantText = contentToText(content);
     if (!assistantText)
-        return "no prior checkpoint recorded";
+        return null;
     const cleanedLines = assistantText
         .split("\n")
         .map((line) => line.replace(/<\/?think>/gi, "").trim())
@@ -198,14 +195,102 @@ function deriveResumeCheckpoint(messages) {
         .find((line) => /^checkpoint\s*:/i.test(line));
     if (explicitCheckpoint) {
         const parsed = explicitCheckpoint.replace(/^checkpoint\s*:\s*/i, "").trim();
-        return parsed || "no prior checkpoint recorded";
+        return parsed || null;
     }
     const firstLine = cleanedLines[0];
-    if (!firstLine)
-        return "no prior checkpoint recorded";
-    if (firstLine.length <= 220)
-        return firstLine;
-    return `${firstLine.slice(0, 217)}...`;
+    return firstLine ?? null;
+}
+function truncateCheckpointText(text) {
+    if (text.length <= 220)
+        return text;
+    return `${text.slice(0, 217)}...`;
+}
+function parseToolArguments(argumentsValue) {
+    if (!argumentsValue)
+        return {};
+    try {
+        const parsed = JSON.parse(argumentsValue);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toolArgumentText(args, keys) {
+    for (const key of keys) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+function summarizeToolAction(name, argumentsValue) {
+    if (!name)
+        return null;
+    const args = parseToolArguments(argumentsValue);
+    if (name === "surface") {
+        const message = toolArgumentText(args, ["message", "text", "content"]);
+        return message ? `surfaced: ${message}` : null;
+    }
+    if (name === "ponder") {
+        const thought = toolArgumentText(args, ["summary", "question", "topic", "prompt"]);
+        return thought ? `pondered: ${thought}` : null;
+    }
+    if (name === "diary_write") {
+        const note = toolArgumentText(args, ["text", "content", "note", "entry"]);
+        return note ? `diary: ${note}` : null;
+    }
+    if (name === "let_go") {
+        const reason = toolArgumentText(args, ["reason", "note", "status"]);
+        return reason ? `let go: ${reason}` : null;
+    }
+    if (name === "rest") {
+        const note = toolArgumentText(args, ["note", "status"]);
+        return note ? `rested: ${note}` : null;
+    }
+    return null;
+}
+function extractToolFunction(toolCall) {
+    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
+        return null;
+    const maybeFunction = toolCall.function;
+    if (!maybeFunction || typeof maybeFunction !== "object")
+        return null;
+    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
+        ? maybeFunction.name
+        : undefined;
+    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
+        ? maybeFunction.arguments
+        : undefined;
+    return { name, arguments: argumentsValue };
+}
+function checkpointTextFromAssistantToolCalls(message) {
+    if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
+        return null;
+    for (let i = message.tool_calls.length - 1; i >= 0; i--) {
+        const toolFunction = extractToolFunction(message.tool_calls[i]);
+        const summary = summarizeToolAction(toolFunction?.name, toolFunction?.arguments);
+        if (summary)
+            return summary;
+    }
+    return null;
+}
+function deriveResumeCheckpoint(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "assistant")
+            continue;
+        const textCheckpoint = checkpointTextFromAssistantContent(message.content);
+        if (textCheckpoint)
+            return truncateCheckpointText(textCheckpoint);
+        const toolCheckpoint = checkpointTextFromAssistantToolCalls(message);
+        if (toolCheckpoint)
+            return truncateCheckpointText(toolCheckpoint);
+    }
+    return "no prior checkpoint recorded";
 }
 function extractAssistantPreview(messages, maxLength = 120) {
     const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");

package/package.json

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