xoonya 2.3.0 → 2.5.0

package/README.md

@@ -14,6 +14,22 @@ This repo is the proof-side half of the final two-repo public stack. It focuses
 
 The 10-phase public program is now complete. `xoonya` is in terminal closeout posture rather than active milestone build posture.
 
+## One-Line After Install
+
+If you only run two commands after install, use:
+
+- `xoonya start-here`
+- `xoonya release --summary`
+
+If you want the shortest machine-readable discovery path, inspect:
+
+- `GET /v1/providers`
+- `GET /v1/frameworks`
+- `GET /v1/integration-matrix`
+- `GET /v1/proof-bridge`
+- `GET /v1/telemetry`
+- `GET /v1/provenance`
+
 ## Start Here
 
 If you are new to the proof-side package, use this order:

package/RELEASE_NOTES.md

@@ -1,29 +1,33 @@
-# xoonya 2.3.0 Release Notes
+# xoonya 2.5.0 Release Notes
 
-`xoonya` 2.3.0 is the public proof-spine intelligence line.
+`xoonya` 2.5.0 is the adoption-surface proof line for contracts, provider and framework discovery, bridge trust, observability, provenance, artifact distribution, shared signals, and rollout portability.
 
 Highlights:
 
-- direct one-line proof-side review with `xoonya-review`
-- trust intelligence for proof readiness, bridge confidence, and recommended review motion
-- review intelligence for governance burden, dispute risk, and dependency posture
-- governance intelligence for escalation, signoff, and handoff continuity
-- bridge intelligence for compatibility strength and bridge coverage posture
-- canonical event, receipt, and proof-bundle model with stable runtime-to-proof followthrough
-- partner-ready onboarding, launch docs, and public example paths remain in place
+- umbrella CLI entrypoint with `xoonya start-here`, plus `xoonya review` and `xoonya release`
+- first-class public contract lanes for `OpenAPI`, `AsyncAPI`, and `CloudEvents`
+- first-class provider, framework, and integration-matrix discovery surfaces for the proof side
+- surfaced proof breadth across `proof-bridge`, `external-proof-import`, `result-package-trust`, major rails, treasury, and registry-backed integrations
+- surfaced observability, provenance, artifact-distribution, shared-signals, and feature-control lanes for proof operations and trust
+- explicit proof-role freeze, role-transition, and capability-registry-home posture remain in place
+- canonical event, receipt, and proof-bundle model remain the proof center while external compatibility stays adapter-friendly
+- clearer install-and-use posture for reviewers, operators, outside builders, and proof-carry integrations
 
 Recommended first checks:
 
 1. `npm install xoonya`
-2. `xoonya-release --candidate --summary`
+2. `xoonya start-here`
 3. `npm run verify:release-candidate`
 4. `node examples/partner_proof_walkthrough.js`
-5. inspect `/v1/trust-intelligence` and `/v1/review-intelligence`
-6. inspect `/v1/governance-intelligence` and `/v1/bridge-intelligence`
-7. inspect `/v1/proof-center/summary` on the deployed service
+5. inspect `/v1/providers`, `/v1/frameworks`, `/v1/integration-matrix`, and `/v1/proof-bridge`
+6. inspect `/v1/telemetry`, `/v1/provenance`, `/v1/artifact-distribution`, `/v1/shared-signals`, and `/v1/feature-control`
+7. inspect `/v1/role-freeze/package`
+8. inspect `/v1/role-transition` and `/v1/capability-registry-home`
+9. inspect `/v1/proof-center/summary` on the deployed service
 
 Recommended first docs:
 
 - `PROGRAM_COMPLETE_RELEASE.md`
+- `FINAL_CONTRACT.md`
 - `WHY_XYTARA_XOONYA.md`
 - `PARTNER_READY_PATH.md`

package/SERVICE_CONTRACT.md

@@ -7,6 +7,54 @@ This file freezes the public service contract for `xoonya`.
 Primary proof-model routes:
 
 - `GET /health`
