@immediately-run/grove 0.1.5 → 0.1.7

package/llms.txt

@@ -1,6 +1,6 @@
 # @immediately-run/grove — the viewer kit for directory-as-content wikis
 
-> The Grove viewer: a kit of React components, layouts and themes for building immediately.run wikis. Composable as a fork, a dispatch target, or a pinned library. (v0.1.5)
+> The Grove viewer: a kit of React components, layouts and themes for building immediately.run wikis. Composable as a fork, a dispatch target, or a pinned library. (v0.1.7)
 
 Grove is NOT a wiki engine: routing, MDX compilation, the frontmatter index, link
 spaces and heading anchors live in the sandbox + `@immediately-run/sdk`. What this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immediately-run/grove",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "main": "src/main.tsx",
   "immediately.run": {
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@immediately-run/mdx-plugins": "0.7.1",
-    "@immediately-run/sdk": "^0.67.0",
+    "@immediately-run/sdk": "^0.72.0",
     "react": "^19.2.5",
     "react-dom": "^19.2.5"
   },
@@ -87,7 +87,7 @@
     "llms.txt"
   ],
   "peerDependencies": {
-    "@immediately-run/sdk": "^0.67.0",
+    "@immediately-run/sdk": "^0.72.0",
     "react": "^19.2.5",
     "react-dom": "^19.2.5"
   }

package/src/GroveApp.css

