xytara 2.13.0 → 2.15.0

package/README.md

@@ -58,6 +58,45 @@ The shortest public runtime loop is:
 - inspect results and economic state
 - hand off into `xoonya` when proof or review is required
 
+The frozen runtime-side fact model for that loop is documented in:
+
+- [XYTARA_EXECUTION_TRUTH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xytara/XYTARA_EXECUTION_TRUTH_MODEL.md)
+
+Machine-readable execution-truth surfaces:
+
+- `GET /v1/execution-truth`
+- `GET /v1/execution-truth/summary`
+
+The frozen multi-surface default-path model for `3.0.0` closeout is documented in:
+
+- [XYTARA_DEFAULT_PATH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xytara/XYTARA_DEFAULT_PATH_MODEL.md)
+
+Machine-readable default-path surfaces:
+
+- `GET /v1/default-path`
+- `GET /v1/default-path/summary`
+- `GET /v1/default-path/:surface_id`
+
+The frozen payment-and-rail claim model for `3.0.0` closeout is documented in:
+
+- [XYTARA_PAYMENT_RAIL_TRUTH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xytara/XYTARA_PAYMENT_RAIL_TRUTH_MODEL.md)
+
+Machine-readable payment-and-rail truth surfaces:
+
+- `GET /v1/payment-rail-truth`
+- `GET /v1/payment-rail-truth/summary`
+- `GET /v1/payment-rail-truth/:profile_id`
+
+The frozen adapter-and-protocol claim model for `3.0.0` closeout is documented in:
+
+- [XYTARA_ADAPTER_PROTOCOL_TRUTH_MODEL.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/xytara/XYTARA_ADAPTER_PROTOCOL_TRUTH_MODEL.md)
+
+Machine-readable adapter-and-protocol truth surfaces:
+
+- `GET /v1/adapter-protocol-truth`
+- `GET /v1/adapter-protocol-truth/summary`
+- `GET /v1/adapter-protocol-truth/:profile_id`
+
 The current runtime breadth already includes:
 
 - discovery and workflow lookup

package/RELEASE_NOTES.md

@@ -1,12 +1,15 @@
-`xytara` 2.13.0 is the broader convergence milestone for aligned npm, GitHub, website, code, documentation, and public-copy surfaces.
+`xytara` 2.15.0 is the final intermediary closeout release for frozen runtime truth surfaces and clearer first-contact truth before the final major closeout.
 
-This release keeps the synchronized public truth bundle intact while bundling the stronger public-first-run, provider-runtime, delivery, runtime-durability, revenue-launch, and operator-observability carry into one coherent public step.
+This release keeps the synchronized public truth bundle intact while freezing the runtime-side truth models, tightening umbrella first-contact alignment, and turning the public runtime story into one coherent final intermediary step before the final major closeout.
 
 Highlights:
 
-- strengthens the quote-first first-run path and the public `/try` entry point for outside builders
-- keeps provider-runtime journeys, delivery summary, runtime durability, and revenue-launch paths publicly inspectable
+- freezes `/v1/execution-truth` and `/v1/execution-truth/summary` as the named runtime fact boundary
+- freezes `/v1/default-path` and `/v1/default-path/summary` as the named multi-surface runtime entry boundary
+- freezes `/v1/payment-rail-truth` and `/v1/payment-rail-truth/summary` as the named payment and settlement-claim boundary
+- freezes `/v1/adapter-protocol-truth` and `/v1/adapter-protocol-truth/summary` as the named first-party front and bounded bridge boundary
+- keeps provider-runtime journeys, delivery summary, runtime durability, and revenue-launch paths publicly inspectable inside the stronger runtime truth story
 - preserves adapter-depth boundaries, pricing guardrails, treasury public-claim safety, and read-only operator observability boundaries
-- keeps the live public catalog, full-catalog claim, and public proof surfaces aligned with the release line so operators and outside builders see the same truth
+- keeps the live public catalog, full-catalog claim, first-run path, release kit, and public proof surfaces aligned with the release line so operators and outside builders see the same truth
 - keeps the canonical `https://naxytra.com/xytara` public product URL and synchronized naxytra release posture intact
 - verifies the release candidate, full package verifier, umbrella pre-deploy gates, and clean-consumer release smoke

package/START_HERE.md

@@ -4,6 +4,8 @@ This is the shortest reliable path for understanding and using the public `xytar
 
 The phase program is now complete, so this file is the right starting point for a closed and release-shaped runtime rather than an in-flight milestone build.
 
+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/xytara/PUBLISH_PLAN.md). That release is meant to freeze the runtime-side public truth surfaces before the final `3.0.0` consolidation.
+
 ## 1. Understand The Role
 
 `xytara` is the transaction-side half of the public stack.
@@ -43,6 +45,27 @@ The underlying command is:
 xytara-run --url https://xytara.onrender.com --account ACCOUNT_REF --task adapter.mcp.invoke --command mcp.invoke:summarize --body-json "{\"tool_name\":\"summarize\",\"arguments\":{\"text\":\"Summarize the naxytra first-run path in one sentence.\"}}" --quote-only --pretty
 ```
 