+- `GET /openapi.json`
+- `GET /v1/openapi`
+- `GET /v1/openapi/summary`
+- `GET /asyncapi.json`
+- `GET /v1/asyncapi`
+- `GET /v1/asyncapi/summary`
+- `GET /cloudevents.json`
+- `GET /v1/cloudevents`
+- `GET /v1/cloudevents/summary`
+- `GET /v1/auth-profiles`
+- `GET /v1/auth-profiles/summary`
+- `GET /v1/identity-interop`
+- `GET /v1/identity-interop/summary`
+- `GET /v1/providers`
+- `GET /v1/providers/summary`
+- `GET /v1/frameworks`
+- `GET /v1/frameworks/summary`
+- `GET /v1/integration-matrix`
+- `GET /v1/integration-matrix/summary`
+- `GET /v1/major-rails`
+- `GET /v1/major-rails/summary`
+- `GET /v1/treasury`
+- `GET /v1/treasury/summary`
+- `GET /v1/erc8004`
+- `GET /v1/erc8004/summary`
+- `GET /v1/proof-bridge`
+- `GET /v1/proof-bridge/summary`
+- `GET /v1/external-proof-import`
+- `GET /v1/external-proof-import/summary`
+- `GET /v1/result-package-trust`
+- `GET /v1/result-package-trust/summary`
+- `GET /v1/event-systems`
+- `GET /v1/event-systems/summary`
+- `GET /v1/telemetry`
+- `GET /v1/telemetry/summary`
+- `GET /v1/provenance`
+- `GET /v1/provenance/summary`
+- `GET /v1/artifact-distribution`
+- `GET /v1/artifact-distribution/summary`
+- `GET /v1/shared-signals`
+- `GET /v1/shared-signals/summary`
+- `GET /v1/feature-control`
+- `GET /v1/feature-control/summary`
+- `GET /v1/integrations`
+- `GET /v1/integrations/summary`
+- `GET /v1/integrations/snapshot`
+- `GET /v1/integrations/promotion-readiness`
+- `GET /v1/integrations/promotion-workflow`
 - `GET /v1/proof-center`
 - `GET /v1/proof-center/summary`
 - `GET /v1/proof-center/governance`
@@ -73,6 +121,22 @@ Expected error shapes:
 
 Compatibility routes may return proof/profile-specific verification payloads, but the top-level shape should still remain predictable.
 
+Interop note:
+
+- `GET /v1/identity-interop` exposes how native proof, attestation, and bridge surfaces map to `JWT`, `DID/VC`, and `SD-JWT VC` interop lanes without replacing canonical proof truth inside `xoonya`
+- `GET /v1/major-rails` exposes the Solana and Antelope/Proton XPR/Metal proof family as one practical settlement-evidence lane
+- `GET /v1/treasury` exposes treasury destination/accounting evidence continuity while keeping DAI/USDC and Monero reserve doctrine clearly internal
+- `GET /v1/external-proof-import` exposes the result, receipt, and proof-bundle import family as one builder-trust lane
+- `GET /v1/result-package-trust` exposes the carried result-package trust continuity posture as a first-class proof-side lane
+- `GET /v1/providers` exposes the OpenAI Codex and Claude/MCP family as first-class provider-origin proof lanes
+- `GET /v1/frameworks` exposes LangGraph, LangChain, AutoGen, and Semantic Kernel as first-class framework followthrough lanes
+- `GET /v1/integration-matrix` exposes the canonical public view across providers, frameworks, proof lanes, and registry-backed proof integrations
+- `GET /v1/telemetry` exposes the OpenTelemetry-aligned proof observability posture across review, verification, bridge, and proof event signals
+- `GET /v1/provenance` exposes the SLSA-aligned provenance posture for proof artifacts, release trust, and bundle followthrough confidence
+- `GET /v1/artifact-distribution` exposes OCI-style artifact distribution posture for proof bundles, handoff bundles, snapshots, and release artifacts
+- `GET /v1/shared-signals` exposes OpenID Shared Signals and CAEP-aligned review, bridge, import, and trust event exchange posture
+- `GET /v1/feature-control` exposes OpenFeature/OFREP-aligned rollout and review portability posture around role freeze, bridge, trust, and release gates
+
 ## Final-Loop Verification
 
 The constitutional proof loop for `xoonya` is:

package/START_HERE.md

@@ -52,6 +52,27 @@ For long-term product understanding, read:
 
 - [FINAL_CONTRACT.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/FINAL_CONTRACT.md)
 - [SERVICE_CONTRACT.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/SERVICE_CONTRACT.md)
