@ouro.bot/cli 0.1.0-alpha.262 → 0.1.0-alpha.264

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.264",
+      "changes": [
+        "fix(bluebubbles): dedup `updated-message` webhooks BEFORE running repair+hydrate+VLM. BlueBubbles routinely sends a `new-message` webhook for a fresh message, then follows up seconds later with one or more `updated-message` webhooks for delivery/read status. The BB sense's `repairEvent` path promotes updated-message events with recoverable content back to `message` kind, which re-runs the full hydration pipeline \u2014 including a second MiniMax VLM describe call on the same image. Verified live on 2026-04-08T00:58Z: two sequential VLM describes for attachment guid 317E37EB-..., 13.7s + 14.0s each, for the exact same 291KB JPEG, triggered by a `new-message` followed 3s later by an `updated-message` for the same guid. The downstream `handleBlueBubblesNormalizedEvent` dedup check was firing correctly but too late (after the expensive VLM round-trip). Fix: add a pre-repair dedup check in `handleBlueBubblesEvent` that consults the inbound sidecar by messageGuid and short-circuits before calling `client.repairEvent(...)`. New nerves event `senses.bluebubbles_repair_skipped_duplicate` at warn level for observability."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.263",
+      "changes": [
+        "fix(tui): arrow keys char-by-char (Ink 3.2 key.meta bug), Option+Arrow word-jump via CSI sequences."
+      ]
+    },
     {
       "version": "0.1.0-alpha.262",
       "changes": [

package/dist/senses/bluebubbles/index.js

@@ -859,7 +859,43 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
 async function handleBlueBubblesEvent(payload, deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const client = resolvedDeps.createClient();
-    const event = await client.repairEvent((0, model_1.normalizeBlueBubblesEvent)(payload));
+    const normalized = (0, model_1.normalizeBlueBubblesEvent)(payload);
+    // Pre-repair dedup: if we've already processed this messageGuid, skip the
+    // repair+hydrate path entirely. Applies to BOTH `kind: "message"` AND
+    // `kind: "mutation"` events — BlueBubbles often sends a `new-message`
+    // webhook for a fresh message AND one or more follow-up `updated-message`
+    // webhooks for delivery/read status. The mutation path (inside repairEvent)
+    // can promote an updated-message back to a message if it has recoverable
+    // content, which then re-runs the full VLM-describe pipeline on the same
+    // attachment.
+    //
+    // Without this early check, we paid DOUBLE latency and double tokens on
+    // every image-bearing message. Verified live on 2026-04-08T00:58Z: two
+    // sequential VLM describes for attachment guid 317E37EB-..., 13.7s +
+    // 14.0s each, for the exact same 291KB JPEG — triggered by a sequence of
+    // `new-message` followed ~3s later by `updated-message` for the same guid.
+    //
+    // We still route the skip through `handleBlueBubblesNormalizedEvent` so
+    // the downstream `already_processed` path fires its observability events
+    // and the caller sees a consistent return shape.
+    const agentName = resolvedDeps.getAgentName();
+    if (normalized.messageGuid
+        && (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, normalized.chat.sessionKey, normalized.messageGuid)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_repair_skipped_duplicate",
+            message: "skipped repair+hydrate for already-processed bluebubbles messageGuid",
+            meta: {
+                messageGuid: normalized.messageGuid,
+                sessionKey: normalized.chat.sessionKey,
+                eventType: normalized.eventType,
+                normalizedKind: normalized.kind,
+            },
+        });
+        return handleBlueBubblesNormalizedEvent(normalized, resolvedDeps, "webhook");
+    }
+    const event = await client.repairEvent(normalized);
     return handleBlueBubblesNormalizedEvent(event, resolvedDeps, "webhook");
 }
 function countPendingRecoveryCandidates(agentName) {

package/dist/senses/cli/input-keys.js

@@ -119,6 +119,12 @@ function classifyEscapeSequence(inputChar) {
     // End: \x1b[F or \x1b[4~
     if (seq === "F" || seq === "4~")
         return "end";
+    // Option+Left: \x1b[1;3D (CSI modified arrow with Alt modifier)
+    if (seq === "1;3D")
+        return "word-left";
+    // Option+Right: \x1b[1;3C
+    if (seq === "1;3C")
+        return "word-right";
     // PageUp: \x1b[5~, PageDown: \x1b[6~
     if (seq === "5~" || seq === "6~")
         return "ignore";

package/dist/senses/cli/ouro-tui.js

@@ -324,39 +324,20 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
             historyIdx.current = -1;
             return;
         }
-        // Left/right arrow: move cursor
+        // Left/right arrow: move cursor (char by char, token-aware)
+        // NOTE: Ink 3.2 bug — key.meta is ALWAYS true for arrow keys because all
+        // arrows start with \x1b and Ink sets meta=true for any ESC-prefixed input.
+        // Word-jump is handled via Meta+B/F (emacs bindings) instead.
         if (key.leftArrow) {
-            if (key.meta) {
-                // Option+Left: jump to previous word boundary
-                const before = inputRef.current.slice(0, cursorRef.current);
-                const match = before.match(/(?:^|\s)\S+\s*$/);
-                const newPos = match ? cursorRef.current - match[0].length + (match[0].startsWith(" ") ? 1 : 0) : 0;
-                cursorRef.current = Math.max(0, newPos);
-                setCursorPos(cursorRef.current);
-            }
-            else {
-                // Token-aware: hop over image ref chips
-                const chipStart = (0, image_ref_navigation_1.imageRefEndingAt)(inputRef.current, cursorRef.current);
-                cursorRef.current = chipStart !== undefined ? chipStart : Math.max(0, cursorRef.current - 1);
-                setCursorPos(cursorRef.current);
-            }
+            const chipStart = (0, image_ref_navigation_1.imageRefEndingAt)(inputRef.current, cursorRef.current);
+            cursorRef.current = chipStart !== undefined ? chipStart : Math.max(0, cursorRef.current - 1);
+            setCursorPos(cursorRef.current);
             return;
         }
         if (key.rightArrow) {
-            if (key.meta) {
-                // Option+Right: jump to next word boundary
-                const after = inputRef.current.slice(cursorRef.current);
-                const match = after.match(/^\s*\S+/);
-                const newPos = match ? cursorRef.current + match[0].length : inputRef.current.length;
-                cursorRef.current = Math.min(inputRef.current.length, newPos);
-                setCursorPos(cursorRef.current);
-            }
-            else {
-                // Token-aware: hop over image ref chips
-                const chipEnd = (0, image_ref_navigation_1.imageRefStartingAt)(inputRef.current, cursorRef.current);
-                cursorRef.current = chipEnd !== undefined ? chipEnd : Math.min(inputRef.current.length, cursorRef.current + 1);
-                setCursorPos(cursorRef.current);
-            }
+            const chipEnd = (0, image_ref_navigation_1.imageRefStartingAt)(inputRef.current, cursorRef.current);
+            cursorRef.current = chipEnd !== undefined ? chipEnd : Math.min(inputRef.current.length, cursorRef.current + 1);
+            setCursorPos(cursorRef.current);
             return;
         }
         // Up/Down: queue pop takes priority over history
@@ -542,22 +523,38 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
         // ─── Non-kill/non-yank keystroke resets ────────────────────────
         killRing.resetAccumulation();
         killRing.resetYankState();
+        // Detect raw escape sequences — Ink 3.2 strips \x1b prefix and sets key.meta,
+        // so we re-prepend it for classification when meta is set and inputChar starts with [
+        const escInput = key.meta && inputChar.startsWith("[") ? "\x1b" + inputChar : inputChar;
+        const escClass = (0, input_keys_1.classifyEscapeSequence)(escInput);
+        if (escClass === "home") {
+            cursorRef.current = (0, input_keys_1.handleHome)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "end") {
+            cursorRef.current = (0, input_keys_1.handleEnd)(inputRef.current, cursorRef.current);
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "word-left") {
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const match = before.match(/(?:^|\s)\S+\s*$/);
+            cursorRef.current = match ? Math.max(0, cursorRef.current - match[0].length + (match[0].startsWith(" ") ? 1 : 0)) : 0;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "word-right") {
+            const after = inputRef.current.slice(cursorRef.current);
+            const match = after.match(/^\s*\S+/);
+            cursorRef.current = match ? Math.min(inputRef.current.length, cursorRef.current + match[0].length) : inputRef.current.length;
+            setCursorPos(cursorRef.current);
+            return;
+        }
+        if (escClass === "ignore")
+            return;
         // Regular character: insert at cursor position
         if (!key.ctrl && !key.meta && inputChar) {
-            // Detect raw escape sequences before inserting text
-            const escClass = (0, input_keys_1.classifyEscapeSequence)(inputChar);
-            if (escClass === "home") {
-                cursorRef.current = (0, input_keys_1.handleHome)(inputRef.current, cursorRef.current);
-                setCursorPos(cursorRef.current);
-                return;
-            }
-            if (escClass === "end") {
-                cursorRef.current = (0, input_keys_1.handleEnd)(inputRef.current, cursorRef.current);
-                setCursorPos(cursorRef.current);
-                return;
-            }
-            if (escClass === "ignore")
-                return; // PageUp/PageDown/mouse wheel fallback
             const before = inputRef.current.slice(0, cursorRef.current);
             const after = inputRef.current.slice(cursorRef.current);
             updateInput(before + inputChar + after, cursorRef.current + 1);

package/package.json

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