@immediately-run/grove 0.1.5 → 0.1.8

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.8)
 
 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.8",
   "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;
@@ -2669,6 +2686,26 @@ button.grove-search__row {
 .ga-reach__cause {
   color: var(--ink-2);
 }
+/* R3-790 — the ✗ chat row's earning affordance: a small token'd control inside
+   the reach card (the .ga-chip vocabulary, scaled to the card's 12.5px context). */
+.ga-reach__enable {
+  font-family: var(--sans);
+  font-weight: 600;
+  font-size: 12px;
+  color: var(--ink);
+  background: var(--panel-2);
+  border: 1px solid var(--line-2);
+  border-radius: var(--r-pill);
+  padding: 3px 10px;
+  margin-left: 8px;
+  cursor: pointer;
+  transition: .14s;
+}
+.ga-reach__enable:hover,
+.ga-reach__enable:focus-visible {
+  border-color: var(--accent-2);
+  color: var(--accent-2);
+}
 .ga-egress {
   margin: 0;
   padding: 8px 16px;

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 () => {
@@ -328,3 +367,155 @@ describe('R3-608 round 2 — the panel returns focus to its (unmounted) trigger'
     expect(container.querySelector('.ga-panel')).toBeNull(); // focus did not reopen
   });
 });
+
+// ── R3-790 — the ungranted chat row's earning affordance ──────────────────────
+
+describe("R3-790 — the ✗ chat row offers its earning affordance (click invokes; the host gesture mints)", () => {
+  beforeAll(() => {
+    HTMLElement.prototype.scrollTo = () => undefined as unknown as void;
+  });
+
+  it('renders Enable chat on the ungranted row — the host-marked forbidden cause', async () => {
+    const { container } = await renderAgent({ writable: false });
+    // The cold mark — no prior configured push: the host strips the provider from
+    // every answer to an ungranted frame (the R3-688 test's shape).
+    await push({ type: 'llm-provider', provider: null, ungranted: true });
+    await push({ type: 'api-catalog', methods: [] }); // answered: nothing granted
+    await openPanel(container);
+    const enable = container.querySelector('.ga-reach__enable');
+    expect(enable).toBeTruthy(); // the affordance exists on the ✗ row
+    expect((enable as HTMLElement).textContent).toBe('Enable chat');
+    // …and the row itself still tells the honest cause.
+    expect(container.querySelector('.ga-reach__row--blocked')?.textContent).toContain(
+      "this Grove wasn't granted chat",
+    );
+  });
+
+  it('renders NO affordance when the provider is not configured (that row points at Settings)', async () => {
+    const { container } = await renderAgent({ writable: false });
+    await push({ type: 'llm-provider', provider: null }); // not-configured, not ungranted
+    await push({ type: 'api-catalog', methods: [] });
+    await openPanel(container);
+    expect(container.querySelector('.ga-reach__enable')).toBeNull();
+  });
+
+  it("a click invokes; a DECLINED dialog ('cancelled') keeps the honest row and says so", async () => {
+    runAgentMock.mockClear();
+    runAgentMock.mockImplementationOnce(() => {
+      const e = new Error('declined') as Error & { code?: string };
+      e.code = 'cancelled';
+      throw e;
+    });
+    const { container } = await renderAgent({ writable: false });
+    // The cold mark — no prior configured push: the host strips the provider from
+    // every answer to an ungranted frame (the R3-688 test's shape).
+    await push({ type: 'llm-provider', provider: null, ungranted: true });
+    await push({ type: 'api-catalog', methods: [] });
+    await openPanel(container);
+    await act(async () => {
+      (container.querySelector('.ga-reach__enable') as HTMLButtonElement).click();
+    });
+    // The invoke RAN (runAgent was called once — the gesture's trigger)…
+    expect(runAgentMock).toHaveBeenCalledTimes(1);
+    // …the decline surfaced honestly…
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 16));
+    });
+    expect(container.querySelector('.ga-toast')?.textContent).toContain("chat didn't start — reading works as normal; you can try again anytime");
+    // …and the row still reads the forbidden cause with the affordance for the next click.
+    expect(container.querySelector('.ga-reach__row--blocked')?.textContent).toContain(
+      "this Grove wasn't granted chat",
+    );
+    expect(container.querySelector('.ga-reach__enable')).toBeTruthy();
+  });
+
+  it('a click invokes; a still-FORBIDDEN answer surfaces the refusal toast (pre-gesture hosts)', async () => {
+    runAgentMock.mockImplementationOnce(() => {
+      const e = new Error('forbidden') as Error & { code?: string };
+      e.code = 'forbidden';
+      throw e;
+    });
+    const { container } = await renderAgent({ writable: false });
+    // The cold mark — no prior configured push: the host strips the provider from
+    // every answer to an ungranted frame (the R3-688 test's shape).
+    await push({ type: 'llm-provider', provider: null, ungranted: true });
+    await push({ type: 'api-catalog', methods: [] });
+    await openPanel(container);
+    await act(async () => {
+      (container.querySelector('.ga-reach__enable') as HTMLButtonElement).click();
+    });
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 16));
+    });
+    expect(container.querySelector('.ga-toast')?.textContent).toContain("this Grove wasn't granted chat");
+  });
+});
+
+// ── R3-790 round 1 — the GRANTED leg: the click's invoke proceeds when the grant lands ──
+
+describe("R3-790 — the granted leg (click → invoke → the grant lands → the ask proceeds, the row flips)", () => {
+  beforeAll(() => {
+    HTMLElement.prototype.scrollTo = () => undefined as unknown as void;
+  });
+  const configured = {
+    type: 'llm-provider',
+    provider: {
+      providerId: 'llm.chat.anthropic',
+      hostVouched: true,
+      features: { vision: false, tools: true, jsonMode: true, reasoning: false, maxContextTokens: 100000 },
+    },
+  } as const;
+  const grantedCatalog = {
+    type: 'api-catalog',
+    methods: [{ name: 'llm:chat', capability: 'llm:chat', stream: true }],
+  } as const;
+
+  it("the affordance's click drives the invoke; the granted catalog flips the row ✓ and the input enables", async () => {
+    runAgentMock.mockClear();
+    runAgentMock.mockImplementationOnce(async () => [
+      {
+        role: 'user',
+        content: [{ type: 'text', text: 'Answer in one sentence: what can you tell me about this wiki?' }],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'This wiki is a small corpus about enabling chat.' }],
+      },
+    ]);
+    const { container } = await renderAgent({ writable: false });
+    await push({ type: 'llm-provider', provider: null, ungranted: true });
+    await push({ type: 'api-catalog', methods: [] });
+    await openPanel(container);
+    // Before: the honest ✗ row + the affordance.
+    expect(container.querySelector('.ga-reach__row--blocked')?.textContent).toContain(
+      "this Grove wasn't granted chat",
+    );
+    await act(async () => {
+      (container.querySelector('.ga-reach__enable') as HTMLButtonElement).click();
+    });
+    // The invoke RAN (the gesture's trigger).
+    expect(runAgentMock).toHaveBeenCalledTimes(1);
+    // The grant lands (the host's mint + lift answers the channels): push the
+    // granted catalog + the configured provider — the envelope recomputes.
+    await push(grantedCatalog);
+    await push(configured);
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 16));
+    });
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 16));
+    });
+    // The ask PROCEEDED: the assistant answer is in the body…
+    expect(container.querySelector('.ga-body')?.textContent).toContain('enabling chat');
+    // …the ANSWER row flipped ✓ (the read-only draft row stays honestly ✗ — that is
+    // its own row, not this one)…
+    const answerRow = [...container.querySelectorAll('.ga-reach__row')].find((r) =>
+      r.textContent?.includes('Answer questions about this wiki'),
+    );
+    expect(answerRow?.className).not.toContain('blocked');
+    expect(container.querySelector('.ga-reach__enable')).toBeNull();
+    // …and the composer input is ENABLED (canAsk true).
+    const input = container.querySelector('.ga-foot input') as HTMLInputElement;
+    expect(input?.disabled).toBe(false);
+  });
+});