+- `GET /openapi.json`
+- `GET /asyncapi.json`
+- `GET /cloudevents.json`
+- `GET /v1/auth-profiles`
+- `GET /v1/identity-interop`
+- `GET /v1/providers`
+- `GET /v1/frameworks`
+- `GET /v1/integration-matrix`
+- `GET /v1/telemetry`
+- `GET /v1/provenance`
+- `GET /v1/artifact-distribution`
+- `GET /v1/shared-signals`
+- `GET /v1/feature-control`
+- `GET /v1/major-rails`
+- `GET /v1/treasury`
+- `GET /v1/erc8004`
+- `GET /v1/proof-bridge`
+- `GET /v1/external-proof-import`
+- `GET /v1/result-package-trust`
+- `GET /v1/event-systems`
+- `GET /v1/integrations`
 - [PROGRAM_STATUS.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/PROGRAM_STATUS.md)
 - [OPERATOR_START_HERE.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/OPERATOR_START_HERE.md)
 - [OPERATIONS_RUNBOOK.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/OPERATIONS_RUNBOOK.md)
@@ -80,6 +101,12 @@ It is:
 
 receive handoff -> inspect review posture -> confirm run posture -> emit and verify proof
 
+If you want the shortest CLI-first read of the package after install, use:
+
+- `xoonya start-here`
+- `xoonya release --summary`
+- `xoonya review --help`
+
 ## 7. If You Are Operating The Closed Program
 
 Use:

package/bin/xoonya.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+function printUsage() {
+  process.stdout.write([
+    "Usage: xoonya <command> [options]",
+    "",
+    "Commands:",
+    "  release [args]    Open the release/adoption/reporting surface",
+    "  review [args]     Review a carried handoff or proof input",
+    "  start-here        Print the shortest first-run path",
+    "  help              Show this help message",
+    "",
+    "Fastest first run:",
+    "  xoonya start-here",
+    "  xoonya release --summary",
+    "  xoonya review --help"
+  ].join("\n"));
+}
+
+function printStartHere() {
+  process.stdout.write([
+    "xoonya start-here",
+    "",
+    "1. xoonya release --summary",
+    "2. node examples/package_quickstart.js",
+    "3. npm run verify:all",
+    "4. Inspect /v1/providers, /v1/frameworks, /v1/integration-matrix, /v1/proof-bridge",
+    "5. Continue into proof review, bridge, and import lanes as needed"
+  ].join("\n"));
+}
+
+function delegate(scriptName, args) {
+  const scriptPath = path.join(__dirname, scriptName);
+  const result = spawnSync(process.execPath, [scriptPath, ...args], { stdio: "inherit" });
+  process.exitCode = typeof result.status === "number" ? result.status : 1;
+}
+
+const [command, ...rest] = process.argv.slice(2);
+
+if (!command || command === "help" || command === "--help" || command === "-h") {
+  printUsage();
+} else if (command === "start-here" || command === "--start-here") {
+  printStartHere();
+} else if (command === "release") {
+  delegate("xoonya-release.js", rest);
+} else if (command === "review") {
+  delegate("xoonya-review.js", rest);
+} else {
+  printUsage();
+  process.exitCode = 1;
+}

package/lib/artifact_distribution_lane_contract.js

@@ -0,0 +1,54 @@
+"use strict";
+
+function buildArtifactDistributionLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-artifact-distribution-lane-pack",
+    pack_version: "xoonya-artifact-distribution-lane-pack-v1",
+    lane_state: "first_party_artifact_distribution_lane_present",
+    posture: "oci_style_distribution_for_proof_bundles_and_integration_artifacts",
+    standards: ["oci_artifacts", "oras_style_distribution"],
+    artifact_families: ["proof_bundles", "handoff_bundles", "integration_snapshots", "release_artifacts"],
+    supported_surfaces: {
+      integrations_ref: "/v1/integrations",
+      integrations_snapshot_ref: "/v1/integrations/snapshot",
+      proof_bridge_ref: "/v1/proof-bridge",
+      result_package_trust_ref: "/v1/result-package-trust",
+      release_center_ref: "/v1/release-center"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "proof_artifact_distribution_alignment",
+        recommended_reason: "best path for teams that want portable proof and integration artifacts rather than custom export conventions",
+        sequence: [
+          "inspect_artifact_distribution_lane_summary",
+          "inspect proof_bridge and import surfaces",
+          "treat proof bundles and integration snapshots as distribution-ready artifacts",
+          "publish or transfer them later through standard artifact registries without changing proof semantics"
+        ]
+      }
+    ],
+    guardrails: [
+      "artifact portability should preserve canonical proof bundle and handoff shapes",
+      "distribution posture must not create a second proof model"
+    ]
+  };
+}
+
+function summarizeArtifactDistributionLanePack() {
+  const pack = buildArtifactDistributionLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-artifact-distribution-lane-pack-summary",
+    summary_version: "xoonya-artifact-distribution-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    standard_count: pack.standards.length,
+    artifact_family_count: pack.artifact_families.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildArtifactDistributionLanePack,
+  summarizeArtifactDistributionLanePack
+};

