@byollm/protocol 0.1.0-alpha.8 → 0.1.0-alpha.81

package/ABOUT-SHORT.md

@@ -0,0 +1,7 @@
+BYOLLM – Bring Your Own LLM – lets you use your own AI on websites you authorize. A small program installed on your machine lets you use your own models and subscriptions on any BYOLLM-integrated site, including new models the moment you get access – no site updates required. BYOLLM Cloud connects sites to your devices with end-to-end encryption, so no one, including us, can see your data.
+
+<!-- lede ends here. Surfaces with room show the tail below; the welcome screen shows the lede only. -->
+
+Sites can charge you less because you bring your own – see why that matters →. Teams can optionally share the free or metered services on their devices with people they name. Personal subscriptions are never shared.
+
+**Learn more →**

package/ABOUT.md

@@ -0,0 +1,60 @@
+# About BYOLLM
+
+**What BYOLLM is**
+
+BYOLLM lets you use your own AI on websites. You install one small program on
+your computer. Then, websites that support BYOLLM can use the AI you already
+have — a free model running on your machine, or an AI service you already pay
+for — instead of the website paying for AI and passing the cost to you.
+
+**Why it matters**
+
+For you:
+
+- Your favorite model, everywhere you go.
+- New models the moment you get them – not when a site gets around to adding
+  them.
+- Encrypted end-to-end. Your prompts go to your own device; byollm.cloud can't
+  read them.
+- Sites never learn which model you use, and your subscriptions are never
+  shared.
+- Pay less. Sites that don't pay for AI can charge you less – or nothing.
+
+For sites and developers:
+
+- Zero AI bills. Your users bring their own compute.
+- No floating money – you don't pay LLM bills up front and hope to collect
+  later, and you never ask people to prepay just to try you.
+- Free trials that cost you nothing to offer.
+- Ship the AI features you kept private for fear of the API bill.
+- One small integration. Your users choose the models.
+
+**Your device**
+
+The `byollm` program runs on your computer. It knows which AI services you have
+set up: free open-source models on your machine, metered services you pay per
+use, or your own subscriptions like Claude Pro/Max. When a website you have
+enabled sends work, your device runs it with the service you chose. Your
+prompts are encrypted end-to-end to your own device. byollm.cloud passes them
+along and cannot read them.
+
+**Sites**
+
+A website that wants to use BYOLLM says what it needs — "writing help," "chat,"
+and so on. When you connect the site, you pick which of your services answers
+each one. The site never learns which model you use. You can turn a site off at
+any time, and it stops getting your work.
+
+**Teams (optional)**
+
+A team lets you share what runs on your devices with people you name — the free
+open-source models on your machine, or a metered service with a spending limit
+you set. Your subscription accounts (like Claude Pro/Max) are never shared with
+anyone. That is a rule, not a setting.
+
+**byollm.cloud (or your own relay)**
+
+Many sites, many devices, many people. byollm.cloud keeps track of who has
+allowed what and sends each job to the right device. It never sees your
+prompts. If you would rather run this part yourself, the relay is open source —
+you can run your own instead of using byollm.cloud.

package/README.md

@@ -1,5 +1,5 @@
 > [!WARNING]
-> **Alpha (`0.1.0-alpha.8`) — under active development. Don't use this yet.**
+> **Alpha (`0.1.0-alpha.81`) — under active development. Don't use this yet.**
 >
 > Install it deliberately: `npm install @byollm/protocol@alpha`.
 >
@@ -11,12 +11,114 @@
 > 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.
