xytara 2.3.0 → 2.4.0

package/lib/commerce_economics.js

@@ -2,6 +2,26 @@
 
 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() : "";
@@ -155,13 +175,21 @@ function actOnEconomicsReceipt(state, receiptId, body) {
 
 function recordAllocationEvent(state, body, direction) {
   const payload = ensureObject(body);
+  const allocationId = normalizeString(payload.allocation_id, `alloc_${state.economicsAllocations.length + 1}`);
   const event = {
-    allocation_id: normalizeString(payload.allocation_id, `alloc_${state.economicsAllocations.length + 1}`),
+    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),
@@ -347,6 +375,11 @@ 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;
@@ -527,21 +560,126 @@ function buildWalletSummary(state, accountId) {
       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 mintedUnits = allocations
+    .filter((entry) => entry && entry.direction === "mint")
+    .reduce((sum, entry) => sum + Number(entry.units || 0), 0)
+    + railCredits.reduce((sum, entry) => sum + Number(entry.units || 0), 0);
+  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);
+  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: railCredits.length
+      },
+      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
+      }
+    },
+    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 + spends.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
   };
@@ -551,6 +689,7 @@ function buildWalletLedgerSummary(state, accountId) {
     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: {
@@ -562,6 +701,7 @@ function buildWalletLedgerSummary(state, accountId) {
       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,
@@ -578,6 +718,7 @@ function buildWalletLedgerSummary(state, accountId) {
     },
     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`
     },
@@ -585,6 +726,235 @@ function buildWalletLedgerSummary(state, accountId) {
   };
 }
 
+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 [];
@@ -875,6 +1245,21 @@ function consumeAccountCredits(state, body) {
       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,
@@ -1484,6 +1869,1731 @@ function buildAgentCreditSpendPolicyView(state, accountId, agentId) {
   };
 }
 
+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 paymentLedger = listPaymentLedgerForAccount(state, accountId);
@@ -1703,7 +3813,12 @@ module.exports = {
   applyRailCredits,
   buildCreditBalanceSummary,
   buildWalletSummary,
+  buildWalletLifecycleSummary,
+  buildWalletReserveSummary,
+  buildWalletCommitSummary,
+  buildWalletLedgerBundle,
   buildWalletLedgerSummary,
+  applyWalletLifecycleEvent,
   buildEconomicsIntelligenceSummary,
   buildTreasuryIntelligenceSummary,
   buildTreasurySummary,
@@ -1716,6 +3831,56 @@ module.exports = {
   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,
@@ -1742,6 +3907,7 @@ module.exports = {
   listMapValuesByAccount,
   listEntitlementsForAccount,
   getEntitlement,
+  getAllocationEvent,
   getCreditSpend,
   listUsageMetersForAccount,
   getUsageMeter,