package/lib/asyncapi_contract.js

@@ -0,0 +1,135 @@
+"use strict";
+
+const pkg = require("../package.json");
+
+function buildAsyncApiDocument() {
+  return {
+    asyncapi: "3.0.0",
+    info: {
+      title: "xoonya Event Contract",
+      version: pkg.version,
+      summary: "Proof and review event contract.",
+      description: "This AsyncAPI document describes the stable proof-side canonicalization, receipt, proof-bundle, and bridge event surfaces."
+    },
+    servers: {
+      httpProof: {
+        host: "127.0.0.1:4340",
+        protocol: "http",
+        description: "Local xoonya HTTP proof event entrypoint"
+      }
+    },
+    channels: {
+      "proof/events/canonicalize": {
+        address: "/v1/events/canonicalize",
+        messages: {
+          canonicalizeEventRequest: {
+            name: "canonicalizeEventRequest",
+            title: "Canonicalize event request",
+            summary: "Canonicalize inbound event data before proof construction."
+          }
+        }
+      },
+      "proof/events/hash": {
+        address: "/v1/events/hash",
+        messages: {
+          hashEventRequest: {
+            name: "hashEventRequest",
+            title: "Hash event request",
+            summary: "Hash canonical event data."
+          }
+        }
+      },
+      "proof/receipts/emit": {
+        address: "/v1/receipts/emit",
+        messages: {
+          emitReceiptRequest: {
+            name: "emitReceiptRequest",
+            title: "Emit receipt request",
+            summary: "Emit proof receipt data."
+          }
+        }
+      },
+      "proof/bundles/build": {
+        address: "/v1/proof-bundles/build",
+        messages: {
+          buildProofBundleRequest: {
+            name: "buildProofBundleRequest",
+            title: "Build proof bundle request",
+            summary: "Build a proof bundle from canonical proof inputs."
+          }
+        }
+      },
+      "proof/bridge/economic-handoff": {
+        address: "/v1/proof-center/bridge/economic-handoff",
+        messages: {
+          economicHandoffRequest: {
+            name: "economicHandoffRequest",
+            title: "Economic handoff bridge request",
+            summary: "Bridge bounded economic consequence data into proof review."
+          }
+        }
+      }
+    },
+    operations: {
+      canonicalizeProofEvent: {
+        action: "send",
+        channel: { $ref: "#/channels/proof/events/canonicalize" },
+        summary: "Send canonicalization input into the proof loop."
+      },
+      hashProofEvent: {
+        action: "send",
+        channel: { $ref: "#/channels/proof/events/hash" },
+        summary: "Send event data for proof hash generation."
+      },
+      emitProofReceipt: {
+        action: "send",
+        channel: { $ref: "#/channels/proof/receipts/emit" },
+        summary: "Send receipt emission input into the proof loop."
+      },
+      buildProofBundle: {
+        action: "send",
+        channel: { $ref: "#/channels/proof/bundles/build" },
+        summary: "Send proof-bundle build input into the proof loop."
+      },
+      bridgeEconomicHandoff: {
+        action: "send",
+        channel: { $ref: "#/channels/proof/bridge/economic-handoff" },
+        summary: "Send runtime economic handoff data into proof review."
+      }
+    },
+    "x-naxytra-contract": {
+      product: "xoonya",
+      stability: "stable_public_event_layer",
+      channel_count: 5,
+      linked_docs: [
+        "SERVICE_CONTRACT.md",
+        "FINAL_CONTRACT.md",
+        "START_HERE.md"
+      ]
+    }
+  };
+}
+
+function summarizeAsyncApiDocument() {
+  const document = buildAsyncApiDocument();
+  return {
+    product: "xoonya",
+    category: "proof-asyncapi-contract-summary",
+    summary_version: "xoonya-asyncapi-contract-summary-v1",
+    asyncapi_version: document.asyncapi,
+    info_version: document.info.version,
+    channel_count: Object.keys(document.channels).length,
+    operation_count: Object.keys(document.operations).length,
+    primary_event_lanes: ["canonicalization", "receipts", "proof_bundles", "bridge"],
+    linked_surfaces: {
+      asyncapi_ref: "/asyncapi.json",
+      service_contract_ref: "SERVICE_CONTRACT.md",
+      openapi_ref: "/openapi.json"
+    }
+  };
+}
+
+module.exports = {
+  buildAsyncApiDocument,
+  summarizeAsyncApiDocument
+};