+If you want the frozen machine-readable default-path contract behind those starter commands, inspect:
+
+```text
+GET /v1/default-path
+GET /v1/default-path/summary
+```
+
+If you want the frozen machine-readable payment and rail claim boundary behind those execution paths, inspect:
+
+```text
+GET /v1/payment-rail-truth
+GET /v1/payment-rail-truth/summary
+```
+
+If you want the frozen machine-readable adapter and protocol front claim boundary behind those execution paths, inspect:
+
+```text
+GET /v1/adapter-protocol-truth
+GET /v1/adapter-protocol-truth/summary
+```
+
 Then execute with direct signed payment or a credits-first funded account:
 
 ```bash

package/XYTARA_ADAPTER_PROTOCOL_TRUTH_MODEL.md

@@ -0,0 +1,75 @@
+# xytara Adapter And Protocol Truth Model
+
+For `3.0.0`, `xytara` must be both protocol-usable and adapter-extensible.
+
+But it also has to stay honest about what kind of front each surface actually is.
+
+## Core Rule
+
+There are three different truths:
+
+1. first-party default entry fronts
+2. built-in supported but nondefault protocol breadth
+3. partner or adapter-extension surfaces
+
+They must not be collapsed into one vague “supported everywhere” claim.
+
+## Launch Defaults
+
+The frozen protocol-entry posture is:
+
+- `mcp` is the primary default tool front
+- `a2a` is a first-party supported negotiation/settlement front
+- `a2c` is a first-party supported session/tooling front
+
+## Built-In Supported Breadth
+
+The current built-in supported bridge breadth includes:
+
+- `acp`
+- `grpc`
+- `mqtt`
+- `kafka`
+- `nats`
+- `ros2`
+- `webhook_event_bus`
+
+These may be supported and inspectable without being promoted into the main default path.
+
+## Partner And Adapter Extension Truth
+
+Third-party or staging fronts are part of the product surface, but they are not launch defaults.
+
+They can be:
+
+- discoverable
+- reviewable
+- staging-registered
+- promotion-ready
+
+They must not be described as first-party default protocol truth until their promotion state supports it.
+
+## Provider-Live Discipline
+
+Where a front depends on provider-bound execution depth, `xytara` must only claim the bindings listed in:
+
+- `GET /v1/adapter-depth`
+- `GET /v1/providers`
+- `GET /v1/providers/journeys`
+
+This is especially important for `mcp`-backed provider paths.
+
+## Machine-Readable Surfaces
+
+- `GET /v1/adapter-protocol-truth`
+- `GET /v1/adapter-protocol-truth/summary`
+- `GET /v1/adapter-protocol-truth/:profile_id`
+
+## Launch Standard
+
+For `3.0.0`, the public claim is truthful only if:
+
+- default fronts are callable and documented as defaults
+- supported nondefault bridge fronts are clearly marked as such
+- partner and staging fronts stay explicitly bounded
+- unlisted provider or tool depth is never implied

package/XYTARA_DEFAULT_PATH_MODEL.md

@@ -0,0 +1,84 @@
+# xytara Default Path Model
+
+`xytara` is supposed to feel immediate from whatever surface the caller is already using.
+
+For `3.0.0`, that means the public runtime story cannot only exist as separate lane packs. It needs one frozen answer to:
+
+- how a caller discovers work
+- how they quote before irreversible spend
+- how they pay using the posture that fits their surface
+- how they execute without switching stacks
+- how the deliverable comes back where they already are
+- how the result remains proof-ready for `xoonya`
+
+## Core Rule
+
+All supported public entry surfaces must converge on one runtime spine:
+
+`discover -> quote -> fund -> execute -> deliver -> prove -> inspect`
+
+Surface-specific ergonomics are allowed.
+Surface-specific truth models are not.
+
+## Supported Surface Families
+
+The frozen `3.0.0` default-path model covers:
+
+- CLI and terminal
+- direct API
+- browser and hosted checkout
+- chat window and agent runtime
+- service-to-service and automation
+
+## What Changes Across Surfaces
+
+What may change:
+
+- the first entrypoint
+- the payment front
+- whether the caller receives output in stdout, JSON, callback form, or hosted workflow form
+
+What must not change:
+
+- quote-first safety
+- runtime execution truth
+- delivery truth
+- result-package and proof-handoff posture
+- operator inspection and reconciliation continuity
+
+## Runtime And Proof Split
+
+`xytara` owns:
+
+- quote and payment admission
+- execution
+- delivery
+- runtime lifecycle
+- settlement/reconciliation linkage
+- proof-ready handoff artifacts
+
+`xoonya` owns:
+
+- proof semantics
+- verification truth
+- review and governance followthrough
+
+So the default path must end with a stable `xytara -> xoonya` handoff, not a dead-end runtime response.
+
+## Public 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 produce or inspect a quote before irreversible spend
+- each listed surface can execute through the shared runtime engine
+- each listed surface can return or expose the deliverable without breaking the runtime truth model
+- each listed surface can continue into proof-ready followthrough
+
+That is the minimum bar for a truthful universal machine-engine claim.

package/XYTARA_EXECUTION_TRUTH_MODEL.md

@@ -0,0 +1,171 @@
+# xytara Execution Truth Model
+
+Status: active closeout contract
+
+Version: `xytara-execution-truth-model/v1`
+
+## Purpose
+
+This document freezes the runtime-side execution-truth model for `xytara`.
+
+It answers the closeout question:
+
+> What is the canonical hot-state fact model that `xytara` owns before proof followthrough moves into `xoonya`?
+
+The answer is:
+
+- `xytara` owns the runtime-side truth of quote, payment, execution, delivery, settlement linkage, treasury linkage, and proof handoff
+- `xoonya` owns proof semantics, proof verification semantics, and native proof truth
+
+## Core Doctrine
+
+`xytara` execution truth is not one isolated blob.
+
+It is a linked runtime-side object model:
+
+1. `quote`
+2. `transaction`
+3. `receipt`
+4. `delivery`
+5. `settlement`
+6. `proof_handoff`
+
+These objects together form the canonical `xytara` fact spine.
+
+## Object Roles
+
+### 1. Quote
+
+The quote is the priced pre-execution offer.
+
+It binds:
+
+- account
+- amount
+- currency
+- capability scope
+- adapter/settlement posture
+
+It must exist before irreversible paid execution.
+
+### 2. Transaction
+
+The transaction is the primary hot-state execution record.
+
+It carries:
+
+- payment state
+- settlement state
+- treasury state
+- execution state
+- timing
+- remediation state
+
+This is the main runtime object for "what happened."
+
+### 3. Receipt
+
+The receipt is the runtime completion record with a proof pointer.
+
+It carries:
+
+- execution summary
+- payment/settlement/treasury mirrors
+- timing
+- remediation
+- `proof_ref`
+
+It is not the proof core.
+
+It is the runtime-side completion artifact that points into proof followthrough.
+
+### 4. Delivery
+
+The delivery record captures:
+
+- where the result went
+- whether it was direct or callback-driven
+- callback retry/queue/failure state
+- output and proof refs
+
+This is part of runtime truth, not a proof-side side note.
+
+### 5. Settlement
+
+Settlement truth is linked to execution truth, but it is not identical to execution success.
+
+`xytara` must preserve:
+
+- settlement reference
+- mode
+- adapter
+- binding hash
+- finality posture where available
+
+without collapsing execution success into chain finality or treasury consequence.
+
+### 6. Proof Handoff
+
+`xytara` emits proof-compatible facts and references.
+
+That handoff includes:
+
+- `receipt.proof_ref`
+- `receipt.execution_summary`
+- `transaction.execution.results_by_task_id`
+- `delivery.proof_ref`
+
+`xoonya` then owns proof review, verification, continuity, and governance followthrough.
+
+## Layer Sequence
+
+The frozen runtime sequence is:
+
+1. quote
+2. pay or authorize
+3. execute
+4. deliver
+5. settle and reconcile
+6. hand off into proof followthrough
+
+This sequence may run synchronously or asynchronously, but the truth model does not change.
+
+## Non-Negotiable Invariants
+
+The following invariants define the closeout standard:
+
+1. Quote precedes irreversible paid execution.
+2. Transaction is the canonical hot-state execution record.
+3. Receipt is the runtime completion record, not the proof core.
+4. Delivery truth remains first-class and inspectable.
+5. Settlement truth remains linked but distinct from execution success.
+6. Treasury consequence remains reconstructible from runtime artifacts.
+7. `xytara` emits proof-compatible facts without redefining `xoonya` proof semantics.
+
+## Public Surfaces
+
+The machine-readable execution-truth surface is:
+
+- `GET /v1/execution-truth`
+- `GET /v1/execution-truth/summary`
+
+Supporting public surfaces include:
+
+- `GET /v1/capability-registry/execution-truth`
+- `GET /v1/lifecycle-continuity`
+- `GET /v1/deliveries`
+- `GET /v1/revenue-launch/paths`
+- `GET /v1/providers/journeys`
+- `POST /v1/transaction-center/result-packages/export`
+
+Proof followthrough boundary:
+
+- `https://xoonya.onrender.com/v1/proof-center/result-package-handoff/run`
+
+## Closeout Meaning
+
+For `3.0.0`, this model means:
+
+- the execution side is no longer only implied by multiple adjacent artifacts
+- the runtime-side fact model is explicit and frozen
+- outside builders and operators can understand where execution truth ends and proof truth begins

