@legioncodeinc/honeycomb 0.1.6 → 0.1.7

package/daemon/index.js

@@ -7369,7 +7369,7 @@ var require_dist = __commonJS({
 // dist/src/shared/constants.js
 var DAEMON_PORT = 3850;
 var DAEMON_HOST = "127.0.0.1";
-var HONEYCOMB_VERSION = true ? "0.1.6" : "0.0.0-dev";
+var HONEYCOMB_VERSION = true ? "0.1.7" : "0.0.0-dev";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -26904,6 +26904,36 @@ function appendOnlyInsert(client, target, scope, row) {
   const sql = buildInsert(target.table, row);
   return withHeal(client, target, scope, () => client.query(sql, scope));
 }
+function buildInsertMany(table, rows) {
+  if (rows.length === 0) {
+    throw new Error("buildInsertMany: at least one row is required");
+  }
+  const tbl = sqlIdent(table);
+  const first = rows[0];
+  const colNames = first.map(([name]) => name);
+  for (const row of rows)
+    assertSameColumns(colNames, row);
+  const cols = colNames.map((name) => sqlIdent(name)).join(", ");
+  const vals = rows.map((row) => `(${row.map(([, v]) => renderValue(v)).join(", ")})`).join(", ");
+  return `INSERT INTO "${tbl}" (${cols}) VALUES ${vals}`;
+}
+function assertSameColumns(expected, row) {
+  if (row.length !== expected.length) {
+    throw new Error(`buildInsertMany: row column count ${row.length} != expected ${expected.length}`);
+  }
+  for (let i = 0; i < expected.length; i++) {
+    const actual = row[i][0];
+    if (actual !== expected[i]) {
+      throw new Error(`buildInsertMany: row column "${actual}" != expected "${expected[i]}" at index ${i}`);
+    }
+  }
+}
+function appendOnlyInsertMany(client, target, scope, rows, opts) {
+  if (rows.length === 0)
+    return Promise.resolve(ok([], 0));
+  const sql = buildInsertMany(target.table, rows);
+  return withHeal(client, target, scope, () => client.query(sql, scope, opts));
+}
 async function readLatestVersion(client, target, scope, keyColumn, keyValue, selectColumns = "*") {
   const tbl = sqlIdent(target.table);
   const key = sqlIdent(keyColumn);
@@ -26988,6 +27018,8 @@ function resolveConfig(config2, ownerFallback) {
 var RESOLVE_POLLS = 8;
 var DISCOVER_POLLS = 8;
 var LEASE_CANDIDATE_TRIES = 8;
+var SOURCE_LEASE = "poll-lease";
+var SOURCE_REAPER = "poll-reaper";
 function defaultClock2() {
   return {
     now: () => Date.now(),
@@ -27164,7 +27196,7 @@ var DeepLakeJobQueueService = class {
       ]);
       if (!wrote)
         return null;
-      const current = await this.resolveCurrent(candidate.id);
+      const current = await this.resolveCurrent(candidate.id, SOURCE_LEASE);
       if (current !== null && current.leaseOwner === owner && current.status === JOB_LEASED) {
         return {
           id: candidate.id,
@@ -27189,7 +27221,7 @@ var DeepLakeJobQueueService = class {
    */
   async selectLeasable(exclude, kinds) {
     const nowIso10 = this.nowIso();
-    const states = await this.discoverIds();
+    const states = await this.discoverIds(SOURCE_LEASE);
     const leasable = states.filter((s) => !exclude.has(s.id) && (kinds === void 0 || kinds.includes(s.type)) && (s.status === JOB_QUEUED || s.status === JOB_FAILED) && s.nextRunAt !== "" && s.nextRunAt <= nowIso10);
     if (leasable.length === 0)
       return null;
@@ -27204,12 +27236,12 @@ var DeepLakeJobQueueService = class {
    * growing. Then resolves each id's current state via {@link resolveCurrent}. The
    * `__ensure__` sentinel row (see {@link ensureTable}) is filtered out.
    */
-  async discoverIds() {
+  async discoverIds(source) {
     const ids = /* @__PURE__ */ new Set();
     let lastSize = -1;
     for (let poll = 0; poll < DISCOVER_POLLS; poll++) {
       const sql = `SELECT DISTINCT ${sqlIdent("id")} FROM "${this.tbl()}"`;
-      const res = await this.storage.query(sql, this.scope);
+      const res = await this.storage.query(sql, this.scope, source !== void 0 ? { source } : {});
       if (isOk(res)) {
         for (const row of res.rows) {
           const id = rowText(row, "id");
@@ -27223,7 +27255,7 @@ var DeepLakeJobQueueService = class {
     }
     const states = [];
     for (const id of ids) {
-      const state = await this.resolveCurrent(id);
+      const state = await this.resolveCurrent(id, source);
       if (state !== null)
         states.push(state);
     }
@@ -27239,11 +27271,11 @@ var DeepLakeJobQueueService = class {
    * when the id has no row at all. Short-circuits once a max-version row is seen
    * twice (the fake is decisive on the first read).
    */
-  async resolveCurrent(id) {
+  async resolveCurrent(id, source) {
     let best = null;
     let seenBestTwice = false;
     for (let poll = 0; poll < RESOLVE_POLLS; poll++) {
-      const row = await this.latestById(id);
+      const row = await this.latestById(id, source);
       if (row !== null) {
         const state = toJobState(row);
         if (best === null || state.version > best.version) {
@@ -27259,10 +27291,10 @@ var DeepLakeJobQueueService = class {
     return best;
   }
   /** One highest-version by-id read of the full job row, or `null` when absent. */
-  async latestById(id) {
+  async latestById(id, source) {
     const cols = STATE_COLUMNS.map((c) => sqlIdent(c)).join(", ");
     const sql = `SELECT ${cols} FROM "${this.tbl()}" WHERE ${sqlIdent("id")} = ${sLiteral(id)} ORDER BY ${sqlIdent("version")} DESC LIMIT 1`;
-    const res = await this.storage.query(sql, this.scope);
+    const res = await this.storage.query(sql, this.scope, source !== void 0 ? { source } : {});
     if (isOk(res) && res.rows.length > 0)
       return res.rows[0];
     return null;
@@ -27362,7 +27394,7 @@ var DeepLakeJobQueueService = class {
    */
   async reapExpiredLeases() {
     const nowIso10 = this.nowIso();
-    const states = await this.discoverIds();
+    const states = await this.discoverIds(SOURCE_REAPER);
     const expired = states.filter((s) => s.status === JOB_LEASED && s.leaseExpiresAt !== "" && s.leaseExpiresAt <= nowIso10);
     if (expired.length === 0)
       return 0;
@@ -28464,7 +28496,7 @@ function buildAllowedProperties(input) {
 }
 var systemTelemetryClock = () => (/* @__PURE__ */ new Date()).toISOString();
 var DEFAULT_EMIT_TIMEOUT_MS = 2e3;
-var HONEYCOMB_VERSION2 = true ? "0.1.6" : "0.0.0-dev";
+var HONEYCOMB_VERSION2 = true ? "0.1.7" : "0.0.0-dev";
 async function emitTelemetry(event, opts, deps = {}) {
   const env = deps.env ?? process.env;
   const key = deps.posthogKey ?? POSTHOG_KEY;
@@ -31094,15 +31126,204 @@ function parseCaptureRequest(body) {
   return { ok: false, error: issues };
 }
 
+// dist/src/daemon/runtime/capture/capture-buffer.js
+var realBufferClock = {
+  now: () => Date.now(),
+  setTimer: (fn, ms) => {
+    const t = setTimeout(fn, ms);
+    if (typeof t === "object" && t !== null && "unref" in t && typeof t.unref === "function")
+      t.unref();
+    return t;
+  },
+  clearTimer: (handle) => clearTimeout(handle)
+};
+var DEFAULT_MAX_EVENTS = 25;
+var DEFAULT_WINDOW_MS = 1e3;
+var CaptureBuffer = class {
+  maxEvents;
+  windowMs;
+  clock;
+  flushFn;
+  /** The current window's buffered items. */
+  items = [];
+  /** The pending time-flush timer, or null when the window is empty. */
+  timer = null;
+  /** The in-flight flush, so a second trigger awaits it rather than racing it. */
+  inFlight = Promise.resolve();
+  /** Set on `close()` so a late `add` after shutdown is rejected, not silently buffered-then-lost. */
+  closed = false;
+  constructor(flushFn, config2 = {}, clock = realBufferClock) {
+    this.flushFn = flushFn;
+    this.maxEvents = Math.max(1, config2.maxEvents ?? DEFAULT_MAX_EVENTS);
+    this.windowMs = Math.max(1, config2.windowMs ?? DEFAULT_WINDOW_MS);
+    this.clock = clock;
+  }
+  /** Number of items currently buffered (for assertions / diagnostics). */
+  get size() {
+    return this.items.length;
+  }
+  /**
+   * Buffer one item. Starts the time window on the first item of an empty buffer,
+   * and triggers an immediate flush when the size cap is reached. Returns a promise
+   * that resolves when THIS item has been flushed (either by the size cap it just
+   * tripped, or by a later time/force flush), so a caller that needs the durable
+   * write before responding can await it; a caller that wants fire-and-forget
+   * batching simply does not await.
+   */
+  add(item) {
+    if (this.closed) {
+      return Promise.reject(new Error("CaptureBuffer.add after close"));
+    }
+    this.items.push(item);
+    if (this.items.length === 1)
+      this.startTimer();
+    if (this.items.length >= this.maxEvents)
+      return this.flushNow();
+    return this.inFlight;
+  }
+  /**
+   * Force a flush of the current window NOW (window close / shutdown drain). Cancels
+   * the pending timer, swaps out the buffered batch, and appends it as one multi-row
+   * write. Awaits any in-flight flush first so two flushes never overlap. A no-op
+   * (resolved) when the buffer is empty.
+   */
+  flushNow() {
+    this.cancelTimer();
+    if (this.items.length === 0)
+      return this.inFlight;
+    const batch = this.items;
+    this.items = [];
+    this.inFlight = this.inFlight.then(() => this.flushFn(batch));
+    return this.inFlight;
+  }
+  /**
+   * Drain + close (graceful shutdown, AC-5 / AC-62c.1.2). Flushes the remaining
+   * window so nothing buffered is lost on a clean stop, then marks the buffer closed
+   * so a late `add` is rejected rather than buffered into a buffer that will never
+   * flush again. Idempotent.
+   */
+  async close() {
+    if (this.closed) {
+      await this.inFlight;
+      return;
+    }
+    const drained = this.flushNow();
+    this.closed = true;
+    await drained;
+  }
+  /** Start the time-flush timer for the current window (called on the first buffered item). */
+  startTimer() {
+    this.cancelTimer();
+    this.timer = this.clock.setTimer(() => {
+      this.timer = null;
+      void this.flushNow();
+    }, this.windowMs);
+  }
+  /** Cancel + clear the pending time-flush timer, if any. */
+  cancelTimer() {
+    if (this.timer !== null) {
+      this.clock.clearTimer(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// dist/src/daemon/runtime/capture/capture-config.js
+var DEFAULT_CAPTURE_WINDOW_MS = 1e3;
+var DEFAULT_CAPTURE_MAX_EVENTS = 25;
+var DEFAULT_CAPTURE_ENVELOPE_BUDGET_BYTES = 16384;
+var BoolFlag = external_exports.preprocess((raw2) => {
+  if (typeof raw2 === "boolean")
+    return raw2;
+  return raw2 === "true" || raw2 === "1";
+}, external_exports.boolean());
+function ClampedInt(def, min = 0) {
+  return external_exports.preprocess((raw2) => {
+    const n = typeof raw2 === "number" ? raw2 : Number(raw2);
+    if (!Number.isFinite(n))
+      return def;
+    return Math.max(min, Math.trunc(n));
+  }, external_exports.number().int());
+}
+var CaptureConfigSchema = external_exports.object({
+  /** Master switch for write batching; DEFAULT-ON (L-X1). Off ⇒ one INSERT per event. */
+  batch: BoolFlag.default(true),
+  /** Time-flush window in ms (AC-5). */
+  windowMs: ClampedInt(DEFAULT_CAPTURE_WINDOW_MS, 1).default(DEFAULT_CAPTURE_WINDOW_MS),
+  /** Size-flush cap in events (AC-5). */
+  maxEvents: ClampedInt(DEFAULT_CAPTURE_MAX_EVENTS, 1).default(DEFAULT_CAPTURE_MAX_EVENTS),
+  /** Per-field tool-I/O byte budget; `0` disables trimming (full envelope, pre-062c). */
+  envelopeBudgetBytes: ClampedInt(DEFAULT_CAPTURE_ENVELOPE_BUDGET_BYTES, 0).default(DEFAULT_CAPTURE_ENVELOPE_BUDGET_BYTES)
+});
+var CAPTURE_ENV_KEYS = {
+  batch: "HONEYCOMB_CAPTURE_BATCH",
+  windowMs: "HONEYCOMB_CAPTURE_WINDOW_MS",
+  maxEvents: "HONEYCOMB_CAPTURE_MAX_EVENTS",
+  envelopeBudgetBytes: "HONEYCOMB_CAPTURE_ENVELOPE_BUDGET_BYTES"
+};
+function resolveCaptureConfig(env = process.env) {
+  const parsed = CaptureConfigSchema.safeParse({
+    batch: env[CAPTURE_ENV_KEYS.batch],
+    windowMs: env[CAPTURE_ENV_KEYS.windowMs],
+    maxEvents: env[CAPTURE_ENV_KEYS.maxEvents],
+    envelopeBudgetBytes: env[CAPTURE_ENV_KEYS.envelopeBudgetBytes]
+  });
+  return parsed.success ? parsed.data : CaptureConfigSchema.parse({});
+}
+
+// dist/src/daemon/runtime/capture/budgeted-stringify.js
+var DEFAULT_ENVELOPE_BUDGET_BYTES = 16384;
+function truncationMarker(originalBytes) {
+  return `\u2026[truncated ${originalBytes} bytes]`;
+}
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function capToolField(value, budgetBytes) {
+  if (value === void 0)
+    return void 0;
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+  if (serialized === void 0)
+    return void 0;
+  if (byteLength(serialized) <= budgetBytes)
+    return value;
+  return truncationMarker(byteLength(serialized));
+}
+function trimEvent(event, budgetBytes) {
+  if (event.kind !== "tool_call")
+    return event;
+  const cappedInput = capToolField(event.input, budgetBytes);
+  const cappedResponse = capToolField(event.response, budgetBytes);
+  if (cappedInput === event.input && cappedResponse === event.response)
+    return event;
+  return {
+    kind: "tool_call",
+    tool: event.tool,
+    ...cappedInput !== void 0 ? { input: cappedInput } : {},
+    ...cappedResponse !== void 0 ? { response: cappedResponse } : {}
+  };
+}
+function budgetedStringify(event, metadata, budgetBytes = DEFAULT_ENVELOPE_BUDGET_BYTES) {
+  const trimmedEvent = trimEvent(event, budgetBytes);
+  return JSON.stringify({ event: trimmedEvent, metadata });
+}
+
 // dist/src/daemon/runtime/capture/capture-handler.js
 var HOOKS_GROUP = "/api/hooks";
+var CAPTURE_WRITE_SOURCE = "capture-write";
 var CAPTURE_PATH = "/capture";
 var CONVERSATION_PATH = "/conversation";
 function createCaptureHandler(deps) {
   const counters = deps.counters ?? new TurnCounters(deps.counterConfig);
   const embed = deps.embed ?? noopEmbedAttachment;
   const now = deps.now ?? (() => Date.now());
-  const handler = new CaptureRouteHandler(deps, counters, embed, now);
+  const config2 = deps.captureConfig ?? resolveCaptureConfig();
+  const handler = new CaptureRouteHandler(deps, counters, embed, now, config2);
   return {
     register(daemon) {
       const group = daemon.group(HOOKS_GROUP);
@@ -31112,7 +31333,8 @@ function createCaptureHandler(deps) {
       group.post(CAPTURE_PATH, (c) => handler.handleCapture(c));
       group.get(CONVERSATION_PATH, (c) => handler.handleConversation(c));
     },
-    counters
+    counters,
+    flush: () => handler.flush()
   };
 }
 var CaptureRouteHandler = class {
@@ -31120,11 +31342,19 @@ var CaptureRouteHandler = class {
   counters;
   embed;
   now;
-  constructor(deps, counters, embed, now) {
+  config;
+  /**
+   * PRD-062c (L-C1): the capture write buffer. NULL when batching is off — the handler
+   * then does one append-only INSERT per event (the pre-062c path). Lazily created on the
+   * first buffered write so a flag-off handler allocates nothing.
+   */
+  buffer = null;
+  constructor(deps, counters, embed, now, config2) {
     this.deps = deps;
     this.counters = counters;
     this.embed = embed;
     this.now = now;
+    this.config = config2;
   }
   /**
    * POST /api/hooks/capture (FR-1..5, FR-7..9 / a-AC-1..5).
@@ -31153,10 +31383,16 @@ var CaptureRouteHandler = class {
     const nowIso10 = new Date(this.now()).toISOString();
     const projectId = this.resolveCaptureProjectId(metadata);
     const row = this.buildRow(id, event, metadata, nowIso10, projectId);
-    const result = await appendOnlyInsert(this.deps.storage, this.deps.sessionsTarget, scope, row);
-    if (!isOk(result)) {
-      this.deps.logger?.event("capture.insert.failed", { id, kind: result.kind });
-      return c.json({ error: "capture_failed", reason: "could not write the session row" }, 502);
+    if (this.config.batch) {
+      this.bufferRow(id, row, scope);
+    } else {
+      const result = await appendOnlyInsertMany(this.deps.storage, this.deps.sessionsTarget, scope, [row], {
+        source: CAPTURE_WRITE_SOURCE
+      });
+      if (!isOk(result)) {
+        this.deps.logger?.event("capture.insert.failed", { id, kind: result.kind });
+        return c.json({ error: "capture_failed", reason: "could not write the session row" }, 502);
+      }
     }
     const cues = this.bumpCounters(metadata);
     await this.enqueueCues(cues);
@@ -31189,6 +31425,67 @@ var CaptureRouteHandler = class {
     }
     return c.json({ path: path4.trim(), rows: result.rows });
   }
+  /**
+   * Buffer one built row for batched flushing (PRD-062c L-C1). Lazily creates the
+   * buffer on first use (a flag-off handler never allocates one). The per-item flush
+   * promise the buffer returns is observed fire-and-forget: a flush failure is logged
+   * here (never swallowed) but does NOT fail the captured turn — the row is committed
+   * to the in-memory window, which the buffer GUARANTEES to flush (window / size /
+   * shutdown). This is the documented trade: worst-case loss is one window on a hard
+   * crash (see {@link CaptureBuffer}); a graceful stop drains the buffer.
+   */
+  bufferRow(id, row, scope) {
+    const buffer = this.ensureBuffer();
+    void buffer.add({ row, scope }).catch((err) => {
+      this.deps.logger?.event("capture.flush.failed", {
+        id,
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+  /** Lazily build the capture write buffer from the resolved config + the flush callback. */
+  ensureBuffer() {
+    if (this.buffer === null) {
+      const cfg = { maxEvents: this.config.maxEvents, windowMs: this.config.windowMs };
+      this.buffer = this.deps.bufferClock !== void 0 ? new CaptureBuffer((batch) => this.flushBatch(batch), cfg, this.deps.bufferClock) : new CaptureBuffer((batch) => this.flushBatch(batch), cfg);
+    }
+    return this.buffer;
+  }
+  /**
+   * Flush a buffered batch as multi-row append(s) (PRD-062c L-C1 / AC-5). Rows that
+   * share a tenancy scope are grouped and written with ONE `appendOnlyInsertMany`, so N
+   * within-window same-scope events become ONE DeepLake write (AC-62c.1.1). Different
+   * scopes (the rare cross-tenant interleave within a window) each get their own append —
+   * a multi-row INSERT cannot span partitions. Every append threads the `capture-write`
+   * 062a meter source. A failed append rejects so the awaiter ({@link bufferRow}) logs it.
+   */
+  async flushBatch(batch) {
+    for (const [scope, rows] of groupRowsByScope(batch)) {
+      const result = await appendOnlyInsertMany(this.deps.storage, this.deps.sessionsTarget, scope, rows, {
+        source: CAPTURE_WRITE_SOURCE
+      });
+      if (!isOk(result)) {
+        this.deps.logger?.event("capture.batch_insert.failed", { count: rows.length, kind: result.kind });
+        throw new Error(`capture batch append failed: ${result.kind}`);
+      }
+    }
+  }
+  /**
+   * Force-flush + close the buffer on shutdown (PRD-062c AC-5 / AC-62c.1.2). Drains the
+   * remaining window so nothing buffered is lost on a clean stop. A no-op when batching is
+   * off (no buffer). Never throws — a flush failure on shutdown is logged, not surfaced.
+   */
+  async flush() {
+    if (this.buffer === null)
+      return;
+    try {
+      await this.buffer.close();
+    } catch (err) {
+      this.deps.logger?.event("capture.flush.failed", {
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
   /**
    * Build the single `sessions` row's ordered column values (FR-4 / FR-5).
    *
@@ -31205,7 +31502,7 @@ var CaptureRouteHandler = class {
    * org/workspace scope the partition.
    */
   buildRow(id, event, meta3, nowIso10, projectId) {
-    const message = JSON.stringify({ event, metadata: meta3 });
+    const message = this.config.envelopeBudgetBytes > 0 ? budgetedStringify(event, meta3, this.config.envelopeBudgetBytes) : JSON.stringify({ event, metadata: meta3 });
     return [
       ["id", val.str(id)],
       ["path", val.str(meta3.path)],
@@ -31365,6 +31662,21 @@ function embedTextFor(event) {
       return [event.tool, serialize(event.input), serialize(event.response)].filter((s) => s.length > 0).join("\n");
   }
 }
+function groupRowsByScope(batch) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of batch) {
+    const key = JSON.stringify([item.scope.org, item.scope.workspace ?? ""]);
+    const bucket = byKey.get(key);
+    if (bucket === void 0)
+      byKey.set(key, { scope: item.scope, rows: [item.row] });
+    else
+      bucket.rows.push(item.row);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const { scope, rows } of byKey.values())
+    out.set(scope, rows);
+  return out;
+}
 function serialize(value) {
   if (value === void 0 || value === null)
     return "";
@@ -31389,7 +31701,9 @@ function attachHooksHandlers(daemon, options) {
     ...options.enqueuePipelineEntry !== void 0 ? { enqueuePipelineEntry: options.enqueuePipelineEntry } : {},
     ...options.firstRunGate !== void 0 ? { firstRunGate: options.firstRunGate } : {},
     ...options.projectsDir !== void 0 ? { projectsDir: options.projectsDir } : {},
-    ...options.logger !== void 0 ? { logger: options.logger } : {}
+    ...options.logger !== void 0 ? { logger: options.logger } : {},
+    ...options.captureConfig !== void 0 ? { captureConfig: options.captureConfig } : {},
+    ...options.bufferClock !== void 0 ? { bufferClock: options.bufferClock } : {}
   });
   handler.register(daemon);
   const group = daemon.group(HOOKS_GROUP);
@@ -32426,9 +32740,9 @@ async function loadGrammar(language, tsx) {
   const base = GRAMMAR_WASM[language];
   const wasm = language === "typescript" && tsx ? "tree-sitter-tsx" : base;
   const key = wasm;
-  const cached2 = grammarCache.get(key);
-  if (cached2)
-    return cached2;
+  const cached3 = grammarCache.get(key);
+  if (cached3)
+    return cached3;
   const promise2 = (async () => {
     const Parser = await parserModule();
     return Parser.Language.load(`${grammarDir()}${wasm}.wasm`);
@@ -35401,13 +35715,13 @@ function mountDashboardApi(daemon, options) {
 }
 var INSTALLED_ASSETS_TTL_MS = 5e3;
 function createInventoryCache() {
-  let cached2;
+  let cached3;
   return async () => {
     const now = Date.now();
-    if (cached2 !== void 0 && now - cached2.at < INSTALLED_ASSETS_TTL_MS)
-      return cached2.value;
+    if (cached3 !== void 0 && now - cached3.at < INSTALLED_ASSETS_TTL_MS)
+      return cached3.value;
     const value = await scanInstalledAssets();
-    cached2 = { value, at: now };
+    cached3 = { value, at: now };
     return value;
   };
 }
@@ -36162,7 +36476,17 @@ var StorageConfigSchema = external_exports.object({
   /** Per-statement timeout, clamped non-negative. */
   queryTimeoutMs: QueryTimeoutMs.default(DEFAULT_QUERY_TIMEOUT_MS),
   /** SQL tracing gate (FR-6). Evaluated at call time, see client.ts. */
-  traceSql: external_exports.boolean().default(false)
+  traceSql: external_exports.boolean().default(false),
+  /**
+   * Query-meter persistence gate (PRD-062a). RESERVED, NOT YET IMPLEMENTED. The
+   * query meter's default posture is in-memory + structured-log only and adds
+   * ZERO DeepLake queries; persisting per-source counts to the existing
+   * `telemetry_counters` tenant group is a later, separate concern and would add
+   * write cost, so it is gated behind this flag. Today the flag is parsed and
+   * carried but nothing reads it for behavior — wiring persistence is out of
+   * scope for this sub-PRD (it must not make the meter itself a write-cost driver).
+   */
+  queryMeterPersist: external_exports.boolean().default(false)
 });
 var StorageConfigError = class extends Error {
   issues;
@@ -36181,7 +36505,8 @@ function envCredentialProvider(env = process.env) {
         org: env.HONEYCOMB_DEEPLAKE_ORG,
         workspace: env.HONEYCOMB_DEEPLAKE_WORKSPACE,
         queryTimeoutMs: env.HONEYCOMB_QUERY_TIMEOUT_MS,
-        traceSql: env.HONEYCOMB_TRACE_SQL === "1" || env.HONEYCOMB_TRACE_SQL === "true"
+        traceSql: env.HONEYCOMB_TRACE_SQL === "1" || env.HONEYCOMB_TRACE_SQL === "true",
+        queryMeterPersist: env.HONEYCOMB_QUERY_METER_PERSIST === "1" || env.HONEYCOMB_QUERY_METER_PERSIST === "true"
       };
     }
   };
@@ -36233,7 +36558,8 @@ function defaultCredentialProvider(options = {}) {
         orgName: fromFile.orgName,
         // Tuning knobs are env-only (the file carries none).
         queryTimeoutMs: fromEnv.queryTimeoutMs,
-        traceSql: fromEnv.traceSql
+        traceSql: fromEnv.traceSql,
+        queryMeterPersist: fromEnv.queryMeterPersist
       };
     }
   };
@@ -37583,12 +37909,12 @@ function mountSetupMigrate(daemon, options = {}) {
 // dist/src/daemon/runtime/pollinating/config.js
 var DEFAULT_TOKEN_THRESHOLD = 1e5;
 var DEFAULT_MAX_INPUT_TOKENS = 128e3;
-var BoolFlag = external_exports.preprocess((raw2) => {
+var BoolFlag2 = external_exports.preprocess((raw2) => {
   if (typeof raw2 === "boolean")
     return raw2;
   return raw2 === "true" || raw2 === "1";
 }, external_exports.boolean());
-function ClampedInt(def, min = 1) {
+function ClampedInt2(def, min = 1) {
   return external_exports.preprocess((raw2) => {
     const n = typeof raw2 === "number" ? raw2 : Number(raw2);
     if (!Number.isFinite(n))
@@ -37598,13 +37924,13 @@ function ClampedInt(def, min = 1) {
 }
 var PollinatingConfigSchema = external_exports.object({
   /** Master switch; off → counter still grows but no job is queued (FR-7 / a-AC-4). */
-  enabled: BoolFlag.default(false),
+  enabled: BoolFlag2.default(false),
   /** Tokens-since-last-pass that queues a pass; reset SUBTRACTS this (FR-3 / FR-5). */
-  tokenThreshold: ClampedInt(DEFAULT_TOKEN_THRESHOLD).default(DEFAULT_TOKEN_THRESHOLD),
+  tokenThreshold: ClampedInt2(DEFAULT_TOKEN_THRESHOLD).default(DEFAULT_TOKEN_THRESHOLD),
   /** Input-token budget a pass's payload must fit under (D-2 / 009c). */
-  maxInputTokens: ClampedInt(DEFAULT_MAX_INPUT_TOKENS).default(DEFAULT_MAX_INPUT_TOKENS),
+  maxInputTokens: ClampedInt2(DEFAULT_MAX_INPUT_TOKENS).default(DEFAULT_MAX_INPUT_TOKENS),
   /** First run with no prior pass enters compaction, not incremental (D-4 / c-AC-1). */
-  backfillOnFirstRun: BoolFlag.default(true)
+  backfillOnFirstRun: BoolFlag2.default(true)
 });
 var PollinatingConfigError = class extends Error {
   issues;
@@ -38632,7 +38958,7 @@ var DEFAULT_KEEP_LATEST_N = 5;
 var DEFAULT_WINDOW_DAYS = 30;
 var DEFAULT_TIMESTAMP_COLUMN = "updated_at";
 var DEFAULT_VERSION_COLUMN = "version";
-function ClampedInt2(def, min) {
+function ClampedInt3(def, min) {
   return external_exports.preprocess((raw2) => {
     const n = typeof raw2 === "number" ? raw2 : Number(raw2);
     if (!Number.isFinite(n))
@@ -38649,9 +38975,9 @@ function IdentColumn(def) {
 }
 var CompactionRetentionSchema = external_exports.object({
   /** Keep the most-recent N versions below the highest (D-1). Clamp `>= 1`. */
-  keepLatestN: ClampedInt2(DEFAULT_KEEP_LATEST_N, 1).default(DEFAULT_KEEP_LATEST_N),
+  keepLatestN: ClampedInt3(DEFAULT_KEEP_LATEST_N, 1).default(DEFAULT_KEEP_LATEST_N),
   /** Keep any version newer than now − windowDays (D-1). Clamp `>= 0` (0 = off). */
-  windowDays: ClampedInt2(DEFAULT_WINDOW_DAYS, 0).default(DEFAULT_WINDOW_DAYS),
+  windowDays: ClampedInt3(DEFAULT_WINDOW_DAYS, 0).default(DEFAULT_WINDOW_DAYS),
   /** The timestamp column the window is measured on. Default `updated_at`. */
   timestampColumn: IdentColumn(DEFAULT_TIMESTAMP_COLUMN).default(DEFAULT_TIMESTAMP_COLUMN),
   /** The version column. Default `version` (mirrors `appendVersionBumped`). */
@@ -40382,12 +40708,12 @@ var DEFAULT_REHEARSAL_BOOST = 1.1;
 var DEFAULT_REHEARSAL_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_MIN_INJECTION_SCORE = 0.6;
 var RERANKER_STRATEGIES = Object.freeze(["embedding-cosine", "llm", "none"]);
-var BoolFlag2 = external_exports.preprocess((raw2) => {
+var BoolFlag3 = external_exports.preprocess((raw2) => {
   if (typeof raw2 === "boolean")
     return raw2;
   return raw2 === "true" || raw2 === "1";
 }, external_exports.boolean());
-function ClampedInt3(def, min = 0) {
+function ClampedInt4(def, min = 0) {
   return external_exports.preprocess((raw2) => {
     const n = typeof raw2 === "number" ? raw2 : Number(raw2);
     if (!Number.isFinite(n))
@@ -40423,29 +40749,29 @@ function OptionalClampedHalfLifeDays(min) {
 }
 var TraversalConfigSchema = external_exports.object({
   /** Max aspects per focal entity. */
-  aspectsPerEntity: ClampedInt3(DEFAULT_TRAVERSAL_ASPECTS_PER_ENTITY, 1).default(DEFAULT_TRAVERSAL_ASPECTS_PER_ENTITY),
+  aspectsPerEntity: ClampedInt4(DEFAULT_TRAVERSAL_ASPECTS_PER_ENTITY, 1).default(DEFAULT_TRAVERSAL_ASPECTS_PER_ENTITY),
   /** Max attributes per aspect. */
-  attrsPerAspect: ClampedInt3(DEFAULT_TRAVERSAL_ATTRS_PER_ASPECT, 1).default(DEFAULT_TRAVERSAL_ATTRS_PER_ASPECT),
+  attrsPerAspect: ClampedInt4(DEFAULT_TRAVERSAL_ATTRS_PER_ASPECT, 1).default(DEFAULT_TRAVERSAL_ATTRS_PER_ASPECT),
   /** Max branching factor per node. */
-  branching: ClampedInt3(DEFAULT_TRAVERSAL_BRANCHING, 1).default(DEFAULT_TRAVERSAL_BRANCHING),
+  branching: ClampedInt4(DEFAULT_TRAVERSAL_BRANCHING, 1).default(DEFAULT_TRAVERSAL_BRANCHING),
   /** Hard cap on total IDs the walk may collect. */
-  totalIds: ClampedInt3(DEFAULT_TRAVERSAL_TOTAL_IDS, 1).default(DEFAULT_TRAVERSAL_TOTAL_IDS),
+  totalIds: ClampedInt4(DEFAULT_TRAVERSAL_TOTAL_IDS, 1).default(DEFAULT_TRAVERSAL_TOTAL_IDS),
   /** Minimum edge strength×confidence to follow an edge. */
   minEdgeWeight: ClampedFloat(DEFAULT_TRAVERSAL_MIN_EDGE_WEIGHT).default(DEFAULT_TRAVERSAL_MIN_EDGE_WEIGHT),
   /** Hard traversal timeout in ms. */
-  timeoutMs: ClampedInt3(DEFAULT_TRAVERSAL_TIMEOUT_MS, 1).default(DEFAULT_TRAVERSAL_TIMEOUT_MS)
+  timeoutMs: ClampedInt4(DEFAULT_TRAVERSAL_TIMEOUT_MS, 1).default(DEFAULT_TRAVERSAL_TIMEOUT_MS)
 });
 var RerankerConfigSchema = external_exports.object({
   /** The reranker strategy (D-4). */
   strategy: external_exports.enum(RERANKER_STRATEGIES).default(DEFAULT_RERANKER),
   /** Reranker timeout in ms; on timeout keep the original order (d-AC-2 / b-AC-2). */
-  timeoutMs: ClampedInt3(DEFAULT_RERANKER_TIMEOUT_MS, 1).default(DEFAULT_RERANKER_TIMEOUT_MS),
+  timeoutMs: ClampedInt4(DEFAULT_RERANKER_TIMEOUT_MS, 1).default(DEFAULT_RERANKER_TIMEOUT_MS),
   /** Rerank window N: how many fused top-N candidates to re-score (PRD-047b). */
-  window: ClampedInt3(DEFAULT_RERANKER_WINDOW, 1).default(DEFAULT_RERANKER_WINDOW)
+  window: ClampedInt4(DEFAULT_RERANKER_WINDOW, 1).default(DEFAULT_RERANKER_WINDOW)
 });
 var DedupConfigSchema = external_exports.object({
   /** Whether semantic near-duplicate dedup runs; ON by default (PRD-047c / c-AC-3). */
-  enabled: BoolFlag2.default(DEFAULT_DEDUP_ENABLED),
+  enabled: BoolFlag3.default(DEFAULT_DEDUP_ENABLED),
   /** The cosine-similarity collapse threshold in `[0,1]` (PRD-047c / c-AC-1). */
   similarityThreshold: ClampedFloat(DEFAULT_DEDUP_SIMILARITY_THRESHOLD).default(DEFAULT_DEDUP_SIMILARITY_THRESHOLD)
 });
@@ -40484,21 +40810,21 @@ var DampeningConfigSchema = external_exports.object({
   /** Bounded rehearsal boost for a recently-accessed memory. Ceiling 4. */
   rehearsalBoost: ClampedFloat(DEFAULT_REHEARSAL_BOOST, 4).default(DEFAULT_REHEARSAL_BOOST),
   /** "Recent" window for the rehearsal boost in ms (7d). */
-  rehearsalWindowMs: ClampedInt3(DEFAULT_REHEARSAL_WINDOW_MS, 1).default(DEFAULT_REHEARSAL_WINDOW_MS)
+  rehearsalWindowMs: ClampedInt4(DEFAULT_REHEARSAL_WINDOW_MS, 1).default(DEFAULT_REHEARSAL_WINDOW_MS)
 });
 var RecallConfigSchema = external_exports.object({
   /** Over-fetch multiplier for scoped vector recalls (D-1 / a-AC-2 / FR-5). */
-  overFetchMultiplier: ClampedInt3(DEFAULT_OVER_FETCH_MULTIPLIER, 1).default(DEFAULT_OVER_FETCH_MULTIPLIER),
+  overFetchMultiplier: ClampedInt4(DEFAULT_OVER_FETCH_MULTIPLIER, 1).default(DEFAULT_OVER_FETCH_MULTIPLIER),
   /** Base per-channel candidate limit (FTS/vector base, pre over-fetch). */
-  channelLimit: ClampedInt3(DEFAULT_CHANNEL_LIMIT, 1).default(DEFAULT_CHANNEL_LIMIT),
+  channelLimit: ClampedInt4(DEFAULT_CHANNEL_LIMIT, 1).default(DEFAULT_CHANNEL_LIMIT),
   /** Hint cap so a memory can't ride in on hints alone (D-2 / a-AC-4 / FR-7). */
-  hintCap: ClampedInt3(DEFAULT_HINT_CAP, 0).default(DEFAULT_HINT_CAP),
+  hintCap: ClampedInt4(DEFAULT_HINT_CAP, 0).default(DEFAULT_HINT_CAP),
   /** Keyword expansion for the LEXICAL path only; OFF by default (D-2 / FR-2). */
-  keywordExpansion: BoolFlag2.default(false),
+  keywordExpansion: BoolFlag3.default(false),
   /** Minimum calibrated injection score (D-6 / e-AC-1); per-agent tunable. */
   minInjectionScore: ClampedFloat(DEFAULT_MIN_INJECTION_SCORE).default(DEFAULT_MIN_INJECTION_SCORE),
   /** Master graph switch for the traversal channel/phase (007b). */
-  graphEnabled: BoolFlag2.default(false),
+  graphEnabled: BoolFlag3.default(false),
   /** D-3 traversal budgets (007b). */
   traversal: TraversalConfigSchema.default(() => TraversalConfigSchema.parse({})),
   /** D-4 reranker config (007d). */
@@ -40581,6 +40907,129 @@ function resolveRecallConfig(provider = envRecallConfigProvider()) {
   return parsed.data;
 }
 
+// dist/src/daemon/runtime/memories/bounded-pool.js
+var Semaphore = class {
+  /** The maximum permits (in-flight tasks) allowed at once. Always `>= 1`. */
+  max;
+  /** Permits currently held (tasks running). Never exceeds {@link max}. */
+  held = 0;
+  /** FIFO queue of waiters parked because all permits were held at acquire time. */
+  waiters = [];
+  constructor(max) {
+    this.max = Number.isFinite(max) && max >= 1 ? Math.trunc(max) : 1;
+  }
+  /** Permits currently held (the live in-flight count). Test-observable for the cap assertion. */
+  get inFlight() {
+    return this.held;
+  }
+  /** Number of tasks parked waiting for a permit (test-observable). */
+  get waiting() {
+    return this.waiters.length;
+  }
+  /**
+   * Acquire one permit. Resolves immediately when a permit is free; otherwise parks
+   * FIFO and resolves when {@link release} hands a permit forward. Each acquire MUST
+   * be paired with exactly one {@link release} (use {@link run} to guarantee it).
+   */
+  acquire() {
+    if (this.held < this.max) {
+      this.held += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve6) => {
+      this.waiters.push(() => {
+        this.held += 1;
+        resolve6();
+      });
+    });
+  }
+  /**
+   * Release one permit. If a waiter is parked, hand the permit STRAIGHT to it (the
+   * held count stays balanced — the waiter's resolver re-increments), otherwise drop
+   * the held count. Releasing with no permit held is a no-op (defensive — a double
+   * release never drives the count negative).
+   */
+  release() {
+    const next = this.waiters.shift();
+    if (next !== void 0) {
+      this.held -= 1;
+      next();
+      return;
+    }
+    if (this.held > 0)
+      this.held -= 1;
+  }
+  /**
+   * Run `fn` under one permit: acquire, run, and ALWAYS release (even when `fn`
+   * throws/rejects), then re-throw the original error. The safe wrapper — a task
+   * that throws never leaks a permit and wedges the pool.
+   */
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+
+// dist/src/daemon/runtime/memories/amplification-config.js
+var DEFAULT_FANOUT_BATCH = true;
+var DEFAULT_RECALL_MAX_CONCURRENCY = 6;
+var MIN_RECALL_MAX_CONCURRENCY = 1;
+var OnByDefaultFlag = external_exports.preprocess((raw2) => {
+  if (typeof raw2 === "boolean")
+    return raw2;
+  if (raw2 === void 0 || raw2 === null || raw2 === "")
+    return true;
+  return !(raw2 === "false" || raw2 === "0");
+}, external_exports.boolean());
+var ConcurrencyKnob = external_exports.preprocess((raw2) => {
+  const n = typeof raw2 === "number" ? raw2 : Number(raw2);
+  if (!Number.isFinite(n))
+    return DEFAULT_RECALL_MAX_CONCURRENCY;
+  return Math.max(MIN_RECALL_MAX_CONCURRENCY, Math.trunc(n));
+}, external_exports.number().int());
+var AmplificationConfigSchema = external_exports.object({
+  /** `HONEYCOMB_FANOUT_BATCH` — batched fan-out enqueue; ON by default (AC-62d.1.1 / AC-9). */
+  fanoutBatch: OnByDefaultFlag.default(DEFAULT_FANOUT_BATCH),
+  /** `HONEYCOMB_RECALL_MAX_CONCURRENCY` — in-flight DeepLake-query ceiling; 6 by default (AC-62d.2.1). */
+  recallMaxConcurrency: ConcurrencyKnob.default(DEFAULT_RECALL_MAX_CONCURRENCY)
+});
+var AmplificationConfigError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`Invalid amplification config: ${issues.join("; ")}`);
+    this.name = "AmplificationConfigError";
+    this.issues = issues;
+  }
+};
+function envAmplificationConfigProvider(env = process.env) {
+  return {
+    read() {
+      return {
+        fanoutBatch: env.HONEYCOMB_FANOUT_BATCH,
+        recallMaxConcurrency: env.HONEYCOMB_RECALL_MAX_CONCURRENCY
+      };
+    }
+  };
+}
+function resolveAmplificationConfig(provider = envAmplificationConfigProvider()) {
+  const parsed = AmplificationConfigSchema.safeParse(provider.read());
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);
+    throw new AmplificationConfigError(issues);
+  }
+  return parsed.data;
+}
+var cached2;
+function amplificationConfig() {
+  if (cached2 === void 0)
+    cached2 = resolveAmplificationConfig();
+  return cached2;
+}
+
 // dist/src/daemon/runtime/memories/activation.js
 var DEFAULT_ACTR_DECAY = 0.5;
 var DEFAULT_ACTR_A_MIN = 0.05;
@@ -40695,6 +41144,15 @@ function deserializeModel(blob) {
 }
 
 // dist/src/daemon/runtime/memories/recall.js
+var SOURCE_RECALL_ARM = "recall-arm";
+var sharedRecallPool;
+function resolveRecallPool(deps) {
+  if (deps.recallPool !== void 0)
+    return deps.recallPool;
+  if (sharedRecallPool === void 0)
+    sharedRecallPool = new Semaphore(amplificationConfig().recallMaxConcurrency);
+  return sharedRecallPool;
+}
 var DEFAULT_RECALL_LIMIT = 20;
 var MAX_RECALL_LIMIT = 200;
 var RRF_K = 60;
@@ -40826,7 +41284,8 @@ function projectConjunctFor(request) {
   });
 }
 async function runArm(sql, request, deps) {
-  const result = await deps.storage.query(sql, request.scope);
+  const pool = resolveRecallPool(deps);
+  const result = await pool.run(() => deps.storage.query(sql, request.scope, { source: SOURCE_RECALL_ARM }));
   return isOk(result) ? result.rows : [];
 }
 var SEMANTIC_ARMS = [
@@ -40866,7 +41325,8 @@ async function runSemanticArm(spec, queryVector, request, deps, limit) {
   const projectClause = projectConjunctFor(request);
   let scored;
   try {
-    const recall = await vectorSearch(deps.storage, request.scope, {
+    const pool = resolveRecallPool(deps);
+    const recall = await pool.run(() => vectorSearch(deps.storage, request.scope, {
       table: spec.table,
       idColumn: spec.idColumn,
       embeddingColumn: spec.embeddingColumn,
@@ -40874,7 +41334,7 @@ async function runSemanticArm(spec, queryVector, request, deps, limit) {
       scope: {},
       limit,
       ...projectClause !== "" ? { extraClause: projectClause } : {}
-    });
+    }));
     scored = recall.ids;
   } catch {
     return [];
@@ -41911,12 +42371,12 @@ var DEFAULT_DEAD_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var DEFAULT_HISTORY_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
 var DEFAULT_TOMBSTONE_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var EXTRACTION_PROVIDER_NONE = "none";
-var BoolFlag3 = external_exports.preprocess((raw2) => {
+var BoolFlag4 = external_exports.preprocess((raw2) => {
   if (typeof raw2 === "boolean")
     return raw2;
   return raw2 === "true" || raw2 === "1";
 }, external_exports.boolean());
-function ClampedInt4(def, min = 1) {
+function ClampedInt5(def, min = 1) {
   return external_exports.preprocess((raw2) => {
     const n = typeof raw2 === "number" ? raw2 : Number(raw2);
     if (!Number.isFinite(n))
@@ -41932,49 +42392,49 @@ var Confidence = external_exports.preprocess((raw2) => {
 }, external_exports.number());
 var AutonomousConfigSchema = external_exports.object({
   /** Master switch for retention/autonomous mutation; off → retention does not run (006e e-AC-4). */
-  enabled: BoolFlag3.default(false),
+  enabled: BoolFlag4.default(false),
   /** Halt switch: set → no further purges even when enabled (006e e-AC-5). */
-  frozen: BoolFlag3.default(false),
+  frozen: BoolFlag4.default(false),
   /** Gate for UPDATE/DELETE proposals being applied (006c c-AC-3 / D-7). */
-  allowUpdateDelete: BoolFlag3.default(false)
+  allowUpdateDelete: BoolFlag4.default(false)
 });
 var GraphConfigSchema = external_exports.object({
   /** Master graph switch; off → no graph rows written (006d d-AC-4). */
-  enabled: BoolFlag3.default(false),
+  enabled: BoolFlag4.default(false),
   /** Whether extraction-derived triples are persisted to the graph (006d d-AC-4). */
-  extractionWritesEnabled: BoolFlag3.default(false)
+  extractionWritesEnabled: BoolFlag4.default(false)
 });
 var ExtractionConfigSchema = external_exports.object({
   /** Input char cap before the model call (a-AC-2 / FR-6). */
-  inputCharCap: ClampedInt4(DEFAULT_INPUT_CHAR_CAP).default(DEFAULT_INPUT_CHAR_CAP),
+  inputCharCap: ClampedInt5(DEFAULT_INPUT_CHAR_CAP).default(DEFAULT_INPUT_CHAR_CAP),
   /** Max facts kept (a-AC-3 / FR-7). */
-  maxFacts: ClampedInt4(DEFAULT_MAX_FACTS).default(DEFAULT_MAX_FACTS),
+  maxFacts: ClampedInt5(DEFAULT_MAX_FACTS).default(DEFAULT_MAX_FACTS),
   /** Max entity triples kept (a-AC-3 / FR-7). */
-  maxEntities: ClampedInt4(DEFAULT_MAX_ENTITIES).default(DEFAULT_MAX_ENTITIES),
+  maxEntities: ClampedInt5(DEFAULT_MAX_ENTITIES).default(DEFAULT_MAX_ENTITIES),
   /** Per-fact content length cap (a-AC-3 / FR-7). */
-  maxFactChars: ClampedInt4(DEFAULT_MAX_FACT_CHARS).default(DEFAULT_MAX_FACT_CHARS)
+  maxFactChars: ClampedInt5(DEFAULT_MAX_FACT_CHARS).default(DEFAULT_MAX_FACT_CHARS)
 });
 var RetentionConfigSchema = external_exports.object({
   /** Per-run row batch cap (e-AC-1 / e-AC-6). */
-  batchLimit: ClampedInt4(DEFAULT_RETENTION_BATCH_LIMIT).default(DEFAULT_RETENTION_BATCH_LIMIT),
+  batchLimit: ClampedInt5(DEFAULT_RETENTION_BATCH_LIMIT).default(DEFAULT_RETENTION_BATCH_LIMIT),
   /** Completed-jobs window in ms. */
-  completedJobMs: ClampedInt4(DEFAULT_COMPLETED_JOB_RETENTION_MS).default(DEFAULT_COMPLETED_JOB_RETENTION_MS),
+  completedJobMs: ClampedInt5(DEFAULT_COMPLETED_JOB_RETENTION_MS).default(DEFAULT_COMPLETED_JOB_RETENTION_MS),
   /** Dead-jobs window in ms. */
-  deadJobMs: ClampedInt4(DEFAULT_DEAD_JOB_RETENTION_MS).default(DEFAULT_DEAD_JOB_RETENTION_MS),
+  deadJobMs: ClampedInt5(DEFAULT_DEAD_JOB_RETENTION_MS).default(DEFAULT_DEAD_JOB_RETENTION_MS),
   /** History window in ms. */
-  historyMs: ClampedInt4(DEFAULT_HISTORY_RETENTION_MS).default(DEFAULT_HISTORY_RETENTION_MS),
+  historyMs: ClampedInt5(DEFAULT_HISTORY_RETENTION_MS).default(DEFAULT_HISTORY_RETENTION_MS),
   /** Tombstone window in ms. */
-  tombstoneMs: ClampedInt4(DEFAULT_TOMBSTONE_RETENTION_MS).default(DEFAULT_TOMBSTONE_RETENTION_MS)
+  tombstoneMs: ClampedInt5(DEFAULT_TOMBSTONE_RETENTION_MS).default(DEFAULT_TOMBSTONE_RETENTION_MS)
 });
 var PipelineConfigSchema = external_exports.object({
   /** Master switch; off → no stage runs (a-AC-5 / FR-9). */
-  enabled: BoolFlag3.default(false),
+  enabled: BoolFlag4.default(false),
   /** Router-selection token; `'none'` disables extraction (a-AC-5 / FR-9). */
   extractionProvider: external_exports.string().trim().min(1).default(EXTRACTION_PROVIDER_NONE),
   /** Shadow mode: proposals logged, no memory written (006c c-AC-4). */
-  shadowMode: BoolFlag3.default(false),
+  shadowMode: BoolFlag4.default(false),
   /** Frozen: nothing written even if shadow off; supersedes shadow (006c c-AC-5). */
-  mutationsFrozen: BoolFlag3.default(false),
+  mutationsFrozen: BoolFlag4.default(false),
   /** ADD confidence gate (D-1 / 006c c-AC-1). */
   minFactConfidenceForWrite: Confidence.default(DEFAULT_MIN_FACT_CONFIDENCE),
   /** Autonomous brakes (retention + UPDATE/DELETE). */
@@ -42125,6 +42585,7 @@ function normalizeProposalKeys(candidate) {
 // dist/src/daemon/runtime/pipeline/controlled-writes.js
 var silentLogger4 = { event() {
 } };
+var CONTROLLED_WRITE_BATCH_KEY = "proposals";
 var MEMORIES_VERSION_COLUMN = Object.freeze({
   name: "version",
   sql: "BIGINT NOT NULL DEFAULT 1"
@@ -42474,33 +42935,66 @@ var noopControlledWriteHandler = async (_job) => {
 function createControlledWriteHandler(deps) {
   if (deps === void 0)
     return noopControlledWriteHandler;
+  const handlerDeps = deps;
   const logger = deps.logger ?? silentLogger4;
   return async (job) => {
-    const parsed = readControlledWriteInput(job.payload);
-    if (parsed === null) {
-      logger.event("controlled_write.unparseable_payload", { id: job.id });
+    const batch = readBatchPayloads(job.payload);
+    if (batch !== null) {
+      for (const factPayload of batch) {
+        const merged = { ...envelopeOf(job.payload), ...factPayload };
+        const factJob = { ...job, payload: merged };
+        await applyOneControlledWrite(factJob, handlerDeps, logger);
+      }
       return;
     }
-    const input = {
-      ...parsed,
-      agentId: parsed.agentId ?? job.scope.agentId
-    };
-    const scope = { org: job.scope.org, workspace: job.scope.workspace };
-    const outcome = await applyControlledWrite(input, scope, deps);
-    if (deps.onOutcome) {
-      try {
-        await deps.onOutcome(job, outcome);
-      } catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        logger.event("controlled_write.fan_out_failed", {
-          id: job.id,
-          action: outcome.action,
-          memoryId: outcome.memoryId,
-          reason
-        });
-      }
+    await applyOneControlledWrite(job, handlerDeps, logger);
+  };
+}
+function envelopeOf(payload) {
+  const out = {};
+  for (const key of ["org", "workspace", "agent_id", "project_id"]) {
+    if (typeof payload[key] === "string")
+      out[key] = payload[key];
+  }
+  return out;
+}
+function readBatchPayloads(payload) {
+  const raw2 = payload[CONTROLLED_WRITE_BATCH_KEY];
+  if (!Array.isArray(raw2) || raw2.length === 0)
+    return null;
+  const out = [];
+  for (const item of raw2) {
+    if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+      out.push(item);
     }
+  }
+  return out.length > 0 ? out : null;
+}
+async function applyOneControlledWrite(job, deps, logger) {
+  const parsed = readControlledWriteInput(job.payload);
+  if (parsed === null) {
+    logger.event("controlled_write.unparseable_payload", { id: job.id });
+    return;
+  }
+  const input = {
+    ...parsed,
+    agentId: parsed.agentId ?? job.scope.agentId
   };
+  const scope = { org: job.scope.org, workspace: job.scope.workspace };
+  const outcome = await applyControlledWrite(input, scope, deps);
+  if (deps.onOutcome) {
+    try {
+      await deps.onOutcome(job, outcome);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.event("controlled_write.fan_out_failed", {
+        id: job.id,
+        action: outcome.action,
+        memoryId: outcome.memoryId,
+        reason
+      });
+    }
+  }
 }
 
 // dist/src/daemon/runtime/memories/store.js
@@ -43609,7 +44103,7 @@ var DEFAULT_OPEN_CONFLICT_SUPPRESSION = DEFAULT_RHO;
 var DEFAULT_CONFLICT_AUTO_RESOLVE = false;
 var STALE_REF_POSTURES = Object.freeze(["observe", "execute"]);
 var DEFAULT_STALE_REF_POSTURE = "observe";
-var BoolFlag4 = external_exports.preprocess((raw2) => {
+var BoolFlag5 = external_exports.preprocess((raw2) => {
   if (typeof raw2 === "boolean")
     return raw2;
   return raw2 === "true" || raw2 === "1";
@@ -43664,7 +44158,7 @@ var LifecycleConfigSchema = external_exports.object({
   /** Open-conflict suppression `ρ` (058b); `0` default (fully suppress, reversible), clamped into `[0,1]`. */
   openConflictSuppression: ClampedFloat2(DEFAULT_OPEN_CONFLICT_SUPPRESSION, 1).default(DEFAULT_OPEN_CONFLICT_SUPPRESSION),
   /** Conflict auto-resolve (058b); OFF by default (detect + queue only, human-in-the-loop). */
-  conflictAutoResolve: BoolFlag4.default(DEFAULT_CONFLICT_AUTO_RESOLVE),
+  conflictAutoResolve: BoolFlag5.default(DEFAULT_CONFLICT_AUTO_RESOLVE),
   /** Stale-ref posture (058c); `observe` by default (`s = 0`, inert). */
   staleRefPosture: PostureFlag.default(DEFAULT_STALE_REF_POSTURE)
 });
@@ -46179,8 +46673,8 @@ function realDiscordProvider(cfg, transport) {
     }
   }
   async function* indexDesktopCache() {
-    const cached2 = await transport.readDesktopCache();
-    for (const m of cached2) {
+    const cached3 = await transport.readDesktopCache();
+    for (const m of cached3) {
       yield messageArtifact(cfg, m);
     }
   }
@@ -48972,6 +49466,216 @@ async function buildInferenceModelClient(deps) {
   return new RouterModelClient(router);
 }
 
+// dist/src/daemon/runtime/services/poll-backoff.js
+var DEFAULT_POLL_BACKOFF_FLOOR_MS = 1e3;
+var DEFAULT_POLL_BACKOFF_CEILING_MS = 3e4;
+var DEFAULT_POLL_BACKOFF_JITTER = 0.1;
+var BoolFlag6 = external_exports.preprocess((raw2) => {
+  if (typeof raw2 === "boolean")
+    return raw2;
+  return raw2 === "true" || raw2 === "1";
+}, external_exports.boolean());
+function ClampedInt6(def, min = 1) {
+  return external_exports.preprocess((raw2) => {
+    const n = typeof raw2 === "number" ? raw2 : Number(raw2);
+    if (!Number.isFinite(n))
+      return def;
+    return Math.max(min, Math.trunc(n));
+  }, external_exports.number().int());
+}
+function ClampedFraction(def) {
+  return external_exports.preprocess((raw2) => {
+    const n = typeof raw2 === "number" ? raw2 : Number(raw2);
+    if (!Number.isFinite(n))
+      return def;
+    return Math.min(1, Math.max(0, n));
+  }, external_exports.number());
+}
+var PollBackoffConfigSchema = external_exports.object({
+  /** Master switch; off → flat `floorMs`, the exact pre-PRD cadence (AC-9). */
+  enabled: BoolFlag6.default(false),
+  /** Fast floor the backoff starts at and resets to on any lease (AC-3). */
+  floorMs: ClampedInt6(DEFAULT_POLL_BACKOFF_FLOOR_MS).default(DEFAULT_POLL_BACKOFF_FLOOR_MS),
+  /** Ceiling the backoff doubles toward while the queue stays empty (AC-2). */
+  ceilingMs: ClampedInt6(DEFAULT_POLL_BACKOFF_CEILING_MS).default(DEFAULT_POLL_BACKOFF_CEILING_MS),
+  /** +/- jitter fraction of the current step, anti-thundering-herd. */
+  jitter: ClampedFraction(DEFAULT_POLL_BACKOFF_JITTER).default(DEFAULT_POLL_BACKOFF_JITTER)
+});
+var PollBackoffConfigError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`Invalid poll-backoff config: ${issues.join("; ")}`);
+    this.name = "PollBackoffConfigError";
+    this.issues = issues;
+  }
+};
+function envPollBackoffConfigProvider(env = process.env) {
+  return {
+    read() {
+      const raw2 = env.HONEYCOMB_POLL_BACKOFF_ENABLED;
+      const enabled = raw2 === void 0 ? true : raw2;
+      return {
+        enabled,
+        floorMs: env.HONEYCOMB_POLL_BACKOFF_FLOOR_MS,
+        ceilingMs: env.HONEYCOMB_POLL_BACKOFF_CEILING_MS,
+        jitter: env.HONEYCOMB_POLL_BACKOFF_JITTER
+      };
+    }
+  };
+}
+function resolvePollBackoffConfig(provider = envPollBackoffConfigProvider()) {
+  const parsed = PollBackoffConfigSchema.safeParse(provider.read());
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);
+    throw new PollBackoffConfigError(issues);
+  }
+  const cfg = parsed.data;
+  return cfg.ceilingMs < cfg.floorMs ? { ...cfg, ceilingMs: cfg.floorMs } : cfg;
+}
+var defaultJitterSource = () => Math.random() * 2 - 1;
+var PollBackoff = class {
+  floorMs;
+  ceilingMs;
+  jitter;
+  jitterSource;
+  /** The current un-jittered step. Starts at the floor; doubles toward the ceiling. */
+  stepMs;
+  /**
+   * @param config the resolved bounds + jitter fraction. The state machine is only
+   *   ever CONSTRUCTED when backoff is active; a loop with `config.enabled === false`
+   *   does not build one (it keeps its flat legacy interval), so this class need not
+   *   re-check the flag.
+   * @param jitterSource injectable `[-1, 1]` source — a test pins it to 0 to assert
+   *   the exact geometric schedule; production uses the uniform random default.
+   */
+  constructor(config2, jitterSource = defaultJitterSource) {
+    this.floorMs = config2.floorMs;
+    this.ceilingMs = Math.max(config2.floorMs, config2.ceilingMs);
+    this.jitter = config2.jitter;
+    this.jitterSource = jitterSource;
+    this.stepMs = this.floorMs;
+  }
+  /**
+   * Step the delay toward the ceiling after an EMPTY lease (no job this tick):
+   * double the current step, capped at the ceiling. Idempotent at the ceiling (a
+   * fully-idle daemon stays there until a job arrives).
+   */
+  onEmptyLease() {
+    this.stepMs = Math.min(this.stepMs * 2, this.ceilingMs);
+  }
+  /**
+   * Reset the delay to the floor after a SUCCESSFUL lease (AC-3): the first real
+   * job snaps the cadence back to fast so an active session is unchanged.
+   */
+  onLease() {
+    this.stepMs = this.floorMs;
+  }
+  /** The current un-jittered step (for assertions on the geometric schedule). */
+  currentStepMs() {
+    return this.stepMs;
+  }
+  /**
+   * The ms to wait before the next tick: the current step plus a bounded jitter.
+   * The jitter is a fraction of the step (`jitter * step`), so it scales with the
+   * step; the result is clamped to `[floorMs, ceilingMs]` so jitter never pushes
+   * the cadence below the fast floor (which would defeat the cost cut) or above the
+   * ceiling (which would blow the worst-case pickup-latency budget).
+   */
+  nextDelayMs() {
+    const offset = this.jitterSource() * this.jitter * this.stepMs;
+    const delayed = this.stepMs + offset;
+    return Math.min(this.ceilingMs, Math.max(this.floorMs, Math.round(delayed)));
+  }
+};
+
+// dist/src/daemon/runtime/services/poll-loop.js
+var AdaptivePollLoop = class {
+  tick;
+  backoffEnabled;
+  flatIntervalMs;
+  timers;
+  backoff;
+  handle;
+  stopped = false;
+  /** Guards against overlapping ticks on the poll loop (the workers' `running` flag). */
+  running = false;
+  constructor(deps) {
+    this.tick = deps.tick;
+    this.backoffEnabled = deps.backoff.enabled;
+    this.flatIntervalMs = deps.flatIntervalMs;
+    this.timers = deps.timers;
+    this.backoff = deps.backoff.enabled ? new PollBackoff(deps.backoff) : null;
+  }
+  start() {
+    this.stopped = false;
+    if (this.backoff === null) {
+      this.handle = this.timers.setTimer(() => {
+        this.fireGuarded(null);
+      }, this.flatIntervalMs);
+      return;
+    }
+    this.scheduleNext(this.backoff.nextDelayMs());
+  }
+  /** Arm the next one-shot tick (adaptive path only). */
+  scheduleNext(ms) {
+    if (this.stopped)
+      return;
+    this.handle = this.timers.setTimer(() => {
+      this.fireGuarded(this.backoff);
+    }, ms);
+  }
+  /**
+   * One guarded tick. Skips if a previous run is still in flight (never overlap).
+   * On the adaptive path, feeds the lease outcome to the state machine and re-arms
+   * the next tick; on the flat path, the repeating interval re-fires on its own.
+   */
+  fireGuarded(backoff) {
+    if (this.running)
+      return;
+    this.running = true;
+    void this.tick().then((processed) => {
+      if (backoff === null)
+        return;
+      if (processed)
+        backoff.onLease();
+      else
+        backoff.onEmptyLease();
+    }).finally(() => {
+      this.running = false;
+      if (backoff !== null)
+        this.scheduleNext(backoff.nextDelayMs());
+    });
+  }
+  stop() {
+    this.stopped = true;
+    if (this.handle !== void 0) {
+      this.timers.clearTimer(this.handle);
+      this.handle = void 0;
+    }
+  }
+};
+function createPollLoop(deps) {
+  return new AdaptivePollLoop(deps);
+}
+function buildWorkerPollLoop(options) {
+  const setTimer = options.setTimer ?? ((cb, ms) => {
+    const t = setInterval(cb, ms);
+    if (typeof t === "object" && t !== null && "unref" in t && typeof t.unref === "function")
+      t.unref();
+    return t;
+  });
+  const clearTimer = options.clearTimer ?? ((handle) => {
+    if (handle !== void 0)
+      clearInterval(handle);
+  });
+  return createPollLoop({
+    tick: options.tick,
+    backoff: options.backoff ?? PollBackoffConfigSchema.parse({}),
+    flatIntervalMs: options.flatIntervalMs,
+    timers: { setTimer, clearTimer }
+  });
+}
+
 // dist/src/daemon/runtime/pipeline/stage-worker.js
 var PIPELINE_JOB_KINDS = Object.freeze([
   "memory_extraction",
@@ -48999,33 +49703,42 @@ var PipelineStageWorker = class {
   queue;
   handlers;
   logger;
+  /** Public for the lease coordinator's union (the kinds this participant owns). */
   leaseKinds;
-  pollIntervalMs;
-  setTimer;
-  clearTimer;
-  handle;
-  /** Guards against overlapping `runOnce` invocations on the poll loop. */
-  running = false;
+  loop;
   constructor(deps) {
     this.queue = deps.queue;
     this.handlers = deps.handlers;
     this.logger = deps.logger;
     this.leaseKinds = deps.leaseKinds ?? PIPELINE_JOB_KINDS;
-    this.pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
-    this.setTimer = deps.setTimer ?? ((cb, ms) => setInterval(cb, ms));
-    this.clearTimer = deps.clearTimer ?? ((handle) => {
-      if (handle !== void 0)
-        clearInterval(handle);
+    this.loop = buildWorkerPollLoop({
+      tick: () => this.runOnce(),
+      flatIntervalMs: deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2,
+      backoff: deps.backoff,
+      setTimer: deps.setTimer,
+      clearTimer: deps.clearTimer
     });
   }
   async runOnce() {
     const leased = await this.queue.lease(this.leaseKinds);
     if (leased === null)
       return false;
+    await this.processLeased(leased);
+    return true;
+  }
+  /**
+   * PRD-062b (AC-4): process ONE already-leased pipeline job — route it by kind, run
+   * the handler, and complete/fail it. Split out of {@link runOnce} so the single
+   * combined lease coordinator can dispatch a job IT leased (over the union of kinds)
+   * to this participant without a second lease. The standalone `runOnce` leases then
+   * calls this; both paths share the identical route+run+complete/fail body, so kind
+   * isolation and the no-swallowed-error contract hold whether consolidation is on or off.
+   */
+  async processLeased(leased) {
     if (!isPipelineJobKind(leased.kind)) {
       this.logger?.event("stage.unknown_kind", { id: leased.id, kind: leased.kind });
       await this.queue.fail(leased.id, `unknown pipeline job kind: ${leased.kind}`);
-      return true;
+      return;
     }
     const job = toStageJob(leased, leased.kind);
     const handler = this.handlers[leased.kind];
@@ -49038,23 +49751,12 @@ var PipelineStageWorker = class {
       this.logger?.event("stage.failed", { id: job.id, kind: job.kind, attempt: job.attempt, reason });
       await this.queue.fail(job.id, reason);
     }
-    return true;
   }
   start() {
-    this.handle = this.setTimer(() => {
-      if (this.running)
-        return;
-      this.running = true;
-      void this.runOnce().finally(() => {
-        this.running = false;
-      });
-    }, this.pollIntervalMs);
+    this.loop.start();
   }
   stop() {
-    if (this.handle !== void 0) {
-      this.clearTimer(this.handle);
-      this.handle = void 0;
-    }
+    this.loop.stop();
   }
 };
 function createStageWorker(deps) {
@@ -49894,34 +50596,45 @@ function extractionFanOut(queue) {
     });
   };
 }
-function decisionFanOut(queue) {
+function buildControlledWritePayload(decision, entities) {
+  const proposal = {
+    action: decision.proposal.action,
+    confidence: decision.proposal.confidence,
+    reason: decision.proposal.reason
+  };
+  if (decision.proposal.targetId !== void 0 && decision.proposal.targetId !== "") {
+    proposal.target_id = decision.proposal.targetId;
+  }
+  const targetId = decision.proposal.targetId;
+  const candidates = decision.candidates.filter((c) => c.id !== "" && c.id !== targetId && typeof c.content === "string" && c.content !== "").map((c) => ({ id: c.id, content: c.content }));
+  return {
+    proposal,
+    content: decision.fact.content,
+    normalized_content: decision.fact.content,
+    fact_confidence: decision.fact.confidence,
+    fact_type: decision.fact.type,
+    entities: serializeEntities(entities),
+    ...candidates.length > 0 ? { candidates } : {}
+  };
+}
+function decisionFanOut(queue, config2 = amplificationConfig()) {
   return async (job, decisions) => {
     const entities = readForwardedEntities(job.payload);
-    for (const decision of decisions) {
-      if (decision.proposal.action === "none")
-        continue;
-      const proposal = {
-        action: decision.proposal.action,
-        confidence: decision.proposal.confidence,
-        reason: decision.proposal.reason
-      };
-      if (decision.proposal.targetId !== void 0 && decision.proposal.targetId !== "") {
-        proposal.target_id = decision.proposal.targetId;
-      }
-      const targetId = decision.proposal.targetId;
-      const candidates = decision.candidates.filter((c) => c.id !== "" && c.id !== targetId && typeof c.content === "string" && c.content !== "").map((c) => ({ id: c.id, content: c.content }));
+    const envelope = scopeEnvelope(job.scope);
+    const facts = decisions.filter((d) => d.proposal.action !== "none").map((d) => buildControlledWritePayload(d, entities));
+    if (facts.length === 0)
+      return;
+    if (config2.fanoutBatch) {
       await queue.enqueue({
         kind: "memory_controlled_write",
-        payload: {
-          ...scopeEnvelope(job.scope),
-          proposal,
-          content: decision.fact.content,
-          normalized_content: decision.fact.content,
-          fact_confidence: decision.fact.confidence,
-          fact_type: decision.fact.type,
-          entities: serializeEntities(entities),
-          ...candidates.length > 0 ? { candidates } : {}
-        }
+        payload: { ...envelope, [CONTROLLED_WRITE_BATCH_KEY]: facts }
+      });
+      return;
+    }
+    for (const fact of facts) {
+      await queue.enqueue({
+        kind: "memory_controlled_write",
+        payload: { ...envelope, ...fact }
       });
     }
   };
@@ -50463,6 +51176,8 @@ function stateUpdaterFromTrigger(trigger) {
   };
 }
 var PollinatingJobWorkerImpl = class {
+  /** Public for the lease coordinator's union — the single `pollinating` kind. */
+  leaseKinds = LEASE_KINDS2;
   queue;
   storage;
   scope;
@@ -50472,12 +51187,7 @@ var PollinatingJobWorkerImpl = class {
   stateUpdater;
   logger;
   clock;
-  pollIntervalMs;
-  setTimer;
-  clearTimer;
-  handle;
-  /** Guards against overlapping `runOnce` invocations on the poll loop. */
-  running = false;
+  loop;
   constructor(deps) {
     this.queue = deps.queue;
     this.storage = deps.storage;
@@ -50488,22 +51198,36 @@ var PollinatingJobWorkerImpl = class {
     this.stateUpdater = deps.stateUpdater ?? stateUpdaterFromTrigger(deps.trigger);
     this.logger = deps.logger;
     this.clock = deps.clock ?? { now: () => Date.now() };
-    this.pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS3;
-    this.setTimer = deps.setTimer ?? ((cb, ms) => setInterval(cb, ms));
-    this.clearTimer = deps.clearTimer ?? ((handle) => {
-      if (handle !== void 0)
-        clearInterval(handle);
+    this.loop = buildWorkerPollLoop({
+      tick: () => this.runOnce(),
+      flatIntervalMs: deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS3,
+      backoff: deps.backoff,
+      setTimer: deps.setTimer,
+      clearTimer: deps.clearTimer
     });
   }
   async runOnce() {
-    const leased = await this.queue.lease(LEASE_KINDS2);
+    const leased = await this.queue.lease(this.leaseKinds);
     if (leased === null)
       return false;
+    await this.processLeased(leased);
+    return true;
+  }
+  /**
+   * PRD-062b (AC-4): process ONE already-leased `pollinating` job — parse it, select
+   * the strategy, run the pass, and complete/fail it. Split out of {@link runOnce} so
+   * the single combined lease coordinator can dispatch a job IT leased (over the
+   * union of kinds) to this participant without a second lease. The standalone
+   * `runOnce` leases then calls this; both share the identical parse+run+complete/fail
+   * body, so kind isolation and the no-swallowed-error contract hold whether
+   * consolidation is on or off.
+   */
+  async processLeased(leased) {
     const job = parsePollinatingJobPayload(leased.payload);
     if (job === null) {
       this.logger?.event("pollinating.worker.bad_payload", { id: leased.id });
       await this.queue.fail(leased.id, "malformed pollinating job payload");
-      return true;
+      return;
     }
     try {
       const strategy = await this.selectStrategy(job);
@@ -50527,7 +51251,6 @@ var PollinatingJobWorkerImpl = class {
       this.logger?.event("pollinating.worker.failed", { id: leased.id, attempt: leased.attempt, reason });
       await this.queue.fail(leased.id, reason);
     }
-    return true;
   }
   /**
    * Select the payload strategy for a job by mode (D-4). Compaction when the payload
@@ -50555,26 +51278,105 @@ var PollinatingJobWorkerImpl = class {
     return shouldEnterCompaction(this.config, state.lastPassAt);
   }
   start() {
-    this.handle = this.setTimer(() => {
-      if (this.running)
-        return;
-      this.running = true;
-      void this.runOnce().finally(() => {
-        this.running = false;
-      });
-    }, this.pollIntervalMs);
+    this.loop.start();
   }
   stop() {
-    if (this.handle !== void 0) {
-      this.clearTimer(this.handle);
-      this.handle = void 0;
-    }
+    this.loop.stop();
   }
 };
 function createPollinatingWorker(deps) {
   return new PollinatingJobWorkerImpl(deps);
 }
 
+// dist/src/daemon/runtime/services/lease-coordinator.js
+var CombinedLeaseCoordinator = class {
+  queue;
+  participants;
+  logger;
+  unionKinds;
+  /** `kind` → the participant that owns it (built once; one owner per kind). */
+  routes;
+  loop;
+  constructor(deps) {
+    this.queue = deps.queue;
+    this.participants = deps.participants;
+    this.logger = deps.logger;
+    this.routes = /* @__PURE__ */ new Map();
+    const union2 = [];
+    for (const participant of deps.participants) {
+      for (const kind of participant.leaseKinds) {
+        if (this.routes.has(kind)) {
+          this.logger?.event("lease.coordinator.duplicate_kind", { kind });
+          continue;
+        }
+        this.routes.set(kind, participant);
+        union2.push(kind);
+      }
+    }
+    this.unionKinds = union2;
+    const timers = deps.timers ?? {
+      setTimer: (cb, ms) => {
+        const t = setInterval(cb, ms);
+        if (typeof t === "object" && t !== null && "unref" in t && typeof t.unref === "function")
+          t.unref();
+        return t;
+      },
+      clearTimer: (handle) => {
+        if (handle !== void 0)
+          clearInterval(handle);
+      }
+    };
+    this.loop = createPollLoop({
+      tick: () => this.runOnce(),
+      backoff: deps.backoff,
+      flatIntervalMs: deps.flatIntervalMs,
+      timers
+    });
+  }
+  async runOnce() {
+    const leased = await this.queue.lease(this.unionKinds);
+    if (leased === null)
+      return false;
+    const participant = this.routes.get(leased.kind);
+    if (participant === void 0) {
+      this.logger?.event("lease.coordinator.unknown_kind", { id: leased.id, kind: leased.kind });
+      await this.queue.fail(leased.id, `no participant owns leased kind: ${leased.kind}`);
+      return true;
+    }
+    await participant.processLeased(leased);
+    return true;
+  }
+  start() {
+    this.loop.start();
+  }
+  stop() {
+    this.loop.stop();
+  }
+};
+function createLeaseCoordinator(deps) {
+  return new CombinedLeaseCoordinator(deps);
+}
+var BoolFlag7 = external_exports.preprocess((raw2) => {
+  if (typeof raw2 === "boolean")
+    return raw2;
+  return raw2 === "true" || raw2 === "1";
+}, external_exports.boolean());
+var PollConsolidateConfigSchema = external_exports.object({
+  /** Master switch; off → two independent lease passes, the pre-PRD path (AC-9). */
+  enabled: BoolFlag7.default(false)
+});
+function envPollConsolidateConfigProvider(env = process.env) {
+  return {
+    read() {
+      const raw2 = env.HONEYCOMB_POLL_CONSOLIDATE;
+      return { enabled: raw2 === void 0 ? true : raw2 };
+    }
+  };
+}
+function resolvePollConsolidateConfig(provider = envPollConsolidateConfigProvider()) {
+  return PollConsolidateConfigSchema.parse(provider.read());
+}
+
 // dist/src/daemon/runtime/skillify/worker.js
 import { homedir as homedir24 } from "node:os";
 import { join as join31 } from "node:path";
@@ -50841,6 +51643,86 @@ function createSkillifyJobWorker(deps) {
 // dist/src/daemon/storage/client.js
 import { setTimeout as delay3 } from "node:timers/promises";
 
+// dist/src/daemon/storage/query-meter.js
+var QUERY_SOURCES = [
+  "poll-lease",
+  "poll-reaper",
+  "capture-write",
+  "fan-out-enqueue",
+  "controlled-write",
+  "recall-arm",
+  "embedding",
+  "other"
+];
+var DEFAULT_QUERY_SOURCE = "other";
+var QueryMeter = class {
+  /** `source` → {reads, writes}. Lazily populated on first hit per source. */
+  counts = /* @__PURE__ */ new Map();
+  /**
+   * Record ONE metered operation against a `source`.
+   *
+   * @param source the attribution label. Callers that have not threaded a label
+   *   pass nothing and the operation is counted under {@link DEFAULT_QUERY_SOURCE}
+   *   (`"other"`), so it is visibly "unlabeled" rather than dropped.
+   * @param isWrite `true` for a write statement (INSERT/UPDATE/DELETE/DDL),
+   *   `false` for a read (SELECT / read-only WITH). The storage client classifies
+   *   this from the statement shape so the split is consistent with the retry
+   *   layer's read/write tag, not guessed per call site.
+   */
+  record(source = DEFAULT_QUERY_SOURCE, isWrite = false) {
+    const entry = this.counts.get(source) ?? { reads: 0, writes: 0 };
+    if (isWrite)
+      entry.writes += 1;
+    else
+      entry.reads += 1;
+    this.counts.set(source, entry);
+  }
+  /**
+   * Take an immutable snapshot of the current per-source counts and rollup
+   * totals. Sources that have never been hit are omitted from `perSource` (a
+   * zero-traffic source contributes nothing), but the entries that ARE present
+   * are emitted in the canonical {@link QUERY_SOURCES} order for stable output.
+   */
+  snapshot() {
+    const perSource = [];
+    let totalReads = 0;
+    let totalWrites = 0;
+    for (const source of QUERY_SOURCES) {
+      const entry = this.counts.get(source);
+      if (entry === void 0)
+        continue;
+      perSource.push({ source, reads: entry.reads, writes: entry.writes });
+      totalReads += entry.reads;
+      totalWrites += entry.writes;
+    }
+    return { perSource, totalReads, totalWrites };
+  }
+  /**
+   * Reset every counter to zero. Used by the idle-baseline harness to start a
+   * clean measurement window, and available if a future caller flushes the meter
+   * per period.
+   */
+  reset() {
+    this.counts.clear();
+  }
+  /**
+   * Render the current snapshot as a single structured log line for the periodic
+   * diagnostic surface (AC-62a.1.3). The shape is `key=value` pairs so it greps
+   * cleanly and parses without a schema:
+   *
+   *   [query-meter] total_reads=42 total_writes=7 poll-lease=r:30/w:0 capture-write=r:0/w:5 other=r:12/w:2
+   *
+   * A meter with no traffic yet renders the header with zero totals and no
+   * per-source segments, so an idle window is still an explicit, loggable fact.
+   */
+  formatLogLine() {
+    const snap = this.snapshot();
+    const segments = snap.perSource.map((e) => `${e.source}=r:${e.reads}/w:${e.writes}`);
+    const header = `[query-meter] total_reads=${snap.totalReads} total_writes=${snap.totalWrites}`;
+    return segments.length === 0 ? header : `${header} ${segments.join(" ")}`;
+  }
+};
+
 // dist/src/daemon/storage/transport.js
 var TransportError = class extends Error {
   kind;
@@ -51015,15 +51897,39 @@ var StorageClient = class {
    * the real timer; a test injects a no-op so the bounded backoff costs zero
    * wall-clock time and the retry count stays deterministic.
    */
-  constructor(transport, config2, sleep2 = realSleep2) {
+  /** Per-source DeepLake query meter (PRD-062a). Always present; default mode is in-memory + log only. */
+  meter;
+  /**
+   * @param sleep injectable backoff clock for the read-retry layer. Defaults to
+   * the real timer; a test injects a no-op so the bounded backoff costs zero
+   * wall-clock time and the retry count stays deterministic.
+   * @param meter injectable query meter (PRD-062a). Defaults to a fresh in-memory
+   * {@link QueryMeter}; the daemon may inject a shared one so diagnostics and a
+   * later persistence path observe the SAME counts. The meter is a pure observer:
+   * supplying it never changes any query's behavior or result.
+   */
+  constructor(transport, config2, sleep2 = realSleep2, meter = new QueryMeter()) {
     this.transport = transport;
     this.config = config2;
     this.sleep = sleep2;
+    this.meter = meter;
   }
   /** The endpoint the client is bound to (for diagnostics; no secrets). */
   get endpoint() {
     return this.config.endpoint;
   }
+  /**
+   * Snapshot the per-source query counts (PRD-062a, AC-62a.1.3). The diagnostic
+   * surface and the idle-baseline harness read the meter through here without
+   * touching the live counter, so a snapshot is stable even as traffic continues.
+   */
+  meterSnapshot() {
+    return this.meter.snapshot();
+  }
+  /** Render the current per-source counts as one structured log line (PRD-062a). */
+  meterLogLine() {
+    return this.meter.formatLogLine();
+  }
   /**
    * Liveness check (a-AC-1): "connects" against the fake transport means a
    * trivial statement succeeds. Returns a typed result so a caller branches on
@@ -51056,7 +51962,9 @@ var StorageClient = class {
    * from the per-statement timeout: each attempt gets its own fresh timeout/abort.
    */
   async query(sql, scope, opts = {}) {
-    if (statementRetryability(sql) === "unsafe-write")
+    const retryability = statementRetryability(sql);
+    this.meter.record(opts.source, retryability !== "read");
+    if (retryability === "unsafe-write")
       return this.attemptOnce(sql, scope, opts);
     let last;
     for (let attempt = 1; attempt <= RETRY_ATTEMPTS; attempt++) {
@@ -51141,7 +52049,7 @@ function createStorageClient(options = {}) {
   const provider = options.provider ?? defaultCredentialProvider();
   const config2 = resolveStorageConfig(provider);
   const transport = options.transport ?? new HttpDeepLakeTransport(config2.endpoint, config2.token);
-  return new StorageClient(transport, config2, options.sleep);
+  return new StorageClient(transport, config2, options.sleep, options.meter);
 }
 function createLazyStorageClient(options = {}) {
   let built = null;
@@ -51291,7 +52199,7 @@ function authForMode(mode, storage, scope) {
   return { authenticator: composeAuthenticator(storage, scope), policy: defaultDenyPolicy };
 }
 function assembleSeams(daemon, storage, defaultScope, orgName, embed, healthDetail, workspaceDir, installedHarnesses, logStore, seams = defaultSeamFns, vault) {
-  seams.attachHooks(daemon, {
+  const captureHandler = seams.attachHooks(daemon, {
     storage,
     queue: daemon.services.queue,
     embed,
@@ -51416,6 +52324,7 @@ function assembleSeams(daemon, storage, defaultScope, orgName, embed, healthDeta
 `);
     }
   }
+  return captureHandler;
 }
 function resolveProductDataDeps(storage, defaultScope, queue, embed) {
   const baseDir = process.env.HONEYCOMB_WORKSPACE ?? process.cwd();
@@ -51502,7 +52411,7 @@ function coerceSettingBool(value) {
     return value === "true" || value === "1";
   return false;
 }
-async function buildGatedPollinatingWorker(options, storage, scope, queue, vault) {
+async function buildGatedPollinatingWorker(options, storage, scope, queue, vault, backoff) {
   let config2;
   try {
     config2 = resolvePollinatingConfig(options.pollinatingConfigProvider);
@@ -51529,7 +52438,7 @@ async function buildGatedPollinatingWorker(options, storage, scope, queue, vault
     ...providerModelOverride !== void 0 ? { providerModelOverride } : {}
   });
   const trigger = createPollinatingTrigger({ storage, scope, config: config2, enqueuer: queue });
-  return createPollinatingWorker({ queue, storage, scope, config: config2, model, trigger });
+  return createPollinatingWorker({ queue, storage, scope, config: config2, model, trigger, backoff });
 }
 function buildSummaryWorker(storage, scope, queue, embed) {
   return createSummaryJobWorker({ queue, storage, scope, embed: embed.client });
@@ -51550,7 +52459,7 @@ function makePipelineEntryEnqueuer(queue) {
     });
   };
 }
-async function buildPipelineWorker(options, storage, scope, queue, embed) {
+async function buildPipelineWorker(options, storage, scope, queue, embed, backoff) {
   let config2;
   try {
     config2 = resolvePipelineConfig();
@@ -51580,7 +52489,7 @@ async function buildPipelineWorker(options, storage, scope, queue, embed) {
     graphPersist: { storage, scope: queryScope, config: config2 },
     retention: { storage, scope: queryScope, config: config2 }
   });
-  return createStageWorker({ queue, handlers });
+  return createStageWorker({ queue, handlers, backoff });
 }
 function buildSkillifyWorker(storage, scope, queue) {
   return createSkillifyJobWorker({
@@ -51635,7 +52544,7 @@ function assembleDaemon(options = {}) {
   const embed = options.embed ?? createEmbedAttachment({ storage });
   const installedHarnesses = options.installedHarnesses ?? (options.harnessTargets !== void 0 && options.harnessTargets.length > 0 ? new Set(options.harnessTargets.map((t) => t.name)) : options.storage === void 0 ? detectInstalledHarnesses() : /* @__PURE__ */ new Set());
   const vault = options.vault ?? (options.storage === void 0 ? buildVaultStore() : void 0);
-  assembleSeams(daemon, storage, scope, daemonOrgName, embed, healthDetail, options.workspaceDir ?? process.cwd(), installedHarnesses, logStore, options.seams ?? defaultSeamFns, vault);
+  const captureHandler = assembleSeams(daemon, storage, scope, daemonOrgName, embed, healthDetail, options.workspaceDir ?? process.cwd(), installedHarnesses, logStore, options.seams ?? defaultSeamFns, vault);
   if (vault !== void 0 && vault instanceof VaultStore) {
     try {
       mountSettingsApi(daemon, { store: vault });
@@ -51705,6 +52614,7 @@ function assembleDaemon(options = {}) {
   let pollinatingWorker = null;
   let summaryWorker = null;
   let pipelineWorker = null;
+  let leaseCoordinator = null;
   let skillifyWorker = null;
   return {
     daemon,
@@ -51724,6 +52634,18 @@ function assembleDaemon(options = {}) {
         probeTimer.unref();
       }
       await daemon.startServices();
+      let pollBackoff;
+      try {
+        pollBackoff = resolvePollBackoffConfig();
+      } catch {
+        pollBackoff = resolvePollBackoffConfig({ read: () => ({}) });
+      }
+      let consolidatePoll = false;
+      try {
+        consolidatePoll = resolvePollConsolidateConfig().enabled;
+      } catch {
+        consolidatePoll = false;
+      }
       try {
         summaryWorker = buildSummaryWorker(storage, scope, daemon.services.queue, embed);
         summaryWorker.start();
@@ -51734,8 +52656,9 @@ function assembleDaemon(options = {}) {
         summaryWorker = null;
       }
       try {
-        pipelineWorker = await buildPipelineWorker(options, storage, scope, daemon.services.queue, embed);
-        pipelineWorker.start();
+        pipelineWorker = await buildPipelineWorker(options, storage, scope, daemon.services.queue, embed, pollBackoff);
+        if (!consolidatePoll)
+          pipelineWorker.start();
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         process.stderr.write(`honeycomb: memory-pipeline worker start failed (non-fatal): ${reason}
@@ -51765,16 +52688,41 @@ function assembleDaemon(options = {}) {
         }
       }
       try {
-        pollinatingWorker = await buildGatedPollinatingWorker(options, storage, scope, daemon.services.queue, vault);
-        pollinatingWorker?.start();
+        pollinatingWorker = await buildGatedPollinatingWorker(options, storage, scope, daemon.services.queue, vault, pollBackoff);
+        const pollinatingInjected = options.pollinatingWorker !== void 0;
+        if (consolidatePoll && !pollinatingInjected) {
+          const participants = [pipelineWorker, pollinatingWorker].filter((p) => p !== null);
+          if (participants.length > 0) {
+            leaseCoordinator = createLeaseCoordinator({
+              queue: daemon.services.queue,
+              participants,
+              backoff: pollBackoff,
+              flatIntervalMs: 1e3
+            });
+            leaseCoordinator.start();
+          }
+        } else {
+          pollinatingWorker?.start();
+          if (consolidatePoll && pollinatingInjected && pipelineWorker !== null) {
+            pipelineWorker.start();
+          }
+        }
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         process.stderr.write(`honeycomb: pollinating worker start failed (non-fatal): ${reason}
 `);
         pollinatingWorker = null;
+        if (consolidatePoll && leaseCoordinator === null && pipelineWorker !== null) {
+          pipelineWorker.start();
+        }
       }
     },
     async shutdown() {
+      await captureHandler.flush?.();
+      if (leaseCoordinator !== null) {
+        leaseCoordinator.stop();
+        leaseCoordinator = null;
+      }
       if (pollinatingWorker !== null) {
         pollinatingWorker.stop();
         pollinatingWorker = null;
@@ -51911,6 +52859,7 @@ export {
   DEFAULT_MAX_POLLS2 as DEFAULT_MAX_POLLS,
   DEFAULT_MAX_RETRIES,
   DEFAULT_OVERFETCH_MULTIPLIER,
+  DEFAULT_QUERY_SOURCE,
   DEFAULT_QUERY_TIMEOUT_MS,
   DEFAULT_TIMESTAMP_COLUMN,
   DEFAULT_VERSION_COLUMN,
@@ -51935,6 +52884,8 @@ export {
   LEGACY_CREDENTIALS_DIR_NAME,
   LOCK_FILE_NAME,
   PID_FILE_NAME,
+  QUERY_SOURCES,
+  QueryMeter,
   ROLES,
   RuntimeConfigError,
   RuntimeConfigSchema,