From de05f3eb24da3b94cd57580a67080740af5f7db9 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 01:09:05 +0900
Subject: [PATCH 1/9] fix: Cycle 0056 pt2: the reader says the editor may ask
 for consent while a question waits (task 15)

---
 extension/README.md                          | 2 ++
 extension/src/constants.ts                   | 4 ++++
 extension/src/deepWikiReader.ts              | 3 ++-
 extension/src/tests/wikiQuestionPage.test.ts | 8 ++++----
 4 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/extension/README.md b/extension/README.md
index 7a5c835d..04605f0e 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.                                                                                                                                                                                                                                                                                             |
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index a18b52ba..b3eb2f4b 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -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}'
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/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,
       },

From a68c512a2e7ebcfd4fda8e5d475deb5f66757411 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 01:20:23 +0900
Subject: [PATCH 2/9] fix: Cycle 0056 pt2: the view's message and rows change
 together, hidden views do no background work, reveal says why it opens
 nothing, fact reads run together (tasks 16, 18-22)

---
 extension/README.md                           |   4 +-
 extension/src/extension.ts                    |   2 +-
 extension/src/tests/llmWikiView.test.ts       | 146 ++++++++++++++++--
 .../src/tests/llmWikiViewReadLoop.test.ts     | 137 ++++++++++++++--
 .../src/tests/readLlmWikiViewFacts.test.ts    |  67 ++++++++
 extension/src/tests/utils/defer.ts            |  17 ++
 .../src/tests/utils/fakeLlmWikiEditor.ts      |  17 +-
 extension/src/tests/utils/wikiUpdateWindow.ts |  45 +++++-
 .../utils/describeUnrevealableWikiFolder.ts   |  30 ++++
 extension/src/utils/isExistingFolder.ts       |  17 ++
 extension/src/utils/llmWikiView.ts            |  60 +++++--
 extension/src/utils/readLlmWikiViewFacts.ts   |  22 ++-
 .../src/utils/registerLlmWikiCommands.ts      |  33 +++-
 13 files changed, 541 insertions(+), 56 deletions(-)
 create mode 100644 extension/src/tests/utils/defer.ts
 create mode 100644 extension/src/utils/describeUnrevealableWikiFolder.ts
 create mode 100644 extension/src/utils/isExistingFolder.ts