+> 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
+> move together: a mixed pair refuses on both sides, because both ends parse
+> `.strict()`.
+>
+> What moved, all of it reconciling the frozen `byollm_009` with its code:
+> `JobStub` gains `site` (the site's identity key id) and loses
+> `audienceAllow`; `ResultRequest` gains `leaseId`; `HeartbeatResponse` loses
+> `leases`, which nothing read; `WireErrorCode` gains `not-ready`,
+> `clock-skew` and `forbidden`, and `403` is `forbidden` rather than
+> `unauthorized`. `RESULT_PROVENANCE` is superseded by
+> `PROVENANCE_NAMES_DEVICE`. See `byollm_009` Amendment A.>
+> **`alpha.16` is a breaking wire change — daemons and relays again, not app
+> authors.** `app.enqueue(...)` and reading results are unchanged. All five
+> packages move together: both ends parse `.strict()`, so a mixed pair
+> refuses.
+>
+> What moved, all of it Tier 2 of `cloud_008`: `model`, `backendClass` and
+> `durationMs` come off `ResultRequest` and are sealed **inside** the result
+> envelope as `SealedOutcome = { outcome, ran }` — so a daemon can no longer
+> declare a model it did not sign, and a relay carries neither.
+> `HeartbeatResponse` loses `leases` (nothing read it) and now reports real
+> cancellations instead of an empty list. `WireErrorCode` gains `forbidden`
+> for 403, leaving `unauthorized` at exactly 401. The relay gained a
+> site-plane `cancel` endpoint, honours `stub.deadlineAt`, honours
+> `stub.audience`, and remembers a refusal.>
+> **`alpha.17` is additive** — no wire change. It exports `ReleaseReason`,
+> which `RoutingStore.releaseLeases` names and the package did not export, so
+> the interface was unimplementable outside this repo.>
+> **`alpha.18` is a breaking wire change — daemons and relays, not app
+> authors.** `app.enqueue(...)` and reading results are unchanged. All five
+> packages move together.
+>
+> The **bearer token is gone**: off `PairPollResponse`, off the runner row,
+> off the daemon's pairings file, out of the adapter's schema. It was minted,
+> hashed and stored on two disks and never sent, looked up or compared —
+> `REQUESTS_SIGNED_NOT_BEARER` was enforced by signatures the whole time. If
+> you run the Supabase adapter, apply
+> `20260819000000_drop_runner_token.sql`; `byollm_approve_pairing` now takes
+> one argument. A pairings file written by an older daemon still loads.
+>
+> `model`, `backendClass` and `durationMs` moved **inside** the sealed result
+> (`SealedOutcome = { outcome, ran }`), so a daemon cannot declare a model it
+> did not sign and a relay carries none of them. Writing a `RoutingStore`?
+> `releaseLeases` takes an optional `reason` and `complete` requires
+> `leaseId`, and **an implementation that ignores either still typechecks** —
+> run the store contract tests.>
+> **`alpha.19` is additive on the wire and a behaviour change in every
+> store.** `ResultResponse` gains an optional `duplicate`. Nothing is removed,
+> so an older daemon keeps working — but the *order* two rules are checked in
+> has changed, and a `RoutingStore` implementation must change with it.
+>
+> `complete` now checks **terminal state before holder**, scoped to the device
+> that finished the job: a replay from that device is answered `duplicate:
+> true` with a 2xx, and anyone else gets exactly the refusal they would get
+> for a job that is not terminal. Previously `RESULT_IDEMPOTENT` held only
+> because the lease is nulled on success, so the holder check tripped first —
+> deleting the idempotency branch failed no test. Run the store contract
+> tests; the compiler cannot see this.
 >
 > **`alpha.3` is a breaking change.** `BackendDescriptor.account` is gone —
 > read `cost` (`free` / `metered` / `subscription`) instead. Four new MUSTs
 > come with it; see `byollm_007`.
 
+<!-- release-note 0.1.0-alpha.21 -->
+> [!NOTE]
+> **`0.1.0-alpha.20` is not a complete release — do not pin it.** Four
+> 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.21` 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
+> ordering without the column it stores the grant in.
+
+<!-- release-note 0.1.0-alpha.40 -->
+**`byollm install` — stop keeping a terminal open.** The daemon can now run
+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
+right now, including the state that matters most: installed but not running,
+which looks fine from an app's dashboard and serves nothing.
+
+If you are running via `npx`, install properly first (`npm install -g
+byollm@alpha`) — `install` refuses to supervise a copy in npx's cache, because
+npm deletes that directory and the service would fail at some later boot.
+
+<!-- release-note 0.1.0-alpha.41 -->
+**`onNoRunner` takes a string.** Your fallback answer is your own value, not
+wire data, and handing back a whole result record for it was ceremony — the
+README's own example got the shape wrong, which is how this was found.
+
+```ts
+const { outcome, fallback } = await job.result({
+  onNoRunner: () => runOnHostedModel(transcript),
+});
+```
+
+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 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.
+
 # `@byollm/protocol`
 
 The BYOLLM wire contract: TypeScript types, zod schemas, and the pure rules
@@ -64,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",