@byollm/protocol 0.1.0-alpha.99 → 0.1.0

package/README.md

@@ -1,17 +1,3 @@
-> [!WARNING]
-> **Alpha (`0.1.0-alpha.99`) — under active development. Don't use this yet.**
->
-> Install it deliberately: `npm install @byollm/protocol@alpha`.
->
-> The protocol is v0 and **will** change without a deprecation path, this has
-> never run outside its own test suite, and nothing here has production miles.
-> Read it, take the ideas, tell us what's wrong — but don't put it in front of
-> your users.
->
-> npm assigns `latest` on a first publish and won't let it be removed, so a
-> bare install resolves here too. This notice is the only guard — deliberately
-> not an npm deprecation, which would read as *abandoned* rather than *early*.
-> Ask for `@alpha` explicitly so your lockfile records that you meant to.>
 > **`alpha.15` is a breaking wire change, and it breaks daemons and relays —
 > not app authors.** If you call `app.enqueue(...)` and read results, nothing
 > in your code changes. If you run a daemon or an upstream, every package must
@@ -183,7 +169,7 @@ to know which one happened.
 
 ## Normative spec
 
-[`docs/protocol.md`](../../docs/protocol.md). Every MUST there carries a
+[`docs/protocol.md`](https://github.com/oftomorrowinc/byollm/blob/main/docs/protocol.md). Every MUST there carries a
 conformance id that appears in this package's `MUSTS` registry.
 
 MIT
@@ -200,4 +186,11 @@ Six packages, and they are only interesting together:
 - [`@byollm/control-plane`](https://www.npmjs.com/package/@byollm/control-plane) — who may ask whom, and the policy store behind it
 - [`@byollm/conformance`](https://www.npmjs.com/package/@byollm/conformance) — the kit that proves an implementation is one — including a posture audit that holds nothing but a URL
 
+### Where the rest lives
+
+- [GitHub](https://github.com/oftomorrowinc/byollm) — the source, and where issues go
+- [byo-llm.com](https://byo-llm.com) — what this is, and why
+- [byollm.cloud](https://byollm.cloud) — the hosted relay — devices, consent and billing
+- [docs.byollm.cloud](https://docs.byollm.cloud) — integrating a site, end to end
+
 <!-- family:end -->

package/dist/index.d.ts

@@ -2,6 +2,84 @@ import { z } from 'zod';
 import { S as StoredKeys, P as PublicIdentity } from './portable-C6rfiCXi.js';
 export { C as CONSOLE_FRAME_VERSION, a as CONSOLE_MAX_DATA_BYTES, b as ConsoleBye, c as ConsoleFrame, d as ConsoleHello, e as ConsoleOrder, f as ConsoleOrderFault, g as ConsoleOrderResult, h as ConsoleResize, i as ConsoleStdin, j as ConsoleStdout, E as ENCRYPTION_KEY_CONTEXT, k as ENVELOPE_BODY_VERSION, l as ENVELOPE_MAX_AGE_MS, m as EnvelopeBodyContext, n as EnvelopeContext, o as EnvelopeDirection, p as EnvelopeFailure, q as EnvelopeInner, O as OpenResult, r as SealedEnvelope, s as consoleDataBytes, t as consoleEnvelope, u as consoleOrder, v as cryptoReady, w as decodeConsoleData, x as decodeEnvelopeInner, y as encodeConsoleData, z as encodeEnvelopeInner, A as envelopeSignedBody, B as fingerprint, D as fromBase64Url, F as generateKeys, G as keyId, H as open, I as publicIdentityOf, J as seal, K as signWith, L as toBase64Url, M as verifyPublicIdentity, N as verifyWith } from './portable-C6rfiCXi.js';
 
+/**
+ * What byollm.cloud can see, in the words a person reads — B039.
+ *
+ * ## Why a sentence is in a published package
+ *
+ * This one sentence has to be true in three places at once: the privacy page
+ * that prints it, the check beside the hub's schema that proves every recorded
+ * column is claimed by one of its clauses, and the page test that pins the
+ * wording. Two of those live in `byollm-cloud`, one in `byollm-cloud-web`, and
+ * **a check cannot read another repository** — so until now the sentence was
+ * written out three times and nothing compared the copies.
+ *
+ * That is not a tidiness problem. An enumeration is a promise, and a promise
+ * kept in three places drifts in two of them: the copy beside the schema is
+ * the one that fails when a column is added, and if it is not the copy on the
+ * page, the page stays reassuring and stops being true. Which is worse than
+ * never having made the promise.
+ *
+ * `byollm_023` named the only two shapes — a copy per repository (they
+ * diverge, silently) or one source both import (it goes stale, loudly, as a
+ * version pin). **Todd ruled shape 2 on 2026-09-17**, and the reason is the
+ * one that decides it: staleness is a number somebody can compare, and B164's
+ * cross-repository pin comparison is the thing that compares it. Divergence
+ * has no such number.
+ *
+ * ## Why it lives in `@byollm/protocol` and not a package of its own
+ *
+ * It was one, for a day. **Todd ruled on 2026-09-19: no seventh package** —
+ * *"I do think just adding it to protocol and importing that makes a ton of
+ * sense"* — and `packages/agreements` was deleted rather than marked private.
+ * Both consuming repositories already pin `@byollm/protocol`, so the sentence
+ * arrives on a pin they carry instead of a name they would have to adopt, and
+ * the cut stops carrying a package that had never been published.
+ *
+ * ## Published, not internal
+ *
+ * It ships to npm rather than living in a private repository, and that is a
+ * property rather than an accident: a promise about what a hosted service can
+ * see is worth more when anybody can install the package, read the sentence,
+ * and check it against what the service does. Protocol is public, so that is
+ * unchanged by the move.
+ */
+/**
+ * The hub fence, verbatim — ruled by Todd, 2026-09-04.
+ *
+ * Asserted whole rather than by keyword wherever it is checked: "close
+ * enough" is not a standard a page about what we can see gets to use, and a
+ * paraphrase that drifted would leave the other repository checking a sentence
+ * nobody ships.
+ */
+declare const HUB_FENCE: string;
+/**
+ * A clause of {@link HUB_FENCE}, and the columns it accounts for.
+ *
+ * The mapping is here rather than beside the schema for the same reason the
+ * sentence is: it is a fact about the sentence, and the sentence is shared.
+ * What stays beside the schema is the CHECK — every recorded column must be
+ * claimed by one of these before that suite passes — because the columns are
+ * the hub's and only the hub's repository can enumerate them.
+ *
+ * Coupling copy to columns by check rather than by convention is the whole of
+ * the ruling: the enumeration is only a promise if something fails when the
+ * code outgrows it.
+ */
+interface FenceClause {
+    /** The clause as it appears in {@link HUB_FENCE}. */
+    readonly says: string;
+    /** The recorded columns this clause accounts for. */
+    readonly covers: readonly string[];
+}
+/**
+ * Every clause, with what it covers.
+ *
+ * A column not claimed by any clause is a fact about somebody that the page
+ * does not mention, which is what the check beside the schema refuses.
+ */
+declare const HUB_FENCE_CLAUSES: readonly FenceClause[];
+
 /**
  * Protocol version carried on every request; servers refuse what they can't
  * speak.
@@ -25,7 +103,7 @@ export { C as CONSOLE_FRAME_VERSION, a as CONSOLE_MAX_DATA_BYTES, b as ConsoleBy
  * own words, from the release that silenced a fleet by adding a backend id.
  * The same sentence applies to removing an offer scope.
  */
-declare const PROTOCOL_VERSION: "1";
+declare const PROTOCOL_VERSION: "2";
 /**
  * Every protocol version this build can serve, **oldest first**.
  *
@@ -268,7 +346,7 @@ type GrantRef = z.infer<typeof GrantRef>;
  * and nothing works over a copied string alone.
  */
 declare const PairStartRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     action: z.ZodLiteral<"start">;
     daemon: z.ZodObject<{
         version: z.ZodString;
@@ -333,7 +411,7 @@ declare const PairStartResponse: z.ZodObject<{
 }, z.core.$strict>;
 type PairStartResponse = z.infer<typeof PairStartResponse>;
 declare const PairPollRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     action: z.ZodLiteral<"poll">;
     deviceCode: z.ZodString;
 }, z.core.$strict>;
@@ -358,7 +436,7 @@ declare const PairPollResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>], "status">;
 type PairPollResponse = z.infer<typeof PairPollResponse>;
 declare const PairRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     action: z.ZodLiteral<"start">;
     daemon: z.ZodObject<{
         version: z.ZodString;
@@ -413,13 +491,13 @@ declare const PairRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     action: z.ZodLiteral<"poll">;
     deviceCode: z.ZodString;
 }, z.core.$strict>], "action">;
 type PairRequest = z.infer<typeof PairRequest>;
 declare const ClaimRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     runnerId: z.ZodString;
     capabilities: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
@@ -506,7 +584,7 @@ declare const ClaimResponse: z.ZodObject<{
 }, z.core.$strict>;
 type ClaimResponse = z.infer<typeof ClaimResponse>;
 declare const HeartbeatRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     runnerId: z.ZodString;
     daemonVersion: z.ZodString;
     capabilities: z.ZodArray<z.ZodObject<{
@@ -564,7 +642,6 @@ declare const HeartbeatRequest: z.ZodObject<{
         jobId: z.ZodString;
         leaseId: z.ZodString;
     }, z.core.$strict>>;
-    paused: z.ZodBoolean;
 }, z.core.$strict>;
 type HeartbeatRequest = z.infer<typeof HeartbeatRequest>;
 declare const HeartbeatResponse: z.ZodObject<{
@@ -616,7 +693,7 @@ declare const ResultDisposition: z.ZodEnum<{
 }>;
 type ResultDisposition = z.infer<typeof ResultDisposition>;
 declare const ResultRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     runnerId: z.ZodString;
     jobId: z.ZodString;
     leaseId: z.ZodString;
@@ -644,7 +721,7 @@ declare const ResultResponse: z.ZodObject<{
 }, z.core.$strict>;
 type ResultResponse = z.infer<typeof ResultResponse>;
 declare const ReleaseRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     runnerId: z.ZodString;
     leases: z.ZodArray<z.ZodObject<{
         jobId: z.ZodString;
@@ -713,7 +790,7 @@ type WireError = z.infer<typeof WireError>;
 /** HTTP status each error code is served with. */
 declare const ERROR_STATUS: Readonly<Record<WireErrorCode, number>>;
 declare const FetchRequest: z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"1">;
+    protocolVersion: z.ZodLiteral<"2">;
     runnerId: z.ZodString;
     jobId: z.ZodString;
     leaseId: z.ZodString;
@@ -1555,6 +1632,44 @@ declare const ClaimedJob: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 type ClaimedJob = z.infer<typeof ClaimedJob>;
+/**
+ * The closed set, as a schema — so the values exist once.
+ *
+ * A bare union would mean anything that has to VALIDATE a stop reason (the
+ * ingress log, and the wire when step 4 lands) retyping the four strings
+ * beside it. Instruction 9: one definition, both ends, and where a consumer
+ * needs a runtime check the definition has to be one it can run.
+ *
+ * The type below is inferred from this rather than written twice, so the
+ * compiler and the validator cannot disagree about what a stop reason is.
+ */
+declare const StopReasonSchema: z.ZodEnum<{
+    length: "length";
+    unknown: "unknown";
+    end: "end";
+    "stop-sequence": "stop-sequence";
+}>;
+type StopReason = 
+/** The model finished on its own. */
+"end"
+/** The model stopped at its own output ceiling. */
+ | "length"
+/** A configured stop token ended it. */
+ | "stop-sequence"
+/**
+ * The adapter cannot tell, and says so.
+ *
+ * **The default, and never `"end"`.** An adapter nobody has updated — or
+ * one somebody adds next year — must not be able to claim completion by
+ * saying nothing. If absence meant "end", every un-updated adapter would go
+ * on telling exactly the lie this exists to fix, and every new adapter
+ * would inherit it in silence.
+ *
+ * It is the opposite-boolean rule this codebase keeps arriving at: when you
+ * cannot tell, guess toward silence rather than toward a claim. "We do not
+ * know" is a thing a site can act on; "it finished" when it did not is not.
+ */
+ | "unknown";
 /**
  * The provenance that travels with every result to the delivery seam.
  *
@@ -1575,6 +1690,13 @@ declare const ResultProvenance: z.ZodObject<{
     }>;
     model: z.ZodString;
     untrusted: z.ZodBoolean;
+    stop: z.ZodOptional<z.ZodEnum<{
+        length: "length";
+        unknown: "unknown";
+        end: "end";
+        "stop-sequence": "stop-sequence";
+    }>>;
+    stopReported: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 type ResultProvenance = z.infer<typeof ResultProvenance>;
 /**
@@ -1587,6 +1709,9 @@ declare function provenanceFor(input: {
     runnerOwner: string;
     backendClass: BackendClass;
     model: string;
+    /** From the sealed `ran`; absent on a cancelled or errored job — B260. */
+    stop?: StopReason | undefined;
+    stopReported?: boolean | undefined;
 }): ResultProvenance;
 /**
  * What the daemon did, sealed with the answer — cloud_008 §2.5.
@@ -1603,44 +1728,6 @@ declare function provenanceFor(input: {
  * opens them, nothing in between sees them, and the disposition check that
  * already compares clear-text against ciphertext extends to cover them.
  */
-/**
- * The closed set, as a schema — so the values exist once.
- *
- * A bare union would mean anything that has to VALIDATE a stop reason (the
- * ingress log, and the wire when step 4 lands) retyping the four strings
- * beside it. Instruction 9: one definition, both ends, and where a consumer
- * needs a runtime check the definition has to be one it can run.
- *
- * The type below is inferred from this rather than written twice, so the
- * compiler and the validator cannot disagree about what a stop reason is.
- */
-declare const StopReasonSchema: z.ZodEnum<{
-    length: "length";
-    unknown: "unknown";
-    end: "end";
-    "stop-sequence": "stop-sequence";
-}>;
-type StopReason = 
-/** The model finished on its own. */
-"end"
-/** The model stopped at its own output ceiling. */
- | "length"
-/** A configured stop token ended it. */
- | "stop-sequence"
-/**
- * The adapter cannot tell, and says so.
- *
- * **The default, and never `"end"`.** An adapter nobody has updated — or
- * one somebody adds next year — must not be able to claim completion by
- * saying nothing. If absence meant "end", every un-updated adapter would go
- * on telling exactly the lie this exists to fix, and every new adapter
- * would inherit it in silence.
- *
- * It is the opposite-boolean rule this codebase keeps arriving at: when you
- * cannot tell, guess toward silence rather than toward a claim. "We do not
- * know" is a thing a site can act on; "it finished" when it did not is not.
- */
- | "unknown";
 declare const RunMetadata: z.ZodObject<{
     model: z.ZodString;
     backendClass: z.ZodEnum<{
@@ -1840,6 +1927,13 @@ declare const DeliveredResult: z.ZodObject<{
         }>;
         model: z.ZodString;
         untrusted: z.ZodBoolean;
+        stop: z.ZodOptional<z.ZodEnum<{
+            length: "length";
+            unknown: "unknown";
+            end: "end";
+            "stop-sequence": "stop-sequence";
+        }>>;
+        stopReported: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
     fallback: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
@@ -2281,6 +2375,74 @@ declare function verifyRequest(input: {
  * what a single-purpose site's one purpose actually is.
  */
 declare const RESERVED_PURPOSE = "default";
+/**
+ * How a purpose's work is routed — RESERVED at 0.1.0, not yet acted on (B236).
+ *
+ * ## Why a key nothing reads is the highest-leverage thing in this file
+ *
+ * {@link Purpose} is `.strict()`, and that is right: a manifest is written by
+ * hand by a third party, and a typo'd key that is silently ignored is a site
+ * whose consent screen quietly says something other than what its author
+ * wrote. The cost of `.strict()` is that **there is no such thing as an
+ * additive change to it.** A key added in 1.4 is rejected by every validator
+ * built before 1.4, and the OSS repository ships the server — so those
+ * validators will exist, on machines nobody can upgrade, run by people who
+ * have no idea a key was added.
+ *
+ * The window in which this field can be introduced is therefore now: before
+ * the wire is declared stable, while every validator in existence is ours.
+ * After that the shape is load-bearing whether or not anything reads it.
+ *
+ * So the values are the ruled ones (B232 house lanes, B233 fallback lanes),
+ * the schema refuses anything else, and no code branches on it. A site may
+ * write `routing` today and get exactly the behaviour it gets without it,
+ * which is the point: the manifest it writes today is still valid the day
+ * the lanes land.
+ *
+ * ## What each value will mean, when something reads it
+ *
+ * - `user-choice` — the person maps this purpose to one of their own
+ *   services, and that mapping is the consent. Today's only behaviour, and
+ *   the default for a manifest that says nothing.
+ * - `site-fixed` — the site pays for and pins the service (B232's house
+ *   lane). The person is told, and consents to that rather than to a mapping.
+ * - `user-first-with-fallback` — the person's service if they have one, the
+ *   site's if they do not (B233).
+ *
+ * **The commitment attached to those last two** is written in the lock
+ * document rather than here, because it binds behaviour this file cannot
+ * enforce: a hub that does not implement a lane treats the purpose as
+ * `user-choice` and SAYS SO in a field rather than silently downgrading it,
+ * and a lane added later carries its own disclosure and never weakens an
+ * existing lane's promise.
+ */
+declare const PurposeRouting: z.ZodEnum<{
+    "user-choice": "user-choice";
+    "site-fixed": "site-fixed";
+    "user-first-with-fallback": "user-first-with-fallback";
+}>;
+type PurposeRouting = z.infer<typeof PurposeRouting>;
+/**
+ * What a purpose that does not say means.
+ *
+ * Named once, here, rather than written into the schema as `.default()`. A
+ * zod default is applied at PARSE, which would mean every manifest read by
+ * anything becomes a manifest with a `routing` key — and a hub that parses a
+ * site's manifest, stores it and serves it back would be handing a key to
+ * readers that predate it. The thing this field exists to avoid, performed by
+ * the field itself.
+ *
+ * Parsing stays shape-preserving; the default is applied where the value is
+ * USED, by {@link routingOf}.
+ */
+declare const DEFAULT_ROUTING: PurposeRouting;
+/**
+ * The routing a purpose asks for, defaulted.
+ *
+ * The one place the absent case is answered, so that when B232 and B233 do
+ * act on this there is no second opinion about what "not stated" meant.
+ */
+declare function routingOf(purpose: Purpose): PurposeRouting;
 declare const Purpose: z.ZodObject<{
     label: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -2288,6 +2450,11 @@ declare const Purpose: z.ZodObject<{
         "llm.generate": "llm.generate";
         "llm.chat": "llm.chat";
     }>>;
+    routing: z.ZodOptional<z.ZodEnum<{
+        "user-choice": "user-choice";
+        "site-fixed": "site-fixed";
+        "user-first-with-fallback": "user-first-with-fallback";
+    }>>;
 }, z.core.$strict>;
 type Purpose = z.infer<typeof Purpose>;
 /**
@@ -2320,6 +2487,11 @@ declare const Manifest: z.ZodRecord<z.ZodString, z.ZodObject<{
         "llm.generate": "llm.generate";
         "llm.chat": "llm.chat";
     }>>;
+    routing: z.ZodOptional<z.ZodEnum<{
+        "user-choice": "user-choice";
+        "site-fixed": "site-fixed";
+        "user-first-with-fallback": "user-first-with-fallback";
+    }>>;
 }, z.core.$strict>>;
 type Manifest = z.infer<typeof Manifest>;
 /**
@@ -2806,4 +2978,4 @@ declare const MUST_IDS: readonly ("PAIR_ONE_USER" | "PAIR_INTERACTIVE" | "PAIR_C
 /** Every MUST verified a particular way. */
 declare function mustsVerifiedBy(kind: MustVerification): MustId[];
 
-export { ABOUT, ABOUT_SHORT, ABOUT_SHORT_LEDE, ABOUT_SHORT_TAIL, AUDIENCES, Audience, BACKENDS, BACKEND_CLASSES, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, CLOCK_ATTRIBUTION_MS, CLOCK_SKEW_WARN_MS, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DeliveredResult, ENDPOINTS, ERROR_STATUS, type Endpoint, FetchRequest, FetchResponse, type FloorRefusal, GRANT_CONTEXT, GRANT_MAX_AGE_MS, GRANT_SIGNED_FIELDS, GeneratePayload, type GrantClaims, GrantRef, type GrantRefusal, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobRefused, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_ENVELOPE_BYTES, MAX_PURPOSES, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, Manifest, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, Purpose, REFUSAL_MESSAGES, REFUSAL_TEXT, RESERVED_PURPOSE, RETIREMENT_WINDOW_MS, RefusalReason, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASSES, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedOutcome, type SignatureFailure, SignedGrant, SizeClass, type SpendConsent, type StopReason, StopReasonSchema, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, UPDATE_OFFER_SINCE, UPGRADE_COMMAND, type VersionRefusal, WireError, WireErrorCode, WithheldKind, backendDescriptor, backendName, canTransition, canonicalRequest, checkDaemonFloor, checkProtocolVersion, classifyCost, compareVersions, declaredVersion, describeBytes, effectiveOfferScope, envelopeBytes, grantStatement, isBackendId, isCloudTaggedModel, isJobKind, isLocalHost, isTerminal, kindsOf, matchAudience, mayOfferUpdate, mentionsWireField, mustsVerifiedBy, payloadTextLength, provenanceFor, resolveCost, signGrant, signRequest, signSiteRequest, signSuccession, singlePurposeManifest, sizeClassCeiling, sizeClassOf, successionStatement, tooLargeMessage, updateOfferFor, verifyGrant, verifyLink, verifyRequest, verifySiteRequest, walkSuccession, withoutComments };
+export { ABOUT, ABOUT_SHORT, ABOUT_SHORT_LEDE, ABOUT_SHORT_TAIL, AUDIENCES, Audience, BACKENDS, BACKEND_CLASSES, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, CLOCK_ATTRIBUTION_MS, CLOCK_SKEW_WARN_MS, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DEFAULT_ROUTING, DeliveredResult, ENDPOINTS, ERROR_STATUS, type Endpoint, type FenceClause, FetchRequest, FetchResponse, type FloorRefusal, GRANT_CONTEXT, GRANT_MAX_AGE_MS, GRANT_SIGNED_FIELDS, GeneratePayload, type GrantClaims, GrantRef, type GrantRefusal, HUB_FENCE, HUB_FENCE_CLAUSES, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobRefused, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_ENVELOPE_BYTES, MAX_PURPOSES, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, Manifest, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, Purpose, PurposeRouting, REFUSAL_MESSAGES, REFUSAL_TEXT, RESERVED_PURPOSE, RETIREMENT_WINDOW_MS, RefusalReason, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASSES, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedOutcome, type SignatureFailure, SignedGrant, SizeClass, type SpendConsent, type StopReason, StopReasonSchema, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, UPDATE_OFFER_SINCE, UPGRADE_COMMAND, type VersionRefusal, WireError, WireErrorCode, WithheldKind, backendDescriptor, backendName, canTransition, canonicalRequest, checkDaemonFloor, checkProtocolVersion, classifyCost, compareVersions, declaredVersion, describeBytes, effectiveOfferScope, envelopeBytes, grantStatement, isBackendId, isCloudTaggedModel, isJobKind, isLocalHost, isTerminal, kindsOf, matchAudience, mayOfferUpdate, mentionsWireField, mustsVerifiedBy, payloadTextLength, provenanceFor, resolveCost, routingOf, signGrant, signRequest, signSiteRequest, signSuccession, singlePurposeManifest, sizeClassCeiling, sizeClassOf, successionStatement, tooLargeMessage, updateOfferFor, verifyGrant, verifyLink, verifyRequest, verifySiteRequest, walkSuccession, withoutComments };

package/dist/index.js

@@ -21,6 +21,34 @@ import {
   toBase64Url
 } from "./chunk-J3HTAGMX.js";
 
+// src/hub-fence.ts
+var HUB_FENCE = "byollm.cloud sees only what routing and metering need: which devices and sites are connected, each job's kind, size, and outcome, and timestamps. Never prompts, never answers, never credentials.";
+var HUB_FENCE_CLAUSES = Object.freeze([
+  {
+    says: "which devices and sites are connected",
+    covers: Object.freeze(["owner_id", "site_id", "member_id"])
+  },
+  {
+    says: "each job's kind, size, and outcome",
+    covers: Object.freeze(["kind", "size_class", "disposition", "bytes"])
+  },
+  {
+    says: "and timestamps",
+    covers: Object.freeze(["at", "month", "updated_at"])
+  },
+  /*
+   * Ruled plumbing, not a new fact about a person — Todd, 2026-09-04.
+   *
+   * Named here rather than silently tolerated. A column exempted by a ruling
+   * and a column nobody noticed look identical to a check that just skips
+   * them, and only one of those is a decision.
+   */
+  {
+    says: "(metering plumbing, ruled unenumerated)",
+    covers: Object.freeze(["id", "job_id", "price_version"])
+  }
+]);
+
 // src/wire.ts
 import { z as z9 } from "zod";
 
@@ -888,6 +916,12 @@ var ClaimedJob = z7.object({
   deadlineAt: z7.number().int().positive().optional(),
   lease: Lease
 }).strict();
+var StopReasonSchema = z7.enum([
+  "end",
+  "length",
+  "stop-sequence",
+  "unknown"
+]);
 var ResultProvenance = z7.object({
   /** The audience the job ran under. */
   audience: Audience,
@@ -900,10 +934,33 @@ var ResultProvenance = z7.object({
   /** The model the runner reports having used. */
   model: z7.string().min(1),
   /**
-   * False only for `self` jobs. When true the app MUST treat `text` as
+   * False only for `private` jobs. When true the app MUST treat `text` as
    * untrusted third-party content.
    */
-  untrusted: z7.boolean()
+  untrusted: z7.boolean(),
+  /**
+   * Why generation stopped, carried from the sealed `ran` — B260.
+   *
+   * It was sealed by the device, opened at the site, used to build this
+   * object, and **dropped**: `provenanceFor` took five fields and `stop` was
+   * not one of them, on either lane. So no site could ever see it, and a
+   * `length` result — an answer cut off mid-thought — arrived
+   * indistinguishable from a complete one. Kevin's team found it on a
+   * book-translation pipeline, which is the difference between shipping a
+   * chapter and shipping half of one without knowing.
+   *
+   * Optional here because it is optional there, and for the same reason:
+   * absent exactly where it would be a fact about nothing.
+   */
+  stop: StopReasonSchema.optional(),
+  /**
+   * Whether the adapter could report a stop signal at all — carried for the
+   * reason {@link RunMetadata.stopReported} gives: `unknown` is two facts,
+   * and a site told only `unknown` says "we do not know why this stopped"
+   * for a `claude-cli` job forever, which is true, and for a
+   * `content_filter` result, which is not the same thing at all.
+   */
+  stopReported: z7.boolean().optional()
 }).strict();
 function provenanceFor(input) {
   return {
@@ -912,15 +969,14 @@ function provenanceFor(input) {
     runnerOwner: input.runnerOwner,
     backendClass: input.backendClass,
     model: input.model,
-    untrusted: input.audience !== "private"
+    untrusted: input.audience !== "private",
+    /* Spread rather than assigned: `exactOptionalPropertyTypes` makes an
+       explicit `undefined` a different thing from an absent key, and this
+       object is `.strict()`. */
+    ...input.stop === void 0 ? {} : { stop: input.stop },
+    ...input.stopReported === void 0 ? {} : { stopReported: input.stopReported }
   };
 }
-var StopReasonSchema = z7.enum([
-  "end",
-  "length",
-  "stop-sequence",
-  "unknown"
-]);
 var RunMetadata = z7.object({
   /** Which model actually served it. */
   model: z7.string().min(1),
@@ -1273,7 +1329,7 @@ async function open(input) {
 }
 
 // src/wire.ts
-var PROTOCOL_VERSION = "1";
+var PROTOCOL_VERSION = "2";
 var SUPPORTED_PROTOCOL_VERSIONS = Object.freeze([
   PROTOCOL_VERSION
 ]);
@@ -1510,9 +1566,7 @@ var HeartbeatRequest = z9.object({
    * Lease ids rather than job ids, so a replayed heartbeat cannot renew a
    * grant the runner no longer holds — see {@link Lease.id}.
    */
-  activeLeases: z9.array(GrantRef),
-  /** True while the owner has the daemon paused; the server stops offering work. */
-  paused: z9.boolean()
+  activeLeases: z9.array(GrantRef)
 }).strict();
 var HeartbeatResponse = z9.object({
   /**
@@ -2181,6 +2235,15 @@ var PurposeKey = z11.string().regex(
   /^[a-z0-9][a-z0-9-]*$/,
   "a purpose key is a lowercase slug \u2014 letters, digits and hyphens"
 ).max(64);
+var PurposeRouting = z11.enum([
+  "user-choice",
+  "site-fixed",
+  "user-first-with-fallback"
+]);
+var DEFAULT_ROUTING = "user-choice";
+function routingOf(purpose) {
+  return purpose.routing ?? DEFAULT_ROUTING;
+}
 var Purpose = z11.object({
   /**
    * What a person reads on the consent screen. The only rendered field.
@@ -2201,7 +2264,16 @@ var Purpose = z11.object({
    */
   kinds: z11.array(JobKind).min(1).max(JOB_KINDS.length).refine((kinds) => new Set(kinds).size === kinds.length, {
     message: "a purpose lists each kind once"
-  })
+  }),
+  /**
+   * How this purpose is routed — RESERVED, validated, not acted on (B236).
+   *
+   * Optional rather than defaulted, so that a manifest without it parses to
+   * a manifest without it. See {@link PurposeRouting} for why a key nothing
+   * reads is worth adding before launch, and {@link routingOf} for the one
+   * place "not stated" is answered.
+   */
+  routing: PurposeRouting.optional()
 }).strict();
 var MAX_PURPOSES = 32;
 var Manifest = z11.record(PurposeKey, Purpose).refine((manifest) => Object.keys(manifest).length > 0, {
@@ -2683,6 +2755,7 @@ export {
   ConsoleResize,
   ConsoleStdin,
   ConsoleStdout,
+  DEFAULT_ROUTING,
   DeliveredResult,
   ENCRYPTION_KEY_CONTEXT,
   ENDPOINTS,
@@ -2697,6 +2770,8 @@ export {
   GRANT_SIGNED_FIELDS,
   GeneratePayload,
   GrantRef,
+  HUB_FENCE,
+  HUB_FENCE_CLAUSES,
   HeartbeatRequest,
   HeartbeatResponse,
   JOB_KINDS,
@@ -2732,6 +2807,7 @@ export {
   PairStartResponse,
   PublicIdentity,
   Purpose,
+  PurposeRouting,
   REFUSAL_MESSAGES,
   REFUSAL_TEXT,
   RESERVED_PURPOSE,
@@ -2803,6 +2879,7 @@ export {
   provenanceFor,
   publicIdentityOf,
   resolveCost,
+  routingOf,
   seal,
   signGrant,
   signRequest,