diff --git a/extension/README.md b/extension/README.md
index 04605f0e..8c0dcbfc 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -251,11 +251,11 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - **`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.
+- **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).`, and in a window connected to a remote host (SSH, WSL, a container) it says `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.` and opens nothing. 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 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, 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. 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/src/extension.ts b/extension/src/extension.ts
index 9bec2154..ab4a959f 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -3271,7 +3271,7 @@ export function activate(
         showNotice,
         view: llmWikiView,
         cancelRun: cancelWikiRun,
-        findOutputDirectory: async () => (await wikiLocation()).outputDirectory,
+        findWikiLocation: wikiLocation,
       }),
     )
   }
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index 44150902..bae0e6c5 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,154 @@ 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).']],
+  )
+})
+
+// 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.',
+      ],
+    ],
+  )
+})
+
+// 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=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 +1761,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..a4e8b1ef 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 {
@@ -536,13 +526,134 @@ 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=whenIdle resolves 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('whenIdle waits for the debounced read of a watched file’s event', 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=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)
+  context.mock.timers.tick(20)
+  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
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/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..5f19ed5b 100644
--- a/extension/src/tests/utils/fakeLlmWikiEditor.ts
+++ b/extension/src/tests/utils/fakeLlmWikiEditor.ts
@@ -17,7 +17,7 @@ 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`.
+ * @returns `editor` (to pass as the view's editor), `rows` (the tree as shown now), `message` (the tree view's message), `contextKeys`, `files` (the fake file watching, to report events), `setVisible`, `fireConfigurationChange`.
  * @example
  * const fake = createFakeLlmWikiEditor()
  * const view = createLlmWikiView({ editor: fake.editor, host: 'vscode', … })
@@ -29,6 +29,8 @@ export function createFakeLlmWikiEditor() {
   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[]
@@ -80,7 +82,12 @@ export function createFakeLlmWikiEditor() {
         provider = treeOptions.treeDataProvider
         return {
           message: undefined as string | undefined,
-          onDidChangeVisibility: () => ({ dispose(): void {} }),
+          get visible(): boolean {
+            return isViewShown
+          },
+          onDidChangeVisibility: (
+            listener: (event: { visible: boolean }) => void,
+          ) => listenTo(visibilityListeners, listener),
           dispose(): void {},
         }
       },
@@ -109,6 +116,12 @@ export function createFakeLlmWikiEditor() {
       }),
     contextKeys,
     files,
+    /** 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..c0a3f1f1 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,10 @@ export async function openWikiUpdateWindow(options: {
       message: () => treeMessage,
       contextKeys,
       treeChangeCount: () => treeChangeCount,
+      renderLog: () => [...renderLog],
+      whenIdle: async () => llmWikiView?.whenIdle(),
       setVisible(isVisible: boolean): void {
+        isViewShown = isVisible
         for (const listener of [...visibilityListeners])
           listener({ visible: isVisible })
       },
diff --git a/extension/src/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
new file mode 100644
index 00000000..a5891d3e
--- /dev/null
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -0,0 +1,30 @@
+/**
+ * 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.exists - Whether the folder exists now.
+ * @param folder.remoteName - The editor's `env.remoteName`; empty or absent for a local window.
+ * @returns
+ * - A missing folder: `The LLM Wiki folder <label> does not exist (yet).`
+ * - An existing folder in a remote window: `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.`
+ * - Otherwise `undefined`: the folder can be revealed.
+ * @example
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: false }) // => 'The LLM Wiki folder .codebook/wiki does not exist (yet).'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'wsl' }) // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on wsl.'
+ */
+export function describeUnrevealableWikiFolder(folder: {
+  outputLabel: string
+  exists: boolean
+  remoteName?: string
+}): string | undefined {
+  // A missing folder is the more useful answer, in a remote window too.
+  if (!folder.exists)
+    return `The LLM Wiki folder ${folder.outputLabel} does not exist (yet).`
+  if (folder.remoteName)
+    return `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${folder.remoteName}.`
+  return undefined
+}
diff --git a/extension/src/utils/isExistingFolder.ts b/extension/src/utils/isExistingFolder.ts
new file mode 100644
index 00000000..2fc7870b
--- /dev/null
+++ b/extension/src/utils/isExistingFolder.ts
@@ -0,0 +1,17 @@
+import { stat } from 'node:fs/promises'
+
+/**
+ * Says whether a path is a folder on this computer now; called by the LLM Wiki view's Reveal Wiki Folder command before it asks the editor to reveal the Wiki folder.
+ * @param folderPath - The absolute path to look at.
+ * @returns `true` for a folder (a link to a folder counts); `false` when nothing is there, a file is there, or the path cannot be read.
+ * @example
+ * await isExistingFolder('/repo/.codebook/wiki') // => true
+ * await isExistingFolder('/repo/missing')        // => false
+ */
+export async function isExistingFolder(folderPath: string): Promise<boolean> {
+  try {
+    return (await stat(folderPath)).isDirectory()
+  } catch {
+    return false
+  }
+}
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index f3708c2f..5a2cec8c 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -74,7 +74,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
@@ -143,6 +143,15 @@ 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 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 +171,15 @@ 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.
+        if (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,6 +209,9 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     },
   })
 
+  // 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, the message and fires one tree change, only for what differs from what is shown. */
   const show = (next: LlmWikiViewModel): void => {
     // A read that finished after dispose shows nothing.
@@ -203,7 +222,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 +231,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 +256,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()
   }
@@ -511,9 +544,13 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     if (nextFacts.kind === 'ready') rememberPublication(nextFacts, next)
     shownReadyFacts = nextFacts.kind === 'ready' ? nextFacts : undefined
     show(next)
+    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')
@@ -553,7 +590,10 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     treeChanges,
     treeView,
     treeView.onDidChangeVisibility((event) => {
+      isViewVisible = event.visible
+      // Hidden: no poll. Shown: one read, which restarts the poll and the freshness check.
       if (event.visible) requestRefresh()
+      else keepPoll()
     }),
     editor.workspace.onDidChangeConfiguration((event) => {
       if (event.affectsConfiguration(WIKI_OUTPUT_DIRECTORY_SETTING))
@@ -569,8 +609,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 +618,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/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
index 5ba0af6d..0101a9a9 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -17,8 +17,11 @@ import {
   WIKI_UPDATE_RECOVERY_REQUEST,
 } from '../constants'
 
+import { describeUnrevealableWikiFolder } from './describeUnrevealableWikiFolder'
+import { isExistingFolder } from './isExistingFolder'
 import type { LlmWikiView } from './llmWikiView'
 import { resolveManageTrustCommand } from './resolveManageTrustCommand'
+import { wikiOutputLabel } from './wikiOutputLabel'
 import { withHomeFolderShown } from './withHomeFolderShown'
 
 /** What the commands of the LLM Wiki view ask of the window. */
@@ -38,8 +41,11 @@ 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
+  }>
 }
 
 /**
@@ -94,7 +100,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 }))
  */
 export function registerLlmWikiCommands(
   options: LlmWikiCommandOptions,
@@ -113,12 +119,23 @@ export function registerLlmWikiCommands(
         'Copied the recovery request. Paste it into the editor chat.',
       )
     }),
-    registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () =>
-      editor.commands.executeCommand(
+    registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () => {
+      const { projectRoot, outputDirectory } = await options.findWikiLocation()
+      // 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),
+        exists: await isExistingFolder(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, () =>

From 1236708b334ade8dcb558b2c4acda343c4ec4246 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 01:24:56 +0900
Subject: [PATCH 3/9] fix: Cycle 0056 pt2: view actions have decided icons and
 Title Case names, the welcome names the default folder, a row 5 click changes
 the location, names and sentences are single-sourced (tasks 24, 25)

---
 extension/README.md                           |  4 +-
 extension/package.json                        | 14 ++---
 extension/src/constants.ts                    | 14 +++--
 extension/src/extension.ts                    | 17 +++---
 extension/src/tests/llmWikiManifest.test.ts   | 53 +++++++++++++++++--
 extension/src/tests/llmWikiView.test.ts       | 24 +++++++++
 .../src/tests/readLlmWikiViewState.test.ts    |  3 +-
 extension/src/utils/describeWikiGeneration.ts |  6 +--
 extension/src/utils/readLlmWikiViewState.ts   |  2 +
 .../src/utils/registerLlmWikiCommands.ts      |  6 ++-
 10 files changed, 114 insertions(+), 29 deletions(-)

diff --git a/extension/README.md b/extension/README.md
index 8c0dcbfc..ecdb569b 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -245,9 +245,9 @@ 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**); **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.
diff --git a/extension/package.json b/extension/package.json
index 6effd410..5c8c1f4a 100644
--- a/extension/package.json
+++ b/extension/package.json
@@ -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",
@@ -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/src/constants.ts b/extension/src/constants.ts
index b3eb2f4b..80efb27b 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -1040,15 +1040,15 @@ 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,
@@ -1778,3 +1778,11 @@ export const REFUSAL_REPORT_LABEL_CHARS = 48
 
 /** The most editor events a {@link PlacementEventLog} keeps and a placement refusal report lists, in events. */
 export const REFUSAL_REPORT_EVENTS = 24
+
+/** What the LLM Wiki view says when the editor lists none of the known ids of its Manage Workspace Trust command ({@link manageTrust}). */
+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.'
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index ab4a959f..a6b1d769 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.
@@ -3184,12 +3185,12 @@ export function activate(
   if (Reflect.has(vscode.window ?? {}, 'createTreeView')) {
     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,
diff --git a/extension/src/tests/llmWikiManifest.test.ts b/extension/src/tests/llmWikiManifest.test.ts
index 5b5e8ba9..95ff67ac 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,45 @@ 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 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',
+  ].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)'],
+  ])
+  assert.deepEqual(
+    [
+      LLM_WIKI_ROW_ACTIONS['try-again'].title,
+      LLM_WIKI_ROW_ACTIONS['stop-watching'].title,
+      LLM_WIKI_ROW_ACTIONS['change-location'].title,
+    ],
+    ['Try Again', 'Stop Watching', 'Change Location'],
+  )
+})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index bae0e6c5..72ad5ede 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -1135,6 +1135,30 @@ test('the message changes only when the tree reads the new rows, not when the ch
   )
 })
 
+// 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
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/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/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 0101a9a9..fad0f31e 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -5,6 +5,8 @@ import type * as vscode from 'vscode'
 import {
   COPY_DETAILS_ACTION,
   COPY_WIKI_RECOVERY_REQUEST_COMMAND,
+  LLM_WIKI_MANAGE_TRUST_FALLBACK_NOTICE,
+  LLM_WIKI_RECOVERY_REQUEST_COPIED_NOTICE,
   LLM_WIKI_ROW_ACTIONS,
   OPEN_CHAT_COMMAND,
   OPEN_FOLDER_COMMAND,
@@ -84,7 +86,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
   }
@@ -116,7 +118,7 @@ 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 () => {

From d0052c4f297acd3c7adf73b9bc2e2138f9b36292 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 05:20:21 +0900
Subject: [PATCH 4/9] =?UTF-8?q?fix:=20Cycle=200056=20pt2:=20local=20review?=
 =?UTF-8?q?=20fixes=20(OCR=20M1,=20L1=E2=80=93L5;=20CodeRabbit=20CLI=201)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- OCR-M1: Copy Recovery Request in Title Case (package.json shortTitle, LLM_WIKI_ROW_ACTIONS); manifest test covers it.
- OCR-L1: Reveal Wiki Folder sentences move to constants.ts (wording unchanged).
- OCR-L2: manage-trust notices sit beside LLM_WIKI_ROW_ACTIONS; link resolves to resolveManageTrustCommand.
- OCR-L3: test harness whenIdle throws when the view was never created.
- OCR-L4: showing a hidden view reads at once instead of through the 1 s debounce.
- OCR-L5: read-loop test renamed to observable behaviour.
- CR2-1: README names inline actions in Title Case (welcome link stays sentence case).
---
 extension/README.md                           |  6 +--
 extension/package.json                        |  2 +-
 extension/src/constants.ts                    | 37 ++++++++++++++-----
 extension/src/tests/llmWikiManifest.test.ts   |  7 +++-
 .../src/tests/llmWikiViewReadLoop.test.ts     | 28 ++++++++++++--
 extension/src/tests/utils/wikiUpdateWindow.ts |  6 ++-
 .../utils/describeUnrevealableWikiFolder.ts   | 11 ++++--
 extension/src/utils/llmWikiView.ts            |  4 +-
 8 files changed, 76 insertions(+), 25 deletions(-)

diff --git a/extension/README.md b/extension/README.md
index ecdb569b..63381eed 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -250,9 +250,9 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - **`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**); **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**, 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).`, and in a window connected to a remote host (SSH, WSL, a container) it says `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.` and opens nothing. 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).`, and in a window connected to a remote host (SSH, WSL, a container) it says `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.` and opens nothing. 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; 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, 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. 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.
diff --git a/extension/package.json b/extension/package.json
index 5c8c1f4a..5af47006 100644
--- a/extension/package.json
+++ b/extension/package.json
@@ -223,7 +223,7 @@
       {
         "command": "codebook.copyWikiRecoveryRequest",
         "title": "Codebook: Copy LLM Wiki Recovery Request",
-        "shortTitle": "Copy recovery request",
+        "shortTitle": "Copy Recovery Request",
         "icon": "$(copy)"
       },
       {
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index 80efb27b..c14bb530 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -1052,7 +1052,7 @@ export const LLM_WIKI_ROW_ACTIONS = {
   },
   'copy-recovery': {
     command: COPY_WIKI_RECOVERY_REQUEST_COMMAND,
-    title: 'Copy recovery request',
+    title: 'Copy Recovery Request',
   },
   'reveal-folder': {
     command: REVEAL_WIKI_FOLDER_COMMAND,
@@ -1068,6 +1068,33 @@ 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).`
+ * @example llmWikiFolderMissingNotice('.codebook/wiki') // => 'The LLM Wiki folder .codebook/wiki does not exist (yet).'
+ */
+export const llmWikiFolderMissingNotice = (outputLabel: string): string =>
+  `The LLM Wiki folder ${outputLabel} does not exist (yet).`
+
+/**
+ * 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>.`
+ * @example llmWikiFolderRemoteNotice('wsl') // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on wsl.'
+ */
+export const llmWikiFolderRemoteNotice = (remoteName: string): string =>
+  `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${remoteName}.`
+
 /** 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. */
@@ -1778,11 +1805,3 @@ export const REFUSAL_REPORT_LABEL_CHARS = 48
 
 /** The most editor events a {@link PlacementEventLog} keeps and a placement refusal report lists, in events. */
 export const REFUSAL_REPORT_EVENTS = 24
-
-/** What the LLM Wiki view says when the editor lists none of the known ids of its Manage Workspace Trust command ({@link manageTrust}). */
-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.'
diff --git a/extension/src/tests/llmWikiManifest.test.ts b/extension/src/tests/llmWikiManifest.test.ts
index 95ff67ac..52b24f5e 100644
--- a/extension/src/tests/llmWikiManifest.test.ts
+++ b/extension/src/tests/llmWikiManifest.test.ts
@@ -166,7 +166,7 @@ test('the palette lists the commands that exist only with the LLM Wiki view only
   })
 })
 
