@legioncodeinc/honeycomb 0.1.6 → 0.1.8

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.8" : "0.0.0-dev";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -25673,6 +25673,28 @@ var SESSIONS_COLUMNS = Object.freeze([
   { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "agent_id", sql: "TEXT NOT NULL DEFAULT 'default'" },
   { name: "visibility", sql: "TEXT NOT NULL DEFAULT 'global'" },
+  // ── PRD-060a (a-AC-3 / a-AC-6): per-turn token + cache usage ──────────────────
+  // Additive columns, healed in via the SAME `ALTER TABLE ADD COLUMN` path the rest
+  // of the catalog uses (the heal engine iterates THIS array; nothing else to wire).
+  //
+  // ZERO vs NULL (a-AC-1 / a-AC-6, the open-question ruling): these four counts are
+  // NULLABLE BIGINT with NO `DEFAULT 0`. The distinction is load-bearing — a genuine
+  // `cache_read_input_tokens = 0` (a real measurement: nothing read from cache) must
+  // stay DISTINCT from "no usage data" (the count was never produced). A `DEFAULT 0`
+  // would collapse "absent" into "measured zero", which a-AC-6 forbids, so absent is
+  // encoded as SQL NULL and a measured zero as the integer 0. Nullable columns are
+  // exempt from the NOT-NULL-needs-a-DEFAULT load guard (NULL is their implicit
+  // default), so `ALTER TABLE ADD COLUMN … BIGINT` heals cleanly onto a populated
+  // legacy table: existing rows read back NULL = "token data absent" (a-AC-4).
+  { name: "input_tokens", sql: "BIGINT" },
+  { name: "output_tokens", sql: "BIGINT" },
+  { name: "cache_read_input_tokens", sql: "BIGINT" },
+  { name: "cache_creation_input_tokens", sql: "BIGINT" },
+  // The capture-source discriminant (a-AC-7): every Claude-Code row carries
+  // `source_tool = 'claude-code'`, so 060b/060e can render a "Claude Code only"
+  // partial state. NOT NULL DEFAULT '' (a discriminant always present; '' = unknown
+  // source) — heal-safe on a populated table because the empty string backfills.
+  { name: "source_tool", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "creation_date", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "last_update_date", sql: "TEXT NOT NULL DEFAULT ''" }
 ]);
