From 2c386b2f499870fc6147c640501fb2ec7f949e4a Mon Sep 17 00:00:00 2001
From: claudebot.disnetdev.com (did:plc:n6ku5xddiuguwze3f356evla) <claudebot.disnetdev.com@noreply.radial>
Date: Fri, 31 Jul 2026 20:36:05 +0000
Subject: [PATCH] Report a blessing by what the bundle carries, and unbreak CI

Two fixes from review and one from the pipeline.

A comment can carry more than one blessing — "Bless it again" on a withdrawn row
writes a second one, and two members can bless the same words independently —
and `blessedRows()` concatenated the live list before the retracted one into a
Map keyed by comment URI, so a stale tombstone overwrote the live blessing
sitting beside it. The exact workflow the section offers therefore reported
"blessing withdrawn" and offered to bless a third time, while the fold and every
turn bundle still carried the live one: the screen inverted the single fact the
section exists to report. It now folds to one row per COMMENT and a live
blessing always outranks a tombstone on a different one, so the row says what
the bundle actually holds and `Withdraw blessing` names the record that is in it.

Turning the space switch off hid the whole section, blessings included — prose
that was still in every turn bundle on the goal, with its only screen and its
only withdrawal control gone. The switch governs solicitation, not revocation,
so it now stops the backlink query and takes away the guest composer while
blessed rows and the button that withdraws them stay. The rule is
`showsCommunity()`, named so it can be tested rather than inlined in a template;
`Community` takes a `discover` prop and says plainly that it did not look, rather
than "none found".

And CI, which was failing on this branch and is not transient. `Community.svelte`
was the only component in the app carrying a scoped `<style>` block — app.css is
deliberately global, and packages/ui/README.md says so — and that one block was
enough to make `svelte-check` invoke vite's CSS preprocessor, which loads
`vite.config.ts`, which reaches `@radial/core` through `client-metadata.ts` and
resolves it through `exports.import` to a `dist/` that Typecheck runs before
Build has created. tsc never noticed because it reads `exports.types`, which is
`src/`, which is why this stayed latent until the first scoped stylesheet landed.
The CSS moves to app.css where the convention already put it, and both workflows
build before they typecheck so the next one does not rediscover this.