@@ -2654,6 +2654,23 @@ button.grove-search__row {
 .ga-reach__row--neutral .ga-reach__mark {
   color: var(--ink-3);
 }
+.ga-reach__row--elsewhere .ga-reach__mark {
+  /* A destination, not an approval and not a denial (R3-752): ink, not accent. */
+  color: var(--ink);
+}
+/* The row's state as text, for the screen reader the glyph gives nothing (R3-752,
+   R-IX-7): visually hidden, never removed from the tree. */
+.ga-reach__stateword {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+  border: 0;
+}
 .ga-reach__label {
   color: var(--ink);
   font-weight: 500;

package/src/GroveWiki.tsx

@@ -33,7 +33,7 @@ import { preferredPolarity } from './data/themes';
 import { useDirectoryListing } from './hooks/useDirectoryListing';
 import { useScrollReset } from './hooks/useScrollReset';
 import { useEditAffordance } from './hooks/useEditAffordance';
-import { getContentRoot } from './lib/contentRoot';
+import { getContentRoot, isDispatched } from './lib/contentRoot';
 import type { RejectedComponent } from './lib/corpusComponents';
 import { GroveShellContext, OutletContext } from './lib/shell';
 import type { GroveShell, NavItem } from './lib/shell';
@@ -415,10 +415,29 @@ export default function GroveWiki({
   return (
     // R3-277b: declare the enclosing bundle for the platform's link-space consumers
     // (the shared resolver's bundle-anchored absolute + `$fs:` handling read this).
-    // R3-482: the field keeps the deprecated `corpusRoot` spelling until grove's SDK
-    // pin reaches a release whose WikiLink reads `bundleRoot` (sdk#171 / 0.68.1) —
-    // stating only the new spelling now would silently un-anchor every absolute link.
-    <LinkSpaceContext.Provider value={{ corpusRoot: getContentRoot() }}>
+    // R3-482: the SDK pin (^0.72.0, #75) reads `bundleRoot` new-then-old, so the new
+    // spelling is stated alone — the deprecated `corpusRoot` stays in the type for
+    // older consumers (mdx-plugins' forever-compat) but no longer here.
+    <LinkSpaceContext.Provider
+      value={{
+        bundleRoot: getContentRoot(),
+        // R3-184 S2 (PERSISTENCE_SPEC §8.3) — the `$fs:` clamp, on this render path.
+        // The clamp that is IN FORCE lives in `lib/content.ts` (`linkSpaceOpts`):
+        // `hrefTargetKey` is where a corpus document's link targets actually
+        // resolve (grove's own WikiLink override routes there), and it passes
+        // `bundleChrooted: isDispatched()` to the shared resolver (R3-319's
+        // chroot), so a dispatched corpus document's `$fs:/mnt/{hash}/…` cannot
+        // name a federated mount materialised beside it — the app-level mount
+        // point is not a corpus path — and the fork's `$fs:` stays
+        // mount-absolute. THIS field carries the same flag for the SDK's generic
+        // component consumers (WikiLink/MDXComponents): the pinned SDK 0.72.0
+        // does not forward it, so it is decided-but-not-consumed until a
+        // forwarding release is published and pinned — the booked follow-up,
+        // stated here rather than blurred (§8.3's dated note:
+        // built-but-not-in-force is a materially different state from done).
+        bundleChrooted: isDispatched(),
+      }}
+    >
     {/* R3-174: the bundle scope CONTENT reads — sibling to the link space, not a
         replacement for it. The two answer different questions: `LinkSpaceContext` tells
         the platform's link resolver where absolute hrefs are anchored; `BundleContext`

package/src/components/GroveAgent.test.tsx

@@ -7,7 +7,7 @@
 // the hooks — the component reads what the host would have said.
 import { describe, it, expect, vi, beforeAll } from 'vitest';
 import { act } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
+import { createRoot } from 'react-dom/client';
 
 // `useHeadings` scans the DOM (no .grove-prose in this harness ⇒ no headings — fine).
 // `fs` is read only through safeSources on the stuffing path, never in these cases.
@@ -21,77 +21,11 @@ vi.mock('@immediately-run/sdk', async (importOriginal) => ({
   runAgent: (opts: unknown) => runAgentMock(opts),
 }));
 
-// An EMITTING stub transport: push channels subscribe per type and tests emit
-// host→app messages through it (the same wire the real host speaks).
-// The transport contract (`hostTransport.ts`): `onMessage(handler)` receives EVERY
-// host→app message; the SDK's addListener filters by `msg.type` itself.
-type Handler = (msg: Record<string, unknown>) => void;
-const handlers = new Set<Handler>();
-const emit = (msg: Record<string, unknown>): void => {
-  for (const h of handlers) h(msg);
-};
-// Controllable per-case (the edit-refusal probe rejects through it); the
-// default resolves like a permissive host.
-const protocolRequest = vi.fn(async () => ({}));
-(globalThis as { __immediatelyRun__?: unknown }).__immediatelyRun__ = {
-  transport: {
-    sendMessage: vi.fn(),
-    protocolRequest,
-    onMessage: (handler: Handler) => {
-      handlers.add(handler);
-      return { dispose: () => handlers.delete(handler) };
-    },
-  },
-};
-
-import type { GroveShell } from '../lib/shell';
-import { TinkerableContext } from '@immediately-run/sdk/TinkerableContext';
-const { default: GroveAgent } = await import('./GroveAgent');
-const { GroveShellContext } = await import('../lib/shell');
-
-const NAV = {
-  mode: 'github',
-  namespace: 'immediately-run',
-  provider: 'github',
-  repository: 'docs',
-  ref: 'main',
-  sandboxPath: '/app',
-  hash: '',
-  search: '',
-};
-
-const shell: GroveShell = { openEditor: vi.fn() } as unknown as GroveShell;
-
-async function renderAgent(props: { writable: boolean }): Promise<{ root: Root; container: HTMLElement }> {
-  const container = document.createElement('div');
-  document.body.appendChild(container);
-  const root = createRoot(container);
-  await act(async () => {
-    root.render(
-      <GroveShellContext.Provider value={shell}>
-        <TinkerableContext.Provider
-          value={{ outerHref: '', navigationState: NAV, routingSpec: {} as never, filesMetadata: {} }}
-        >
-          <GroveAgent {...props} entryKey="/app/content/wiki/security.mdx" entryTitle="Security" />
-        </TinkerableContext.Provider>
-      </GroveShellContext.Provider>,
-    );
-  });
-  return { root, container };
-}
-
-const openPanel = async (container: HTMLElement): Promise<void> => {
-  await act(async () => {
-    (container.querySelector('.ga-line input') as HTMLInputElement)?.focus();
-  });
-};
-
-/** Drive host→app pushes the way the host would: after the app subscribed. */
-const push = async (msg: Record<string, unknown>): Promise<void> => {
-  await act(async () => {
-    emit(msg);
-  });
-};
+// The transport stub, the renderer and the push driver live in
+// `src/test/groveAgentHarness.tsx` — shared rather than copied, because
+// `GroveAgent.unanswered.test.tsx` needs the same harness in a module registry where the
+// catalog has never been answered (grove#75 round 3).
+const { renderAgent, openPanel, push, protocolRequest } = await import('../../test/groveAgentHarness');
 
 // NOTE: no per-test handler reset. The SDK's push channels are module-global and
 // subscribe to the transport exactly once (the `started` flag in `createPushChannel`),
@@ -101,15 +35,29 @@ const push = async (msg: Record<string, unknown>): Promise<void> => {
 describe('G-GA-1 — no unbacked capability claims in the DOM', () => {
   it('writable=false + no provider: no write-flavored chip, no phantom-write copy', async () => {
     const { container } = await renderAgent({ writable: false });
-    await push({ type: 'llm-provider', provider: null }); // answered: not-configured
-    await push({ type: 'api-catalog', methods: [] }); // nothing granted
+    // The host generation this models matters, because the two pushes below only make
+    // sense together on ONE of them. R-LLM-2 says a frame lacking `llm:chat` is answered
+    // `{ provider: null }` — the SAME payload as a granted frame with no key — so on a
+    // host that predates R3-688's `ungranted` mark this pair (null provider, empty
+    // catalog) is exactly what an ungranted fork sees, and it is indistinguishable at the
+    // provider channel from keyless-but-granted. That indistinguishability IS R3-688.
+    // A 0.72.0 host would instead mark the answer, which the R3-688 case below covers.
+    await push({ type: 'llm-provider', provider: null }); // pre-mark host: null either way
+    await push({ type: 'api-catalog', methods: [] }); // nothing granted — the deciding fact
     await openPanel(container);
     const text = container.textContent ?? '';
     expect(text).not.toMatch(/add an entry|fix broken links|reorganize the sidebar|add a timeline/i);
     expect(text).not.toMatch(/proposes the edit|host confirms the write/i);
     expect(container.querySelectorAll('.ga-chip').length).toBe(0); // no ✓ rows ⇒ no chips
-    // And the honest causes ARE there:
-    expect(text).toContain('no model key connected');
+    // And the honest causes ARE there. R3-688 CHANGED which one this case gets, and the
+    // change is the point of the item. On a pre-mark host the provider channel cannot
+    // tell keyless from ungranted, so the CATALOG is the only fact that discriminates —
+    // and it says not granted. The old order asked not-configured first and therefore
+    // told a user who may well have a key to go add one, which cannot unblock them.
+    // The key cause is still rendered for a frame the catalog says IS granted
+    // (`reachCard.test.ts` — "not-configured names the KEY cause").
+    expect(text).toContain("wasn't granted chat");
+    expect(text).not.toContain('no model key connected');
     expect(text).toContain('you’re a reader here');
   });
 });
@@ -135,6 +83,22 @@ describe('G-GA-2 / R-GA-5 — read-only never blocks Q&A', () => {
     expect(container.textContent).not.toMatch(/Suggest an edit/i); // no write chip while read-only
   });
 
+  it('keyless but GRANTED renders the KEY cause — the case the catalog decides the other way', async () => {
+    // The counterpart the suite lost when the G-GA-1 case above changed verdict, and the
+    // one that proves the reorder did not simply make the grant cause win everywhere.
+    // Same provider payload as that case — `{ provider: null }`, which R-LLM-2 gives both
+    // a keyless frame and (on a pre-mark host) an ungranted one — but the catalog says
+    // `llm:chat` IS granted. So the only actionable fact is the missing key, and that is
+    // what the card must say.
+    const { container } = await renderAgent({ writable: true });
+    await push({ type: 'llm-provider', provider: null });
+    await push({ type: 'api-catalog', methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }] });
+    await openPanel(container);
+    const text = container.textContent ?? '';
+    expect(text).toContain('no model key connected — add one in Settings');
+    expect(text).not.toContain("wasn't granted chat");
+  });
+
   it('an ungranted fork renders the DISTINCT forbidden cause, never connect-a-key copy', async () => {
     const { container } = await renderAgent({ writable: true });
     await push({
@@ -154,6 +118,19 @@ describe('G-GA-2 / R-GA-5 — read-only never blocks Q&A', () => {
     expect(input.disabled).toBe(true); // cannot ask — but reading works, and the card says why
   });
 
+  it('R3-688 — the host-marked grantless answer renders the consent cause without any provider', async () => {
+    // The ungranted fork is answered {provider:null, ungranted:true} — never the
+    // provider — so before the mark this fork could only render the KEY copy. The
+    // mark is the host's grant decision; the card repeats it, never invents it.
+    const { container } = await renderAgent({ writable: true });
+    await push({ type: 'llm-provider', provider: null, ungranted: true });
+    await push({ type: 'api-catalog', methods: [] });
+    await openPanel(container);
+    const text = container.textContent ?? '';
+    expect(text).toContain("this Grove wasn't granted chat — reading works as normal");
+    expect(text).not.toContain('add one in Settings'); // the KEY copy — never conflated (G-GA-10)
+  });
+
   it('R-GA-6 — the egress disclosure shows whenever a provider is bound', async () => {
     const { container } = await renderAgent({ writable: false });
     await push({
@@ -168,6 +145,79 @@ describe('G-GA-2 / R-GA-5 — read-only never blocks Q&A', () => {
     await openPanel(container);
     expect(container.textContent).toContain('answers come from your connected model provider');
   });
+
+  // R3-752 — the apply row is a DESTINATION: `→` on the row, no ✗ anywhere on the
+  // card, and every row's state is text as well as glyph.
+  it('R3-752 — read-only + configured granted provider: the apply row renders → elsewhere, never ✗, with hidden state words', async () => {
+    const { container } = await renderAgent({ writable: false });
+    await push({
+      type: 'llm-provider',
+      provider: {
+        providerId: 'llm.chat.anthropic',
+        hostVouched: true,
+        features: { vision: false, tools: true, jsonMode: true, reasoning: false, maxContextTokens: 100000 },
+      },
+    });
+    await push({ type: 'api-catalog', methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }] });
+    await openPanel(container);
+    const card = container.querySelector('.ga-reach')!;
+    const applyRow = card.querySelector('.ga-reach__row--elsewhere')!;
+    expect(applyRow.textContent).toContain('Apply changes');
+    expect(applyRow.textContent).toContain('→ in the editor or workbench, where you confirm them');
+    // A destination is never rendered as a denial: the card's only ✗ is the draft
+    // row's (read-only), the apply row's mark is the arrow.
+    expect(applyRow.querySelector('.ga-reach__mark')!.textContent).toBe('→');
+    expect(card.textContent).not.toContain('changes open in the editor'); // the old cause copy is gone
+    // State is text, never glyph alone: the hidden words are in the tree.
+    const words = [...card.querySelectorAll('.ga-reach__stateword')].map((n) => n.textContent);
+    expect(words).toContain('available');
+    expect(words).toContain('unavailable');
+    expect(words).toContain('opens elsewhere');
+    // The substrate is context, stated, with the git-indeterminate trust line under
+    // the card (the SDK's fail-closed default basis).
+    expect(card.textContent).toContain('Reads its own entries');
+    expect(card.parentElement!.textContent).toContain('anyone who can push to this repo can change what the agent reads');
+  });
+
+  it('R3-752 — a grant flip is ANNOUNCED, not only re-rendered (R-IX-7): the standing live region tracks the card', async () => {
+    const { container } = await renderAgent({ writable: false });
+    await push({
+      type: 'llm-provider',
+      provider: {
+        providerId: 'llm.chat.anthropic',
+        hostVouched: true,
+        features: { vision: false, tools: true, jsonMode: true, reasoning: false, maxContextTokens: 100000 },
+      },
+    });
+    await push({ type: 'api-catalog', methods: [] }); // key, but NOT granted chat
+    await openPanel(container);
+    const live = container.querySelector('[role="status"].ga-reach__stateword')!;
+    expect(live.getAttribute('aria-live') ?? 'polite').toBe('polite'); // role=status is polite by default
+    expect(live.textContent).toContain('unavailable'); // the blocked Q&A row, in words
+
+    // Grant chat: the flip must change the announcement — the Q&A segment goes
+    // unavailable → available (the draft row stays honestly unavailable; read-only).
+    await push({ type: 'api-catalog', methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }] });
+    expect(live.textContent).toContain('Answer questions about this wiki — available');
+    expect(live.textContent).not.toContain('Answer questions about this wiki — unavailable');
+  });
+
+  it('R3-752 — a configured provider WITHOUT tools keeps Q&A ✓ and shows the degrade qualifier, not silence', async () => {
+    const { container } = await renderAgent({ writable: false });
+    await push({
+      type: 'llm-provider',
+      provider: {
+        providerId: 'llm.chat.anthropic',
+        hostVouched: true,
+        features: { vision: false, tools: false, jsonMode: true, reasoning: false, maxContextTokens: 100000 },
+      },
+    });
+    await push({ type: 'api-catalog', methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }] });
+    await openPanel(container);
+    const answerRow = container.querySelector('.ga-reach__row--ok')!;
+    expect(answerRow.textContent).toContain('Answer questions about this wiki');
+    expect(answerRow.textContent).toContain('reads a summary of this wiki, not entries on demand');
+  });
 });
 
 describe('R3-608 — the composer stops the run; a refusal surfaces, a cancel does not', () => {
@@ -278,21 +328,10 @@ describe('R3-608 — the composer stops the run; a refusal surfaces, a cancel do
   });
 
   it('the agent panel renders the refusal text where the affordance is offered', async () => {
-    const host = document.createElement('div');
-    document.body.appendChild(host);
-    const root = createRoot(host);
-    const refusingShell: GroveShell = { openEditor: vi.fn(), editRefused: true } as unknown as GroveShell;
-    await act(async () => {
-      root.render(
-        <GroveShellContext.Provider value={refusingShell}>
-          <TinkerableContext.Provider
-            value={{ outerHref: '', navigationState: NAV, routingSpec: {} as never, filesMetadata: {} }}
-          >
-            <GroveAgent writable={false} entryKey="/app/content/wiki/security.mdx" entryTitle="Security" />
-          </TinkerableContext.Provider>
-        </GroveShellContext.Provider>,
-      );
-    });
+    const { root, container: host } = await renderAgent(
+      { writable: false },
+      { shell: { editRefused: true } as Partial<import('../lib/shell').GroveShell> },
+    );
     await openPanel(host);
     expect(host.textContent).toContain('Could not open the editor — the host refused');
     await act(async () => {

package/src/components/GroveAgent.tsx

@@ -15,18 +15,22 @@ import { useOverlayFocusDismiss } from '../hooks/useOverlayFocusDismiss';
 import { getContentRoot } from '../lib/contentRoot';
 import { createReadEntryTool, createGroveMetadataTool, groveAgentTools, toolExecutor } from '../lib/agentTools';
 import { buildSystemPrompt } from '../lib/agentPrompt';
-import { computeReachRows, reachChips, showEgressDisclosure, EGRESS_DISCLOSURE } from '../lib/reachCard';
+import { computeReachRows, reachChips, sourceTrustLine, stateWord, showEgressDisclosure, EGRESS_DISCLOSURE } from '../lib/reachCard';
+import { getCorpusMountId } from '../lib/contentRoot';
 import { transcriptToRows, toolActivityLine, type AgentRow } from '../lib/agentTranscript';
+import { useCatalogAnswered } from '../hooks/useCatalogAnswered';
 import { safeSources } from '../lib/safeSources';
 import Icon from './Icon';
 
 // `.grove-agent` — Grove's own embedded agent (GROVE_AGENT_SPEC).
 //
 // The surface is a FUNCTION of the session's envelope (R-GA-1): the reach card in
-// the expanded header is computed from the provider three-state, the `llm:chat`
-// grant (the grant-filtered catalog), mount writability, and source trust — never
-// hand-written copy. The loop rides the workbench's seam — SDK `runAgent` over the
-// host `llm.chat` slot — and its two tools are the mount-chrooted `read_entry` and
+// the expanded header is computed from the provider four-state (R3-688 added the
+// host-marked `ungranted` — the distinct not-granted cause), the `llm:chat`
+// grant (the grant-filtered catalog), mount writability, the corpus packaging,
+// tools support, and source trust — never hand-written copy. The loop rides the
+// workbench's seam — SDK `runAgent` over the host `llm.chat` slot — and its two
+// tools are the mount-chrooted `read_entry` and
 // the index query (R-GA-2). The widget never writes (R-GA-3): every change is a
 // hand-off to the editor / workbench. Read-only never blocks Q&A (R-GA-5). When a
 // provider is bound the egress line is shown unconditionally (R-GA-6). Every
@@ -66,12 +70,40 @@ export default function GroveAgent({
   // catalog iff this app holds the consent — an ungranted fork reads a DISTINCT
   // cause from a user without a key (G-GA-10).
   const chatGranted = catalog.some((m) => m.name === 'llm:chat');
+  // Distinguishes "granted nothing" from "has not replied yet" — `catalog` alone cannot,
+  // because an empty catalog is a legitimate answer. See the hook for how it is derived.
+  const catalogAnswered = useCatalogAnswered();
   const context = useAgentContext({ entryPath: entryKey, entryTitle, heading: activeHeading || undefined });
+  // G-GA-8: a provider without `features.tools` degrades to context-stuffing.
+  // Computed ONCE at render scope — the reach card's Q&A qualifier (R3-752) and the
+  // ask() path below read the same fact, never two computations of it.
+  const toolsSupported = providerState.status === 'configured' && providerState.provider.features.tools === true;
   const reachRows = useMemo(
-    () => computeReachRows({ providerState, chatGranted, writable, sourceShared: context.sourceShared }),
-    [providerState, chatGranted, writable, context.sourceShared],
+    () =>
+      computeReachRows({
+        providerState,
+        chatGranted,
+        catalogAnswered,
+        writable,
+        sourceShared: context.sourceShared,
+        mountId: getCorpusMountId(),
+        toolsSupported,
+      }),
+    [providerState, chatGranted, catalogAnswered, writable, context.sourceShared, toolsSupported],
   );
   const chips = useMemo(() => reachChips(reachRows), [reachRows]);
+  const trustLine = useMemo(
+    () => sourceTrustLine(context.sourceShared, context.sourceSharedBasis),
+    [context.sourceShared, context.sourceSharedBasis],
+  );
+  // R-IX-7 (R3-752): a state flip is ANNOUNCED, not only re-rendered — one standing
+  // polite live region whose text is the card's computed summary. A grant flip
+  // changes the text, which is what a status region announces; the visually hidden
+  // per-row words are static text and announce nothing.
+  const reachAnnouncement = useMemo(
+    () => `What the agent can do here: ${reachRows.map((r) => `${r.label} — ${stateWord(r.state)}`).join('; ')}`,
+    [reachRows],
+  );
   const canAsk = providerState.status === 'configured' && chatGranted;
 
   // Read at CALL time (a scan may land, the reader may navigate) — refs kept fresh
@@ -121,8 +153,8 @@ export default function GroveAgent({
 
     // G-GA-8: a provider without `features.tools` degrades to context-stuffing —
     // the deixis block, an index summary, and the current entry body ride the
-    // prompt; the request carries ZERO tools.
-    const toolsSupported = providerState.status === 'configured' && providerState.provider.features.tools === true;
+    // prompt; the request carries ZERO tools. The same hoisted fact the reach
+    // card's Q&A qualifier reads (R3-752) — computed once at render scope.
     const chroot = getContentRoot();
     const currentKey = entryRef.current;
     const contextBlock = renderAgentContext({
@@ -271,18 +303,28 @@ export default function GroveAgent({
                 </span>
               </div>
 
-              {/* The reach card — the envelope, computed (R-GA-1). */}
+              {/* The reach card — the envelope, computed (R-GA-1). State is text as
+                  well as glyph (R3-752): the hidden word beside the mark keeps the
+                  card from reading as four identical lines to a screen reader. */}
               <div className="ga-reach" role="list" aria-label="What the agent can do here">
                 {reachRows.map((r) => (
                   <div className={`ga-reach__row ga-reach__row--${r.state}`} role="listitem" key={r.key}>
                     <span className="ga-reach__mark" aria-hidden>
-                      {r.state === 'ok' ? '✓' : r.state === 'blocked' ? '✗' : '·'}
+                      {r.state === 'ok' ? '✓' : r.state === 'blocked' ? '✗' : r.state === 'elsewhere' ? '→' : '·'}
                     </span>
+                    <span className="ga-reach__stateword">{stateWord(r.state)}</span>
                     <span className="ga-reach__label">{r.label}</span>
                     {r.cause && <span className="ga-reach__cause">{r.cause}</span>}
+                    {r.destination && <span className="ga-reach__cause">{`→ ${r.destination}`}</span>}
                   </div>
                 ))}
               </div>
+              {trustLine && <p className="ga-egress">{trustLine}</p>}
+              {/* The standing live region (R-IX-7): the computed card summary, so a
+                  state flip is announced politely and not only re-rendered. */}
+              <div className="ga-reach__stateword" role="status">
+                {reachAnnouncement}
+              </div>
               {showEgressDisclosure(providerState) && <p className="ga-egress">{EGRESS_DISCLOSURE}</p>}
               {errorToast && (
                 <div className="ga-toast" role="status">

package/src/components/GroveAgent.unanswered.test.tsx

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+// ONE case, in its own file, because it needs a module registry where the catalog has
+// never been answered.
+//
+// `useCatalogAnswered`'s flag is module-global and never resets — correct for an app, in
+// which the host answers once per realm, but it means any test that has already pushed an
+// `api-catalog` poisons this one. Every case in `GroveAgent.test.tsx` pushes one. Vitest
+// isolates by file, so a separate file IS the isolation; the harness is shared rather
+// than copied (`src/test/groveAgentHarness.tsx`).
+//
+// Why this case exists at all: round 3 showed the hook was not load-bearing for any
+// component test — replacing `useCatalogAnswered()` with the literal `true`, i.e. exactly
+// the behaviour the hook was written to replace, left all 506 tests green. The unit arm
+// (`reachCard.test.ts`) and the hook itself were covered; the wire between them was not.
+// That is round 1's blocking finding recurring one level up.
+import { describe, it, expect, vi } from 'vitest';
+
+// `useHeadings` scans the DOM; `fs` is read only on the stuffing path, never here.
+vi.mock('fs', () => ({ default: { promises: { readFile: vi.fn(async () => '') } } }));
+vi.mock('@immediately-run/sdk', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@immediately-run/sdk')>()),
+  runAgent: vi.fn(),
+}));
+
+const { renderAgent, openPanel, push } = await import('../../test/groveAgentHarness');
+
+describe('R3-688 — before the catalog answers, the Q&A row names no cause', () => {
+  it('renders neutral: not a guessed consent state, not a guessed key state, no chips', async () => {
+    // No catalog push at all. The provider HAS answered `{ provider: null }`, which on a
+    // pre-mark host is what both a keyless frame and an ungranted fork receive — so the
+    // grant is genuinely unknown and the card must say nothing rather than pick one.
+    const { container } = await renderAgent({ writable: true });
+    await push({ type: 'llm-provider', provider: null });
+    await openPanel(container);
+    const text = container.textContent ?? '';
+
+    expect(text).toContain('Answer questions about this wiki');
+    expect(text).not.toContain("wasn't granted chat");
+    expect(text).not.toContain('no model key connected');
+    // No Q&A chips. Not "no chips at all": `writable: true` makes the Draft row ✓ and it
+    // contributes its own, which is correct and has nothing to do with the catalog.
+    const chips = [...container.querySelectorAll('.ga-chip')].map((c) => c.textContent ?? '');
+    expect(chips.some((c) => /summarize|tagged security/i.test(c))).toBe(false);
+  });
+});

package/src/hooks/useCatalogAnswered.late.test.tsx

@@ -0,0 +1,59 @@
+// @vitest-environment jsdom
+// The LATE-IMPORT case, in its own file because it is the one ordering the sibling suite
+// cannot produce: the host answers BEFORE this module is evaluated.
+//
+// grove is published as a pinned library (`src/lib.ts`), so "imported before any render"
+// is an assumption about one embedding, not a guarantee. If the subscribe-time call is
+// discarded with a blanket reset, a host that already answered is invisible for the
+// realm's life — and because the host does not push again, nothing corrects it.
+//
+// This file exists because round 3's own fix was untested: replacing
+// `answered = catalog.length > 0` with `answered = false` — i.e. the blanket reset the
+// fix replaced — left the whole suite green. A fix with no failing case is a guess.
+import { describe, it, expect, vi } from 'vitest';
+
+type Handler = (msg: Record<string, unknown>) => void;
+const handlers = new Set<Handler>();
+const emit = (msg: Record<string, unknown>): void => {
+  for (const h of handlers) h(msg);
+};
+
+(globalThis as { __immediatelyRun__?: unknown }).__immediatelyRun__ = {
+  transport: {
+    sendMessage: vi.fn(),
+    protocolRequest: vi.fn(async () => ({})),
+    onMessage: (handler: Handler) => {
+      handlers.add(handler);
+      return { dispose: () => handlers.delete(handler) };
+    },
+  },
+};
+
+describe('useCatalogAnswered, imported AFTER the host answered', () => {
+  it('reads a non-empty catalog at subscribe as proof the answer landed', async () => {
+    // Start and answer the channel through the SDK directly, with the hook module not yet
+    // imported — the ordering a late-mounting library consumer produces.
+    const { getCatalog } = await import('@immediately-run/sdk');
+    getCatalog();
+    emit({ type: 'api-catalog', methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }] });
+
+    // NOW import. The listener's synchronous subscribe-time call carries the answered
+    // catalog; a blanket reset would throw it away and the flag would be false forever.
+    const { useCatalogAnswered } = await import('./useCatalogAnswered');
+
+    const { act } = await import('react');
+    const { createRoot } = await import('react-dom/client');
+    const seen: boolean[] = [];
+    const Probe = () => {
+      seen.push(useCatalogAnswered());
+      return null;
+    };
+    const root = createRoot(document.createElement('div'));
+    await act(async () => {
+      root.render(<Probe />);
+    });
+
+    expect(seen[seen.length - 1]).toBe(true);
+    await act(async () => root.unmount());
+  });
+});