@@ -52,6 +52,22 @@ CARD_BACKFILL=1
 CARD_BACKFILL_BATCH=8
 CARD_BACKFILL_SECONDS=20
 
+# OpenWebring (logicsrc.com/openwebring). The crawler seeds one ring per
+# well-covered topic and reads every member's front page for a link back, one
+# site at a time, oldest verdict first. RING_VERIFY=0 pauses the pass and the
+# seeding without changing their tuning. RING_TOPICS is how many topics get a
+# ring (the most covered, at least five eligible feeds each); RING_BATCH
+# members are checked per pass, every RING_SECONDS; a verdict stands
+# RING_RECHECK_DAYS before the member is looked at again; the rings are
+# re-seeded every RING_SEED_SECONDS so a feed new to a topic joins at the end.
+# One-off: `node --env-file=.env scripts/seed-rings.mjs`.
+RING_VERIFY=1
+RING_TOPICS=20
+RING_BATCH=25
+RING_SECONDS=60
+RING_RECHECK_DAYS=7
+RING_SEED_SECONDS=21600
+
 # Nonessential maintenance can be paused while a large first-crawl backlog owns
 # the database write path. The work is resumable when these are switched on.
 CLUSTER_BACKFILL=1
 
@@ -21,6 +21,8 @@ import {
   drainDiscoveryQueue,
   drainDiscoveryKeywords,
   drainImport,
+  seedTopRings,
+  verifyRingMembers,
 } from '@rssamplifier/ingest';
 import { runDueSources, discoverFromOwnTopics } from '@rssamplifier/discover';
 import { findFeedCard } from '@rssamplifier/feed';
@@ -97,6 +99,21 @@ const cardEnabled = env['CARD_BACKFILL'] !== '0' && env['CARD_BACKFILL'] !== 'fa
 // that only happens if the process lives long enough to reach it.
 const cardIntervalMs = (Number(env['CARD_BACKFILL_SECONDS']) || 20) * 1000;
 
+// OpenWebring (logicsrc.com/openwebring). The rings are seeded from the most
+// covered topics and every member's front page is read for a link back, one
+// site at a time, oldest verdict first; see packages/ingest/src/webring.js.
+// How many members a pass checks, how often a pass runs, how long a verdict
+// stands before the member is looked at again, how many topics get a ring,
+// and how often the rings are re-seeded so a feed new to a topic joins at
+// the end. RING_VERIFY=0 pauses all of it without changing the tuning.
+const ringEnabled = env['RING_VERIFY'] !== '0' && env['RING_VERIFY'] !== 'false';
+const ringBatch = Number(env['RING_BATCH']) || 25;
+const ringIntervalMs = (Number(env['RING_SECONDS']) || 60) * 1000;
+const ringRecheckDays = Number(env['RING_RECHECK_DAYS']) || 7;
+const ringTopics = Number(env['RING_TOPICS']) || 20;
+const ringSeedMs = (Number(env['RING_SEED_SECONDS']) || 21_600) * 1000;
+const ringBase = (env['SITE_URL'] || 'https://rssamplifier.com').replace(/\/+$/, '');
+
 // Items keyed for grouping per tick. Each one is a title hashed in process and
 // a single-column update, so the batch is bounded by the write round trip
 // rather than by CPU.
@@ -245,6 +262,10 @@ let carding = false;
 // Guards the enrichment pass against overlapping itself. A batch of five feeds
 // that each need four fetches of a slow server can outlast its own interval.
 let enriching = false;
+// The same guard for the webring pass, which fetches strangers' front pages
+// one at a time and must not stack, and when the rings were last seeded.
+let ringing = false;
+let lastRingSeed = 0;
 
 // And for the alert pass, where stacking would be worse than wasteful: two
 // overlapping passes read the same watermark and would send the same digest
@@ -756,6 +777,48 @@ async function cardTick() {
   }
 }
 