-// 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 falls back to sentence case; no_claim=how the editor draws the icons (N56 step 5); seam=the packaged manifest
+// 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()
@@ -183,6 +183,7 @@ test('the LLM Wiki view’s inline actions carry the decided icons and Title Cas
     '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]
@@ -197,13 +198,15 @@ test('the LLM Wiki view’s inline actions carry the decided icons and Title Cas
     ['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'],
+    ['Try Again', 'Stop Watching', 'Change Location', 'Copy Recovery Request'],
   )
 })
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index a4e8b1ef..9684c6e2 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -544,8 +544,8 @@ const runningFacts = (): ReadyFacts =>
     },
   })
 
-// Value: protects=the debounce flush; fails_when=whenIdle resolves 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('whenIdle waits for the debounced read of a watched file’s event', async (context) => {
+// 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()
@@ -617,6 +617,29 @@ test('the poll stops once a good read shows no run after the error row', async (
   assert.equal(reads - readsAfterTheGoodRead, 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
@@ -637,7 +660,6 @@ test('a hidden view does not poll and a shown view reads once and polls again',
   await view.whenIdle()
   const readsAfterHiddenTicks = reads
   fake.setVisible(true)
-  context.mock.timers.tick(20)
   await view.whenIdle()
   const readsAfterShown = reads
   context.mock.timers.tick(50)
diff --git a/extension/src/tests/utils/wikiUpdateWindow.ts b/extension/src/tests/utils/wikiUpdateWindow.ts
index c0a3f1f1..73cbc187 100644
--- a/extension/src/tests/utils/wikiUpdateWindow.ts
+++ b/extension/src/tests/utils/wikiUpdateWindow.ts
@@ -1071,7 +1071,11 @@ export async function openWikiUpdateWindow(options: {
       contextKeys,
       treeChangeCount: () => treeChangeCount,
       renderLog: () => [...renderLog],
-      whenIdle: async () => llmWikiView?.whenIdle(),
+      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])
diff --git a/extension/src/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
index a5891d3e..7d079abe 100644
--- a/extension/src/utils/describeUnrevealableWikiFolder.ts
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -1,3 +1,8 @@
+import {
+  llmWikiFolderMissingNotice,
+  llmWikiFolderRemoteNotice,
+} from '../constants'
+
 /**
  * Words why Reveal Wiki Folder opens nothing, so the learner is not left with a command that does nothing visible.
  *
@@ -22,9 +27,7 @@ export function describeUnrevealableWikiFolder(folder: {
   remoteName?: string
 }): string | undefined {
   // A missing folder is the more useful answer, in a remote window too.
-  if (!folder.exists)
-    return `The LLM Wiki folder ${folder.outputLabel} does not exist (yet).`
-  if (folder.remoteName)
-    return `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${folder.remoteName}.`
+  if (!folder.exists) return llmWikiFolderMissingNotice(folder.outputLabel)
+  if (folder.remoteName) return llmWikiFolderRemoteNotice(folder.remoteName)
   return undefined
 }
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index 5a2cec8c..5cbd5bf1 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -591,8 +591,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     treeView,
     treeView.onDidChangeVisibility((event) => {
       isViewVisible = event.visible
-      // Hidden: no poll. Shown: one read, which restarts the poll and the freshness check.
-      if (event.visible) requestRefresh()
+      // Hidden: no poll. Shown: one read at once (the 1 s debounce is for file events), which restarts the poll and the freshness check.
+      if (event.visible) void refresh()
       else keepPoll()
     }),
     editor.workspace.onDidChangeConfiguration((event) => {

From faea27df9ad6bee1064688498728babbb88a6839 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 06:11:29 +0900
Subject: [PATCH 5/9] test: Cycle 0056 pt2: coverage audit tests (poll without
 a prior run row, reveal reason precedence, real folder check)

---
 .../describeUnrevealableWikiFolder.test.ts    | 31 +++++++++++++++++++
 extension/src/tests/isExistingFolder.test.ts  | 26 ++++++++++++++++
 .../src/tests/llmWikiViewReadLoop.test.ts     | 25 +++++++++++++++
 3 files changed, 82 insertions(+)
 create mode 100644 extension/src/tests/describeUnrevealableWikiFolder.test.ts
 create mode 100644 extension/src/tests/isExistingFolder.test.ts

diff --git a/extension/src/tests/describeUnrevealableWikiFolder.test.ts b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
new file mode 100644
index 00000000..feb8e035
--- /dev/null
+++ b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
@@ -0,0 +1,31 @@
+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',
+    exists: false,
+    remoteName: 'wsl',
+  }
+  const existingInLocal = {
+    outputLabel: '.codebook/wiki',
+    exists: true,
+    remoteName: '',
+  }
+
+  // Act
+  const results = [
+    describeUnrevealableWikiFolder(missingInRemote),
+    describeUnrevealableWikiFolder(existingInLocal),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    'The LLM Wiki folder .codebook/wiki does not exist (yet).',
+    undefined,
+  ])
+})
diff --git a/extension/src/tests/isExistingFolder.test.ts b/extension/src/tests/isExistingFolder.test.ts
new file mode 100644
index 00000000..1dcdbb10
--- /dev/null
+++ b/extension/src/tests/isExistingFolder.test.ts
@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { isExistingFolder } from '../utils/isExistingFolder'
+
+// Value: protects=Reveal Wiki Folder reveals only a real folder; fails_when=a file or a missing path counts as a folder, so the editor's reveal opens nothing without a sentence; why_new=no test reaches the real stat; seam=none; no_claim=symlink handling on every OS
+test('a folder counts as an existing folder while a file and a missing path do not', async (context) => {
+  // Arrange
+  const root = await mkdtemp(join(tmpdir(), 'codebook-folder-'))
+  context.after(() => rm(root, { recursive: true, force: true }))
+  const file = join(root, 'wiki.txt')
+  await writeFile(file, 'x')
+
+  // Act
+  const results = [
+    await isExistingFolder(root),
+    await isExistingFolder(file),
+    await isExistingFolder(join(root, 'missing')),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [true, false, false])
+})
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index 9684c6e2..5feb5439 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -617,6 +617,31 @@ test('the poll stops once a good read shows no run after the error row', async (
   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

From 386449b1f0d6076d27040466d7c36297427d3841 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 06:45:01 +0900
Subject: [PATCH 6/9] fix: Cycle 0056 pt2: pre-landing review fixes (pass 1)

- SM2-1..SM2-7: read-loop tests for debounce x dispose, reading x requestRefresh/refresh/show, error-after-run-row x hide/show, cleared message x getChildren
- RT2-A: a read failure that persists across poll ticks is recorded once in Output while the error row stands; a different failure or one after a good read is recorded again
- RT2-B (1): a WSL window reveals the Wiki folder like a local one
- RT2-B (2): a file at the output path gets its own Reveal Wiki Folder sentence (new isExistingFile helper)
- D2: the missing and remote Reveal Wiki Folder notices add the next step after task 21's sentence
- D3: README lists Copy Recovery Request among the Title Case inline actions
- RT2-C: the view's tree provider tolerates a root read inside createTreeView
---
 extension/README.md                           |   4 +-
 extension/src/constants.ts                    |  21 +-
 .../describeUnrevealableWikiFolder.test.ts    |  32 +-
 extension/src/tests/isExistingFile.test.ts    |  26 ++
 extension/src/tests/llmWikiView.test.ts       |  46 ++-
 .../src/tests/llmWikiViewReadLoop.test.ts     | 309 +++++++++++++++++-
 .../src/tests/utils/fakeLlmWikiEditor.ts      |  31 +-
 .../utils/describeUnrevealableWikiFolder.ts   |  28 +-
 extension/src/utils/isExistingFile.ts         |  17 +
 extension/src/utils/llmWikiView.ts            |  28 +-
 .../src/utils/registerLlmWikiCommands.ts      |   6 +-
 11 files changed, 517 insertions(+), 31 deletions(-)
 create mode 100644 extension/src/tests/isExistingFile.test.ts
 create mode 100644 extension/src/utils/isExistingFile.ts

diff --git a/extension/README.md b/extension/README.md
index 63381eed..5b372baa 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -247,11 +247,11 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - 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 (`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** (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**); **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…` 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**, 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).`, and in a window connected to a remote host (SSH, WSL, a container) it says `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.` and opens nothing. 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.
+- **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 or file manager on <remote name>.` and opens nothing. 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.
 
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index c14bb530..17673548 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -1080,20 +1080,29 @@ export const LLM_WIKI_RECOVERY_REQUEST_COPIED_NOTICE =
 /**
  * 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).`
- * @example llmWikiFolderMissingNotice('.codebook/wiki') // => 'The LLM Wiki folder .codebook/wiki does not exist (yet).'
+ * @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).`
+  `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 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>.`
- * @example llmWikiFolderRemoteNotice('wsl') // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on wsl.'
+ * @returns `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>. Open it from a terminal or file manager on <remote name>.` (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 or file manager on ssh-remote.'
  */
 export const llmWikiFolderRemoteNotice = (remoteName: string): string =>
-  `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${remoteName}.`
+  `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ${remoteName}. Open it from a terminal or file manager on ${remoteName}.`
 
 /** 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
diff --git a/extension/src/tests/describeUnrevealableWikiFolder.test.ts b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
index feb8e035..b9bd7793 100644
--- a/extension/src/tests/describeUnrevealableWikiFolder.test.ts
+++ b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
@@ -25,7 +25,37 @@ test('Reveal Wiki Folder names a missing folder before the remote host and lets
 
   // Assert
   assert.deepEqual(results, [
-    'The LLM Wiki folder .codebook/wiki does not exist (yet).',
+    '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', exists: false, isFile: true }
+  const existingInSsh = {
+    outputLabel: 'docs/wiki',
+    exists: true,
+    remoteName: 'ssh-remote',
+  }
+  const existingInWsl = {
+    outputLabel: 'docs/wiki',
+    exists: true,
+    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 or file manager on ssh-remote.',
     undefined,
   ])
 })
diff --git a/extension/src/tests/isExistingFile.test.ts b/extension/src/tests/isExistingFile.test.ts
new file mode 100644
index 00000000..7b3aef20
--- /dev/null
+++ b/extension/src/tests/isExistingFile.test.ts
@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { isExistingFile } from '../utils/isExistingFile'
+
+// Value: protects=RT2-B (2) (Reveal Wiki Folder tells a file from nothing); fails_when=a folder or a missing path counts as a file, or a real file does not; why_new=no other test reaches the real stat of this helper; seam=none; no_claim=symlink handling on every OS
+test('a file counts as an existing file while a folder and a missing path do not', async (context) => {
+  // Arrange
+  const root = await mkdtemp(join(tmpdir(), 'codebook-file-'))
+  context.after(() => rm(root, { recursive: true, force: true }))
+  const file = join(root, 'wiki.txt')
+  await writeFile(file, 'x')
+
+  // Act
+  const results = [
+    await isExistingFile(file),
+    await isExistingFile(root),
+    await isExistingFile(join(root, 'missing')),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [true, false, false])
+})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index 72ad5ede..73415df2 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -1051,7 +1051,12 @@ test('Reveal Wiki Folder on a missing folder says the folder does not exist yet
   // Assert
   assert.deepEqual(
     [project.executedCommands, project.notices],
-    [[], ['The LLM Wiki folder .codebook/wiki does not exist (yet).']],
+    [
+      [],
+      [
+        'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.',
+      ],
+    ],
   )
 })
 
@@ -1071,7 +1076,44 @@ test('Reveal Wiki Folder in a remote window says the folder is on the remote hos
     [
       [],
       [
-        'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote.',
+        'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal or file manager on ssh-remote.',
+      ],
+    ],
+  )
+})
+
+// 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.',
       ],
     ],
   )
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index 5feb5439..36df4edb 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -46,8 +46,9 @@ 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 tellings: string[] = []
   const view = createLlmWikiView({
@@ -795,3 +796,309 @@ 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=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],
+  )
+})
diff --git a/extension/src/tests/utils/fakeLlmWikiEditor.ts b/extension/src/tests/utils/fakeLlmWikiEditor.ts
index 5f19ed5b..61066968 100644
--- a/extension/src/tests/utils/fakeLlmWikiEditor.ts
+++ b/extension/src/tests/utils/fakeLlmWikiEditor.ts
@@ -17,13 +17,18 @@ 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), `message` (the tree view's message), `contextKeys`, `files` (the fake file watching, to report events), `setVisible`, `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<
@@ -79,9 +84,23 @@ 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,
+          get message(): string | undefined {
+            return shownMessage
+          },
+          set message(text: string | undefined) {
+            shownMessage = text
+            renderLog.push(`message:${text}`)
+          },
           get visible(): boolean {
             return isViewShown
           },
@@ -116,6 +135,10 @@ 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
diff --git a/extension/src/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
index 7d079abe..8b514ee6 100644
--- a/extension/src/utils/describeUnrevealableWikiFolder.ts
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -1,6 +1,8 @@
 import {
+  llmWikiFolderIsFileNotice,
   llmWikiFolderMissingNotice,
   llmWikiFolderRemoteNotice,
+  WSL_REMOTE_NAME,
 } from '../constants'
 
 /**
@@ -12,22 +14,32 @@ import {
  * @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.exists - Whether the folder exists now.
- * @param folder.remoteName - The editor's `env.remoteName`; empty or absent for a local window.
+ * @param folder.isFile - Whether a file stands at the path instead (only read when the folder does not exist).
+ * @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 missing folder: `The LLM Wiki folder <label> does not exist (yet).`
- * - An existing folder in a remote window: `Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on <remote name>.`
+ * - 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 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 or file manager on <remote name>.`
  * - Otherwise `undefined`: the folder can be revealed.
  * @example
- * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: false }) // => 'The LLM Wiki folder .codebook/wiki does not exist (yet).'
- * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'wsl' }) // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on wsl.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: false }) // => 'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'ssh-remote' }) // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal or file manager on ssh-remote.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'wsl' }) // => undefined
  */
 export function describeUnrevealableWikiFolder(folder: {
   outputLabel: string
   exists: boolean
+  isFile?: boolean
   remoteName?: string
 }): string | undefined {
-  // A missing folder is the more useful answer, in a remote window too.
-  if (!folder.exists) return llmWikiFolderMissingNotice(folder.outputLabel)
-  if (folder.remoteName) return llmWikiFolderRemoteNotice(folder.remoteName)
+  // A missing folder or a file in its place is the more useful answer, in a remote window too.
+  if (!folder.exists) {
+    return folder.isFile
+      ? llmWikiFolderIsFileNotice(folder.outputLabel)
+      : llmWikiFolderMissingNotice(folder.outputLabel)
+  }
+  // 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/isExistingFile.ts b/extension/src/utils/isExistingFile.ts
new file mode 100644
index 00000000..fa8615df
--- /dev/null
+++ b/extension/src/utils/isExistingFile.ts
@@ -0,0 +1,17 @@
+import { stat } from 'node:fs/promises'
+
+/**
+ * Says whether a path is a file (not a folder) on this computer now; called by the LLM Wiki view's Reveal Wiki Folder command when the Wiki output is not a folder, to tell a file in the folder's place from nothing at all.
+ * @param filePath - The absolute path to look at.
+ * @returns `true` for a file (a link to a file counts); `false` for a folder, nothing there, or a path that cannot be read.
+ * @example
+ * await isExistingFile('/repo/.codebook/wiki') // => true when a file stands there
+ * await isExistingFile('/repo/missing')        // => false
+ */
+export async function isExistingFile(filePath: string): Promise<boolean> {
+  try {
+    return (await stat(filePath)).isFile()
+  } catch {
+    return false
+  }
+}
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index 5cbd5bf1..876f124f 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -115,7 +115,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}).
@@ -150,6 +150,10 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   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 cause text of the failure recorded while the error row stands; the poll's repeats of it are not recorded again. */
+  let recordedFailureCause: string | 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
@@ -174,7 +178,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
       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.
-        if (model.message !== appliedMessage) {
+        // A root read inside createTreeView finds no handle yet; the next root read writes the message.
+        if (isTreeViewCreated && model.message !== appliedMessage) {
           appliedMessage = model.message
           treeView.message = model.message
         }
@@ -209,6 +214,7 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     },
   })
 
+  isTreeViewCreated = true
   // The editor reports whether the view is shown now; a collapsed view runs no poll.
   isViewVisible = treeView.visible
 
@@ -525,10 +531,18 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   /** Shows the error row for a read that threw anywhere, and records the cause once. */
   const showReadFailure = (cause: unknown): void => {
     if (isDisposed) return
-    try {
-      options.recordFailure('The LLM Wiki view could not read its state', cause)
-    } catch {
-      // A failure that cannot be recorded has nowhere to be told.
+    // The poll reads again across the error row, so the same failure is recorded once while the row stands; a different failure is recorded too.
+    const causeText = cause instanceof Error ? cause.message : String(cause)
+    if (causeText !== recordedFailureCause) {
+      recordedFailureCause = causeText
+      try {
+        options.recordFailure(
+          'The LLM Wiki view could not read its state',
+          cause,
+        )
+      } catch {
+        // A failure that cannot be recorded has nowhere to be told.
+      }
     }
     // lateWatch stays: a publication after one failed read is still a late publication.
     shownReadyFacts = undefined
@@ -538,6 +552,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
 
   /** Shows one read: the rows with the cached or `checking` freshness, then asks for the freshness check apart. */
   const showRead = (read: LlmWikiViewFacts): void => {
+    // A good read ends the failure: the next one is recorded again.
+    recordedFailureCause = undefined
     const nextFacts = read.kind === 'ready' ? withViewState(read) : read
     if (nextFacts.kind === 'ready') noteLatePublication(nextFacts)
     const next = readLlmWikiViewState(nextFacts)
diff --git a/extension/src/utils/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
index fad0f31e..f01ea7ee 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -20,6 +20,7 @@ import {
 } from '../constants'
 
 import { describeUnrevealableWikiFolder } from './describeUnrevealableWikiFolder'
+import { isExistingFile } from './isExistingFile'
 import { isExistingFolder } from './isExistingFolder'
 import type { LlmWikiView } from './llmWikiView'
 import { resolveManageTrustCommand } from './resolveManageTrustCommand'
@@ -124,9 +125,12 @@ export function registerLlmWikiCommands(
     registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () => {
       const { projectRoot, outputDirectory } = await options.findWikiLocation()
       // The editor's reveal shows nothing for a missing folder or one on a remote host, so the learner is told instead.
+      const exists = await isExistingFolder(outputDirectory)
       const reason = describeUnrevealableWikiFolder({
         outputLabel: wikiOutputLabel(projectRoot, outputDirectory),
-        exists: await isExistingFolder(outputDirectory),
+        exists,
+        // A file in the folder's place gets its own sentence, not "does not exist".
+        isFile: !exists && (await isExistingFile(outputDirectory)),
         remoteName: editor.env.remoteName,
       })
       if (reason !== undefined) {

From abd068547a57c1662e15031461cc0b455734a721 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 06:56:49 +0900
Subject: [PATCH 7/9] fix: Cycle 0056 pt2: pre-landing review fixes (pass 2)

- SM3: recordedFailureCause is cleared only once a non-error model is shown (after show, and after the freshness result is shown), so a persistent row-step or freshness failure is recorded once across poll ticks.
- RT3-b: the dedupe key is name|code|message for Errors and util.inspect text otherwise (failureKeyOf).
- RT3-c: one stat (wikiFolderKindOf) replaces isExistingFolder/isExistingFile; an unreadable path gets its own sentence with the error code; README updated.
- D4: the remote Reveal notice's next step is "Open it from a terminal in this window, which runs on that remote."; task 21's first sentence unchanged.
- M4: the show docstring no longer says it sets the message.
---
 extension/README.md                           |  2 +-
 extension/src/constants.ts                    | 19 +++-
 .../describeUnrevealableWikiFolder.test.ts    | 34 +++++--
 extension/src/tests/isExistingFile.test.ts    | 26 -----
 extension/src/tests/isExistingFolder.test.ts  | 26 -----
 extension/src/tests/llmWikiView.test.ts       | 24 ++++-
 .../src/tests/llmWikiViewReadLoop.test.ts     | 95 ++++++++++++++++++-
 extension/src/tests/wikiFolderKindOf.test.ts  | 34 +++++++
 .../utils/describeUnrevealableWikiFolder.ts   | 31 +++---
 extension/src/utils/failureKeyOf.ts           | 23 +++++
 extension/src/utils/isExistingFile.ts         | 17 ----
 extension/src/utils/isExistingFolder.ts       | 17 ----
 extension/src/utils/llmWikiView.ts            | 19 +++-
 .../src/utils/registerLlmWikiCommands.ts      |  9 +-
 extension/src/utils/wikiFolderKindOf.ts       | 42 ++++++++
 15 files changed, 294 insertions(+), 124 deletions(-)
 delete mode 100644 extension/src/tests/isExistingFile.test.ts
 delete mode 100644 extension/src/tests/isExistingFolder.test.ts
 create mode 100644 extension/src/tests/wikiFolderKindOf.test.ts
 create mode 100644 extension/src/utils/failureKeyOf.ts
 delete mode 100644 extension/src/utils/isExistingFile.ts
 delete mode 100644 extension/src/utils/isExistingFolder.ts
 create mode 100644 extension/src/utils/wikiFolderKindOf.ts

diff --git a/extension/README.md b/extension/README.md
index 5b372baa..e76b6b1a 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -251,7 +251,7 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - **`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**, 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 or file manager on <remote name>.` and opens nothing. 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.
+- **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 on that remote.` 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 its permissions, or change the location.` instead of saying the folder does not exist. 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.
 
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index 17673548..43e3c29c 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -1095,14 +1095,27 @@ export const llmWikiFolderMissingNotice = (outputLabel: string): string =>
 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 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`, …).
+ * @returns `The LLM Wiki folder <label> cannot be read (<code>). Check its permissions, or change the location.`
+ * @example llmWikiFolderUnreadableNotice('.codebook/wiki', 'EACCES') // => 'The LLM Wiki folder .codebook/wiki cannot be read (EACCES). Check its permissions, or change the location.'
+ */
+export const llmWikiFolderUnreadableNotice = (
+  outputLabel: string,
+  code: string,
+): string =>
+  `The LLM Wiki folder ${outputLabel} cannot be read (${code}). Check its permissions, or change the location.`
+
 /**
  * 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 or file manager on <remote name>.` (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 or file manager on ssh-remote.'
+ * @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 on that remote.` (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 on that remote.'
  */
 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 or file manager on ${remoteName}.`
+  `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 on that remote.`
 
 /** 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
diff --git a/extension/src/tests/describeUnrevealableWikiFolder.test.ts b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
index b9bd7793..cb0ce3f6 100644
--- a/extension/src/tests/describeUnrevealableWikiFolder.test.ts
+++ b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
@@ -8,12 +8,12 @@ test('Reveal Wiki Folder names a missing folder before the remote host and lets
   // Arrange
   const missingInRemote = {
     outputLabel: '.codebook/wiki',
-    exists: false,
+    folderKind: { kind: 'missing' } as const,
     remoteName: 'wsl',
   }
   const existingInLocal = {
     outputLabel: '.codebook/wiki',
-    exists: true,
+    folderKind: { kind: 'folder' } as const,
     remoteName: '',
   }
 
@@ -33,15 +33,18 @@ test('Reveal Wiki Folder names a missing folder before the remote host and lets
 // 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', exists: false, isFile: true }
+  const fileInPlace = {
+    outputLabel: 'docs/wiki',
+    folderKind: { kind: 'file' } as const,
+  }
   const existingInSsh = {
     outputLabel: 'docs/wiki',
-    exists: true,
+    folderKind: { kind: 'folder' } as const,
     remoteName: 'ssh-remote',
   }
   const existingInWsl = {
     outputLabel: 'docs/wiki',
-    exists: true,
+    folderKind: { kind: 'folder' } as const,
     remoteName: 'wsl',
   }
 
@@ -55,7 +58,26 @@ test('Reveal Wiki Folder words a file, a remote host with its next step, and let
   // 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 or file manager on 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 on that remote.',
     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 its permissions, or change the location.',
+  )
+})
diff --git a/extension/src/tests/isExistingFile.test.ts b/extension/src/tests/isExistingFile.test.ts
deleted file mode 100644
index 7b3aef20..00000000
--- a/extension/src/tests/isExistingFile.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import assert from 'node:assert/strict'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { test } from 'node:test'
-
-import { isExistingFile } from '../utils/isExistingFile'
-
-// Value: protects=RT2-B (2) (Reveal Wiki Folder tells a file from nothing); fails_when=a folder or a missing path counts as a file, or a real file does not; why_new=no other test reaches the real stat of this helper; seam=none; no_claim=symlink handling on every OS
-test('a file counts as an existing file while a folder and a missing path do not', async (context) => {
-  // Arrange
-  const root = await mkdtemp(join(tmpdir(), 'codebook-file-'))
-  context.after(() => rm(root, { recursive: true, force: true }))
-  const file = join(root, 'wiki.txt')
-  await writeFile(file, 'x')
-
-  // Act
-  const results = [
-    await isExistingFile(file),
-    await isExistingFile(root),
-    await isExistingFile(join(root, 'missing')),
-  ]
-
-  // Assert
-  assert.deepEqual(results, [true, false, false])
-})
diff --git a/extension/src/tests/isExistingFolder.test.ts b/extension/src/tests/isExistingFolder.test.ts
deleted file mode 100644
index 1dcdbb10..00000000
--- a/extension/src/tests/isExistingFolder.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import assert from 'node:assert/strict'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { test } from 'node:test'
-
-import { isExistingFolder } from '../utils/isExistingFolder'
-
-// Value: protects=Reveal Wiki Folder reveals only a real folder; fails_when=a file or a missing path counts as a folder, so the editor's reveal opens nothing without a sentence; why_new=no test reaches the real stat; seam=none; no_claim=symlink handling on every OS
-test('a folder counts as an existing folder while a file and a missing path do not', async (context) => {
-  // Arrange
-  const root = await mkdtemp(join(tmpdir(), 'codebook-folder-'))
-  context.after(() => rm(root, { recursive: true, force: true }))
-  const file = join(root, 'wiki.txt')
-  await writeFile(file, 'x')
-
-  // Act
-  const results = [
-    await isExistingFolder(root),
-    await isExistingFolder(file),
-    await isExistingFolder(join(root, 'missing')),
-  ]
-
-  // Assert
-  assert.deepEqual(results, [true, false, false])
-})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index 73415df2..008eccd4 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -1076,7 +1076,7 @@ test('Reveal Wiki Folder in a remote window says the folder is on the remote hos
     [
       [],
       [
-        'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal or file manager on 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 on that remote.',
       ],
     ],
   )
@@ -1119,6 +1119,28 @@ test('Reveal Wiki Folder on a file in the folder’s place says it is a file and
   )
 })
 
+// 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 its permissions, or change the location.',
+      ],
+    ],
+  )
+})
+
 // 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
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index 36df4edb..6140fc49 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -50,6 +50,7 @@ function openView(
 ) {
   const fake = createFakeLlmWikiEditor(fakeOptions)
   const recordedFailures: string[] = []
+  const recordedCauses: unknown[] = []
   const tellings: string[] = []
   const view = createLlmWikiView({
     editor: fake.editor,
@@ -61,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[] =>
@@ -827,6 +831,93 @@ test('a read failure that persists across poll ticks is recorded once in Output'
   ])
 })
 
+// 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
diff --git a/extension/src/tests/wikiFolderKindOf.test.ts b/extension/src/tests/wikiFolderKindOf.test.ts
new file mode 100644
index 00000000..86e9c56f
--- /dev/null
+++ b/extension/src/tests/wikiFolderKindOf.test.ts
@@ -0,0 +1,34 @@
+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'
+
+// 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' },
+  ])
+})
diff --git a/extension/src/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
index 8b514ee6..c1f93244 100644
--- a/extension/src/utils/describeUnrevealableWikiFolder.ts
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -2,9 +2,12 @@ import {
   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.
  *
@@ -13,31 +16,31 @@ import {
  *
  * @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.exists - Whether the folder exists now.
- * @param folder.isFile - Whether a file stands at the path instead (only read when the folder does not exist).
+ * @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 path that cannot be read: `The LLM Wiki folder <label> cannot be read (<code>). Check 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 or file manager on <remote name>.`
+ * - 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 on that remote.`
  * - Otherwise `undefined`: the folder can be revealed.
  * @example
- * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: false }) // => 'The LLM Wiki folder .codebook/wiki does not exist (yet). Generate LLM Wiki creates it.'
- * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'ssh-remote' }) // => 'Reveal Wiki Folder opens folders on this computer only; the Wiki folder is on ssh-remote. Open it from a terminal or file manager on ssh-remote.'
- * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', exists: true, remoteName: 'wsl' }) // => undefined
+ * 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 on that remote.'
+ * describeUnrevealableWikiFolder({ outputLabel: '.codebook/wiki', folderKind: { kind: 'folder' }, remoteName: 'wsl' }) // => undefined
  */
 export function describeUnrevealableWikiFolder(folder: {
   outputLabel: string
-  exists: boolean
-  isFile?: boolean
+  folderKind: WikiFolderKind
   remoteName?: string
 }): string | undefined {
-  // A missing folder or a file in its place is the more useful answer, in a remote window too.
-  if (!folder.exists) {
-    return folder.isFile
-      ? llmWikiFolderIsFileNotice(folder.outputLabel)
-      : llmWikiFolderMissingNotice(folder.outputLabel)
-  }
+  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 === '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)
diff --git a/extension/src/utils/failureKeyOf.ts b/extension/src/utils/failureKeyOf.ts
new file mode 100644
index 00000000..82780110
--- /dev/null
+++ b/extension/src/utils/failureKeyOf.ts
@@ -0,0 +1,23 @@
+import { inspect } from 'node:util'
+
+import { systemErrorCode } from './systemErrorCode'
+
+/**
+ * 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.
+ * Trigger: the LLM Wiki view ({@link createLlmWikiView}) asks it for each failed read, 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)
+ * - Anything else: its `util.inspect` text
+ * @example
+ * failureKeyOf(Object.assign(new Error('busy'), { code: 'EBUSY' })) // => 'Error|EBUSY|busy'
+ * failureKeyOf({ reason: 'busy' })                                   // => "{ reason: 'busy' }"
+ */
+export function failureKeyOf(cause: unknown): string {
+  if (cause instanceof Error)
+    return `${cause.name}|${systemErrorCode(cause)}|${cause.message}`
+  return inspect(cause)
+}
diff --git a/extension/src/utils/isExistingFile.ts b/extension/src/utils/isExistingFile.ts
deleted file mode 100644
index fa8615df..00000000
--- a/extension/src/utils/isExistingFile.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { stat } from 'node:fs/promises'
-
-/**
- * Says whether a path is a file (not a folder) on this computer now; called by the LLM Wiki view's Reveal Wiki Folder command when the Wiki output is not a folder, to tell a file in the folder's place from nothing at all.
- * @param filePath - The absolute path to look at.
- * @returns `true` for a file (a link to a file counts); `false` for a folder, nothing there, or a path that cannot be read.
- * @example
- * await isExistingFile('/repo/.codebook/wiki') // => true when a file stands there
- * await isExistingFile('/repo/missing')        // => false
- */
-export async function isExistingFile(filePath: string): Promise<boolean> {
-  try {
-    return (await stat(filePath)).isFile()
-  } catch {
-    return false
-  }
-}
diff --git a/extension/src/utils/isExistingFolder.ts b/extension/src/utils/isExistingFolder.ts
deleted file mode 100644
index 2fc7870b..00000000
--- a/extension/src/utils/isExistingFolder.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { stat } from 'node:fs/promises'
-
-/**
- * Says whether a path is a folder on this computer now; called by the LLM Wiki view's Reveal Wiki Folder command before it asks the editor to reveal the Wiki folder.
- * @param folderPath - The absolute path to look at.
- * @returns `true` for a folder (a link to a folder counts); `false` when nothing is there, a file is there, or the path cannot be read.
- * @example
- * await isExistingFolder('/repo/.codebook/wiki') // => true
- * await isExistingFolder('/repo/missing')        // => false
- */
-export async function isExistingFolder(folderPath: string): Promise<boolean> {
-  try {
-    return (await stat(folderPath)).isDirectory()
-  } catch {
-    return false
-  }
-}
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index 876f124f..9dca7f52 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,
@@ -218,7 +219,10 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   // 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, the message and fires one tree change, only for what differs from what is shown. */
+  /**
+   * 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 it next reads its root children ({@link getChildren} / the provider).
+   */
   const show = (next: LlmWikiViewModel): void => {
     // A read that finished after dispose shows nothing.
     if (isDisposed) return
@@ -416,6 +420,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
         wiki: { ...shown.wiki, freshness: value },
       }),
     )
+    // The freshness result is shown: the failure that stood is over.
+    recordedFailureCause = 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. */
@@ -532,7 +538,7 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   const showReadFailure = (cause: unknown): void => {
     if (isDisposed) return
     // The poll reads again across the error row, so the same failure is recorded once while the row stands; a different failure is recorded too.
-    const causeText = cause instanceof Error ? cause.message : String(cause)
+    const causeText = failureKeyOf(cause)
     if (causeText !== recordedFailureCause) {
       recordedFailureCause = causeText
       try {
@@ -552,8 +558,6 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
 
   /** Shows one read: the rows with the cached or `checking` freshness, then asks for the freshness check apart. */
   const showRead = (read: LlmWikiViewFacts): void => {
-    // A good read ends the failure: the next one is recorded again.
-    recordedFailureCause = undefined
     const nextFacts = read.kind === 'ready' ? withViewState(read) : read
     if (nextFacts.kind === 'ready') noteLatePublication(nextFacts)
     const next = readLlmWikiViewState(nextFacts)
@@ -570,8 +574,13 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
       nextFacts.kind === 'ready' &&
       nextFacts.wiki &&
       next.rows.some((row) => row.id === 'wiki')
-    )
+    ) {
+      // The failure ends only when the freshness result is shown too (see checkFreshness), so a check that keeps failing is recorded once.
       requestFreshness(nextFacts)
+      return
+    }
+    // A model shown without a failure ends it: the next failure is recorded again.
+    recordedFailureCause = undefined
   }
 
   /** One read from the facts to the rows; whatever throws in it shows the error row. */
diff --git a/extension/src/utils/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
index f01ea7ee..3063b2b8 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -20,10 +20,9 @@ import {
 } from '../constants'
 
 import { describeUnrevealableWikiFolder } from './describeUnrevealableWikiFolder'
-import { isExistingFile } from './isExistingFile'
-import { isExistingFolder } from './isExistingFolder'
 import type { LlmWikiView } from './llmWikiView'
 import { resolveManageTrustCommand } from './resolveManageTrustCommand'
+import { wikiFolderKindOf } from './wikiFolderKindOf'
 import { wikiOutputLabel } from './wikiOutputLabel'
 import { withHomeFolderShown } from './withHomeFolderShown'
 
@@ -125,12 +124,10 @@ export function registerLlmWikiCommands(
     registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () => {
       const { projectRoot, outputDirectory } = await options.findWikiLocation()
       // The editor's reveal shows nothing for a missing folder or one on a remote host, so the learner is told instead.
-      const exists = await isExistingFolder(outputDirectory)
       const reason = describeUnrevealableWikiFolder({
         outputLabel: wikiOutputLabel(projectRoot, outputDirectory),
-        exists,
-        // A file in the folder's place gets its own sentence, not "does not exist".
-        isFile: !exists && (await isExistingFile(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) {
diff --git a/extension/src/utils/wikiFolderKindOf.ts b/extension/src/utils/wikiFolderKindOf.ts
new file mode 100644
index 00000000..42fd51ad
--- /dev/null
+++ b/extension/src/utils/wikiFolderKindOf.ts
@@ -0,0 +1,42 @@
+import { stat } from 'node:fs/promises'
+
+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: 'unreadable'; code: string }
+
+/**
+ * Looks once at the Wiki output path and says what stands there, so Reveal Wiki Folder can tell a folder, a file, nothing and a path it cannot read apart.
+ *
+ * Why: one `stat` answers all four, and only `ENOENT` means nothing is there; a permission or path error (`EACCES`, `ENOTDIR`, `ENAMETOOLONG`) must not be told as "does not exist (yet)".
+ * 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.
+ * @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`): `{ kind: 'missing' }`
+ * - Any other failure of the look: `{ 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,
+): Promise<WikiFolderKind> {
+  try {
+    return (await stat(folderPath)).isDirectory()
+      ? { kind: 'folder' }
+      : { kind: 'file' }
+  } catch (error) {
+    const code = systemErrorCode(error)
+    // Only a path with nothing at it is a folder that is not there yet.
+    if (code === 'ENOENT') return { kind: 'missing' }
+    return { kind: 'unreadable', code: code || 'UNKNOWN' }
+  }
+}

From c82e4be8e7056357b3d4fed5889d737c8d765fd3 Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 07:19:12 +0900
Subject: [PATCH 8/9] fix: Cycle 0056 pt2: pre-landing review fixes (pass 3 and
 adversarial review)

- F1: a freshness check queued before the view is hidden no longer starts while it is hidden; a show reads again and queues a current one.
- F2: Reveal Wiki Folder gives up on a path look that never answers (3 s, ETIMEDOUT) and tells a link whose target is missing in its own sentence.
- F3: the unreadable sentence reads "Check the path and its permissions, or change the location."
- F4: a cause that cannot be read (throwing message getter) still shows the error row; failureKeyOf falls back to the type tag.
- F5: the failure key is bounded (500 characters), includes the cause one level down and ignores digit runs of the message.
- F6: a good read ends the read failure; the freshness check records its own failure once and a successful check clears it.
- F7: Reveal Wiki Folder tells and records a Wiki location that cannot be worked out.
- F8: the tree view writes no message after dispose and applies the current message once after creation.
- F9: systemErrorCode returns a code only when it is a string or a number.
- F10/F11: failureKeyOf tests; the UNKNOWN fallback of wikiFolderKindOf is tested through a look seam.
- F12: the show docstring no longer links getChildren.
- F13: the remote notice's next step: "...which runs in that remote environment, not on this computer."
- F14: the README says the poll runs while the view is shown and a run row shows, and a hidden view reads once when shown again.
---
 extension/README.md                           |   4 +-
 extension/src/constants.ts                    |  38 +++-
 extension/src/extension.ts                    |  17 +-
 .../describeUnrevealableWikiFolder.test.ts    |  29 ++-
 extension/src/tests/failureKeyOf.test.ts      |  96 ++++++++++
 extension/src/tests/llmWikiView.test.ts       |  58 +++++-
 .../src/tests/llmWikiViewReadLoop.test.ts     | 169 ++++++++++++++++++
 extension/src/tests/systemErrorCode.test.ts   |  28 +++
 extension/src/tests/wikiFolderKindOf.test.ts  |  55 ++++++
 .../utils/describeUnrevealableWikiFolder.ts   |  10 +-
 extension/src/utils/failureKeyOf.ts           |  38 +++-
 extension/src/utils/llmWikiView.ts            | 101 +++++++----
 .../src/utils/registerLlmWikiCommands.ts      |  23 ++-
 extension/src/utils/systemErrorCode.ts        |  12 +-
 extension/src/utils/wikiFolderKindOf.ts       |  70 ++++++--
 15 files changed, 670 insertions(+), 78 deletions(-)
 create mode 100644 extension/src/tests/failureKeyOf.test.ts
 create mode 100644 extension/src/tests/systemErrorCode.test.ts

diff --git a/extension/README.md b/extension/README.md
index e76b6b1a..4345e1b0 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -251,11 +251,11 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - **`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**, 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 on that remote.` 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 its permissions, or change the location.` instead of saying the folder does not exist. 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.
+- **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; 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, 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. 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/src/constants.ts b/extension/src/constants.ts
index 43e3c29c..fb3f4ca2 100644
--- a/extension/src/constants.ts
+++ b/extension/src/constants.ts
@@ -1095,27 +1095,51 @@ export const llmWikiFolderMissingNotice = (outputLabel: string): string =>
 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`, …).
- * @returns `The LLM Wiki folder <label> cannot be read (<code>). Check its permissions, or change the location.`
- * @example llmWikiFolderUnreadableNotice('.codebook/wiki', 'EACCES') // => 'The LLM Wiki folder .codebook/wiki cannot be read (EACCES). Check its permissions, or change the location.'
+ * @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 its permissions, or change the location.`
+  `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 on that remote.` (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 on that remote.'
+ * @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 on that remote.`
+  `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
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index a6b1d769..c7d93644 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -3183,6 +3183,14 @@ 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: wikiHost,
@@ -3256,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() },
@@ -3273,6 +3275,7 @@ export function activate(
         view: llmWikiView,
         cancelRun: cancelWikiRun,
         findWikiLocation: wikiLocation,
+        recordFailure: recordLlmWikiFailure,
       }),
     )
   }
diff --git a/extension/src/tests/describeUnrevealableWikiFolder.test.ts b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
index cb0ce3f6..f760877b 100644
--- a/extension/src/tests/describeUnrevealableWikiFolder.test.ts
+++ b/extension/src/tests/describeUnrevealableWikiFolder.test.ts
@@ -58,7 +58,7 @@ test('Reveal Wiki Folder words a file, a remote host with its next step, and let
   // 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 on that 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.',
     undefined,
   ])
 })
@@ -78,6 +78,31 @@ test('Reveal Wiki Folder words an unreadable path with its error code and a next
   // Assert
   assert.equal(
     result,
-    'The LLM Wiki folder .codebook/wiki cannot be read (EACCES). Check its permissions, or change the location.',
+    '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/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index 008eccd4..4f1bb38c 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -1076,7 +1076,7 @@ test('Reveal Wiki Folder in a remote window says the folder is on the remote hos
     [
       [],
       [
-        '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 on that 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.',
       ],
     ],
   )
@@ -1135,7 +1135,61 @@ test('Reveal Wiki Folder on an unreadable path says it cannot be read with the e
     [
       [],
       [
-        'The LLM Wiki folder .codebook/wiki cannot be read (ENOTDIR). Check its permissions, or change the location.',
+        '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.',
       ],
     ],
   )
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
index 6140fc49..b7e26f8b 100644
--- a/extension/src/tests/llmWikiViewReadLoop.test.ts
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -1193,3 +1193,172 @@ test('an editor that reads the root inside createTreeView still gets the rows an
     [['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/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/wikiFolderKindOf.test.ts b/extension/src/tests/wikiFolderKindOf.test.ts
index 86e9c56f..87206f28 100644
--- a/extension/src/tests/wikiFolderKindOf.test.ts
+++ b/extension/src/tests/wikiFolderKindOf.test.ts
@@ -6,6 +6,11 @@ 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
@@ -32,3 +37,53 @@ test('the Wiki output path is told as a folder, a file, missing, or unreadable w
     { 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/utils/describeUnrevealableWikiFolder.ts b/extension/src/utils/describeUnrevealableWikiFolder.ts
index c1f93244..ad75e0bc 100644
--- a/extension/src/utils/describeUnrevealableWikiFolder.ts
+++ b/extension/src/utils/describeUnrevealableWikiFolder.ts
@@ -1,4 +1,5 @@
 import {
+  llmWikiFolderDanglingLinkNotice,
   llmWikiFolderIsFileNotice,
   llmWikiFolderMissingNotice,
   llmWikiFolderRemoteNotice,
@@ -20,13 +21,14 @@ import type { WikiFolderKind } from './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 path that cannot be read: `The LLM Wiki folder <label> cannot be read (<code>). Check its permissions, 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 on that remote.`
+ * - 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 on that remote.'
+ * 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: {
@@ -39,6 +41,8 @@ export function describeUnrevealableWikiFolder(folder: {
   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.
diff --git a/extension/src/utils/failureKeyOf.ts b/extension/src/utils/failureKeyOf.ts
index 82780110..edf33b1d 100644
--- a/extension/src/utils/failureKeyOf.ts
+++ b/extension/src/utils/failureKeyOf.ts
@@ -1,23 +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.
- * Trigger: the LLM Wiki view ({@link createLlmWikiView}) asks it for each failed read, to record a failure in Output once while it recurs.
+ * 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)
+ * - 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 {
-  if (cause instanceof Error)
-    return `${cause.name}|${systemErrorCode(cause)}|${cause.message}`
-  return inspect(cause)
+  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 9dca7f52..9a7bb093 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -151,8 +151,9 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   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 cause text of the failure recorded while the error row stands; the poll's repeats of it are not recorded again. */
-  let recordedFailureCause: string | undefined
+  /** 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. */
@@ -180,7 +181,12 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
         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.
-        if (isTreeViewCreated && model.message !== appliedMessage) {
+        // After dispose the handle is gone: nothing is written.
+        if (
+          isTreeViewCreated &&
+          !isDisposed &&
+          model.message !== appliedMessage
+        ) {
           appliedMessage = model.message
           treeView.message = model.message
         }
@@ -216,12 +222,17 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
   })
 
   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 it next reads its root children ({@link getChildren} / the provider).
+   * 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.
@@ -401,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.
@@ -413,15 +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 },
       }),
     )
-    // The freshness result is shown: the failure that stood is over.
-    recordedFailureCause = undefined
+    // 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. */
@@ -434,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 {
@@ -534,22 +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
-    // The poll reads again across the error row, so the same failure is recorded once while the row stands; a different failure is recorded too.
-    const causeText = failureKeyOf(cause)
-    if (causeText !== recordedFailureCause) {
-      recordedFailureCause = causeText
-      try {
-        options.recordFailure(
-          'The LLM Wiki view could not read its state',
-          cause,
-        )
-      } catch {
-        // A failure that cannot be recorded has nowhere to be told.
-      }
+  /**
+   * 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(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] })
@@ -564,6 +602,8 @@ 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),
     )
@@ -575,12 +615,8 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
       nextFacts.wiki &&
       next.rows.some((row) => row.id === 'wiki')
     ) {
-      // The failure ends only when the freshness result is shown too (see checkFreshness), so a check that keeps failing is recorded once.
       requestFreshness(nextFacts)
-      return
     }
-    // A model shown without a failure ends it: the next failure is recorded again.
-    recordedFailureCause = undefined
   }
 
   /** One read from the facts to the rows; whatever throws in it shows the error row. */
@@ -616,9 +652,12 @@ export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
     treeView,
     treeView.onDidChangeVisibility((event) => {
       isViewVisible = event.visible
-      // Hidden: no poll. Shown: one read at once (the 1 s debounce is for file events), which restarts the poll and the freshness check.
+      // 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 keepPoll()
+      else {
+        freshnessRequest = undefined
+        keepPoll()
+      }
     }),
     editor.workspace.onDidChangeConfiguration((event) => {
       if (event.affectsConfiguration(WIKI_OUTPUT_DIRECTORY_SETTING))
diff --git a/extension/src/utils/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
index 3063b2b8..ff396f37 100644
--- a/extension/src/utils/registerLlmWikiCommands.ts
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -6,6 +6,7 @@ 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,
@@ -22,6 +23,7 @@ import {
 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'
@@ -48,6 +50,8 @@ export type LlmWikiCommandOptions = {
     projectRoot: string
     outputDirectory: string
   }>
+  /** Writes a failure to Output › Codebook, as the view's own record does. */
+  recordFailure: (message: string, cause: unknown) => void
 }
 
 /**
@@ -102,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, findWikiLocation }))
+ * context.subscriptions.push(...registerLlmWikiCommands({ editor: vscode, registerCommand, showNotice, view, cancelRun, findWikiLocation, recordFailure }))
  */
 export function registerLlmWikiCommands(
   options: LlmWikiCommandOptions,
@@ -122,7 +126,22 @@ export function registerLlmWikiCommands(
       )
     }),
     registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () => {
-      const { projectRoot, outputDirectory } = await options.findWikiLocation()
+      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),
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
index 42fd51ad..b3cd3835 100644
--- a/extension/src/utils/wikiFolderKindOf.ts
+++ b/extension/src/utils/wikiFolderKindOf.ts
@@ -1,4 +1,6 @@
-import { stat } from 'node:fs/promises'
+import { lstat, stat } from 'node:fs/promises'
+
+import { WIKI_FOLDER_STAT_TIMEOUT_MS } from '../constants'
 
 import { systemErrorCode } from './systemErrorCode'
 
@@ -7,20 +9,33 @@ 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 and a path it cannot read apart.
+ * 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 all four, and only `ENOENT` means nothing is there; a permission or path error (`EACCES`, `ENOTDIR`, `ENAMETOOLONG`) must not be told as "does not exist (yet)".
+ * 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`): `{ kind: 'missing' }`
- * - Any other failure of the look: `{ kind: 'unreadable', code }` (`'UNKNOWN'` when the error carries no code)
+ * - 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' }
@@ -28,15 +43,44 @@ export type WikiFolderKind =
  */
 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 stat(folderPath)).isDirectory()
-      ? { kind: 'folder' }
-      : { kind: 'file' }
-  } catch (error) {
-    const code = systemErrorCode(error)
-    // Only a path with nothing at it is a folder that is not there yet.
-    if (code === 'ENOENT') return { kind: 'missing' }
-    return { kind: 'unreadable', code: code || 'UNKNOWN' }
+    return await Promise.race([lookAtPath(), noAnswer])
+  } finally {
+    clearTimeout(timer)
   }
 }

From 7ccdfdd9800ebf601befd4f15f47891e003ba95d Mon Sep 17 00:00:00 2001
From: Ryota Murakami <dojce1048@gmail.com>
Date: Tue, 27 Oct 2026 07:24:09 +0900
Subject: [PATCH 9/9] chore: bump version and changelog (v0.2.48.0)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                             | 25 ++++++++++++++++++++++++
 README.md                                |  2 +-
 VERSION                                  |  2 +-
 extension/package.json                   |  2 +-
 extension/scripts/tests/package.test.mjs |  2 +-
 extension/src/constants.ts               |  2 +-
 6 files changed, 30 insertions(+), 5 deletions(-)

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/package.json b/extension/package.json
index 5af47006..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",
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 fb3f4ca2..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'