diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9738caa3..7aab4ee6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.2.48.0] - 2026-10-27 (development candidate)
+
+Cycle 0056 ([Issue #135](https://github.com/laststance/codebook/issues/135)), a bug-fix cycle, second of its three pull requests: the LLM Wiki view and the browser reader say what is true in the states the cycle's tasks list. The Cursor test-replay fix and the native trial N56 follow in the third.
+
+**The reader.**
+
+- **A question waits with** `Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there.` in both editors, since the editor may ask for consent before its model answers.
+
+**The LLM Wiki view.**
+
+- **The message above the tree changes in the same render as the rows**, so a row never shows beside the previous state's message.
+- **A collapsed or hidden view does no background work**: no 30-second poll and no freshness check (not even one that was waiting when it was hidden), and one read as soon as it is shown again.
+- **The 30-second poll goes on across an error row** that follows a run row, so the view finds the run's end after a failed read; a read failure that persists is written to Output › Codebook once (again after a good read, or for a different failure), and a freshness check that keeps failing is written there once too.
+- **Reveal Wiki Folder says why it opened nothing**:
+  - a folder that does not exist yet (`… does not exist (yet). Generate LLM Wiki creates it.`);
+  - a file in the folder's place;
+  - a link whose target is missing;
+  - a path that cannot be read (with its error code, also when the disk does not answer within 3 seconds);
+  - a folder in a remote window (`Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote>. …`).
+  A WSL window reveals the folder like a local one.
+- **View actions have decided names and icons**: inline actions in Title Case (**Stop Watching** with an eye-closed icon, **Try Again** with a restart icon, **Change Location**, **Open Chat**, **Open Folder**, **Show Output**, **Copy Recovery Request**); **Cancel** keeps the stop icon because it stops the agent.
+- **The welcome names the default folder**: `The Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder.` with the **Change location** link, and a click on the **Output** row opens the same setting.
+
+**Compatibility.** The MCP API stays 1.8; the Wiki's published format, the marker format, stored learner data and the bundled skill (1.0.50) do not change.
+
 ## [0.2.47.0] - 2026-10-27 (development candidate)
 
 Cycle 0056 ([Issue #135](https://github.com/laststance/codebook/issues/135)), a bug-fix cycle, first of its three pull requests: the LLM Wiki run lifecycle says what happens on a joined, stopped or bounded start and releases what it claimed. The LLM Wiki view and the reader (second pull request) and the Cursor test-replay fix with the native trial N56 (third) follow.
diff --git a/README.md b/README.md
index ba3ee80b..aaedd996 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ Codebook contributes `debug.focusEditorOnBreak: false` as the native debugger de
 
 ## Implementation status
 
-This is a preview, not a Marketplace or Open VSX release. The delivered version is **0.2.47.0** once the first pull request of [Cycle 0056](https://github.com/laststance/codebook/issues/135) is merged; until then 0.2.46.0 ([PR #134](https://github.com/laststance/codebook/pull/134), Cycle 0055's second pull request) is the delivered one, and the active cycle Issue says where the delivery stands. Cycle 0056 is a bug-fix cycle that closes the defects Cycle 0055 carried, in three pull requests: the first makes an LLM Wiki start say what happens when it joins a start under way, is stopped or passes its bound, and release or write back what it claimed; the second the LLM Wiki view and the reader; the third a saved test replay that Cursor refused to open, with the native trial. [Cycle 0055](https://github.com/laststance/codebook/issues/132) is a feature cycle: **Codebook: Generate LLM Wiki** writes a project's first LLM Wiki through the editor's agent from Codebook's own entry (its first pull request), and an **LLM Wiki** view in the Activity Bar shows, opens and updates it (its second). Cycle 0053 was a feature cycle: a test inside a workspace package runs with that package's Vitest and config, as the package's own `vitest` would, while a test the repository root's config already selects keeps running from the root. Cycle 0054 is a bug-fix cycle that closes the three defects Cycle 0053 carried: a test that ends before a later declared stop says so, a package test's launch asks the repository root again whether its config now selects the test, and the native-trial bootstrap keeps a listing it could not release. Cycle 0051 opened a test replay in the learning-replay composition a browser replay has: the Learning summary in the chat's place, one transport for both replay families, and a Learning summary button that shows a hidden summary again. Cycle 0052 was a bug-fix cycle that closed every defect Cycle 0051 carried, in three pull requests: the first makes replays leave, open and reload without stale frames and makes their entries and exits behave as the learner chose; the second fixes a test replay's moves and its summary page; the third the live runtime's unreadable facts, a browser run's refusals and the tests' hygiene. The MCP API is 1.8. What each earlier cycle delivered, with its tests, trials and limits, is in the [change history](CHANGELOG.md) and in that cycle's record, kept under the tag [`docs-archive-2026-10-20`](https://github.com/laststance/codebook/tree/docs-archive-2026-10-20/docs/cycles); from Cycle 0048 on, the cycle's Issue holds its tasks and state, and its pull requests the results.
+This is a preview, not a Marketplace or Open VSX release. The delivered version is **0.2.48.0** once the second pull request of [Cycle 0056](https://github.com/laststance/codebook/issues/135) is merged; until then 0.2.47.0 ([PR #136](https://github.com/laststance/codebook/pull/136), the cycle's first pull request) is the delivered one, and the active cycle Issue says where the delivery stands. Cycle 0056 is a bug-fix cycle that closes the defects Cycle 0055 carried, in three pull requests: the first makes an LLM Wiki start say what happens when it joins a start under way, is stopped or passes its bound, and release or write back what it claimed; the second the LLM Wiki view and the reader; the third a saved test replay that Cursor refused to open, with the native trial. [Cycle 0055](https://github.com/laststance/codebook/issues/132) is a feature cycle: **Codebook: Generate LLM Wiki** writes a project's first LLM Wiki through the editor's agent from Codebook's own entry (its first pull request), and an **LLM Wiki** view in the Activity Bar shows, opens and updates it (its second). Cycle 0053 was a feature cycle: a test inside a workspace package runs with that package's Vitest and config, as the package's own `vitest` would, while a test the repository root's config already selects keeps running from the root. Cycle 0054 is a bug-fix cycle that closes the three defects Cycle 0053 carried: a test that ends before a later declared stop says so, a package test's launch asks the repository root again whether its config now selects the test, and the native-trial bootstrap keeps a listing it could not release. Cycle 0051 opened a test replay in the learning-replay composition a browser replay has: the Learning summary in the chat's place, one transport for both replay families, and a Learning summary button that shows a hidden summary again. Cycle 0052 was a bug-fix cycle that closed every defect Cycle 0051 carried, in three pull requests: the first makes replays leave, open and reload without stale frames and makes their entries and exits behave as the learner chose; the second fixes a test replay's moves and its summary page; the third the live runtime's unreadable facts, a browser run's refusals and the tests' hygiene. The MCP API is 1.8. What each earlier cycle delivered, with its tests, trials and limits, is in the [change history](CHANGELOG.md) and in that cycle's record, kept under the tag [`docs-archive-2026-10-20`](https://github.com/laststance/codebook/tree/docs-archive-2026-10-20/docs/cycles); from Cycle 0048 on, the cycle's Issue holds its tasks and state, and its pull requests the results.
 
 The specification is [goal version 10](PRODUCT_GOAL.md), and the implementation targets external repositories. Historical fixture or coupled-Wiki success is not proof of that destination.
 
diff --git a/VERSION b/VERSION
index 8c070137..8a3198e4 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.2.47.0
+0.2.48.0
diff --git a/extension/README.md b/extension/README.md
index 7a5c835d..4345e1b0 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -184,6 +184,8 @@ To write the Wiki elsewhere, set the folder in your settings (a path inside the
 
 **Codebook: Open LLM Wiki in Browser** serves the generated site from a loopback reader in your browser. The reader answers only on this computer: a request whose Host is its own loopback address, or any loopback address the editor has forwarded it to (each stays accepted if the editor forwards it again). A window whose forward goes to another host (a tunnel, a browser-based editor) gets no page, only a 403 that says so. The reader removes the effect of a page's own `referrerpolicy` attributes and `<meta name="referrer">` element, so a Wiki page cannot send the reader's private address to another site. **Update LLM Wiki** (the button in the right rail of that page, or **Codebook: Update LLM Wiki** in the Command Palette) asks the editor agent to regenerate the site. The button asks for confirmation in the editor first; in VS Code the confirmation says where the request goes: `Copilot Chat receives the update request for this project in a new chat; the chat you have open keeps its place in the chat list. If the Chat view has not been opened in this window yet, the request may go into the chat it restores. A draft you typed into an empty chat is replaced by the request; a draft in a chat with messages stays with that chat.` The command starts at once and asks nothing: its request goes into a new chat in the same way (into the chat the Chat view restores, if that view opens only now) and replaces a draft in an empty chat in the same way; the Chat view shows the chat with the request. When the watch ends and what to do after you refused a step of the chat are in the row **Updating LLM Wiki…** below. The page then shows the run and its result under the button without a reload; the site stays readable the whole time.
 
+A question asked on the page waits with `Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there.` in both editors, because the editor may ask for your consent before its model answers the first question; the page cannot know whether you gave it.
+
 | The page says                                           | What happened                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | What to do                                                                                                                                                                                                                                                                                                         |
 | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | Confirm the update in your editor                       | You pressed the button and the editor is asking whether to start.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Confirm in the editor.                                                                                                                                                                                                                                                                                             |
@@ -243,17 +245,17 @@ For tools: `GET <reader>/api/update-status` answers the current state as JSON (`
 The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site of the opened project stands and the next step; it sits below the **Repository Wiki** view, which lists repository articles, not the generated site. Its rows come and go with the facts they show, in a fixed order, and the tooltip of a row has its full text:
 
 - With no folder open the view says `Open a folder to use the LLM Wiki` with **Open Folder**; in a folder you have not trusted it says `Trust this folder to use the LLM Wiki` with **Manage Workspace Trust**.
-- In a folder with no Wiki and no run the view shows a welcome with a **Generate LLM Wiki** button, what runs it in your editor (Copilot Chat in VS Code, `cursor-agent` in Cursor) and the output folder with a **Change location** link.
+- In a folder with no Wiki and no run the view shows a welcome with a **Generate LLM Wiki** button, what runs it in your editor (Copilot Chat in VS Code, `cursor-agent` in Cursor) and the output folder with a **Change location** link (`The Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder.`). A click on the **Output** row opens the same setting.
 - **`<folder> Wiki`** is the published Wiki. A click opens it in the browser. Its description is the freshness label of the reader page (`Wiki source current`, `Source changed · Update available`, `Wiki freshness unknown: …`, or `Checking freshness…` while the check runs), and its tooltip names the generation: `Generated from <first 7 characters of the commit> on <date>`, `Generated on <date> (no Git revision)` in a folder without Git, or `Generated from <commit>` when the date cannot be read; when the Wiki records no Git revision, the tooltip also says in full that added files are not checked, which the description may cut off in a narrow sidebar. **Update LLM Wiki** is its action while no run shows. The row stays while a run works, so you can read the Wiki during an update.
-- **`Generating…` or `Updating…`** is this window's run. In VS Code it reads `Waiting for the chat to start` and then `In chat · <N> min of <bound>`, with the actions **Stop watching**, **Open Chat** (the chat that waits for an approval or never started is one click away) and **Show Output**; the message above the tree says that Stop watching does not stop the chat. In Cursor it reads `cursor-agent · <N> min of <bound>` with **Cancel** and **Show Output**. The description is read again every 30 seconds. If the start time cannot be read, the row shows no minutes (`In chat` or `cursor-agent`) rather than a wrong number.
+- **`Generating…` or `Updating…`** is this window's run. In VS Code it reads `Waiting for the chat to start` and then `In chat · <N> min of <bound>`, with the actions **Stop Watching** (an eye-closed icon), **Open Chat** (the chat that waits for an approval or never started is one click away) and **Show Output**; the message above the tree says that Stop watching does not stop the chat. A failed generation's row offers **Try Again** (a restart icon). Inline action names are in Title Case (**Stop Watching**, **Change Location**, **Open Chat**, **Open Folder**, **Show Output**, **Try Again**, **Copy Recovery Request**); **Cancel** keeps the stop icon because it stops the agent. In Cursor it reads `cursor-agent · <N> min of <bound>` with **Cancel** and **Show Output**. The description is read again every 30 seconds. If the start time cannot be read, the row shows no minutes (`In chat` or `cursor-agent`) rather than a wrong number.
 - **`Generating in another window`** or **`Updating in another window`** shows a run of another editor window on the same folder, with its start time.
 - **`Waiting for chat`** shows the reservation a stopped VS Code watch leaves, from any window: `retry after <time> (about <N> min)`. **Open Chat** opens the chat view, where the session is in the chat history; Codebook allows a new start after that time even if the chat stopped earlier. In VS Code the message above the tree then says that Codebook stopped watching the chat, which may still publish this Wiki, and that you stop the request in the chat. Once that time has passed the row is gone, so **Generate LLM Wiki** or **Update LLM Wiki** is available again whether or not the recorded process still exists. A Wiki the chat publishes meanwhile ends the wait: the Wiki row shows at once and the notice `An LLM Wiki was published in <folder>.` offers **Open in Browser**.
-- **`Last generation stopped`** shows how this window's generation ended without a Wiki (`stopped watching`, `cancelled`, `stopped after 55 minutes`, `no Wiki published`, `agent exit <code>`). A click shows the full sentence with **Copy details** (your home folder shown as `~`); **Try again** starts a new generation. It goes away when a Wiki is published or a new run starts.
-- **Attention rows** name what blocks an update or makes the manifest unusable, with the cause as the description; a click shows the sentence the reader page shows for it. **`Publish in progress or stopped`** (a publish lock or an unfinished publish) and **`Wiki manifest needs recovery`** (the manifest was edited or cannot be read) offer **Copy recovery request**, which copies `/codebook Recover the unfinished LLM Wiki publish for this project` for the editor chat; Codebook copies no shell command. **`Wiki folder belongs elsewhere`** (the output is a file or a link, a folder on its path is a link, or the manifest names another checkout) offers **Change location**. **`Wiki files changed by hand`** (a generated page was edited or is missing, or the folder holds a link or special file) offers **Reveal Wiki Folder**. An unreadable manifest, an edited manifest, a link or a file in the folder's place hides the Wiki row; the other causes leave the Wiki readable. **Refresh** reads the state again.
-- **`Output: <folder>`** shows the resolved folder with **Change location** (the `codebook.wikiOutputDirectory` setting) whenever another row shows. A folder outside the project shows its absolute path.
+- **`Last generation stopped`** shows how this window's generation ended without a Wiki (`stopped watching`, `cancelled`, `stopped after 55 minutes`, `no Wiki published`, `agent exit <code>`). A click shows the full sentence with **Copy details** (your home folder shown as `~`); **Try Again** starts a new generation. It goes away when a Wiki is published or a new run starts.
+- **Attention rows** name what blocks an update or makes the manifest unusable, with the cause as the description; a click shows the sentence the reader page shows for it. **`Publish in progress or stopped`** (a publish lock or an unfinished publish) and **`Wiki manifest needs recovery`** (the manifest was edited or cannot be read) offer **Copy Recovery Request**, which copies `/codebook Recover the unfinished LLM Wiki publish for this project` for the editor chat; Codebook copies no shell command. **`Wiki folder belongs elsewhere`** (the output is a file or a link, a folder on its path is a link, or the manifest names another checkout) offers **Change Location**. **`Wiki files changed by hand`** (a generated page was edited or is missing, or the folder holds a link or special file) offers **Reveal Wiki Folder**, which opens the folder in your file manager; for a folder that is not there it says `The LLM Wiki folder <folder> does not exist (yet). Generate LLM Wiki creates it.`, for a file in the folder's place it says `The LLM Wiki folder <folder> is a file, not a folder. Remove or rename that file, or change the location.`, and in a window connected to a remote host (SSH, a container; a WSL window reveals the folder like a local one) it says `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>. Open it from a terminal in this window, which runs in that remote environment, not on this computer.` and opens nothing. When the path cannot be looked at (no permission, or a file where a parent folder should be) it says `The LLM Wiki folder <folder> cannot be read (<error code>). Check the path and its permissions, or change the location.` instead of saying the folder does not exist; the look gives up after 3 seconds (a network drive that does not answer), with the code `ETIMEDOUT`. A link at the folder's place whose target is missing gets `The LLM Wiki folder <folder> is a link whose target is missing. Remove or fix the link, or change the location.`, because **Generate LLM Wiki** refuses a link. When the setting names no usable folder (empty, or outside the project) it says `Reveal Wiki Folder could not find the Wiki folder (<reason>). Change the location.` and Output › Codebook records the cause. An unreadable manifest, an edited manifest, a link or a file in the folder's place hides the Wiki row; the other causes leave the Wiki readable. **Refresh** reads the state again.
+- **`Output: <folder>`** shows the resolved folder with **Change Location** (the `codebook.wikiOutputDirectory` setting) whenever another row shows. A folder outside the project shows its absolute path.
 - A read that fails shows `Could not read the LLM Wiki state` with `Refresh to retry`; a click opens Output › Codebook, where the cause is written.
 
-The view reads its state again after a change of this window's run and once this window has removed or turned into a reservation the run's marker (so `Waiting for chat` shows also without a file event), after a change of the Wiki's manifest or of the three marker files beside the Wiki folder (one second after the last change, so a burst of changes is one read), after a change of `codebook.wikiOutputDirectory` or of workspace trust, when the view is shown, every 30 seconds while a run row shows (a marker whose window died leaves no file event), and with the **Refresh** action in its title bar. When the Wiki folder's parent does not exist yet, as in a fresh project, Codebook watches the closest folder of the project that does (never above the project folder) and moves the watch once a run makes the parent; the watch includes the Wiki folder itself, so deleting or renaming it is seen. An output folder outside the project is watched only when its own parent exists; the home folder and a file-system root are never watched. If the editor refuses the watch, or there is no folder to watch, the view refreshes when it is shown and with **Refresh** only, the **Output** row's tooltip says so and Output › Codebook records the cause once. The freshness label is read at each refresh, so a source edit shows as `Source changed` when the view is next shown or refreshed, not at the save. A refresh with nothing new changes nothing the screen reader announces and never moves the focus. Every action is also in the row's context menu (Shift+F10). **Codebook: Refresh LLM Wiki**, **Codebook: Copy LLM Wiki Recovery Request** and **Codebook: Reveal LLM Wiki Folder** are listed in the Command Palette only in an editor that shows the view. Only the first workspace folder is read. The 55 minutes of a generation count wall-clock time, so time asleep counts toward them.
+The view reads its state again after a change of this window's run and once this window has removed or turned into a reservation the run's marker (so `Waiting for chat` shows also without a file event), after a change of the Wiki's manifest or of the three marker files beside the Wiki folder (one second after the last change, so a burst of changes is one read), after a change of `codebook.wikiOutputDirectory` or of workspace trust, when the view is shown, every 30 seconds while the view is shown and a run row shows (a marker whose window died leaves no file event; the poll goes on across the error row of a read that failed after a run row showed), and with the **Refresh** action in its title bar. A collapsed or hidden view runs no poll and no freshness check, not even one that was waiting when it was hidden, and reads once when it is shown again. The message above the tree changes in the same render as the rows. When the Wiki folder's parent does not exist yet, as in a fresh project, Codebook watches the closest folder of the project that does (never above the project folder) and moves the watch once a run makes the parent; the watch includes the Wiki folder itself, so deleting or renaming it is seen. An output folder outside the project is watched only when its own parent exists; the home folder and a file-system root are never watched. If the editor refuses the watch, or there is no folder to watch, the view refreshes when it is shown and with **Refresh** only, the **Output** row's tooltip says so and Output › Codebook records the cause once. A failure of a read or of the freshness check is recorded once while it keeps happening (a message that differs only in its numbers counts as the same failure), and again when a different one comes or after a good read or check. The freshness label is read at each refresh, so a source edit shows as `Source changed` when the view is next shown or refreshed, not at the save. A refresh with nothing new changes nothing the screen reader announces and never moves the focus. Every action is also in the row's context menu (Shift+F10). **Codebook: Refresh LLM Wiki**, **Codebook: Copy LLM Wiki Recovery Request** and **Codebook: Reveal LLM Wiki Folder** are listed in the Command Palette only in an editor that shows the view. Only the first workspace folder is read. The 55 minutes of a generation count wall-clock time, so time asleep counts toward them.
 
 ### Troubleshooting the LLM Wiki
 
diff --git a/extension/package.json b/extension/package.json
index 6effd410..3b40a827 100644
--- a/extension/package.json
+++ b/extension/package.json
@@ -3,7 +3,7 @@
   "displayName": "codebook",
   "description": "Connect an external agent to source-grounded codebase studies.",
   "publisher": "laststance",
-  "version": "0.2.47",
+  "version": "0.2.48",
   "private": true,
   "engines": {
     "vscode": "^1.120.0",
@@ -169,8 +169,8 @@
       {
         "command": "codebook.generateDeepWiki",
         "title": "Codebook: Generate LLM Wiki",
-        "shortTitle": "Try again",
-        "icon": "$(play)"
+        "shortTitle": "Try Again",
+        "icon": "$(debug-restart)"
       },
       {
         "command": "codebook.updateDeepWiki",
@@ -223,7 +223,7 @@
       {
         "command": "codebook.copyWikiRecoveryRequest",
         "title": "Codebook: Copy LLM Wiki Recovery Request",
-        "shortTitle": "Copy recovery request",
+        "shortTitle": "Copy Recovery Request",
         "icon": "$(copy)"
       },
       {
@@ -234,8 +234,8 @@
       },
       {
         "command": "codebook.llmWiki.stopWatching",
-        "title": "Stop watching",
-        "icon": "$(debug-stop)"
+        "title": "Stop Watching",
+        "icon": "$(eye-closed)"
       },
       {
         "command": "codebook.llmWiki.cancelRun",
@@ -249,7 +249,7 @@
       },
       {
         "command": "codebook.llmWiki.changeLocation",
-        "title": "Change location",
+        "title": "Change Location",
         "icon": "$(edit)"
       },
       {
@@ -349,12 +349,12 @@
       {
         "view": "codebook.llmWiki",
         "when": "codebook.llmWiki.state == none && codebook.host == vscode",
-        "contents": "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.\n[Generate LLM Wiki](command:codebook.generateDeepWiki)\nIt runs in a new Copilot Chat session and uses your chat plan. The chat asks you to approve its commands and may ask you to Continue; keep the Chat view open.\nThe Wiki is written to the folder the setting codebook.wikiOutputDirectory names (default .codebook/wiki). [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)"
+        "contents": "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.\n[Generate LLM Wiki](command:codebook.generateDeepWiki)\nIt runs in a new Copilot Chat session and uses your chat plan. The chat asks you to approve its commands and may ask you to Continue; keep the Chat view open.\nThe Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder. [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)"
       },
       {
         "view": "codebook.llmWiki",
         "when": "codebook.llmWiki.state == none && codebook.host == cursor",
-        "contents": "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.\n[Generate LLM Wiki](command:codebook.generateDeepWiki)\nIt runs through Cursor's agent CLI (cursor-agent), uses your Cursor plan and can take several minutes. You can keep working.\nThe Wiki is written to the folder the setting codebook.wikiOutputDirectory names (default .codebook/wiki). [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)"
+        "contents": "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.\n[Generate LLM Wiki](command:codebook.generateDeepWiki)\nIt runs through Cursor's agent CLI (cursor-agent), uses your Cursor plan and can take several minutes. You can keep working.\nThe Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder. [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)"
       },
       {
         "view": "codebook.learningOutline",
diff --git a/extension/scripts/tests/package.test.mjs b/extension/scripts/tests/package.test.mjs
index ba00e1c7..37d30369 100644
--- a/extension/scripts/tests/package.test.mjs
+++ b/extension/scripts/tests/package.test.mjs
@@ -95,7 +95,7 @@ test('a real VSIX loads outside the checkout and excludes bundled applications a
   // Assert
   assert.equal(receipt.isolatedModuleLoad, true)
   assert.equal(receipt.isolatedWikiPageWorker, true)
-  assert.equal(checked.extension.version, '0.2.47')
+  assert.equal(checked.extension.version, '0.2.48')
   assert.equal(checked.extension.apiVersion, '1.8')
   assert.equal(checked.entries, 33)
   assert.equal(receipt.dependencies.length, 16)
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index a18b52ba..2f63daeb 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -8,7 +8,7 @@ import { CAPTURE_TIMEOUT_MS } from './runtimeSupport/constants'
  * 1.8 changed node-test outcomes: a passing test whose history sealed complete reads `demonstrated` in `finalOutcome`, `studyOutcome` and `recordedStudyOutcome` (1.7 stopped at `partial`), its sealed history is a test replay (`recordingAvailable` and `replayAvailable`), and `nodeTest` adds `testResult`, `learningCoverage` and `learningMissing`. A node-test start's deterministic refusals arrive as the run's `error` before its first stop, a failed history seal makes `codebook_stop` answer `HISTORY_SEAL_FAILED`, and `codebook_playback` refuses a test replay with `PLAYBACK_PROFILE_UNSUPPORTED`.
  */
 export const API_VERSION = '1.8'
-export const EXTENSION_VERSION = '0.2.47'
+export const EXTENSION_VERSION = '0.2.48'
 export const CONFIGURED_MINIMUM_EXTENSION_VERSION = '0.2.0'
 export const NODE_TEST_MINIMUM_EXTENSION_VERSION = '0.2.12'
 export const LOOPBACK_ADDRESS = '127.0.0.1'
@@ -833,6 +833,10 @@ export const WIKI_UPDATE_STATUS_ROUTE = 'api/update-status'
 export const WIKI_FRESHNESS_ROUTE = 'api/freshness'
 /** Route of the Wiki reader that takes a repository question from its own page. */
 export const WIKI_QUESTION_ROUTE = 'api/ask'
+
+/** The reader's status line while a question waits for the editor model; the editor may be asking for consent meanwhile. */
+export const WIKI_QUESTION_WAITING_STATUS =
+  'Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there.'
 /** The rules of the question status line of a Wiki page (`.qa-status`, the empty `role=status` line the progress of a question is told in): the bundled `reader-shell.html` carries the same rules, and the reader's page script adds them to a page published before the shell had the line, when it adds the line there. Empty, the line takes no room. */
 export const WIKI_QUESTION_STATUS_STYLE =
   '.qa-status{font-size:.85rem;margin:.4rem 0 0;overflow-wrap:anywhere}.qa-status:empty{margin:0}'
@@ -1036,19 +1040,19 @@ export const LLM_WIKI_ROW_ACTIONS = {
   update: { command: UPDATE_DEEP_WIKI_COMMAND, title: 'Update LLM Wiki' },
   'stop-watching': {
     command: 'codebook.llmWiki.stopWatching',
-    title: 'Stop watching',
+    title: 'Stop Watching',
   },
   'cancel-run': { command: 'codebook.llmWiki.cancelRun', title: 'Cancel' },
   'open-chat': { command: 'codebook.llmWiki.openChat', title: 'Open Chat' },
   'show-output': { command: SHOW_WIKI_OUTPUT_COMMAND, title: 'Show Output' },
-  'try-again': { command: GENERATE_DEEP_WIKI_COMMAND, title: 'Try again' },
+  'try-again': { command: GENERATE_DEEP_WIKI_COMMAND, title: 'Try Again' },
   'change-location': {
     command: 'codebook.llmWiki.changeLocation',
-    title: 'Change location',
+    title: 'Change Location',
   },
   'copy-recovery': {
     command: COPY_WIKI_RECOVERY_REQUEST_COMMAND,
-    title: 'Copy recovery request',
+    title: 'Copy Recovery Request',
   },
   'reveal-folder': {
     command: REVEAL_WIKI_FOLDER_COMMAND,
@@ -1064,6 +1068,79 @@ export const LLM_WIKI_ROW_ACTIONS = {
     title: 'Manage Workspace Trust',
   },
 } as const
+
+/** What the LLM Wiki view says when the editor lists none of the known ids of its Manage Workspace Trust command ({@link resolveManageTrustCommand}, run by {@link registerLlmWikiCommands}). */
+export const LLM_WIKI_MANAGE_TRUST_FALLBACK_NOTICE =
+  'Run "Workspaces: Manage Workspace Trust" from the Command Palette to trust this folder.'
+
+/** What the LLM Wiki view says once the recovery request is copied. */
+export const LLM_WIKI_RECOVERY_REQUEST_COPIED_NOTICE =
+  'Copied the recovery request. Paste it into the editor chat.'
+
+/**
+ * Sentence for a Wiki folder that does not exist, so Reveal Wiki Folder opens nothing.
+ * @param outputLabel - The folder as the learner reads it.
+ * @returns `The LLM Wiki folder <label> does not exist (yet). Generate LLM Wiki creates it.` (the first sentence is Issue #135 task 21's; the second names the next step)
+ * @example llmWikiFolderMissingNotice('.codebook/wiki') // => 'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.'
+ */
+export const llmWikiFolderMissingNotice = (outputLabel: string): string =>
+  `The LLM Wiki folder ${outputLabel} does not exist (yet). Generate LLM Wiki creates it.`
+
+/**
+ * Sentence for a Wiki output path where a file stands, so Reveal Wiki Folder opens nothing.
+ * @param outputLabel - The path as the learner reads it.
+ * @returns `The LLM Wiki folder <label> is a file, not a folder. Remove or rename that file, or change the location.`
+ * @example llmWikiFolderIsFileNotice('.codebook/wiki') // => 'The LLM Wiki folder .codebook/wiki is a file, not a folder. Remove or rename that file, or change the location.'
+ */
+export const llmWikiFolderIsFileNotice = (outputLabel: string): string =>
+  `The LLM Wiki folder ${outputLabel} is a file, not a folder. Remove or rename that file, or change the location.`
+
+/**
+ * Sentence for a Wiki output path whose entry is a link to nothing, so Reveal Wiki Folder opens nothing and does not promise that Generate LLM Wiki creates it (generation refuses a link).
+ * @param outputLabel - The path as the learner reads it.
+ * @returns `The LLM Wiki folder <label> is a link whose target is missing. Remove or fix the link, or change the location.`
+ * @example llmWikiFolderDanglingLinkNotice('.codebook/wiki') // => 'The LLM Wiki folder .codebook/wiki is a link whose target is missing. Remove or fix the link, or change the location.'
+ */
+export const llmWikiFolderDanglingLinkNotice = (outputLabel: string): string =>
+  `The LLM Wiki folder ${outputLabel} is a link whose target is missing. Remove or fix the link, or change the location.`
+
+/**
+ * Sentence for a Wiki output path that cannot be looked at, so Reveal Wiki Folder opens nothing and does not claim the folder is missing.
+ * @param outputLabel - The path as the learner reads it.
+ * @param code - The system error name of the failed look (`EACCES`, `ENOTDIR`, `ETIMEDOUT`, …).
+ * @returns `The LLM Wiki folder <label> cannot be read (<code>). Check the path and its permissions, or change the location.`
+ * @example llmWikiFolderUnreadableNotice('.codebook/wiki', 'EACCES') // => 'The LLM Wiki folder .codebook/wiki cannot be read (EACCES). Check the path and its permissions, or change the location.'
+ */
+export const llmWikiFolderUnreadableNotice = (
+  outputLabel: string,
+  code: string,
+): string =>
+  `The LLM Wiki folder ${outputLabel} cannot be read (${code}). Check the path and its permissions, or change the location.`
+
+/**
+ * Sentence for a Wiki location that cannot be worked out (the setting is empty or points outside the project), so Reveal Wiki Folder does not fail without a word.
+ * @param reason - The message of the failure, as the setting check words it; one closing full stop is dropped.
+ * @returns `Reveal Wiki Folder could not find the Wiki folder (<reason>). Change the location.`
+ * @example llmWikiFolderLocationFailedNotice('Choose a nonempty local DeepWiki output directory.') // => 'Reveal Wiki Folder could not find the Wiki folder (Choose a nonempty local DeepWiki output directory). Change the location.'
+ */
+export const llmWikiFolderLocationFailedNotice = (reason: string): string =>
+  `Reveal Wiki Folder could not find the Wiki folder (${reason.replace(/\.$/, '')}). Change the location.`
+
+/** How long Reveal Wiki Folder waits for the file system to look at the Wiki output path (ms): a dead network mount never answers, and the learner is told it cannot be read instead of getting no feedback. */
+export const WIKI_FOLDER_STAT_TIMEOUT_MS = 3_000
+
+/** The cap on the text two failed reads are compared by, so a message that embeds a long dump keeps the memory of the last failure small. */
+export const FAILURE_KEY_MAX_LENGTH = 500
+
+/**
+ * Sentence for a Wiki folder in a remote window, where Reveal Wiki Folder opens folders of this computer only.
+ * @param remoteName - The editor's `env.remoteName`.
+ * @returns `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>. Open it from a terminal in this window, which runs in that remote environment, not on this computer.` (the first sentence is Issue #135 task 21's; the second names the next step)
+ * @example llmWikiFolderRemoteNotice('ssh-remote') // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal in this window, which runs in that remote environment, not on this computer.'
+ */
+export const llmWikiFolderRemoteNotice = (remoteName: string): string =>
+  `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${remoteName}. Open it from a terminal in this window, which runs in that remote environment, not on this computer.`
+
 /** How often the extension looks for a newly published manifest while a Wiki update is watched. */
 export const WIKI_UPDATE_WATCH_POLL_MS = 2_000
 /** How often the reader page asks for the update state while a run is active. */
diff --git a/extension/src/deepWikiReader.ts b/extension/src/deepWikiReader.ts
index b8e50f5a..f53c4b52 100644
--- a/extension/src/deepWikiReader.ts
+++ b/extension/src/deepWikiReader.ts
@@ -23,6 +23,7 @@ import {
   WIKI_PAGE_SERVE_DEADLINE_MS,
   WIKI_QUESTION_LIMIT_CHARS,
   WIKI_QUESTION_ROUTE,
+  WIKI_QUESTION_WAITING_STATUS,
   WIKI_QUESTION_STATUS_STYLE,
   WIKI_READER_FOREIGN_HOST_REFUSAL,
   WIKI_REFUSED_STEP_ADVICE,
@@ -147,7 +148,7 @@ const qaClient = `(function () {
     // The answer's region is shown and emptied now, so the answer written after the request changes a region already in the page; the progress goes to the status line, which was there before it.
     output.style.display = 'block'; output.textContent = '';
     var asked = ++questionsAsked;
-    questionStatus.textContent = 'Asking the editor model…';
+    questionStatus.textContent = ${JSON.stringify(WIKI_QUESTION_WAITING_STATUS)};
     // A hand-off or a failure can come back within the frame that showed the answer's region, which would enter the page together with that text: the sentence is the status line's, which was in the page before it, and the answer's empty disclosure leaves again. A newer question keeps its own progress and disclosure.
     var tell = function (sentence) {
       if (asked !== questionsAsked) return;
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index 9bec2154..c7d93644 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -280,6 +280,8 @@ export function activate(
   }
   const isCursorHost =
     vscode.env?.appName?.toLowerCase().includes('cursor') ?? false
+  /** The editor host as the LLM Wiki code names it ({@link WikiUpdateHost}). */
+  const wikiHost: WikiUpdateHost = isCursorHost ? 'cursor' : 'vscode'
   const setupMatchesCurrentWorkspace = () => {
     try {
       return (
@@ -2314,7 +2316,7 @@ export function activate(
         outputDirectory,
         outputLabel: wikiOutputLabel(projectRoot, outputDirectory),
       },
-      host: isCursorHost ? 'cursor' : 'vscode',
+      host: wikiHost,
     }
   }
   /** Starts a project-bound skill update from the browser or command, coalescing repeated clicks. @param acknowledgedLeftovers - Given when the learner pressed "Update anyway": the leftovers named by the refusals it was pressed on, one press after the other, which alone are ignored; every other leftover, there already or appeared since, refuses the start with a notice of its own, and another window's running update still refuses it. @param isChoiceCarried - Whether the press carries a choice (Update anyway, the offer's Update), which a start under way would not apply ({@link runWikiAttempt}). @example await updateDeepWiki() */
@@ -2434,9 +2436,8 @@ export function activate(
    * @example await refuseThrownWikiGenerate(new Error('EACCES: permission denied'))
    */
   const refuseThrownWikiGenerate = async (error: unknown): Promise<void> => {
-    const fallbackHost: WikiUpdateHost = isCursorHost ? 'cursor' : 'vscode'
     const { host, wikiOutput } = await wikiRunPlace().catch(() => ({
-      host: fallbackHost,
+      host: wikiHost,
       wikiOutput: { outputDirectory: '', outputLabel: '' },
     }))
     refuseWikiGenerate(host, wikiOutput, thrownMessage(error))
@@ -2457,7 +2458,7 @@ export function activate(
     wikiOutput: WikiUpdateOutput,
   ): Promise<'generate' | 'change-location' | undefined> => {
     const confirmation = describeWikiGenerateConfirmation({
-      host: isCursorHost ? 'cursor' : 'vscode',
+      host: wikiHost,
       projectName: basename(projectRoot),
       outputDirectory: wikiOutput.outputDirectory,
       chatHandOver: isCursorHost
@@ -3030,14 +3031,14 @@ export function activate(
                   projectRoot,
                   sources,
                   question,
-                  isCursorHost ? 'cursor' : 'vscode',
+                  wikiHost,
                   cancellation.token,
                 )
               } finally {
                 cancellation.dispose()
               }
             },
-            isCursorHost ? 'cursor' : 'vscode',
+            wikiHost,
             () => wikiUpdateRun.status(),
           )
           // A source also changes without a save in this editor (an agent's CLI and Git write files directly), so the project's files are watched for as long as the reader serves.
@@ -3182,14 +3183,22 @@ export function activate(
   )
   // The LLM Wiki view: rows from the Wiki folder, the run state and the markers; an editor without tree views shows none.
   if (Reflect.has(vscode.window ?? {}, 'createTreeView')) {
+    /** Writes a failure of the LLM Wiki view or its commands to Output › Codebook; the view and Reveal Wiki Folder use it. */
+    const recordLlmWikiFailure = (message: string, cause: unknown): void => {
+      try {
+        output?.error(`${message}: ${thrownMessage(cause)}`)
+      } catch {
+        // A disposed channel has nowhere to write.
+      }
+    }
     const llmWikiView = createLlmWikiView({
       editor: vscode,
-      host: isCursorHost ? 'cursor' : 'vscode',
+      host: wikiHost,
       debounceMs: LLM_WIKI_REFRESH_DEBOUNCE_MS,
       pollMs: LLM_WIKI_POLL_MS,
       readFacts: () =>
         readLlmWikiViewFacts({
-          host: isCursorHost ? 'cursor' : 'vscode',
+          host: wikiHost,
           isFolderOpen: () =>
             Boolean(vscode.workspace.workspaceFolders?.length),
           isTrusted: () => vscode.workspace.isTrusted,
@@ -3255,13 +3264,7 @@ export function activate(
           `An LLM Wiki was published in ${outputLabel}.`,
           [OPEN_WIKI_IN_BROWSER_ACTION],
         ),
-      recordFailure: (message, cause) => {
-        try {
-          output?.error(`${message}: ${thrownMessage(cause)}`)
-        } catch {
-          // A disposed channel has nowhere to write.
-        }
-      },
+      recordFailure: recordLlmWikiFailure,
     })
     context.subscriptions.push(
       { dispose: () => llmWikiView.dispose() },
@@ -3271,7 +3274,8 @@ export function activate(
         showNotice,
         view: llmWikiView,
         cancelRun: cancelWikiRun,
-        findOutputDirectory: async () => (await wikiLocation()).outputDirectory,
+        findWikiLocation: wikiLocation,
+        recordFailure: recordLlmWikiFailure,
       }),
     )
   }
diff --git a/extension/src/tests/describeUnrevealableWikiFolder.test.ts b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
new file mode 100644
index 00000000..f760877b
--- /dev/null
+++ b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { describeUnrevealableWikiFolder } from '../utils/describeUnrevealableWikiFolder'
+
+// Value: protects=Reveal Wiki Folder names the useful reason first; fails_when=a missing folder in a remote window is told as "on the remote host" or an empty remote name blocks a local reveal; why_new=llmWikiView.test.ts covers missing and remote separately, never both and never the empty name; seam=none; no_claim=the editor's reveal command
+test('Reveal Wiki Folder names a missing folder before the remote host and lets a local window reveal', () => {
+  // Arrange
+  const missingInRemote = {
+    outputLabel: '.codebook/wiki',
+    folderKind: { kind: 'missing' } as const,
+    remoteName: 'wsl',
+  }
+  const existingInLocal = {
+    outputLabel: '.codebook/wiki',
+    folderKind: { kind: 'folder' } as const,
+    remoteName: '',
+  }
+
+  // Act
+  const results = [
+    describeUnrevealableWikiFolder(missingInRemote),
+    describeUnrevealableWikiFolder(existingInLocal),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.',
+    undefined,
+  ])
+})
+
+// Value: protects=RT2-B and D2 (each reason gives its next step; WSL is local); fails_when=a file in the folder's place is told as missing, a remote reason lacks the next step, or WSL is refused as remote; why_new=the test above covers missing and local only; seam=none; no_claim=the editor's reveal command
+test('Reveal Wiki Folder words a file, a remote host with its next step, and lets WSL reveal', () => {
+  // Arrange
+  const fileInPlace = {
+    outputLabel: 'docs/wiki',
+    folderKind: { kind: 'file' } as const,
+  }
+  const existingInSsh = {
+    outputLabel: 'docs/wiki',
+    folderKind: { kind: 'folder' } as const,
+    remoteName: 'ssh-remote',
+  }
+  const existingInWsl = {
+    outputLabel: 'docs/wiki',
+    folderKind: { kind: 'folder' } as const,
+    remoteName: 'wsl',
+  }
+
+  // Act
+  const results = [
+    describeUnrevealableWikiFolder(fileInPlace),
+    describeUnrevealableWikiFolder(existingInSsh),
+    describeUnrevealableWikiFolder(existingInWsl),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    'The LLM Wiki folder docs/wiki is a file, not a folder. Remove or rename that file, or change the location.',
+    'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal in this window, which runs in that remote environment, not on this computer.',
+    undefined,
+  ])
+})
+
+// Value: protects=RT3-c (an unreadable path is not told as missing); fails_when=a path the look could not read is worded "does not exist (yet)", or the remote reason hides it; why_new=the tests above cover folder, file and missing only; seam=none; no_claim=the system call that failed
+test('Reveal Wiki Folder words an unreadable path with its error code and a next step, before the remote host', () => {
+  // Arrange
+  const unreadableInRemote = {
+    outputLabel: '.codebook/wiki',
+    folderKind: { kind: 'unreadable', code: 'EACCES' } as const,
+    remoteName: 'ssh-remote',
+  }
+
+  // Act
+  const result = describeUnrevealableWikiFolder(unreadableInRemote)
+
+  // Assert
+  assert.equal(
+    result,
+    'The LLM Wiki folder .codebook/wiki cannot be read (EACCES). Check the path and its permissions, or change the location.',
+  )
+})
+
+// Value: protects=F2 (b) and F3 (a link to nothing and a look that timed out have their own words); fails_when=a dangling link is worded as missing, or a timeout is worded as a permission problem only; no_claim=the system call that failed; seam=none
+test('Reveal Wiki Folder words a link whose target is missing, and a look that timed out', () => {
+  // Arrange
+  const danglingLink = {
+    outputLabel: '.codebook/wiki',
+    folderKind: { kind: 'dangling-link' } as const,
+  }
+  const timedOut = {
+    outputLabel: '.codebook/wiki',
+    folderKind: { kind: 'unreadable', code: 'ETIMEDOUT' } as const,
+  }
+
+  // Act
+  const results = [
+    describeUnrevealableWikiFolder(danglingLink),
+    describeUnrevealableWikiFolder(timedOut),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    'The LLM Wiki folder .codebook/wiki is a link whose target is missing. Remove or fix the link, or change the location.',
+    'The LLM Wiki folder .codebook/wiki cannot be read (ETIMEDOUT). Check the path and its permissions, or change the location.',
+  ])
+})
diff --git a/extension/src/tests/failureKeyOf.test.ts b/extension/src/tests/failureKeyOf.test.ts
new file mode 100644
index 00000000..1ef8e5a3
--- /dev/null
+++ b/extension/src/tests/failureKeyOf.test.ts
@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { failureKeyOf } from '../utils/failureKeyOf'
+
+// Value: protects=F10 (the key tells an Error with a code, one without, an object and a thrown string apart); fails_when=a code is dropped, an Error and a thrown string with the same text share a key, or an object prints as its message; no_claim=the Output wording; seam=none
+test('the failure key tells an Error with a code, an Error without one, an object and a string apart', () => {
+  // Arrange
+  const withCode = Object.assign(new Error('busy'), { code: 'EBUSY' })
+  const withoutCode = new TypeError('busy')
+
+  // Act
+  const keys = [
+    failureKeyOf(withCode),
+    failureKeyOf(withoutCode),
+    failureKeyOf({ reason: 'busy' }),
+    failureKeyOf('busy'),
+  ]
+
+  // Assert
+  assert.deepEqual(keys, [
+    'Error|EBUSY|busy',
+    'TypeError||busy',
+    "{ reason: 'busy' }",
+    "'busy'",
+  ])
+})
+
+// Value: protects=F5 (a changing number does not make a new failure, a changing code does); fails_when=digit runs stay in the key (every tick looks new), or the code is normalised away; no_claim=other punctuation in the message; seam=none
+test('the failure key ignores the numbers of a message and keeps the error code', () => {
+  // Arrange
+  const earlier = Object.assign(new Error('pid 4711 gone after 30 ms'), {
+    code: 'EBUSY',
+  })
+  const later = Object.assign(new Error('pid 52 gone after 60 ms'), {
+    code: 'EBUSY',
+  })
+  const otherCode = Object.assign(new Error('pid 52 gone after 60 ms'), {
+    code: 'EIO',
+  })
+
+  // Act
+  const keys = [
+    failureKeyOf(earlier),
+    failureKeyOf(later),
+    failureKeyOf(otherCode),
+  ]
+
+  // Assert
+  assert.deepEqual(keys, [
+    'Error|EBUSY|pid # gone after # ms',
+    'Error|EBUSY|pid # gone after # ms',
+    'Error|EIO|pid # gone after # ms',
+  ])
+})
+
+// Value: protects=F5 (the cause one level down is part of the key, and the key is bounded); fails_when=two failures that differ in their cause share a key, or a long dump is kept whole; no_claim=a cause deeper than one level; seam=an Error with an Error cause, a very long message, a very long object
+test('the failure key includes the cause one level down and is cut at 500 characters', () => {
+  // Arrange
+  const withCause = new Error('read failed', {
+    cause: Object.assign(new Error('socket 7 closed'), { code: 'ECONNRESET' }),
+  })
+  const longMessage = new Error('x'.repeat(2_000))
+  const longObject = { text: 'y'.repeat(2_000) }
+
+  // Act
+  const results = [
+    failureKeyOf(withCause),
+    failureKeyOf(longMessage).length,
+    failureKeyOf(longObject).length,
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    'Error||read failed<-Error|ECONNRESET|socket # closed',
+    500,
+    500,
+  ])
+})
+
+// Value: protects=F4 (a cause that cannot be read still has a key); fails_when=a message getter that throws makes the key throw; no_claim=the key of a readable cause; seam=an Error whose message getter throws
+test('the failure key of a cause whose message cannot be read is its type tag', () => {
+  // Arrange
+  const hostile = new Error('hidden')
+  Object.defineProperty(hostile, 'message', {
+    get(): never {
+      throw new Error('getter failed')
+    },
+  })
+
+  // Act
+  const key = failureKeyOf(hostile)
+
+  // Assert
+  assert.equal(key, '[object Error]')
+})
diff --git a/extension/src/tests/llmWikiManifest.test.ts b/extension/src/tests/llmWikiManifest.test.ts
index 5b5e8ba9..52b24f5e 100644
--- a/extension/src/tests/llmWikiManifest.test.ts
+++ b/extension/src/tests/llmWikiManifest.test.ts
@@ -10,7 +10,12 @@ type Manifest = {
     viewsContainers: { activitybar: Array<{ id: string; icon: string }> }
     views: { codebook: Array<{ id: string; name: string }> }
     viewsWelcome: Array<{ view: string; when: string; contents: string }>
-    commands: Array<{ command: string; title: string }>
+    commands: Array<{
+      command: string
+      title: string
+      shortTitle?: string
+      icon?: string
+    }>
     menus: Record<
       string,
       Array<{ command: string; when?: string; group?: string }>
@@ -44,7 +49,7 @@ test('the LLM Wiki view’s welcome content shows only in the none state, per ho
           "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.",
           '[Generate LLM Wiki](command:codebook.generateDeepWiki)',
           'It runs in a new Copilot Chat session and uses your chat plan. The chat asks you to approve its commands and may ask you to Continue; keep the Chat view open.',
-          'The Wiki is written to the folder the setting codebook.wikiOutputDirectory names (default .codebook/wiki). [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)',
+          'The Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder. [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)',
         ],
       },
       {
@@ -53,7 +58,7 @@ test('the LLM Wiki view’s welcome content shows only in the none state, per ho
           "Explore this project through source-linked chapters, diagrams and questions, written by your editor's AI.",
           '[Generate LLM Wiki](command:codebook.generateDeepWiki)',
           "It runs through Cursor's agent CLI (cursor-agent), uses your Cursor plan and can take several minutes. You can keep working.",
-          'The Wiki is written to the folder the setting codebook.wikiOutputDirectory names (default .codebook/wiki). [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)',
+          'The Wiki is written to .codebook/wiki unless the setting codebook.wikiOutputDirectory names another folder. [Change location](command:workbench.action.openSettings?%5B%22%40id%3Acodebook.wikiOutputDirectory%22%5D)',
         ],
       },
     ],
@@ -160,3 +165,48 @@ test('the palette lists the commands that exist only with the LLM Wiki view only
     'codebook.revealWikiFolder': 'codebook.llmWiki.state',
   })
 })
+
+// Value: protects=task 25 (view copy and icons, O3); fails_when=Try again loses its restart icon, Stop watching keeps the stop icon that Cancel keeps for stopping the agent, or an inline action's title (Copy Recovery Request included) falls back to sentence case; no_claim=how the editor draws the icons (N56 step 5); seam=the packaged manifest
+test('the LLM Wiki view’s inline actions carry the decided icons and Title Case titles', async () => {
+  // Arrange
+  const manifest = await readManifest()
+  const commandsById = new Map(
+    manifest.contributes.commands.map((command) => [command.command, command]),
+  )
+
+  // Act
+  const shown = [
+    'codebook.generateDeepWiki',
+    'codebook.llmWiki.stopWatching',
+    'codebook.llmWiki.cancelRun',
+    'codebook.llmWiki.openChat',
+    'codebook.showWikiOutput',
+    'codebook.llmWiki.changeLocation',
+    'codebook.llmWiki.openFolder',
+    'codebook.copyWikiRecoveryRequest',
+  ].map((id) => {
+    const command = commandsById.get(id)
+    return [id, command?.shortTitle ?? command?.title, command?.icon]
+  })
+
+  // Assert
+  assert.deepEqual(shown, [
+    ['codebook.generateDeepWiki', 'Try Again', '$(debug-restart)'],
+    ['codebook.llmWiki.stopWatching', 'Stop Watching', '$(eye-closed)'],
+    ['codebook.llmWiki.cancelRun', 'Cancel', '$(debug-stop)'],
+    ['codebook.llmWiki.openChat', 'Open Chat', '$(comment-discussion)'],
+    ['codebook.showWikiOutput', 'Show Output', '$(output)'],
+    ['codebook.llmWiki.changeLocation', 'Change Location', '$(edit)'],
+    ['codebook.llmWiki.openFolder', 'Open Folder', '$(folder-opened)'],
+    ['codebook.copyWikiRecoveryRequest', 'Copy Recovery Request', '$(copy)'],
+  ])
+  assert.deepEqual(
+    [
+      LLM_WIKI_ROW_ACTIONS['try-again'].title,
+      LLM_WIKI_ROW_ACTIONS['stop-watching'].title,
+      LLM_WIKI_ROW_ACTIONS['change-location'].title,
+      LLM_WIKI_ROW_ACTIONS['copy-recovery'].title,
+    ],
+    ['Try Again', 'Stop Watching', 'Change Location', 'Copy Recovery Request'],
+  )
+})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index 44150902..4f1bb38c 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -518,7 +518,7 @@ test('a manifest created in the output folder shows the Wiki row after the watch
   // Act
   await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
   project.reportFileEvent('create', join(project.projectRoot, 'notes.md'))
-  await new Promise((resolve) => setTimeout(resolve, 300))
+  await project.llmWiki.whenIdle()
   const idsBeforeTheEvent = idsOf(project)
   const readsBeforeTheEvent = project.looks.publishTokenReads
   project.reportFileEvent(
@@ -548,8 +548,8 @@ test('five file events inside the debounce become one read that shows the last s
     await new Promise((resolve) => setTimeout(resolve, 10))
   }
   await untilRow(project, 'wiki')
-  // gstack-timing-ok: proves no second read follows; waits six times the shortened 40 ms debounce after the last event
-  await new Promise((resolve) => setTimeout(resolve, 250))
+  // Settled: no debounced read is waiting and no read runs, so a second read would already be counted.
+  await project.llmWiki.whenIdle()
 
   // Assert
   // Two reads: the burst's one, and the single follow-up read that the watcher's move from the project to .codebook adds once the Wiki's folders exist.
@@ -987,32 +987,296 @@ test('a refused file watcher is recorded once in Output, said in the Output row
   )
 })
 
-// Value: protects=AC 2 (the row actions are commands a keyboard reaches); fails_when=Open Chat, Change location, Copy recovery request or Reveal Wiki Folder run another editor command or copy another text; no_claim=what the editor does with them; seam=the stubbed editor's command log and clipboard
-test('Open Chat, Change location, Reveal Wiki Folder and Copy recovery request run the editor commands and the copy the plan names', async (context) => {
+// Value: protects=AC 2 (the row actions are commands a keyboard reaches); fails_when=Open Chat, Change location or Copy recovery request run another editor command or copy another text; no_claim=what the editor does with them; seam=the stubbed editor's command log and clipboard
+test('Open Chat, Change location and Copy recovery request run the editor commands and the copy the plan names', async (context) => {
   // Arrange
   const project = await openEmptyProject(context)
 
   // Act
   await project.runCommand('codebook.llmWiki.openChat')
   await project.runCommand('codebook.llmWiki.changeLocation')
-  await project.runCommand('codebook.revealWikiFolder')
   await project.runCommand('codebook.copyWikiRecoveryRequest')
 
   // Assert
   assert.deepEqual(
     [project.executedCommands, project.clipboard, project.notices],
     [
-      [
-        'workbench.action.chat.open',
-        'workbench.action.openSettings',
-        'revealFileInOS',
-      ],
+      ['workbench.action.chat.open', 'workbench.action.openSettings'],
       ['/codebook Recover the unfinished LLM Wiki publish for this project'],
       ['Copied the recovery request. Paste it into the editor chat.'],
     ],
   )
 })
 
+// Value: protects=AC 2 (the view settles after a debounced event, so a test proves an absent read without a fixed sleep); fails_when=whenIdle resolves while the debounced read of a watched file's event is still waiting, so a test reads its result too early or proves an absence too soon; no_claim=the debounce length; seam=a manifest event, the debounce shortened to 40 ms
+test('the view is idle only after the debounced read of a manifest event has shown the Wiki', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+
+  // Act
+  project.reportFileEvent(
+    'create',
+    join(project.outputDirectory, 'codebook-wiki.json'),
+  )
+  await project.llmWiki.whenIdle()
+
+  // Assert
+  assert.deepEqual(idsOf(project), ['wiki', 'output'])
+})
+
+// Value: protects=AC 4 (Reveal Wiki Folder opens a folder that exists on this computer); fails_when=the command opens nothing for a Wiki folder that exists locally, or opens another folder; no_claim=what the operating system's file manager does; seam=the stubbed editor's command log
+test('Reveal Wiki Folder on a published Wiki asks the editor to reveal that folder', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context)
+
+  // Act
+  await window.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [window.executedCommands, window.notices],
+    [['revealFileInOS'], []],
+  )
+})
+
+// Value: protects=AC 4 (Reveal Wiki Folder says why nothing opened for a missing folder); fails_when=the command runs the editor's reveal on a folder that does not exist, which shows nothing, or says nothing; no_claim=the wording in another editor language; seam=a project with no Wiki folder
+test('Reveal Wiki Folder on a missing folder says the folder does not exist yet and reveals nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+
+  // Act
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [project.executedCommands, project.notices],
+    [
+      [],
+      [
+        'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=AC 4 (Reveal Wiki Folder says why nothing opened in a remote window); fails_when=a window connected to a remote host asks the editor to reveal a folder that is on the remote host, which opens nothing on this computer, with no sentence; no_claim=the remote name's spelling in every editor; seam=env.remoteName of the fake editor
+test('Reveal Wiki Folder in a remote window says the folder is on the remote host and reveals nothing', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context, {
+    remoteName: 'ssh-remote',
+  })
+
+  // Act
+  await window.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [window.executedCommands, window.notices],
+    [
+      [],
+      [
+        'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal in this window, which runs in that remote environment, not on this computer.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=RT2-B (1) (a WSL window reveals as a local one); fails_when=a WSL window is refused as remote although the editor's reveal works there, as Codebook treats WSL like a local window everywhere; no_claim=what the reveal shows in WSL; seam=env.remoteName of the fake editor
+test('Reveal Wiki Folder in a WSL window reveals the folder and shows no notice', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context, { remoteName: 'wsl' })
+
+  // Act
+  await window.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [window.executedCommands, window.notices],
+    [['revealFileInOS'], []],
+  )
+})
+
+// Value: protects=RT2-B (2) (a file at the output path is not told as missing); fails_when=a file where the Wiki folder should be is told "does not exist (yet)", which sends the learner to Generate instead of to the file; no_claim=the Wiki row for this cause; seam=a file written at the default output path
+test('Reveal Wiki Folder on a file in the folder’s place says it is a file and reveals nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await mkdir(dirname(project.outputDirectory), { recursive: true })
+  await writeFile(project.outputDirectory, 'not a folder')
+
+  // Act
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [project.executedCommands, project.notices],
+    [
+      [],
+      [
+        'The LLM Wiki folder .codebook/wiki is a file, not a folder. Remove or rename that file, or change the location.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=RT3-c (an unreadable parent of the Wiki folder is not told as "does not exist (yet)"); fails_when=a path whose look fails with ENOTDIR is worded as missing, which sends the learner to Generate instead of to the path; no_claim=EACCES wording (same branch, code differs); seam=a file written where the output's parent folder should be
+test('Reveal Wiki Folder on an unreadable path says it cannot be read with the error code and reveals nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await mkdir(dirname(dirname(project.outputDirectory)), { recursive: true })
+  await writeFile(dirname(project.outputDirectory), 'not a folder')
+
+  // Act
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [project.executedCommands, project.notices],
+    [
+      [],
+      [
+        'The LLM Wiki folder .codebook/wiki cannot be read (ENOTDIR). Check the path and its permissions, or change the location.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=F2 (b) (a link to nothing at the output path is not told as missing); fails_when=a dangling link is worded "does not exist (yet)" so the learner presses Generate, which refuses a link; no_claim=a link to a folder; seam=a symbolic link at the default output path whose target does not exist
+test('Reveal Wiki Folder on a link whose target is missing says so and reveals nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await mkdir(dirname(project.outputDirectory), { recursive: true })
+  await symlink(
+    join(project.projectRoot, 'nowhere'),
+    project.outputDirectory,
+    'junction',
+  )
+
+  // Act
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [project.executedCommands, project.notices],
+    [
+      [],
+      [
+        'The LLM Wiki folder .codebook/wiki is a link whose target is missing. Remove or fix the link, or change the location.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=F7 (a Wiki location that cannot be worked out is told); fails_when=an empty output setting makes Reveal Wiki Folder reject with no notice and nothing in Output; no_claim=the wording of the setting check; seam=the output setting set to an empty text
+test('Reveal Wiki Folder with an empty output setting says the folder cannot be found, records it and reveals nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  project.setOutputSetting('')
+
+  // Act
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(
+    [
+      project.executedCommands,
+      project.notices,
+      project.outputLines.filter((line) => line.includes('Reveal Wiki Folder')),
+    ],
+    [
+      [],
+      [
+        'Reveal Wiki Folder could not find the Wiki folder (Choose a nonempty local DeepWiki output directory). Change the location.',
+      ],
+      [
+        'error: Reveal Wiki Folder could not resolve the Wiki folder: Choose a nonempty local DeepWiki output directory.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=AC 2 (the view does no background work while hidden); fails_when=a manifest event while the view is collapsed runs the freshness check, or showing the view again does not read once more and check the freshness; no_claim=the poll (read-loop tests); seam=setVisible(false), a manifest event and the view's own settle
+test('a collapsed view runs no freshness check for a manifest event and checks once when it is shown again', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(context)
+  await untilFreshness(window)
+  await window.llmWiki.whenIdle()
+  const checksWhileShown = window.looks.freshnessInspections
+
+  // Act
+  window.llmWiki.setVisible(false)
+  window.reportFileEvent(
+    'change',
+    join(wiki.outputDirectory, 'codebook-wiki.json'),
+  )
+  await window.llmWiki.whenIdle()
+  const checksWhileHidden = window.looks.freshnessInspections
+  window.llmWiki.setVisible(true)
+  await window.llmWiki.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [
+      checksWhileHidden - checksWhileShown,
+      window.looks.freshnessInspections - checksWhileShown,
+    ],
+    [0, 1],
+  )
+})
+
+// Value: protects=N55-F3 (the message and the rows change in one render); fails_when=the view writes the tree message when it sets its model, before the editor reads the new rows, so the message shows in one frame and the rows in another; no_claim=the editor's frames (N56 step 4); seam=the fake tree's render log of change events, root reads and message writes
+test('the message changes only when the tree reads the new rows, not when the change event fires', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  const watchingMessage =
+    'Codebook is watching the chat. Stop watching does not stop the chat; stop it in the chat.'
+  const stoppedMessage =
+    'Codebook stopped watching the chat, which may still publish this Wiki. To stop it, stop the request in the chat.'
+
+  // Act
+  await project.runCommand('codebook.llmWiki.stopWatching')
+  await untilRow(project, 'reservation')
+
+  // Assert
+  const log = project.llmWiki.renderLog()
+  const writeIndex = log.indexOf(`message:${stoppedMessage}`)
+  assert.deepEqual(
+    [project.llmWiki.message(), log.slice(writeIndex - 2, writeIndex + 1)],
+    [
+      stoppedMessage,
+      [`change:${watchingMessage}`, 'getChildren', `message:${stoppedMessage}`],
+    ],
+  )
+})
+
+// Value: protects=task 25 (row 5's click, O3); fails_when=a click on the Output row does nothing, so its description Change location is not a way to change the location; no_claim=what the settings editor shows; seam=the row's command as the editor would run it
+test('a click on the Output row opens the setting that names the Wiki folder', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context)
+
+  // Act
+  const click = rowOf(window, 'output')?.command
+  await window.runCommand(click?.command ?? '')
+
+  // Assert
+  assert.deepEqual(
+    [click?.command, window.executedCommandCalls],
+    [
+      'codebook.llmWiki.changeLocation',
+      [
+        {
+          name: 'workbench.action.openSettings',
+          argument: '@id:codebook.wikiOutputDirectory',
+        },
+      ],
+    ],
+  )
+})
+
 // Value: protects=the view's folder row actions; fails_when=Open Folder runs a command other than the editor's folder dialog; no_claim=the dialog; seam=the stubbed editor's command log
 test('Open Folder runs the editor’s folder dialog command', async (context) => {
   // Arrange
@@ -1639,6 +1903,8 @@ test('a reservation inside its window still shows Waiting for chat', async (cont
 test('Change location opens the settings searched for the output setting and Reveal Wiki Folder reveals the output folder', async (context) => {
   // Arrange
   const project = await openEmptyProject(context)
+  // Reveal Wiki Folder reveals a folder that exists; a missing one is told instead.
+  await mkdir(project.outputDirectory, { recursive: true })
 
   // Act
   await project.runCommand('codebook.llmWiki.changeLocation')
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index 95a31e08..b7e26f8b 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -15,6 +15,7 @@ import type {
   LlmWikiViewFacts,
 } from '../utils/readLlmWikiViewState'
 
+import { defer } from './utils/defer'
 import { createFakeLlmWikiEditor } from './utils/fakeLlmWikiEditor'
 
 type ReadyFacts = Extract<LlmWikiViewFacts, { kind: 'ready' }>
@@ -22,17 +23,6 @@ type ReadyFacts = Extract<LlmWikiViewFacts, { kind: 'ready' }>
 const WATCHED_PROJECT = '/project'
 const WATCHED_OUTPUT = '/project/.codebook/wiki'
 
-/** A promise a test settles by hand. */
-function defer<Value>() {
-  let resolve: (value: Value) => void = () => {}
-  let reject: (cause: unknown) => void = () => {}
-  const promise = new Promise<Value>((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise
-    reject = rejectPromise
-  })
-  return { promise, resolve, reject }
-}
-
 /** Ready facts for a project with no Wiki; a test adds what it examines. */
 function readyFacts(overrides: Partial<ReadyFacts> = {}): ReadyFacts {
   return {
@@ -56,9 +46,11 @@ const publishedWiki: ReadyFacts['wiki'] = {
 function openView(
   context: TestContext,
   overrides: Partial<LlmWikiViewOptions> = {},
+  fakeOptions: Parameters<typeof createFakeLlmWikiEditor>[0] = {},
 ) {
-  const fake = createFakeLlmWikiEditor()
+  const fake = createFakeLlmWikiEditor(fakeOptions)
   const recordedFailures: string[] = []
+  const recordedCauses: unknown[] = []
   const tellings: string[] = []
   const view = createLlmWikiView({
     editor: fake.editor,
@@ -70,13 +62,16 @@ function openView(
     tellPublished: (label): void => {
       tellings.push(label)
     },
-    recordFailure: (message) => recordedFailures.push(message),
+    recordFailure: (message, cause) => {
+      recordedFailures.push(message)
+      recordedCauses.push(cause)
+    },
     debounceMs: 20,
     pollMs: 50,
     ...overrides,
   })
   context.after(() => view.dispose())
-  return { fake, view, recordedFailures, tellings }
+  return { fake, view, recordedFailures, recordedCauses, tellings }
 }
 
 const idsOf = (fake: ReturnType<typeof createFakeLlmWikiEditor>): string[] =>
@@ -536,13 +531,181 @@ test('an event of an unrelated file below the watched folder reads nothing', asy
 
   // Act
   fake.files.report('change', '/project/.codebook/wiki/index.html')
-  // gstack-timing-ok: proves no read follows; waits six times this view's 20 ms debounce, after which a matched event would have read
-  await new Promise((resolve) => setTimeout(resolve, 120))
+  // Settled: no debounced read is waiting and none runs, so a read for this event would already be counted.
+  await view.whenIdle()
 
   // Assert
   assert.equal(readCount() - readsBefore, 0)
 })
 
+/** Facts that show this window's run row, so the view polls. */
+const runningFacts = (): ReadyFacts =>
+  readyFacts({
+    run: {
+      kind: 'generate',
+      startedAtMs: 0,
+      timeoutMs: 3_300_000,
+      isAwaitingChat: false,
+    },
+  })
+
+// Value: protects=the debounce flush; fails_when=the view reports itself settled while the debounce of a matched event is still waiting, so the read it will make is missed by a test that proves a count; no_claim=the debounce length; seam=a matched event, the debounce of 20 ms
+test('a watched file’s event is read once after the debounce, before the view reports itself settled', async (context) => {
+  // Arrange
+  const { fake, readCount, view } = openWatchedView(context)
+  await view.whenIdle()
+  const readsBefore = readCount()
+
+  // Act
+  fake.files.report('change', WATCHED_OUTPUT)
+  await view.whenIdle()
+
+  // Assert
+  assert.equal(readCount() - readsBefore, 1)
+})
+
+// Value: protects=the 30 second poll across a failed read; fails_when=a read that throws while a run row showed replaces the run row with the error row and the poll stops, so a run that ended elsewhere never clears the error row; no_claim=the 30 second value; seam=mocked timers, a read that succeeds with a run and then throws
+test('the poll keeps reading after a read failed while a run row showed', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let isFailing = false
+  let reads = 0
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isFailing) throw new Error('disk busy')
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+  isFailing = true
+  await view.refresh()
+  const readsWithTheErrorRow = reads
+
+  // Act
+  context.mock.timers.tick(50)
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [fake.rows().map((row) => row.label), reads - readsWithTheErrorRow],
+    [[ERROR_ROW_LABEL], 1],
+  )
+})
+
+// Value: protects=the error row clears once the run is over; fails_when=the poll that continues across the error row never stops, or the next good read does not clear the error row; no_claim=the 30 second value; seam=mocked timers
+test('the poll stops once a good read shows no run after the error row', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let step: 'run' | 'fail' | 'idle' = 'run'
+  let reads = 0
+  const { view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (step === 'fail') throw new Error('disk busy')
+      return step === 'run' ? runningFacts() : readyFacts()
+    },
+  })
+  await view.whenIdle()
+  step = 'fail'
+  await view.refresh()
+  step = 'idle'
+  context.mock.timers.tick(50)
+  await view.whenIdle()
+  const readsAfterTheGoodRead = reads
+
+  // Act
+  context.mock.timers.tick(200)
+  await view.whenIdle()
+
+  // Assert
+  assert.equal(reads - readsAfterTheGoodRead, 0)
+})
+
+// Value: protects=the poll runs only for a run that was shown; fails_when=an error row after a read that never showed a run starts the poll, so a broken folder is read again and again; why_new=the neighbouring poll tests start from a shown run; no_claim=the 30 second value; seam=mocked timers, a read that throws from the first call
+test('the poll does not start for an error row when no run row was shown before', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let reads = 0
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      throw new Error('disk busy')
+    },
+  })
+  await view.whenIdle()
+  const readsWithTheErrorRow = reads
+
+  // Act
+  context.mock.timers.tick(200)
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [fake.rows().map((row) => row.label), reads - readsWithTheErrorRow],
+    [[ERROR_ROW_LABEL], 0],
+  )
+})
+
+// Value: protects=task 22 (one read when the view is shown); fails_when=showing a hidden view waits for the 1 s debounce, so stale rows stay on screen and the poll stays stopped for that second; no_claim=the editor's visibility semantics; seam=mocked timers with no tick after the view is shown
+test('a hidden view that is shown reads at once without waiting for the debounce', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let reads = 0
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+  fake.setVisible(false)
+  const readsWhenHidden = reads
+
+  // Act
+  fake.setVisible(true)
+  await afterEventLoopTurn()
+
+  // Assert
+  assert.equal(reads - readsWhenHidden, 1)
+})
+
+// Value: protects=no background work while hidden; fails_when=a collapsed view still polls while a run row shows, or showing it again does not read once and restart the poll; no_claim=the editor's visibility semantics; seam=mocked timers, the fake view's visibility
+test('a hidden view does not poll and a shown view reads once and polls again', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let reads = 0
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  fake.setVisible(false)
+  const readsWhenHidden = reads
+  context.mock.timers.tick(500)
+  await view.whenIdle()
+  const readsAfterHiddenTicks = reads
+  fake.setVisible(true)
+  await view.whenIdle()
+  const readsAfterShown = reads
+  context.mock.timers.tick(50)
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [
+      readsAfterHiddenTicks - readsWhenHidden,
+      readsAfterShown - readsAfterHiddenTicks,
+      reads - readsAfterShown,
+    ],
+    [0, 1, 1],
+  )
+})
+
 // Value: protects=item 8, an output outside the project whose parent is missing; fails_when=the watcher walks up to an ancestor (the home folder or the root) and watches it recursively, or the Output row does not say the view refreshes on visibility and Refresh only, or the cause is recorded more than once; no_claim=the editor's cost of a recursive watch; seam=a findWatchedFolder that answers a far ancestor
 test('an output outside the project with a missing parent gets no watcher, an Output tooltip that says so and one record in Output', async (context) => {
   // Arrange
@@ -637,3 +800,565 @@ test('refresh resolves even when the read failed', async (context) => {
   // Assert
   assert.equal(outcome, 'resolved')
 })
+
+const WATCHING_MESSAGE =
+  'Codebook is watching the chat. Stop watching does not stop the chat; stop it in the chat.'
+
+// Value: protects=RT2-A (one Output record per failure while the error row stands); fails_when=the 30 s poll that continues across the error row writes the same read failure to Output › Codebook at every tick; no_claim=the 30 second value; seam=mocked timers, a read that succeeds with a run and then keeps throwing
+test('a read failure that persists across poll ticks is recorded once in Output', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let isFailing = false
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      if (isFailing) throw new Error('disk busy')
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+  isFailing = true
+
+  // Act
+  await view.refresh()
+  for (let tick = 0; tick < 3; tick += 1) {
+    context.mock.timers.tick(50)
+    await view.whenIdle()
+  }
+
+  // Assert
+  assert.deepEqual(recordedFailures, [
+    'The LLM Wiki view could not read its state',
+  ])
+})
+
+// Value: protects=SM3 (a) (a failure in the row step is recorded once however many poll ticks meet it); fails_when=a read that fails in the step that makes rows clears the dedupe first, so every 30 s tick writes the same record to Output; no_claim=the 30 second value; seam=mocked timers, a run row shown, then facts whose row step throws on every read
+test('a row-step failure that persists across poll ticks is recorded once in Output', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let isBroken = false
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      const facts = runningFacts()
+      if (isBroken)
+        Object.defineProperty(facts, 'run', {
+          enumerable: true,
+          get(): never {
+            throw new Error('row step failed')
+          },
+        })
+      return facts
+    },
+  })
+  await view.whenIdle()
+  isBroken = true
+
+  // Act
+  await view.refresh()
+  for (let tick = 0; tick < 3; tick += 1) {
+    context.mock.timers.tick(50)
+    await view.whenIdle()
+  }
+
+  // Assert
+  assert.equal(recordedFailures.length, 1)
+})
+
+// Value: protects=SM3 (b) (a freshness check that cannot be shown is recorded once however many poll ticks meet it); fails_when=a good read clears the dedupe before the freshness result is shown, so each tick records the same freshness failure again and the view flips between the Wiki row and the error row; no_claim=the 30 second value; seam=mocked timers, a run row with a Wiki, a freshness read that returns a value the rows cannot be made from
+test('a freshness failure that persists across poll ticks is recorded once in Output', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => ({ ...runningFacts(), wiki: publishedWiki }),
+    // A freshness answer whose status getter throws when the rows are made from it.
+    readFreshness: async () => {
+      const freshness = {}
+      Object.defineProperty(freshness, 'status', {
+        enumerable: true,
+        get(): never {
+          throw new Error('freshness rows failed')
+        },
+      })
+      return freshness as LlmWikiFreshness
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  for (let tick = 0; tick < 3; tick += 1) {
+    context.mock.timers.tick(50)
+    await view.whenIdle()
+  }
+
+  // Assert
+  assert.equal(recordedFailures.length, 1)
+})
+
+// Value: protects=RT3-b (two different failures with the same message are two records); fails_when=the dedupe keys on the message text only, so an error with the same message and another code (or a thrown non-Error with the same text) is swallowed; no_claim=the Output wording; seam=readFacts that throws the same message with two codes
+test('two failures with the same message and different error codes are recorded twice', async (context) => {
+  // Arrange
+  const outcomes = [
+    Object.assign(new Error('operation failed'), { code: 'EACCES' }),
+    Object.assign(new Error('operation failed'), { code: 'EBUSY' }),
+  ]
+  let next = 0
+  const { recordedCauses, view } = openView(context, {
+    readFacts: async () => {
+      throw outcomes[next++]
+    },
+  })
+
+  // Act
+  await view.whenIdle()
+  await view.refresh()
+
+  // Assert
+  assert.deepEqual(
+    recordedCauses.map((cause) => (cause as { code: string }).code),
+    ['EACCES', 'EBUSY'],
+  )
+})
+
+// Value: protects=RT2-A (a different failure, or one after a good read, is recorded again); fails_when=the dedupe swallows a new cause or never resets after a good read, so a later failure leaves Output silent; no_claim=the cause's wording; seam=a readFacts that throws two causes, then succeeds, then throws the first cause again
+test('a different failure and a failure after a good read are recorded again', async (context) => {
+  // Arrange
+  const outcomes: Array<Error | 'good'> = [
+    new Error('disk busy'),
+    new Error('disk busy'),
+    new Error('permission denied'),
+    'good',
+    new Error('disk busy'),
+  ]
+  let next = 0
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      const outcome = outcomes[next++]
+      if (outcome instanceof Error) throw outcome
+      return readyFacts()
+    },
+  })
+
+  // Act
+  for (let read = 0; read < outcomes.length; read += 1) await view.refresh()
+
+  // Assert
+  assert.equal(recordedFailures.length, 3)
+})
+
+// Value: protects=SM2-1 (debounce-pending x dispose, T2); fails_when=whenIdle keeps waiting for a debounce that dispose dropped, so a test or caller hangs, or the dropped debounce still reads; no_claim=the debounce length; seam=mocked timers with no tick after dispose
+test('dispose while a debounce is pending settles whenIdle without a tick and reads nothing', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let reads = 0
+  const { view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      return readyFacts()
+    },
+  })
+  await view.whenIdle()
+  const readsBefore = reads
+  view.requestRefresh()
+  let isIdle = false
+  const idle = view.whenIdle().then(() => {
+    isIdle = true
+  })
+
+  // Act
+  view.dispose()
+  await idle
+
+  // Assert
+  assert.deepEqual([isIdle, reads - readsBefore], [true, 0])
+})
+
+// Value: protects=SM2-2 (reading x requestRefresh); fails_when=a debounced refresh that fires while a read runs is dropped or double-counted, so the last event is not shown or three reads happen; no_claim=the debounce length; seam=mocked timers, a held readFacts
+test('a debounced refresh that fires during a read makes one more read and shows the last facts', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  const held = defer<LlmWikiViewFacts>()
+  let reads = 0
+  let isHoldingNextRead = false
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isHoldingNextRead) {
+        // Only the first read after the arrangement is held; the re-read is not.
+        isHoldingNextRead = false
+        return held.promise
+      }
+      return readyFacts({ wiki: publishedWiki, outputLabel: '.codebook/last' })
+    },
+  })
+  await view.whenIdle()
+  const readsBefore = reads
+  isHoldingNextRead = true
+  const heldRefresh = view.refresh()
+  await afterEventLoopTurn()
+
+  // Act
+  view.requestRefresh()
+  context.mock.timers.tick(20)
+  await afterEventLoopTurn()
+  held.resolve(
+    readyFacts({ wiki: publishedWiki, outputLabel: '.codebook/held' }),
+  )
+  await heldRefresh
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [reads - readsBefore, rowOf(fake, 'output')?.label],
+    [2, 'Output: .codebook/last'],
+  )
+})
+
+// Value: protects=SM2-3 (reading x refresh); fails_when=refreshes asked for during a read start a read each, or are dropped so the last facts are not shown; no_claim=the Refresh command's wiring; seam=a held readFacts, three refresh calls
+test('three refreshes during a read make exactly one more read and show the last facts', async (context) => {
+  // Arrange
+  const held = defer<LlmWikiViewFacts>()
+  let reads = 0
+  let isHoldingNextRead = false
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isHoldingNextRead) {
+        // Only the first read after the arrangement is held; the re-read is not.
+        isHoldingNextRead = false
+        return held.promise
+      }
+      return readyFacts({ wiki: publishedWiki, outputLabel: '.codebook/last' })
+    },
+  })
+  await view.whenIdle()
+  const readsBefore = reads
+  isHoldingNextRead = true
+  const heldRefresh = view.refresh()
+  await afterEventLoopTurn()
+
+  // Act
+  const more = [view.refresh(), view.refresh(), view.refresh()]
+  held.resolve(
+    readyFacts({ wiki: publishedWiki, outputLabel: '.codebook/held' }),
+  )
+  await Promise.all([heldRefresh, ...more])
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [reads - readsBefore, rowOf(fake, 'output')?.label],
+    [2, 'Output: .codebook/last'],
+  )
+})
+
+// Value: protects=SM2-4 (reading x show); fails_when=showing a hidden view while a read runs neither re-reads nor runs the freshness check, so the rows stay as that read left them; no_claim=the editor's visibility semantics; seam=a hidden view, a held readFacts, setVisible(true)
+test('showing a hidden view during a read reads again and runs the freshness check', async (context) => {
+  // Arrange
+  const held = defer<LlmWikiViewFacts>()
+  let reads = 0
+  let freshnessChecks = 0
+  let isHoldingNextRead = false
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isHoldingNextRead) {
+        // Only the first read after the arrangement is held; the re-read is not.
+        isHoldingNextRead = false
+        return held.promise
+      }
+      return readyFacts({ wiki: publishedWiki })
+    },
+    readFreshness: async () => {
+      freshnessChecks += 1
+      return { status: 'current' }
+    },
+  })
+  await view.whenIdle()
+  fake.setVisible(false)
+  const readsBefore = reads
+  const checksBefore = freshnessChecks
+  isHoldingNextRead = true
+  const heldRefresh = view.refresh()
+  await afterEventLoopTurn()
+
+  // Act
+  fake.setVisible(true)
+  held.resolve(readyFacts({ wiki: publishedWiki }))
+  await heldRefresh
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [reads - readsBefore, freshnessChecks > checksBefore],
+    [2, true],
+  )
+})
+
+// Value: protects=SM2-5 (error-after-run-row x hide); fails_when=a collapsed view keeps polling across the error row; no_claim=the 30 second value; seam=mocked timers, a run row, a failing read, setVisible(false)
+test('hiding the view while the error row follows a run row stops the poll', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let isFailing = false
+  let reads = 0
+  const { view, fake } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isFailing) throw new Error('disk busy')
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+  isFailing = true
+  await view.refresh()
+  fake.setVisible(false)
+  await view.whenIdle()
+  const readsWhenHidden = reads
+
+  // Act
+  context.mock.timers.tick(200)
+  await view.whenIdle()
+
+  // Assert
+  assert.equal(reads - readsWhenHidden, 0)
+})
+
+// Value: protects=SM2-6 (error-after-run-row x show); fails_when=showing the view again with a still-failing read forgets the run that was shown, so the poll never restarts and the error row stays; no_claim=the 30 second value; seam=mocked timers, a run row, a failing read, hide, show
+test('showing the view again with a read that still fails restarts the poll across the error row', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  let isFailing = false
+  let reads = 0
+  const { view, fake } = openView(context, {
+    readFacts: async () => {
+      reads += 1
+      if (isFailing) throw new Error('disk busy')
+      return runningFacts()
+    },
+  })
+  await view.whenIdle()
+  isFailing = true
+  await view.refresh()
+  fake.setVisible(false)
+  fake.setVisible(true)
+  await view.whenIdle()
+  const readsAfterShown = reads
+
+  // Act
+  context.mock.timers.tick(50)
+  await view.whenIdle()
+
+  // Assert
+  assert.equal(reads - readsAfterShown, 1)
+})
+
+// Value: protects=SM2-7 (message cleared x getChildren) and N55-F3; fails_when=a state without a message writes the cleared message before the tree reads the new rows, or never clears the old one; no_claim=the editor's frames; seam=the fake tree's render log
+test('a state without a message clears the message when the tree reads its rows, after getChildren', async (context) => {
+  // Arrange
+  let isRunning = true
+  const { fake, view } = openView(context, {
+    readFacts: async () => (isRunning ? runningFacts() : readyFacts()),
+  })
+  await view.whenIdle()
+  fake.rows()
+  isRunning = false
+  await view.refresh()
+
+  // Act
+  fake.rows()
+
+  // Assert
+  assert.deepEqual(fake.renderLog(), [
+    'getChildren',
+    `message:${WATCHING_MESSAGE}`,
+    'getChildren',
+    'message:undefined',
+  ])
+})
+
+// Value: protects=RT2-C (a root read inside createTreeView); fails_when=an editor that reads the provider while createTreeView runs makes the view throw before it has its tree view handle, or the message is lost afterwards; no_claim=a message at that moment (the first model has none); seam=a fake editor that calls getChildren synchronously from createTreeView
+test('an editor that reads the root inside createTreeView still gets the rows and the message', async (context) => {
+  // Arrange
+  const { fake, view } = openView(
+    context,
+    { readFacts: async () => runningFacts() },
+    { readsRootInsideCreateTreeView: true },
+  )
+
+  // Act
+  await view.whenIdle()
+  const rowIds = idsOf(fake)
+
+  // Assert
+  assert.deepEqual(
+    [rowIds, fake.message()],
+    [['run', 'output'], WATCHING_MESSAGE],
+  )
+})
+
+// Value: protects=F1 (no freshness work while hidden, also for a check queued before the hide); fails_when=a check queued while another ran still starts after the view is hidden (full-source hashing and Git work for a collapsed view), or showing the view again queues no current check; no_claim=the answer of the check that was running; seam=a held first freshness check, a refresh that queues the second, setVisible(false) before the first is released
+test('a freshness check queued before the view is hidden does not start while it is hidden, and showing the view checks again', async (context) => {
+  // Arrange
+  const heldFirstCheck = defer<LlmWikiFreshness>()
+  let checkCount = 0
+  const { fake, view } = openView(context, {
+    readFreshness: () => {
+      checkCount += 1
+      return checkCount === 1
+        ? heldFirstCheck.promise
+        : Promise.resolve<LlmWikiFreshness>({ status: 'current' })
+    },
+  })
+  await waitUntil(() => checkCount === 1, 'the first check', 6_000)
+  await view.refresh()
+
+  // Act
+  fake.setVisible(false)
+  heldFirstCheck.resolve({ status: 'changed' })
+  await view.whenIdle()
+  await afterEventLoopTurn()
+  const checksWhileHidden = checkCount
+  fake.setVisible(true)
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [checksWhileHidden, checkCount, rowOf(fake, 'wiki')?.description],
+    [1, 2, 'Wiki source current'],
+  )
+})
+
+// Value: protects=F4 (a cause that cannot be read still shows the error row); fails_when=a cause whose message getter throws makes the failure key throw, so refresh rejects, the error row never shows and nothing is recorded; no_claim=the wording of the record; seam=an Error whose message getter throws, thrown by readFacts twice
+test('a failure whose message cannot be read still shows the error row, resolves refresh and is recorded once', async (context) => {
+  // Arrange
+  const unhandled = collectUnhandledRejections(context)
+  const hostileCause = new Error('hidden')
+  Object.defineProperty(hostileCause, 'message', {
+    get(): never {
+      throw new Error('message getter failed')
+    },
+  })
+  const { fake, recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      throw hostileCause
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  const outcome = await view.refresh().then(
+    () => 'resolved',
+    () => 'rejected',
+  )
+  await afterEventLoopTurn()
+
+  // Assert
+  assert.deepEqual(
+    [outcome, fake.rows().map((row) => row.label), recordedFailures, unhandled],
+    [
+      'resolved',
+      [ERROR_ROW_LABEL],
+      ['The LLM Wiki view could not read its state'],
+      [],
+    ],
+  )
+})
+
+// Value: protects=F5 (a message that embeds a changing number is one failure); fails_when=a failure whose message differs only in a number at each poll tick (a pid, a duration) is recorded at every tick, which floods Output › Codebook; no_claim=a different code with the same text (the codes test above); seam=readFacts that throws the same code with a counting number in its message
+test('a failure that differs from the recorded one only in a number of its message is recorded once', async (context) => {
+  // Arrange
+  let attempt = 0
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      attempt += 1
+      throw Object.assign(new Error(`disk busy after ${attempt * 30} ms`), {
+        code: 'EBUSY',
+      })
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  await view.refresh()
+  await view.refresh()
+
+  // Assert
+  assert.deepEqual(recordedFailures, [
+    'The LLM Wiki view could not read its state',
+  ])
+})
+
+// Value: protects=F6 (a good read between two equal failures); fails_when=a good read that still waits for its freshness answer does not end the failure that stood, so the same failure after it is swallowed and Output stays silent for a real new failure; no_claim=the freshness answer; seam=a read that fails, a good read with a Wiki whose freshness check is held, the same failure again
+test('a failure after a good read is recorded again even while that read’s freshness check is still running', async (context) => {
+  // Arrange
+  let isFailing = true
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => {
+      if (isFailing) throw new Error('disk busy')
+      return readyFacts({ wiki: publishedWiki })
+    },
+    // The check never answers during the test: the good read has not shown a freshness result.
+    readFreshness: () => new Promise<LlmWikiFreshness>(() => {}),
+  })
+  await view.refresh()
+  isFailing = false
+  await view.refresh()
+
+  // Act
+  isFailing = true
+  await view.refresh()
+
+  // Assert
+  assert.equal(recordedFailures.length, 2)
+})
+
+// Value: protects=F6 (a freshness check that keeps failing is recorded once, a later one after a good check again); fails_when=a failing freshness check is never written to Output (the label says unknown and nothing tells why), is written at every poll tick, or is not written again after a check succeeded; no_claim=the unknown label (the test above); seam=mocked timers, a run row with a Wiki, a freshness read that fails on three ticks, then succeeds for a new publication, then fails
+test('a freshness check that keeps failing is recorded once in Output, and again after a check succeeded', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setInterval', 'setTimeout'] })
+  const freshnessOutcomes = ['fail', 'fail', 'fail', 'ok', 'fail']
+  let checkCount = 0
+  const { recordedFailures, view } = openView(context, {
+    readFacts: async () => ({
+      ...runningFacts(),
+      // The receipt changes after the third check, so the cached answer of the successful check does not serve the last one.
+      publication: checkCount >= 4 ? 'b@2' : 'a@1',
+      wiki: publishedWiki,
+    }),
+    readFreshness: async () => {
+      const outcome = freshnessOutcomes[checkCount++]
+      if (outcome === 'fail') throw new Error('git failed')
+      return { status: 'current' }
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  for (let tick = 0; tick < 4; tick += 1) {
+    context.mock.timers.tick(50)
+    await view.whenIdle()
+  }
+
+  // Assert
+  assert.deepEqual(recordedFailures, [
+    'The LLM Wiki view could not check whether the Wiki is current',
+    'The LLM Wiki view could not check whether the Wiki is current',
+  ])
+})
+
+// Value: protects=F8 (no write on a disposed tree view); fails_when=a root read after dispose writes the message on the disposed tree view; no_claim=the message before dispose; seam=a run row's message set on the model but not yet read by the tree, then dispose, then a root read
+test('a root read after dispose writes no message on the tree view', async (context) => {
+  // Arrange
+  const { fake, view } = openView(context, {
+    readFacts: async () => runningFacts(),
+  })
+  await view.whenIdle()
+  view.dispose()
+
+  // Act
+  fake.rows()
+
+  // Assert
+  assert.deepEqual(
+    [fake.renderLog(), fake.message()],
+    [['getChildren'], undefined],
+  )
+})
diff --git a/extension/src/tests/readLlmWikiViewFacts.test.ts b/extension/src/tests/readLlmWikiViewFacts.test.ts
index 55a12288..f9025075 100644
--- a/extension/src/tests/readLlmWikiViewFacts.test.ts
+++ b/extension/src/tests/readLlmWikiViewFacts.test.ts
@@ -1,12 +1,15 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
+import { waitUntil } from '../runtimeSupport/utils/waitUntil'
 import type { WikiUpdateMarkerLook } from '../utils/readLiveWikiUpdateMarker'
 import {
   readLlmWikiViewFacts,
   type LlmWikiViewFactsDependencies,
 } from '../utils/readLlmWikiViewFacts'
 
+import { defer } from './utils/defer'
+
 const NOW_MS = 1_790_000_000_000
 const GENERATE_BOUND_MS = 3_300_000
 
@@ -151,3 +154,67 @@ test('the ready facts name the project root next to the output folder', async ()
     ['/repo', '/repo/.codebook/wiki'],
   )
 })