package/XYTARA_PAYMENT_RAIL_TRUTH_MODEL.md

@@ -0,0 +1,68 @@
+# xytara Payment And Rail Truth Model
+
+For `3.0.0`, `xytara` needs a payment story that is both broad and honest.
+
+That means one public rule:
+
+- payment fronts can be callable and live
+- settlement families can be runtime-ready
+- but a specific treasury landing rail is only a public live claim when it is explicitly configured and allowed
+
+## Core Distinction
+
+There are two different truths:
+
+1. payment and execution truth
+2. treasury landing claim truth
+
+The first answers:
+
+- can the caller quote?
+- can they pay through a supported front?
+- can the work execute right away?
+- can the result continue into proof followthrough?
+
+The second answers:
+
+- which exact rail can we publicly say is already a live landing destination?
+
+Those are related, but they are not the same.
+
+## Launch Defaults
+
+The frozen `3.0.0` default posture is:
+
+- machine-native default front: `x402`
+- repeat-use default front: `account_credits`
+- human/browser default front: hosted checkout
+- optional permissionless fronts: `l402`, `bolt`
+- native settlement center: `bsv_teranode`
+
+## Claim Discipline
+
+`xytara` may publicly claim:
+
+- callable payment fronts
+- funded runtime execution
+- proof-ready followthrough
+- supported settlement families
+
+`xytara` must not publicly claim:
+
+- a specific rail as live treasury landing truth unless `public_claim_allowed` is true for that rail
+- operator-only custody or landing refs on public surfaces
+- adapter-ready fronts as first-party launch defaults
+
+## Machine-Readable Surfaces
+
+- `GET /v1/payment-rail-truth`
+- `GET /v1/payment-rail-truth/summary`
+- `GET /v1/payment-rail-truth/:profile_id`
+
+## Why This Matters
+
+This keeps the `3.0.0` claim clean:
+
+- we can truthfully say users can pay through multiple comfortable fronts
+- we can truthfully say execution and proof followthrough are real
+- we do not overclaim live treasury landing breadth where real operator configuration is still the deciding factor