package/lib/auth_interop_contract.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const pkg = require("../package.json");
+
+function buildAuthInteropContract() {
+  return {
+    product: "xoonya",
+    category: "proof-auth-interop-contract",
+    contract_version: "xoonya-auth-interop-contract-v1",
+    service_version: pkg.version,
+    primary_posture: "proof_verification_with_oauth_oidc_and_token_exchange_interop",
+    supported_interop_profiles: [
+      {
+        profile_id: "proof_verifier_client_credentials",
+        standards: ["oauth_2_0", "oidc_optional"],
+        intended_use: "machine verifier access to proof verification surfaces",
+        primary_routes: ["/v1/receipts/verify", "/v1/proof-bundles/verify"]
+      },
+      {
+        profile_id: "runtime_to_proof_handoff_token_exchange",
+        standards: ["oauth_2_0_token_exchange", "jwt_bearer_optional"],
+        intended_use: "map runtime-side bearer posture into bounded proof-side review and bridge intake",
+        primary_routes: ["/v1/proof-center/bridge/economic-handoff"]
+      },
+      {
+        profile_id: "proof_role_governance_interop",
+        standards: ["oauth_2_0", "oidc"],
+        intended_use: "operator and reviewer access to frozen proof-role and governance surfaces",
+        primary_routes: ["/v1/role-freeze", "/v1/role-freeze/package"]
+      }
+    ],
+    native_proof_mapping: {
+      proof_verify: "/v1/proof-bundles/verify",
+      receipt_verify: "/v1/receipts/verify",
+      bridge_economic_handoff: "/v1/proof-center/bridge/economic-handoff",
+      role_freeze_package: "/v1/role-freeze/package"
+    },
+    guardrails: [
+      "proof verification semantics remain canonical inside xoonya rather than inside bearer tokens",
+      "token exchange may convey bounded review posture but must not redefine proof truth",
+      "bridge intake auth must remain subordinate to proof-side review and governance checks"
+    ],
+    linked_surfaces: {
+      openapi_ref: "/openapi.json",
+      asyncapi_ref: "/asyncapi.json",
+      cloudevents_ref: "/cloudevents.json",
+      service_contract_ref: "SERVICE_CONTRACT.md"
+    }
+  };
+}
+
+function summarizeAuthInteropContract() {
+  const contract = buildAuthInteropContract();
+  return {
+    product: "xoonya",
+    category: "proof-auth-interop-contract-summary",
+    summary_version: "xoonya-auth-interop-contract-summary-v1",
+    contract_version: contract.contract_version,
+    profile_count: contract.supported_interop_profiles.length,
+    primary_posture: contract.primary_posture,
+    primary_protocol_lanes: ["proof_verify", "receipt_verify", "bridge"],
+    linked_surfaces: contract.linked_surfaces
+  };
+}
+
+module.exports = {
+  buildAuthInteropContract,
+  summarizeAuthInteropContract
+};