@@ -25939,6 +25961,52 @@ var ROUTER_HISTORY_COLUMNS = Object.freeze([
   { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" }
 ]);
+var ROI_METRICS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "session_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent_id", sql: "TEXT NOT NULL DEFAULT 'default'" },
+  { name: "project_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "team_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  // GATED: '' until a verified backend-token claim populates it (f-AC-6/f-AC-7).
+  { name: "user_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "input_tokens", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "output_tokens", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "cache_read_tokens", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "cache_creation_tokens", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // MEASURED / MODELED / GROSS / INFRA money — BIGINT integer cents, never FLOAT (f-AC-4).
+  { name: "measured_cache_savings_cents", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "modeled_savings_cents", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "modeled_assumption_ref", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "gross_cost_cents", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "infra_cost_cents", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // cost_basis ∈ {measured, allocated, none}; allocation_method '' unless allocated (f-AC-5).
+  { name: "cost_basis", sql: "TEXT NOT NULL DEFAULT 'none'" },
+  { name: "allocation_method", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "price_ref", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "period_start", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "period_end", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var ROI_COST_BASES = Object.freeze(["measured", "allocated", "none"]);
+var TEAMS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "team_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "team_name", sql: "TEXT NOT NULL DEFAULT ''" },
+  // 'agent' rows work today; 'user' rows inert until user_id verified.
+  { name: "member_type", sql: "TEXT NOT NULL DEFAULT 'agent'" },
+  { name: "member_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "role", sql: "TEXT NOT NULL DEFAULT 'member'" },
+  { name: "active", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var TEAM_MEMBER_TYPES = Object.freeze(["agent", "user"]);
+var TEAM_ACTIVE = 1;
 var TENANCY_TABLES = defineGroup([
   {
     name: "agents",
@@ -25977,6 +26045,25 @@ var TENANCY_TABLES = defineGroup([
     pattern: "append-only",
     embeddingColumns: [],
     scope: "tenant"
+  },
+  {
+    // PRD-060f (f-AC-1/f-AC-2): the shared spend ledger. APPEND-ONLY — one
+    // immutable row per session, a re-price APPENDs a new row (new price_ref),
+    // NEVER an in-place UPDATE; the canonical row is MAX(created_at) per session.
+    name: "roi_metrics",
+    columns: ROI_METRICS_COLUMNS,
+    pattern: "append-only",
+    embeddingColumns: [],
+    scope: "tenant"
+  },
+  {
+    // PRD-060f (f-AC-8): the roster. VERSION-BUMPED — one row per (team, member),
+    // an edit APPENDs version N+1, read ORDER BY version DESC (same as api_keys).
+    name: "teams",
+    columns: TEAMS_COLUMNS,
+    pattern: "version-bumped",
+    embeddingColumns: [],
+    scope: "tenant"
   }
 ]);
 function buildApiKeyLookupByIdSql(id) {
@@ -26904,6 +26991,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 +27105,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 +27283,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 +27308,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 +27323,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 +27342,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 +27358,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 +27378,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 +27481,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 +28583,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.8" : "0.0.0-dev";
 async function emitTelemetry(event, opts, deps = {}) {
   const env = deps.env ?? process.env;
   const key = deps.posthogKey ?? POSTHOG_KEY;
@@ -31039,6 +31158,17 @@ function createSummaryJobWorker(deps) {
 
 // dist/src/daemon/runtime/capture/event-contract.js
 var nonEmpty = external_exports.string().trim().min(1);
+var tokenCount = external_exports.number().int().nonnegative();
+var TurnUsageSchema = external_exports.object({
+  /** `input_tokens` — prompt tokens billed for this turn. */
+  input: tokenCount.optional(),
+  /** `output_tokens` — completion tokens billed for this turn. */
+  output: tokenCount.optional(),
+  /** `cache_read_input_tokens` — tokens served from the prompt cache (a real 0 ≠ absent). */
+  cacheRead: tokenCount.optional(),
+  /** `cache_creation_input_tokens` — tokens written into the prompt cache. */
+  cacheCreation: tokenCount.optional()
+}).optional().transform((u) => u !== void 0 && (u.input !== void 0 || u.output !== void 0 || u.cacheRead !== void 0 || u.cacheCreation !== void 0) ? u : void 0);
 var UserMessageEventSchema = external_exports.object({
   kind: external_exports.literal("user_message"),
   text: external_exports.string()
@@ -31051,7 +31181,9 @@ var ToolCallEventSchema = external_exports.object({
 });
 var AssistantMessageEventSchema = external_exports.object({
   kind: external_exports.literal("assistant_message"),
-  text: external_exports.string()
+  text: external_exports.string(),
+  /** PRD-060a: optional per-turn token + cache counts; absent when unavailable. */
+  usage: TurnUsageSchema
 });
 var CaptureEventSchema = external_exports.discriminatedUnion("kind", [
   UserMessageEventSchema,
@@ -31094,15 +31226,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 +31433,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 +31442,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 +31483,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 +31525,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,8 +31602,8 @@ var CaptureRouteHandler = class {
    * org/workspace scope the partition.
    */
   buildRow(id, event, meta3, nowIso10, projectId) {
-    const message = JSON.stringify({ event, metadata: meta3 });
-    return [
+    const message = this.config.envelopeBudgetBytes > 0 ? budgetedStringify(event, meta3, this.config.envelopeBudgetBytes) : JSON.stringify({ event, metadata: meta3 });
+    const row = [
       ["id", val.str(id)],
       ["path", val.str(meta3.path)],
       ["filename", val.str(meta3.hookEventName)],
@@ -31220,9 +31617,17 @@ var CaptureRouteHandler = class {
       ["project_id", val.str(projectId)],
       ["plugin_version", val.str(meta3.pluginVersion)],
       ["agent_id", val.str(meta3.agentId)],
+      // PRD-060a (a-AC-7): the capture-source discriminant. `metadata.agent` is the
+      // canonical harness token the shim stamps (`claude-code` for the reference
+      // shim), so every Claude-Code-captured row carries `source_tool='claude-code'`.
+      ["source_tool", val.str(meta3.agent)],
       ["creation_date", val.str(nowIso10)],
       ["last_update_date", val.str(nowIso10)]
     ];
+    for (const [col, value] of usageColumns(event)) {
+      row.push([col, val.num(value)]);
+    }
+    return row;
   }
   /**
    * Resolve the capture row's `project_id` from the session cwd (PRD-049b 49b-AC-1 / 49b-AC-3).
@@ -31365,6 +31770,36 @@ function embedTextFor(event) {
       return [event.tool, serialize(event.input), serialize(event.response)].filter((s) => s.length > 0).join("\n");
   }
 }
+function usageColumns(event) {
+  if (event.kind !== "assistant_message" || event.usage === void 0)
+    return [];
+  const u = event.usage;
+  const cols = [];
+  if (u.input !== void 0)
+    cols.push(["input_tokens", u.input]);
+  if (u.output !== void 0)
+    cols.push(["output_tokens", u.output]);
+  if (u.cacheRead !== void 0)
+    cols.push(["cache_read_input_tokens", u.cacheRead]);
+  if (u.cacheCreation !== void 0)
+    cols.push(["cache_creation_input_tokens", u.cacheCreation]);
+  return cols;
+}
+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 +31824,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 +32863,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`);
@@ -34945,6 +35382,37 @@ function mountSkillPropagationApi(daemon, options) {
   }
 }
 
+// dist/src/dashboard/contracts.js
+var EMPTY_DASHBOARD_DATA = Object.freeze({
+  kpis: { memoryCount: 0, sessionCount: 0, turnCount: 0, estimatedSavings: 0, teamSkillCount: 0 },
+  sessions: { sessions: [] },
+  settings: { orgId: "", orgName: "", workspace: "", settings: {} },
+  graph: { built: false, nodes: [], edges: [] },
+  rules: { rules: [] },
+  skillSync: { skills: [] }
+});
+var EMPTY_ROI_VIEW = Object.freeze({
+  savings: {
+    status: "absent",
+    measuredCents: 0,
+    modeledCents: 0,
+    assumption: { kind: "", assumptionText: "", signedOff: false },
+    blendedCentsPerMtok: null
+  },
+  infra: { status: "absent", cents: 0, costBasis: "none" },
+  pollination: { status: "absent", cents: 0, lines: [] },
+  net: { status: "absent", computed: false, netCents: 0, modeled: true, costBasis: "none" },
+  rollups: [],
+  perUserAvailable: false,
+  scopedAcrossDevices: false,
+  ratesAsOf: ""
+});
+var EMPTY_ROI_TREND = Object.freeze({
+  status: "absent",
+  series: [],
+  startedAt: ""
+});
+
 // dist/src/daemon/runtime/dashboard/installed-assets.js
 import { homedir as homedir11 } from "node:os";
 import { join as join16 } from "node:path";
@@ -35103,6 +35571,548 @@ function sanitizeName(name) {
   return name.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 
+// dist/src/daemon/runtime/dashboard/roi-rates.js
+var ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
+var ANTHROPIC_CACHE_WRITE_MULTIPLIER = 1.25;
+function anthropicCacheRate(inputCentsPerMtok, multiplier) {
+  return Math.round(inputCentsPerMtok * multiplier);
+}
+var RATES_AS_OF = "2026-06-26";
+var RATE_TABLE = Object.freeze([
+  Object.freeze({
+    provider: "anthropic",
+    model: "claude-sonnet-4-6",
+    input_cents_per_mtok: 300,
+    output_cents_per_mtok: 1500,
+    cache_read_cents_per_mtok: anthropicCacheRate(300, ANTHROPIC_CACHE_READ_MULTIPLIER),
+    cache_write_cents_per_mtok: anthropicCacheRate(300, ANTHROPIC_CACHE_WRITE_MULTIPLIER)
+  }),
+  Object.freeze({
+    provider: "anthropic",
+    model: "claude-opus-4-8",
+    input_cents_per_mtok: 1500,
+    output_cents_per_mtok: 7500,
+    cache_read_cents_per_mtok: anthropicCacheRate(1500, ANTHROPIC_CACHE_READ_MULTIPLIER),
+    cache_write_cents_per_mtok: anthropicCacheRate(1500, ANTHROPIC_CACHE_WRITE_MULTIPLIER)
+  }),
+  // Finding (haiku-rate): the skillify gate runs `claude-haiku-4-5` (roi-pollination.ts
+  // SKILLIFY_HAIKU_MODEL). Without its own row, `priceHaikuTokens` fell back to the Sonnet default and
+  // MIS-priced Honeycomb's own-inference cost. Anthropic Haiku per-Mtok: $1 in / $5 out; the cache
+  // columns are derived from input via the SAME 0.1x / 1.25x multipliers (the invariant a test asserts).
+  Object.freeze({
+    provider: "anthropic",
+    model: "claude-haiku-4-5",
+    input_cents_per_mtok: 100,
+    output_cents_per_mtok: 500,
+    cache_read_cents_per_mtok: anthropicCacheRate(100, ANTHROPIC_CACHE_READ_MULTIPLIER),
+    cache_write_cents_per_mtok: anthropicCacheRate(100, ANTHROPIC_CACHE_WRITE_MULTIPLIER)
+  })
+]);
+var DEFAULT_RATE_PROVIDER = "anthropic";
+var DEFAULT_RATE_MODEL = "claude-sonnet-4-6";
+function rateRowFor(provider, model) {
+  return RATE_TABLE.find((r) => r.provider === provider && r.model === model);
+}
+function defaultRateRow() {
+  const row = rateRowFor(DEFAULT_RATE_PROVIDER, DEFAULT_RATE_MODEL);
+  if (row === void 0) {
+    throw new Error("roi-rates: the default rate row must exist in RATE_TABLE");
+  }
+  return row;
+}
+function resolveRate(provider, model) {
+  if (provider === void 0 || model === void 0 || provider.length === 0 || model.length === 0) {
+    return defaultRateRow();
+  }
+  return rateRowFor(provider, model) ?? defaultRateRow();
+}
+
+// dist/src/daemon/runtime/dashboard/roi-savings.js
+function measured(value) {
+  return { tag: "measured", value };
+}
+function modeled(value, assumption) {
+  return { tag: "modeled", value, assumption };
+}
+function tokensAtRate(tokens, centsPerMtok) {
+  return Math.round(tokens * centsPerMtok / 1e6);
+}
+function measuredCacheSavings(turns) {
+  let savingsCents = 0;
+  let measuredTurns = 0;
+  for (const turn of turns) {
+    if (turn.cache_read_input_tokens === null)
+      continue;
+    measuredTurns += 1;
+    const rate = resolveRate(turn.provider, turn.model);
+    const deltaCentsPerMtok = rate.input_cents_per_mtok - rate.cache_read_cents_per_mtok;
+    savingsCents += tokensAtRate(turn.cache_read_input_tokens, deltaCentsPerMtok);
+  }
+  const totalTurns = turns.length;
+  const status = totalTurns === 0 || measuredTurns === 0 ? "absent" : measuredTurns < totalTurns ? "partial" : "measured";
+  return measured({ savingsCents, measuredTurns, totalTurns, status });
+}
+function blendedCentsPerMtok(turns) {
+  let totalCents = 0;
+  let totalTokens = 0;
+  for (const turn of turns) {
+    const rate = resolveRate(turn.provider, turn.model);
+    if (turn.input_tokens !== null) {
+      totalCents += tokensAtRate(turn.input_tokens, rate.input_cents_per_mtok);
+      totalTokens += turn.input_tokens;
+    }
+    if (turn.output_tokens !== null) {
+      totalCents += tokensAtRate(turn.output_tokens, rate.output_cents_per_mtok);
+      totalTokens += turn.output_tokens;
+    }
+    if (turn.cache_read_input_tokens !== null) {
+      totalCents += tokensAtRate(turn.cache_read_input_tokens, rate.cache_read_cents_per_mtok);
+      totalTokens += turn.cache_read_input_tokens;
+    }
+    if (turn.cache_creation_input_tokens !== null) {
+      totalCents += tokensAtRate(turn.cache_creation_input_tokens, rate.cache_write_cents_per_mtok);
+      totalTokens += turn.cache_creation_input_tokens;
+    }
+  }
+  if (totalTokens === 0)
+    return null;
+  return Math.round(totalCents / totalTokens * 1e6);
+}
+var MEMORY_INJECTION_ASSUMPTION = Object.freeze({
+  kind: "turns-saved-per-session",
+  turnsSavedPerSession: 2,
+  avgTokensPerSavedTurn: 4e3,
+  includesOutputTokens: false,
+  signedOff: false,
+  assumptionText: "PLACEHOLDER (pending operator sign-off): estimates that injecting memory saves ~2 turns of re-explaining per session, at ~4,000 input tokens per saved turn, priced at the session's input rate. Output-token savings are NOT yet claimed. This is a model, not a billed figure."
+});
+function modeledMemoryInjectionSavings(sessions, rate = resolveRate(void 0, void 0), assumption = MEMORY_INJECTION_ASSUMPTION) {
+  const savedTokens = Math.max(0, sessions) * assumption.turnsSavedPerSession * assumption.avgTokensPerSavedTurn;
+  let estimatedCents = tokensAtRate(savedTokens, rate.input_cents_per_mtok);
+  if (assumption.includesOutputTokens) {
+    estimatedCents += tokensAtRate(savedTokens, rate.output_cents_per_mtok);
+  }
+  return modeled({ estimatedCents, sessions: Math.max(0, sessions) }, assumption);
+}
+
+// dist/src/daemon/runtime/dashboard/roi-billing.js
+var realSleeper3 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var systemBillingClock = {
+  now() {
+    return Date.now();
+  }
+};
+var DEFAULT_MAX_RETRIES2 = 3;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_TTL_MS2 = 5 * 6e4;
+var DEEPLAKE_CLIENT_HEADER2 = "X-Deeplake-Client";
+var DEEPLAKE_ORG_HEADER2 = "X-Activeloop-Org-Id";
+var DEEPLAKE_CLIENT_VALUE2 = "honeycomb";
+var centsField = external_exports.number().int().catch(0);
+var numberField = external_exports.number().catch(0);
+var ComputeTierSchema = external_exports.object({
+  tier: external_exports.string().catch(""),
+  hours: numberField,
+  cost_cents: centsField,
+  unit_price_cents: centsField
+});
+var BillingComparisonSchema = external_exports.object({
+  compute_cost_previous: centsField,
+  total_cost_previous: centsField,
+  delta_pct: numberField
+});
+var BillingComputeSchema = external_exports.object({
+  total_cost_cents: centsField,
+  total_pod_hours: numberField,
+  by_tier: external_exports.array(ComputeTierSchema).catch([])
+});
+var BillingSummarySchema = external_exports.object({
+  balance_cents: centsField,
+  period_start: external_exports.string().catch(""),
+  period_end: external_exports.string().catch(""),
+  total_cost_cents: centsField,
+  storage_cost_cents: centsField,
+  transfer_cost_cents: centsField,
+  projected_end_of_period_cents: centsField,
+  compute: BillingComputeSchema,
+  comparison: BillingComparisonSchema
+});
+var SESSION_TYPES = ["query", "embedding", "ingestion"];
+var SessionTypeSchema = external_exports.enum(SESSION_TYPES);
+var ComputeSessionSchema = external_exports.object({
+  session_type: SessionTypeSchema,
+  gpu_hours: numberField,
+  gpu_units: numberField,
+  price_cents_per_gpu_hour: centsField,
+  // Finding (billing-zero): keep `total_cost_cents` OPTIONAL/nullish so a MISSING field (absent on the
+  // wire) stays `undefined` and is distinguishable from a legitimate explicit `0` (a free session). The
+  // `.catch(undefined)` keeps a present-but-malformed value from throwing while NOT collapsing it to 0
+  // -- `buildSessionTypeBreakdown` derives a cost ONLY when the field is truly absent, never over an
+  // explicit 0 (which would overwrite a legitimately-free session with gpu_hours x price).
+  total_cost_cents: centsField.optional().nullable().catch(void 0)
+});
+var ComputeUsageSchema = external_exports.object({
+  total_cost_cents: centsField,
+  total_gpu_hours: numberField,
+  sessions: external_exports.array(ComputeSessionSchema).catch([])
+});
+function sessionTypeTotalCents(lines) {
+  return lines.reduce((sum, line) => sum + line.cost_cents, 0);
+}
+function isRetryable2(status) {
+  return status === 429 || status >= 500 && status <= 599;
+}
+function billingHeaders(creds) {
+  const headers = {
+    Authorization: `Bearer ${creds.token}`,
+    "Content-Type": "application/json",
+    [DEEPLAKE_CLIENT_HEADER2]: DEEPLAKE_CLIENT_VALUE2
+  };
+  if (creds.orgId.length > 0)
+    headers[DEEPLAKE_ORG_HEADER2] = creds.orgId;
+  return headers;
+}
+function resolveBillingApiUrl(creds) {
+  const base = creds.apiUrl !== void 0 && creds.apiUrl.length > 0 ? creds.apiUrl : DEFAULT_DEEPLAKE_API_URL;
+  return base.replace(/\/+$/, "");
+}
+function buildSessionTypeBreakdown(usage) {
+  return usage.sessions.map((s) => {
+    const derived = Math.round(s.gpu_hours * s.price_cents_per_gpu_hour);
+    const cost_cents = s.total_cost_cents !== void 0 && s.total_cost_cents !== null ? s.total_cost_cents : derived;
+    return {
+      session_type: s.session_type,
+      gpu_hours: s.gpu_hours,
+      price_cents_per_gpu_hour: s.price_cents_per_gpu_hour,
+      cost_cents
+    };
+  });
+}
+function createInfraCostReadModel(options = {}) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const sleep2 = options.sleep ?? realSleeper3;
+  const clock = options.clock ?? systemBillingClock;
+  const dir = options.dir;
+  const loadCreds = options.creds ?? (() => loadDiskCredentials(dir));
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES2;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS2;
+  let cached3;
+  async function getJson(apiUrl, path4, headers) {
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const resp = await doFetch(`${apiUrl}${path4}`, { method: "GET", headers, signal: controller.signal });
+        if (resp.ok) {
+          return await resp.json().catch(() => null);
+        }
+        if (isRetryable2(resp.status) && attempt < maxRetries) {
+          clearTimeout(timer);
+          await sleep2(250 * 2 ** attempt);
+          continue;
+        }
+        return null;
+      } catch {
+        if (attempt < maxRetries) {
+          clearTimeout(timer);
+          await sleep2(250 * 2 ** attempt);
+          continue;
+        }
+        return null;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    return null;
+  }
+  function parseOrMissing(raw2, schema) {
+    if (raw2 === null || raw2 === void 0)
+      return void 0;
+    const result = schema.safeParse(raw2);
+    return result.success ? result.data : void 0;
+  }
+  async function fetchSnapshot() {
+    const creds = loadCreds();
+    if (creds === null || creds.token.length === 0) {
+      return { status: "unauthenticated", missing: [], sessionTypes: [], fetchedAt: clock.now() };
+    }
+    const apiUrl = resolveBillingApiUrl(creds);
+    const headers = billingHeaders(creds);
+    const [summaryRaw, computeRaw] = await Promise.all([
+      getJson(apiUrl, "/billing/summary", headers),
+      getJson(apiUrl, "/billing/usage/compute", headers)
+    ]);
+    const summary = parseOrMissing(summaryRaw, BillingSummarySchema);
+    const compute = parseOrMissing(computeRaw, ComputeUsageSchema);
+    const missing = [];
+    if (summary === void 0)
+      missing.push("/billing/summary");
+    if (compute === void 0)
+      missing.push("/billing/usage/compute");
+    const okCount = (summary !== void 0 ? 1 : 0) + (compute !== void 0 ? 1 : 0);
+    const status = okCount === 0 ? "unreachable" : okCount === 2 ? "ok" : "partial";
+    const sessionTypes = compute !== void 0 ? buildSessionTypeBreakdown(compute) : [];
+    return {
+      status,
+      missing,
+      ...summary !== void 0 ? { summary } : {},
+      ...compute !== void 0 ? { compute } : {},
+      sessionTypes,
+      fetchedAt: clock.now()
+    };
+  }
+  return {
+    async read() {
+      const now = clock.now();
+      if (cached3 !== void 0 && now - cached3.fetchedAt < ttlMs) {
+        return cached3;
+      }
+      const snapshot = await fetchSnapshot();
+      cached3 = snapshot;
+      return snapshot;
+    },
+    invalidate() {
+      cached3 = void 0;
+    }
+  };
+}
+
+// dist/src/daemon/runtime/dashboard/roi-pollination.js
+var SKILLIFY_PROVIDER = "anthropic";
+var SKILLIFY_HAIKU_MODEL = "claude-haiku-4-5";
+function tokensAtRate2(tokens, centsPerMtok) {
+  return Math.round(tokens * centsPerMtok / 1e6);
+}
+function priceHaikuTokens(snapshot) {
+  if (snapshot.perModel !== void 0 && snapshot.perModel.length > 0) {
+    return snapshot.perModel.reduce((sum, b) => sum + priceBucket(b), 0);
+  }
+  const rate = resolveRate(SKILLIFY_PROVIDER, snapshot.model ?? SKILLIFY_HAIKU_MODEL);
+  return tokensAtRate2(snapshot.inputTokens, rate.input_cents_per_mtok) + tokensAtRate2(snapshot.outputTokens, rate.output_cents_per_mtok) + tokensAtRate2(snapshot.cacheReadInputTokens, rate.cache_read_cents_per_mtok) + tokensAtRate2(snapshot.cacheCreationInputTokens, rate.cache_write_cents_per_mtok);
+}
+function priceBucket(b) {
+  const rate = resolveRate(SKILLIFY_PROVIDER, b.model.length > 0 ? b.model : SKILLIFY_HAIKU_MODEL);
+  return tokensAtRate2(b.inputTokens, rate.input_cents_per_mtok) + tokensAtRate2(b.outputTokens, rate.output_cents_per_mtok) + tokensAtRate2(b.cacheReadInputTokens, rate.cache_read_cents_per_mtok) + tokensAtRate2(b.cacheCreationInputTokens, rate.cache_write_cents_per_mtok);
+}
+function composeHaikuContribution(snapshot) {
+  const buckets = snapshot.perModel;
+  const model = buckets !== void 0 && buckets.length > 1 ? "mixed" : buckets !== void 0 && buckets.length === 1 ? buckets[0].model : snapshot.model ?? SKILLIFY_HAIKU_MODEL;
+  if (snapshot.recorded === 0) {
+    return {
+      status: "absent",
+      cents: 0,
+      recorded: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      model
+    };
+  }
+  return {
+    status: "measured",
+    cents: priceHaikuTokens(snapshot),
+    recorded: snapshot.recorded,
+    inputTokens: snapshot.inputTokens,
+    outputTokens: snapshot.outputTokens,
+    cacheReadInputTokens: snapshot.cacheReadInputTokens,
+    cacheCreationInputTokens: snapshot.cacheCreationInputTokens,
+    model
+  };
+}
+function emptyPerType() {
+  return { query: 0, embedding: 0, ingestion: 0 };
+}
+function composeDeeplakeContribution(infra) {
+  const perTypeCents = emptyPerType();
+  for (const line of infra.sessionTypes) {
+    perTypeCents[line.session_type] += line.cost_cents;
+  }
+  return {
+    status: infra.status,
+    cents: sessionTypeTotalCents(infra.sessionTypes),
+    bySessionType: infra.sessionTypes,
+    perTypeCents
+  };
+}
+var STATUS_SEVERITY = Object.freeze({
+  unauthenticated: 0,
+  // worst — no credentials, no figure.
+  unreachable: 1,
+  // billing could not be read.
+  absent: 2,
+  // Haiku has no data yet.
+  partial: 3,
+  // billing partially read.
+  measured: 4,
+  // Haiku ok (a real token figure).
+  ok: 5
+  // best — billing fully read.
+});
+function worstPollinationStatus(haiku, deeplake) {
+  if (haiku === "measured" && deeplake === "ok")
+    return "ok";
+  const haikuStatus = haiku;
+  const deeplakeStatus = deeplake;
+  return STATUS_SEVERITY[haikuStatus] <= STATUS_SEVERITY[deeplakeStatus] ? haikuStatus : deeplakeStatus;
+}
+function composePollinationCost(usage, infra) {
+  const haiku = composeHaikuContribution(usage.snapshot());
+  const deeplake = composeDeeplakeContribution(infra);
+  return {
+    pollinationCents: haiku.cents + deeplake.cents,
+    status: worstPollinationStatus(haiku.status, deeplake.status),
+    haiku,
+    deeplake
+  };
+}
+
+// dist/src/daemon/runtime/dashboard/roi-skillify-meter.js
+function emptySnapshot() {
+  return {
+    recorded: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function snapshotSource(snapshot) {
+  return { snapshot: () => snapshot };
+}
+var emptyUsageSource = snapshotSource(emptySnapshot());
+
+// dist/src/daemon/runtime/recall/scope-clause.js
+var PROJECT_ID_COLUMN = "project_id";
+var PROJECT_ID_UNSET = "";
+var CROSS_PROJECT_ADMITTED = Object.freeze(["user", "workspace"]);
+var SCOPE_READ_POLICIES = Object.freeze(["isolated", "shared", "group"]);
+function asReadPolicy(raw2) {
+  return SCOPE_READ_POLICIES.includes(raw2) ? raw2 : null;
+}
+function buildProjectScopeClause(input) {
+  const projectColumn = input.projectColumn ?? PROJECT_ID_COLUMN;
+  const rawId = input.projectId ?? "";
+  const isInbox = rawId.trim() === "" || rawId === UNSORTED_PROJECT_ID;
+  const bound = input.bound ?? !isInbox;
+  const col = sqlIdent(projectColumn);
+  const primaryId = bound ? rawId : UNSORTED_PROJECT_ID;
+  const admitted = primaryId === PROJECT_ID_UNSET ? [PROJECT_ID_UNSET] : [primaryId, PROJECT_ID_UNSET];
+  const disjuncts = admitted.map((id) => `${col} = ${sLiteral(id)}`);
+  const values = [...admitted];
+  if (input.promotionColumn !== void 0 && input.promotionColumn !== "") {
+    const promoCol = sqlIdent(input.promotionColumn);
+    for (const reach of CROSS_PROJECT_ADMITTED) {
+      disjuncts.push(`${promoCol} = ${sLiteral(reach)}`);
+      values.push(reach);
+    }
+  }
+  const sql = `(${disjuncts.join(" OR ")})`;
+  return { sql, values, bound };
+}
+function buildProjectScopeConjunct(input) {
+  return ` AND ${buildProjectScopeClause(input).sql}`;
+}
+
+// dist/src/daemon/runtime/dashboard/roi-ledger.js
+var BACKEND_TOKEN_SOURCE = "backend-token";
+function resolveGatedUserId(verifiedClaim) {
+  if (verifiedClaim !== void 0 && verifiedClaim.source === BACKEND_TOKEN_SOURCE) {
+    return verifiedClaim.userId;
+  }
+  return "";
+}
+async function resolveTeamId(client, scope, agentId) {
+  const tbl = sqlIdent("teams");
+  const memberType = sqlIdent("member_type");
+  const memberId = sqlIdent("member_id");
+  const activeCol = sqlIdent("active");
+  const versionCol = sqlIdent("version");
+  const sql = `SELECT team_id FROM "${tbl}" AS t WHERE ${memberType} = ${sLiteral("agent")} AND ${memberId} = ${sLiteral(agentId)} AND ${activeCol} = ${TEAM_ACTIVE} AND ${versionCol} = (SELECT MAX(${versionCol}) FROM "${tbl}" AS u WHERE u.${memberType} = ${sLiteral("agent")} AND u.${memberId} = ${sLiteral(agentId)}) LIMIT 1`;
+  let res;
+  try {
+    res = await client.query(sql, scope);
+  } catch {
+    return "";
+  }
+  if (!isOk(res) || res.rows.length === 0)
+    return "";
+  const raw2 = res.rows[0].team_id;
+  return typeof raw2 === "string" ? raw2 : "";
+}
+function toInt(n) {
+  if (n === void 0 || !Number.isFinite(n))
+    return 0;
+  return Math.trunc(n);
+}
+function asCostBasis(raw2) {
+  return raw2 !== void 0 && ROI_COST_BASES.includes(raw2) ? raw2 : "none";
+}
+async function appendRoiMetric(client, scope, input) {
+  const agentId = input.agentId.trim() === "" ? "default" : input.agentId;
+  const teamId = await resolveTeamId(client, scope, agentId);
+  const userId = resolveGatedUserId(input.verifiedClaim);
+  const costBasis = asCostBasis(input.costBasis);
+  const row = [
+    ["id", val.str(input.id)],
+    ["session_id", val.str(input.sessionId)],
+    ["org_id", val.str(scope.org)],
+    ["workspace_id", val.str(scope.workspace ?? "")],
+    ["agent_id", val.str(agentId)],
+    ["project_id", val.str(input.projectId ?? "")],
+    ["team_id", val.str(teamId)],
+    ["user_id", val.str(userId)],
+    ["input_tokens", val.num(toInt(input.inputTokens))],
+    ["output_tokens", val.num(toInt(input.outputTokens))],
+    ["cache_read_tokens", val.num(toInt(input.cacheReadTokens))],
+    ["cache_creation_tokens", val.num(toInt(input.cacheCreationTokens))],
+    ["measured_cache_savings_cents", val.num(toInt(input.measuredCacheSavingsCents))],
+    ["modeled_savings_cents", val.num(toInt(input.modeledSavingsCents))],
+    ["modeled_assumption_ref", val.str(input.modeledAssumptionRef ?? "")],
+    ["gross_cost_cents", val.num(toInt(input.grossCostCents))],
+    ["infra_cost_cents", val.num(toInt(input.infraCostCents))],
+    ["cost_basis", val.str(costBasis)],
+    ["allocation_method", val.str(input.allocationMethod ?? "")],
+    ["price_ref", val.str(input.priceRef ?? "")],
+    ["period_start", val.str(input.periodStart ?? "")],
+    ["period_end", val.str(input.periodEnd ?? "")],
+    ["created_at", val.str(input.createdAt)]
+  ];
+  const result = await appendOnlyInsert(client, healTargetFor("roi_metrics"), scope, row);
+  return { result, teamId, userId };
+}
+function buildRoiReadScopeSql(input, tableAlias) {
+  const agentCol = tableAlias !== void 0 ? `${sqlIdent(tableAlias)}.${sqlIdent("agent_id")}` : sqlIdent("agent_id");
+  const ownSql = `${agentCol} = ${sLiteral(input.agentId)}`;
+  const noRows = `(${sLiteral("1")} = ${sLiteral("0")})`;
+  const policy = asReadPolicy(input.readPolicy);
+  if (input.agentId.trim() === "" || policy === null || policy === "isolated") {
+    const ownClause = input.agentId.trim() === "" ? noRows : ownSql;
+    return { sql: `(${ownClause})`, policyApplied: "isolated" };
+  }
+  if (policy === "shared") {
+    return { sql: `(${sLiteral("1")} = ${sLiteral("1")})`, policyApplied: "shared" };
+  }
+  return { sql: `(${ownSql})`, policyApplied: "group" };
+}
+async function readRoiMetrics(client, scope, input) {
+  const tbl = sqlIdent("roi_metrics");
+  const { sql: scopeSql } = buildRoiReadScopeSql(input, "m");
+  const projectClause = input.projectId !== void 0 && input.projectId.trim() !== "" ? ` AND ${sqlIdent("m")}.${sqlIdent("project_id")} = ${sLiteral(input.projectId.trim())}` : "";
+  const sql = `SELECT m.* FROM "${tbl}" AS m WHERE ${scopeSql}${projectClause} AND NOT EXISTS (SELECT 1 FROM "${tbl}" AS n WHERE n.session_id = m.session_id AND (n.created_at > m.created_at OR (n.created_at = m.created_at AND n.id > m.id)))`;
+  let res;
+  try {
+    res = await client.query(sql, scope);
+  } catch (err) {
+    return { status: "shared-ledger-absent", reason: err instanceof Error ? err.message : "query threw" };
+  }
+  if (!isOk(res)) {
+    return { status: "shared-ledger-absent", reason: res.kind === "query_error" ? res.message : res.kind };
+  }
+  return { status: "ok", rows: res.rows };
+}
+
 // dist/src/daemon/runtime/dashboard/api.js
 var DASHBOARD_GROUPS = Object.freeze({
   /**
@@ -35147,7 +36157,14 @@ var DASHBOARD_GROUPS = Object.freeze({
    * READ-ONLY filesystem walk; tenancy-independent (no org header required). PRD-036b calls
    * the underlying `scanInstalledAssets` IN-PROCESS, not over this HTTP surface.
    */
-  installedAssets: "/api/diagnostics"
+  installedAssets: "/api/diagnostics",
+  /**
+   * ROI composite read-model (PRD-060e) — served off the diagnostics group at `/roi` + `/roi/trend`
+   * (full paths `/api/diagnostics/roi` + `/api/diagnostics/roi/trend`). Local-mode-only loopback like
+   * every other dashboard view-model; attached under the already-mounted, protected diagnostics group
+   * (no new group, no `server.ts` edit). The page is a PURE function of the `RoiView` this returns.
+   */
+  roi: "/api/diagnostics"
 });
 function toNum2(value) {
   const n = typeof value === "number" ? value : Number(value ?? 0);
@@ -35331,6 +36348,176 @@ async function fetchSkillSyncView(storage, scope, scan = scanInstalledAssets) {
   }
   return { skills: [...merged.values()] };
 }
+var DEFAULT_ROI_READ_POLICY = "shared";
+function roiSectionStatusFor(status) {
+  if (status === "measured")
+    return "ok";
+  return status;
+}
+function tokenCountOrNull(value) {
+  if (value === null || value === void 0)
+    return null;
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? Math.trunc(n) : null;
+}
+function rowToCapturedTurn(r) {
+  const sourceTool = toStr2(r.source_tool);
+  return {
+    input_tokens: tokenCountOrNull(r.input_tokens),
+    output_tokens: tokenCountOrNull(r.output_tokens),
+    cache_read_input_tokens: tokenCountOrNull(r.cache_read_input_tokens),
+    cache_creation_input_tokens: tokenCountOrNull(r.cache_creation_input_tokens),
+    ...sourceTool !== "" ? { sourceTool } : {}
+  };
+}
+var ROI_SESSIONS_LIMIT = 5e3;
+async function readCapturedTurns(storage, scope, projectId) {
+  const tbl = sqlIdent("sessions");
+  const dateCol = sqlIdent("creation_date");
+  const idCol = sqlIdent("id");
+  const projClause = projectId !== void 0 && projectId !== "" ? ` WHERE ${sqlIdent("project_id")} = ${sLiteral(projectId)}` : "";
+  const sql = `SELECT ${sqlIdent("input_tokens")}, ${sqlIdent("output_tokens")}, ${sqlIdent("cache_read_input_tokens")}, ${sqlIdent("cache_creation_input_tokens")}, ${sqlIdent("source_tool")} FROM "${tbl}"${projClause} ORDER BY ${dateCol} DESC, ${idCol} DESC LIMIT ${ROI_SESSIONS_LIMIT}`;
+  const rows = await selectRows2(storage, sql, scope);
+  return rows.map(rowToCapturedTurn);
+}
+var ROLLUP_DIMENSIONS = Object.freeze([
+  { dimension: "org", column: "org_id" },
+  { dimension: "team", column: "team_id" },
+  { dimension: "agent", column: "agent_id" },
+  { dimension: "project", column: "project_id" }
+]);
+function asCostBasisTag(raw2) {
+  const s = toStr2(raw2);
+  return s === "measured" || s === "allocated" || s === "none" ? s : "none";
+}
+function computeRollups(rows) {
+  return ROLLUP_DIMENSIONS.map(({ dimension, column }) => {
+    const groups = /* @__PURE__ */ new Map();
+    const allBases = /* @__PURE__ */ new Set();
+    for (const r of rows) {
+      const key = toStr2(r[column]);
+      const measured2 = toNum2(r.measured_cache_savings_cents);
+      const modeled2 = toNum2(r.modeled_savings_cents);
+      const infra = toNum2(r.infra_cost_cents);
+      const gross = toNum2(r.gross_cost_cents);
+      const basis = asCostBasisTag(r.cost_basis);
+      allBases.add(basis);
+      const g = groups.get(key) ?? { measured: 0, net: 0, infra: 0, sessions: 0, bases: /* @__PURE__ */ new Set() };
+      g.measured += measured2;
+      g.net += measured2 + modeled2 - (infra + gross);
+      g.infra += infra;
+      g.sessions += 1;
+      g.bases.add(basis);
+      groups.set(key, g);
+    }
+    const rollupRows = [...groups.entries()].map(([key, g]) => ({
+      key,
+      label: key,
+      measuredSavingsCents: g.measured,
+      netCents: g.net,
+      infraCostCents: g.infra,
+      // A row whose own group mixes bases is flagged `allocated` (the more-cautious tag); a single
+      // basis carries through verbatim, so a measured-only row stays `measured`.
+      costBasis: g.bases.size > 1 ? "allocated" : [...g.bases][0] ?? "none",
+      sessions: g.sessions
+    }));
+    return { dimension, rows: rollupRows, mixedBasis: allBases.size > 1 };
+  });
+}
+async function fetchRoiView(storage, scope, options = {}) {
+  const agentId = options.agentId !== void 0 && options.agentId.trim() !== "" ? options.agentId.trim() : "";
+  const readPolicy = options.readPolicy ?? DEFAULT_ROI_READ_POLICY;
+  const infraModel = options.infra ?? createInfraCostReadModel();
+  const usage = options.usage ?? emptyUsageSource;
+  const projectId = options.projectId !== void 0 && options.projectId.trim() !== "" ? options.projectId.trim() : void 0;
+  try {
+    const [turns, infra, ledger] = await Promise.all([
+      readCapturedTurns(storage, scope, projectId),
+      infraModel.read(),
+      readRoiMetrics(storage, scope, { agentId, readPolicy, ...projectId !== void 0 ? { projectId } : {} })
+    ]);
+    return assembleRoiView({ turns, infra, usage, ledger, readPolicy });
+  } catch {
+    return EMPTY_ROI_VIEW;
+  }
+}
+function assembleRoiView(input) {
+  const { turns, infra, usage, ledger, readPolicy } = input;
+  const measured2 = measuredCacheSavings(turns);
+  const modeled2 = modeledMemoryInjectionSavings(turns.length);
+  const blended = blendedCentsPerMtok(turns);
+  const captureStatus = measured2.value.status;
+  const savingsStatus = captureStatus === "measured" ? "ok" : captureStatus;
+  const savings = {
+    status: savingsStatus,
+    measuredCents: measured2.value.savingsCents,
+    modeledCents: modeled2.value.estimatedCents,
+    assumption: {
+      kind: modeled2.assumption.kind,
+      assumptionText: modeled2.assumption.assumptionText,
+      signedOff: modeled2.assumption.signedOff
+    },
+    blendedCentsPerMtok: blended
+  };
+  const infraStatus = roiSectionStatusFor(infra.status);
+  const infraCents = infra.summary !== void 0 ? infra.summary.total_cost_cents : 0;
+  const infraSection = {
+    status: infraStatus,
+    cents: infraCents,
+    // Org/workspace infra read from billing is a MEASURED fact when present; otherwise no line.
+    costBasis: infra.status === "ok" || infra.status === "partial" ? "measured" : "none"
+  };
+  const pollination = composePollinationCost(usage, infra);
+  const pollinationLines = [
+    { label: "haiku-skillify", cents: pollination.haiku.cents },
+    ...pollination.deeplake.bySessionType.map((s) => ({ label: `deeplake-${s.session_type}`, cents: s.cost_cents }))
+  ];
+  const pollinationSection = {
+    status: roiSectionStatusFor(pollination.status),
+    cents: pollination.pollinationCents,
+    lines: pollinationLines
+  };
+  const savingsPresent = savingsStatus === "ok";
+  const infraConfident = infraStatus === "ok";
+  const pollinationConfident = pollinationSection.status === "ok";
+  const netComputable = savingsPresent && infraConfident && pollinationConfident;
+  let netSection;
+  if (netComputable) {
+    const netCents = measured2.value.savingsCents + modeled2.value.estimatedCents - (infraCents + pollination.pollinationCents);
+    netSection = {
+      status: "ok",
+      computed: true,
+      netCents,
+      modeled: true,
+      // the net folds a modeled term → ALWAYS `est.` (e-AC-3 net-hero inheritance).
+      costBasis: infraSection.costBasis
+    };
+  } else {
+    const reason = !savingsPresent ? savingsStatus : !infraConfident ? infraStatus : pollinationSection.status;
+    netSection = { status: reason, computed: false, netCents: 0, modeled: true, costBasis: "none" };
+  }
+  const ledgerRows = ledger.status === "ok" ? ledger.rows : [];
+  const rollups = computeRollups(ledgerRows);
+  return {
+    savings,
+    infra: infraSection,
+    pollination: pollinationSection,
+    net: netSection,
+    rollups,
+    // PER-USER GATE (e-AC-14): there is no verified backend user-claim today, so per-user is NEVER
+    // available — the page shows the "per-user requires verified login" empty state, never a $0/name.
+    perUserAvailable: false,
+    // ACROSS-DEVICE (e-AC-12): a `shared` read returned workspace-wide rows (across devices); an
+    // `isolated` read returned only this machine's. The page captions the scope from this.
+    scopedAcrossDevices: readPolicy === "shared",
+    ratesAsOf: RATES_AS_OF
+  };
+}
+async function fetchRoiTrendView(storage, scope, _range, _options = {}) {
+  void storage;
+  void scope;
+  return EMPTY_ROI_TREND;
+}
 var NO_ORG_BODY4 = { error: "bad_request", reason: "x-honeycomb-org header is required" };
 function mountDashboardApi(daemon, options) {
   const storage = options.storage;
@@ -35398,16 +36585,44 @@ function mountDashboardApi(daemon, options) {
       return c.json(await inventoryCache());
     });
   }
+  const roi = daemon.group(DASHBOARD_GROUPS.roi);
+  if (roi !== void 0) {
+    const roiOptions = (c, scope) => {
+      const project = resolveRequestProject(c, scope);
+      return {
+        ...options.roiInfra !== void 0 ? { infra: options.roiInfra } : {},
+        ...options.roiUsage !== void 0 ? { usage: options.roiUsage } : {},
+        readPolicy: resolveRoiReadPolicy(c.req.query("policy")),
+        ...!project.degraded ? { projectId: project.projectId } : {}
+      };
+    };
+    roi.get("/roi", async (c) => {
+      const scope = resolveScope5(c);
+      if (scope === null)
+        return c.json(NO_ORG_BODY4, 400);
+      return c.json(await fetchRoiView(storage, scope, roiOptions(c, scope)));
+    });
+    roi.get("/roi/trend", async (c) => {
+      const scope = resolveScope5(c);
+      if (scope === null)
+        return c.json(NO_ORG_BODY4, 400);
+      const range = c.req.query("range") ?? "";
+      return c.json(await fetchRoiTrendView(storage, scope, range, roiOptions(c, scope)));
+    });
+  }
+}
+function resolveRoiReadPolicy(raw2) {
+  return raw2 === "isolated" || raw2 === "shared" || raw2 === "group" ? raw2 : DEFAULT_ROI_READ_POLICY;
 }
 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;
   };
 }
@@ -35693,8 +36908,61 @@ function nestedString(raw2, a, b) {
 function userMessageData(text) {
   return { kind: "user_message", text };
 }
-function assistantMessageData(text) {
-  return { kind: "assistant_message", text };
+function assistantMessageData(text, usage) {
+  const normalized = usage !== void 0 ? compactUsage(usage) : void 0;
+  return {
+    kind: "assistant_message",
+    text,
+    ...normalized !== void 0 ? { usage: normalized } : {}
+  };
+}
+function compactUsage(usage) {
+  const out = {};
+  if (isCount(usage.input))
+    out.input = usage.input;
+  if (isCount(usage.output))
+    out.output = usage.output;
+  if (isCount(usage.cacheRead))
+    out.cacheRead = usage.cacheRead;
+  if (isCount(usage.cacheCreation))
+    out.cacheCreation = usage.cacheCreation;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function isCount(n) {
+  return typeof n === "number" && Number.isInteger(n) && n >= 0;
+}
+function extractTurnUsage(raw2) {
+  const block = usageBlock(raw2);
+  if (block === void 0)
+    return void 0;
+  const usage = {
+    ...readCount(block, "input_tokens") !== void 0 ? { input: readCount(block, "input_tokens") } : {},
+    ...readCount(block, "output_tokens") !== void 0 ? { output: readCount(block, "output_tokens") } : {},
+    ...readCount(block, "cache_read_input_tokens") !== void 0 ? { cacheRead: readCount(block, "cache_read_input_tokens") } : {},
+    ...readCount(block, "cache_creation_input_tokens") !== void 0 ? { cacheCreation: readCount(block, "cache_creation_input_tokens") } : {}
+  };
+  return compactUsage(usage);
+}
+function usageBlock(raw2) {
+  const top = nested(raw2, "usage");
+  if (top !== null && typeof top === "object")
+    return top;
+  const inner = nestedRecord(nested(raw2, "message"), "usage");
+  return inner;
+}
+function nestedRecord(obj, key) {
+  if (obj !== null && typeof obj === "object") {
+    const value = obj[key];
+    if (value !== null && typeof value === "object")
+      return value;
+  }
+  return void 0;
+}
+function readCount(block, key) {
+  const value = block[key];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0)
+    return void 0;
+  return value;
 }
 function toolCallData(tool, input, response) {
   return { kind: "tool_call", tool, input, response };
@@ -35744,7 +37012,7 @@ function claudeCodeExtractData(raw2, logical) {
     case "tool_call":
       return toolCallData(pickString(raw2, "tool_name", "tool"), nested(raw2, "tool_input"), nested(raw2, "tool_response"));
     case "assistant_message":
-      return assistantMessageData(pickString(raw2, "text", "message"));
+      return assistantMessageData(pickString(raw2, "text", "message"), extractTurnUsage(raw2));
     case "session-end":
       return sessionEndData(pickString(raw2, "reason") || "Stop");
     default:
@@ -36162,7 +37430,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 +37459,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 +37512,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 +38863,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 +38878,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 +39912,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 +39929,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`). */
@@ -39055,35 +40335,6 @@ async function readBody4(c) {
   }
 }
 
-// dist/src/daemon/runtime/recall/scope-clause.js
-var PROJECT_ID_COLUMN = "project_id";
-var PROJECT_ID_UNSET = "";
-var CROSS_PROJECT_ADMITTED = Object.freeze(["user", "workspace"]);
-var SCOPE_READ_POLICIES = Object.freeze(["isolated", "shared", "group"]);
-function buildProjectScopeClause(input) {
-  const projectColumn = input.projectColumn ?? PROJECT_ID_COLUMN;
-  const rawId = input.projectId ?? "";
-  const isInbox = rawId.trim() === "" || rawId === UNSORTED_PROJECT_ID;
-  const bound = input.bound ?? !isInbox;
-  const col = sqlIdent(projectColumn);
-  const primaryId = bound ? rawId : UNSORTED_PROJECT_ID;
-  const admitted = primaryId === PROJECT_ID_UNSET ? [PROJECT_ID_UNSET] : [primaryId, PROJECT_ID_UNSET];
-  const disjuncts = admitted.map((id) => `${col} = ${sLiteral(id)}`);
-  const values = [...admitted];
-  if (input.promotionColumn !== void 0 && input.promotionColumn !== "") {
-    const promoCol = sqlIdent(input.promotionColumn);
-    for (const reach of CROSS_PROJECT_ADMITTED) {
-      disjuncts.push(`${promoCol} = ${sLiteral(reach)}`);
-      values.push(reach);
-    }
-  }
-  const sql = `(${disjuncts.join(" OR ")})`;
-  return { sql, values, bound };
-}
-function buildProjectScopeConjunct(input) {
-  return ` AND ${buildProjectScopeClause(input).sql}`;
-}
-
 // dist/src/daemon/runtime/memories/reads.js
 var DEFAULT_LIST_LIMIT = 50;
 var MAX_LIST_LIMIT = 500;
@@ -40382,12 +41633,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 +41674,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 +41735,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 +41832,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 +42069,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 +42209,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 +42250,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 +42259,7 @@ async function runSemanticArm(spec, queryVector, request, deps, limit) {
       scope: {},
       limit,
       ...projectClause !== "" ? { extraClause: projectClause } : {}
-    });
+    }));
     scored = recall.ids;
   } catch {
     return [];
@@ -41388,6 +42773,19 @@ async function recallMemories(request, deps) {
 }
 
 // dist/src/daemon/runtime/secrets/api.js
+function localDefaultScopeResolver(mode, defaultScope) {
+  return {
+    resolve(c) {
+      const fromHeader = headerScopeResolver2.resolve(c);
+      if (fromHeader !== null)
+        return fromHeader;
+      if (mode === "local" && defaultScope !== void 0) {
+        return { org: defaultScope.org, workspace: defaultScope.workspace ?? "default" };
+      }
+      return null;
+    }
+  };
+}
 var headerScopeResolver2 = {
   resolve(c) {
     const org = c.req.header("x-honeycomb-org");
@@ -41911,12 +43309,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 +43330,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 +43523,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 +43873,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 +45041,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 +45096,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 +47611,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);
     }
   }
@@ -48850,12 +50282,34 @@ var RouterModelClient = class {
 var ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_VERSION = "2023-06-01";
 var DEFAULT_MAX_TOKENS = 4096;
+var noopUsageSink = {
+  record() {
+  }
+};
 var AnthropicContentBlockSchema = external_exports.object({
   type: external_exports.string(),
   text: external_exports.string().optional()
 });
+var AnthropicUsageSchema = external_exports.object({
+  input_tokens: external_exports.number().int().nonnegative().catch(0).default(0),
+  output_tokens: external_exports.number().int().nonnegative().catch(0).default(0),
+  cache_read_input_tokens: external_exports.number().int().nonnegative().catch(0).default(0),
+  cache_creation_input_tokens: external_exports.number().int().nonnegative().catch(0).default(0)
+});
+var ZERO_USAGE = {
+  input_tokens: 0,
+  output_tokens: 0,
+  cache_read_input_tokens: 0,
+  cache_creation_input_tokens: 0
+};
 var AnthropicMessagesResponseSchema = external_exports.object({
-  content: external_exports.array(AnthropicContentBlockSchema).default([])
+  content: external_exports.array(AnthropicContentBlockSchema).default([]),
+  // Finding (usage-failsoft): `.default(ZERO_USAGE)` only covers `usage === undefined`. A response with
+  // `usage: null` or a malformed `usage` object would FAIL the object parse and -- because this field is
+  // part of the whole-response schema -- bubble up to a 502 that DROPS an otherwise-valid completion.
+  // `.catch(ZERO_USAGE)` makes ANY invalid value (null, a string, a malformed object) fall back to
+  // zero-usage so a valid completion is NEVER dropped over its (side-channel) usage block.
+  usage: AnthropicUsageSchema.default(ZERO_USAGE).catch(ZERO_USAGE)
 });
 function toAnthropicBody(call, defaultMaxTokens) {
   const systemParts = [];
@@ -48883,6 +50337,7 @@ function createAnthropicTransport(deps = {}) {
   const doFetch = deps.fetch ?? globalThis.fetch;
   const url2 = deps.baseUrl ?? ANTHROPIC_MESSAGES_URL;
   const defaultMaxTokens = deps.defaultMaxTokens ?? DEFAULT_MAX_TOKENS;
+  const usageSink = deps.usageSink ?? noopUsageSink;
   async function post(call) {
     const body = toAnthropicBody(call, defaultMaxTokens);
     let res;
@@ -48908,16 +50363,33 @@ function createAnthropicTransport(deps = {}) {
     if (!parsed.success) {
       throw new ProviderError(502, "anthropic transport: malformed provider response");
     }
-    return joinContentText(parsed.data.content);
+    const u = parsed.data.usage;
+    const usage = {
+      model: call.target.model,
+      workload: call.request.workload,
+      inputTokens: u.input_tokens,
+      outputTokens: u.output_tokens,
+      cacheReadInputTokens: u.cache_read_input_tokens,
+      cacheCreationInputTokens: u.cache_creation_input_tokens
+    };
+    return { output: joinContentText(parsed.data.content), usage };
+  }
+  function reportUsage(usage) {
+    try {
+      usageSink.record(usage);
+    } catch {
+    }
   }
   return {
     async execute(call) {
-      const output = await post(call);
+      const { output, usage } = await post(call);
+      reportUsage(usage);
       return { output };
     },
     stream(call) {
       async function* gen() {
-        const output = await post(call);
+        const { output, usage } = await post(call);
+        reportUsage(usage);
         yield { delta: output };
       }
       return gen();
@@ -48962,7 +50434,7 @@ async function buildInferenceModelClient(deps) {
   }
   const effectiveConfig = deps.providerModelOverride !== void 0 ? applyProviderModelOverride(config2, deps.providerModelOverride) : config2;
   const secrets = createSecretResolver(deps.secretsStore, deps.scope);
-  const transport = createAnthropicTransport();
+  const transport = createAnthropicTransport(deps.usageSink !== void 0 ? { usageSink: deps.usageSink } : {});
   const router = createInferenceRouter({
     config: effectiveConfig,
     transport,
@@ -48972,6 +50444,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 +50681,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 +50729,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 +51574,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 +52154,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 +52165,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 +52176,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 +52229,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 +52256,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";
@@ -50668,6 +52448,95 @@ function sanitizeSegment5(projectKey) {
   return cleaned === "" ? "default" : cleaned;
 }
 
+// dist/src/daemon/runtime/dashboard/roi-session-writer.js
+import { randomUUID as randomUUID7 } from "node:crypto";
+var SESSION_TURNS_LIMIT = 2e3;
+function tokenCountOrNull2(value) {
+  if (value === null || value === void 0)
+    return null;
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? Math.trunc(n) : null;
+}
+function rowToCapturedTurn2(r) {
+  const sourceTool = typeof r.source_tool === "string" ? r.source_tool : "";
+  return {
+    input_tokens: tokenCountOrNull2(r.input_tokens),
+    output_tokens: tokenCountOrNull2(r.output_tokens),
+    cache_read_input_tokens: tokenCountOrNull2(r.cache_read_input_tokens),
+    cache_creation_input_tokens: tokenCountOrNull2(r.cache_creation_input_tokens),
+    ...sourceTool !== "" ? { sourceTool } : {}
+  };
+}
+async function readSessionTurns(storage, scope, path4) {
+  const tbl = sqlIdent("sessions");
+  const pathCol = sqlIdent("path");
+  const sql = `SELECT ${sqlIdent("input_tokens")}, ${sqlIdent("output_tokens")}, ${sqlIdent("cache_read_input_tokens")}, ${sqlIdent("cache_creation_input_tokens")}, ${sqlIdent("source_tool")} FROM "${tbl}" WHERE ${pathCol} = ${sLiteral(path4)} LIMIT ${SESSION_TURNS_LIMIT}`;
+  let result;
+  try {
+    result = await storage.query(sql, scope);
+  } catch {
+    return [];
+  }
+  return isOk(result) ? result.rows.map(rowToCapturedTurn2) : [];
+}
+function createRoiSessionWriter(deps) {
+  const clock = deps.clock ?? { now: () => Date.now() };
+  return {
+    async writeForSession(input) {
+      try {
+        if (input.path.trim() === "") {
+          deps.logger?.event("roi.write.skipped", { reason: "blank path", sessionId: input.sessionId });
+          return;
+        }
+        const turns = await readSessionTurns(deps.storage, deps.scope, input.path);
+        const measured2 = measuredCacheSavings(turns);
+        const modeled2 = modeledMemoryInjectionSavings(1);
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cacheReadTokens = 0;
+        let cacheCreationTokens = 0;
+        for (const t of turns) {
+          inputTokens += t.input_tokens ?? 0;
+          outputTokens += t.output_tokens ?? 0;
+          cacheReadTokens += t.cache_read_input_tokens ?? 0;
+          cacheCreationTokens += t.cache_creation_input_tokens ?? 0;
+        }
+        const createdAt = new Date(clock.now()).toISOString();
+        const { teamId, userId } = await appendRoiMetric(deps.storage, deps.scope, {
+          id: randomUUID7(),
+          sessionId: input.sessionId,
+          agentId: input.agentId,
+          ...input.projectId !== void 0 ? { projectId: input.projectId } : {},
+          inputTokens,
+          outputTokens,
+          cacheReadTokens,
+          cacheCreationTokens,
+          measuredCacheSavingsCents: measured2.value.savingsCents,
+          modeledSavingsCents: modeled2.value.estimatedCents,
+          modeledAssumptionRef: modeled2.assumption.kind,
+          grossCostCents: 0,
+          infraCostCents: 0,
+          costBasis: "none",
+          allocationMethod: "",
+          createdAt
+        });
+        deps.logger?.event("roi.write.appended", {
+          sessionId: input.sessionId,
+          measuredCents: measured2.value.savingsCents,
+          teamId,
+          // user_id is gated to '' today — surface that it stayed gated (never a leaked identity).
+          userGated: userId === ""
+        });
+      } catch (err) {
+        deps.logger?.event("roi.write.failed", {
+          sessionId: input.sessionId,
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+
 // dist/src/daemon/runtime/skillify/worker.js
 var SKILLIFY_JOB_KIND = "skillify";
 var DEFAULT_POLL_INTERVAL_MS4 = 1e3;
@@ -50710,6 +52579,8 @@ var SkillifyJobWorkerImpl = class {
   gateOverride;
   fetcherOverride;
   storeOverride;
+  /** PRD-060e/060f — the per-session ROI writer fired once at completion (fail-soft). */
+  roiWriter;
   handle;
   /** Guards against overlapping `runOnce` invocations on the poll loop. */
   running = false;
@@ -50735,6 +52606,7 @@ var SkillifyJobWorkerImpl = class {
     this.gateOverride = deps.gateOverride;
     this.fetcherOverride = deps.fetcherOverride;
     this.storeOverride = deps.storeOverride;
+    this.roiWriter = deps.roiWriter ?? createRoiSessionWriter({ storage: this.storage, scope: this.scope });
   }
   async runOnce() {
     let leased;
@@ -50775,6 +52647,19 @@ var SkillifyJobWorkerImpl = class {
       const outcome = await writeSkill(result.outcome.verdict, { store, install, author: this.author, projectId }, result.outcome.minedSessionIds, "global");
       const sessionDates = result.outcome.pairs.map((p) => p.sessionDate);
       this.watermarkStore.advance(projectKey, sessionDates);
+      try {
+        await this.roiWriter.writeForSession({
+          sessionId: payload.sessionId,
+          path: payload.path,
+          agentId: this.author,
+          projectId
+        });
+      } catch (roiErr) {
+        this.logger?.event("skillify.worker.roi_write_failed", {
+          id: job.id,
+          reason: roiErr instanceof Error ? roiErr.message : String(roiErr)
+        });
+      }
       await this.queue.complete(job.id);
       this.logger?.event("skillify.worker.completed", {
         id: job.id,
@@ -50841,6 +52726,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;
@@ -50853,8 +52818,8 @@ var TransportError = class extends Error {
       this.status = status;
   }
 };
-var DEEPLAKE_CLIENT_HEADER2 = "X-Deeplake-Client";
-var DEEPLAKE_ORG_HEADER2 = "X-Activeloop-Org-Id";
+var DEEPLAKE_CLIENT_HEADER3 = "X-Deeplake-Client";
+var DEEPLAKE_ORG_HEADER3 = "X-Activeloop-Org-Id";
 var HttpDeepLakeTransport = class {
   endpoint;
   token;
@@ -50870,8 +52835,8 @@ var HttpDeepLakeTransport = class {
         headers: {
           Authorization: `Bearer ${this.token}`,
           "Content-Type": "application/json",
-          [DEEPLAKE_ORG_HEADER2]: req.org,
-          [DEEPLAKE_CLIENT_HEADER2]: "honeycomb"
+          [DEEPLAKE_ORG_HEADER3]: req.org,
+          [DEEPLAKE_CLIENT_HEADER3]: "honeycomb"
         },
         signal: req.signal,
         body: JSON.stringify({ query: req.sql })
@@ -51015,15 +52980,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 +53045,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 +53132,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 +53282,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,
@@ -51347,7 +53338,7 @@ function assembleSeams(daemon, storage, defaultScope, orgName, embed, healthDeta
     seams.mountMemoriesPrime(daemon, { storage, defaultScope });
   }
   seams.mountVfs(daemon, { storage, defaultScope });
-  seams.mountProductData(daemon, resolveProductDataDeps(storage, defaultScope, daemon.services.queue, embed.client));
+  seams.mountProductData(daemon, resolveProductDataDeps(storage, defaultScope, daemon.services.queue, embed.client, daemon.config.mode));
   seams.mountPollinate(daemon, { storage, defaultScope, enqueuer: daemon.services.queue });
   try {
     seams.mountProjectsSync(daemon, { storage, defaultScope });
@@ -51416,11 +53407,16 @@ function assembleSeams(daemon, storage, defaultScope, orgName, embed, healthDeta
 `);
     }
   }
+  return captureHandler;
 }
-function resolveProductDataDeps(storage, defaultScope, queue, embed) {
+function resolveProductDataDeps(storage, defaultScope, queue, embed, mode) {
   const baseDir = process.env.HONEYCOMB_WORKSPACE ?? process.cwd();
   const secrets = {
-    store: new SecretsStore({ baseDir, machineKey: createMachineKeyProvider() })
+    store: new SecretsStore({ baseDir, machineKey: createMachineKeyProvider() }),
+    // PRD-022 local-mode default: the dashboard's `GET /api/secrets` (names-only) carries no
+    // `x-honeycomb-org` header, so resolve the daemon's single local tenant instead of 400ing.
+    // Team/hybrid stay fail-closed (a missing org still 400s) — cross-tenant access is rejected.
+    scope: localDefaultScopeResolver(mode, defaultScope)
   };
   let sources;
   try {
@@ -51502,7 +53498,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 +53525,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 +53546,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 +53576,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,10 +53631,10 @@ 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 });
+      mountSettingsApi(daemon, { store: vault, scope: localDefaultScopeResolver(daemon.config.mode, scope) });
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       process.stderr.write(`honeycomb: settings API mount failed (non-fatal): ${reason}
@@ -51705,6 +53701,7 @@ function assembleDaemon(options = {}) {
   let pollinatingWorker = null;
   let summaryWorker = null;
   let pipelineWorker = null;
+  let leaseCoordinator = null;
   let skillifyWorker = null;
   return {
     daemon,
@@ -51724,6 +53721,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 +53743,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 +53775,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;
@@ -51897,9 +53932,9 @@ export {
   CompactionConfigError,
   CompactionRefusedError,
   CompactionRetentionSchema,
-  DEEPLAKE_CLIENT_HEADER2 as DEEPLAKE_CLIENT_HEADER,
+  DEEPLAKE_CLIENT_HEADER3 as DEEPLAKE_CLIENT_HEADER,
   DEFAULT_MAX_POLLS as DEEPLAKE_DEFAULT_MAX_POLLS,
-  DEEPLAKE_ORG_HEADER2 as DEEPLAKE_ORG_HEADER,
+  DEEPLAKE_ORG_HEADER3 as DEEPLAKE_ORG_HEADER,
   DEFAULT_CONVERGE_BACKOFF_BASE_MS,
   DEFAULT_CONVERGE_BACKOFF_CAP_MS,
   DEFAULT_CONVERGE_BUDGET,
@@ -51911,6 +53946,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 +53971,8 @@ export {
   LEGACY_CREDENTIALS_DIR_NAME,
   LOCK_FILE_NAME,
   PID_FILE_NAME,
+  QUERY_SOURCES,
+  QueryMeter,
   ROLES,
   RuntimeConfigError,
   RuntimeConfigSchema,