@ouro.bot/cli 0.1.0-alpha.725 → 0.1.0-alpha.727

package/dist/senses/bluebubbles/latest-turn.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reserveObservation = reserveObservation;
+exports.beginObservationBatch = beginObservationBatch;
+exports.reserveObservationFromBatch = reserveObservationFromBatch;
+exports.clearPending = clearPending;
+exports.reactivateObservation = reactivateObservation;
+exports.mergeObservationReservations = mergeObservationReservations;
+exports.promote = promote;
+exports.isCurrent = isCurrent;
+exports.observationSchedulingKeys = observationSchedulingKeys;
+exports.awaitDeliveryAdmission = awaitDeliveryAdmission;
+exports.isDeliveryAdmittedNow = isDeliveryAdmittedNow;
+exports.cancel = cancel;
+exports.finish = finish;
+exports.__resetBlueBubblesLatestTurnsForTests = __resetBlueBubblesLatestTurnsForTests;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const AMBIGUOUS_IDENTIFIER = Symbol("ambiguous-bluebubbles-identifier");
+const UNRESOLVED_SCHEDULING_KEY = "unresolved:*";
+const pending = new Map();
+const lanes = new Map();
+const identifierBindings = new Map();
+const reservationHints = new WeakMap();
+const batchReservations = new WeakMap();
+const observationEpoch = `${new Date().toISOString()}/${(0, node_crypto_1.randomUUID)()}`;
+let nextOrdinal = 0;
+function clean(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.toLowerCase() !== "unknown" ? trimmed : null;
+}
+function canonicalIdentifier(value) {
+    const trimmed = clean(value);
+    if (!trimmed)
+        return null;
+    if (trimmed.includes("@"))
+        return trimmed.toLowerCase();
+    if (/^[+\d\s().-]+$/.test(trimmed)) {
+        const compact = trimmed.replace(/[^\d+]/g, "");
+        if (compact)
+            return compact;
+    }
+    return trimmed;
+}
+function guidAlias(guid) {
+    return `guid:${guid}`;
+}
+function identifierAlias(identifier) {
+    return `identifier:${identifier}`;
+}
+function observationHints(input) {
+    const guid = clean(input.chatGuid);
+    const identifier = canonicalIdentifier(input.chatIdentifier);
+    return [
+        ...(guid ? [guidAlias(guid)] : []),
+        ...(identifier ? [identifierAlias(identifier)] : []),
+    ];
+}
+function settlePending(ordinal) {
+    const entry = pending.get(ordinal);
+    if (!entry)
+        return;
+    pending.delete(ordinal);
+    entry.settle();
+}
+function createReservation(ordinal, input) {
+    const knownHints = new Set(observationHints(input));
+    const reservation = Object.freeze({
+        observationEpoch,
+        ordinal,
+        get hints() {
+            return Object.freeze([...knownHints]);
+        },
+    });
+    reservationHints.set(reservation, knownHints);
+    let settle;
+    const settled = new Promise((resolve) => {
+        settle = resolve;
+    });
+    pending.set(ordinal, {
+        reservation,
+        hints: new Set(knownHints),
+        settled,
+        settle,
+    });
+    return reservation;
+}
+function reserveObservation(input) {
+    return createReservation(++nextOrdinal, input);
+}
+function beginObservationBatch(size) {
+    if (!Number.isSafeInteger(size) || size <= 0)
+        throw new Error("bluebubbles_observation_batch_size_invalid");
+    // BlueBubbles' `before` filter is inclusive. Subtract one millisecond so a
+    // row created in the same clock tick after this reservation cannot be
+    // backdated into the already-reserved ordinal range.
+    const batch = Object.freeze({
+        highOrdinal: nextOrdinal + size,
+        size,
+        beforeTimestamp: Date.now() - 1,
+    });
+    nextOrdinal = batch.highOrdinal;
+    batchReservations.set(batch, new Set());
+    return batch;
+}
+function reserveObservationFromBatch(batch, newestOffset, input) {
+    const used = batchReservations.get(batch);
+    if (!used || !Number.isSafeInteger(newestOffset) || newestOffset < 0 || newestOffset >= batch.size) {
+        throw new Error("bluebubbles_observation_batch_offset_invalid");
+    }
+    const ordinal = batch.highOrdinal - newestOffset;
+    if (used.has(ordinal))
+        throw new Error("bluebubbles_observation_batch_offset_reused");
+    used.add(ordinal);
+    return createReservation(ordinal, input);
+}
+function clearPending(reservation) {
+    settlePending(reservation.ordinal);
+}
+function reactivateObservation(reservation) {
+    if (pending.has(reservation.ordinal))
+        return;
+    const knownHints = reservationHints.get(reservation);
+    if (!knownHints)
+        throw new Error("bluebubbles_observation_reservation_unknown");
+    let settle;
+    const settled = new Promise((resolve) => {
+        settle = resolve;
+    });
+    pending.set(reservation.ordinal, {
+        reservation,
+        hints: new Set(knownHints),
+        settled,
+        settle,
+    });
+}
+function mergeObservationReservations(primary, duplicate) {
+    if (primary === duplicate)
+        return primary;
+    const primaryHints = reservationHints.get(primary);
+    const duplicateHints = reservationHints.get(duplicate);
+    if (!primaryHints || !duplicateHints)
+        throw new Error("bluebubbles_observation_reservation_unknown");
+    for (const hint of duplicateHints)
+        primaryHints.add(hint);
+    const primaryPending = pending.get(primary.ordinal);
+    if (primaryPending) {
+        for (const hint of duplicateHints)
+            primaryPending.hints.add(hint);
+    }
+    settlePending(duplicate.ordinal);
+    return primary;
+}
+function bindIdentifier(identifier, guid) {
+    const existing = identifierBindings.get(identifier);
+    if (existing === undefined) {
+        identifierBindings.set(identifier, guid);
+        return true;
+    }
+    if (existing === guid)
+        return true;
+    identifierBindings.set(identifier, AMBIGUOUS_IDENTIFIER);
+    return false;
+}
+function resolveCanonicalChat(input) {
+    const inputGuid = clean(input.chatGuid);
+    const observedIdentifier = clean(input.chatIdentifier);
+    const identifier = canonicalIdentifier(input.chatIdentifier);
+    let guid = inputGuid;
+    if (guid && identifier)
+        bindIdentifier(identifier, guid);
+    if (!guid && identifier) {
+        const binding = identifierBindings.get(identifier);
+        if (typeof binding === "string")
+            guid = binding;
+    }
+    if (!guid)
+        return null;
+    return {
+        chatGuid: guid,
+        ...(observedIdentifier && identifier && identifierBindings.get(identifier) === guid
+            ? { chatIdentifier: observedIdentifier }
+            : {}),
+        sessionKey: `chat:${guid}`,
+    };
+}
+function promote(reservation, input, options = {}) {
+    const canonicalChat = resolveCanonicalChat(input);
+    settlePending(reservation.ordinal);
+    if (!canonicalChat)
+        return { status: "unresolved" };
+    const chatKey = guidAlias(canonicalChat.chatGuid);
+    const lane = lanes.get(chatKey) ?? { highWater: 0, current: null };
+    const sameGenerationRetry = reservation.ordinal === lane.highWater
+        && options.allowSameGenerationRetry === true
+        && lane.current === null;
+    if (reservation.ordinal < lane.highWater || (reservation.ordinal === lane.highWater && !sameGenerationRetry)) {
+        return { status: "stale" };
+    }
+    lane.current?.controller.abort(new Error("superseded"));
+    const controller = new AbortController();
+    const capability = Object.freeze({
+        ordinal: reservation.ordinal,
+        chatKey,
+        canonicalChat: Object.freeze(canonicalChat),
+        signal: controller.signal,
+        controller,
+    });
+    lane.highWater = reservation.ordinal;
+    lane.current = capability;
+    lanes.set(chatKey, lane);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_latest_turn_promoted",
+        message: "promoted the latest process-local bluebubbles turn",
+        meta: {
+            chatKey,
+            ordinal: reservation.ordinal,
+            aliasCount: 1 + [...identifierBindings.values()].filter((binding) => binding === canonicalChat.chatGuid).length,
+        },
+    });
+    return { status: "promoted", capability };
+}
+function internal(capability) {
+    return capability;
+}
+function isCurrent(capability) {
+    const lane = lanes.get(capability.chatKey);
+    return lane?.current === capability && !capability.signal.aborted;
+}
+function pendingIntersects(capability, entry) {
+    if (entry.reservation.ordinal <= capability.ordinal)
+        return false;
+    const hasGuidHint = [...entry.hints].some((hint) => hint.startsWith("guid:"));
+    if (entry.hints.size === 0)
+        return true;
+    for (const hint of entry.hints) {
+        if (hint === capability.chatKey)
+            return true;
+        if (hint.startsWith("identifier:")) {
+            const identifier = hint.slice("identifier:".length);
+            const binding = identifierBindings.get(identifier);
+            if (binding === capability.canonicalChat.chatGuid)
+                return true;
+            // An identifier-only observation can repair into any GUID lane. Until
+            // that relation is proved, it is a temporary global delivery fence—not
+            // an active shared chat lane. A direct GUID hint keeps paired events
+            // independently schedulable through that exact coordinate.
+            if (!hasGuidHint && typeof binding !== "string")
+                return true;
+        }
+    }
+    return false;
+}
+function observationSchedulingKeys(reservation) {
+    const hints = reservationHints.get(reservation);
+    if (!hints)
+        throw new Error("bluebubbles_observation_reservation_unknown");
+    const keys = new Set();
+    const hasGuidHint = [...hints].some((hint) => hint.startsWith("guid:"));
+    if (hints.size === 0)
+        keys.add(UNRESOLVED_SCHEDULING_KEY);
+    for (const hint of hints) {
+        if (hint.startsWith("identifier:")) {
+            const identifier = hint.slice("identifier:".length);
+            const binding = identifierBindings.get(identifier);
+            keys.add(typeof binding === "string"
+                ? guidAlias(binding)
+                : hasGuidHint ? hint : UNRESOLVED_SCHEDULING_KEY);
+        }
+        else {
+            keys.add(hint);
+        }
+    }
+    return Object.freeze([...keys]);
+}
+async function awaitDeliveryAdmission(capability) {
+    const value = internal(capability);
+    while (isCurrent(value)) {
+        const blockers = [...pending.values()].filter((entry) => pendingIntersects(value, entry));
+        if (blockers.length === 0)
+            return true;
+        await Promise.all(blockers.map((entry) => entry.settled));
+    }
+    return false;
+}
+function isDeliveryAdmittedNow(capability) {
+    const value = internal(capability);
+    return isCurrent(value)
+        && ![...pending.values()].some((entry) => pendingIntersects(value, entry));
+}
+function cancel(capability, reason = "cancelled") {
+    const lane = lanes.get(capability.chatKey);
+    if (lane?.current !== capability)
+        return;
+    internal(capability).controller.abort(new Error(reason));
+    lane.current = null;
+}
+function finish(capability) {
+    const lane = lanes.get(capability.chatKey);
+    if (lane?.current === capability)
+        lane.current = null;
+}
+function __resetBlueBubblesLatestTurnsForTests() {
+    for (const entry of pending.values())
+        entry.settle();
+    pending.clear();
+    lanes.clear();
+    identifierBindings.clear();
+    nextOrdinal = 0;
+}