+/**
+ * Keep the webrings seeded and verified.
+ *
+ * Two jobs on one timer. Seeding runs every RING_SEED_SECONDS: one ring per
+ * well-covered topic, existing members keeping their place and new feeds
+ * appended (webrings.seedTopicRing). Verification runs every tick: a bounded
+ * batch of the members whose verdict is oldest, each one a fetch of their
+ * front page and of their descriptor, sequentially, because every one is a
+ * request to a stranger's server and the crawl beside this already owns the
+ * outbound budget. The hop routes never do any of this; they read only what
+ * this pass last wrote, which is what keeps a hop a cheap 302.
+ */
+async function ringTick() {
+  if (!ringEnabled || stopping || ringing) return;
+  ringing = true;
+
+  try {
+    if (Date.now() - lastRingSeed >= ringSeedMs) {
+      lastRingSeed = Date.now();
+      const seeded = await seedTopRings(db, { topics: ringTopics, minMembers: 5 });
+      // Logged only when something changed: once the rings exist, a line
+      // every six hours saying "0 added" is not a log.
+      if (seeded.created || seeded.added) log('rings-seeded', seeded);
+    }
+
+    const result = await verifyRingMembers(db, {
+      batch: ringBatch,
+      base: ringBase,
+      recheckDays: ringRecheckDays,
+      onEvent: publishLog ? recorder.record : null,
+      stopping: () => stopping,
+    });
+    // Silent when nothing was due, which is the steady state between recheck
+    // periods.
+    if (result.checked) log('rings', result);
+  } catch (err) {
+    log('rings-error', { message: String(err?.message ?? err) });
+  } finally {
+    ringing = false;
+  }
+}
+
 /**
  * Tell people about the posts they asked to be told about.
  *
@@ -1047,6 +1110,7 @@ const backfillTimer = setInterval(backfillTick, clusterIntervalMs);
 const cardTimer = setInterval(cardTick, cardIntervalMs);
 const alertTimer = setInterval(alertTick, alertIntervalMs);
 const enrichTimer = setInterval(enrichTick, authorIntervalMs);
+const ringTimer = setInterval(ringTick, ringIntervalMs);
 const queueTimer = setInterval(queueTick, queueSampleMs);
 const statsTimer = setInterval(statsTick, statsWarmMs);
 const searchTimer = setInterval(searchTick, searchIntervalMs);
@@ -1058,6 +1122,7 @@ void backfillTick();
 void cardTick();
 void alertTick();
 void enrichTick();
+void ringTick();
 void queueTick();
 // Run once at boot, so a deploy does not leave the page slow until the first
 // interval comes round.
@@ -1071,6 +1136,8 @@ log('started', {
   clusterBackfill,
   cardBatch: cardEnabled ? cardBatch : 0,
   authorBatch: authorEnabled ? authorBatch : 0,
+  ringBatch: ringEnabled ? ringBatch : 0,
+  ringTopics: ringEnabled ? ringTopics : 0,
   crawlAutocommit: ['1', 'true'].includes(String(env['TURSO_CRAWL_AUTOCOMMIT'] ?? '').toLowerCase()),
   auxiliaryWrites: !['0', 'false'].includes(String(env['CRAWL_AUXILIARY_WRITES'] ?? '').toLowerCase()),
   catchupOnly,
@@ -1091,6 +1158,7 @@ function shutdown(signal) {
   clearInterval(backfillTimer);
   clearInterval(cardTimer);
   clearInterval(enrichTimer);
+  clearInterval(ringTimer);
   clearInterval(alertTimer);
   clearInterval(queueTimer);
   clearInterval(statsTimer);
 
@@ -19,7 +19,8 @@
     ]
   },
   "scopes": {
-    "openprofile:edit": "Correct an author's OpenProfile.md you have claimed: PUT /api/authors/{slug}/openprofile (text/markdown, the whole file, or a JSON patch), POST /api/authors/{slug}/claim. The grant's principal is recorded as the owner; a claim is verified by the address the author published or by their site linking back."
+    "openprofile:edit": "Correct an author's OpenProfile.md you have claimed: PUT /api/authors/{slug}/openprofile (text/markdown, the whole file, or a JSON patch), POST /api/authors/{slug}/claim. The grant's principal is recorded as the owner; a claim is verified by the address the author published or by their site linking back.",
+    "openwebring:edit": "State who makes a site of yours that is in one of this host's webrings: PUT /api/rings/{ring}/members/{slug} with a JSON body { made_by: human | ai | both | null, disclosure }. Recorded as the owner's word, which a later read of the site's own /.well-known/openwebring.json never overwrites."
   },
   "honours": [
     "profullstack.com/all-access"
 
@@ -29,7 +29,10 @@
     "submit_feed",
     "get_openprofile",
     "update_openprofile",
-    "claim_openprofile"
+    "claim_openprofile",
+    "list_rings",
+    "get_ring",
+    "ring_next"
   ],
   "catalogs": [
     "https://openmcp.logicsrc.com"
 
@@ -0,0 +1,27 @@
+import { webrings } from '@rssamplifier/db';
+
+import { db, siteUrl } from '../../../lib/db.js';
+import { hostFile } from '../../../lib/openwebring.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * /.well-known/openwebring.json: the rings this site hosts.
+ *
+ * A route rather than a file in /public, because rings are data: which
+ * topics have one and how many members each holds changes as the poller
+ * seeds and verifies, and a file would say whatever it said on deploy day.
+ * Five minutes of caching is the same allowance the JSON API gives itself.
+ */
+export async function GET() {
+  const rings = await webrings.listRings(db());
+  const body = hostFile({ base: siteUrl(), siteName: 'RSS Amplifier', rings });
+
+  return new Response(JSON.stringify(body, null, 2), {
+    headers: {
+      'content-type': 'application/json; charset=utf-8',
+      'access-control-allow-origin': '*',
+      'cache-control': 'public, max-age=300',
+    },
+  });
+}
@@ -0,0 +1,76 @@
+import { webrings } from '@rssamplifier/db';
+
+import { db } from '../../../../../../lib/db.js';
+import { forgetRing, loadRing, profilesForFeed } from '../../../../../../lib/rings.js';
+import { madeByPatch, memberEditVerdict, memberEntry } from '../../../../../../lib/openwebring.js';
+import { adminEmails, callerOf } from '../../../../../../lib/profileAuth.js';
+import { json } from '../../../../authors/route.js';
+
+export const dynamic = 'force-dynamic';
+
+/** The most a patch may be. Two fields; a page of them is somebody probing. */
+const BODY_LIMIT = 4 * 1024;
+
+/**
+ * One member of a ring, read and corrected.
+ *
+ * GET is the member's entry from the ring file.
+ *
+ * PUT is the owner's word on who makes the site: `{ "made_by": "human" |
+ * "ai" | "both" | null, "disclosure": "none" | "ai-assisted" | "ai-generated"
+ * | "autonomous" | null }`. Recorded as the owner's (or an admin's), which a
+ * later read of the site's own descriptor never overwrites. Auth: the site's
+ * session, an API key, or an OpenAccess bearer; the caller must have claimed
+ * the profile of one of the feed's authors, be an admin, or hold the
+ * `openwebring:edit` scope.
+ *
+ * @param {Request} req
+ * @param {{ params: Promise<{ slug: string, member: string }> }} ctx
+ */
+export async function GET(req, { params }) {
+  const { slug, member } = await params;
+  const loaded = await loadRing(slug);
+  const row = loaded?.members.find((m) => m.member_slug === member.toLowerCase());
+  if (!loaded || !row) return json({ error: 'not-found', ring: slug, member }, 404);
+  return json({ ring: loaded.ring.slug, member: memberEntry(row) });
+}
+
+/**
+ * @param {Request} req
+ * @param {{ params: Promise<{ slug: string, member: string }> }} ctx
+ */
+export async function PUT(req, { params }) {
+  const { slug, member } = await params;
+  const client = db();
+
+  const ring = await webrings.ringBySlug(client, slug.toLowerCase());
+  const row = ring ? await webrings.memberBySlug(client, ring.slug, member.toLowerCase()) : null;
+  if (!ring || !row) return json({ error: 'not-found', ring: slug, member }, 404);
+
+  const caller = await callerOf(req);
+  const verdict = memberEditVerdict(caller, {
+    profiles: await profilesForFeed(row.feed_id),
+    admins: adminEmails(),
+  });
+  if (!verdict.ok) return json({ error: verdict.error }, verdict.status);
+
+  const text = await req.text();
+  if (text.length > BODY_LIMIT) return json({ error: `body over ${BODY_LIMIT} bytes` }, 413);
+  let body;
+  try {
+    body = JSON.parse(text || '{}');
+  } catch {
+    return json({ error: 'bad-json' }, 400);
+  }
+  const patch = madeByPatch(body);
+  if (!patch.ok) return json({ error: patch.error }, 400);
+
+  const saved = await webrings.setMemberMadeBy(client, ring.slug, row.feed_id, {
+    madeBy: patch.madeBy,
+    disclosure: patch.disclosure,
+    source: verdict.source,
+  });
+  forgetRing(ring.slug);
+
+  return json({ ok: true, ring: ring.slug, source: verdict.source, member: memberEntry(saved ?? row) });
+}
@@ -0,0 +1,36 @@
+import { siteUrl } from '../../../../lib/db.js';
+import { loadRing } from '../../../../lib/rings.js';
+import { hopUrl, ringFile } from '../../../../lib/openwebring.js';
+import { json } from '../../authors/route.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * One ring, as JSON: the ring file plus where its pages are.
+ *
+ * @param {Request} req
+ * @param {{ params: Promise<{ slug: string }> }} ctx
+ */
+export async function GET(req, { params }) {
+  const { slug } = await params;
+  const loaded = await loadRing(slug);
+  if (!loaded) return json({ error: 'not-found', slug }, 404);
+
+  const base = siteUrl();
+  const file = ringFile({ base, ring: loaded.ring, members: loaded.members });
+
+  return json({
+    ...file,
+    members: file.members.map((m) => ({
+      ...m,
+      page: `${base}/${encodeURIComponent(String(m.slug))}`,
+      next: hopUrl(base, loaded.ring.slug, 'next', String(m.url)),
+      previous: hopUrl(base, loaded.ring.slug, 'previous', String(m.url)),
+    })),
+    active: loaded.ring.active_count,
+    page: file.ring.url,
+    opml: `${file.ring.url}/opml`,
+    random: hopUrl(base, loaded.ring.slug, 'random'),
+    join: `${file.ring.url}#join`,
+  });
+}
@@ -0,0 +1,33 @@
+import { webrings } from '@rssamplifier/db';
+
+import { db, siteUrl } from '../../../lib/db.js';
+import { SPEC, hostEntry } from '../../../lib/openwebring.js';
+import { json } from '../authors/route.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * The rings this site hosts, as JSON.
+ *
+ * The same entries as /.well-known/openwebring.json, with the page and the
+ * API address of each ring added, and the active count beside the listed
+ * count so a caller can see how much of a ring is live without fetching
+ * every ring file.
+ */
+export async function GET() {
+  const base = siteUrl();
+  const rings = await webrings.listRings(db());
+
+  return json({
+    total: rings.length,
+    host: `${base}/.well-known/openwebring.json`,
+    spec: SPEC,
+    rings: rings.map((ring) => ({
+      ...hostEntry({ base, ring }),
+      active: ring.active_count,
+      kind: ring.kind,
+      ...(ring.topic_slug ? { topic: `${base}/topics/${encodeURIComponent(ring.topic_slug)}` } : {}),
+      api: `${base}/api/rings/${encodeURIComponent(ring.slug)}`,
+    })),
+  });
+}
@@ -304,7 +304,11 @@ export default function RootLayout({ children }) {
             <p>
               Machine-readable: <a href="/mcp">MCP server</a> · <a href="/cli">CLI</a> ·{' '}
               <a href="/api/feeds">JSON API</a> · <a href="/opml">OPML</a> ·{' '}
-              <a href="/llms.txt">llms.txt</a> · <a href="/crawlstats">Crawler status</a>
+              <a href="/llms.txt">llms.txt</a> · <a href="/crawlstats">Crawler status</a> ·{' '}
+              {/* Here rather than in Browse: a ring is a thing another site
+                  links into and a program reads, and its index page is the
+                  human face of /.well-known/openwebring.json. */}
+              <a href="/ring">Webrings</a>
             </p>
             {/* The install command itself, not just a link to it. Somebody who
                 scrolled to the bottom of a feed page is exactly the person who
 
@@ -0,0 +1,16 @@
+import { hopResponse } from '../../../../../lib/rings.js';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * /ring/<slug>/<member>/next: the hop with the member named in the path,
+ * the shape Hotline and the older IndieWeb rings used. No parameter and no
+ * Referer needed.
+ *
+ * @param {Request} req
+ * @param {{ params: Promise<{ slug: string, member: string }> }} ctx
+ */
+export async function GET(req, { params }) {
+  const { slug, member } = await params;
+  return hopResponse(req, { slug, memberSlug: member, kind: 'next' });
+}