diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c907f3de..d3125200b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.2.46.0] - 2026-10-26 (development candidate)
+
+Cycle 0055 ([Issue #132](https://github.com/laststance/codebook/issues/132)), a feature cycle, second of its two pull requests: the LLM Wiki gets its own view in Codebook's Activity Bar, and the Wiki feature area is proven again natively in VS Code and Cursor (trial N55).
+
+**The LLM Wiki view.**
+
+- **An LLM Wiki view in Codebook's Activity Bar**, below the Repository Wiki view (which lists repository articles, not the generated site), shows where the project's generated site stands and the next step. Its rows come and go with the facts they show, in a fixed order; each tooltip has the full text and each action is also in the row's context menu.
+- **In a folder with no Wiki** 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. With no folder open it offers **Open Folder**; in a folder you have not trusted, **Manage Workspace Trust**.
+- **`<folder> Wiki`** opens the published Wiki in the browser. Its description is the reader page's freshness label (`Wiki source current`, `Source changed · Update available`, `Wiki freshness unknown: …`, or `Checking freshness…`), its tooltip names the generation (`Generated from <commit> on <date>`), and **Update LLM Wiki** is its action. When the Wiki records no Git revision, the tooltip says in full that added files are not checked. The row stays while a run works, so you can read the Wiki during an update.
+- **`Generating…` or `Updating…`** shows this window's run with its minutes of the bound: in VS Code `Waiting for the chat to start`, then `In chat · <N> min of <bound>`, with **Stop watching**, **Open Chat** and **Show Output**, and a message that Stop watching does not stop the chat; in Cursor `cursor-agent · <N> min of <bound>` with **Cancel** and **Show Output**. A start time that cannot be read shows no minutes.
+- **`Generating in another window`**, **`Updating in another window`** and **`Waiting for chat`** show a run of another window and the reservation a stopped VS Code watch leaves (`retry after <time>`, with **Open Chat**; the message above the tree says that Codebook stopped watching and the chat may still publish). Once the retry time has passed the reservation row is gone and Generate or Update is available again, whether or not the recorded process still exists. A Wiki the chat publishes meanwhile shows at once, with the notice `An LLM Wiki was published in <folder>.` and **Open in Browser**.
+- **`Last generation stopped`** says how this window's generation ended without a Wiki; a click shows the full sentence with **Copy details** (your home folder as `~`), and **Try again** starts a new one.
+- **Attention rows** name what blocks an update or makes the manifest unusable: `Publish in progress or stopped` and `Wiki manifest needs recovery` offer **Copy recovery request** (a chat request, never a shell command), `Wiki folder belongs elsewhere` offers **Change location**, and `Wiki files changed by hand` offers **Reveal Wiki Folder**.
+- **`Output: <folder>`** shows the resolved folder with **Change location**. A read that fails shows `Could not read the LLM Wiki state` with **Refresh to retry**.
+- **The view follows changes by itself:** this window's run, the Wiki's manifest and the marker files beside it (watched one second after the last change, the Wiki folder itself included, so deleting or renaming it is seen), the output setting, workspace trust, the view becoming visible, every 30 seconds while a run row shows, and **Refresh** in its title bar. The watch never stands above the project folder, on the home folder or on a file-system root; an output outside the project is watched only when its own parent exists. Without a watch the view refreshes when shown and with **Refresh**, and the Output row's tooltip says so.
+- **Codebook: Refresh LLM Wiki**, **Codebook: Copy LLM Wiki Recovery Request** and **Codebook: Reveal LLM Wiki Folder** are listed in the Command Palette in an editor that shows the view.
+
+**Changed.**
+
+- **Codebook's learning view container has its own Activity Bar icon** (an open notebook with a check mark), so the two Codebook icons are told apart.
+- **The browser reader's freshness label and the view's row share one wording**, so both say the same.
+
+**Proven natively (N55, development target `nextjs-dashboard`, both hosts).** From the empty view, Generate published a Wiki in 32 min 05 s (VS Code, Copilot Chat, GPT-6 Luna) and 4 min 27 s (Cursor, `cursor-agent`, Grok 4.6 High Fast); the reader matched the specification's region 3; 6 of 6 sampled claims per host were correct against the source; a question's citation opened the right file and line in the same editor; **?** opened the shortcut list; an update after a source edit stated the new value; Stop watching and Cancel left the states this entry describes. Saved replays were unchanged.
+
+**Compatibility.** The MCP API stays 1.8, the Wiki's published format and the stored learner data do not change, and the bundled skill stays 1.0.49.
+
 ## [0.2.45.0] - 2026-10-26 (development candidate)
 
 Cycle 0055 ([Issue #132](https://github.com/laststance/codebook/issues/132)), a feature cycle, first of its two pull requests: Codebook generates a project's first LLM Wiki from its own commands. The LLM Wiki view in the Activity Bar and the native trial follow in the second.
diff --git a/README.md b/README.md
index a3c03f0c5..1aea92701 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.45.0** once the first pull request of [Cycle 0055](https://github.com/laststance/codebook/issues/132) is merged; until then 0.2.44.0 ([PR #131](https://github.com/laststance/codebook/pull/131) of Cycle 0054) is the delivered one, and the active cycle Issue says where the delivery stands. [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.46.0** once the second pull request of [Cycle 0055](https://github.com/laststance/codebook/issues/132) is merged; until then 0.2.45.0 ([PR #133](https://github.com/laststance/codebook/pull/133), the cycle's first pull request) is the delivered one, and the active cycle Issue says where the delivery stands. [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 0650c3b49..4a193462e 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.2.45.0
+0.2.46.0
diff --git a/extension/README.md b/extension/README.md
index c3f68597d..8861f399e 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -150,7 +150,7 @@ A test runs the way its package's own `vitest` command would: in its **Vitest ro
 The **LLM Wiki** is the browser site your editor's AI writes for the whole repository: overview, architecture and module chapters with diagrams, citations into your editor and repository questions. It is not the **Repository Wiki** view in Codebook's Activity Bar, which lists repository articles an MCP agent wrote ([Learn this repository](#learn-this-repository)). No runtime MCP connection, debugger or running application is needed.
 
 1. Prerequisites. VS Code: Copilot Chat enabled and signed in. Cursor: the `cursor-agent` CLI installed and signed in (`cursor-agent --version` answers; Codebook looks for `~/.local/bin/cursor-agent`, then `cursor-agent` on the editor's PATH).
-2. Open the project folder and run **Codebook: Generate LLM Wiki** from the Command Palette, or press **Generate LLM Wiki** in the notice **Open LLM Wiki in Browser** or **Update LLM Wiki** shows in a folder without a Wiki (`Codebook found no LLM Wiki in <folder>.`).
+2. Open the project folder and press **Generate LLM Wiki** in the **LLM Wiki** view of Codebook's Activity Bar, run **Codebook: Generate LLM Wiki** from the Command Palette, or press **Generate LLM Wiki** in the notice **Open LLM Wiki in Browser** or **Update LLM Wiki** shows in a folder without a Wiki (`Codebook found no LLM Wiki in <folder>.`).
 3. Confirm. The confirmation names the folder the Wiki is written to and where the request goes. **Change location** opens the `codebook.wikiOutputDirectory` setting and starts nothing; dismissing it starts nothing either.
 4. Wait for `LLM Wiki generated in <folder>.` and press **Open in Browser**. Codebook waits up to 55 minutes.
 
@@ -184,25 +184,25 @@ 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.
 
-| 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.                                                                                                                                                                                                                                                                                             |
-| No update started.                                      | Two minutes passed and no run began.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Confirm in the editor, or press the button again.                                                                                                                                                                                                                                                                  |
-| Updating LLM Wiki…                                      | VS Code: the request went to a new chat. Codebook waits up to 30 seconds for the first sign that the chat works on it (its reply or its wait for a confirmation, a file of the Wiki or of the Codebook skill that it opens, the publisher it runs in a terminal, or a folder the publisher prepares beside the Wiki) and then watches the output folder for up to 15 minutes. The watch ends when the new Wiki is published, when a file of your own in the Wiki folder is in the way of the publish (**Update stopped**), when a new site is on disk whose manifest Codebook still cannot read 10 seconds after it appeared, when the chat's reply ends before the chat asked you to approve a step, when you press **Stop watching** in the status bar, or after those 15 minutes. Cursor: Cursor Agent is running, for up to 15 minutes. The button reads **Updating…** and is held back.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | VS Code: follow the chat and approve its steps. If you refuse a step, press **Stop watching** in the status bar: once the chat has asked you, Codebook does not see it stop, and would watch for the 15 minutes. Cursor: cancel from the notification if you need to.                                                         |
-| Updated at …                                            | A new site was published and matches the source.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Press **Reload to read the new pages** when the page offers it.                                                                                                                                                                                                                                                    |
-| Already current                                         | The Wiki already matched the source, so no run started. In a folder without a Git repository only the indexed sources are compared, and the sentence says that added files are not checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Nothing.                                                                                                                                                                                                                                                                                                           |
+| 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.                                                                                                                                                                                                                                                                                             |
+| No update started.                                      | Two minutes passed and no run began.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Confirm in the editor, or press the button again.                                                                                                                                                                                                                                                                  |
+| Updating LLM Wiki…                                      | VS Code: the request went to a new chat. Codebook waits up to 30 seconds for the first sign that the chat works on it (its reply or its wait for a confirmation, a file of the Wiki or of the Codebook skill that it opens, the publisher it runs in a terminal, or a folder the publisher prepares beside the Wiki) and then watches the output folder for up to 15 minutes. The watch ends when the new Wiki is published, when a file of your own in the Wiki folder is in the way of the publish (**Update stopped**), when a new site is on disk whose manifest Codebook still cannot read 10 seconds after it appeared, when the chat's reply ends before the chat asked you to approve a step, when you press **Stop watching** in the status bar, or after those 15 minutes. Cursor: Cursor Agent is running, for up to 15 minutes. The button reads **Updating…** and is held back.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | VS Code: follow the chat and approve its steps. If you refuse a step, press **Stop watching** in the status bar: once the chat has asked you, Codebook does not see it stop, and would watch for the 15 minutes. Cursor: cancel from the notification if you need to.                                              |
+| Updated at …                                            | A new site was published and matches the source.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Press **Reload to read the new pages** when the page offers it.                                                                                                                                                                                                                                                    |
+| Already current                                         | The Wiki already matched the source, so no run started. In a folder without a Git repository only the indexed sources are compared, and the sentence says that added files are not checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Nothing.                                                                                                                                                                                                                                                                                                           |
 | Update failed                                           | The run ended without a new site, or it was not started. In VS Code an update without such a sign within 30 seconds ends with `Codebook saw no sign of the update in the editor chat within 30 seconds and left its request in the chat without running any chat command on it, so the request may still be there. Stop or remove it in the Chat view, check that Copilot Chat is enabled and signed in, then retry, with Update anyway if Codebook still waits for that chat.` A chat that answers the request with an error ends it at once with `The editor chat answered the update request with an error and stopped (…). Read its message in the Chat view, then press Update LLM Wiki again.`, the chat's message in the brackets; a chat that finishes its reply without publishing ends it with `The editor chat finished its reply without publishing a new Wiki. Read its reply in the Chat view, then press Update LLM Wiki again.` The sentence then says what became of the site: `Nothing had been replaced by then.` where the chat can still publish after that end (the request Codebook left in the chat after the 30 seconds, a watch of Codebook's that broke off with an error), and `The last usable site is kept.` where it cannot, as after the chat's error or its finished reply. Where no Wiki is there to keep, it names no kept site: in a folder that has no Wiki yet it says `Codebook found no LLM Wiki in <folder>.` and offers **Generate LLM Wiki**, and where a publish that did not finish left no Wiki it names the recovery. | Follow the sentence, then update again.                                                                                                                                                                                                                                                                            |
-| Update failed, and the sentence names **Update anyway** | An earlier chat may still be updating this Wiki, so no agent was asked: the VS Code chat of this window or of another window after its watch stopped or after a request Codebook left in the chat, or a candidate folder written within the last 15 minutes. The sentence names the time Codebook waits until. The wait for a chat whose watch stopped ends earlier when that chat publishes: once a site was published after the watch stopped, the next update starts without this sentence (in the window that watched only when the candidate folder its watch saw is gone too).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Wait until that time, or, if that chat was stopped, press **Update anyway** in the editor's notification. It starts the update past what that notification named; anything else in the way gets a new notification of its own. Another window's running update offers no **Update anyway**: wait for it to finish. |
-| Update needs another run                                | A new site was published, but it does not match the source (for example a file changed while the agent worked).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Follow the sentence; usually press the button again.                                                                                                                                                                                                                                                               |
-| Stopped watching (VS Code)                              | You cancelled: only Codebook's watch stopped. The chat may still be working and can still publish.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Stop the chat itself to cancel the update. If it has already stopped (you refused a step), press **Update anyway** when you update again.                                                                                                                                                                          |
-| Update cancelled (Cursor)                               | Cursor Agent was stopped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Update again when ready.                                                                                                                                                                                                                                                                                           |
-| No new site appeared (VS Code)                          | Nothing was published within 15 minutes, so Codebook stopped watching; nothing had been replaced by then. The chat was not stopped with the watch: it may still be working and can still publish, and the page says when it has (**A new site was published**).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Check the chat. If it waits for you, answer it. If it is still working, let it finish. If it stopped or reported a problem, update again, then press **Update anyway** in the editor's notification if Codebook still waits for that chat.                                                                         |
-| Update timed out (Cursor)                               | Cursor Agent did not finish within 15 minutes and was stopped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Update again.                                                                                                                                                                                                                                                                                                      |
-| Update stopped                                          | The new site would overwrite a file of your own in the Wiki folder. In VS Code only Codebook's watch stopped: the chat that prepared the site was not stopped and can still publish once the file is out of the way.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Move or rename the file. Cursor: update again. VS Code: answer the chat if it waits for you, or stop it. To start again, update again and press **Update anyway** if Codebook still waits for that chat.                                                                                                           |
-| Update not started                                      | A generated page or the Wiki's manifest was changed by hand, a publish of this Wiki holds its publish lock (it may still be running, or it was stopped), an earlier publish did not finish, or the Wiki folder, or a folder on its path inside the project, is a link or a file, which the publisher refuses. No agent ran.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Follow the sentence, then update again.                                                                                                                                                                                                                                                                            |
-| A new site was published                                | After a run that ended without success, a later publish replaced the site on disk. The sentence says that it matches the source, or points to the freshness label when it does not or cannot be checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Press **Reload to read the new pages** when the page offers it.                                                                                                                                                                                                                                                    |
-| Lost contact with the editor                            | The editor window that served the page closed or reloaded. The pages you are reading are unchanged.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Run **Codebook: Open LLM Wiki in Browser** again.                                                                                                                                                                                                                                                                  |
-| Update status unknown                                   | The editor answered a state this page does not know.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Reopen the Wiki from the editor.                                                                                                                                                                                                                                                                                   |
+| Update failed, and the sentence names **Update anyway** | An earlier chat may still be updating this Wiki, so no agent was asked: the VS Code chat of this window or of another window after its watch stopped or after a request Codebook left in the chat, or a candidate folder written within the last 15 minutes. The sentence names the time Codebook waits until. The wait for a chat whose watch stopped ends earlier when that chat publishes: once a site was published after the watch stopped, the next update starts without this sentence (in the window that watched only when the candidate folder its watch saw is gone too).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Wait until that time, or, if that chat was stopped, press **Update anyway** in the editor's notification. It starts the update past what that notification named; anything else in the way gets a new notification of its own. Another window's running update offers no **Update anyway**: wait for it to finish. |
+| Update needs another run                                | A new site was published, but it does not match the source (for example a file changed while the agent worked).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Follow the sentence; usually press the button again.                                                                                                                                                                                                                                                               |
+| Stopped watching (VS Code)                              | You cancelled: only Codebook's watch stopped. The chat may still be working and can still publish.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Stop the chat itself to cancel the update. If it has already stopped (you refused a step), press **Update anyway** when you update again.                                                                                                                                                                          |
+| Update cancelled (Cursor)                               | Cursor Agent was stopped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Update again when ready.                                                                                                                                                                                                                                                                                           |
+| No new site appeared (VS Code)                          | Nothing was published within 15 minutes, so Codebook stopped watching; nothing had been replaced by then. The chat was not stopped with the watch: it may still be working and can still publish, and the page says when it has (**A new site was published**).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Check the chat. If it waits for you, answer it. If it is still working, let it finish. If it stopped or reported a problem, update again, then press **Update anyway** in the editor's notification if Codebook still waits for that chat.                                                                         |
+| Update timed out (Cursor)                               | Cursor Agent did not finish within 15 minutes and was stopped.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | Update again.                                                                                                                                                                                                                                                                                                      |
+| Update stopped                                          | The new site would overwrite a file of your own in the Wiki folder. In VS Code only Codebook's watch stopped: the chat that prepared the site was not stopped and can still publish once the file is out of the way.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Move or rename the file. Cursor: update again. VS Code: answer the chat if it waits for you, or stop it. To start again, update again and press **Update anyway** if Codebook still waits for that chat.                                                                                                           |
+| Update not started                                      | A generated page or the Wiki's manifest was changed by hand, a publish of this Wiki holds its publish lock (it may still be running, or it was stopped), an earlier publish did not finish, or the Wiki folder, or a folder on its path inside the project, is a link or a file, which the publisher refuses. No agent ran.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Follow the sentence, then update again.                                                                                                                                                                                                                                                                            |
+| A new site was published                                | After a run that ended without success, a later publish replaced the site on disk. The sentence says that it matches the source, or points to the freshness label when it does not or cannot be checked.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Press **Reload to read the new pages** when the page offers it.                                                                                                                                                                                                                                                    |
+| Lost contact with the editor                            | The editor window that served the page closed or reloaded. The pages you are reading are unchanged.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Run **Codebook: Open LLM Wiki in Browser** again.                                                                                                                                                                                                                                                                  |
+| Update status unknown                                   | The editor answered a state this page does not know.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Reopen the Wiki from the editor.                                                                                                                                                                                                                                                                                   |
 
 In VS Code the update's request does not go into the chat you are using, with the one exception named below: Codebook reveals the chat, runs the editor's **New Chat** and sends the request into that new chat, so a request of yours that is in progress, waits for a confirmation or is queued is neither stopped nor held back, and the update does not wait behind it. Your chat is not closed: with a request in progress or waiting for a confirmation it goes on in the background, and you return to it from the Chat view's session list (its chat history). The update asks nothing about edits of that chat you have not decided on yet: they stay pending in their chat, with Keep and Undo, and the **Suggested Edits** editor that shows them stays open. Two limits, the first of them that exception. When the Chat view has not been opened in the window yet, it may still be restoring your last chat while New Chat runs: New Chat then does nothing, and the request goes into that restored chat; the confirmation names this case. When the chat you focused last is a chat in an editor tab, the new chat starts in that tab, and the chat that was shown there keeps its place in the chat list. When Codebook sees no sign within those 30 seconds, it leaves its request in the chat and runs none of the chat's commands: the chat's Cancel and its Remove All Queued act on the chat you focused last and on the session it shows, and the editor tells Codebook neither which session that is nor which request is its own, so they could stop or remove a request of yours instead. Your own work elsewhere in the window (a file you open, a command you run) is not taken for a sign. What the update's own steps touch counts whoever does it, because Codebook cannot tell you from the chat there: a file opened in the Wiki's folder, in a folder prepared beside it or in the Codebook skill's folder, a terminal command that names `publish-wiki.mjs` or the Wiki's folder, and a change in the Wiki's folder or in a folder prepared beside it. When the chat's command has not returned by then, the sentence reads `Codebook saw no sign of the update in the editor chat within 30 seconds and left its request in the chat without running any chat command on it, so the request may still be there. Stop or remove it in the Chat view, check that Copilot Chat is enabled and signed in, then retry, with Update anyway if Codebook still waits for that chat.` Codebook then waits for that chat as it does after a stopped watch, for 15 minutes: a retry in that time is answered with the wait and **Update anyway**, not with a second request beside the first. If the chat's command had returned without the chat taking a request, the sentence reads `Codebook saw no sign of the update in the editor chat within 30 seconds and the chat holds no request of it, so no update is running. Check that Copilot Chat is enabled and signed in, then retry.` Every supported VS Code (1.120 and later) has New Chat. An editor without that command, and one in which the reveal of the chat or New Chat fails or does not return within 5 seconds, gets the request in the chat that is open, where it acts like a message you typed: it waits in the queue behind a request in progress, the editor cancels a request that waits for a confirmation, and a draft in the chat's input is replaced. The confirmation says so before the press where the editor lacks the command; where the reveal or New Chat failed, nothing says so before, and the Chat view shows the request in the chat that was open. At the 30 seconds Codebook leaves its request in that chat as well, also where it waits in the queue, and removes none of yours.
 
@@ -238,6 +238,23 @@ A stopped VS Code watch's reservation describes a chat that can still publish. I
 
 For tools: `GET <reader>/api/update-status` answers the current state as JSON (`Cache-Control: no-store`). `state` is one of `idle`, `running`, `succeeded`, `already-current`, `failed`, `cancelled`, `timed-out` or `conflict`; only `running` is not final. An `already-current` answer carries `addedFilesUnchecked: true` when the folder has no Git repository, so only the indexed sources were compared. Any other method answers `405` with `Allow: GET`.
 
+### The LLM Wiki view
+
+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.
+- **`<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 in another window`** or **`Updating in another window`** shows a run of another editor window on the same folder, with its start time.
+- **`Waiting for chat`** shows the reservation a stopped VS Code watch leaves, from any window: `retry after <time> (about <N> min)`. **Open Chat** opens the chat view, where the session is in the chat history; Codebook allows a new start after that time even if the chat stopped earlier. In VS Code the message above the tree then says that Codebook stopped watching the chat, which may still publish this Wiki, and that you stop the request in the chat. Once that time has passed the row is gone, so **Generate LLM Wiki** or **Update LLM Wiki** is available again whether or not the recorded process still exists. A Wiki the chat publishes meanwhile ends the wait: the Wiki row shows at once and the notice `An LLM Wiki was published in <folder>.` offers **Open in Browser**.
+- **`Last generation stopped`** shows how this window's generation ended without a Wiki (`stopped watching`, `cancelled`, `stopped after 55 minutes`, `no Wiki published`, `agent exit <code>`). A click shows the full sentence with **Copy details** (your home folder shown as `~`); **Try again** starts a new generation. It goes away when a Wiki is published or a new run starts.
+- **Attention rows** name what blocks an update or makes the manifest unusable, with the cause as the description; a click shows the sentence the reader page shows for it. **`Publish in progress or stopped`** (a publish lock or an unfinished publish) and **`Wiki manifest needs recovery`** (the manifest was edited or cannot be read) offer **Copy recovery request**, which copies `/codebook Recover the unfinished LLM Wiki publish for this project` for the editor chat; Codebook copies no shell command. **`Wiki folder belongs elsewhere`** (the output is a file or a link, a folder on its path is a link, or the manifest names another checkout) offers **Change location**. **`Wiki files changed by hand`** (a generated page was edited or is missing, or the folder holds a link or special file) offers **Reveal Wiki Folder**. An unreadable manifest, an edited manifest, a link or a file in the folder's place hides the Wiki row; the other causes leave the Wiki readable. **Refresh** reads the state again.
+- **`Output: <folder>`** shows the resolved folder with **Change location** (the `codebook.wikiOutputDirectory` setting) whenever another row shows. A folder outside the project shows its absolute path.
+- 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, 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.
+
 ### Troubleshooting the LLM Wiki
 
 Each entry is a sentence Codebook shows when a generation ends or does not start, with what was kept and the next step.
@@ -499,7 +516,7 @@ A slow start does not fail a replay. Loading a recording and starting or retirin
 
 **Open replay** pressed while another window has the desktop focus waits up to 10 seconds for the Codebook work window to gain the focus and then opens the Learning summary. When the focus does not come, the replay is refused with `Focus the Codebook work window before reading the learning summary: another window kept the desktop focus for 10 s. Click in this editor window, then choose Open replay again.`, and the status bar's **Open replay** shows that reason as a notification (`Codebook could not open the learning replay: …`) and writes it to **Output › Codebook** as one `open:recording` entry with the study, the profile and the cause. A browser replay whose open fails for any other cause (its recording could not load, for example) also writes one `open:recording` entry beside the load-failure notification, so you can copy the cause into a report.
 
-The Learning summary has its own icon in the Activity Bar in both editors, because Cursor rejects the secondary side bar container an extension contributes. In Cursor it opens in the primary side bar. In VS Code, the first time you open a replay yourself in a profile (never an agent's open), Codebook moves the summary once into the Chat container on the right with VS Code's internal `vscode.moveViews` command; a place you choose afterwards is never changed back, and if the command is refused or missing the summary stays in the Activity Bar and Output › Codebook says so. Nothing is offered in VS Code. Once per editor session, until you have taken the step in that workspace, Cursor shows the notification `Cursor opens the Codebook Learning summary in its primary side bar. To keep it on the right, move it once: choose "New Secondary Side Bar Entry" in the list that opens.` with the button **Move Learning Summary…**. Cursor removes an unanswered notification by itself, so the same step stays within reach as the title action **Codebook: Move Learning Summary…** of the Learning summary view and under that name in Cursor's Command Palette. Each opens the editor's own Move View list for the summary. When **Show Variables** opens Run and Debug in the side bar the summary shares, the offer reads `Run and Debug took the Learning summary's place in Cursor's side bar. Move the summary to the right once to keep both in view.`, with the same button, at most once per editor session.
+The Learning summary has its own icon in the Activity Bar in both editors (an open notebook with a check mark, unlike the book of Codebook's own container, so the two are told apart), because Cursor rejects the secondary side bar container an extension contributes. In Cursor it opens in the primary side bar. In VS Code, the first time you open a replay yourself in a profile (never an agent's open), Codebook moves the summary once into the Chat container on the right with VS Code's internal `vscode.moveViews` command; a place you choose afterwards is never changed back, and if the command is refused or missing the summary stays in the Activity Bar and Output › Codebook says so. Nothing is offered in VS Code. Once per editor session, until you have taken the step in that workspace, Cursor shows the notification `Cursor opens the Codebook Learning summary in its primary side bar. To keep it on the right, move it once: choose "New Secondary Side Bar Entry" in the list that opens.` with the button **Move Learning Summary…**. Cursor removes an unanswered notification by itself, so the same step stays within reach as the title action **Codebook: Move Learning Summary…** of the Learning summary view and under that name in Cursor's Command Palette. Each opens the editor's own Move View list for the summary. When **Show Variables** opens Run and Debug in the side bar the summary shares, the offer reads `Run and Debug took the Learning summary's place in Cursor's side bar. Move the summary to the right once to keep both in view.`, with the same button, at most once per editor session.
 
 **Hiding and showing the Learning summary.** During a replay of either family, the bottom panel's transport ends its status row with a **Learning summary** button (its tooltip and accessible name: `Show learning summary`). When you have hidden or collapsed the summary, or closed its container, the button shows it again; when it is shown, the button brings the keyboard to it. Hiding and showing it keep the selected moment, the replay debugger's frame and the summary's scroll position, a paused replay stays where it is and a playing one goes on playing; the keyboard returns to the control the summary last held, or, when that control is gone, to the moment's step heading or the summary's title. **Codebook: Show Learning Summary** in the Command Palette and the summary's own Activity Bar container do the same, also while the bottom panel is hidden. In VS Code the summary shares the Chat container on the right: collapse the Chat section by its header to give the summary the whole side bar, and the same click expands the Chat again. In Cursor, take the Move View step described above once, so the summary stands on the right with the Agent chat one tab away. The editor's own view commands still move or hide either view as you like. A development build of Cycle 0051 was checked by hand in VS Code 1.142.0 and Cursor 3.27.12 (hiding the side bar and pressing the button kept the moment and the reading position in VS Code; the button showed the summary in Cursor's side bar); the recorded native round of this release (N51: its VSIX, requests and take SHA-256 values) is in [Issue #122](https://github.com/laststance/codebook/issues/122), and its recordings stay in private storage.
 
diff --git a/extension/package.json b/extension/package.json
index 5b2898c55..79b6fa176 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.45",
+  "version": "0.2.46",
   "private": true,
   "engines": {
     "vscode": "^1.120.0",
@@ -168,11 +168,15 @@
       },
       {
         "command": "codebook.generateDeepWiki",
-        "title": "Codebook: Generate LLM Wiki"
+        "title": "Codebook: Generate LLM Wiki",
+        "shortTitle": "Try again",
+        "icon": "$(play)"
       },
       {
         "command": "codebook.updateDeepWiki",
-        "title": "Codebook: Update LLM Wiki"
+        "title": "Codebook: Update LLM Wiki",
+        "shortTitle": "Update LLM Wiki",
+        "icon": "$(cloud-download)"
       },
       {
         "command": "codebook.cancelWikiRun",
@@ -180,7 +184,9 @@
       },
       {
         "command": "codebook.showWikiOutput",
-        "title": "Codebook: Show LLM Wiki Output"
+        "title": "Codebook: Show LLM Wiki Output",
+        "shortTitle": "Show Output",
+        "icon": "$(output)"
       },
       {
         "command": "codebook.closeRepositoryWiki",
@@ -203,6 +209,58 @@
         "command": "codebook.moveLearningSummary",
         "title": "Codebook: Move Learning Summary…",
         "icon": "$(move)"
+      },
+      {
+        "command": "codebook.refreshLlmWiki",
+        "title": "Codebook: Refresh LLM Wiki",
+        "shortTitle": "Refresh",
+        "icon": "$(refresh)"
+      },
+      {
+        "command": "codebook.showLlmWikiAttention",
+        "title": "Codebook: Show LLM Wiki Details"
+      },
+      {
+        "command": "codebook.copyWikiRecoveryRequest",
+        "title": "Codebook: Copy LLM Wiki Recovery Request",
+        "shortTitle": "Copy recovery request",
+        "icon": "$(copy)"
+      },
+      {
+        "command": "codebook.revealWikiFolder",
+        "title": "Codebook: Reveal LLM Wiki Folder",
+        "shortTitle": "Reveal Wiki Folder",
+        "icon": "$(folder-opened)"
+      },
+      {
+        "command": "codebook.llmWiki.stopWatching",
+        "title": "Stop watching",
+        "icon": "$(debug-stop)"
+      },
+      {
+        "command": "codebook.llmWiki.cancelRun",
+        "title": "Cancel",
+        "icon": "$(debug-stop)"
+      },
+      {
+        "command": "codebook.llmWiki.openChat",
+        "title": "Open Chat",
+        "icon": "$(comment-discussion)"
+      },
+      {
+        "command": "codebook.llmWiki.changeLocation",
+        "title": "Change location",
+        "icon": "$(edit)"
+      },
+      {
+        "command": "codebook.llmWiki.openFolder",
+        "title": "Open Folder",
+        "icon": "$(folder-opened)"
+      },
+      {
+        "command": "codebook.llmWiki.manageTrust",
+        "title": "Manage Workspace Trust",
+        "icon": "$(shield)"
       }
     ],
     "configuration": {
@@ -246,7 +304,7 @@
         {
           "id": "codebookLearning",
           "title": "Learning summary",
-          "icon": "src/assets/book.svg"
+          "icon": "src/assets/learning.svg"
         }
       ],
       "panel": [
@@ -263,6 +321,10 @@
           "id": "codebook.repositoryWiki",
           "name": "Repository Wiki"
         },
+        {
+          "id": "codebook.llmWiki",
+          "name": "LLM Wiki"
+        },
         {
           "id": "codebook.learningOutline",
           "name": "Learning outline"
@@ -284,6 +346,16 @@
       ]
     },
     "viewsWelcome": [
+      {
+        "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)"
+      },
+      {
+        "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)"
+      },
       {
         "view": "codebook.learningOutline",
         "contents": "Connect the application screen with its actual code.\n[Open Study workspace](command:codebook.openStudyWorkspace)"
@@ -300,12 +372,179 @@
           "command": "codebook.moveLearningSummary",
           "when": "view == codebook.learningSummary && codebook.learningSummaryMovable",
           "group": "navigation"
+        },
+        {
+          "command": "codebook.refreshLlmWiki",
+          "when": "view == codebook.llmWiki",
+          "group": "navigation"
         }
       ],
       "commandPalette": [
         {
           "command": "codebook.moveLearningSummary",
           "when": "codebook.learningSummaryMovable"
+        },
+        {
+          "command": "codebook.refreshLlmWiki",
+          "when": "codebook.llmWiki.state"
+        },
+        {
+          "command": "codebook.copyWikiRecoveryRequest",
+          "when": "codebook.llmWiki.state"
+        },
+        {
+          "command": "codebook.revealWikiFolder",
+          "when": "codebook.llmWiki.state"
+        },
+        {
+          "command": "codebook.showLlmWikiAttention",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.stopWatching",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.cancelRun",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.openChat",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.changeLocation",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.openFolder",
+          "when": "false"
+        },
+        {
+          "command": "codebook.llmWiki.manageTrust",
+          "when": "false"
+        }
+      ],
+      "view/item/context": [
+        {
+          "command": "codebook.updateDeepWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[update\\]/",
+          "group": "inline@0"
+        },
+        {
+          "command": "codebook.updateDeepWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[update\\]/",
+          "group": "llmWiki@0"
+        },
+        {
+          "command": "codebook.llmWiki.stopWatching",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[stop-watching\\]/",
+          "group": "inline@1"
+        },
+        {
+          "command": "codebook.llmWiki.stopWatching",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[stop-watching\\]/",
+          "group": "llmWiki@1"
+        },
+        {
+          "command": "codebook.llmWiki.cancelRun",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[cancel-run\\]/",
+          "group": "inline@2"
+        },
+        {
+          "command": "codebook.llmWiki.cancelRun",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[cancel-run\\]/",
+          "group": "llmWiki@2"
+        },
+        {
+          "command": "codebook.llmWiki.openChat",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[open-chat\\]/",
+          "group": "inline@3"
+        },
+        {
+          "command": "codebook.llmWiki.openChat",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[open-chat\\]/",
+          "group": "llmWiki@3"
+        },
+        {
+          "command": "codebook.showWikiOutput",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[show-output\\]/",
+          "group": "inline@4"
+        },
+        {
+          "command": "codebook.showWikiOutput",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[show-output\\]/",
+          "group": "llmWiki@4"
+        },
+        {
+          "command": "codebook.generateDeepWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[try-again\\]/",
+          "group": "inline@5"
+        },
+        {
+          "command": "codebook.generateDeepWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[try-again\\]/",
+          "group": "llmWiki@5"
+        },
+        {
+          "command": "codebook.llmWiki.changeLocation",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[change-location\\]/",
+          "group": "inline@6"
+        },
+        {
+          "command": "codebook.llmWiki.changeLocation",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[change-location\\]/",
+          "group": "llmWiki@6"
+        },
+        {
+          "command": "codebook.copyWikiRecoveryRequest",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[copy-recovery\\]/",
+          "group": "inline@7"
+        },
+        {
+          "command": "codebook.copyWikiRecoveryRequest",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[copy-recovery\\]/",
+          "group": "llmWiki@7"
+        },
+        {
+          "command": "codebook.revealWikiFolder",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[reveal-folder\\]/",
+          "group": "inline@8"
+        },
+        {
+          "command": "codebook.revealWikiFolder",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[reveal-folder\\]/",
+          "group": "llmWiki@8"
+        },
+        {
+          "command": "codebook.refreshLlmWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[refresh\\]/",
+          "group": "inline@9"
+        },
+        {
+          "command": "codebook.refreshLlmWiki",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[refresh\\]/",
+          "group": "llmWiki@9"
+        },
+        {
+          "command": "codebook.llmWiki.openFolder",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[open-folder\\]/",
+          "group": "inline@10"
+        },
+        {
+          "command": "codebook.llmWiki.openFolder",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[open-folder\\]/",
+          "group": "llmWiki@10"
+        },
+        {
+          "command": "codebook.llmWiki.manageTrust",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[manage-trust\\]/",
+          "group": "inline@11"
+        },
+        {
+          "command": "codebook.llmWiki.manageTrust",
+          "when": "view == codebook.llmWiki && viewItem =~ /\\[manage-trust\\]/",
+          "group": "llmWiki@11"
         }
       ]
     }
diff --git a/extension/scripts/tests/package.test.mjs b/extension/scripts/tests/package.test.mjs
index 906d14df5..b96930792 100644
--- a/extension/scripts/tests/package.test.mjs
+++ b/extension/scripts/tests/package.test.mjs
@@ -95,9 +95,9 @@ 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.45')
+  assert.equal(checked.extension.version, '0.2.46')
   assert.equal(checked.extension.apiVersion, '1.8')
-  assert.equal(checked.entries, 32)
+  assert.equal(checked.entries, 33)
   assert.equal(receipt.dependencies.length, 16)
   assert.deepEqual(
     original.get('extension/skills/codebook/SKILL.md'),
@@ -177,6 +177,30 @@ test('a real VSIX loads outside the checkout and excludes bundled applications a
     original.get('extension/src/assets/book.svg'),
     await readFile(join(repository, 'extension/src/assets/book.svg')),
   )
+  assert.deepEqual(
+    original.get('extension/src/assets/learning.svg'),
+    await readFile(join(repository, 'extension/src/assets/learning.svg')),
+  )
+})
+
+test('the packaged manifest gives the two Activity Bar containers different icon files, both shipped', () => {
+  // Arrange
+  const manifest = JSON.parse(original.get('extension/package.json'))
+
+  // Act
+  const icons = Object.fromEntries(
+    manifest.contributes.viewsContainers.activitybar.map((container) => [
+      container.id,
+      container.icon,
+    ]),
+  )
+
+  // Assert
+  assert.deepEqual(icons, {
+    codebook: 'src/assets/book.svg',
+    codebookLearning: 'src/assets/learning.svg',
+  })
+  assert.ok(original.has('extension/src/assets/learning.svg'))
 })
 
 test('a coherent SHA-256 Git revision survives real archive checking', async () => {
@@ -340,6 +364,7 @@ for (const method of ['openPromise', 'fromBufferPromise']) {
 for (const file of [
   'dist/extension.js',
   'src/assets/book.svg',
+  'src/assets/learning.svg',
   'skills/codebook/SKILL.md',
 ]) {
   test(`a VSIX missing ${file} is rejected before installation`, async () => {
diff --git a/extension/scripts/utils/verifyPackageContent.mjs b/extension/scripts/utils/verifyPackageContent.mjs
index a31fa4034..fc02ad3c9 100644
--- a/extension/scripts/utils/verifyPackageContent.mjs
+++ b/extension/scripts/utils/verifyPackageContent.mjs
@@ -14,6 +14,7 @@ export const REQUIRED_PACKAGE_FILES = [
   'dist/wikiPageWorker.js',
   'dist/build.json',
   'src/assets/book.svg',
+  'src/assets/learning.svg',
   'skills/codebook/SKILL.md',
   'skills/codebook/publish-wiki.mjs',
   'skills/codebook/render-wiki.mjs',
diff --git a/extension/src/assets/learning.svg b/extension/src/assets/learning.svg
new file mode 100644
index 000000000..7ff169649
--- /dev/null
+++ b/extension/src/assets/learning.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round" d="M12 6.5C10 4.7 7 4 3.5 4.5v14c3.5-.5 6.5.2 8.5 2m0-14c2-1.8 5-2.5 8.5-2v14c-3.5-.5-6.5.2-8.5 2m0-14v14M14.8 10l1.6 1.6 3-3.2"/></svg>
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index 281737ae9..c88f1277c 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.45'
+export const EXTENSION_VERSION = '0.2.46'
 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'
@@ -954,6 +954,93 @@ export const GENERATE_ANYWAY_ACTION = 'Generate anyway'
 export const UPDATE_WIKI_ACTION = 'Update LLM Wiki'
 /** The button of a generation's notices that opens the new Wiki in the browser. */
 export const OPEN_WIKI_IN_BROWSER_ACTION = 'Open in Browser'
+/** How many characters of a commit hash the generation line of the LLM Wiki view's Wiki row shows. */
+export const WIKI_SHORT_REVISION_CHARS = 7
+/** VS Code's command that reveals the chat a request would go to (the chat focused last when it can be shown, the Chat view otherwise) and makes it the chat focused last; with a query it sends the query as a request into that chat and, with `blockOnResponse`, returns when the response completes or waits for a confirmation. Without one it only reveals the chat: the LLM Wiki view's Open Chat action runs it, so a chat that waits for an approval, or never started the skill, is one click away. */
+export const OPEN_CHAT_COMMAND = 'workbench.action.chat.open'
+/** The editor's own command that opens settings, with a setting's id as its argument. */
+export const OPEN_SETTINGS_COMMAND = 'workbench.action.openSettings'
+/** The id of the setting that names the Wiki output folder. */
+export const WIKI_OUTPUT_DIRECTORY_SETTING = 'codebook.wikiOutputDirectory'
+/** The settings search that shows the setting naming the Wiki output folder, the argument of {@link OPEN_SETTINGS_COMMAND}. */
+export const WIKI_OUTPUT_SETTINGS_QUERY = `@id:${WIKI_OUTPUT_DIRECTORY_SETTING}`
+/** The id of the LLM Wiki tree view in the Activity Bar (Cycle 0055 pt2). */
+export const LLM_WIKI_VIEW_ID = 'codebook.llmWiki'
+/** The context key that says what the LLM Wiki view shows, so its welcome content shows in the empty state only: `loading` until the first read ends, `none` when the folder holds no Wiki and no run, `other` for every row. */
+export const LLM_WIKI_STATE_CONTEXT_KEY = 'codebook.llmWiki.state'
+/** The context key that names the editor host (`vscode` or `cursor`), so the welcome content words the runner of the host it runs in. */
+export const CODEBOOK_HOST_CONTEXT_KEY = 'codebook.host'
+/** How long the LLM Wiki view waits after the last event that asks for a read before it reads: events inside this time coalesce into one read, and the last event always reads. */
+export const LLM_WIKI_REFRESH_DEBOUNCE_MS = 1_000
+/** How often the LLM Wiki view reads its state again while a row of a run (this window's, another window's or a stopped watch's reservation) is shown: a marker whose window died leaves no file event. */
+export const LLM_WIKI_POLL_MS = 30_000
+/** The editor's command that sets a context key (`setContext`, key, value). */
+export const SET_CONTEXT_COMMAND = 'setContext'
+/** The editor's command that shows a file or folder in the system's file manager. */
+export const REVEAL_FILE_IN_OS_COMMAND = 'revealFileInOS'
+/** The editor's command that opens its folder dialog. */
+export const OPEN_FOLDER_COMMAND = 'vscode.openFolder'
+/** The command that updates the published LLM Wiki; the Wiki row's Update action and the notices' Update button run it. */
+export const UPDATE_DEEP_WIKI_COMMAND = 'codebook.updateDeepWiki'
+/** The command that opens the published Wiki in the browser; the Wiki row of the LLM Wiki view runs it on click. */
+export const OPEN_DEEP_WIKI_COMMAND = 'codebook.openDeepWiki'
+/** The window id the LLM Wiki view passes when it reads a run marker: one no window has, so this window's own reservation is seen as a stopped watch's too. */
+export const LLM_WIKI_VIEW_WINDOW_ID = '\u0000llm-wiki-view'
+/** The message above the LLM Wiki tree while a VS Code watch is shown: Stop watching ends Codebook's watch only. */
+export const LLM_WIKI_WATCHING_MESSAGE =
+  'Codebook is watching the chat. Stop watching does not stop the chat; stop it in the chat.'
+/** The LLM Wiki view's wrapping message (VS Code) while only a stopped watch's reservation stands: Codebook no longer watches, the chat may still publish. */
+export const LLM_WIKI_RESERVATION_MESSAGE =
+  'Codebook stopped watching the chat, which may still publish this Wiki. To stop it, stop the request in the chat.'
+/** The command of the LLM Wiki view's title bar Refresh action. */
+export const REFRESH_LLM_WIKI_COMMAND = 'codebook.refreshLlmWiki'
+/** The command that a click on the view's attention or last-attempt row runs: it shows the row's full sentence, with Copy details. */
+export const SHOW_LLM_WIKI_ATTENTION_COMMAND = 'codebook.showLlmWikiAttention'
+/** The command that copies the chat request of the publisher's recovery ({@link WIKI_UPDATE_RECOVERY_REQUEST}). */
+export const COPY_WIKI_RECOVERY_REQUEST_COMMAND =
+  'codebook.copyWikiRecoveryRequest'
+/** The command that reveals the Wiki folder in the system's file manager. */
+export const REVEAL_WIKI_FOLDER_COMMAND = 'codebook.revealWikiFolder'
+/** The button of the attention notice that copies its sentence. */
+export const COPY_DETAILS_ACTION = 'Copy details'
+/** The ids of the editor's command that manages workspace trust, in the order Codebook prefers them; the view runs the first one the editor lists (`workbench.trust.manage` is VS Code's own id; vscode-go calls `workbench.action.manageTrust`). Unverified in each host until the native trial. */
+export const MANAGE_WORKSPACE_TRUST_COMMAND_IDS = [
+  'workbench.trust.manage',
+  'workbench.action.manageTrust',
+] as const
+/** What one inline action of an LLM Wiki view row is: the command it runs and the words of its title. The row function names an action by its key, the manifest contributes each command with a menu entry that tests `viewItem` for the key. */
+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',
+  },
+  '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' },
+  'change-location': {
+    command: 'codebook.llmWiki.changeLocation',
+    title: 'Change location',
+  },
+  'copy-recovery': {
+    command: COPY_WIKI_RECOVERY_REQUEST_COMMAND,
+    title: 'Copy recovery request',
+  },
+  'reveal-folder': {
+    command: REVEAL_WIKI_FOLDER_COMMAND,
+    title: 'Reveal Wiki Folder',
+  },
+  refresh: { command: REFRESH_LLM_WIKI_COMMAND, title: 'Refresh' },
+  'open-folder': {
+    command: 'codebook.llmWiki.openFolder',
+    title: 'Open Folder',
+  },
+  'manage-trust': {
+    command: 'codebook.llmWiki.manageTrust',
+    title: 'Manage Workspace Trust',
+  },
+} as const
 /** How often the extension looks for a newly published manifest while a Wiki update is watched. */
 export const WIKI_UPDATE_WATCH_POLL_MS = 2_000
 /** How often the reader page asks for the update state while a run is active. */
diff --git a/extension/src/deepWikiReader.ts b/extension/src/deepWikiReader.ts
index 6522fb40f..b8e50f5aa 100644
--- a/extension/src/deepWikiReader.ts
+++ b/extension/src/deepWikiReader.ts
@@ -44,6 +44,7 @@ import type {
   WikiIncludedSource,
 } from './utils/answerDeepWikiQuestion'
 import { assertNoLinkOnWikiPath } from './utils/assertNoLinkOnWikiPath'
+import { describeWikiFreshness } from './utils/describeWikiFreshness'
 import { describeWikiUpdate } from './utils/describeWikiUpdate'
 import {
   inspectDeepWikiFreshness,
@@ -104,7 +105,7 @@ const qaClient = `(function () {
     { action: 'Keyboard shortcuts', keys: '?', context: 'DeepWiki, outside text inputs', selector: '[data-shortcut-help]' },
     { action: 'Close keyboard shortcuts', keys: 'Esc', context: 'Keyboard shortcuts dialog' }
   ], 'body');
-  (${installWikiUpdateStatus.toString()})({ readerPrefix: prefix, pagePublication: (document.currentScript && document.currentScript.getAttribute('data-codebook-publication')) || undefined, updateStatusRoute: '${WIKI_UPDATE_STATUS_ROUTE}', freshnessRoute: '${WIKI_FRESHNESS_ROUTE}', describeUpdate: (${describeWikiUpdate.toString()}), statusPollMs: ${WIKI_UPDATE_STATUS_POLL_MS}, idlePollMs: ${WIKI_UPDATE_IDLE_POLL_MS}, freshnessMinIntervalMs: ${WIKI_FRESHNESS_MIN_INTERVAL_MS}, startWaitMs: ${WIKI_UPDATE_START_WAIT_MS}, statusRetryLimit: ${WIKI_UPDATE_STATUS_RETRY_LIMIT}, pathLimit: ${WIKI_UPDATE_SHOWN_PATH_LIMIT}, reasonLimitChars: ${WIKI_UPDATE_REASON_LIMIT_CHARS}, msPerMinute: ${MS_PER_MINUTE}, recoveryRequest: ${JSON.stringify(WIKI_UPDATE_RECOVERY_REQUEST)}, outsideOutputApprovalsNote: ${JSON.stringify(WIKI_OUTSIDE_OUTPUT_APPROVALS_NOTE)}, refusedStepAdvice: ${JSON.stringify(WIKI_REFUSED_STEP_ADVICE)}, missingPageTextDelayMs: ${WIKI_MISSING_PAGE_TEXT_DELAY_MS}, missingPagePathLimitChars: ${WIKI_MISSING_PAGE_PATH_LIMIT_CHARS} });
+  (${installWikiUpdateStatus.toString()})({ readerPrefix: prefix, pagePublication: (document.currentScript && document.currentScript.getAttribute('data-codebook-publication')) || undefined, updateStatusRoute: '${WIKI_UPDATE_STATUS_ROUTE}', freshnessRoute: '${WIKI_FRESHNESS_ROUTE}', describeUpdate: (${describeWikiUpdate.toString()}), describeFreshness: (${describeWikiFreshness.toString()}), statusPollMs: ${WIKI_UPDATE_STATUS_POLL_MS}, idlePollMs: ${WIKI_UPDATE_IDLE_POLL_MS}, freshnessMinIntervalMs: ${WIKI_FRESHNESS_MIN_INTERVAL_MS}, startWaitMs: ${WIKI_UPDATE_START_WAIT_MS}, statusRetryLimit: ${WIKI_UPDATE_STATUS_RETRY_LIMIT}, pathLimit: ${WIKI_UPDATE_SHOWN_PATH_LIMIT}, reasonLimitChars: ${WIKI_UPDATE_REASON_LIMIT_CHARS}, msPerMinute: ${MS_PER_MINUTE}, recoveryRequest: ${JSON.stringify(WIKI_UPDATE_RECOVERY_REQUEST)}, outsideOutputApprovalsNote: ${JSON.stringify(WIKI_OUTSIDE_OUTPUT_APPROVALS_NOTE)}, refusedStepAdvice: ${JSON.stringify(WIKI_REFUSED_STEP_ADVICE)}, missingPageTextDelayMs: ${WIKI_MISSING_PAGE_TEXT_DELAY_MS}, missingPagePathLimitChars: ${WIKI_MISSING_PAGE_PATH_LIMIT_CHARS} });
   // The shell's form by its element and its id together: a page published before the publisher kept the ids of a page's content apart from the reader's may carry the id on a heading of its article, which stands before the form.
   var form = document.querySelector('form#qa-form, [data-codebook-question]');
   if (!form) return;
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index ffdd864d7..dc3d8f604 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -24,10 +24,15 @@ import {
   GENERATE_CONFIRM_ACTION,
   GENERATE_DEEP_WIKI_COMMAND,
   GENERATE_WIKI_ACTION,
+  LLM_WIKI_POLL_MS,
+  LLM_WIKI_REFRESH_DEBOUNCE_MS,
+  LLM_WIKI_VIEW_WINDOW_ID,
+  OPEN_DEEP_WIKI_COMMAND,
   OPEN_WIKI_IN_BROWSER_ACTION,
   PRIVATE_DIRECTORY_MODE,
   PRIVATE_FILE_MODE,
   SHOW_WIKI_OUTPUT_COMMAND,
+  UPDATE_DEEP_WIKI_COMMAND,
   UPDATE_WIKI_ACTION,
   WIKI_CHAT_OPEN_TIMEOUT_MS,
   WIKI_CHAT_SESSION_START_TIMEOUT_MS,
@@ -102,6 +107,7 @@ import { detectWikiPublishConflicts } from './utils/detectWikiPublishConflicts'
 import { endOfWikiChatStart } from './utils/endOfWikiChatStart'
 import { failureOfWikiChatReplyEnd } from './utils/failureOfWikiChatReplyEnd'
 import { findGeneratedWikiProblem } from './utils/findGeneratedWikiProblem'
+import { findNearestExistingAncestor } from './utils/findNearestExistingAncestor'
 import { findUnacknowledgedWikiLeftover } from './utils/findUnacknowledgedWikiLeftover'
 import { findWikiUpdateStartBlock } from './utils/findWikiUpdateStartBlock'
 import {
@@ -113,14 +119,17 @@ import {
   formatCodebookDiagnostic,
   type CodebookDiagnostic,
 } from './utils/formatCodebookDiagnostic'
+import { hasWikiPublishEndedWait } from './utils/hasWikiPublishEndedWait'
 import { inspectDeepWikiFreshness } from './utils/inspectDeepWikiFreshness'
 import type { WikiLeftover } from './utils/isAcknowledgedWikiLeftover'
 import { isWikiManifestOf } from './utils/isWikiManifestOf'
 import { joinInFlight } from './utils/joinInFlight'
 import { listWikiCandidates } from './utils/listWikiCandidates'
+import { createLlmWikiView } from './utils/llmWikiView'
 import { mayWikiChatStillPublish } from './utils/mayWikiChatStillPublish'
 import { noticeWithSetupStep } from './utils/noticeWithSetupStep'
 import { readLiveWikiUpdateMarker } from './utils/readLiveWikiUpdateMarker'
+import { readLlmWikiViewFacts } from './utils/readLlmWikiViewFacts'
 import { readWikiFileToOpen } from './utils/readWikiFileToOpen'
 import { readWikiPublicationIdentity } from './utils/readWikiPublicationIdentity'
 import { readWikiPublishToken } from './utils/readWikiPublishToken'
@@ -130,6 +139,7 @@ import {
   refreshCursorMcpCatalog,
   removeOwnedCursorMcpCatalog,
 } from './utils/refreshCursorMcpCatalog'
+import { registerLlmWikiCommands } from './utils/registerLlmWikiCommands'
 import { registerPlainCommand } from './utils/registerPlainCommand'
 import { requestCursorWikiText } from './utils/requestCursorWikiText'
 import { resolveDeepWikiDirectory } from './utils/resolveDeepWikiDirectory'
@@ -295,6 +305,8 @@ export function activate(
   /** The output of the latest run's record, and whether the editor stored it; {@link dropWikiReservation} waits for it at shutdown before removing the reload's fallback reservation. */
   let lastWikiRunWrite:
     { outputDirectory: string; written: Promise<boolean> } | undefined
+  /** How the Cursor agent of this window's last run exited; the LLM Wiki view words a stopped generation's cause from it. */
+  let lastWikiAgentExit: WikiAgentExit | undefined
   // This window's id in the marker of a running update; another window's live marker refuses a start here.
   const wikiWindowId = randomUUID()
   // The reservation each of this window's stopped VS Code watches left on disk for other windows, by Wiki output, with the timer that removes it at that watch's bound.
@@ -1150,8 +1162,8 @@ export function activate(
   }
   /** The command each button of a generation's notice runs ({@link wikiGenerateNotice}). */
   const WIKI_NOTICE_ACTION_COMMANDS: Record<string, string> = {
-    [OPEN_WIKI_IN_BROWSER_ACTION]: 'codebook.openDeepWiki',
-    [UPDATE_WIKI_ACTION]: 'codebook.updateDeepWiki',
+    [OPEN_WIKI_IN_BROWSER_ACTION]: OPEN_DEEP_WIKI_COMMAND,
+    [UPDATE_WIKI_ACTION]: UPDATE_DEEP_WIKI_COMMAND,
     [GENERATE_WIKI_ACTION]: GENERATE_DEEP_WIKI_COMMAND,
   }
   /** Shows a notice whose buttons each start a Codebook command ({@link WIKI_NOTICE_ACTION_COMMANDS}); the pressed button's command tells the learner itself what failed. @example showWikiActionNotice('error', 'Codebook found no LLM Wiki in .codebook/wiki.', [GENERATE_WIKI_ACTION]) */
@@ -1202,7 +1214,7 @@ export function activate(
         else if (choice === OPEN_WIKI_ACTION)
           // The command's own handler tells the learner why the Wiki did not open; its rejection has nobody else to go to.
           void vscode.commands
-            .executeCommand('codebook.openDeepWiki')
+            .executeCommand(OPEN_DEEP_WIKI_COMMAND)
             .then(undefined, () => undefined)
       },
       // A notification the editor could not show has nobody to report to either.
@@ -1401,6 +1413,7 @@ export function activate(
         hasNewPublication: false,
       }),
     )
+    lastWikiAgentExit = run.agentExit
     wikiUpdateRun.end(end)
     const endedAtMs = Date.now()
     // Stopping a VS Code watch does not stop the chat, and neither does a watch that broke off or a request Codebook left in the chat at the 30 seconds; a Cursor agent is stopped with its run, and a closing window takes its chat with it. A chat whose publish is on disk has done its work, also when the watch was stopped while it read that publish or just before its next look: it leaves no chat that may still publish and no reservation.
@@ -2557,6 +2570,22 @@ export function activate(
         },
       }),
     )
+  /** Stops this window's run, or tells the learner why there is nothing to stop; called by Stop LLM Wiki Run and by the LLM Wiki view's Stop watching and Cancel. @example cancelWikiRun() */
+  const cancelWikiRun = (): void => {
+    if (activeWikiRun) {
+      activeWikiRun.controller.abort()
+      return
+    }
+    // A run that is still starting has nothing to stop yet; the learner is told so instead of "nothing is running".
+    if (wikiUpdate) {
+      void showNotice('information', WIKI_RUN_STARTING_SENTENCE)
+      return
+    }
+    void showNotice(
+      'information',
+      'No LLM Wiki generation or update is running in this window.',
+    )
+  }
   context.subscriptions.push(
     registerCommand('codebook.startAgentServer', start),
     registerCommand('codebook.stopAgentServer', stopOnRequest),
@@ -2652,7 +2681,7 @@ export function activate(
     }),
     // A second command while the first is still opening joins it: two opens in flight would each start a reader, and the failure of one would close the other's.
     registerCommand(
-      'codebook.openDeepWiki',
+      OPEN_DEEP_WIKI_COMMAND,
       joinInFlight(async () => {
         try {
           // A folder without a Wiki offers its generation instead of an error about a missing manifest (Cycle 0055, proposed change 3).
@@ -2785,7 +2814,7 @@ export function activate(
         }
       }),
     ),
-    registerCommand('codebook.updateDeepWiki', async () => {
+    registerCommand(UPDATE_DEEP_WIKI_COMMAND, async () => {
       try {
         await updateDeepWiki()
       } catch (error) {
@@ -2810,21 +2839,7 @@ export function activate(
       }
     }),
     // Stops this window's run, generation or update: a VS Code watch, also while it still waits for the chat's first sign, or the Cursor agent. The chat itself is not stopped.
-    registerCommand(CANCEL_WIKI_RUN_COMMAND, () => {
-      if (activeWikiRun) {
-        activeWikiRun.controller.abort()
-        return
-      }
-      // A run that is still starting has nothing to stop yet; the learner is told so instead of "nothing is running".
-      if (wikiUpdate) {
-        void showNotice('information', WIKI_RUN_STARTING_SENTENCE)
-        return
-      }
-      void showNotice(
-        'information',
-        'No LLM Wiki generation or update is running in this window.',
-      )
-    }),
+    registerCommand(CANCEL_WIKI_RUN_COMMAND, cancelWikiRun),
     registerCommand(SHOW_WIKI_OUTPUT_COMMAND, () => {
       diagnostics.show()
     }),
@@ -2908,6 +2923,93 @@ export function activate(
       replacingReaders = settled
     }),
   )
+  // 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')) {
+    const llmWikiView = createLlmWikiView({
+      editor: vscode,
+      host: isCursorHost ? 'cursor' : 'vscode',
+      debounceMs: LLM_WIKI_REFRESH_DEBOUNCE_MS,
+      pollMs: LLM_WIKI_POLL_MS,
+      readFacts: () =>
+        readLlmWikiViewFacts({
+          host: isCursorHost ? 'cursor' : 'vscode',
+          isFolderOpen: () =>
+            Boolean(vscode.workspace.workspaceFolders?.length),
+          isTrusted: () => vscode.workspace.isTrusted,
+          wikiLocation,
+          readPublishToken: readWikiPublishToken,
+          readPublication: readWikiPublicationIdentity,
+          findStartBlock: findWikiUpdateStartBlock,
+          readGeneration: async (projectRoot, outputDirectory) => {
+            const manifest = await readDeepWikiManifest(
+              outputDirectory,
+              projectRoot,
+            )
+            const manifestStat = await lstat(
+              join(outputDirectory, WIKI_MANIFEST_FILE),
+            ).catch(() => undefined)
+            return {
+              revision: manifest.revision,
+              publishedAtMs: manifestStat?.mtimeMs,
+            }
+          },
+          isWikiOwnedBy,
+          // A window id nobody has: this window's own reservation is seen as the stopped watch's too.
+          readMarker: (outputDirectory) =>
+            readLiveWikiUpdateMarker(outputDirectory, LLM_WIKI_VIEW_WINDOW_ID),
+          ownWindowId: wikiWindowId,
+          isStartUnderWay: () => wikiUpdate !== undefined,
+          hasPublishEndedWait: hasWikiPublishEndedWait,
+          runStatus: () => wikiUpdateRun.status(),
+          isAwaitingChat: () => activeWikiRun?.awaitsChat === true,
+          lastAgentExit: () => lastWikiAgentExit,
+          now: () => Date.now(),
+        }),
+      // The facts the rows show name the project and folder to inspect, so a setting changed meanwhile cannot make the check read another Wiki.
+      readFreshness: async ({ projectRoot, outputDirectory }) => {
+        const published = await inspectPublishedWiki(
+          projectRoot,
+          outputDirectory,
+        )
+        if (!published)
+          return {
+            status: 'unknown',
+            reason: 'The manifest could not be read.',
+          }
+        return {
+          status: published.freshness.status,
+          reason: published.freshness.reason,
+          isAdditionUnchecked: published.freshness.addedFilesUnchecked === true,
+        }
+      },
+      findWatchedFolder: findNearestExistingAncestor,
+      onRunChange: (listener) => wikiUpdateRun.onDidChange(listener),
+      tellPublished: (outputLabel) =>
+        showWikiActionNotice(
+          'information',
+          `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.
+        }
+      },
+    })
+    context.subscriptions.push(
+      { dispose: () => llmWikiView.dispose() },
+      ...registerLlmWikiCommands({
+        editor: vscode,
+        register: registerCommand,
+        showNotice,
+        view: llmWikiView,
+        cancelRun: cancelWikiRun,
+        findOutputDirectory: async () => (await wikiLocation()).outputDirectory,
+      }),
+    )
+  }
   // Register lazy readers before restored captured documents or contributed views request their providers.
   workspace()
   repository()
diff --git a/extension/src/tests/chooseWikiWatchFolder.test.ts b/extension/src/tests/chooseWikiWatchFolder.test.ts
new file mode 100644
index 000000000..3aa297e8a
--- /dev/null
+++ b/extension/src/tests/chooseWikiWatchFolder.test.ts
@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict'
+import { win32 } from 'node:path'
+import { test } from 'node:test'
+
+import { chooseWikiWatchFolder } from '../utils/chooseWikiWatchFolder'
+
+const HOME = '/Users/ada'
+
+// Value: protects=the watcher standing on the project root in a fresh project; fails_when=a missing .codebook inside the project gives no watcher or one above the project; no_claim=the editor's watcher; seam=the pure function
+test('a missing .codebook inside the project is watched from the project root', () => {
+  // Arrange
+  const choice = {
+    projectRoot: '/work/repo',
+    outputDirectory: '/work/repo/.codebook/wiki',
+    nearestExistingFolder: '/work/repo',
+    homeDirectory: HOME,
+  }
+
+  // Act
+  const folder = chooseWikiWatchFolder(choice)
+
+  // Assert
+  assert.equal(folder, '/work/repo')
+})
+
+// Value: protects=the editor from a recursive watch of the home folder or the root; fails_when=an output outside the project whose parent does not exist is watched from the nearest existing ancestor, here the home folder; no_claim=what the view shows instead (host test); seam=the pure function
+test('an output outside the project whose parent is missing gets no watcher, even when an ancestor exists', () => {
+  // Arrange
+  const choice = {
+    projectRoot: '/work/repo',
+    outputDirectory: '/Users/ada/x/y/wiki',
+    nearestExistingFolder: HOME,
+    homeDirectory: HOME,
+  }
+
+  // Act
+  const folder = chooseWikiWatchFolder(choice)
+
+  // Assert
+  assert.equal(folder, undefined)
+})
+
+// Value: protects=the watch of an output outside the project; fails_when=an existing parent outside the project is refused, so such a Wiki is never refreshed by events; no_claim=the editor's watcher; seam=the pure function
+test('an output outside the project is watched from its own parent when that exists', () => {
+  // Arrange
+  const choice = {
+    projectRoot: '/work/repo',
+    outputDirectory: '/data/notes/wiki',
+    nearestExistingFolder: '/data/notes',
+    homeDirectory: HOME,
+  }
+
+  // Act
+  const folder = chooseWikiWatchFolder(choice)
+
+  // Assert
+  assert.equal(folder, '/data/notes')
+})
+
+// Value: protects=the editor from a recursive watch of the home folder or the root; fails_when=a project or an output parent that is the home folder or a file-system root is watched; no_claim=the Windows root forms beyond C:\; seam=the pure function with both path modules
+test('the home folder and a file-system root are never watched', () => {
+  // Arrange
+  const projectAtHome = {
+    projectRoot: HOME,
+    outputDirectory: `${HOME}/.codebook/wiki`,
+    nearestExistingFolder: HOME,
+    homeDirectory: HOME,
+  }
+  const outputBelowRoot = {
+    projectRoot: '/work/repo',
+    outputDirectory: '/wiki',
+    nearestExistingFolder: '/',
+    homeDirectory: HOME,
+  }
+  const windowsRoot = {
+    projectRoot: 'C:\\repo',
+    outputDirectory: 'D:\\wiki',
+    nearestExistingFolder: 'D:\\',
+    homeDirectory: 'C:\\Users\\ada',
+    pathApi: win32,
+  }
+
+  // Act
+  const folders = [projectAtHome, outputBelowRoot, windowsRoot].map(
+    chooseWikiWatchFolder,
+  )
+
+  // Assert
+  assert.deepEqual(folders, [undefined, undefined, undefined])
+})
diff --git a/extension/src/tests/comparableFilePath.test.ts b/extension/src/tests/comparableFilePath.test.ts
new file mode 100644
index 000000000..5d0a40a71
--- /dev/null
+++ b/extension/src/tests/comparableFilePath.test.ts
@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { comparableFilePath } from '../utils/comparableFilePath'
+
+// Value: protects=the LLM Wiki view's watcher filter on Windows, where Uri.fsPath lowercases the drive letter; fails_when=the two spellings of one file compare differently, so every watcher event is dropped; no_claim=the editor's own spelling; seam=the pure function with an explicit platform
+test('on Windows a lowercase drive letter and a backslash path name the same file as the uppercase one', () => {
+  // Arrange
+  const computed = 'C:\\Repo\\.codebook\\wiki.update-run.json'
+  const reported = 'c:/Repo/.codebook/wiki.update-run.json'
+
+  // Act
+  const result = [
+    comparableFilePath(computed, 'win32'),
+    comparableFilePath(reported, 'win32'),
+  ]
+
+  // Assert
+  assert.deepEqual(result, [
+    'c:/repo/.codebook/wiki.update-run.json',
+    'c:/repo/.codebook/wiki.update-run.json',
+  ])
+})
+
+// Value: protects=case-sensitive systems; fails_when=Linux paths that differ in case compare equal; no_claim=macOS volumes formatted case-sensitive; seam=the pure function with an explicit platform
+test('on Linux paths that differ in case stay different, on macOS they match', () => {
+  // Arrange
+  const path = '/Repo/a.json'
+
+  // Act
+  const result = [
+    comparableFilePath(path, 'linux'),
+    comparableFilePath(path, 'darwin'),
+  ]
+
+  // Assert
+  assert.deepEqual(result, ['/Repo/a.json', '/repo/a.json'])
+})
diff --git a/extension/src/tests/describeWikiFreshness.test.ts b/extension/src/tests/describeWikiFreshness.test.ts
new file mode 100644
index 000000000..da5ebd89f
--- /dev/null
+++ b/extension/src/tests/describeWikiFreshness.test.ts
@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { describeWikiFreshness } from '../utils/describeWikiFreshness'
+
+import { openFakeWikiPage } from './utils/fakeWikiPage'
+import { readServedWikiScript } from './utils/readServedWikiScript'
+
+// Value: protects=AC 2 (row 1's description) and the shared freshness wording of the page and the LLM Wiki view; fails_when=a status gets another label than the reader page shows for it, or a current Wiki without a Git revision loses its note; no_claim=the page's own timing of the check; seam=the pure function
+test('describeWikiFreshness words a current, a changed and an undecided Wiki as the reader page does', () => {
+  // Arrange
+  const reasonLimit = 160
+
+  // Act
+  const labels = {
+    current: describeWikiFreshness('current', '', false, reasonLimit),
+    currentWithoutGit: describeWikiFreshness('current', '', true, reasonLimit),
+    changed: describeWikiFreshness('changed', '', false, reasonLimit),
+    unknownWithoutReason: describeWikiFreshness(
+      'unknown',
+      '',
+      false,
+      reasonLimit,
+    ),
+    unknownWithReason: describeWikiFreshness(
+      'unknown',
+      'The manifest is unreadable.',
+      false,
+      reasonLimit,
+    ),
+    unanswered: describeWikiFreshness(undefined, '', false, reasonLimit),
+  }
+
+  // Assert
+  assert.deepEqual(labels, {
+    current: 'Wiki source current',
+    currentWithoutGit:
+      'Wiki source current (no Git revision recorded, so added files are not checked)',
+    changed: 'Source changed · Update available',
+    unknownWithoutReason: 'Wiki freshness unknown',
+    unknownWithReason: 'Wiki freshness unknown: The manifest is unreadable.',
+    unanswered: 'Wiki freshness unknown',
+  })
+})
+
+// Value: protects=the rail's narrow width; fails_when=a long reason is not cut at a space before the limit; no_claim=the tooltip that keeps the whole reason; seam=the pure function
+test('describeWikiFreshness cuts a reason longer than the limit at the last space before it', () => {
+  // Arrange
+  const reason =
+    'An indexed source could not be checked: packages/dashboard/a.ts'
+
+  // Act
+  const label = describeWikiFreshness('unknown', reason, false, 45)
+
+  // Assert
+  assert.equal(
+    label,
+    'Wiki freshness unknown: An indexed source could not be checked:…',
+  )
+})
+
+// Value: protects=Eng decision 86, the page installer is serialized with toString() and cannot import the shared function; fails_when=the emitted page script does not carry the shared wording, so the page's label for current, changed or unknown differs from the function's; no_claim=the freshness check itself; seam=the served page script run in the fake page
+test('the emitted page script labels a current, a changed and an unknown Wiki with the shared wording', async () => {
+  // Arrange
+  const script = await readServedWikiScript()
+
+  // Act
+  const labels = []
+  for (const [freshness, freshnessDetail] of [
+    ['current', {}],
+    ['changed', {}],
+    ['unknown', { reason: 'The manifest is unreadable.' }],
+  ] as const) {
+    const page = await openFakeWikiPage(script, 'current-shell', {
+      freshness,
+      freshnessDetail,
+    })
+    labels.push(page.find('[data-codebook-freshness]')?.textContent)
+  }
+
+  // Assert
+  assert.deepEqual(labels, [
+    'Wiki source current',
+    'Source changed · Update available',
+    'Wiki freshness unknown: The manifest is unreadable.',
+  ])
+})
diff --git a/extension/src/tests/describeWikiGeneration.test.ts b/extension/src/tests/describeWikiGeneration.test.ts
new file mode 100644
index 000000000..2e5a231a2
--- /dev/null
+++ b/extension/src/tests/describeWikiGeneration.test.ts
@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { describeWikiGeneration } from '../utils/describeWikiGeneration'
+
+const revision = '1936e41913729663cc99081e3224db89bb2d8e56'
+const formatDate = (): string => 'Oct 26, 2026'
+
+// Value: protects=AC 10 (accepted X1), the four tooltip forms; fails_when=a form names the wrong parts, a branch name counts as a revision, or a Wiki with neither shows a line; no_claim=the date's locale; seam=the pure function
+test('describeWikiGeneration words the four forms of a Wiki’s generation', () => {
+  // Arrange
+  const date = 1_790_000_000_000
+
+  // Act
+  const forms = [
+    describeWikiGeneration({ revision, publishedAtMs: date }, formatDate),
+    describeWikiGeneration({ publishedAtMs: date }, formatDate),
+    describeWikiGeneration(
+      { revision: 'main', publishedAtMs: date },
+      formatDate,
+    ),
+    describeWikiGeneration({ revision }, formatDate),
+    describeWikiGeneration({}, formatDate),
+  ]
+
+  // Assert
+  assert.deepEqual(forms, [
+    'Generated from 1936e41 on Oct 26, 2026',
+    'Generated on Oct 26, 2026 (no Git revision)',
+    'Generated on Oct 26, 2026 (no Git revision)',
+    'Generated from 1936e41',
+    undefined,
+  ])
+})
diff --git a/extension/src/tests/describeWikiWatch.test.ts b/extension/src/tests/describeWikiWatch.test.ts
new file mode 100644
index 000000000..4ea39514a
--- /dev/null
+++ b/extension/src/tests/describeWikiWatch.test.ts
@@ -0,0 +1,104 @@
+import assert from 'node:assert/strict'
+import { posix, win32 } from 'node:path'
+import { test } from 'node:test'
+
+import { describeWikiWatch } from '../utils/describeWikiWatch'
+
+// Value: protects=the watcher seeing the Wiki folder itself and a folder not made yet; fails_when=the glob lists only the four files, so the delete of the output folder alone (or the creation of .codebook) is never reported; no_claim=the editor's glob engine; seam=the pure function with the POSIX path module
+test('the plan lists the output folder, the folders between it and the watched folder, and the four files', () => {
+  // Arrange
+  const watchedFolder = '/repo'
+  const outputDirectory = '/repo/.codebook/wiki'
+
+  // Act
+  const plan = describeWikiWatch(watchedFolder, outputDirectory, posix)
+
+  // Assert
+  assert.deepEqual(plan, {
+    glob: '{.codebook,.codebook/wiki,.codebook/wiki/codebook-wiki.json,.codebook/wiki.update-run.json,.codebook/wiki.publish-lock.json,.codebook/wiki.publish-journal.json}',
+    paths: [
+      '/repo/.codebook',
+      '/repo/.codebook/wiki',
+      '/repo/.codebook/wiki/codebook-wiki.json',
+      '/repo/.codebook/wiki.update-run.json',
+      '/repo/.codebook/wiki.publish-lock.json',
+      '/repo/.codebook/wiki.publish-journal.json',
+    ],
+  })
+})
+
+// Value: protects=a folder named with glob characters; fails_when=`a]b` or `wiki[1]` is embedded raw so the editor reads a character class; no_claim=the editor's glob engine; seam=the pure function
+test('glob characters of the folder names are escaped in every entry of the glob', () => {
+  // Arrange
+  const watchedFolder = '/repo/docs'
+  const outputDirectory = '/repo/docs/a]b'
+
+  // Act
+  const plan = describeWikiWatch(watchedFolder, outputDirectory, posix)
+
+  // Assert
+  assert.equal(
+    plan?.glob,
+    '{a[]]b,a[]]b/codebook-wiki.json,a[]]b.update-run.json,a[]]b.publish-lock.json,a[]]b.publish-journal.json}',
+  )
+})
+
+// Value: protects=a Wiki output on another Windows drive than the watched folder; fails_when=the relative path is absolute and becomes a glob that matches nothing instead of the no-watcher fallback; no_claim=a real Windows host; seam=the pure function with path.win32
+test('an output on another Windows drive has no plan, and a folder above the watched one has none either', () => {
+  // Arrange
+  const watchedFolder = 'C:\\repo'
+
+  // Act
+  const plans = [
+    describeWikiWatch(watchedFolder, 'D:\\wiki', win32),
+    describeWikiWatch(watchedFolder, 'C:\\other\\wiki', win32),
+    describeWikiWatch('/repo/sub', '/repo', posix),
+  ]
+
+  // Assert
+  assert.deepEqual(plans, [undefined, undefined, undefined])
+})
+
+// Value: protects=the exact-path filter on Windows; fails_when=the absolute paths use forward slashes while the glob uses backslashes, or the reverse; no_claim=drive letter case (comparableFilePath tests); seam=the pure function with path.win32
+test('on Windows the glob uses forward slashes and the paths keep the drive and backslashes', () => {
+  // Arrange
+  const watchedFolder = 'C:\\repo\\.codebook'
+  const outputDirectory = 'C:\\repo\\.codebook\\wiki'
+
+  // Act
+  const plan = describeWikiWatch(watchedFolder, outputDirectory, win32)
+
+  // Assert
+  assert.deepEqual(plan, {
+    glob: '{wiki,wiki/codebook-wiki.json,wiki.update-run.json,wiki.publish-lock.json,wiki.publish-journal.json}',
+    paths: [
+      'C:\\repo\\.codebook\\wiki',
+      'C:\\repo\\.codebook\\wiki\\codebook-wiki.json',
+      'C:\\repo\\.codebook\\wiki.update-run.json',
+      'C:\\repo\\.codebook\\wiki.publish-lock.json',
+      'C:\\repo\\.codebook\\wiki.publish-journal.json',
+    ],
+  })
+})
+
+// Value: protects=the watcher of a Wiki folder whose name holds a comma; fails_when=the comma is embedded raw in the brace list, so the glob's alternatives no longer name the folder, the manifest or the markers; no_claim=the editor's glob engine; seam=the pure function with the POSIX path module
+test('a comma in the Wiki folder name stays one entry of the glob, and the paths keep the name as written', () => {
+  // Arrange
+  const watchedFolder = '/repo'
+  const outputDirectory = '/repo/wiki,old'
+
+  // Act
+  const plan = describeWikiWatch(watchedFolder, outputDirectory, posix)
+
+  // Assert
+  assert.deepEqual(plan, {
+    glob: '{wiki[,]old,wiki[,]old/codebook-wiki.json,wiki[,]old.update-run.json,wiki[,]old.publish-lock.json,wiki[,]old.publish-journal.json}',
+    paths: [
+      '/repo/wiki,old',
+      '/repo/wiki,old/codebook-wiki.json',
+      '/repo/wiki,old.update-run.json',
+      '/repo/wiki,old.publish-lock.json',
+      '/repo/wiki,old.publish-journal.json',
+    ],
+  })
+})
diff --git a/extension/src/tests/escapeGlobCharacters.test.ts b/extension/src/tests/escapeGlobCharacters.test.ts
new file mode 100644
index 000000000..49c027125
--- /dev/null
+++ b/extension/src/tests/escapeGlobCharacters.test.ts
@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { escapeGlobCharacters } from '../utils/escapeGlobCharacters'
+
+// Value: protects=the watcher glob for folders with glob characters; fails_when=a character the editor's glob reads as syntax stays unescaped; no_claim=the editor's glob engine; seam=the pure function
+test('glob characters of a folder name are put in brackets and plain names stay as they are', () => {
+  // Arrange
+  const names = ['docs/wiki', 'wiki[1]', '{draft}/a*b?']
+
+  // Act
+  const escaped = names.map(escapeGlobCharacters)
+
+  // Assert
+  assert.deepEqual(escaped, [
+    'docs/wiki',
+    'wiki[[]1[]]',
+    '[{]draft[}]/a[*]b[?]',
+  ])
+})
+
+// Value: protects=the watcher glob for a folder named with a closing bracket; fails_when=a `]` outside brackets stays raw, which the editor's glob turns into an empty character class that matches nothing; no_claim=the editor's glob engine (its source treats `]` as literal only as the first character inside brackets); seam=the pure function
+test('a closing bracket in a folder name is put in brackets too', () => {
+  // Arrange
+  const name = 'a]b'
+
+  // Act
+  const escaped = escapeGlobCharacters(name)
+
+  // Assert
+  assert.equal(escaped, 'a[]]b')
+})
+
+// Value: protects=the watcher glob for a folder named with a comma; fails_when=a `,` stays raw inside the watcher's brace list, so the editor splits `docs/wiki,old` into two alternatives and no entry matches the real manifest or markers; no_claim=the editor's glob engine (its brace split skips separators inside brackets); seam=the pure function
+test('a comma in a folder name is put in brackets so the brace list does not split it', () => {
+  // Arrange
+  const name = 'docs/wiki,old'
+
+  // Act
+  const escaped = escapeGlobCharacters(name)
+
+  // Assert
+  assert.equal(escaped, 'docs/wiki[,]old')
+})
diff --git a/extension/src/tests/findNearestExistingAncestor.test.ts b/extension/src/tests/findNearestExistingAncestor.test.ts
new file mode 100644
index 000000000..30048c0f9
--- /dev/null
+++ b/extension/src/tests/findNearestExistingAncestor.test.ts
@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict'
+import { mkdir, mkdtemp, realpath, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+
+import { findNearestExistingAncestor } from '../utils/findNearestExistingAncestor'
+
+// Value: protects=Eng decision 78, the watcher of a fresh project; fails_when=a path whose parents are missing is returned as it is, so the watcher stands on a folder that does not exist; no_claim=the watcher; seam=a temporary folder
+test('findNearestExistingAncestor returns the folder itself when it exists and the nearest existing parent when it does not', async (context) => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-ancestor-')),
+  )
+  context.after(() => rm(root, { recursive: true, force: true }))
+  await mkdir(join(root, '.codebook'))
+
+  // Act
+  const found = [
+    await findNearestExistingAncestor(join(root, '.codebook')),
+    await findNearestExistingAncestor(join(root, '.codebook', 'wiki', 'deep')),
+    await findNearestExistingAncestor(join(root, 'docs', 'wiki')),
+  ]
+
+  // Assert
+  assert.deepEqual(found, [
+    join(root, '.codebook'),
+    join(root, '.codebook'),
+    root,
+  ])
+})
diff --git a/extension/src/tests/fullCommitHash.test.ts b/extension/src/tests/fullCommitHash.test.ts
new file mode 100644
index 000000000..91646f8a8
--- /dev/null
+++ b/extension/src/tests/fullCommitHash.test.ts
@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { fullCommitHash } from '../utils/fullCommitHash'
+
+// Value: protects=the revision handed to Git: only a SHA-1 (40) or SHA-256 (64) object name passes; fails_when=a length between the two (41 to 63 digits) or a non-hex text is taken as a full hash; no_claim=that the hash names a commit that exists; seam=the pure function
+test('a revision is a full commit hash only at 40 or 64 hexadecimal digits', () => {
+  // Arrange
+  const lengths = [39, 40, 41, 63, 64, 65]
+
+  // Act
+  const accepted = lengths.map(
+    (length) => fullCommitHash('a'.repeat(length)) !== undefined,
+  )
+
+  // Assert
+  assert.deepEqual(accepted, [false, true, false, false, true, false])
+})
+
+// Value: protects=the revision handed to Git against branch names and option-like text; fails_when=a non-hex text, an empty text or no revision is returned as a hash; no_claim=the case rule beyond what the function already keeps (upper case digits are accepted); seam=the pure function
+test('a branch name, a text with a non-hex digit, an empty text and no revision are no full hash, while upper case digits keep counting', () => {
+  // Arrange
+  const nonHex = `${'a'.repeat(39)}g`
+  const upperCase = 'ABCDEF0123456789ABCDEF0123456789ABCDEF01'
+
+  // Act
+  const results = [
+    fullCommitHash('main'),
+    fullCommitHash(nonHex),
+    fullCommitHash(''),
+    fullCommitHash(undefined),
+    fullCommitHash(upperCase),
+  ]
+
+  // Assert
+  assert.deepEqual(results, [
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    upperCase,
+  ])
+})
diff --git a/extension/src/tests/llmWikiManifest.test.ts b/extension/src/tests/llmWikiManifest.test.ts
new file mode 100644
index 000000000..5b5e8ba9d
--- /dev/null
+++ b/extension/src/tests/llmWikiManifest.test.ts
@@ -0,0 +1,162 @@
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { test } from 'node:test'
+
+import { LLM_WIKI_ROW_ACTIONS } from '../constants'
+
+type Manifest = {
+  contributes: {
+    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 }>
+    menus: Record<
+      string,
+      Array<{ command: string; when?: string; group?: string }>
+    >
+  }
+}
+
+const readManifest = async (): Promise<Manifest> =>
+  JSON.parse(await readFile(resolve(__dirname, '../../package.json'), 'utf8'))
+
+// Value: protects=AC 1, the empty state's welcome content by host; fails_when=a host's entry loses its none-state condition, the Generate LLM Wiki button on its own line, the host's runner sentence or the inline Change location settings link; no_claim=how the editor renders it (N55 step 1); seam=the packaged manifest
+test('the LLM Wiki view’s welcome content shows only in the none state, per host, with a Generate button on its own line and a Change location link', async () => {
+  // Arrange
+  const manifest = await readManifest()
+
+  // Act
+  const entries = manifest.contributes.viewsWelcome.filter(
+    (entry) => entry.view === 'codebook.llmWiki',
+  )
+
+  // Assert
+  assert.deepEqual(
+    entries.map((entry) => ({
+      when: entry.when,
+      lines: entry.contents.split('\n'),
+    })),
+    [
+      {
+        when: 'codebook.llmWiki.state == none && codebook.host == vscode',
+        lines: [
+          "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)',
+        ],
+      },
+      {
+        when: 'codebook.llmWiki.state == none && codebook.host == cursor',
+        lines: [
+          "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)',
+        ],
+      },
+    ],
+  )
+})
+
+// Value: protects=task 5b and AC-ENTRY, two Activity Bar entries with one icon; fails_when=the Learning summary container uses the same icon file as the codebook container, or its file is missing; no_claim=how the icon looks (N55 step 1); seam=the packaged manifest
+test('the two Activity Bar containers use different icon files', async () => {
+  // Arrange
+  const manifest = await readManifest()
+
+  // Act
+  const icons = Object.fromEntries(
+    manifest.contributes.viewsContainers.activitybar.map((container) => [
+      container.id,
+      container.icon,
+    ]),
+  )
+  const learningIcon = await readFile(
+    resolve(__dirname, '../../src/assets/learning.svg'),
+    'utf8',
+  )
+
+  // Assert
+  assert.deepEqual(icons, {
+    codebook: 'src/assets/book.svg',
+    codebookLearning: 'src/assets/learning.svg',
+  })
+  assert.match(learningIcon, /viewBox="0 0 24 24"/)
+  assert.match(learningIcon, /currentColor/)
+})
+
+// Value: protects=AC 2 (the view sits after Repository Wiki in the codebook container) and keyboard access; fails_when=the view is missing, comes before Repository Wiki, or a row action has no command, no inline entry or no context-menu entry; no_claim=the rows' when conditions at runtime (host tests); seam=the packaged manifest
+test('the LLM Wiki view follows Repository Wiki and every row action is a contributed command with an inline and a context-menu entry', async () => {
+  // Arrange
+  const manifest = await readManifest()
+  const commandIds = new Set(
+    manifest.contributes.commands.map((command) => command.command),
+  )
+  const itemMenu = manifest.contributes.menus['view/item/context'] ?? []
+
+  // Act
+  const missing = Object.entries(LLM_WIKI_ROW_ACTIONS).flatMap(
+    ([key, action]) => {
+      const entries = itemMenu.filter(
+        (entry) =>
+          entry.command === action.command &&
+          entry.when?.includes(`\\[${key}\\]`) === true,
+      )
+      return [
+        commandIds.has(action.command) ? [] : [`${key}: no command`],
+        entries.some((entry) => entry.group?.startsWith('inline@'))
+          ? []
+          : [`${key}: no inline entry`],
+        entries.some((entry) => entry.group?.startsWith('llmWiki@'))
+          ? []
+          : [`${key}: no context-menu entry`],
+      ].flat()
+    },
+  )
+
+  // Assert
+  assert.deepEqual(
+    manifest.contributes.views.codebook.map((view) => view.id),
+    ['codebook.repositoryWiki', 'codebook.llmWiki', 'codebook.learningOutline'],
+  )
+  assert.deepEqual(missing, [])
+  assert.deepEqual(
+    manifest.contributes.menus['view/title']?.filter(
+      (entry) => entry.command === 'codebook.refreshLlmWiki',
+    ),
+    [
+      {
+        command: 'codebook.refreshLlmWiki',
+        when: 'view == codebook.llmWiki',
+        group: 'navigation',
+      },
+    ],
+  )
+})
+
+// Value: protects=the Command Palette of an editor that offers no tree view; fails_when=Refresh LLM Wiki, Copy LLM Wiki Recovery Request or Reveal LLM Wiki Folder is listed in the palette without the view that registers it (the view sets codebook.llmWiki.state), so choosing one says "command not found"; no_claim=that the editor hides them (host trial); seam=the packaged manifest
+test('the palette lists the commands that exist only with the LLM Wiki view only while the view has set its state key', async () => {
+  // Arrange
+  const manifest = await readManifest()
+  const palette = manifest.contributes.menus.commandPalette ?? []
+
+  // Act
+  const whenByCommand = Object.fromEntries(
+    [
+      'codebook.refreshLlmWiki',
+      'codebook.copyWikiRecoveryRequest',
+      'codebook.revealWikiFolder',
+    ].map((command) => [
+      command,
+      palette.find((entry) => entry.command === command)?.when,
+    ]),
+  )
+
+  // Assert
+  assert.deepEqual(whenByCommand, {
+    'codebook.refreshLlmWiki': 'codebook.llmWiki.state',
+    'codebook.copyWikiRecoveryRequest': 'codebook.llmWiki.state',
+    'codebook.revealWikiFolder': 'codebook.llmWiki.state',
+  })
+})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
new file mode 100644
index 000000000..b2f8a4967
--- /dev/null
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -0,0 +1,1668 @@
+import assert from 'node:assert/strict'
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rename,
+  rm,
+  symlink,
+  unlink,
+  utimes,
+  writeFile,
+} from 'node:fs/promises'
+import { homedir, tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { test, type TestContext } from 'node:test'
+
+import { waitUntil } from '../runtimeSupport/utils/waitUntil'
+import { WikiUpdateTimeoutError } from '../utils/wikiUpdateTimeoutError'
+
+import {
+  exists,
+  openProjectWithoutWiki,
+  publishGeneratedWiki,
+} from './utils/openProjectWithoutWiki'
+import { publishedWikiFixture } from './utils/publishedWikiFixture'
+import { openWikiUpdateWindow } from './utils/wikiUpdateWindow'
+
+type Window = Awaited<ReturnType<typeof openWikiUpdateWindow>>
+
+const STATE_KEY = 'codebook.llmWiki.state'
+const GENERATE_COMMAND = 'codebook.generateDeepWiki'
+/** A debounce and a poll short enough to wait for. */
+const FAST = { LLM_WIKI_REFRESH_DEBOUNCE_MS: 40, LLM_WIKI_POLL_MS: 120 }
+/** The glob the view hands the editor for an output folder (given as its path from the watched folder) whose parents are `parents`: the folders themselves, the output folder, its manifest and the three markers. */
+const globFor = (parents: string[], outputName: string): string => {
+  const output = [...parents, outputName].join('/')
+  const folders = [...parents, outputName].map((_name, index, names) =>
+    names.slice(0, index + 1).join('/'),
+  )
+  return `{${[
+    ...folders,
+    `${output}/codebook-wiki.json`,
+    `${output}.update-run.json`,
+    `${output}.publish-lock.json`,
+    `${output}.publish-journal.json`,
+  ].join(',')}}`
+}
+
+const idsOf = (window: Window): string[] =>
+  window.llmWiki.rows().map((row) => row.id)
+const rowOf = (window: Window, rowId: string) =>
+  window.llmWiki.rows().find((row) => row.id === rowId)
+
+/** Waits until the view has read its state for the first time. */
+const untilFirstRead = (window: Window) =>
+  waitUntil(
+    () => window.llmWiki.contextKeys[STATE_KEY] !== 'loading',
+    'the first read of the LLM Wiki state',
+    6_000,
+  )
+/** Waits until a row with this id is shown, or gone. */
+const untilRow = (window: Window, rowId: string, isShown = true) =>
+  waitUntil(
+    () => (rowOf(window, rowId) !== undefined) === isShown,
+    `the ${rowId} row ${isShown ? 'to show' : 'to go'}`,
+    6_000,
+  )
+/** Waits until the Wiki row's freshness check has answered. */
+const untilFreshness = (window: Window) =>
+  waitUntil(
+    () => rowOf(window, 'wiki')?.description !== 'Checking freshness…',
+    'the freshness label',
+    6_000,
+  )
+
+/** Opens a window on a project with a real published Wiki. */
+async function openPublishedWiki(
+  context: TestContext,
+  options: Partial<Parameters<typeof openWikiUpdateWindow>[0]> = {},
+  prepare: (
+    wiki: Awaited<ReturnType<typeof publishedWikiFixture>>,
+  ) => Promise<void> = async () => {},
+) {
+  const wiki = await publishedWikiFixture()
+  await prepare(wiki)
+  const window = await openWikiUpdateWindow({
+    constants: FAST,
+    ...options,
+    projectRoot: wiki.projectRoot,
+    openReader: false,
+  })
+  context.after(async () => {
+    await window.close()
+    await wiki.cleanup()
+  })
+  await untilFirstRead(window)
+  return { wiki, window }
+}
+
+/** Opens a window on a project with no Wiki, with the view's short timing. */
+async function openEmptyProject(
+  context: TestContext,
+  options: Parameters<typeof openProjectWithoutWiki>[0] = {},
+) {
+  const project = await openProjectWithoutWiki({ constants: FAST, ...options })
+  context.after(() => project.close())
+  await untilFirstRead(project)
+  return project
+}
+
+// Value: protects=AC 1 and AC 2 (loading), the welcome content not showing before the first read; fails_when=the state key is not `loading` until the first read ends, or the tree shows no reading row; no_claim=the welcome text; seam=a start check held open
+test('until its first read ends the view shows Reading the LLM Wiki state and the state key is loading, then none', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    constants: FAST,
+    holdAtOpen: ['start-block'],
+  })
+  context.after(() => project.close())
+
+  // Act
+  const whileLoading = {
+    contextState: project.llmWiki.contextKeys[STATE_KEY],
+    labels: project.llmWiki.rows().map((row) => row.label),
+  }
+  project.hold('start-block').release()
+  await untilFirstRead(project)
+
+  // Assert
+  assert.deepEqual(whileLoading, {
+    contextState: 'loading',
+    labels: ['Reading the LLM Wiki state…'],
+  })
+  assert.equal(project.llmWiki.contextKeys[STATE_KEY], 'none')
+})
+
+// Value: protects=AC 1, the empty state; fails_when=a folder with no Wiki returns a row, sets a TreeView message or leaves the state key other, so the welcome content with Generate LLM Wiki never shows; no_claim=the welcome text (manifest test); seam=the stubbed editor's tree view
+test('a folder with no Wiki returns no rows and no message and sets the state key none, with the host key vscode', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+
+  // Act
+  const shown = {
+    rows: project.llmWiki.rows(),
+    message: project.llmWiki.message(),
+    state: project.llmWiki.contextKeys[STATE_KEY],
+    host: project.llmWiki.contextKeys['codebook.host'],
+  }
+
+  // Assert
+  assert.deepEqual(shown, {
+    rows: [],
+    message: undefined,
+    state: 'none',
+    host: 'vscode',
+  })
+})
+
+// Value: protects=AC 1, the welcome content chosen by host; fails_when=Cursor sets the VS Code host key, so Cursor's welcome shows the Copilot Chat sentence; no_claim=the welcome text; seam=the stubbed editor's context keys
+test('Cursor sets the host key cursor', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, { cursor: true })
+
+  // Act
+  const host = project.llmWiki.contextKeys['codebook.host']
+
+  // Assert
+  assert.equal(host, 'cursor')
+})
+
+// Value: protects=AC 2 row 1 and the loading label; fails_when=the Wiki row hides while the freshness check runs, never shows Checking freshness…, or opens anything but the browser Wiki; no_claim=the freshness check; seam=a freshness inspection held open
+test('a published Wiki opens in the browser from its row and reads Checking freshness… until the check answers', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context, {
+    holdAtOpen: ['freshness-inspection'],
+  })
+  const whileChecking = rowOf(window, 'wiki')
+
+  // Act
+  window.hold('freshness-inspection').release()
+  await untilFreshness(window)
+
+  // Assert
+  assert.deepEqual(
+    [
+      whileChecking?.description,
+      whileChecking?.command?.command,
+      rowOf(window, 'wiki')?.description,
+      idsOf(window),
+      window.llmWiki.contextKeys[STATE_KEY],
+    ],
+    [
+      'Checking freshness…',
+      'codebook.openDeepWiki',
+      'Source changed · Update available',
+      ['wiki', 'output'],
+      'other',
+    ],
+  )
+})
+
+// Value: protects=AC 10 (accepted X1) with a manifest the real publisher wrote; fails_when=the tooltip names no revision, or one that is not the first 7 characters of the manifest's revision; no_claim=the date's locale; seam=a Wiki published by the shipped publisher
+test('the Wiki row tooltip names the first seven characters of the manifest revision and the date of the publication', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context)
+
+  // Act
+  const tooltip = rowOf(window, 'wiki')?.tooltip
+
+  // Assert
+  assert.match(tooltip ?? '', /^Generated from a1b2c3d on .+\nClick to open/)
+})
+
+const ATTENTION_HOST_CASES: Array<{
+  name: string
+  prepare: (
+    wiki: Awaited<ReturnType<typeof publishedWikiFixture>>,
+  ) => Promise<void>
+  label: string
+  shortCause: string
+  isWikiShown: boolean
+}> = [
+  {
+    name: 'edited-page',
+    prepare: async (wiki): Promise<void> =>
+      writeFile(join(wiki.outputDirectory, 'index.html'), '<h1>Mine</h1>'),
+    label: 'Wiki files changed by hand',
+    shortCause: 'page edited by hand',
+    isWikiShown: true,
+  },
+  {
+    name: 'missing-page',
+    prepare: async (wiki): Promise<void> =>
+      rm(join(wiki.outputDirectory, 'index.html')),
+    label: 'Wiki files changed by hand',
+    shortCause: 'page missing',
+    isWikiShown: true,
+  },
+  {
+    name: 'special-file',
+    prepare: async (wiki): Promise<void> =>
+      symlink(wiki.learnerFile, join(wiki.outputDirectory, 'shared.md')),
+    label: 'Wiki files changed by hand',
+    shortCause: 'link or special file',
+    isWikiShown: true,
+  },
+  {
+    name: 'edited-manifest',
+    prepare: async (wiki): Promise<void> => {
+      const manifestPath = join(wiki.outputDirectory, 'codebook-wiki.json')
+      await writeFile(manifestPath, `${await readFile(manifestPath, 'utf8')}\n`)
+    },
+    label: 'Wiki manifest needs recovery',
+    shortCause: 'manifest edited',
+    isWikiShown: false,
+  },
+  {
+    name: 'unreadable-manifest',
+    prepare: async (wiki): Promise<void> =>
+      writeFile(
+        join(wiki.outputDirectory, 'codebook-wiki.json'),
+        '{ "schemaVersion": 1, "pages": [',
+      ),
+    label: 'Wiki manifest needs recovery',
+    shortCause: 'manifest unreadable',
+    isWikiShown: false,
+  },
+  {
+    name: 'unfinished-publish',
+    prepare: async (wiki): Promise<void> => {
+      const journal = `${wiki.outputDirectory}.publish-journal.json`
+      await writeFile(journal, JSON.stringify({ operation: 'publish' }))
+      const longAgo = new Date(Date.now() - 3_600_000)
+      await utimes(journal, longAgo, longAgo)
+    },
+    label: 'Publish in progress or stopped',
+    shortCause: 'unfinished publish',
+    isWikiShown: true,
+  },
+  {
+    name: 'held-publish-lock',
+    prepare: async (wiki): Promise<void> => {
+      const lock = `${wiki.outputDirectory}.publish-lock.json`
+      await writeFile(lock, JSON.stringify({ pid: 99_999_999 }))
+      const longAgo = new Date(Date.now() - 3_600_000)
+      await utimes(lock, longAgo, longAgo)
+    },
+    label: 'Publish in progress or stopped',
+    shortCause: 'publish lock found',
+    isWikiShown: true,
+  },
+  {
+    name: 'not-a-folder',
+    prepare: async (wiki): Promise<void> => {
+      await rm(wiki.outputDirectory, { recursive: true })
+      await writeFile(wiki.outputDirectory, 'a file where the folder was')
+    },
+    label: 'Wiki folder belongs elsewhere',
+    shortCause: 'output is a file or link',
+    isWikiShown: false,
+  },
+  {
+    name: 'linked-parent',
+    prepare: async (wiki): Promise<void> => {
+      const movedAside = join(wiki.projectRoot, 'moved-codebook')
+      await rename(join(wiki.projectRoot, '.codebook'), movedAside)
+      await symlink(movedAside, join(wiki.projectRoot, '.codebook'), 'junction')
+    },
+    label: 'Wiki folder belongs elsewhere',
+    shortCause: 'link on the folder path',
+    isWikiShown: false,
+  },
+]
+
+for (const attentionCase of ATTENTION_HOST_CASES) {
+  // Value: protects=AC 2, each start block the update start finds is a row of the view with its label and its Wiki row rule; fails_when=the cause shows another label, or hides the readable Wiki for a cause that leaves it readable, or keeps an unusable one; no_claim=the learner-file cause, which only a run's end finds (the pure matrix); seam=a Wiki published by the shipped publisher, then damaged on disk
+  test(`the view shows ${attentionCase.label} for a published Wiki with ${attentionCase.name}`, async (context) => {
+    // Arrange
+    const { window } = await openPublishedWiki(
+      context,
+      {},
+      attentionCase.prepare,
+    )
+    await untilRow(window, 'attention')
+
+    // Act
+    const attention = rowOf(window, 'attention')
+
+    // Assert
+    assert.deepEqual(
+      [
+        attention?.label,
+        attention?.description,
+        rowOf(window, 'wiki') !== undefined,
+      ],
+      [
+        attentionCase.label,
+        attentionCase.shortCause,
+        attentionCase.isWikiShown,
+      ],
+    )
+  })
+}
+
+// Value: protects=AC 2 (the foreign manifest), a Wiki folder of another checkout; fails_when=a manifest naming another checkout shows the Wiki row or any label but the one that sends the learner to Change location; no_claim=the refusal sentences of Generate and Update; seam=a hand-written manifest of another repository
+test('a manifest of another checkout shows Wiki folder belongs elsewhere with Change location and no Wiki row', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({ constants: FAST })
+  context.after(() => project.close())
+  await publishGeneratedWiki(
+    project.outputDirectory,
+    project.projectRoot,
+    '/somewhere/else',
+  )
+  await project.runCommand('codebook.refreshLlmWiki')
+  await untilRow(project, 'attention')
+
+  // Act
+  const attention = rowOf(project, 'attention')
+
+  // Assert
+  assert.deepEqual(
+    [
+      attention?.label,
+      attention?.description,
+      attention?.contextValue,
+      idsOf(project),
+    ],
+    [
+      'Wiki folder belongs elsewhere',
+      'another checkout',
+      '[change-location]',
+      ['attention', 'output'],
+    ],
+  )
+})
+
+// Value: protects=AC 2 (the row click shows the cause's sentence with Copy details); fails_when=clicking the attention row shows another sentence than the update's, offers no Copy details, or copies the home folder instead of ~; no_claim=every cause's wording (describeWikiUpdate tests); seam=a hand-edited page
+test('clicking the attention row shows the update’s sentence with the page it names and Copy details copies it', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(
+    context,
+    { chooseAction: (_message, actions) => actions[0] },
+    async (wiki) =>
+      writeFile(join(wiki.outputDirectory, 'index.html'), '<h1>Mine</h1>'),
+  )
+  await untilRow(window, 'attention')
+  const click = rowOf(window, 'attention')?.command
+
+  // Act
+  await window.runCommand(click?.command ?? '', ...(click?.arguments ?? []))
+  await waitUntil(
+    () => window.clipboard.length > 0,
+    'the copied details',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    [
+      { command: click?.command, arguments: click?.arguments },
+      window.warnings[0]?.includes('index.html'),
+      window.offeredActions[0]?.actions,
+      window.clipboard[0] === window.warnings[0]?.split(homedir()).join('~'),
+    ],
+    [
+      { command: 'codebook.showLlmWikiAttention', arguments: ['attention'] },
+      true,
+      ['Copy details'],
+      true,
+    ],
+  )
+})
+
+// Value: protects=AC 2 (the folder and trust rows); fails_when=a window without a folder shows no Open Folder row, an untrusted folder shows no Manage Workspace Trust row, or trust granted later does not replace it; no_claim=the editor's own trust dialog; seam=the stubbed editor's trust and folder state
+test('a window without a folder offers Open Folder and an untrusted folder offers Manage Workspace Trust until trust is granted', async (context) => {
+  // Arrange
+  const noFolder = await openWikiUpdateWindow({
+    projectRoot: tmpdir(),
+    openReader: false,
+    noFolder: true,
+    constants: FAST,
+  })
+  context.after(() => noFolder.close())
+  const { window: untrusted } = await openPublishedWiki(context, {
+    trusted: false,
+  })
+  const whileUntrusted = idsOf(untrusted)
+
+  // Act
+  untrusted.grantTrust()
+  await untilRow(untrusted, 'wiki')
+
+  // Assert
+  assert.deepEqual(
+    [
+      noFolder.llmWiki
+        .rows()
+        .map((row) => [row.id, row.label, row.contextValue]),
+      whileUntrusted,
+      idsOf(untrusted),
+    ],
+    [
+      [['folder', 'Open a folder to use the LLM Wiki', '[open-folder]']],
+      ['trust'],
+      ['wiki', 'output'],
+    ],
+  )
+})
+
+// Value: protects=the manage-trust id decision; fails_when=the action runs an id the editor does not list, or runs none and says nothing; no_claim=that the id exists in Cursor (native trial); seam=the stubbed editor's command list
+test('Manage Workspace Trust runs the first known trust command the editor lists, and says where to find it when it lists none', async (context) => {
+  // Arrange
+  const { window: listed } = await openPublishedWiki(context, {
+    trusted: false,
+    extraEditorCommands: ['workbench.action.manageTrust'],
+  })
+  const { window: unlisted } = await openPublishedWiki(context, {
+    trusted: false,
+  })
+
+  // Act
+  await listed.runCommand('codebook.llmWiki.manageTrust')
+  await unlisted.runCommand('codebook.llmWiki.manageTrust')
+
+  // Assert
+  assert.deepEqual(
+    [listed.executedCommands, unlisted.executedCommands, unlisted.notices],
+    [
+      ['workbench.action.manageTrust'],
+      [],
+      [
+        'Run "Workspaces: Manage Workspace Trust" from the Command Palette to trust this folder.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=AC 2 (error row); fails_when=a read that throws leaves the tree empty or on loading, writes no cause to Output, or does not recover at Refresh; no_claim=the cause's wording; seam=a folder that no longer exists
+test('a read that throws shows Could not read the LLM Wiki state, records the cause in Output and recovers at Refresh', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  const realRoot = project.projectRoot
+  project.openWorkspace(join(realRoot, 'does-not-exist'))
+
+  // Act
+  await project.runCommand('codebook.refreshLlmWiki')
+  const errorRow = rowOf(project, 'error')
+  project.openWorkspace(realRoot)
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [
+      errorRow?.label,
+      errorRow?.description,
+      errorRow?.command?.command,
+      project.outputLines.some((line) =>
+        line.startsWith('error: The LLM Wiki view could not read its state: '),
+      ),
+      project.llmWiki.contextKeys[STATE_KEY],
+    ],
+    [
+      'Could not read the LLM Wiki state',
+      'Refresh to retry',
+      'codebook.showWikiOutput',
+      true,
+      'none',
+    ],
+  )
+})
+
+// Value: protects=AC 2 (refresh on a change of the Wiki files); fails_when=a manifest created on disk does not show the Wiki row after the watcher's event, an event of an unrelated file reads the state, or the view polls when no run row shows; no_claim=VS Code's real watcher; seam=the fake file watching
+test('a manifest created in the output folder shows the Wiki row after the watcher event, and an unrelated file’s event reads nothing', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  const readsAtStart = project.looks.publishTokenReads
+
+  // Act
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  project.reportFileEvent('create', join(project.projectRoot, 'notes.md'))
+  await new Promise((resolve) => setTimeout(resolve, 300))
+  const idsBeforeTheEvent = idsOf(project)
+  const readsBeforeTheEvent = project.looks.publishTokenReads
+  project.reportFileEvent(
+    'create',
+    join(project.outputDirectory, 'codebook-wiki.json'),
+  )
+  await untilRow(project, 'wiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsBeforeTheEvent, readsBeforeTheEvent - readsAtStart],
+    [[], 0],
+  )
+})
+
+// Value: protects=AC 2 (the trailing debounce); fails_when=a burst of events reads the state once per event (more than the burst's read and the one follow-up read of the watcher's move), or the last event of the burst is dropped; no_claim=the 1 second value (a constant); seam=five events 10 ms apart, with the debounce shortened to 40 ms
+test('five file events inside the debounce become one read that shows the last state', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  const readsAtStart = project.looks.publishTokenReads
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const manifestPath = join(project.outputDirectory, 'codebook-wiki.json')
+
+  // Act
+  for (let event = 0; event < 5; event += 1) {
+    project.reportFileEvent('change', manifestPath)
+    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))
+
+  // 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.
+  assert.equal(project.looks.publishTokenReads - readsAtStart, 2)
+})
+
+// Value: protects=AC 2 (refresh on the setting and on visibility); fails_when=changing codebook.wikiOutputDirectory or showing the view again does not read the state, or the watcher stays on the old folder; no_claim=VS Code's settings UI; seam=the stubbed configuration event and visibility event
+test('changing the output setting and showing the view again read the state again and move the watcher', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(context)
+  const patternsAtStart = window.watchedPatterns().length
+  await publishGeneratedWiki(
+    join(wiki.projectRoot, 'docs', 'wiki'),
+    wiki.projectRoot,
+  )
+
+  // Act
+  window.setOutputSetting('docs/wiki')
+  await waitUntil(
+    () => rowOf(window, 'output')?.label === 'Output: docs/wiki',
+    'the new output folder',
+    6_000,
+  )
+  const watchedAfterTheSetting = window.watchedPatterns().at(-1)
+  await rm(join(wiki.projectRoot, 'docs'), { recursive: true })
+  window.llmWiki.setVisible(true)
+  await untilRow(window, 'wiki', false)
+
+  // Assert
+  assert.deepEqual(
+    [
+      window.watchedPatterns().length > patternsAtStart,
+      watchedAfterTheSetting?.base,
+      watchedAfterTheSetting?.pattern,
+      window.llmWiki.contextKeys[STATE_KEY],
+    ],
+    [true, join(wiki.projectRoot, 'docs'), globFor([], 'wiki'), 'none'],
+  )
+})
+
+// Value: protects=AC 2 (the 30 second poll for rows 2b); fails_when=a marker whose window died leaves a row for another window forever because no file event arrives; no_claim=the 30 second value; seam=a marker removed without a file event, the poll shortened to 120 ms
+test('another window’s run row disappears at the next poll after its marker is removed without a file event', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(
+    context,
+    {},
+    async (fixture) => {
+      await writeFile(
+        `${fixture.outputDirectory}.update-run.json`,
+        JSON.stringify({
+          pid: process.pid,
+          windowId: 'the-other-window',
+          host: 'vscode',
+          startedAtMs: Date.now() - 60_000,
+          runKind: 'update',
+        }),
+      )
+    },
+  )
+  const rowsWhileItRuns = idsOf(window)
+
+  // Act
+  await unlink(`${wiki.outputDirectory}.update-run.json`)
+  await untilRow(window, 'elsewhere', false)
+
+  // Assert
+  assert.deepEqual(
+    [rowsWhileItRuns, rowOf(window, 'wiki')?.contextValue, idsOf(window)],
+    [['wiki', 'elsewhere', 'output'], '[update]', ['wiki', 'output']],
+  )
+})
+
+// Value: protects=AC 2 (an output outside the workspace); fails_when=an output folder outside the project shows no Wiki, or the label is not its absolute path; no_claim=the editor's watch outside the workspace; seam=an absolute output setting
+test('an output folder outside the project shows its Wiki with the absolute folder as its label', async (context) => {
+  // Arrange
+  const outside = await mkdtemp(join(tmpdir(), 'codebook-outside-wiki-'))
+  context.after(() => rm(outside, { recursive: true, force: true }))
+  const project = await openProjectWithoutWiki({
+    constants: FAST,
+    outputSetting: join(outside, 'wiki'),
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(join(outside, 'wiki'), project.projectRoot)
+
+  // Act
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [rowOf(project, 'output')?.label, project.watchedPatterns().at(-1)?.base],
+    [`Output: ${join(outside, 'wiki')}`, outside],
+  )
+})
+
+// Value: protects=AC 2 (a missing output parent) and Eng decision 78; fails_when=the watcher stands on a folder that does not exist, or is not made again on the folder a run creates; no_claim=VS Code's watcher on the root; seam=a Cursor generation whose agent waits
+test('in a fresh project the watcher stands on the project and moves to .codebook once a run makes it', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: (_root, _prompt, signal) =>
+      new Promise<string>((_resolve, reject) =>
+        signal?.addEventListener('abort', () => reject(new Error('stopped'))),
+      ),
+  })
+  const watchedAtStart = project.watchedPatterns().at(-1)
+
+  // Act
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  await waitUntil(
+    () => project.watchedPatterns().at(-1)?.base !== watchedAtStart?.base,
+    'the watcher on .codebook',
+    6_000,
+  )
+  await project.runCommand('codebook.llmWiki.cancelRun')
+
+  // Assert
+  assert.deepEqual(
+    [watchedAtStart, project.watchedPatterns().at(-1)],
+    [
+      {
+        base: project.projectRoot,
+        pattern: globFor(['.codebook'], 'wiki'),
+      },
+      {
+        base: join(project.projectRoot, '.codebook'),
+        pattern: globFor([], 'wiki'),
+      },
+    ],
+  )
+})
+
+// Value: protects=AC 2 (an output folder deleted while the view is open); fails_when=the Wiki row stays after its folder is deleted, or the empty state does not come back; no_claim=the watcher's delete event of the real editor; seam=the fake delete event
+test('an output folder deleted while the view is open brings back the empty state', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(context)
+
+  // Act
+  await rm(wiki.outputDirectory, { recursive: true })
+  window.reportFileEvent(
+    'delete',
+    join(wiki.outputDirectory, 'codebook-wiki.json'),
+  )
+  await untilRow(window, 'wiki', false)
+
+  // Assert
+  assert.deepEqual(
+    [window.llmWiki.rows(), window.llmWiki.contextKeys[STATE_KEY]],
+    [[], 'none'],
+  )
+})
+
+// Value: protects=AC 2 (a refresh with nothing new fires no tree change) and accessibility; fails_when=Refresh with an unchanged state fires a tree change, which a screen reader announces; no_claim=focus handling; seam=the tree view's change event count
+test('Refresh with nothing new fires no tree change', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context)
+  await untilFreshness(window)
+  const changesBefore = window.llmWiki.treeChangeCount()
+
+  // Act
+  await window.runCommand('codebook.refreshLlmWiki')
+  await window.runCommand('codebook.refreshLlmWiki')
+  // gstack-timing-ok: proves no tree change arrives later; waits five times the shortened 40 ms debounce
+  await new Promise((resolve) => setTimeout(resolve, 200))
+
+  // Assert
+  assert.equal(window.llmWiki.treeChangeCount() - changesBefore, 0)
+})
+
+// Value: protects=AC 2 (row 2 and the TreeView message in VS Code); fails_when=a VS Code generation shows no Generating row with Waiting for the chat to start, lacks Stop watching, Open Chat and Show Output as inline actions, shows them as the row click, or lacks the wrapping message; no_claim=the minutes (pure matrix); seam=a chat that never answers
+test('a VS Code generation shows Generating… waiting for the chat, with its three inline actions and the watching message', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+
+  // Act
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  const run = rowOf(project, 'run')
+
+  // Assert
+  assert.deepEqual(
+    [
+      run?.label,
+      run?.description,
+      run?.contextValue,
+      run?.command,
+      project.llmWiki.message(),
+      project.llmWiki.contextKeys[STATE_KEY],
+    ],
+    [
+      'Generating…',
+      'Waiting for the chat to start',
+      '[stop-watching][open-chat][show-output]',
+      undefined,
+      'Codebook is watching the chat. Stop watching does not stop the chat; stop it in the chat.',
+      'other',
+    ],
+  )
+})
+
+// Value: protects=AC 2 (row 2c) and AC 4; fails_when=Stop watching leaves no Waiting for chat row with its retry time, or the message still says Codebook is watching once the watch has stopped; no_claim=the reservation's bound (marker tests); seam=a chat that never answers, stopped through the view's own action
+test('Stop watching in the view ends the generation and leaves a Waiting for chat row with the retry time', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+
+  // Act
+  await project.runCommand('codebook.llmWiki.stopWatching')
+  await untilRow(project, 'reservation')
+
+  // Assert
+  assert.deepEqual(
+    [
+      idsOf(project),
+      rowOf(project, 'reservation')?.label,
+      rowOf(project, 'reservation')?.description?.startsWith('retry after '),
+      rowOf(project, 'reservation')?.contextValue,
+      rowOf(project, 'last-attempt')?.description,
+      project.llmWiki.message(),
+    ],
+    [
+      ['run', 'reservation', 'last-attempt', 'output'].filter(
+        (id) => id !== 'run',
+      ),
+      'Waiting for chat',
+      true,
+      '[open-chat]',
+      'stopped watching',
+      'Codebook stopped watching the chat, which may still publish this Wiki. To stop it, stop the request in the chat.',
+    ],
+  )
+})
+
+// Value: protects=the late-publication notice and AC 4 (a late publication shows as published, no run claims it); fails_when=a Wiki the chat publishes after Stop watching shows no notice with Open in Browser, leaves the reservation or the last-attempt row, or shows the notice twice; no_claim=the browser opening; seam=a publication written after the watch stopped, with the watcher event
+test('a Wiki published after Stop watching shows the notice with Open in Browser and replaces the reservation and the last attempt', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  await project.runCommand('codebook.llmWiki.stopWatching')
+  await untilRow(project, 'reservation')
+  const noticesBefore = project.notices.length
+
+  // Act
+  // gstack-timing-ok: separates the publication's file times from the earlier read; no assertion measures the wait
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  project.reportFileEvent(
+    'create',
+    join(project.outputDirectory, 'codebook-wiki.json'),
+  )
+  await untilRow(project, 'wiki')
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [
+      idsOf(project),
+      project.notices.slice(noticesBefore),
+      project.offeredActions.at(-1),
+    ],
+    [
+      ['wiki', 'output'],
+      ['An LLM Wiki was published in .codebook/wiki.'],
+      {
+        message: 'An LLM Wiki was published in .codebook/wiki.',
+        actions: ['Open in Browser'],
+      },
+    ],
+  )
+})
+
+// Value: protects=AC 2 row 3 and AC 4; fails_when=a Cursor generation whose agent exits 1 without publishing shows no Last generation stopped row with its cause and Try again, the click shows another sentence, or Try again starts nothing; no_claim=the end sentence's wording (generate flow tests); seam=an agent that fails with an exit code
+test('a Cursor generation that ends with exit code 1 shows Last generation stopped, its sentence on click and Try again', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: async () => {
+      throw Object.assign(new Error('The agent stopped.'), {
+        exitCode: 1,
+        exitSignal: null,
+      })
+    },
+  })
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await untilRow(project, 'last-attempt')
+  const row = rowOf(project, 'last-attempt')
+
+  // Act
+  await project.runCommand(
+    row?.command?.command ?? '',
+    ...(row?.command?.arguments ?? []),
+  )
+
+  // Assert
+  assert.deepEqual(
+    [
+      row?.label,
+      row?.description,
+      row?.contextValue,
+      project.warnings.length,
+      idsOf(project),
+    ],
+    [
+      'Last generation stopped',
+      'agent exit 1',
+      '[try-again]',
+      1,
+      ['last-attempt', 'output'],
+    ],
+  )
+})
+
+// Value: protects=AC 2 (row 2 in Cursor, no Open Chat, no message); fails_when=a Cursor run shows Stop watching or Open Chat, the VS Code message, or no cursor-agent progress; no_claim=the agent's work; seam=a Cursor agent that waits for its abort
+test('a Cursor generation shows cursor-agent progress with Cancel and Show Output and no watching message, and Cancel ends it', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: (_root, _prompt, signal) =>
+      new Promise<string>((_resolve, reject) =>
+        signal?.addEventListener('abort', () => reject(new Error('stopped'))),
+      ),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  const run = rowOf(project, 'run')
+
+  // Act
+  await project.runCommand('codebook.llmWiki.cancelRun')
+  await untilRow(project, 'run', false)
+
+  // Assert
+  assert.deepEqual(
+    [
+      run?.description,
+      run?.contextValue,
+      project.llmWiki.message(),
+      rowOf(project, 'last-attempt')?.description,
+    ],
+    [
+      'cursor-agent · 0 min of 55',
+      '[cancel-run][show-output]',
+      undefined,
+      'cancelled',
+    ],
+  )
+})
+
+// Value: protects=AC 2 (row 1 beside a run); fails_when=a published Wiki disappears or keeps its Update action while an update runs; no_claim=the update's own work; seam=a Cursor update whose agent waits
+test('a published Wiki stays readable beside a running update and offers no second Update', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context, {
+    cursor: true,
+    cursorAgent: (_root, _prompt, signal) =>
+      new Promise<string>((_resolve, reject) =>
+        signal?.addEventListener('abort', () => reject(new Error('stopped'))),
+      ),
+  })
+  await untilFreshness(window)
+
+  // Act
+  void window.runUpdateCommand()
+  await untilRow(window, 'run')
+  const rows = window.llmWiki.rows()
+  await window.runCommand('codebook.llmWiki.cancelRun')
+
+  // Assert
+  assert.deepEqual(
+    rows.map((row) => [row.id, row.contextValue]),
+    [
+      ['wiki', ''],
+      ['run', '[cancel-run][show-output]'],
+      ['output', '[change-location]'],
+    ],
+  )
+})
+
+// Value: protects=AC 2 (a watcher that cannot be created); fails_when=the view fails, writes the cause more than once, or hides in the Output row that it refreshes on visibility and Refresh only; no_claim=the cause's wording; seam=a refused file watcher
+test('a refused file watcher is recorded once in Output, said in the Output row’s tooltip, and Refresh still works', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(context, {
+    wikiWatcherFails: 'no watcher available',
+  })
+  await window.runCommand('codebook.refreshLlmWiki')
+  await unlink(join(wiki.outputDirectory, 'index.html'))
+
+  // Act
+  await window.runCommand('codebook.refreshLlmWiki')
+  await untilRow(window, 'attention')
+
+  // Assert
+  assert.deepEqual(
+    [
+      window.outputLines.filter((line) => line.includes('could not watch')),
+      rowOf(window, 'output')?.tooltip?.includes('refreshes when it is shown'),
+    ],
+    [
+      [
+        'error: The LLM Wiki view could not watch the Wiki folder: no watcher available',
+      ],
+      true,
+    ],
+  )
+})
+
+// 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) => {
+  // 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',
+      ],
+      ['/codebook Recover the unfinished LLM Wiki publish for this project'],
+      ['Copied the recovery request. Paste it into the editor chat.'],
+    ],
+  )
+})
+
+// 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
+  const project = await openWikiUpdateWindow({
+    projectRoot: tmpdir(),
+    openReader: false,
+    noFolder: true,
+    constants: FAST,
+  })
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand('codebook.llmWiki.openFolder')
+
+  // Assert
+  assert.deepEqual(project.executedCommands, ['vscode.openFolder'])
+})
+
+// Value: protects=AC 14 (the view only reads); fails_when=reading the state makes the .codebook folder of a project that has none, which a later Generate must make itself after its confirmation; no_claim=the Generate flow's folder; seam=a project with no .codebook
+test('reading the state of a project without a Wiki makes no folder', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+
+  // Act
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.equal(await exists(join(project.projectRoot, '.codebook')), false)
+})
+
+// Value: protects=AC 2 (refresh on a change of the Wiki files) on Windows and macOS, where the editor may spell a path in another case; fails_when=an event whose path differs from the computed one only in case is dropped, so the view refreshes on poll, visibility and Refresh only; no_claim=the Windows drive-letter form (comparableFilePath tests); seam=the fake file watching reporting another spelling
+test(
+  'a watcher event that spells the manifest path in another case still refreshes the view',
+  { skip: process.platform === 'linux' },
+  async (context) => {
+    // Arrange
+    const project = await openEmptyProject(context)
+    await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+    const manifestPath = join(project.outputDirectory, 'codebook-wiki.json')
+
+    // Act
+    project.reportFileEvent('create', manifestPath, manifestPath.toUpperCase())
+    await untilRow(project, 'wiki')
+
+    // Assert
+    assert.deepEqual(idsOf(project), ['wiki', 'output'])
+  },
+)
+
+// Value: protects=AC 2 (a Wiki folder whose name holds glob characters); fails_when=the watcher's glob embeds `wiki[1]` raw, so the editor reads it as a character class and never reports the manifest; no_claim=the editor's glob engine; seam=the pattern the view hands to createFileSystemWatcher
+test('an output folder named wiki[1] is watched with its brackets escaped in the glob', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+
+  // Act
+  project.setOutputSetting('wiki[1]')
+  await waitUntil(
+    () => project.watchedPatterns().at(-1)?.pattern.includes('wiki[') === true,
+    'the escaped glob',
+    6_000,
+  )
+
+  // Assert
+  assert.equal(
+    project.watchedPatterns().at(-1)?.pattern,
+    globFor([], 'wiki[[]1[]]'),
+  )
+})
+
+// Value: protects=the accessible name of each row (label plus description); fails_when=a row's accessibility label is missing, so the editor reads the tooltip instead, or it drops the description; no_claim=what a screen reader says; seam=the tree item the view hands to the stubbed editor
+test('each row of the view has the accessible name label plus description, and the label alone without a description', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(context, {}, async (wiki) =>
+    writeFile(join(wiki.outputDirectory, 'index.html'), '<h1>Mine</h1>'),
+  )
+  await untilRow(window, 'attention')
+  await untilFreshness(window)
+  const noFolder = await openWikiUpdateWindow({
+    projectRoot: tmpdir(),
+    openReader: false,
+    noFolder: true,
+    constants: FAST,
+  })
+  context.after(() => noFolder.close())
+  await untilFirstRead(noFolder)
+
+  // Act
+  const names = [...window.llmWiki.rows(), ...noFolder.llmWiki.rows()].map(
+    (row) => [row.id, row.accessibleName],
+  )
+
+  // Assert
+  assert.deepEqual(names, [
+    [
+      'wiki',
+      `${rowOf(window, 'wiki')?.label}, ${rowOf(window, 'wiki')?.description}`,
+    ],
+    ['attention', 'Wiki files changed by hand, page edited by hand'],
+    ['output', 'Output: .codebook/wiki, Change location'],
+    ['folder', 'Open a folder to use the LLM Wiki'],
+  ])
+})
+
+// Value: protects=the late-publication notice after one transient read error; fails_when=a failed read forgets that a reservation or failed generation stood, so the publication that follows shows no notice; no_claim=the notice wording; seam=a workspace folder that disappears for one read
+test('a Wiki published after one failed read still shows the late-publication notice', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  await project.runCommand('codebook.llmWiki.stopWatching')
+  await untilRow(project, 'reservation')
+  const noticesBefore = project.notices.length
+  project.openWorkspace(join(project.projectRoot, 'does-not-exist'))
+  await project.runCommand('codebook.refreshLlmWiki')
+  project.openWorkspace(project.projectRoot)
+
+  // Act
+  // gstack-timing-ok: separates the publication's file times from the earlier read; no assertion measures the wait
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(project.notices.slice(noticesBefore), [
+    'An LLM Wiki was published in .codebook/wiki.',
+  ])
+})
+
+// Value: protects=the freshness check running only for a shown Wiki row; fails_when=a manifest that needs recovery hides the Wiki row and the view still runs the Git freshness check for it; no_claim=the check's answer; seam=a freshness inspection held open and watched
+test('a manifest that needs recovery runs no freshness check because no Wiki row is shown', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(
+    context,
+    { holdAtOpen: ['freshness-inspection'] },
+    async (wiki) => {
+      const manifestPath = join(wiki.outputDirectory, 'codebook-wiki.json')
+      await writeFile(manifestPath, `${await readFile(manifestPath, 'utf8')}\n`)
+    },
+  )
+  await untilRow(window, 'attention')
+
+  // Act
+  const didCheckStart = await Promise.race([
+    window.hold('freshness-inspection').started.then(() => true),
+    new Promise<boolean>((resolve) => setTimeout(() => resolve(false), 300)),
+  ])
+
+  // Assert
+  assert.equal(didCheckStart, false)
+})
+
+// Value: protects=deactivation during a read; fails_when=a read that passed readFacts before dispose still creates a file watcher, which then leaks for the life of the editor; no_claim=the rows; seam=the first read held open at the start check, then the window closed
+test('a read that ends after the window closed creates no file watcher', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    constants: FAST,
+    holdAtOpen: ['start-block'],
+  })
+  context.after(() => project.close())
+  const hold = project.hold('start-block')
+  await hold.started
+
+  // Act
+  const closing = project.closeWindow()
+  // gstack-timing-ok: lets the close dispose the view before the held read resumes
+  await new Promise((resolve) => setTimeout(resolve, 100))
+  hold.release()
+  await closing
+  // gstack-timing-ok: proves no watcher appears after the close; waits five times the shortened 40 ms debounce
+  await new Promise((resolve) => setTimeout(resolve, 200))
+
+  // Assert
+  assert.equal(project.liveWatcherCount(), 0)
+})
+
+// Value: protects=AC 2 row 3 (a generation that ran out of time); fails_when=the bound the run passed is not carried from the run state to the row, so a Cursor generation stopped at 55 minutes reads "stopped after 0 minutes" or no cause; no_claim=the end sentence's wording; seam=a Cursor agent that throws the timeout error; why_new=the pure-row table passes timeoutMs by hand, so only a host test proves the run state's bound reaches the row
+test('a Cursor generation that runs past its bound shows Last generation stopped after 55 minutes', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: async () => {
+      throw new WikiUpdateTimeoutError('Cursor Agent timed out.')
+    },
+  })
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await untilRow(project, 'last-attempt')
+
+  // Assert
+  assert.deepEqual(
+    [rowOf(project, 'last-attempt')?.description, idsOf(project)],
+    ['stopped after 55 minutes', ['last-attempt', 'output']],
+  )
+})
+
+// Value: protects=AC 2 row 3 (the last attempt belongs to the folder it ran for); fails_when=after the learner points the output setting at another folder, the stopped generation of the old folder still shows, with Try again for a folder it never touched; no_claim=the setting UI; seam=the stubbed configuration event; why_new=no test changes the folder after a stopped generation
+test('a stopped generation is forgotten when the output setting names another folder', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: async () => {
+      throw Object.assign(new Error('The agent stopped.'), {
+        exitCode: 1,
+        exitSignal: null,
+      })
+    },
+  })
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await untilRow(project, 'last-attempt')
+
+  // Act
+  project.setOutputSetting('docs/other-wiki')
+  await untilRow(project, 'last-attempt', false)
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), project.llmWiki.contextKeys[STATE_KEY]],
+    [[], 'none'],
+  )
+})
+
+/** Opens a project whose generation was stopped by Stop watching, so the reservation row stands. */
+async function openProjectWithReservation(context: TestContext) {
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  await project.runCommand('codebook.llmWiki.stopWatching')
+  await untilRow(project, 'reservation')
+  return project
+}
+
+/** Opens a project whose Cursor generation ended with exit code 1, so the last-attempt row stands. */
+async function openProjectWithLastAttempt(context: TestContext) {
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: async () => {
+      throw Object.assign(new Error('The agent stopped.'), {
+        exitCode: 1,
+        exitSignal: null,
+      })
+    },
+  })
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await untilRow(project, 'last-attempt')
+  return project
+}
+
+/** Opens a project whose Cursor generation is running in this window, so the run row stands. */
+async function openProjectWithRun(context: TestContext) {
+  const project = await openEmptyProject(context, {
+    cursor: true,
+    cursorAgent: (_root, _prompt, signal) =>
+      new Promise<string>((_resolve, reject) =>
+        signal?.addEventListener('abort', () => reject(new Error('stopped'))),
+      ),
+  })
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+  return project
+}
+
+/** Opens a project where another window's live generation stands, so the elsewhere row shows. */
+async function openProjectWithRunElsewhere(context: TestContext) {
+  const project = await openEmptyProject(context)
+  await mkdir(dirname(project.markerPath), { recursive: true })
+  await writeFile(
+    project.markerPath,
+    JSON.stringify({
+      pid: process.pid,
+      windowId: 'the-other-window',
+      host: 'vscode',
+      startedAtMs: Date.now() - 60_000,
+      runKind: 'generate',
+    }),
+  )
+  await project.runCommand('codebook.refreshLlmWiki')
+  await untilRow(project, 'elsewhere')
+  return project
+}
+
+/** Closes the folder, reads, opens it again, reads, and answers the row ids after each read. */
+async function idsWhileFolderIsRemoved(
+  project: Awaited<ReturnType<typeof openEmptyProject>>,
+): Promise<{ removed: string[]; restored: string[] }> {
+  project.closeFolder()
+  await project.runCommand('codebook.refreshLlmWiki')
+  const removed = idsOf(project)
+  project.reopenFolder()
+  await project.runCommand('codebook.refreshLlmWiki')
+  return { removed, restored: idsOf(project) }
+}
+
+// Value: protects=AC 2 row 2c (a reservation that ends without a publication); fails_when=a removed reservation marker leaves the Waiting for chat row, shows a Wiki row, or tells the learner a Wiki was published; no_claim=the reservation's expiry time (marker tests); seam=the marker file removed and the view refreshed; why_new=no test ends a reservation without a publication
+test('a reservation whose marker is gone leaves no Waiting for chat row, no Wiki row and no published notice', async (context) => {
+  // Arrange
+  const project = await openProjectWithReservation(context)
+  const noticesBefore = project.notices.length
+
+  // Act
+  await unlink(project.markerPath)
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), project.notices.length - noticesBefore],
+    [['last-attempt', 'output'], 0],
+  )
+})
+
+// Value: protects=the late-publication notice belonging to its folder; fails_when=after the learner points the output setting at a folder that already holds a Wiki, the view says a Wiki was published, though nothing waited for that folder; no_claim=the setting UI; seam=the stubbed configuration event over a Wiki published beforehand; why_new=only a reservation in one folder and a Wiki in another folder proves the memory is tied to the folder
+test('pointing the output setting at a folder that already holds a Wiki shows its rows and no published notice while a reservation stood', async (context) => {
+  // Arrange
+  const project = await openProjectWithReservation(context)
+  await publishGeneratedWiki(
+    join(project.projectRoot, 'docs', 'wiki'),
+    project.projectRoot,
+  )
+  const noticesBefore = project.notices.length
+
+  // Act
+  project.setOutputSetting('docs/wiki')
+  await untilRow(project, 'wiki')
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), project.notices.length - noticesBefore],
+    [['wiki', 'output'], 0],
+  )
+})
+
+// Value: protects=AC 2 row 2c and the late-publication memory across a removed folder; fails_when=a folder removed and restored loses the reservation row, shows a notice nothing caused, or forgets that a Wiki published afterwards is late; no_claim=VS Code's folder prompts; seam=the stubbed workspace folders; why_new=no test removes the folder while a reservation stands
+test('a folder removed and restored while a reservation stands shows the folder row, then the reservation again, and a later publication still shows its notice once', async (context) => {
+  // Arrange
+  const project = await openProjectWithReservation(context)
+  const noticesBefore = project.notices.length
+
+  // Act
+  const whileRemoved = await idsWhileFolderIsRemoved(project)
+  const noticesAfterRestore = project.notices.length - noticesBefore
+  // gstack-timing-ok: separates the publication's file times from the earlier read; no assertion measures the wait
+  await new Promise((resolve) => setTimeout(resolve, 20))
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [whileRemoved, noticesAfterRestore, project.notices.slice(noticesBefore)],
+    [
+      {
+        removed: ['folder'],
+        restored: ['reservation', 'last-attempt', 'output'],
+      },
+      0,
+      ['An LLM Wiki was published in .codebook/wiki.'],
+    ],
+  )
+})
+
+// Value: protects=AC 2 row 3 across a removed folder; fails_when=a folder removed and restored loses the Last generation stopped row; no_claim=VS Code's folder prompts; seam=the stubbed workspace folders; why_new=no test removes the folder while a last attempt stands
+test('a folder removed and restored while a stopped generation stands shows the folder row, then Last generation stopped again', async (context) => {
+  // Arrange
+  const project = await openProjectWithLastAttempt(context)
+
+  // Act
+  const whileRemoved = await idsWhileFolderIsRemoved(project)
+
+  // Assert
+  assert.deepEqual(whileRemoved, {
+    removed: ['folder'],
+    restored: ['last-attempt', 'output'],
+  })
+})
+
+// Value: protects=AC 2 row 2 (the plan's presence condition: this window's run, whatever folder the setting names now); fails_when=after the output setting names another folder the run row of this window's running generation disappears, so its Cancel is no longer in the view; no_claim=what the run does to the old folder; seam=the stubbed configuration event over a Cursor generation that waits; why_new=no test changes the folder while a run stands
+test('the run row stays, with its Cancel, when the output setting names another folder during the run', async (context) => {
+  // Arrange
+  const project = await openProjectWithRun(context)
+
+  // Act
+  project.setOutputSetting('docs/other-wiki')
+  await waitUntil(
+    () => rowOf(project, 'output')?.label === 'Output: docs/other-wiki',
+    'the new output folder',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), rowOf(project, 'run')?.contextValue],
+    [['run', 'output'], '[cancel-run][show-output]'],
+  )
+})
+
+// Value: protects=AC 2 row 2 across a removed folder; fails_when=a folder removed and restored loses the run row of a running generation; no_claim=VS Code's folder prompts; seam=the stubbed workspace folders over a Cursor generation that waits; why_new=no test removes the folder while a run stands
+test('a folder removed and restored while a generation runs shows the folder row, then the run row again', async (context) => {
+  // Arrange
+  const project = await openProjectWithRun(context)
+
+  // Act
+  const whileRemoved = await idsWhileFolderIsRemoved(project)
+
+  // Assert
+  assert.deepEqual(whileRemoved, {
+    removed: ['folder'],
+    restored: ['run', 'output'],
+  })
+})
+
+// Value: protects=AC 2 row 2b (another window's run belongs to its folder); fails_when=after the output setting names another folder the Generating in another window row of the old folder still shows; no_claim=the other window's work; seam=a live marker of another window and the stubbed configuration event; why_new=no test changes the folder while another window runs
+test('the elsewhere row is gone when the output setting names another folder', async (context) => {
+  // Arrange
+  const project = await openProjectWithRunElsewhere(context)
+
+  // Act
+  project.setOutputSetting('docs/other-wiki')
+  await untilRow(project, 'elsewhere', false)
+
+  // Assert
+  assert.deepEqual(idsOf(project), [])
+})
+
+// Value: protects=AC 2 row 2b across a removed folder; fails_when=a folder removed and restored loses the row of another window's live run; no_claim=VS Code's folder prompts; seam=a live marker of another window and the stubbed workspace folders; why_new=no test removes the folder while another window runs
+test('a folder removed and restored while another window runs shows the folder row, then the elsewhere row again', async (context) => {
+  // Arrange
+  const project = await openProjectWithRunElsewhere(context)
+
+  // Act
+  const whileRemoved = await idsWhileFolderIsRemoved(project)
+
+  // Assert
+  assert.deepEqual(whileRemoved, {
+    removed: ['folder'],
+    restored: ['elsewhere', 'output'],
+  })
+})
+
+// Value: protects=the late-publication notice when a read straddles a publication; fails_when=a read held at the receipt read while the Wiki is published tells nothing, tells twice, or leaves the Wiki row unshown; no_claim=the notice wording and the state between the two reads of the publisher (the facts reader's and the read-loop tests pin the order of the reads and the memory); seam=a hold on the read of the publication identity, which the facts reader makes first; why_new=the published-after-Stop-watching test publishes between reads and never lets one read straddle the publication
+test('a read held at the receipt while the Wiki is published shows the Wiki and tells the learner once', async (context) => {
+  // Arrange
+  const project = await openProjectWithReservation(context)
+  const noticesBefore = project.notices.length
+  const midPublicationRead = project.hold('publication-read')
+  const readInTheMiddle = project.runCommand('codebook.refreshLlmWiki')
+  await midPublicationRead.started
+  // gstack-timing-ok: separates the publication's file times from the earlier read; no assertion measures the wait
+  await new Promise((resolve) => setTimeout(resolve, 20))
+
+  // Act
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  midPublicationRead.release()
+  await readInTheMiddle
+  const idsAfterHeldRead = idsOf(project)
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsAfterHeldRead, idsOf(project), project.notices.slice(noticesBefore)],
+    [
+      ['wiki', 'output'],
+      ['wiki', 'output'],
+      ['An LLM Wiki was published in .codebook/wiki.'],
+    ],
+  )
+})
+
+// Value: protects=AC 2 row 2 (this window's run is status-driven, not marker-driven); fails_when=deleting the run's marker file drops the run row of a generation that still runs here, with its Cancel; no_claim=the marker's own lifecycle; seam=the marker file removed under a Cursor generation that waits; why_new=no test removes the marker while this window's run stands
+test('the run row stays when its marker file is removed during the run', async (context) => {
+  // Arrange
+  const project = await openProjectWithRun(context)
+
+  // Act
+  await rm(project.markerPath, { force: true })
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), rowOf(project, 'run')?.contextValue],
+    [['run', 'output'], '[cancel-run][show-output]'],
+  )
+})
+
+// Value: protects=AC 2 row 3 (the last attempt is status-driven, not marker-driven); fails_when=deleting a marker file clears Last generation stopped; no_claim=the marker's own lifecycle; seam=the marker file removed after a Cursor generation that exited 1; why_new=no test removes the marker while a last attempt stands
+test('Last generation stopped stays when a marker file is removed', async (context) => {
+  // Arrange
+  const project = await openProjectWithLastAttempt(context)
+
+  // Act
+  await rm(project.markerPath, { force: true })
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(idsOf(project), ['last-attempt', 'output'])
+})
+
+// Value: protects=AC 2 row 2b and the late-publication notice belonging to this window's own stopped watch; fails_when=a Wiki published while another window runs shows no Wiki row, keeps the elsewhere row after that window's marker is gone, or tells "published" though nothing of this window waited; no_claim=the other window's work; seam=a live marker of another window, then a publication and the marker removed; why_new=no test publishes while another window runs
+test('a Wiki published while another window runs shows the Wiki row, the elsewhere row goes with that marker and no published notice shows', async (context) => {
+  // Arrange
+  const project = await openProjectWithRunElsewhere(context)
+  const noticesBefore = project.notices.length
+
+  // Act
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  await project.runCommand('codebook.refreshLlmWiki')
+  const idsWhileOtherWindowRuns = idsOf(project)
+  await rm(project.markerPath, { force: true })
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [
+      idsWhileOtherWindowRuns,
+      idsOf(project),
+      project.notices.length - noticesBefore,
+    ],
+    [['wiki', 'elsewhere', 'output'], ['wiki', 'output'], 0],
+  )
+})
+
+// Value: protects=item 7, a Wiki folder deleted or moved as a whole; fails_when=an event that names only the output folder (the editor may report no file inside) is dropped, so a deleted or renamed Wiki keeps showing Wiki source current and the welcome never returns; no_claim=what the real editor reports for a recursive delete; seam=the fake file watching reporting the folder's path only
+test('a delete event of the output folder alone, for a deleted or a renamed Wiki folder, brings back the empty state', async (context) => {
+  // Arrange
+  const deleted = await openPublishedWiki(context)
+  const renamed = await openPublishedWiki(context)
+
+  // Act
+  await rm(deleted.wiki.outputDirectory, { recursive: true })
+  deleted.window.reportFileEvent('delete', deleted.wiki.outputDirectory)
+  await rename(
+    renamed.wiki.outputDirectory,
+    `${renamed.wiki.outputDirectory}-moved`,
+  )
+  renamed.window.reportFileEvent('delete', renamed.wiki.outputDirectory)
+  await untilRow(deleted.window, 'wiki', false)
+  await untilRow(renamed.window, 'wiki', false)
+
+  // Assert
+  assert.deepEqual(
+    [
+      deleted.window.llmWiki.contextKeys[STATE_KEY],
+      renamed.window.llmWiki.contextKeys[STATE_KEY],
+    ],
+    ['none', 'none'],
+  )
+})
+
+/** Writes a marker like the one a window of an earlier version left, naming a process that exists (pid 1), with the given reservation times. */
+async function writeSpoofedReservation(
+  markerPath: string,
+  times: { startedAtMs: number; watchEndedAtMs: number },
+): Promise<void> {
+  await mkdir(dirname(markerPath), { recursive: true })
+  await writeFile(
+    markerPath,
+    JSON.stringify({
+      pid: 1,
+      windowId: 'spoof',
+      host: 'vscode',
+      ...times,
+    }),
+  )
+}
+
+// Value: protects=item 12, Generate and Update available after a reservation ran out; fails_when=an expired reservation whose recorded owner process exists keeps Waiting for chat forever, hides the welcome and the Update action; no_claim=the start check's own refusal text; seam=a marker with watchEndedAtMs 0 naming pid 1, beside an empty output
+test('an expired reservation of a live-looking process leaves the empty state with the welcome', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await writeSpoofedReservation(project.markerPath, {
+    startedAtMs: 0,
+    watchEndedAtMs: 0,
+  })
+
+  // Act
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [project.llmWiki.rows(), project.llmWiki.contextKeys[STATE_KEY]],
+    [[], 'none'],
+  )
+})
+
+// Value: protects=item 12, the Update action beside an expired reservation; fails_when=an expired reservation beside a published Wiki adds a Waiting for chat row and takes the Update action from row 1; no_claim=the freshness label; seam=the same spoofed marker beside a published Wiki
+test('an expired reservation beside a Wiki keeps row 1 with its Update action', async (context) => {
+  // Arrange
+  const { wiki, window } = await openPublishedWiki(context)
+  await writeSpoofedReservation(`${wiki.outputDirectory}.update-run.json`, {
+    startedAtMs: 0,
+    watchEndedAtMs: 0,
+  })
+
+  // Act
+  await window.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(window), rowOf(window, 'wiki')?.contextValue],
+    [['wiki', 'output'], '[update]'],
+  )
+})
+
+// Value: protects=item 12, a reservation inside its window; fails_when=the deadline check hides a reservation that still stands, so a second start looks possible; no_claim=the retry time's wording; seam=a marker whose watch ended a minute ago
+test('a reservation inside its window still shows Waiting for chat', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+  await writeSpoofedReservation(project.markerPath, {
+    startedAtMs: Date.now() - 120_000,
+    watchEndedAtMs: Date.now() - 60_000,
+  })
+
+  // Act
+  await project.runCommand('codebook.refreshLlmWiki')
+
+  // Assert
+  assert.deepEqual(idsOf(project), ['reservation', 'output'])
+})
+
+// Value: protects=item 25, what the row actions hand the editor; fails_when=Change location opens the settings without the query of the output setting, or Reveal Wiki Folder reveals another folder than the output; no_claim=what the editor does with them; seam=the arguments the stubbed editor recorded
+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)
+
+  // Act
+  await project.runCommand('codebook.llmWiki.changeLocation')
+  await project.runCommand('codebook.revealWikiFolder')
+
+  // Assert
+  assert.deepEqual(project.executedCommandCalls, [
+    {
+      name: 'workbench.action.openSettings',
+      argument: '@id:codebook.wikiOutputDirectory',
+    },
+    {
+      name: 'revealFileInOS',
+      argument: { scheme: 'file', fsPath: project.outputDirectory },
+    },
+  ])
+})
+
+// Value: protects=item 26, Copy details only on the learner's choice; fails_when=dismissing the notice copies the sentence anyway; no_claim=the sentence; seam=a click on the attention row with no button pressed
+test('dismissing the attention notice copies nothing', async (context) => {
+  // Arrange
+  const { window } = await openPublishedWiki(
+    context,
+    { chooseAction: () => undefined },
+    async (wiki) =>
+      writeFile(join(wiki.outputDirectory, 'index.html'), '<h1>Mine</h1>'),
+  )
+  await untilRow(window, 'attention')
+  const click = rowOf(window, 'attention')?.command
+
+  // Act
+  await window.runCommand(click?.command ?? '', ...(click?.arguments ?? []))
+
+  // Assert
+  assert.deepEqual([window.warnings.length, window.clipboard], [1, []])
+})
+
+// Value: protects=item 26, a stale row id; fails_when=the details command shows a notice for an id the view no longer has; no_claim=the shown rows; seam=the command run with an unknown id and with the id of a row that is gone
+test('the details command shows nothing for an unknown or stale row id', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context)
+
+  // Act
+  await project.runCommand('codebook.showLlmWikiAttention', 'no-such-row')
+  await project.runCommand('codebook.showLlmWikiAttention', 'attention')
+
+  // Assert
+  assert.deepEqual(
+    [project.warnings, project.notices, project.errors, project.clipboard],
+    [[], [], [], []],
+  )
+})
diff --git a/extension/src/tests/llmWikiViewReadLoop.test.ts b/extension/src/tests/llmWikiViewReadLoop.test.ts
new file mode 100644
index 000000000..95a31e08a
--- /dev/null
+++ b/extension/src/tests/llmWikiViewReadLoop.test.ts
@@ -0,0 +1,639 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, rm, symlink, realpath } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test, type TestContext } from 'node:test'
+
+import { waitUntil } from '../runtimeSupport/utils/waitUntil'
+import {
+  createLlmWikiView,
+  type LlmWikiView,
+  type LlmWikiViewOptions,
+} from '../utils/llmWikiView'
+import type {
+  LlmWikiFreshness,
+  LlmWikiViewFacts,
+} from '../utils/readLlmWikiViewState'
+
+import { createFakeLlmWikiEditor } from './utils/fakeLlmWikiEditor'
+
+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 {
+    kind: 'ready',
+    host: 'vscode',
+    projectRoot: WATCHED_PROJECT,
+    repositoryName: 'project',
+    outputLabel: '.codebook/wiki',
+    outputDirectory: WATCHED_OUTPUT,
+    nowMs: 0,
+    ...overrides,
+  }
+}
+
+const publishedWiki: ReadyFacts['wiki'] = {
+  freshness: { status: 'checking' },
+  generation: { publishedAtMs: 1_000 },
+}
+
+/** Opens the view on stand-ins that count their calls; a test overrides the closure it examines. */
+function openView(
+  context: TestContext,
+  overrides: Partial<LlmWikiViewOptions> = {},
+) {
+  const fake = createFakeLlmWikiEditor()
+  const recordedFailures: string[] = []
+  const tellings: string[] = []
+  const view = createLlmWikiView({
+    editor: fake.editor,
+    host: 'vscode',
+    readFacts: async () => readyFacts({ wiki: publishedWiki }),
+    readFreshness: async () => ({ status: 'current' }),
+    findWatchedFolder: async () => WATCHED_PROJECT,
+    onRunChange: () => (): void => {},
+    tellPublished: (label): void => {
+      tellings.push(label)
+    },
+    recordFailure: (message) => recordedFailures.push(message),
+    debounceMs: 20,
+    pollMs: 50,
+    ...overrides,
+  })
+  context.after(() => view.dispose())
+  return { fake, view, recordedFailures, tellings }
+}
+
+const idsOf = (fake: ReturnType<typeof createFakeLlmWikiEditor>): string[] =>
+  fake.rows().map((row) => row.id)
+const rowOf = (fake: ReturnType<typeof createFakeLlmWikiEditor>, id: string) =>
+  fake.rows().find((row) => row.id === id)
+
+/** Lets the event loop run so a rejection that nobody handles would surface. */
+const afterEventLoopTurn = (): Promise<void> =>
+  new Promise((resolve) => setImmediate(resolve))
+
+/** Collects the rejections nobody handled while a test runs. */
+function collectUnhandledRejections(context: TestContext): unknown[] {
+  const unhandled: unknown[] = []
+  const listener = (cause: unknown): void => {
+    unhandled.push(cause)
+  }
+  process.on('unhandledRejection', listener)
+  context.after(() => process.off('unhandledRejection', listener))
+  return unhandled
+}
+
+const ERROR_ROW_LABEL = 'Could not read the LLM Wiki state'
+
+// Value: protects=item 1, the error row for a failure after the facts were read; fails_when=a findWatchedFolder that rejects leaves the old rows, shows no error row, records nothing, or becomes an unhandled rejection; no_claim=the cause's wording; seam=a rejecting findWatchedFolder
+test('a watcher lookup that rejects shows the error row, records the failure once and leaves no unhandled rejection', async (context) => {
+  // Arrange
+  const unhandled = collectUnhandledRejections(context)
+  const { fake, view, recordedFailures } = openView(context, {
+    findWatchedFolder: async () => {
+      throw new Error('stat failed')
+    },
+  })
+
+  // Act
+  await view.whenIdle()
+  await afterEventLoopTurn()
+
+  // Assert
+  assert.deepEqual(
+    [
+      fake.rows().map((row) => row.label),
+      recordedFailures,
+      unhandled,
+      fake.contextKeys['codebook.llmWiki.state'],
+    ],
+    [
+      [ERROR_ROW_LABEL],
+      ['The LLM Wiki view could not read its state'],
+      [],
+      'other',
+    ],
+  )
+})
+
+// Value: protects=item 1, the error row for a failure in the step that turns facts into rows; fails_when=facts that make the row step throw leave the old rows, show no error row or reject unhandled; no_claim=which fact is broken; seam=ready facts with a getter that throws
+test('a failure while the rows are made shows the error row, records it once and the next good read recovers', async (context) => {
+  // Arrange
+  const unhandled = collectUnhandledRejections(context)
+  let isBroken = true
+  const { fake, view, recordedFailures } = openView(context, {
+    readFacts: async () => {
+      const facts = readyFacts({ wiki: publishedWiki })
+      // The getter is added after the facts were made, so the read succeeds and the step that makes rows from the facts throws.
+      if (isBroken)
+        Object.defineProperty(facts, 'run', {
+          enumerable: true,
+          get(): never {
+            throw new Error('row step failed')
+          },
+        })
+      return facts
+    },
+  })
+  await view.whenIdle()
+  const whileBroken = fake.rows().map((row) => row.label)
+  isBroken = false
+
+  // Act
+  await view.refresh()
+  await afterEventLoopTurn()
+
+  // Assert
+  assert.deepEqual(
+    [whileBroken, recordedFailures.length, unhandled, idsOf(fake)],
+    [[ERROR_ROW_LABEL], 1, [], ['wiki', 'output']],
+  )
+})
+
+// Value: protects=item 2, one freshness check at a time; fails_when=three refreshes during a check start three checks, whenIdle resolves while the re-run still runs, or the re-run is missing; no_claim=the check's answer; seam=a freshness read held open
+test('three refreshes during a freshness check start one check and one re-run, and the view is idle only after the re-run', async (context) => {
+  // Arrange
+  const held = [defer<LlmWikiFreshness>(), defer<LlmWikiFreshness>()]
+  let checkCount = 0
+  const { fake, view } = openView(context, {
+    readFreshness: () => held[checkCount++]?.promise ?? Promise.reject(),
+  })
+  await waitUntil(() => checkCount === 1, 'the first check', 6_000)
+
+  // Act
+  await view.refresh()
+  await view.refresh()
+  await view.refresh()
+  const checksWhileHeld = checkCount
+  let isIdle = false
+  const idle = view.whenIdle().then(() => {
+    isIdle = true
+  })
+  held[0]?.resolve({ status: 'changed' })
+  await waitUntil(() => checkCount === 2, 'the re-run', 6_000)
+  await afterEventLoopTurn()
+  const isIdleDuringReRun = isIdle
+  held[1]?.resolve({ status: 'current' })
+  await idle
+
+  // Assert
+  assert.deepEqual(
+    [
+      checksWhileHeld,
+      isIdleDuringReRun,
+      checkCount,
+      rowOf(fake, 'wiki')?.description,
+    ],
+    [1, false, 2, 'Wiki source current'],
+  )
+})
+
+// Value: protects=item 2, no work after dispose; fails_when=a re-run starts after dispose, or the answer of a running check is still shown; no_claim=the watcher's disposal; seam=a freshness read held open across dispose
+test('after dispose no freshness re-run starts and the running check’s answer is dropped', async (context) => {
+  // Arrange
+  const held = defer<LlmWikiFreshness>()
+  let checkCount = 0
+  const { fake, view } = openView(context, {
+    readFreshness: () => {
+      checkCount += 1
+      return held.promise
+    },
+  })
+  await waitUntil(() => checkCount === 1, 'the first check', 6_000)
+  await view.refresh()
+  const descriptionBefore = rowOf(fake, 'wiki')?.description
+
+  // Act
+  view.dispose()
+  held.resolve({ status: 'changed' })
+  await afterEventLoopTurn()
+  await afterEventLoopTurn()
+
+  // Assert
+  assert.deepEqual(
+    [checkCount, descriptionBefore, rowOf(fake, 'wiki')?.description],
+    [1, 'Checking freshness…', 'Checking freshness…'],
+  )
+})
+
+// Value: protects=item 2, a failed check is no answer; fails_when=a check that threw is cached as an answer, so the next read shows the unknown label as if it were known instead of Checking freshness… while it asks again; no_claim=the failure's wording; seam=a freshness read that rejects once and is then held
+test('a failed freshness check shows the unknown label once, and the next refresh reads Checking freshness… while it checks again', async (context) => {
+  // Arrange
+  const heldSecondCheck = defer<LlmWikiFreshness>()
+  let checkCount = 0
+  const { fake, view } = openView(context, {
+    readFreshness: () => {
+      checkCount += 1
+      return checkCount === 1
+        ? Promise.reject(new Error('git failed'))
+        : heldSecondCheck.promise
+    },
+  })
+  await waitUntil(
+    () =>
+      rowOf(fake, 'wiki')?.description?.startsWith('Wiki freshness unknown'),
+    'the unknown label',
+    6_000,
+  )
+  const afterFailure = rowOf(fake, 'wiki')?.description
+
+  // Act
+  await view.refresh()
+  const whileCheckingAgain = rowOf(fake, 'wiki')?.description
+  heldSecondCheck.resolve({ status: 'current' })
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [
+      afterFailure,
+      whileCheckingAgain,
+      checkCount,
+      rowOf(fake, 'wiki')?.description,
+    ],
+    [
+      'Wiki freshness unknown: The freshness check failed.',
+      'Checking freshness…',
+      2,
+      'Wiki source current',
+    ],
+  )
+})
+
+// Value: protects=items 2 and 4, the freshness check inspects the folder the facts name and its answer is shown for that folder only; fails_when=the check asks the setting again, or the answer of the earlier folder is shown after the rows moved to another folder; no_claim=the Git work of the check; seam=two folders and a freshness read held open
+test('a freshness check inspects the folder of the facts it was asked for and its answer is not shown for another folder', async (context) => {
+  // Arrange
+  const heldForFirstFolder = defer<LlmWikiFreshness>()
+  const requestedLocations: Array<{
+    projectRoot: string
+    outputDirectory: string
+  }> = []
+  let outputDirectory = WATCHED_OUTPUT
+  const { fake, view } = openView(context, {
+    readFacts: async () =>
+      readyFacts({
+        outputDirectory,
+        publication: outputDirectory,
+        wiki: publishedWiki,
+      }),
+    readFreshness: (location) => {
+      requestedLocations.push(location)
+      return requestedLocations.length === 1
+        ? heldForFirstFolder.promise
+        : Promise.resolve({ status: 'current' })
+    },
+    findWatchedFolder: async () => WATCHED_PROJECT,
+  })
+  await waitUntil(
+    () => requestedLocations.length === 1,
+    'the first check',
+    6_000,
+  )
+
+  // Act
+  outputDirectory = '/project/docs/wiki'
+  await view.refresh()
+  heldForFirstFolder.resolve({ status: 'changed' })
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [requestedLocations, rowOf(fake, 'wiki')?.description],
+    [
+      [
+        { projectRoot: WATCHED_PROJECT, outputDirectory: WATCHED_OUTPUT },
+        { projectRoot: WATCHED_PROJECT, outputDirectory: '/project/docs/wiki' },
+      ],
+      'Wiki source current',
+    ],
+  )
+})
+
+// Value: protects=item 3, a publication between the first read and the watcher's registration; fails_when=a Wiki published while the watcher lookup is held is in neither the first read nor an event, so the row never appears; no_claim=the editor's own event delivery; seam=a held findWatchedFolder
+test('a Wiki published while the watcher is being made shows without any further trigger', async (context) => {
+  // Arrange
+  const heldLookup = defer<string>()
+  let isPublished = false
+  let readCount = 0
+  const { fake, view } = openView(context, {
+    readFacts: async () => {
+      readCount += 1
+      return readyFacts(isPublished ? { wiki: publishedWiki } : {})
+    },
+    findWatchedFolder: () => heldLookup.promise,
+  })
+  await waitUntil(() => readCount === 1, 'the first read', 6_000)
+
+  // Act
+  isPublished = true
+  heldLookup.resolve(WATCHED_PROJECT)
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual([idsOf(fake), readCount], [['wiki', 'output'], 2])
+})
+
+// Value: protects=item 3, the follow-up read is single; fails_when=a watcher that stays where it is makes every read read twice; no_claim=the number of reads at the first start; seam=a counted readFacts
+test('a read whose watcher did not move is not followed by another read', async (context) => {
+  // Arrange
+  let readCount = 0
+  const { view } = openView(context, {
+    readFacts: async () => {
+      readCount += 1
+      return readyFacts({ wiki: publishedWiki })
+    },
+  })
+  await view.whenIdle()
+  const readsAtStart = readCount
+
+  // Act
+  await view.refresh()
+  await view.refresh()
+
+  // Assert
+  assert.deepEqual([readsAtStart, readCount - readsAtStart], [2, 2])
+})
+
+// Value: protects=item 5, the mid-publication hold ends where a cause or this window's run shows; fails_when=an unreadable manifest with a new receipt freezes the memory, so the good read after this window's own generation tells a Wiki was published again; no_claim=the notice wording; seam=scripted facts across four reads
+test('an unreadable manifest with a new receipt does not freeze the memory, so a later good read after this window’s own run tells nothing', async (context) => {
+  // Arrange
+  let step: 'reservation' | 'unreadable' | 'run' | 'published' = 'reservation'
+  const reservation: ReadyFacts['reservation'] = {
+    host: 'vscode',
+    startedAtMs: 0,
+    retryAtMs: 60_000,
+  }
+  const { tellings, view } = openView(context, {
+    readFacts: async () => {
+      switch (step) {
+        case 'reservation':
+          return readyFacts({ reservation })
+        case 'unreadable':
+          return readyFacts({
+            publication: 'receipt-new',
+            attention: { cause: 'unreadable-manifest', sentence: 'x' },
+          })
+        case 'run':
+          return readyFacts({
+            publication: 'receipt-new',
+            run: {
+              kind: 'generate',
+              startedAtMs: 0,
+              timeoutMs: 3_300_000,
+              isAwaitingChat: false,
+            },
+          })
+        case 'published':
+          return readyFacts({
+            publication: 'receipt-new',
+            wiki: publishedWiki,
+          })
+      }
+    },
+  })
+  await view.whenIdle()
+
+  // Act
+  for (const next of ['unreadable', 'run', 'published'] as const) {
+    step = next
+    await view.refresh()
+  }
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(tellings, [])
+})
+
+// Value: protects=the late-publication notice across a read that lands mid-publication; fails_when=a read that sees the new receipt before the Wiki is readable replaces the memory, so the read that shows the Wiki tells nothing; no_claim=the notice wording; seam=scripted facts across three reads
+test('a read that lands mid-publication keeps the memory, and the read that shows the Wiki tells once', async (context) => {
+  // Arrange
+  let step: 'reservation' | 'mid' | 'published' = 'reservation'
+  const { fake, tellings, view } = openView(context, {
+    readFacts: async () => {
+      if (step === 'reservation')
+        return readyFacts({
+          reservation: { host: 'vscode', startedAtMs: 0, retryAtMs: 60_000 },
+        })
+      if (step === 'mid')
+        return readyFacts({
+          publication: 'receipt-new',
+          reservation: { host: 'vscode', startedAtMs: 0, retryAtMs: 60_000 },
+        })
+      return readyFacts({ publication: 'receipt-new', wiki: publishedWiki })
+    },
+  })
+  await view.whenIdle()
+  step = 'mid'
+  await view.refresh()
+  const idsMidPublication = idsOf(fake)
+
+  // Act
+  step = 'published'
+  await view.refresh()
+  await view.refresh()
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    [idsMidPublication, idsOf(fake), tellings],
+    [['reservation', 'output'], ['wiki', 'output'], ['.codebook/wiki']],
+  )
+})
+
+// Value: protects=item 27's consequence for the notice; fails_when=a Wiki whose manifest appears while the receipt read still shows none tells nothing at that read and never later; no_claim=the notice wording; seam=a read that pairs the older receipt with the newer manifest
+test('a Wiki whose manifest is newer than the receipt read with it still tells the learner once', async (context) => {
+  // Arrange
+  let isPublished = false
+  const { tellings, view } = openView(context, {
+    readFacts: async () =>
+      isPublished
+        ? readyFacts({ wiki: publishedWiki })
+        : readyFacts({
+            reservation: { host: 'vscode', startedAtMs: 0, retryAtMs: 60_000 },
+          }),
+  })
+  await view.whenIdle()
+
+  // Act
+  isPublished = true
+  await view.refresh()
+  await view.refresh()
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(tellings, ['.codebook/wiki'])
+})
+
+/** Opens the view with a published Wiki, a folder to stand on and the events of its watcher reportable. */
+function openWatchedView(
+  context: TestContext,
+  overrides: Partial<LlmWikiViewOptions> & { facts?: Partial<ReadyFacts> } = {},
+) {
+  const { facts, ...options } = overrides
+  let readCount = 0
+  const opened = openView(context, {
+    readFacts: async () => {
+      readCount += 1
+      return readyFacts({ wiki: publishedWiki, ...facts })
+    },
+    ...options,
+  })
+  return { ...opened, readCount: () => readCount }
+}
+
+// Value: protects=item 7, a deleted or moved output folder; fails_when=a delete event of the folder itself (no file events) is dropped, so a deleted Wiki keeps showing Wiki source current; no_claim=what the real editor reports; seam=the fake file watching reporting only the folder
+test('a directory-only event of the output folder or a folder above it refreshes the view', async (context) => {
+  // Arrange
+  const { fake, readCount, view } = openWatchedView(context)
+  await view.whenIdle()
+  const kinds = ['delete', 'create'] as const
+
+  // Act
+  const readsAfterEachEvent: number[] = []
+  for (const [index, path] of [
+    WATCHED_OUTPUT,
+    '/project/.codebook',
+  ].entries()) {
+    const readsBefore = readCount()
+    fake.files.report(kinds[index] ?? 'delete', path)
+    await waitUntil(
+      () => readCount() > readsBefore,
+      'a read after the event',
+      6_000,
+    )
+    readsAfterEachEvent.push(readCount() - readsBefore)
+  }
+
+  // Assert
+  assert.deepEqual(
+    readsAfterEachEvent.map((reads) => reads > 0),
+    [true, true],
+  )
+})
+
+// Value: protects=item 7, the exact-path filter; fails_when=an event of a file that is not one of the watched files refreshes the view; no_claim=the glob; seam=the fake file watching
+test('an event of an unrelated file below the watched folder reads nothing', async (context) => {
+  // Arrange
+  const { fake, readCount, view } = openWatchedView(context)
+  await view.whenIdle()
+  const readsBefore = readCount()
+
+  // 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))
+
+  // Assert
+  assert.equal(readCount() - readsBefore, 0)
+})
+
+// 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
+  const { fake, recordedFailures, view } = openWatchedView(context, {
+    facts: {
+      outputDirectory: '/elsewhere/missing/wiki',
+      outputLabel: '/elsewhere/missing/wiki',
+    },
+    findWatchedFolder: async () => '/elsewhere',
+  })
+  await view.whenIdle()
+
+  // Act
+  await view.refresh()
+  await view.refresh()
+
+  // Assert
+  assert.deepEqual(
+    [
+      fake.files.liveWatcherCount(),
+      recordedFailures,
+      rowOf(fake, 'output')?.tooltip?.includes('refreshes when it is shown'),
+    ],
+    [0, ['The LLM Wiki view could not watch the Wiki folder'], true],
+  )
+})
+
+// Value: protects=item 8, a fresh project; fails_when=a missing .codebook inside the project watches anything but the project root; no_claim=the move to .codebook once a run makes it (host test); seam=the pattern handed to the fake file watching
+test('a missing .codebook inside the project is watched from the project root', async (context) => {
+  // Arrange
+  const { fake, view } = openWatchedView(context)
+
+  // Act
+  await view.whenIdle()
+
+  // Assert
+  assert.deepEqual(
+    fake.files.watched.map(({ base }) => base),
+    [WATCHED_PROJECT],
+  )
+})
+
+// Value: protects=item 9, a project reached through a symbolic link; fails_when=an event spelled with the real path is dropped because only the linked spelling was computed; no_claim=macOS's /var versus /private/var itself; seam=a real symbolic link and the fake file watching reporting the real spelling
+test('an event spelled with the real path of a symlinked project still refreshes the view', async (context) => {
+  // Arrange
+  const directory = await mkdtemp(join(tmpdir(), 'codebook-view-link-'))
+  context.after(() => rm(directory, { recursive: true, force: true }))
+  const realProject = join(await realpath(directory), 'real')
+  const linkedProject = join(directory, 'linked')
+  await mkdir(join(realProject, '.codebook', 'wiki'), { recursive: true })
+  await symlink(realProject, linkedProject)
+  const linkedOutput = join(linkedProject, '.codebook', 'wiki')
+  const { fake, readCount, view } = openWatchedView(context, {
+    facts: { projectRoot: linkedProject, outputDirectory: linkedOutput },
+    findWatchedFolder: async () => join(linkedProject, '.codebook'),
+  })
+  await view.whenIdle()
+  const readsBefore = readCount()
+
+  // Act
+  fake.files.report(
+    'create',
+    join(linkedOutput, 'codebook-wiki.json'),
+    join(realProject, '.codebook', 'wiki', 'codebook-wiki.json'),
+  )
+  await waitUntil(
+    () => readCount() > readsBefore,
+    'a read after the event',
+    6_000,
+  )
+
+  // Assert
+  assert.equal(readCount() > readsBefore, true)
+})
+
+// Value: protects=the handle's contract; fails_when=refresh rejects for a read that failed, so the Refresh command or a timer fails; no_claim=the error row; seam=a readFacts that rejects
+test('refresh resolves even when the read failed', async (context) => {
+  // Arrange
+  const { view } = openView(context, {
+    readFacts: async () => {
+      throw new Error('disk gone')
+    },
+  })
+  const handle: LlmWikiView = view
+
+  // Act
+  const outcome = await handle.refresh().then(
+    () => 'resolved',
+    () => 'rejected',
+  )
+
+  // Assert
+  assert.equal(outcome, 'resolved')
+})
diff --git a/extension/src/tests/readLlmWikiViewFacts.test.ts b/extension/src/tests/readLlmWikiViewFacts.test.ts
new file mode 100644
index 000000000..55a122882
--- /dev/null
+++ b/extension/src/tests/readLlmWikiViewFacts.test.ts
@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import type { WikiUpdateMarkerLook } from '../utils/readLiveWikiUpdateMarker'
+import {
+  readLlmWikiViewFacts,
+  type LlmWikiViewFactsDependencies,
+} from '../utils/readLlmWikiViewFacts'
+
+const NOW_MS = 1_790_000_000_000
+const GENERATE_BOUND_MS = 3_300_000
+
+/** Dependencies for a project with a published Wiki and nothing else; a test overrides what it examines. */
+function dependencies(
+  overrides: Partial<LlmWikiViewFactsDependencies> = {},
+): LlmWikiViewFactsDependencies {
+  return {
+    host: 'vscode',
+    isFolderOpen: () => true,
+    isTrusted: () => true,
+    wikiLocation: async () => ({
+      projectRoot: '/repo',
+      outputDirectory: '/repo/.codebook/wiki',
+    }),
+    readPublishToken: async () => 'token',
+    readPublication: async () => 'receipt@1',
+    findStartBlock: async () => undefined,
+    readGeneration: async () => ({ revision: undefined, publishedAtMs: 1 }),
+    isWikiOwnedBy: async () => true,
+    readMarker: async () => ({ kind: 'none' }),
+    ownWindowId: 'this-window',
+    isStartUnderWay: () => false,
+    hasPublishEndedWait: async () => false,
+    runStatus: () => ({ state: 'idle' }),
+    isAwaitingChat: () => false,
+    lastAgentExit: () => undefined,
+    now: () => NOW_MS,
+    ...overrides,
+  }
+}
+
+/** A reservation a stopped VS Code watch left, whose watch ended `endedAgoMs` ago. */
+function reservationLook(endedAgoMs: number): WikiUpdateMarkerLook {
+  return {
+    kind: 'live',
+    heldBy: {
+      pid: 1,
+      windowId: 'spoof',
+      host: 'vscode',
+      startedAtMs: NOW_MS - endedAgoMs - 60_000,
+      watchEndedAtMs: NOW_MS - endedAgoMs,
+      runKind: 'generate',
+    },
+  }
+}
+
+// Value: protects=Generate and Update staying available after a reservation ran out (item 12); fails_when=a reservation whose deadline has passed, kept alive by a live owner process, still reads as Waiting for chat; no_claim=the start check's own refusal; seam=the facts reader with a marker look and a fixed clock
+test('a reservation past its deadline yields no reservation fact, one inside its window does', async () => {
+  // Arrange
+  const readMarkerFor = (endedAgoMs: number) =>
+    dependencies({ readMarker: async () => reservationLook(endedAgoMs) })
+
+  // Act
+  const expired = await readLlmWikiViewFacts(
+    readMarkerFor(GENERATE_BOUND_MS + 1),
+  )
+  const atDeadline = await readLlmWikiViewFacts(
+    readMarkerFor(GENERATE_BOUND_MS),
+  )
+  const inside = await readLlmWikiViewFacts(readMarkerFor(60_000))
+
+  // Assert
+  assert.deepEqual(
+    [expired, atDeadline, inside].map((facts) =>
+      facts.kind === 'ready' ? facts.reservation?.retryAtMs : 'not ready',
+    ),
+    [undefined, undefined, NOW_MS - 60_000 + GENERATE_BOUND_MS],
+  )
+})
+
+// Value: protects=the pairing of the receipt with the manifest it names (item 27); fails_when=a publication that lands between the two reads pairs the old manifest with the new receipt, so the view shows the old Wiki under the new receipt; no_claim=which of the two the next refresh shows; seam=a world that changes right after the first of the two reads
+test('a publication landing between the receipt read and the manifest read pairs the older receipt with the newer manifest, never the reverse', async () => {
+  // Arrange
+  let world: 'before' | 'after' = 'before'
+  const readOnceThenPublish = async <Value>(
+    values: Record<typeof world, Value>,
+  ): Promise<Value> => {
+    const value = values[world]
+    // The publication lands right after whichever of the two reads comes first.
+    world = 'after'
+    return value
+  }
+  const facts = await readLlmWikiViewFacts(
+    dependencies({
+      readPublication: () =>
+        readOnceThenPublish({ before: 'receipt-old', after: 'receipt-new' }),
+      readGeneration: () =>
+        readOnceThenPublish({
+          before: { revision: undefined, publishedAtMs: 111 },
+          after: { revision: undefined, publishedAtMs: 222 },
+        }),
+    }),
+  )
+
+  // Act
+  const pairing =
+    facts.kind === 'ready'
+      ? [facts.publication, facts.wiki?.generation.publishedAtMs]
+      : []
+
+  // Assert
+  assert.deepEqual(pairing, ['receipt-old', 222])
+})
+
+// Value: protects=the attention cause for a manifest whose token cannot be read (item 13); fails_when=a token read that rejects no longer counts as a manifest standing there, so the unreadable manifest shows no row; no_claim=the wording of the cause; seam=a rejected token read
+test('a publish token that cannot be read still shows the unreadable-manifest cause', async () => {
+  // Arrange
+  const unreadable = dependencies({
+    readPublishToken: async () => {
+      throw new Error('EACCES')
+    },
+    readGeneration: async () => {
+      throw new Error('not a Wiki of this project')
+    },
+    isWikiOwnedBy: async () => {
+      throw new Error('EACCES')
+    },
+  })
+
+  // Act
+  const facts = await readLlmWikiViewFacts(unreadable)
+
+  // Assert
+  assert.equal(
+    facts.kind === 'ready' ? facts.attention?.cause : 'not ready',
+    'unreadable-manifest',
+  )
+})
+
+// Value: protects=the project the freshness check inspects (item 4); fails_when=the facts omit the project root, so the check must ask the setting again; no_claim=the check itself; seam=the facts reader
+test('the ready facts name the project root next to the output folder', async () => {
+  // Arrange
+  const reader = dependencies()
+
+  // Act
+  const facts = await readLlmWikiViewFacts(reader)
+
+  // Assert
+  assert.deepEqual(
+    facts.kind === 'ready' ? [facts.projectRoot, facts.outputDirectory] : [],
+    ['/repo', '/repo/.codebook/wiki'],
+  )
+})
diff --git a/extension/src/tests/readLlmWikiViewState.test.ts b/extension/src/tests/readLlmWikiViewState.test.ts
new file mode 100644
index 000000000..7f6c32d57
--- /dev/null
+++ b/extension/src/tests/readLlmWikiViewState.test.ts
@@ -0,0 +1,671 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import {
+  readLlmWikiViewState,
+  type LlmWikiViewFacts,
+  type LlmWikiViewWording,
+} from '../utils/readLlmWikiViewState'
+
+type ReadyFacts = Extract<LlmWikiViewFacts, { kind: 'ready' }>
+
+const START_MS = Date.UTC(2026, 9, 26, 12, 0, 0)
+const MINUTE_MS = 60_000
+const wording: LlmWikiViewWording = {
+  formatTime: (epochMs) => new Date(epochMs).toISOString().slice(11, 16),
+  formatDate: () => 'Oct 26, 2026',
+}
+
+/** A ready window twelve minutes after the run started, in VS Code, with no Wiki and no run. */
+function ready(overrides: Partial<ReadyFacts> = {}): ReadyFacts {
+  return {
+    kind: 'ready',
+    host: 'vscode',
+    projectRoot: '/repo',
+    repositoryName: 'nextjs-dashboard',
+    outputLabel: '.codebook/wiki',
+    outputDirectory: '/repo/.codebook/wiki',
+    nowMs: START_MS + 12 * MINUTE_MS,
+    ...overrides,
+  }
+}
+
+const publishedWiki: ReadyFacts['wiki'] = {
+  freshness: { status: 'current' },
+  generation: {
+    revision: '1936e41913729663cc99081e3224db89bb2d8e56',
+    publishedAtMs: START_MS,
+  },
+}
+const generationRun: ReadyFacts['run'] = {
+  kind: 'generate',
+  startedAtMs: START_MS,
+  timeoutMs: 3_300_000,
+  isAwaitingChat: false,
+}
+
+/** The ids of the rows of a model, in order. */
+const idsOf = (facts: LlmWikiViewFacts): string[] =>
+  readLlmWikiViewState(facts, wording).rows.map((row) => row.id)
+
+// Value: protects=AC 2 (folder and trust rows); fails_when=a window without a folder shows no way to open one, or an untrusted folder shows no way to manage trust; no_claim=what the commands do; seam=the pure row function
+test('a window without a folder offers Open Folder and an untrusted folder offers Manage Workspace Trust', () => {
+  // Arrange
+  const noFolder: LlmWikiViewFacts = { kind: 'no-folder' }
+  const untrusted: LlmWikiViewFacts = { kind: 'untrusted' }
+
+  // Act
+  const rows = [noFolder, untrusted].map(
+    (facts) => readLlmWikiViewState(facts, wording).rows[0],
+  )
+
+  // Assert
+  assert.deepEqual(
+    rows.map((row) => [row?.id, row?.label, row?.actions]),
+    [
+      ['folder', 'Open a folder to use the LLM Wiki', ['open-folder']],
+      ['trust', 'Trust this folder to use the LLM Wiki', ['manage-trust']],
+    ],
+  )
+})
+
+// Value: protects=AC 1 (empty state shows the welcome); fails_when=a folder with no Wiki and no run returns a row or leaves state other, so the welcome content never shows; no_claim=the welcome text (manifest test); seam=the pure row function
+test('a folder with no Wiki and no run has no rows and state none so the welcome content shows', () => {
+  // Arrange
+  const facts = ready()
+
+  // Act
+  const model = readLlmWikiViewState(facts, wording)
+
+  // Assert
+  assert.deepEqual(model, { state: 'none', rows: [] })
+})
+
+// Value: protects=AC 2 row 1; fails_when=the Wiki row loses its label, the reader's freshness wording, the generation tooltip, the open command or the Update action; no_claim=the browser opening; seam=the pure row function
+test('a published Wiki shows its folder name, the reader freshness label, its generation and opens in the browser', () => {
+  // Arrange
+  const facts = ready({ wiki: publishedWiki })
+
+  // Act
+  const model = readLlmWikiViewState(facts, wording)
+
+  // Assert
+  assert.deepEqual(model.rows[0], {
+    id: 'wiki',
+    label: 'nextjs-dashboard Wiki',
+    description: 'Wiki source current',
+    tooltip:
+      'Generated from 1936e41 on Oct 26, 2026\nClick to open the Wiki in the browser.',
+    icon: 'book',
+    command: { command: 'codebook.openDeepWiki' },
+    actions: ['update'],
+  })
+  assert.equal(model.state, 'other')
+})
+
+// Value: protects=AC 2 (row 1 description takes each freshness label); fails_when=a freshness answer gets another wording than the reader page; no_claim=the freshness check; seam=the pure row function
+test('the Wiki row takes the checking, changed, unknown and no-Git freshness labels', () => {
+  // Arrange
+  const descriptionFor = (
+    freshness: NonNullable<ReadyFacts['wiki']>['freshness'],
+  ) =>
+    readLlmWikiViewState(
+      ready({ wiki: { ...publishedWiki, freshness } }),
+      wording,
+    ).rows[0]?.description
+
+  // Act
+  const descriptions = [
+    descriptionFor({ status: 'checking' }),
+    descriptionFor({ status: 'changed' }),
+    descriptionFor({ status: 'unknown', reason: 'Git is not installed.' }),
+    descriptionFor({ status: 'current', isAdditionUnchecked: true }),
+  ]
+
+  // Assert
+  assert.deepEqual(descriptions, [
+    'Checking freshness…',
+    'Source changed · Update available',
+    'Wiki freshness unknown: Git is not installed.',
+    'Wiki source current (no Git revision recorded, so added files are not checked)',
+  ])
+})
+
+// Value: protects=AC 10 (accepted X1), the four forms of the generation line; fails_when=a form names the wrong revision or date, keeps a short non-commit revision, or shows a line when neither is known; no_claim=the manifest read; seam=the pure row function
+test('the Wiki row tooltip names the generation in each of its four forms', () => {
+  // Arrange
+  const tooltipFor = (
+    generation: NonNullable<ReadyFacts['wiki']>['generation'],
+  ) =>
+    readLlmWikiViewState(
+      ready({ wiki: { freshness: { status: 'current' }, generation } }),
+      wording,
+    ).rows[0]?.tooltip?.split('\n')[0]
+  const revision = '1936e41913729663cc99081e3224db89bb2d8e56'
+
+  // Act
+  const lines = [
+    tooltipFor({ revision, publishedAtMs: START_MS }),
+    tooltipFor({ publishedAtMs: START_MS }),
+    tooltipFor({ revision: 'main', publishedAtMs: START_MS }),
+    tooltipFor({ revision }),
+    tooltipFor({}),
+  ]
+
+  // Assert
+  assert.deepEqual(lines, [
+    'Generated from 1936e41 on Oct 26, 2026',
+    'Generated on Oct 26, 2026 (no Git revision)',
+    'Generated on Oct 26, 2026 (no Git revision)',
+    'Generated from 1936e41',
+    'Click to open the Wiki in the browser.',
+  ])
+})
+
+// Value: protects=AC 2 (row 1 stays beside row 2 and a published Wiki can be read during an update); fails_when=the Wiki row disappears during a run, or still offers Update beside it; no_claim=the update's own refusal; seam=the pure row function
+test('the Wiki row stays beside a running update and hides its Update action', () => {
+  // Arrange
+  const facts = ready({
+    wiki: publishedWiki,
+    run: { ...generationRun, kind: 'update', timeoutMs: 900_000 },
+  })
+
+  // Act
+  const model = readLlmWikiViewState(facts, wording)
+
+  // Assert
+  assert.deepEqual(
+    model.rows.map((row) => [row.id, row.actions]),
+    [
+      ['wiki', []],
+      ['run', ['stop-watching', 'open-chat', 'show-output']],
+      ['output', ['change-location']],
+    ],
+  )
+})
+
+// Value: protects=AC 2 row 2 in VS Code; fails_when=the run row loses Stop watching, Open Chat or Show Output as inline actions, shows them as its click, or words the chat progress wrongly; no_claim=the status bar entry; seam=the pure row function
+test('a VS Code generation row shows the chat progress and carries Stop watching, Open Chat and Show Output', () => {
+  // Arrange
+  const facts = ready({ run: generationRun })
+
+  // Act
+  const row = readLlmWikiViewState(facts, wording).rows[0]
+
+  // Assert
+  assert.deepEqual(row, {
+    id: 'run',
+    label: 'Generating…',
+    description: 'In chat · 12 min of 55',
+    tooltip:
+      'Codebook is watching the chat for the new Wiki. Stop watching ends Codebook’s watch, not the chat.',
+    icon: 'sync~spin',
+    actions: ['stop-watching', 'open-chat', 'show-output'],
+  })
+})
+
+// Value: protects=AC 2 row 2 before the first sign; fails_when=a VS Code run that waits for the chat shows the minutes instead of the waiting text; no_claim=the first-sign detection; seam=the pure row function
+test('a VS Code run that waits for the chat reads Waiting for the chat to start', () => {
+  // Arrange
+  const facts = ready({ run: { ...generationRun, isAwaitingChat: true } })
+
+  // Act
+  const description = readLlmWikiViewState(facts, wording).rows[0]?.description
+
+  // Assert
+  assert.equal(description, 'Waiting for the chat to start')
+})
+
+// Value: protects=AC 2 row 2 in Cursor; fails_when=the Cursor run offers Open Chat or Stop watching, or does not name the agent; no_claim=the agent process; seam=the pure row function
+test('a Cursor update row names cursor-agent and carries Cancel and Show Output only', () => {
+  // Arrange
+  const facts = ready({
+    host: 'cursor',
+    run: { ...generationRun, kind: 'update', timeoutMs: 900_000 },
+  })
+
+  // Act
+  const model = readLlmWikiViewState(facts, wording)
+
+  // Assert
+  assert.deepEqual(
+    [model.rows[0]?.label, model.rows[0]?.description, model.rows[0]?.actions],
+    ['Updating…', 'cursor-agent · 12 min of 15', ['cancel-run', 'show-output']],
+  )
+  assert.equal(model.message, undefined)
+})
+
+// Value: protects=the TreeView.message while row 2 or 2c shows in VS Code; fails_when=the wrapping message is missing in VS Code during a watch, says Codebook is watching while only a reservation stands (the watch has stopped), or shows in Cursor or without a run; no_claim=the editor's wrapping; seam=the pure row function
+test('a VS Code run shows the watching message, a reservation alone says the watch stopped and the chat may still publish, and Cursor shows neither', () => {
+  // Arrange
+  const reservation: ReadyFacts['reservation'] = {
+    kind: 'generate',
+    host: 'vscode',
+    startedAtMs: START_MS,
+    retryAtMs: START_MS + 55 * MINUTE_MS,
+  }
+  const messageOf = (facts: ReadyFacts) =>
+    readLlmWikiViewState(facts, wording).message
+
+  // Act
+  const messages = [
+    messageOf(ready({ run: generationRun })),
+    messageOf(ready({ reservation })),
+    messageOf(ready({ host: 'cursor', run: generationRun })),
+    messageOf(ready({ wiki: publishedWiki })),
+  ]
+
+  // Assert
+  assert.deepEqual(messages, [
+    'Codebook is watching the chat. Stop watching does not stop the chat; stop it in the chat.',
+    'Codebook stopped watching the chat, which may still publish this Wiki. To stop it, stop the request in the chat.',
+    undefined,
+    undefined,
+  ])
+})
+
+// Value: protects=AC 2 row 2b; fails_when=another window's run is not named by kind and start time, or offers an action; no_claim=marker liveness; seam=the pure row function
+test('another window’s update, generation and half-written marker are named with their start time and offer no action', () => {
+  // Arrange
+  const rowFor = (elsewhere: ReadyFacts['elsewhere']) =>
+    readLlmWikiViewState(ready({ elsewhere }), wording).rows[0]
+
+  // Act
+  const rows = [
+    rowFor({ kind: 'update', startedAtMs: START_MS }),
+    rowFor({ kind: 'generate', startedAtMs: START_MS }),
+    rowFor({ startedAtMs: START_MS }),
+  ]
+
+  // Assert
+  assert.deepEqual(
+    rows.map((row) => [row?.label, row?.description, row?.actions]),
+    [
+      ['Updating in another window', 'since 12:00', []],
+      ['Generating in another window', 'since 12:00', []],
+      ['Starting in another window', 'since 12:00', []],
+    ],
+  )
+})
+
+// Value: protects=AC 2 row 2c; fails_when=a stopped watch's reservation does not show the retry time and the minutes left, its start in the tooltip or Open Chat; no_claim=the reservation's bound; seam=the pure row function
+test('a stopped watch’s reservation reads Waiting for chat with its retry time and offers Open Chat', () => {
+  // Arrange
+  const facts = ready({
+    reservation: {
+      kind: 'generate',
+      host: 'vscode',
+      startedAtMs: START_MS,
+      retryAtMs: START_MS + 55 * MINUTE_MS,
+    },
+  })
+
+  // Act
+  const row = readLlmWikiViewState(facts, wording).rows[0]
+
+  // Assert
+  assert.deepEqual(row, {
+    id: 'reservation',
+    label: 'Waiting for chat',
+    description: 'retry after 12:55 (about 43 min)',
+    tooltip:
+      'Generating started at 12:00 in VS Code. Open Chat opens the chat view; find the session in the chat history to stop it. Codebook allows a new start after 12:55 even if the chat stopped earlier.',
+    icon: 'clock',
+    actions: ['open-chat'],
+  })
+})
+
+// Value: protects=AC 2 row 3 and AC 4; fails_when=a generation that ended without a Wiki hides its short cause, or the cause is worded wrongly for each ending; no_claim=the full sentence (host tests); seam=the pure row function
+test('the last attempt row words each ending of a generation in a few words and offers Try again', () => {
+  // Arrange
+  const sentence = 'The generation stopped.'
+  const descriptionFor = (
+    stopped: NonNullable<ReadyFacts['lastAttempt']>,
+  ): [string | undefined, string[] | undefined] => {
+    const row = readLlmWikiViewState(ready({ lastAttempt: stopped }), wording)
+      .rows[0]
+    return [row?.description, row?.actions]
+  }
+
+  // Act
+  const endings = [
+    descriptionFor({ state: 'cancelled', host: 'vscode', sentence }),
+    descriptionFor({ state: 'cancelled', host: 'cursor', sentence }),
+    descriptionFor({
+      state: 'timed-out',
+      host: 'cursor',
+      timeoutMs: 3_300_000,
+      sentence,
+    }),
+    descriptionFor({ state: 'failed', host: 'cursor', sentence }),
+    descriptionFor({
+      state: 'failed',
+      host: 'cursor',
+      agentExitCode: 1,
+      sentence,
+    }),
+    descriptionFor({ state: 'conflict', host: 'vscode', sentence }),
+  ]
+
+  // Assert
+  assert.deepEqual(endings, [
+    ['stopped watching', ['try-again']],
+    ['cancelled', ['try-again']],
+    ['stopped after 55 minutes', ['try-again']],
+    ['no Wiki published', ['try-again']],
+    ['agent exit 1', ['try-again']],
+    ['files in the way', ['try-again']],
+  ])
+})
+
+// Value: protects=AC 2 row 3 click; fails_when=the row click does not run the attention command with the row id, or the full sentence is lost; no_claim=the notice; seam=the pure row function
+test('the last attempt row click shows its full sentence through the attention command', () => {
+  // Arrange
+  const facts = ready({
+    lastAttempt: {
+      state: 'failed',
+      host: 'cursor',
+      sentence: 'Cursor Agent finished without publishing an LLM Wiki.',
+    },
+  })
+
+  // Act
+  const row = readLlmWikiViewState(facts, wording).rows[0]
+
+  // Assert
+  assert.deepEqual(
+    [row?.command, row?.detail],
+    [
+      { command: 'codebook.showLlmWikiAttention', arguments: ['last-attempt'] },
+      'Cursor Agent finished without publishing an LLM Wiki.',
+    ],
+  )
+})
+
+// Value: protects=AC 4 and the late publication (row 3 goes away); fails_when=the last attempt row stays beside a published Wiki, or Try again shows beside a run or an attention row; no_claim=the late-publication notice; seam=the pure row function
+test('the last attempt row goes away when a Wiki is published and hides Try again beside a run or an attention row', () => {
+  // Arrange
+  const stopped: ReadyFacts['lastAttempt'] = {
+    state: 'cancelled',
+    host: 'vscode',
+    sentence: 'Stopped.',
+  }
+
+  // Act
+  const ids = {
+    withWiki: idsOf(ready({ lastAttempt: stopped, wiki: publishedWiki })),
+    withRun: readLlmWikiViewState(
+      ready({ lastAttempt: stopped, run: generationRun }),
+      wording,
+    ).rows.find((row) => row.id === 'last-attempt')?.actions,
+    withAttention: readLlmWikiViewState(
+      ready({
+        lastAttempt: stopped,
+        attention: { cause: 'held-publish-lock', sentence: 'Locked.' },
+      }),
+      wording,
+    ).rows.find((row) => row.id === 'last-attempt')?.actions,
+  }
+
+  // Assert
+  assert.deepEqual(ids, {
+    withWiki: ['wiki', 'output'],
+    withRun: [],
+    withAttention: [],
+  })
+})
+
+const ATTENTION_CASES: Array<{
+  cause: string
+  label: string
+  shortCause: string
+  actions: string[]
+  hidesWiki: boolean
+}> = [
+  {
+    cause: 'held-publish-lock',
+    label: 'Publish in progress or stopped',
+    shortCause: 'publish lock found',
+    actions: ['copy-recovery', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'unfinished-publish',
+    label: 'Publish in progress or stopped',
+    shortCause: 'unfinished publish',
+    actions: ['copy-recovery', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'edited-manifest',
+    label: 'Wiki manifest needs recovery',
+    shortCause: 'manifest edited',
+    actions: ['copy-recovery', 'refresh'],
+    hidesWiki: true,
+  },
+  {
+    cause: 'unreadable-manifest',
+    label: 'Wiki manifest needs recovery',
+    shortCause: 'manifest unreadable',
+    actions: ['copy-recovery', 'refresh'],
+    hidesWiki: true,
+  },
+  {
+    cause: 'not-a-folder',
+    label: 'Wiki folder belongs elsewhere',
+    shortCause: 'output is a file or link',
+    actions: ['change-location'],
+    hidesWiki: true,
+  },
+  {
+    cause: 'linked-parent',
+    label: 'Wiki folder belongs elsewhere',
+    shortCause: 'link on the folder path',
+    actions: ['change-location'],
+    hidesWiki: true,
+  },
+  {
+    cause: 'foreign-manifest',
+    label: 'Wiki folder belongs elsewhere',
+    shortCause: 'another checkout',
+    actions: ['change-location'],
+    hidesWiki: true,
+  },
+  {
+    cause: 'learner-file',
+    label: 'Wiki files changed by hand',
+    shortCause: 'your file is in the folder',
+    actions: ['reveal-folder', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'special-file',
+    label: 'Wiki files changed by hand',
+    shortCause: 'link or special file',
+    actions: ['reveal-folder', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'edited-page',
+    label: 'Wiki files changed by hand',
+    shortCause: 'page edited by hand',
+    actions: ['reveal-folder', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'missing-page',
+    label: 'Wiki files changed by hand',
+    shortCause: 'page missing',
+    actions: ['reveal-folder', 'refresh'],
+    hidesWiki: false,
+  },
+  {
+    cause: 'a-cause-added-later',
+    label: 'Wiki needs attention',
+    shortCause: 'see details',
+    actions: ['refresh'],
+    hidesWiki: false,
+  },
+]
+
+for (const attentionCase of ATTENTION_CASES) {
+  // Value: protects=AC 2 (each of the ten conflict causes, the foreign manifest and a later cause); fails_when=the cause loses its label, short cause, actions or its row-click sentence, or hides or keeps the Wiki row wrongly; no_claim=how the cause is found (host tests); seam=the pure row function
+  test(`the attention cause ${attentionCase.cause} shows ${attentionCase.label} with its sentence and actions`, () => {
+    // Arrange
+    const facts = ready({
+      wiki: publishedWiki,
+      attention: { cause: attentionCase.cause, sentence: 'The full sentence.' },
+    })
+
+    // Act
+    const model = readLlmWikiViewState(facts, wording)
+
+    // Assert
+    const attention = model.rows.find((row) => row.id === 'attention')
+    assert.deepEqual(
+      {
+        label: attention?.label,
+        description: attention?.description,
+        actions: attention?.actions,
+        command: attention?.command,
+        detail: attention?.detail,
+        isWikiShown: model.rows.some((row) => row.id === 'wiki'),
+      },
+      {
+        label: attentionCase.label,
+        description: attentionCase.shortCause,
+        actions: attentionCase.actions,
+        command: {
+          command: 'codebook.showLlmWikiAttention',
+          arguments: ['attention'],
+        },
+        detail: 'The full sentence.',
+        isWikiShown: !attentionCase.hidesWiki,
+      },
+    )
+  })
+}
+
+// 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
+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({
+    wiki: publishedWiki,
+    run: generationRun,
+    elsewhere: { kind: 'update', startedAtMs: START_MS },
+    reservation: {
+      kind: 'generate',
+      host: 'vscode',
+      startedAtMs: START_MS,
+      retryAtMs: START_MS + MINUTE_MS,
+    },
+    lastAttempt: { state: 'failed', host: 'vscode', sentence: 'Failed.' },
+    attention: { cause: 'edited-page', sentence: 'Edited.' },
+    isWatcherBroken: true,
+  })
+
+  // Act
+  const model = readLlmWikiViewState(facts, wording)
+
+  // Assert
+  assert.deepEqual(
+    model.rows.map((row) => row.id),
+    ['wiki', 'run', 'elsewhere', 'reservation', 'attention', 'output'],
+  )
+  assert.deepEqual(model.rows.at(-1), {
+    id: 'output',
+    label: 'Output: .codebook/wiki',
+    description: 'Change location',
+    tooltip:
+      '/repo/.codebook/wiki\nCodebook could not watch this folder, so the view refreshes when it is shown and with Refresh only.',
+    icon: 'folder',
+    actions: ['change-location'],
+  })
+})
+
+// Value: protects=the Wiki row's explanation of the no-Git caveat; fails_when=the tooltip of a current Wiki without a recorded Git revision omits the sentence that added files are not checked, which the description truncates in a narrow sidebar; no_claim=the description's wording (the freshness table test); seam=the pure row function
+test('the Wiki row tooltip repeats the no-Git caveat that the description may truncate', () => {
+  // Arrange
+  const facts = ready({
+    wiki: {
+      ...publishedWiki,
+      freshness: { status: 'current', isAdditionUnchecked: true },
+    },
+  })
+
+  // Act
+  const tooltip = readLlmWikiViewState(facts, wording).rows[0]?.tooltip
+
+  // Assert
+  assert.equal(
+    tooltip,
+    'Generated from 1936e41 on Oct 26, 2026\nNo Git revision is recorded for this Wiki, so added files are not checked.\nClick to open the Wiki in the browser.',
+  )
+})
+
+// Value: protects=rows against a start time that cannot be read (Date.parse gives NaN); fails_when=a run, another window's run or a reservation shows NaN, Invalid Date or a made-up number of minutes; no_claim=how the facts reader finds the start; seam=the pure row function
+test('a run, an elsewhere row and a reservation with an unknown start show no minutes and no time', () => {
+  // Arrange
+  const unknownStart = Number.NaN
+  const vscodeRun = ready({
+    run: { ...generationRun, startedAtMs: unknownStart },
+  })
+  const cursorRun = ready({
+    host: 'cursor',
+    run: { ...generationRun, startedAtMs: unknownStart },
+  })
+  const elsewhere = ready({ elsewhere: { startedAtMs: unknownStart } })
+  const reservation = ready({
+    reservation: {
+      kind: 'generate',
+      host: 'vscode',
+      startedAtMs: unknownStart,
+      retryAtMs: START_MS + 55 * MINUTE_MS,
+    },
+  })
+
+  // Act
+  const rows = [vscodeRun, cursorRun, elsewhere, reservation].map(
+    (facts) => readLlmWikiViewState(facts, wording).rows[0],
+  )
+
+  // Assert
+  assert.deepEqual(
+    rows.map((row) => [row?.description, row?.tooltip]),
+    [
+      [
+        'In chat',
+        'Codebook is watching the chat for the new Wiki. Stop watching ends Codebook’s watch, not the chat.',
+      ],
+      ['cursor-agent', 'Cursor Agent is writing the Wiki. Cancel stops it.'],
+      [undefined, undefined],
+      [
+        'retry after 12:55 (about 43 min)',
+        'Generating started in VS Code. Open Chat opens the chat view; find the session in the chat history to stop it. Codebook allows a new start after 12:55 even if the chat stopped earlier.',
+      ],
+    ],
+  )
+})
+
+// Value: protects=the Wiki row's generation line against a manifest time that cannot be read; fails_when=the tooltip says Invalid Date for a non-finite publication time; no_claim=the date's locale; seam=the pure row function
+test('a publication time that is not a number leaves the date out of the generation line', () => {
+  // Arrange
+  const facts = ready({
+    wiki: {
+      ...publishedWiki,
+      generation: {
+        revision: '1936e41913729663cc99081e3224db89bb2d8e56',
+        publishedAtMs: Number.NaN,
+      },
+    },
+  })
+
+  // Act
+  const tooltip = readLlmWikiViewState(facts, wording).rows[0]?.tooltip
+
+  // Assert
+  assert.equal(
+    tooltip,
+    'Generated from 1936e41\nClick to open the Wiki in the browser.',
+  )
+})
diff --git a/extension/src/tests/resolveManageTrustCommand.test.ts b/extension/src/tests/resolveManageTrustCommand.test.ts
new file mode 100644
index 000000000..95fd6e828
--- /dev/null
+++ b/extension/src/tests/resolveManageTrustCommand.test.ts
@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { resolveManageTrustCommand } from '../utils/resolveManageTrustCommand'
+
+// Value: protects=the manage-trust id decision (assumed ids workbench.trust.manage and workbench.action.manageTrust); fails_when=the first known id is not preferred, an id the editor does not list is returned, or an editor with none gets one; no_claim=that either id exists in Cursor (native trial); seam=the pure function
+test('the manage-trust command is the first known id the editor lists, and none when it lists none', () => {
+  // Arrange
+  const both = ['x', 'workbench.action.manageTrust', 'workbench.trust.manage']
+  const onlySecond = ['workbench.action.manageTrust']
+
+  // Act
+  const picks = [
+    resolveManageTrustCommand(both),
+    resolveManageTrustCommand(onlySecond),
+    resolveManageTrustCommand(['other']),
+  ]
+
+  // Assert
+  assert.deepEqual(picks, [
+    'workbench.trust.manage',
+    'workbench.action.manageTrust',
+    undefined,
+  ])
+})
diff --git a/extension/src/tests/utils/fakeFileWatching.ts b/extension/src/tests/utils/fakeFileWatching.ts
index a280b8017..a8c907ea7 100644
--- a/extension/src/tests/utils/fakeFileWatching.ts
+++ b/extension/src/tests/utils/fakeFileWatching.ts
@@ -44,7 +44,7 @@ function isUnderFolder(base: string, fsPath: string): boolean {
  *
  * As in the editor, a listener whose registration was disposed gets no further event although its watcher lives on, and a watcher gets only the files under its folder. The glob under that folder is not evaluated: every file below the folder is delivered.
  *
- * @returns `createFileSystemWatcher` for the stub's `workspace`; `watched` (the pattern of every watcher created so far); `report` (fires one event of a kind at the listeners of every watcher that is not disposed and whose folder contains the file); `liveWatcherCount`.
+ * @returns `createFileSystemWatcher` for the stub's `workspace`; `watched` (the pattern of every watcher created so far); `report` (fires one event of a kind at the listeners of every watcher that is not disposed and whose folder contains the file; `reportedAs` is the spelling the listeners get when the editor spells the path in another case or drive letter than the folder check does); `liveWatcherCount`.
  *
  * @example
  * ```ts
@@ -61,7 +61,7 @@ export function createFakeFileWatching(): {
     dispose(): void
   }
   watched: FakeRelativePattern[]
-  report(kind: FileEventKind, fsPath: string): void
+  report(kind: FileEventKind, fsPath: string, reportedAs?: string): void
   liveWatcherCount(): number
 } {
   const watched: FakeRelativePattern[] = []
@@ -94,11 +94,12 @@ export function createFakeFileWatching(): {
       }
     },
     watched,
-    report(kind, fsPath): void {
+    report(kind, fsPath, reportedAs = fsPath): void {
       for (const watcher of liveWatchers) {
         // A watcher hears only of files under the folder it watches.
         if (!isUnderFolder(watcher.pattern.base, fsPath)) continue
-        for (const listener of watcher.listeners[kind]) listener({ fsPath })
+        for (const listener of watcher.listeners[kind])
+          listener({ fsPath: reportedAs })
       }
     },
     liveWatcherCount: () => liveWatchers.size,
diff --git a/extension/src/tests/utils/fakeLlmWikiEditor.ts b/extension/src/tests/utils/fakeLlmWikiEditor.ts
new file mode 100644
index 000000000..fadbee4f0
--- /dev/null
+++ b/extension/src/tests/utils/fakeLlmWikiEditor.ts
@@ -0,0 +1,117 @@
+import type { LlmWikiViewOptions } from '../../utils/llmWikiView'
+
+import { createFakeFileWatching, FakeRelativePattern } from './fakeFileWatching'
+import { listenTo } from './listenTo'
+
+/** One row of the fake tree as a test reads it. */
+export type FakeTreeRow = {
+  id: string
+  label: string
+  description: string | undefined
+  tooltip: string | undefined
+}
+
+/**
+ * Stands in for the editor surface of {@link createLlmWikiView} (tree view, context keys, events, file watcher), so a test drives the view's read loop without the extension's activation.
+ *
+ * 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`.
+ * @example
+ * const fake = createFakeLlmWikiEditor()
+ * const view = createLlmWikiView({ editor: fake.editor, host: 'vscode', … })
+ * fake.rows().map((row) => row.id) // => ['wiki', 'output']
+ */
+export function createFakeLlmWikiEditor() {
+  const files = createFakeFileWatching()
+  const contextKeys: Record<string, unknown> = {}
+  const configurationListeners: Array<
+    (event: { affectsConfiguration: (id: string) => boolean }) => void
+  > = []
+  let provider:
+    | {
+        getChildren(element?: string): string[]
+        getTreeItem(id: string): Record<string, unknown>
+      }
+    | undefined
+  const editorStub = {
+    commands: {
+      executeCommand: async (
+        name: string,
+        key?: string,
+        value?: unknown,
+      ): Promise<void> => {
+        if (name === 'setContext' && key !== undefined) contextKeys[key] = value
+      },
+    },
+    EventEmitter: class {
+      readonly #listeners: Array<() => void> = []
+      readonly event = (listener: () => void) =>
+        listenTo(this.#listeners, listener)
+      fire(): void {
+        for (const listener of [...this.#listeners]) listener()
+      }
+      dispose(): void {}
+    },
+    RelativePattern: FakeRelativePattern,
+    ThemeIcon: class {
+      constructor(readonly id: string) {}
+    },
+    TreeItem: class {
+      id?: string
+      description?: string
+      tooltip?: string
+      accessibilityInformation?: { label: string }
+      iconPath?: unknown
+      contextValue?: string
+      command?: unknown
+      constructor(
+        readonly label: string,
+        readonly collapsibleState?: number,
+      ) {}
+    },
+    TreeItemCollapsibleState: { None: 0 },
+    window: {
+      createTreeView: (
+        _id: string,
+        treeOptions: { treeDataProvider: NonNullable<typeof provider> },
+      ) => {
+        provider = treeOptions.treeDataProvider
+        return {
+          message: undefined as string | undefined,
+          onDidChangeVisibility: () => ({ dispose(): void {} }),
+          dispose(): void {},
+        }
+      },
+    },
+    workspace: {
+      createFileSystemWatcher: files.createFileSystemWatcher,
+      onDidChangeConfiguration: (
+        listener: (typeof configurationListeners)[number],
+      ) => listenTo(configurationListeners, listener),
+      onDidGrantWorkspaceTrust: () => ({ dispose(): void {} }),
+      onDidChangeWorkspaceFolders: () => ({ dispose(): void {} }),
+    },
+  }
+  return {
+    // The stub implements the surface the view uses; the full editor API is far larger.
+    editor: editorStub as unknown as LlmWikiViewOptions['editor'],
+    rows: (): FakeTreeRow[] =>
+      (provider?.getChildren() ?? []).map((id) => {
+        const item = provider?.getTreeItem(id) ?? {}
+        return {
+          id,
+          label: String(item.label),
+          description: item.description as string | undefined,
+          tooltip: item.tooltip as string | undefined,
+        }
+      }),
+    contextKeys,
+    files,
+    fireConfigurationChange(): void {
+      for (const listener of [...configurationListeners])
+        listener({ affectsConfiguration: () => true })
+    },
+  }
+}
diff --git a/extension/src/tests/utils/openProjectWithoutWiki.ts b/extension/src/tests/utils/openProjectWithoutWiki.ts
new file mode 100644
index 000000000..1de476bcb
--- /dev/null
+++ b/extension/src/tests/utils/openProjectWithoutWiki.ts
@@ -0,0 +1,84 @@
+import { createHash } from 'node:crypto'
+import {
+  access,
+  mkdir,
+  mkdtemp,
+  realpath,
+  rename,
+  rm,
+  writeFile,
+} from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { openWikiUpdateWindow } from './wikiUpdateWindow'
+
+/** Says whether a path exists on disk. */
+export const exists = (path: string): Promise<boolean> =>
+  access(path).then(
+    () => true,
+    () => false,
+  )
+
+/** Publishes a first Wiki the way the publisher would: its entry page, then the manifest of this project and the receipt that names the manifest's hash, each moved into place. */
+export async function publishGeneratedWiki(
+  outputDirectory: string,
+  projectRoot: string,
+  repositoryRoot = projectRoot,
+): Promise<void> {
+  await mkdir(outputDirectory, { recursive: true })
+  await writeFile(join(outputDirectory, 'index.html'), '<title>Wiki</title>')
+  const manifestText = JSON.stringify({
+    schemaVersion: 1,
+    repositoryRoot,
+    generated: { revision: '1936e41913729663cc99081e3224db89bb2d8e56' },
+    pages: [],
+    assets: [],
+    excludedPaths: [],
+    includedSources: [{ path: 'src/a.ts', sha256: 'a'.repeat(64) }],
+  })
+  const manifestPath = join(outputDirectory, 'codebook-wiki.json')
+  await writeFile(`${manifestPath}.next`, manifestText)
+  await rename(`${manifestPath}.next`, manifestPath)
+  const receiptPath = join(outputDirectory, 'codebook-publication.json')
+  await writeFile(
+    `${receiptPath}.next`,
+    JSON.stringify({
+      schemaVersion: 1,
+      kind: 'published',
+      manifestSha256: createHash('sha256').update(manifestText).digest('hex'),
+    }),
+  )
+  await rename(`${receiptPath}.next`, receiptPath)
+}
+
+/** Opens a window on a project that has no Wiki and no `.codebook` folder yet, the ordinary first use; the browser reader is not opened, since there is nothing to serve. */
+export async function openProjectWithoutWiki(
+  options: Omit<
+    Parameters<typeof openWikiUpdateWindow>[0],
+    'projectRoot' | 'openReader'
+  > = {},
+) {
+  const projectDirectory = await mkdtemp(
+    join(tmpdir(), 'codebook-wiki-generate-'),
+  )
+  const projectRoot = await realpath(projectDirectory)
+  const window = await openWikiUpdateWindow({
+    ...options,
+    projectRoot,
+    openReader: false,
+  })
+  const outputDirectory = join(projectRoot, '.codebook', 'wiki')
+  return {
+    ...window,
+    projectRoot,
+    outputDirectory,
+    markerPath: `${outputDirectory}.update-run.json`,
+    /** Closes the editor window as the learner does, keeping the project on disk for the test's assertions; `close` still removes it. */
+    closeWindow: (): Promise<void> => window.close(),
+    async close(): Promise<void> {
+      await window.close()
+      await rm(projectDirectory, { recursive: true, force: true })
+    },
+  }
+}
diff --git a/extension/src/tests/utils/wikiUpdateWindow.ts b/extension/src/tests/utils/wikiUpdateWindow.ts
index fc8129044..2df2eb678 100644
--- a/extension/src/tests/utils/wikiUpdateWindow.ts
+++ b/extension/src/tests/utils/wikiUpdateWindow.ts
@@ -13,6 +13,7 @@ import {
 } from '../../utils/inspectDeepWikiFreshness'
 import { listWikiCandidates } from '../../utils/listWikiCandidates'
 import { PREPARED_LOCK_SUFFIX } from '../../utils/preparedLockSuffix'
+import { readWikiPublicationIdentity } from '../../utils/readWikiPublicationIdentity'
 import { readWikiPublishToken } from '../../utils/readWikiPublishToken'
 import { readWikiWatchStamp } from '../../utils/readWikiWatchStamp'
 import { startWikiChatUpdate } from '../../utils/startWikiChatUpdate'
@@ -25,6 +26,11 @@ import { createFakeFileWatching, FakeRelativePattern } from './fakeFileWatching'
 import { listenTo } from './listenTo'
 import { loadModule } from './loadModule'
 
+/** How often an opening window looks whether the LLM Wiki view has shown its first read. */
+const FIRST_VIEW_READ_POLL_MS = 5
+/** How long an opening window waits for the LLM Wiki view's first read before the test fails with that cause. */
+const FIRST_VIEW_READ_LIMIT_MS = 10_000
+
 /** The Cancel of one run the window showed: the Cancel button of a progress notification (a Cursor run), or a press on the status bar entry that watches a VS Code update. */
 export type CancellableProgress = {
   cancel(): void
@@ -46,6 +52,28 @@ type FakeStatusBarEntry = {
   dispose(): void
 }
 
+/** One row of the LLM Wiki view as the editor would draw it. */
+export type FakeLlmWikiRow = {
+  id: string
+  label: string
+  description?: string
+  tooltip?: string
+  iconId?: string
+  command?: { command: string; arguments?: unknown[] }
+  contextValue?: string
+  /** The accessible name the editor reads for the row. */
+  accessibleName?: string
+}
+
+/** The LLM Wiki view as the fake editor holds it: its rows, its message, its context keys and how often it fired a change. */
+export type FakeLlmWikiView = {
+  rows(): FakeLlmWikiRow[]
+  message(): string | undefined
+  contextKeys: Record<string, unknown>
+  treeChangeCount(): number
+  setVisible(isVisible: boolean): void
+}
+
 type UriHandler = (uri: { path: string; query: string }) => Promise<void>
 
 /** A document the fake editor reports as opened: only the address the extension looks at. */
@@ -67,7 +95,7 @@ type NumericConstantName = {
     : never
 }[keyof typeof constants]
 
-/** An awaited step of an update that a test can keep open: the freshness inspection among the start checks, VS Code's chat command that carries the request, one listing of the candidates (the next listing after `hold` is kept open once it has read the folder; later ones pass), the wait of the start check before its second look at a publish journal written a moment ago (held, it lasts until the release and no real time), a read of the publish token (the start checks read it and so does the end of a run, so a hold set after the start keeps the end open), or the change of the run's marker at its end (its removal or its turn into a reservation: held, the run's end is already recorded and told, and the run waits there), or the write of the reservation that turn puts beside the marker (held, the change holds the claim on the marker while it waits, as a slow disk holds it), or the moment after a start's claim on the marker answered and before the start reads the answer (`claim-answer`). */
+/** An awaited step of an update that a test can keep open: the freshness inspection among the start checks, VS Code's chat command that carries the request, one listing of the candidates (the next listing after `hold` is kept open once it has read the folder; later ones pass), the wait of the start check before its second look at a publish journal written a moment ago (held, it lasts until the release and no real time), a read of the publish token (the start checks read it and so does the end of a run, so a hold set after the start keeps the end open), or the change of the run's marker at its end (its removal or its turn into a reservation: held, the run's end is already recorded and told, and the run waits there), or the write of the reservation that turn puts beside the marker (held, the change holds the claim on the marker while it waits, as a slow disk holds it), or the moment after a start's claim on the marker answered and before the start reads the answer (`claim-answer`), or a read of the publication identity (the LLM Wiki view reads it after the manifest, so a hold keeps a read open between the two). */
 export type HeldUpdateStep =
   | 'freshness-inspection'
   | 'chat-open'
@@ -77,6 +105,8 @@ export type HeldUpdateStep =
   | 'marker-change'
   | 'marker-write'
   | 'claim-answer'
+  | 'start-block'
+  | 'publication-read'
 
 /**
  * Opens an editor window (the real extension with a stubbed `vscode`) on a project whose Wiki already exists, and records everything the learner would see of an update.
@@ -161,9 +191,21 @@ export async function openWikiUpdateWindow(options: {
     message: string,
     choices: string[],
   ) => string | undefined
+  /** Whether the editor trusts the folder; true when omitted. */
+  trusted?: boolean
+  /** Opens the window with no folder. */
+  noFolder?: boolean
+  /** Keeps these steps open from the window's activation on, so a test sees the state before the first read ends; `hold(step)` then returns the same hold. */
+  holdAtOpen?: HeldUpdateStep[]
+  /** Commands the editor lists besides the chat's (for example the id of its manage-trust command). */
+  extraEditorCommands?: string[]
+  /** Makes the editor refuse the file watcher of the LLM Wiki view with this message. */
+  wikiWatcherFails?: string
 }): Promise<{
   chatRequests: Array<{ name: string; query: string }>
   executedCommands: string[]
+  /** Every editor command the extension ran, in order, with its first argument (a `Uri` is kept as given, so a test reads its `fsPath`). */
+  executedCommandCalls: Array<{ name: string; argument: unknown }>
   notices: string[]
   warnings: string[]
   errors: string[]
@@ -176,14 +218,36 @@ export async function openWikiUpdateWindow(options: {
   skillCalls: string[]
   /** Every line the extension wrote to Output › Codebook, as `info: …` or `error: …`. */
   outputLines: string[]
-  /** Runs one of the extension's registered commands, as the Command Palette does. */
-  runCommand(name: string): Promise<void>
+  /** Runs one of the extension's registered commands with the arguments a menu or a row passes, as the Command Palette does. */
+  runCommand(name: string, ...args: unknown[]): Promise<void>
+  /** What the editor shows of the LLM Wiki view. */
+  llmWiki: FakeLlmWikiView
+  /** Reports a file event the way the editor's watchers do. */
+  reportFileEvent(
+    kind: 'change' | 'create' | 'delete',
+    fsPath: string,
+    reportedAs?: string,
+  ): void
+  /** Says how many file watchers of the extension are alive. */
+  liveWatcherCount(): number
+  /** The patterns every file watcher of the extension was created with. */
+  watchedPatterns(): Array<{ base: string; pattern: string }>
+  /** What the extension copied to the clipboard. */
+  clipboard: string[]
+  /** Changes whether the editor trusts the folder; trust is granted during a session, never revoked. */
+  grantTrust(): void
+  /** Closes the folder: the window has none from now on. */
+  closeFolder(): void
+  /** Opens the folder again after {@link closeFolder}, as the learner restores it. */
+  reopenFolder(): void
   visibleStatusBarTexts(): string[]
   looks: {
     candidateListings: number
     stampReads: number
     stampReadsDone: number
     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
   }
   markerChanges: WikiMarkerChange[]
   openWorkspace(nextProjectRoot: string): void
@@ -216,6 +280,7 @@ export async function openWikiUpdateWindow(options: {
   let publishTokenReadFailure = options.publishTokenReadFails
   const chatRequests: Array<{ name: string; query: string }> = []
   const executedCommands: string[] = []
+  const executedCommandCalls: Array<{ name: string; argument: unknown }> = []
   const notices: string[] = []
   const warnings: string[] = []
   const errors: string[] = []
@@ -252,6 +317,7 @@ export async function openWikiUpdateWindow(options: {
     stampReads: 0,
     stampReadsDone: 0,
     markerClaims: 0,
+    publishTokenReads: 0,
   }
   const markerChanges: WikiMarkerChange[] = []
   /** Records one change of this window's marker, and what it answered once it settled. */
@@ -272,11 +338,74 @@ export async function openWikiUpdateWindow(options: {
       },
     )
   }
-  const commands = new Map<string, () => Promise<void>>()
+  const commands = new Map<string, (...args: unknown[]) => Promise<void>>()
+  const fileWatching = createFakeFileWatching()
+  const clipboard: string[] = []
+  const contextKeys: Record<string, unknown> = {}
+  const configurationListeners: Array<
+    (event: { affectsConfiguration: (id: string) => boolean }) => void
+  > = []
+  const trustListeners: Array<() => void> = []
+  let isTrusted = options.trusted ?? true
+  let isFolderOpen = !options.noFolder
+  let treeProvider:
+    | {
+        getChildren(): string[]
+        getTreeItem(id: string): Record<string, unknown>
+        onDidChangeTreeData(listener: () => void): { dispose(): void }
+      }
+    | undefined
+  let treeMessage: string | undefined
+  let treeChangeCount = 0
+  const visibilityListeners: Array<(event: { visible: boolean }) => void> = []
+  const holdControls = new Map<
+    HeldUpdateStep,
+    { started: Promise<void>; release(): void }
+  >()
   const holds = new Map<
     HeldUpdateStep,
     { reached(): void; released: Promise<void> }
   >()
+  /** Makes a hold on a step, or returns the one already made, for `hold()` and `holdAtOpen`. */
+  const makeHold = (
+    step: HeldUpdateStep,
+  ): { started: Promise<void>; release(): void } => {
+    const existing = holdControls.get(step)
+    if (existing) return existing
+    let reached = (): void => {}
+    let release = (): void => {}
+    const started = new Promise<void>((resolveStarted) => {
+      reached = resolveStarted
+    })
+    const released = new Promise<void>((resolveReleased) => {
+      release = resolveReleased
+    })
+    holds.set(step, { reached, released })
+    const controls = {
+      started,
+      release(): void {
+        holds.delete(step)
+        holdControls.delete(step)
+        release()
+      },
+    }
+    holdControls.set(step, controls)
+    return controls
+  }
+  for (const step of options.holdAtOpen ?? []) makeHold(step)
+  /** Waits until the LLM Wiki view has shown its first read: its state key no longer reads `loading` (an editor without the view never sets it). */
+  const untilFirstViewRead = async (): Promise<void> => {
+    const deadline = Date.now() + FIRST_VIEW_READ_LIMIT_MS
+    while (
+      contextKeys[constants.LLM_WIKI_STATE_CONTEXT_KEY] === 'loading' &&
+      Date.now() < deadline
+    )
+      await sleepFor(FIRST_VIEW_READ_POLL_MS)
+    if (contextKeys[constants.LLM_WIKI_STATE_CONTEXT_KEY] === 'loading')
+      throw new Error(
+        `The LLM Wiki view did not show its first read within ${FIRST_VIEW_READ_LIMIT_MS} ms.`,
+      )
+  }
   /** Waits at a step a test holds open; a step nobody holds passes at once. */
   const passHold = async (step: HeldUpdateStep): Promise<void> => {
     const hold = holds.get(step)
@@ -372,7 +501,10 @@ export async function openWikiUpdateWindow(options: {
         StatusBarAlignment: { Left: 1, Right: 2 },
         RelativePattern: FakeRelativePattern,
         commands: {
-          registerCommand(name: string, action: () => Promise<void>) {
+          registerCommand(
+            name: string,
+            action: (...args: unknown[]) => Promise<void>,
+          ) {
             commands.set(name, action)
             return { dispose(): void {} }
           },
@@ -383,10 +515,20 @@ export async function openWikiUpdateWindow(options: {
               'workbench.action.chat.newChat',
               'workbench.action.chat.cancel',
               'workbench.action.chat.removeAllPendingRequests',
+              ...(options.extraEditorCommands ?? []),
             ].filter(
               (command) => !options.missingEditorCommands?.includes(command),
             ),
-          executeCommand: async (name: string, argument?: unknown) => {
+          executeCommand: async (
+            name: string,
+            argument?: unknown,
+            value?: unknown,
+          ) => {
+            // A context key is the editor's own bookkeeping, not a command the learner ran.
+            if (name === 'setContext') {
+              contextKeys[String(argument)] = value
+              return undefined
+            }
             // Only the chat command that carries a query is the request; without one it reveals the chat.
             const query =
               typeof argument === 'object' &&
@@ -398,6 +540,7 @@ export async function openWikiUpdateWindow(options: {
             executedCommands.push(
               query === undefined ? name : `${name} with the update request`,
             )
+            executedCommandCalls.push({ name, argument })
             if (
               name === 'codebook.openDeepWiki' &&
               options.openWikiFails !== undefined
@@ -424,6 +567,21 @@ export async function openWikiUpdateWindow(options: {
         workspace: {
           getConfiguration: () => ({ get: () => outputSetting }),
           onDidChangeWorkspaceFolders: () => ({ dispose(): void {} }),
+          onDidChangeConfiguration: (
+            listener: (event: {
+              affectsConfiguration: (id: string) => boolean
+            }) => void,
+          ) => listenTo(configurationListeners, listener),
+          onDidGrantWorkspaceTrust: (listener: () => void) =>
+            listenTo(trustListeners, listener),
+          get isTrusted() {
+            return isTrusted
+          },
+          get workspaceFolders() {
+            return isFolderOpen
+              ? [{ uri: { scheme: 'file', fsPath: openedWorkspace } }]
+              : undefined
+          },
           onDidOpenTextDocument: (
             listener: (document: FakeTextDocument) => void,
           ) => {
@@ -432,15 +590,56 @@ export async function openWikiUpdateWindow(options: {
             return listenTo(documentOpenListeners, listener)
           },
           // The opened Wiki watches the project's files; these tests report no file event.
-          createFileSystemWatcher:
-            createFakeFileWatching().createFileSystemWatcher,
+          createFileSystemWatcher: (pattern: FakeRelativePattern) => {
+            // The LLM Wiki view's own watcher can be refused; the opened Wiki's watches the project.
+            if (
+              options.wikiWatcherFails !== undefined &&
+              pattern.pattern !== '**'
+            )
+              throw new Error(options.wikiWatcherFails)
+            return fileWatching.createFileSystemWatcher(pattern)
+          },
+        },
+        EventEmitter: class {
+          readonly #listeners: Array<(value: unknown) => void> = []
+          readonly event = (listener: (value: unknown) => void) =>
+            listenTo(this.#listeners, listener)
+          fire(value?: unknown): void {
+            for (const listener of [...this.#listeners]) listener(value)
+          }
+          dispose(): void {}
+        },
+        TreeItem: class {
+          id?: string
+          description?: string
+          tooltip?: string
+          accessibilityInformation?: { label: string }
+          iconPath?: unknown
+          contextValue?: string
+          command?: unknown
+          constructor(
+            readonly label: string,
+            readonly collapsibleState?: number,
+          ) {}
         },
+        ThemeIcon: class {
+          constructor(readonly id: string) {}
+        },
+        TreeItemCollapsibleState: { None: 0, Collapsed: 1, Expanded: 2 },
         env: {
           ...(options.cursor ? { appName: 'Cursor' } : {}),
           asExternalUri: keepLocalAddress,
           openExternal: async () => true,
+          clipboard: {
+            writeText: async (text: string) => {
+              clipboard.push(text)
+            },
+          },
+        },
+        Uri: {
+          parse: parseFakeUri,
+          file: (fsPath: string) => ({ scheme: 'file', fsPath }),
         },
-        Uri: { parse: parseFakeUri },
         window: {
           registerUriHandler: (handler: { handleUri: UriHandler }) => {
             handleUri = handler.handleUri
@@ -484,6 +683,29 @@ export async function openWikiUpdateWindow(options: {
           onDidStartTerminalShellExecution: (
             listener: (event: FakeShellExecution) => void,
           ) => listenTo(terminalCommandListeners, listener),
+          createTreeView: (
+            _id: string,
+            treeOptions: {
+              treeDataProvider: NonNullable<typeof treeProvider>
+            },
+          ) => {
+            treeProvider = treeOptions.treeDataProvider
+            treeProvider.onDidChangeTreeData(() => {
+              treeChangeCount += 1
+            })
+            return {
+              get message() {
+                return treeMessage
+              },
+              set message(next: string | undefined) {
+                treeMessage = next
+              },
+              onDidChangeVisibility: (
+                listener: (event: { visible: boolean }) => void,
+              ) => listenTo(visibilityListeners, listener),
+              dispose(): void {},
+            }
+          },
           // A real editor always has both, so every test runs the product's own way of showing a run; only collecting their Cancel is optional.
           withProgress,
           createStatusBarItem,
@@ -507,16 +729,18 @@ export async function openWikiUpdateWindow(options: {
         : {}),
       // The real start check runs; a test that holds its wait at a fresh journal decides when the second look comes, and otherwise the real time passes.
       './utils/findWikiUpdateStartBlock': {
-        findWikiUpdateStartBlock: (
+        findWikiUpdateStartBlock: async (
           outputDirectory: string,
           projectRoot: string,
-        ) =>
-          findWikiUpdateStartBlock(outputDirectory, projectRoot, {
+        ) => {
+          await passHold('start-block')
+          return findWikiUpdateStartBlock(outputDirectory, projectRoot, {
             wait: async (delayMs: number) => {
               if (holds.has('journal-wait')) await passHold('journal-wait')
               else await sleepFor(delayMs)
             },
-          }),
+          })
+        },
       },
       // The real listing runs; the window only counts how often a look parsed the candidates, and can keep one listing open after it has read the folder.
       './utils/listWikiCandidates': {
@@ -568,12 +792,19 @@ export async function openWikiUpdateWindow(options: {
       },
       './utils/readWikiPublishToken': {
         readWikiPublishToken: async (outputDirectory: string) => {
+          looks.publishTokenReads += 1
           if (publishTokenReadFailure !== undefined)
             throw new Error(publishTokenReadFailure)
           await passHold('publish-token-read')
           return readWikiPublishToken(outputDirectory)
         },
       },
+      './utils/readWikiPublicationIdentity': {
+        readWikiPublicationIdentity: async (outputDirectory: string) => {
+          await passHold('publication-read')
+          return readWikiPublicationIdentity(outputDirectory)
+        },
+      },
       './deepWikiReader': {
         readDeepWikiManifest,
         startDeepWikiReader: async (
@@ -647,10 +878,11 @@ export async function openWikiUpdateWindow(options: {
       },
     },
   )
+  const contextSubscriptions: Array<{ dispose(): unknown }> = []
   boundary.activate({
     extensionPath: resolve(__dirname, '../../..'),
     globalStorageUri: { fsPath: projectRoot },
-    subscriptions: [],
+    subscriptions: contextSubscriptions,
     workspaceState: {
       get: (key: string) => workspaceState.get(key),
       update: async (key: string, value: unknown) => {
@@ -667,9 +899,12 @@ export async function openWikiUpdateWindow(options: {
   // The reader serves the update state, so the browser tab must be open first.
   if (options.openReader ?? true)
     await commands.get('codebook.openDeepWiki')?.()
+  // The LLM Wiki view reads the Wiki at activation, and once more after its watcher stands. A test arranges its holds on the Wiki's reads only after those, so the view never takes a hold meant for a run; a test that holds a step at open wants the loading state and waits itself.
+  if ((options.holdAtOpen ?? []).length === 0) await untilFirstViewRead()
   return {
     chatRequests,
     executedCommands,
+    executedCommandCalls,
     notices,
     warnings,
     errors,
@@ -680,10 +915,55 @@ export async function openWikiUpdateWindow(options: {
     statusBarTexts,
     skillCalls,
     outputLines,
-    async runCommand(name: string): Promise<void> {
+    async runCommand(name: string, ...args: unknown[]): Promise<void> {
       const command = commands.get(name)
       if (!command) throw new Error(`The window registered no ${name}.`)
-      await command()
+      await command(...args)
+    },
+    llmWiki: {
+      rows: () =>
+        (treeProvider?.getChildren() ?? []).map((id) => {
+          const item = treeProvider?.getTreeItem(id) ?? {}
+          const icon = item.iconPath
+          return {
+            id,
+            label: String(item.label),
+            description: item.description as string | undefined,
+            tooltip: item.tooltip as string | undefined,
+            iconId:
+              typeof icon === 'object' && icon !== null && 'id' in icon
+                ? String(icon.id)
+                : undefined,
+            command: item.command as FakeLlmWikiRow['command'],
+            contextValue: item.contextValue as string | undefined,
+            accessibleName: (
+              item.accessibilityInformation as { label: string } | undefined
+            )?.label,
+          }
+        }),
+      message: () => treeMessage,
+      contextKeys,
+      treeChangeCount: () => treeChangeCount,
+      setVisible(isVisible: boolean): void {
+        for (const listener of [...visibilityListeners])
+          listener({ visible: isVisible })
+      },
+    },
+    reportFileEvent: (kind, fsPath, reportedAs): void =>
+      fileWatching.report(kind, fsPath, reportedAs),
+    liveWatcherCount: () => fileWatching.liveWatcherCount(),
+    watchedPatterns: () =>
+      fileWatching.watched.map(({ base, pattern }) => ({ base, pattern })),
+    clipboard,
+    grantTrust(): void {
+      isTrusted = true
+      for (const listener of [...trustListeners]) listener()
+    },
+    closeFolder(): void {
+      isFolderOpen = false
+    },
+    reopenFolder(): void {
+      isFolderOpen = true
     },
     visibleStatusBarTexts: (): string[] =>
       statusBarEntries
@@ -728,6 +1008,10 @@ export async function openWikiUpdateWindow(options: {
     },
     setOutputSetting(value: string): void {
       outputSetting = value
+      for (const listener of [...configurationListeners])
+        listener({
+          affectsConfiguration: (id) => id === 'codebook.wikiOutputDirectory',
+        })
     },
     setFreshness(next: WikiFreshness): void {
       freshness = next
@@ -735,24 +1019,11 @@ export async function openWikiUpdateWindow(options: {
     breakPublishTokenRead(message: string | undefined): void {
       publishTokenReadFailure = message
     },
-    hold(step: HeldUpdateStep): { started: Promise<void>; release(): void } {
-      let reached = (): void => {}
-      let release = (): void => {}
-      const started = new Promise<void>((resolveStarted) => {
-        reached = resolveStarted
-      })
-      const released = new Promise<void>((resolveReleased) => {
-        release = resolveReleased
-      })
-      holds.set(step, { reached, released })
-      return {
-        started,
-        release(): void {
-          holds.delete(step)
-          release()
-        },
-      }
+    hold: makeHold,
+    close: async (): Promise<void> => {
+      await boundary.deactivate()
+      // The editor disposes the extension's subscriptions after deactivate; the LLM Wiki view's watcher and timers end there.
+      for (const subscription of contextSubscriptions) subscription.dispose()
     },
-    close: (): Promise<void> => boundary.deactivate(),
   }
 }
diff --git a/extension/src/tests/wikiGenerateFlow.test.ts b/extension/src/tests/wikiGenerateFlow.test.ts
index 978147ba2..74306ac25 100644
--- a/extension/src/tests/wikiGenerateFlow.test.ts
+++ b/extension/src/tests/wikiGenerateFlow.test.ts
@@ -2,14 +2,11 @@ import assert from 'node:assert/strict'
 import { createHash } from 'node:crypto'
 import { writeFileSync } from 'node:fs'
 import {
-  access,
   chmod,
   mkdir,
   mkdtemp,
   readFile,
   readdir,
-  realpath,
-  rename,
   rm,
   symlink,
   writeFile,
@@ -21,6 +18,11 @@ import { test } from 'node:test'
 import { waitUntil } from '../runtimeSupport/utils/waitUntil'
 import type { WikiFreshness } from '../utils/inspectDeepWikiFreshness'
 
+import {
+  exists,
+  openProjectWithoutWiki,
+  publishGeneratedWiki,
+} from './utils/openProjectWithoutWiki'
 import { openWikiUpdateWindow } from './utils/wikiUpdateWindow'
 
 const CURRENT: WikiFreshness = {
@@ -31,76 +33,6 @@ const CURRENT: WikiFreshness = {
 
 const GENERATE_COMMAND = 'codebook.generateDeepWiki'
 
-/** Says whether a path exists on disk. */
-const exists = (path: string): Promise<boolean> =>
-  access(path).then(
-    () => true,
-    () => false,
-  )
-
-/** Publishes a first Wiki the way the publisher would: its entry page, then the manifest of this project and the receipt that names the manifest's hash, each moved into place. */
-async function publishGeneratedWiki(
-  outputDirectory: string,
-  projectRoot: string,
-  repositoryRoot = projectRoot,
-): Promise<void> {
-  await mkdir(outputDirectory, { recursive: true })
-  await writeFile(join(outputDirectory, 'index.html'), '<title>Wiki</title>')
-  const manifestText = JSON.stringify({
-    schemaVersion: 1,
-    repositoryRoot,
-    generated: { revision: '1936e41913729663cc99081e3224db89bb2d8e56' },
-    pages: [],
-    assets: [],
-    excludedPaths: [],
-    includedSources: [{ path: 'src/a.ts', sha256: 'a'.repeat(64) }],
-  })
-  const manifestPath = join(outputDirectory, 'codebook-wiki.json')
-  await writeFile(`${manifestPath}.next`, manifestText)
-  await rename(`${manifestPath}.next`, manifestPath)
-  const receiptPath = join(outputDirectory, 'codebook-publication.json')
-  await writeFile(
-    `${receiptPath}.next`,
-    JSON.stringify({
-      schemaVersion: 1,
-      kind: 'published',
-      manifestSha256: createHash('sha256').update(manifestText).digest('hex'),
-    }),
-  )
-  await rename(`${receiptPath}.next`, receiptPath)
-}
-
-/** Opens a window on a project that has no Wiki and no `.codebook` folder yet, the ordinary first use; the browser reader is not opened, since there is nothing to serve. */
-async function openProjectWithoutWiki(
-  options: Omit<
-    Parameters<typeof openWikiUpdateWindow>[0],
-    'projectRoot' | 'openReader'
-  > = {},
-) {
-  const projectDirectory = await mkdtemp(
-    join(tmpdir(), 'codebook-wiki-generate-'),
-  )
-  const projectRoot = await realpath(projectDirectory)
-  const window = await openWikiUpdateWindow({
-    ...options,
-    projectRoot,
-    openReader: false,
-  })
-  const outputDirectory = join(projectRoot, '.codebook', 'wiki')
-  return {
-    ...window,
-    projectRoot,
-    outputDirectory,
-    markerPath: `${outputDirectory}.update-run.json`,
-    /** Closes the editor window as the learner does, keeping the project on disk for the test's assertions; `close` still removes it. */
-    closeWindow: (): Promise<void> => window.close(),
-    async close(): Promise<void> {
-      await window.close()
-      await rm(projectDirectory, { recursive: true, force: true })
-    },
-  }
-}
-
 // Value: protects=AC 1 and 14, the first Generate from Codebook's entry in VS Code in a project without `.codebook`; fails_when=Generate starts without the confirmation that names the resolved folder and the chat hand-over, sends no generate request, fails to claim its marker because the folder that holds it is missing (`placeStorageLock` makes no folder), writes no `runKind` into the marker, or makes the output folder itself; no_claim=the chat's own work and its publish (later tests); seam=the stubbed editor
 test('Generate LLM Wiki in VS Code confirms the folder and the chat hand-over, then hands a generate request to a new chat and claims a generation marker, in a project without .codebook', async (context) => {
   // Arrange
diff --git a/extension/src/tests/wikiUpdateRun.test.ts b/extension/src/tests/wikiUpdateRun.test.ts
index eafe7ae77..327036d79 100644
--- a/extension/src/tests/wikiUpdateRun.test.ts
+++ b/extension/src/tests/wikiUpdateRun.test.ts
@@ -499,3 +499,50 @@ test('a start refused because somebody is still updating the Wiki, and a run tha
     site: 'kept',
   })
 })
+
+// Value: protects=the LLM Wiki view's refresh on a change of this window's run state; fails_when=a start, an end, a refused start or a stopped listener's later change is reported wrongly; no_claim=what the view does with it; seam=the run state object
+test('onDidChange reports every change of the state and nothing after the listener is removed', () => {
+  // Arrange
+  const run = new WikiUpdateRun()
+  const output = {
+    outputDirectory: '/repo/.codebook/wiki',
+    outputLabel: '.codebook/wiki',
+  }
+  let changes = 0
+  const stopListening = run.onDidChange(() => {
+    changes += 1
+  })
+
+  // Act
+  run.begin('cursor', output, 900_000, false)
+  run.markCandidateStaged()
+  run.end({ state: 'cancelled', site: 'kept' })
+  run.refuseStart('cursor', output, {
+    kind: 'conflict',
+    paths: ['index.html'],
+    cause: 'edited-page',
+  })
+  const changesWhileListening = changes
+  stopListening()
+  run.begin('cursor', output, 900_000, false)
+
+  // Assert
+  assert.deepEqual([changesWhileListening, changes], [4, 4])
+})
+
+// Value: protects=the run state against a listener that throws; fails_when=a throwing listener stops the listeners after it from hearing a change, or the error leaves begin() or end() so the run's caller fails; no_claim=what a listener does with the change; seam=two listeners on one WikiUpdateRun; why_new=no test registers a throwing listener
+test('a listener that throws neither hides a change from the next listener nor fails the run call', () => {
+  // Arrange
+  const run = new WikiUpdateRun(fixedClock)
+  const heardStates: string[] = []
+  run.onDidChange(() => {
+    throw new Error('a broken view')
+  })
+  run.onDidChange(() => heardStates.push(run.status().state))
+
+  // Act
+  const wasAccepted = run.begin('vscode', output, 900_000, false)
+
+  // Assert
+  assert.deepEqual([wasAccepted, heardStates], [true, ['running']])
+})
diff --git a/extension/src/tests/withHomeFolderShown.test.ts b/extension/src/tests/withHomeFolderShown.test.ts
new file mode 100644
index 000000000..fe961ae30
--- /dev/null
+++ b/extension/src/tests/withHomeFolderShown.test.ts
@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { withHomeFolderShown } from '../utils/withHomeFolderShown'
+
+// Value: protects=Copy details hiding the learner's account; fails_when=the home folder stays in the copied sentence; no_claim=Windows spellings; seam=the pure function
+test('the home folder in a copied sentence reads ~', () => {
+  // Arrange
+  const sentence = 'Edited /Users/ada/repo/a.html and /Users/ada/b.md'
+
+  // Act
+  const copied = withHomeFolderShown(sentence, '/Users/ada')
+
+  // Assert
+  assert.equal(copied, 'Edited ~/repo/a.html and ~/b.md')
+})
+
+// Value: protects=the copied text when the home is a root or empty; fails_when=every slash of the sentence becomes ~ or the text is interleaved with ~; no_claim=how such a home arises; seam=the pure function
+test('a home folder that is / or empty leaves the copied sentence as it is', () => {
+  // Arrange
+  const sentence = 'Edited /repo/a.html'
+
+  // Act
+  const copied = [
+    withHomeFolderShown(sentence, '/'),
+    withHomeFolderShown(sentence, ''),
+  ]
+
+  // Assert
+  assert.deepEqual(copied, [sentence, sentence])
+})
+
+// Value: protects=the account name of a neighbour folder and of the learner in Copy details; fails_when=a folder whose name starts with the home's name is cut to ~ plus its tail, or the home before a closing quote, bracket or full stop stays; no_claim=Windows spellings; seam=the pure function; why_new=the first test only has paths below the home
+test('a sibling folder that starts with the home name stays whole and a home before a quote or full stop is hidden', () => {
+  // Arrange
+  const sentence =
+    'Edited /Users/adam/x and "/Users/ada" and (/Users/ada) and /Users/ada.'
+
+  // Act
+  const copied = withHomeFolderShown(sentence, '/Users/ada', 'darwin')
+
+  // Assert
+  assert.equal(copied, 'Edited /Users/adam/x and "~" and (~) and ~.')
+})
+
+// Value: protects=the account name in Copy details on Windows; fails_when=a home spelled with another drive letter case or with / instead of \ stays in the copied text, or a sibling folder is cut; no_claim=a real Windows host; seam=the pure function with the platform passed in; why_new=the other tests use POSIX paths
+test('on Windows the home folder reads ~ whatever the drive letter case and separator, and a sibling folder stays whole', () => {
+  // Arrange
+  const sentence =
+    'Edited c:\\users\\ADA\\repo\\a.html and C:/Users/ada/b.md and C:\\Users\\adam\\c.md'
+
+  // Act
+  const copied = withHomeFolderShown(sentence, 'C:\\Users\\ada', 'win32')
+
+  // Assert
+  assert.equal(
+    copied,
+    'Edited ~\\repo\\a.html and ~/b.md and C:\\Users\\adam\\c.md',
+  )
+})
+
+// Value: protects=a path that merely contains the home path further right; fails_when=/srv/home/me/x loses its /srv prefix to ~ because the home /home/me is found inside it; no_claim=every spelling of a left boundary; seam=the pure function; why_new=the earlier tests only put the home at the start of a word
+test('a path that contains the home path after another folder stays whole, while a home after a quote, bracket, equals sign or file:// is hidden', () => {
+  // Arrange
+  const sentence =
+    'Moved /srv/home/me/x and "/home/me/a" and [/home/me/b] and root=/home/me/c and file:///home/me/d'
+
+  // Act
+  const copied = withHomeFolderShown(sentence, '/home/me', 'linux')
+
+  // Assert
+  assert.equal(
+    copied,
+    'Moved /srv/home/me/x and "~/a" and [~/b] and root=~/c and file://~/d',
+  )
+})
+
+// Value: protects=the account name in Copy details on macOS, whose disks ignore case; fails_when=a home spelled in another case stays in the copied text on darwin, or is hidden on Linux where case matters; no_claim=a real Mac; seam=the pure function with the platform passed in; why_new=only Windows ignored case
+test('on macOS the home folder reads ~ whatever its case, and on Linux a different case stays', () => {
+  // Arrange
+  const sentence = 'Edited /users/ADA/a.html'
+
+  // Act
+  const copied = [
+    withHomeFolderShown(sentence, '/Users/ada', 'darwin'),
+    withHomeFolderShown(sentence, '/Users/ada', 'linux'),
+  ]
+
+  // Assert
+  assert.deepEqual(copied, ['Edited ~/a.html', sentence])
+})
diff --git a/extension/src/utils/chooseWikiWatchFolder.ts b/extension/src/utils/chooseWikiWatchFolder.ts
new file mode 100644
index 000000000..7deb69ebc
--- /dev/null
+++ b/extension/src/utils/chooseWikiWatchFolder.ts
@@ -0,0 +1,57 @@
+import * as nodePath from 'node:path'
+
+/** What {@link chooseWikiWatchFolder} weighs. */
+type WikiWatchChoice = {
+  /** The opened project's folder. */
+  projectRoot: string
+  /** The resolved Wiki folder. */
+  outputDirectory: string
+  /** The nearest folder at or above the output's parent that exists ({@link findNearestExistingAncestor}). */
+  nearestExistingFolder: string
+  /** The learner's home folder, which is never watched. */
+  homeDirectory: string
+  /** The path module of the system the paths belong to; tests pass `path.win32`. */
+  pathApi?: Pick<typeof nodePath, 'relative' | 'isAbsolute' | 'sep' | 'dirname'>
+}
+
+/**
+ * Chooses the folder the LLM Wiki view's watcher stands on, or none when every candidate would be too broad.
+ *
+ * Why: walking up from a Wiki output whose parents do not exist yet could end at the home folder or the file-system root, and a recursive watch there costs the editor far more than the view is worth.
+ * Trigger: {@link createLlmWikiView} at each read that shows a ready state.
+ *
+ * Inside the project the watcher never stands above the project root; for an output outside it, only on the output's own parent when that exists. The home folder and a file-system root are never watched.
+ *
+ * @param choice - The project, the output, the nearest existing folder and the home folder.
+ * @returns The folder to watch; `undefined` for the no-watcher fallback (the view then refreshes on visibility and its Refresh action only).
+ * @example
+ * chooseWikiWatchFolder({ projectRoot: '/repo', outputDirectory: '/repo/.codebook/wiki', nearestExistingFolder: '/repo', homeDirectory: '/Users/ada' }) // => '/repo'
+ * chooseWikiWatchFolder({ projectRoot: '/repo', outputDirectory: '/Users/ada/x/y/wiki', nearestExistingFolder: '/Users/ada', homeDirectory: '/Users/ada' }) // => undefined
+ */
+export function chooseWikiWatchFolder(
+  choice: WikiWatchChoice,
+): string | undefined {
+  const { projectRoot, outputDirectory, nearestExistingFolder, homeDirectory } =
+    choice
+  const pathApi = choice.pathApi ?? nodePath
+  /** Whether a path is the folder itself or lies below it. */
+  const isAtOrBelow = (folder: string, path: string): boolean => {
+    const fromFolder = pathApi.relative(folder, path)
+    return (
+      !pathApi.isAbsolute(fromFolder) &&
+      fromFolder !== '..' &&
+      !fromFolder.startsWith(`..${pathApi.sep}`)
+    )
+  }
+  const isInsideProject = isAtOrBelow(projectRoot, outputDirectory)
+  // Inside the project the nearest folder is the project root at the highest; outside, only the output's own parent counts.
+  const isAcceptable = isInsideProject
+    ? isAtOrBelow(projectRoot, nearestExistingFolder)
+    : nearestExistingFolder === pathApi.dirname(outputDirectory)
+  const isRoot =
+    pathApi.dirname(nearestExistingFolder) === nearestExistingFolder
+  const isHome =
+    homeDirectory !== '' &&
+    pathApi.relative(homeDirectory, nearestExistingFolder) === ''
+  return isAcceptable && !isRoot && !isHome ? nearestExistingFolder : undefined
+}
diff --git a/extension/src/utils/comparableFilePath.ts b/extension/src/utils/comparableFilePath.ts
new file mode 100644
index 000000000..58efc085d
--- /dev/null
+++ b/extension/src/utils/comparableFilePath.ts
@@ -0,0 +1,21 @@
+/**
+ * Writes a file path in the form two spellings of the same file share, so a watcher event is matched against the path Codebook computed even when the editor spells the drive letter or the case differently.
+ *
+ * Why: VS Code's `Uri.fsPath` lowercases the drive letter on Windows, and Windows and macOS disks are case-insensitive by default, so an exact string comparison drops real events.
+ * Trigger: the LLM Wiki view's file watcher compares each event with its four watched files ({@link createLlmWikiView}).
+ *
+ * @param path - An absolute file path.
+ * @param platform - The system whose paths these are; tests pass their own.
+ * @returns Windows: lower case with `/` as separator; macOS: lower case; every other system: the path as it is.
+ * @example
+ * comparableFilePath('C:\\Repo\\.codebook\\wiki.update-run.json', 'win32') // => 'c:/repo/.codebook/wiki.update-run.json'
+ * comparableFilePath('/Repo/a.json', 'linux')                              // => '/Repo/a.json'
+ */
+export function comparableFilePath(
+  path: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform === 'win32') return path.toLowerCase().replaceAll('\\', '/')
+  if (platform === 'darwin') return path.toLowerCase()
+  return path
+}
diff --git a/extension/src/utils/describeWikiFreshness.ts b/extension/src/utils/describeWikiFreshness.ts
new file mode 100644
index 000000000..adf9104d0
--- /dev/null
+++ b/extension/src/utils/describeWikiFreshness.ts
@@ -0,0 +1,43 @@
+/**
+ * Words how a Wiki stands against its source: the one label the served Wiki page shows above its outline and the editor's LLM Wiki view shows beside its Wiki row.
+ *
+ * Why: the page and the view must say the same thing about the same check, so the sentence is written once. The function is embedded into the served page script with `toString()` (through `WikiUpdatePageSettings.describeFreshness`, like `describeWikiUpdate`), so it must stay free of imports and outer variables.
+ * Trigger: the page calls it with each `api/freshness` answer; the view calls it with each freshness check it reads.
+ *
+ * @param status - The answered freshness status (`current`, `changed`, `unknown`), or `undefined` when nothing answered.
+ * @param reason - Why a check could not decide; empty when the answer gave none.
+ * @param isAdditionUnchecked - Whether the project has no Git repository, so added files were not looked for.
+ * @param reasonLimitChars - How many characters of a reason the label shows before it is cut at the last space.
+ * @returns
+ * - `changed`: "Source changed · Update available"
+ * - `current`: "Wiki source current", with the note on unchecked additions where they were not looked for
+ * - Any other status: "Wiki freshness unknown", followed by the reason when there is one, shortened to the limit
+ *
+ * @example
+ * ```ts
+ * describeWikiFreshness('current', '', false, 160) // => 'Wiki source current'
+ * describeWikiFreshness('unknown', 'The manifest is unreadable.', false, 160) // => 'Wiki freshness unknown: The manifest is unreadable.'
+ * ```
+ */
+export function describeWikiFreshness(
+  status: string | undefined,
+  reason: string,
+  isAdditionUnchecked: boolean,
+  reasonLimitChars: number,
+): string {
+  if (status === 'changed') return 'Source changed · Update available'
+  if (status === 'current')
+    return isAdditionUnchecked
+      ? 'Wiki source current (no Git revision recorded, so added files are not checked)'
+      : 'Wiki source current'
+  if (!reason) return 'Wiki freshness unknown'
+  // The label sits above the outline in a narrow rail: a long reason is cut at the last space before the limit and stays whole in the tooltip.
+  const lastSpace = reason.lastIndexOf(' ', reasonLimitChars)
+  const shownReason =
+    reason.length > reasonLimitChars
+      ? reason
+          .slice(0, lastSpace > 0 ? lastSpace : reasonLimitChars)
+          .trimEnd() + '…'
+      : reason
+  return 'Wiki freshness unknown: ' + shownReason
+}
diff --git a/extension/src/utils/describeWikiGeneration.ts b/extension/src/utils/describeWikiGeneration.ts
new file mode 100644
index 000000000..1f929a67f
--- /dev/null
+++ b/extension/src/utils/describeWikiGeneration.ts
@@ -0,0 +1,51 @@
+import { WIKI_SHORT_REVISION_CHARS } from '../constants'
+
+import { fullCommitHash } from './fullCommitHash'
+
+/** What the manifest and the manifest file say of one generation: the revision it records and when the manifest was written (epoch milliseconds). */
+export type WikiGeneration = {
+  /** The manifest's `generated.revision` as written; kept only when it is a full commit hash. */
+  revision?: string
+  /** The manifest file's modification time; the publisher writes a new manifest at each publish. */
+  publishedAtMs?: number
+}
+
+/**
+ * Words which generation a published Wiki is, for the tooltip of the LLM Wiki view's Wiki row (accepted X1).
+ *
+ * Why: a learner who sees `Source changed` asks which source the Wiki was written from and when; the revision and the date answer without opening the browser.
+ * Trigger: {@link readLlmWikiViewState} calls it for each Wiki row.
+ *
+ * @param generation - The revision the manifest records and the manifest file's modification time.
+ * @param formatDate - Turns the time into the date in the editor's locale; tests pass a fixed one.
+ * @returns
+ * - Both known: "Generated from <first 7 characters of the revision> on <date>"
+ * - A date and no usable revision (a folder without Git, or a revision that is no full commit hash): "Generated on <date> (no Git revision)"
+ * - A revision and no date: "Generated from <first 7 characters of the revision>"
+ * - Neither: `undefined`, so the tooltip has no generation line
+ *
+ * @example
+ * describeWikiGeneration({ revision: '1936e41913729663cc99081e3224db89bb2d8e56', publishedAtMs: 1_790_000_000_000 }, () => 'Sep 21, 2026')
+ * // => 'Generated from 1936e41 on Sep 21, 2026'
+ */
+export function describeWikiGeneration(
+  generation: WikiGeneration,
+  formatDate: (epochMs: number) => string = (epochMs) =>
+    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(
+    0,
+    WIKI_SHORT_REVISION_CHARS,
+  )
+  const date =
+    // A time that is not a finite number would print as "Invalid Date".
+    generation.publishedAtMs === undefined ||
+    !Number.isFinite(generation.publishedAtMs)
+      ? undefined
+      : formatDate(generation.publishedAtMs)
+  if (fullRevision && date) return `Generated from ${fullRevision} on ${date}`
+  if (date) return `Generated on ${date} (no Git revision)`
+  if (fullRevision) return `Generated from ${fullRevision}`
+  return undefined
+}
diff --git a/extension/src/utils/describeWikiWatch.ts b/extension/src/utils/describeWikiWatch.ts
new file mode 100644
index 000000000..9cc6c11c9
--- /dev/null
+++ b/extension/src/utils/describeWikiWatch.ts
@@ -0,0 +1,74 @@
+import * as nodePath from 'node:path'
+
+import {
+  WIKI_MANIFEST_FILE,
+  WIKI_PUBLISH_JOURNAL_SUFFIX,
+  WIKI_PUBLISH_LOCK_SUFFIX,
+  WIKI_UPDATE_RUN_MARKER_SUFFIX,
+} from '../constants'
+
+import { escapeGlobCharacters } from './escapeGlobCharacters'
+
+/** What the LLM Wiki view's file watcher stands on: the glob it hands the editor and the absolute paths whose events refresh the view. */
+export type WikiWatchPlan = {
+  /** A glob relative to the watched folder, with forward slashes. */
+  glob: string
+  /** The folders between the watched folder and the Wiki output (the output included) and the four files, as absolute paths in the spelling of the path module. */
+  paths: string[]
+}
+
+/** The files the view watches beside the output folder, as the endings of the output's path (the manifest lies inside it, the markers beside it). */
+const WATCHED_ENDINGS = [
+  `/${WIKI_MANIFEST_FILE}`,
+  WIKI_UPDATE_RUN_MARKER_SUFFIX,
+  WIKI_PUBLISH_LOCK_SUFFIX,
+  WIKI_PUBLISH_JOURNAL_SUFFIX,
+] as const
+
+/**
+ * Plans what the LLM Wiki view's watcher listens to: the Wiki folder itself and every folder not made yet between the watched folder and it (so a deleted or moved folder is seen even when the editor reports only the folder), the manifest and the three markers.
+ *
+ * Why: the editor may report only the delete of a folder, not of each file inside; a glob of the four files alone then never fires. Different drives give no relative path at all, which would make a glob that matches nothing.
+ * Trigger: {@link createLlmWikiView} when it makes or moves its watcher.
+ *
+ * @param watchedFolder - The existing folder the watcher stands on.
+ * @param outputDirectory - The resolved Wiki folder.
+ * @param pathApi - The path module of the system the paths belong to; tests pass `path.win32`.
+ * @returns The plan, or `undefined` when the output does not lie below the watched folder (another drive, or a folder above it), where no glob can match.
+ * @example
+ * describeWikiWatch('/repo', '/repo/.codebook/wiki')?.glob // => '{.codebook,.codebook/wiki,.codebook/wiki/codebook-wiki.json,.codebook/wiki.update-run.json,.codebook/wiki.publish-lock.json,.codebook/wiki.publish-journal.json}'
+ * describeWikiWatch('C:\\repo', 'D:\\wiki', nodePath.win32) // => undefined
+ */
+export function describeWikiWatch(
+  watchedFolder: string,
+  outputDirectory: string,
+  pathApi: Pick<
+    typeof nodePath,
+    'relative' | 'isAbsolute' | 'sep' | 'join'
+  > = nodePath,
+): WikiWatchPlan | undefined {
+  const outputFromFolder = pathApi.relative(watchedFolder, outputDirectory)
+  const segments = outputFromFolder.split(pathApi.sep)
+  // An empty, absolute (another drive) or upward path lies outside the watched folder.
+  if (
+    outputFromFolder === '' ||
+    pathApi.isAbsolute(outputFromFolder) ||
+    segments[0] === '..'
+  )
+    return undefined
+  // Every folder from the first below the watched one down to the output.
+  const folders = segments.map((_segment, index) =>
+    segments.slice(0, index + 1).join('/'),
+  )
+  const outputInGlob = segments.join('/')
+  const entries = [
+    ...folders,
+    ...WATCHED_ENDINGS.map((ending) => `${outputInGlob}${ending}`),
+  ]
+  return {
+    glob: `{${entries.map((entry) => escapeGlobCharacters(entry)).join(',')}}`,
+    paths: entries.map((entry) =>
+      pathApi.join(watchedFolder, ...entry.split('/')),
+    ),
+  }
+}
diff --git a/extension/src/utils/escapeGlobCharacters.ts b/extension/src/utils/escapeGlobCharacters.ts
new file mode 100644
index 000000000..d8241cd72
--- /dev/null
+++ b/extension/src/utils/escapeGlobCharacters.ts
@@ -0,0 +1,18 @@
+/**
+ * Escapes the characters the editor's glob reads as syntax, so a folder name is matched as written.
+ *
+ * Why: the LLM Wiki view's file watcher builds its glob from the Wiki folder's name, and the setting may name `wiki[1]` or `{draft}`.
+ * Trigger: {@link createLlmWikiView} when it makes the watcher's pattern.
+ *
+ * The editor's glob has no backslash escape; a character in brackets is literal, so `[` becomes `[[]`. A `]` outside brackets would make an empty character class in the editor's glob, so it is put in brackets too (`[]]`: a `]` first in brackets is literal). A `,` would split the watcher's brace list into alternatives; the editor splits only at commas outside brackets, so it is put in brackets as well.
+ *
+ * @param text - A relative path with forward slashes.
+ * @returns The text with `[`, `]`, `{`, `}`, `*`, `?` and `,` each put in brackets.
+ * @example
+ * escapeGlobCharacters('docs/wiki[1]') // => 'docs/wiki[[]1[]]'
+ * escapeGlobCharacters('wiki,old')     // => 'wiki[,]old'
+ * escapeGlobCharacters('wiki')         // => 'wiki'
+ */
+export function escapeGlobCharacters(text: string): string {
+  return text.replaceAll(/[[\]{}*?,]/g, (character) => `[${character}]`)
+}
diff --git a/extension/src/utils/findNearestExistingAncestor.ts b/extension/src/utils/findNearestExistingAncestor.ts
new file mode 100644
index 000000000..14b4240dc
--- /dev/null
+++ b/extension/src/utils/findNearestExistingAncestor.ts
@@ -0,0 +1,27 @@
+import { stat } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
+/**
+ * Finds the nearest folder at or above a path that exists, so a file watcher can stand where a first Wiki's folders are not made yet.
+ *
+ * Why: in a fresh project the Wiki output's parent (`.codebook/`) does not exist until a run makes it; a watcher on a missing folder would never fire, and the output may lie outside the workspace.
+ * Trigger: {@link LlmWikiView} calls it at each refresh to keep its watcher on the closest folder that exists.
+ *
+ * @param path - An absolute path, usually the Wiki output folder.
+ * @returns The path itself when it is a folder, else the nearest parent that is; the path's root when nothing below exists.
+ * @example
+ * await findNearestExistingAncestor('/repo/.codebook/wiki') // => '/repo' while .codebook does not exist yet
+ */
+export async function findNearestExistingAncestor(
+  path: string,
+): Promise<string> {
+  let candidate = path
+  for (;;) {
+    const candidateStat = await stat(candidate).catch(() => undefined)
+    if (candidateStat?.isDirectory()) return candidate
+    const parent = dirname(candidate)
+    // The root has no parent: nothing below it exists either.
+    if (parent === candidate) return candidate
+    candidate = parent
+  }
+}
diff --git a/extension/src/utils/fullCommitHash.ts b/extension/src/utils/fullCommitHash.ts
new file mode 100644
index 000000000..e06e46d38
--- /dev/null
+++ b/extension/src/utils/fullCommitHash.ts
@@ -0,0 +1,16 @@
+/**
+ * Keeps a generated revision only when it is a full commit hash; called by {@link findAddedSources} before the revision is given to Git, and by {@link describeWikiGeneration} before it shortens the revision for the Wiki row.
+ * @param generatedRevision - The revision the manifest records, if any.
+ * @returns The revision when it is 40 (SHA-1) or 64 (SHA-256) hexadecimal digits, `undefined` otherwise (none, empty, a short hash, a branch name).
+ * @example
+ * fullCommitHash('0f9e8d7c6b5a49382716051a2b3c4d5e6f708192') // => '0f9e8d7c6b5a49382716051a2b3c4d5e6f708192'
+ * fullCommitHash('main')                                     // => undefined
+ */
+export function fullCommitHash(
+  generatedRevision: string | undefined,
+): string | undefined {
+  return generatedRevision &&
+    /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(generatedRevision)
+    ? generatedRevision
+    : undefined
+}
diff --git a/extension/src/utils/handWikiRequestToChat.ts b/extension/src/utils/handWikiRequestToChat.ts
index 1df68edd2..068111229 100644
--- a/extension/src/utils/handWikiRequestToChat.ts
+++ b/extension/src/utils/handWikiRequestToChat.ts
@@ -1,9 +1,9 @@
+import { OPEN_CHAT_COMMAND } from '../constants'
+
 import { chatCommandReturnsInTime } from './chatCommandReturnsInTime'
 import { sleepUntilAborted } from './sleepUntilAborted'
 import type { BoundedWait } from './waitWithin'
 
-/** VS Code's command that reveals the chat a request would go to (the chat focused last when it can be shown, the Chat view otherwise) and makes it the chat focused last; with a query it sends the query as a request into that chat and, with `blockOnResponse`, returns when the response completes or waits for a confirmation. */
-const OPEN_CHAT_COMMAND = 'workbench.action.chat.open'
 /** VS Code's command "New Chat": the chat focused last gets a new, empty session; the session it showed is kept. {@link describeWikiChatHandOver} looks for it among the editor's commands to say before the press where the request will go. */
 export const NEW_CHAT_COMMAND = 'workbench.action.chat.newChat'
 
diff --git a/extension/src/utils/inspectDeepWikiFreshness.ts b/extension/src/utils/inspectDeepWikiFreshness.ts
index b4e05374c..8bdc0e8df 100644
--- a/extension/src/utils/inspectDeepWikiFreshness.ts
+++ b/extension/src/utils/inspectDeepWikiFreshness.ts
@@ -11,6 +11,7 @@ import {
 } from '../constants'
 
 import type { WikiIncludedSource } from './answerDeepWikiQuestion'
+import { fullCommitHash } from './fullCommitHash'
 import { gitExecutablePath } from './gitExecutablePath'
 import { hashFileSha256 } from './hashFileSha256'
 import { isWikiSourceCandidate } from './isWikiSourceCandidate'
@@ -172,22 +173,6 @@ function listingFailure(error: unknown): AdditionCheck {
   }
 }
 
-/**
- * Keeps a generated revision only when it is a full commit hash; called by {@link findAddedSources} before the revision is given to Git.
- * @param generatedRevision - The revision the manifest records, if any.
- * @returns The revision when it is 40 to 64 hexadecimal digits, `undefined` otherwise (none, empty, a short hash, a branch name).
- * @example
- * fullCommitHash('0f9e8d7c6b5a49382716051a2b3c4d5e6f708192') // => '0f9e8d7c6b5a49382716051a2b3c4d5e6f708192'
- * fullCommitHash('main')                                     // => undefined
- */
-function fullCommitHash(
-  generatedRevision: string | undefined,
-): string | undefined {
-  return generatedRevision && /^[a-f0-9]{40,64}$/i.test(generatedRevision)
-    ? generatedRevision
-    : undefined
-}
-
 /**
  * Picks, from the paths Git listed, the source files the Wiki neither indexes nor excludes; called by {@link findAddedSources} with the answers of its three listing commands.
  * @param committedListing - Git's NUL-separated answer for the files the index holds and the generated revision does not (committed or staged since).
diff --git a/extension/src/utils/installWikiUpdateStatus.ts b/extension/src/utils/installWikiUpdateStatus.ts
index 989f7b796..86fca654a 100644
--- a/extension/src/utils/installWikiUpdateStatus.ts
+++ b/extension/src/utils/installWikiUpdateStatus.ts
@@ -1,3 +1,4 @@
+import type { describeWikiFreshness } from './describeWikiFreshness'
 import type {
   describeWikiUpdate,
   WikiUpdateDescription,
@@ -24,6 +25,8 @@ export type WikiUpdatePageSettings = {
   pagePublication: string | undefined
   /** The one wording shared with the editor notification, embedded next to this function. */
   describeUpdate: typeof describeWikiUpdate
+  /** The one wording of the freshness label shared with the editor's LLM Wiki view, embedded next to this function ({@link describeWikiFreshness}). */
+  describeFreshness: typeof describeWikiFreshness
   /** How often the page asks for the update state while a run is active or awaited (ms). */
   statusPollMs: number
   /** How often the page asks while nothing is running and the tab is visible (ms). */
@@ -69,6 +72,7 @@ export type WikiUpdatePageSettings = {
  *   freshnessRoute: 'api/freshness',
  *   pagePublication: 'dc9d3160…@1837466',
  *   describeUpdate: describeWikiUpdate,
+ *   describeFreshness: describeWikiFreshness,
  *   statusPollMs: 2_000,
  *   idlePollMs: 15_000,
  *   freshnessMinIntervalMs: 5_000,
@@ -334,32 +338,6 @@ export function installWikiUpdateStatus(
     state === 'timed-out' ||
     state === 'conflict'
 
-  /** Words the freshness label of a check that could not decide; {@link noteFreshness} asks for it before it knows which label applies. @param reason - Why the check could not decide; empty when the answer gave none. @returns "Wiki freshness unknown", followed by the reason when there is one, shortened to the rail's limit. @example undecidedFreshnessLabel('The manifest is unreadable.') // => 'Wiki freshness unknown: The manifest is unreadable.' */
-  const undecidedFreshnessLabel = (reason: string): string => {
-    // The label sits above the outline in a narrow rail: a long reason is cut at the last space before the rail's limit and stays whole in the tooltip.
-    const lastSpace = reason.lastIndexOf(' ', settings.reasonLimitChars)
-    const shownReason =
-      reason.length > settings.reasonLimitChars
-        ? reason
-            .slice(0, lastSpace > 0 ? lastSpace : settings.reasonLimitChars)
-            .trimEnd() + '…'
-        : reason
-    return reason
-      ? 'Wiki freshness unknown: ' + shownReason
-      : 'Wiki freshness unknown'
-  }
-  /** Chooses the text of the freshness label for one answer; called by {@link noteFreshness} on every answered or failed check. @param status - The answered status, or undefined when the reader did not answer. @param undecidedLabel - The label of a check that could not decide, from {@link undecidedFreshnessLabel}. @param isAdditionUnchecked - Whether added files were not looked for. @returns The label of a changed source, of a current one (with the note on unchecked additions), or `undecidedLabel` for any other status. @example freshnessLabelText('current', 'Wiki freshness unknown', false) // => 'Wiki source current' */
-  const freshnessLabelText = (
-    status: string | undefined,
-    undecidedLabel: string,
-    isAdditionUnchecked: boolean,
-  ): string => {
-    if (status === 'changed') return 'Source changed · Update available'
-    if (status !== 'current') return undecidedLabel
-    return isAdditionUnchecked
-      ? 'Wiki source current (no Git revision recorded, so added files are not checked)'
-      : 'Wiki source current'
-  }
   /** Takes in what `api/freshness` answered and writes it into the freshness label; called by {@link readFreshness} when its check is answered or fails. @param status - The answered status, or undefined when the reader did not answer. @param reason - Why a check could not decide; empty when the answer gave none. @param isAdditionUnchecked - Whether the project has no Git repository, so added files were not looked for. @returns Nothing; the label, its `data-status` and its tooltip are written when the page has a label. @example noteFreshness('unknown', 'The manifest is unreadable.', false) // the label reads "Wiki freshness unknown: The manifest is unreadable." */
   const noteFreshness = (
     status: string | undefined,
@@ -368,12 +346,12 @@ export function installWikiUpdateStatus(
   ): void => {
     freshness = status
     if (!freshnessLabel) return
-    // A check that could not decide says why in the label itself: a tooltip needs a pointer, and a paragraph cannot take the focus.
-    const undecidedLabel = undecidedFreshnessLabel(reason)
-    freshnessLabel.textContent = freshnessLabelText(
+    // A check that could not decide says why in the label itself: a tooltip needs a pointer, and a paragraph cannot take the focus. The wording is the one the editor's LLM Wiki view shows (describeFreshness).
+    freshnessLabel.textContent = settings.describeFreshness(
       status,
-      undecidedLabel,
+      reason,
       isAdditionUnchecked,
+      settings.reasonLimitChars,
     )
     freshnessLabel.setAttribute('data-status', status ?? 'unknown')
     // The reason of an earlier look must not outlive it.
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
new file mode 100644
index 000000000..8b5bfeb1b
--- /dev/null
+++ b/extension/src/utils/llmWikiView.ts
@@ -0,0 +1,586 @@
+import { realpath } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join, relative } from 'node:path'
+
+import type * as vscode from 'vscode'
+
+import {
+  CODEBOOK_HOST_CONTEXT_KEY,
+  LLM_WIKI_POLL_MS,
+  LLM_WIKI_REFRESH_DEBOUNCE_MS,
+  LLM_WIKI_STATE_CONTEXT_KEY,
+  LLM_WIKI_VIEW_ID,
+  SET_CONTEXT_COMMAND,
+  WIKI_OUTPUT_DIRECTORY_SETTING,
+} from '../constants'
+
+import { chooseWikiWatchFolder } from './chooseWikiWatchFolder'
+import { comparableFilePath } from './comparableFilePath'
+import { describeWikiWatch } from './describeWikiWatch'
+import {
+  LLM_WIKI_ERROR_ROW,
+  LLM_WIKI_LOADING_ROW,
+  LLM_WIKI_RUN_ROW_IDS,
+  LLM_WIKI_WAITING_ROW_IDS,
+  readLlmWikiViewState,
+  type LlmWikiFreshness,
+  type LlmWikiRow,
+  type LlmWikiViewFacts,
+  type LlmWikiViewModel,
+} from './readLlmWikiViewState'
+
+type ReadyFacts = Extract<LlmWikiViewFacts, { kind: 'ready' }>
+
+/** What the view asks of the window, each as a closure of the extension's activation. */
+export type LlmWikiViewOptions = {
+  /** The editor's API; the view uses its tree, watcher and context-key surfaces only. */
+  editor: Pick<
+    typeof vscode,
+    | 'commands'
+    | 'EventEmitter'
+    | 'RelativePattern'
+    | 'ThemeIcon'
+    | 'TreeItem'
+    | 'TreeItemCollapsibleState'
+    | 'window'
+    | 'workspace'
+  >
+  /** The editor host, set as the context key the welcome content is chosen by. */
+  host: 'vscode' | 'cursor'
+  /** Reads the facts the rows are made of, without the freshness check ({@link readLlmWikiViewFacts}). */
+  readFacts: () => Promise<LlmWikiViewFacts>
+  /** Runs the freshness check of the Wiki in the project and folder the shown facts name, so a setting that changed meanwhile cannot make it inspect another Wiki. */
+  readFreshness: (location: {
+    projectRoot: string
+    outputDirectory: string
+  }) => Promise<LlmWikiFreshness>
+  /** Finds the nearest folder at or above the Wiki output that exists ({@link findNearestExistingAncestor}). */
+  findWatchedFolder: (outputDirectory: string) => Promise<string>
+  /** Subscribes to changes of this window's run state; returns the unsubscribe function. */
+  onRunChange: (listener: () => void) => () => void
+  /** Tells the learner that a Wiki was published after a run was stopped or a watch ended. */
+  tellPublished: (outputLabel: string) => void
+  /** Writes a failure to Output › Codebook, where the error row sends the learner. */
+  recordFailure: (message: string, cause: unknown) => void
+  /** The trailing debounce of event-driven refreshes (ms). */
+  debounceMs?: number
+  /** The poll interval while a run row is shown (ms). */
+  pollMs?: number
+}
+
+/** The view as the extension's wiring and its commands use it. */
+export type LlmWikiView = {
+  /** Reads the state now and shows it; resolves once the rows are shown (not the freshness check). It never rejects: a read that fails shows the error row. */
+  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. */
+  whenIdle(): Promise<void>
+  /** The row with this id as it is shown now. */
+  findRow(rowId: string): LlmWikiRow | undefined
+  dispose(): void
+}
+
+/** What the view remembers of the last ready read, kept across reads that are not ready, so a publication after a removed and restored folder still counts as late. */
+type LateWatch = {
+  outputDirectory: string
+  /** Whether a reservation or a stopped generation was shown. */
+  wasWaiting: boolean
+  /** The publisher's receipt of the last read. */
+  publication: string | undefined
+  /** When the manifest was written, as the last read saw it. */
+  manifestWrittenAtMs: number | undefined
+}
+
+/** The editor's file watcher as the view holds it. */
+type HeldWatcher = {
+  folder: string
+  outputDirectory: string
+  dispose: () => void
+}
+
+/**
+ * Names the publication a cached freshness answer belongs to, so the answer of an older Wiki is never shown for a newer one.
+ * @param facts - The ready facts.
+ * @returns The folder and the publisher's receipt.
+ * @example freshnessKeyOf(facts) // => '/repo/.codebook/wiki|abc@1'
+ */
+function freshnessKeyOf(facts: ReadyFacts): string {
+  return `${facts.outputDirectory}|${facts.publication ?? ''}`
+}
+
+/**
+ * Creates the LLM Wiki tree view: its data provider, its context keys, and the triggers that read its state again (this window's run, the Wiki files, the setting, trust, visibility and a poll while a run row is shown).
+ *
+ * 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.
+ *
+ * @param options - The editor API and the window's closures ({@link LlmWikiViewOptions}).
+ * @returns The view's handle ({@link LlmWikiView}).
+ * @example
+ * const view = createLlmWikiView({ editor: vscode, host: 'vscode', readFacts, readFreshness, findWatchedFolder, onRunChange, tellPublished, recordFailure })
+ * await view.refresh()
+ */
+export function createLlmWikiView(options: LlmWikiViewOptions): LlmWikiView {
+  const { editor } = options
+  const debounceMs = options.debounceMs ?? LLM_WIKI_REFRESH_DEBOUNCE_MS
+  const pollMs = options.pollMs ?? LLM_WIKI_POLL_MS
+  const treeChanges = new editor.EventEmitter<void>()
+  let model: LlmWikiViewModel = { state: 'other', rows: [LLM_WIKI_LOADING_ROW] }
+  // Until the first read ends the welcome content must not show: the state is `loading`.
+  let shownState: string | undefined = 'loading'
+  let shownKey = JSON.stringify(model)
+  /** The ready facts the rows show now; the freshness answer is shown only for these. */
+  let shownReadyFacts: ReadyFacts | undefined
+  let lateWatch: LateWatch | undefined
+  let freshnessCache: { key: string; value: LlmWikiFreshness } | undefined
+  let running: Promise<void> | undefined
+  let isRereadWanted = false
+  /** The one freshness check that runs, with the loop that re-runs it for the requests that came meanwhile. */
+  let freshnessLoop: Promise<void> | undefined
+  /** 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
+  let pollTimer: NodeJS.Timeout | undefined
+  let isDisposed = false
+  let isWatcherBroken = false
+  let watcher: HeldWatcher | undefined
+
+  void editor.commands.executeCommand(
+    SET_CONTEXT_COMMAND,
+    CODEBOOK_HOST_CONTEXT_KEY,
+    options.host,
+  )
+  void editor.commands.executeCommand(
+    SET_CONTEXT_COMMAND,
+    LLM_WIKI_STATE_CONTEXT_KEY,
+    'loading',
+  )
+
+  const treeView = editor.window.createTreeView<string>(LLM_WIKI_VIEW_ID, {
+    treeDataProvider: {
+      onDidChangeTreeData: treeChanges.event,
+      getChildren: (element) =>
+        element ? [] : model.rows.map((row) => row.id),
+      getTreeItem: (rowId) => {
+        const row = model.rows.find((candidate) => candidate.id === rowId)
+        const item = new editor.TreeItem(
+          row?.label ?? rowId,
+          editor.TreeItemCollapsibleState.None,
+        )
+        if (!row) return item
+        item.id = row.id
+        item.description = row.description
+        item.tooltip = row.tooltip
+        // A string tooltip would be read as the accessible name, so the name is set apart: the label, then the description.
+        item.accessibilityInformation = {
+          label: row.description
+            ? `${row.label}, ${row.description}`
+            : row.label,
+        }
+        item.iconPath = new editor.ThemeIcon(row.icon)
+        item.contextValue = row.actions.map((key) => `[${key}]`).join('')
+        if (row.command)
+          item.command = {
+            command: row.command.command,
+            title: row.label,
+            arguments: row.command.arguments,
+          }
+        return item
+      },
+    },
+  })
+
+  /** 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.
+    if (isDisposed) return
+    const nextKey = JSON.stringify(next)
+    if (nextKey === shownKey && next.state === shownState) return
+    const didStateChange = next.state !== shownState
+    model = next
+    shownKey = nextKey
+    shownState = next.state
+    treeView.message = next.message
+    if (didStateChange)
+      void editor.commands.executeCommand(
+        SET_CONTEXT_COMMAND,
+        LLM_WIKI_STATE_CONTEXT_KEY,
+        next.state,
+      )
+    treeChanges.fire()
+  }
+
+  /** Keeps the poll timer running exactly while a run row is shown. */
+  const keepPoll = (): void => {
+    if (isDisposed) return
+    const isRunShown = model.rows.some((row) =>
+      LLM_WIKI_RUN_ROW_IDS.has(row.id),
+    )
+    if (!isRunShown) {
+      clearInterval(pollTimer)
+      pollTimer = undefined
+      return
+    }
+    pollTimer ??= setInterval(() => {
+      void refresh()
+    }, pollMs).unref()
+  }
+
+  /** Asks for a refresh after the debounce; the last call always reads. */
+  const requestRefresh = (): void => {
+    if (isDisposed) return
+    clearTimeout(debounceTimer)
+    debounceTimer = setTimeout(() => {
+      void refresh()
+    }, debounceMs)
+    debounceTimer.unref()
+  }
+
+  /** Stops watching and says why once, so the view refreshes on visibility and its Refresh action only. */
+  const watchNothing = (cause: unknown): void => {
+    watcher?.dispose()
+    watcher = undefined
+    // Output › Codebook records the cause once, until a watcher can be made again.
+    if (!isWatcherBroken)
+      options.recordFailure(
+        'The LLM Wiki view could not watch the Wiki folder',
+        cause,
+      )
+    isWatcherBroken = true
+  }
+
+  /**
+   * Makes the watcher for a folder and a plan, listening to the planned paths in both their spelling and their real-path spelling.
+   * @param folder - The folder the watcher stands on.
+   * @param realFolder - The same folder with its symbolic links resolved; a symlinked ancestor makes the editor report this spelling, so both are compared.
+   * @param plan - What to listen to ({@link describeWikiWatch}).
+   * @param outputDirectory - The resolved Wiki folder.
+   * @returns The watcher.
+   */
+  const makeWatcher = (
+    folder: string,
+    realFolder: string,
+    plan: NonNullable<ReturnType<typeof describeWikiWatch>>,
+    outputDirectory: string,
+  ): HeldWatcher => {
+    const fileWatcher = editor.workspace.createFileSystemWatcher(
+      new editor.RelativePattern(folder, plan.glob),
+    )
+    // The editor may spell the drive letter or the case of a path differently, so both sides are compared in one form.
+    const watchedPaths = new Set(
+      plan.paths.flatMap((path) => [
+        comparableFilePath(path),
+        comparableFilePath(join(realFolder, relative(folder, path))),
+      ]),
+    )
+    const onEvent = (file: vscode.Uri): void => {
+      if (watchedPaths.has(comparableFilePath(file.fsPath))) requestRefresh()
+    }
+    const subscriptions = [
+      fileWatcher.onDidCreate(onEvent),
+      fileWatcher.onDidChange(onEvent),
+      fileWatcher.onDidDelete(onEvent),
+    ]
+    return {
+      folder,
+      outputDirectory,
+      dispose: (): void => {
+        for (const subscription of subscriptions) subscription.dispose()
+        fileWatcher.dispose()
+      },
+    }
+  }
+
+  /**
+   * Puts the watcher on the nearest existing folder of the output, and makes it again when that folder or the output changed.
+   * @param readyFacts - The facts just read.
+   * @returns Whether a new watcher now stands, so the caller reads once more: an event between the read and the registration is in neither.
+   */
+  const keepWatcher = async (readyFacts: ReadyFacts): Promise<boolean> => {
+    const { outputDirectory, projectRoot } = readyFacts
+    // The markers lie beside the output folder, so its parent is the first folder to stand on.
+    const nearestExistingFolder = await options.findWatchedFolder(
+      dirname(outputDirectory),
+    )
+    // A read that finished after dispose must leave no watcher behind.
+    if (isDisposed) return false
+    const folder = chooseWikiWatchFolder({
+      projectRoot,
+      outputDirectory,
+      nearestExistingFolder,
+      homeDirectory: homedir(),
+    })
+    const plan =
+      folder === undefined
+        ? undefined
+        : describeWikiWatch(folder, outputDirectory)
+    if (folder === undefined || plan === undefined) {
+      watchNothing(
+        new Error(
+          'No folder at or above the Wiki output is both inside the project (or the output’s own parent) and narrow enough to watch.',
+        ),
+      )
+      return false
+    }
+    // Read before the watcher is looked at, so nothing is awaited between that look and the new watcher.
+    const realFolder = await realpath(folder).catch(() => folder)
+    if (isDisposed) return false
+    if (
+      watcher?.folder === folder &&
+      watcher.outputDirectory === outputDirectory
+    )
+      return false
+    watcher?.dispose()
+    watcher = undefined
+    try {
+      watcher = makeWatcher(folder, realFolder, plan, outputDirectory)
+      isWatcherBroken = false
+      return true
+    } catch (cause) {
+      // Without a watcher the view refreshes on visibility and its Refresh only.
+      watchNothing(cause)
+      return false
+    }
+  }
+
+  /**
+   * Runs the freshness check for facts and shows its answer, unless the rows now show another Wiki or the window is gone.
+   * A failed check shows the unknown label for this read only and is not cached, so the next refresh checks again.
+   */
+  const checkFreshness = async (target: ReadyFacts): Promise<void> => {
+    let value: LlmWikiFreshness
+    let didCheckFail = false
+    try {
+      value = await options.readFreshness({
+        projectRoot: target.projectRoot,
+        outputDirectory: target.outputDirectory,
+      })
+    } catch {
+      didCheckFail = true
+      value = { status: 'unknown', reason: 'The freshness check failed.' }
+    }
+    const shown = shownReadyFacts
+    // The answer belongs to one publication of one folder; a newer read has asked for its own check.
+    if (
+      isDisposed ||
+      !shown?.wiki ||
+      freshnessKeyOf(shown) !== freshnessKeyOf(target)
+    )
+      return
+    if (!didCheckFail) freshnessCache = { key: freshnessKeyOf(target), value }
+    show(
+      readLlmWikiViewState({
+        ...shown,
+        wiki: { ...shown.wiki, freshness: value },
+      }),
+    )
+  }
+
+  /** 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. */
+  const requestFreshness = (shown: ReadyFacts): void => {
+    freshnessRequest = shown
+    freshnessLoop ??= (async () => {
+      // The first await keeps the clearing below after the assignment of this loop.
+      await Promise.resolve()
+      try {
+        while (freshnessRequest && !isDisposed) {
+          const target = freshnessRequest
+          freshnessRequest = undefined
+          try {
+            await checkFreshness(target)
+          } catch (cause) {
+            // A check that cannot even be shown must not become an unhandled rejection.
+            showReadFailure(cause)
+          }
+        }
+      } finally {
+        // Cleared in the same turn in which the loop found no request, so no request is left without a loop.
+        freshnessLoop = undefined
+      }
+    })()
+  }
+
+  /** Says what makes a publication differ from the one last seen: the receipt, or the time the manifest was written. */
+  const hasPublicationChanged = (
+    nextFacts: ReadyFacts,
+    memory: LateWatch,
+  ): boolean =>
+    nextFacts.publication !== memory.publication ||
+    nextFacts.wiki?.generation.publishedAtMs !== memory.manifestWrittenAtMs
+
+  /** Tells the learner about a Wiki that appeared while a stopped watch's reservation or a failed generation stood. */
+  const noteLatePublication = (nextFacts: ReadyFacts): void => {
+    // A publication in another folder than the one that was waiting is not a late one.
+    if (
+      lateWatch?.outputDirectory === nextFacts.outputDirectory &&
+      lateWatch.wasWaiting &&
+      nextFacts.wiki &&
+      hasPublicationChanged(nextFacts, lateWatch)
+    )
+      options.tellPublished(nextFacts.outputLabel)
+  }
+
+  /**
+   * Remembers what this read showed for the next one.
+   * A read that lands mid-publication (the publisher's new receipt stands while the Wiki is not readable yet) must not replace the receipt, or the read that shows the Wiki compares against the new receipt and tells nothing; the hold lasts only while the read shows no attention row and no run of this window, so a cause that hides the Wiki, or this window's own run (which tells its own end), cannot freeze the memory.
+   */
+  const rememberPublication = (
+    nextFacts: ReadyFacts,
+    next: LlmWikiViewModel,
+  ): void => {
+    const isPublicationPending =
+      lateWatch?.outputDirectory === nextFacts.outputDirectory &&
+      nextFacts.publication !== undefined &&
+      nextFacts.publication !== lateWatch.publication &&
+      !nextFacts.wiki
+    const isOtherCauseShown = next.rows.some(
+      (row) => row.id === 'attention' || row.id === 'run',
+    )
+    if (isPublicationPending && !isOtherCauseShown) return
+    lateWatch = {
+      outputDirectory: nextFacts.outputDirectory,
+      wasWaiting: next.rows.some((row) => LLM_WIKI_WAITING_ROW_IDS.has(row.id)),
+      // A pending publication stays unseen while the rows follow the read.
+      publication: isPublicationPending
+        ? lateWatch?.publication
+        : nextFacts.publication,
+      manifestWrittenAtMs: isPublicationPending
+        ? lateWatch?.manifestWrittenAtMs
+        : nextFacts.wiki?.generation.publishedAtMs,
+    }
+  }
+
+  /** Adds what the view knows beside the read: whether the watcher is broken, and the cached or `checking` freshness. */
+  const withViewState = (readyFacts: ReadyFacts): ReadyFacts => ({
+    ...readyFacts,
+    ...(isWatcherBroken ? { isWatcherBroken: true as const } : {}),
+    ...(readyFacts.wiki
+      ? {
+          wiki: {
+            ...readyFacts.wiki,
+            freshness:
+              freshnessCache?.key === freshnessKeyOf(readyFacts)
+                ? freshnessCache.value
+                : { status: 'checking' as const },
+          },
+        }
+      : {}),
+  })
+
+  /**
+   * Reads the facts and, for a ready read, keeps the watcher; a watcher that is new or moved is followed by one more read, because a publication between the first read and the watcher's registration is in neither.
+   * @returns The facts to show; `undefined` when the window was disposed meanwhile.
+   */
+  const readFactsAndWatch = async (): Promise<LlmWikiViewFacts | undefined> => {
+    let read = await options.readFacts()
+    if (isDisposed) return undefined
+    if (read.kind !== 'ready') return read
+    const didWatcherChange = await keepWatcher(read)
+    if (isDisposed) return undefined
+    if (!didWatcherChange) return read
+    // One follow-up read, never a loop: it repeats only when the watcher moved again.
+    read = await options.readFacts()
+    if (isDisposed) return undefined
+    if (read.kind === 'ready' && (await keepWatcher(read)))
+      isRereadWanted = true
+    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
+    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
+    show({ state: 'other', rows: [LLM_WIKI_ERROR_ROW] })
+    keepPoll()
+  }
+
+  /** Shows one read: the rows with the cached or `checking` freshness, then asks for the freshness check apart. */
+  const showRead = (read: LlmWikiViewFacts): void => {
+    const nextFacts = read.kind === 'ready' ? withViewState(read) : read
+    if (nextFacts.kind === 'ready') noteLatePublication(nextFacts)
+    const next = readLlmWikiViewState(nextFacts)
+    if (nextFacts.kind === 'ready') rememberPublication(nextFacts, next)
+    shownReadyFacts = nextFacts.kind === 'ready' ? nextFacts : undefined
+    show(next)
+    keepPoll()
+    // No Wiki row shown (an attention cause hides it) means no freshness to read.
+    if (
+      nextFacts.kind === 'ready' &&
+      nextFacts.wiki &&
+      next.rows.some((row) => row.id === 'wiki')
+    )
+      requestFreshness(nextFacts)
+  }
+
+  /** One read from the facts to the rows; whatever throws in it shows the error row. */
+  const readOnce = async (): Promise<void> => {
+    try {
+      const read = await readFactsAndWatch()
+      if (read) showRead(read)
+    } catch (cause) {
+      showReadFailure(cause)
+    }
+  }
+
+  /** Reads now; a read asked for while one runs makes that one read again once, so the last event always shows. */
+  function refresh(): Promise<void> {
+    if (isDisposed) return Promise.resolve()
+    if (running) {
+      isRereadWanted = true
+      return running
+    }
+    running = (async () => {
+      do {
+        isRereadWanted = false
+        await readOnce()
+      } while (isRereadWanted && !isDisposed)
+    })().finally(() => {
+      running = undefined
+    })
+    return running
+  }
+
+  const subscriptions: vscode.Disposable[] = [
+    treeChanges,
+    treeView,
+    treeView.onDidChangeVisibility((event) => {
+      if (event.visible) requestRefresh()
+    }),
+    editor.workspace.onDidChangeConfiguration((event) => {
+      if (event.affectsConfiguration(WIKI_OUTPUT_DIRECTORY_SETTING))
+        requestRefresh()
+    }),
+    editor.workspace.onDidGrantWorkspaceTrust(() => requestRefresh()),
+    editor.workspace.onDidChangeWorkspaceFolders(() => requestRefresh()),
+    { dispose: options.onRunChange(requestRefresh) },
+  ]
+  void refresh()
+
+  return {
+    refresh,
+    requestRefresh,
+    async whenIdle(): Promise<void> {
+      while (running ?? freshnessLoop) {
+        await Promise.all([running, freshnessLoop])
+      }
+    },
+    findRow: (rowId) => model.rows.find((row) => row.id === rowId),
+    dispose(): void {
+      isDisposed = true
+      freshnessRequest = undefined
+      clearTimeout(debounceTimer)
+      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
new file mode 100644
index 000000000..37e66004e
--- /dev/null
+++ b/extension/src/utils/readLlmWikiViewFacts.ts
@@ -0,0 +1,313 @@
+import { basename } from 'node:path'
+
+import { WIKI_UPDATE_RECOVERY_REQUEST } from '../constants'
+
+import { describeWikiGenerateBlock } from './describeWikiGenerateBlock'
+import type { WikiUpdateStartBlock } from './findWikiUpdateStartBlock'
+import type { AwaitedWikiChat } from './hasWikiPublishEndedWait'
+import type {
+  WikiUpdateMarker,
+  WikiUpdateMarkerLook,
+} from './readLiveWikiUpdateMarker'
+import type {
+  LlmWikiStoppedGeneration,
+  LlmWikiViewFacts,
+} from './readLlmWikiViewState'
+import { wikiGenerateNotice } from './wikiGenerateNotice'
+import { wikiOutputLabel } from './wikiOutputLabel'
+import { wikiRunBoundMs } from './wikiRunBoundMs'
+import type { WikiAgentExit } from './wikiRunRecord'
+import { wikiUpdateNotice } from './wikiUpdateNotice'
+import type { WikiUpdateHost, WikiUpdateStatus } from './wikiUpdateRun'
+
+/** What {@link readLlmWikiViewFacts} asks of the editor window, each as a closure of the extension's activation, so host tests pass the real ones and unit tests stand-ins. */
+export type LlmWikiViewFactsDependencies = {
+  /** The editor this window runs in. */
+  host: WikiUpdateHost
+  /** Whether the window has a folder open. */
+  isFolderOpen: () => boolean
+  /** Whether the editor trusts the folder. */
+  isTrusted: () => boolean
+  /** The project and the Wiki folder its setting names, without reading the folder. */
+  wikiLocation: () => Promise<{ projectRoot: string; outputDirectory: string }>
+  /** The publish token of the manifest; `undefined` while there is none. */
+  readPublishToken: (outputDirectory: string) => Promise<string | undefined>
+  /** The publisher's receipt that names the manifest; `undefined` while there is none. */
+  readPublication: (outputDirectory: string) => Promise<string | undefined>
+  /** What makes the publisher refuse an update before it stages anything. */
+  findStartBlock: (
+    outputDirectory: string,
+    projectRoot: string,
+  ) => Promise<WikiUpdateStartBlock | undefined>
+  /** Reads the manifest as a Wiki of this project: the revision it records and when it was written. @throws When the manifest is no Wiki of this project. */
+  readGeneration: (
+    projectRoot: string,
+    outputDirectory: string,
+  ) => Promise<{ revision?: string; publishedAtMs?: number }>
+  /** Says whether the manifest names this project. @throws When the manifest cannot be read. */
+  isWikiOwnedBy: (
+    projectRoot: string,
+    outputDirectory: string,
+  ) => Promise<boolean>
+  /** Looks at the run marker as a window that owns none, so this window's own reservation is seen too. */
+  readMarker: (outputDirectory: string) => Promise<WikiUpdateMarkerLook>
+  /** This window's own id in the marker. */
+  ownWindowId: string
+  /** Whether a start of this window is under way that has not begun its run. */
+  isStartUnderWay: () => boolean
+  /** Whether a publication after a stopped watch's end ended its wait. */
+  hasPublishEndedWait: (
+    outputDirectory: string,
+    awaited: AwaitedWikiChat,
+  ) => Promise<boolean>
+  /** This window's run state. */
+  runStatus: () => WikiUpdateStatus
+  /** Whether a VS Code run still waits for the chat's first sign. */
+  isAwaitingChat: () => boolean
+  /** How the Cursor agent of this window's last run exited. */
+  lastAgentExit: () => WikiAgentExit | undefined
+  /** The present (epoch milliseconds). */
+  now: () => number
+}
+
+/** What a read of the facts found about the marker. */
+type MarkerFacts = Pick<
+  Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+  'elsewhere' | 'reservation'
+>
+
+/**
+ * Words the sentence of a start block for the attention row: the update's sentence where a Wiki stands, the generation's where none does.
+ * @param block - The cause and the paths the start check named.
+ * @param isWikiPresent - Whether a manifest stands in the folder.
+ * @param location - The Wiki folder and its label.
+ * @param host - The editor host.
+ * @param nowMs - The present, for the sentence's time.
+ * @returns The full sentence.
+ * @example sentenceOfBlock({ cause: 'held-publish-lock', paths: ['wiki.publish-lock.json'] }, false, location, 'vscode', 0)
+ */
+function sentenceOfBlock(
+  block: WikiUpdateStartBlock,
+  isWikiPresent: boolean,
+  location: { outputDirectory: string; outputLabel: string },
+  host: WikiUpdateHost,
+  nowMs: number,
+): string {
+  if (!isWikiPresent)
+    return describeWikiGenerateBlock(block, location.outputLabel)
+  const notice = wikiUpdateNotice({
+    state: 'conflict',
+    host,
+    finishedAt: new Date(nowMs).toISOString(),
+    paths: block.paths,
+    cause: block.cause,
+    site: 'kept',
+    ...location,
+  })
+  return (
+    notice?.message ?? describeWikiGenerateBlock(block, location.outputLabel)
+  )
+}
+
+/**
+ * Reads the marker beside the Wiki into this window's view of the other windows: a live run of another window, or the reservation of a stopped watch.
+ * @param dependencies - The editor window's closures.
+ * @param outputDirectory - The Wiki folder.
+ * @returns Row 2b or row 2c facts; none for this window's own running marker (row 2 shows it), for a reservation whose wait a publication ended, and for a look that failed.
+ * @example await readMarkerFacts(dependencies, '/repo/.codebook/wiki') // => { elsewhere: { kind: 'update', startedAtMs: 1_790_000_000_000 } }
+ */
+async function readMarkerFacts(
+  dependencies: LlmWikiViewFactsDependencies,
+  outputDirectory: string,
+): Promise<MarkerFacts> {
+  const look = await dependencies
+    .readMarker(outputDirectory)
+    .catch(() => undefined)
+  if (look?.kind === 'being-written') {
+    // This window's own claim is written for a moment before its run begins.
+    return dependencies.isStartUnderWay()
+      ? {}
+      : { elsewhere: { startedAtMs: look.heldBy.beingWrittenSinceMs } }
+  }
+  if (look?.kind !== 'live') return {}
+  const held: WikiUpdateMarker = look.heldBy
+  if (held.watchEndedAtMs === undefined)
+    // This window's own live marker is row 2's, never "another window".
+    return held.windowId === dependencies.ownWindowId
+      ? {}
+      : { elsewhere: { kind: held.runKind, startedAtMs: held.startedAtMs } }
+  // A start refuses for this reservation only until its own deadline, the same one the start check uses; a live owner process does not extend it.
+  const retryAtMs = held.watchEndedAtMs + wikiRunBoundMs(held.runKind, 'vscode')
+  if (dependencies.now() >= retryAtMs) return {}
+  const hasWaitEnded = await dependencies
+    .hasPublishEndedWait(outputDirectory, {
+      watchEndedAtMs: held.watchEndedAtMs,
+      candidateNames: [],
+    })
+    .catch(() => false)
+  if (hasWaitEnded) return {}
+  return {
+    reservation: {
+      kind: held.runKind,
+      host: held.host,
+      startedAtMs: held.startedAtMs,
+      retryAtMs,
+    },
+  }
+}
+
+/**
+ * Reads this window's run: the running one, or the generation that ended without a publication.
+ * @param dependencies - The editor window's closures.
+ * @param outputDirectory - The Wiki folder the view shows.
+ * @returns Row 2 or row 3 facts.
+ * @example readRunFacts(dependencies, '/repo/.codebook/wiki') // => { run: { kind: 'generate', startedAtMs: 1_790_000_000_000, timeoutMs: 3_300_000, isAwaitingChat: false } }
+ */
+function readRunFacts(
+  dependencies: LlmWikiViewFactsDependencies,
+  outputDirectory: string,
+): Pick<Extract<LlmWikiViewFacts, { kind: 'ready' }>, 'run' | 'lastAttempt'> {
+  const status = dependencies.runStatus()
+  if (status.state === 'running')
+    return {
+      run: {
+        kind: status.runKind ?? 'update',
+        startedAtMs: Date.parse(status.startedAt),
+        timeoutMs: status.timeoutMs,
+        isAwaitingChat: dependencies.isAwaitingChat(),
+      },
+    }
+  if (
+    status.state === 'idle' ||
+    status.state === 'succeeded' ||
+    status.state === 'already-current' ||
+    status.runKind !== 'generate' ||
+    status.outputDirectory !== outputDirectory
+  )
+    return {}
+  const sentence = wikiGenerateNotice(status)?.message
+  if (sentence === undefined) return {}
+  const exitCode = dependencies.lastAgentExit()?.exitCode ?? undefined
+  const lastAttempt: LlmWikiStoppedGeneration = {
+    state: status.state,
+    host: status.host,
+    sentence,
+    ...(status.state === 'timed-out' ? { timeoutMs: status.timeoutMs } : {}),
+    ...(exitCode === undefined ? {} : { agentExitCode: exitCode }),
+  }
+  return { lastAttempt }
+}
+
+/**
+ * Reads the manifest and the start block into the Wiki and attention facts.
+ * @param dependencies - The editor window's closures.
+ * @param location - The project, the Wiki folder and its label.
+ * @returns The published Wiki (its freshness still `checking`), its generation and the attention cause, where there is one.
+ * @example await readManifestFacts(dependencies, location) // => { wiki: { freshness: { status: 'checking' }, generation: {} } }
+ */
+async function readManifestFacts(
+  dependencies: LlmWikiViewFactsDependencies,
+  location: {
+    projectRoot: string
+    outputDirectory: string
+    outputLabel: string
+  },
+): Promise<
+  Pick<Extract<LlmWikiViewFacts, { kind: 'ready' }>, 'wiki' | 'attention'>
+> {
+  const { projectRoot, outputDirectory, outputLabel } = location
+  const nowMs = dependencies.now()
+  const block = await dependencies.findStartBlock(outputDirectory, projectRoot)
+  // A token that cannot be read still means a manifest stands there.
+  const tokenLook = await dependencies.readPublishToken(outputDirectory).then(
+    (token) => ({ didReadFail: false, token }),
+    () => ({ didReadFail: true, token: undefined }),
+  )
+  const isManifestPresent =
+    tokenLook.didReadFail || tokenLook.token !== undefined
+  const generation = isManifestPresent
+    ? await dependencies
+        .readGeneration(projectRoot, outputDirectory)
+        .catch(() => undefined)
+    : undefined
+  const wiki = generation
+    ? { wiki: { freshness: { status: 'checking' as const }, generation } }
+    : {}
+  if (block)
+    return {
+      ...wiki,
+      attention: {
+        cause: block.cause,
+        sentence: sentenceOfBlock(
+          block,
+          isManifestPresent,
+          { outputDirectory, outputLabel },
+          dependencies.host,
+          nowMs,
+        ),
+      },
+    }
+  // A manifest that stands but reads as no Wiki of this project is another checkout's, or cannot be read.
+  if (isManifestPresent && !generation) {
+    const isOwned = await dependencies
+      .isWikiOwnedBy(projectRoot, outputDirectory)
+      .catch(() => undefined)
+    return isOwned === false
+      ? {
+          attention: {
+            cause: 'foreign-manifest',
+            sentence: `The manifest in ${outputLabel} belongs to another checkout, not to this project. Set codebook.wikiOutputDirectory to a folder of this project.`,
+          },
+        }
+      : {
+          attention: {
+            cause: 'unreadable-manifest',
+            sentence: `The manifest in ${outputLabel} cannot be read as an LLM Wiki of this project. Ask the editor chat "${WIKI_UPDATE_RECOVERY_REQUEST}" to recover it.`,
+          },
+        }
+  }
+  return wiki
+}
+
+/**
+ * Reads every fact the LLM Wiki view's rows are made of, without the slow freshness check: folder and trust, the manifest, the start block, the marker beside the Wiki and this window's run.
+ *
+ * Why: the view must show a published Wiki at once and read its freshness afterwards, so the read that decides the rows stays fast.
+ * Trigger: {@link LlmWikiView} calls it for every refresh.
+ *
+ * @param dependencies - The editor window's closures ({@link LlmWikiViewFactsDependencies}).
+ * @returns The facts for {@link readLlmWikiViewState}; the Wiki's freshness is `checking`.
+ * @throws What the folder, the manifest or the start check threw; the view shows its error row.
+ * @example
+ * await readLlmWikiViewFacts(dependencies) // => { kind: 'ready', host: 'vscode', repositoryName: 'nextjs-dashboard', … }
+ */
+export async function readLlmWikiViewFacts(
+  dependencies: LlmWikiViewFactsDependencies,
+): Promise<LlmWikiViewFacts> {
+  if (!dependencies.isFolderOpen()) return { kind: 'no-folder' }
+  if (!dependencies.isTrusted()) return { kind: 'untrusted' }
+  const { projectRoot, outputDirectory } = await dependencies.wikiLocation()
+  const outputLabel = wikiOutputLabel(projectRoot, outputDirectory)
+  // The receipt is read before the manifest: a publication between the two reads then pairs the newer manifest with the older receipt, which the next refresh corrects, and never an old Wiki with the new receipt.
+  const publication = await dependencies
+    .readPublication(outputDirectory)
+    .catch(() => undefined)
+  const manifestFacts = await readManifestFacts(dependencies, {
+    projectRoot,
+    outputDirectory,
+    outputLabel,
+  })
+  return {
+    kind: 'ready',
+    host: dependencies.host,
+    projectRoot,
+    repositoryName: basename(projectRoot),
+    outputLabel,
+    outputDirectory,
+    nowMs: dependencies.now(),
+    publication,
+    ...manifestFacts,
+    ...readRunFacts(dependencies, outputDirectory),
+    ...(await readMarkerFacts(dependencies, outputDirectory)),
+  }
+}
diff --git a/extension/src/utils/readLlmWikiViewState.ts b/extension/src/utils/readLlmWikiViewState.ts
new file mode 100644
index 000000000..1910fed04
--- /dev/null
+++ b/extension/src/utils/readLlmWikiViewState.ts
@@ -0,0 +1,656 @@
+import {
+  LLM_WIKI_RESERVATION_MESSAGE,
+  LLM_WIKI_ROW_ACTIONS,
+  LLM_WIKI_WATCHING_MESSAGE,
+  MS_PER_MINUTE,
+  OPEN_DEEP_WIKI_COMMAND,
+  SHOW_LLM_WIKI_ATTENTION_COMMAND,
+  WIKI_UPDATE_REASON_LIMIT_CHARS,
+} from '../constants'
+
+import { describeMinutes } from './describeMinutes'
+import { describeWikiFreshness } from './describeWikiFreshness'
+import {
+  describeWikiGeneration,
+  type WikiGeneration,
+} from './describeWikiGeneration'
+import { formatClockTime } from './formatClockTime'
+import type { WikiRunKind, WikiUpdateHost } from './wikiUpdateRun'
+
+/** The key of one inline action of a row ({@link LLM_WIKI_ROW_ACTIONS}); the manifest shows the command of each key on the rows whose context value names it. */
+export type LlmWikiRowActionKey = keyof typeof LLM_WIKI_ROW_ACTIONS
+
+/** The stable id of a row, kept across changes of its label so the editor keeps the selection (accessibility). */
+export type LlmWikiRowId =
+  | 'wiki'
+  | 'run'
+  | 'elsewhere'
+  | 'reservation'
+  | 'last-attempt'
+  | 'attention'
+  | 'output'
+  | 'folder'
+  | 'trust'
+  | 'loading'
+  | 'error'
+
+/** The rows that show a run, whoever owns it: while one stands the view reads its state again on a timer, and the Wiki row offers no Update. */
+export const LLM_WIKI_RUN_ROW_IDS: ReadonlySet<LlmWikiRowId> = new Set([
+  'run',
+  'elsewhere',
+  'reservation',
+])
+
+/** The rows that show a start was waiting for a chat or a generation ended unpublished: a publication that follows them is a late one. */
+export const LLM_WIKI_WAITING_ROW_IDS: ReadonlySet<LlmWikiRowId> = new Set([
+  'reservation',
+  'last-attempt',
+])
+
+/** One row of the LLM Wiki view, as plain data: the view turns it into a tree item. */
+export type LlmWikiRow = {
+  id: LlmWikiRowId
+  label: string
+  /** The grey text after the label; it may truncate in a narrow sidebar. */
+  description?: string
+  /** The text of the hover; it holds the full text when the description is short. */
+  tooltip?: string
+  /** A theme icon's id (a codicon), for example `book` or `sync~spin`. */
+  icon: string
+  /** The command a click on the row runs, with the row's id as its argument where the command shows the row's sentence. */
+  command?: { command: string; arguments?: string[] }
+  /** The inline actions of the row, also in its context menu. */
+  actions: LlmWikiRowActionKey[]
+  /** The full sentence of an attention or last-attempt row, shown by {@link SHOW_LLM_WIKI_ATTENTION_COMMAND}. */
+  detail?: string
+}
+
+/** What the view shows: `none` when the folder holds no Wiki and no run (the welcome content shows), `other` for every row; the view adds `loading` before its first read. */
+export type LlmWikiViewModel = {
+  state: 'none' | 'other'
+  rows: LlmWikiRow[]
+  /** The wrapping message above the tree; set while a VS Code watch is shown. */
+  message?: string
+}
+
+/** How fresh the published Wiki is: still being checked, or the answer of the freshness check. */
+export type LlmWikiFreshness =
+  | { status: 'checking' }
+  | {
+      status: 'current' | 'changed' | 'unknown'
+      reason?: string
+      isAdditionUnchecked?: boolean
+    }
+
+/** Why a generation of this window ended without a publication. */
+export type LlmWikiStoppedGeneration = {
+  state: 'cancelled' | 'timed-out' | 'failed' | 'conflict'
+  host: WikiUpdateHost
+  /** The bound a `timed-out` end passed (ms). */
+  timeoutMs?: number
+  /** The exit code of the Cursor agent's process, where it ended on its own. */
+  agentExitCode?: number
+  /** The full sentence the editor told ({@link wikiGenerateNotice}). */
+  sentence: string
+}
+
+/** Everything the view's rows are made of, read once; {@link readLlmWikiViewState} turns it into rows. */
+export type LlmWikiViewFacts =
+  | { kind: 'no-folder' }
+  | { kind: 'untrusted' }
+  | {
+      kind: 'ready'
+      /** The editor this window runs in. */
+      host: WikiUpdateHost
+      /** The absolute opened project folder the Wiki output belongs to; the freshness check inspects this project and no other. */
+      projectRoot: string
+      repositoryName: string
+      /** The output folder as the learner reads it ({@link wikiOutputLabel}). */
+      outputLabel: string
+      /** The absolute resolved output folder. */
+      outputDirectory: string
+      /** Set when the file watcher could not be made, so the view refreshes on visibility and its Refresh only. */
+      isWatcherBroken?: true
+      nowMs: number
+      /** The publisher's receipt that names the manifest now on disk; the view compares it between reads to notice a late publication. Absent while the folder holds none. */
+      publication?: string
+      /** A published Wiki that reads as a Wiki of this project. */
+      wiki?: { freshness: LlmWikiFreshness; generation: WikiGeneration }
+      /** This window's run. `isAwaitingChat` marks a VS Code run that still waits for the chat's first sign. */
+      run?: {
+        kind: WikiRunKind
+        startedAtMs: number
+        timeoutMs: number
+        isAwaitingChat: boolean
+      }
+      /** A live marker of another window; `kind` is absent while the marker is being written. */
+      elsewhere?: { kind?: WikiRunKind; startedAtMs: number }
+      /** The reservation of a stopped VS Code watch, from any window. */
+      reservation?: {
+        kind?: WikiRunKind
+        host: WikiUpdateHost
+        startedAtMs: number
+        retryAtMs: number
+      }
+      lastAttempt?: LlmWikiStoppedGeneration
+      /** A start block, or a manifest that cannot be used; `cause` is a conflict cause, `foreign-manifest`, or one a later version adds. */
+      attention?: { cause: string; sentence: string }
+    }
+
+/** How the rows write times and dates; tests pass fixed ones. */
+export type LlmWikiViewWording = {
+  formatTime: (epochMs: number) => string
+  formatDate: (epochMs: number) => string
+}
+
+/** The wording the view reads in the editor's locale. */
+const LOCAL_WORDING: LlmWikiViewWording = {
+  formatTime: (epochMs) => formatClockTime(epochMs),
+  formatDate: (epochMs) => new Date(epochMs).toLocaleDateString(),
+}
+
+/** How an attention cause is worded and what its row offers (the plan's attention table). */
+type AttentionRow = {
+  label: string
+  shortCause: string
+  actions: LlmWikiRowActionKey[]
+  /** Whether the cause leaves the manifest unusable, so the Wiki row is not shown. */
+  hidesWiki: boolean
+}
+
+/** The attention row of every cause of a start block and of a foreign manifest. */
+const ATTENTION_ROWS = new Map<string, AttentionRow>([
+  [
+    'held-publish-lock',
+    {
+      label: 'Publish in progress or stopped',
+      shortCause: 'publish lock found',
+      actions: ['copy-recovery', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+  [
+    'unfinished-publish',
+    {
+      label: 'Publish in progress or stopped',
+      shortCause: 'unfinished publish',
+      actions: ['copy-recovery', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+  [
+    'edited-manifest',
+    {
+      label: 'Wiki manifest needs recovery',
+      shortCause: 'manifest edited',
+      actions: ['copy-recovery', 'refresh'],
+      hidesWiki: true,
+    },
+  ],
+  [
+    'unreadable-manifest',
+    {
+      label: 'Wiki manifest needs recovery',
+      shortCause: 'manifest unreadable',
+      actions: ['copy-recovery', 'refresh'],
+      hidesWiki: true,
+    },
+  ],
+  [
+    'not-a-folder',
+    {
+      label: 'Wiki folder belongs elsewhere',
+      shortCause: 'output is a file or link',
+      actions: ['change-location'],
+      hidesWiki: true,
+    },
+  ],
+  [
+    'linked-parent',
+    {
+      label: 'Wiki folder belongs elsewhere',
+      shortCause: 'link on the folder path',
+      actions: ['change-location'],
+      hidesWiki: true,
+    },
+  ],
+  [
+    'foreign-manifest',
+    {
+      label: 'Wiki folder belongs elsewhere',
+      shortCause: 'another checkout',
+      actions: ['change-location'],
+      hidesWiki: true,
+    },
+  ],
+  [
+    'learner-file',
+    {
+      label: 'Wiki files changed by hand',
+      shortCause: 'your file is in the folder',
+      actions: ['reveal-folder', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+  [
+    'special-file',
+    {
+      label: 'Wiki files changed by hand',
+      shortCause: 'link or special file',
+      actions: ['reveal-folder', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+  [
+    'edited-page',
+    {
+      label: 'Wiki files changed by hand',
+      shortCause: 'page edited by hand',
+      actions: ['reveal-folder', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+  [
+    'missing-page',
+    {
+      label: 'Wiki files changed by hand',
+      shortCause: 'page missing',
+      actions: ['reveal-folder', 'refresh'],
+      hidesWiki: false,
+    },
+  ],
+])
+
+/** What a cause added later without a row of its own falls back to: its own sentence, and a way to look again. */
+const FALLBACK_ATTENTION_ROW: AttentionRow = {
+  label: 'Wiki needs attention',
+  shortCause: 'see details',
+  actions: ['refresh'],
+  hidesWiki: false,
+}
+
+/** The row of a view that reads its state for the first time. */
+export const LLM_WIKI_LOADING_ROW: LlmWikiRow = {
+  id: 'loading',
+  label: 'Reading the LLM Wiki state…',
+  icon: 'loading~spin',
+  actions: [],
+}
+
+/** The row of a view whose read threw: the cause is in Output › Codebook, and Refresh retries. */
+export const LLM_WIKI_ERROR_ROW: LlmWikiRow = {
+  id: 'error',
+  label: 'Could not read the LLM Wiki state',
+  description: 'Refresh to retry',
+  tooltip:
+    'The cause is written to Output › Codebook. The Refresh action in the title bar reads the state again.',
+  icon: 'error',
+  command: { command: LLM_WIKI_ROW_ACTIONS['show-output'].command },
+  actions: [],
+}
+
+/** Words a run kind as the progress word of a row's label. @example runWord('generate') // => 'Generating' */
+function runWord(kind: WikiRunKind | undefined): string {
+  return kind === 'generate' ? 'Generating' : 'Updating'
+}
+
+/** Names an editor host as the learner knows it. @example hostName('vscode') // => 'VS Code' */
+function hostName(host: WikiUpdateHost): string {
+  return host === 'cursor' ? 'Cursor' : 'VS Code'
+}
+
+/** Counts the whole minutes of a duration with one rule for every number of a row, so `N min of M` rounds both numbers alike. @example wholeMinutes(750_000) // => 12 */
+function wholeMinutes(durationMs: number): number {
+  return Math.max(0, Math.floor(durationMs / MS_PER_MINUTE))
+}
+
+/**
+ * Builds row 1, the published Wiki: its label, the shared freshness wording and the generation line of the tooltip.
+ * @param facts - The ready facts that hold a Wiki.
+ * @param wiki - The published Wiki.
+ * @param wording - How times and dates are written.
+ * @param hasRunRow - Whether a run row stands, which hides the Update action.
+ * @returns The Wiki row.
+ * @example wikiRow(facts, wiki, wording, false).description // => 'Wiki source current'
+ */
+function wikiRow(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+  wiki: NonNullable<Extract<LlmWikiViewFacts, { kind: 'ready' }>['wiki']>,
+  wording: LlmWikiViewWording,
+  hasRunRow: boolean,
+): LlmWikiRow {
+  const freshness = wiki.freshness
+  const description =
+    freshness.status === 'checking'
+      ? 'Checking freshness…'
+      : describeWikiFreshness(
+          freshness.status,
+          freshness.reason ?? '',
+          freshness.isAdditionUnchecked ?? false,
+          WIKI_UPDATE_REASON_LIMIT_CHARS,
+        )
+  const generationLine = describeWikiGeneration(
+    wiki.generation,
+    wording.formatDate,
+  )
+  const reasonLine =
+    freshness.status === 'unknown' ? freshness.reason : undefined
+  // The description truncates in a narrow sidebar, so the caveat is also said in full here.
+  const additionLine =
+    freshness.status !== 'checking' && freshness.isAdditionUnchecked
+      ? 'No Git revision is recorded for this Wiki, so added files are not checked.'
+      : undefined
+  return {
+    id: 'wiki',
+    label: `${facts.repositoryName} Wiki`,
+    description,
+    tooltip: [
+      generationLine,
+      reasonLine,
+      additionLine,
+      'Click to open the Wiki in the browser.',
+    ]
+      .filter((line) => line !== undefined && line !== '')
+      .join('\n'),
+    icon: 'book',
+    command: { command: OPEN_DEEP_WIKI_COMMAND },
+    actions: hasRunRow ? [] : ['update'],
+  }
+}
+
+/**
+ * Builds row 2, this window's run, with the actions that fit its host.
+ * @param facts - The ready facts that hold a run.
+ * @param run - This window's run.
+ * @returns The run row: Stop watching, Open Chat and Show Output in VS Code; Cancel and Show Output in Cursor.
+ * @example runRow(facts, run).label // => 'Generating…'
+ */
+function runRow(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+  run: NonNullable<Extract<LlmWikiViewFacts, { kind: 'ready' }>['run']>,
+): LlmWikiRow {
+  const isCursor = facts.host === 'cursor'
+  // A start that could not be read leaves the minutes out rather than showing NaN.
+  const progress = Number.isFinite(run.startedAtMs)
+    ? ` · ${wholeMinutes(facts.nowMs - run.startedAtMs)} min of ${wholeMinutes(run.timeoutMs)}`
+    : ''
+  let description: string
+  if (isCursor) description = `cursor-agent${progress}`
+  else if (run.isAwaitingChat) description = 'Waiting for the chat to start'
+  else description = `In chat${progress}`
+  return {
+    id: 'run',
+    label: `${runWord(run.kind)}…`,
+    description,
+    tooltip: isCursor
+      ? 'Cursor Agent is writing the Wiki. Cancel stops it.'
+      : 'Codebook is watching the chat for the new Wiki. Stop watching ends Codebook’s watch, not the chat.',
+    icon: 'sync~spin',
+    actions: isCursor
+      ? ['cancel-run', 'show-output']
+      : ['stop-watching', 'open-chat', 'show-output'],
+  }
+}
+
+/**
+ * Builds row 2b, a run of another window.
+ * @param elsewhere - The other window's marker.
+ * @param wording - How times are written.
+ * @returns The row; a marker still being written reads as a start.
+ * @example elsewhereRow({ kind: 'generate', startedAtMs: 1_790_000_000_000 }, wording).label // => 'Generating in another window'
+ */
+function elsewhereRow(
+  elsewhere: NonNullable<
+    Extract<LlmWikiViewFacts, { kind: 'ready' }>['elsewhere']
+  >,
+  wording: LlmWikiViewWording,
+): LlmWikiRow {
+  return {
+    id: 'elsewhere',
+    label:
+      elsewhere.kind === undefined
+        ? 'Starting in another window'
+        : `${runWord(elsewhere.kind)} in another window`,
+    description: Number.isFinite(elsewhere.startedAtMs)
+      ? `since ${wording.formatTime(elsewhere.startedAtMs)}`
+      : undefined,
+    icon: 'sync~spin',
+    actions: [],
+  }
+}
+
+/**
+ * Builds row 2c, the reservation a stopped VS Code watch left.
+ * @param facts - The ready facts that hold a reservation.
+ * @param reservation - The reservation.
+ * @param wording - How times are written.
+ * @returns The row, with the retry time in its description and the run's start in its tooltip.
+ * @example reservationRow(facts, reservation, wording).label // => 'Waiting for chat'
+ */
+function reservationRow(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+  reservation: NonNullable<
+    Extract<LlmWikiViewFacts, { kind: 'ready' }>['reservation']
+  >,
+  wording: LlmWikiViewWording,
+): LlmWikiRow {
+  const retryTime = wording.formatTime(reservation.retryAtMs)
+  // The countdown rounds up so the learner never retries early, and never reads 0.
+  const minutesLeft = Math.max(
+    1,
+    Math.ceil((reservation.retryAtMs - facts.nowMs) / MS_PER_MINUTE),
+  )
+  const startedAt = Number.isFinite(reservation.startedAtMs)
+    ? ` at ${wording.formatTime(reservation.startedAtMs)}`
+    : ''
+  return {
+    id: 'reservation',
+    label: 'Waiting for chat',
+    description: `retry after ${retryTime} (about ${minutesLeft} min)`,
+    tooltip: `${runWord(reservation.kind)} started${startedAt} in ${hostName(reservation.host)}. Open Chat opens the chat view; find the session in the chat history to stop it. Codebook allows a new start after ${retryTime} even if the chat stopped earlier.`,
+    icon: 'clock',
+    actions: ['open-chat'],
+  }
+}
+
+/** Says in a few words how a generation ended without a publication. @example describeStoppedCause({ state: 'timed-out', host: 'cursor', timeoutMs: 3_300_000, sentence: '' }) // => 'stopped after 55 minutes' */
+function describeStoppedCause(stopped: LlmWikiStoppedGeneration): string {
+  if (stopped.state === 'cancelled')
+    return stopped.host === 'cursor' ? 'cancelled' : 'stopped watching'
+  if (stopped.state === 'timed-out')
+    return `stopped after ${describeMinutes(stopped.timeoutMs ?? 0)}`
+  if (stopped.state === 'conflict') return 'files in the way'
+  return stopped.agentExitCode === undefined
+    ? 'no Wiki published'
+    : `agent exit ${stopped.agentExitCode}`
+}
+
+/**
+ * Builds row 3, the generation of this window that ended without a publication.
+ * @param stopped - How it ended.
+ * @param isTryAgainOffered - Whether Try again is offered: not while a run or an attention row stands.
+ * @returns The row; a click shows its full sentence.
+ * @example lastAttemptRow({ state: 'failed', host: 'cursor', agentExitCode: 1, sentence: '…' }, true).description // => 'agent exit 1'
+ */
+function lastAttemptRow(
+  stopped: LlmWikiStoppedGeneration,
+  isTryAgainOffered: boolean,
+): LlmWikiRow {
+  return {
+    id: 'last-attempt',
+    label: 'Last generation stopped',
+    description: describeStoppedCause(stopped),
+    tooltip: stopped.sentence,
+    icon: 'info',
+    command: {
+      command: SHOW_LLM_WIKI_ATTENTION_COMMAND,
+      arguments: ['last-attempt'],
+    },
+    actions: isTryAgainOffered ? ['try-again'] : [],
+    detail: stopped.sentence,
+  }
+}
+
+/**
+ * Finds how a cause is worded and what its row offers, with the fallback for a cause added later.
+ * @param cause - The cause of a start block, a foreign manifest or a later version's cause.
+ * @returns The cause's attention row, or {@link FALLBACK_ATTENTION_ROW}.
+ * @example attentionRowOf('edited-page').label // => 'Wiki files changed by hand'
+ */
+function attentionRowOf(cause: string): AttentionRow {
+  return ATTENTION_ROWS.get(cause) ?? FALLBACK_ATTENTION_ROW
+}
+
+/**
+ * Builds row 4, what blocks a start or makes the manifest unusable.
+ * @param attention - The cause and the sentence of the block.
+ * @returns The row; a click shows the sentence with Copy details.
+ * @example attentionRow({ cause: 'edited-page', sentence: '…' }).label // => 'Wiki files changed by hand'
+ */
+function attentionRow(
+  attention: NonNullable<
+    Extract<LlmWikiViewFacts, { kind: 'ready' }>['attention']
+  >,
+): LlmWikiRow {
+  const row = attentionRowOf(attention.cause)
+  return {
+    id: 'attention',
+    label: row.label,
+    description: row.shortCause,
+    tooltip: attention.sentence,
+    icon: 'warning',
+    command: {
+      command: SHOW_LLM_WIKI_ATTENTION_COMMAND,
+      arguments: ['attention'],
+    },
+    actions: row.actions,
+    detail: attention.sentence,
+  }
+}
+
+/**
+ * Builds the rows of a ready view in the fixed order: Wiki, run, elsewhere, reservation, last attempt, attention.
+ * @param facts - The ready facts.
+ * @param wording - How times and dates are written.
+ * @returns The rows before the Output row; empty when the folder holds no Wiki and no run.
+ * @example readyRows(facts, wording).map((row) => row.id) // => ['wiki']
+ */
+function readyRows(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+  wording: LlmWikiViewWording,
+): LlmWikiRow[] {
+  const hasRunRow = Boolean(facts.run || facts.elsewhere || facts.reservation)
+  const attentionRowOfCause = facts.attention
+    ? attentionRowOf(facts.attention.cause)
+    : undefined
+  // A cause that leaves the manifest unusable takes the Wiki row away; the other causes leave the published Wiki readable.
+  const isWikiShown = Boolean(facts.wiki) && !attentionRowOfCause?.hidesWiki
+  const rows: LlmWikiRow[] = []
+  if (facts.wiki && isWikiShown)
+    rows.push(wikiRow(facts, facts.wiki, wording, hasRunRow))
+  if (facts.run) rows.push(runRow(facts, facts.run))
+  if (facts.elsewhere) rows.push(elsewhereRow(facts.elsewhere, wording))
+  if (facts.reservation)
+    rows.push(reservationRow(facts, facts.reservation, wording))
+  // A publication ends the last attempt: the Wiki row stands instead.
+  if (facts.lastAttempt && !isWikiShown)
+    rows.push(lastAttemptRow(facts.lastAttempt, !hasRunRow && !facts.attention))
+  if (facts.attention) rows.push(attentionRow(facts.attention))
+  return rows
+}
+
+/**
+ * Builds row 5, the output folder and its Change location action.
+ * @param facts - The ready facts.
+ * @returns The Output row; its tooltip says so when the file watcher could not be made.
+ * @example outputRow(facts).label // => 'Output: .codebook/wiki'
+ */
+function outputRow(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+): LlmWikiRow {
+  return {
+    id: 'output',
+    label: `Output: ${facts.outputLabel}`,
+    description: 'Change location',
+    tooltip: facts.isWatcherBroken
+      ? `${facts.outputDirectory}\nCodebook could not watch this folder, so the view refreshes when it is shown and with Refresh only.`
+      : facts.outputDirectory,
+    icon: 'folder',
+    actions: ['change-location'],
+  }
+}
+
+/**
+ * Chooses the wrapping message above the LLM Wiki view's rows in VS Code, where the description of a row may be cut off.
+ * @param facts - The ready facts.
+ * @returns
+ * - This window's run: the watching message (Stop watching does not stop the chat)
+ * - Only a stopped watch's reservation: that Codebook stopped watching and the chat may still publish
+ * - Cursor, or neither: no message
+ * @example watchMessageOf({ ...facts, host: 'vscode', run: undefined, reservation }) // => { message: 'Codebook stopped watching the chat, …' }
+ */
+function watchMessageOf(
+  facts: Extract<LlmWikiViewFacts, { kind: 'ready' }>,
+): Pick<LlmWikiViewModel, 'message'> {
+  if (facts.host !== 'vscode') return {}
+  // A run is a watch Codebook still keeps; a reservation alone is what a stopped watch left.
+  if (facts.run) return { message: LLM_WIKI_WATCHING_MESSAGE }
+  if (facts.reservation) return { message: LLM_WIKI_RESERVATION_MESSAGE }
+  return {}
+}
+
+/**
+ * Turns one record of facts into the rows of the LLM Wiki view, in their fixed order, each present exactly when its fact holds.
+ *
+ * Why: the view shows a Wiki beside a run, a reservation and an attention cause, so its rows are independent axes, not one state; one pure function keeps the complexity limits met and lets one table-driven test cover the whole matrix (Eng decision 82).
+ * Trigger: {@link LlmWikiView} calls it after each read of the facts.
+ *
+ * @param facts - What the folder, the trust, this window's run, other windows' markers, the manifest and the last attempt say.
+ * @param wording - How times and dates are written; the editor's locale when omitted.
+ * @returns
+ * - No folder: one row that opens a folder; untrusted: one row that manages trust
+ * - Otherwise the Wiki, run, elsewhere, reservation, last-attempt and attention rows that hold, then the Output row when any of them does
+ * - No row at all, and state `none`, when the folder holds no Wiki and no run (the welcome content shows)
+ * - A `message` in VS Code while a watch or a stopped watch's reservation is shown
+ *
+ * @example
+ * ```ts
+ * readLlmWikiViewState({ kind: 'no-folder' }).rows[0]?.label // => 'Open a folder to use the LLM Wiki'
+ * ```
+ */
+export function readLlmWikiViewState(
+  facts: LlmWikiViewFacts,
+  wording: LlmWikiViewWording = LOCAL_WORDING,
+): LlmWikiViewModel {
+  if (facts.kind === 'no-folder')
+    return {
+      state: 'other',
+      rows: [
+        {
+          id: 'folder',
+          label: 'Open a folder to use the LLM Wiki',
+          icon: 'folder-opened',
+          actions: ['open-folder'],
+        },
+      ],
+    }
+  if (facts.kind === 'untrusted')
+    return {
+      state: 'other',
+      rows: [
+        {
+          id: 'trust',
+          label: 'Trust this folder to use the LLM Wiki',
+          icon: 'shield',
+          actions: ['manage-trust'],
+        },
+      ],
+    }
+  const rows = readyRows(facts, wording)
+  if (rows.length === 0) return { state: 'none', rows: [] }
+  return {
+    state: 'other',
+    rows: [...rows, outputRow(facts)],
+    ...watchMessageOf(facts),
+  }
+}
diff --git a/extension/src/utils/registerLlmWikiCommands.ts b/extension/src/utils/registerLlmWikiCommands.ts
new file mode 100644
index 000000000..5ba0af6d4
--- /dev/null
+++ b/extension/src/utils/registerLlmWikiCommands.ts
@@ -0,0 +1,140 @@
+import { homedir } from 'node:os'
+
+import type * as vscode from 'vscode'
+
+import {
+  COPY_DETAILS_ACTION,
+  COPY_WIKI_RECOVERY_REQUEST_COMMAND,
+  LLM_WIKI_ROW_ACTIONS,
+  OPEN_CHAT_COMMAND,
+  OPEN_FOLDER_COMMAND,
+  OPEN_SETTINGS_COMMAND,
+  REFRESH_LLM_WIKI_COMMAND,
+  REVEAL_FILE_IN_OS_COMMAND,
+  REVEAL_WIKI_FOLDER_COMMAND,
+  SHOW_LLM_WIKI_ATTENTION_COMMAND,
+  WIKI_OUTPUT_SETTINGS_QUERY,
+  WIKI_UPDATE_RECOVERY_REQUEST,
+} from '../constants'
+
+import type { LlmWikiView } from './llmWikiView'
+import { resolveManageTrustCommand } from './resolveManageTrustCommand'
+import { withHomeFolderShown } from './withHomeFolderShown'
+
+/** What the commands of the LLM Wiki view ask of the window. */
+export type LlmWikiCommandOptions = {
+  editor: Pick<typeof vscode, 'commands' | 'env' | 'Uri'>
+  /** Registers a command of this window ({@link registerPlainCommand}). */
+  register: (
+    command: string,
+    handler: (...args: never[]) => unknown,
+  ) => vscode.Disposable
+  /** Shows a notification; resolves with the pressed button. */
+  showNotice: (
+    severity: 'information' | 'warning' | 'error',
+    message: string,
+    ...actions: string[]
+  ) => Thenable<string | undefined>
+  view: LlmWikiView
+  /** Stops this window's run: the VS Code watch, or the Cursor agent. */
+  cancelRun: () => void
+  /** The resolved Wiki folder. */
+  findOutputDirectory: () => Promise<string>
+}
+
+/**
+ * Shows the full sentence of an attention or last-attempt row, with Copy details; the click of those rows.
+ * @param options - The window's closures.
+ * @param rowId - The id of the clicked row.
+ * @returns Nothing; the sentence is copied with the home folder shown as `~` when the learner presses Copy details.
+ * @example await showRowDetail(options, 'attention')
+ */
+async function showRowDetail(
+  options: LlmWikiCommandOptions,
+  rowId: string,
+): Promise<void> {
+  const detail = options.view.findRow(rowId)?.detail
+  if (detail === undefined) return
+  const choice = await options.showNotice(
+    'warning',
+    detail,
+    COPY_DETAILS_ACTION,
+  )
+  if (choice === COPY_DETAILS_ACTION)
+    await options.editor.env.clipboard.writeText(
+      withHomeFolderShown(detail, homedir()),
+    )
+}
+
+/**
+ * Runs the editor's command that manages workspace trust, or says where to find it when the editor lists none of the known ids.
+ * @param options - The window's closures.
+ * @returns Nothing.
+ * @example await manageTrust(options)
+ */
+async function manageTrust(options: LlmWikiCommandOptions): Promise<void> {
+  const available = await options.editor.commands.getCommands(true)
+  const commandId = resolveManageTrustCommand(available)
+  if (commandId === undefined) {
+    void options.showNotice(
+      'information',
+      'Run "Workspaces: Manage Workspace Trust" from the Command Palette to trust this folder.',
+    )
+    return
+  }
+  await options.editor.commands.executeCommand(commandId)
+}
+
+/**
+ * Registers every command of the LLM Wiki view: Refresh, the row sentence, the recovery request, the folder reveal and the wrappers of the row actions whose editor commands are not Codebook's own.
+ *
+ * Why: the manifest can show an inline action only for a command it contributes, so each action that runs an editor command, or one whose title differs by host (Stop watching, Cancel), is a Codebook command with the title the row needs.
+ * Trigger: `activate()` calls it once per window beside the view.
+ *
+ * @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 }))
+ */
+export function registerLlmWikiCommands(
+  options: LlmWikiCommandOptions,
+): vscode.Disposable[] {
+  const { register: registerCommand, editor } = options
+  const cancelRun = (): void => options.cancelRun()
+  return [
+    registerCommand(REFRESH_LLM_WIKI_COMMAND, () => options.view.refresh()),
+    registerCommand(SHOW_LLM_WIKI_ATTENTION_COMMAND, (rowId: string) =>
+      showRowDetail(options, rowId),
+    ),
+    registerCommand(COPY_WIKI_RECOVERY_REQUEST_COMMAND, async () => {
+      await editor.env.clipboard.writeText(WIKI_UPDATE_RECOVERY_REQUEST)
+      void options.showNotice(
+        'information',
+        'Copied the recovery request. Paste it into the editor chat.',
+      )
+    }),
+    registerCommand(REVEAL_WIKI_FOLDER_COMMAND, async () =>
+      editor.commands.executeCommand(
+        REVEAL_FILE_IN_OS_COMMAND,
+        editor.Uri.file(await options.findOutputDirectory()),
+      ),
+    ),
+    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, () =>
+      editor.commands.executeCommand(OPEN_CHAT_COMMAND),
+    ),
+    registerCommand(LLM_WIKI_ROW_ACTIONS['change-location'].command, () =>
+      editor.commands.executeCommand(
+        OPEN_SETTINGS_COMMAND,
+        WIKI_OUTPUT_SETTINGS_QUERY,
+      ),
+    ),
+    registerCommand(LLM_WIKI_ROW_ACTIONS['open-folder'].command, () =>
+      editor.commands.executeCommand(OPEN_FOLDER_COMMAND),
+    ),
+    registerCommand(LLM_WIKI_ROW_ACTIONS['manage-trust'].command, () =>
+      manageTrust(options),
+    ),
+  ]
+}
diff --git a/extension/src/utils/resolveManageTrustCommand.ts b/extension/src/utils/resolveManageTrustCommand.ts
new file mode 100644
index 000000000..b2223d0ee
--- /dev/null
+++ b/extension/src/utils/resolveManageTrustCommand.ts
@@ -0,0 +1,21 @@
+import { MANAGE_WORKSPACE_TRUST_COMMAND_IDS } from '../constants'
+
+/**
+ * Picks the id of the editor's command that manages workspace trust from the commands the editor lists.
+ *
+ * Why: the command's id is not documented and may differ between VS Code and Cursor ({@link MANAGE_WORKSPACE_TRUST_COMMAND_IDS}); the first listed one is run, and none lets the caller say where to find it.
+ * Trigger: the LLM Wiki view's Manage Workspace Trust action.
+ *
+ * @param availableCommands - The ids `vscode.commands.getCommands(true)` lists.
+ * @returns The first known id the editor lists; `undefined` when it lists none.
+ * @example
+ * resolveManageTrustCommand(['workbench.trust.manage', 'other']) // => 'workbench.trust.manage'
+ * resolveManageTrustCommand(['other'])                            // => undefined
+ */
+export function resolveManageTrustCommand(
+  availableCommands: readonly string[],
+): string | undefined {
+  return MANAGE_WORKSPACE_TRUST_COMMAND_IDS.find((commandId) =>
+    availableCommands.includes(commandId),
+  )
+}
diff --git a/extension/src/utils/wikiUpdateRun.ts b/extension/src/utils/wikiUpdateRun.ts
index e5673f6f1..b962f5736 100644
--- a/extension/src/utils/wikiUpdateRun.ts
+++ b/extension/src/utils/wikiUpdateRun.ts
@@ -247,12 +247,39 @@ function refusalReason(
 export class WikiUpdateRun {
   #status: WikiUpdateStatus = { state: 'idle' }
   readonly #now: () => Date
+  readonly #changeListeners = new Set<() => void>()
 
   /** @param now - Clock for result timestamps; tests pass a fixed one. */
   constructor(now: () => Date = () => new Date()) {
     this.#now = now
   }
 
+  /**
+   * Calls a listener after every change of the state; used by the LLM Wiki view, which reads its rows again when this window's run starts, advances or ends.
+   * @param listener - Called synchronously after the state changed; one that throws is skipped and the others still hear the change.
+   * @returns The function that removes the listener.
+   * @example const stopListening = run.onDidChange(() => refreshView())
+   */
+  onDidChange(listener: () => void): () => void {
+    this.#changeListeners.add(listener)
+    return (): void => {
+      this.#changeListeners.delete(listener)
+    }
+  }
+
+  /** Replaces the state and tells the listeners; every change of the state goes through it. @param next - The new state. @example this.#record({ state: 'idle' }) */
+  #record(next: WikiUpdateStatus): void {
+    this.#status = next
+    for (const listener of [...this.#changeListeners]) {
+      // A broken listener must not hide the change from the others or fail the run's caller.
+      try {
+        listener()
+      } catch {
+        // The listener's owner has nowhere to be told here.
+      }
+    }
+  }
+
   /** @returns A copy of the current state, safe to serialize. @example run.status().state // => 'idle' */
   status(): WikiUpdateStatus {
     return structuredClone(this.#status)
@@ -272,7 +299,7 @@ export class WikiUpdateRun {
     runKind: WikiRunKind = 'update',
   ): boolean {
     if (this.isRunning()) return false
-    this.#status = {
+    this.#record({
       state: 'running',
       host,
       startedAt: this.#now().toISOString(),
@@ -281,14 +308,14 @@ export class WikiUpdateRun {
       ...(isOutputOutsideProject ? { isOutputOutsideProject: true } : {}),
       ...(runKind === 'generate' ? { runKind } : {}),
       ...output,
-    }
+    })
     return true
   }
 
   /** Notes that the agent has staged a candidate site, so the page can say work is under way. Ignored when no run is active. @example run.markCandidateStaged() */
   markCandidateStaged(): void {
     if (this.#status.state !== 'running') return
-    this.#status = { ...this.#status, candidateStaged: true }
+    this.#record({ ...this.#status, candidateStaged: true })
   }
 
   /**
@@ -305,7 +332,7 @@ export class WikiUpdateRun {
    */
   end(result: WikiUpdateEnd): void {
     if (this.#status.state !== 'running') return
-    this.#status = endedStatus(this.#status, this.#now().toISOString(), result)
+    this.#record(endedStatus(this.#status, this.#now().toISOString(), result))
   }
 
   /** Records that nothing needed updating; no run starts. @param output - Resolved Wiki folder and its label. @param published - What the current site is called. @param areAddedFilesUnchecked - Whether the project has no Git repository, so "current" covers the indexed sources only; the state then says so. @example run.alreadyCurrent({ outputDirectory: '/repo/.codebook/wiki', outputLabel: '.codebook/wiki' }, { identity: 'a1b2c3d4e5f6+0f9e8d7c', revision: 'a1b2c3d4e5f6', index: '0f9e8d7c' }, false) */
@@ -315,13 +342,13 @@ export class WikiUpdateRun {
     areAddedFilesUnchecked: boolean,
   ): void {
     if (this.isRunning()) return
-    this.#status = {
+    this.#record({
       state: 'already-current',
       finishedAt: this.#now().toISOString(),
       ...(areAddedFilesUnchecked ? { addedFilesUnchecked: true } : {}),
       ...published,
       ...output,
-    }
+    })
   }
 
   /** Records a start that was refused before any agent ran, so the page shows why; nothing was replaced. Ignored while a run is active. @param host - Editor host that was asked. @param output - Resolved Wiki folder and its label. @param refusal - The block found before the start. @example run.refuseStart('vscode', output, { kind: 'conflict', paths: ['index.html'], cause: 'edited-page' }) */
@@ -332,7 +359,7 @@ export class WikiUpdateRun {
   ): void {
     if (this.isRunning()) return
     const finishedAt = this.#now().toISOString()
-    this.#status =
+    this.#record(
       refusal.kind === 'conflict' && refusal.paths.length > 0
         ? {
             state: 'conflict',
@@ -349,6 +376,7 @@ export class WikiUpdateRun {
             finishedAt,
             ...refusalReason(refusal),
             ...output,
-          }
+          },
+    )
   }
 }
diff --git a/extension/src/utils/withHomeFolderShown.ts b/extension/src/utils/withHomeFolderShown.ts
new file mode 100644
index 000000000..2113d4482
--- /dev/null
+++ b/extension/src/utils/withHomeFolderShown.ts
@@ -0,0 +1,50 @@
+import { posix, win32 } from 'node:path'
+
+/** What may follow a home folder that ends there: a separator, the text's end, a space or quote or closing bracket, or a sentence's closing mark. */
+const HOME_FOLDER_END = String.raw`(?=[\\/]|[\s'"\x60)\]}>,;:!?]|\.(?:\s|$)|$)`
+
+/** What may stand before a home folder that starts there: the text's start, a space, a quote, `(`, `[`, `=` or the `file://` of a file link (`file:///` before a Windows drive). */
+const HOME_FOLDER_START = String.raw`(?<=^|[\s'"\x60(\[=]|file:///?)`
+
+/**
+ * Shows the home folder as `~` in a text, so a sentence copied into an issue does not name the learner's account.
+ *
+ * Why: the attention sentence names paths below the home folder; replacing a home that is empty or a file-system root would corrupt every `/` of the text, and a plain substring match would turn `/Users/adam` into `~m` for the home `/Users/ada` and miss a Windows spelling of the same folder.
+ * Trigger: Copy details in {@link registerLlmWikiCommands}.
+ *
+ * @param text - The sentence to copy.
+ * @param homeDirectory - The learner's home folder; tests pass their own.
+ * @param platform - The system whose paths these are; tests pass their own. On Windows and macOS the match ignores case; on Windows it takes `/` or `\` for either separator.
+ * @returns The text with every occurrence of the home folder as a whole path part, not preceded by another folder name, replaced by `~`; the text itself when the home is empty or a root (`/`, `C:\`).
+ * @example
+ * withHomeFolderShown('Edited /Users/ada/repo/a.html', '/Users/ada') // => 'Edited ~/repo/a.html'
+ * withHomeFolderShown('Edited /Users/adam/a.html', '/Users/ada')     // => 'Edited /Users/adam/a.html'
+ * withHomeFolderShown('Edited c:/users/ADA/a.html', 'C:\\Users\\ada', 'win32') // => 'Edited ~/a.html'
+ * withHomeFolderShown('Edited /repo/a.html', '/')                    // => 'Edited /repo/a.html'
+ */
+export function withHomeFolderShown(
+  text: string,
+  homeDirectory: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  const isWindows = platform === 'win32'
+  // A root is its own parent; replacing it would rewrite every separator.
+  if (
+    homeDirectory === '' ||
+    (isWindows ? win32 : posix).dirname(homeDirectory) === homeDirectory
+  )
+    return text
+  const homeWithoutTrailingSeparator = homeDirectory.replace(/[\\/]+$/, '')
+  const homePattern = homeWithoutTrailingSeparator
+    .split(isWindows ? /[\\/]+/ : '/')
+    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`))
+    .join(isWindows ? String.raw`[\\/]+` : '/')
+  return text.replace(
+    new RegExp(
+      `${HOME_FOLDER_START}${homePattern}${HOME_FOLDER_END}`,
+      // Windows and macOS disks ignore case by default, as {@link comparableFilePath} assumes.
+      isWindows || platform === 'darwin' ? 'gi' : 'g',
+    ),
+    '~',
+  )
+}