package/dist/senses/bluebubbles/outbound-state.js

@@ -38,6 +38,7 @@ exports.blueBubblesOutboundRecordPath = blueBubblesOutboundRecordPath;
 exports.buildBlueBubblesRouteProof = buildBlueBubblesRouteProof;
 exports.buildBlueBubblesAttachmentProof = buildBlueBubblesAttachmentProof;
 exports.readBlueBubblesOutboundRecord = readBlueBubblesOutboundRecord;
+exports.readBlueBubblesOutboundRecordByIdempotencyKey = readBlueBubblesOutboundRecordByIdempotencyKey;
 exports.reserveBlueBubblesOutbound = reserveBlueBubblesOutbound;
 exports.markBlueBubblesOutboundAccepted = markBlueBubblesOutboundAccepted;
 exports.markBlueBubblesOutboundEnqueued = markBlueBubblesOutboundEnqueued;
@@ -174,6 +175,9 @@ function readBlueBubblesOutboundRecord(agentRoot, recordId) {
         return null;
     }
 }
+function readBlueBubblesOutboundRecordByIdempotencyKey(agentRoot, idempotencyKey) {
+    return readBlueBubblesOutboundRecord(agentRoot, recordIdFor(idempotencyKey.trim()));
+}
 function writeBlueBubblesOutboundRecord(agentRoot, record) {
     writeJsonAtomic(blueBubblesOutboundRecordPath(agentRoot, record.recordId), record);
     return record;

package/dist/senses/bluebubbles/reaction-policy.js

@@ -25,17 +25,11 @@ function classifyBlueBubblesReaction(input) {
     else if (input.canonicalValue === "unknown") {
         decision = { route: "capture_only", outcome: "capture_only_unknown" };
     }
-    else if (input.targetAuthorship !== "agent") {
-        decision = { route: "capture_only", outcome: "capture_only_target_not_agent" };
-    }
-    else if (input.trustedActor === undefined) {
-        decision = { route: "trust_required" };
-    }
-    else if (!input.trustedActor) {
-        decision = { route: "capture_only", outcome: "capture_only_untrusted_actor" };
+    else if (input.canonicalValue === "question") {
+        decision = { route: "capture_only", outcome: "capture_only_question" };
     }
     else {
-        decision = { route: "restricted_feedback" };
+        decision = { route: "capture_only", outcome: "capture_only_negative" };
     }
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
@@ -45,10 +39,8 @@ function classifyBlueBubblesReaction(input) {
             action: input.action,
             canonicalValue: input.canonicalValue,
             fromMe: input.fromMe,
-            targetAuthorship: input.targetAuthorship,
-            trustEvaluated: input.trustedActor !== undefined,
             route: decision.route,
-            outcome: decision.route === "capture_only" ? decision.outcome : null,
+            outcome: decision.outcome,
         },
     });
     return decision;

package/dist/senses/bluebubbles/semantic-receipts.js

@@ -55,6 +55,7 @@ exports.writeBlueBubblesSemanticCapture = writeBlueBubblesSemanticCapture;
 exports.readBlueBubblesSemanticCapture = readBlueBubblesSemanticCapture;
 exports.readBlueBubblesSemanticCaptureAtRoot = readBlueBubblesSemanticCaptureAtRoot;
 exports.listPendingBlueBubblesSemanticCaptures = listPendingBlueBubblesSemanticCaptures;
+exports.compareBlueBubblesSemanticCaptureOrder = compareBlueBubblesSemanticCaptureOrder;
 exports.writeBlueBubblesSemanticHandled = writeBlueBubblesSemanticHandled;
 exports.readBlueBubblesSemanticHandled = readBlueBubblesSemanticHandled;
 exports.acquireBlueBubblesSemanticClaim = acquireBlueBubblesSemanticClaim;
@@ -92,6 +93,14 @@ const SEMANTIC_OWNERSHIP_SCHEMA_SQL = `CREATE TABLE owner_leases (
       owner_json TEXT NOT NULL
     ) STRICT, WITHOUT ROWID`;
 const CAPTURE_KEYS = ["schemaVersion", "canonicalKey", "keyHash", "providerNamespace", "capturedAt", "event"];
+const OBSERVATION_ORDER_KEYS = [
+    "schemaVersion",
+    "keyHash",
+    "captureHash",
+    "observedAt",
+    "observationEpoch",
+    "observationOrdinal",
+];
 const CAPTURE_EVENT_KEYS = [
     "provider",
     "kind",
@@ -157,6 +166,7 @@ function getBlueBubblesSemanticPathsAtRoot(agentRoot) {
         root,
         cutover: path.join(root, "cutover.json"),
         captures: path.join(root, "captures"),
+        observationOrders: path.join(root, "observation-orders"),
         handled: path.join(root, "handled"),
         claims: path.join(root, "claims"),
         coordinates: path.join(root, "coordinates"),
@@ -413,6 +423,22 @@ function buildBlueBubblesSemanticCapture(input) {
         : null;
     if (!providerNamespace || !capturedAt || !actorExternalId)
         return null;
+    const inputObservationEpoch = input.observationEpoch;
+    const inputObservationOrdinal = input.observationOrdinal;
+    const observationClock = inputObservationEpoch === undefined
+        && inputObservationOrdinal === undefined
+        ? null
+        : isBlueBubblesObservationEpoch(inputObservationEpoch)
+            && typeof inputObservationOrdinal === "number"
+            && Number.isSafeInteger(inputObservationOrdinal)
+            && inputObservationOrdinal > 0
+            ? {
+                observationEpoch: inputObservationEpoch,
+                observationOrdinal: inputObservationOrdinal,
+            }
+            : false;
+    if (observationClock === false)
+        return null;
     const kind = input.event.kind === "message" ? "message" : input.event.mutationType;
     const eventGuid = requiredIdentifier(input.event.messageGuid);
     const targetGuid = input.event.kind === "mutation"
@@ -451,7 +477,7 @@ function buildBlueBubblesSemanticCapture(input) {
         externalId,
         displayName: null,
     })));
-    return {
+    const capture = {
         schemaVersion: 1,
         canonicalKey: identity.canonicalKey,
         keyHash: identity.keyHash,
@@ -484,6 +510,16 @@ function buildBlueBubblesSemanticCapture(input) {
             contentSha256: kind === "edit" ? textSha256 : null,
         },
     };
+    if (observationClock) {
+        attachBlueBubblesSemanticObservationOrder(capture, {
+            schemaVersion: 1,
+            keyHash: capture.keyHash,
+            captureHash: blueBubblesSemanticCaptureHash(capture),
+            observedAt: capturedAt,
+            ...observationClock,
+        });
+    }
+    return capture;
 }
 function buildBlueBubblesReactionCoordinateRecord(input) {
     return {
@@ -551,12 +587,17 @@ function writeBlueBubblesSemanticCapture(agentName, capture, deps = {}) {
     try {
         const paths = getBlueBubblesSemanticPaths(agentName);
         const finalPath = semanticRecordPath(paths.captures, capture.keyHash);
+        const validCapture = isBlueBubblesSemanticCapture(capture, capture.keyHash);
         const existing = readExistingCaptureForWrite(agentName, capture.keyHash, deps);
-        if (existing)
+        if (existing) {
+            if (validCapture && capturesAreEquivalent(existing, capture)) {
+                persistBlueBubblesSemanticObservationOrder(agentName, capture, deps);
+            }
             return finishCaptureComparison(agentName, existing, capture, deps);
-        if (!isBlueBubblesSemanticCapture(capture, capture.keyHash)) {
-            throw semanticStoreError("semantic_capture_invalid");
         }
+        if (!validCapture)
+            throw semanticStoreError("semantic_capture_invalid");
+        persistBlueBubblesSemanticObservationOrder(agentName, capture, deps);
         const publication = publishImmutableSemanticRecord(paths.captures, finalPath, capture, deps);
         if (publication === "exists") {
             const winner = readExistingCaptureForWrite(agentName, capture.keyHash, deps);
@@ -581,12 +622,14 @@ function writeBlueBubblesSemanticCapture(agentName, capture, deps = {}) {
 function readBlueBubblesSemanticCapture(agentName, keyHash, deps = {}) {
     const paths = getBlueBubblesSemanticPaths(agentName);
     const finalPath = semanticRecordPath(paths.captures, keyHash);
-    return readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    const capture = readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    return capture ? attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) : null;
 }
 function readBlueBubblesSemanticCaptureAtRoot(agentRoot, keyHash, deps = {}) {
     const paths = getBlueBubblesSemanticPathsAtRoot(agentRoot);
     const finalPath = semanticRecordPath(paths.captures, keyHash);
-    return readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    const capture = readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    return capture ? attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) : null;
 }
 function listPendingBlueBubblesSemanticCaptures(agentName, deps = {}) {
     const storeFs = semanticFs(deps);
@@ -606,7 +649,109 @@ function listPendingBlueBubblesSemanticCaptures(agentName, deps = {}) {
             continue;
         captures.push(capture);
     }
-    return captures.sort((left, right) => (left.capturedAt.localeCompare(right.capturedAt) || left.keyHash.localeCompare(right.keyHash)));
+    return captures.sort((left, right) => (compareBlueBubblesSemanticCaptureOrder(left, right)));
+}
+function compareBlueBubblesSemanticCaptureOrder(left, right) {
+    if (left.observationEpoch !== undefined
+        && left.observationEpoch === right.observationEpoch
+        && left.observationOrdinal !== undefined
+        && right.observationOrdinal !== undefined
+        && left.observationOrdinal !== right.observationOrdinal) {
+        return left.observationOrdinal - right.observationOrdinal;
+    }
+    const capturedOrder = (left.observationObservedAt ?? left.capturedAt)
+        .localeCompare(right.observationObservedAt ?? right.capturedAt);
+    if (capturedOrder !== 0)
+        return capturedOrder;
+    if (left.observationEpoch === undefined && right.observationEpoch === undefined)
+        return 0;
+    const epochOrder = (left.observationEpoch ?? "").localeCompare(right.observationEpoch ?? "");
+    if (epochOrder !== 0)
+        return epochOrder;
+    return left.keyHash.localeCompare(right.keyHash);
+}
+function attachBlueBubblesSemanticObservationOrder(capture, order) {
+    Object.defineProperties(capture, {
+        observationObservedAt: {
+            configurable: true,
+            enumerable: false,
+            value: order.observedAt,
+        },
+        observationEpoch: {
+            configurable: true,
+            enumerable: false,
+            value: order.observationEpoch,
+        },
+        observationOrdinal: {
+            configurable: true,
+            enumerable: false,
+            value: order.observationOrdinal,
+        },
+    });
+    return capture;
+}
+function blueBubblesSemanticObservationOrderFromCapture(capture) {
+    if (!isBlueBubblesObservationEpoch(capture.observationEpoch)
+        || typeof capture.observationOrdinal !== "number"
+        || !Number.isSafeInteger(capture.observationOrdinal)
+        || capture.observationOrdinal <= 0)
+        return null;
+    return {
+        schemaVersion: 1,
+        keyHash: capture.keyHash,
+        captureHash: blueBubblesSemanticCaptureHash(capture),
+        observedAt: capture.capturedAt,
+        observationEpoch: capture.observationEpoch,
+        observationOrdinal: capture.observationOrdinal,
+    };
+}
+function compareBlueBubblesSemanticObservationOrders(left, right) {
+    if (left.observationEpoch === right.observationEpoch
+        && left.observationOrdinal !== right.observationOrdinal) {
+        return left.observationOrdinal - right.observationOrdinal;
+    }
+    const observedOrder = left.observedAt.localeCompare(right.observedAt);
+    if (observedOrder !== 0)
+        return observedOrder;
+    const epochOrder = left.observationEpoch.localeCompare(right.observationEpoch);
+    if (epochOrder !== 0)
+        return epochOrder;
+    return left.observationOrdinal - right.observationOrdinal;
+}
+function persistBlueBubblesSemanticObservationOrder(agentName, capture, deps) {
+    const candidate = blueBubblesSemanticObservationOrderFromCapture(capture);
+    if (!candidate)
+        return;
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.observationOrders, candidate.captureHash);
+    const startedAt = semanticNow(deps).getTime();
+    while (true) {
+        const result = withExclusiveSemanticOwnership(paths.ownership, deps, () => {
+            const inspected = inspectSemanticRecord(finalPath, capture.keyHash, (value) => (isBlueBubblesSemanticObservationOrderRecord(value, capture.keyHash, candidate.captureHash)), deps);
+            if (inspected.status === "valid") {
+                if (compareBlueBubblesSemanticObservationOrders(inspected.value, candidate) <= 0) {
+                    fsyncSemanticDirectory(paths.observationOrders, semanticFs(deps));
+                    return;
+                }
+            }
+            else if (inspected.status === "invalid") {
+                quarantineSemanticRecord(finalPath, "observation-order", capture.keyHash, deps, inspected.reason);
+            }
+            writeMutableSemanticRecord(paths.observationOrders, finalPath, candidate, deps);
+        });
+        if (result.status === "completed")
+            return;
+        if (semanticNow(deps).getTime() - startedAt >= SEMANTIC_CLAIM_TIMEOUT_MS) {
+            throw semanticStoreError("semantic_ownership_busy");
+        }
+        semanticSleepSync(SEMANTIC_CLAIM_POLL_MS, deps);
+    }
+}
+function attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) {
+    const captureHash = blueBubblesSemanticCaptureHash(capture);
+    const finalPath = semanticRecordPath(paths.observationOrders, captureHash);
+    const order = readSemanticRecord(finalPath, "observation-order", capture.keyHash, (value) => (isBlueBubblesSemanticObservationOrderRecord(value, capture.keyHash, captureHash)), deps);
+    return order ? attachBlueBubblesSemanticObservationOrder(capture, order) : capture;
 }
 function writeBlueBubblesSemanticHandled(agentName, record, deps = {}) {
     try {
@@ -822,7 +967,10 @@ function finishHandledComparison(agentName, existing, candidate, deps) {
     return "semantic_handled_collision";
 }
 function capturesAreEquivalent(left, right) {
-    const project = (capture) => ({
+    return blueBubblesSemanticCaptureHash(left) === blueBubblesSemanticCaptureHash(right);
+}
+function blueBubblesSemanticCaptureHash(capture) {
+    const projection = {
         schemaVersion: capture.schemaVersion,
         canonicalKey: capture.canonicalKey,
         keyHash: capture.keyHash,
@@ -844,8 +992,8 @@ function capturesAreEquivalent(left, right) {
             revision: capture.event.revision,
             contentSha256: capture.event.contentSha256,
         },
-    });
-    return JSON.stringify(project(left)) === JSON.stringify(project(right));
+    };
+    return sha256Utf8(JSON.stringify(projection));
 }
 function handledRecordsAreEquivalent(left, right) {
     const project = (record) => ({
@@ -1379,6 +1527,26 @@ function isBlueBubblesSemanticCapture(value, expectedKeyHash) {
     }
     return captureIdentityMatchesEvent(value);
 }
+function isBlueBubblesSemanticObservationOrderRecord(value, expectedKeyHash, expectedCaptureHash) {
+    return isRecord(value)
+        && hasExactKeys(value, OBSERVATION_ORDER_KEYS)
+        && value.schemaVersion === 1
+        && value.keyHash === expectedKeyHash
+        && value.captureHash === expectedCaptureHash
+        && exactIsoMilliseconds(value.observedAt) !== null
+        && isBlueBubblesObservationEpoch(value.observationEpoch)
+        && typeof value.observationOrdinal === "number"
+        && Number.isSafeInteger(value.observationOrdinal)
+        && value.observationOrdinal > 0;
+}
+function isBlueBubblesObservationEpoch(value) {
+    if (typeof value !== "string")
+        return false;
+    const parts = value.split("/");
+    return parts.length === 2
+        && exactIsoMilliseconds(parts[0]) !== null
+        && UUID_V4_PATTERN.test(parts[1]);
+}
 function captureIdentityMatchesEvent(value) {
     const event = value.event;
     const coordinateGeneration = event.kind === "reaction"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.725",
+  "version": "0.1.0-alpha.727",
   "engines": {
     "node": ">=22"
   },