xoonya 2.14.0 → 2.15.0

package/README.md

@@ -43,6 +43,36 @@ The shortest public proof loop is:
 - emit a durable proof bundle
 - preserve governance and continuity context when needed
 
+The frozen proof-side fact model for `3.0.0` closeout is documented in:
+
+- [XOONYA_PROOF_TRUTH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xoonya/XOONYA_PROOF_TRUTH_MODEL.md)
+
+Machine-readable proof-truth surfaces:
+
+- `GET /v1/proof-truth`
+- `GET /v1/proof-truth/summary`
+- `GET /v1/proof-truth/:object_id`
+
+The frozen multi-surface proof default-path model for `3.0.0` closeout is documented in:
+
+- [XOONYA_DEFAULT_PATH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xoonya/XOONYA_DEFAULT_PATH_MODEL.md)
+
+Machine-readable proof default-path surfaces:
+
+- `GET /v1/default-path`
+- `GET /v1/default-path/summary`
+- `GET /v1/default-path/:surface_id`
+
+The frozen bridge, governance, trust-portability, and verification followthrough boundary for `3.0.0` closeout is documented in:
+
+- [XOONYA_FOLLOWTHROUGH_TRUTH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xoonya/XOONYA_FOLLOWTHROUGH_TRUTH_MODEL.md)
+
+Machine-readable followthrough-truth surfaces:
+
+- `GET /v1/followthrough-truth`
+- `GET /v1/followthrough-truth/summary`
+- `GET /v1/followthrough-truth/:profile_id`
+
 The current proof breadth already includes:
 
 - canonical events, receipts, and proof bundles

package/RELEASE_NOTES.md

@@ -1,11 +1,12 @@
-`xoonya` 2.14.0 is the lifecycle and continuity hardening release for stronger proof-side followthrough, trust portability, and cross-venue review continuity.
+`xoonya` 2.15.0 is the final intermediary closeout release for frozen proof truth surfaces and clearer proof-side first contact before the final major closeout.
 
-This release keeps the synchronized public-release bundle intact while tightening trust-portability, governance/dispute visibility, and the runtime-to-proof followthrough story into one coherent next step toward the final closeout line.
+This release keeps the synchronized public-release bundle intact while freezing the proof-side truth models, tightening umbrella first-contact alignment, and turning the proof-side story into one coherent final intermediary step before the final major closeout.
 
 Highlights:
 
-- keeps `/v1/proof-center/trust-portability` and `/v1/proof-center/trust-portability/summary` as the named proof-side continuity boundary for the release
-- strengthens visibility for portability across identity, delegation, delivery history, and settlement-linked followthrough
+- freezes `/v1/proof-truth` and `/v1/proof-truth/summary` as the named proof object boundary
+- freezes `/v1/default-path` and `/v1/default-path/summary` as the named proof-side multi-surface entry boundary
+- freezes `/v1/followthrough-truth` and `/v1/followthrough-truth/summary` as the named bridge, governance, portability, and verification claim boundary
 - keeps verification services, trust-portability surfaces, governance/dispute visibility, and reference-implementation posture aligned with the same synchronized public release line
 - preserves XNYA-compatible conformance, native reference implementation boundaries, external proof import boundaries, and the PQ/hybrid design gate
 - strengthens the native-standard, payload-profile, line-rate-frame, and conformance-mark story as one discoverable proof stack

package/START_HERE.md

@@ -4,7 +4,7 @@ This is the shortest reliable path for understanding and using the public `xoony
 
 The phase program is now complete, so this file is the right starting point for a closed and release-shaped proof system rather than an in-flight milestone build.
 
-The next public release path is intentionally intermediary and is now centered on the paired `2.14.0` lifecycle and continuity hardening milestone documented in [RELEASE_2_14_0_LIFECYCLE_CONTINUITY_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/docs/release/RELEASE_2_14_0_LIFECYCLE_CONTINUITY_PLAN.md) and [PUBLISH_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/PUBLISH_PLAN.md). That release is meant to tighten proof-side followthrough before the final `3.0.0` consolidation.
+The next public release path is intentionally intermediary and is now centered on the paired `2.15.0` final intermediary closeout milestone documented in [RELEASE_2_15_0_FINAL_INTERMEDIARY_CLOSEOUT_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/docs/release/RELEASE_2_15_0_FINAL_INTERMEDIARY_CLOSEOUT_PLAN.md) and [PUBLISH_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xoonya/PUBLISH_PLAN.md). That release is meant to freeze the proof-side public truth surfaces before the final `3.0.0` consolidation.
 
 ## 1. Understand The Role
 
@@ -29,6 +29,27 @@ Then run the local proof followthrough:
 xoonya first-run --verify-native --pretty
 ```
 
+If you want the frozen machine-readable proof-truth contract behind that flow, inspect:
+
+```text
+GET /v1/proof-truth
+GET /v1/proof-truth/summary
+```
+
+If you want the frozen machine-readable proof default-path contract behind that flow, inspect:
+
+```text
+GET /v1/default-path
+GET /v1/default-path/summary
+```
+
+If you want the frozen machine-readable followthrough claim boundary behind that flow, inspect:
+
+```text
+GET /v1/followthrough-truth
+GET /v1/followthrough-truth/summary
+```
+
 ## 2. Run The Fastest Real Example
 
 Run:

package/XOONYA_DEFAULT_PATH_MODEL.md

@@ -0,0 +1,63 @@
+# xoonya Default Path Model
+
+`xoonya` should feel immediate from the surface the caller already uses.
+
+For `3.0.0`, the public proof story cannot only live across scattered review routes and helper commands.
+
+It needs one frozen answer to:
+
+- how a caller brings proof-side input in
+- how they review it
+- how they verify or run proof followthrough
+- how they emit durable proof artifacts
+- how bridge and governance followthrough remain attached
+
+## Core Rule
+
+All supported proof entry surfaces must converge on one spine:
+
+`receive -> review -> run/emit -> verify -> inspect/governance`
+
+Surface-specific ergonomics are allowed.
+Surface-specific proof truth models are not.
+
+## Supported Surface Families
+
+The frozen `3.0.0` default-path model covers:
+
+- CLI and terminal
+- direct API
+- carried handoff review
+- native proof loop
+- service-to-service and embedded review
+
+## What Changes Across Surfaces
+
+What may change:
+
+- the first entrypoint
+- whether the caller starts from a handoff review, a proof loop, or a verification command
+- whether output is returned as CLI JSON, API JSON, or embedded review state
+
+What must not change:
+
+- proof truth
+- review posture
+- verification posture
+- bridge carry
+- governance followthrough
+
+## Machine-Readable Surfaces
+
+- `GET /v1/default-path`
+- `GET /v1/default-path/summary`
+- `GET /v1/default-path/:surface_id`
+
+## Launch Standard
+
+For `3.0.0`, this model is considered real only if:
+
+- each listed surface has a callable first path
+- each listed surface can review or verify before claiming completion
+- each listed surface converges into the shared proof truth model
+- each listed surface can preserve bridge and governance followthrough where needed

package/XOONYA_FOLLOWTHROUGH_TRUTH_MODEL.md

