@vibes.diy/prompts 14.3.161 → 14.3.163

package/llms/backend.md

@@ -100,11 +100,13 @@ visitor can invoke must not run owner-privileged.
 
 ### Taking on the authorization job: `config.fetch.unfilteredReads`
 
-Because the `fetch` lane runs as the calling user, a `fetch` handler by default
-reads nothing for a caller with no session, and cannot read an access-fn-bound
-database without an opt-in. Some routes legitimately need to: a calendar feed at
-`GET /_api/faves.ics?t=<token>` is fetched by a calendar app that carries no
-login, and the docs it serves are private to one user. For those, `backend.js`
+Because the `fetch` lane runs as the calling user, a signed-in caller's
+`fetch` handler reads exactly what that caller could read from their own page —
+an access-fn-bound database comes back filtered to their channels, like
+`onChange` reads for its triggering user. A caller with no session reads the
+databases the opt-in below names. Some routes need exactly that: a calendar
+feed at `GET /_api/faves.ics?t=<token>` is fetched by a calendar app that carries
+no login, and the docs it serves are private to one user. For those, `backend.js`
 can opt in — per database, `fetch` lane only:
 
 ```js
@@ -155,8 +157,10 @@ const res = await ctx.fetch("https://api.example.com/x", { headers }); // outbou
 await ctx.notify({ toHandle: "alice", body: "Your turn", dedupeKey: "game-7-turn-3", path: "#game-7" }); // one participant; `path` optional; throws on failure
 ctx.log("info", "tick finished", { written: 3 }); // diagnostics — read back with: vibes-diy app logs owner/slug
 const gh = await ctx.github.fetch("/repos/acme/site/issues", { method: "POST", body: { title: "Filed from the vibe" } }); // connected GitHub repo
+const routes = await ctx.github.routes(); // [{ repo, accountLogin, binderHandle, installationId }] — who connected which repo; no GitHub call
 ```
 