package/index.js

@@ -45,6 +45,30 @@ const {
   getProviderRuntimeJourneyDetail,
   summarizeProviderRuntimeJourneyPack
 } = require("./lib/provider_runtime_journey_contract");
+const {
+  buildExecutionTruthModelPack,
+  summarizeExecutionTruthModelPack
+} = require("./lib/execution_truth_contract");
+const {
+  buildDefaultPathPack,
+  summarizeDefaultPathPack,
+  getDefaultPathSurfaceDetail
+} = require("./lib/default_path_contract");
+const {
+  buildPaymentRailTruthPack,
+  summarizePaymentRailTruthPack,
+  getPaymentRailTruthProfileDetail
+} = require("./lib/payment_rail_truth_contract");
+const {
+  buildAdapterProtocolTruthPack,
+  summarizeAdapterProtocolTruthPack,
+  getAdapterProtocolTruthProfileDetail
+} = require("./lib/adapter_protocol_truth_contract");
+const {
+  buildLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail,
+  summarizeLifecycleContinuityPack
+} = require("./lib/lifecycle_continuity_contract");
 const {
   buildFirstRunConversionPack,
   getFirstRunConversionDetail,
@@ -226,6 +250,20 @@ module.exports = {
   buildProviderRuntimeJourneyPack,
   getProviderRuntimeJourneyDetail,
   summarizeProviderRuntimeJourneyPack,
+  buildExecutionTruthModelPack,
+  summarizeExecutionTruthModelPack,
+  buildDefaultPathPack,
+  summarizeDefaultPathPack,
+  getDefaultPathSurfaceDetail,
+  buildPaymentRailTruthPack,
+  summarizePaymentRailTruthPack,
+  getPaymentRailTruthProfileDetail,
+  buildAdapterProtocolTruthPack,
+  summarizeAdapterProtocolTruthPack,
+  getAdapterProtocolTruthProfileDetail,
+  buildLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail,
+  summarizeLifecycleContinuityPack,
   buildFirstRunConversionPack,
   getFirstRunConversionDetail,
   summarizeFirstRunConversionPack,