xytara 3.1.17 → 3.2.0

package/lib/commerce_economics.js

@@ -1,4017 +0,0 @@
-"use strict";
-
-const crypto = require("crypto");
-const { findTask, findWorkflow } = require("../fixtures/catalog");
-const {
-  buildAuthoritySummary,
-  buildAuthorityAttentionSummary
-} = require("./commerce_authority");
-const {
-  buildMachineIdentitySummary,
-  buildMachineIdentityAttentionSummary
-} = require("./commerce_identity");
-const {
-  createAuthorityBinding,
-  renewAuthorityBinding,
-  revokeAuthorityBinding,
-  rotateAuthorityBinding
-} = require("./account_auth");
-const {
-  createIdentityBinding,
-  renewIdentityBinding,
-  revokeIdentityBinding,
-  rotateIdentityBinding
-} = require("./identity_auth");
-
-function normalizeString(value, fallback) {
-  const trimmed = typeof value === "string" ? value.trim() : "";
-  return trimmed || fallback || null;
-}
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function ensureArray(value) {
-  return Array.isArray(value) ? value : [];
-}
-
-function ensureObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
-const PRICING_BAND_UNITS = {
-  utility: 1,
-  transactional: 2,
-  decision_support: 3,
-  governed_high_consequence: 5,
-  trust_critical: 8
-};
-
-function createEconomicsBudget(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const budgetId = normalizeString(payload.budget_id, `budget_${state.economicsBudgets.size + 1}`);
-  const createdAt = nowIso();
-  const budget = {
-    budget_id: budgetId,
-    account_id: accountId,
-    label: normalizeString(payload.label, budgetId),
-    status: normalizeString(payload.status, "active"),
-    max_reserve_units: typeof payload.max_reserve_units === "number" ? payload.max_reserve_units : 1000,
-    allowed_job_domains: ensureArray(payload.allowed_job_domains),
-    policy_ref: normalizeString(payload.policy_ref, "policy.default"),
-    created_at_iso: createdAt,
-    updated_at_iso: createdAt
-  };
-  state.economicsBudgets.set(budgetId, budget);
-  return budget;
-}
-
-function setEconomicsBudgetStatus(state, budgetId, body) {
-  if (!state.economicsBudgets.has(budgetId)) return null;
-  const payload = ensureObject(body);
-  const current = state.economicsBudgets.get(budgetId);
-  const next = {
-    ...current,
-    status: normalizeString(payload.status, current.status),
-    status_reason: normalizeString(payload.reason, current.status_reason || null),
-    updated_at_iso: nowIso()
-  };
-  state.economicsBudgets.set(budgetId, next);
-  return next;
-}
-
-function createEconomicsAgent(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const agentId = normalizeString(payload.agent_id, `agent_${state.economicsAgents.size + 1}`);
-  const createdAt = nowIso();
-  const agent = {
-    agent_id: agentId,
-    account_id: accountId,
-    label: normalizeString(payload.label, agentId),
-    status: normalizeString(payload.status, "active"),
-    default_budget_id: normalizeString(payload.default_budget_id, null),
-    allowed_job_domains: ensureArray(payload.allowed_job_domains),
-    created_at_iso: createdAt,
-    updated_at_iso: createdAt
-  };
-  state.economicsAgents.set(agentId, agent);
-  return agent;
-}
-
-function setEconomicsAgentStatus(state, agentId, body) {
-  if (!state.economicsAgents.has(agentId)) return null;
-  const payload = ensureObject(body);
-  const current = state.economicsAgents.get(agentId);
-  const next = {
-    ...current,
-    status: normalizeString(payload.status, current.status),
-    status_reason: normalizeString(payload.reason, current.status_reason || null),
-    updated_at_iso: nowIso()
-  };
-  state.economicsAgents.set(agentId, next);
-  return next;
-}
-
-function createEconomicsReceipt(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const receiptId = normalizeString(payload.receipt_id, `econ_receipt_${state.economicsReceipts.size + 1}`);
-  const createdAt = nowIso();
-  const receipt = {
-    receipt_id: receiptId,
-    account_id: accountId,
-    job_id: normalizeString(payload.job_id, null),
-    agent_id: normalizeString(payload.agent_id, null),
-    type: normalizeString(payload.type, "execution_result"),
-    lifecycle_status: normalizeString(payload.lifecycle_status, "recorded"),
-    operator_status: normalizeString(payload.operator_status, "pending_review"),
-    evidence: {
-      hash: normalizeString(payload.hash, null),
-      uri: normalizeString(payload.uri, null)
-    },
-    created_at_iso: createdAt,
-    updated_at_iso: createdAt
-  };
-  state.economicsReceipts.set(receiptId, receipt);
-  return receipt;
-}
-
-function updateEconomicsReceiptLifecycle(state, receiptId, body) {
-  if (!state.economicsReceipts.has(receiptId)) return null;
-  const payload = ensureObject(body);
-  const current = state.economicsReceipts.get(receiptId);
-  const next = {
-    ...current,
-    lifecycle_status: normalizeString(payload.lifecycle_status, current.lifecycle_status),
-    lifecycle_reason: normalizeString(payload.reason, current.lifecycle_reason || null),
-    updated_at_iso: nowIso()
-  };
-  state.economicsReceipts.set(receiptId, next);
-  return next;
-}
-
-function actOnEconomicsReceipt(state, receiptId, body) {
-  if (!state.economicsReceipts.has(receiptId)) return null;
-  const payload = ensureObject(body);
-  const current = state.economicsReceipts.get(receiptId);
-  const historyEntry = {
-    action: normalizeString(payload.action, "reviewed"),
-    actor: normalizeString(payload.actor, "operator"),
-    reason: normalizeString(payload.reason, null),
-    at_iso: nowIso()
-  };
-  const next = {
-    ...current,
-    operator_status: historyEntry.action,
-    operator_history: [...ensureArray(current.operator_history), historyEntry],
-    updated_at_iso: historyEntry.at_iso
-  };
-  state.economicsReceipts.set(receiptId, next);
-  return next;
-}
-
-function recordAllocationEvent(state, body, direction) {
-  const payload = ensureObject(body);
-  const allocationId = normalizeString(payload.allocation_id, `alloc_${state.economicsAllocations.length + 1}`);
-  const event = {
-    allocation_id: allocationId,
-    account_id: normalizeString(payload.account_id, "acct_demo"),
-    budget_id: normalizeString(payload.budget_id, null),
-    job_id: normalizeString(payload.job_id, null),
-    agent_id: normalizeString(payload.agent_id, null),
-    receipt_ref: normalizeString(payload.receipt_ref, null),
-    transaction_id: normalizeString(payload.transaction_id, null),
-    credit_spend_id: normalizeString(payload.credit_spend_id, null),
-    usage_meter_id: normalizeString(payload.usage_meter_id, null),
-    lifecycle_ref: normalizeString(payload.lifecycle_ref, null),
-    reserve_ref: normalizeString(payload.reserve_ref, direction === "reserve" ? `reserve.${allocationId}` : null),
-    commit_ref: normalizeString(payload.commit_ref, direction === "commit" ? `commit.${allocationId}` : null),
-    resolves_allocation_id: normalizeString(payload.resolves_allocation_id, null),
-    units: typeof payload.units === "number" ? payload.units : 0,
-    direction,
-    reason: normalizeString(payload.reason, null),
-    created_at_iso: nowIso()
-  };
-  // Allocation events are the source of truth for credit balances; they must never be truncated.
-  state.economicsAllocations = [event, ...ensureArray(state.economicsAllocations)];
-  return event;
-}
-
-function previewRailCredits(body) {
-  const payload = ensureObject(body);
-  const units = typeof payload.units === "number" ? payload.units : typeof payload.amount_units === "number" ? payload.amount_units : 0;
-  return {
-    account_id: normalizeString(payload.account_id, "acct_demo"),
-    rail_kind: normalizeString(payload.rail_kind, "payment_credit"),
-    units,
-    preview_status: "admissible",
-    normalized_event_kind: "mint",
-    bounded_operator_artifacts: [
-      "rail_summary",
-      "treasury_summary",
-      "reconciliation_pack"
-    ]
-  };
-}
-
-function applyRailCredits(state, body) {
-  const payload = ensureObject(body);
-  const preview = previewRailCredits(payload);
-  const event = {
-    credit_event_id: normalizeString(payload.credit_event_id, `credit_${state.economicsRailCredits.length + 1}`),
-    ...preview,
-    amount_minor: typeof payload.amount_minor === "number" ? payload.amount_minor : null,
-    currency: normalizeString(payload.currency, null),
-    purchase_intent_id: normalizeString(payload.purchase_intent_id, null),
-    provider_reference: normalizeString(payload.provider_reference, null),
-    normalized_event_kind: "mint",
-    reverses_credit_event_id: null,
-    created_at_iso: nowIso(),
-    applied_status: "recorded"
-  };
-  state.economicsRailCredits = [event, ...ensureArray(state.economicsRailCredits)].slice(0, 200);
-  return event;
-}
-
-function reverseRailCredits(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const originalCreditEventId = normalizeString(payload.credit_event_id, null);
-  const purchaseIntentId = normalizeString(payload.purchase_intent_id, null);
-  const providerReference = normalizeString(payload.provider_reference, null);
-  const credits = ensureArray(state.economicsRailCredits);
-  const original = credits.find((entry) => {
-    if (!entry || entry.account_id !== accountId || entry.normalized_event_kind === "reverse") return false;
-    if (originalCreditEventId && entry.credit_event_id === originalCreditEventId) return true;
-    if (purchaseIntentId && entry.purchase_intent_id === purchaseIntentId) return true;
-    if (providerReference && entry.provider_reference === providerReference) return true;
-    return false;
-  });
-
-  if (!original) {
-    return {
-      ok: false,
-      reason: "credit_event_not_found",
-      account_id: accountId,
-      credit_event_id: originalCreditEventId,
-      purchase_intent_id: purchaseIntentId
-    };
-  }
-
-  const existingReversal = credits.find((entry) =>
-    entry
-    && entry.account_id === accountId
-    && entry.normalized_event_kind === "reverse"
-    && entry.reverses_credit_event_id === original.credit_event_id
-  );
-  if (existingReversal) {
-    return {
-      ok: true,
-      reversal: existingReversal,
-      original,
-      already_reversed: true
-    };
-  }
-
-  const reversalUnits = Number.isFinite(Number(payload.units))
-    ? Math.max(0, Number(payload.units))
-    : Math.max(0, Number(original.units || 0));
-  const reversal = {
-    credit_event_id: normalizeString(payload.reversal_credit_event_id, `credit_reverse_${state.economicsRailCredits.length + 1}`),
-    account_id: accountId,
-    rail_kind: normalizeString(payload.rail_kind, original.rail_kind || "payment_credit"),
-    units: reversalUnits,
-    preview_status: "admissible",
-    normalized_event_kind: "reverse",
-    reverses_credit_event_id: original.credit_event_id,
-    amount_minor: Number.isFinite(Number(payload.amount_minor))
-      ? Number(payload.amount_minor)
-      : Number.isFinite(Number(original.amount_minor))
-        ? Number(original.amount_minor)
-        : null,
-    currency: normalizeString(payload.currency, original.currency || null),
-    purchase_intent_id: purchaseIntentId || original.purchase_intent_id || null,
-    provider_reference: providerReference || original.provider_reference || null,
-    reason: normalizeString(payload.reason, "hosted_checkout_refund_compensation"),
-    created_at_iso: nowIso(),
-    applied_status: "recorded"
-  };
-  state.economicsRailCredits = [reversal, ...credits].slice(0, 200);
-  return {
-    ok: true,
-    reversal,
-    original,
-    already_reversed: false
-  };
-}
-
-function summarizeRailCreditLifecycle(credits) {
-  const allCredits = Array.isArray(credits) ? credits : [];
-  return {
-    mint_count: allCredits.filter((entry) => entry && entry.normalized_event_kind !== "reverse").length,
-    reverse_count: allCredits.filter((entry) => entry && entry.normalized_event_kind === "reverse").length,
-    minted_units: allCredits
-      .filter((entry) => entry && entry.normalized_event_kind !== "reverse")
-      .reduce((sum, entry) => sum + Number(entry.units || 0), 0),
-    reversed_units: allCredits
-      .filter((entry) => entry && entry.normalized_event_kind === "reverse")
-      .reduce((sum, entry) => sum + Number(entry.units || 0), 0)
-  };
-}
-
-function listEntitlementsForAccount(state, accountId) {
-  return Array.from(state.economicsEntitlements.values()).filter((item) => item && item.account_id === accountId);
-}
-
-function getEntitlement(state, entitlementId) {
-  if (!entitlementId) return null;
-  return state.economicsEntitlements.get(entitlementId) || null;
-}
-
-function buildEntitlementReplenishmentView(entitlement) {
-  if (!entitlement) return null;
-  const remainingUnits = Number(entitlement.remaining_units || 0);
-  const thresholdUnits = Number(entitlement.low_balance_threshold_units || 25);
-  const lowBalanceState = remainingUnits <= 0 ? "depleted" : remainingUnits <= thresholdUnits ? "low" : "healthy";
-  return {
-    entitlement_id: entitlement.entitlement_id,
-    account_id: entitlement.account_id,
-    pack_id: entitlement.pack_id || null,
-    low_balance_threshold_units: thresholdUnits,
-    low_balance_state: lowBalanceState,
-    recommended_replenishment_pack_id: entitlement.preferred_replacement_pack_id || entitlement.pack_id || null,
-    preferred_external_topup_ref: entitlement.preferred_external_topup_ref || null,
-    remaining_units: remainingUnits,
-    generated_at_iso: nowIso()
-  };
-}
-
-function upsertEntitlementPool(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const entitlementId = normalizeString(payload.entitlement_id, `entitlement_${state.economicsEntitlements.size + 1}`);
-  const now = nowIso();
-  const current = state.economicsEntitlements.get(entitlementId) || null;
-  const issuedUnitsDelta = typeof payload.issued_units === "number" ? payload.issued_units : 0;
-  const next = current ? {
-    ...current,
-    issued_units: (current.issued_units || 0) + issuedUnitsDelta,
-    remaining_units: Math.max(0, ((current.issued_units || 0) + issuedUnitsDelta) - (current.consumed_units || 0)),
-    low_balance_threshold_units: typeof payload.low_balance_threshold_units === "number"
-      ? payload.low_balance_threshold_units
-      : current.low_balance_threshold_units,
-    preferred_replacement_pack_id: normalizeString(payload.preferred_replacement_pack_id, current.preferred_replacement_pack_id || null),
-    preferred_external_topup_ref: normalizeString(payload.preferred_external_topup_ref, current.preferred_external_topup_ref || null),
-    updated_at_iso: now
-  } : {
-    entitlement_id: entitlementId,
-    account_id: accountId,
-    pack_id: normalizeString(payload.pack_id, null),
-    pool_kind: normalizeString(payload.pool_kind, "pack_credit_pool"),
-    source_ref: normalizeString(payload.source_ref, null),
-    issued_units: issuedUnitsDelta,
-    consumed_units: 0,
-    remaining_units: issuedUnitsDelta,
-    low_balance_threshold_units: typeof payload.low_balance_threshold_units === "number" ? payload.low_balance_threshold_units : 25,
-    preferred_replacement_pack_id: normalizeString(payload.preferred_replacement_pack_id, normalizeString(payload.pack_id, null)),
-    preferred_external_topup_ref: normalizeString(payload.preferred_external_topup_ref, null),
-    status: normalizeString(payload.status, "active"),
-    created_at_iso: now,
-    updated_at_iso: now
-  };
-  state.economicsEntitlements.set(entitlementId, next);
-  return next;
-}
-
-function updateEntitlementReplenishmentPreference(state, entitlementId, body) {
-  const current = getEntitlement(state, entitlementId);
-  if (!current) return null;
-  const payload = ensureObject(body);
-  const next = {
-    ...current,
-    low_balance_threshold_units: typeof payload.low_balance_threshold_units === "number"
-      ? payload.low_balance_threshold_units
-      : current.low_balance_threshold_units,
-    preferred_replacement_pack_id: normalizeString(payload.preferred_replacement_pack_id, current.preferred_replacement_pack_id || null),
-    preferred_external_topup_ref: normalizeString(payload.preferred_external_topup_ref, current.preferred_external_topup_ref || null),
-    updated_at_iso: nowIso()
-  };
-  state.economicsEntitlements.set(entitlementId, next);
-  return next;
-}
-
-function buildEntitlementSummary(state, accountId) {
-  const entitlements = listEntitlementsForAccount(state, accountId);
-  const replenishmentViews = entitlements.map((entry) => buildEntitlementReplenishmentView(entry));
-  return {
-    account_id: accountId,
-    entitlement_count: entitlements.length,
-    active_entitlement_count: entitlements.filter((entry) => entry.status === "active" && entry.remaining_units > 0).length,
-    low_entitlement_count: replenishmentViews.filter((entry) => entry && entry.low_balance_state === "low").length,
-    depleted_entitlement_count: replenishmentViews.filter((entry) => entry && entry.low_balance_state === "depleted").length,
-    issued_units: entitlements.reduce((sum, entry) => sum + (entry.issued_units || 0), 0),
-    consumed_units: entitlements.reduce((sum, entry) => sum + (entry.consumed_units || 0), 0),
-    remaining_units: entitlements.reduce((sum, entry) => sum + (entry.remaining_units || 0), 0),
-    pack_ids: Array.from(new Set(entitlements.map((entry) => entry.pack_id).filter(Boolean))),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildEntitlementReplenishmentSummary(state, accountId) {
-  const entitlements = listEntitlementsForAccount(state, accountId);
-  const replenishment = entitlements.map((entry) => buildEntitlementReplenishmentView(entry));
-  return {
-    account_id: accountId,
-    entitlement_count: replenishment.length,
-    low_balance_count: replenishment.filter((entry) => entry && entry.low_balance_state === "low").length,
-    depleted_count: replenishment.filter((entry) => entry && entry.low_balance_state === "depleted").length,
-    recommended_pack_ids: Array.from(new Set(replenishment.map((entry) => entry && entry.recommended_replenishment_pack_id).filter(Boolean))),
-    entitlements: replenishment,
-    generated_at_iso: nowIso()
-  };
-}
-
-function selectEntitlementPool(state, payload) {
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const requestedEntitlementId = normalizeString(payload.entitlement_id, null);
-  const requestedPackId = normalizeString(payload.pack_id, null);
-  if (requestedEntitlementId) {
-    const entitlement = getEntitlement(state, requestedEntitlementId);
-    if (!entitlement || entitlement.account_id !== accountId) {
-      return { ok: false, reason: "entitlement_not_found", entitlement_id: requestedEntitlementId };
-    }
-    if (entitlement.status !== "active" || entitlement.remaining_units <= 0) {
-      return { ok: false, reason: "entitlement_inactive", entitlement_id: requestedEntitlementId };
-    }
-    return { ok: true, entitlement };
-  }
-  const candidates = listEntitlementsForAccount(state, accountId)
-    .filter((entry) => entry.status === "active" && entry.remaining_units > 0)
-    .filter((entry) => !requestedPackId || entry.pack_id === requestedPackId)
-    .sort((left, right) => String(left.created_at_iso).localeCompare(String(right.created_at_iso)) || String(left.entitlement_id).localeCompare(String(right.entitlement_id)));
-  if (candidates.length === 0) {
-    return requestedPackId
-      ? { ok: false, reason: "entitlement_pack_not_found", pack_id: requestedPackId }
-      : { ok: true, entitlement: null };
-  }
-  return { ok: true, entitlement: candidates[0] };
-}
-
-function listCreditSpendsForAccount(state, accountId) {
-  return ensureArray(state.economicsCreditSpends).filter((item) => item && item.account_id === accountId);
-}
-
-function getAllocationEvent(state, allocationId) {
-  if (!allocationId) return null;
-  return ensureArray(state.economicsAllocations).find((item) => item && item.allocation_id === allocationId) || null;
-}
-
-function getCreditSpend(state, creditSpendId) {
-  if (!creditSpendId) return null;
-  return ensureArray(state.economicsCreditSpends).find((item) => item && item.credit_spend_id === creditSpendId) || null;
-}
-
-function getTaskDomain(taskRef) {
-  const task = findTask(taskRef);
-  return task && task.public_category ? task.public_category : null;
-}
-
-function buildCreditSpendPolicyDecision(state, payload) {
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const taskRef = normalizeString(payload.task_ref, null);
-  const taskDomain = getTaskDomain(taskRef);
-  const agentId = normalizeString(payload.agent_id, null);
-  const budgetIdFromPayload = normalizeString(payload.budget_id, null);
-  const agent = agentId ? state.economicsAgents.get(agentId) || null : null;
-
-  if (agentId && !agent) {
-    return {
-      ok: false,
-      reason: "agent_not_found",
-      account_id: accountId,
-      agent_id: agentId
-    };
-  }
-
-  if (agent && agent.account_id !== accountId) {
-    return {
-      ok: false,
-      reason: "agent_account_mismatch",
-      account_id: accountId,
-      agent_id: agentId
-    };
-  }
-
-  if (agent && agent.status !== "active") {
-    return {
-      ok: false,
-      reason: "agent_inactive",
-      account_id: accountId,
-      agent_id: agentId,
-      agent_status: agent.status
-    };
-  }
-
-  if (agent && ensureArray(agent.allowed_job_domains).length > 0 && taskDomain && !ensureArray(agent.allowed_job_domains).includes(taskDomain)) {
-    return {
-      ok: false,
-      reason: "agent_domain_not_allowed",
-      account_id: accountId,
-      agent_id: agentId,
-      task_domain: taskDomain,
-      allowed_job_domains: ensureArray(agent.allowed_job_domains)
-    };
-  }
-
-  const resolvedBudgetId = budgetIdFromPayload || (agent && agent.default_budget_id ? agent.default_budget_id : null);
-  const budget = resolvedBudgetId ? state.economicsBudgets.get(resolvedBudgetId) || null : null;
-
-  if (resolvedBudgetId && !budget) {
-    return {
-      ok: false,
-      reason: "budget_not_found",
-      account_id: accountId,
-      budget_id: resolvedBudgetId
-    };
-  }
-
-  if (budget && budget.account_id !== accountId) {
-    return {
-      ok: false,
-      reason: "budget_account_mismatch",
-      account_id: accountId,
-      budget_id: resolvedBudgetId
-    };
-  }
-
-  if (budget && budget.status !== "active") {
-    return {
-      ok: false,
-      reason: "budget_inactive",
-      account_id: accountId,
-      budget_id: resolvedBudgetId,
-      budget_status: budget.status
-    };
-  }
-
-  if (budget && ensureArray(budget.allowed_job_domains).length > 0 && taskDomain && !ensureArray(budget.allowed_job_domains).includes(taskDomain)) {
-    return {
-      ok: false,
-      reason: "budget_domain_not_allowed",
-      account_id: accountId,
-      budget_id: resolvedBudgetId,
-      task_domain: taskDomain,
-      allowed_job_domains: ensureArray(budget.allowed_job_domains)
-    };
-  }
-
-  return {
-    ok: true,
-    task_domain: taskDomain,
-    agent_id: agent ? agent.agent_id : null,
-    budget_id: budget ? budget.budget_id : null,
-    policy_ref: budget ? budget.policy_ref || null : null,
-    max_reserve_units: budget && typeof budget.max_reserve_units === "number" ? budget.max_reserve_units : null
-  };
-}
-
-function buildCreditBalanceSummary(state, accountId) {
-  const credits = listRailCreditsForAccount(state, accountId);
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const spends = listCreditSpendsForAccount(state, accountId);
-  const railCreditLifecycle = summarizeRailCreditLifecycle(credits);
-  const issuedUnits = allocations.filter((entry) => entry.direction === "mint").reduce((sum, entry) => sum + (entry.units || 0), 0)
-    + railCreditLifecycle.minted_units;
-  const reversedUnits = allocations.filter((entry) => entry.direction === "reverse").reduce((sum, entry) => sum + (entry.units || 0), 0)
-    + railCreditLifecycle.reversed_units;
-  const consumedUnits = spends.reduce((sum, entry) => sum + (entry.units || 0), 0);
-  return {
-    account_id: accountId,
-    issued_units: issuedUnits,
-    consumed_units: consumedUnits,
-    reversed_units: reversedUnits,
-    available_units: Math.max(0, issuedUnits - consumedUnits - reversedUnits),
-    spend_count: spends.length,
-    entitlement_summary: buildEntitlementSummary(state, accountId),
-    metering_summary: buildUsageMeteringSummary(state, accountId),
-    replenishment_summary: buildEntitlementReplenishmentSummary(state, accountId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletSummary(state, accountId) {
-  const balance = buildCreditBalanceSummary(state, accountId);
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const usageMeters = listUsageMetersForAccount(state, accountId);
-  const reserveUnits = allocations
-    .filter((entry) => entry && entry.direction === "reserve")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const committedUnits = allocations
-    .filter((entry) => entry && entry.direction === "commit")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const releasedUnits = allocations
-    .filter((entry) => entry && entry.direction === "release")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const reversedUnits = allocations
-    .filter((entry) => entry && entry.direction === "reverse")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const reserveCount = allocations.filter((entry) => entry && entry.direction === "reserve").length;
-  const walletState = balance.available_units <= 0
-    ? "depleted"
-    : balance.entitlement_summary.low_entitlement_count > 0
-      ? "low_balance"
-      : "healthy";
-
-  return {
-    wallet_version: "xytara-machine-wallet-summary-v1",
-    wallet_id: `wallet_${accountId}`,
-    account_id: accountId,
-    canonical_unit: "usage_units",
-    wallet_state: walletState,
-    issued_units: balance.issued_units,
-    available_units: balance.available_units,
-    reserved_units: reserveUnits,
-    committed_units: committedUnits,
-    released_units: releasedUnits,
-    reversed_units: reversedUnits,
-    consumed_units: balance.consumed_units,
-    reserve_count: reserveCount,
-    entitlement_count: balance.entitlement_summary.entitlement_count,
-    active_entitlement_count: balance.entitlement_summary.active_entitlement_count,
-    usage_meter_count: usageMeters.length,
-    replenishment_posture: balance.replenishment_summary.depleted_count > 0
-      ? "replenishment_required"
-      : balance.replenishment_summary.low_balance_count > 0
-        ? "replenishment_recommended"
-        : "sufficient_capacity",
-    linked_surfaces: {
-      credit_balance_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
-      entitlements_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements`,
-      usage_meters_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/usage-meters`,
-      wallet_commit_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-commit-summary`,
-      wallet_lifecycle_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-lifecycle-summary`,
-      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletLifecycleSummary(state, accountId) {
-  const wallet = buildWalletSummary(state, accountId);
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const railCredits = listRailCreditsForAccount(state, accountId);
-  const creditSpends = listCreditSpendsForAccount(state, accountId);
-  const usageMeters = listUsageMetersForAccount(state, accountId);
-  const railCreditLifecycle = summarizeRailCreditLifecycle(railCredits);
-  const mintedUnits = allocations
-    .filter((entry) => entry && entry.direction === "mint")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0)
-    + railCreditLifecycle.minted_units;
-  const reservedUnits = allocations
-    .filter((entry) => entry && entry.direction === "reserve")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const explicitCommittedUnits = allocations
-    .filter((entry) => entry && entry.direction === "commit")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const explicitCommitSpendIds = new Set(
-    allocations
-      .filter((entry) => entry && entry.direction === "commit" && entry.credit_spend_id)
-      .map((entry) => entry.credit_spend_id)
-  );
-  const fallbackCommittedSpends = creditSpends.filter((entry) => entry && !explicitCommitSpendIds.has(entry.credit_spend_id));
-  const spendCommittedUnits = fallbackCommittedSpends.reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const releasedUnits = allocations
-    .filter((entry) => entry && entry.direction === "release")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-  const reversedUnits = allocations
-    .filter((entry) => entry && entry.direction === "reverse")
-    .reduce((sum, entry) => sum + Number(entry.units || 0), 0)
-    + railCreditLifecycle.reversed_units;
-  const committedUnits = explicitCommittedUnits + spendCommittedUnits;
-  const openReservedUnits = Math.max(0, reservedUnits - releasedUnits);
-  const correctionState = reversedUnits > 0 ? "corrective_activity_present" : "none";
-  const reserveState = openReservedUnits > 0 ? "open_reserves_present" : reservedUnits > 0 ? "reserves_fully_resolved" : "no_reserves_recorded";
-  const commitState = committedUnits > 0 ? "committed_consequence_present" : "no_committed_consequence";
-
-  return {
-    summary_version: "xytara-wallet-lifecycle-summary-v1",
-    wallet_id: wallet.wallet_id,
-    account_id: accountId,
-    canonical_unit: wallet.canonical_unit,
-    canonical_lifecycle_model: "mint_reserve_commit_release_reverse",
-    lifecycle_semantics: {
-      mint: "introduces usage-unit capacity into the hidden machine wallet",
-      reserve: "places bounded pre-execution hold against available capacity before final consequence",
-      commit: "records final consequence against wallet capacity, including live credit-spend consequence",
-      release: "returns previously reserved capacity when bounded execution does not finalize against that hold",
-      reverse: "records explicit corrective removal or rollback against previously issued or committed capacity"
-    },
-    lifecycle_totals: {
-      minted_units: mintedUnits,
-      reserved_units: reservedUnits,
-      committed_units: committedUnits,
-      released_units: releasedUnits,
-      reversed_units: reversedUnits,
-      consumed_units: wallet.consumed_units,
-      open_reserved_units: openReservedUnits,
-      available_units: wallet.available_units
-    },
-    lifecycle_states: {
-      wallet_state: wallet.wallet_state,
-      reserve_state: reserveState,
-      commit_state: commitState,
-      correction_state: correctionState
-    },
-    record_interpretation: {
-      mint_sources: {
-        allocation_mint_count: allocations.filter((entry) => entry && entry.direction === "mint").length,
-        rail_credit_count: railCreditLifecycle.mint_count
-      },
-      reserve_sources: {
-        allocation_reserve_count: allocations.filter((entry) => entry && entry.direction === "reserve").length
-      },
-      commit_sources: {
-        explicit_commit_count: allocations.filter((entry) => entry && entry.direction === "commit").length,
-        derived_credit_spend_commit_count: fallbackCommittedSpends.length,
-        usage_meter_count: usageMeters.length
-      },
-      release_sources: {
-        allocation_release_count: allocations.filter((entry) => entry && entry.direction === "release").length
-      },
-      reverse_sources: {
-        allocation_reverse_count: allocations.filter((entry) => entry && entry.direction === "reverse").length,
-        rail_credit_reverse_count: railCreditLifecycle.reverse_count
-      }
-    },
-    linked_surfaces: {
-      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
-      wallet_commit_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-commit-summary`,
-      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`,
-      credit_balance_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
-      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
-      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletLedgerSummary(state, accountId) {
-  const wallet = buildWalletSummary(state, accountId);
-  const lifecycle = buildWalletLifecycleSummary(state, accountId);
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const spends = listCreditSpendsForAccount(state, accountId);
-  const railCredits = listRailCreditsForAccount(state, accountId);
-  const explicitCommitSpendIds = new Set(
-    allocations
-      .filter((entry) => entry && entry.direction === "commit" && entry.credit_spend_id)
-      .map((entry) => entry.credit_spend_id)
-  );
-  const fallbackCommittedSpends = spends.filter((entry) => entry && !explicitCommitSpendIds.has(entry.credit_spend_id));
-  const consequences = {
-    mint_count: allocations.filter((entry) => entry && entry.direction === "mint").length + railCredits.length,
-    reserve_count: allocations.filter((entry) => entry && entry.direction === "reserve").length,
-    commit_count: allocations.filter((entry) => entry && entry.direction === "commit").length + fallbackCommittedSpends.length,
-    release_count: allocations.filter((entry) => entry && entry.direction === "release").length,
-    reverse_count: allocations.filter((entry) => entry && entry.direction === "reverse").length
-  };
-
-  return {
-    summary_version: "xytara-wallet-ledger-summary-v1",
-    wallet_id: wallet.wallet_id,
-    account_id: accountId,
-    canonical_truth_posture: "allocation_and_consequence_records_with_materialized_wallet_summary",
-    canonical_lifecycle_model: lifecycle.canonical_lifecycle_model,
-    canonical_unit: wallet.canonical_unit,
-    wallet_state: wallet.wallet_state,
-    wallet_summary: {
-      issued_units: wallet.issued_units,
-      available_units: wallet.available_units,
-      reserved_units: wallet.reserved_units,
-      committed_units: wallet.committed_units,
-      released_units: wallet.released_units,
-      reversed_units: wallet.reversed_units,
-      consumed_units: wallet.consumed_units
-    },
-    lifecycle_state_summary: lifecycle.lifecycle_states,
-    ledger_lifecycle_counts: consequences,
-    source_record_counts: {
-      allocation_count: allocations.length,
-      rail_credit_count: railCredits.length,
-      credit_spend_count: spends.length,
-      entitlement_count: wallet.entitlement_count,
-      usage_meter_count: wallet.usage_meter_count
-    },
-    translation_boundary: {
-      public_commercial_shell: "credits",
-      canonical_hidden_unit: "usage_units",
-      canonical_wallet_truth: "hidden_machine_wallet",
-      materialized_projection: "wallet_summary"
-    },
-    linked_surfaces: {
-      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
-      wallet_lifecycle_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-lifecycle-summary`,
-      ledger_export_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/ledger-export`,
-      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletReserveSummary(state, accountId) {
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const reserveEvents = allocations.filter((entry) => entry && entry.direction === "reserve");
-  const resolutionEvents = allocations.filter((entry) => entry && (entry.direction === "release" || entry.direction === "reverse"));
-  const reserveRows = reserveEvents.map((reserve) => {
-    const linkedResolutions = resolutionEvents.filter((entry) => entry && entry.resolves_allocation_id === reserve.allocation_id);
-    const resolvedUnits = linkedResolutions.reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-    const openUnits = Math.max(0, Number(reserve.units || 0) - resolvedUnits);
-    return {
-      reserve_ref: reserve.reserve_ref || `reserve.${reserve.allocation_id}`,
-      allocation_id: reserve.allocation_id,
-      account_id: reserve.account_id,
-      units: Number(reserve.units || 0),
-      open_units: openUnits,
-      reserve_state: openUnits > 0 ? "open" : "resolved",
-      reason: reserve.reason || null,
-      created_at_iso: reserve.created_at_iso || null,
-      linked_resolution_count: linkedResolutions.length,
-      linked_resolutions: linkedResolutions.map((entry) => ({
-        allocation_id: entry.allocation_id,
-        direction: entry.direction,
-        units: Number(entry.units || 0),
-        reason: entry.reason || null,
-        created_at_iso: entry.created_at_iso || null
-      }))
-    };
-  });
-
-  return {
-    summary_version: "xytara-wallet-reserve-summary-v1",
-    account_id: accountId,
-    reserve_count: reserveRows.length,
-    open_reserve_count: reserveRows.filter((entry) => entry.reserve_state === "open").length,
-    resolved_reserve_count: reserveRows.filter((entry) => entry.reserve_state === "resolved").length,
-    total_reserved_units: reserveRows.reduce((sum, entry) => sum + entry.units, 0),
-    total_open_reserved_units: reserveRows.reduce((sum, entry) => sum + entry.open_units, 0),
-    reserves: reserveRows,
-    linked_surfaces: {
-      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
-      wallet_commit_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-commit-summary`,
-      wallet_lifecycle_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-lifecycle-summary`,
-      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletCommitSummary(state, accountId) {
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const commitEvents = allocations.filter((entry) => entry && entry.direction === "commit");
-  const reverseEvents = allocations.filter((entry) => entry && entry.direction === "reverse");
-  const commitRows = commitEvents.map((commit) => {
-    const linkedReversals = reverseEvents.filter((entry) => entry && entry.resolves_allocation_id === commit.allocation_id);
-    const reversedUnits = linkedReversals.reduce((sum, entry) => sum + Number(entry.units || 0), 0);
-    const netCommittedUnits = Math.max(0, Number(commit.units || 0) - reversedUnits);
-    return {
-      commit_ref: commit.commit_ref || `commit.${commit.allocation_id}`,
-      allocation_id: commit.allocation_id,
-      account_id: commit.account_id,
-      credit_spend_id: commit.credit_spend_id || null,
-      usage_meter_id: commit.usage_meter_id || null,
-      transaction_id: commit.transaction_id || null,
-      receipt_ref: commit.receipt_ref || null,
-      units: Number(commit.units || 0),
-      net_committed_units: netCommittedUnits,
-      commit_state: netCommittedUnits > 0 ? "active" : "fully_reversed",
-      reason: commit.reason || null,
-      created_at_iso: commit.created_at_iso || null,
-      linked_reversal_count: linkedReversals.length,
-      linked_reversals: linkedReversals.map((entry) => ({
-        allocation_id: entry.allocation_id,
-        direction: entry.direction,
-        units: Number(entry.units || 0),
-        reason: entry.reason || null,
-        created_at_iso: entry.created_at_iso || null
-      }))
-    };
-  });
-
-  return {
-    summary_version: "xytara-wallet-commit-summary-v1",
-    account_id: accountId,
-    commit_count: commitRows.length,
-    active_commit_count: commitRows.filter((entry) => entry.commit_state === "active").length,
-    fully_reversed_commit_count: commitRows.filter((entry) => entry.commit_state === "fully_reversed").length,
-    total_committed_units: commitRows.reduce((sum, entry) => sum + entry.units, 0),
-    total_net_committed_units: commitRows.reduce((sum, entry) => sum + entry.net_committed_units, 0),
-    commits: commitRows,
-    linked_surfaces: {
-      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
-      wallet_lifecycle_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-lifecycle-summary`,
-      wallet_commit_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-commit-summary`,
-      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildWalletLedgerBundle(state, accountId) {
-  const wallet = buildWalletSummary(state, accountId);
-  const lifecycle = buildWalletLifecycleSummary(state, accountId);
-  const reserves = buildWalletReserveSummary(state, accountId);
-  const commits = buildWalletCommitSummary(state, accountId);
-  const ledger = buildWalletLedgerSummary(state, accountId);
-  const balance = buildCreditBalanceSummary(state, accountId);
-
-  return {
-    bundle_version: "xytara-wallet-ledger-bundle-v1",
-    account_id: accountId,
-    wallet_id: wallet.wallet_id,
-    canonical_unit: wallet.canonical_unit,
-    canonical_truth_posture: ledger.canonical_truth_posture,
-    canonical_lifecycle_model: lifecycle.canonical_lifecycle_model,
-    bundle_state: {
-      wallet_state: wallet.wallet_state,
-      reserve_state: lifecycle.lifecycle_states.reserve_state,
-      commit_state: lifecycle.lifecycle_states.commit_state,
-      correction_state: lifecycle.lifecycle_states.correction_state,
-      replenishment_posture: wallet.replenishment_posture
-    },
-    compact_totals: {
-      issued_units: wallet.issued_units,
-      available_units: wallet.available_units,
-      consumed_units: wallet.consumed_units,
-      open_reserved_units: lifecycle.lifecycle_totals.open_reserved_units,
-      active_commit_units: commits.total_net_committed_units,
-      reversed_units: lifecycle.lifecycle_totals.reversed_units
-    },
-    wallet_summary: wallet,
-    wallet_lifecycle_summary: lifecycle,
-    wallet_reserve_summary: reserves,
-    wallet_commit_summary: commits,
-    wallet_ledger_summary: ledger,
-    credit_balance_summary: balance,
-    linked_surfaces: {
-      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
-      wallet_lifecycle_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-lifecycle-summary`,
-      wallet_reserve_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-reserve-summary`,
-      wallet_commit_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-commit-summary`,
-      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`,
-      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function applyWalletLifecycleEvent(state, body, direction) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const units = typeof payload.units === "number" ? payload.units : 0;
-  if (!(units > 0)) {
-    return { ok: false, reason: "units_must_be_positive", account_id: accountId };
-  }
-
-  let reserveTarget = null;
-  let resolvedTarget = null;
-  if (direction === "release") {
-    const resolvesAllocationId = normalizeString(payload.resolves_allocation_id, null);
-    if (!resolvesAllocationId) {
-      return { ok: false, reason: "resolves_allocation_id_required", account_id: accountId };
-    }
-    reserveTarget = getAllocationEvent(state, resolvesAllocationId);
-    if (!reserveTarget || reserveTarget.account_id !== accountId || reserveTarget.direction !== "reserve") {
-      return { ok: false, reason: "reserve_target_not_found", account_id: accountId, resolves_allocation_id: resolvesAllocationId };
-    }
-  }
-  if (direction === "reverse") {
-    const resolvesAllocationId = normalizeString(payload.resolves_allocation_id, null);
-    if (resolvesAllocationId) {
-      resolvedTarget = getAllocationEvent(state, resolvesAllocationId);
-      if (!resolvedTarget || resolvedTarget.account_id !== accountId) {
-        return { ok: false, reason: "reverse_target_not_found", account_id: accountId, resolves_allocation_id: resolvesAllocationId };
-      }
-    }
-  }
-
-  const lifecycle = buildWalletLifecycleSummary(state, accountId);
-  if (direction === "reserve" && lifecycle.lifecycle_totals.available_units < units) {
-    return {
-      ok: false,
-      reason: "insufficient_available_units",
-      account_id: accountId,
-      available_units: lifecycle.lifecycle_totals.available_units,
-      required_units: units
-    };
-  }
-
-  if (direction === "release" && lifecycle.lifecycle_totals.open_reserved_units < units) {
-    return {
-      ok: false,
-      reason: "insufficient_open_reserved_units",
-      account_id: accountId,
-      open_reserved_units: lifecycle.lifecycle_totals.open_reserved_units,
-      required_units: units
-    };
-  }
-
-  if (direction === "reverse" && lifecycle.lifecycle_totals.available_units < units) {
-    return {
-      ok: false,
-      reason: "insufficient_reversible_units",
-      account_id: accountId,
-      available_units: lifecycle.lifecycle_totals.available_units,
-      required_units: units
-    };
-  }
-
-  const event = recordAllocationEvent(state, {
-    ...payload,
-    reserve_ref: direction === "reserve"
-      ? normalizeString(payload.reserve_ref, null)
-      : reserveTarget
-        ? reserveTarget.reserve_ref || `reserve.${reserveTarget.allocation_id}`
-        : normalizeString(payload.reserve_ref, null)
-    ,
-    commit_ref: resolvedTarget && resolvedTarget.direction === "commit"
-      ? resolvedTarget.commit_ref || `commit.${resolvedTarget.allocation_id}`
-      : normalizeString(payload.commit_ref, null)
-  }, direction);
-  return {
-    ok: true,
-    lifecycle_event: event,
-    wallet_lifecycle_summary: buildWalletLifecycleSummary(state, accountId),
-    wallet_reserve_summary: buildWalletReserveSummary(state, accountId),
-    wallet_commit_summary: buildWalletCommitSummary(state, accountId),
-    balance: buildCreditBalanceSummary(state, accountId)
-  };
-}
-
-function getWorkflowTaskRefs(workflowRef) {
-  const workflow = findWorkflow(workflowRef);
-  if (!workflow || !Array.isArray(workflow.tasks)) return [];
-  return workflow.tasks
-    .map((entry) => entry && (entry.task_ref || entry.public_task_ref || entry.task_id))
-    .filter(Boolean);
-}
-
-function buildUsageMeterBase(payload) {
-  const taskRef = normalizeString(payload.task_ref, null);
-  const workflowRef = normalizeString(payload.workflow_ref, null);
-  const task = taskRef ? findTask(taskRef) : null;
-  const workflowTaskRefs = workflowRef ? getWorkflowTaskRefs(workflowRef) : [];
-  const workflowTasks = workflowTaskRefs.map((ref) => findTask(ref)).filter(Boolean);
-  const pricingBand = task
-    ? task.pricing_band
-    : workflowTasks.length > 0
-      ? workflowTasks.reduce((selected, entry) => {
-          const currentUnits = PRICING_BAND_UNITS[entry.pricing_band] || 1;
-          const selectedUnits = PRICING_BAND_UNITS[selected] || 1;
-          return currentUnits > selectedUnits ? entry.pricing_band : selected;
-        }, workflowTasks[0].pricing_band || "utility")
-      : "utility";
-  const taskDomain = task
-    ? task.public_category || null
-    : workflowTasks.length > 0
-      ? Array.from(new Set(workflowTasks.map((entry) => entry.public_category).filter(Boolean))).join(",")
-      : null;
-  const suggestedUnits = task
-    ? (PRICING_BAND_UNITS[task.pricing_band] || 1)
-    : workflowTasks.length > 0
-      ? workflowTasks.reduce((sum, entry) => sum + (PRICING_BAND_UNITS[entry.pricing_band] || 1), 0)
-      : 1;
-  return {
-    task_ref: taskRef,
-    workflow_ref: workflowRef,
-    pricing_band: pricingBand,
-    task_domain: taskDomain,
-    workflow_task_refs: workflowTaskRefs,
-    suggested_units: suggestedUnits
-  };
-}
-
-function resolveUsageMeterUnits(payload, base) {
-  if (typeof payload.units === "number" && Number.isFinite(payload.units) && payload.units > 0) return payload.units;
-  if (typeof payload.quoted_units === "number" && Number.isFinite(payload.quoted_units) && payload.quoted_units > 0) return payload.quoted_units;
-  return base.suggested_units;
-}
-
-function createUsageMeterRecord(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const base = buildUsageMeterBase(payload);
-  const units = resolveUsageMeterUnits(payload, base);
-  const meterInput = {
-    account_id: accountId,
-    task_ref: base.task_ref,
-    workflow_ref: base.workflow_ref,
-    pricing_band: base.pricing_band,
-    task_domain: base.task_domain,
-    units,
-    quote_id: normalizeString(payload.quote_id, null),
-    credit_spend_id: normalizeString(payload.credit_spend_id, null),
-    transaction_id: normalizeString(payload.transaction_id, null),
-    meter_kind: normalizeString(payload.meter_kind, "credit_spend"),
-    pack_id: normalizeString(payload.pack_id, null),
-    entitlement_id: normalizeString(payload.entitlement_id, null)
-  };
-  const fingerprint = crypto.createHash("sha256").update(JSON.stringify(meterInput)).digest("hex").slice(0, 16);
-  const usageMeterId = normalizeString(payload.usage_meter_id, `usage_meter_${fingerprint}`);
-  const createdAt = nowIso();
-  const record = {
-    usage_meter_id: usageMeterId,
-    ...meterInput,
-    workflow_task_refs: base.workflow_task_refs,
-    deterministic_profile: {
-      pricing_band: base.pricing_band,
-      suggested_units: base.suggested_units,
-      explicit_units: typeof payload.units === "number" || typeof payload.quoted_units === "number"
-    },
-    created_at_iso: createdAt
-  };
-  state.economicsUsageMeters.set(usageMeterId, record);
-  return record;
-}
-
-function listUsageMetersForAccount(state, accountId) {
-  return Array.from(state.economicsUsageMeters.values())
-    .filter((item) => item && item.account_id === accountId)
-    .sort((left, right) => String(right.created_at_iso || "").localeCompare(String(left.created_at_iso || "")) || String(right.usage_meter_id || "").localeCompare(String(left.usage_meter_id || "")));
-}
-
-function getUsageMeter(state, usageMeterId) {
-  if (!usageMeterId) return null;
-  return state.economicsUsageMeters.get(usageMeterId) || null;
-}
-
-function buildUsageMeterPreview(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const base = buildUsageMeterBase(payload);
-  const units = resolveUsageMeterUnits(payload, base);
-  return {
-    ok: true,
-    account_id: accountId,
-    task_ref: base.task_ref,
-    workflow_ref: base.workflow_ref,
-    pricing_band: base.pricing_band,
-    task_domain: base.task_domain,
-    workflow_task_refs: base.workflow_task_refs,
-    usage_units: units,
-    deterministic_profile: {
-      pricing_band: base.pricing_band,
-      suggested_units: base.suggested_units,
-      explicit_units: typeof payload.units === "number" || typeof payload.quoted_units === "number"
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildUsageMeteringSummary(state, accountId) {
-  const usageMeters = listUsageMetersForAccount(state, accountId);
-  return {
-    account_id: accountId,
-    usage_meter_count: usageMeters.length,
-    total_units: usageMeters.reduce((sum, entry) => sum + Number(entry.units || 0), 0),
-    pricing_bands: Array.from(new Set(usageMeters.map((entry) => entry.pricing_band).filter(Boolean))),
-    latest_usage_meter_id: usageMeters.length > 0 ? usageMeters[0].usage_meter_id : null,
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildEconomicConsequenceHandoffBundle(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const usageMeterId = normalizeString(payload.usage_meter_id, null);
-  const creditSpendId = normalizeString(payload.credit_spend_id, null);
-  if (!usageMeterId) {
-    return { ok: false, reason: "usage_meter_id_required" };
-  }
-  if (!creditSpendId) {
-    return { ok: false, reason: "credit_spend_id_required" };
-  }
-  const usageMeter = getUsageMeter(state, usageMeterId);
-  if (!usageMeter || usageMeter.account_id !== accountId) {
-    return { ok: false, reason: "usage_meter_not_found", usage_meter_id: usageMeterId };
-  }
-  const creditSpend = getCreditSpend(state, creditSpendId);
-  if (!creditSpend || creditSpend.account_id !== accountId) {
-    return { ok: false, reason: "credit_spend_not_found", credit_spend_id: creditSpendId };
-  }
-  if (normalizeString(usageMeter.credit_spend_id, null) !== creditSpend.credit_spend_id) {
-    return {
-      ok: false,
-      reason: "usage_meter_credit_spend_mismatch",
-      usage_meter_id: usageMeterId,
-      credit_spend_id: creditSpendId
-    };
-  }
-  const meterProfileRef = normalizeString(payload.meter_profile_ref, `meter-profile.${usageMeter.pricing_band || "utility"}.v1`);
-  const paymentRef = normalizeString(payload.payment_ref, null);
-  const settlementRef = normalizeString(payload.settlement_ref, null);
-  const settlementTxid = normalizeString(payload.settlement_txid, null);
-  const settlementStatus = normalizeString(payload.settlement_status, null);
-  const settlementFinalityStatus = normalizeString(payload.settlement_finality_status, null);
-  const treasuryReceiptRef = normalizeString(payload.treasury_receipt_ref, null);
-  const proofRef = normalizeString(payload.proof_ref, null);
-  const handoffBundle = {
-    contract_version: "naxytra-economic-consequence-handoff-v1",
-    source_system: "xytara",
-    account_ref: accountId,
-    usage_meter_ref: usageMeter.usage_meter_id,
-    meter_profile_ref: meterProfileRef,
-    credit_spend_ref: creditSpend.credit_spend_id,
-    usage_meter: usageMeter,
-    credit_spend: creditSpend,
-    payment_ref: paymentRef,
-    settlement_ref: settlementRef,
-    settlement_txid: settlementTxid,
-    settlement_status: settlementStatus,
-    settlement_finality_status: settlementFinalityStatus,
-    treasury_receipt_ref: treasuryReceiptRef,
-    proof_ref: proofRef,
-    handoff_surfaces: {
-      proof_bridge_surface: "/v1/proof-center/bridge/economic-handoff",
-      proof_conformance_surface: "/v1/proof-center/bridge/economic-conformance-pack"
-    },
-    generated_at_iso: nowIso()
-  };
-  return {
-    ok: true,
-    handoff_bundle: handoffBundle
-  };
-}
-
-function consumeAccountCredits(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const usageMeterPreview = buildUsageMeterPreview(state, payload);
-  const units = usageMeterPreview.usage_units;
-  const balance = buildCreditBalanceSummary(state, accountId);
-  const policyDecision = buildCreditSpendPolicyDecision(state, payload);
-  const entitlementDecision = selectEntitlementPool(state, payload);
-  if (!policyDecision.ok) {
-    return {
-      ok: false,
-      ...policyDecision
-    };
-  }
-  if (!entitlementDecision.ok) {
-    return {
-      ok: false,
-      ...entitlementDecision
-    };
-  }
-  if (balance.available_units < units) {
-    return {
-      ok: false,
-      reason: "insufficient_credits",
-      required_units: units,
-      available_units: balance.available_units
-    };
-  }
-  if (policyDecision.budget_id) {
-    const alreadySpentUnderBudget = listCreditSpendsForAccount(state, accountId)
-      .filter((entry) => entry && entry.budget_id === policyDecision.budget_id)
-      .reduce((sum, entry) => sum + (entry.units || 0), 0);
-    const nextSpentUnderBudget = alreadySpentUnderBudget + units;
-    if (policyDecision.max_reserve_units != null && nextSpentUnderBudget > policyDecision.max_reserve_units) {
-      return {
-        ok: false,
-        reason: "budget_limit_exceeded",
-        budget_id: policyDecision.budget_id,
-        max_reserve_units: policyDecision.max_reserve_units,
-        attempted_units: units,
-        spent_units: alreadySpentUnderBudget,
-        next_spent_units: nextSpentUnderBudget
-      };
-    }
-  }
-  const spend = {
-    credit_spend_id: normalizeString(payload.credit_spend_id, `credit_spend_${ensureArray(state.economicsCreditSpends).length + 1}`),
-    account_id: accountId,
-    transaction_id: normalizeString(payload.transaction_id, null),
-    receipt_id: normalizeString(payload.receipt_id, null),
-    quote_id: normalizeString(payload.quote_id, null),
-    task_ref: normalizeString(payload.task_ref, null),
-    task_domain: policyDecision.task_domain,
-    agent_id: policyDecision.agent_id,
-    budget_id: policyDecision.budget_id,
-    policy_ref: policyDecision.policy_ref,
-    entitlement_id: entitlementDecision.entitlement ? entitlementDecision.entitlement.entitlement_id : null,
-    pack_id: entitlementDecision.entitlement ? entitlementDecision.entitlement.pack_id || null : normalizeString(payload.pack_id, null),
-    units,
-    reason: normalizeString(payload.reason, "execution_credit_spend"),
-    created_at_iso: nowIso()
-  };
-  const usageMeter = createUsageMeterRecord(state, {
-    account_id: accountId,
-    task_ref: spend.task_ref,
-    workflow_ref: normalizeString(payload.workflow_ref, null),
-    task_domain: spend.task_domain,
-    units,
-    quote_id: spend.quote_id,
-    credit_spend_id: spend.credit_spend_id,
-    transaction_id: spend.transaction_id,
-    pack_id: spend.pack_id,
-    entitlement_id: spend.entitlement_id,
-    meter_kind: "credit_spend"
-  });
-  spend.usage_meter_id = usageMeter.usage_meter_id;
-  spend.usage_meter = {
-    usage_meter_id: usageMeter.usage_meter_id,
-    pricing_band: usageMeter.pricing_band,
-    units: usageMeter.units
-  };
-  if (entitlementDecision.entitlement) {
-    const nextEntitlement = {
-      ...entitlementDecision.entitlement,
-      consumed_units: (entitlementDecision.entitlement.consumed_units || 0) + units,
-      remaining_units: Math.max(0, (entitlementDecision.entitlement.remaining_units || 0) - units),
-      updated_at_iso: spend.created_at_iso
-    };
-    state.economicsEntitlements.set(nextEntitlement.entitlement_id, nextEntitlement);
-    spend.entitlement = {
-      entitlement_id: nextEntitlement.entitlement_id,
-      pack_id: nextEntitlement.pack_id || null,
-      remaining_units: nextEntitlement.remaining_units
-    };
-  }
-  recordAllocationEvent(state, {
-    allocation_id: `alloc_commit_${spend.credit_spend_id}`,
-    account_id: accountId,
-    budget_id: spend.budget_id,
-    job_id: normalizeString(payload.job_id, null),
-    agent_id: spend.agent_id,
-    receipt_ref: spend.receipt_id,
-    transaction_id: spend.transaction_id,
-    credit_spend_id: spend.credit_spend_id,
-    usage_meter_id: usageMeter.usage_meter_id,
-    lifecycle_ref: `commit.${spend.credit_spend_id}`,
-    commit_ref: `commit.${spend.credit_spend_id}`,
-    units,
-    reason: spend.reason
-  }, "commit");
-  state.economicsCreditSpends = [spend, ...ensureArray(state.economicsCreditSpends)].slice(0, 500);
-  return {
-    ok: true,
-    credit_spend: spend,
-    balance: buildCreditBalanceSummary(state, accountId)
-  };
-}
-
-function previewCreditSpend(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const usageMeterPreview = buildUsageMeterPreview(state, payload);
-  const units = usageMeterPreview.usage_units;
-  const balance = buildCreditBalanceSummary(state, accountId);
-  const policyDecision = buildCreditSpendPolicyDecision(state, payload);
-  const entitlementDecision = selectEntitlementPool(state, payload);
-  const preview = {
-    ok: Boolean(policyDecision.ok),
-    account_id: accountId,
-    task_ref: normalizeString(payload.task_ref, null),
-    units,
-    balance,
-    spend_posture: policyDecision.budget_id || policyDecision.agent_id ? "bounded_spend" : "open_spend",
-    entitlement_guard: {
-      reason: entitlementDecision.reason || null,
-      entitlement_id: entitlementDecision.entitlement ? entitlementDecision.entitlement.entitlement_id : normalizeString(payload.entitlement_id, null),
-      pack_id: entitlementDecision.entitlement ? entitlementDecision.entitlement.pack_id || null : normalizeString(payload.pack_id, null)
-    },
-    policy_guard: {
-      reason: policyDecision.reason || null,
-      task_domain: policyDecision.task_domain || null,
-      agent_id: policyDecision.agent_id || normalizeString(payload.agent_id, null),
-      budget_id: policyDecision.budget_id || normalizeString(payload.budget_id, null),
-      policy_ref: policyDecision.policy_ref || null,
-      max_reserve_units: policyDecision.max_reserve_units || null,
-      allowed_job_domains: policyDecision.allowed_job_domains || null,
-      budget_status: policyDecision.budget_status || null,
-      agent_status: policyDecision.agent_status || null
-    },
-    credit_spend_preview: {
-      available_units: balance.available_units,
-      required_units: units,
-      executable_now: false,
-      next_balance_units: balance.available_units,
-      failure_reason: null
-    },
-    usage_meter_preview: usageMeterPreview,
-    generated_at_iso: nowIso()
-  };
-
-  if (!policyDecision.ok) {
-    preview.credit_spend_preview.failure_reason = policyDecision.reason;
-    return preview;
-  }
-
-  if (!entitlementDecision.ok) {
-    preview.ok = false;
-    preview.credit_spend_preview.failure_reason = entitlementDecision.reason;
-    return preview;
-  }
-
-  if (balance.available_units < units) {
-    preview.ok = false;
-    preview.credit_spend_preview.failure_reason = "insufficient_credits";
-    return preview;
-  }
-
-  if (policyDecision.budget_id) {
-    const alreadySpentUnderBudget = listCreditSpendsForAccount(state, accountId)
-      .filter((entry) => entry && entry.budget_id === policyDecision.budget_id)
-      .reduce((sum, entry) => sum + (entry.units || 0), 0);
-    const nextSpentUnderBudget = alreadySpentUnderBudget + units;
-    preview.credit_spend_preview.budget_spent_units = alreadySpentUnderBudget;
-    preview.credit_spend_preview.next_budget_spent_units = nextSpentUnderBudget;
-    if (policyDecision.max_reserve_units != null && nextSpentUnderBudget > policyDecision.max_reserve_units) {
-      preview.ok = false;
-      preview.credit_spend_preview.failure_reason = "budget_limit_exceeded";
-      return preview;
-    }
-  }
-
-  preview.credit_spend_preview.executable_now = true;
-  preview.credit_spend_preview.next_balance_units = Math.max(0, balance.available_units - units);
-  preview.credit_spend_preview.entitlement_id = entitlementDecision.entitlement ? entitlementDecision.entitlement.entitlement_id : null;
-  preview.credit_spend_preview.pack_id = entitlementDecision.entitlement ? entitlementDecision.entitlement.pack_id || null : normalizeString(payload.pack_id, null);
-  preview.credit_spend_preview.usage_meter_units = preview.usage_meter_preview.usage_units;
-  preview.credit_spend_preview.pricing_band = preview.usage_meter_preview.pricing_band;
-  return preview;
-}
-
-function listMapValuesByAccount(map, accountId) {
-  return Array.from(map.values()).filter((item) => item && item.account_id === accountId);
-}
-
-function listAllocationEventsForAccount(state, accountId) {
-  return ensureArray(state.economicsAllocations).filter((item) => item && item.account_id === accountId);
-}
-
-function listRailCreditsForAccount(state, accountId) {
-  return ensureArray(state.economicsRailCredits).filter((item) => item && item.account_id === accountId);
-}
-
-function listPaymentLedgerForAccount(state, accountId) {
-  return ensureArray(state.paymentLedger).filter((item) => item && item.account_id === accountId);
-}
-
-function listTransactionsForAccount(state, accountId) {
-  return Array.from(state.transactions.values())
-    .map((entry) => entry && entry.transaction)
-    .filter((item) => item && item.account_id === accountId);
-}
-
-function listReceiptsForAccount(state, accountId) {
-  return Array.from(state.receipts.values())
-    .map((entry) => entry && entry.receipt)
-    .filter((item) => item && item.account_id === accountId);
-}
-
-function listEconomicsJobActionsForAccount(state, accountId) {
-  return ensureArray(state.economicsJobActions).filter((item) => item && item.account_id === accountId);
-}
-
-function buildTreasurySummary(state, accountId) {
-  const allocations = listAllocationEventsForAccount(state, accountId);
-  const credits = listRailCreditsForAccount(state, accountId);
-  const spends = listCreditSpendsForAccount(state, accountId);
-  const paymentLedger = listPaymentLedgerForAccount(state, accountId);
-  const budgets = listMapValuesByAccount(state.economicsBudgets, accountId);
-  const railCreditLifecycle = summarizeRailCreditLifecycle(credits);
-  const mintedUnits = allocations.filter((entry) => entry.direction === "mint").reduce((sum, entry) => sum + (entry.units || 0), 0)
-    + railCreditLifecycle.minted_units;
-  const reversedUnits = allocations.filter((entry) => entry.direction === "reverse").reduce((sum, entry) => sum + (entry.units || 0), 0)
-    + railCreditLifecycle.reversed_units;
-  const consumedUnits = spends.reduce((sum, entry) => sum + (entry.units || 0), 0);
-  const settledMinor = paymentLedger.reduce((sum, entry) => sum + (entry.amount_minor || 0), 0);
-  const committedUnits = listTransactionsForAccount(state, accountId).length;
-  return {
-    account_id: accountId,
-    treasury: {
-      minted_units: mintedUnits,
-      consumed_units: consumedUnits,
-      available_units: Math.max(0, mintedUnits - consumedUnits - reversedUnits),
-      committed_units: committedUnits,
-      reversed_units: reversedUnits,
-      settled_amount_minor: settledMinor
-    },
-    budgets: {
-      total: budgets.length,
-      active: budgets.filter((entry) => entry.status === "active").length,
-      total_committed_units: committedUnits
-    },
-    payment_ledger_count: paymentLedger.length,
-    generated_at_iso: nowIso()
-  };
-}
-
-function selectRecommendedCreditPack(totalUnits, usageMeterCount) {
-  if (totalUnits >= 1500 || usageMeterCount >= 20) return "credits.fleet";
-  if (totalUnits >= 500 || usageMeterCount >= 10) return "credits.agent";
-  if (totalUnits >= 100 || usageMeterCount >= 3) return "credits.builder";
-  if (totalUnits > 0 || usageMeterCount > 0) return "credits.starter";
-  return null;
-}
-
-function buildEconomicsIntelligenceSummary(state, accountId) {
-  const balanceSummary = buildCreditBalanceSummary(state, accountId);
-  const meteringSummary = buildUsageMeteringSummary(state, accountId);
-  const replenishmentSummary = buildEntitlementReplenishmentSummary(state, accountId);
-  const treasurySummary = buildTreasurySummary(state, accountId);
-
-  const usageMeterCount = Number(meteringSummary.usage_meter_count || 0);
-  const totalUnits = Number(meteringSummary.total_units || 0);
-  const availableUnits = Number(balanceSummary.available_units || 0);
-  const consumedUnits = Number(balanceSummary.consumed_units || 0);
-  const lowBalanceCount = Number(replenishmentSummary.low_balance_count || 0);
-  const depletedCount = Number(replenishmentSummary.depleted_count || 0);
-  const mintedUnits = Number(treasurySummary.treasury && treasurySummary.treasury.minted_units || 0);
-  const settledAmountMinor = Number(treasurySummary.treasury && treasurySummary.treasury.settled_amount_minor || 0);
-  const budgetCount = Number(treasurySummary.budgets && treasurySummary.budgets.total || 0);
-
-  let recommendedFundingPosture = "direct_pay_first";
-  if (availableUnits > 0 || consumedUnits > 0 || usageMeterCount > 0) {
-    recommendedFundingPosture = "credits_first";
-  }
-  if (availableUnits <= 0 && (usageMeterCount > 0 || consumedUnits > 0)) {
-    recommendedFundingPosture = "pack_backed_credits_first";
-  }
-
-  const recommendedPackId = replenishmentSummary.recommended_pack_ids[0] || selectRecommendedCreditPack(totalUnits, usageMeterCount);
-
-  let replenishmentRiskState = "low";
-  if (lowBalanceCount > 0) replenishmentRiskState = "watch";
-  if (depletedCount > 0 || (availableUnits > 0 && availableUnits <= Math.max(8, totalUnits))) {
-    replenishmentRiskState = "high";
-  }
-
-  let treasuryHealthState = "healthy";
-  if (mintedUnits === 0 && settledAmountMinor === 0 && usageMeterCount === 0) {
-    treasuryHealthState = "pre_funding";
-  } else if (availableUnits <= 0 && (consumedUnits > 0 || usageMeterCount > 0)) {
-    treasuryHealthState = "constrained";
-  } else if (lowBalanceCount > 0 || budgetCount > 0) {
-    treasuryHealthState = "watch";
-  }
-
-  let nextBestAction = "continue_current_posture";
-  if (recommendedFundingPosture === "direct_pay_first") {
-    nextBestAction = "start_with_direct_pay";
-  }
-  if (recommendedFundingPosture === "credits_first" && recommendedPackId && usageMeterCount >= 3) {
-    nextBestAction = "consider_pack_funding";
-  }
-  if (replenishmentRiskState === "watch") {
-    nextBestAction = "prepare_replenishment";
-  }
-  if (replenishmentRiskState === "high") {
-    nextBestAction = "replenish_credits";
-  }
-  if (treasuryHealthState === "constrained") {
-    nextBestAction = "restore_runtime_balance";
-  }
-
-  return {
-    account_id: accountId,
-    category: "machine-commerce-account-economics-intelligence-summary",
-    recommended_funding_posture: recommendedFundingPosture,
-    recommended_pack_id: recommendedPackId,
-    replenishment_risk_state: replenishmentRiskState,
-    treasury_health_state: treasuryHealthState,
-    next_best_action: nextBestAction,
-    explanation_signals: {
-      available_units: availableUnits,
-      consumed_units: consumedUnits,
-      usage_meter_count: usageMeterCount,
-      metered_units: totalUnits,
-      low_balance_count: lowBalanceCount,
-      depleted_count: depletedCount,
-      recommended_replenishment_pack_ids: replenishmentSummary.recommended_pack_ids,
-      pricing_bands: meteringSummary.pricing_bands,
-      minted_units: mintedUnits,
-      settled_amount_minor: settledAmountMinor,
-      budget_count: budgetCount
-    },
-    linked_surfaces: {
-      credit_balance_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
-      metering_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/metering-summary`,
-      entitlement_replenishment_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements/replenishment-summary`,
-      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
-      operator_dashboard_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/operator-dashboard`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTreasuryIntelligenceSummary(state, accountId) {
-  const treasurySummary = buildTreasurySummary(state, accountId);
-  const treasuryDrilldown = buildTreasuryDrilldown(state, accountId);
-  const reconciliationPack = buildReconciliationPack(state, accountId);
-  const meteringSummary = buildUsageMeteringSummary(state, accountId);
-  const balanceSummary = buildCreditBalanceSummary(state, accountId);
-  const railSummary = buildRailSummary(state, accountId);
-
-  const mintedUnits = Number(treasurySummary.treasury.minted_units || 0);
-  const consumedUnits = Number(treasurySummary.treasury.consumed_units || 0);
-  const availableUnits = Number(treasurySummary.treasury.available_units || 0);
-  const settledAmountMinor = Number(treasurySummary.treasury.settled_amount_minor || 0);
-  const usageMeterCount = Number(meteringSummary.usage_meter_count || 0);
-  const pendingTransactions = Number(treasuryDrilldown.unresolved_flags.pending_transactions || 0);
-  const pendingReceipts = Number(treasuryDrilldown.unresolved_flags.pending_receipts || 0);
-  const disputedReceipts = Number(reconciliationPack.unresolved_state.disputed_receipt_count || 0);
-  const escalatedReceipts = Number(reconciliationPack.unresolved_state.escalated_receipt_count || 0);
-  const paymentLedgerCount = Number(treasurySummary.payment_ledger_count || 0);
-  const railCreditEventCount = Number(railSummary.credit_event_count || 0);
-
-  let treasuryEfficiencyState = "healthy";
-  if (mintedUnits === 0 && settledAmountMinor === 0 && usageMeterCount === 0) {
-    treasuryEfficiencyState = "pre_funding";
-  } else if (availableUnits <= 0 && (consumedUnits > 0 || usageMeterCount > 0)) {
-    treasuryEfficiencyState = "constrained";
-  } else if (pendingTransactions > 0 || pendingReceipts > 0) {
-    treasuryEfficiencyState = "watch";
-  }
-
-  let valueCaptureState = "aligned";
-  if (usageMeterCount === 0 && paymentLedgerCount === 0 && railCreditEventCount === 0) {
-    valueCaptureState = "pre_conversion";
-  } else if (usageMeterCount >= 3 && paymentLedgerCount <= 1 && consumedUnits > 0) {
-    valueCaptureState = "repeat_use_ready";
-  } else if (consumedUnits > mintedUnits && mintedUnits > 0) {
-    valueCaptureState = "leaking";
-  }
-
-  let reconciliationRiskState = "low";
-  if (pendingTransactions > 0 || pendingReceipts > 0) reconciliationRiskState = "watch";
-  if (disputedReceipts > 0 || escalatedReceipts > 0) reconciliationRiskState = "high";
-
-  let replenishmentFatigueState = "low";
-  if (railCreditEventCount >= 2 && availableUnits <= Math.max(8, meteringSummary.total_units || 0)) {
-    replenishmentFatigueState = "watch";
-  }
-  if (railCreditEventCount >= 3 && balanceSummary.replenishment_summary.low_balance_count > 0) {
-    replenishmentFatigueState = "high";
-  }
-
-  let nextBestAction = "continue_treasury_posture";
-  if (treasuryEfficiencyState === "pre_funding") {
-    nextBestAction = "establish_runtime_funding";
-  } else if (treasuryEfficiencyState === "constrained") {
-    nextBestAction = "restore_runtime_balance";
-  } else if (reconciliationRiskState === "high") {
-    nextBestAction = "review_reconciliation_pack";
-  } else if (reconciliationRiskState === "watch") {
-    nextBestAction = "inspect_treasury_drilldown";
-  } else if (replenishmentFatigueState === "high" || valueCaptureState === "repeat_use_ready") {
-    nextBestAction = "recommend_larger_pack_posture";
-  }
-
-  return {
-    account_id: accountId,
-    category: "machine-commerce-account-treasury-intelligence-summary",
-    treasury_efficiency_state: treasuryEfficiencyState,
-    value_capture_state: valueCaptureState,
-    reconciliation_risk_state: reconciliationRiskState,
-    replenishment_fatigue_state: replenishmentFatigueState,
-    next_best_action: nextBestAction,
-    explanation_signals: {
-      minted_units: mintedUnits,
-      consumed_units: consumedUnits,
-      available_units: availableUnits,
-      settled_amount_minor: settledAmountMinor,
-      usage_meter_count: usageMeterCount,
-      payment_ledger_count: paymentLedgerCount,
-      rail_credit_event_count: railCreditEventCount,
-      pending_transaction_count: pendingTransactions,
-      pending_receipt_count: pendingReceipts,
-      disputed_receipt_count: disputedReceipts,
-      escalated_receipt_count: escalatedReceipts
-    },
-    linked_surfaces: {
-      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
-      treasury_drilldown_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-drilldown`,
-      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`,
-      metering_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/metering-summary`,
-      rail_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/rail-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildLedgerExport(state, accountId) {
-  return {
-    export_version: "xytara-economics-ledger-export-v1",
-    account: {
-      account_id: accountId
-    },
-    budgets: listMapValuesByAccount(state.economicsBudgets, accountId),
-    agents: listMapValuesByAccount(state.economicsAgents, accountId),
-    economics_receipts: listMapValuesByAccount(state.economicsReceipts, accountId),
-    entitlements: listEntitlementsForAccount(state, accountId),
-    allocations: listAllocationEventsForAccount(state, accountId),
-    rail_credits: listRailCreditsForAccount(state, accountId),
-    credit_spends: listCreditSpendsForAccount(state, accountId),
-    payment_ledger: listPaymentLedgerForAccount(state, accountId),
-    governed_transactions: listTransactionsForAccount(state, accountId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTreasuryDrilldown(state, accountId) {
-  const summary = buildTreasurySummary(state, accountId);
-  const paymentLedger = listPaymentLedgerForAccount(state, accountId);
-  return {
-    account_id: accountId,
-    summary,
-    latest_payment_entries: paymentLedger.slice(0, 10),
-    latest_allocation_entries: listAllocationEventsForAccount(state, accountId).slice(0, 10),
-    latest_credit_entries: listRailCreditsForAccount(state, accountId).slice(0, 10),
-    latest_entitlement_entries: listEntitlementsForAccount(state, accountId).slice(0, 10),
-    latest_credit_spend_entries: listCreditSpendsForAccount(state, accountId).slice(0, 10),
-    unresolved_flags: {
-      pending_transactions: listTransactionsForAccount(state, accountId).filter((entry) => entry.status !== "completed").length,
-      pending_receipts: listMapValuesByAccount(state.economicsReceipts, accountId).filter((entry) => entry.lifecycle_status !== "validated").length
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildReconciliationPack(state, accountId) {
-  const treasury = buildTreasurySummary(state, accountId);
-  const paymentLedger = listPaymentLedgerForAccount(state, accountId);
-  return {
-    pack_version: "xytara-economics-reconciliation-pack-v1",
-    account_id: accountId,
-    treasury_summary: treasury,
-    payment_ledger_count: paymentLedger.length,
-    transaction_count: listTransactionsForAccount(state, accountId).length,
-    canonical_state: {
-      budgets: listMapValuesByAccount(state.economicsBudgets, accountId).length,
-      agents: listMapValuesByAccount(state.economicsAgents, accountId).length,
-      economics_receipts: listMapValuesByAccount(state.economicsReceipts, accountId).length,
-      entitlements: listEntitlementsForAccount(state, accountId).length
-    },
-    unresolved_state: {
-      disputed_receipt_count: listMapValuesByAccount(state.economicsReceipts, accountId).filter((entry) => entry.operator_status === "disputed").length,
-      escalated_receipt_count: listMapValuesByAccount(state.economicsReceipts, accountId).filter((entry) => entry.operator_status === "escalated").length
-    },
-    replenishment_summary: buildEntitlementReplenishmentSummary(state, accountId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildAccountSummary(state, accountId) {
-  const budgets = listMapValuesByAccount(state.economicsBudgets, accountId);
-  const agents = listMapValuesByAccount(state.economicsAgents, accountId);
-  const economicsReceipts = listMapValuesByAccount(state.economicsReceipts, accountId);
-  const governedTransactions = listTransactionsForAccount(state, accountId);
-  return {
-    account_id: accountId,
-    advisory_state: {
-      budget_count: budgets.length,
-      active_budget_count: budgets.filter((entry) => entry.status === "active").length,
-      agent_count: agents.length,
-      active_agent_count: agents.filter((entry) => entry.status === "active").length,
-      economics_receipt_count: economicsReceipts.length,
-      governed_transaction_count: governedTransactions.length
-    },
-    integrity_signals: {
-      missing_default_budget_agent_count: agents.filter((entry) => !entry.default_budget_id).length,
-      unvalidated_receipt_count: economicsReceipts.filter((entry) => entry.lifecycle_status !== "validated").length,
-      pending_transaction_count: governedTransactions.filter((entry) => entry.status !== "completed").length
-    },
-    evidence_entries: economicsReceipts.slice(0, 10).map((entry) => ({
-      receipt_id: entry.receipt_id,
-      hash: entry.evidence && entry.evidence.hash ? entry.evidence.hash : null,
-      uri: entry.evidence && entry.evidence.uri ? entry.evidence.uri : null,
-      lifecycle_status: entry.lifecycle_status
-    })),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildOperatorView(state, accountId) {
-  const receipts = listMapValuesByAccount(state.economicsReceipts, accountId);
-  const budgets = listMapValuesByAccount(state.economicsBudgets, accountId);
-  const agents = listMapValuesByAccount(state.economicsAgents, accountId);
-  const jobActions = listEconomicsJobActionsForAccount(state, accountId);
-  return {
-    account_id: accountId,
-    lifecycle_buckets: {
-      recorded: receipts.filter((entry) => entry.lifecycle_status === "recorded").length,
-      validated: receipts.filter((entry) => entry.lifecycle_status === "validated").length,
-      reversed: receipts.filter((entry) => entry.lifecycle_status === "reversed").length
-    },
-    receipt_linkability_state: {
-      with_job_id: receipts.filter((entry) => entry.job_id).length,
-      without_job_id: receipts.filter((entry) => !entry.job_id).length
-    },
-    integrity_alerts: {
-      paused_budget_count: budgets.filter((entry) => entry.status === "paused").length,
-      suspended_agent_count: agents.filter((entry) => entry.status === "suspended").length
-    },
-    receipt_anomalies: {
-      missing_evidence_locator_count: receipts.filter((entry) => !(entry.evidence && (entry.evidence.hash || entry.evidence.uri))).length
-    },
-    per_job_evidence_summaries: Object.values(
-      receipts.reduce((acc, entry) => {
-        if (!entry || !entry.job_id) return acc;
-        if (!acc[entry.job_id]) acc[entry.job_id] = { job_id: entry.job_id, receipt_count: 0, validated_count: 0 };
-        acc[entry.job_id].receipt_count += 1;
-        if (entry.lifecycle_status === "validated") acc[entry.job_id].validated_count += 1;
-        return acc;
-      }, {})
-    ),
-    trust_linked_economic_summary: {
-      disputed_receipt_count: receipts.filter((entry) => entry.operator_status === "disputed").length,
-      escalated_receipt_count: receipts.filter((entry) => entry.operator_status === "escalated").length
-    },
-    budget_usage_read_model: budgets.map((entry) => ({
-      budget_id: entry.budget_id,
-      status: entry.status,
-      max_reserve_units: entry.max_reserve_units
-    })),
-    agent_usage_read_model: agents.map((entry) => ({
-      agent_id: entry.agent_id,
-      status: entry.status,
-      default_budget_id: entry.default_budget_id || null
-    })),
-    job_operator_actions: jobActions,
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildOperatorDashboard(state, accountId) {
-  const treasurySummary = buildTreasurySummary(state, accountId);
-  const operatorView = buildOperatorView(state, accountId);
-  const recentReceipts = listMapValuesByAccount(state.economicsReceipts, accountId).slice(0, 10);
-  return {
-    account_id: accountId,
-    overview: {
-      minted_units: treasurySummary.treasury.minted_units,
-      committed_units: treasurySummary.treasury.committed_units,
-      settled_amount_minor: treasurySummary.treasury.settled_amount_minor
-    },
-    trust: operatorView.trust_linked_economic_summary,
-    workflow: {
-      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
-      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`
-    },
-    recent_activity: recentReceipts.map((entry) => ({
-      receipt_id: entry.receipt_id,
-      lifecycle_status: entry.lifecycle_status,
-      operator_status: entry.operator_status,
-      updated_at_iso: entry.updated_at_iso
-    })),
-    case_summaries: {
-      disputed_jobs: Array.from(new Set(recentReceipts.filter((entry) => entry.operator_status === "disputed").map((entry) => entry.job_id).filter(Boolean))),
-      escalated_jobs: Array.from(new Set(recentReceipts.filter((entry) => entry.operator_status === "escalated").map((entry) => entry.job_id).filter(Boolean)))
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPolicySummary(state, accountId) {
-  const budgets = listMapValuesByAccount(state.economicsBudgets, accountId);
-  const agents = listMapValuesByAccount(state.economicsAgents, accountId);
-  const activeBudgets = budgets.filter((entry) => entry.status === "active");
-  return {
-    account_id: accountId,
-    default_spend_posture: "open_spend",
-    bounded_spend_available: activeBudgets.length > 0 || agents.length > 0,
-    budget_policy_count: budgets.length,
-    active_budget_count: activeBudgets.length,
-    agent_count: agents.length,
-    agents_with_default_budget: agents.filter((entry) => entry.default_budget_id).length,
-    allowed_job_domains: Array.from(new Set(budgets.flatMap((entry) => ensureArray(entry.allowed_job_domains)))),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildAccountCreditSpendPolicyPack(state, accountId) {
-  const budgets = listMapValuesByAccount(state.economicsBudgets, accountId);
-  const agents = listMapValuesByAccount(state.economicsAgents, accountId);
-  const activeBudgets = budgets.filter((entry) => entry && entry.status === "active");
-  const allowedJobDomains = Array.from(new Set(
-    activeBudgets.flatMap((entry) => ensureArray(entry.allowed_job_domains)).filter(Boolean)
-  ));
-  return {
-    pack_version: "xytara-account-credit-spend-policy-pack-v1",
-    account_id: accountId,
-    default_spend_posture: "open_spend",
-    bounded_spend_posture_available: activeBudgets.length > 0 || agents.length > 0,
-    policy_summary: buildPolicySummary(state, accountId),
-    balance_summary: buildCreditBalanceSummary(state, accountId),
-    active_budget_count: activeBudgets.length,
-    active_budget_refs: activeBudgets.map((entry) => ({
-      budget_id: entry.budget_id,
-      label: entry.label,
-      max_reserve_units: entry.max_reserve_units,
-      allowed_job_domains: ensureArray(entry.allowed_job_domains),
-      policy_ref: entry.policy_ref || null
-    })),
-    agent_refs: agents.map((entry) => ({
-      agent_id: entry.agent_id,
-      status: entry.status,
-      default_budget_id: entry.default_budget_id || null,
-      allowed_job_domains: ensureArray(entry.allowed_job_domains)
-    })),
-    effective_allowed_job_domains: allowedJobDomains,
-    guidance: {
-      default_path: "spend_existing_credits_and_execute",
-      bounded_controls_note: "bounded spend only applies when the caller intentionally uses an agent or budget posture",
-      credit_first_execution_surface: "/v1/commands/execute",
-      balance_surface: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
-      policy_summary_surface: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildAgentCreditSpendPolicyView(state, accountId, agentId) {
-  const agent = state.economicsAgents.get(agentId) || null;
-  if (!agent || agent.account_id !== accountId) {
-    return null;
-  }
-  const budget = agent.default_budget_id ? state.economicsBudgets.get(agent.default_budget_id) || null : null;
-  const spends = listCreditSpendsForAccount(state, accountId).filter((entry) => entry && entry.agent_id === agentId);
-  const spentUnits = spends.reduce((sum, entry) => sum + (entry.units || 0), 0);
-  return {
-    account_id: accountId,
-    agent_id: agent.agent_id,
-    status: agent.status,
-    allowed_job_domains: ensureArray(agent.allowed_job_domains),
-    default_budget: budget ? {
-      budget_id: budget.budget_id,
-      status: budget.status,
-      max_reserve_units: budget.max_reserve_units,
-      allowed_job_domains: ensureArray(budget.allowed_job_domains),
-      policy_ref: budget.policy_ref || null
-    } : null,
-    spend_posture: {
-      mode: budget ? "bounded_spend" : "open_spend",
-      spent_units: spentUnits,
-      spend_count: spends.length,
-      remaining_budget_units: budget && typeof budget.max_reserve_units === "number"
-        ? Math.max(0, budget.max_reserve_units - spentUnits)
-        : null
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingPolicySummary(state, accountId) {
-  const balanceSummary = buildCreditBalanceSummary(state, accountId);
-  const meteringSummary = buildUsageMeteringSummary(state, accountId);
-  const policySummary = buildPolicySummary(state, accountId);
-  const economicsIntelligence = buildEconomicsIntelligenceSummary(state, accountId);
-  const replenishmentSummary = buildEntitlementReplenishmentSummary(state, accountId);
-
-  const pricingBands = ensureArray(meteringSummary.pricing_bands).filter(Boolean);
-  const dominantPricingBand = pricingBands[0] || null;
-  const usageMeterCount = Number(meteringSummary.usage_meter_count || 0);
-  const totalUnits = Number(meteringSummary.total_units || 0);
-
-  let pricingPosture = "direct_pay_entry";
-  if (usageMeterCount > 0 || Number(balanceSummary.consumed_units || 0) > 0) {
-    pricingPosture = "credits_first_runtime";
-  }
-  if (economicsIntelligence.recommended_funding_posture === "pack_backed_credits_first") {
-    pricingPosture = "pack_backed_runtime";
-  }
-
-  let pricingRiskState = "low";
-  if (replenishmentSummary.low_balance_count > 0 || policySummary.active_budget_count > 0) {
-    pricingRiskState = "watch";
-  }
-  if (replenishmentSummary.depleted_count > 0 || (usageMeterCount > 0 && Number(balanceSummary.available_units || 0) <= Math.max(8, totalUnits))) {
-    pricingRiskState = "high";
-  }
-
-  return {
-    summary_version: "xytara-pricing-policy-summary-v1",
-    account_id: accountId,
-    pricing_posture: pricingPosture,
-    pricing_risk_state: pricingRiskState,
-    dominant_pricing_band: dominantPricingBand,
-    recommended_pack_id: economicsIntelligence.recommended_pack_id,
-    bounded_spend_available: policySummary.bounded_spend_available,
-    explanation_signals: {
-      usage_meter_count: usageMeterCount,
-      total_units: totalUnits,
-      pricing_bands: pricingBands,
-      available_units: balanceSummary.available_units,
-      active_budget_count: policySummary.active_budget_count,
-      agent_count: policySummary.agent_count,
-      low_balance_count: replenishmentSummary.low_balance_count,
-      depleted_count: replenishmentSummary.depleted_count
-    },
-    linked_surfaces: {
-      policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-summary`,
-      policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-pack`,
-      economics_intelligence_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/intelligence-summary`,
-      metering_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/metering-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingPolicyOperatorBundle(state, accountId) {
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const policySummary = buildPolicySummary(state, accountId);
-  const policyPack = buildAccountCreditSpendPolicyPack(state, accountId);
-  const economicsIntelligence = buildEconomicsIntelligenceSummary(state, accountId);
-  const treasuryIntelligence = buildTreasuryIntelligenceSummary(state, accountId);
-
-  let recommendedOperatorMotion = "maintain_current_pricing_posture";
-  if (pricingPolicySummary.pricing_risk_state === "high") {
-    recommendedOperatorMotion = "restore_pricing_headroom";
-  } else if (pricingPolicySummary.pricing_posture === "pack_backed_runtime") {
-    recommendedOperatorMotion = "stabilize_pack_backed_runtime";
-  } else if (policySummary.bounded_spend_available) {
-    recommendedOperatorMotion = "tighten_bounded_spend_pricing_controls";
-  } else if (economicsIntelligence.recommended_funding_posture === "direct_pay_first") {
-    recommendedOperatorMotion = "keep_direct_pay_entry_clear";
-  }
-
-  return {
-    bundle_version: "xytara-pricing-policy-operator-bundle-v1",
-    account_id: accountId,
-    operator_posture: {
-      pricing_posture: pricingPolicySummary.pricing_posture,
-      pricing_risk_state: pricingPolicySummary.pricing_risk_state,
-      treasury_health_state: economicsIntelligence.treasury_health_state,
-      value_capture_state: treasuryIntelligence.value_capture_state,
-      recommended_operator_motion: recommendedOperatorMotion
-    },
-    pricing_policy_summary: pricingPolicySummary,
-    policy_summary: policySummary,
-    policy_pack: policyPack,
-    economics_intelligence_summary: economicsIntelligence,
-    treasury_intelligence_summary: treasuryIntelligence,
-    linked_surfaces: {
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-pack`,
-      economics_intelligence_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/intelligence-summary`,
-      treasury_intelligence_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-intelligence-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingPolicyPack(state, accountId) {
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const operatorBundle = buildPricingPolicyOperatorBundle(state, accountId);
-  const pricingBandProfiles = Object.entries(PRICING_BAND_UNITS).map(([pricing_band, usage_units]) => ({
-    pricing_band,
-    usage_units,
-    recommended_for: usage_units >= 8
-      ? "high consequence or multi-step runtime work"
-      : usage_units >= 3
-        ? "moderate runtime execution"
-        : "entry and lightweight runtime paths"
-  }));
-  const policyTemplates = [
-    {
-      template_id: "direct_pay_entry_clear",
-      recommended_for: "keeping first-contact spend simple",
-      target_motion: "keep_direct_pay_entry_clear",
-      pricing_posture: "direct_pay_entry"
-    },
-    {
-      template_id: "credits_first_runtime_default",
-      recommended_for: "normal repeat runtime execution",
-      target_motion: "maintain_current_pricing_posture",
-      pricing_posture: "credits_first_runtime"
-    },
-    {
-      template_id: "pack_backed_runtime_scale",
-      recommended_for: "repeat usage with replenishment pressure",
-      target_motion: "stabilize_pack_backed_runtime",
-      pricing_posture: "pack_backed_runtime"
-    },
-    {
-      template_id: "bounded_spend_guardrails",
-      recommended_for: "agent and budget-constrained runtime usage",
-      target_motion: "tighten_bounded_spend_pricing_controls",
-      pricing_posture: "credits_first_runtime"
-    }
-  ];
-
-  return {
-    pack_version: "xytara-pricing-policy-pack-v1",
-    account_id: accountId,
-    pricing_policy_summary: pricingPolicySummary,
-    operator_bundle: operatorBundle,
-    pricing_band_profiles: pricingBandProfiles,
-    policy_templates: policyTemplates,
-    recommended_policy_motion: operatorBundle.operator_posture.recommended_operator_motion,
-    linked_surfaces: {
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      pricing_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-operator-bundle`,
-      pricing_policy_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-application-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingPolicyApplicationSummary(state, accountId, templateId) {
-  const pack = buildPricingPolicyPack(state, accountId);
-  const selectedTemplate = ensureArray(pack.policy_templates).find((entry) => entry.template_id === templateId)
-    || ensureArray(pack.policy_templates).find((entry) => entry.target_motion === pack.recommended_policy_motion)
-    || ensureArray(pack.policy_templates)[0]
-    || null;
-
-  return {
-    summary_version: "xytara-pricing-policy-application-summary-v1",
-    account_id: accountId,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
-    available_template_ids: ensureArray(pack.policy_templates).map((entry) => entry.template_id),
-    selected_template: selectedTemplate,
-    suggested_pricing_targets: {
-      funding_posture: pack.pricing_policy_summary.pricing_posture,
-      dominant_pricing_band: pack.pricing_policy_summary.dominant_pricing_band,
-      recommended_pack_id: pack.pricing_policy_summary.recommended_pack_id,
-      bounded_spend_available: pack.pricing_policy_summary.bounded_spend_available
-    },
-    linked_surfaces: {
-      pricing_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-pack`,
-      pricing_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-operator-bundle`,
-      policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-pack`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingPolicyPackage(state, accountId) {
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const operatorBundle = buildPricingPolicyOperatorBundle(state, accountId);
-  const pack = buildPricingPolicyPack(state, accountId);
-  const applicationSummary = buildPricingPolicyApplicationSummary(state, accountId, null);
-  return {
-    package_version: "xytara-pricing-policy-package-v1",
-    account_id: accountId,
-    package_posture: {
-      pricing_posture: pricingPolicySummary.pricing_posture,
-      pricing_risk_state: pricingPolicySummary.pricing_risk_state,
-      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion,
-      recommended_policy_motion: pack.recommended_policy_motion
-    },
-    pricing_policy_summary: pricingPolicySummary,
-    pricing_policy_operator_bundle: operatorBundle,
-    pricing_policy_pack: pack,
-    pricing_policy_application_summary: applicationSummary,
-    linked_surfaces: {
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      pricing_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-operator-bundle`,
-      pricing_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-pack`,
-      pricing_policy_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-application-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildQuotePolicyDecisionSummary(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const usagePreview = buildUsageMeterPreview(state, payload);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const policyDecision = buildCreditSpendPolicyDecision(state, payload);
-  const quotedUnits = resolveUsageMeterUnits(payload, buildUsageMeterBase(payload));
-  const amountMinor = quotedUnits * 100;
-
-  let quotePolicyState = "direct_pay_quote";
-  if (pricingPolicySummary.pricing_posture !== "direct_pay_entry") {
-    quotePolicyState = "credits_first_quote";
-  }
-  if (pricingPolicySummary.pricing_posture === "pack_backed_runtime") {
-    quotePolicyState = "pack_backed_quote";
-  }
-
-  let recommendedQuoteMotion = "issue_standard_quote";
-  if (!policyDecision.ok) {
-    recommendedQuoteMotion = "require_bounded_policy_repair";
-  } else if (pricingPolicySummary.pricing_risk_state === "high") {
-    recommendedQuoteMotion = "issue_replenishment_aware_quote";
-  } else if (pricingPolicySummary.pricing_posture === "pack_backed_runtime") {
-    recommendedQuoteMotion = "issue_pack_aligned_quote";
-  }
-
-  return {
-    summary_version: "xytara-quote-policy-decision-summary-v1",
-    account_id: accountId,
-    quote_policy_state: quotePolicyState,
-    recommended_quote_motion: recommendedQuoteMotion,
-    quoted_units: quotedUnits,
-    quoted_amount_minor: amountMinor,
-    pricing_band: usagePreview.pricing_band,
-    task_domain: usagePreview.task_domain,
-    policy_guard: {
-      ok: Boolean(policyDecision.ok),
-      reason: policyDecision.reason || null,
-      budget_id: policyDecision.budget_id || null,
-      agent_id: policyDecision.agent_id || null,
-      max_reserve_units: policyDecision.max_reserve_units || null
-    },
-    linked_surfaces: {
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      pricing_policy_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-package`,
-      policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/policy-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildPricingBandDecisionSummary(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const usagePreview = buildUsageMeterPreview(state, payload);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const bandUnits = PRICING_BAND_UNITS[usagePreview.pricing_band] || usagePreview.usage_units || 1;
-
-  let bandDecisionState = "standard_band";
-  if (usagePreview.pricing_band === "utility") {
-    bandDecisionState = "entry_band";
-  } else if (usagePreview.pricing_band === "premium" || usagePreview.pricing_band === "heavy") {
-    bandDecisionState = "high_consequence_band";
-  }
-
-  let recommendedBandMotion = "accept_detected_band";
-  if (pricingPolicySummary.pricing_risk_state === "high" && bandUnits >= 8) {
-    recommendedBandMotion = "review_high_unit_band";
-  } else if (pricingPolicySummary.pricing_posture === "direct_pay_entry" && bandUnits > 3) {
-    recommendedBandMotion = "check_entry_path_alignment";
-  }
-
-  return {
-    summary_version: "xytara-pricing-band-decision-summary-v1",
-    account_id: accountId,
-    pricing_band: usagePreview.pricing_band,
-    usage_units: usagePreview.usage_units,
-    band_units: bandUnits,
-    band_decision_state: bandDecisionState,
-    recommended_band_motion: recommendedBandMotion,
-    task_ref: usagePreview.task_ref,
-    workflow_ref: usagePreview.workflow_ref,
-    task_domain: usagePreview.task_domain,
-    linked_surfaces: {
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      pricing_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-pack`,
-      metering_preview_ref: "/v1/economics/metering/preview"
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildQuotePolicyOperatorBundle(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const quoteDecision = buildQuotePolicyDecisionSummary(state, payload);
-  const bandDecision = buildPricingBandDecisionSummary(state, payload);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-
-  let recommendedOperatorMotion = "maintain_quote_policy_posture";
-  if (quoteDecision.policy_guard.ok === false) {
-    recommendedOperatorMotion = "repair_bounded_quote_controls";
-  } else if (quoteDecision.recommended_quote_motion === "issue_replenishment_aware_quote") {
-    recommendedOperatorMotion = "prepare_replenishment_aligned_quote";
-  } else if (bandDecision.recommended_band_motion === "review_high_unit_band") {
-    recommendedOperatorMotion = "review_high_unit_quote_band";
-  }
-
-  return {
-    bundle_version: "xytara-quote-policy-operator-bundle-v1",
-    account_id: accountId,
-    operator_posture: {
-      quote_policy_state: quoteDecision.quote_policy_state,
-      pricing_band: bandDecision.pricing_band,
-      pricing_risk_state: pricingPolicySummary.pricing_risk_state,
-      recommended_quote_motion: quoteDecision.recommended_quote_motion,
-      recommended_band_motion: bandDecision.recommended_band_motion,
-      recommended_operator_motion: recommendedOperatorMotion
-    },
-    quote_policy_decision_summary: quoteDecision,
-    pricing_band_decision_summary: bandDecision,
-    pricing_policy_summary: pricingPolicySummary,
-    linked_surfaces: {
-      quote_policy_decision_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-decision-summary`,
-      pricing_band_decision_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-band-decision-summary`,
-      quote_policy_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeQuotePolicyOperatorBundle(state, body) {
-  const bundle = buildQuotePolicyOperatorBundle(state, body);
-  return {
-    bundle_version: bundle.bundle_version,
-    account_id: bundle.account_id,
-    quote_policy_state: bundle.operator_posture.quote_policy_state,
-    pricing_band: bundle.operator_posture.pricing_band,
-    recommended_operator_motion: bundle.operator_posture.recommended_operator_motion
-  };
-}
-
-function buildQuotePolicyPack(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const operatorBundle = buildQuotePolicyOperatorBundle(state, payload);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const templates = [
-    {
-      template_id: "direct_pay_quote_entry",
-      recommended_for: "first-contact quotes and low-friction runtime entry",
-      target_motion: "issue_standard_quote",
-      quote_policy_state: "direct_pay_quote"
-    },
-    {
-      template_id: "credits_first_quote_default",
-      recommended_for: "normal repeat runtime quoting",
-      target_motion: "issue_standard_quote",
-      quote_policy_state: "credits_first_quote"
-    },
-    {
-      template_id: "pack_aligned_quote_flow",
-      recommended_for: "repeat use with pack-backed credits posture",
-      target_motion: "issue_pack_aligned_quote",
-      quote_policy_state: "pack_backed_quote"
-    },
-    {
-      template_id: "replenishment_aware_quote",
-      recommended_for: "high pricing-risk or low-headroom quote posture",
-      target_motion: "issue_replenishment_aware_quote",
-      quote_policy_state: "credits_first_quote"
-    },
-    {
-      template_id: "bounded_quote_guardrails",
-      recommended_for: "agent or budget-constrained quoting",
-      target_motion: "require_bounded_policy_repair",
-      quote_policy_state: "credits_first_quote"
-    }
-  ];
-
-  return {
-    pack_version: "xytara-quote-policy-pack-v1",
-    account_id: accountId,
-    quote_policy_operator_bundle: operatorBundle,
-    pricing_policy_summary: pricingPolicySummary,
-    recommended_policy_motion: operatorBundle.operator_posture.recommended_quote_motion,
-    policy_templates: templates,
-    linked_surfaces: {
-      quote_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-operator-bundle`,
-      quote_policy_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-application-summary`,
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeQuotePolicyPack(state, body) {
-  const pack = buildQuotePolicyPack(state, body);
-  return {
-    pack_version: pack.pack_version,
-    account_id: pack.account_id,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    template_count: ensureArray(pack.policy_templates).length
-  };
-}
-
-function buildQuotePolicyApplicationSummary(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const templateId = normalizeString(payload.template_id, null);
-  const pack = buildQuotePolicyPack(state, payload);
-  const selectedTemplate = ensureArray(pack.policy_templates).find((entry) => entry.template_id === templateId)
-    || ensureArray(pack.policy_templates).find((entry) => entry.target_motion === pack.recommended_policy_motion)
-    || ensureArray(pack.policy_templates)[0]
-    || null;
-
-  return {
-    summary_version: "xytara-quote-policy-application-summary-v1",
-    account_id: accountId,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
-    available_template_ids: ensureArray(pack.policy_templates).map((entry) => entry.template_id),
-    selected_template: selectedTemplate,
-    suggested_quote_targets: {
-      quote_policy_state: pack.quote_policy_operator_bundle.operator_posture.quote_policy_state,
-      pricing_band: pack.quote_policy_operator_bundle.operator_posture.pricing_band,
-      recommended_quote_motion: pack.quote_policy_operator_bundle.operator_posture.recommended_quote_motion,
-      pricing_risk_state: pack.pricing_policy_summary.pricing_risk_state
-    },
-    linked_surfaces: {
-      quote_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-pack`,
-      quote_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-operator-bundle`,
-      quote_policy_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildQuotePolicyPackage(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const quoteDecision = buildQuotePolicyDecisionSummary(state, payload);
-  const bandDecision = buildPricingBandDecisionSummary(state, payload);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const operatorBundle = buildQuotePolicyOperatorBundle(state, payload);
-  const policyPack = buildQuotePolicyPack(state, payload);
-  const applicationSummary = buildQuotePolicyApplicationSummary(state, payload);
-
-  return {
-    package_version: "xytara-quote-policy-package-v1",
-    account_id: accountId,
-    package_posture: {
-      quote_policy_state: quoteDecision.quote_policy_state,
-      recommended_quote_motion: quoteDecision.recommended_quote_motion,
-      pricing_band: bandDecision.pricing_band,
-      recommended_band_motion: bandDecision.recommended_band_motion,
-      pricing_risk_state: pricingPolicySummary.pricing_risk_state,
-      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion,
-      recommended_policy_motion: policyPack.recommended_policy_motion
-    },
-    quote_policy_decision_summary: quoteDecision,
-    pricing_band_decision_summary: bandDecision,
-    quote_policy_operator_bundle: operatorBundle,
-    quote_policy_pack: policyPack,
-    quote_policy_application_summary: applicationSummary,
-    pricing_policy_summary: pricingPolicySummary,
-    linked_surfaces: {
-      quote_policy_decision_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-decision-summary`,
-      pricing_band_decision_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-band-decision-summary`,
-      quote_policy_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-operator-bundle`,
-      quote_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-pack`,
-      quote_policy_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/quote-policy-application-summary`,
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeQuotePolicyPackage(state, body) {
-  const pack = buildQuotePolicyPackage(state, body);
-  return {
-    package_version: pack.package_version,
-    account_id: pack.account_id,
-    quote_policy_state: pack.package_posture.quote_policy_state,
-    pricing_band: pack.package_posture.pricing_band,
-    recommended_operator_motion: pack.package_posture.recommended_operator_motion,
-    recommended_policy_motion: pack.package_posture.recommended_policy_motion
-  };
-}
-
-function buildTrustInputSummary(state, accountId) {
-  const paymentCount = listPaymentLedgerForAccount(state, accountId).length;
-  const creditSpendCount = ensureArray(state.economicsCreditSpends).filter((entry) => entry && entry.account_id === accountId).length;
-  const allocationCount = ensureArray(state.economicsAllocations).filter((entry) => entry && entry.account_id === accountId).length;
-  const disputeCount = listMapValuesByAccount(state.disputes, accountId).length;
-  const refundCount = listMapValuesByAccount(state.refunds, accountId).length;
-  const remediationCount = listMapValuesByAccount(state.remediationTickets, accountId).length;
-  const activeParticipantCount = listOperatorParticipantsForAccount(state, accountId).filter((entry) => entry && entry.status === "active").length;
-  const revokedParticipantCount = listOperatorParticipantsForAccount(state, accountId).filter((entry) => entry && entry.status === "revoked").length;
-
-  let runtimeHistoryState = "thin";
-  if (paymentCount > 0 || creditSpendCount > 0 || allocationCount > 0) {
-    runtimeHistoryState = "working";
-  }
-  if (
-    paymentCount > 0
-    && creditSpendCount > 0
-    && allocationCount > 0
-    && disputeCount === 0
-    && refundCount === 0
-    && remediationCount === 0
-  ) {
-    runtimeHistoryState = "strong";
-  }
-
-  let reputationRiskState = "low";
-  if (disputeCount > 0 || refundCount > 0 || remediationCount > 0) {
-    reputationRiskState = "high";
-  } else if (paymentCount === 0 || creditSpendCount === 0 || revokedParticipantCount > 0) {
-    reputationRiskState = "watch";
-  }
-
-  let recommendedInputMotion = "maintain_runtime_reputation_inputs";
-  if (runtimeHistoryState === "thin") {
-    recommendedInputMotion = "establish_runtime_history_inputs";
-  } else if (reputationRiskState === "high") {
-    recommendedInputMotion = "repair_reputation_risk_inputs";
-  } else if (reputationRiskState === "watch") {
-    recommendedInputMotion = "deepen_runtime_history_inputs";
-  }
-
-  return {
-    summary_version: "xytara-trust-input-summary-v1",
-    account_id: accountId,
-    runtime_history_state: runtimeHistoryState,
-    reputation_risk_state: reputationRiskState,
-    recommended_input_motion: recommendedInputMotion,
-    explanation_signals: {
-      payment_count: paymentCount,
-      credit_spend_count: creditSpendCount,
-      allocation_count: allocationCount,
-      dispute_count: disputeCount,
-      refund_count: refundCount,
-      remediation_count: remediationCount,
-      active_participant_count: activeParticipantCount,
-      revoked_participant_count: revokedParticipantCount
-    },
-    linked_surfaces: {
-      trust_layer_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-summary`,
-      payment_ledger_ref: "/v1/payment-ledger",
-      multi_operator_participation_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTrustLayerSummary(state, accountId) {
-  const authoritySummary = buildAuthoritySummary(state, accountId);
-  const authorityAttention = buildAuthorityAttentionSummary(state, accountId);
-  const machineIdentitySummary = buildMachineIdentitySummary(state, accountId);
-  const machineIdentityAttention = buildMachineIdentityAttentionSummary(state, accountId);
-  const walletSummary = buildWalletSummary(state, accountId);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const trustInputSummary = buildTrustInputSummary(state, accountId);
-
-  const activeAuthorityBindings = Number(authoritySummary.authority_binding_count || 0);
-  const activeIdentityBindings = Number(machineIdentitySummary.identity_binding_count || 0);
-  const availableUnits = Number(walletSummary.available_units || 0);
-
-  let trustState = "early";
-  if (
-    activeAuthorityBindings > 0
-    && activeIdentityBindings > 0
-    && authorityAttention.overall_attention_state === "healthy"
-    && machineIdentityAttention.overall_attention_state === "healthy"
-    && trustInputSummary.runtime_history_state !== "thin"
-  ) {
-    trustState = "strong";
-  } else if (
-    activeAuthorityBindings > 0
-    || activeIdentityBindings > 0
-    || trustInputSummary.runtime_history_state !== "thin"
-  ) {
-    trustState = "working";
-  }
-
-  let trustRiskState = "low";
-  if (
-    authorityAttention.overall_attention_state === "attention_required"
-    || machineIdentityAttention.overall_attention_state === "attention_required"
-    || pricingPolicySummary.pricing_risk_state === "high"
-    || trustInputSummary.reputation_risk_state === "high"
-  ) {
-    trustRiskState = "high";
-  } else if (
-    pricingPolicySummary.pricing_risk_state === "watch"
-    || availableUnits <= 0
-    || trustInputSummary.reputation_risk_state === "watch"
-  ) {
-    trustRiskState = "watch";
-  }
-
-  let recommendedTrustMotion = "maintain_runtime_trust_posture";
-  if (trustState === "early") {
-    recommendedTrustMotion = "establish_authority_and_identity_trust";
-  } else if (trustRiskState === "high") {
-    recommendedTrustMotion = "repair_runtime_trust_attention";
-  } else if (trustInputSummary.runtime_history_state === "thin") {
-    recommendedTrustMotion = "deepen_runtime_reputation_inputs";
-  } else if (pricingPolicySummary.pricing_posture === "pack_backed_runtime") {
-    recommendedTrustMotion = "stabilize_pack_backed_trust_posture";
-  }
-
-  return {
-    summary_version: "xytara-trust-layer-summary-v1",
-    account_id: accountId,
-    trust_state: trustState,
-    trust_risk_state: trustRiskState,
-    recommended_trust_motion: recommendedTrustMotion,
-    explanation_signals: {
-      authority_state: authoritySummary.authority_state,
-      authority_binding_count: activeAuthorityBindings,
-      authority_attention_state: authorityAttention.overall_attention_state,
-      machine_identity_state: machineIdentitySummary.machine_identity_state,
-      identity_binding_count: activeIdentityBindings,
-      machine_identity_attention_state: machineIdentityAttention.overall_attention_state,
-      pricing_posture: pricingPolicySummary.pricing_posture,
-      pricing_risk_state: pricingPolicySummary.pricing_risk_state,
-      available_units: availableUnits,
-      runtime_history_state: trustInputSummary.runtime_history_state,
-      reputation_risk_state: trustInputSummary.reputation_risk_state,
-      active_participant_count: trustInputSummary.explanation_signals.active_participant_count,
-      dispute_count: trustInputSummary.explanation_signals.dispute_count
-    },
-    linked_surfaces: {
-      authority_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/authority-summary`,
-      authority_attention_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/authority-attention-summary`,
-      machine_identity_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/machine-identity-summary`,
-      machine_identity_attention_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/machine-identity-attention-summary`,
-      pricing_policy_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/pricing-policy-summary`,
-      trust_input_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-input-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTrustLayerOperatorBundle(state, accountId) {
-  const trustSummary = buildTrustLayerSummary(state, accountId);
-  const authoritySummary = buildAuthoritySummary(state, accountId);
-  const machineIdentitySummary = buildMachineIdentitySummary(state, accountId);
-  const pricingPolicySummary = buildPricingPolicySummary(state, accountId);
-  const trustInputSummary = buildTrustInputSummary(state, accountId);
-
-  let recommendedOperatorMotion = "maintain_runtime_trust_posture";
-  if (trustSummary.trust_state === "early") {
-    recommendedOperatorMotion = "establish_runtime_trust_foundations";
-  } else if (trustSummary.trust_risk_state === "high") {
-    recommendedOperatorMotion = "repair_runtime_trust_attention";
-  } else if (trustInputSummary.runtime_history_state === "thin") {
-    recommendedOperatorMotion = "deepen_runtime_reputation_inputs";
-  } else if (pricingPolicySummary.pricing_posture === "pack_backed_runtime") {
-    recommendedOperatorMotion = "stabilize_pack_backed_trust_posture";
-  }
-
-  return {
-    bundle_version: "xytara-trust-layer-operator-bundle-v1",
-    account_id: accountId,
-    operator_posture: {
-      trust_state: trustSummary.trust_state,
-      trust_risk_state: trustSummary.trust_risk_state,
-      authority_state: authoritySummary.authority_state,
-      machine_identity_state: machineIdentitySummary.machine_identity_state,
-      runtime_history_state: trustInputSummary.runtime_history_state,
-      reputation_risk_state: trustInputSummary.reputation_risk_state,
-      pricing_posture: pricingPolicySummary.pricing_posture,
-      recommended_operator_motion: recommendedOperatorMotion
-    },
-    trust_layer_summary: trustSummary,
-    trust_input_summary: trustInputSummary,
-    authority_summary: authoritySummary,
-    machine_identity_summary: machineIdentitySummary,
-    pricing_policy_summary: pricingPolicySummary,
-    linked_surfaces: trustSummary.linked_surfaces,
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeTrustLayerOperatorBundle(state, accountId) {
-  const bundle = buildTrustLayerOperatorBundle(state, accountId);
-  return {
-    bundle_version: bundle.bundle_version,
-    account_id: bundle.account_id,
-    trust_state: bundle.operator_posture.trust_state,
-    trust_risk_state: bundle.operator_posture.trust_risk_state,
-    recommended_operator_motion: bundle.operator_posture.recommended_operator_motion
-  };
-}
-
-function buildTrustLayerPolicyPack(state, accountId) {
-  const operatorBundle = buildTrustLayerOperatorBundle(state, accountId);
-  const templates = [
-    {
-      template_id: "runtime_trust_foundation",
-      recommended_for: "establishing initial authority and identity trust",
-      target_motion: "establish_runtime_trust_foundations",
-      trust_state: "early"
-    },
-    {
-      template_id: "runtime_trust_maintenance",
-      recommended_for: "healthy continuing runtime trust posture",
-      target_motion: "maintain_runtime_trust_posture",
-      trust_state: "working"
-    },
-    {
-      template_id: "trust_attention_repair",
-      recommended_for: "repairing active authority, identity, or pricing risk",
-      target_motion: "repair_runtime_trust_attention",
-      trust_state: "working"
-    },
-    {
-      template_id: "pack_backed_trust_stabilization",
-      recommended_for: "repeat-use runtime trust with pack-backed credits",
-      target_motion: "stabilize_pack_backed_trust_posture",
-      trust_state: "strong"
-    }
-  ];
-
-  return {
-    pack_version: "xytara-trust-layer-policy-pack-v1",
-    account_id: accountId,
-    trust_layer_operator_bundle: operatorBundle,
-    recommended_policy_motion: operatorBundle.operator_posture.recommended_operator_motion,
-    policy_templates: templates,
-    linked_surfaces: {
-      trust_layer_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-operator-bundle`,
-      trust_layer_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-application-summary`,
-      trust_layer_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeTrustLayerPolicyPack(state, accountId) {
-  const pack = buildTrustLayerPolicyPack(state, accountId);
-  return {
-    pack_version: pack.pack_version,
-    account_id: pack.account_id,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    template_count: ensureArray(pack.policy_templates).length
-  };
-}
-
-function buildTrustLayerApplicationSummary(state, accountId, templateId) {
-  const pack = buildTrustLayerPolicyPack(state, accountId);
-  const selectedTemplate = ensureArray(pack.policy_templates).find((entry) => entry.template_id === templateId)
-    || ensureArray(pack.policy_templates).find((entry) => entry.target_motion === pack.recommended_policy_motion)
-    || ensureArray(pack.policy_templates)[0]
-    || null;
-
-  return {
-    summary_version: "xytara-trust-layer-application-summary-v1",
-    account_id: accountId,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
-    available_template_ids: ensureArray(pack.policy_templates).map((entry) => entry.template_id),
-    selected_template: selectedTemplate,
-    suggested_trust_targets: {
-      trust_state: pack.trust_layer_operator_bundle.operator_posture.trust_state,
-      trust_risk_state: pack.trust_layer_operator_bundle.operator_posture.trust_risk_state,
-      authority_state: pack.trust_layer_operator_bundle.operator_posture.authority_state,
-      machine_identity_state: pack.trust_layer_operator_bundle.operator_posture.machine_identity_state
-    },
-    linked_surfaces: {
-      trust_layer_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-policy-pack`,
-      trust_layer_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-operator-bundle`,
-      trust_layer_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTrustLayerPackage(state, accountId) {
-  const summary = buildTrustLayerSummary(state, accountId);
-  const operatorBundle = buildTrustLayerOperatorBundle(state, accountId);
-  const policyPack = buildTrustLayerPolicyPack(state, accountId);
-  const applicationSummary = buildTrustLayerApplicationSummary(state, accountId, null);
-
-  return {
-    package_version: "xytara-trust-layer-package-v1",
-    account_id: accountId,
-    package_posture: {
-      trust_state: summary.trust_state,
-      trust_risk_state: summary.trust_risk_state,
-      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion,
-      recommended_policy_motion: policyPack.recommended_policy_motion
-    },
-    trust_layer_summary: summary,
-    trust_layer_operator_bundle: operatorBundle,
-    trust_input_summary: operatorBundle.trust_input_summary,
-    trust_layer_policy_pack: policyPack,
-    trust_layer_application_summary: applicationSummary,
-    linked_surfaces: {
-      trust_input_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-input-summary`,
-      trust_layer_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-summary`,
-      trust_layer_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-operator-bundle`,
-      trust_layer_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-policy-pack`,
-      trust_layer_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-application-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeTrustLayerPackage(state, accountId) {
-  const pack = buildTrustLayerPackage(state, accountId);
-  return {
-    package_version: pack.package_version,
-    account_id: pack.account_id,
-    trust_state: pack.package_posture.trust_state,
-    trust_risk_state: pack.package_posture.trust_risk_state,
-    recommended_operator_motion: pack.package_posture.recommended_operator_motion,
-    recommended_policy_motion: pack.package_posture.recommended_policy_motion
-  };
-}
-
-function listOperatorParticipantsForAccount(state, accountId) {
-  return Array.from(state.operatorParticipants.values())
-    .filter((entry) => entry && entry.account_id === accountId);
-}
-
-function listLegacyAgentAccountsForParticipation(state, accountId) {
-  return Array.from(state.agentAccounts.values())
-    .map((entry) => entry && entry.account ? entry.account : null)
-    .filter(Boolean)
-    .filter((entry) => entry.account_id === accountId);
-}
-
-function buildMultiOperatorParticipantPublicView(entry) {
-  if (!entry) return null;
-  return {
-    participant_id: entry.participant_id,
-    account_id: entry.account_id,
-    label: entry.label,
-    operator_kind: entry.operator_kind,
-    status: entry.status,
-    participant_scope: ensureArray(entry.participant_scope),
-    authority_binding_id: entry.authority_binding_id || null,
-    identity_binding_id: entry.identity_binding_id || null,
-    rotated_from_participant_id: entry.rotated_from_participant_id || null,
-    replaced_by_participant_id: entry.replaced_by_participant_id || null,
-    created_at_iso: entry.created_at_iso,
-    updated_at_iso: entry.updated_at_iso,
-    revoked_at_iso: entry.revoked_at_iso || null,
-    revoke_reason: entry.revoke_reason || null,
-    issued_by: entry.issued_by || null,
-    labels: ensureArray(entry.labels)
-  };
-}
-
-function listMultiOperatorParticipants(state, accountId) {
-  return listOperatorParticipantsForAccount(state, accountId).map((entry) => buildMultiOperatorParticipantPublicView(entry));
-}
-
-function getMultiOperatorParticipant(state, accountId, participantId) {
-  if (!participantId || !state.operatorParticipants.has(participantId)) return null;
-  const entry = state.operatorParticipants.get(participantId);
-  if (!entry || entry.account_id !== accountId) return null;
-  return buildMultiOperatorParticipantPublicView(entry);
-}
-
-function buildMultiOperatorAdmissionPreview(state, accountId, body) {
-  const payload = ensureObject(body);
-  const policyPack = buildMultiOperatorParticipationPolicyPack(state, accountId);
-  const selectedTemplate = ensureArray(policyPack.policy_templates).find((entry) => entry.template_id === normalizeString(payload.template_id, null))
-    || ensureArray(policyPack.policy_templates).find((entry) => entry.target_motion === policyPack.recommended_policy_motion)
-    || ensureArray(policyPack.policy_templates)[0]
-    || null;
-  const participantLabel = normalizeString(payload.label, `operator-participant-${listOperatorParticipantsForAccount(state, accountId).length + 1}`);
-  return {
-    preview_version: "xytara-multi-operator-admission-preview-v1",
-    account_id: accountId,
-    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
-    selected_template: selectedTemplate,
-    proposed_participant: {
-      label: participantLabel,
-      operator_kind: normalizeString(payload.operator_kind, "coordinator_operator"),
-      participant_scope: ensureArray(payload.participant_scope).length > 0
-        ? ensureArray(payload.participant_scope)
-        : ["runtime.execute", "economics.reserve"]
-    },
-    planned_bindings: {
-      authority_kind: normalizeString(payload.authority_kind, "delegated_runtime_spend"),
-      identity_kind: normalizeString(payload.identity_kind, "registry_anchor_identity")
-    },
-    linked_surfaces: {
-      multi_operator_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-policy-pack`,
-      multi_operator_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participants`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function createMultiOperatorParticipant(state, accountId, body) {
-  const payload = ensureObject(body);
-  const createdAtIso = nowIso();
-  const nextIndex = state.operatorParticipants.size + 1;
-  const participantId = normalizeString(payload.participant_id, `operator_participant_${nextIndex}`);
-  const participantScope = ensureArray(payload.participant_scope).length > 0
-    ? ensureArray(payload.participant_scope).map((value) => String(value || "").trim()).filter(Boolean)
-    : ["runtime.execute", "economics.reserve"];
-  const authorityBinding = createAuthorityBinding(state, {
-    binding_id: normalizeString(payload.authority_binding_id, `${participantId}_authority`),
-    credential_id: normalizeString(payload.credential_id, `${participantId}_credential`),
-    account_id: accountId,
-    authority_kind: normalizeString(payload.authority_kind, "delegated_runtime_spend"),
-    authority_scope: participantScope,
-    allowed_consequence_families: ensureArray(payload.allowed_consequence_families).length > 0
-      ? ensureArray(payload.allowed_consequence_families)
-      : ["commit", "reserve"],
-    max_commit_units: Number.isFinite(Number(payload.max_commit_units)) ? Number(payload.max_commit_units) : 5,
-    max_reserve_units: Number.isFinite(Number(payload.max_reserve_units)) ? Number(payload.max_reserve_units) : 5,
-    max_reversal_units: Number.isFinite(Number(payload.max_reversal_units)) ? Number(payload.max_reversal_units) : 1,
-    labels: ensureArray(payload.labels),
-    issued_by: normalizeString(payload.issued_by, "operator")
-  });
-  const identityBinding = createIdentityBinding(state, {
-    binding_id: normalizeString(payload.identity_binding_id, `${participantId}_identity`),
-    account_id: accountId,
-    identity_kind: normalizeString(payload.identity_kind, "registry_anchor_identity"),
-    identity_ref: normalizeString(payload.identity_ref, `${participantId}.identity`),
-    attached_agent_account_id: participantId,
-    labels: ensureArray(payload.labels),
-    issued_by: normalizeString(payload.issued_by, "operator")
-  });
-  const participant = {
-    participant_id: participantId,
-    account_id: accountId,
-    label: normalizeString(payload.label, participantId),
-    operator_kind: normalizeString(payload.operator_kind, "coordinator_operator"),
-    status: normalizeString(payload.status, "active"),
-    participant_scope: participantScope,
-    authority_binding_id: authorityBinding.binding_id,
-    identity_binding_id: identityBinding.binding_id,
-    created_at_iso: createdAtIso,
-    updated_at_iso: createdAtIso,
-    issued_by: normalizeString(payload.issued_by, "operator"),
-    labels: ensureArray(payload.labels).map((value) => String(value || "").trim()).filter(Boolean)
-  };
-  state.operatorParticipants.set(participantId, participant);
-  return {
-    participant: buildMultiOperatorParticipantPublicView(participant),
-    authority_binding: authorityBinding,
-    identity_binding: identityBinding
-  };
-}
-
-function renewMultiOperatorParticipant(state, accountId, participantId, body) {
-  const payload = ensureObject(body);
-  if (!participantId || !state.operatorParticipants.has(participantId)) return null;
-  const current = state.operatorParticipants.get(participantId);
-  if (!current || current.account_id !== accountId) return null;
-  const renewedAuthorityBinding = current.authority_binding_id
-    ? renewAuthorityBinding(state, current.authority_binding_id, { expires_at_iso: normalizeString(payload.expires_at_iso, null) })
-    : null;
-  const renewedIdentityBinding = current.identity_binding_id
-    ? renewIdentityBinding(state, current.identity_binding_id, { expires_at_iso: normalizeString(payload.expires_at_iso, null) })
-    : null;
-  const next = {
-    ...current,
-    updated_at_iso: nowIso()
-  };
-  state.operatorParticipants.set(participantId, next);
-  return {
-    participant: buildMultiOperatorParticipantPublicView(next),
-    authority_binding: renewedAuthorityBinding,
-    identity_binding: renewedIdentityBinding
-  };
-}
-
-function revokeMultiOperatorParticipant(state, accountId, participantId, body) {
-  const payload = ensureObject(body);
-  if (!participantId || !state.operatorParticipants.has(participantId)) return null;
-  const current = state.operatorParticipants.get(participantId);
-  if (!current || current.account_id !== accountId) return null;
-  const revokedAuthorityBinding = current.authority_binding_id
-    ? revokeAuthorityBinding(state, current.authority_binding_id, { reason: normalizeString(payload.reason, "participant_revoked") })
-    : null;
-  const revokedIdentityBinding = current.identity_binding_id
-    ? revokeIdentityBinding(state, current.identity_binding_id, { reason: normalizeString(payload.reason, "participant_revoked") })
-    : null;
-  const next = {
-    ...current,
-    status: "revoked",
-    updated_at_iso: nowIso(),
-    revoked_at_iso: nowIso(),
-    revoke_reason: normalizeString(payload.reason, "participant_revoked")
-  };
-  state.operatorParticipants.set(participantId, next);
-  return {
-    participant: buildMultiOperatorParticipantPublicView(next),
-    authority_binding: revokedAuthorityBinding,
-    identity_binding: revokedIdentityBinding
-  };
-}
-
-function rotateMultiOperatorParticipant(state, accountId, participantId, body) {
-  const payload = ensureObject(body);
-  if (!participantId || !state.operatorParticipants.has(participantId)) return null;
-  const current = state.operatorParticipants.get(participantId);
-  if (!current || current.account_id !== accountId) return null;
-  const successorParticipantId = normalizeString(payload.successor_participant_id, `${participantId}_rotated`);
-  const authorityRotation = current.authority_binding_id
-    ? rotateAuthorityBinding(state, current.authority_binding_id, {
-        successor_binding_id: normalizeString(payload.successor_authority_binding_id, `${successorParticipantId}_authority`),
-        successor_credential_id: normalizeString(payload.successor_credential_id, `${successorParticipantId}_credential`),
-        authority_scope: ensureArray(payload.participant_scope).length > 0 ? ensureArray(payload.participant_scope) : ensureArray(current.participant_scope),
-        labels: ensureArray(payload.labels).length > 0 ? ensureArray(payload.labels) : ensureArray(current.labels),
-        reason: normalizeString(payload.reason, "participant_rotated")
-      })
-    : null;
-  const identityRotation = current.identity_binding_id
-    ? rotateIdentityBinding(state, current.identity_binding_id, {
-        successor_binding_id: normalizeString(payload.successor_identity_binding_id, `${successorParticipantId}_identity`),
-        attached_agent_account_id: successorParticipantId,
-        labels: ensureArray(payload.labels).length > 0 ? ensureArray(payload.labels) : ensureArray(current.labels),
-        reason: normalizeString(payload.reason, "participant_rotated")
-      })
-    : null;
-  const successor = {
-    participant_id: successorParticipantId,
-    account_id: accountId,
-    label: normalizeString(payload.label, current.label),
-    operator_kind: normalizeString(payload.operator_kind, current.operator_kind),
-    status: normalizeString(payload.status, "active"),
-    participant_scope: ensureArray(payload.participant_scope).length > 0
-      ? ensureArray(payload.participant_scope).map((value) => String(value || "").trim()).filter(Boolean)
-      : ensureArray(current.participant_scope),
-    authority_binding_id: authorityRotation && authorityRotation.successor_authority_binding
-      ? authorityRotation.successor_authority_binding.binding_id
-      : null,
-    identity_binding_id: identityRotation && identityRotation.successor_identity_binding
-      ? identityRotation.successor_identity_binding.binding_id
-      : null,
-    rotated_from_participant_id: current.participant_id,
-    replaced_by_participant_id: null,
-    created_at_iso: nowIso(),
-    updated_at_iso: nowIso(),
-    issued_by: normalizeString(payload.issued_by, current.issued_by || "operator"),
-    labels: ensureArray(payload.labels).length > 0 ? ensureArray(payload.labels).map((value) => String(value || "").trim()).filter(Boolean) : ensureArray(current.labels)
-  };
-  const rotated = {
-    ...current,
-    status: "revoked",
-    replaced_by_participant_id: successorParticipantId,
-    updated_at_iso: nowIso(),
-    revoked_at_iso: nowIso(),
-    revoke_reason: normalizeString(payload.reason, "participant_rotated")
-  };
-  state.operatorParticipants.set(participantId, rotated);
-  state.operatorParticipants.set(successorParticipantId, successor);
-  return {
-    rotated_participant: buildMultiOperatorParticipantPublicView(rotated),
-    successor_participant: buildMultiOperatorParticipantPublicView(successor),
-    authority_rotation: authorityRotation,
-    identity_rotation: identityRotation
-  };
-}
-
-function buildMultiOperatorParticipantRotationSummary(state, accountId, participantId) {
-  const participant = getMultiOperatorParticipant(state, accountId, participantId);
-  if (!participant) return null;
-  return {
-    summary_version: "xytara-multi-operator-participant-rotation-summary-v1",
-    account_id: accountId,
-    participant_id: participant.participant_id,
-    status: participant.status,
-    predecessor_participant_id: participant.rotated_from_participant_id || null,
-    successor_participant_id: participant.replaced_by_participant_id || null,
-    rotation_state: participant.rotated_from_participant_id || participant.replaced_by_participant_id ? "lineage_present" : "standalone",
-    linked_surfaces: {
-      participant_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participants/${encodeURIComponent(participantId)}`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMultiOperatorReviewBundle(state, accountId) {
-  const participants = listOperatorParticipantsForAccount(state, accountId);
-  const reviewRows = participants.map((entry) => {
-    let review_state = "healthy";
-    if (entry.status === "revoked") review_state = "revoked";
-    else if (!entry.authority_binding_id || !entry.identity_binding_id) review_state = "repair_required";
-    else if (ensureArray(entry.participant_scope).length === 0) review_state = "attention_required";
-    return {
-      participant_id: entry.participant_id,
-      label: entry.label,
-      status: entry.status,
-      operator_kind: entry.operator_kind,
-      review_state,
-      authority_binding_id: entry.authority_binding_id || null,
-      identity_binding_id: entry.identity_binding_id || null
-    };
-  });
-  return {
-    bundle_version: "xytara-multi-operator-review-bundle-v1",
-    account_id: accountId,
-    review_rows: reviewRows,
-    review_counts: {
-      healthy_count: reviewRows.filter((entry) => entry.review_state === "healthy").length,
-      attention_required_count: reviewRows.filter((entry) => entry.review_state === "attention_required").length,
-      repair_required_count: reviewRows.filter((entry) => entry.review_state === "repair_required").length,
-      revoked_count: reviewRows.filter((entry) => entry.review_state === "revoked").length
-    },
-    linked_surfaces: {
-      participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participants`,
-      package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMultiOperatorAttentionSummary(state, accountId) {
-  const reviewBundle = buildMultiOperatorReviewBundle(state, accountId);
-  const attentionRows = ensureArray(reviewBundle.review_rows).filter((entry) => entry.review_state !== "healthy");
-  return {
-    summary_version: "xytara-multi-operator-attention-summary-v1",
-    account_id: accountId,
-    overall_attention_state: attentionRows.length > 0 ? "attention_required" : "healthy",
-    attention_rows: attentionRows,
-    linked_surfaces: {
-      multi_operator_review_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-review-bundle`,
-      multi_operator_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMultiOperatorParticipationSummary(state, accountId) {
-  const authoritySummary = buildAuthoritySummary(state, accountId);
-  const machineIdentitySummary = buildMachineIdentitySummary(state, accountId);
-  const trustLayerSummary = buildTrustLayerSummary(state, accountId);
-  const operatorParticipants = listOperatorParticipantsForAccount(state, accountId);
-  const agentAccounts = listLegacyAgentAccountsForParticipation(state, accountId);
-  const coordinationHandoffCount = ensureArray(state.coordinationHandoffs).length;
-  const admissionCaseCount = ensureArray(state.zoneAdmissionCases).length;
-  const activeAuthorityBindings = Number(authoritySummary.authority_binding_count || 0);
-  const activeIdentityBindings = Number(machineIdentitySummary.identity_binding_count || 0);
-  const activeParticipantCount = operatorParticipants.filter((entry) => entry.status === "active").length;
-  const activeAgentCount = agentAccounts.filter((entry) => entry.status === "active").length;
-  const activeOperatorCount = activeParticipantCount > 0 ? activeParticipantCount : activeAgentCount;
-
-  let participationState = "single_operator_only";
-  if (activeOperatorCount >= 2 && activeAuthorityBindings > 0 && activeIdentityBindings > 0) {
-    participationState = "multi_operator_ready";
-  } else if (activeOperatorCount >= 1 || activeAuthorityBindings > 0 || activeIdentityBindings > 0) {
-    participationState = "emerging_multi_operator";
-  }
-
-  let coordinationReadinessState = "limited";
-  if (coordinationHandoffCount > 0 && admissionCaseCount > 0) {
-    coordinationReadinessState = "active";
-  } else if (coordinationHandoffCount > 0 || admissionCaseCount > 0) {
-    coordinationReadinessState = "preview_ready";
-  }
-
-  let participationRiskState = "low";
-  if (trustLayerSummary.trust_risk_state === "high" || activeOperatorCount === 0) {
-    participationRiskState = "high";
-  } else if (coordinationReadinessState !== "active" || participationState !== "multi_operator_ready") {
-    participationRiskState = "watch";
-  }
-
-  let recommendedParticipationMotion = "maintain_multi_operator_posture";
-  if (participationState === "single_operator_only") {
-    recommendedParticipationMotion = "establish_second_operator_and_bindings";
-  } else if (participationRiskState === "high") {
-    recommendedParticipationMotion = "repair_trust_before_multi_operator_expansion";
-  } else if (coordinationReadinessState !== "active") {
-    recommendedParticipationMotion = "activate_coordination_followthrough";
-  } else if (participationState === "emerging_multi_operator") {
-    recommendedParticipationMotion = "tighten_multi_operator_contracts";
-  }
-
-  return {
-    summary_version: "xytara-multi-operator-participation-summary-v1",
-    account_id: accountId,
-    multi_operator_participation_state: participationState,
-    coordination_readiness_state: coordinationReadinessState,
-    participation_risk_state: participationRiskState,
-    recommended_participation_motion: recommendedParticipationMotion,
-    explanation_signals: {
-      active_operator_participant_count: activeParticipantCount,
-      active_legacy_agent_account_count: activeAgentCount,
-      authority_binding_count: activeAuthorityBindings,
-      identity_binding_count: activeIdentityBindings,
-      trust_state: trustLayerSummary.trust_state,
-      trust_risk_state: trustLayerSummary.trust_risk_state,
-      coordination_handoff_count: coordinationHandoffCount,
-      admission_case_count: admissionCaseCount
-    },
-    linked_surfaces: {
-      multi_operator_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participants`,
-      agent_accounts_ref: "/v1/agent-accounts",
-      authority_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/authority-summary`,
-      machine_identity_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/machine-identity-summary`,
-      trust_layer_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-summary`,
-      coordination_center_ref: "/v1/coordination-center/summary",
-      zones_dashboard_ref: "/v1/coordination-center/zones-dashboard"
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMultiOperatorParticipationOperatorBundle(state, accountId) {
-  const summary = buildMultiOperatorParticipationSummary(state, accountId);
-  const authoritySummary = buildAuthoritySummary(state, accountId);
-  const machineIdentitySummary = buildMachineIdentitySummary(state, accountId);
-  const trustLayerSummary = buildTrustLayerSummary(state, accountId);
-  const reviewBundle = buildMultiOperatorReviewBundle(state, accountId);
-  const attentionSummary = buildMultiOperatorAttentionSummary(state, accountId);
-  const operatorParticipants = listMultiOperatorParticipants(state, accountId);
-  const agentAccounts = listLegacyAgentAccountsForParticipation(state, accountId);
-  const activeOperatorCount = operatorParticipants.filter((entry) => entry.status === "active").length;
-
-  let recommendedOperatorMotion = "maintain_multi_operator_posture";
-  if (summary.multi_operator_participation_state === "single_operator_only") {
-    recommendedOperatorMotion = "issue_additional_operator_account";
-  } else if (summary.participation_risk_state === "high") {
-    recommendedOperatorMotion = "repair_multi_operator_trust";
-  } else if (summary.coordination_readiness_state !== "active") {
-    recommendedOperatorMotion = "open_coordination_followthrough";
-  } else if (summary.multi_operator_participation_state === "emerging_multi_operator") {
-    recommendedOperatorMotion = "tighten_multi_operator_contracts";
-  }
-
-  return {
-    bundle_version: "xytara-multi-operator-participation-operator-bundle-v1",
-    account_id: accountId,
-    operator_posture: {
-      multi_operator_participation_state: summary.multi_operator_participation_state,
-      coordination_readiness_state: summary.coordination_readiness_state,
-      participation_risk_state: summary.participation_risk_state,
-      active_operator_participant_count: activeOperatorCount,
-      active_legacy_agent_account_count: agentAccounts.filter((entry) => entry.status === "active").length,
-      authority_state: authoritySummary.authority_state,
-      machine_identity_state: machineIdentitySummary.machine_identity_state,
-      trust_state: trustLayerSummary.trust_state,
-      overall_attention_state: attentionSummary.overall_attention_state,
-      recommended_operator_motion: recommendedOperatorMotion
-    },
-    multi_operator_participation_summary: summary,
-    multi_operator_review_bundle: reviewBundle,
-    multi_operator_attention_summary: attentionSummary,
-    authority_summary: authoritySummary,
-    machine_identity_summary: machineIdentitySummary,
-    trust_layer_summary: trustLayerSummary,
-    operator_participants: operatorParticipants,
-    legacy_agent_accounts: agentAccounts,
-    linked_surfaces: summary.linked_surfaces,
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeMultiOperatorParticipationOperatorBundle(state, accountId) {
-  const bundle = buildMultiOperatorParticipationOperatorBundle(state, accountId);
-  return {
-    bundle_version: bundle.bundle_version,
-    account_id: bundle.account_id,
-    multi_operator_participation_state: bundle.operator_posture.multi_operator_participation_state,
-    coordination_readiness_state: bundle.operator_posture.coordination_readiness_state,
-    participation_risk_state: bundle.operator_posture.participation_risk_state,
-    recommended_operator_motion: bundle.operator_posture.recommended_operator_motion
-  };
-}
-
-function buildMultiOperatorParticipationPolicyPack(state, accountId) {
-  const operatorBundle = buildMultiOperatorParticipationOperatorBundle(state, accountId);
-  const templates = [
-    {
-      template_id: "second_operator_foundation",
-      recommended_for: "opening a second operator track on top of a single-operator account",
-      target_motion: "issue_additional_operator_account",
-      target_state: "emerging_multi_operator"
-    },
-    {
-      template_id: "coordination_activation",
-      recommended_for: "activating cross-zone and coordination followthrough",
-      target_motion: "open_coordination_followthrough",
-      target_state: "emerging_multi_operator"
-    },
-    {
-      template_id: "contract_tightening",
-      recommended_for: "tightening authority and identity contracts for multiple operators",
-      target_motion: "tighten_multi_operator_contracts",
-      target_state: "multi_operator_ready"
-    },
-    {
-      template_id: "multi_operator_trust_repair",
-      recommended_for: "repairing trust before widening operator participation",
-      target_motion: "repair_multi_operator_trust",
-      target_state: "emerging_multi_operator"
-    },
-    {
-      template_id: "steady_multi_operator_maintenance",
-      recommended_for: "maintaining a healthy multi-operator runtime posture",
-      target_motion: "maintain_multi_operator_posture",
-      target_state: "multi_operator_ready"
-    }
-  ];
-
-  return {
-    pack_version: "xytara-multi-operator-participation-policy-pack-v1",
-    account_id: accountId,
-    multi_operator_participation_operator_bundle: operatorBundle,
-    recommended_policy_motion: operatorBundle.operator_posture.recommended_operator_motion,
-    policy_templates: templates,
-    linked_surfaces: {
-      multi_operator_participation_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-operator-bundle`,
-      multi_operator_participation_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-application-summary`,
-      multi_operator_participation_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeMultiOperatorParticipationPolicyPack(state, accountId) {
-  const pack = buildMultiOperatorParticipationPolicyPack(state, accountId);
-  return {
-    pack_version: pack.pack_version,
-    account_id: pack.account_id,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    template_count: ensureArray(pack.policy_templates).length
-  };
-}
-
-function buildMultiOperatorParticipationApplicationSummary(state, accountId, templateId) {
-  const pack = buildMultiOperatorParticipationPolicyPack(state, accountId);
-  const selectedTemplate = ensureArray(pack.policy_templates).find((entry) => entry.template_id === templateId)
-    || ensureArray(pack.policy_templates).find((entry) => entry.target_motion === pack.recommended_policy_motion)
-    || ensureArray(pack.policy_templates)[0]
-    || null;
-
-  return {
-    summary_version: "xytara-multi-operator-participation-application-summary-v1",
-    account_id: accountId,
-    recommended_policy_motion: pack.recommended_policy_motion,
-    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
-    available_template_ids: ensureArray(pack.policy_templates).map((entry) => entry.template_id),
-    selected_template: selectedTemplate,
-    suggested_participation_targets: {
-      multi_operator_participation_state: pack.multi_operator_participation_operator_bundle.operator_posture.multi_operator_participation_state,
-      coordination_readiness_state: pack.multi_operator_participation_operator_bundle.operator_posture.coordination_readiness_state,
-      participation_risk_state: pack.multi_operator_participation_operator_bundle.operator_posture.participation_risk_state,
-      trust_state: pack.multi_operator_participation_operator_bundle.operator_posture.trust_state
-    },
-    linked_surfaces: {
-      multi_operator_participation_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-policy-pack`,
-      multi_operator_participation_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-operator-bundle`,
-      multi_operator_participation_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMultiOperatorParticipationPackage(state, accountId) {
-  const summary = buildMultiOperatorParticipationSummary(state, accountId);
-  const operatorBundle = buildMultiOperatorParticipationOperatorBundle(state, accountId);
-  const policyPack = buildMultiOperatorParticipationPolicyPack(state, accountId);
-  const applicationSummary = buildMultiOperatorParticipationApplicationSummary(state, accountId, null);
-  const reviewBundle = buildMultiOperatorReviewBundle(state, accountId);
-  const attentionSummary = buildMultiOperatorAttentionSummary(state, accountId);
-
-  return {
-    package_version: "xytara-multi-operator-participation-package-v1",
-    account_id: accountId,
-    package_posture: {
-      multi_operator_participation_state: summary.multi_operator_participation_state,
-      coordination_readiness_state: summary.coordination_readiness_state,
-      participation_risk_state: summary.participation_risk_state,
-      overall_attention_state: attentionSummary.overall_attention_state,
-      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion,
-      recommended_policy_motion: policyPack.recommended_policy_motion
-    },
-    multi_operator_participation_summary: summary,
-    multi_operator_participation_operator_bundle: operatorBundle,
-    multi_operator_participation_policy_pack: policyPack,
-    multi_operator_participation_application_summary: applicationSummary,
-    multi_operator_review_bundle: reviewBundle,
-    multi_operator_attention_summary: attentionSummary,
-    linked_surfaces: {
-      multi_operator_participation_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-summary`,
-      multi_operator_participation_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-operator-bundle`,
-      multi_operator_participation_policy_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-policy-pack`,
-      multi_operator_participation_application_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-application-summary`,
-      multi_operator_review_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-review-bundle`,
-      multi_operator_attention_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-attention-summary`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function summarizeMultiOperatorParticipationPackage(state, accountId) {
-  const pack = buildMultiOperatorParticipationPackage(state, accountId);
-  return {
-    package_version: pack.package_version,
-    account_id: pack.account_id,
-    multi_operator_participation_state: pack.package_posture.multi_operator_participation_state,
-    coordination_readiness_state: pack.package_posture.coordination_readiness_state,
-    participation_risk_state: pack.package_posture.participation_risk_state,
-    recommended_operator_motion: pack.package_posture.recommended_operator_motion,
-    recommended_policy_motion: pack.package_posture.recommended_policy_motion
-  };
-}
-
-function listNetworkParticipantsForAccount(state, accountId) {
-  return Array.from(state.networkParticipants.values())
-    .filter((entry) => entry && entry.account_id === accountId);
-}
-
-function buildNetworkParticipantPublicView(entry) {
-  if (!entry) return null;
-  return {
-    network_participant_id: entry.network_participant_id,
-    account_id: entry.account_id,
-    label: entry.label,
-    network_kind: entry.network_kind,
-    partner_ref: entry.partner_ref || null,
-    status: entry.status,
-    participation_scope: ensureArray(entry.participation_scope),
-    authority_binding_id: entry.authority_binding_id || null,
-    identity_binding_id: entry.identity_binding_id || null,
-    created_at_iso: entry.created_at_iso,
-    updated_at_iso: entry.updated_at_iso,
-    issued_by: entry.issued_by || null,
-    labels: ensureArray(entry.labels)
-  };
-}
-
-function listNetworkParticipants(state, accountId) {
-  return listNetworkParticipantsForAccount(state, accountId).map((entry) => buildNetworkParticipantPublicView(entry));
-}
-
-function getNetworkParticipant(state, accountId, participantId) {
-  if (!participantId || !state.networkParticipants.has(participantId)) return null;
-  const entry = state.networkParticipants.get(participantId);
-  if (!entry || entry.account_id !== accountId) return null;
-  return buildNetworkParticipantPublicView(entry);
-}
-
-function buildNetworkParticipationAdmissionPreview(state, accountId, body) {
-  const payload = ensureObject(body);
-  const nextIndex = listNetworkParticipantsForAccount(state, accountId).length + 1;
-  return {
-    preview_version: "xytara-network-participation-admission-preview-v1",
-    account_id: accountId,
-    proposed_participant: {
-      label: normalizeString(payload.label, `network-participant-${nextIndex}`),
-      network_kind: normalizeString(payload.network_kind, "external_operator"),
-      partner_ref: normalizeString(payload.partner_ref, `partner_${nextIndex}`),
-      participation_scope: ensureArray(payload.participation_scope).length > 0
-        ? ensureArray(payload.participation_scope)
-        : ["network.coordinate", "runtime.execute"]
-    },
-    planned_bindings: {
-      authority_kind: normalizeString(payload.authority_kind, "delegated_runtime_spend"),
-      identity_kind: normalizeString(payload.identity_kind, "registry_anchor_identity")
-    },
-    linked_surfaces: {
-      network_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participants`,
-      network_participation_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function createNetworkParticipant(state, accountId, body) {
-  const payload = ensureObject(body);
-  const createdAtIso = nowIso();
-  const nextIndex = state.networkParticipants.size + 1;
-  const networkParticipantId = normalizeString(payload.network_participant_id, `network_participant_${nextIndex}`);
-  const participationScope = ensureArray(payload.participation_scope).length > 0
-    ? ensureArray(payload.participation_scope).map((value) => String(value || "").trim()).filter(Boolean)
-    : ["network.coordinate", "runtime.execute"];
-  const authorityBinding = createAuthorityBinding(state, {
-    binding_id: normalizeString(payload.authority_binding_id, `${networkParticipantId}_authority`),
-    credential_id: normalizeString(payload.credential_id, `${networkParticipantId}_credential`),
-    account_id: accountId,
-    authority_kind: normalizeString(payload.authority_kind, "delegated_runtime_spend"),
-    authority_scope: participationScope,
-    allowed_consequence_families: ensureArray(payload.allowed_consequence_families).length > 0
-      ? ensureArray(payload.allowed_consequence_families)
-      : ["commit", "reserve"],
-    max_commit_units: Number.isFinite(Number(payload.max_commit_units)) ? Number(payload.max_commit_units) : 5,
-    max_reserve_units: Number.isFinite(Number(payload.max_reserve_units)) ? Number(payload.max_reserve_units) : 5,
-    max_reversal_units: Number.isFinite(Number(payload.max_reversal_units)) ? Number(payload.max_reversal_units) : 1,
-    labels: ensureArray(payload.labels),
-    issued_by: normalizeString(payload.issued_by, "operator")
-  });
-  const identityBinding = createIdentityBinding(state, {
-    binding_id: normalizeString(payload.identity_binding_id, `${networkParticipantId}_identity`),
-    account_id: accountId,
-    identity_kind: normalizeString(payload.identity_kind, "registry_anchor_identity"),
-    identity_ref: normalizeString(payload.identity_ref, `${networkParticipantId}.identity`),
-    attached_agent_account_id: networkParticipantId,
-    labels: ensureArray(payload.labels),
-    issued_by: normalizeString(payload.issued_by, "operator")
-  });
-  const participant = {
-    network_participant_id: networkParticipantId,
-    account_id: accountId,
-    label: normalizeString(payload.label, networkParticipantId),
-    network_kind: normalizeString(payload.network_kind, "external_operator"),
-    partner_ref: normalizeString(payload.partner_ref, null),
-    status: normalizeString(payload.status, "active"),
-    participation_scope: participationScope,
-    authority_binding_id: authorityBinding.binding_id,
-    identity_binding_id: identityBinding.binding_id,
-    created_at_iso: createdAtIso,
-    updated_at_iso: createdAtIso,
-    issued_by: normalizeString(payload.issued_by, "operator"),
-    labels: ensureArray(payload.labels).map((value) => String(value || "").trim()).filter(Boolean)
-  };
-  state.networkParticipants.set(networkParticipantId, participant);
-  return {
-    network_participant: buildNetworkParticipantPublicView(participant),
-    authority_binding: authorityBinding,
-    identity_binding: identityBinding
-  };
-}
-
-function buildNetworkParticipationReviewBundle(state, accountId) {
-  const participants = listNetworkParticipantsForAccount(state, accountId);
-  const reviewRows = participants.map((entry) => {
-    let review_state = "healthy";
-    if (entry.status !== "active") review_state = "revoked";
-    else if (!entry.authority_binding_id || !entry.identity_binding_id) review_state = "repair_required";
-    else if (!entry.partner_ref) review_state = "attention_required";
-    return {
-      network_participant_id: entry.network_participant_id,
-      label: entry.label,
-      network_kind: entry.network_kind,
-      status: entry.status,
-      partner_ref: entry.partner_ref || null,
-      review_state
-    };
-  });
-  return {
-    bundle_version: "xytara-network-participation-review-bundle-v1",
-    account_id: accountId,
-    review_rows: reviewRows,
-    review_counts: {
-      healthy_count: reviewRows.filter((entry) => entry.review_state === "healthy").length,
-      attention_required_count: reviewRows.filter((entry) => entry.review_state === "attention_required").length,
-      repair_required_count: reviewRows.filter((entry) => entry.review_state === "repair_required").length,
-      revoked_count: reviewRows.filter((entry) => entry.review_state === "revoked").length
-    },
-    linked_surfaces: {
-      network_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participants`,
-      network_participation_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildNetworkParticipationAttentionSummary(state, accountId) {
-  const reviewBundle = buildNetworkParticipationReviewBundle(state, accountId);
-  const attentionRows = ensureArray(reviewBundle.review_rows).filter((entry) => entry.review_state !== "healthy");
-  return {
-    summary_version: "xytara-network-participation-attention-summary-v1",
-    account_id: accountId,
-    overall_attention_state: attentionRows.length > 0 ? "attention_required" : "healthy",
-    attention_rows: attentionRows,
-    linked_surfaces: {
-      network_participation_review_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-review-bundle`,
-      network_participation_package_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-package`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildNetworkParticipationSummary(state, accountId) {
-  const trustLayerSummary = buildTrustLayerSummary(state, accountId);
-  const multiOperatorSummary = buildMultiOperatorParticipationSummary(state, accountId);
-  const participants = listNetworkParticipantsForAccount(state, accountId);
-  const activeParticipantCount = participants.filter((entry) => entry.status === "active").length;
-  const coordinationHandoffCount = ensureArray(state.coordinationHandoffs).length;
-  const admissionCaseCount = ensureArray(state.zoneAdmissionCases).length;
-
-  let participationState = "local_only";
-  if (activeParticipantCount > 0 && multiOperatorSummary.multi_operator_participation_state !== "single_operator_only") {
-    participationState = "external_network_present";
-  } else if (activeParticipantCount > 0) {
-    participationState = "network_edge_present";
-  }
-
-  let networkReadinessState = "limited";
-  if (activeParticipantCount > 0 && coordinationHandoffCount > 0 && admissionCaseCount > 0) {
-    networkReadinessState = "active";
-  } else if (activeParticipantCount > 0 || coordinationHandoffCount > 0 || admissionCaseCount > 0) {
-    networkReadinessState = "preview_ready";
-  }
-
-  let participationRiskState = "low";
-  if (trustLayerSummary.trust_risk_state === "high" || activeParticipantCount === 0) {
-    participationRiskState = "high";
-  } else if (networkReadinessState !== "active") {
-    participationRiskState = "watch";
-  }
-
-  let recommendedParticipationMotion = "maintain_external_network_posture";
-  if (activeParticipantCount === 0) {
-    recommendedParticipationMotion = "admit_first_external_network_participant";
-  } else if (participationRiskState === "high") {
-    recommendedParticipationMotion = "repair_trust_before_external_network_expansion";
-  } else if (networkReadinessState !== "active") {
-    recommendedParticipationMotion = "activate_external_coordination_followthrough";
-  }
-
-  return {
-    summary_version: "xytara-network-participation-summary-v1",
-    account_id: accountId,
-    network_participation_state: participationState,
-    network_readiness_state: networkReadinessState,
-    participation_risk_state: participationRiskState,
-    recommended_participation_motion: recommendedParticipationMotion,
-    explanation_signals: {
-      active_network_participant_count: activeParticipantCount,
-      coordination_handoff_count: coordinationHandoffCount,
-      admission_case_count: admissionCaseCount,
-      trust_state: trustLayerSummary.trust_state,
-      trust_risk_state: trustLayerSummary.trust_risk_state,
-      multi_operator_participation_state: multiOperatorSummary.multi_operator_participation_state
-    },
-    linked_surfaces: {
-      network_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participants`,
-      multi_operator_participation_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/multi-operator-participation-summary`,
-      trust_layer_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/trust-layer-summary`,
-      coordination_center_ref: "/v1/coordination-center/summary"
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildNetworkParticipationOperatorBundle(state, accountId) {
-  const summary = buildNetworkParticipationSummary(state, accountId);
-  const reviewBundle = buildNetworkParticipationReviewBundle(state, accountId);
-  const attentionSummary = buildNetworkParticipationAttentionSummary(state, accountId);
-  const trustLayerSummary = buildTrustLayerSummary(state, accountId);
-  const multiOperatorSummary = buildMultiOperatorParticipationSummary(state, accountId);
-  const participants = listNetworkParticipants(state, accountId);
-
-  let recommendedOperatorMotion = "maintain_external_network_posture";
-  if (summary.network_participation_state === "local_only") {
-    recommendedOperatorMotion = "admit_first_external_network_participant";
-  } else if (summary.participation_risk_state === "high") {
-    recommendedOperatorMotion = "repair_trust_before_external_network_expansion";
-  } else if (summary.network_readiness_state !== "active") {
-    recommendedOperatorMotion = "activate_external_coordination_followthrough";
-  }
-
-  return {
-    bundle_version: "xytara-network-participation-operator-bundle-v1",
-    account_id: accountId,
-    operator_posture: {
-      network_participation_state: summary.network_participation_state,
-      network_readiness_state: summary.network_readiness_state,
-      participation_risk_state: summary.participation_risk_state,
-      active_network_participant_count: participants.filter((entry) => entry.status === "active").length,
-      trust_state: trustLayerSummary.trust_state,
-      multi_operator_participation_state: multiOperatorSummary.multi_operator_participation_state,
-      overall_attention_state: attentionSummary.overall_attention_state,
-      recommended_operator_motion: recommendedOperatorMotion
-    },
-    network_participation_summary: summary,
-    network_participation_review_bundle: reviewBundle,
-    network_participation_attention_summary: attentionSummary,
-    trust_layer_summary: trustLayerSummary,
-    multi_operator_participation_summary: multiOperatorSummary,
-    network_participants: participants,
-    linked_surfaces: summary.linked_surfaces,
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildNetworkParticipationPackage(state, accountId) {
-  const summary = buildNetworkParticipationSummary(state, accountId);
-  const operatorBundle = buildNetworkParticipationOperatorBundle(state, accountId);
-  const reviewBundle = buildNetworkParticipationReviewBundle(state, accountId);
-  const attentionSummary = buildNetworkParticipationAttentionSummary(state, accountId);
-  return {
-    package_version: "xytara-network-participation-package-v1",
-    account_id: accountId,
-    package_posture: {
-      network_participation_state: summary.network_participation_state,
-      network_readiness_state: summary.network_readiness_state,
-      participation_risk_state: summary.participation_risk_state,
-      overall_attention_state: attentionSummary.overall_attention_state,
-      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion
-    },
-    network_participation_summary: summary,
-    network_participation_operator_bundle: operatorBundle,
-    network_participation_review_bundle: reviewBundle,
-    network_participation_attention_summary: attentionSummary,
-    linked_surfaces: {
-      network_participation_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-summary`,
-      network_participation_operator_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-operator-bundle`,
-      network_participation_review_bundle_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-review-bundle`,
-      network_participation_attention_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participation-attention-summary`,
-      network_participants_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/network-participants`
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildRailSummary(state, accountId) {
-  const credits = listRailCreditsForAccount(state, accountId);
-  const railCreditLifecycle = summarizeRailCreditLifecycle(credits);
-  const paymentLedger = listPaymentLedgerForAccount(state, accountId);
-  const spends = listCreditSpendsForAccount(state, accountId);
-  const entitlements = listEntitlementsForAccount(state, accountId);
-  const replenishment = buildEntitlementReplenishmentSummary(state, accountId);
-  return {
-    account_id: accountId,
-    credit_event_count: credits.length,
-    credit_mint_count: railCreditLifecycle.mint_count,
-    credit_reverse_count: railCreditLifecycle.reverse_count,
-    credit_units_total: railCreditLifecycle.minted_units,
-    reversed_credit_units_total: railCreditLifecycle.reversed_units,
-    credit_spend_count: spends.length,
-    entitlement_count: entitlements.length,
-    low_balance_entitlement_count: replenishment.low_balance_count,
-    depleted_entitlement_count: replenishment.depleted_count,
-    available_credit_units: buildCreditBalanceSummary(state, accountId).available_units,
-    settlement_adapter_counts: paymentLedger.reduce((acc, entry) => {
-      const key = entry && entry.settlement_adapter ? entry.settlement_adapter : "unknown";
-      acc[key] = (acc[key] || 0) + 1;
-      return acc;
-    }, {}),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTreasuryWorkflowPack(state, accountId) {
-  return {
-    pack_version: "xytara-economics-treasury-workflow-pack-v1",
-    account_id: accountId,
-    treasury_summary: buildTreasurySummary(state, accountId),
-    rail_summary: buildRailSummary(state, accountId),
-    policy_summary: buildPolicySummary(state, accountId),
-    reconciliation_pack: buildReconciliationPack(state, accountId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildTreasurySignoffPack(state, accountId) {
-  return {
-    pack_version: "xytara-economics-treasury-signoff-pack-v1",
-    workflow_pack: buildTreasuryWorkflowPack(state, accountId),
-    signoff_posture: "operator_review_required",
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildRailWorkflowPack(state, accountId) {
-  return {
-    pack_version: "xytara-economics-rail-workflow-pack-v1",
-    account_id: accountId,
-    rail_summary: buildRailSummary(state, accountId),
-    treasury_summary: buildTreasurySummary(state, accountId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildRailSignoffPack(state, accountId) {
-  return {
-    pack_version: "xytara-economics-rail-signoff-pack-v1",
-    workflow_pack: buildRailWorkflowPack(state, accountId),
-    signoff_posture: "operator_review_required",
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMarketPreview(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const treasurySummary = buildTreasurySummary(state, accountId);
-  return {
-    account_id: accountId,
-    market_ref: normalizeString(payload.market_ref, "market.default"),
-    interaction_class: normalizeString(payload.interaction_class, "standard"),
-    admissible_capacity_hint: {
-      minted_units: treasurySummary.treasury.minted_units,
-      committed_units: treasurySummary.treasury.committed_units,
-      free_units: Math.max(0, treasurySummary.treasury.minted_units - treasurySummary.treasury.committed_units)
-    },
-    recommended_artifacts: [
-      "treasury_summary",
-      "rail_summary",
-      "policy_summary",
-      "reconciliation_pack"
-    ],
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMarketWorkflowPack(state, body) {
-  const preview = buildMarketPreview(state, body);
-  return {
-    pack_version: "xytara-economics-market-workflow-pack-v1",
-    preview,
-    treasury_summary: buildTreasurySummary(state, preview.account_id),
-    rail_summary: buildRailSummary(state, preview.account_id),
-    policy_summary: buildPolicySummary(state, preview.account_id),
-    reconciliation_pack: buildReconciliationPack(state, preview.account_id),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMarketSignoffPack(state, body) {
-  const workflowPack = buildMarketWorkflowPack(state, body);
-  return {
-    pack_version: "xytara-economics-market-signoff-pack-v1",
-    workflow_pack: workflowPack,
-    signoff_posture: "operator_review_required",
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildMarketCoordinationPack(state, body) {
-  const signoffPack = buildMarketSignoffPack(state, body);
-  return {
-    pack_version: "xytara-economics-market-coordination-pack-v1",
-    signoff_pack: signoffPack,
-    adjacency_refs: {
-      coordination_surface: "/v1/economics/markets/coordination-pack",
-      next_public_surface: "/v1/zones"
-    },
-    generated_at_iso: nowIso()
-  };
-}
-
-function actOnEconomicsJob(state, jobId, body) {
-  const payload = ensureObject(body);
-  const entry = {
-    job_id: normalizeString(jobId, `job_${ensureArray(state.economicsJobActions).length + 1}`),
-    account_id: normalizeString(payload.account_id, "acct_demo"),
-    action: normalizeString(payload.action, "reviewed"),
-    actor: normalizeString(payload.actor, "operator"),
-    reason: normalizeString(payload.reason, null),
-    created_at_iso: nowIso()
-  };
-  state.economicsJobActions = [entry, ...ensureArray(state.economicsJobActions)].slice(0, 200);
-  return entry;
-}
-
-function buildEvidenceByReceipt(state, receiptRef) {
-  const receipt = state.economicsReceipts.get(receiptRef) || null;
-  if (!receipt) return null;
-  const ledgerConsequences = ensureArray(state.economicsAllocations).filter((entry) => entry && entry.receipt_ref === receiptRef);
-  return {
-    receipt,
-    ledger_consequences: ledgerConsequences,
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildEvidenceByJob(state, jobId) {
-  const receipts = Array.from(state.economicsReceipts.values()).filter((entry) => entry && entry.job_id === jobId);
-  return {
-    job_id: jobId,
-    economics_receipts: receipts,
-    ledger_consequences: ensureArray(state.economicsAllocations).filter((entry) => entry && entry.job_id === jobId),
-    operator_actions: ensureArray(state.economicsJobActions).filter((entry) => entry && entry.job_id === jobId),
-    generated_at_iso: nowIso()
-  };
-}
-
-function buildIntegrationJobEvidence(state, jobId) {
-  const evidence = buildEvidenceByJob(state, jobId);
-  return {
-    integration_job_ref: jobId,
-    adjacent_surfaces: {
-      proof_side: "/v1/proof-bundles/build",
-      transaction_side: "/v1/payment-ledger"
-    },
-    evidence_bundle: evidence,
-    generated_at_iso: nowIso()
-  };
-}
-
-function validateReceiptLedgerHandoff(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  return {
-    ok: true,
-    account_id: accountId,
-    validation_status: "valid",
-    handoff_kind: "receipt_ledger",
-    payment_ledger_count: listPaymentLedgerForAccount(state, accountId).length,
-    receipt_count: listMapValuesByAccount(state.economicsReceipts, accountId).length,
-    generated_at_iso: nowIso()
-  };
-}
-
-function emitInterpretationHandoff(state, body) {
-  const payload = ensureObject(body);
-  const accountId = normalizeString(payload.account_id, "acct_demo");
-  const treasurySummary = buildTreasurySummary(state, accountId);
-  const handoff = {
-    handoff_version: "xytara-economics-interpretation-handoff-v1",
-    account_id: accountId,
-    treasury_summary: treasurySummary,
-    policy_summary: buildPolicySummary(state, accountId),
-    rail_summary: buildRailSummary(state, accountId),
-    reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`,
-    generated_at_iso: nowIso()
-  };
-  state.economicsInterpretationHandoffs = [handoff, ...ensureArray(state.economicsInterpretationHandoffs)].slice(0, 50);
-  return {
-    ok: true,
-    handoff
-  };
-}
-
-module.exports = {
-  createEconomicsBudget,
-  setEconomicsBudgetStatus,
-  createEconomicsAgent,
-  setEconomicsAgentStatus,
-  createEconomicsReceipt,
-  updateEconomicsReceiptLifecycle,
-  actOnEconomicsReceipt,
-  recordAllocationEvent,
-  previewRailCredits,
-  applyRailCredits,
-  reverseRailCredits,
-  buildCreditBalanceSummary,
-  buildWalletSummary,
-  buildWalletLifecycleSummary,
-  buildWalletReserveSummary,
-  buildWalletCommitSummary,
-  buildWalletLedgerBundle,
-  buildWalletLedgerSummary,
-  applyWalletLifecycleEvent,
-  buildEconomicsIntelligenceSummary,
-  buildTreasuryIntelligenceSummary,
-  buildTreasurySummary,
-  buildLedgerExport,
-  buildTreasuryDrilldown,
-  buildReconciliationPack,
-  buildAccountSummary,
-  buildOperatorView,
-  buildOperatorDashboard,
-  buildPolicySummary,
-  buildAccountCreditSpendPolicyPack,
-  buildAgentCreditSpendPolicyView,
-  buildPricingPolicySummary,
-  buildPricingPolicyOperatorBundle,
-  buildPricingPolicyPack,
-  buildPricingPolicyApplicationSummary,
-  buildPricingPolicyPackage,
-  buildQuotePolicyDecisionSummary,
-  buildPricingBandDecisionSummary,
-  buildQuotePolicyOperatorBundle,
-  summarizeQuotePolicyOperatorBundle,
-  buildQuotePolicyPack,
-  summarizeQuotePolicyPack,
-  buildQuotePolicyApplicationSummary,
-  buildQuotePolicyPackage,
-  summarizeQuotePolicyPackage,
-  buildTrustInputSummary,
-  buildTrustLayerSummary,
-  buildTrustLayerOperatorBundle,
-  summarizeTrustLayerOperatorBundle,
-  buildTrustLayerPolicyPack,
-  summarizeTrustLayerPolicyPack,
-  buildTrustLayerApplicationSummary,
-  buildTrustLayerPackage,
-  summarizeTrustLayerPackage,
-  listNetworkParticipants,
-  getNetworkParticipant,
-  buildNetworkParticipationAdmissionPreview,
-  createNetworkParticipant,
-  buildNetworkParticipationReviewBundle,
-  buildNetworkParticipationAttentionSummary,
-  buildNetworkParticipationSummary,
-  buildNetworkParticipationOperatorBundle,
-  buildNetworkParticipationPackage,
-  listMultiOperatorParticipants,
-  getMultiOperatorParticipant,
-  buildMultiOperatorAdmissionPreview,
-  createMultiOperatorParticipant,
-  renewMultiOperatorParticipant,
-  revokeMultiOperatorParticipant,
-  rotateMultiOperatorParticipant,
-  buildMultiOperatorParticipantRotationSummary,
-  buildMultiOperatorReviewBundle,
-  buildMultiOperatorAttentionSummary,
-  buildMultiOperatorParticipationSummary,
-  buildMultiOperatorParticipationOperatorBundle,
-  summarizeMultiOperatorParticipationOperatorBundle,
-  buildMultiOperatorParticipationPolicyPack,
-  summarizeMultiOperatorParticipationPolicyPack,
-  buildMultiOperatorParticipationApplicationSummary,
-  buildMultiOperatorParticipationPackage,
-  summarizeMultiOperatorParticipationPackage,
-  buildRailSummary,
-  buildTreasuryWorkflowPack,
-  buildTreasurySignoffPack,
-  buildRailWorkflowPack,
-  buildRailSignoffPack,
-  buildEntitlementSummary,
-  buildEntitlementReplenishmentSummary,
-  buildEntitlementReplenishmentView,
-  buildEconomicConsequenceHandoffBundle,
-  buildUsageMeterPreview,
-  buildUsageMeteringSummary,
-  buildMarketPreview,
-  buildMarketWorkflowPack,
-  buildMarketSignoffPack,
-  buildMarketCoordinationPack,
-  consumeAccountCredits,
-  previewCreditSpend,
-  actOnEconomicsJob,
-  buildEvidenceByReceipt,
-  buildEvidenceByJob,
-  buildIntegrationJobEvidence,
-  validateReceiptLedgerHandoff,
-  emitInterpretationHandoff,
-  listMapValuesByAccount,
-  listEntitlementsForAccount,
-  getEntitlement,
-  getAllocationEvent,
-  getCreditSpend,
-  listUsageMetersForAccount,
-  getUsageMeter,
-  upsertEntitlementPool,
-  updateEntitlementReplenishmentPreference
-};