@adhdev/daemon-standalone 1.0.58-rc.30 → 1.0.58-rc.31

package/dist/index.js

@@ -36885,10 +36885,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "2b2c70723e15856b63170cd9496e217fe6d8e02a" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "2b2c7072" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.30" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-28T01:12:45.223Z" : void 0);
+      const commit = readInjected(true ? "d999ca9754d675f6c465f5bab1ff747fc444f7c6" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "d999ca97" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.31" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-28T04:19:17.942Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -43741,7 +43741,8 @@ child.on('exit', () => process.exit(0));
           "command_result",
           "error",
           "agent_event",
-          "log"
+          "log",
+          "beacon_vectors"
         ];
         SERVER_TO_DAEMON_WS_MSGS = [
           "auth_ok",
@@ -43753,7 +43754,8 @@ child.on('exit', () => process.exit(0));
           "force_update_required",
           "command",
           "agent_command",
-          "resolve_action"
+          "resolve_action",
+          "beacon_vectors_result"
         ];
       }
     });
@@ -50985,7 +50987,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           // bound a hostile peer streams arbitrarily many distinct in-range chunks into
           // one map. 64 MiB = 256 × MAX_FRAME_BYTES; the largest library-bounded
           // legitimate body is a ring-tail SNAP of RING_DEFAULT (500) rows ×
-          // MAX_ROW_BYTES (65_536) ≈ 32 MiB, ≈ 43.7 MiB after base64 — comfortably
+          // MAX_ROW_BYTES (65_536) = 31.25 MiB, ≈ 41.7 MiB after base64 — comfortably
           // under. Hosts serving bigger (policy-unbounded) view tables raise this.
           MAX_REASSEMBLY_BYTES: 67108864,
           INFLIGHT_CREDITS: 4,
