@ouro.bot/cli 0.1.0-alpha.580 → 0.1.0-alpha.582

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.582",
+      "changes": [
+        "BlueBubbles now suppresses same-turn near-duplicate outward sends using token/Jaccard similarity, covering rewritten retry answers, repeated status messages, and retry-loop variants without blocking short distinct replies.",
+        "BlueBubbles status sends now pass through the same duplicate guard as normal outward text, preserving inner/meta leak protections while reducing repeated iMessage status loops."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.581",
+      "changes": [
+        "Trip ledger storage now uses git-controlled bundle-root `trips/` as canonical local storage, with copy-only import from legacy ignored `state/trips/` and divergence warnings instead of silent merges.",
+        "`ouro doctor` now checks durable trip ledgers and reports legacy-only or divergent `state/trips/` data clearly so bundle sync and backup gaps surface before travel facts are lost."
+      ]
+    },
     {
       "version": "0.1.0-alpha.580",
       "changes": [

package/dist/heart/daemon/doctor.js

@@ -373,15 +373,27 @@ function checkTrips(deps) {
         return { name: "Trips", checks };
     }
     for (const agentDir of agents) {
-        const tripsRootPath = `${deps.bundlesRoot}/${agentDir}/state/trips`;
-        if (!deps.existsSync(tripsRootPath)) {
-            // Trip ledger is optional; absence is fine. Pass with a hint.
-            checks.push({ label: `${agentDir} trip ledger`, status: "pass", detail: "no ledger directory (no trips ensured yet)" });
+        const durableTripsRoot = `${deps.bundlesRoot}/${agentDir}/trips`;
+        const legacyTripsRoot = `${deps.bundlesRoot}/${agentDir}/state/trips`;
+        const hasDurableTrips = deps.existsSync(durableTripsRoot);
+        const hasLegacyTrips = deps.existsSync(legacyTripsRoot);
+        if (!hasDurableTrips) {
+            if (hasLegacyTrips) {
+                checks.push({
+                    label: `${agentDir} trip ledger`,
+                    status: "warn",
+                    detail: "legacy state/trips exists but durable trips/ missing — run any trip tool to copy legacy storage into trips/",
+                });
+            }
+            else {
+                // Trip ledger is optional; absence is fine. Pass with a hint.
+                checks.push({ label: `${agentDir} trip ledger`, status: "pass", detail: "no ledger directory (no trips ensured yet)" });
+            }
             continue;
         }
-        const ledgerPath = `${tripsRootPath}/ledger.json`;
+        const ledgerPath = `${durableTripsRoot}/ledger.json`;
         if (!deps.existsSync(ledgerPath)) {
-            checks.push({ label: `${agentDir} trip ledger`, status: "warn", detail: "state/trips/ exists but ledger.json missing — run trip_ensure_ledger" });
+            checks.push({ label: `${agentDir} trip ledger`, status: "warn", detail: "trips/ exists but ledger.json missing — run trip_ensure_ledger" });
             continue;
         }
         let raw;
@@ -420,7 +432,7 @@ function checkTrips(deps) {
             continue;
         }
         let recordCount = 0;
-        const recordsDir = `${tripsRootPath}/records`;
+        const recordsDir = `${durableTripsRoot}/records`;
         /* v8 ignore start -- defensive: records dir presence and readdir error are filesystem-state branches not all exercised by tests; pluralization branch likewise depends on record count fixtures @preserve */
         if (deps.existsSync(recordsDir)) {
             try {
@@ -430,15 +442,50 @@ function checkTrips(deps) {
                 // ignore — the warn detail will still report 0 records
             }
         }
+        const legacyDiverges = hasLegacyTrips && tripStoresDiffer(deps, durableTripsRoot, legacyTripsRoot);
         checks.push({
             label: `${agentDir} trip ledger`,
-            status: "pass",
-            detail: `${ledgerId} (${recordCount} record${recordCount === 1 ? "" : "s"})`,
+            status: legacyDiverges ? "warn" : "pass",
+            detail: `${ledgerId} (${recordCount} record${recordCount === 1 ? "" : "s"})${legacyDiverges ? "; legacy state/trips differs from durable trips/ — durable trips/ is authoritative" : ""}`,
         });
         /* v8 ignore stop */
     }
     return { name: "Trips", checks };
 }
+function listTripStoreFiles(deps, root) {
+    const files = [];
+    if (deps.existsSync(`${root}/ledger.json`)) {
+        files.push("ledger.json");
+    }
+    const recordsDir = `${root}/records`;
+    if (deps.existsSync(recordsDir)) {
+        for (const name of deps.readdirSync(recordsDir)) {
+            if (name.endsWith(".json")) {
+                files.push(`records/${name}`);
+            }
+        }
+    }
+    return files.sort();
+}
+function tripStoresDiffer(deps, durableRoot, legacyRoot) {
+    const relativePaths = new Set([
+        ...listTripStoreFiles(deps, durableRoot),
+        ...listTripStoreFiles(deps, legacyRoot),
+    ]);
+    for (const relativePath of relativePaths) {
+        const durablePath = `${durableRoot}/${relativePath}`;
+        const legacyPath = `${legacyRoot}/${relativePath}`;
+        const durableExists = deps.existsSync(durablePath);
+        const legacyExists = deps.existsSync(legacyPath);
+        if (durableExists !== legacyExists) {
+            return true;
+        }
+        if (durableExists && deps.readFileSync(durablePath) !== deps.readFileSync(legacyPath)) {
+            return true;
+        }
+    }
+    return false;
+}
 function checkMailroom(deps) {
     const checks = [];
     const agents = discoverAgents(deps);

package/dist/senses/bluebubbles/index.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enrichReactionText = enrichReactionText;
+exports.tokenizeForDedupe = tokenizeForDedupe;
+exports.jaccardSimilarity = jaccardSimilarity;
 exports.createStatusBatcher = createStatusBatcher;
 exports.createBlueBubblesCallbacks = createBlueBubblesCallbacks;
 exports.isAgentSelfHandle = isAgentSelfHandle;
@@ -95,6 +97,29 @@ function enrichReactionText(baseText, originalText, maxLen) {
         : originalText;
     return `${baseText} to: "${truncated}"`;
 }
+// ── Near-duplicate outward-text detection ────────────────────────
+// Used by createBlueBubblesCallbacks to collapse mid-turn rephrasings of the
+// same answer/status into a single delivery. Exposed for direct unit testing
+// of the similarity behavior without spinning up the full callbacks closure.
+const NEAR_DUPLICATE_JACCARD_THRESHOLD = 0.7;
+const NEAR_DUPLICATE_MIN_TOKENS = 5;
+function tokenizeForDedupe(text) {
+    const matches = text.toLowerCase().match(/[a-z0-9']+/g);
+    if (!matches)
+        return new Set();
+    return new Set(matches);
+}
+function jaccardSimilarity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const token of a) {
+        if (b.has(token))
+            intersection += 1;
+    }
+    const union = a.size + b.size - intersection;
+    return intersection / union;
+}
 /**
  * Accumulates status descriptions and debounces them.
  * If multiple descriptions arrive within `delayMs`, they are joined with ` · `
@@ -466,7 +491,16 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
     // final flush, surfacing as 4 near-identical iMessages from one ask
     // (2026-05-08 06:18 incident). The guard lets the engine retry harmlessly
     // without duplicating outward delivery to the friend.
+    //
+    // PR #699 used exact whitespace+case-normalized match. Post-#699 evidence
+    // (2026-05-09 05:25 UTC, evt-001814 + evt-001818) showed two answers that
+    // start "yep — I looked it up… Assuming you mean AMC's The Audacity…" with
+    // substantially the same content but slight rephrasing — the LLM rewrites
+    // the same answer on a retry/recovery loop and bypasses an exact-match
+    // guard. We now also keep the original token sets so a fuzzy (Jaccard)
+    // check catches near-duplicates from the same turn.
     const sentOutwardTextNorms = new Set();
+    const sentOutwardTokenSets = [];
     function enqueue(operation, task) {
         queue = queue.then(task).catch((error) => {
             (0, runtime_1.emitNervesEvent)({
@@ -504,7 +538,25 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
         const norm = trimmed.replace(/\s+/g, " ").trim().toLowerCase();
         if (sentOutwardTextNorms.has(norm))
             return true;
+        // Fuzzy near-duplicate: when the same answer is rephrased between speak
+        // and settle (or across two speak calls in a recovery loop), the exact
+        // norm differs but token overlap is very high. We compare against every
+        // already-sent body's token set; if any has Jaccard overlap >= the
+        // threshold, treat as a duplicate. We require a minimum token count on
+        // the new body so single-word replies ("yes", "ok") don't get suppressed
+        // against any previous short one with shared tokens.
+        const newTokens = tokenizeForDedupe(trimmed);
+        if (newTokens.size >= NEAR_DUPLICATE_MIN_TOKENS) {
+            for (const prevTokens of sentOutwardTokenSets) {
+                if (prevTokens.size < NEAR_DUPLICATE_MIN_TOKENS)
+                    continue;
+                if (jaccardSimilarity(newTokens, prevTokens) >= NEAR_DUPLICATE_JACCARD_THRESHOLD) {
+                    return true;
+                }
+            }
+        }
         sentOutwardTextNorms.add(norm);
+        sentOutwardTokenSets.push(newTokens);
         return false;
     }
     function emitDuplicateOutwardSuppressed(site, messageLength) {
@@ -540,10 +592,25 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
         }
     }
     function sendStatus(text) {
+        const trimmed = text.trim();
+        /* v8 ignore next -- defensive guard; current status callers always provide non-empty text @preserve */
+        if (!trimmed)
+            return;
+        // Status surfaces share the per-turn dedupe set so a status-style
+        // outward message (tool description, error notice, watchdog ping)
+        // can't deliver a near-duplicate of an already-sent answer or status
+        // (post-#699 evidence: evt-001820 + evt-001821 + evt-001823 on
+        // 2026-05-09 — overlapping status surface updates about the same
+        // duplicate issue, which the flushNow/flush-only guard could not catch
+        // because sendStatus writes directly via client.sendText).
+        if (isDuplicateOutwardText(trimmed)) {
+            emitDuplicateOutwardSuppressed("status", trimmed.length);
+            return;
+        }
         enqueue("send_status", async () => {
             await client.sendText({
                 chat,
-                text,
+                text: trimmed,
                 replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
             });
             recordVisibleActivity();

package/dist/trips/store.js

@@ -45,6 +45,9 @@ const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
 function tripsRoot(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "trips");
+}
+function legacyTripsRoot(agentName) {
     return path.join((0, identity_1.getAgentRoot)(agentName), "state", "trips");
 }
 function ledgerPath(agentName) {
@@ -56,6 +59,118 @@ function recordsDir(agentName) {
 function recordPath(agentName, tripId) {
     return path.join(recordsDir(agentName), `${tripId}.json`);
 }
+function ledgerPathFor(root) {
+    return path.join(root, "ledger.json");
+}
+function recordsDirFor(root) {
+    return path.join(root, "records");
+}
+function removeMigrationTempRoot(tmpRoot) {
+    const records = recordsDirFor(tmpRoot);
+    if (fs.existsSync(records)) {
+        for (const entry of fs.readdirSync(records)) {
+            fs.unlinkSync(path.join(records, entry));
+        }
+        fs.rmdirSync(records);
+    }
+    const ledger = ledgerPathFor(tmpRoot);
+    if (fs.existsSync(ledger)) {
+        fs.unlinkSync(ledger);
+    }
+    if (fs.existsSync(tmpRoot)) {
+        fs.rmdirSync(tmpRoot);
+    }
+}
+function copyLegacyTripsIfNeeded(agentName) {
+    const durableRoot = tripsRoot(agentName);
+    const legacyRoot = legacyTripsRoot(agentName);
+    if (fs.existsSync(durableRoot) || !fs.existsSync(ledgerPathFor(legacyRoot))) {
+        return;
+    }
+    const tmpRoot = `${durableRoot}.tmp-${process.pid}-${Date.now()}`;
+    removeMigrationTempRoot(tmpRoot);
+    try {
+        fs.mkdirSync(recordsDirFor(tmpRoot), { recursive: true });
+        fs.copyFileSync(ledgerPathFor(legacyRoot), ledgerPathFor(tmpRoot));
+        const legacyRecordsDir = recordsDirFor(legacyRoot);
+        if (fs.existsSync(legacyRecordsDir)) {
+            for (const entry of fs.readdirSync(legacyRecordsDir)) {
+                if (entry.endsWith(".json")) {
+                    fs.copyFileSync(path.join(legacyRecordsDir, entry), path.join(recordsDirFor(tmpRoot), entry));
+                }
+            }
+        }
+        fs.renameSync(tmpRoot, durableRoot);
+    }
+    catch (error) {
+        removeMigrationTempRoot(tmpRoot);
+        throw error;
+    }
+}
+function collectStoreFiles(root) {
+    const files = [];
+    if (fs.existsSync(ledgerPathFor(root))) {
+        files.push("ledger.json");
+    }
+    const records = recordsDirFor(root);
+    if (fs.existsSync(records)) {
+        for (const entry of fs.readdirSync(records)) {
+            if (entry.endsWith(".json")) {
+                files.push(`records/${entry}`);
+            }
+        }
+    }
+    return files.sort();
+}
+function fileAt(root, relativePath) {
+    return path.join(root, ...relativePath.split("/"));
+}
+function findLegacyDifferences(durableRoot, legacyRoot) {
+    const paths = new Set([...collectStoreFiles(durableRoot), ...collectStoreFiles(legacyRoot)]);
+    const differences = [];
+    for (const relativePath of [...paths].sort()) {
+        const durablePath = fileAt(durableRoot, relativePath);
+        const legacyPath = fileAt(legacyRoot, relativePath);
+        const durableExists = fs.existsSync(durablePath);
+        const legacyExists = fs.existsSync(legacyPath);
+        if (durableExists !== legacyExists) {
+            differences.push(relativePath);
+            continue;
+        }
+        if (durableExists && !fs.readFileSync(durablePath).equals(fs.readFileSync(legacyPath))) {
+            differences.push(relativePath);
+        }
+    }
+    return differences;
+}
+function reportLegacyDivergence(agentName) {
+    const durableRoot = tripsRoot(agentName);
+    const legacyRoot = legacyTripsRoot(agentName);
+    if (!fs.existsSync(durableRoot) || !fs.existsSync(legacyRoot)) {
+        return;
+    }
+    const differences = findLegacyDifferences(durableRoot, legacyRoot);
+    if (differences.length === 0) {
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "trips",
+        event: "trips.legacy_diverged",
+        message: "legacy trip store differs from durable trip store",
+        meta: {
+            agentId: agentName,
+            durablePath: "trips",
+            legacyPath: "state/trips",
+            differenceCount: differences.length,
+            differences: differences.slice(0, 10),
+        },
+    });
+}
+function prepareTripStorage(agentName) {
+    copyLegacyTripsIfNeeded(agentName);
+    reportLegacyDivergence(agentName);
+}
 function readJsonFile(filePath) {
     if (!fs.existsSync(filePath))
         return null;
@@ -79,6 +194,7 @@ exports.TripNotFoundError = TripNotFoundError;
  * generate a fresh keypair and persist both halves.
  */
 function ensureAgentTripLedger(input) {
+    prepareTripStorage(input.agentName);
     const existing = readJsonFile(ledgerPath(input.agentName));
     if (existing) {
         return { ledger: existing.ledger, added: false };
@@ -103,6 +219,7 @@ function ensureAgentTripLedger(input) {
     return { ledger: created.ledger, added: true };
 }
 function readLedgerOrThrow(agentName) {
+    prepareTripStorage(agentName);
     const stored = readJsonFile(ledgerPath(agentName));
     if (!stored) {
         throw new Error(`no trip ledger for agent ${agentName} — call ensureAgentTripLedger first`);
@@ -129,6 +246,7 @@ function upsertTripRecord(agentName, trip) {
     });
 }
 function readTripRecord(agentName, tripId) {
+    prepareTripStorage(agentName);
     const payload = readJsonFile(recordPath(agentName, tripId));
     if (!payload)
         throw new TripNotFoundError({ agentName, tripId });
@@ -136,6 +254,7 @@ function readTripRecord(agentName, tripId) {
     return (0, core_1.decryptTripRecord)(payload, stored.privateKeyPem);
 }
 function listTripIds(agentName) {
+    prepareTripStorage(agentName);
     const dir = recordsDir(agentName);
     if (!fs.existsSync(dir))
         return [];

package/package.json

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