@motebit/protocol 1.3.0 → 2.0.1

package/dist/settlement-asset.js

@@ -0,0 +1,82 @@
+/**
+ * Settlement-asset types — the closed vocabulary of stablecoin assets
+ * the protocol clears settlement in.
+ *
+ * Permissive floor (Apache-2.0). Layer 0. Sub-phase A of the
+ * asset-pluggability commitment named in
+ * [`docs/doctrine/off-ramp-as-user-action.md`](../../../docs/doctrine/off-ramp-as-user-action.md)
+ * § "Asset pluggability":
+ *
+ *   > "settlement is asset-pluggable. USDC is the bootstrap stablecoin.
+ *   > A `SettlementAsset` closed union (`"USDC"` only at land) with a
+ *   > bespoke coverage test should ship as sub-phase A of this arc — a
+ *   > typed vocabulary consumers can reference, promoted to the 8th
+ *   > registered registry per `registry-pattern-canonical.md` when a
+ *   > second asset (PYUSD, USDP, etc.) arrives as a real consumer
+ *   > (sub-phase B)."
+ *
+ * Sub-phase A intentionally stops short of the full eight-artifact
+ * registered-registry set: the per-registry coverage gate, perturbation
+ * probe, drift-defenses inventory entry, and `REGISTERED_REGISTRIES`
+ * append are deferred until a second asset materializes as a real
+ * consumer. With a single literal there is no cross-implementation
+ * drift surface to defend against yet; the four criteria in
+ * [`docs/doctrine/registry-pattern-canonical.md`](../../../docs/doctrine/registry-pattern-canonical.md)
+ * § "When to add a registry to `REGISTERED_REGISTRIES`" require "real
+ * or anticipated drift," which this sub-phase does not meet. What it
+ * does meet: interop law (the field is signed on `SovereignRail` and
+ * read by independent verifiers), multi-consumer (rail + relay book-
+ * keeping + agent discovery), wire-format presence (`SovereignRail.asset`
+ * is the protocol-shaped boundary). Three of four criteria → bespoke
+ * coverage; the fourth criterion gates the registry promotion.
+ *
+ * **The registry membership IS the protocol-vs-product wall** (per the
+ * off-ramp doctrine memo's "asset-pluggability" section): if `"MOTE"`
+ * is ever added to `ALL_SETTLEMENT_ASSETS`, it's protocol; if it
+ * isn't, it's a motebit-cloud product overlay that converts to/from a
+ * protocol-level asset at its boundaries. A future MOTE stablecoin is
+ * **not** an architectural endpoint — it's a candidate motebit-cloud
+ * convenience product, evaluated against asset-pluggability when its
+ * compliance, market, and economic case can stand on its own
+ * (deferred per the `feedback_no_mote_stablecoin` memory).
+ *
+ * Semantic note — `SettlementAsset` is distinct from "currency".
+ * `BatchWithdrawalItem.currency`, `DepositResult.currency`,
+ * `WithdrawalResult.currency`, `CapabilityPrice.currency`, and
+ * `BudgetAllocation.currency` retain `string` typing because they
+ * mix fiat ("USD" via Stripe) and stablecoin ("USDC" via x402) across
+ * guest-rail kinds. Only fields whose semantic is unambiguously a
+ * settlement asset — `SovereignRail.asset` is the canonical site —
+ * tighten to this closed union. The fiat/stablecoin distinction lives
+ * at the rail-kind boundary, not in this vocabulary.
+ */
+/**
+ * Canonical iteration order over `SettlementAsset`, frozen. The single
+ * source of truth for "every settlement asset" — exhaustive switches,
+ * bookkeeping enumerations, and the future per-registry coverage gate
+ * (sub-phase B) enumerate through this array.
+ *
+ * Same shape as `ALL_SUITE_IDS`, `ALL_TOKEN_AUDIENCES`,
+ * `ALL_CONTENT_ARTIFACT_TYPES`, `ALL_TASK_SHAPES`,
+ * `ALL_SENSITIVITY_LEVELS`, `ALL_EVENT_TYPES`, `ALL_SETTLEMENT_MODES`.
+ * The array shape is established before the registry is registered so
+ * that the sub-phase B promotion is a one-line `REGISTERED_REGISTRIES`
+ * append, not a refactor.
+ */
+export const ALL_SETTLEMENT_ASSETS = Object.freeze([
+    "USDC",
+]);
+/**
+ * Type guard — narrows `unknown` to `SettlementAsset`. Consumers that
+ * derive settlement-asset values from external sources (peer rail
+ * announcements, signed `SovereignRail` declarations, discovery
+ * responses) call this before dispatching so an unchecked cast is a
+ * fail-open path the type system can't catch.
+ *
+ * Same shape as `isSuiteId`, `isTokenAudience`, `isContentArtifactType`,
+ * `isTaskShape`, `isSensitivityLevel`, `isEventType`, `isSettlementMode`.
+ */
+export function isSettlementAsset(value) {
+    return typeof value === "string" && ALL_SETTLEMENT_ASSETS.includes(value);
+}
+//# sourceMappingURL=settlement-asset.js.map