@@ -51910,27 +51912,47 @@ The instruction it carried was never delivered to anyone. If it still matters, r
     var init_beacon = __esm2({
       "../../vendor/seqscribe/dist/beacon.js"() {
         "use strict";
+        init_encoding();
         init_errors3();
         BeaconHub = class {
           deps;
           known = [];
           transport = null;
           debounceTimer = null;
-          stopped = false;
+          // Node-level teardown (proposals-v3.5 P28). Terminal and distinct from an
+          // arming's stop(): a BeaconHub that outlived its owning node's close() must
+          // never push again, so this is the one latch that is genuinely one-way.
+          closed = false;
+          hostHints = null;
+          // Monotonic arming id. stop() is a PAUSE — the hub is re-startable, matching
+          // the shape of start() itself (a handle you can stop() reads as something you
+          // can start() again) and the reconnect-scoped re-arm hosts actually write.
+          // Handles are per-arming: a stale handle's stop() must not tear down a LATER
+          // arming, which is why stop() compares its own generation before acting.
+          armGen = 0;
           constructor(deps) {
             this.deps = deps;
           }
-          start(t) {
+          start(t, o) {
+            if (this.closed)
+              throw misuse("beacon closed \u2014 the node is closed");
             if (this.transport)
               throw misuse("beacon already started");
+            const gen = ++this.armGen;
             this.transport = t;
+            this.hostHints = o?.hints ?? null;
             this.push();
             return {
               stop: () => {
-                this.stopped = true;
-                if (this.debounceTimer !== null)
+                if (this.armGen !== gen)
+                  return;
+                this.armGen++;
+                if (this.debounceTimer !== null) {
                   this.deps.timers.clearTimeout(this.debounceTimer);
+                  this.debounceTimer = null;
+                }
                 this.transport = null;
+                this.hostHints = null;
               }
             };
           }
@@ -51938,16 +51960,18 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           // core.vectors() when it fires, so node.close() must cancel it like every
           // other hub timer rather than rely on the host calling the handle's stop().
           close() {
-            this.stopped = true;
+            this.closed = true;
+            this.armGen++;
             if (this.debounceTimer !== null) {
               this.deps.timers.clearTimeout(this.debounceTimer);
               this.debounceTimer = null;
             }
             this.transport = null;
+            this.hostHints = null;
           }
           // called from the applied fan-out — 5 s debounce after append (§5.7)
           notifyApplied() {
-            if (!this.transport || this.stopped || this.debounceTimer !== null)
+            if (!this.transport || this.closed || this.debounceTimer !== null)
               return;
             this.debounceTimer = this.deps.timers.setTimeout(() => {
               this.debounceTimer = null;
@@ -51990,17 +52014,73 @@ The instruction it carried was never delivered to anyone. If it still matters, r
             }
             return out;
           }
+          // §5.7 hints (P27). `hintKeys` is the per-topic opt-in gate: a topic that has
+          // not set it contributes nothing and, if the host names it anyway, is dropped
+          // — the SPEC wire format implies the gate, and honoring it is what stops a
+          // "hash" declaration from leaking plaintext keys by omission.
+          //   "plain" — the key as authored
+          //   "hash"  — sha256 hex of the key, so a board operator sees change activity
+          //             without learning key names
+          // Host-supplied entries are merged OVER library-derived ones for the same
+          // topic: the host asked for a specific advertisement, so it wins.
+          buildHints() {
+            const out = {};
+            const modeOf = (topic) => {
+              try {
+                return this.deps.topics.get(topic).policy.hintKeys;
+              } catch {
+                return void 0;
+              }
+            };
+            const add = (topic, mode, raw) => {
+              const dst = out[topic] ??= {};
+              for (const [key2, at] of Object.entries(raw))
+                dst[mode === "hash" ? sha256HexUtf8(key2) : key2] = at;
+            };
+            const registers = this.deps.registers;
+            if (registers)
+              for (const topic of this.deps.topics.list()) {
+                const mode = modeOf(topic);
+                if (mode === void 0)
+                  continue;
+                if (this.deps.topics.get(topic).policy.kind !== "register")
+                  continue;
+                add(topic, mode, registers.hintsFor(topic));
+              }
+            if (this.hostHints) {
+              let supplied;
+              try {
+                supplied = this.hostHints();
+              } catch {
+                supplied = {};
+              }
+              for (const [topic, raw] of Object.entries(supplied)) {
+                const mode = modeOf(topic);
+                if (mode === void 0)
+                  continue;
+                add(topic, mode, raw);
+              }
+            }
+            for (const topic of Object.keys(out))
+              if (Object.keys(out[topic]).length === 0)
+                delete out[topic];
+            return Object.keys(out).length > 0 ? out : void 0;
+          }
           push() {
             const t = this.transport;
-            if (!t || this.stopped)
+            if (!t || this.closed)
               return;
+            const gen = this.armGen;
             const report = {
               node: this.deps.writerId,
               at: new Date(this.deps.clock()).toISOString(),
               vectors: this.deps.core.vectors()
             };
+            const hints = this.buildHints();
+            if (hints)
+              report.hints = hints;
             void t.put(report).then(() => t.get()).then((reports) => {
-              if (!this.stopped)
+              if (!this.closed && this.armGen === gen)
                 this.known = reports;
             }).catch(() => {
             });
@@ -53593,6 +53673,38 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           ownerOf(topic, key2) {
             return this.topicState(topic).keys.get(key2)?.owner ?? null;
           }
+          // §5.7 pre-write warning source (proposals-v3.5 P27): the latest change this
+          // node knows about per key, as the [writer, seq] shape BeaconReport.hints
+          // declares. Sourced from the MATERIALIZED winner, NOT from scopeTails —
+          // scopeTails is the §11.2 own-uncommitted tail and is deleted as each own
+          // write materializes (and never holds a peer's write at all), so it is empty
+          // in exactly the steady state a hint has to describe. `winner` is the fold's
+          // per-key judgment over the total order, which is what "latest known change
+          // to this key" means, and it covers peer writes and own writes alike.
+          //
+          // Member-only keys (a set with no scalar winner) report their highest member
+          // entry: under §11.5 mirror rules such a key never has a `winner`, but an
+          // add/remove is still a change a concurrent editor would overwrite.
+          hintsFor(topic) {
+            const out = {};
+            for (const [key2, ks] of this.topicState(topic).keys) {
+              let best;
+              let bestOrder;
+              if (ks.winner && ks.winnerOrder) {
+                best = [ks.winner[1], ks.winner[2]];
+                bestOrder = ks.winnerOrder;
+              }
+              for (const ms of ks.members.values()) {
+                if (bestOrder !== void 0 && orderCompare(ms.order, bestOrder) <= 0)
+                  continue;
+                best = [ms.entry[1], ms.entry[2]];
+                bestOrder = ms.order;
+              }
+              if (best)
+                out[key2] = best;
+            }
+            return out;
+          }
           pendingRequests(topic, now) {
             const cutoff = (now ?? this.deps.clock()) - this.deps.constants.REQUEST_TTL_MS;
             const out = [];
@@ -57362,7 +57474,15 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       sync.setSnapshotHub(snapshots);
       const archive = new ArchiveHub({ core: core2, store, topics, views, registers, constants: constants2, clock, emitAnomaly });
       consumers.setOnAdvance((topic) => archive.onConsumerAdvance(topic));
-      const beaconHub = new BeaconHub({ core: core2, topics, writerId: opts.writerId, constants: constants2, timers, clock });
+      const beaconHub = new BeaconHub({
+        core: core2,
+        topics,
+        writerId: opts.writerId,
+        constants: constants2,
+        timers,
+        clock,
+        registers
+      });
       finalityHub.setOnAccepted((cert) => {
         views.notifyApplied(cert.topic);
         sync.onCertAccepted();
@@ -57407,7 +57527,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         vectors: () => core2.vectors(),
         setKnownVectors: (v) => beaconHub.setKnownVectors(v),
         staleness: (topic, key2) => beaconHub.staleness(topic, key2),
-        beacon: (t) => beaconHub.start(t),
+        beacon: (t, o) => beaconHub.start(t, o),
         finality: (topic) => finalityHub.finality(topic),
         proposeFinality: (topic) => finalityHub.proposeFinality(topic),
         ingestFinality: (cert) => finalityHub.ingestFinality(cert),
@@ -96908,6 +97028,7 @@ ${e?.stderr || ""}`;
       ASSISTANT_JOURNAL_TOPIC: () => ASSISTANT_JOURNAL_TOPIC,
       AcpProviderInstance: () => AcpProviderInstance,
       AgentStreamPoller: () => AgentStreamPoller,
+      BEACON_ENV: () => BEACON_ENV,
       BUILD_CHANNEL_ENV_VAR: () => BUILD_CHANNEL_ENV_VAR,
       BUILTIN_CHAT_MESSAGE_KINDS: () => BUILTIN_CHAT_MESSAGE_KINDS,
       CANONICAL_MESH_TOOL_COUNT: () => CANONICAL_MESH_TOOL_COUNT,
@@ -96988,6 +97109,7 @@ ${e?.stderr || ""}`;
       LowDiskSpaceError: () => LowDiskSpaceError,
       MAGI_NEEDS_VERIFICATION_PREVIEW_CAP: () => MAGI_NEEDS_VERIFICATION_PREVIEW_CAP,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
+      MAX_BEACON_GET_QUERIES: () => MAX_BEACON_GET_QUERIES,
       MAX_CAPTURE_LOG_GENERATIONS: () => MAX_CAPTURE_LOG_GENERATIONS,
       MAX_CAPTURE_LOG_SIZE: () => MAX_CAPTURE_LOG_SIZE,
       MAX_INFLIGHT: () => MAX_INFLIGHT,
@@ -97100,7 +97222,9 @@ ${e?.stderr || ""}`;
       appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
       appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+      armBeacon: () => armBeacon,
       assertNoDependencyCycle: () => assertNoDependencyCycle,
+      assertNoPlaintextHintTopics: () => assertNoPlaintextHintTopics,
       assistantJournalPolicy: () => assistantJournalPolicy,
       backfillMeshEventShadow: () => backfillMeshEventShadow,
       baseTopicDefinitions: () => baseTopicDefinitions,
@@ -97208,6 +97332,7 @@ ${e?.stderr || ""}`;
       daemonIdsEquivalent: () => daemonIdsEquivalent,
       decideMissingSessionAttempt: () => decideMissingSessionAttempt2,
       declareWorkspaceIntents: () => declareWorkspaceIntents,
+      defaultBeaconTopicScope: () => defaultBeaconTopicScope,
       delegatedWorkerAutoApproveSettings: () => delegatedWorkerAutoApproveSettings,
       deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       deleteMesh: () => deleteMesh,
@@ -97472,6 +97597,7 @@ ${e?.stderr || ""}`;
       printQuotaInstallError: () => printQuotaInstallError2,
       printQuotaRefreshOutcome: () => printQuotaRefreshOutcome2,
       probeCdpPort: () => probeCdpPort,
+      projectBeaconReport: () => projectBeaconReport,
       projectGraphPublicPolicy: () => projectGraphPublicPolicy,
       projectMeshLedgerEntry: () => projectMeshLedgerEntry,
       pruneOperatingNotes: () => pruneOperatingNotes,
@@ -97538,6 +97664,7 @@ ${e?.stderr || ""}`;
       resolveAllowSendKeysDestructive: () => resolveAllowSendKeysDestructive,
       resolveAutoConvergeCodeChange: () => resolveAutoConvergeCodeChange,
       resolveBackoffMs: () => resolveBackoffMs,
+      resolveBeaconMode: () => resolveBeaconMode,
       resolveBuildTrack: () => resolveBuildTrack,
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveConsoleSymbols: () => resolveConsoleSymbols,
@@ -147984,10 +148111,22 @@ data: ${JSON.stringify(msg.data)}
         "Seqscribe",
         `node open writer=${writerId} topics=${defs.length} authority=${authority ? "on" : "off"}${opts.isCoordinator ? " role=coordinator" : ""}`
       );
+      const closeCallbacks = [];
       let closed = false;
       const close = async () => {
         if (closed) return;
         closed = true;
+        while (closeCallbacks.length > 0) {
+          const fn = closeCallbacks.shift();
+          try {
+            fn();
+          } catch (err) {
+            LOG2.warn(
+              "Seqscribe",
+              `close callback failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
         try {
           finalityLoop?.stop();
         } catch {
@@ -148018,6 +148157,16 @@ data: ${JSON.stringify(msg.data)}
         topics: defs,
         authorityEnabled: authority !== null,
         finalityLoop,
+        onClose: (fn) => {
+          if (closed) {
+            try {
+              fn();
+            } catch {
+            }
+            return;
+          }
+          closeCallbacks.push(fn);
+        },
         close
       };
     }
@@ -149415,6 +149564,279 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
 \u2717 ${message}
 `));
     }
+    init_logger();
+    init_topics2();
+    var BEACON_ENV = "ADHDEV_SEQSCRIBE_BEACON";
+    function resolveBeaconMode(env2 = process.env) {
+      const raw = env2[BEACON_ENV]?.trim().toLowerCase();
+      if (!raw) return "on";
+      if (raw === "off") return "off";
+      if (raw === "on") return "on";
+      warnOnce4(
+        `unrecognized ${BEACON_ENV}=${raw}; treating as 'on'. Valid values are 'on' (default) and 'off'.`
+      );
+      return "on";
+    }
+    var warnedUnrecognized = false;
+    function warnOnce4(message) {
+      if (warnedUnrecognized) return;
+      warnedUnrecognized = true;
+      LOG2.warn("Seqscribe", message);
+    }
+    var CHAIN_RE2 = /^[0-9a-f]{64}$/;
+    var WRITER_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+    var TOPIC_RE2 = /^[A-Za-z0-9._*-]{1,160}$/;
+    var MAX_TOPICS_PER_REPORT = 512;
+    var MAX_WRITERS_PER_TOPIC = 512;
+    function finiteCount(v) {
+      return typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : void 0;
+    }
+    function hash64(v) {
+      return typeof v === "string" && CHAIN_RE2.test(v) ? v : void 0;
+    }
+    function projectWriterEntry(raw) {
+      if (!raw || typeof raw !== "object") return null;
+      const v = raw;
+      const rgen = finiteCount(v.rgen);
+      if (v.retired === true) {
+        const finalSeq = finiteCount(v.finalSeq);
+        const finalChain = hash64(v.finalChain);
+        if (finalSeq === void 0 || finalChain === void 0 || rgen === void 0) return null;
+        return { retired: true, finalSeq, finalChain, rgen };
+      }
+      const contig = finiteCount(v.contig);
+      const chain = hash64(v.chain);
+      if (contig === void 0 || chain === void 0) return null;
+      return rgen === void 0 ? { contig, chain } : { contig, chain, rgen };
+    }
+    function projectBeaconReport(raw) {
+      if (!raw || typeof raw !== "object") return null;
+      const v = raw;
+      const node = typeof v.node === "string" && WRITER_ID_RE.test(v.node) ? v.node : null;
+      if (!node) return null;
+      const at = typeof v.at === "string" && !Number.isNaN(Date.parse(v.at)) ? new Date(v.at).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+      const vectors = {};
+      const rawVectors = v.vectors;
+      if (rawVectors && typeof rawVectors === "object") {
+        let topicCount = 0;
+        for (const [topic, vec] of Object.entries(rawVectors)) {
+          if (topicCount >= MAX_TOPICS_PER_REPORT) break;
+          if (!TOPIC_RE2.test(topic)) continue;
+          if (!vec || typeof vec !== "object") continue;
+          const rawWriters = vec.writers;
+          if (!rawWriters || typeof rawWriters !== "object") continue;
+          const writers = {};
+          let writerCount = 0;
+          for (const [writerId, entry] of Object.entries(rawWriters)) {
+            if (writerCount >= MAX_WRITERS_PER_TOPIC) break;
+            if (!WRITER_ID_RE.test(writerId)) continue;
+            const clean2 = projectWriterEntry(entry);
+            if (!clean2) continue;
+            writers[writerId] = clean2;
+            writerCount++;
+          }
+          if (writerCount === 0) continue;
+          const fgen = finiteCount(vec.fgen);
+          vectors[topic] = fgen === void 0 ? { writers } : { fgen, writers };
+          topicCount++;
+        }
+      }
+      return { node, at, vectors };
+    }
+    function assertNoPlaintextHintTopics(defs) {
+      const offenders = defs.filter((d) => d.policy.hintKeys === "plain").map((d) => d.topic);
+      if (offenders.length === 0) return;
+      throw new Error(
+        `seqscribe beacon: topic(s) ${offenders.join(", ")} declare hintKeys:'plain'. Only 'hash' (or omitting the field) is permitted \u2014 plaintext register keys on the server exceed the approved Beacon content-boundary exception (CLAUDE.md).`
+      );
+    }
+    function defaultBeaconTopicScope(vectors) {
+      return Object.keys(vectors).filter(
+        (topic) => topic === FLEET_STATUS_TOPIC || meshIdFromEventsTopic(topic) !== null
+      );
+    }
+    function emptyCounters() {
+      return {
+        put: 0,
+        putFailed: 0,
+        get: 0,
+        getFailed: 0,
+        truncated: 0,
+        rejected: 0,
+        splitRetries: 0
+      };
+    }
+    var MAX_BEACON_GET_QUERIES = 16;
+    function mergeBeaconReportsByNode(left, right) {
+      const byNode = /* @__PURE__ */ new Map();
+      const unkeyed = [];
+      const ingest2 = (report) => {
+        const node = report && typeof report === "object" && typeof report.node === "string" ? report.node : void 0;
+        if (!node) {
+          unkeyed.push(report);
+          return;
+        }
+        const existing = byNode.get(node);
+        if (!existing) {
+          byNode.set(node, report);
+          return;
+        }
+        const existingAt = existing.at;
+        const candidateAt = report.at;
+        const existingTime = typeof existingAt === "string" ? Date.parse(existingAt) : NaN;
+        const candidateTime = typeof candidateAt === "string" ? Date.parse(candidateAt) : NaN;
+        if (!Number.isNaN(candidateTime) && (Number.isNaN(existingTime) || candidateTime > existingTime)) {
+          byNode.set(node, report);
+        }
+      };
+      for (const r of left) ingest2(r);
+      for (const r of right) ingest2(r);
+      return [...byNode.values(), ...unkeyed];
+    }
+    function armBeacon(handle, transport, opts = {}) {
+      const mode = resolveBeaconMode(opts.env ?? process.env);
+      if (mode === "off") {
+        LOG2.info("Seqscribe", `beacon disabled (${BEACON_ENV}=off)`);
+        return null;
+      }
+      assertNoPlaintextHintTopics(handle.topics);
+      const counters5 = emptyCounters();
+      const scopeOf = opts.topicScope ?? defaultBeaconTopicScope;
+      let stopped = false;
+      let lastScope = [];
+      const doPut = async (rawReport) => {
+        const projected = projectBeaconReport(rawReport);
+        if (!projected) {
+          counters5.rejected++;
+          LOG2.warn("Seqscribe", "beacon report failed the content projection; not sent");
+          return;
+        }
+        lastScope = scopeOf(projected.vectors);
+        try {
+          await transport.put(projected);
+          counters5.put++;
+        } catch (err) {
+          counters5.putFailed++;
+          LOG2.info(
+            "Seqscribe",
+            `beacon put failed (advisory, ignored): ${err instanceof Error ? err.message : String(err)}`
+          );
+          throw err;
+        }
+      };
+      const rawQuery = async (topics) => {
+        try {
+          const res = await transport.get(topics);
+          counters5.get++;
+          return res;
+        } catch (err) {
+          counters5.getFailed++;
+          LOG2.info(
+            "Seqscribe",
+            `beacon get failed (advisory, ignored): ${err instanceof Error ? err.message : String(err)}`
+          );
+          throw err;
+        }
+      };
+      const queryWithSplitRetry = async (topics, queriesUsed) => {
+        if (queriesUsed.count >= MAX_BEACON_GET_QUERIES) {
+          return { reports: [], truncated: topics.length };
+        }
+        queriesUsed.count++;
+        const res = await rawQuery(topics);
+        const truncated = typeof res?.truncated === "number" ? res.truncated : 0;
+        const reports = Array.isArray(res?.reports) ? res.reports : [];
+        if (truncated === 0 || topics.length <= 1) {
+          return { reports, truncated };
+        }
+        if (queriesUsed.count + 2 > MAX_BEACON_GET_QUERIES) {
+          return { reports, truncated };
+        }
+        const mid = Math.ceil(topics.length / 2);
+        const left = topics.slice(0, mid);
+        const right = topics.slice(mid);
+        counters5.splitRetries++;
+        const [leftRes, rightRes] = await Promise.all([
+          queryWithSplitRetry(left, queriesUsed),
+          queryWithSplitRetry(right, queriesUsed)
+        ]);
+        return {
+          reports: mergeBeaconReportsByNode(leftRes.reports, rightRes.reports),
+          truncated: leftRes.truncated + rightRes.truncated
+        };
+      };
+      const doGet = async () => {
+        const queriesUsed = { count: 0 };
+        let truncated = 0;
+        let reports = [];
+        try {
+          const res = await queryWithSplitRetry(lastScope, queriesUsed);
+          reports = res.reports;
+          truncated = res.truncated;
+        } catch (err) {
+          counters5.getFailed++;
+          LOG2.info(
+            "Seqscribe",
+            `beacon get failed (advisory, ignored): ${err instanceof Error ? err.message : String(err)}`
+          );
+          throw err;
+        }
+        if (truncated > 0) {
+          counters5.truncated += truncated;
+          LOG2.info(
+            "Seqscribe",
+            `beacon get: ${truncated} peer report(s) remained truncated after split-retry (${queriesUsed.count} quer${queriesUsed.count === 1 ? "y" : "ies"})`
+          );
+        }
+        const clean2 = reports.map((r) => projectBeaconReport(r)).filter((r) => r !== null);
+        LOG2.info(
+          "Seqscribe",
+          `beacon get writer=${handle.writerId} peers=${clean2.length} topics=${lastScope.length}`
+        );
+        return clean2;
+      };
+      const libHandle = handle.node.beacon({
+        async put(rawReport) {
+          if (stopped) return;
+          await doPut(rawReport);
+        },
+        async get() {
+          if (stopped) return [];
+          return await doGet();
+        }
+      });
+      LOG2.info("Seqscribe", `beacon armed writer=${handle.writerId}`);
+      const beaconHandle = {
+        stop() {
+          if (stopped) return;
+          stopped = true;
+          try {
+            libHandle.stop();
+          } catch {
+          }
+          LOG2.info(
+            "Seqscribe",
+            `beacon stopped writer=${handle.writerId} put=${counters5.put}/${counters5.put + counters5.putFailed} get=${counters5.get}/${counters5.get + counters5.getFailed} splitRetries=${counters5.splitRetries} truncated=${counters5.truncated} rejected=${counters5.rejected}`
+          );
+        },
+        counters: () => ({ ...counters5 }),
+        async pushNow() {
+          if (stopped) return;
+          try {
+            await doPut({
+              node: handle.writerId,
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              vectors: handle.node.vectors()
+            });
+            const board = await doGet();
+            if (!stopped) handle.node.setKnownVectors(board);
+          } catch {
+          }
+        }
+      };
+      handle.onClose(() => beaconHandle.stop());
+      return beaconHandle;
+    }
     init_topics2();
     init_authority();
     init_mesh_dual_write();