@essentialai/cogent-bridge 3.23.2 → 3.23.4

package/dist/services/wake-lock.js

@@ -0,0 +1,257 @@
+/**
+ * CROSS-PROCESS WAKE LOCK — never two agent turns running at once in ONE CHECKOUT.
+ *
+ * ── THE DEFECT THIS FIXES, AND HOW IT DIFFERS FROM wake-claim.ts ─────────────────────────
+ * `wake-claim.ts` excludes on the MESSAGE id: it stops one message, fanned by the relay to N
+ * sockets of the same peer, from being answered N times. That is a real defect and it is fixed.
+ *
+ * It cannot help here. Measured on a real user (peer `marvin-coder`, 2026-09-05): the SAME peer
+ * was registered on the FREE relay at plugin v3.20.0 AND on the TEAM relay at v3.23.1 — same cwd,
+ * same thread id, two live bridge processes. Reachable because credentials are keyed on cwd ALONE
+ * (`~/.cogent/credentials/<sha256(cwd)>.json`, credential-store.ts:64-71); the endpoint is not part
+ * of the key, so a second join overwrites the file while the first process keeps running from its
+ * in-memory token and live WebSocket. Nothing on disk then records that the first relay is in play,
+ * which is why nothing reaps it.
+ *
+ * Two relays mint two DIFFERENT message ids, so both per-message claims succeed and both processes
+ * resume the SAME session concurrently. `scripts/wake-dedup-matrix-test.mjs --topology two-relay`
+ * reproduces it offline against two local relays: two wakes, one session id, 4001ms of overlap.
+ *
+ * ── WHY THE KEY IS THE CWD, NOT THE SESSION ──────────────────────────────────────────────
+ * The first cut of this keyed on (cwd, sessionId). That is too narrow. `pinnedSessionId` is
+ * per-process in-memory state (auto-relay.ts:338) and `decideResolution` returns whatever pin it
+ * was handed whenever that pin still validates, so two bridge processes in one checkout can hold
+ * DIFFERENT pins — they would take different locks and overlap anyway.
+ *
+ * More importantly the damage is a property of the WORKTREE, not of the session: two `claude`
+ * processes editing one checkout corrupt it whether or not they resume the same session. So the
+ * key is the cwd. The session id is recorded in the lease for diagnostics only.
+ *
+ * `wake-claim.ts` explicitly rejected a per-cwd lock — "a per-cwd lock would ... LOSE messages,
+ * the loser would silently drop a message it was the only one free to handle". That objection is
+ * about DROP semantics and does not apply here: this lock WAITS. Same key, opposite conclusion.
+ *
+ * Blast radius is deliberately small: with a single bridge process the lock is never contended, so
+ * nothing about normal operation changes. Contention only arises in the topology that IS the bug.
+ *
+ * ── WHY IT WAITS INSTEAD OF DROPPING ─────────────────────────────────────────────────────
+ * Two relays carry two genuinely distinct questions; answering both is CORRECT. What is never
+ * correct is running both turns at once against one worktree. So a loser waits for the holder and
+ * then proceeds, which serialises the turns without losing a message. Dropping would trade a
+ * corruption bug for a silence bug, and silence is the worse failure mode in this codebase.
+ *
+ * ── FAILS OPEN, DELIBERATELY ─────────────────────────────────────────────────────────────
+ * Every uncertain path — unreadable lock dir, corrupt holder record, a holder that outlives the
+ * wait budget — resolves to "go ahead and wake". A lock that can mute an agent for good is worse
+ * than the overlap it prevents. That is the 3.21.5 lesson: a fix whose blast radius is "auto-wake
+ * stops working" is not a safe fix, however correct it looks.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getConfig } from "../config.js";
+import { logger } from "../logger.js";
+/** Hard ceiling on how long one lease may exclude others. Mirrors wake-claim's CLAIM_MAX_MS. */
+export const WAKE_LOCK_MAX_MS = 1_800_000; // 30 min
+/** Multiplier over COGENT_TIMEOUT_MS covering primary + rotated-session retry, as wake-claim does. */
+const LEASE_TIMEOUT_FACTOR = 3;
+/** How often a waiter re-checks. Short enough to be invisible, long enough not to spin. */
+const POLL_MS = 250;
+/** MUST match wake-claim / wake-inflight / credential-store — one cwd, one key, everywhere. */
+function hashCwd(cwd) {
+    return crypto.createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 16);
+}
+/** `~/.cogent/wake-locks/<sha256(cwd)[..16]>.json` — ONE checkout, ONE turn. */
+export function wakeLockPath(cwd = process.cwd()) {
+    return path.join(os.homedir(), ".cogent", "wake-locks", `${hashCwd(cwd)}.json`);
+}
+function leaseTtlMs() {
+    let timeout = 300_000;
+    try {
+        const c = getConfig()?.COGENT_TIMEOUT_MS;
+        if (typeof c === "number" && Number.isFinite(c) && c > 0)
+            timeout = c;
+    }
+    catch {
+        /* config not loaded — documented default */
+    }
+    return Math.min(timeout * LEASE_TIMEOUT_FACTOR, WAKE_LOCK_MAX_MS);
+}
+/** Default budget for waiting out another process's turn: one full turn. */
+function defaultMaxWaitMs() {
+    try {
+        const c = getConfig()?.COGENT_TIMEOUT_MS;
+        if (typeof c === "number" && Number.isFinite(c) && c > 0)
+            return c;
+    }
+    catch {
+        /* config not loaded */
+    }
+    return 300_000;
+}
+/**
+ * How many nested acquisitions this process currently holds.
+ *
+ * 🔴 WHY RE-ENTRANCY IS NOT OPTIONAL. `_injectOnly` is called from handleIncoming (auto-relay.ts:811),
+ * OUTSIDE the `processing` lock, so it can run while a wake in THIS SAME process holds the lease.
+ * Without this counter the inner acquire would treat the self-pid record as stale, steal it, and
+ * then delete it on release — leaving the outer wake running with no lease and letting a second
+ * process in. That is the hole this lock exists to close, reopened one level down.
+ */
+let heldDepth = 0;
+/**
+ * Is the recorded holder still a live process?
+ *
+ * A record bearing OUR pid counts as dead ONLY when heldDepth is 0 — i.e. we are not actually
+ * holding it, so the file is a leak from an earlier turn. While we do hold it, re-entrancy is
+ * handled before this is ever consulted.
+ */
+function holderAlive(pid) {
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (pid === process.pid)
+        return heldDepth > 0;
+    try {
+        process.kill(pid, 0); // signal 0 = existence check only
+        return true;
+    }
+    catch (err) {
+        // EPERM means it EXISTS but belongs to another user — alive for our purposes.
+        return err?.code === "EPERM";
+    }
+}
+/** Read the current holder, or null when absent/corrupt (both mean "free"). */
+function readHolder(p) {
+    try {
+        const held = JSON.parse(fs.readFileSync(p, "utf-8"));
+        if (!held || typeof held.expiresAt !== "number")
+            return null;
+        return held;
+    }
+    catch {
+        return null;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Become the single process running an agent turn in `cwd`, waiting out any other holder.
+ *
+ * `sessionId` is recorded in the lease for diagnostics; it is NOT part of the key (see the header).
+ *
+ * Never returns `acquired: false` today — every path either takes the lease or fails open — but the
+ * field is explicit so a caller reads the intent rather than assuming it.
+ */
+export async function acquireWakeLock(cwd = process.cwd(), sessionId = "unknown", opts = {}) {
+    const p = wakeLockPath(cwd);
+    const maxWaitMs = opts.maxWaitMs ?? defaultMaxWaitMs();
+    const started = Date.now();
+    let contended = false;
+    // Re-entrant: this process already holds the checkout, so nothing may block and nothing may be
+    // written. Only the OUTERMOST release removes the file.
+    if (heldDepth > 0) {
+        heldDepth++;
+        let released = false;
+        return {
+            acquired: true,
+            waitedMs: 0,
+            contended: false,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                heldDepth--;
+            },
+        };
+    }
+    const lease = () => {
+        heldDepth++;
+        let released = false;
+        return {
+            acquired: true,
+            waitedMs: Date.now() - started,
+            contended,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                heldDepth--;
+                if (heldDepth === 0)
+                    releaseWakeLock(cwd);
+            },
+        };
+    };
+    /** Fail open: the caller wakes, and nothing is left behind that could mute the next turn. */
+    const failOpen = (why) => {
+        logger.warn(`wake-lock: ${why} — waking anyway (fail-open)`);
+        return { acquired: true, waitedMs: Date.now() - started, contended, release: () => { } };
+    };
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+    }
+    catch (err) {
+        return failOpen(`cannot create lock dir (${err.message})`);
+    }
+    for (;;) {
+        const now = Date.now();
+        const body = JSON.stringify({
+            pid: process.pid,
+            sessionId,
+            startedAt: now,
+            expiresAt: now + leaseTtlMs(),
+        });
+        try {
+            fs.writeFileSync(p, body, { flag: "wx" }); // atomic: exactly one winner
+            if (contended) {
+                logger.info(`Auto-relay: waited ${Date.now() - started}ms for another bridge process to finish its ` +
+                    `turn in this checkout before resuming — turns are serialised, not overlapping.`);
+            }
+            return lease();
+        }
+        catch (err) {
+            if (err?.code !== "EEXIST") {
+                return failOpen(`cannot write lock (${err.message})`);
+            }
+        }
+        // Held. Take it over when the holder is gone, expired, or unreadable — a lease that outlives
+        // its holder would mute this agent until the writer-stamped expiry.
+        const held = readHolder(p);
+        if (!held || held.expiresAt <= now || !holderAlive(held.pid)) {
+            try {
+                fs.writeFileSync(p, body); // steal
+            }
+            catch (err) {
+                return failOpen(`cannot steal abandoned lock (${err.message})`);
+            }
+            logger.debug(`wake-lock: took over an abandoned lease in ${cwd}`);
+            return lease();
+        }
+        if (!contended) {
+            contended = true;
+            logger.info(`Auto-relay: pid ${held.pid} is already running an agent turn in this checkout ` +
+                `(session ${held.sessionId}) — waiting for it rather than running a second resume over ` +
+                `the same worktree. Two bridge processes are live for this cwd; if that is unexpected, ` +
+                `check for a stale one left behind by a plugin update.`);
+        }
+        if (Date.now() - started >= maxWaitMs) {
+            // Budget spent and the holder is STILL alive. Proceeding risks the overlap this lock
+            // exists to prevent; refusing risks silence. Silence is worse — but say so loudly.
+            return failOpen(`pid ${held.pid} still holds this checkout after ${Date.now() - started}ms`);
+        }
+        await sleep(POLL_MS);
+    }
+}
+/** Test-only: reset the in-process nesting counter. Production code must never call this. */
+export function __resetWakeLockDepthForTests() {
+    heldDepth = 0;
+}
+/** Release the lease. Best-effort; an orphan expires or is stolen when its holder dies. */
+export function releaseWakeLock(cwd = process.cwd()) {
+    try {
+        fs.unlinkSync(wakeLockPath(cwd));
+    }
+    catch {
+        /* already gone, or never ours */
+    }
+}
+//# sourceMappingURL=wake-lock.js.map

