xytara 3.1.16 → 3.2.0

package/lib/activity_audit_contract.js

@@ -1,322 +0,0 @@
-"use strict";
-
-function toArrayFromMap(mapValue) {
-  if (!(mapValue instanceof Map)) return [];
-  return Array.from(mapValue.values());
-}
-
-function normalizeTimestamp(value) {
-  if (typeof value !== "string" || !value.trim()) return null;
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
-}
-
-function firstTimestamp(record, fieldNames) {
-  for (const fieldName of fieldNames) {
-    const timestamp = normalizeTimestamp(record && record[fieldName]);
-    if (timestamp) return timestamp;
-  }
-  return null;
-}
-
-function sortByTimestampDescending(items) {
-  return [...items].sort((left, right) => {
-    const leftTime = left && left.at_iso ? Date.parse(left.at_iso) : 0;
-    const rightTime = right && right.at_iso ? Date.parse(right.at_iso) : 0;
-    return rightTime - leftTime;
-  });
-}
-
-function buildQuoteActivities(state, accountId) {
-  return toArrayFromMap(state.quotes)
-    .filter((quote) => !accountId || quote.account_id === accountId)
-    .map((quote) => ({
-      activity_id: `quote.${quote.quote_id}`,
-      activity_kind: "quote",
-      activity_family: "commercial_admission",
-      at_iso: firstTimestamp(quote, ["executed_at_iso", "payment_recorded_at_iso", "created_at_iso"]),
-      account_id: quote.account_id || null,
-      actor_ref: quote.account_id || null,
-      action: quote.status === "executed" ? "quoted_and_executed" : "quoted",
-      status: quote.status || null,
-      amount_minor: quote.amount_minor || null,
-      currency: quote.currency || null,
-      settlement_mode: quote.settlement_mode || null,
-      payment_protocol: quote.payment_protocol || null,
-      route_ref: "/v1/payment-quotes",
-      linked_refs: {
-        quote_ref: quote.quote_id ? `/v1/quotes/${encodeURIComponent(quote.quote_id)}` : null
-      }
-    }));
-}
-
-function buildTransactionActivities(state, accountId) {
-  return toArrayFromMap(state.transactions)
-    .map((entry) => entry && entry.transaction ? entry.transaction : null)
-    .filter(Boolean)
-    .filter((transaction) => !accountId || transaction.account_id === accountId)
-    .map((transaction) => ({
-      activity_id: `transaction.${transaction.transaction_id}`,
-      activity_kind: "transaction",
-      activity_family: "runtime_execution",
-      at_iso: firstTimestamp(transaction, ["completed_at_iso", "created_at_iso"]),
-      account_id: transaction.account_id || null,
-      actor_ref: transaction.account_id || null,
-      action: "executed_runtime_work",
-      status: transaction.status || null,
-      amount_minor: transaction.payment && transaction.payment.amount_minor ? transaction.payment.amount_minor : null,
-      currency: transaction.payment && transaction.payment.currency ? transaction.payment.currency : null,
-      settlement_mode: transaction.settlement && transaction.settlement.mode ? transaction.settlement.mode : null,
-      payment_protocol: transaction.payment && transaction.payment.protocol ? transaction.payment.protocol : null,
-      delivery_target_kind: transaction.callback_url ? "callback" : "direct",
-      route_ref: "/v1/commands/execute",
-      linked_refs: {
-        transaction_ref: transaction.transaction_id ? `/v1/transactions/${encodeURIComponent(transaction.transaction_id)}` : null,
-        proof_ref: transaction.proof_ref || null
-      }
-    }));
-}
-
-function buildReceiptActivities(state, accountId) {
-  return toArrayFromMap(state.receipts)
-    .map((entry) => entry && entry.receipt ? entry.receipt : null)
-    .filter(Boolean)
-    .filter((receipt) => !accountId || receipt.account_id === accountId)
-    .map((receipt) => ({
-      activity_id: `receipt.${receipt.receipt_id}`,
-      activity_kind: "receipt",
-      activity_family: "delivery_proof",
-      at_iso: firstTimestamp(receipt, ["created_at_iso", "completed_at_iso"]),
-      account_id: receipt.account_id || null,
-      actor_ref: receipt.account_id || null,
-      action: "receipt_issued",
-      status: receipt.status || null,
-      proof_ref: receipt.proof_ref || null,
-      route_ref: receipt.receipt_id ? `/v1/receipts/${encodeURIComponent(receipt.receipt_id)}` : "/v1/receipts",
-      linked_refs: {
-        receipt_ref: receipt.receipt_id ? `/v1/receipts/${encodeURIComponent(receipt.receipt_id)}` : null
-      }
-    }));
-}
-
-function buildPaymentActivities(state, accountId) {
-  const ledger = Array.isArray(state.paymentLedger) ? state.paymentLedger : [];
-  return ledger
-    .filter((payment) => !accountId || payment.account_id === accountId)
-    .map((payment) => ({
-      activity_id: `payment.${payment.payment_id}`,
-      activity_kind: "payment",
-      activity_family: "funds_in",
-      at_iso: firstTimestamp(payment, ["recorded_at_iso"]),
-      account_id: payment.account_id || null,
-      actor_ref: payment.account_id || null,
-      action: "payment_recorded",
-      status: payment.payment && payment.payment.status ? payment.payment.status : null,
-      amount_minor: payment.amount_minor || null,
-      currency: payment.currency || null,
-      settlement_mode: payment.settlement && payment.settlement.mode ? payment.settlement.mode : null,
-      settlement_adapter: payment.settlement_adapter || null,
-      settlement_integration_id: payment.settlement_integration_id || null,
-      payment_protocol: payment.payment && payment.payment.protocol ? payment.payment.protocol : null,
-      treasury_destination_id: payment.treasury && payment.treasury.destination_id ? payment.treasury.destination_id : null,
-      treasury_external_ref: payment.treasury && payment.treasury.custody_external_ref ? payment.treasury.custody_external_ref : null,
-      route_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}` : "/v1/payment-ledger",
-      linked_refs: {
-        payment_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}` : null,
-        operator_pack_ref: payment.payment_id ? `/v1/payment-ledger/${encodeURIComponent(payment.payment_id)}/operator-pack` : null
-      }
-    }));
-}
-
-function buildDeliveryActivities(state, accountId) {
-  return toArrayFromMap(state.deliveries)
-    .filter((delivery) => !accountId || delivery.account_id === accountId)
-    .map((delivery) => ({
-      activity_id: `delivery.${delivery.delivery_id}`,
-      activity_kind: "delivery",
-      activity_family: "delivery_proof",
-      at_iso: firstTimestamp(delivery, ["delivered_at_iso", "last_attempt_at_iso", "created_at_iso"]),
-      account_id: delivery.account_id || null,
-      actor_ref: delivery.account_id || null,
-      action: delivery.status === "delivered" ? "delivered_result" : "delivery_pending",
-      status: delivery.status || null,
-      output_ref: delivery.output_ref || null,
-      proof_ref: delivery.proof_ref || null,
-      payment_id: delivery.payment_id || null,
-      delivery_target_kind: delivery.delivery_target_kind || null,
-      route_ref: delivery.transaction_id ? `/v1/transactions/${encodeURIComponent(delivery.transaction_id)}` : null,
-      linked_refs: {
-        transaction_ref: delivery.transaction_id ? `/v1/transactions/${encodeURIComponent(delivery.transaction_id)}` : null,
-        receipt_ref: delivery.receipt_id ? `/v1/receipts/${encodeURIComponent(delivery.receipt_id)}` : null
-      }
-    }));
-}
-
-function buildHistoryActivities(records, accountId, config) {
-  return records.flatMap((record) => {
-    const history = Array.isArray(record && record.history) ? record.history : [];
-    return history
-      .filter((entry) => {
-        const recordAccountId = record && record.account_id ? record.account_id : null;
-        const transactionId = record && record.transaction_id ? record.transaction_id : null;
-        if (!accountId) return true;
-        return recordAccountId === accountId || transactionId === accountId || record && record.requested_by === accountId;
-      })
-      .map((entry, index) => ({
-        activity_id: `${config.prefix}.${record[config.idField]}.${index}`,
-        activity_kind: config.kind,
-        activity_family: config.family,
-        at_iso: firstTimestamp(entry, ["at_iso"]) || firstTimestamp(record, ["updated_at_iso", "created_at_iso"]),
-        account_id: record && record.account_id ? record.account_id : null,
-        actor_ref: entry && entry.actor ? `${entry.actor.type || "actor"}:${entry.actor.role || "unknown"}` : null,
-        action: entry && entry.event ? entry.event : config.defaultAction,
-        status: entry && entry.next_status ? entry.next_status : record.status || null,
-        reason_code: entry && entry.reason_code ? entry.reason_code : record.reason_code || null,
-        note: entry && entry.note ? entry.note : null,
-        route_ref: config.routeTemplate(record[config.idField]),
-        linked_refs: {
-          transaction_ref: record && record.transaction_id ? `/v1/transactions/${encodeURIComponent(record.transaction_id)}` : null,
-          receipt_ref: record && record.receipt_id ? `/v1/receipts/${encodeURIComponent(record.receipt_id)}` : null
-        }
-      }));
-  });
-}
-
-function buildCreditGrantActivities(state, accountId) {
-  return toArrayFromMap(state.externalCreditGrants)
-    .filter((grant) => !accountId || grant.account_id === accountId)
-    .map((grant) => ({
-      activity_id: `credit_grant.${grant.grant_id || grant.credit_grant_id || grant.account_id || "unknown"}`,
-      activity_kind: "credit_grant",
-      activity_family: "funding",
-      at_iso: firstTimestamp(grant, ["created_at_iso", "granted_at_iso", "recorded_at_iso"]),
-      account_id: grant.account_id || null,
-      actor_ref: grant.account_id || null,
-      action: "credit_granted",
-      status: grant.status || null,
-      amount_minor: grant.amount_minor || grant.credit_amount_minor || null,
-      currency: grant.currency || null,
-      route_ref: "/v1/credit-bridge/grants",
-      linked_refs: {}
-    }));
-}
-
-function buildBridgeActivities(state, accountId) {
-  return toArrayFromMap(state.runtimeBridgeDispatches)
-    .filter((dispatch) => !accountId || dispatch.account_id === accountId)
-    .map((dispatch) => ({
-      activity_id: `bridge.${dispatch.dispatch_id || dispatch.bridge_dispatch_id || "unknown"}`,
-      activity_kind: "bridge_dispatch",
-      activity_family: "runtime_proof_handoff",
-      at_iso: firstTimestamp(dispatch, ["created_at_iso", "dispatched_at_iso", "recorded_at_iso"]),
-      account_id: dispatch.account_id || null,
-      actor_ref: dispatch.account_id || null,
-      action: "bridge_dispatched",
-      status: dispatch.status || null,
-      route_ref: "/v1/proof-bridge",
-      linked_refs: {
-        proof_ref: dispatch.proof_ref || null,
-        receipt_ref: dispatch.receipt_id ? `/v1/receipts/${encodeURIComponent(dispatch.receipt_id)}` : null
-      }
-    }));
-}
-
-function buildParticipantActivities(records, kind, routeRef) {
-  return records.map((participant) => ({
-    activity_id: `${kind}.${participant.participant_id || participant.operator_id || participant.network_participant_id || "unknown"}`,
-    activity_kind: kind,
-    activity_family: "third_party_participation",
-    at_iso: firstTimestamp(participant, ["created_at_iso", "updated_at_iso", "admitted_at_iso"]),
-    account_id: participant.account_id || null,
-    actor_ref: participant.account_id || null,
-    action: `registered_${kind}`,
-    status: participant.status || null,
-    route_ref: routeRef,
-    linked_refs: {}
-  }));
-}
-
-function buildActivityLedger(state, options) {
-  const accountId = options && options.account_id ? options.account_id : null;
-  const activities = sortByTimestampDescending([
-    ...buildQuoteActivities(state, accountId),
-    ...buildTransactionActivities(state, accountId),
-    ...buildReceiptActivities(state, accountId),
-    ...buildPaymentActivities(state, accountId),
-    ...buildDeliveryActivities(state, accountId),
-    ...buildHistoryActivities(toArrayFromMap(state.refunds), accountId, {
-      prefix: "refund",
-      idField: "refund_id",
-      kind: "refund",
-      family: "remediation",
-      defaultAction: "refund_review",
-      routeTemplate: (id) => `/v1/refunds/${encodeURIComponent(id)}`
-    }),
-    ...buildHistoryActivities(toArrayFromMap(state.disputes), accountId, {
-      prefix: "dispute",
-      idField: "dispute_id",
-      kind: "dispute",
-      family: "remediation",
-      defaultAction: "dispute_review",
-      routeTemplate: (id) => `/v1/disputes/${encodeURIComponent(id)}`
-    }),
-    ...buildHistoryActivities(toArrayFromMap(state.remediationTickets), accountId, {
-      prefix: "remediation_ticket",
-      idField: "ticket_id",
-      kind: "remediation_ticket",
-      family: "remediation",
-      defaultAction: "remediation_review",
-      routeTemplate: (id) => `/v1/remediation-tickets/${encodeURIComponent(id)}`
-    }),
-    ...buildCreditGrantActivities(state, accountId),
-    ...buildBridgeActivities(state, accountId),
-    ...buildParticipantActivities(toArrayFromMap(state.operatorParticipants), "operator_participant", "/v1/multi-operator"),
-    ...buildParticipantActivities(toArrayFromMap(state.networkParticipants), "network_participant", "/v1/network-participation")
-  ]).slice(0, 300);
-
-  return {
-    product: "xytara",
-    category: "machine-commerce-activity-ledger",
-    pack_version: "xytara-activity-ledger-v1",
-    posture: "operator_facing_runtime_and_funds_activity_visibility",
-    audit_posture: "operator_visibility_first",
-    account_scope: accountId || "all_accounts",
-    counts: {
-      activity_count: activities.length,
-      payment_count: activities.filter((entry) => entry.activity_kind === "payment").length,
-      transaction_count: activities.filter((entry) => entry.activity_kind === "transaction").length,
-      delivery_count: activities.filter((entry) => entry.activity_kind === "delivery").length,
-      remediation_count: activities.filter((entry) => entry.activity_family === "remediation").length,
-      participation_count: activities.filter((entry) => entry.activity_family === "third_party_participation").length
-    },
-    activities,
-    linked_surfaces: {
-      payment_ledger_ref: "/v1/payment-ledger",
-      reconciliation_report_ref: "/v1/reconciliation-report",
-      integration_registry_ref: "/v1/integrations",
-      treasury_summary_ref_template: "/v1/economics/accounts/:account_id/treasury-summary",
-      rail_summary_ref_template: "/v1/economics/accounts/:account_id/rail-summary",
-      proof_bridge_ref: "/v1/proof-bridge",
-      activity_summary_ref: "/v1/activity-ledger/summary"
-    },
-    operator_note: "use this ledger to inspect who did what, what was paid, what was delivered, and how funds and consequence moved through the runtime"
-  };
-}
-
-function summarizeActivityLedger(state, options) {
-  const pack = buildActivityLedger(state, options);
-  return {
-    product: "xytara",
-    category: "machine-commerce-activity-ledger-summary",
-    summary_version: "xytara-activity-ledger-summary-v1",
-    activity_count: pack.counts.activity_count,
-    account_scope: pack.account_scope,
-    counts: pack.counts,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-module.exports = {
-  buildActivityLedger,
-  summarizeActivityLedger
-};

package/lib/adapter_certification_contract.js

@@ -1,130 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-
-function buildAdapterCertificationContractPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "naxytra-adapter-certification-contract",
-    pack_version: "naxytra-adapter-certification-contract-v1",
-    doctrine: "xytara_certifies_adapters_by_front_specific_normalized_contracts_without_leaking_vendor_truth_into_core_logic",
-    model_state: "core_now",
-    core_claim: "adapter certification is the machine-readable gate for manifest, capability, health, idempotency, failure, proof, and front-specific compatibility claims",
-    certification_states: [
-      { state: "pass", description: "the adapter satisfies the declared front contract without material constraints" },
-      { state: "pass_with_constraints", description: "the adapter is usable but only within declared constraints" },
-      { state: "needs_retest", description: "the adapter needs a fresh run against updated vectors or interface versions" },
-      { state: "blocked", description: "the adapter cannot be certified until a required dependency or vector exists" },
-      { state: "fail", description: "the adapter does not satisfy the declared front contract" }
-    ],
-    certification_fronts: [
-      {
-        front_id: "protocol_front",
-        required_tests: ["protocol negotiation", "surface discovery", "normalized request translation"],
-        required_evidence: ["manifest", "protocol compatibility result", "failure mapping result"],
-        claim_boundary: "only_claim_listed_protocol_front_compatibility"
-      },
-      {
-        front_id: "execution_front",
-        required_tests: ["task dispatch", "idempotency", "execution result normalization"],
-        required_evidence: ["manifest", "task vector results", "proof-compatible output facts"],
-        claim_boundary: "only_claim_listed_execution_front_compatibility"
-      },
-      {
-        front_id: "payment_front",
-        required_tests: ["quote to pay compatibility", "payment admission", "reversal or refund posture"],
-        required_evidence: ["payment state result", "receipt compatibility result", "failure mapping result"],
-        claim_boundary: "only_claim_listed_payment_front_compatibility"
-      },
-      {
-        front_id: "settlement_front",
-        required_tests: ["settlement target translation", "finality reference capture", "batch or direct settlement posture"],
-        required_evidence: ["settlement reference", "finality state", "reconciliation evidence"],
-        claim_boundary: "only_claim_listed_settlement_front_compatibility"
-      },
-      {
-        front_id: "identity_trust_front",
-        required_tests: ["identity schema compatibility", "registry linkage", "attestation or trust-state roundtrip"],
-        required_evidence: ["identity record", "registry proof", "trust-state result"],
-        claim_boundary: "only_claim_listed_identity_trust_front_compatibility"
-      },
-      {
-        front_id: "proof_front",
-        required_tests: ["receipt compatibility", "proof import or export compatibility", "verification hook compatibility"],
-        required_evidence: ["proof contract result", "receipt result", "verification evidence"],
-        claim_boundary: "only_claim_listed_proof_front_compatibility"
-      },
-      {
-        front_id: "treasury_front",
-        required_tests: ["destination routing", "balance model compatibility", "payout landing compatibility"],
-        required_evidence: ["treasury route result", "account abstraction result", "operator review note"],
-        claim_boundary: "only_claim_listed_treasury_front_compatibility"
-      },
-      {
-        front_id: "operator_front",
-        required_tests: ["review surface visibility", "promotion posture", "reporting export compatibility"],
-        required_evidence: ["review summary", "promotion readiness result", "operator export"],
-        claim_boundary: "only_claim_listed_operator_front_compatibility"
-      }
-    ],
-    harness_requirements: {
-      test_categories: [
-        "manifest_validity",
-        "interface_conformance",
-        "capability_declaration",
-        "health_reporting",
-        "failure_mapping",
-        "idempotency_behavior",
-        "proof_compatibility",
-        "front_specific_lifecycle_compatibility"
-      ],
-      required_result_fields: [
-        "certification_state",
-        "interface_version",
-        "tested_fronts",
-        "tested_capabilities",
-        "failed_cases",
-        "warnings",
-        "evidence_refs"
-      ]
-    },
-    linked_surfaces: {
-      integrations_summary_ref: "/v1/integrations/summary",
-      promotion_readiness_ref: "/v1/integrations/promotion-readiness",
-      promotion_actions_ref: "/v1/integrations/promotion-actions",
-      submission_bundle_review_ref: "/v1/integrations/review/submission-bundle",
-      submission_bundle_set_review_ref: "/v1/integrations/review/submission-bundle-set",
-      registry_snapshot_review_ref: "/v1/integrations/review/registry-snapshot"
-    },
-    claim_boundary: "claim_adapter_certification_as_front_specific_compatibility_and_review_gate_without_claiming_vendor_default_or_runtime_truth"
-  };
-}
-
-function summarizeAdapterCertificationContractPack() {
-  const pack = buildAdapterCertificationContractPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    summary_version: "naxytra-adapter-certification-contract-summary-v1",
-    pack_version: pack.pack_version,
-    model_state: pack.model_state,
-    certification_state_count: pack.certification_states.length,
-    certification_front_count: pack.certification_fronts.length,
-    required_test_category_count: pack.harness_requirements.test_categories.length,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-function getAdapterCertificationFrontDetail(frontId) {
-  const normalized = String(frontId || "").trim().toLowerCase();
-  return (buildAdapterCertificationContractPack().certification_fronts || []).find((entry) => entry.front_id === normalized) || null;
-}
-
-module.exports = {
-  buildAdapterCertificationContractPack,
-  summarizeAdapterCertificationContractPack,
-  getAdapterCertificationFrontDetail
-};
-

package/lib/adapter_depth_contract.js

@@ -1,218 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const { catalog } = require("../fixtures/catalog");
-const { loadExecutionTargetRegistry } = require("./external_execution_runtime");
-const { listProviders } = require("./provider_registry");
-
-function normalizeString(value, fallback = "") {
-  const raw = typeof value === "string" ? value.trim() : "";
-  return raw || fallback;
-}
-
-function listAdapterTasks() {
-  return (Array.isArray(catalog.tasks) ? catalog.tasks : [])
-    .filter((task) => normalizeString(task && task.public_category) === "adapter")
-    .map((task) => ({
-      task_ref: task.public_task_ref,
-      internal_task_ref: task.task_ref,
-      public_title: task.public_title,
-      execution_mode: task.execution_mode,
-      latency_class: task.latency_class
-    }));
-}
-
-function listTargetsForTask(taskRef) {
-  const normalizedTaskRef = normalizeString(taskRef);
-  return loadExecutionTargetRegistry().filter((target) => {
-    if (!target || target.enabled === false) return false;
-    if (normalizeString(target.task_ref) === normalizedTaskRef) return true;
-    if (normalizedTaskRef === "adapter.mcp.invoke" || normalizedTaskRef.startsWith("adapter.mcp.")) {
-      return Boolean(normalizeString(target.tool_name) || normalizeString(target.integration_id));
-    }
-    return false;
-  });
-}
-
-function summarizeTarget(target) {
-  const provider = normalizeString(target && target.provider, "external_execution");
-  const toolName = normalizeString(target && target.tool_name);
-  return {
-    target_id: target.target_id,
-    provider,
-    task_ref: target.task_ref || null,
-    tool_name: toolName || null,
-    integration_id: target.integration_id || null,
-    enabled: target.enabled !== false,
-    timeout_ms: target.timeout_ms,
-    endpoint_configured: Boolean(normalizeString(target.endpoint_url)),
-    auth_configured: Boolean(normalizeString(target.auth_token)),
-    operational_coverage: {
-      execute_endpoint: Boolean(normalizeString(target.endpoint_url)),
-      bearer_auth: Boolean(normalizeString(target.auth_token)),
-      bounded_timeout: Number(target.timeout_ms || 0) >= 500,
-      proof_fact_compatible: provider === "xytara_mcp_executor" || toolName === "summarize" || toolName === "zones.lookup",
-      deterministic_retry_surface: true,
-      tool_level_binding: Boolean(toolName),
-      operator_health_surface: provider === "xytara_mcp_executor" ? "/health" : null,
-      operator_tool_catalog_surface: provider === "xytara_mcp_executor" ? "/tools" : null
-    }
-  };
-}
-
-// ACTIVE open-network providers that declared this task_ref. Env targets resolve before the
-// registry at call time, so a provider is shadowed (not routed) when an enabled env target pins
-// the WHOLE lane (task_ref with no tool/integration selector); it is then listed but not counted.
-function listRegistryProvidersForTask(state, taskRef, envTargets) {
-  if (!state) return [];
-  const normalizedTaskRef = normalizeString(taskRef);
-  const wholeLanePinned = envTargets.some((target) =>
-    target.enabled !== false
-    && normalizeString(target.task_ref) === normalizedTaskRef
-    && !normalizeString(target.tool_name)
-    && !normalizeString(target.integration_id)
-  );
-  return listProviders(state, { status: "active" })
-    .filter((provider) => Array.isArray(provider.task_refs) && provider.task_refs.includes(normalizedTaskRef))
-    .map((provider) => {
-      const health = (provider.health && provider.health.status) || "healthy";
-      return {
-        target_id: `registry:${provider.provider_id}`,
-        provider: provider.provider_id,
-        routing: "open_provider_registry",
-        task_ref: normalizedTaskRef,
-        tool_name: null,
-        tool_names: Array.isArray(provider.tool_names) ? provider.tool_names.slice() : [],
-        integration_id: null,
-        enabled: !wholeLanePinned,
-        shadowed_by_env_target: wholeLanePinned,
-        health_status: health,
-        timeout_ms: provider.timeout_ms,
-        endpoint_configured: Boolean(normalizeString(provider.endpoint_url)),
-        auth_configured: Boolean(normalizeString(provider.auth_token)),
-        operational_coverage: {
-          execute_endpoint: Boolean(normalizeString(provider.endpoint_url)),
-          bearer_auth: Boolean(normalizeString(provider.auth_token)),
-          bounded_timeout: Number(provider.timeout_ms || 0) >= 500,
-          // The provider-network execution contract fixes the deliverable shape
-          // (result.output / output_payload), and activation is operator-vetted against it.
-          proof_fact_compatible: true,
-          deterministic_retry_surface: true,
-          tool_level_binding: Array.isArray(provider.tool_names) && provider.tool_names.length > 0,
-          operator_health_surface: "runtime_tracked_provider_health",
-          operator_tool_catalog_surface: null
-        }
-      };
-    });
-}
-
-function summarizeAdapterTaskDepth(task, state) {
-  const envTargets = listTargetsForTask(task.task_ref).map(summarizeTarget);
-  const registryTargets = listRegistryProvidersForTask(state, task.task_ref, loadExecutionTargetRegistry());
-  const targets = envTargets.concat(registryTargets);
-  const enabledTargets = targets.filter((target) => target.enabled);
-  const toolNames = Array.from(new Set(enabledTargets
-    .flatMap((target) => [target.tool_name].concat(target.tool_names || []))
-    .filter(Boolean))).sort();
-  const allTargetsCovered = enabledTargets.length > 0 && enabledTargets.every((target) =>
-    target.operational_coverage.execute_endpoint
-    && target.operational_coverage.bounded_timeout
-    && target.operational_coverage.proof_fact_compatible
-  );
-  const depthState = enabledTargets.length >= 2 && allTargetsCovered
-    ? "provider_live_path_deepened"
-    : enabledTargets.length > 0
-      ? "initial_provider_live_path"
-      : "provider_wiring_required";
-
-  return {
-    ...task,
-    provider_depth_state: depthState,
-    provider_live: enabledTargets.length > 0,
-    configured_target_count: targets.length,
-    enabled_target_count: enabledTargets.length,
-    env_target_count: envTargets.length,
-    registry_provider_count: registryTargets.filter((target) => target.enabled).length,
-    configured_tool_count: toolNames.length,
-    configured_tools: toolNames,
-    execution_targets: targets,
-    operator_claim_boundary: enabledTargets.length > 0
-      ? "claim_only_the_listed_task_and_tool_bindings_as_provider_live"
-      : "do_not_claim_provider_live_until_execution_targets_are_configured"
-  };
-}
-
-// `state` (optional): the live runtime state. When given, ACTIVE open-network providers count as
-// provider-live paths alongside operator env targets (each labelled routing:open_provider_registry).
-// Without it the pack is env-target-only, exactly as before.
-function buildAdapterDepthPack(state) {
-  const adapterTasks = listAdapterTasks().map((task) => summarizeAdapterTaskDepth(task, state));
-  const providerLiveTasks = adapterTasks.filter((task) => task.provider_live);
-  const deepenedTasks = adapterTasks.filter((task) => task.provider_depth_state === "provider_live_path_deepened");
-  const configuredTargets = loadExecutionTargetRegistry().filter((target) => target && target.enabled !== false);
-  const registryProviderIds = new Set(adapterTasks.flatMap((task) =>
-    task.execution_targets.filter((target) => target.routing === "open_provider_registry" && target.enabled).map((target) => target.provider)
-  ));
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-adapter-depth-pack",
-    pack_version: "xytara-adapter-depth-pack-v1",
-    adapter_depth_state: deepenedTasks.length > 0
-      ? "provider_live_path_deepened"
-      : providerLiveTasks.length > 0
-        ? "initial_provider_live_path"
-        : "provider_wiring_required",
-    counts: {
-      adapter_task_count: adapterTasks.length,
-      provider_live_task_count: providerLiveTasks.length,
-      deepened_provider_live_task_count: deepenedTasks.length,
-      configured_execution_target_count: configuredTargets.length,
-      configured_provider_count: new Set(configuredTargets.map((target) => normalizeString(target.provider))).size,
-      configured_tool_count: new Set(configuredTargets.map((target) => normalizeString(target.tool_name)).filter(Boolean)).size,
-      registry_provider_count: registryProviderIds.size
-    },
-    depth_sources: state ? ["operator_env_targets", "open_provider_registry"] : ["operator_env_targets"],
-    adapter_tasks: adapterTasks,
-    production_depth_requirements: [
-      "at_least_one_enabled_execution_target_for_provider_backed_task",
-      "tool_or_integration_level_binding_for_claimed_provider_lane",
-      "bounded_timeout_and_retry_observability",
-      "proof_fact_compatible_result_shape",
-      "operator_health_or_catalog_surface_for_target_service"
-    ],
-    public_claim_boundary: {
-      live_provider_claim_allowed: providerLiveTasks.length > 0,
-      deep_provider_claim_allowed: deepenedTasks.length > 0,
-      live_task_refs: providerLiveTasks.map((task) => task.task_ref),
-      deepened_task_refs: deepenedTasks.map((task) => task.task_ref),
-      rule: "only_claim_provider_depth_for_task_refs_and_tool_bindings_listed_in_this_pack"
-    },
-    linked_surfaces: {
-      execution_truth_ref: "/v1/capability-registry/execution-truth",
-      adapter_depth_summary_ref: "/v1/adapter-depth/summary",
-      integrations_ref: "/v1/integrations",
-      runtime_bridge_ref: "/v1/runtime-bridge/dispatches"
-    }
-  };
-}
-
-function summarizeAdapterDepthPack(state) {
-  const pack = buildAdapterDepthPack(state);
-  return {
-    ok: true,
-    product: pack.product,
-    category: "machine-commerce-adapter-depth-summary",
-    summary_version: "xytara-adapter-depth-summary-v1",
-    adapter_depth_state: pack.adapter_depth_state,
-    counts: pack.counts,
-    depth_sources: pack.depth_sources,
-    public_claim_boundary: pack.public_claim_boundary,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-module.exports = {
-  buildAdapterDepthPack,
-  summarizeAdapterDepthPack
-};