@ouro.bot/cli 0.1.0-alpha.720 → 0.1.0-alpha.722

package/dist/senses/bluebubbles/context-packet.js

@@ -45,6 +45,23 @@ function messageToContextInput(event, chatGuidHash) {
         },
     };
 }
+function normalizeKnownMessageText(value) {
+    return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function hasKnownMessageText(candidate, knownTexts) {
+    if (knownTexts.size === 0)
+        return false;
+    const body = normalizeKnownMessageText(candidate.textForAgent || candidate.text);
+    if (!body)
+        return true;
+    if (knownTexts.has(body))
+        return true;
+    for (const known of knownTexts) {
+        if (body.length >= 12 && known.includes(body))
+            return true;
+    }
+    return false;
+}
 async function buildBlueBubblesContextPacket(input) {
     if (!Number.isFinite(input.event.timestamp))
         return null;
@@ -53,6 +70,9 @@ async function buildBlueBubblesContextPacket(input) {
     const event = input.event;
     const chatGuidHash = blueBubblesContextChatKeyHash(event);
     const anchorTimestamp = new Date(event.timestamp).toISOString();
+    const knownTexts = new Set((input.knownMessageTexts ?? [])
+        .map(normalizeKnownMessageText)
+        .filter((value) => value.length > 0));
     const candidates = await input.client.listRecentMessages({
         beforeTimestamp: event.timestamp,
         limit: exports.BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
@@ -65,7 +85,8 @@ async function buildBlueBubblesContextPacket(input) {
         .filter((candidate) => isSameBlueBubblesChat(candidate, event))
         .filter((candidate) => candidate.messageGuid !== event.messageGuid)
         .filter((candidate) => candidate.timestamp <= event.timestamp)
-        .filter((candidate) => event.timestamp - candidate.timestamp <= exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS);
+        .filter((candidate) => event.timestamp - candidate.timestamp <= exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS)
+        .filter((candidate) => !hasKnownMessageText(candidate, knownTexts));
     if (history.length === 0)
         return null;
     const packet = (0, context_packets_1.buildSenseContextPacket)({

package/dist/senses/bluebubbles/index.js

@@ -623,12 +623,18 @@ function insertEphemeralContextMessages(messages, contextMessages) {
         ...messages.slice(insertionIndex),
     ];
 }
+function knownProviderMessageTexts(messages) {
+    return messages
+        .map((message) => extractMessageText(message.content))
+        .map((text) => text.trim())
+        .filter((text) => text.length > 0);
+}
 async function buildBlueBubblesContextMessages(input) {
     if (input.event.kind !== "message")
-        return [];
+        return { messages: [], contextPacketIds: [] };
     const event = input.event;
     if (!Number.isFinite(event.timestamp))
-        return [];
+        return { messages: [], contextPacketIds: [] };
     const chatGuidHash = (0, context_packet_1.blueBubblesContextChatKeyHash)(event);
     const anchorTimestamp = new Date(event.timestamp).toISOString();
     try {
@@ -636,9 +642,10 @@ async function buildBlueBubblesContextMessages(input) {
             agentName: input.agentName,
             client: input.client,
             event,
+            knownMessageTexts: knownProviderMessageTexts(input.knownMessages ?? []),
         });
         if (!result)
-            return [];
+            return { messages: [], contextPacketIds: [] };
         const { packet, rendered, historyCount } = result;
         (0, context_packet_ledger_1.writeSenseContextPacket)(input.agentRoot, packet);
         (0, runtime_1.emitNervesEvent)({
@@ -651,7 +658,10 @@ async function buildBlueBubblesContextMessages(input) {
                 contextMessages: historyCount,
             },
         });
-        return [{ role: "system", content: rendered.text }];
+        return {
+            messages: [{ role: "system", content: rendered.text }],
+            contextPacketIds: [packet.packetId],
+        };
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -671,9 +681,12 @@ async function buildBlueBubblesContextMessages(input) {
             maxAgeMs: 24 * 60 * 60 * 1000,
         });
         if (!fallback)
-            return [];
+            return { messages: [], contextPacketIds: [] };
         const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(fallback);
-        return [{ role: "system", content: rendered.text }];
+        return {
+            messages: [{ role: "system", content: rendered.text }],
+            contextPacketIds: [fallback.packetId],
+        };
     }
 }
 function createReplyTargetController(event) {
@@ -1468,6 +1481,10 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 if (typeof timeoutTimer.unref === "function") {
                     timeoutTimer.unref();
                 }
+                let preparedBlueBubblesContext = {
+                    messages: [],
+                    contextPacketIds: [],
+                };
                 const turnPromise = (0, pipeline_1.handleInboundTurn)({
                     channel: "bluebubbles",
                     sessionKey: event.chat.sessionKey,
@@ -1494,35 +1511,44 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     enforceTrustGate: trust_gate_1.enforceTrustGate,
                     drainPending: pending_1.drainPending,
                     drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
-                    runAgent: async (msgs, cb, channel, sig, opts) => {
-                        const contextMessages = await buildBlueBubblesContextMessages({
+                    prepareRunAgentOptions: async ({ messages, runAgentOptions }) => {
+                        preparedBlueBubblesContext = await buildBlueBubblesContextMessages({
                             agentName,
                             agentRoot: (0, identity_1.getAgentRoot)(),
                             client,
                             event,
+                            knownMessages: messages,
                         });
-                        return resolvedDeps.runAgent(insertEphemeralContextMessages(msgs, contextMessages), cb, channel, sig, {
-                            ...opts,
-                            toolContext: {
-                                /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                                signin: async () => undefined,
-                                ...opts?.toolContext,
-                                summarize,
-                                bluebubblesReplyTarget: {
-                                    setSelection: (selection) => replyTarget.setSelection(selection),
-                                },
-                                codingFeedback: {
-                                    send: async (message) => {
-                                        await client.sendText({
-                                            chat: event.chat,
-                                            text: message,
-                                            replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                                        });
-                                    },
+                        if (preparedBlueBubblesContext.contextPacketIds.length === 0)
+                            return undefined;
+                        return {
+                            contextPacketIds: [
+                                ...(runAgentOptions.contextPacketIds ?? []),
+                                ...preparedBlueBubblesContext.contextPacketIds,
+                            ],
+                        };
+                    },
+                    runAgent: async (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(insertEphemeralContextMessages(msgs, preparedBlueBubblesContext.messages), cb, channel, sig, {
+                        ...opts,
+                        toolContext: {
+                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                            signin: async () => undefined,
+                            ...opts?.toolContext,
+                            summarize,
+                            bluebubblesReplyTarget: {
+                                setSelection: (selection) => replyTarget.setSelection(selection),
+                            },
+                            codingFeedback: {
+                                send: async (message) => {
+                                    await client.sendText({
+                                        chat: event.chat,
+                                        text: message,
+                                        replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                                    });
                                 },
                             },
-                        });
-                    },
+                        },
+                    }),
                     postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
                         const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
                         resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);

package/dist/senses/context-packet-ledger.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeSenseContextPacket = writeSenseContextPacket;
 exports.readSenseContextLedger = readSenseContextLedger;
+exports.listSenseContextPacketSummaries = listSenseContextPacketSummaries;
+exports.readSenseContextPacketView = readSenseContextPacketView;
 exports.readLatestVisibleSenseContextPacket = readLatestVisibleSenseContextPacket;
 exports.compactSenseContextPacketReceipts = compactSenseContextPacketReceipts;
 const fs = __importStar(require("node:fs"));
@@ -44,6 +46,9 @@ const context_packets_1 = require("./context-packets");
 function contextPacketRoot(agentRoot, sense) {
     return path.join(agentRoot, "state", "senses", "context-packets", sense);
 }
+function contextPacketBaseRoot(agentRoot) {
+    return path.join(agentRoot, "state", "senses", "context-packets");
+}
 function packetPath(agentRoot, packet) {
     const month = packet.anchorTimestamp.slice(0, 7) || "unknown";
     return path.join(contextPacketRoot(agentRoot, packet.sense), month, `${packet.packetId}.json`);
@@ -181,6 +186,127 @@ function readSenseContextLedger(agentRoot, sense) {
     });
     return rows;
 }
+function safeContextPacketLimit(limit) {
+    return Number.isInteger(limit) && typeof limit === "number" && limit >= 1 && limit <= 100 ? limit : 20;
+}
+function discoverContextPacketSenses(agentRoot) {
+    const root = contextPacketBaseRoot(agentRoot);
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root)
+        .filter((entry) => {
+        try {
+            return fs.statSync(path.join(root, entry)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+}
+function summarizeLedgerRow(row) {
+    return {
+        packetId: row.packetId,
+        sense: row.sense,
+        agent: row.agent,
+        chatKeyHash: row.chatKeyHash,
+        anchorMessageGuid: row.anchorMessageGuid,
+        anchorTimestamp: row.anchorTimestamp,
+        createdAt: row.createdAt,
+        messageCount: row.messageCount,
+        sourceRefs: row.sourceRefs,
+        bodyHashes: row.bodyHashes,
+        rawBodyStored: row.rawBodyStored,
+        privacyClass: row.privacyClass,
+        omittedMessages: row.omittedMessages,
+        truncatedMessages: row.truncatedMessages,
+    };
+}
+function readAllContextPacketRows(agentRoot, sense) {
+    const senses = sense ? [sense] : discoverContextPacketSenses(agentRoot);
+    return senses.flatMap((entry) => readSenseContextLedger(agentRoot, entry));
+}
+function timestampSortValue(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function listSenseContextPacketSummaries(agentRoot, options = {}) {
+    const limit = safeContextPacketLimit(options.limit);
+    const rows = readAllContextPacketRows(agentRoot, options.sense)
+        .sort((left, right) => timestampSortValue(right.createdAt || right.anchorTimestamp) - timestampSortValue(left.createdAt || left.anchorTimestamp));
+    return {
+        totalCount: rows.length,
+        limit,
+        items: rows.slice(0, limit).map(summarizeLedgerRow),
+    };
+}
+function isSafeContextPacketId(packetId) {
+    return /^scp_[A-Za-z0-9_-]+$/.test(packetId);
+}
+function pathInsideContextPacketRoot(agentRoot, sense, filePath) {
+    const root = path.resolve(contextPacketRoot(agentRoot, sense));
+    const resolved = path.resolve(filePath);
+    return resolved === root || resolved.startsWith(`${root}${path.sep}`);
+}
+function redactPreview(value) {
+    return value
+        .replace(/\bpassword=[^\s]+/gi, "password=[redacted]")
+        .replace(/\b(token|api[_-]?key|secret)=[^\s]+/gi, "$1=[redacted]");
+}
+function viewMessage(message) {
+    const { chatGuid: _chatGuid, ...sourceRef } = message.sourceRef;
+    return {
+        timestamp: message.timestamp,
+        authorLabel: message.authorLabel,
+        bodyHash: message.bodyHash,
+        bodyPreview: redactPreview(message.bodyPreview),
+        sourceRef,
+        renderedSourceRef: message.renderedSourceRef,
+    };
+}
+function emitContextPacketReadWarning(packetId, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.context_packet_read_error",
+        message: "failed to read sense context packet view",
+        meta: { packetId, reason },
+    });
+}
+function readSenseContextPacketView(agentRoot, packetId) {
+    if (!isSafeContextPacketId(packetId))
+        return null;
+    const row = readAllContextPacketRows(agentRoot).find((entry) => entry.packetId === packetId);
+    if (!row)
+        return null;
+    if (!pathInsideContextPacketRoot(agentRoot, row.sense, row.packetPath)) {
+        emitContextPacketReadWarning(packetId, "packet path escaped context-packet root");
+        return null;
+    }
+    if (!fs.existsSync(row.packetPath))
+        return null;
+    try {
+        const packet = JSON.parse(fs.readFileSync(row.packetPath, "utf-8"));
+        if (packet.packetId !== packetId || !Array.isArray(packet.messages))
+            return null;
+        return {
+            row: summarizeLedgerRow(row),
+            packet: {
+                packetId,
+                sense: typeof packet.sense === "string" ? packet.sense : row.sense,
+                agent: typeof packet.agent === "string" ? packet.agent : row.agent,
+                privacyClass: packet.privacyClass === "private-runtime" ? packet.privacyClass : "private-runtime",
+                messages: packet.messages.map((message) => viewMessage(message)),
+                omittedMessages: typeof packet.omittedMessages === "number" ? packet.omittedMessages : row.omittedMessages,
+                truncatedMessages: typeof packet.truncatedMessages === "number" ? packet.truncatedMessages : row.truncatedMessages,
+            },
+        };
+    }
+    catch (error) {
+        emitContextPacketReadWarning(packetId, error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}
 function timestampMs(value) {
     return Date.parse(value);
 }

package/dist/senses/pipeline.js

@@ -369,6 +369,36 @@ let _lastSessionKey = null;
 function runAgentOptionContextPacketIds(options) {
     return Array.isArray(options.contextPacketIds) ? options.contextPacketIds : [];
 }
+function mergeRunAgentContextPacketIds(left, right) {
+    const merged = [
+        ...(Array.isArray(left) ? left : []),
+        ...(Array.isArray(right) ? right : []),
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    return merged.length > 0 ? [...new Set(merged)] : undefined;
+}
+function mergePreparedRunAgentOptions(base, prepared) {
+    if (!prepared)
+        return base;
+    const contextPacketIds = mergeRunAgentContextPacketIds(base.contextPacketIds, prepared.contextPacketIds);
+    const { contextPacketIds: _baseContextPacketIds, ...baseOptions } = base;
+    const { contextPacketIds: _preparedContextPacketIds, ...preparedOptions } = prepared;
+    const merged = {
+        ...baseOptions,
+        ...preparedOptions,
+        ...(contextPacketIds ? { contextPacketIds } : {}),
+    };
+    if (prepared.toolContext) {
+        const toolContext = {
+            ...base.toolContext,
+            ...prepared.toolContext,
+        };
+        merged.toolContext = {
+            ...toolContext,
+            signin: toolContext.signin ?? (async () => undefined),
+        };
+    }
+    return merged;
+}
 function buildInboundRunLedgerInput(input) {
     const target = {
         channel: input.channel,
@@ -822,7 +852,7 @@ async function handleInboundTurn(input) {
         const existingToolContext = input.runAgentOptions?.toolContext;
         const currentUserMessage = existingToolContext?.currentUserMessage
             ?? latestUserAuthoredText(input.messages, input.continuityIngressTexts);
-        const runAgentOptions = {
+        let runAgentOptions = {
             ...input.runAgentOptions,
             ...(orientationFrame ? { orientationFrame } : {}),
             ...(liveLatencyMode ? { skipKeptNotes: true } : {}),
@@ -856,6 +886,12 @@ async function handleInboundTurn(input) {
                 ...(orientationFrame ? { orientationFrame } : {}),
             },
         };
+        runAgentOptions = mergePreparedRunAgentOptions(runAgentOptions, await input.prepareRunAgentOptions?.({
+            messages: sessionMessages,
+            currentUserMessages,
+            resolvedContext,
+            runAgentOptions,
+        }));
         const runLedger = prepareInboundRunLedger({
             channel: input.channel,
             senseType: input.capabilities.senseType,

package/package.json

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