package/dist/services/wake-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wake-lock.js","sourceRoot":"","sources":["../../src/services/wake-lock.ts"],"names":[],"mappings":"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"}

package/dist/services/wake-ownership.d.ts

@@ -0,0 +1,48 @@
+interface BridgeEntry {
+    pid: number;
+    startedAt: number;
+    version: string;
+    peerId: string;
+    endpoint: string;
+    cwd: string;
+}
+/** `~/.cogent/bridges/<sha256(cwd)[..16]>.<peerId>/` — one directory per identity. */
+export declare function bridgeDirFor(cwd: string, peerId: string): string;
+/**
+ * Announce this process as a bridge serving `peerId` in `cwd`.
+ *
+ * Called once the peer is actually registered, so a bridge that never registered never competes
+ * for ownership. Best-effort: a failure here leaves us un-announced, which can only make us LOSE
+ * ownership to someone else, never wrongly take it.
+ */
+export declare function announceBridge(cwd: string, peerId: string, version: string, endpoint: string): void;
+/** Remove this process's announcement. Called on graceful shutdown; a crash is handled by pruning. */
+export declare function withdrawBridge(cwd: string, peerId: string): void;
+/**
+ * Every LIVE bridge announced for this identity, newest process first.
+ *
+ * Prunes entries whose process is gone, so a machine that has been through a dozen plugin updates
+ * does not accumulate junk here forever.
+ */
+export declare function listLiveBridges(cwd: string, peerId: string): BridgeEntry[];
+export interface OwnershipVerdict {
+    /** True when this process should do this peer's work. Every uncertain path returns true. */
+    isOwner: boolean;
+    /** The bridge that owns it instead, when we do not. */
+    owner?: {
+        pid: number;
+        version: string;
+        endpoint: string;
+    };
+    /** How many live bridges serve this identity, including us. */
+    liveCount: number;
+}
+/**
+ * Should THIS process wake for `peerId` in `cwd`?
+ *
+ * No when a strictly newer live bridge serves the same identity — that bridge is the one the user
+ * most recently started, and we are the leftover.
+ */
+export declare function checkWakeOwnership(cwd: string, peerId: string): OwnershipVerdict;
+export {};
+//# sourceMappingURL=wake-ownership.d.ts.map