Co-Authored-By: claudebot.disnetdev.com (did:plc:n6ku5xddiuguwze3f356evla) <claudebot.disnetdev.com@noreply.radial>
---
 .github/workflows/ci.yml | 7 ++++++-
 .tangled/workflows/ci.yml | 9 +++++++--
 packages/ui/README.md | 17 +++++++++++++++--
 packages/ui/src/app.css | 15 +++++++++++++++
 packages/ui/src/lib/guests.test.ts | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 packages/ui/src/lib/guests.ts | 57 +++++++++++++++++++++++++++++++++++++++++++++++++--------
 packages/ui/src/lib/components/Community.svelte | 69 ++++++++++++++++++++++++++++++++-------------------------------------
 packages/ui/src/lib/components/Community.svelte.test.ts | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 packages/ui/src/routes/g/[did]/[rkey]/+page.svelte | 16 ++++++++++------
 9 file(s) changed, 283 insertion(s)(+), 61 deletion(s)(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,7 +19,12 @@
       - run: pnpm install --frozen-lockfile
       - run: pnpm codegen
       - run: git diff --exit-code
+      # Build FIRST, before the checks that read a built package. `@radial/core` resolves through
+      # `exports.import` to `dist/`, and the UI's `vite.config.ts` reaches it via `client-metadata.ts`
+      # — so with no `dist/` the config fails to load, and `svelte-check` fails any component that
+      # has a `<style>` block. tsc itself is unaffected (it reads `exports.types`, which is `src/`),
+      # which is what kept this latent until the first scoped stylesheet landed.
+      - run: pnpm build
       - run: pnpm typecheck
       - run: pnpm lint
       - run: pnpm test
-      - run: pnpm build
diff --git a/.tangled/workflows/ci.yml b/.tangled/workflows/ci.yml
--- a/.tangled/workflows/ci.yml
+++ b/.tangled/workflows/ci.yml
@@ -28,11 +28,16 @@
     command: |
       pnpm codegen
       git diff --exit-code
+  # Build FIRST, before the checks that read a built package. `@radial/core` resolves through
+  # `exports.import` to `dist/`, and the UI's `vite.config.ts` reaches it via `client-metadata.ts` —
+  # so with no `dist/` the config fails to load, and `svelte-check` fails any component that has a
+  # `<style>` block. tsc itself is unaffected (it reads `exports.types`, which is `src/`), which is
+  # what kept this latent until the first scoped stylesheet landed.
+  - name: "Build"
+    command: pnpm build
   - name: "Typecheck"
     command: pnpm typecheck
   - name: "Lint"
     command: pnpm lint
   - name: "Test"
     command: pnpm test
-  - name: "Build"
-    command: pnpm build
diff --git a/packages/ui/README.md b/packages/ui/README.md
--- a/packages/ui/README.md
+++ b/packages/ui/README.md
@@ -90,8 +90,16 @@
 ### Comments from outside the space
 
 A goal page has a **Community** section when an admin has turned guest comments on
-(`setGuestComments`, folded onto `index.guestCommentsEnabled`). It is the one surface in this app
-whose contents did not come from the fold, and it is built so that stays obvious.
+(`setGuestComments`, folded onto `index.guestCommentsEnabled`) — or when the space has blessed a
+comment on that goal, whether or not the switch is still on. It is the one surface in this app whose
+contents did not come from the fold, and it is built so that stays obvious.
+
+The switch governs **solicitation**, not revocation, and `showsCommunity()` is where the difference
+is spelt out. Turning it off stops the backlink query and takes away the guest composer; it does not
+touch a `blessComment` already in the fold, and that record is in the bundle of every turn on the
+goal until a `retractBless` withdraws it. So blessed rows outlive the switch, along with the button
+that withdraws them — hiding them would leave agents reading prose with nowhere on screen to see it
+or take it back.
 
 The path is: ask [Constellation](https://constellation.microcosm.blue/) which records point at the
 goal, drop every hit whose DID is an active member (their messages are already in the thread), fetch
@@ -112,6 +120,11 @@
 merged into the thread. **Withdrawing** writes `retractBless`, which the blessing's author or an
 active admin may do, and takes it back out of every bundle. A guest who edited their comment after it
 was blessed is badged, because the screen shows the live text while the bundle carries the snapshot.
+
+A comment can accumulate several blessings — "Bless it again" on a withdrawn row writes a second one,
+and two members can bless the same words independently — so `blessedRows()` folds them to one row per
+*comment* and a live blessing always outranks a tombstone on a different one. The row reports what
+the bundle actually carries, and `Withdraw blessing` names the record that is in it.
 
 Signed-in non-members get a composer of their own. It writes an ordinary `message` into *their* repo
 — the same record a member's message is, through the same `runCli` path — which was always possible;
diff --git a/packages/ui/src/app.css b/packages/ui/src/app.css
--- a/packages/ui/src/app.css
+++ b/packages/ui/src/app.css
@@ -650,6 +650,21 @@
 .msg .pending .dot { width: 13px; height: 13px; flex: none; }
 .msg .pending b { color: var(--ink); font-weight: 600; }
 
+/* ─── community (comments from outside the space) ────────────────────────── */
+/* Apart from the thread on purpose. Everything above is a record this space's own fold admitted;
+   everything here is text a stranger wrote that the tab went and fetched. A guest row is inset
+   behind its own rail and reads a shade quieter, so the difference between "somebody here said
+   this" and "a stranger said this" is visible before any badge is read. */
+.community { margin-left: 2px; padding-left: 14px; border-left: 2px solid var(--line-soft); }
+/* One column, not the thread's disc-plus-body two: a guest has no disc, because a coloured identity
+   token beside a stranger's words is the one piece of furniture that would make them look like
+   somebody the space knows. */
+.community .guest { grid-template-columns: 1fr; color: var(--ink-2); }
+.community .guest .msg-acts { grid-column: 1; flex-wrap: wrap; align-items: baseline; }
+/* Blessed: this one is in every turn bundle on the goal, which is worth the accent rail. */
+.community .guest.blessed { border-left: 2px solid var(--accent); margin-left: -16px; padding-left: 14px; }
+.community .guest .hint { font-size: 12.5px; color: var(--warn); }
+
 /* ─── writing ────────────────────────────────────────────────────────────── */
 /* Every field a human types a record into: the goal composer's two, the thread box, the request
    brief, and the assignee picker. One set of rules rather than one per card, because they are one
diff --git a/packages/ui/src/lib/guests.test.ts b/packages/ui/src/lib/guests.test.ts
--- a/packages/ui/src/lib/guests.test.ts
+++ b/packages/ui/src/lib/guests.test.ts
@@ -8,6 +8,7 @@
   didOf,
   discoverGuestComments,
   getBacklinks,
+  showsCommunity,
   unblessArgs,
   unblessable,
   type BacklinkLocator,
@@ -180,7 +181,13 @@
 
 // ── the section's own rows ──────────────────────────────────────────────────────────────────────
 
-const bless = (did: string, rkey: string, comment: { uri: string; cid: string }, body: string) => ({
+const bless = (
+  did: string,
+  rkey: string,
+  comment: { uri: string; cid: string },
+  body: string,
+  createdAt = '2026-01-01T00:05:00Z',
+) => ({
   did,
   uri: `at://${did}/${COLLECTIONS.blessComment}/${rkey}`,
   cid: `cid-${rkey}`,
@@ -192,7 +199,7 @@
     goal: { uri: GOAL, cid: 'cid-goal' },
     comment,
     body,
-    createdAt: '2026-01-01T00:05:00Z',
+    createdAt,
   },
 })
 
@@ -235,6 +242,90 @@
       { ...commentRef, did: GUEST, body: 'Same words', createdAt: '2026-01-01T00:00:00Z' },
     ])
     expect(rows[0]?.edited).toBe(false)
+  })
+
+  // The workflow the section itself offers: bless, withdraw, then "Bless it again". The comment now
+  // carries a live blessing AND a tombstoned one, and the live blessing is what every turn bundle on
+  // this goal reads — so a row that reported "withdrawn" would be telling a member their comment is
+  // out of agent reach while agents were still reading it, and offering the wrong button besides.
+  it('reports a re-blessed comment as blessed, not as the withdrawal it replaced', () => {
+    const withdrawn = bless(MEMBER, 'b1', commentRef, 'First blessing', '2026-01-01T00:05:00Z')
+    const again = bless(MEMBER, 'b2', commentRef, 'Blessed again', '2026-01-01T00:09:00Z')
+    for (const rows of [
+      blessedRows(view([again], [withdrawn])),
+      communityRows(view([again], [withdrawn])),
+    ]) {
+      expect(rows).toHaveLength(1)
+      expect(rows[0]?.retracted).toBe(false)
+      // And it names the LIVE blessing, so `Withdraw blessing` writes a tombstone against the record
+      // that is actually in the bundle rather than re-tombstoning a dead one.
+      expect(rows[0]?.bless?.uri).toBe(again.uri)
+      expect(rows[0]?.body).toBe('Blessed again')
+    }
+  })
+
+  it('still reports withdrawn when every blessing on a comment is withdrawn', () => {
+    const rows = communityRows(
+      view([], [
+        bless(MEMBER, 'b1', commentRef, 'First', '2026-01-01T00:05:00Z'),
+        bless(MEMBER, 'b2', commentRef, 'Second', '2026-01-01T00:09:00Z'),
+      ]),
+    )
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.retracted).toBe(true)
+    expect(rows[0]?.bless?.rkey).toBe('b2')
+  })
+
+  it('gives two comments two rows, and never merges across them', () => {
+    const other = { uri: `at://${GUEST}/${COLLECTIONS.message}/two`, cid: 'cid-two' }
+    const rows = communityRows(
+      view([bless(MEMBER, 'b2', other, 'Live elsewhere')], [bless(MEMBER, 'b1', commentRef, 'Gone')]),
+    )
+    expect(rows.map((row) => [row.uri, row.retracted])).toEqual(
+      expect.arrayContaining([
+        [commentRef.uri, true],
+        [other.uri, false],
+      ]),
+    )
+    expect(rows).toHaveLength(2)
+  })
+
+  // Discovery running over a re-blessed comment must not undo the merge either: `communityRows`
+  // takes the live body for display, and the blessing it carries has to stay the live one.
+  it('keeps the live blessing when discovery supplies the same comment', () => {
+    const withdrawn = bless(MEMBER, 'b1', commentRef, 'First blessing', '2026-01-01T00:05:00Z')
+    const again = bless(MEMBER, 'b2', commentRef, 'Blessed again', '2026-01-01T00:09:00Z')
+    const rows = communityRows(view([again], [withdrawn]), [
+      { ...commentRef, did: GUEST, body: 'Blessed again', createdAt: '2026-01-01T00:00:00Z' },
+    ])
+    expect(rows[0]?.retracted).toBe(false)
+    expect(rows[0]?.bless?.uri).toBe(again.uri)
+    expect(rows[0]?.edited).toBe(false)
+  })
+})
+
+// The switch is solicitation, not revocation, and the section has to outlive it: a blessing stays in
+// the bundle of every turn on the goal until a `retractBless` withdraws it, so a page that hid the
+// section would leave agents reading prose with nowhere on screen to see it or take it back.
+describe('whether the section is drawn at all', () => {
+  const commentRef = { uri: `at://${GUEST}/${COLLECTIONS.message}/one`, cid: 'cid-one' }
+
+  it('draws it whenever the space is asking for comments', () => {
+    expect(showsCommunity(view([]), true)).toBe(true)
+  })
+
+  it('keeps drawing it with the switch off while a live blessing stands', () => {
+    expect(showsCommunity(view([bless(MEMBER, 'b1', commentRef, 'In every bundle')]), false)).toBe(true)
+  })
+
+  it('keeps drawing it with the switch off for a withdrawn blessing too', () => {
+    // Not in any bundle any more, but it is the space's own record of a decision, and the row is
+    // where "this was withdrawn" is said at all.
+    expect(showsCommunity(view([], [bless(MEMBER, 'b1', commentRef, 'Withdrawn')]), false)).toBe(true)
+  })
+
+  it('drops it only when the switch is off and the space blessed nothing here', () => {
+    expect(showsCommunity(view([]), false)).toBe(false)
   })
 })
 
diff --git a/packages/ui/src/lib/guests.ts b/packages/ui/src/lib/guests.ts
--- a/packages/ui/src/lib/guests.ts
+++ b/packages/ui/src/lib/guests.ts
@@ -240,19 +240,60 @@
   edited: boolean
 }
 
-/** The blessings this space holds for a goal, live and withdrawn, as rows. */
+/**
+ * Whether the goal page draws the Community section at all.
+ *
+ * `setGuestComments` governs SOLICITATION: with it off, the page stops querying the backlink index
+ * and stops the composer inviting anybody. It is deliberately NOT revocation, and this is where the
+ * difference has teeth — a blessing already in the fold is in the bundle of every turn on this goal
+ * until a `retractBless` withdraws it. Hiding the section on the switch would take away the only
+ * screen that prose appears on and the only control that removes it, while agents went on reading
+ * it. So the section outlives the switch for as long as the space holds a blessing on this goal.
+ */
+export const showsCommunity = (view: GoalView, enabled: boolean): boolean =>
+  enabled || view.blessedComments.length > 0 || view.retractedBlessings.length > 0
+
+/**
+ * The blessings this space holds for a goal, live and withdrawn, as rows — one row per COMMENT,
+ * never one per blessing record.
+ *
+ * A comment can carry several blessings, and the section itself is what produces them: "Bless it
+ * again" on a withdrawn row writes a second `blessComment` beside the tombstoned first, and two
+ * members can independently bless the same words. So the row has to answer one question about the
+ * comment — is anything the space signed for it still live? — and a LIVE blessing always wins,
+ * because a live blessing is what the turn bundle carries. Letting a stale tombstone speak for a
+ * comment that is in every bundle right now would invert the one fact this section exists to report.
+ *
+ * Among several of the same kind the last wins: the fold orders blessings (createdAt, uri), so that
+ * is the space's most recent decision, and it is the one `Withdraw blessing` should name.
+ */
 export function blessedRows(view: GoalView): CommunityRow[] {
-  const rows = (blessings: Array<IndexedRecord<BlessCommentRecord>>, retracted: boolean) =>
-    blessings.map((bless) => ({
-      uri: bless.value.comment.uri,
+  const live = new Map<string, IndexedRecord<BlessCommentRecord>>()
+  const withdrawn = new Map<string, IndexedRecord<BlessCommentRecord>>()
+  for (const bless of view.blessedComments) live.set(bless.value.comment.uri, bless)
+  for (const bless of view.retractedBlessings) withdrawn.set(bless.value.comment.uri, bless)
+  const rows: CommunityRow[] = []
+  for (const uri of new Set([...live.keys(), ...withdrawn.keys()])) {
+    const bless = live.get(uri) ?? withdrawn.get(uri)
+    if (!bless) continue
+    rows.push({
+      uri,
       cid: bless.value.comment.cid,
-      did: didOf(bless.value.comment.uri),
+      did: didOf(uri),
       body: bless.value.body,
       bless,
-      retracted,
+      retracted: !live.has(uri),
       edited: false,
-    }))
-  return [...rows(view.blessedComments, false), ...rows(view.retractedBlessings, true)]
+    })
+  }
+  // (createdAt, uri) over the BLESSING, since a row built from a snapshot has no guest timestamp of
+  // its own — enough to make the list stable, and `communityRows` re-sorts once discovery supplies
+  // the real ones.
+  return rows.sort(
+    (left, right) =>
+      (left.bless?.value.createdAt ?? '').localeCompare(right.bless?.value.createdAt ?? '') ||
+      left.uri.localeCompare(right.uri),
+  )
 }
 
 /**
diff --git a/packages/ui/src/lib/components/Community.svelte b/packages/ui/src/lib/components/Community.svelte
--- a/packages/ui/src/lib/components/Community.svelte
+++ b/packages/ui/src/lib/components/Community.svelte
@@ -37,10 +37,17 @@
   interface Props {
     view: GoalView
     space: Space
+    /**
+     * Whether to go and ask the backlink index. False when the space has guest comments switched
+     * off: the switch governs SOLICITATION, so it stops this tab querying somebody else's service
+     * and stops the composer inviting new comments — but what the space has already blessed is in
+     * the fold and in every turn bundle, and stays on screen with the control to withdraw it.
+     */
+    discover?: boolean
     /** Injected by the component test; the real one is the space's own read transport. */
     reader?: ForeignReader | undefined
   }
-  const { view, space, reader }: Props = $props()
+  const { view, space, discover = true, reader }: Props = $props()
 
   let discovered = $state<GuestComment[]>([])
   let looking = $state(false)
@@ -56,6 +63,14 @@
   const mayBless = $derived(writable && participates(space.directory, me))
   const rows = $derived(communityRows(view, discovered))
   const live = $derived(rows.filter((row) => row.bless && !row.retracted).length)
+  // With the switch off nothing was looked for, so "none found" would be claiming a search happened.
+  const empty = $derived(
+    looking
+      ? 'Looking…'
+      : discover
+        ? 'No comments from outside this space.'
+        : 'Nothing from outside this space has been blessed.',
+  )
 
   const foreign = (): ForeignReader | undefined => {
     if (reader) return reader
@@ -82,7 +97,14 @@
     const goalUri = view.target.uri
     const members = memberKey ? memberKey.split(' ') : []
     const read = foreign()
-    if (space.fixture || !read) return undefined
+    if (!discover || space.fixture || !read) {
+      // Whatever a previous lookup found is dropped rather than left standing: with the switch off
+      // the only thing this section may speak for is what the space itself signed.
+      discovered = []
+      failed = 0
+      lookupError = ''
+      return undefined
+    }
     const controller = new AbortController()
     looking = true
     lookupError = ''
@@ -137,8 +159,13 @@
   {#if live > 0}<span class="n">· {live} blessed</span>{/if}
 </div>
 <p class="grouphint">
-  Comments from people who are not members of this space, found through a public backlink index and
-  read from their own repos. Nothing here reaches an agent until a member blesses it.
+  {#if discover}
+    Comments from people who are not members of this space, found through a public backlink index and
+    read from their own repos. Nothing here reaches an agent until a member blesses it.
+  {:else}
+    This space is no longer asking for comments from outside it, so nothing new is being looked for.
+    What a member already blessed is still read by every turn on this goal until it is withdrawn.
+  {/if}
 </p>
 
 {#if lookupError}
@@ -158,7 +185,7 @@
 
 {#if rows.length === 0}
   <div class="empty">
-    <p>{looking ? 'Looking…' : 'No comments from outside this space.'}</p>
+    <p>{empty}</p>
   </div>
 {:else}
   <div class="community">
@@ -227,35 +254,3 @@
 {#if error}
   <p class="write-error" role="alert">{error}</p>
 {/if}
-
-<style>
-  /* Apart from the thread on purpose. A guest row is inset behind its own rail and reads a shade
-     quieter than a member's, so the difference between "somebody here said this" and "a stranger
-     said this" is visible before any badge is read. */
-  .community {
-    margin-left: 2px;
-    padding-left: 14px;
-    border-left: 2px solid var(--line-soft);
-  }
-  /* One column, not the thread's disc-plus-body two: a guest has no disc, because a coloured
-     identity token beside a stranger's words is the one piece of visual furniture that would make
-     them look like somebody the space knows. */
-  .guest {
-    grid-template-columns: 1fr;
-    color: var(--ink-2);
-  }
-  .guest .msg-acts {
-    grid-column: 1;
-    flex-wrap: wrap;
-    align-items: baseline;
-  }
-  .guest.blessed {
-    border-left: 2px solid var(--accent);
-    margin-left: -16px;
-    padding-left: 14px;
-  }
-  .guest .hint {
-    font-size: 12.5px;
-    color: var(--warn);
-  }
-</style>
diff --git a/packages/ui/src/lib/components/Community.svelte.test.ts b/packages/ui/src/lib/components/Community.svelte.test.ts
--- a/packages/ui/src/lib/components/Community.svelte.test.ts
+++ b/packages/ui/src/lib/components/Community.svelte.test.ts
@@ -28,7 +28,7 @@
 const GUEST = 'did:plc:guest'
 const HOSTILE = '<img src=x onerror="document.title=\'pwned\'"> **not bold**'
 
-const bless = (rkey: string, body: string, comment: string) => ({
+const bless = (rkey: string, body: string, comment: string, createdAt = '2026-01-01T00:05:00Z') => ({
   did: 'did:plc:member',
   uri: `at://did:plc:member/${COLLECTIONS.blessComment}/${rkey}`,
   cid: `cid-${rkey}`,
@@ -40,7 +40,7 @@
     goal: { uri: GOAL, cid: 'cid-goal' },
     comment: { uri: `at://${GUEST}/${COLLECTIONS.message}/${comment}`, cid: `cid-${comment}` },
     body,
-    createdAt: '2026-01-01T00:05:00Z',
+    createdAt,
   },
 })
 
@@ -78,7 +78,12 @@
   host.remove()
 })
 
-const render = (props: { view: GoalView; space: Space; reader?: ForeignReader }): void => {
+const render = (props: {
+  view: GoalView
+  space: Space
+  discover?: boolean
+  reader?: ForeignReader
+}): void => {
   component = mount(Community, { target: host, props }) as Record<string, unknown>
   flushSync()
 }
@@ -110,6 +115,54 @@
   it('says nothing has been found rather than showing an empty list', () => {
     render({ view: view([]), space: space() })
     expect(host.textContent).toContain('No comments from outside this space')
+  })
+
+  it('offers withdrawal, not a third blessing, once a withdrawn comment is blessed again', () => {
+    render({
+      view: view(
+        [bless('b2', 'Blessed again', 'c1', '2026-01-01T00:09:00Z')],
+        [bless('b1', 'First blessing', 'c1', '2026-01-01T00:05:00Z')],
+      ),
+      space: space(),
+    })
+    const labels = [...host.querySelectorAll('button')].map((entry) => entry.textContent?.trim())
+    expect(labels).toContain('Withdraw blessing')
+    expect(labels).not.toContain('Bless it again')
+    expect(host.textContent).toContain('blessed')
+    expect(host.textContent).not.toContain('blessing withdrawn')
+  })
+
+  // The switch governs solicitation. Prose a member signed for is in the bundle of every turn on
+  // this goal until it is withdrawn, so it stays on screen with the control that removes it —
+  // hiding the section would leave agents reading text nobody could see or retract.
+  it('keeps a blessed comment and its withdrawal control when discovery is off', () => {
+    render({
+      view: view([bless('b1', 'Still in every bundle', 'c1')]),
+      space: space(),
+      discover: false,
+    })
+    expect(host.textContent).toContain('Still in every bundle')
+    expect(
+      [...host.querySelectorAll('button')].map((entry) => entry.textContent?.trim()),
+    ).toContain('Withdraw blessing')
+    // …and it does not claim a lookup happened.
+    expect(host.textContent).not.toContain('found through a public backlink index')
+    expect(host.textContent).toContain('no longer asking for comments')
+  })
+
+  it('does not query the index at all when discovery is off', () => {
+    const fetched = vi.fn(async () => new Response('{}', { status: 200 }))
+    const read = vi.fn()
+    vi.stubGlobal('fetch', fetched)
+    render({
+      view: view([bless('b1', 'Blessed', 'c1')]),
+      space: space(),
+      discover: false,
+      reader: { getForeignRecord: read as unknown as ForeignReader['getForeignRecord'] },
+    })
+    expect(fetched).not.toHaveBeenCalled()
+    expect(read).not.toHaveBeenCalled()
+    vi.unstubAllGlobals()
   })
 
   it('makes blessing a two-step, and writes only on the second press', async () => {
diff --git a/packages/ui/src/routes/g/[did]/[rkey]/+page.svelte b/packages/ui/src/routes/g/[did]/[rkey]/+page.svelte
--- a/packages/ui/src/routes/g/[did]/[rkey]/+page.svelte
+++ b/packages/ui/src/routes/g/[did]/[rkey]/+page.svelte
@@ -14,6 +14,7 @@
   import UriChip from '$lib/components/UriChip.svelte'
   import Who from '$lib/components/Who.svelte'
   import { shortDate } from '$lib/format.js'
+  import { showsCommunity } from '$lib/guests.js'
   import { currentSpace } from '$lib/session.svelte.js'
   import type { ThreadMessage } from '$lib/replies.js'
   import { goalByRoute, unitsOf } from '$lib/space.js'
@@ -34,6 +35,8 @@
   const ending = $derived(goal ? endingBadge(goal) : undefined)
   /** Whether this space asks non-members for comments — an admin's `setGuestComments` overlay. */
   const community = $derived(space.index.guestCommentsEnabled)
+  /** …and whether the section is drawn at all, which the switch alone does not decide. */
+  const section = $derived(goal ? showsCommunity(goal, community) : false)
 
   /** The message the composer is answering, when Reply pointed it at one. */
   let replyTo = $state<ThreadMessage | undefined>(undefined)
@@ -123,13 +126,14 @@
        same record with one more field on it. -->
   <Thread view={goal} {space} onReply={(message) => (replyTo = message)} />
   <Composer view={goal} {space} {replyTo} clearReply={() => (replyTo = undefined)} />
-  <!-- Below the space's own conversation, and only when the space has asked for it. A blessing this
-       space already holds is folded and would render with the toggle off too — but a section that
-       appeared and disappeared on a setting is worse than one that is simply not part of a space
-       that does not want guests, so the whole thing is behind the switch. Retract a blessing to
-       take it out of agent reach; the toggle is about solicitation, not revocation. -->
+  <!-- Below the space's own conversation. The switch governs SOLICITATION, and the two conditions
+       differ on purpose: `showsCommunity` keeps what the space already blessed on screen — with the
+       control that withdraws it — after the switch goes off, because that prose is still in every
+       turn bundle on this goal. Only the composer and the index lookup go away with the switch. -->
+  {#if section}
+    <Community view={goal} {space} discover={community} />
+  {/if}
   {#if community}
-    <Community view={goal} {space} />
     <GuestComposer view={goal} {space} />
   {/if}
   <!-- Last on the page, deliberately. Closing a goal is the end of reading it, not a control to

--
tangled.sh