@@ -0,0 +1,63 @@
+# xoonya Followthrough Truth Model
+
+`xoonya` cannot reach a truthful `3.0.0` if its followthrough story is left as scattered bridge, governance, trust-portability, and verification endpoints.
+
+For the public launch line, it needs one frozen answer to:
+
+- what proof-side followthrough is publicly claimable
+- what trust portability is real and bounded
+- what bridge carry is real and bounded
+- what governance and dispute posture is real and bounded
+- what must remain outside the public `xoonya` claim boundary
+
+## Core Rule
+
+All public followthrough claims must stay inside one bounded proof-side truth:
+
+`verify -> carry -> review -> govern -> preserve continuity`
+
+`xoonya` may expose many helper routes.
+It may not imply unbounded scope.
+
+## Covered Followthrough Families
+
+The frozen `3.0.0` followthrough truth model covers:
+
+- verification services
+- trust portability
+- bridge followthrough
+- governance followthrough
+
+## What This Model Allows Us To Claim
+
+We can publicly claim:
+
+- proof bundles, receipts, and handoffs can be verified and replayed through real public surfaces
+- trust can remain portable across the listed identity, delegation, delivery, and settlement-linked review lanes
+- bridge carry can preserve operator and compatibility review without becoming the runtime owner
+- governance can preserve disputes, signoff, interpretation, and handoff continuity without pretending to be universal legal truth
+
+## What This Model Does Not Allow Us To Claim
+
+We do not publicly claim:
+
+- unbounded runtime execution truth
+- universal external chain truth
+- universal custody truth
+- universal identity truth
+- universal legal or regulatory judgment truth
+
+## Machine-Readable Surfaces
+
+- `GET /v1/followthrough-truth`
+- `GET /v1/followthrough-truth/summary`
+- `GET /v1/followthrough-truth/:profile_id`
+
+## Launch Standard
+
+For `3.0.0`, this model is considered real only if:
+
+- each listed profile has callable first-party surfaces
+- each listed profile stays attached to proof truth and proof review
+- each listed profile has an explicit claim boundary
+- no launch copy overstates `xoonya` beyond these frozen followthrough profiles

package/XOONYA_PROOF_TRUTH_MODEL.md

@@ -0,0 +1,58 @@
+# xoonya Proof Truth Model
+
+`xoonya` is the proof-side truth layer for the public stack.
+
+For `3.0.0`, that has to be explicit, not implied from many helper surfaces.
+
+## Core Rule
+
+The proof-side spine is:
+
+`canonical event -> receipt -> proof bundle -> reviewable handoff -> verification -> bridge/governance followthrough`
+
+`xoonya` may expose many routes, but they all need to converge on that same truth model.
+
+## What xoonya Owns
+
+`xoonya` owns:
+
+- deterministic proof construction
+- canonical proof verification
+- native `XNYA` compact evidence artifacts
+- reviewable runtime-to-proof handoff continuation
+- bridge carry and proof-adjacent operator review
+- governance and dispute followthrough
+
+It does not own:
+
+- runtime pricing
+- runtime execution truth
+- treasury or payment control planes
+- universal external chain, identity, or legal judgment truth
+
+## Canonical Objects
+
+The frozen `3.0.0` proof truth model centers on:
+
+- `canonical_event_bundle`
+- `receipt`
+- `proof_bundle`
+- `xnya_native_artifact`
+- `proof_handoff_review`
+- `bridge_and_governance_followthrough`
+
+## Machine-Readable Surfaces
+
+- `GET /v1/proof-truth`
+- `GET /v1/proof-truth/summary`
+- `GET /v1/proof-truth/:object_id`
+
+## Launch Standard
+
+For `3.0.0`, this model is real only if:
+
+- the proof core is deterministic and replayable
+- `XNYA` remains a first-class native evidence family
+- runtime handoffs can continue into review and proof without dead-end loss
+- verification services are visible and callable
+- bridge and governance followthrough remain bounded, reviewable, and explicit

package/index.js

