@legioncodeinc/honeycomb 0.1.7 → 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.7" : "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) {
@@ -28496,7 +28583,7 @@ function buildAllowedProperties(input) {
 }
 var systemTelemetryClock = () => (/* @__PURE__ */ new Date()).toISOString();
 var DEFAULT_EMIT_TIMEOUT_MS = 2e3;
-var HONEYCOMB_VERSION2 = true ? "0.1.7" : "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;
@@ -31071,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()
@@ -31083,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,
@@ -31503,7 +31603,7 @@ var CaptureRouteHandler = class {
    */
   buildRow(id, event, meta3, nowIso10, projectId) {
     const message = this.config.envelopeBudgetBytes > 0 ? budgetedStringify(event, meta3, this.config.envelopeBudgetBytes) : JSON.stringify({ event, metadata: meta3 });
-    return [
+    const row = [
       ["id", val.str(id)],
       ["path", val.str(meta3.path)],
       ["filename", val.str(meta3.hookEventName)],
@@ -31517,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).
@@ -31662,6 +31770,21 @@ 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) {
@@ -35259,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";
@@ -35417,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({
   /**
@@ -35461,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);
@@ -35645,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;
@@ -35712,6 +36585,34 @@ 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() {
@@ -36007,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 };
@@ -36058,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:
@@ -39381,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;
@@ -41848,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");
@@ -49344,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 = [];
@@ -49377,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;
@@ -49402,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();
@@ -49456,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,
@@ -51470,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;
@@ -51512,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;
@@ -51537,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;
@@ -51577,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,
@@ -51735,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;
@@ -51752,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 })
@@ -52255,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 });
@@ -52326,10 +53409,14 @@ 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 {
@@ -52547,7 +53634,7 @@ function assembleDaemon(options = {}) {
   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}
@@ -52845,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,