package/dist/settlement-asset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-asset.js","sourceRoot":"","sources":["../src/settlement-asset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAmBH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA+B,MAAM,CAAC,MAAM,CAAC;IAC7E,MAAM;CACc,CAAC,CAAC;AAExB;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,qBAA2C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACnG,CAAC"}

package/dist/settlement-mode.d.ts

@@ -7,8 +7,102 @@
 /** How money moves for a task: through the relay's virtual accounts, or directly onchain. */
 export type SettlementMode = "relay" | "p2p";
 /**
- * Proof of direct onchain payment from delegator to worker.
- * Submitted by the delegator at task submission time.
+ * The narrow subset of `SettlementMode` that the relay is permitted to
+ * write for **new** worker-settlement rows after Arc 3 of the off-ramp
+ * arc. Reads accept the full `SettlementMode` union (legacy `"relay"`
+ * rows must remain readable for audit, verifier, and federation
+ * compat); writes are structurally restricted to `"p2p"`.
+ *
+ * This is the asymmetric-typing enforcement shape from
+ * [`architecture_disjointness_by_construction`](../../../../.claude/projects/-Users-daniel-src-motebit/memory/architecture_disjointness_by_construction.md)
+ * — the surface stays open for reads but closed for writes; legacy
+ * data remains verifiable but no new code can re-introduce the
+ * relay-custody worker-settlement path. The doctrine: *the relay does
+ * not accept delegator-paid funds on behalf of a worker*. The type:
+ * `WritableSettlementMode = Extract<SettlementMode, "p2p">`. The
+ * structural enforcement: a compile error at every site that tries to
+ * write `"relay"` for a worker settlement.
+ *
+ * Composes with the prior arcs' Layer 1 enforcement shapes:
+ *   - Surface deletion (`BridgeSettlementRail.withdraw`) — Arc 1
+ *   - Marker interface (`WithdrawableGuestRail`) — Arc 1
+ *   - Asymmetric typing (this) — Arc 3
+ *
+ * Doctrine: [`docs/doctrine/off-ramp-as-user-action.md`](../../../docs/doctrine/off-ramp-as-user-action.md) § "Arc 3 close".
+ */
+export type WritableSettlementMode = Extract<SettlementMode, "p2p">;
+/**
+ * Canonical iteration order over `SettlementMode`, frozen. The single
+ * source of truth for "every settlement mode" — drift gates, exhaustive
+ * switches, settlement-eligibility evaluators, and the protocol's
+ * registry-coverage gate (`check-settlement-mode-canonical`) all
+ * enumerate through this array.
+ *
+ * Promoted to a registered registry per
+ * [`docs/doctrine/registry-pattern-canonical.md`](../../../docs/doctrine/registry-pattern-canonical.md)
+ * on 2026-05-15 — the seventh instance after `SuiteId`, `TokenAudience`,
+ * `ContentArtifactType`, `TaskShape`, `SensitivityLevel`, and
+ * `EventType`. The four criteria are met: interop law (cross-
+ * implementation agreement required for settlement to clear), multi-
+ * consumer (relay, agents, discovery, settlement-rails, eligibility
+ * evaluator), wire-format presence (`SettlementEligibility.mode`,
+ * `AgentDiscovery.settlement_modes[]`), anticipated drift (the closed
+ * union will grow when a third mode lands — escrow / hybrid / batched —
+ * and silently breaking peers without the structural lock would
+ * fail interoperability).
+ *
+ * Same shape as `ALL_SUITE_IDS`, `ALL_TOKEN_AUDIENCES`,
+ * `ALL_CONTENT_ARTIFACT_TYPES`, `ALL_TASK_SHAPES`,
+ * `ALL_SENSITIVITY_LEVELS`, `ALL_EVENT_TYPES`. Adding a settlement
+ * mode is intentional protocol-level work: new union entry + new
+ * entry here + gate reference update + spec update if wire-format-
+ * relevant.
+ */
+export declare const ALL_SETTLEMENT_MODES: readonly SettlementMode[];
+/**
+ * Type guard — narrows `unknown` to `SettlementMode`. Consumers that
+ * derive settlement-mode values from external sources (peer
+ * negotiation, discovery responses, relay routing decisions) call
+ * this before dispatching so an unchecked cast is a fail-open path
+ * the type system can't catch.
+ *
+ * Same shape as `isSuiteId`, `isTokenAudience`,
+ * `isContentArtifactType`, `isTaskShape`, `isSensitivityLevel`,
+ * `isEventType`.
+ */
+export declare function isSettlementMode(value: unknown): value is SettlementMode;
+/**
+ * Proof of direct onchain payment for a P2P-settled task. After Arc 2
+ * of the off-ramp arc, the delegator's single signed Solana
+ * transaction composes TWO atomic SPL Transfer instructions:
+ *
+ *   1. **Worker leg** — delegator → worker, amount = `amount_micro`
+ *      (the worker's listing unit_cost, what they earn net).
+ *   2. **Fee leg** — delegator → relay treasury, amount =
+ *      `fee_amount_micro` (the platform fee, derived from the gross
+ *      via `platform_fee_rate`).
+ *
+ * Both legs land atomically (either the whole tx succeeds or it
+ * doesn't); the `p2p-verifier` walks the on-chain `transfers[]` to
+ * confirm both legs match the declared addresses + amounts. The relay
+ * treasury address is the relay's identity-derived Solana wallet
+ * (`deriveSolanaAddress(relay.publicKey)`) — same address that funds
+ * `SolanaMemoSubmitter` for anchoring and that `OperatorSolanaTransfer`
+ * uses for Path 0 withdrawals. Delegators discover it via the published
+ * relay public key on `/.well-known/motebit.json` or
+ * `/.well-known/motebit-transparency.json`.
+ *
+ * Doctrine: `docs/doctrine/off-ramp-as-user-action.md` — Arc 2 closes
+ * the sibling-doc contradiction between the top-level `CLAUDE.md`
+ * Economic Loop "5% applies through both lanes" claim and
+ * `services/relay/CLAUDE.md` rule 8's pre-Arc-2 "Fee: zero on P2P"
+ * policy. The fee is now structurally present on every P2P settlement
+ * as a direct delegator→treasury leg.
+ *
+ * **Breaking change from pre-Arc-2 P2pPaymentProof shape**: the new
+ * `fee_to_address` + `fee_amount_micro` fields are required. The
+ * worker-leg fields (`to_address`, `amount_micro`) keep their existing
+ * semantics — they describe only the worker leg, not the gross.
  */
 export interface P2pPaymentProof {
     /** Onchain transaction signature (Solana base58, 87-88 chars). */
@@ -19,8 +113,27 @@ export interface P2pPaymentProof {
     network: string;
     /** Worker's declared settlement address (base58 for Solana). */
     to_address: string;
-    /** Exact payment amount in micro-units (USDC 6 decimals). Must match expected amount. */
+    /**
+     * Worker leg amount in micro-units (USDC 6 decimals). Equals the
+     * worker's listing unit_cost — what the worker earns net.
+     */
     amount_micro: number;
+    /**
+     * Relay treasury Solana address (base58). Derivable from the relay's
+     * published Ed25519 public key via `deriveSolanaAddress(publicKey)`
+     * (see `@motebit/wallet-solana`). Delegators MUST fetch the relay's
+     * public key from a verified source (transparency declaration or
+     * pinned config) — passing a wrong address sends the fee leg to a
+     * non-relay address and verification fails-closed.
+     */
+    fee_to_address: string;
+    /**
+     * Fee leg amount in micro-units. The platform fee, computed as
+     * `gross - amount_micro` where `gross = amount_micro / (1 - platformFeeRate)`.
+     * The verifier validates this matches the relay's recorded
+     * `platform_fee_rate` against the declared `amount_micro`.
+     */
+    fee_amount_micro: number;
 }
 /** Verification status of an onchain payment proof. */
 export type PaymentVerificationStatus = "pending" | "verified" | "failed";
@@ -52,17 +165,35 @@ export interface SolvencyProof {
     signature: string;
 }
 /**
- * Result of policy-based settlement mode evaluation.
+ * Result of policy-based settlement-eligibility evaluation. After Arc 3
+ * of the off-ramp arc, the eligibility check no longer routes between
+ * relay-custody and P2P — P2P is the only worker-settlement path. The
+ * gate now answers a binary question: "can this delegator-worker pair
+ * transact at all?"
+ *
+ * Disjunctive eligibility per [`docs/doctrine/off-ramp-as-user-action.md`](../../../docs/doctrine/off-ramp-as-user-action.md):
+ *   - **Established-pair branch**: trust ≥ 0.6 AND interactions ≥ 5
+ *     AND no_active_disputes AND worker_has_settlement_address.
+ *   - **New-pair branch**: `delegator_acknowledges_no_history_risk`
+ *     AND no_active_disputes AND worker_not_blocked AND
+ *     worker_has_settlement_address.
+ *
+ * The disjunctive type encodes "allowed implies p2p" structurally —
+ * the `mode` field uses `WritableSettlementMode` so consumers that
+ * destructure `{ mode }` on an allowed result get the narrow type;
+ * the disallowed case has no `mode` field because there's no
+ * fallback rail to route to.
  *
- * The eligibility check considers: mutual opt-in, trust level,
- * interaction history, active disputes, and declared settlement capabilities.
+ * Composes with [[trust_as_economic_membrane]] — the established-pair
+ * branch is the trust-as-fast-path; the new-pair branch is the
+ * cold-start unlock with explicit consent.
  */
-export interface SettlementEligibility {
-    /** Whether p2p settlement is allowed for this pair + task. */
-    allowed: boolean;
-    /** Selected settlement mode. */
-    mode: SettlementMode;
-    /** Human-readable reason for the decision. */
+export type SettlementEligibility = {
+    allowed: true;
+    mode: WritableSettlementMode;
     reason: string;
-}
+} | {
+    allowed: false;
+    reason: string;
+};
 //# sourceMappingURL=settlement-mode.d.ts.map

package/dist/settlement-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settlement-mode.d.ts","sourceRoot":"","sources":["../src/settlement-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,6FAA6F;AAC7F,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC;AAI7C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,yFAAyF;IACzF,YAAY,EAAE,MAAM,CAAC;CACtB;AAID,uDAAuD;AACvD,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;AAI1E;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACnB;AAID;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,IAAI,EAAE,cAAc,CAAC;IACrB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;CAChB"}
+{"version":3,"file":"settlement-mode.d.ts","sourceRoot":"","sources":["../src/settlement-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,6FAA6F;AAC7F,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,cAAc,EAGpC,CAAC;AAEvB;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAExE;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAID,uDAAuD;AACvD,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;AAI1E;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;CACnB;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,qBAAqB,GAC7B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,sBAAsB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/settlement-mode.js

@@ -4,5 +4,49 @@
  * Permissive floor (Apache-2.0): these types define the interoperable format
  * for settlement mode selection and payment proof verification.
  */
-export {};
+/**
+ * Canonical iteration order over `SettlementMode`, frozen. The single
+ * source of truth for "every settlement mode" — drift gates, exhaustive
+ * switches, settlement-eligibility evaluators, and the protocol's
+ * registry-coverage gate (`check-settlement-mode-canonical`) all
+ * enumerate through this array.
+ *
+ * Promoted to a registered registry per
+ * [`docs/doctrine/registry-pattern-canonical.md`](../../../docs/doctrine/registry-pattern-canonical.md)
+ * on 2026-05-15 — the seventh instance after `SuiteId`, `TokenAudience`,
+ * `ContentArtifactType`, `TaskShape`, `SensitivityLevel`, and
+ * `EventType`. The four criteria are met: interop law (cross-
+ * implementation agreement required for settlement to clear), multi-
+ * consumer (relay, agents, discovery, settlement-rails, eligibility
+ * evaluator), wire-format presence (`SettlementEligibility.mode`,
+ * `AgentDiscovery.settlement_modes[]`), anticipated drift (the closed
+ * union will grow when a third mode lands — escrow / hybrid / batched —
+ * and silently breaking peers without the structural lock would
+ * fail interoperability).
+ *
+ * Same shape as `ALL_SUITE_IDS`, `ALL_TOKEN_AUDIENCES`,
+ * `ALL_CONTENT_ARTIFACT_TYPES`, `ALL_TASK_SHAPES`,
+ * `ALL_SENSITIVITY_LEVELS`, `ALL_EVENT_TYPES`. Adding a settlement
+ * mode is intentional protocol-level work: new union entry + new
+ * entry here + gate reference update + spec update if wire-format-
+ * relevant.
+ */
+export const ALL_SETTLEMENT_MODES = Object.freeze([
+    "relay",
+    "p2p",
+]);
+/**
+ * Type guard — narrows `unknown` to `SettlementMode`. Consumers that
+ * derive settlement-mode values from external sources (peer
+ * negotiation, discovery responses, relay routing decisions) call
+ * this before dispatching so an unchecked cast is a fail-open path
+ * the type system can't catch.
+ *
+ * Same shape as `isSuiteId`, `isTokenAudience`,
+ * `isContentArtifactType`, `isTaskShape`, `isSensitivityLevel`,
+ * `isEventType`.
+ */
+export function isSettlementMode(value) {
+    return typeof value === "string" && ALL_SETTLEMENT_MODES.includes(value);
+}
 //# sourceMappingURL=settlement-mode.js.map

package/dist/settlement-mode.js.map

@@ -1 +1 @@
-{"version":3,"file":"settlement-mode.js","sourceRoot":"","sources":["../src/settlement-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}
+{"version":3,"file":"settlement-mode.js","sourceRoot":"","sources":["../src/settlement-mode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiCH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA8B,MAAM,CAAC,MAAM,CAAC;IAC3E,OAAO;IACP,KAAK;CACc,CAAC,CAAC;AAEvB;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,oBAA0C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAClG,CAAC"}

package/dist/trust-algebra.d.ts

@@ -32,7 +32,7 @@ export declare function composeTrustChain(scores: number[]): number;
 export declare function joinParallelRoutes(scores: number[]): number;
 export declare const REFERENCE_TRUST_THRESHOLDS: TrustTransitionThresholds;
 /**
- * @deprecated since 1.0.1, removed in 2.0.0. Use {@link REFERENCE_TRUST_THRESHOLDS} instead.
+ * @deprecated since 1.0.1, removed in 3.0.0. Use {@link REFERENCE_TRUST_THRESHOLDS} instead.
  *
  * Reason: the `DEFAULT_` prefix read as "THE value every motebit
  * implementation uses," but trust-transition thresholds are motebit

package/dist/trust-algebra.js

@@ -71,7 +71,7 @@ export const REFERENCE_TRUST_THRESHOLDS = {
     demote_minTasks: 3,
 };
 /**
- * @deprecated since 1.0.1, removed in 2.0.0. Use {@link REFERENCE_TRUST_THRESHOLDS} instead.
+ * @deprecated since 1.0.1, removed in 3.0.0. Use {@link REFERENCE_TRUST_THRESHOLDS} instead.
  *
  * Reason: the `DEFAULT_` prefix read as "THE value every motebit
  * implementation uses," but trust-transition thresholds are motebit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motebit/protocol",
-  "version": "1.3.0",
+  "version": "2.0.1",
   "description": "Motebit protocol — identity, receipts, credentials, delegation, settlement, and trust algebra for sovereign AI agents. Types, semirings, routing primitives. Apache-2.0, zero dependencies.",
   "type": "module",
   "main": "./dist/index.js",