@byollm/protocol 0.1.0-alpha.43 → 0.1.0-alpha.44

package/README.md

@@ -1,5 +1,5 @@
 > [!WARNING]
-> **Alpha (`0.1.0-alpha.43`) — under active development. Don't use this yet.**
+> **Alpha (`0.1.0-alpha.44`) — under active development. Don't use this yet.**
 >
 > Install it deliberately: `npm install @byollm/protocol@alpha`.
 >
@@ -83,7 +83,7 @@
 > packages published and `@byollm/server` did not: a Sigstore
 > transparency-log 409 on its provenance attestation. The workflow's
 > "already published" guard correctly refuses to resume a partial publish,
-> so `0.1.0-alpha.43` is that release, whole.
+> so `0.1.0-alpha.44` is that release, whole.
 >
 > If you run the Supabase adapter, `alpha.21` needs
 > `20260819010000_completed_by_lease_id.sql`: alpha.19 shipped §3.6's
@@ -91,7 +91,7 @@
 
 <!-- release-note 0.1.0-alpha.40 -->
 **`byollm install` — stop keeping a terminal open.** The daemon can now run
-under your machine's own supervisor and restart itself if it stops: a launchd
+under your computer's own supervisor and restart itself if it stops: a launchd
 agent on macOS, a `systemd --user` unit on Linux, a logon task on Windows. All
 user-level — no root, no system directories, and `byollm uninstall` takes it
 away. `byollm status` gained a line saying whether it is actually supervised