+
+// Value: protects=the speed of a refresh and the receipt-before-manifest order (item 25 of #132, item 27); fails_when=the start block, the publish token and the marker are read one after another instead of together, or any of them starts before the receipt has been read; no_claim=how long a real disk read takes; seam=reads held open until all three have started
+test('the receipt is read first, then the start block, the token and the marker start together', async () => {
+  // Arrange
+  const started: string[] = []
+  const settleReceipt = defer<string>()
+  const settleBlock = defer<undefined>()
+  const settleToken = defer<string>()
+  const settleMarker = defer<WikiUpdateMarkerLook>()
+  const read = readLlmWikiViewFacts(
+    dependencies({
+      readPublication: () => {
+        started.push('receipt')
+        return settleReceipt.promise
+      },
+      findStartBlock: () => {
+        started.push('start-block')
+        return settleBlock.promise
+      },
+      readPublishToken: () => {
+        started.push('token')
+        return settleToken.promise
+      },
+      readMarker: () => {
+        started.push('marker')
+        return settleMarker.promise
+      },
+    }),
+  )
+  await waitUntil(() => started.length >= 1, 'the receipt read', 2_000)
+  const startedBeforeTheReceipt = [...started]
+
+  // Act
+  settleReceipt.resolve('receipt@1')
+  const didAllStart = await waitUntil(
+    () => started.length >= 4,
+    'the three independent reads to start together',
+    2_000,
+  ).then(
+    () => true,
+    () => false,
+  )
+  const startedWhileAllAreHeld = [...started]
+  settleBlock.resolve(undefined)
+  settleToken.resolve('token')
+  settleMarker.resolve({ kind: 'none' })
+  const facts = await read
+
+  // Assert
+  assert.deepEqual(
+    [
+      startedBeforeTheReceipt,
+      didAllStart,
+      startedWhileAllAreHeld,
+      facts.kind === 'ready' ? facts.publication : 'not ready',
+    ],
+    [
+      ['receipt'],
+      true,
+      ['receipt', 'start-block', 'token', 'marker'],
+      'receipt@1',
+    ],
+  )
+})
diff --git a/extension/src/tests/readLlmWikiViewState.test.ts b/extension/src/tests/readLlmWikiViewState.test.ts
index 7f6c32d5..9bd9893e 100644
--- a/extension/src/tests/readLlmWikiViewState.test.ts
+++ b/extension/src/tests/readLlmWikiViewState.test.ts
@@ -546,7 +546,7 @@ for (const attentionCase of ATTENTION_CASES) {
   })
 }
 