package/lib/cloudevents_contract.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const pkg = require("../package.json");
+
+function buildCloudEventsContract() {
+  return {
+    product: "xoonya",
+    category: "proof-cloudevents-contract",
+    contract_version: "xoonya-cloudevents-contract-v1",
+    specversion: "1.0",
+    service_version: pkg.version,
+    envelope: {
+      required_attributes: ["specversion", "id", "source", "type", "time", "subject", "datacontenttype", "data"],
+      datacontenttype_default: "application/json",
+      source_prefix: "urn:naxytra:xoonya",
+      id_shape: "evt_<opaque_id>",
+      time_format: "RFC3339"
+    },
+    event_families: [
+      {
+        type: "io.naxytra.xoonya.event.canonicalized",
+        source: "urn:naxytra:xoonya:events",
+        subject: "event.canonicalized"
+      },
+      {
+        type: "io.naxytra.xoonya.event.hashed",
+        source: "urn:naxytra:xoonya:events",
+        subject: "event.hashed"
+      },
+      {
+        type: "io.naxytra.xoonya.receipt.emitted",
+        source: "urn:naxytra:xoonya:receipts",
+        subject: "receipt.emitted"
+      },
+      {
+        type: "io.naxytra.xoonya.proof_bundle.built",
+        source: "urn:naxytra:xoonya:proof_bundles",
+        subject: "proof_bundle.built"
+      },
+      {
+        type: "io.naxytra.xoonya.bridge.economic_handoff.accepted",
+        source: "urn:naxytra:xoonya:bridge",
+        subject: "bridge.economic_handoff"
+      }
+    ],
+    stable_http_surfaces: [
+      "/v1/events/canonicalize",
+      "/v1/events/hash",
+      "/v1/receipts/emit",
+      "/v1/proof-bundles/build",
+      "/v1/proof-center/bridge/economic-handoff"
+    ],
+    linked_surfaces: {
+      openapi_ref: "/openapi.json",
+      asyncapi_ref: "/asyncapi.json",
+      service_contract_ref: "SERVICE_CONTRACT.md"
+    }
+  };
+}
+
+function summarizeCloudEventsContract() {
+  const contract = buildCloudEventsContract();
+  return {
+    product: "xoonya",
+    category: "proof-cloudevents-contract-summary",
+    summary_version: "xoonya-cloudevents-contract-summary-v1",
+    specversion: contract.specversion,
+    contract_version: contract.contract_version,
+    event_family_count: contract.event_families.length,
+    stable_surface_count: contract.stable_http_surfaces.length,
+    primary_event_lanes: ["canonicalization", "proof_bundle", "bridge"],
+    linked_surfaces: contract.linked_surfaces
+  };
+}
+
+module.exports = {
+  buildCloudEventsContract,
+  summarizeCloudEventsContract
+};

package/lib/erc8004_proof_lane_contract.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const {
+  buildPhase4Erc8004ProofPack,
+  summarizePhase4Erc8004ProofPack
+} = require("./phase_4_erc8004_proof_pack");
+
+function buildErc8004ProofLanePack() {
+  const phasePack = buildPhase4Erc8004ProofPack();
+  return {
+    product: "xoonya",
+    category: "proof-erc8004-lane-pack",
+    pack_version: "xoonya-erc8004-lane-pack-v1",
+    lane_state: "first_party_erc8004_proof_present",
+    posture: "identity_and_attestation_proof_interop_lane",
+    phase_alignment: {
+      phase_ref: phasePack.phase_ref,
+      phase_proof_pack: phasePack,
+      phase_proof_summary: summarizePhase4Erc8004ProofPack()
+    },
+    supported_surfaces: {
+      phase_proof_ref: "/v1/phases/phase-4/erc8004/proof",
+      phase_proof_summary_ref: "/v1/phases/phase-4/erc8004/proof/summary",
+      identity_interop_ref: "/v1/identity-interop",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      trust_intelligence_ref: "/v1/trust-intelligence/summary"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "erc8004.attestation_proof_view",
+        recommended_reason: "best first proof-facing trust lane for attestation, subject binding, and policy carry review",
+        sequence: [
+          "inspect_erc8004_proof_lane_summary",
+          "inspect_identity_interop_contract",
+          "inspect_bridge_summary",
+          "inspect_trust_intelligence_summary"
+        ]
+      }
+    ],
+    guardrails: [
+      "erc8004 is an interop lane rather than the canonical source of proof truth",
+      "native proof review and attestation semantics remain canonical inside xoonya",
+      "erc8004 posture should improve external verifier trust without turning xoonya into a generic credential wallet"
+    ]
+  };
+}
+
+function summarizeErc8004ProofLanePack() {
+  const pack = buildErc8004ProofLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-erc8004-lane-pack-summary",
+    summary_version: "xoonya-erc8004-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    posture: pack.posture,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildErc8004ProofLanePack,
+  summarizeErc8004ProofLanePack
+};