@@ -115,7 +115,7 @@ const { outcome, fallback } = await job.result({
 
 Whatever you return, `result()` labels it `fallback: true` — the stamp is
 applied by the wait, not taken from you, so an answer that did not run on
-somebody's machine cannot be reported as though it did (`FALLBACK_LABELED`).
+somebody's device cannot be reported as though it did (`FALLBACK_LABELED`).
 Both delivery channels do it, polling and Supabase Realtime. Records still
 work; they just get labelled too.
 
@@ -166,10 +166,10 @@ job's owner.
 import { matchAudience } from "@byollm/protocol";
 
 matchAudience(
-  { owner: "alice", audience: "named" },
+  { owner: "alice", audience: "team" },
   {
     owner: "bob",
-    offerScope: "named",
+    offerScope: "team",
     account: "open",
     // The daemon's OWN allowlist decides — never the server's assertion.
     locallyAllows: (owner) => owner === "alice",

package/dist/index.d.ts

@@ -157,45 +157,98 @@ declare function backendDescriptor(id: BackendId): BackendDescriptor;
  */
 declare function isLocalHost(hostname: string): boolean;
 /**
- * The cost class of a configured backend instance.
+ * Is this model name a hosted one billed by its vendor?
+ *
+ * Ollama serves cloud models through the same local endpoint as local ones,
+ * so the address says "free" about a model somebody is being charged for. The
+ * only thing that distinguishes them is the name, and the distinguishing part
+ * is the **tag** — everything after the last colon.
+ *
+ * End-anchored on the tag, which is what makes it decidable rather than a
+ * guess about substrings:
+ *
+ * - `glm-5.2:cloud` → cloud
+ * - `deepseek-v4-flash:0731-cloud` → cloud
+ * - `x:cloudless` → not cloud, the tag ends in "less"
+ * - `cloudmodel:7b` → not cloud, the tag is "7b"
+ * - `llama3.2` → not cloud, there is no tag at all
+ *
+ * An oddball like `:xcloud` classifies as cloud, and that is the **only
+ * permitted failure direction**: calling a free model metered narrows what an
+ * owner may share and costs nobody money, while the reverse hands somebody
+ * else's bill to a stranger.
+ */
+declare function isCloudTaggedModel(model: string): boolean;
+/**
+ * The cost class of a configured service.
  *
  * For every named provider this is whatever the registry says, full stop
  * ({@link MUSTS.COST_NOT_CONFIGURABLE}). For the generic `openai-http` entry
  * it is inferred from the base URL, and a base URL that cannot be parsed is
  * treated as `metered` — the expensive side, because guessing "free" wrong
  * costs the owner money.
+ *
+ * The model has the last word in one direction only. A local address with a
+ * cloud-tagged model is `metered`: Ollama proxies hosted models through
+ * `127.0.0.1`, so the endpoint is local and the bill is not. Read from the
+ * **configured value**, never from what the server lists — the owner's config
+ * is the thing they chose, and a server's catalogue is not theirs to be
+ * classified by.
  */
-declare function resolveCost(id: BackendId, baseUrl: string | undefined): BackendCost;
+declare function resolveCost(id: BackendId, baseUrl: string | undefined, model?: string): BackendCost;
 
 /**
  * Who may run a job, declared by the app that enqueued it.
  *
- * - `self` — only the job owner's own daemon.
- * - `named` — a daemon whose owner has explicitly allowed this (server, user)
- *   pair in their *local* allowlist (byollm_001 Rev 1 §B).
- * - `public` — any daemon offering `public` compute.
+ * - `private` — only the job owner's own devices.
+ * - `team` — a device whose owner has this person on their roster.
+ * - `public` — any device offering `public` compute.
+ *
+ * **One vocabulary, ruled 2026-08-24.** These were `self | named | public`
+ * while {@link OfferScope} became `private | team | public`, which would have
+ * left every seam where the two meet speaking two languages for one idea, and
+ * every doc explaining "self versus private" for ever. They are still
+ * independent axes — a job says who may run it, a service says who it will run
+ * for — and a job runs only where both agree
+ * ({@link MUSTS.AUDIENCE_BOTH_SIDES}). Sharing the words costs nothing and
+ * saves a mapping layer nobody would have enjoyed maintaining.
  */
 declare const Audience: z.ZodEnum<{
-    self: "self";
-    named: "named";
+    private: "private";
+    team: "team";
     public: "public";
 }>;
 type Audience = z.infer<typeof Audience>;
 /**
- * What a daemon backend is willing to run, declared by the machine's owner.
- * Same three values as {@link Audience}, but the two are independent axes —
- * a job runs only where both agree ({@link MUSTS.AUDIENCE_BOTH_SIDES}).
+ * What a device's owner is willing to run for other people, per service.
+ *
+ * - `private` — the owner's own work only.
+ * - `team` — the owner's roster. Membership is **central**, not per-person:
+ *   the device follows the roster rather than holding its own copy of who is
+ *   in it (byollm_016, 2026-08-24).
+ * - `public` — any job, from anyone. This is the community posture the daemon
+ *   has always had (`byollm offer <service> public`), bounded by community
+ *   budgets. byollm_016 parks it as a **hosted-product** surface — the cloud
+ *   dashboard does not offer it — which is not the same as removing it from
+ *   the daemon, and the CLI still accepts it.
+ *
+ * Deliberately *not* the same words as {@link Audience}, which they used to
+ * share. They are independent axes — a job says who may run it, a service says
+ * who it will run for — and identical spellings made that read as one concept
+ * with two homes. A job runs only where both agree
+ * ({@link MUSTS.AUDIENCE_BOTH_SIDES}); {@link matches} is the one place the
+ * correspondence lives.
  */
 declare const OfferScope: z.ZodEnum<{
-    self: "self";
-    named: "named";
+    private: "private";
+    team: "team";
     public: "public";
 }>;
 type OfferScope = z.infer<typeof OfferScope>;
 /** All audience values, in widening order. */
-declare const AUDIENCES: readonly ("self" | "named" | "public")[];
+declare const AUDIENCES: readonly ("private" | "team" | "public")[];
 /** All offer scopes, in widening order. */
-declare const OFFER_SCOPES: readonly ("self" | "named" | "public")[];
+declare const OFFER_SCOPES: readonly ("private" | "team" | "public")[];
 /**
  * Why a job was refused. Distinct codes because byollm_002 requires that
  * different truths never share a message — "no matching work" and "refused on
@@ -236,7 +289,7 @@ interface SpendConsent {
  *
  * - `subscription` is locked to `self` regardless of config
  *   ({@link MUSTS.SUBSCRIPTION_SELF_LOCK}) — someone else's terms.
- * - `metered` narrows to `self` unless the owner has explicitly acknowledged
+ * - `metered` narrows to `private` unless the owner has explicitly acknowledged
  *   the spend ({@link MUSTS.METERED_DEFAULTS_SELF}) — their money.
  * - `free` passes through — their electricity.
  *
@@ -291,10 +344,10 @@ interface MatchDaemon {
  * @example
  * ```ts
  * const result = matchAudience(
- *   { owner: "alice", audience: "named" },
+ *   { owner: "alice", audience: "team" },
  *   {
  *     owner: "bob",
- *     offerScope: "named",
+ *     offerScope: "team",
  *     cost: "free",
  *     locallyAllows: (o) => o === "alice",
  *   },
@@ -505,8 +558,8 @@ declare const ClaimedJob: z.ZodObject<{
         system: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>]>;
     audience: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
     owner: z.ZodString;
@@ -527,8 +580,8 @@ type ClaimedJob = z.infer<typeof ClaimedJob>;
  */
 declare const ResultProvenance: z.ZodObject<{
     audience: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
     runnerId: z.ZodString;
@@ -663,8 +716,8 @@ declare const DeliveredResult: z.ZodObject<{
     }, z.core.$strict>], "outcome">>;
     provenance: z.ZodOptional<z.ZodObject<{
         audience: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
         runnerId: z.ZodString;
@@ -742,8 +795,8 @@ declare const JobStub: z.ZodObject<{
     owner: z.ZodString;
     site: z.ZodString;
     audience: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
     sizeClass: z.ZodEnum<{
@@ -766,8 +819,8 @@ declare const ClaimedStub: z.ZodObject<{
     owner: z.ZodString;
     site: z.ZodString;
     audience: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
     sizeClass: z.ZodEnum<{
@@ -1452,6 +1505,8 @@ declare const Capability: z.ZodObject<{
         "llm.generate": "llm.generate";
         "llm.chat": "llm.chat";
     }>;
+    service: z.ZodString;
+    isDefault: z.ZodBoolean;
     backendId: z.ZodEnum<{
         ollama: "ollama";
         mlx: "mlx";
@@ -1478,8 +1533,8 @@ declare const Capability: z.ZodObject<{
     }>;
     model: z.ZodString;
     offerScope: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
 }, z.core.$strict>;
@@ -1490,6 +1545,8 @@ declare const CapabilityMatrix: z.ZodArray<z.ZodObject<{
         "llm.generate": "llm.generate";
         "llm.chat": "llm.chat";
     }>;
+    service: z.ZodString;
+    isDefault: z.ZodBoolean;
     backendId: z.ZodEnum<{
         ollama: "ollama";
         mlx: "mlx";
@@ -1516,12 +1573,41 @@ declare const CapabilityMatrix: z.ZodArray<z.ZodObject<{
     }>;
     model: z.ZodString;
     offerScope: z.ZodEnum<{
-        self: "self";
-        named: "named";
+        private: "private";
+        team: "team";
         public: "public";
     }>;
 }, z.core.$strict>>;
 type CapabilityMatrix = z.infer<typeof CapabilityMatrix>;
+/**
+ * A kind this device could serve and deliberately does not — byollm_016.
+ *
+ * Two services answer one kind and the owner has not said which wins, so the
+ * kind is not advertised. That is correct and, unsaid, invisible: the owner
+ * adds a second service, jobs stop matching, and no surface explains it.
+ *
+ * It travels because the surfaces that must say so are not all on the device.
+ * The owner's card names the claimants; a teammate's card says only that the
+ * owner has a choice to make. Claimant **offer scopes** ride along so the hub
+ * can compute that difference without the device deciding who is asking —
+ * carry for computation, filter for display, the same shape the effective
+ * offer already uses.
+ */
+declare const WithheldKind: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "llm.generate": "llm.generate";
+        "llm.chat": "llm.chat";
+    }>;
+    claimants: z.ZodArray<z.ZodObject<{
+        service: z.ZodString;
+        offer: z.ZodEnum<{
+            private: "private";
+            team: "team";
+            public: "public";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type WithheldKind = z.infer<typeof WithheldKind>;
 /**
  * Pairing is a device-code exchange, not a pasted secret
  * ({@link MUSTS.PAIR_INTERACTIVE}). The daemon starts a pairing, shows the
@@ -1551,6 +1637,8 @@ declare const PairStartRequest: z.ZodObject<{
             "llm.generate": "llm.generate";
             "llm.chat": "llm.chat";
         }>;
+        service: z.ZodString;
+        isDefault: z.ZodBoolean;
         backendId: z.ZodEnum<{
             ollama: "ollama";
             mlx: "mlx";
@@ -1577,8 +1665,8 @@ declare const PairStartRequest: z.ZodObject<{
         }>;
         model: z.ZodString;
         offerScope: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
     }, z.core.$strict>>;
@@ -1638,6 +1726,8 @@ declare const PairRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "llm.generate": "llm.generate";
             "llm.chat": "llm.chat";
         }>;
+        service: z.ZodString;
+        isDefault: z.ZodBoolean;
         backendId: z.ZodEnum<{
             ollama: "ollama";
             mlx: "mlx";
@@ -1664,8 +1754,8 @@ declare const PairRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         model: z.ZodString;
         offerScope: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
     }, z.core.$strict>>;
@@ -1683,6 +1773,8 @@ declare const ClaimRequest: z.ZodObject<{
             "llm.generate": "llm.generate";
             "llm.chat": "llm.chat";
         }>;
+        service: z.ZodString;
+        isDefault: z.ZodBoolean;
         backendId: z.ZodEnum<{
             ollama: "ollama";
             mlx: "mlx";
@@ -1709,8 +1801,8 @@ declare const ClaimRequest: z.ZodObject<{
         }>;
         model: z.ZodString;
         offerScope: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
     }, z.core.$strict>>;
@@ -1727,8 +1819,8 @@ declare const ClaimResponse: z.ZodObject<{
         owner: z.ZodString;
         site: z.ZodString;
         audience: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
         sizeClass: z.ZodEnum<{
@@ -1757,6 +1849,8 @@ declare const HeartbeatRequest: z.ZodObject<{
             "llm.generate": "llm.generate";
             "llm.chat": "llm.chat";
         }>;
+        service: z.ZodString;
+        isDefault: z.ZodBoolean;
         backendId: z.ZodEnum<{
             ollama: "ollama";
             mlx: "mlx";
@@ -1783,11 +1877,25 @@ declare const HeartbeatRequest: z.ZodObject<{
         }>;
         model: z.ZodString;
         offerScope: z.ZodEnum<{
-            self: "self";
-            named: "named";
+            private: "private";
+            team: "team";
             public: "public";
         }>;
     }, z.core.$strict>>;
+    withheld: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "llm.generate": "llm.generate";
+            "llm.chat": "llm.chat";
+        }>;
+        claimants: z.ZodArray<z.ZodObject<{
+            service: z.ZodString;
+            offer: z.ZodEnum<{
+                private: "private";
+                team: "team";
+                public: "public";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     activeLeases: z.ZodArray<z.ZodObject<{
         jobId: z.ZodString;
         leaseId: z.ZodString;
@@ -1957,4 +2065,4 @@ declare const FetchResponse: z.ZodObject<{
 }, z.core.$strict>;
 type FetchResponse = z.infer<typeof FetchResponse>;
 
-export { AUDIENCES, Audience, BACKENDS, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DeliveredResult, ENCRYPTION_KEY_CONTEXT, ENDPOINTS, ENVELOPE_MAX_AGE_MS, ERROR_STATUS, type Endpoint, type EnvelopeContext, EnvelopeDirection, type EnvelopeFailure, FetchRequest, FetchResponse, GeneratePayload, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, type OpenResult, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, REFUSAL_MESSAGES, RETIREMENT_WINDOW_MS, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedEnvelope, SealedOutcome, type SignatureFailure, SizeClass, type SpendConsent, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, type VersionRefusal, WireError, WireErrorCode, backendDescriptor, canTransition, canonicalRequest, checkProtocolVersion, cryptoReady, declaredVersion, effectiveOfferScope, fingerprint, generateKeys, isBackendId, isJobKind, isLocalHost, isTerminal, keyId, kindsOf, matchAudience, mustsVerifiedBy, open, payloadTextLength, provenanceFor, publicIdentityOf, resolveCost, seal, signRequest, signSiteRequest, signSuccession, signWith, sizeClassCeiling, sizeClassOf, successionStatement, verifyLink, verifyPublicIdentity, verifyRequest, verifySiteRequest, verifyWith, walkSuccession };
+export { AUDIENCES, Audience, BACKENDS, BACKEND_IDS, BackendClass, BackendCost, type BackendDescriptor, type BackendId, BackendIdSchema, Capability, CapabilityMatrix, ChatMessage, ChatPayload, ClaimRequest, ClaimResponse, ClaimedJob, ClaimedStub, DeliveredResult, ENCRYPTION_KEY_CONTEXT, ENDPOINTS, ENVELOPE_MAX_AGE_MS, ERROR_STATUS, type Endpoint, type EnvelopeContext, EnvelopeDirection, type EnvelopeFailure, FetchRequest, FetchResponse, GeneratePayload, HeartbeatRequest, HeartbeatResponse, JOB_KINDS, JobKind, JobOutcome, JobPayload, JobResultCanceled, JobResultError, JobResultOk, JobState, JobStub, KindedPayload, Lease, MAX_CLOCK_SKEW_MS, MAX_SUCCESSION_CHAIN, MIN_PROTOCOL_VERSION, MUSTS, MUST_IDS, type MatchDaemon, type MatchJob, MatchRefusal, type MatchResult, type Must, type MustEnforcer, type MustId, type MustVerification, type MustVerifiedBy, OFFER_SCOPES, OfferScope, type OpenResult, PAYLOAD_LIMITS, PROTOCOL_PREFIX, PROTOCOL_VERSION, PairPollRequest, PairPollResponse, PairRequest, PairStartRequest, PairStartResponse, type PayloadFor, PublicIdentity, REFUSAL_MESSAGES, RETIREMENT_WINDOW_MS, ReleaseRequest, ReleaseResponse, RequestSignature, ResultDisposition, ResultProvenance, ResultRequest, ResultResponse, RunMetadata, SIZE_CLASS_LIMITS, SUCCESSION_CONTEXT, SUPPORTED_PROTOCOL_VERSIONS, SealedEnvelope, SealedOutcome, type SignatureFailure, SizeClass, type SpendConsent, StoredKeys, Succession, type SuccessionFailure, type SuccessionWalk, TERMINAL_STATES, type VersionRefusal, WireError, WireErrorCode, WithheldKind, backendDescriptor, canTransition, canonicalRequest, checkProtocolVersion, cryptoReady, declaredVersion, effectiveOfferScope, fingerprint, generateKeys, isBackendId, isCloudTaggedModel, isJobKind, isLocalHost, isTerminal, keyId, kindsOf, matchAudience, mustsVerifiedBy, open, payloadTextLength, provenanceFor, publicIdentityOf, resolveCost, seal, signRequest, signSiteRequest, signSuccession, signWith, sizeClassCeiling, sizeClassOf, successionStatement, verifyLink, verifyPublicIdentity, verifyRequest, verifySiteRequest, verifyWith, walkSuccession };

package/dist/index.js

@@ -189,9 +189,13 @@ function isLocalHost(hostname) {
   if (host.startsWith("192.168.")) return true;
   return /^172\.(1[6-9]|2\d|3[01])\./.test(host);
 }
-function resolveCost(id, baseUrl) {
+function isCloudTaggedModel(model) {
+  return /:[^:]*cloud$/.test(model);
+}
+function resolveCost(id, baseUrl, model) {
   const declared = BACKENDS[id].cost;
   if (declared !== null) return declared;
+  if (model !== void 0 && isCloudTaggedModel(model)) return "metered";
   if (baseUrl === void 0) return "metered";
   try {
     return isLocalHost(new URL(baseUrl).hostname) ? "free" : "metered";
@@ -201,8 +205,8 @@ function resolveCost(id, baseUrl) {
 }
 
 // src/audience.ts
-var Audience = z2.enum(["self", "named", "public"]);
-var OfferScope = z2.enum(["self", "named", "public"]);
+var Audience = z2.enum(["private", "team", "public"]);
+var OfferScope = z2.enum(["private", "team", "public"]);
 var AUDIENCES = Object.freeze(Audience.options);
 var OFFER_SCOPES = Object.freeze(OfferScope.options);
 var MatchRefusal = z2.enum([
@@ -226,16 +230,16 @@ var MatchRefusal = z2.enum([
 var ALLOWED = Object.freeze({ ok: true });
 var refuse = (refusal) => Object.freeze({ ok: false, refusal });
 function effectiveOfferScope(configured, cost, spend) {
-  if (cost === "subscription") return "self";
-  if (cost === "metered" && spend?.acknowledged !== true) return "self";
+  if (cost === "subscription") return "private";
+  if (cost === "metered" && spend?.acknowledged !== true) return "private";
   return configured;
 }
 function matchAudience(job, daemon) {
   const sameOwner = job.owner === daemon.owner;
-  if (job.audience === "self" && !sameOwner) {
+  if (job.audience === "private" && !sameOwner) {
     return refuse("audience-self-other-owner");
   }
-  if (job.audience === "named" && !sameOwner && job.audienceAllow !== void 0 && !job.audienceAllow.includes(daemon.owner)) {
+  if (job.audience === "team" && !sameOwner && job.audienceAllow !== void 0 && !job.audienceAllow.includes(daemon.owner)) {
     return refuse("not-in-server-allowlist");
   }
   const scope = effectiveOfferScope(
@@ -258,19 +262,19 @@ function matchAudience(job, daemon) {
     }
   }
   switch (scope) {
-    case "self":
+    case "private":
       return refuse("offer-scope-too-narrow");
-    case "named":
+    case "team":
       return daemon.locallyAllows(job.owner) ? ALLOWED : refuse("not-locally-allowed");
     case "public":
       return ALLOWED;
   }
 }
 var REFUSAL_MESSAGES = Object.freeze({
-  "no-capability": "no backend on this machine is configured and healthy for that job kind",
-  "audience-self-other-owner": "the job is private to its owner and this machine is paired to someone else",
-  "not-locally-allowed": "the job's owner is not on this machine's allowlist (byollm allow <server> <user>)",
-  "not-in-server-allowlist": "the app restricted this job to named runners and this machine is not one of them",
+  "no-capability": "no backend on this device is configured and healthy for that job kind",
+  "audience-self-other-owner": "the job is private to its owner and this device is paired to someone else",
+  "not-locally-allowed": "the job's owner is not on this device's allowlist (byollm allow <server> <user>)",
+  "not-in-server-allowlist": "the app restricted this job to named runners and this device is not one of them",
   "offer-scope-too-narrow": "this backend is offered to its owner only (byollm offer <backend> named|public to widen)",
   "subscription-self-lock": "subscription-backed models run their owner's work only \u2014 this is a protocol rule, not a setting",
   "metered-no-spend-consent": "this backend bills its owner per token, and they have not agreed to spend it on other people's work",
@@ -431,7 +435,7 @@ function provenanceFor(input) {
     runnerOwner: input.runnerOwner,
     backendClass: input.backendClass,
     model: input.model,
-    untrusted: input.audience !== "self"
+    untrusted: input.audience !== "private"
   };
 }
 var RunMetadata = z4.object({
@@ -1388,12 +1392,36 @@ var ENDPOINTS = Object.freeze([
 ]);
 var Capability = z9.object({
   kind: JobKind,
+  /**
+   * The owner's name for the service answering this kind — byollm_016.
+   *
+   * A device advertises *which* of its services serves a kind, not merely
+   * that something does. Phase B lets a job select by this name; until then
+   * it is what a device page shows and what a default is chosen between.
+   */
+  service: z9.string().min(1),
+  /**
+   * Whether this row is the default for its kind.
+   *
+   * Stated rather than inferred from being the only row, which is true in
+   * Phase A and stops being true the moment Phase B advertises every
+   * selectable service per kind. A consumer that learned "default means
+   * alone" would have to unlearn it, and the ones that did not would be
+   * quietly wrong. One field now, no second shape later.
+   */
+  isDefault: z9.boolean(),
   backendId: BackendIdSchema,
   backendClass: BackendClass,
   model: z9.string().min(1),
   offerScope: OfferScope
 }).strict();
 var CapabilityMatrix = z9.array(Capability);
+var WithheldKind = z9.object({
+  kind: JobKind,
+  claimants: z9.array(
+    z9.object({ service: z9.string().min(1), offer: OfferScope }).strict()
+  ).min(2)
+}).strict();
 var PairStartRequest = z9.object({
   protocolVersion: z9.literal(PROTOCOL_VERSION),
   action: z9.literal("start"),
@@ -1504,6 +1532,14 @@ var HeartbeatRequest = z9.object({
   runnerId: z9.string().min(1),
   daemonVersion: z9.string().min(1),
   capabilities: CapabilityMatrix,
+  /**
+   * Kinds this device is withholding, and why it can be said.
+   *
+   * Optional so a daemon that has nothing withheld sends nothing, and so an
+   * older daemon against a newer hub is simply a device with no withheld
+   * kinds rather than a parse failure.
+   */
+  withheld: z9.array(WithheldKind).default([]),
   /**
    * Leases this daemon believes it holds; the server renews exactly these.
    *
@@ -1976,6 +2012,7 @@ export {
   TERMINAL_STATES,
   WireError,
   WireErrorCode,
+  WithheldKind,
   backendDescriptor,
   canTransition,
   canonicalRequest,
@@ -1986,6 +2023,7 @@ export {
   fingerprint,
   generateKeys,
   isBackendId,
+  isCloudTaggedModel,
   isJobKind,
   isLocalHost,
   isTerminal,