-// Value: protects=AC 2 (fixed order of rows and row 5's presence); fails_when=the rows come in another order, or the Output row shows in the empty state or lacks Change location and the watcher note; no_claim=the settings command; seam=the pure row function
+// Value: protects=AC 2 (fixed order of rows and row 5's presence); fails_when=the rows come in another order, or the Output row shows in the empty state or lacks Change location, its click command and the watcher note; no_claim=what the settings editor shows; seam=the pure row function
 test('every row shows in the fixed order and the Output row comes last with its Change location action and watcher note', () => {
   // Arrange
   const facts = ready({
@@ -579,6 +579,7 @@ test('every row shows in the fixed order and the Output row comes last with its
     tooltip:
       '/repo/.codebook/wiki\nCodebook could not watch this folder, so the view refreshes when it is shown and with Refresh only.',
     icon: 'folder',
+    command: { command: 'codebook.llmWiki.changeLocation' },
     actions: ['change-location'],
   })
 })
diff --git a/extension/src/tests/systemErrorCode.test.ts b/extension/src/tests/systemErrorCode.test.ts
new file mode 100644
index 00000000..ac346f42
--- /dev/null
+++ b/extension/src/tests/systemErrorCode.test.ts
@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { systemErrorCode } from '../utils/systemErrorCode'
+
+// Value: protects=F9 (an own code of undefined or null is no code); fails_when=an Error with code undefined or null reads as the text 'undefined' or 'null', which then shows in "cannot be read (undefined)" and in failure keys; no_claim=the callers' branches (their own tests); seam=none
+test('the system error code is the text of a string or number code and empty for any other failure', () => {
+  // Arrange
+  const withText = Object.assign(new Error('kill'), { code: 'ESRCH' })
+  const withNumber = Object.assign(new Error('exit'), { code: 3 })
+  const withUndefined = Object.assign(new Error('odd'), { code: undefined })
+  const withNull = Object.assign(new Error('odd'), { code: null })
+  const withoutCode = new Error('plain')
+  const notAnError = { code: 'EBUSY' }
+
+  // Act
+  const codes = [
+    systemErrorCode(withText),
+    systemErrorCode(withNumber),
+    systemErrorCode(withUndefined),
+    systemErrorCode(withNull),
+    systemErrorCode(withoutCode),
+    systemErrorCode(notAnError),
+  ]
+
+  // Assert
+  assert.deepEqual(codes, ['ESRCH', '3', '', '', '', ''])
+})
diff --git a/extension/src/tests/utils/defer.ts b/extension/src/tests/utils/defer.ts
new file mode 100644
index 00000000..5bdce737
--- /dev/null
+++ b/extension/src/tests/utils/defer.ts
@@ -0,0 +1,17 @@
+/**
+ * Makes a promise a test settles by hand, so a read can be held open and released at the moment the test chooses.
+ * @returns The promise with its `resolve` and `reject`.
+ * @example
+ * const held = defer<string>()
+ * held.resolve('done')
+ * await held.promise // => 'done'
+ */
+export function defer<Value>() {
+  let resolve: (value: Value) => void = () => {}
+  let reject: (cause: unknown) => void = () => {}
+  const promise = new Promise<Value>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise
+    reject = rejectPromise
+  })
+  return { promise, resolve, reject }
+}
diff --git a/extension/src/tests/utils/fakeLlmWikiEditor.ts b/extension/src/tests/utils/fakeLlmWikiEditor.ts
index fadbee4f..61066968 100644
--- a/extension/src/tests/utils/fakeLlmWikiEditor.ts
+++ b/extension/src/tests/utils/fakeLlmWikiEditor.ts
@@ -17,18 +17,25 @@ export type FakeTreeRow = {
  * Why: the host harness reaches the view through the whole extension; the read-loop tests need to hold its closures open and count their calls, which only the view's own options allow.
  * Used by the read-loop tests of the LLM Wiki view.
  *
- * @returns `editor` (to pass as the view's editor), `rows` (the tree as shown now), `contextKeys`, `files` (the fake file watching, to report events), `fireConfigurationChange`.
+ * @param fakeOptions - `readsRootInsideCreateTreeView` makes the editor read the provider's root children synchronously inside `createTreeView`, as an editor that renders at once could.
+ * @returns `editor` (to pass as the view's editor), `rows` (the tree as shown now), `message` (the tree view's message), `renderLog` (`getChildren` for each root read and `message:<text>` for each message write, in order), `contextKeys`, `files` (the fake file watching, to report events), `setVisible`, `fireConfigurationChange`.
  * @example
  * const fake = createFakeLlmWikiEditor()
  * const view = createLlmWikiView({ editor: fake.editor, host: 'vscode', … })
  * fake.rows().map((row) => row.id) // => ['wiki', 'output']
  */
-export function createFakeLlmWikiEditor() {
+export function createFakeLlmWikiEditor(
+  fakeOptions: { readsRootInsideCreateTreeView?: boolean } = {},
+) {
+  const renderLog: string[] = []
+  let shownMessage: string | undefined
   const files = createFakeFileWatching()
   const contextKeys: Record<string, unknown> = {}
   const configurationListeners: Array<
     (event: { affectsConfiguration: (id: string) => boolean }) => void
   > = []
+  const visibilityListeners: Array<(event: { visible: boolean }) => void> = []
+  let isViewShown = true
   let provider:
     | {
         getChildren(element?: string): string[]
@@ -77,10 +84,29 @@ export function createFakeLlmWikiEditor() {
         _id: string,
         treeOptions: { treeDataProvider: NonNullable<typeof provider> },
       ) => {
-        provider = treeOptions.treeDataProvider
+        const viewProvider = treeOptions.treeDataProvider
+        provider = {
+          getChildren(element) {
+            if (element === undefined) renderLog.push('getChildren')
+            return viewProvider.getChildren(element)
+          },
+          getTreeItem: (id) => viewProvider.getTreeItem(id),
+        }
+        if (fakeOptions.readsRootInsideCreateTreeView) provider.getChildren()
         return {
-          message: undefined as string | undefined,
-          onDidChangeVisibility: () => ({ dispose(): void {} }),
+          get message(): string | undefined {
+            return shownMessage
+          },
+          set message(text: string | undefined) {
+            shownMessage = text
+            renderLog.push(`message:${text}`)
+          },
+          get visible(): boolean {
+            return isViewShown
+          },
+          onDidChangeVisibility: (
+            listener: (event: { visible: boolean }) => void,
+          ) => listenTo(visibilityListeners, listener),
           dispose(): void {},
         }
       },
@@ -109,6 +135,16 @@ export function createFakeLlmWikiEditor() {
       }),
     contextKeys,
     files,
+    /** The message the tree view shows now. */
+    message: (): string | undefined => shownMessage,
+    /** What the fake tree did, in order: `getChildren` for each root read and `message:<text>` for each message write. */
+    renderLog: (): string[] => [...renderLog],
+    /** Shows or hides the view as the learner expands or collapses it, and reports it to the view. */
+    setVisible(isVisible: boolean): void {
+      isViewShown = isVisible
+      for (const listener of [...visibilityListeners])
+        listener({ visible: isVisible })
+    },
     fireConfigurationChange(): void {
       for (const listener of [...configurationListeners])
         listener({ affectsConfiguration: () => true })
diff --git a/extension/src/tests/utils/wikiUpdateWindow.ts b/extension/src/tests/utils/wikiUpdateWindow.ts
index 30aeb6c1..73cbc187 100644
--- a/extension/src/tests/utils/wikiUpdateWindow.ts
+++ b/extension/src/tests/utils/wikiUpdateWindow.ts
@@ -12,6 +12,7 @@ import {
   type WikiFreshness,
 } from '../../utils/inspectDeepWikiFreshness'
 import { listWikiCandidates } from '../../utils/listWikiCandidates'
+import { createLlmWikiView, type LlmWikiView } from '../../utils/llmWikiView'
 import { PREPARED_LOCK_SUFFIX } from '../../utils/preparedLockSuffix'
 import { readWikiPublicationIdentity } from '../../utils/readWikiPublicationIdentity'
 import { readWikiPublishToken } from '../../utils/readWikiPublishToken'
@@ -93,6 +94,10 @@ export type FakeLlmWikiView = {
   contextKeys: Record<string, unknown>
   treeChangeCount(): number
   setVisible(isVisible: boolean): void
+  /** Resolves once the view has no debounced refresh waiting and no read or freshness check under way, so a test proves an absent read without a fixed sleep. */
+  whenIdle(): Promise<void>
+  /** What the fake tree did, in order: `change:<message shown when the change event fired>`, `getChildren` (the root read the editor makes after a change event) and `message:<text written>`. A message written before the change event shows as a `change:` entry that already holds the new text. */
+  renderLog(): string[]
 }
 
 type UriHandler = (uri: { path: string; query: string }) => Promise<void>
@@ -145,6 +150,7 @@ export type HeldUpdateStep =
  * @param options.missingEditorCommands - Commands this editor does not have: the list of its commands leaves them out, and running one throws the editor's "command not found". An editor has the chat's commands when omitted.
  * @param options.signWatchFails - Makes the editor throw this message when the extension registers its listener for opened documents.
  * @param options.editorCommand - What the editor does when the extension runs a command other than the chat request (the reveal of the chat, which is the chat command without a query, the editor's New Chat, the chat's Cancel and its "Remove All Queued", for example): it gets the command's name, and what it returns or throws is the command's result. Such a command returns nothing when omitted.
+ * @param options.remoteName - The editor's `env.remoteName`, as a window connected to a remote host reports it (for example `ssh-remote`); absent for a local window.
  * @param options.cursorAgent - What the Cursor agent does; it gets the project, the prompt, the run's abort signal, the bound the run would stop it at and the run's kind.
  * @param options.cancellable - Collects the Cancel of each run the window shows: the Cancel button of a progress notification, and the press on a status bar entry, which runs the entry's command while the entry is on screen, as a click does; the window shows both and records their texts also when omitted.
  * @param options.declineConfirmation - Makes the learner dismiss the modal confirmation of the browser's update link.
@@ -173,6 +179,7 @@ export async function openWikiUpdateWindow(options: {
   projectRoot: string
   outputSetting?: string
   cursor?: boolean
+  remoteName?: string
   chatFails?: boolean | string
   chatReply?: () => Promise<unknown>
   chatAnswerClock?: {
@@ -281,6 +288,8 @@ export async function openWikiUpdateWindow(options: {
     markerClaims: number
     /** How often the extension read the publish token: once per read of the LLM Wiki view's state, among the start checks' reads. */
     publishTokenReads: number
+    /** How often the freshness of the published Wiki was inspected: once per freshness check of the LLM Wiki view. */
+    freshnessInspections: number
   }
   markerChanges: WikiMarkerChange[]
   openWorkspace(nextProjectRoot: string): void
@@ -355,6 +364,7 @@ export async function openWikiUpdateWindow(options: {
     stampReadsDone: 0,
     markerClaims: 0,
     publishTokenReads: 0,
+    freshnessInspections: 0,
   }
   const markerChanges: WikiMarkerChange[] = []
   /** Records one change of this window's marker, and what it answered once it settled. */
@@ -394,7 +404,10 @@ export async function openWikiUpdateWindow(options: {
     | undefined
   let treeMessage: string | undefined
   let treeChangeCount = 0
+  const renderLog: string[] = []
+  let llmWikiView: LlmWikiView | undefined
   const visibilityListeners: Array<(event: { visible: boolean }) => void> = []
+  let isViewShown = true
   const holdControls = new Map<
     HeldUpdateStep,
     { started: Promise<void>; release(): void }
@@ -665,6 +678,7 @@ export async function openWikiUpdateWindow(options: {
         TreeItemCollapsibleState: { None: 0, Collapsed: 1, Expanded: 2 },
         env: {
           ...(options.cursor ? { appName: 'Cursor' } : {}),
+          ...(options.remoteName ? { remoteName: options.remoteName } : {}),
           asExternalUri: keepLocalAddress,
           openExternal: async () => true,
           clipboard: {
@@ -728,17 +742,31 @@ export async function openWikiUpdateWindow(options: {
               treeDataProvider: NonNullable<typeof treeProvider>
             },
           ) => {
-            treeProvider = treeOptions.treeDataProvider
-            treeProvider.onDidChangeTreeData(() => {
+            const provider = treeOptions.treeDataProvider
+            treeProvider = {
+              ...provider,
+              getChildren: () => {
+                renderLog.push('getChildren')
+                return provider.getChildren()
+              },
+            }
+            // Like the editor, the fake reads the root children after every change event.
+            provider.onDidChangeTreeData(() => {
               treeChangeCount += 1
+              renderLog.push(`change:${treeMessage ?? ''}`)
+              treeProvider?.getChildren()
             })
             return {
               get message() {
                 return treeMessage
               },
               set message(next: string | undefined) {
+                renderLog.push(`message:${next ?? ''}`)
                 treeMessage = next
               },
+              get visible() {
+                return isViewShown
+              },
               onDidChangeVisibility: (
                 listener: (event: { visible: boolean }) => void,
               ) => listenTo(visibilityListeners, listener),
@@ -874,6 +902,15 @@ export async function openWikiUpdateWindow(options: {
           return stamp
         },
       },
+      // The real view runs; the window only keeps its handle so a test can wait for it to settle.
+      './utils/llmWikiView': {
+        createLlmWikiView: (
+          ...created: Parameters<typeof createLlmWikiView>
+        ) => {
+          llmWikiView = createLlmWikiView(...created)
+          return llmWikiView
+        },
+      },
       './utils/readWikiPublishToken': {
         readWikiPublishToken: async (outputDirectory: string) => {
           looks.publishTokenReads += 1
@@ -933,6 +970,7 @@ export async function openWikiUpdateWindow(options: {
         inspectDeepWikiFreshness: async (
           ...checked: Parameters<typeof inspectDeepWikiFreshness>
         ) => {
+          looks.freshnessInspections += 1
           await passHold('freshness-inspection')
           return options.realFreshnessCheck
             ? inspectDeepWikiFreshness(...checked)
@@ -1032,7 +1070,14 @@ export async function openWikiUpdateWindow(options: {
       message: () => treeMessage,
       contextKeys,
       treeChangeCount: () => treeChangeCount,
+      renderLog: () => [...renderLog],
+      whenIdle: async (): Promise<void> => {
+        // A view that was never created has nothing to settle; an absent-read test must not pass on it.
+        if (!llmWikiView) throw new Error('The LLM Wiki view was not created')
+        await llmWikiView.whenIdle()
+      },
       setVisible(isVisible: boolean): void {
+        isViewShown = isVisible
         for (const listener of [...visibilityListeners])
           listener({ visible: isVisible })
       },
diff --git a/extension/src/tests/wikiFolderKindOf.test.ts b/extension/src/tests/wikiFolderKindOf.test.ts
new file mode 100644
index 00000000..87206f28
--- /dev/null
+++ b/extension/src/tests/wikiFolderKindOf.test.ts
@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { wikiFolderKindOf } from '../utils/wikiFolderKindOf'
+
+import {
+  createLinkIfAllowed,
+  LINK_NOT_ALLOWED,
+} from './utils/createLinkIfAllowed'
+
+// Value: protects=RT3-c (Reveal Wiki Folder tells a folder, a file, nothing and an unreadable path apart from one look); fails_when=a folder counts as a file, a file as a folder, a missing path as unreadable, or a path under a file reads as missing; why_new=replaces the isExistingFolder and isExistingFile tests with the one look that has all four answers; seam=a temporary folder with a folder, a file and a path below that file; no_claim=EACCES (the host test reaches the same branch with ENOTDIR on every OS)
+test('the Wiki output path is told as a folder, a file, missing, or unreadable with its error code', async (context) => {
+  // Arrange
+  const root = await mkdtemp(join(tmpdir(), 'codebook-kind-'))
+  context.after(() => rm(root, { recursive: true, force: true }))
+  const folder = join(root, 'wiki')
+  await mkdir(folder)
+  const file = join(root, 'wiki.txt')
+  await writeFile(file, 'x')
+
+  // Act
+  const results = [
+    await wikiFolderKindOf(folder),
+    await wikiFolderKindOf(file),
+    await wikiFolderKindOf(join(root, 'missing')),
+    await wikiFolderKindOf(join(file, 'below')),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    { kind: 'folder' },
+    { kind: 'file' },
+    { kind: 'missing' },
+    { kind: 'unreadable', code: 'ENOTDIR' },
+  ])
+})
+
+// Value: protects=F2 (b) (a dangling link at the output path is not told as missing); fails_when=a link to nothing reads as "does not exist (yet)", which promises that Generate creates it although generation refuses a link; no_claim=a link to a folder (it counts as a folder); seam=a symbolic link to a path that does not exist
+test('a symbolic link at the Wiki output path whose target is missing is told as a dangling link', async (context) => {
+  // Arrange
+  const root = await mkdtemp(join(tmpdir(), 'codebook-kind-'))
+  context.after(() => rm(root, { recursive: true, force: true }))
+  const link = join(root, 'wiki')
+  if (!(await createLinkIfAllowed(join(root, 'nowhere'), link)))
+    return context.skip(LINK_NOT_ALLOWED)
+
+  // Act
+  const result = await wikiFolderKindOf(link)
+
+  // Assert
+  assert.deepEqual(result, { kind: 'dangling-link' })
+})
+
+// Value: protects=F2 (a) (a look that never answers still ends); fails_when=a stat on a dead mount that never settles leaves Reveal Wiki Folder without any feedback; no_claim=the 3 second production bound; seam=an injected stat that never settles and a bound of 20 ms
+test('a look at the Wiki output path that never answers is told as unreadable with ETIMEDOUT', async () => {
+  // Arrange
+  const neverAnswering = () => new Promise<never>(() => {})
+
+  // Act
+  const result = await wikiFolderKindOf('/dead/mount/wiki', {
+    stat: neverAnswering,
+    lstat: neverAnswering,
+    timeoutMs: 20,
+  })
+
+  // Assert
+  assert.deepEqual(result, { kind: 'unreadable', code: 'ETIMEDOUT' })
+})
+
+// Value: protects=F11 (a failure without a code still has a word); fails_when=an error with no code reads as an empty or undefined code in "cannot be read (…)"; no_claim=which real failure carries no code; seam=an injected stat that rejects with a plain Error
+test('a failed look that carries no error code is told as unreadable with UNKNOWN', async () => {
+  // Arrange
+  const failing = async (): Promise<never> => {
+    throw new Error('odd failure')
+  }
+
+  // Act
+  const result = await wikiFolderKindOf('/odd/wiki', {
+    stat: failing,
+    lstat: failing,
+    timeoutMs: 1_000,
+  })
+
+  // Assert
+  assert.deepEqual(result, { kind: 'unreadable', code: 'UNKNOWN' })
+})
diff --git a/extension/src/tests/wikiQuestionPage.test.ts b/extension/src/tests/wikiQuestionPage.test.ts
index e9e80483..bded1a5b 100644
--- a/extension/src/tests/wikiQuestionPage.test.ts
+++ b/extension/src/tests/wikiQuestionPage.test.ts
@@ -45,7 +45,7 @@ function questionStatusOf(page: FakeWikiPage) {
     : 'no question status line'
 }
 
-// Value: protects=a screen reader user who asks a question on a served Wiki published before this build: "Asking the editor model…" is written into a status line that was in the page, drawn and empty, before the question, and the answer into an answer region that was shown and empty before the answer; fails_when=the reader writes the progress sentence into the answer's status region in the same handler that shows its hidden, closed disclosure, so the region enters the page together with its first text and is not announced; why_new=D2; seam=openFakeWikiPage with the 0.2.29.0 shell's script and the served codebook-qa.js, the composer of a Wiki published before the question status line, holdNext('api/ask'); no_claim=what a given screen reader announces, and the timing of a browser's accessibility tree
+// Value: protects=a screen reader user who asks a question on a served Wiki published before this build: "Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there." is written into a status line that was in the page, drawn and empty, before the question, and the answer into an answer region that was shown and empty before the answer; fails_when=the reader writes the progress sentence into the answer's status region in the same handler that shows its hidden, closed disclosure, so the region enters the page together with its first text and is not announced; why_new=D2; seam=openFakeWikiPage with the 0.2.29.0 shell's script and the served codebook-qa.js, the composer of a Wiki published before the question status line, holdNext('api/ask'); no_claim=what a given screen reader announces, and the timing of a browser's accessibility tree
 test('a question asked on a served Wiki published before this build is announced from a status line the reader added, which was in the page, drawn and empty, before the question', async () => {
   // Arrange: the page of a Wiki published by 0.2.29.0 runs that shell's own script before the reader's.
   const script = `${await shellScriptOf('scripts/fixtures/reader-shell-0.2.29.0.txt')}\n${await readServedWikiScript()}`
@@ -96,7 +96,7 @@ test('a question asked on a served Wiki published before this build is announced
       },
       statusWhileAsking: {
         role: 'status/polite',
-        text: 'Asking the editor model…',
+        text: 'Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there.',
         isShown: true,
         isInADisclosure: false,
       },
@@ -115,7 +115,7 @@ test('a question asked on a served Wiki published before this build is announced
   )
 })
 
-// Value: protects=a screen reader user who asks a question on a Wiki this build publishes: the reader writes "Asking the editor model…" into the shell's own question status line, in the page and empty before the question, and adds no second line; fails_when=the reader keeps writing the progress sentence into the answer region it shows in the same handler, or adds a line of its own beside the shell's, so the progress is not announced or is announced twice; why_new=D2; seam=openFakeWikiPage with the bundled shell's script and the served codebook-qa.js, the current shell's composer, holdNext('api/ask'); no_claim=what a given screen reader announces
+// Value: protects=a screen reader user who asks a question on a Wiki this build publishes: the reader writes "Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there." into the shell's own question status line, in the page and empty before the question, and adds no second line; fails_when=the reader keeps writing the progress sentence into the answer region it shows in the same handler, or adds a line of its own beside the shell's, so the progress is not announced or is announced twice; why_new=D2; seam=openFakeWikiPage with the bundled shell's script and the served codebook-qa.js, the current shell's composer, holdNext('api/ask'); no_claim=what a given screen reader announces
 test('a question asked on a served Wiki of this build is announced from the shell’s own status line, and the reader adds no second one', async () => {
   // Arrange: the page runs the bundled shell's script before the reader's.
   const script = `${await shellScriptOf('skills/codebook/reader-shell.html')}\n${await readServedWikiScript()}`
@@ -151,7 +151,7 @@ test('a question asked on a served Wiki of this build is announced from the shel
       },
       statusWhileAsking: {
         role: 'status/polite',
-        text: 'Asking the editor model…',
+        text: 'Asking the editor model… The editor may first ask you to allow Codebook to use it; answer there.',
         isShown: true,
         isInADisclosure: false,
       },
diff --git a/extension/src/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
new file mode 100644
index 00000000..ad75e0bc
--- /dev/null
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -0,0 +1,52 @@
+import {
+  llmWikiFolderDanglingLinkNotice,
+  llmWikiFolderIsFileNotice,
+  llmWikiFolderMissingNotice,
+  llmWikiFolderRemoteNotice,
+  llmWikiFolderUnreadableNotice,
+  WSL_REMOTE_NAME,
+} from '../constants'
+
+import type { WikiFolderKind } from './wikiFolderKindOf'
+
+/**
+ * Words why Reveal Wiki Folder opens nothing, so the learner is not left with a command that does nothing visible.
+ *
+ * Why: the editor's reveal command opens folders of this computer only and shows nothing for a missing one.
+ * Trigger: the LLM Wiki view's Reveal Wiki Folder command asks it before it reveals the folder.
+ *
+ * @param folder - What is known of the Wiki folder.
+ * @param folder.outputLabel - The folder as the learner reads it (project-relative or absolute).
+ * @param folder.folderKind - What stands at the path now ({@link wikiFolderKindOf}).
+ * @param folder.remoteName - The editor's `env.remoteName`; empty or absent for a local window. A WSL window counts as a local one, as everywhere in Codebook.
+ * @returns
+ * - A file in the folder's place: `The LLM Wiki folder <label> is a file, not a folder. Remove or rename that file, or change the location.`
+ * - A link whose target is missing: `The LLM Wiki folder <label> is a link whose target is missing. Remove or fix the link, or change the location.`
+ * - A path that cannot be read (or did not answer in time, `ETIMEDOUT`): `The LLM Wiki folder <label> cannot be read (<code>). Check the path and its permissions, or change the location.`
+ * - A missing folder: `The LLM Wiki folder <label> does not exist (yet). Generate LLM Wiki creates it.`
+ * - An existing folder in a remote window other than WSL: `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>. Open it from a terminal in this window, which runs in that remote environment, not on this computer.`
+ * - Otherwise `undefined`: the folder can be revealed.
+ * @example
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', folderKind: { kind: 'missing' } }) // => 'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', folderKind: { kind: 'folder' }, remoteName: 'ssh-remote' }) // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal in this window, which runs in that remote environment, not on this computer.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', folderKind: { kind: 'folder' }, remoteName: 'wsl' }) // => undefined
+ */
+export function describeUnrevealableWikiFolder(folder: {
+  outputLabel: string
+  folderKind: WikiFolderKind
+  remoteName?: string
+}): string | undefined {
+  const { folderKind, outputLabel } = folder
+  // A missing, unreadable or file path is the more useful answer, in a remote window too.
+  if (folderKind.kind === 'file') return llmWikiFolderIsFileNotice(outputLabel)
+  if (folderKind.kind === 'missing')
+    return llmWikiFolderMissingNotice(outputLabel)
+  if (folderKind.kind === 'dangling-link')
+    return llmWikiFolderDanglingLinkNotice(outputLabel)
+  if (folderKind.kind === 'unreadable')
+    return llmWikiFolderUnreadableNotice(outputLabel, folderKind.code)
+  // A WSL window reveals as a local one: the editor's reveal works there.
+  if (folder.remoteName && folder.remoteName !== WSL_REMOTE_NAME)
+    return llmWikiFolderRemoteNotice(folder.remoteName)
+  return undefined
+}
diff --git a/extension/src/utils/describeWikiGeneration.ts b/extension/src/utils/describeWikiGeneration.ts
index 1f929a67..f20cc635 100644
--- a/extension/src/utils/describeWikiGeneration.ts
+++ b/extension/src/utils/describeWikiGeneration.ts
@@ -34,7 +34,7 @@ export function describeWikiGeneration(
     new Date(epochMs).toLocaleDateString(),
 ): string | undefined {
   // A revision is kept only as a full commit hash, as the freshness check keeps it.
-  const fullRevision = fullCommitHash(generation.revision)?.slice(
+  const shortRevision = fullCommitHash(generation.revision)?.slice(
     0,
     WIKI_SHORT_REVISION_CHARS,
   )
@@ -44,8 +44,8 @@ export function describeWikiGeneration(
     !Number.isFinite(generation.publishedAtMs)
       ? undefined
       : formatDate(generation.publishedAtMs)
-  if (fullRevision && date) return `Generated from ${fullRevision} on ${date}`
+  if (shortRevision && date) return `Generated from ${shortRevision} on ${date}`
   if (date) return `Generated on ${date} (no Git revision)`
-  if (fullRevision) return `Generated from ${fullRevision}`
+  if (shortRevision) return `Generated from ${shortRevision}`
   return undefined
 }
diff --git a/extension/src/utils/failureKeyOf.ts b/extension/src/utils/failureKeyOf.ts
new file mode 100644
index 00000000..edf33b1d
--- /dev/null
+++ b/extension/src/utils/failureKeyOf.ts
@@ -0,0 +1,49 @@
+import { inspect } from 'node:util'
+
+import { FAILURE_KEY_MAX_LENGTH } from '../constants'
+
+import { systemErrorCode } from './systemErrorCode'
+
+/**
+ * Makes the `<name>|<code>|<message>` text of one `Error`, with every run of digits in the message replaced by `#`.
+ * @param error - The error to describe.
+ * @returns The text; two errors that differ only in the numbers of their messages (a pid, a timestamp, a port) read alike.
+ * @example errorKeyOf(Object.assign(new Error('busy 4711'), { code: 'EBUSY' })) // => 'Error|EBUSY|busy #'
+ */
+function errorKeyOf(error: Error): string {
+  return `${error.name}|${systemErrorCode(error)}|${error.message.replace(/\d+/g, '#')}`
+}
+
+/**
+ * Makes the text two failures are compared by, so a failure that repeats is told apart from a different one.
+ *
+ * Why: the message alone merges failures that differ in kind (the same text with another system error code) and non-`Error` throws that print alike; a message that embeds a changing number (a pid, a timestamp) must not make every poll tick look like a new failure; a long dump must not be kept whole.
+ * Trigger: the LLM Wiki view ({@link createLlmWikiView}) asks it for each failed read and each failed freshness check, to record a failure in Output once while it recurs.
+ *
+ * @param cause - Whatever the failed read threw.
+ * @returns
+ * - An `Error`: `<name>|<code>|<message>` (`code` is empty when it carries none, digit runs of the message read `#`), followed by `<-` and the same triple of its `cause` when that is an `Error` too
+ * - Anything else: its `util.inspect` text
+ * - Cut to {@link FAILURE_KEY_MAX_LENGTH} characters
+ * - `Object.prototype.toString` text (`[object Object]`) when reading the cause throws (a `message` getter or an inspect hook that throws), so a hostile cause cannot break the caller
+ * @example
+ * failureKeyOf(Object.assign(new Error('busy'), { code: 'EBUSY' })) // => 'Error|EBUSY|busy'
+ * failureKeyOf(new Error('pid 4711 gone'))                          // => 'Error||pid # gone'
+ * failureKeyOf({ reason: 'busy' })                                   // => "{ reason: 'busy' }"
+ */
+export function failureKeyOf(cause: unknown): string {
+  try {
+    const key =
+      cause instanceof Error
+        ? `${errorKeyOf(cause)}${cause.cause instanceof Error ? `<-${errorKeyOf(cause.cause)}` : ''}`
+        : inspect(cause)
+    return key.slice(0, FAILURE_KEY_MAX_LENGTH)
+  } catch {
+    // A cause that cannot be read still needs a key; its type tag is all that is left to compare by.
+    try {
+      return Object.prototype.toString.call(cause)
+    } catch {
+      return 'unreadable failure'
+    }
+  }
+}
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index f3708c2f..9a7bb093 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -17,6 +17,7 @@ import {
 import { chooseWikiWatchFolder } from './chooseWikiWatchFolder'
 import { comparableFilePath } from './comparableFilePath'
 import { describeWikiWatch } from './describeWikiWatch'
+import { failureKeyOf } from './failureKeyOf'
 import {
   LLM_WIKI_ERROR_ROW,
   LLM_WIKI_LOADING_ROW,
@@ -74,7 +75,7 @@ export type LlmWikiView = {
   refresh(): Promise<void>
   /** Asks for a refresh after the debounce; many calls inside it become one read. Production reaches it through the editor's events only; tests call it to stand in for one. */
   requestRefresh(): void
-  /** Resolves once no read and no freshness check is under way. Only tests call it, to wait for the view to settle. */
+  /** Resolves once no debounced refresh is waiting (it has fired or was never scheduled) and no read and no freshness check is under way. Only tests call it, to wait for the view to settle, so a test proves an absent read without a fixed sleep. */
   whenIdle(): Promise<void>
   /** The row with this id as it is shown now. */
   findRow(rowId: string): LlmWikiRow | undefined
@@ -115,7 +116,7 @@ function freshnessKeyOf(facts: ReadyFacts): string {
  * Why: the Activity Bar needs one place that shows the generated site's state and its next step; the rows are one pure function of one record of facts ({@link readLlmWikiViewState}), and this module only reads, compares and shows.
  * Trigger: `activate()` in `extension.ts` creates it once per window when the editor offers tree views.
  *
- * A refresh fires a tree change only when the rows, the message or the state actually changed, so a read with nothing new is silent for screen readers and never moves focus. Any failure of one read shows the error row and is recorded once; no refresh rejects.
+ * A refresh fires a tree change only when the rows, the message or the state actually changed, so a read with nothing new is silent for screen readers and never moves focus. Any failure of one read shows the error row and is recorded once while the error row stands; no refresh rejects.
  *
  * @param options - The editor API and the window's closures ({@link LlmWikiViewOptions}).
  * @returns The view's handle ({@link LlmWikiView}).
@@ -143,6 +144,20 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   /** The latest facts that ask for a freshness check; requests while one runs coalesce into this one. */
   let freshnessRequest: ReadyFacts | undefined
   let debounceTimer: NodeJS.Timeout | undefined
+  /** Settles when the waiting debounce has fired or was dropped; `whenIdle` waits on it. */
+  let debounceSettled:
+    { promise: Promise<void>; settle: () => void } | undefined
+  /** Whether the tree is shown; a hidden view runs no poll and no freshness check. */
+  let isViewVisible = true
+  /** Whether the last good read showed a run row, so the poll goes on across a failed read's error row. */
+  let wasRunShownBeforeError = false
+  /** The key ({@link failureKeyOf}) of the last failure recorded in Output, per kind: `read` is cleared when a good model is shown, `freshness` when a freshness check succeeds, so a failure that persists across poll ticks is recorded once and a different one is recorded too. */
+  const recordedFailureKeys: Record<'read' | 'freshness', string | undefined> =
+    { read: undefined, freshness: undefined }
+  /** Whether the tree view handle exists; an editor may read the provider while it is being created. */
+  let isTreeViewCreated = false
+  /** The message the tree view shows now; the next one is applied when the tree reads the new rows. */
+  let appliedMessage: string | undefined
   let pollTimer: NodeJS.Timeout | undefined
   let isDisposed = false
   let isWatcherBroken = false
@@ -162,8 +177,21 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   const treeView = editor.window.createTreeView<string>(LLM_WIKI_VIEW_ID, {
     treeDataProvider: {
       onDidChangeTreeData: treeChanges.event,
-      getChildren: (element) =>
-        element ? [] : model.rows.map((row) => row.id),
+      getChildren: (element) => {
+        if (element) return []
+        // The message follows the rows in one render: it is written here, when the tree reads the new model's root children after the change event, not when the model is set.
+        // A root read inside createTreeView finds no handle yet; the next root read writes the message.
+        // After dispose the handle is gone: nothing is written.
+        if (
+          isTreeViewCreated &&
+          !isDisposed &&
+          model.message !== appliedMessage
+        ) {
+          appliedMessage = model.message
+          treeView.message = model.message
+        }
+        return model.rows.map((row) => row.id)
+      },
       getTreeItem: (rowId) => {
         const row = model.rows.find((candidate) => candidate.id === rowId)
         const item = new editor.TreeItem(
@@ -193,7 +221,19 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     },
   })
 
-  /** Shows a model: sets the context key, the message and fires one tree change, only for what differs from what is shown. */
+  isTreeViewCreated = true
+  // A root read inside createTreeView found no handle; the message of the model shown now is applied once, not left to a later change.
+  if (model.message !== appliedMessage) {
+    appliedMessage = model.message
+    treeView.message = model.message
+  }
+  // The editor reports whether the view is shown now; a collapsed view runs no poll.
+  isViewVisible = treeView.visible
+
+  /**
+   * Shows a model: sets the context key and fires one tree change, only for what differs from what is shown.
+   * The message is not written here; the tree writes it when the provider's getChildren next reads the root children.
+   */
   const show = (next: LlmWikiViewModel): void => {
     // A read that finished after dispose shows nothing.
     if (isDisposed) return
@@ -203,7 +243,6 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     model = next
     shownKey = nextKey
     shownState = next.state
-    treeView.message = next.message
     if (didStateChange)
       void editor.commands.executeCommand(
         SET_CONTEXT_COMMAND,
@@ -213,13 +252,18 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     treeChanges.fire()
   }
 
-  /** Keeps the poll timer running exactly while a run row is shown. */
+  /** Keeps the poll timer running exactly while the view is shown and a run row is shown, or the error row follows a read that showed one. */
   const keepPoll = (): void => {
     if (isDisposed) return
     const isRunShown = model.rows.some((row) =>
       LLM_WIKI_RUN_ROW_IDS.has(row.id),
     )
-    if (!isRunShown) {
+    const isErrorShown = model.rows.some(
+      (row) => row.id === LLM_WIKI_ERROR_ROW.id,
+    )
+    const isPollWanted =
+      isViewVisible && (isRunShown || (isErrorShown && wasRunShownBeforeError))
+    if (!isPollWanted) {
       clearInterval(pollTimer)
       pollTimer = undefined
       return
@@ -233,8 +277,18 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   const requestRefresh = (): void => {
     if (isDisposed) return
     clearTimeout(debounceTimer)
+    if (!debounceSettled) {
+      let settle: () => void = () => {}
+      const promise = new Promise<void>((resolve) => {
+        settle = resolve
+      })
+      debounceSettled = { promise, settle }
+    }
     debounceTimer = setTimeout(() => {
+      // The read starts in this turn, so `whenIdle` sees it as `running` once the debounce is settled.
       void refresh()
+      debounceSettled?.settle()
+      debounceSettled = undefined
     }, debounceMs)
     debounceTimer.unref()
   }
@@ -358,9 +412,15 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
         projectRoot: target.projectRoot,
         outputDirectory: target.outputDirectory,
       })
-    } catch {
+    } catch (cause) {
       didCheckFail = true
       value = { status: 'unknown', reason: 'The freshness check failed.' }
+      if (!isDisposed)
+        recordFailureOnce(
+          'freshness',
+          'The LLM Wiki view could not check whether the Wiki is current',
+          cause,
+        )
     }
     const shown = shownReadyFacts
     // The answer belongs to one publication of one folder; a newer read has asked for its own check.
@@ -370,13 +430,17 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
       freshnessKeyOf(shown) !== freshnessKeyOf(target)
     )
       return
-    if (!didCheckFail) freshnessCache = { key: freshnessKeyOf(target), value }
     show(
       readLlmWikiViewState({
         ...shown,
         wiki: { ...shown.wiki, freshness: value },
       }),
     )
+    // A check that succeeded and whose answer is shown ends the freshness failure that stood; an answer that could not be shown was not kept, so the next read checks again.
+    if (!didCheckFail) {
+      freshnessCache = { key: freshnessKeyOf(target), value }
+      recordedFailureKeys.freshness = undefined
+    }
   }
 
   /** Asks for a freshness check of the shown Wiki: one runs at a time, and requests meanwhile become one re-run with the latest facts. */
@@ -389,11 +453,13 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
         while (freshnessRequest && !isDisposed) {
           const target = freshnessRequest
           freshnessRequest = undefined
+          // A view hidden since the request was queued runs no check; a show reads again and queues a current one.
+          if (!isViewVisible) continue
           try {
             await checkFreshness(target)
           } catch (cause) {
-            // A check that cannot even be shown must not become an unhandled rejection.
-            showReadFailure(cause)
+            // A check that cannot even be shown must not become an unhandled rejection; it recurs with its own key, so a good read between does not make it new.
+            showReadFailure(cause, 'freshness')
           }
         }
       } finally {
@@ -489,14 +555,39 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     return isDisposed ? undefined : read
   }
 
-  /** Shows the error row for a read that threw anywhere, and records the cause once. */
-  const showReadFailure = (cause: unknown): void => {
-    if (isDisposed) return
+  /**
+   * Records a failure in Output unless it has the key of the one recorded last for its kind.
+   * @param kind - `read` for a read or the rows made of it, `freshness` for the freshness check and the showing of its answer.
+   * @param message - What failed, for Output.
+   * @param cause - What was thrown.
+   */
+  const recordFailureOnce = (
+    kind: 'read' | 'freshness',
+    message: string,
+    cause: unknown,
+  ): void => {
+    // The poll reads again across the error row, so the same failure is recorded once; a different failure is recorded too.
+    const key = failureKeyOf(cause)
+    if (key === recordedFailureKeys[kind]) return
+    recordedFailureKeys[kind] = key
     try {
-      options.recordFailure('The LLM Wiki view could not read its state', cause)
+      options.recordFailure(message, cause)
     } catch {
       // A failure that cannot be recorded has nowhere to be told.
     }
+  }
+
+  /**
+   * Shows the error row for a read that threw anywhere, and records the cause once.
+   * @param cause - What was thrown.
+   * @param kind - Which kind of failure it is for the once-only record; the freshness stage's own failures keep their own key.
+   */
+  const showReadFailure = (
+    cause: unknown,
+    kind: 'read' | 'freshness' = 'read',
+  ): void => {
+    if (isDisposed) return
+    recordFailureOnce(kind, 'The LLM Wiki view could not read its state', cause)
     // lateWatch stays: a publication after one failed read is still a late publication.
     shownReadyFacts = undefined
     show({ state: 'other', rows: [LLM_WIKI_ERROR_ROW] })
@@ -511,14 +602,21 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     if (nextFacts.kind === 'ready') rememberPublication(nextFacts, next)
     shownReadyFacts = nextFacts.kind === 'ready' ? nextFacts : undefined
     show(next)
+    // A good model is shown: the read failure that stood is over, so the next one is recorded again.
+    recordedFailureKeys.read = undefined
+    wasRunShownBeforeError = next.rows.some((row) =>
+      LLM_WIKI_RUN_ROW_IDS.has(row.id),
+    )
     keepPoll()
-    // No Wiki row shown (an attention cause hides it) means no freshness to read.
+    // No Wiki row shown (an attention cause hides it) means no freshness to read; a hidden view reads it when it is shown again.
     if (
+      isViewVisible &&
       nextFacts.kind === 'ready' &&
       nextFacts.wiki &&
       next.rows.some((row) => row.id === 'wiki')
-    )
+    ) {
       requestFreshness(nextFacts)
+    }
   }
 
   /** One read from the facts to the rows; whatever throws in it shows the error row. */
@@ -553,7 +651,13 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     treeChanges,
     treeView,
     treeView.onDidChangeVisibility((event) => {
-      if (event.visible) requestRefresh()
+      isViewVisible = event.visible
+      // Hidden: no poll and no freshness check, not even one queued before; shown: one read at once (the 1 s debounce is for file events), which restarts the poll and queues a current freshness check.
+      if (event.visible) void refresh()
+      else {
+        freshnessRequest = undefined
+        keepPoll()
+      }
     }),
     editor.workspace.onDidChangeConfiguration((event) => {
       if (event.affectsConfiguration(WIKI_OUTPUT_DIRECTORY_SETTING))
@@ -569,8 +673,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     refresh,
     requestRefresh,
     async whenIdle(): Promise<void> {
-      while (running ?? freshnessLoop) {
-        await Promise.all([running, freshnessLoop])
+      while (debounceSettled ?? running ?? freshnessLoop) {
+        await Promise.all([debounceSettled?.promise, running, freshnessLoop])
       }
     },
     findRow: (rowId) => model.rows.find((row) => row.id === rowId),
@@ -578,6 +682,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
       isDisposed = true
       freshnessRequest = undefined
       clearTimeout(debounceTimer)
+      debounceSettled?.settle()
+      debounceSettled = undefined
       clearInterval(pollTimer)
       watcher?.dispose()
       for (const subscription of subscriptions) subscription.dispose()
diff --git a/extension/src/utils/readLlmWikiViewFacts.ts b/extension/src/utils/readLlmWikiViewFacts.ts
index 63a72200..0eb317ad 100644
--- a/extension/src/utils/readLlmWikiViewFacts.ts
+++ b/extension/src/utils/readLlmWikiViewFacts.ts
@@ -217,12 +217,14 @@ async function readManifestFacts(
 > {
   const { projectRoot, outputDirectory, outputLabel } = location
   const nowMs = dependencies.now()
-  const block = await dependencies.findStartBlock(outputDirectory, projectRoot)
+  // The start check and the token read do not depend on each other, so both are under way together.
+  const blockRead = dependencies.findStartBlock(outputDirectory, projectRoot)
   // A token that cannot be read still means a manifest stands there.
-  const tokenLook = await dependencies.readPublishToken(outputDirectory).then(
+  const tokenRead = dependencies.readPublishToken(outputDirectory).then(
     (token) => ({ didReadFail: false, token }),
     () => ({ didReadFail: true, token: undefined }),
   )
+  const [block, tokenLook] = await Promise.all([blockRead, tokenRead])
   const isManifestPresent =
     tokenLook.didReadFail || tokenLook.token !== undefined
   const generation = isManifestPresent
@@ -292,11 +294,15 @@ export async function readLlmWikiViewFacts(
   const publication = await dependencies
     .readPublication(outputDirectory)
     .catch(() => undefined)
-  const manifestFacts = await readManifestFacts(dependencies, {
-    projectRoot,
-    outputDirectory,
-    outputLabel,
-  })
+  // Once the receipt is read, the manifest facts and the marker do not depend on each other, so they are read together.
+  const [manifestFacts, markerFacts] = await Promise.all([
+    readManifestFacts(dependencies, {
+      projectRoot,
+      outputDirectory,
+      outputLabel,
+    }),
+    readMarkerFacts(dependencies, outputDirectory),
+  ])
   return {
     kind: 'ready',
     host: dependencies.host,
@@ -308,6 +314,6 @@ export async function readLlmWikiViewFacts(
     publication,
     ...manifestFacts,
     ...readRunFacts(dependencies, outputDirectory),
-    ...(await readMarkerFacts(dependencies, outputDirectory)),
+    ...markerFacts,
   }
 }
diff --git a/extension/src/utils/readLlmWikiViewState.ts b/extension/src/utils/readLlmWikiViewState.ts
index 1910fed0..76945969 100644
--- a/extension/src/utils/readLlmWikiViewState.ts
+++ b/extension/src/utils/readLlmWikiViewState.ts
@@ -576,6 +576,8 @@ function outputRow(
       ? `${facts.outputDirectory}\nCodebook could not watch this folder, so the view refreshes when it is shown and with Refresh only.`
       : facts.outputDirectory,
     icon: 'folder',
+    // A click on the row changes the location too, so its description reads as the row's own action.
+    command: { command: LLM_WIKI_ROW_ACTIONS['change-location'].command },
     actions: ['change-location'],
   }
 }
diff --git a/extension/src/utils/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
index 5ba0af6d..ff396f37 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -5,6 +5,9 @@ import type * as vscode from 'vscode'
 import {
   COPY_DETAILS_ACTION,
   COPY_WIKI_RECOVERY_REQUEST_COMMAND,
+  LLM_WIKI_MANAGE_TRUST_FALLBACK_NOTICE,
+  llmWikiFolderLocationFailedNotice,
+  LLM_WIKI_RECOVERY_REQUEST_COPIED_NOTICE,
   LLM_WIKI_ROW_ACTIONS,
   OPEN_CHAT_COMMAND,
   OPEN_FOLDER_COMMAND,
@@ -17,8 +20,12 @@ import {
   WIKI_UPDATE_RECOVERY_REQUEST,
 } from '../constants'
 
+import { describeUnrevealableWikiFolder } from './describeUnrevealableWikiFolder'
 import type { LlmWikiView } from './llmWikiView'
 import { resolveManageTrustCommand } from './resolveManageTrustCommand'
+import { thrownMessage } from './thrownMessage'
+import { wikiFolderKindOf } from './wikiFolderKindOf'
+import { wikiOutputLabel } from './wikiOutputLabel'
 import { withHomeFolderShown } from './withHomeFolderShown'
 
 /** What the commands of the LLM Wiki view ask of the window. */
@@ -38,8 +45,13 @@ export type LlmWikiCommandOptions = {
   view: LlmWikiView
   /** Stops this window's run: the VS Code watch, or the Cursor agent. */
   cancelRun: () => void
-  /** The resolved Wiki folder. */
-  findOutputDirectory: () => Promise<string>
+  /** The opened project and the resolved Wiki folder. */
+  findWikiLocation: () => Promise<{
+    projectRoot: string
+    outputDirectory: string
+  }>
+  /** Writes a failure to Output › Codebook, as the view's own record does. */
+  recordFailure: (message: string, cause: unknown) => void
 }
 
 /**
@@ -78,7 +90,7 @@ async function manageTrust(options: LlmWikiCommandOptions): Promise<void> {
   if (commandId === undefined) {
     void options.showNotice(
       'information',
-      'Run "Workspaces: Manage Workspace Trust" from the Command Palette to trust this folder.',
+      LLM_WIKI_MANAGE_TRUST_FALLBACK_NOTICE,
     )
     return
   }
@@ -94,7 +106,7 @@ async function manageTrust(options: LlmWikiCommandOptions): Promise<void> {
  * @param options - The window's closures ({@link LlmWikiCommandOptions}).
  * @returns The registrations, to dispose with the extension.
  * @example
- * context.subscriptions.push(...registerLlmWikiCommands({ editor: vscode, registerCommand, showNotice, view, cancelRun, findOutputDirectory }))
+ * context.subscriptions.push(...registerLlmWikiCommands({ editor: vscode, registerCommand, showNotice, view, cancelRun, findWikiLocation, recordFailure }))
  */
 export function registerLlmWikiCommands(
   options: LlmWikiCommandOptions,
@@ -110,15 +122,42 @@ export function registerLlmWikiCommands(
       await editor.env.clipboard.writeText(WIKI_UPDATE_RECOVERY_REQUEST)
       void options.showNotice(
         'information',
-        'Copied the recovery request. Paste it into the editor chat.',
+        LLM_WIKI_RECOVERY_REQUEST_COPIED_NOTICE,
       )
     }),
-    registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () =>
-      editor.commands.executeCommand(
+    registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () => {
+      let location: Awaited<ReturnType<typeof options.findWikiLocation>>
+      try {
+        location = await options.findWikiLocation()
+      } catch (cause) {
+        // A setting that names no usable folder (empty, or outside the project) would otherwise fail without a word.
+        options.recordFailure(
+          'Reveal Wiki Folder could not resolve the Wiki folder',
+          cause,
+        )
+        void options.showNotice(
+          'information',
+          llmWikiFolderLocationFailedNotice(thrownMessage(cause)),
+        )
+        return
+      }
+      const { projectRoot, outputDirectory } = location
+      // The editor's reveal shows nothing for a missing folder or one on a remote host, so the learner is told instead.
+      const reason = describeUnrevealableWikiFolder({
+        outputLabel: wikiOutputLabel(projectRoot, outputDirectory),
+        // One look tells a folder, a file, nothing and an unreadable path apart, each with its own sentence.
+        folderKind: await wikiFolderKindOf(outputDirectory),
+        remoteName: editor.env.remoteName,
+      })
+      if (reason !== undefined) {
+        void options.showNotice('information', reason)
+        return
+      }
+      await editor.commands.executeCommand(
         REVEAL_FILE_IN_OS_COMMAND,
-        editor.Uri.file(await options.findOutputDirectory()),
-      ),
-    ),
+        editor.Uri.file(outputDirectory),
+      )
+    }),
     registerCommand(LLM_WIKI_ROW_ACTIONS['stop-watching'].command, cancelRun),
     registerCommand(LLM_WIKI_ROW_ACTIONS['cancel-run'].command, cancelRun),
     registerCommand(LLM_WIKI_ROW_ACTIONS['open-chat'].command, () =>
diff --git a/extension/src/utils/systemErrorCode.ts b/extension/src/utils/systemErrorCode.ts
index e3efc93c..b5ce71c6 100644
--- a/extension/src/utils/systemErrorCode.ts
+++ b/extension/src/utils/systemErrorCode.ts
@@ -5,12 +5,18 @@
  *
  * @param error - Whatever the failed call threw.
  * @returns
- * - The error's `code` as text when it is an `Error` that carries one
- * - `''` for any other failure
+ * - The error's `code` as text when it is an `Error` whose `code` is a string or a number
+ * - `''` for any other failure (also an `Error` whose own `code` is `undefined` or `null`, which must not read as the text `undefined`)
  * @example
  * systemErrorCode(Object.assign(new Error('kill ESRCH'), { code: 'ESRCH' })) // => 'ESRCH'
  * systemErrorCode(new Error('probe interrupted'))                            // => ''
+ * systemErrorCode(Object.assign(new Error('odd'), { code: undefined }))      // => ''
  */
 export function systemErrorCode(error: unknown): string {
-  return error instanceof Error && 'code' in error ? String(error.code) : ''
+  if (!(error instanceof Error) || !('code' in error)) return ''
+  const { code } = error
+  // Only a string or a number is a system error name; `undefined` and `null` would print as words.
+  return typeof code === 'string' || typeof code === 'number'
+    ? String(code)
+    : ''
 }
diff --git a/extension/src/utils/wikiFolderKindOf.ts b/extension/src/utils/wikiFolderKindOf.ts
new file mode 100644
index 00000000..b3cd3835
--- /dev/null
+++ b/extension/src/utils/wikiFolderKindOf.ts
@@ -0,0 +1,86 @@
+import { lstat, stat } from 'node:fs/promises'
+
+import { WIKI_FOLDER_STAT_TIMEOUT_MS } from '../constants'
+
+import { systemErrorCode } from './systemErrorCode'
+
+/** What stands at the Wiki output path; `unreadable` carries the system error name of the failed look. */
+export type WikiFolderKind =
+  | { kind: 'folder' }
+  | { kind: 'file' }
+  | { kind: 'missing' }
+  | { kind: 'dangling-link' }
+  | { kind: 'unreadable'; code: string }
+
+/** The file-system looks and the bound {@link wikiFolderKindOf} uses; a test replaces them. */
+export type WikiFolderLook = {
+  /** Follows links, as `fs.promises.stat`. */
+  stat: (path: string) => Promise<{ isDirectory: () => boolean }>
+  /** Does not follow links, as `fs.promises.lstat`. */
+  lstat: (path: string) => Promise<{ isSymbolicLink: () => boolean }>
+  /** How long the look may take before the path counts as unreadable (ms). */
+  timeoutMs: number
+}
+
+/**
+ * Looks once at the Wiki output path and says what stands there, so Reveal Wiki Folder can tell a folder, a file, nothing, a link to nothing and a path it cannot read apart.
+ *
+ * Why: one `stat` answers most of it, and only `ENOENT` means nothing is there; a permission or path error (`EACCES`, `ENOTDIR`, `ENAMETOOLONG`) must not be told as "does not exist (yet)", a link to nothing must not promise that Generate LLM Wiki creates the folder (generation refuses a link), and a dead mount that never answers must not leave the command without a word.
+ * Trigger: the Reveal Wiki Folder command ({@link registerLlmWikiCommands}) asks it before it reveals the folder; {@link describeUnrevealableWikiFolder} words the answer.
+ *
+ * @param folderPath - The absolute path to look at.
+ * @param look - The file-system looks and the bound; the real ones when omitted.
+ * @returns
+ * - A folder (a link to a folder counts): `{ kind: 'folder' }`
+ * - Any other entry that exists (a file, or a special file): `{ kind: 'file' }`
+ * - Nothing at the path (`ENOENT` for the path and for the link itself): `{ kind: 'missing' }`
+ * - A symbolic link whose target is missing: `{ kind: 'dangling-link' }`
+ * - Any other failure of the look, or no answer within the bound (`'ETIMEDOUT'`): `{ kind: 'unreadable', code }` (`'UNKNOWN'` when the error carries no code)
+ * @example
+ * await wikiFolderKindOf('/repo/.codebook/wiki')         // => { kind: 'folder' }
+ * await wikiFolderKindOf('/repo/missing')                // => { kind: 'missing' }
+ * await wikiFolderKindOf('/repo/a-file/.codebook/wiki')  // => { kind: 'unreadable', code: 'ENOTDIR' }
+ */
+export async function wikiFolderKindOf(
+  folderPath: string,
+  look: WikiFolderLook = {
+    stat,
+    lstat,
+    timeoutMs: WIKI_FOLDER_STAT_TIMEOUT_MS,
+  },
+): Promise<WikiFolderKind> {
+  const lookAtPath = async (): Promise<WikiFolderKind> => {
+    try {
+      return (await look.stat(folderPath)).isDirectory()
+        ? { kind: 'folder' }
+        : { kind: 'file' }
+    } catch (error) {
+      const code = systemErrorCode(error)
+      if (code !== 'ENOENT')
+        return { kind: 'unreadable', code: code || 'UNKNOWN' }
+      // Nothing at the end of the path: a link that points to nothing is not the same as no entry.
+      try {
+        return (await look.lstat(folderPath)).isSymbolicLink()
+          ? { kind: 'dangling-link' }
+          : { kind: 'missing' }
+      } catch (linkError) {
+        const linkCode = systemErrorCode(linkError)
+        return linkCode === 'ENOENT'
+          ? { kind: 'missing' }
+          : { kind: 'unreadable', code: linkCode || 'UNKNOWN' }
+      }
+    }
+  }
+  let timer: NodeJS.Timeout | undefined
+  const noAnswer = new Promise<WikiFolderKind>((resolve) => {
+    timer = setTimeout(
+      () => resolve({ kind: 'unreadable', code: 'ETIMEDOUT' }),
+      look.timeoutMs,
+    )
+  })
+  try {
+    return await Promise.race([lookAtPath(), noAnswer])
+  } finally {
+    clearTimeout(timer)
+  }
+}