+- An app that works with somebody's GitHub repo loads the `github` skill: the connect link, `config.github`, `ctx.github.routes()`, deliveries and a complete example.
 - `ctx.github.fetch(path, init)` calls the GitHub REST API **as the GitHub App
   installation the owner connected to this vibe**. It is the only GitHub surface
   a backend has: `path` is a GitHub API path rooted at `/` (`/repos/…`, plus
@@ -182,6 +186,58 @@ const gh = await ctx.github.fetch("/repos/acme/site/issues", { method: "POST", b
   `permission_not_granted` — the installation lacks that permission, or
   `upstream_error`); branch on `err.reason`, and tell the user which one it was.
 
+- **Connecting a repository is a link, not a call.** The page links to the
+  PLATFORM's `/github/install?vibe=<owner>/<slug>` with an **absolute** URL in a
+  **new tab** — never a root-relative `/github/install` (the app is served from
+  its own host, where that path is not the platform's) and never `fetch` (the
+  next stop is github.com, and the consent page refuses to load in a frame).
+  `buildGithubInstallUrl()` from `use-vibes` returns that absolute address for
+  the running vibe — on `https://vibes.diy`, or on the PR preview the vibe runs
+  under — so the page never writes the host or its own `<owner>/<slug>`:
+
+  ```jsx
+  import { buildGithubInstallUrl } from "use-vibes";
+
+  <a href={buildGithubInstallUrl()} target="_blank" rel="noopener">
+    Connect a GitHub repository
+  </a>;
+  ```
+
+  The owner goes straight to GitHub to pick repositories. By default only the
+  owner may connect one; to let **visitors** connect their own repositories (a
+  PR reviewer, a repo dashboard anyone can use), declare it in `backend.js`:
+
+  ```js
+  export const config = {
+    github: { bind: "anyone", why: "Reviews the pull requests you open and leaves comments on them." },
+  };
+  ```
+
+  `bind` is `"owner"` (the default) or `"anyone"`; with `"anyone"`, `why` is
+  required — one static sentence, 280 characters at most — because the platform
+  shows it on the consent page a visitor reads before going to GitHub. Write it
+  inline as `github: { … }` — a shorthand `{ github }` or a method is refused —
+  and a malformed `config.github` refuses the push. A visitor always passes
+  through that consent page: an install that skips it connects nothing. Repositories a visitor connects are
+  bound to this vibe like the owner's, so `ctx.github.fetch` and the
+  `/_api/github-webhook` deliveries cover them too; a repository someone else
+  already connected stays theirs.
+- `ctx.github.routes()` lists the repos connected to THIS vibe and who
+  connected each one, as
+  `[{ repo, accountLogin, binderHandle, installationId }]`: `repo` is
+  `owner/name` (lowercase, as stored), `accountLogin` is the GitHub account the
+  App is installed on, `binderHandle` is the vibes.diy handle of the person who
+  connected it (`undefined` when that account has no handle), and
+  `installationId` is a number. It reads the platform's own records and makes
+  no GitHub call, so it is cheap enough to run on every request. An unconnected
+  vibe gets `[]`, never an error. This is how ONE vibe serves many people's
+  repos: key per-repo settings by `repo`, and let only the person whose handle
+  is `binderHandle` change them (compare it to `ctx.userInfo`).
+  `/installation/repositories` answers the same question from GitHub: with
+  repos from several installations it returns
+  `{ total_count, repositories }` holding only the repos connected to this
+  vibe, and ignores `per_page`/`page`.
+
 - `{ db }` names the Fireproof database (same names `App.jsx` uses with
   `useFireproof`). It is **required** — except inside `onChange`, where the
   database that triggered the event is the default.
@@ -252,14 +308,15 @@ const gh = await ctx.github.fetch("/repos/acme/site/issues", { method: "POST", b
   array operation (`.filter()`, `.map()`, spread) returns a plain array with no
   `next`. On the last page the property is absent, not undefined — `"next" in
   page` is `false`.
-- Both reads are read-gated as the acting identity, through the same gate:
-  anonymous `fetch` callers are denied, and in `fetch` a database bound to an
-  access function cannot be read at all (keep the fetch lane's read databases
-  unbound, or declare `config.fetch.unfilteredReads`). In `onChange` a bound
-  database reads **filtered to the triggering user's channels** — the same
-  per-reader filter the client's own reads use, so the handler sees exactly
-  what the user who triggered it could see: neighbouring docs for dedup, rank
-  and "don't repeat what's already there" checks, and nothing privileged. In
+- Both reads are read-gated as the acting identity, through the same gate. In
+  `onChange` and in a signed-in `fetch` a bound database reads **filtered to the
+  acting user's channels** — the same per-reader filter the client's own reads
+  use, so the handler sees exactly what that user could see: the triggering
+  user's neighbouring docs for dedup, rank and "don't repeat what's already
+  there" checks, or the calling user's own docs for a page's `apiFetch` route,
+  and nothing privileged. A doc outside those channels reads as `null` from
+  `get`, the same as one that isn't there. A `fetch` caller with no session
+  reads the databases `config.fetch.unfilteredReads` names. In
   `scheduled` (admin mode) reads are
   **unfiltered** — access-fn-bound databases return every doc, across all users
   and channels. Made for `scheduled` sweeps: read, decide, then `put`/`delete`.
@@ -707,9 +764,23 @@ stays the signal for a bug to fix.
 A connected GitHub repository's deliveries arrive here too, as a `POST` to
 `/_api/github-webhook`, already verified by the platform, with the event name
 in `x-vibes-github-event`, GitHub's delivery id in `x-vibes-github-delivery`
-(key writes by it — a delivery can arrive twice), and an untrusted third-party
-body; a `4xx` ends the delivery, and a throw marks it failed (GitHub does not
-retry it).
+(key writes by it — a delivery can arrive twice), the handle of the person
+who connected that repo in `x-vibes-github-binder` (left off when they have no
+handle), and an untrusted third-party body; a `4xx` ends the delivery, and a
+throw marks it failed (GitHub does not retry it). `x-vibes-github-binder` is
+how a vibe shared by many people knows whose repo an event belongs to, and so
+whose settings apply. The platform sets it, the same as
+`x-vibes-github-event`, so you can trust it: any `x-vibes-*` header a caller
+sends is deleted before the platform adds its own. It matches the
+`binderHandle` that `ctx.github.routes()` returns for that repo.
+
+A delivery **runs as the person who connected the repo**: `ctx.userInfo` is
+them, `ctx.db` writes pass `access.js` as them (`user.backend === "fetch"`,
+`user.userHandle` equal to `x-vibes-github-binder`), reads see their channels,
+and `ctx.callAI` runs on their credits. So a review bot keeps each person's
+records in that person's channel, and every repo's activity is paid for by
+the person who connected it. The consent page tells them so before they
+connect.
 
 `/_api` opens to every caller once the app is published. Before its first
 publish, and after the owner unpublishes it, the routes answer the app's own
@@ -774,21 +845,43 @@ where the first stopped.
 
 ### `backend.js`
 ```js
-export const config = { fetch: { unfilteredReads: ["rsvps"] } };
+export const config = {
+  fetch: {
+    unfilteredReads: {
+      dbs: ["rsvps"],
+      why: "/admin/normalize serves only the app owner, checked against ctx.appInfo.ownerHandle before it reads",
+    },
+  },
+};
+
+const STATE_ID = "state:normalize";
+
+function json(data, status) {
+  return new Response(JSON.stringify(data), { status: status ?? 200, headers: { "content-type": "application/json" } });
+}
 
 export async function fetch(request, ctx) {
   const url = new URL(request.url);
-  if (url.pathname !== "/admin/normalize") return new Response("not found", { status: 404 });
-  if (ctx.user?.userHandle !== ctx.ownerHandle) return new Response("forbidden", { status: 403 });
-  const page = await ctx.db.query("kind", { key: "rsvp", limit: 100, db: "rsvps" });
-  for (const doc of page) {
-    if (typeof doc.name === "string" && doc.name !== doc.name.trim()) {
-      await ctx.db.put({ ...doc, name: doc.name.trim() }, { db: "rsvps" });
+  if (url.pathname !== "/admin/normalize") return json({ ok: false, reason: "not found" }, 404);
+  if (ctx.userInfo?.userHandle !== ctx.appInfo.ownerHandle) return json({ ok: false, reason: "owner only" }, 403);
+  // Progress lives in one state document read by id, so a second run picks up where the first stopped.
+  const state = await ctx.db.get(STATE_ID, { db: "rsvps" });
+  if (state?.done === true) return json({ ok: true, fixed: 0 });
+  let after = state?.after ?? undefined;
+  let fixed = 0;
+  do {
+    const page = await ctx.db.query({ db: "rsvps", field: "kind", key: "rsvp", limit: 100, after });
+    for (const doc of page) {
+      if (typeof doc.name === "string" && doc.name !== doc.name.trim()) {
+        await ctx.db.put({ ...doc, name: doc.name.trim() }, { db: "rsvps", id: doc._id });
+        fixed += 1;
+      }
     }
-  }
-  return new Response(JSON.stringify({ ok: true, more: page.next ?? null }), {
-    headers: { "content-type": "application/json" },
-  });
+    after = page.next; // absent on the last page
+    await ctx.db.put({ kind: "normalizeState", after: after ?? null, done: after === undefined }, { db: "rsvps", id: STATE_ID });
+  } while (after);
+  ctx.log("info", "normalized rsvp names", { fixed });
+  return json({ ok: true, fixed });
 }
 ```
 
@@ -926,6 +1019,11 @@ export async function onChange(event, ctx) {
 }
 ```
 
+`fetch` reads the same way for a signed-in caller: when the page calls
+`apiFetch`, the handler runs as the visitor and a bound database returns the
+docs in their channels — the same set their page already shows them — so a
+route can sum, rank or reshape the caller's own docs server-side.
+
 ### Jobs that finish even when a run crashes
 
 **A job that survives a crash carries its status, its claim and its lease on the document.**

package/llms/connections.js

@@ -1,7 +1,7 @@
 export const connectionsConfig = {
     name: "connections",
     label: "Connections",
-    description: "Connect a visitor's own GitHub, Threads or Instagram account with one click and read it from backend.js — config.connections, useConnection, @vibes.diy/social",
+    description: "Connect a visitor's own GitHub profile, Threads or Instagram account with one click and read it from backend.js — config.connections, useConnection, @vibes.diy/social",
     cues: [
         "connect my",
         "sign in with github",

package/llms/connections.js.map

@@ -1 +1 @@
-{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../jsr/llms/connections.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAc;IAC1C,IAAI,EAAE,aAAa;IACnB,KAAK,EAAE,aAAa;IACpB,WAAW,EACT,gKAAgK;IAClK,IAAI,EAAE;QACJ,YAAY;QACZ,qBAAqB;QACrB,wBAAwB;QACxB,sBAAsB;QACtB,cAAc;QACd,YAAY;QACZ,WAAW;QACX,UAAU;QACV,cAAc;QACd,oBAAoB;QACpB,WAAW;QACX,SAAS;QACT,gBAAgB;KACjB;IACD,YAAY,EAAE,WAAW;IACzB,UAAU,EAAE,eAAe;CAC5B,CAAC"}
+{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../jsr/llms/connections.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAc;IAC1C,IAAI,EAAE,aAAa;IACnB,KAAK,EAAE,aAAa;IACpB,WAAW,EACT,wKAAwK;IAC1K,IAAI,EAAE;QACJ,YAAY;QACZ,qBAAqB;QACrB,wBAAwB;QACxB,sBAAsB;QACtB,cAAc;QACd,YAAY;QACZ,WAAW;QACX,UAAU;QACV,cAAc;QACd,oBAAoB;QACpB,WAAW;QACX,SAAS;QACT,gBAAgB;KACjB;IACD,YAAY,EAAE,WAAW;IACzB,UAAU,EAAE,eAAe;CAC5B,CAAC"}

package/llms/connections.md

@@ -23,6 +23,11 @@ A request that names one of the providers below and wants **their** data is a
 connection. A request for public data nobody has to log in for (a public feed,
 a public profile) is an ordinary `ctx.fetch` and needs no connection.
 
+A request about somebody's GitHub **repos** — pull requests, issues, commits,
+files, a bot that answers GitHub events — connects the repo through the
+vibes.diy GitHub App instead: load the `github` skill. The GitHub row below is
+the visitor's profile.
+
 ## The three moving parts
 
 **Declare the provider in `config.connections`, render the Connect button from
@@ -66,7 +71,7 @@ refuses the call, not because posting is forbidden but because nobody agreed to
 it.
 
 **GitHub is read-only on this lane** — there is no GitHub write scope to
-declare. Instagram views and plays (the `insights` edge) are not available
+declare; reading and writing a repo is the `github` skill's GitHub App lane. Instagram views and plays (the `insights` edge) are not available
 either. Build the app around what the table gives you; do not add a token field
 for the rest.
 

package/llms/github.d.ts

@@ -0,0 +1,2 @@
+import type { LlmConfig } from "./types.js";
+export declare const githubConfig: LlmConfig;

package/llms/github.js

@@ -0,0 +1,21 @@
+export const githubConfig = {
+    name: "github",
+    label: "GitHub repos",
+    description: "Work with somebody's GitHub repo — a pull request bot, a code reviewer, an issue sorter, a repo dashboard, anything reading files, commits or a README or answering GitHub webhooks — through the vibes.diy GitHub App: a Connect link to /github/install, config.github in backend.js, ctx.github.fetch for repo calls and the /github-webhook route for events (a visitor's GitHub profile alone is connections)",
+    cues: [
+        "my repo",
+        "github repo",
+        "pull request",
+        "pull requests",
+        "PR",
+        "PRs",
+        "code review",
+        "issues",
+        "readme",
+        "commits",
+        "github bot",
+        "webhook from github",
+        "github webhook",
+    ],
+};
+//# sourceMappingURL=github.js.map

package/llms/github.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.js","sourceRoot":"","sources":["../../jsr/llms/github.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,YAAY,GAAc;IACrC,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,cAAc;IACrB,WAAW,EACT,oZAAoZ;IACtZ,IAAI,EAAE;QACJ,SAAS;QACT,aAAa;QACb,cAAc;QACd,eAAe;QACf,IAAI;QACJ,KAAK;QACL,aAAa;QACb,QAAQ;QACR,QAAQ;QACR,SAAS;QACT,YAAY;QACZ,qBAAqB;QACrB,gBAAgB;KACjB;CACF,CAAC"}

package/llms/github.md

@@ -0,0 +1,564 @@
+# GitHub — connect a repo to your app
+
+An app that works with somebody's GitHub repo — answers its pull requests,
+sorts its issues, reads its files, shows its commits — connects that repo in
+one click through the **vibes.diy GitHub App**. The person presses Connect,
+picks repos on GitHub's own screen, and lands back in your app. From then on
+`backend.js` reads and writes those repos with `ctx.github.fetch`, and GitHub's
+events for them arrive at your `/_api/github-webhook` route.
+
+**The platform's GitHub App holds the credential, so the app carries no GitHub key of its own.**
+The whole integration is a link, a declaration and `ctx.github.fetch`; the
+person's consent and the credential both live on the platform. (An app built
+without this skill asked its owner to register a GitHub OAuth App and paste its
+client secret into the vibe's secrets — the GitHub App replaces every step of
+that.)
+
+## Which lane — signal words
+
+| The ask                                                                                                          | Lane                                   | What you write                                                                                       |
+| ---------------------------------------------------------------------------------------------------------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| "my repo", "my GitHub repo", pull requests, PRs, code review, issues, commits, files, a README, "a GitHub bot", "when someone opens a PR" | **The repo lane — this skill**         | the `/github/install` link, `config.github`, `ctx.github.fetch`, the `/github-webhook` route          |
+| the visitor's GitHub **profile** — their name, avatar, bio next to their entries                                 | **Connections** (`connections` skill)  | `config.connections` with `provider: "github"`, `scopes: ["read:user"]`, and `useConnection`          |
+| public GitHub data nobody signs in for — stars or releases of a public repo, a public user's repos                 | **Plain `ctx.fetch`**                  | `ctx.fetch("https://api.github.com/repos/nodejs/node")` in `backend.js`, no connect step              |
+
+Repos, pull requests and issues always ride the repo lane, even when the ask
+also says "sign in with GitHub": the Connections lane carries the profile, and
+the GitHub App carries the repos. An app can use both side by side.
+
+## The three pieces
+
+### 1. Declare it — `backend.js`
+
+**`backend.js` declares `config.github` with `bind` and a `why` sentence** the
+visitor reads on the platform's consent page before GitHub opens:
+
+```js
+export const config = {
+  github: {
+    bind: "anyone",
+    why: "Leaves a short note on each new pull request in the repos you pick.",
+  },
+};
+```
+
+- `bind: "anyone"` lets every signed-in visitor connect their **own** repos —
+  the shape for a tool other people use (a reviewer, a triager, a board anyone
+  brings their repos to). `bind: "owner"` (the default) keeps connecting to the
+  app's owner — the shape for one team's own repo.
+- `why` is one static sentence, 280 characters at most, written to the visitor
+  in the app's own voice ("Sorts the issues people open in your repos with a
+  label."). It is required with `"anyone"`; write it for `"owner"` too, so a
+  remix that opens up to visitors already says what it does.
+- A malformed `config.github` refuses the push, with a message naming the field.
+
+### 2. Connect it — `App.jsx`
+
+**The Connect button is a link to `buildGithubInstallUrl()` from `use-vibes`, opened in a new tab**
+with `target="_blank" rel="noopener"`. `buildGithubInstallUrl()` takes no
+arguments and returns the platform's absolute
+`/github/install?vibe=<ownerHandle>/<appSlug>` address for the app that is
+running — on `https://vibes.diy`, or on the preview the app runs under — so the
+link stays right in every copy and remix of the app. The app runs on its own
+subdomain, so a path starting at `/github/install` would point at the app
+itself, and the new tab gives the platform's consent page a whole window of its
+own:
+
+```jsx
+import { buildGithubInstallUrl } from "use-vibes";
+
+<a href={buildGithubInstallUrl()} target="_blank" rel="noopener">Connect a GitHub repo</a>
+```
+
+The app's owner goes straight to GitHub. A visitor first sees the platform's
+consent page quoting your `why`; its Continue button carries the visitor on to
+GitHub's install screen, where they pick the repos. **The platform builds every
+step after `/github/install` itself, so the app's one link is
+`buildGithubInstallUrl()`** — GitHub's own install page is reached only through
+that door. When the new tab finishes, the person comes back to the app's tab,
+so re-read the repo list when the window regains focus.
+Connecting needs a signed-in visitor, so a signed-out visitor gets the sign-in
+ask (`requestLogin` from `useViewer`) in that spot.
+
+### 3. Call and listen — `backend.js`
+
+**Every call to a connected repo goes through `ctx.github.fetch`** — GitHub's
+REST API, called as the GitHub App installation that covers that repo:
+
+```js
+const res = await ctx.github.fetch(`/repos/${repo}/pulls/${number}/files?per_page=100`);
+const files = await res.json();
+await ctx.github.fetch(`/repos/${repo}/pulls/${number}/reviews`, {
+  method: "POST",
+  body: { commit_id: sha, event: "COMMENT", body: "Looks tidy." },
+});
+```
+
+`ctx.github.fetch` attaches the App's credential itself, so a repo call carries only its path, method and body.
+`path` starts at `/`: any `/repos/{owner}/{repo}/…` path for a repo connected to
+this app, plus `/installation/repositories`. Methods are GET, POST, PUT, PATCH
+and DELETE; an object `body` is sent as JSON. It resolves a normal `Response`
+(GitHub's own 404 or 422 included — read `res.ok` and `res.status`), and it
+rejects with an `Error` whose `err.reason` names what happened:
+`not_connected` (no repo connected yet), `unmodeled_endpoint` (a path outside
+those, or a repo this app has not connected), `permission_not_granted`,
+`unsupported_method`, `body_too_large`, `upstream_error`. Branch on
+`err.reason` and tell the person which one it was.
+
+**`ctx.github.routes()` lists the connected repos and who connected each** —
+`[{ repo, accountLogin, binderHandle, installationId }]`, spending no GitHub
+call. It is how a route answers "which of these repos are mine?": keep the rows
+whose `binderHandle` is `ctx.userInfo.userHandle`. Check a repo name the page
+sends against that list before building a path from it.
+
+**A delivery arrives as `POST /github-webhook` with the event name in `x-vibes-github-event`**
+(`pull_request`, `issues`, `push`, …) and GitHub's delivery id in
+`x-vibes-github-delivery`. The platform has already verified it came from
+GitHub, so the headers are trustworthy and the body is GitHub's payload.
+
+- **A delivery runs as the person who connected the repo.** `ctx.userInfo` is
+  them, and its `ctx.db.put` writes pass `access.js` as them, with
+  `user.backend === "fetch"` — so a delivery can keep its own records in that
+  person's channel, and the page shows them live.
+- **Claim each unit of work before spending on it.** GitHub can deliver the
+  same event twice, and a pull request is pushed to many times. Put a record
+  whose `_id` names the work — the repo, the number and the head commit, or the
+  delivery id — with `ifRev: null`; the first delivery writes it, and a repeat
+  meets `err.code === "conflict"` and answers `200` having done nothing.
+- A `4xx` answer ends the delivery; a thrown handler marks it failed.
+
+**Automatic work starts with the repo's team: read `author_association` off the delivery.**
+A delivery runs as the person who connected the repo, so the work it takes on
+by itself spends their credits (`ctx.callAI` included) and writes under their
+name, and on a public repo anyone can open a pull request. GitHub stamps every
+pull request, issue and comment with its author's place in the repo, so the
+delivery already carries the answer, with no extra call:
+`payload.pull_request.author_association`, `payload.issue.author_association`,
+`payload.comment.author_association`. `OWNER`, `MEMBER` and `COLLABORATOR` are
+the repo's team; every other value (`CONTRIBUTOR`, `FIRST_TIME_CONTRIBUTOR`,
+`FIRST_TIMER`, `NONE`, `MANNEQUIN`) is anyone.
+
+- **Each repo gets a `who` setting, `"team"` or `"anyone"`, starting at
+  `"team"`.** The person who connected the repo saves it, and the page shows it
+  as two plain choices: **People on the repo's team** and **Anyone who opens a
+  pull request** (for an issue bot, **Anyone who opens an issue**). An app whose
+  whole job is greeting newcomers starts at `"anyone"`, with the same two
+  choices.
+- **Work from beyond the chosen circle waits for its person.** The delivery
+  records it in their channel, so it shows up live on their page, with a
+  one-tap **Review it now**: an `apiFetch` route, so the work runs as them and
+  the pull request hears from the app the moment they press it.
+- Issue and comment bots read the same stamp off `payload.issue` and
+  `payload.comment`, and honour the same setting.
+
+**Opening the app and spending on the work are separate dials.** An app can be
+open for anyone to visit and read, while its costly work (a `ctx.callAI`
+review, a comment posted to GitHub) runs only for the people who chose it. Set
+each dial on its own:
+
+| Dial | Who it decides | Where it lives |
+| --- | --- | --- |
+| Open the app and read its records | visitors | publishing (apps are public by default) and `access.js` channels and grants |
+| Connect a repo | signed-in visitors | `config.github.bind` |
+| Set off the costly work | pull request, issue and comment authors, and page callers | the repo's `who` setting on deliveries; a `ctx.userInfo` check against `binderHandle` on every route that spends |
+
+So a review bot stays published and public, with a landing page that explains
+it and a shared board that anyone can browse, while a stranger's pull request
+or an anonymous page visit sets off no AI call. A route that only reads (a
+public board, the page's own listing) spends nothing and can answer anyone. A
+route that spends (`ctx.callAI`, a POST through `ctx.github.fetch`) first
+checks that `ctx.userInfo?.userHandle` is the `binderHandle` of the repo it
+touches, and answers everyone else with a plain `403` reason. Keep the app
+open; put the gate on the spend.
+
+## A complete example — pull request size notes
+
+Each new pull request in a connected repo gets a short review comment saying
+how many lines it changes; past a size the person picks, the note adds where to
+start reading. Anyone can connect their own repos, set their own size, and see
+their notes land live. Pull requests from the repo's team get their note right
+away; one from anyone else waits on the person's page with **Review it now**,
+until they switch the repo to **Anyone who opens a pull request**.
+
+### `backend.js`
+```js app=size-notes
+export const config = {
+  github: {
+    bind: "anyone",
+    why: "Leaves a short note on each new pull request in the repos you pick, saying how big the change is.",
+  },
+};
+
+const DB = "sizeNotes";
+const DEFAULT_BIG_AT = 400;
+const PR_ACTIONS = ["opened", "reopened", "synchronize"];
+// The author_association values GitHub gives the people on a repo's team.
+const TEAM = ["OWNER", "MEMBER", "COLLABORATOR"];
+const DEFAULT_WHO = "team";
+
+function json(data, status) {
+  return new Response(JSON.stringify(data), { status: status ?? 200, headers: { "content-type": "application/json" } });
+}
+
+function settingsId(repo) {
+  return `settings:${repo.toLowerCase()}`;
+}
+
+// The repos the signed-in caller connected to this app.
+async function myRepos(ctx) {
+  const me = ctx.userInfo?.userHandle;
+  if (me === undefined) return [];
+  const routes = await ctx.github.routes();
+  return routes.filter((r) => r.binderHandle === me);
+}
+
+async function writeNote(ctx, repo, pr, bigAt) {
+  const res = await ctx.github.fetch(`/repos/${repo}/pulls/${pr.number}/files?per_page=100`);
+  if (res.ok === false) return { status: "failed", reason: `GitHub answered ${res.status} for the file list` };
+  const files = await res.json();
+  const lines = files.reduce((sum, f) => sum + f.additions + f.deletions, 0);
+  const largest = [...files].sort((a, b) => b.changes - a.changes)[0];
+  const body =
+    lines >= bigAt && largest !== undefined
+      ? `This pull request changes ${lines} lines across ${files.length} files. A good place to start reading: \`${largest.filename}\`.`
+      : `This pull request changes ${lines} lines across ${files.length} files.`;
+  const posted = await ctx.github.fetch(`/repos/${repo}/pulls/${pr.number}/reviews`, {
+    method: "POST",
+    body: { commit_id: pr.head.sha, event: "COMMENT", body },
+  });
+  if (posted.ok === false) return { status: "failed", reason: `GitHub answered ${posted.status} to the note` };
+  const review = await posted.json();
+  return { status: "done", lines, files: files.length, reviewUrl: review.html_url };
+}
+
+function noteId(repo, pr) {
+  return `note:${repo.toLowerCase()}#${pr.number}@${pr.head.sha}`;
+}
+
+function noteRecord(repo, pr, binderHandle, status) {
+  return { type: "note", repo, number: pr.number, title: pr.title, url: pr.html_url, author: pr.user?.login, binderHandle, status, at: Date.now() };
+}
+
+// The person's `who` setting decides whose pull requests get a note by themselves.
+function takesOn(settings, pr) {
+  const who = settings?.who ?? DEFAULT_WHO;
+  return who === "anyone" || TEAM.includes(pr.author_association);
+}
+
+async function finishNote(ctx, id, repo, pr, bigAt) {
+  const outcome = await writeNote(ctx, repo, pr, bigAt).catch((err) => ({
+    status: "failed",
+    reason: err.reason === "permission_not_granted" ? "the GitHub App needs permission to review pull requests" : String(err.reason ?? err.message),
+  }));
+  const claimed = await ctx.db.get(id, { db: DB });
+  await ctx.db.put({ ...claimed, ...outcome }, { db: DB, id, ifRev: claimed._rev });
+  return { ok: outcome.status === "done", ...outcome };
+}
+
+async function noteOnPull(ctx, repo, pr, binderHandle) {
+  const settings = await ctx.db.get(settingsId(repo), { db: DB });
+  // From the team, or the person opened it to anyone: the note runs now. Otherwise it waits for them.
+  const status = takesOn(settings, pr) ? "running" : "waiting";
+  // One record per pull request and head commit: the first delivery claims it, a repeat steps aside.
+  const id = noteId(repo, pr);
+  try {
+    await ctx.db.put(noteRecord(repo, pr, binderHandle, status), { db: DB, id, ifRev: null });
+  } catch (err) {
+    if (err.code === "conflict") return { ok: true, skipped: "already-claimed" };
+    throw err;
+  }
+  if (status === "waiting") return { ok: true, waiting: pr.author_association };
+  return finishNote(ctx, id, repo, pr, settings?.bigAt ?? DEFAULT_BIG_AT);
+}
+
+// "Review it now": the person who connected the repo takes on a waiting pull request, as themselves.
+async function reviewNow(request, ctx) {
+  const input = await request.json();
+  const mine = await myRepos(ctx);
+  const bound = mine.find((r) => r.repo.toLowerCase() === String(input.repo).toLowerCase());
+  if (bound === undefined) return json({ ok: false, reason: "Connect this repo first, and its pull requests open here." }, 404);
+  const res = await ctx.github.fetch(`/repos/${bound.repo}/pulls/${Number(input.number)}`);
+  if (res.ok === false) return json({ ok: false, reason: `GitHub answered ${res.status} for that pull request` }, 422);
+  const pr = await res.json();
+  const id = noteId(bound.repo, pr);
+  const held = await ctx.db.get(id, { db: DB });
+  if (held !== null && held.status !== "waiting") return json({ ok: true, skipped: "already-claimed" });
+  const record = held === null ? noteRecord(bound.repo, pr, bound.binderHandle, "running") : { ...held, status: "running" };
+  try {
+    await ctx.db.put(record, { db: DB, id, ifRev: held === null ? null : held._rev });
+  } catch (err) {
+    if (err.code === "conflict") return json({ ok: true, skipped: "already-claimed" });
+    throw err;
+  }
+  const settings = await ctx.db.get(settingsId(bound.repo), { db: DB });
+  const outcome = await finishNote(ctx, id, bound.repo, pr, settings?.bigAt ?? DEFAULT_BIG_AT);
+  return json(outcome, outcome.ok ? 200 : 422);
+}
+
+async function onDelivery(request, ctx) {
+  const event = request.headers.get("x-vibes-github-event");
+  if (event !== "pull_request") return json({ ok: true, ignored: event });
+  const payload = await request.json();
+  if (PR_ACTIONS.includes(payload.action) === false) return json({ ok: true, ignored: payload.action });
+  const repo = payload.repository?.full_name;
+  const pr = payload.pull_request;
+  if (typeof repo !== "string" || pr === undefined) return json({ ok: false, reason: "this delivery carries no pull request" }, 400);
+  // The delivery runs as the person who connected this repo.
+  const binderHandle = ctx.userInfo?.userHandle;
+  if (binderHandle === undefined) return json({ ok: false, reason: "this delivery arrived without its person" }, 422);
+  ctx.log("info", "pull request", {
+    repo,
+    number: pr.number,
+    author: pr.author_association,
+    delivery: request.headers.get("x-vibes-github-delivery"),
+  });
+  const outcome = await noteOnPull(ctx, repo, pr, binderHandle);
+  return json(outcome, outcome.ok || outcome.skipped ? 200 : 422);
+}
+
+async function listRepos(ctx) {
+  const rows = [];
+  for (const r of await myRepos(ctx)) {
+    const settings = await ctx.db.get(settingsId(r.repo), { db: DB });
+    rows.push({ repo: r.repo, bigAt: settings?.bigAt ?? DEFAULT_BIG_AT, who: settings?.who ?? DEFAULT_WHO });
+  }
+  return json({ ok: true, repos: rows });
+}
+
+async function saveSettings(request, ctx) {
+  const input = await request.json();
+  const mine = await myRepos(ctx);
+  const bound = mine.find((r) => r.repo.toLowerCase() === String(input.repo).toLowerCase());
+  if (bound === undefined) return json({ ok: false, reason: "Connect this repo first, and its settings open here." }, 404);
+  const bigAt = Math.max(1, Math.round(Number(input.bigAt) || DEFAULT_BIG_AT));
+  const who = input.who === "anyone" ? "anyone" : "team";
+  const existing = await ctx.db.get(settingsId(bound.repo), { db: DB });
+  await ctx.db.put(
+    { type: "settings", repo: bound.repo, binderHandle: bound.binderHandle, bigAt, who },
+    { db: DB, id: settingsId(bound.repo), ifRev: existing === null ? null : existing._rev }
+  );
+  return json({ ok: true, bigAt, who });
+}
+
+export async function fetch(request, ctx) {
+  const route = `${request.method} ${new URL(request.url).pathname}`;
+  const run = async () => {
+    if (route === "POST /github-webhook") return onDelivery(request, ctx);
+    if (route === "GET /repos") return listRepos(ctx);
+    if (route === "POST /settings") return saveSettings(request, ctx);
+    if (route === "POST /review") return reviewNow(request, ctx);
+    return json({ ok: false, reason: "not found" }, 404);
+  };
+  return run().catch((err) => {
+    ctx.log("error", "route failed", { route, reason: err.reason ?? err.code, message: String(err.message ?? err) });
+    return json({ ok: false, reason: err.reason ?? "error" }, err.reason === "not_connected" ? 409 : 500);
+  });
+}
+```
+
+### `access.js`
+```js app=size-notes
+// Notes and settings are written by backend.js: settings by POST /settings, notes by the GitHub
+// delivery (which runs as the person who connected the repo) and by POST /review. Each lands in
+// that person's channel.
+export default function (doc, oldDoc, user, ctx) {
+  if (doc.type === "note" || doc.type === "settings") {
+    ctx.requireBackend("fetch");
+    const binder = doc.binderHandle;
+    if (typeof binder !== "string" || binder === "") throw { forbidden: "missing binderHandle" };
+    // write-once: a record stays with the person who connected its repo
+    if (oldDoc && oldDoc.binderHandle !== binder) throw { forbidden: "binderHandle is fixed" };
+    if (binder !== user.userHandle) throw { forbidden: "not your repo" };
+    const ch = `repo-of:${binder}`;
+    return { channels: [ch], grant: { users: { [binder]: [ch] } } };
+  }
+  throw { forbidden: "unknown document type" };
+}
+```
+
+### `App.jsx`
+```jsx app=size-notes
+import React, { useCallback, useEffect, useState } from "react";
+import { apiFetch, buildGithubInstallUrl, useViewer } from "use-vibes";
+import { useFireproof } from "use-fireproof";
+import { Badge, Button, Field, Heading, Input, RowCard, Skeleton, Stack, Text } from "@vibes.diy/pouf";
+import { RadioGroup } from "@vibes.diy/pouf/interactive";
+
+const TONE = { done: "up", failed: "warn", running: "info", waiting: "info" };
+const WHO_CHOICES = [
+  { value: "team", label: "People on the repo's team" },
+  { value: "anyone", label: "Anyone who opens a pull request" },
+];
+
+function badgeText(n) {
+  if (n.status === "done") return `${n.lines} lines`;
+  if (n.status === "failed") return n.reason;
+  if (n.status === "waiting") return `From ${n.author ?? "someone new"}`;
+  return "Writing…";
+}
+
+function NoteRow({ note }) {
+  const [busy, setBusy] = useState(false);
+
+  // Runs as the person who connected the repo; the record turns to "done" live when the note lands.
+  async function reviewNow() {
+    setBusy(true);
+    await apiFetch("/review", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ repo: note.repo, number: note.number }),
+    });
+    setBusy(false);
+  }
+
+  return (
+    <RowCard>
+      <a className="underline" href={note.reviewUrl ?? note.url} target="_blank" rel="noreferrer">
+        #{note.number} {note.title}
+      </a>
+      <Badge tone={TONE[note.status] ?? "info"}>{badgeText(note)}</Badge>
+      {note.status === "waiting" && (
+        <Button type="button" size="sm" loading={busy} onClick={reviewNow}>
+          Review it now
+        </Button>
+      )}
+    </RowCard>
+  );
+}
+
+// The live ledger: each note record is written by the delivery itself, so new ones appear as
+// pull requests open.
+function RecentNotes({ repo }) {
+  const { useLiveQuery } = useFireproof("sizeNotes");
+  const { docs } = useLiveQuery("repo", { key: repo });
+  const notes = docs.filter((d) => d.type === "note").sort((a, b) => b.at - a.at).slice(0, 10);
+  if (notes.length === 0) return <Text muted>Open a pull request and its note shows up here and on GitHub.</Text>;
+  return (
+    <Stack gap={2}>
+      {notes.map((n) => (
+        <NoteRow key={n._id} note={n} />
+      ))}
+    </Stack>
+  );
+}
+
+function RepoPanel({ row }) {
+  const [bigAt, setBigAt] = useState(String(row.bigAt));
+  const [who, setWho] = useState(row.who);
+  const [message, setMessage] = useState("");
+
+  async function save() {
+    setMessage("Saving…");
+    const res = await apiFetch("/settings", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ repo: row.repo, bigAt: Number(bigAt), who }),
+    });
+    const body = await res.json();
+    setMessage(res.ok ? "Saved. The next pull request uses it." : body.reason);
+  }
+
+  return (
+    <Stack gap={3}>
+      <Heading level={2}>
+        <a href={`https://github.com/${row.repo}`} target="_blank" rel="noreferrer">
+          {row.repo}
+        </a>
+      </Heading>
+      <Field label="Suggest where to start reading at this many changed lines">
+        {(id, describedBy) => <Input id={id} describedBy={describedBy} value={bigAt} onChange={setBigAt} />}
+      </Field>
+      <RadioGroup label="Whose pull requests get a note right away" value={who} onChange={setWho} options={WHO_CHOICES} />
+      <Button type="button" size="sm" onClick={save}>
+        Save
+      </Button>
+      {message !== "" && <Text size="sm" muted>{message}</Text>}
+      <RecentNotes repo={row.repo} />
+    </Stack>
+  );
+}
+
+export default function App() {
+  const { viewer, isViewerPending, requestLogin } = useViewer();
+  const [state, setState] = useState({ loading: true, repos: [] });
+
+  const load = useCallback(async () => {
+    const res = await apiFetch("/repos");
+    const body = await res.json();
+    setState({ loading: false, repos: body.repos ?? [] });
+  }, []);
+
+  useEffect(() => {
+    if (isViewerPending === false) load();
+  }, [isViewerPending, viewer, load]);
+
+  // Connecting finishes in the tab the link opened; re-read the list when the person comes back.
+  useEffect(() => {
+    window.addEventListener("focus", load);
+    return () => window.removeEventListener("focus", load);
+  }, [load]);
+
+  return (
+    <main className="min-h-screen bg-background text-foreground font-sans mx-auto max-w-2xl p-6">
+      <Stack gap={5}>
+        <Heading level={1}>Pull request size notes</Heading>
+        <Text>
+          Connect a GitHub repo and each new pull request gets a short note on how big it is, with a place to start reading when it runs long. Your team's pull
+          requests get theirs right away, and the rest are one tap away here.
+        </Text>
+        {viewer && (
+          <a className="inline-block rounded-md bg-foreground px-4 py-2 font-bold text-background" href={buildGithubInstallUrl()} target="_blank" rel="noopener">
+            Connect a GitHub repo
+          </a>
+        )}
+        {isViewerPending === false && !viewer && (
+          <Button type="button" onClick={requestLogin}>
+            Sign in to connect a repo
+          </Button>
+        )}
+        {state.loading ? <Skeleton /> : state.repos.map((row) => <RepoPanel key={row.repo} row={row} />)}
+      </Stack>
+    </main>
+  );
+}
+```
+
+`GET /repos`, `POST /settings` and the delivery each run as a signed-in
+person, so their `ctx.db` reads of `sizeNotes` come back filtered to that
+person's own channels — the same records their page sees — with no extra
+config. Before writing, a route still checks the repo against the ones
+`ctx.github.routes()` says the caller connected. A pull request from beyond
+the repo's `who` setting is claimed as a `waiting` record, and **Review it
+now** calls `POST /review`, which runs the same note as the person who pressed
+it. The page reads its notes
+through `useLiveQuery`, which shows each person the records in their own
+channel.
+
+## Good to know
+
+- **The page calls its routes with `apiFetch`** from `use-vibes`, so the route
+  runs as the signed-in visitor and `ctx.userInfo` says whose repos to list.
+- **The repo's team comes first.** Every app that acts on pull requests,
+  issues or comments by itself reads `author_association` and starts each repo
+  at `who: "team"` (`OWNER`, `MEMBER`, `COLLABORATOR`), with a two-choice
+  control that opens it to anyone. Everything else waits on the connector's
+  page with **Review it now**, so their credits and their name go where they
+  choose.
+- **The app stays open; the spend has its own gate.** Who can visit and read
+  the app is publishing plus `access.js`. Who sets off AI calls and GitHub
+  posts is the repo's `who` setting on deliveries and a `binderHandle` check on
+  every spending route. Keep the app published and gate the spend.
+- **What the App may do today:** read repository contents, and write to pull
+  requests — reviews, review comments, and comments on a pull request's
+  conversation. Build on those. Other writes (labels, issue comments, check
+  runs) may answer `permission_not_granted`; record that reason on the
+  person's record and show it, so they see exactly what happened.
+- **One repo connects to one app.** A repo already connected to another app
+  answers the person on the connect screen with "Already connected" — say so on
+  your page near the Connect button, so it reads as expected.
+- **Repo names are case-insensitive on GitHub.** Lower-case them in `_id`s and
+  comparisons, as the example does, and keep GitHub's spelling for display.
+- **Disconnecting happens on GitHub**, in the person's installed GitHub Apps
+  settings.
+- More on `ctx` — `ctx.db`, `ctx.log`, `ifRev`, `apiFetch` — lives in the
+  `backend` skill.

package/llms/index.d.ts

@@ -16,6 +16,7 @@ export { useVibeConfig } from "./use-vibe.js";
 export { createVibeConfig } from "./create-vibe.js";
 export { accessConfig } from "./access.js";
 export { connectionsConfig } from "./connections.js";
+export { githubConfig } from "./github.js";
 export { youtubeConfig } from "./youtube.js";
 export { blueskyConfig } from "./bluesky.js";
 export { spotifyConfig } from "./spotify.js";
@@ -57,5 +58,5 @@ export { poufCalendarConfig } from "./pouf-calendar.js";
 export { poufTestimonialsConfig } from "./pouf-testimonials.js";
 export type { LlmConfig } from "./types.js";
 export { cueMatches, cueMatchedSkills, type CueCatalogEntry } from "./cues.js";
-export declare const allConfigs: readonly [import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig];
+export declare const allConfigs: readonly [import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig, import("./types.js").LlmConfig];
 export { mapsConfig } from "./maps.js";

package/llms/index.js

@@ -17,6 +17,7 @@ import { useVibeConfig } from "./use-vibe.js";
 import { createVibeConfig } from "./create-vibe.js";
 import { accessConfig } from "./access.js";
 import { connectionsConfig } from "./connections.js";
+import { githubConfig } from "./github.js";
 import { youtubeConfig } from "./youtube.js";
 import { blueskyConfig } from "./bluesky.js";
 import { spotifyConfig } from "./spotify.js";
@@ -74,6 +75,7 @@ export { useVibeConfig } from "./use-vibe.js";
 export { createVibeConfig } from "./create-vibe.js";
 export { accessConfig } from "./access.js";
 export { connectionsConfig } from "./connections.js";
+export { githubConfig } from "./github.js";
 export { youtubeConfig } from "./youtube.js";
 export { blueskyConfig } from "./bluesky.js";
 export { spotifyConfig } from "./spotify.js";
@@ -134,6 +136,7 @@ export const allConfigs = [
     boardGamesConfig,
     accessConfig,
     connectionsConfig,
+    githubConfig,
     youtubeConfig,
     blueskyConfig,
     spotifyConfig,

package/llms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../jsr/llms/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../jsr/llms/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibes.diy/prompts",
-  "version": "14.3.161",
+  "version": "14.3.163",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -39,10 +39,10 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@adviser/cement": "~0.5.34",
-    "@vibes.diy/api-types": "14.3.161",
-    "@vibes.diy/call-ai-v2": "14.3.161",
-    "@vibes.diy/identity": "14.3.161",
-    "@vibes.diy/use-vibes-types": "14.3.161",
+    "@vibes.diy/api-types": "14.3.163",
+    "@vibes.diy/call-ai-v2": "14.3.163",
+    "@vibes.diy/identity": "14.3.163",
+    "@vibes.diy/use-vibes-types": "14.3.163",
     "arktype": "~2.2.6",
     "json-schema-faker": "~0.6.3"
   },