package/dist/services/wake-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wake-ownership.d.ts","sourceRoot":"","sources":["../../src/services/wake-ownership.ts"],"names":[],"mappings":"AA0DA,UAAU,WAAW;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAQD,sFAAsF;AACtF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhE;AAeD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgBnG;AAED,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAiC1E;AAED,MAAM,WAAW,gBAAgB;IAC/B,4FAA4F;IAC5F,OAAO,EAAE,OAAO,CAAC;IACjB,uDAAuD;IACvD,KAAK,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CA0BhF"}

package/dist/services/wake-ownership.js

@@ -0,0 +1,193 @@
+/**
+ * WAKE OWNERSHIP — a superseded bridge process stops waking, by itself, with nobody running pkill.
+ *
+ * ── WHY (operator, 2026-09-05) ───────────────────────────────────────────────────────────
+ * "killed, but my users dont do that - so think how to have self healing mechanism"
+ *
+ * ── WHAT IS ACTUALLY ON A REAL MACHINE (measured here, 2026-09-05) ───────────────────────
+ * 37 live cogent-bridge processes, and NOT ONE of them is an orphan — every parent is alive:
+ *
+ *   codex app-server (1 daemon, up 3.5 days) ......... 7 bridges, all at a stale 3.22.0
+ *   claude --resume <one interactive session> ........ 2 bridges (plugin AND an npx @latest)
+ *   5 other interactive `claude --resume` sessions ... 1 each
+ *
+ * That kills the obvious fix. "Exit when stdin hits EOF" heals nothing here, because no bridge has
+ * lost its parent. They are not orphaned, they are REDUNDANT: a long-lived daemon spawns a bridge
+ * per MCP session and never reaps them, and one agent session can have cogent registered twice.
+ * A plugin update does not stop any of them, so old versions keep serving for days.
+ *
+ * ── THE SIGNAL: SAME peerId, NOT same cwd ────────────────────────────────────────────────
+ * Superseding on cwd alone would break a legitimate setup — two agents working one checkout (say
+ * `marvin-coder` and `marvin-mobile`) are two DIFFERENT peers and both must keep waking. What is
+ * never legitimate is the same peerId served by two bridges in one checkout: that is the ghost,
+ * and it is exactly what was measured on the real user (`marvin-coder` live on the FREE relay at
+ * v3.20.0 and on the TEAM relay at v3.23.1, same cwd, same thread).
+ *
+ * So ownership is keyed on (cwd, peerId). The wake LOCK (wake-lock.ts) stays keyed on cwd alone,
+ * because worktree corruption does not care which peer caused it. Two invariants, two keys:
+ *   ownership → only ONE process does this peer's work   (kills duplicate work)
+ *   lock      → only ONE turn runs in this checkout      (kills concurrent corruption)
+ *
+ * ── NEWEST WINS, BY PROCESS START, SO IT CANNOT OSCILLATE ────────────────────────────────
+ * The owner is the live bridge with the latest PROCESS START time. Start time is fixed for the
+ * life of a process, so a superseded bridge can never win the title back — if ownership were keyed
+ * on registration time instead, a stood-down bridge that re-registered would steal it back and the
+ * two would ping-pong forever.
+ *
+ * ── ONE FILE PER PID, SO THERE IS NO WRITE RACE ──────────────────────────────────────────
+ * Each process writes ONLY its own `<pid>.json`; nobody rewrites a shared document, so concurrent
+ * registration cannot corrupt or lose an entry. Reading is a readdir plus a liveness check, and
+ * dead entries are pruned opportunistically by whoever notices them.
+ *
+ * ── FAILS OPEN ───────────────────────────────────────────────────────────────────────────
+ * Any unreadable/unwritable state resolves to "you are the owner, go ahead and wake". A
+ * self-healing mechanism that can silence a healthy agent is a worse bug than the one it heals —
+ * that is the 3.21.5 lesson, where a fix took auto-wake down for every default-config macOS user.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "../logger.js";
+/**
+ * When this process started. Captured at module load — as close to process start as we can get
+ * from inside — and never recomputed, which is what makes ownership stable and non-oscillating.
+ */
+const PROCESS_STARTED_AT = Date.now() - Math.floor(process.uptime() * 1000);
+/** MUST match wake-lock / wake-claim / credential-store — one cwd, one key, everywhere. */
+function hashCwd(cwd) {
+    return crypto.createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 16);
+}
+const safe = (s) => String(s).replace(/[^A-Za-z0-9._-]/g, "_");
+/** `~/.cogent/bridges/<sha256(cwd)[..16]>.<peerId>/` — one directory per identity. */
+export function bridgeDirFor(cwd, peerId) {
+    return path.join(os.homedir(), ".cogent", "bridges", `${hashCwd(cwd)}.${safe(peerId)}`);
+}
+/** Is that pid a live process? Unknown/odd values count as DEAD so their entries get pruned. */
+function pidAlive(pid) {
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0); // signal 0 = existence check only
+        return true;
+    }
+    catch (err) {
+        // EPERM means it EXISTS but belongs to another user — alive for our purposes.
+        return err?.code === "EPERM";
+    }
+}
+/**
+ * Announce this process as a bridge serving `peerId` in `cwd`.
+ *
+ * Called once the peer is actually registered, so a bridge that never registered never competes
+ * for ownership. Best-effort: a failure here leaves us un-announced, which can only make us LOSE
+ * ownership to someone else, never wrongly take it.
+ */
+export function announceBridge(cwd, peerId, version, endpoint) {
+    const dir = bridgeDirFor(cwd, peerId);
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        const entry = {
+            pid: process.pid,
+            startedAt: PROCESS_STARTED_AT,
+            version,
+            peerId,
+            endpoint,
+            cwd: path.resolve(cwd),
+        };
+        fs.writeFileSync(path.join(dir, `${process.pid}.json`), JSON.stringify(entry));
+    }
+    catch (err) {
+        logger.debug(`wake-ownership: could not announce this bridge (${err.message})`);
+    }
+}
+/** Remove this process's announcement. Called on graceful shutdown; a crash is handled by pruning. */
+export function withdrawBridge(cwd, peerId) {
+    try {
+        fs.unlinkSync(path.join(bridgeDirFor(cwd, peerId), `${process.pid}.json`));
+    }
+    catch {
+        /* already gone, or never announced */
+    }
+}
+/**
+ * Every LIVE bridge announced for this identity, newest process first.
+ *
+ * Prunes entries whose process is gone, so a machine that has been through a dozen plugin updates
+ * does not accumulate junk here forever.
+ */
+export function listLiveBridges(cwd, peerId) {
+    const dir = bridgeDirFor(cwd, peerId);
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return []; // no directory = nobody announced = no competition
+    }
+    const live = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const p = path.join(dir, name);
+        let entry = null;
+        try {
+            entry = JSON.parse(fs.readFileSync(p, "utf-8"));
+        }
+        catch {
+            entry = null;
+        }
+        if (!entry || !pidAlive(entry.pid) || typeof entry.startedAt !== "number") {
+            try {
+                fs.unlinkSync(p); // prune: the process is gone or the record is unusable
+            }
+            catch {
+                /* raced with another pruner */
+            }
+            continue;
+        }
+        live.push(entry);
+    }
+    // Newest process first; pid breaks a same-millisecond tie deterministically so every process
+    // computes the SAME owner. A non-deterministic tie-break would let two bridges each believe
+    // they own it — the exact condition this exists to prevent.
+    live.sort((a, b) => b.startedAt - a.startedAt || b.pid - a.pid);
+    return live;
+}
+/**
+ * Should THIS process wake for `peerId` in `cwd`?
+ *
+ * No when a strictly newer live bridge serves the same identity — that bridge is the one the user
+ * most recently started, and we are the leftover.
+ */
+export function checkWakeOwnership(cwd, peerId) {
+    let live;
+    try {
+        live = listLiveBridges(cwd, peerId);
+    }
+    catch (err) {
+        logger.warn(`wake-ownership: could not read bridge registry (${err.message}) — assuming ownership`);
+        return { isOwner: true, liveCount: 1 };
+    }
+    // Nobody announced (including us — announcement is best-effort): assume ownership. Standing
+    // down on missing evidence would mute a healthy, solitary agent.
+    if (live.length === 0)
+        return { isOwner: true, liveCount: 0 };
+    const owner = live[0];
+    if (owner.pid === process.pid)
+        return { isOwner: true, liveCount: live.length };
+    // We are announced but are not newest -> superseded.
+    if (live.some((e) => e.pid === process.pid)) {
+        return {
+            isOwner: false,
+            owner: { pid: owner.pid, version: owner.version, endpoint: owner.endpoint },
+            liveCount: live.length,
+        };
+    }
+    // Others are announced but we are not (our own announce failed). Do NOT stand down on the
+    // strength of a record we could not write: fail open.
+    return { isOwner: true, liveCount: live.length + 1 };
+}
+//# sourceMappingURL=wake-ownership.js.map

package/dist/services/wake-ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wake-ownership.js","sourceRoot":"","sources":["../../src/services/wake-ownership.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@essentialai/cogent-bridge",
-  "version": "3.23.2",
+  "version": "3.23.4",
   "description": "Cogent Bridge — cross-agent comms for Claude Code, OpenAI Codex and Slack. Codex users: install with `curl -fsSL https://cogent.tools/install.sh | sh`, then start with `cogent-codex` for real-time peer wake.",
   "type": "module",
   "workspaces": [

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.eaisdevelopment/cogent",
   "title": "Cogent Bridge from Essential AI Solutions (essentialai.uk)",
   "description": "MCP bridge for inter-session communication between Claude Code instances",
-  "version": "3.23.2",
+  "version": "3.23.4",
   "repository": {
     "url": "https://github.com/eaisdevelopment/cogent",
     "source": "github"
@@ -12,7 +12,7 @@
     {
       "registryType": "npm",
       "identifier": "@essentialai/cogent-bridge",
-      "version": "3.23.2",
+      "version": "3.23.4",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"