@@ -5,6 +5,9 @@ module.exports = {
   ...require("./integrations/registry"),
   ...require("./lib/verification_service_pack"),
   ...require("./lib/trust_portability_pack"),
+  ...require("./lib/proof_truth_contract"),
+  ...require("./lib/default_path_contract"),
+  ...require("./lib/followthrough_truth_contract"),
   ...require("./lib/governance_disputes_summary"),
   ...require("./lib/release_pack"),
   ...require("./lib/release_manifest"),

package/lib/default_path_contract.js

@@ -0,0 +1,380 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+const { summarizeProofTruthModelPack } = require("./proof_truth_contract");
+const { summarizeVerificationServicesPack } = require("./verification_service_pack");
+const { summarizeTrustPortabilityPack } = require("./trust_portability_pack");
+
+function uniqueSorted(values) {
+  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
+}
+
+function buildStages(stageEntries) {
+  return (Array.isArray(stageEntries) ? stageEntries : []).map((entry, index) => ({
+    stage_index: index + 1,
+    ...entry
+  }));
+}
+
+function buildSurface(entry) {
+  const stages = buildStages(entry.stages);
+  return {
+    surface_id: entry.surface_id,
+    surface_label: entry.surface_label,
+    surface_kind: entry.surface_kind,
+    interaction_modes: uniqueSorted(entry.interaction_modes),
+    actor_classes: uniqueSorted(entry.actor_classes),
+    real_time_ready: true,
+    review_ready: stages.some((stage) => stage.stage_id === "review"),
+    verify_ready: stages.some((stage) => stage.stage_id === "verify"),
+    proof_emit_ready: stages.some((stage) => stage.stage_id === "emit" || stage.stage_id === "run"),
+    governance_followthrough_ready: stages.some((stage) => stage.stage_id === "governance" || stage.stage_id === "inspect"),
+    stage_count: stages.length,
+    primary_entrypoints: uniqueSorted(entry.primary_entrypoints),
+    primary_output_posture: entry.primary_output_posture,
+    default_loop_or_followthrough_ref: entry.default_loop_or_followthrough_ref,
+    stages,
+    supporting_surfaces: uniqueSorted(entry.supporting_surfaces),
+    claim_boundary: entry.claim_boundary
+  };
+}
+
+function buildDefaultPathPack() {
+  const proofTruthSummary = summarizeProofTruthModelPack();
+  const proofCenterSummary = proofSdk.summarizeDefaultProofCenter();
+  const proofLoopSummary = proofSdk.summarizeDefaultProofLoops();
+  const resultPackageHandoffSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const governanceSummary = proofSdk.summarizeGovernanceCenter();
+  const verificationServicesSummary = summarizeVerificationServicesPack();
+  const trustPortabilitySummary = summarizeTrustPortabilityPack();
+
+  const surfaces = [
+    buildSurface({
+      surface_id: "cli_terminal",
+      surface_label: "CLI and terminal",
+      surface_kind: "human_or_operator_shell_surface",
+      interaction_modes: ["cli", "terminal"],
+      actor_classes: ["human", "operator", "developer", "agent"],
+      primary_entrypoints: [
+        "xoonya start-here",
+        "xoonya first-run --verify-native --pretty",
+        "xoonya-review --file ./handoff.json --summary",
+        "xoonya conformance --json"
+      ],
+      primary_output_posture: "stdout_json_review_and_local_verification_summary",
+      default_loop_or_followthrough_ref: "default.proof.bundle.loop",
+      stages: [
+        {
+          stage_id: "receive",
+          surface_ref: "xoonya start-here",
+          expected_outcome: "outside builder or operator discovers the proof-side default path immediately after install"
+        },
+        {
+          stage_id: "review",
+          surface_ref: "xoonya-review --file ./handoff.json --summary",
+          expected_outcome: "carried runtime handoff becomes a concise reviewable proof-side intake"
+        },
+        {
+          stage_id: "verify",
+          surface_ref: "xoonya first-run --verify-native --pretty",
+          expected_outcome: "local native verification confirms xoonya proof binding and conformance posture"
+        },
+        {
+          stage_id: "emit",
+          surface_ref: "xoonya conformance --json",
+          expected_outcome: "operator can confirm proof bundle and native artifact posture from the same shell surface"
+        },
+        {
+          stage_id: "inspect",
+          surface_ref: "/v1/proof-center/governance/summary",
+          expected_outcome: "governance and continuity posture remain inspectable after proof review and verification"
+        }
+      ],
+      supporting_surfaces: [
+        "https://www.naxytra.com/v1/first-run-kit",
+        "/v1/proof-center/summary",
+        "/v1/proof-center/native-standard/summary",
+        "/v1/proof-center/result-package-handoff/review/summary"
+      ],
+      claim_boundary: "claim_cli_terminal_default_path_only_for_the_listed_review_verify_emit_and_inspection_surfaces_not_as_unbounded_external_chain_or_identity_truth"
+    }),
+    buildSurface({
+      surface_id: "direct_api",
+      surface_label: "Direct API",
+      surface_kind: "http_api_surface",
+      interaction_modes: ["api", "http"],
+      actor_classes: ["agent", "machine", "developer", "enterprise"],
+      primary_entrypoints: [
+        "/v1/proof-center",
+        "/v1/proof-bundles/build",
+        "/v1/proof-bundles/verify"
+      ],
+      primary_output_posture: "json_proof_bundle_and_verification_result",
+      default_loop_or_followthrough_ref: "/v1/proof-center/default-loops/run",
+      stages: [
+        {
+          stage_id: "receive",
+          surface_ref: "/v1/proof-center/summary",
+          expected_outcome: "caller discovers the canonical proof center and proof model through machine-readable HTTP surfaces"
+        },
+        {
+          stage_id: "review",
+          surface_ref: "/v1/proof-center/result-package-handoff/review/summary",
+          expected_outcome: "runtime handoff becomes reviewable before proof emission"
+        },
+        {
+          stage_id: "run",
+          surface_ref: "/v1/proof-center/default-loops/run",
+          expected_outcome: "application can emit and verify the canonical proof-native loop in one API path"
+        },
+        {
+          stage_id: "verify",
+          surface_ref: "/v1/proof-bundles/verify",
+          expected_outcome: "proof output is verified through the same public API spine"
+        },
+        {
+          stage_id: "inspect",
+          surface_ref: "/v1/proof-center/verification-services/summary",
+          expected_outcome: "verification service and followthrough posture remain externally inspectable"
+        }
+      ],
+      supporting_surfaces: [
+        "/openapi.json",
+        "/v1/proof-center/default-loops/summary",
+        "/v1/proof-center/native-standard/summary",
+        "/v1/proof-center/trust-portability/summary"
+      ],
+      claim_boundary: "claim_direct_api_default_path_only_for_the_listed_proof_core_review_run_verify_and_inspection_surfaces_not_as_unbounded_external_verifier_or_judgment_truth"
+    }),
+    buildSurface({
+      surface_id: "carried_handoff_review",
+      surface_label: "Carried handoff review",
+      surface_kind: "runtime_to_proof_continuation_surface",
+      interaction_modes: ["handoff", "review", "continuation"],
+      actor_classes: ["agent", "machine", "human", "enterprise", "operator"],
+      primary_entrypoints: [
+        "/v1/proof-center/result-package-handoff",
+        "/v1/proof-center/result-package-handoff/review/summary",
+        "/v1/proof-center/result-package-handoff/run"
+      ],
+      primary_output_posture: "review_summary_then_proof_continuation_bundle",
+      default_loop_or_followthrough_ref: "/v1/proof-center/result-package-handoff/run",
+      stages: [
+        {
+          stage_id: "receive",
+          surface_ref: "/v1/proof-center/result-package-handoff/summary",
+          expected_outcome: "caller discovers the stable runtime-to-proof continuation boundary"
+        },
+        {
+          stage_id: "review",
+          surface_ref: "/v1/proof-center/result-package-handoff/review/summary",
+          expected_outcome: "handoff bundle is reviewed for carry, boundary, and proof readiness"
+        },
+        {
+          stage_id: "run",
+          surface_ref: "/v1/proof-center/result-package-handoff/run",
+          expected_outcome: "reviewed handoff continues into canonical proof-side completion"
+        },
+        {
+          stage_id: "verify",
+          surface_ref: "/v1/proof-center/verification-services/summary",
+          expected_outcome: "verification posture for the carried handoff remains first-class and inspectable"
+        },
+        {
+          stage_id: "governance",
+          surface_ref: "/v1/proof-center/bridge/summary",
+          expected_outcome: "bridge carry and operator review posture remain attached to the continuation path"
+        }
+      ],
+      supporting_surfaces: [
+        "/v1/proof-center/result-package-handoff/review/bridge-summary",
+        "/v1/proof-center/governance/summary",
+        "/v1/proof-center/trust-portability/summary"
+      ],
+      claim_boundary: "claim_carried_handoff_review_only_for_the_listed_review_run_bridge_and_governance_surfaces_not_as_generic_runtime_execution_truth"
+    }),
+    buildSurface({
+      surface_id: "native_proof_loop",
+      surface_label: "Native proof loop",
+      surface_kind: "proof_native_surface",
+      interaction_modes: ["proof_native", "xnya", "bundle"],
+      actor_classes: ["developer", "agent", "machine", "human"],
+      primary_entrypoints: [
+        "/v1/proof-center/default-loops",
+        "/v1/proof-center/default-loops/run",
+        "/v1/proof-center/native-standard/summary"
+      ],
+      primary_output_posture: "deterministic_proof_bundle_or_receipt_loop_output",
+      default_loop_or_followthrough_ref: "default.proof.bundle.loop",
+      stages: [
+        {
+          stage_id: "receive",
+          surface_ref: "/v1/proof-center/default-loops/summary",
+          expected_outcome: "builder sees the default proof-native loops and their canonical stages"
+        },
+        {
+          stage_id: "review",
+          surface_ref: "/v1/proof-center/native-standard/summary",
+          expected_outcome: "native XNYA and proof-standard posture is inspected before emitting proof artifacts"
+        },
+        {
+          stage_id: "run",
+          surface_ref: "/v1/proof-center/default-loops/run",
+          expected_outcome: "proof bundle loop executes through the canonical proof center"
+        },
+        {
+          stage_id: "verify",
+          surface_ref: "/v1/proof-bundles/verify",
+          expected_outcome: "proof output is verified through the canonical bundle contract"
+        },
+        {
+          stage_id: "inspect",
+          surface_ref: "/v1/proof-center/native-anchor-profile/summary",
+          expected_outcome: "native anchor-binding and followthrough posture remain visible after proof emission"
+        }
+      ],
+      supporting_surfaces: [
+        "/v1/proof-center/native-atom-spec/summary",
+        "/v1/proof-center/native-payload-profile/summary",
+        "/v1/proof-center/native-conformance-mark/summary"
+      ],
+      claim_boundary: "claim_native_proof_loop_only_for_the_listed_xnya_and_bundle_surfaces_not_as_forced_identity_or_auth_replacement"
+    }),
+    buildSurface({
+      surface_id: "service_to_service",
+      surface_label: "Service-to-service and embedded review",
+      surface_kind: "backend_review_surface",
+      interaction_modes: ["service_to_service", "embedded_review", "callback"],
+      actor_classes: ["machine", "enterprise", "operator", "agent"],
+      primary_entrypoints: [
+        "/v1/proof-center/result-package-handoff/review/summary",
+        "/v1/proof-center/result-package-handoff/review/handoff-run",
+        "/v1/proof-center/governance/review-link"
+      ],
+      primary_output_posture: "embedded_review_summary_then_proof_followthrough_and_governance_linkage",
+      default_loop_or_followthrough_ref: "/v1/proof-center/result-package-handoff/review/handoff-run",
+      stages: [
+        {
+          stage_id: "receive",
+          surface_ref: "/v1/proof-center/result-package-handoff/review/handoff-intake",
+          expected_outcome: "backend caller receives and normalizes a runtime handoff into the proof review boundary"
+        },
+        {
+          stage_id: "review",
+          surface_ref: "/v1/proof-center/result-package-handoff/review/summary",
+          expected_outcome: "embedded service gets a compact proof-readiness and carry summary"
+        },
+        {
+          stage_id: "run",
+          surface_ref: "/v1/proof-center/result-package-handoff/review/handoff-run",
+          expected_outcome: "service advances the handoff into proof-side continuation from the same embedded path"
+        },
+        {
+          stage_id: "verify",
+          surface_ref: "/v1/proof-center/verification-services/summary",
+          expected_outcome: "verification posture remains callable and inspectable for the embedded review path"
+        },
+        {
+          stage_id: "governance",
+          surface_ref: "/v1/proof-center/governance/review-link",
+          expected_outcome: "follow-up review and governance remain linkable for downstream systems"
+        }
+      ],
+      supporting_surfaces: [
+        "/v1/proof-center/bridge/operator-review-pack",
+        "/v1/proof-center/governance/summary",
+        "/asyncapi.json",
+        "/cloudevents.json"
+      ],
+      claim_boundary: "claim_service_to_service_default_path_only_for_the_listed_embedded_review_run_verify_and_governance_surfaces_not_as_generic_external_case_management_truth"
+    })
+  ];
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "xoonya-default-path-model",
+    pack_version: "xoonya-default-path-model-v1",
+    posture: "multi_surface_proof_followthrough_default_path",
+    model_state: "frozen_for_3_0_0_closeout",
+    doctrine: "every_supported_proof_surface_should_converge_on_one_receive_review_verify_emit_followthrough_spine_so_the_public_proof_story_stays_true_across_cli_api_handoff_and_embedded_review_entrypoints",
+    core_claim: "xoonya can meet callers where they already are while keeping one proof, review, verification, bridge, and governance truth model",
+    default_path_order: [
+      "receive",
+      "review",
+      "run",
+      "verify",
+      "emit",
+      "inspect",
+      "governance"
+    ],
+    supported_surface_count: surfaces.length,
+    real_time_ready_surface_count: surfaces.filter((entry) => entry.real_time_ready).length,
+    review_ready_surface_count: surfaces.filter((entry) => entry.review_ready).length,
+    verify_ready_surface_count: surfaces.filter((entry) => entry.verify_ready).length,
+    proof_emit_ready_surface_count: surfaces.filter((entry) => entry.proof_emit_ready).length,
+    governance_followthrough_ready_surface_count: surfaces.filter((entry) => entry.governance_followthrough_ready).length,
+    surfaces,
+    universal_invariants: [
+      "every_default_path_must_begin_with_public_intake_or_start_here_guidance",
+      "every_default_path_must_make_review_or_verification_possible_before_claiming_completion",
+      "every_default_path_must_converge_back_into_the_same_proof_truth_model",
+      "every_default_path_must_preserve_xnya_and_proof_bundle_posture_without_redefining_runtime_truth",
+      "every_default_path_must_keep_bridge_and_governance_followthrough_available_when_needed"
+    ],
+    linked_summaries: {
+      proof_truth_summary: proofTruthSummary,
+      proof_center_summary: proofCenterSummary,
+      proof_loop_summary: proofLoopSummary,
+      result_package_handoff_summary: resultPackageHandoffSummary,
+      bridge_summary: bridgeSummary,
+      governance_summary: governanceSummary,
+      verification_services_summary: verificationServicesSummary,
+      trust_portability_summary: trustPortabilitySummary
+    },
+    linked_surfaces: {
+      start_here_ref: "START_HERE.md",
+      first_run_kit_ref: "https://www.naxytra.com/v1/first-run-kit",
+      proof_center_ref: "/v1/proof-center",
+      proof_center_summary_ref: "/v1/proof-center/summary",
+      proof_truth_ref: "/v1/proof-truth",
+      proof_loops_ref: "/v1/proof-center/default-loops",
+      result_package_handoff_ref: "/v1/proof-center/result-package-handoff",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      governance_summary_ref: "/v1/proof-center/governance/summary"
+    },
+    claim_boundary: "claim_only_the_listed_multi_surface_proof_default_paths_and_their_shared_proof_review_verification_and_governance_spine_without_implying_unbounded_runtime_or_external_judgment_truth"
+  };
+}
+
+function summarizeDefaultPathPack() {
+  const pack = buildDefaultPathPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    summary_version: "xoonya-default-path-model-summary-v1",
+    pack_version: pack.pack_version,
+    model_state: pack.model_state,
+    supported_surface_count: pack.supported_surface_count,
+    review_ready_surface_count: pack.review_ready_surface_count,
+    verify_ready_surface_count: pack.verify_ready_surface_count,
+    proof_emit_ready_surface_count: pack.proof_emit_ready_surface_count,
+    governance_followthrough_ready_surface_count: pack.governance_followthrough_ready_surface_count,
+    default_path_stage_count: pack.default_path_order.length,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function getDefaultPathSurfaceDetail(surfaceId) {
+  const normalized = String(surfaceId || "").trim().toLowerCase();
+  return (buildDefaultPathPack().surfaces || []).find((entry) => entry.surface_id === normalized) || null;
+}
+
+module.exports = {
+  buildDefaultPathPack,
+  summarizeDefaultPathPack,
+  getDefaultPathSurfaceDetail
+};

package/lib/followthrough_truth_contract.js

@@ -0,0 +1,214 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+const { summarizeProofTruthModelPack } = require("./proof_truth_contract");
+const { summarizeDefaultPathPack } = require("./default_path_contract");
+const { summarizeVerificationServicesPack } = require("./verification_service_pack");
+const { summarizeTrustPortabilityPack } = require("./trust_portability_pack");
+
+function uniqueSorted(values) {
+  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
+}
+
+function buildProfile(entry) {
+  return {
+    profile_id: entry.profile_id,
+    profile_label: entry.profile_label,
+    followthrough_axis: entry.followthrough_axis,
+    claim_status: entry.claim_status,
+    public_claim_allowed: entry.public_claim_allowed !== false,
+    real_time_ready: true,
+    primary_surfaces: uniqueSorted(entry.primary_surfaces),
+    supporting_surfaces: uniqueSorted(entry.supporting_surfaces),
+    actor_classes: uniqueSorted(entry.actor_classes),
+    continuity_outputs: uniqueSorted(entry.continuity_outputs),
+    expected_launch_outcome: entry.expected_launch_outcome,
+    claim_boundary: entry.claim_boundary
+  };
+}
+
+function buildFollowthroughTruthPack() {
+  const proofTruthSummary = summarizeProofTruthModelPack();
+  const defaultPathSummary = summarizeDefaultPathPack();
+  const verificationServicesSummary = summarizeVerificationServicesPack();
+  const trustPortabilitySummary = summarizeTrustPortabilityPack();
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const governanceSummary = proofSdk.summarizeGovernanceCenter();
+
+  const profiles = [
+    buildProfile({
+      profile_id: "verification_services",
+      profile_label: "Verification services",
+      followthrough_axis: "verification_and_replay",
+      claim_status: "live",
+      primary_surfaces: [
+        "/v1/proof-center/verification-services",
+        "/v1/proof-center/verification-services/summary",
+        "/v1/proof-bundles/verify",
+        "/v1/receipts/verify"
+      ],
+      supporting_surfaces: [
+        "/v1/proof-truth/summary",
+        "/v1/default-path/summary",
+        "/v1/proof-center/result-package-handoff/summary"
+      ],
+      actor_classes: ["agent", "developer", "enterprise", "human", "machine", "operator"],
+      continuity_outputs: ["bundle_verify", "delivery_verify", "identity_link_verify", "settlement_verify"],
+      expected_launch_outcome: "proof outputs can be verified, replayed, and inspected from the same public proof spine",
+      claim_boundary: "verification_services_claim_only_the_listed_bundle_delivery_identity_and_settlement_binding_surfaces_not_external_chain_identity_or_legal_judgment_truth"
+    }),
+    buildProfile({
+      profile_id: "trust_portability",
+      profile_label: "Trust portability",
+      followthrough_axis: "cross_venue_portability",
+      claim_status: "bounded_live",
+      primary_surfaces: [
+        "/v1/proof-center/trust-portability",
+        "/v1/proof-center/trust-portability/summary",
+        "/v1/identity-interop",
+        "/v1/result-package-trust"
+      ],
+      supporting_surfaces: [
+        "/v1/auth-profiles/summary",
+        "/v1/proof-center/verification-services/summary",
+        "/v1/phases/phase-4/trust-continuity/summary"
+      ],
+      actor_classes: ["agent", "developer", "enterprise", "human", "machine", "operator"],
+      continuity_outputs: [
+        "agent_identity_portability",
+        "delegation_capability_portability",
+        "delivery_history_portability",
+        "settlement_linked_trust_portability"
+      ],
+      expected_launch_outcome: "identity, delegation, delivery, and settlement-linked trust remain portable without redefining runtime or custody truth",
+      claim_boundary: "trust_portability_claim_only_the_listed_identity_delegation_delivery_and_settlement_linked_review_surfaces_not_global_identity_session_or_custody_truth"
+    }),
+    buildProfile({
+      profile_id: "bridge_followthrough",
+      profile_label: "Bridge followthrough",
+      followthrough_axis: "bridge_and_compatibility_carry",
+      claim_status: "bounded_live",
+      primary_surfaces: [
+        "/v1/proof-center/bridge",
+        "/v1/proof-center/bridge/summary",
+        "/v1/proof-center/bridge/economic-handoff",
+        "/v1/proof-center/bridge/operator-review-pack",
+        "/v1/proof-center/bridge/compatibility-pack"
+      ],
+      supporting_surfaces: [
+        "/v1/proof-center/result-package-handoff/review/bridge-summary",
+        "/v1/proof-center/result-package-handoff/review/bridge-run",
+        "/v1/proof-center/governance/review-link"
+      ],
+      actor_classes: ["agent", "enterprise", "machine", "operator"],
+      continuity_outputs: [
+        "receipt_ledger_handoff",
+        "economic_consequence_handoff",
+        "compatibility_packaging",
+        "operator_review_packaging"
+      ],
+      expected_launch_outcome: "bridge-facing review and carry stay attached to the proof center without widening xoonya into runtime execution ownership",
+      claim_boundary: "bridge_followthrough_claim_only_the_listed_receipt_ledger_economic_carry_operator_and_compatibility_surfaces_not_generic_runtime_or_external_validator_truth"
+    }),
+    buildProfile({
+      profile_id: "governance_followthrough",
+      profile_label: "Governance followthrough",
+      followthrough_axis: "governance_dispute_and_signoff",
+      claim_status: "bounded_live",
+      primary_surfaces: [
+        "/v1/proof-center/governance",
+        "/v1/proof-center/governance/summary",
+        "/v1/proof-center/governance/disputes/summary",
+        "/v1/proof-center/governance/review-link",
+        "/v1/proof-center/governance/handoff-bundle"
+      ],
+      supporting_surfaces: [
+        "/v1/proof-center/result-package-handoff/review/summary",
+        "/v1/proof-center/bridge/summary",
+        "/v1/proof-center/verification-services/summary"
+      ],
+      actor_classes: ["enterprise", "human", "operator"],
+      continuity_outputs: [
+        "interpretation_validation",
+        "governance_coordination",
+        "dispute_review",
+        "signoff_packaging",
+        "operator_handoff_bundle"
+      ],
+      expected_launch_outcome: "operators can interpret, escalate, sign off, and preserve review linkage without breaking the canonical proof story",
+      claim_boundary: "governance_followthrough_claim_only_the_listed_interpretation_coordination_dispute_signoff_and_review_link_surfaces_not_external_legal_or_regulatory_judgment_truth"
+    })
+  ];
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "xoonya-followthrough-truth-model",
+    pack_version: "xoonya-followthrough-truth-model-v1",
+    posture: "bridge_governance_and_trust_followthrough_claim_boundary",
+    model_state: "frozen_for_3_0_0_closeout",
+    doctrine: "xoonya_should_make_verification_trust_portability_bridge_carry_and_governance_followthrough_publicly_claimable_only_where_the_proof_center_exposes_a_real_bounded_callable_surface",
+    core_claim: "xoonya keeps proof-side followthrough real and multi-surface without overclaiming runtime, external chain, custody, identity, or legal judgment truth",
+    profile_count: profiles.length,
+    live_profile_count: profiles.filter((entry) => entry.claim_status === "live").length,
+    bounded_live_profile_count: profiles.filter((entry) => entry.claim_status === "bounded_live").length,
+    public_claim_allowed_profile_count: profiles.filter((entry) => entry.public_claim_allowed).length,
+    profiles,
+    universal_invariants: [
+      "followthrough_truth_must_converge_back_into_the_same_proof_truth_model",
+      "bridge_and_governance_surfaces_must_stay_reviewable_before_claiming_completion",
+      "trust_portability_must_remain_bounded_to_the_listed_surfaces_and_profiles",
+      "verification_services_must_not_overclaim_external_chain_identity_or_legal_truth",
+      "operator_exports_must_preserve_review_linkage_without_mutating_proof_semantics"
+    ],
+    linked_summaries: {
+      proof_truth_summary: proofTruthSummary,
+      default_path_summary: defaultPathSummary,
+      verification_services_summary: verificationServicesSummary,
+      trust_portability_summary: trustPortabilitySummary,
+      bridge_summary: bridgeSummary,
+      governance_summary: governanceSummary
+    },
+    linked_surfaces: {
+      proof_truth_ref: "/v1/proof-truth",
+      default_path_ref: "/v1/default-path",
+      verification_services_ref: "/v1/proof-center/verification-services",
+      trust_portability_ref: "/v1/proof-center/trust-portability",
+      bridge_ref: "/v1/proof-center/bridge",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      governance_ref: "/v1/proof-center/governance",
+      governance_summary_ref: "/v1/proof-center/governance/summary",
+      governance_review_link_ref: "/v1/proof-center/governance/review-link"
+    },
+    claim_boundary: "claim_only_the_listed_followthrough_profiles_and_surfaces_as_public_xoonya_truth_without_implying_unbounded_runtime_external_chain_identity_custody_or_legal_judgment_scope"
+  };
+}
+
+function summarizeFollowthroughTruthPack() {
+  const pack = buildFollowthroughTruthPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    summary_version: "xoonya-followthrough-truth-model-summary-v1",
+    pack_version: pack.pack_version,
+    model_state: pack.model_state,
+    profile_count: pack.profile_count,
+    live_profile_count: pack.live_profile_count,
+    bounded_live_profile_count: pack.bounded_live_profile_count,
+    public_claim_allowed_profile_count: pack.public_claim_allowed_profile_count,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function getFollowthroughTruthProfileDetail(profileId) {
+  const normalized = String(profileId || "").trim().toLowerCase();
+  return (buildFollowthroughTruthPack().profiles || []).find((entry) => entry.profile_id === normalized) || null;
+}
+
+module.exports = {
+  buildFollowthroughTruthPack,
+  summarizeFollowthroughTruthPack,
+  getFollowthroughTruthProfileDetail
+};

package/lib/proof_truth_contract.js

@@ -0,0 +1,224 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+const { summarizeVerificationServicesPack } = require("./verification_service_pack");
+const { summarizeTrustPortabilityPack } = require("./trust_portability_pack");
+
+function buildProofTruthModelPack() {
+  const proofCenter = proofSdk.summarizeDefaultProofCenter();
+  const nativeStandard = proofSdk.summarizexoonyaNativeProofStandard();
+  const nativeAtom = proofSdk.summarizexoonyaNativeAtomSpec();
+  const nativePayloadProfile = proofSdk.summarizexoonyaNativePayloadProfilePack();
+  const nativeAnchorProfile = proofSdk.summarizexoonyaNativeAnchorProfile();
+  const verificationServices = summarizeVerificationServicesPack();
+  const trustPortability = summarizeTrustPortabilityPack();
+  const transactionHandoff = proofSdk.summarizeTransactionProofHandoffCenter();
+  const interactionHandoff = proofSdk.summarizeInteractionSpineProofHandoffCenter();
+  const resultPackageHandoff = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+  const bridge = proofSdk.summarizeBridgeCenter();
+  const governance = proofSdk.summarizeGovernanceCenter();
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "xoonya-proof-truth-model",
+    pack_version: "xoonya-proof-truth-model-v1",
+    posture: "deterministic_proof_truth_plus_reviewable_followthrough",
+    model_state: "frozen_for_3_0_0_closeout",
+    doctrine: "xoonya_owns_proof_truth_verification_reviewable_handoff_followthrough_and_governance_without_reabsorbing_runtime_commerce_semantics",
+    core_claim: "xoonya is the canonical proof-side fact model linking canonical events, receipts, proof bundles, native XNYA artifacts, verification services, handoff continuation, bridge carry, and governance followthrough",
+    canonical_objects: [
+      {
+        object_id: "canonical_event_bundle",
+        role: "deterministic_hot_input_for_proof_construction",
+        required_fields: [
+          "event",
+          "event_hash_sha256"
+        ],
+        primary_surfaces: [
+          "/v1/events/canonicalize",
+          "/v1/events/hash"
+        ]
+      },
+      {
+        object_id: "receipt",
+        role: "canonical_intermediate_statement_of_what_is_being_proved",
+        required_fields: [
+          "receipt_id",
+          "event_hash_sha256",
+          "verification_method"
+        ],
+        primary_surfaces: [
+          "/v1/receipts/emit",
+          "/v1/receipts/verify"
+        ]
+      },
+      {
+        object_id: "proof_bundle",
+        role: "portable_replayable_verifiable_proof_output",
+        required_fields: [
+          "version",
+          "ceb",
+          "receipt",
+          "proof"
+        ],
+        primary_surfaces: [
+          "/v1/proof-bundles/build",
+          "/v1/proof-bundles/verify"
+        ]
+      },
+      {
+        object_id: "xnya_native_artifact",
+        role: "native_compact_machine_evidence_artifact",
+        required_fields: [
+          "method",
+          "native_atom_magic",
+          "payload_hash_or_binding"
+        ],
+        primary_surfaces: [
+          "/v1/proof-center/native-standard",
+          "/v1/proof-center/native-atom-spec",
+          "/v1/proof-center/native-payload-profile",
+          "/v1/proof-center/native-anchor-profile"
+        ]
+      },
+      {
+        object_id: "proof_handoff_review",
+        role: "reviewable_runtime_to_proof_continuation_boundary",
+        required_fields: [
+          "source_ref",
+          "proof_ref",
+          "review_summary"
+        ],
+        primary_surfaces: [
+          "/v1/proof-center/transaction-handoff/summary",
+          "/v1/proof-center/interaction-spine-handoff/summary",
+          "/v1/proof-center/result-package-handoff/review/summary"
+        ]
+      },
+      {
+        object_id: "bridge_and_governance_followthrough",
+        role: "operator_review_bridge_and_dispute_followthrough_bundle",
+        required_fields: [
+          "bridge_ref_or_bundle",
+          "governance_review_ref_or_case"
+        ],
+        primary_surfaces: [
+          "/v1/proof-center/bridge/summary",
+          "/v1/proof-center/governance/summary",
+          "/v1/proof-center/governance/disputes/summary"
+        ]
+      }
+    ],
+    layer_model: [
+      {
+        layer_id: "proof_core",
+        order_index: 1,
+        objects: ["canonical_event_bundle", "receipt", "proof_bundle"],
+        invariants: [
+          "proof_core_stays_deterministic_portable_and_replayable",
+          "proof_bundle_verification_is_canonical_xoonya_truth"
+        ]
+      },
+      {
+        layer_id: "native_xnya",
+        order_index: 2,
+        objects: ["xnya_native_artifact"],
+        invariants: [
+          "xnya_is_the_native_compact_machine_evidence_family",
+          "native_artifacts_do_not_replace_runtime_or_identity_control_planes"
+        ]
+      },
+      {
+        layer_id: "verification_services",
+        order_index: 3,
+        objects: ["proof_bundle", "proof_handoff_review"],
+        invariants: [
+          "verification_surfaces_stay_first_class_services",
+          "external_signature_or_chain_truth_requires_bounded_claim_language"
+        ]
+      },
+      {
+        layer_id: "handoff_and_bridge_continuity",
+        order_index: 4,
+        objects: ["proof_handoff_review", "bridge_and_governance_followthrough"],
+        invariants: [
+          "runtime_outputs_can_continue_into_proof_without_dead_end_loss",
+          "bridge_carry_preserves_reviewable_context_without_becoming_runtime_truth"
+        ]
+      },
+      {
+        layer_id: "governance_followthrough",
+        order_index: 5,
+        objects: ["bridge_and_governance_followthrough"],
+        invariants: [
+          "governance_preserves_reviewable_dispute_and_resolution_posture",
+          "xoonya_does_not_claim_universal_external_judgment_truth"
+        ]
+      }
+    ],
+    proof_truth_invariants: [
+      "canonical_event_bundle_precedes_receipt_and_bundle_verification",
+      "receipt_is_a_canonical_proof_intermediate_not_runtime_commerce_truth",
+      "proof_bundle_is_the_portable_verifiable_output",
+      "xnya_is_the_native_compact_evidence_family",
+      "handoff_review_is_first_class_not_optional_afterthought",
+      "bridge_and_governance_surfaces_extend_proof_followthrough_without_redefining_runtime_truth"
+    ],
+    linked_summaries: {
+      proof_center_summary: proofCenter,
+      native_standard_summary: nativeStandard,
+      native_atom_summary: nativeAtom,
+      native_payload_profile_summary: nativePayloadProfile,
+      native_anchor_profile_summary: nativeAnchorProfile,
+      verification_services_summary: verificationServices,
+      trust_portability_summary: trustPortability,
+      transaction_handoff_summary: transactionHandoff,
+      interaction_handoff_summary: interactionHandoff,
+      result_package_handoff_summary: resultPackageHandoff,
+      bridge_summary: bridge,
+      governance_summary: governance
+    },
+    linked_surfaces: {
+      proof_center_ref: "/v1/proof-center",
+      proof_center_summary_ref: "/v1/proof-center/summary",
+      native_standard_summary_ref: "/v1/proof-center/native-standard/summary",
+      verification_services_summary_ref: "/v1/proof-center/verification-services/summary",
+      trust_portability_summary_ref: "/v1/proof-center/trust-portability/summary",
+      transaction_handoff_summary_ref: "/v1/proof-center/transaction-handoff/summary",
+      interaction_handoff_summary_ref: "/v1/proof-center/interaction-spine-handoff/summary",
+      result_package_handoff_review_summary_ref: "/v1/proof-center/result-package-handoff/review/summary",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      governance_summary_ref: "/v1/proof-center/governance/summary"
+    },
+    claim_boundary: "claim_the_proof_side_fact_model_verification_and_reviewable_followthrough_only_without_reclaiming_runtime_commerce_truth_or_unbounded_external_chain_identity_or_judgment_truth"
+  };
+}
+
+function summarizeProofTruthModelPack() {
+  const pack = buildProofTruthModelPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    summary_version: "xoonya-proof-truth-model-summary-v1",
+    pack_version: pack.pack_version,
+    model_state: pack.model_state,
+    canonical_object_count: pack.canonical_objects.length,
+    layer_count: pack.layer_model.length,
+    invariant_count: pack.proof_truth_invariants.length,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function getProofTruthObjectDetail(objectId) {
+  const normalized = String(objectId || "").trim().toLowerCase();
+  return (buildProofTruthModelPack().canonical_objects || []).find((entry) => entry.object_id === normalized) || null;
+}
+
+module.exports = {
+  buildProofTruthModelPack,
+  summarizeProofTruthModelPack,
+  getProofTruthObjectDetail
+};

package/lib/release_history.js

@@ -10,6 +10,19 @@ function buildReleaseHistory() {
     current_version: packageJson.version,
     release_track: "public_release",
     history: [
+      {
+        version: "2.15.0",
+        channel: "public_release",
+        maturity_posture: "final_intermediary_closeout",
+        headline: "final intermediary closeout release with frozen proof truth, default-path, and followthrough surfaces plus an explicit 3.0.0 claim boundary",
+        milestone_refs: [
+          "proof_truth_model",
+          "default_path_model",
+          "followthrough_truth_model",
+          "umbrella_first_contact_alignment",
+          "synchronized_2_15_release_prep"
+        ]
+      },
       {
         version: "2.14.0",
         channel: "public_release",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xoonya",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Deterministic proof and review engine for receipts, handoffs, governance, and verification.",
   "main": "index.js",
   "bin": {
@@ -31,6 +31,9 @@
     "RELEASE_NOTES.md",
     ".env.example",
     "README.md",
+    "XOONYA_PROOF_TRUTH_MODEL.md",
+    "XOONYA_DEFAULT_PATH_MODEL.md",
+    "XOONYA_FOLLOWTHROUGH_TRUTH_MODEL.md",
     "XOONYA_NATIVE_PROOF_FORMAT.md",
     "XOONYA_NATIVE_ATOM_SPEC.md",
     "XOONYA_NATIVE_STANDARD_GOVERNANCE.md",

package/scripts/verify_service.js

@@ -127,6 +127,65 @@ async function main() {
     assert.strictEqual(trustPortabilityDetailResponse.status, 200, 'trust portability detail route failed');
     assert.strictEqual(trustPortabilityDetailResponse.json.profile.profile_id, 'agent_identity_portability', 'trust portability detail profile missing');
 
+    const proofTruthResponse = await getJson(baseUrl, '/v1/proof-truth');
+    assert.strictEqual(proofTruthResponse.status, 200, 'proof truth route failed');
+    assert.strictEqual(proofTruthResponse.json.category, 'xoonya-proof-truth-model', 'proof truth category missing');
+    assert.strictEqual(proofTruthResponse.json.pack_version, 'xoonya-proof-truth-model-v1', 'proof truth version missing');
+    assert.strictEqual(proofTruthResponse.json.canonical_objects.length >= 6, true, 'proof truth object count missing');
+
+    const proofTruthSummaryResponse = await getJson(baseUrl, '/v1/proof-truth/summary');
+    assert.strictEqual(proofTruthSummaryResponse.status, 200, 'proof truth summary route failed');
+    assert.strictEqual(proofTruthSummaryResponse.json.category, 'xoonya-proof-truth-model', 'proof truth summary category missing');
+    assert.strictEqual(proofTruthSummaryResponse.json.pack_version, 'xoonya-proof-truth-model-v1', 'proof truth summary version missing');
+
+    const proofBundleTruthDetailResponse = await getJson(baseUrl, '/v1/proof-truth/proof_bundle');
+    assert.strictEqual(proofBundleTruthDetailResponse.status, 200, 'proof truth proof_bundle detail route failed');
+    assert.strictEqual(proofBundleTruthDetailResponse.json.object.object_id, 'proof_bundle', 'proof truth proof_bundle detail missing');
+
+    const xnyaTruthDetailResponse = await getJson(baseUrl, '/v1/proof-truth/xnya_native_artifact');
+    assert.strictEqual(xnyaTruthDetailResponse.status, 200, 'proof truth xnya detail route failed');
+    assert.strictEqual(xnyaTruthDetailResponse.json.object.object_id, 'xnya_native_artifact', 'proof truth xnya detail missing');
+
+    const defaultPathResponse = await getJson(baseUrl, '/v1/default-path');
+    assert.strictEqual(defaultPathResponse.status, 200, 'default path route failed');
+    assert.strictEqual(defaultPathResponse.json.category, 'xoonya-default-path-model', 'default path category missing');
+    assert.strictEqual(defaultPathResponse.json.pack_version, 'xoonya-default-path-model-v1', 'default path version missing');
+    assert.strictEqual(defaultPathResponse.json.supported_surface_count >= 5, true, 'default path surface count missing');
+
+    const defaultPathSummaryResponse = await getJson(baseUrl, '/v1/default-path/summary');
+    assert.strictEqual(defaultPathSummaryResponse.status, 200, 'default path summary route failed');
+    assert.strictEqual(defaultPathSummaryResponse.json.category, 'xoonya-default-path-model', 'default path summary category missing');
+    assert.strictEqual(defaultPathSummaryResponse.json.pack_version, 'xoonya-default-path-model-v1', 'default path summary version missing');
+    assert.strictEqual(defaultPathSummaryResponse.json.default_path_stage_count, 7, 'default path stage count missing');
+
+    const cliDefaultPathDetailResponse = await getJson(baseUrl, '/v1/default-path/cli_terminal');
+    assert.strictEqual(cliDefaultPathDetailResponse.status, 200, 'cli default path detail route failed');
+    assert.strictEqual(cliDefaultPathDetailResponse.json.surface.surface_id, 'cli_terminal', 'cli default path detail missing');
+
+    const handoffDefaultPathDetailResponse = await getJson(baseUrl, '/v1/default-path/carried_handoff_review');
+    assert.strictEqual(handoffDefaultPathDetailResponse.status, 200, 'carried handoff default path detail route failed');
+    assert.strictEqual(handoffDefaultPathDetailResponse.json.surface.surface_id, 'carried_handoff_review', 'carried handoff default path detail missing');
+
+    const followthroughTruthResponse = await getJson(baseUrl, '/v1/followthrough-truth');
+    assert.strictEqual(followthroughTruthResponse.status, 200, 'followthrough truth route failed');
+    assert.strictEqual(followthroughTruthResponse.json.category, 'xoonya-followthrough-truth-model', 'followthrough truth category missing');
+    assert.strictEqual(followthroughTruthResponse.json.pack_version, 'xoonya-followthrough-truth-model-v1', 'followthrough truth version missing');
+    assert.strictEqual(followthroughTruthResponse.json.profile_count >= 4, true, 'followthrough truth profile count missing');
+
+    const followthroughTruthSummaryResponse = await getJson(baseUrl, '/v1/followthrough-truth/summary');
+    assert.strictEqual(followthroughTruthSummaryResponse.status, 200, 'followthrough truth summary route failed');
+    assert.strictEqual(followthroughTruthSummaryResponse.json.category, 'xoonya-followthrough-truth-model', 'followthrough truth summary category missing');
+    assert.strictEqual(followthroughTruthSummaryResponse.json.pack_version, 'xoonya-followthrough-truth-model-v1', 'followthrough truth summary version missing');
+    assert.strictEqual(followthroughTruthSummaryResponse.json.bounded_live_profile_count >= 3, true, 'followthrough truth bounded live count missing');
+
+    const bridgeFollowthroughDetailResponse = await getJson(baseUrl, '/v1/followthrough-truth/bridge_followthrough');
+    assert.strictEqual(bridgeFollowthroughDetailResponse.status, 200, 'bridge followthrough detail route failed');
+    assert.strictEqual(bridgeFollowthroughDetailResponse.json.profile.profile_id, 'bridge_followthrough', 'bridge followthrough detail missing');
+
+    const governanceFollowthroughDetailResponse = await getJson(baseUrl, '/v1/followthrough-truth/governance_followthrough');
+    assert.strictEqual(governanceFollowthroughDetailResponse.status, 200, 'governance followthrough detail route failed');
+    assert.strictEqual(governanceFollowthroughDetailResponse.json.profile.profile_id, 'governance_followthrough', 'governance followthrough detail missing');
+
     const providerLaneResponse = await getJson(baseUrl, '/v1/providers');
     assert.strictEqual(providerLaneResponse.status, 200, 'provider lane route failed');
     assert.strictEqual(providerLaneResponse.json.product, 'xoonya', 'provider lane product missing');

package/server.js

@@ -85,6 +85,21 @@ const {
   getTrustPortabilityProfile,
   summarizeTrustPortabilityPack
 } = require('./lib/trust_portability_pack');
+const {
+  buildProofTruthModelPack,
+  summarizeProofTruthModelPack,
+  getProofTruthObjectDetail
+} = require('./lib/proof_truth_contract');
+const {
+  buildDefaultPathPack,
+  summarizeDefaultPathPack,
+  getDefaultPathSurfaceDetail
+} = require('./lib/default_path_contract');
+const {
+  buildFollowthroughTruthPack,
+  summarizeFollowthroughTruthPack,
+  getFollowthroughTruthProfileDetail
+} = require('./lib/followthrough_truth_contract');
 const {
   buildOpenApiDocument,
   summarizeOpenApiDocument,
@@ -796,6 +811,90 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/v1/proof-truth') {
+    sendJson(res, 200, buildProofTruthModelPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/proof-truth/summary') {
+    sendJson(res, 200, summarizeProofTruthModelPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/proof-truth/')) {
+    const suffix = decodeURIComponent(url.pathname.slice('/v1/proof-truth/'.length));
+    if (suffix && suffix !== 'summary') {
+      const objectDetail = getProofTruthObjectDetail(suffix);
+      if (!objectDetail) {
+        sendJson(res, 404, { ok: false, error: 'proof_truth_object_not_found' });
+        return;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        product: 'xoonya',
+        category: 'xoonya-proof-truth-detail',
+        object: objectDetail
+      });
+      return;
+    }
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/default-path') {
+    sendJson(res, 200, buildDefaultPathPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/default-path/summary') {
+    sendJson(res, 200, summarizeDefaultPathPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/default-path/')) {
+    const suffix = decodeURIComponent(url.pathname.slice('/v1/default-path/'.length));
+    if (suffix && suffix !== 'summary') {
+      const surface = getDefaultPathSurfaceDetail(suffix);
+      if (!surface) {
+        sendJson(res, 404, { ok: false, error: 'default_path_surface_not_found' });
+        return;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        product: 'xoonya',
+        category: 'xoonya-default-path-surface-detail',
+        surface
+      });
+      return;
+    }
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/followthrough-truth') {
+    sendJson(res, 200, buildFollowthroughTruthPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/followthrough-truth/summary') {
+    sendJson(res, 200, summarizeFollowthroughTruthPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname.startsWith('/v1/followthrough-truth/')) {
+    const suffix = decodeURIComponent(url.pathname.slice('/v1/followthrough-truth/'.length));
+    if (suffix && suffix !== 'summary') {
+      const profile = getFollowthroughTruthProfileDetail(suffix);
+      if (!profile) {
+        sendJson(res, 404, { ok: false, error: 'followthrough_truth_profile_not_found' });
+        return;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        product: 'xoonya',
+        category: 'xoonya-followthrough-truth-profile-detail',
+        profile
+      });
+      return;
+    }
+  }
+
   if (req.method === 'GET' && url.pathname === '/v1/providers') {
     sendJson(res, 200, buildProviderLanePack());
     return;