diff --git a/.github/workflows/storage-locks-windows.yml b/.github/workflows/storage-locks-windows.yml
index fd117dd3d..e70c732ff 100644
--- a/.github/workflows/storage-locks-windows.yml
+++ b/.github/workflows/storage-locks-windows.yml
@@ -113,6 +113,7 @@ on:
       - extension/src/utils/judgeLeftEmpty.ts
       - extension/src/utils/listFolderTreeWithoutFollowing.ts
       - extension/src/utils/listPlacedClaims.ts
+      - extension/src/utils/longestWikiRunMs.ts
       - extension/src/utils/modifiedAtMsOf.ts
       - extension/src/utils/namesMachineInClear.ts
       - extension/src/utils/newStagedConfigPath.ts
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3125200b..9738caa31 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.2.47.0] - 2026-10-27 (development candidate)
+
+Cycle 0056 ([Issue #135](https://github.com/laststance/codebook/issues/135)), a bug-fix cycle, first of its three pull requests: the LLM Wiki run lifecycle says what happens on a joined, stopped or bounded start and releases what it claimed. The LLM Wiki view and the reader (second pull request) and the Cursor test-replay fix with the native trial N56 (third) follow.
+
+**Starting and stopping an LLM Wiki run.**
+
+- **A press that joins a start under way says so once**: a second Generate or Update LLM Wiki (or the reader's **Update**) during a start shows `Codebook is already starting an LLM Wiki <generation|update> in this window; this press joins it.`; **Generate anyway**, **Update anyway** or the offer's **Update LLM Wiki** pressed then shows `…, so this choice was not applied. If that start stops for the same reason, choose it again.`
+- **In Cursor, readying Codebook's skill is bounded and stoppable.** The skill's check and deployment run for at most 30 seconds with the Wiki's marker claimed. **Stop LLM Wiki Run** ends them at once (`The LLM Wiki <generation|update> was cancelled at <time> while Codebook readied the Cursor skill; no agent was started. Press <Generate|Update> LLM Wiki when you want to start again.`, with the time you pressed Stop), and the 30 seconds end them with `Codebook stopped readying the Cursor skill after 30 seconds; no agent was started. …`. A closing window ends them too, and a window that is already closing starts none. A new press waits for a stopped step that is still writing the skill, so two deployments never run at once; a step that never settles is named with **Developer: Reload Window** as the way out.
+- **Remove Managed Cursor Skill waits for a skill step of the window** (up to 5 seconds) so a late deployment cannot bring the skill back, says so when the step does not end in time, and a Generate or Update pressed during the removal readies no skill and starts no agent.
+- **A start never loses another window's protection.** When **Generate anyway** or **Update anyway** took over a stopped VS Code watch's reservation and the start is then refused (for example by a skill conflict in Cursor), the reservation is written back as that window's own marker text, with its own window and bound, so that window still removes it; a closing window keeps it on disk and retries a write-back that another window's claim blocked for up to 5 seconds. A reservation already gone from disk is never brought back.
+- **A marker that cannot be removed at once is removed on a retry** instead of standing until its bound.
+- **With nothing running, Stop LLM Wiki Run says** `No LLM Wiki run is going on in this window.`
+
+**Clearer sentences.**
+
+- **One verb per editor for a stop**: VS Code says `stopped watching` and Cursor says `cancelled` in every notice and Output record, including a stop after a Wiki was published.
+- **A folder that cannot take a first Wiki names what is in the way** (`The folder <folder> cannot take a new LLM Wiki: <path> is in the way. Press Update LLM Wiki for the details and the next step.`); the block's cause id moves to the Output record.
+- **The LLM Wiki view shows `Waiting for chat`** as soon as a stopped watch's reservation is written, also without a file event.
+
+**Diagrams.** The bundled skill moves to **1.0.50**: two conditional edges between the same nodes, an edge that crosses a row, and edges between different nodes with one midpoint no longer draw their labels over each other or over a node.
+
+**Compatibility.** The MCP API stays 1.8; the Wiki's published format, the marker format and stored learner data do not change.
+
 ## [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).
diff --git a/README.md b/README.md
index 1aea92701..ba3ee80b8 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.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.
+This is a preview, not a Marketplace or Open VSX release. The delivered version is **0.2.47.0** once the first pull request of [Cycle 0056](https://github.com/laststance/codebook/issues/135) is merged; until then 0.2.46.0 ([PR #134](https://github.com/laststance/codebook/pull/134), Cycle 0055's second pull request) is the delivered one, and the active cycle Issue says where the delivery stands. Cycle 0056 is a bug-fix cycle that closes the defects Cycle 0055 carried, in three pull requests: the first makes an LLM Wiki start say what happens when it joins a start under way, is stopped or passes its bound, and release or write back what it claimed; the second the LLM Wiki view and the reader; the third a saved test replay that Cursor refused to open, with the native trial. [Cycle 0055](https://github.com/laststance/codebook/issues/132) is a feature cycle: **Codebook: Generate LLM Wiki** writes a project's first LLM Wiki through the editor's agent from Codebook's own entry (its first pull request), and an **LLM Wiki** view in the Activity Bar shows, opens and updates it (its second). Cycle 0053 was a feature cycle: a test inside a workspace package runs with that package's Vitest and config, as the package's own `vitest` would, while a test the repository root's config already selects keeps running from the root. Cycle 0054 is a bug-fix cycle that closes the three defects Cycle 0053 carried: a test that ends before a later declared stop says so, a package test's launch asks the repository root again whether its config now selects the test, and the native-trial bootstrap keeps a listing it could not release. Cycle 0051 opened a test replay in the learning-replay composition a browser replay has: the Learning summary in the chat's place, one transport for both replay families, and a Learning summary button that shows a hidden summary again. Cycle 0052 was a bug-fix cycle that closed every defect Cycle 0051 carried, in three pull requests: the first makes replays leave, open and reload without stale frames and makes their entries and exits behave as the learner chose; the second fixes a test replay's moves and its summary page; the third the live runtime's unreadable facts, a browser run's refusals and the tests' hygiene. The MCP API is 1.8. What each earlier cycle delivered, with its tests, trials and limits, is in the [change history](CHANGELOG.md) and in that cycle's record, kept under the tag [`docs-archive-2026-10-20`](https://github.com/laststance/codebook/tree/docs-archive-2026-10-20/docs/cycles); from Cycle 0048 on, the cycle's Issue holds its tasks and state, and its pull requests the results.
 
 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.
 
@@ -42,7 +42,8 @@ Read [AGENTS.md](AGENTS.md) when starting or resuming work; Codex loads it as it
 ## Tracking and continuation
 
 - [Goal Issue #1](https://github.com/laststance/codebook/issues/1) remains open until all acceptance conditions and owner acceptance hold.
-- [Cycle 0055 Issue #132](https://github.com/laststance/codebook/issues/132) is the active cycle: a feature cycle in which Codebook's Activity Bar generates, opens and updates the LLM Wiki, re-proven natively in both editors. Its baseline E1 measured a first generation at 34 min 33 s in VS Code and 4 min 14 s in Cursor's agent CLI, so a generation is bounded at 55 minutes.
+- [Cycle 0056 Issue #135](https://github.com/laststance/codebook/issues/135) is the active cycle: a bug-fix cycle with no increment that closes the defects Cycle 0055 carried, in three pull requests (the LLM Wiki run lifecycle; the LLM Wiki view and the reader; the Cursor test-replay fix with the native trial N56); the Issue holds its tasks and state.
+- [Cycle 0055 Issue #132](https://github.com/laststance/codebook/issues/132) is closed after [PR #133](https://github.com/laststance/codebook/pull/133) and [PR #134](https://github.com/laststance/codebook/pull/134): a feature cycle in which Codebook's Activity Bar generates, opens and updates the LLM Wiki, re-proven natively in both editors. Its baseline E1 measured a first generation at 34 min 33 s in VS Code and 4 min 14 s in Cursor's agent CLI, so a generation is bounded at 55 minutes.
 - [Cycle 0054 Issue #130](https://github.com/laststance/codebook/issues/130) is closed after [PR #131](https://github.com/laststance/codebook/pull/131): a bug-fix cycle with no increment that closed the three defects Cycle 0053 carried (an unreached declared stop explains itself, a launch asks the root claim again, the native trial keeps unreleased listings); the Issue holds its tasks and state.
 - [Cycle 0053 Issue #128](https://github.com/laststance/codebook/issues/128) is closed after [PR #129](https://github.com/laststance/codebook/pull/129): a feature cycle in which a test inside a workspace package runs with that package's Vitest and config (TanStack Query's and Redux Toolkit's library tests among the final-acceptance targets); the three defects it carried are the tasks of Cycle 0054.
 - [Cycle 0052 Issue #124](https://github.com/laststance/codebook/issues/124) is closed after [PR #125](https://github.com/laststance/codebook/pull/125), [PR #126](https://github.com/laststance/codebook/pull/126) and [PR #127](https://github.com/laststance/codebook/pull/127): a bug-fix cycle with no increment that closed every defect Cycle 0051 carried (replays leave, open and reload without stale frames; a test replay's moves and summary page; the live runtime, a browser run's refusals and the tests' hygiene); it carried nothing.
diff --git a/VERSION b/VERSION
index 4a193462e..8c0701375 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.2.46.0
+0.2.47.0
diff --git a/extension/README.md b/extension/README.md
index 8861f399e..7a5c835d2 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -147,7 +147,7 @@ A test runs the way its package's own `vitest` command would: in its **Vitest ro
 
 ## First LLM Wiki
 
-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.
+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. The bundled skill draws the flow diagrams itself: where two conditional arrows join the same two parts, an arrow crosses a row, or arrows between different parts have one midpoint, each label keeps its own place beside its arrow, clear of the other labels and of the parts. 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 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>.`).
@@ -174,10 +174,10 @@ To write the Wiki elsewhere, set the folder in your settings (a path inside the
 - **Cursor.** The request goes to `cursor-agent` with the same flags as an update's, without further prompts; a notification `Generating the LLM Wiki in cursor-agent…` with Cancel shows the run. It uses your Cursor plan. Codebook readies the managed Codebook skill in `~/.cursor/skills/codebook` first, without starting the MCP connection: a missing or outdated managed skill is installed, and a skill of your own or one you edited stays and refuses the generation with its sentence. The model is the one `cursor-agent` is set to use (the `model` of `~/.cursor/cli-config.json`); Codebook does not choose it.
 - **Existing Wiki.** Generate never overwrites a Wiki: in a folder that holds a manifest it says `An LLM Wiki already exists in <folder>. Update it instead?` with **Update LLM Wiki**, also when a Wiki was published between its first look and its start. To generate again from scratch, ask the chat `/codebook Generate the LLM Wiki for this project`; the publisher keeps the earlier Wiki beside the new one.
 - **Its bound.** A generation runs up to 55 minutes in both editors, the longest measured first generation times 1.5; the time counts while the computer sleeps. A generation that publishes counts as generated even when sources changed meanwhile: the notice then says `LLM Wiki generated in <folder>. <N> source files changed while it was written.` and offers **Update LLM Wiki** first.
-- **Stopping it.** **Codebook: Stop LLM Wiki Run** stops this window's generation or update. In VS Code it stops Codebook's watch, not the chat (the status bar's **Stop watching** does the same): the chat may still publish, Codebook waits for it 55 minutes after the watch's end before it starts another generation or update of that Wiki, and a publish of that chat ends the wait. In Cursor it stops the agent. While the run is still starting (its checks, the confirmation, the claim of the Wiki), it says `Codebook is starting an LLM Wiki run in this window. Once it runs, its progress shows and Stop LLM Wiki Run stops it.`; **Open LLM Wiki in Browser** says the same then instead of offering a second generation.
-- **Output record.** Every generation and update end writes one line to Output › Codebook (**Codebook: Show LLM Wiki Output**): the run's kind, editor, start and end time, how it ended in Codebook's words, the agent's exit code and the output folder with your home folder shown as `~`. It never holds the agent's reply, its errors or a chat's error text.
+- **Stopping it.** **Codebook: Stop LLM Wiki Run** stops this window's generation or update. In VS Code it stops Codebook's watch, not the chat (the status bar's **Stop watching** does the same): the chat may still publish, Codebook waits for it 55 minutes after the watch's end before it starts another generation or update of that Wiki, and a publish of that chat ends the wait. In Cursor it stops the agent. While the run is still starting (its checks, the confirmation, the claim of the Wiki), it says `Codebook is starting an LLM Wiki run in this window. Once it runs, its progress shows and Stop LLM Wiki Run stops it.`; **Open LLM Wiki in Browser** says the same then instead of offering a second generation. A second press of Generate or Update LLM Wiki (or the browser reader's **Update**) during that start joins it and says so once while that start lasts: `Codebook is already starting an LLM Wiki <generation|update> in this window; this press joins it.` A press of **Generate anyway**, **Update anyway** or the offer's **Update LLM Wiki** during that start joins it without its choice and is told once instead: `Codebook is already starting an LLM Wiki <generation|update> in this window, so this choice was not applied. If that start stops for the same reason, choose it again.` In Cursor the start also readies Codebook's skill for up to 30 seconds with the Wiki's marker claimed: **Stop LLM Wiki Run** ends it at once with `The LLM Wiki <generation|update> was cancelled at <time> while Codebook readied the Cursor skill; no agent was started. Press <Generate|Update> LLM Wiki when you want to start again.`, and a step that passes 30 seconds ends it with `Codebook stopped readying the Cursor skill after 30 seconds; no agent was started. Press <Generate|Update> LLM Wiki again, or run Codebook: Set Up AI Chat.`; either way the start leaves the marker (it is removed, or a reservation of another window's stopped watch that **Generate anyway** or **Update anyway** took over is written back as it was, with its own window and its own bound). A window that closes during that step ends it the same way, so the marker is not left to expire. A reservation of another window's stopped watch that this window wrote back stays on disk when the window closes, until its own bound, because that window's chat may still publish; it is written back as that window's own text, so that window still removes it at its bound or when it closes, and a write-back that cannot be made at the close (another window holds the marker's claim at that moment) is tried again for up to 5 seconds. A reservation that is already gone from disk when a refused start ends (its window removed it) is never brought back. A marker a start cannot remove at once is removed on a retry (every 10 seconds for two minutes, [below](#llm-wiki-open-and-update)) instead of standing until its bound. A window that begins to close before a start has reached the skill step starts no check or deployment of the skill: the start ends without an agent and leaves its marker (removed, or a taken-over reservation written back). A step that was stopped may still be writing the skill: a new press of Generate or Update LLM Wiki waits for it to finish before it readies the skill again, so two deployments of the skill never run at once, and Stop LLM Wiki Run and the 30 seconds apply to that wait too; a step that never settles ends that wait at the 30 seconds with `Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press <Generate|Update> LLM Wiki again.` (no agent starts, the marker is left as for the 30 seconds). With nothing running, Stop LLM Wiki Run says `No LLM Wiki run is going on in this window.`
+- **Output record.** Every generation and update end writes one line to Output › Codebook (**Codebook: Show LLM Wiki Output**): the run's kind, editor, start and end time, how it ended in Codebook's words, the agent's exit code, the cause id of a block that refused a generation's start (the notice names the file in the way and leaves the id out) and the output folder with your home folder shown as `~`. It never holds the agent's reply, its errors or a chat's error text.
 - **Buttons of an older notice.** **Generate anyway**, **Update anyway** and the offer's **Update LLM Wiki** wait only for the start whose notice showed them; pressed while another run of the window works, they are told that a run is under way at once and start nothing when it ends.
-- **Names.** **Codebook: Open LLM Wiki in Browser** was titled **Open DeepWiki in Browser** before 0.2.45; its command id `codebook.openDeepWiki` is unchanged, so keybindings and scripts keep working. The bundled skill 1.0.49 names it in the reader's offline note.
+- **Names.** **Codebook: Open LLM Wiki in Browser** was titled **Open DeepWiki in Browser** before 0.2.45; its command id `codebook.openDeepWiki` is unchanged, so keybindings and scripts keep working. The bundled skill 1.0.50 names it in the reader's offline note.
 - **Several windows.** Update every window of a project to this version before you generate: an earlier Codebook reads a generation's marker with an update's 15-minute bounds and may start an update beside a generation that still runs (the publisher still refuses a second publish while one runs). Stop a running generation before you go back to an earlier Codebook.
 
 ## LLM Wiki: open and update
@@ -230,7 +230,7 @@ The folder is `.codebook/wiki` in the project unless `codebook.wikiOutputDirecto
 
 A Wiki folder you commit to Git must keep the publisher's bytes: mark it `-text` in `.gitattributes` (the line `".codebook/wiki/**" -text`, with your folder's path), so that a checkout with `core.autocrlf`, the default of Git for Windows, keeps its LF line ends. The skill's publisher writes every page with LF line ends only, also when the text of a page held CRLF, so that this way out restores every page. The skill's publisher refuses a Wiki whose files a checkout gave CRLF line ends, with a sentence that names them and the way out: add that line to the `.gitattributes` file in the folder the sentence names (the project's, for a Wiki folder inside it) and commit that file; then, in that folder, run `git rm -r --cached --quiet -- ".codebook/wiki"` and `git checkout HEAD -- ".codebook/wiki"` (with your folder's path from there), which write the folder's committed files again with LF line ends (a change of them that is not committed is lost), and run the step again. The publisher also refuses a manifest that starts with a UTF-8 byte order mark (PowerShell 5.1's `Set-Content -Encoding UTF8` writes one) and says: `Write the file again as UTF-8 without that mark`. It reads `--output=<path>` as it reads `--output <path>`; a separate value that begins with a dash gets its usage.
 
-While an update runs, its window keeps a marker file beside the output folder, `<folder>.update-run.json` (`.codebook/wiki.update-run.json` unless the setting names another folder), so that a second editor window on the same project does not start a second update. That window's start is refused with `Another editor window is updating this Wiki (<editor>, started <time>). Wait for it to finish, then press Update LLM Wiki again.`, or for a generation with `Another editor window is generating this Wiki (<editor>, started <time>). Wait for it to finish, then press Open LLM Wiki in Browser.` Two shorter refusals name no run. `Another editor window is starting an update of this Wiki. Wait a moment and try again.` is shown while another window is writing its marker: a marker file without content, or one that cannot be read and is not dated ahead of the clock, that is younger than 2 seconds. `Another editor window is starting or ending an update of this Wiki. Wait a moment and try again.` is shown while another window holds the claim under which a marker is removed or replaced, and a leftover marker is in the way. A start of the window whose own last run is removing or replacing its marker at that moment (**Update anyway** chosen right after that run ended, for example) is not refused with it: the start waits until that change is made and claims the marker again. A marker file that cannot be read (another program holds it open, as a scanner or an indexer can on Windows, or this user may not read it) may be a running update's marker, so it counts until 61 minutes 30 seconds after its last write, as long as any marker counts (a generation's); once it is 2 seconds old, or when its time lies ahead of the clock, the start is refused with `Another editor window may be updating this Wiki: Codebook cannot read the Wiki’s marker file (<path>), which another program may hold open (as a scanner or an indexer can on Windows) or which this user may not read. Press Update LLM Wiki again once the file can be read; if the file stays as it is, this refusal ends at <time>.`, where `<time>` is the first whole minute after those 61 minutes 30 seconds. The marker usually lies in your project folder, so it holds nothing that names the computer, its host or its user in clear: it records the process id of the window's extension host and when that process began, a random id of the window, the editor, the time the run started, the id of the computer's boot on Linux and macOS, and two digests that stand for the machine. A digest is a pseudonym and no secret: a commit of the file publishes it, and the digest of a common host name can be found by trying names. When the run ends, its window removes the marker; after a stopped VS Code watch the file stays as that window's note that the chat may still publish, and the window removes it later or the next update does. Where the window cannot remove or replace its marker at that moment (another window holds the claim on it, the system refuses the claim or the change, or the marker cannot be read at that moment, as on Windows while a scanner or an indexer holds the file open), it tries again every 10 seconds for two minutes, and once more when it closes; a marker still left after that counts until its run's longest time has passed.
+While an update runs, its window keeps a marker file beside the output folder, `<folder>.update-run.json` (`.codebook/wiki.update-run.json` unless the setting names another folder), so that a second editor window on the same project does not start a second update. That window's start is refused with `Another editor window is updating this Wiki (<editor>, started <time>). Wait for it to finish, then press Update LLM Wiki again.`, or for a generation with `Another editor window is generating this Wiki (<editor>, started <time>). Wait for it to finish, then press Open LLM Wiki in Browser.` Two shorter refusals name no run. `Another editor window is starting an update of this Wiki. Wait a moment and try again.` is shown while another window is writing its marker: a marker file without content, or one that cannot be read and is not dated ahead of the clock, that is younger than 2 seconds. `Another editor window is starting or ending an update of this Wiki. Wait a moment and try again.` is shown while another window holds the claim under which a marker is removed or replaced, and a leftover marker is in the way. A start of the window whose own last run is removing or replacing its marker at that moment (**Update anyway** chosen right after that run ended, for example) is not refused with it: the start waits until that change is made and claims the marker again. A marker file that cannot be read (another program holds it open, as a scanner or an indexer can on Windows, or this user may not read it) may be a running update's marker, so it counts until 61 minutes 30 seconds after its last write, as long as any marker counts (a generation's); once it is 2 seconds old, or when its time lies ahead of the clock, the start is refused with `Another editor window may be updating this Wiki: Codebook cannot read the Wiki’s marker file (<path>), which another program may hold open (as a scanner or an indexer can on Windows) or which this user may not read. Press Update LLM Wiki again once the file can be read; if the file stays as it is, this refusal ends at <time>.`, where `<time>` is the first whole minute after those 61 minutes 30 seconds. The marker usually lies in your project folder, so it holds nothing that names the computer, its host or its user in clear: it records the process id of the window's extension host and when that process began, a random id of the window, the editor, the time the run started, the id of the computer's boot on Linux and macOS, and two digests that stand for the machine. A digest is a pseudonym and no secret: a commit of the file publishes it, and the digest of a common host name can be found by trying names. When the run ends, its window removes the marker; after a stopped VS Code watch the file stays as that window's note that the chat may still publish, and the window removes it later or the next update does. Where the window cannot remove or replace its marker at that moment (another window holds the claim on it, the system refuses the claim or the change, or the marker cannot be read at that moment, as on Windows while a scanner or an indexer holds the file open), it tries again every 10 seconds for two minutes, and once more when it closes; a marker still left after that counts until its run's longest time has passed. A start that ends before its run began (refused, stopped or bounded while Codebook readied the Cursor skill, or ended by the closing window) leaves the marker it claimed the same way, with the same retries.
 
 A marker of a running update that a killed editor left on this machine does not refuse a start: a window of this build judges a marker by the start of its owner's process, so the marker counts as nobody's when that process is gone and also when another process has its process id since, and the next start removes it. A marker whose owner cannot be judged here counts until its run's longest time has passed at the latest: 21 minutes after the run began for Cursor and 21 minutes 30 seconds for VS Code (a generation's marker: 61 minutes and 61 minutes 30 seconds, its 55 minutes in place of the 15) (the 15 minutes of a run, in VS Code after the 30 seconds for the chat's first answer, then 1 minute, then the 5 minutes by which two clocks may differ). That is a marker written on another computer (a project folder shared between machines), in another system or another pid namespace of this computer (a Windows window beside a WSL window, another WSL distribution, a container), where its process id means another process, by a window that could not read its own process start, or by a Linux window that could not read its own pid namespace (such a window also judges no other window's marker by its process). A running update's marker of this computer that names another boot than the running one (on Linux and macOS, which name their boots) is nobody's all the same. A marker of 0.2.29.0 counts that long when a process still has its process id. [What a lock or an update marker cannot tell](#what-a-lock-or-an-update-marker-cannot-tell) lists the limits.
 
@@ -253,7 +253,7 @@ The **LLM Wiki** view in Codebook's Activity Bar shows where the generated site
 - **`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.
+The view reads its state again after a change of this window's run and once this window has removed or turned into a reservation the run's marker (so `Waiting for chat` shows also without a file event), after a change of the Wiki's manifest or of the three marker files beside the Wiki folder (one second after the last change, so a burst of changes is one read), after a change of `codebook.wikiOutputDirectory` or of workspace trust, when the view is shown, every 30 seconds while a run row shows (a marker whose window died leaves no file event), and with the **Refresh** action in its title bar. When the Wiki folder's parent does not exist yet, as in a fresh project, Codebook watches the closest folder of the project that does (never above the project folder) and moves the watch once a run makes the parent; the watch includes the Wiki folder itself, so deleting or renaming it is seen. An output folder outside the project is watched only when its own parent exists; the home folder and a file-system root are never watched. If the editor refuses the watch, or there is no folder to watch, the view refreshes when it is shown and with **Refresh** only, the **Output** row's tooltip says so and Output › Codebook records the cause once. The freshness label is read at each refresh, so a source edit shows as `Source changed` when the view is next shown or refreshed, not at the save. A refresh with nothing new changes nothing the screen reader announces and never moves the focus. Every action is also in the row's context menu (Shift+F10). **Codebook: Refresh LLM Wiki**, **Codebook: Copy LLM Wiki Recovery Request** and **Codebook: Reveal LLM Wiki Folder** are listed in the Command Palette only in an editor that shows the view. Only the first workspace folder is read. The 55 minutes of a generation count wall-clock time, so time asleep counts toward them.
 
 ### Troubleshooting the LLM Wiki
 
@@ -269,7 +269,7 @@ Each entry is a sentence Codebook shows when a generation ends or does not start
 
 #### Generation stopped
 
-`Codebook stopped watching the LLM Wiki generation at <time>. …` (VS Code) or `LLM Wiki generation cancelled at <time>. Cursor Agent was stopped; nothing was published.` (Cursor). In VS Code the chat may still publish, and **Open LLM Wiki in Browser** opens the Wiki once it has; stop the request in the chat to end it. A stop names a Wiki as published, with **Open in Browser**, only for a publish of the Codebook publisher that names this project and has its entry page; a manifest that appeared otherwise counts as nothing published. A new generation waits for that chat up to 55 minutes after the watch's end, and its refusal offers **Generate anyway** once you stopped the chat.
+`Codebook stopped watching the LLM Wiki generation at <time>. …` (VS Code) or `LLM Wiki generation cancelled at <time>. Cursor Agent was stopped; nothing was published.` (Cursor). A stop that came after a Wiki was published says so in the same verb (`Codebook stopped watching the LLM Wiki generation at <time>, after an LLM Wiki was published in <folder>.` in VS Code, `The LLM Wiki generation was cancelled at <time>, after …` in Cursor), and the Output record words the stop the same way (`stopped watching by the learner or the closing window` in VS Code, `cancelled by the learner or the closing window` in Cursor). In VS Code the chat may still publish, and **Open LLM Wiki in Browser** opens the Wiki once it has; stop the request in the chat to end it. A stop names a Wiki as published, with **Open in Browser**, only for a publish of the Codebook publisher that names this project and has its entry page; a manifest that appeared otherwise counts as nothing published. A new generation waits for that chat up to 55 minutes after the watch's end, and its refusal offers **Generate anyway** once you stopped the chat.
 
 #### Generation timed out
 
@@ -299,6 +299,10 @@ Each entry is a sentence Codebook shows when a generation ends or does not start
 
 `<folder> is a link or a file, not a folder of its own, …`, `A folder on the path to <folder> (<path>) is a link or a file, …` or `<folder> holds a link or special file (<path>), …` The publisher refuses to write there. Replace it with a real folder, move the entry out, or set `codebook.wikiOutputDirectory` to another folder.
 
+#### Something else in the Wiki folder is in the way
+
+`The folder <folder> cannot take a new LLM Wiki: <path> is in the way. Press Update LLM Wiki for the details and the next step.` The folder holds something a first generation cannot work around; where Codebook names no path, the sentence reads `The folder <folder> cannot take a new LLM Wiki. Press Update LLM Wiki for the details and the next step.` Press **Update LLM Wiki** for the details and the next step.
+
 #### Another window or an earlier chat is generating
 
 `Another editor window is generating this Wiki (<editor>, started <time>). …` or `The VS Code chat … may still be generating this Wiki; …` Wait for it; once that chat was stopped, choose **Generate anyway** in the notice.
@@ -307,6 +311,12 @@ Each entry is a sentence Codebook shows when a generation ends or does not start
 
 A refusal that names the Cursor skill `codebook` (a skill of your own or one you edited): Codebook keeps it and does not generate. Move a skill of your own out of `~/.cursor/skills/codebook`, or run **Codebook: Restore Managed Cursor Skill** to put back the managed skill you edited, then generate again.
 
+#### An earlier Cursor skill step is still running
+
+`Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press <Generate|Update> LLM Wiki again.` A check or deployment of Codebook's Cursor skill started by an earlier press did not finish, and a new press waits for it for up to 30 seconds. No agent was started and the Wiki's marker is left as after any ended start (removed, or another window's stopped-watch reservation written back). Reload the window to end the stuck step, then press the button again.
+
+**Codebook: Remove Managed Cursor Skill** ends a Cursor skill step of the window and waits up to 5 seconds for it, so a late deployment cannot write the skill again after it was removed. A step that still runs after that leaves everything in place and says `Codebook did not remove the managed Cursor skill: a Cursor skill step of this window is still running and could write the skill again. Reload the window (Developer: Reload Window) to end it, then run Codebook: Remove Managed Cursor Skill again.` A Generate or Update pressed while the removal is under way readies no skill and starts no agent: `Codebook is removing the managed Cursor skill in this window; no agent was started. Press <Generate|Update> LLM Wiki again when the removal has finished, and Codebook installs its skill again.`
+
 #### Cursor Agent CLI is not installed
 
 `Cursor Agent CLI is not installed: Codebook looks for ~/.local/bin/cursor-agent, then cursor-agent on the editor's PATH. …` Install `cursor-agent`, sign in, and retry, or use Cursor chat.
diff --git a/extension/package.json b/extension/package.json
index 79b6fa176..6effd4103 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.46",
+  "version": "0.2.47",
   "private": true,
   "engines": {
     "vscode": "^1.120.0",
diff --git a/extension/scripts/tests/package.test.mjs b/extension/scripts/tests/package.test.mjs
index b96930792..ba00e1c75 100644
--- a/extension/scripts/tests/package.test.mjs
+++ b/extension/scripts/tests/package.test.mjs
@@ -95,7 +95,7 @@ test('a real VSIX loads outside the checkout and excludes bundled applications a
   // Assert
   assert.equal(receipt.isolatedModuleLoad, true)
   assert.equal(receipt.isolatedWikiPageWorker, true)
-  assert.equal(checked.extension.version, '0.2.46')
+  assert.equal(checked.extension.version, '0.2.47')
   assert.equal(checked.extension.apiVersion, '1.8')
   assert.equal(checked.entries, 33)
   assert.equal(receipt.dependencies.length, 16)
diff --git a/extension/scripts/tests/publishWiki.test.mjs b/extension/scripts/tests/publishWiki.test.mjs
index 0ff28d425..dba95a4b2 100644
--- a/extension/scripts/tests/publishWiki.test.mjs
+++ b/extension/scripts/tests/publishWiki.test.mjs
@@ -5261,6 +5261,371 @@ test('pending and success branches retain their own conditions and operations',
   }
 })
 
+// Value: protects=two conditional edges between the same two stacked nodes keep their labels readable in a published diagram; fails_when=the labels of a Show result edge and a Show error edge share one label band, so their backing boxes overlap; no_claim=how a browser paints the SVG or the room left of the first column
+test('two branch edges from one node to the node below it draw label boxes that do not overlap', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-label-boxes-')),
+  )
+  try {
+    const manifest = await diagramInput(root),
+      diagram = manifest.pages[0].diagrams[0]
+    diagram.nodes[1].row = 1
+    diagram.nodes[1].column = 0
+    diagram.edges[0] = {
+      ...diagram.edges[0],
+      kind: 'branch',
+      label: 'Show the saved result',
+      condition: 'ready',
+    }
+    diagram.edges.push({
+      ...diagram.edges[0],
+      id: 'failure',
+      label: 'Show the failure notice',
+      condition: 'denied',
+    })
+    // Act
+    const html = (
+      await renderWikiPages(manifest, {
+        projectRoot: root,
+        outputDirectory: join(root, '.codebook/wiki'),
+      })
+    ).get('index.html')
+    const boxes = ['read', 'failure'].map((id) => {
+      const [, x, y, width, height] = edgeGroup(html, id).match(
+        /<rect x="([\d.-]+)" y="([\d.-]+)" width="([\d.]+)" height="([\d.]+)" rx="3"/,
+      )
+      return {
+        left: Number(x),
+        right: Number(x) + Number(width),
+        top: Number(y),
+        bottom: Number(y) + Number(height),
+      }
+    })
+    // Assert
+    const [first, second] = boxes
+    const doOverlap =
+      first.left < second.right &&
+      second.left < first.right &&
+      first.top < second.bottom &&
+      second.top < first.bottom
+    assert.equal(doOverlap, false)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+/** Replaces the fixture's two nodes and one edge with a column of three nodes and the given edges, each edge as `[id, from, to, label, condition]`; an edge with a condition is a branch. */
+function threeRowColumn(diagram, edges) {
+  const reference = diagram.nodes[0].sources
+  diagram.nodes = ['a', 'b', 'c'].map((id, row) => ({
+    id,
+    label: id,
+    row,
+    column: 0,
+    sources: reference,
+  }))
+  diagram.edges = edges.map(([id, from, to, label, condition]) => ({
+    id,
+    from,
+    to,
+    label,
+    kind: condition ? 'branch' : 'call',
+    ...(condition ? { condition } : {}),
+    sources: reference,
+  }))
+}
+
+/** Replaces the fixture's nodes and edges with the given grid: each node as `[id, row, column]`, each edge as `[id, from, to, label, condition]`; an edge with a condition is a branch. */
+function gridDiagram(diagram, nodes, edges) {
+  const reference = diagram.nodes[0].sources
+  diagram.nodes = nodes.map(([id, row, column]) => ({
+    id,
+    label: id,
+    row,
+    column,
+    sources: reference,
+  }))
+  diagram.edges = edges.map(([id, from, to, label, condition]) => ({
+    id,
+    from,
+    to,
+    label,
+    kind: condition ? 'branch' : 'call',
+    ...(condition ? { condition } : {}),
+    sources: reference,
+  }))
+}
+
+/** The boxes of a rendered flow diagram: each node's rectangle and each edge's label backing, by id. */
+function diagramBoxes(html) {
+  const box = ([, id, x, y, width, height]) => ({
+    id,
+    left: Number(x),
+    right: Number(x) + Number(width),
+    top: Number(y),
+    bottom: Number(y) + Number(height),
+  })
+  return {
+    nodes: [
+      ...html.matchAll(
+        /<g data-node-id="([^"]+)"><rect x="([\d.-]+)" y="([\d.-]+)" width="([\d.]+)" height="([\d.]+)"/g,
+      ),
+    ].map(box),
+    labels: [
+      ...html.matchAll(
+        /<g data-edge-id="([^"]+)"[^>]*>(?:(?!<\/g>)[\s\S])*?<rect x="([\d.-]+)" y="([\d.-]+)" width="([\d.]+)" height="([\d.]+)" rx="3"/g,
+      ),
+    ].map(box),
+  }
+}
+
+/** The pairs of boxes (a label and a node, or two labels) that cover a common area, as `label e4 × node b`. */
+function overlappingBoxes({ nodes, labels }) {
+  const overlap = (first, second) =>
+    first.left < second.right &&
+    second.left < first.right &&
+    first.top < second.bottom &&
+    second.top < first.bottom
+  return labels.flatMap((label, index) => [
+    ...nodes
+      .filter((node) => overlap(label, node))
+      .map((node) => `label ${label.id} × node ${node.id}`),
+    ...labels
+      .slice(index + 1)
+      .filter((other) => overlap(label, other))
+      .map((other) => `label ${label.id} × label ${other.id}`),
+  ])
+}
+
+/** Renders the fixture's page and returns the first page's HTML. */
+async function renderedDiagramHtml(root, manifest) {
+  return (
+    await renderWikiPages(manifest, {
+      projectRoot: root,
+      outputDirectory: join(root, '.codebook/wiki'),
+    })
+  ).get('index.html')
+}
+
+// Value: protects=Cycle 0056 pass 3 A4(1), a diagram that needs no stacked labels keeps the layout it had before the label bands grew; fails_when=widening the label bands to every node pair moves the label boxes or the rows of a diagram whose edges share no node pair, so every published diagram changes; no_claim=how a browser paints the SVG; seam=label boxes hard-coded from the renderer of the release before this change
+test('a three-row diagram whose labels need no stacking keeps the label boxes of the earlier renderer', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-unchanged-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    threeRowColumn(manifest.pages[0].diagrams[0], [
+      ['e1', 'a', 'b', 'Read data'],
+      ['e2', 'b', 'c', 'Write the result'],
+    ])
+
+    // Act
+    const { labels } = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert
+    assert.deepEqual(
+      labels.map(({ id, left, top, right, bottom }) => ({
+        id,
+        left: Math.round(left * 100) / 100,
+        top,
+        right: Math.round(right * 100) / 100,
+        bottom,
+      })),
+      [
+        { id: 'e1', left: 83.88, top: 145, right: 180.12, bottom: 163 },
+        { id: 'e2', left: 51.12, top: 307, right: 212.88, bottom: 325 },
+      ],
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=Cycle 0056 pass 3 A4(2), the label of an edge that crosses a row; fails_when=a conditional edge from the top to the bottom node of a column puts its label on the node between them, where the node paints over it, or a node or label is not drawn at all; no_claim=the connector line, which an author's grid placement decides; seam=a column of three nodes with one edge across two rows
+test('the label of an edge across two rows stays clear of the node between them', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-span-label-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    threeRowColumn(manifest.pages[0].diagrams[0], [
+      ['e1', 'a', 'b', 'Read data'],
+      ['e4', 'a', 'c', 'Skip the write', 'cached'],
+    ])
+
+    // Act
+    const boxes = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert: every node and label was drawn, so no missing box passes as no overlap.
+    assert.deepEqual(
+      {
+        nodes: boxes.nodes.map(({ id }) => id).sort(),
+        labels: boxes.labels.map(({ id }) => id).sort(),
+        overlaps: overlappingBoxes(boxes),
+      },
+      { nodes: ['a', 'b', 'c'], labels: ['e1', 'e4'], overlaps: [] },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=Cycle 0056 pass 3 A4(2), a column of three rows with a stacked pair and an edge across two rows; fails_when=any label box covers a node or another label box once the label bands span every edge pair, or a node or label is not drawn at all; no_claim=how a browser paints the SVG; seam=the stacked pair between the lower two nodes and the crossing edge from the top node
+test('a column with a stacked pair and an edge across two rows draws no label over a node or another label', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-stack-span-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    threeRowColumn(manifest.pages[0].diagrams[0], [
+      ['e1', 'a', 'b', 'Read data'],
+      ['e2', 'b', 'c', 'Show the saved result', 'ready'],
+      ['e3', 'b', 'c', 'Show the failure notice', 'denied'],
+      ['e4', 'a', 'c', 'Skip the write', 'cached'],
+    ])
+
+    // Act
+    const boxes = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert: every node and label was drawn, so no missing box passes as no overlap.
+    assert.deepEqual(
+      {
+        nodes: boxes.nodes.map(({ id }) => id).sort(),
+        labels: boxes.labels.map(({ id }) => id).sort(),
+        overlaps: overlappingBoxes(boxes),
+      },
+      {
+        nodes: ['a', 'b', 'c'],
+        labels: ['e1', 'e2', 'e3', 'e4'],
+        overlaps: [],
+      },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=CodeRabbit on PR #136 (render-wiki-diagrams.mjs labelBandOf), two edges whose labels share a midpoint in one gap; fails_when=an edge from the first to the third column and an edge straight down the second column, both leaving the top row, draw their labels in the same place because their bands are keyed by different column pairs; no_claim=the connector lines; seam=a two-row grid with those two edges
+test('two edges that cross the same gap at the same midpoint stack their labels instead of drawing them over each other', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-shared-midpoint-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    gridDiagram(
+      manifest.pages[0].diagrams[0],
+      [
+        ['a', 0, 0],
+        ['b', 0, 1],
+        ['c', 1, 1],
+        ['d', 1, 2],
+      ],
+      [
+        ['e1', 'a', 'd', 'Send the order'],
+        ['e2', 'b', 'c', 'Check the stock'],
+      ],
+    )
+
+    // Act
+    const boxes = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert
+    assert.deepEqual(
+      {
+        nodes: boxes.nodes.map(({ id }) => id).sort(),
+        labels: boxes.labels.map(({ id }) => id).sort(),
+        overlaps: overlappingBoxes(boxes),
+      },
+      { nodes: ['a', 'b', 'c', 'd'], labels: ['e1', 'e2'], overlaps: [] },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=Cycle 0056 (found with the CodeRabbit finding above), a row's horizontal label under a tall stack of labels that cross the gap above that row at the same midpoint; fails_when=the stack in the gap reaches down over the label reserved above the row; no_claim=labels at different midpoints; seam=two conditional edges down from the top row and one edge along the second row, all with one midpoint
+test('a horizontal label below a stack of labels in the gap above its row keeps clear of that stack', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-gap-and-row-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    gridDiagram(
+      manifest.pages[0].diagrams[0],
+      [
+        ['a', 0, 0],
+        ['b', 1, 1],
+        ['x', 1, 0],
+      ],
+      [
+        ['e1', 'a', 'b', 'Save the draft', 'the form is valid'],
+        ['e2', 'a', 'b', 'Show the errors', 'the form is invalid'],
+        ['e3', 'x', 'b', 'Load the saved draft'],
+      ],
+    )
+
+    // Act
+    const boxes = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert
+    assert.deepEqual(
+      {
+        nodes: boxes.nodes.map(({ id }) => id).sort(),
+        labels: boxes.labels.map(({ id }) => id).sort(),
+        overlaps: overlappingBoxes(boxes),
+      },
+      { nodes: ['a', 'b', 'x'], labels: ['e1', 'e2', 'e3'], overlaps: [] },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=Cycle 0056 (found with the CodeRabbit finding above), two horizontal edges of one row between different node pairs with one midpoint; fails_when=the outer and the inner pair draw their labels in the same place above the row; no_claim=the connector lines, which cross the inner nodes as the author placed them; seam=one row of four nodes with an edge from the first to the fourth and one from the second to the third
+test('two edges of one row between different nodes with one midpoint stack their labels', async () => {
+  // Arrange
+  const root = await realpath(
+    await mkdtemp(join(tmpdir(), 'codebook-diagram-row-midpoint-')),
+  )
+  try {
+    const manifest = await diagramInput(root)
+    gridDiagram(
+      manifest.pages[0].diagrams[0],
+      [
+        ['a', 0, 0],
+        ['b', 0, 1],
+        ['c', 0, 2],
+        ['d', 0, 3],
+      ],
+      [
+        ['e1', 'a', 'd', 'Forward the receipt'],
+        ['e2', 'b', 'c', 'Count the items'],
+      ],
+    )
+
+    // Act
+    const boxes = diagramBoxes(await renderedDiagramHtml(root, manifest))
+
+    // Assert
+    assert.deepEqual(
+      {
+        nodes: boxes.nodes.map(({ id }) => id).sort(),
+        labels: boxes.labels.map(({ id }) => id).sort(),
+        overlaps: overlappingBoxes(boxes),
+      },
+      { nodes: ['a', 'b', 'c', 'd'], labels: ['e1', 'e2'], overlaps: [] },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
 test('wrapped diagram operations preserve word boundaries and an accessible condition label', async () => {
   // Arrange
   const root = await realpath(
diff --git a/extension/scripts/tests/workflowPins.test.mjs b/extension/scripts/tests/workflowPins.test.mjs
index 3fa5414ef..f48226064 100644
--- a/extension/scripts/tests/workflowPins.test.mjs
+++ b/extension/scripts/tests/workflowPins.test.mjs
@@ -900,6 +900,7 @@ test('the Windows job runs its test files on windows-latest, one at a time, and
     'extension/src/utils/judgeLeftEmpty.ts',
     'extension/src/utils/listFolderTreeWithoutFollowing.ts',
     'extension/src/utils/listPlacedClaims.ts',
+    'extension/src/utils/longestWikiRunMs.ts',
     'extension/src/utils/modifiedAtMsOf.ts',
     'extension/src/utils/namesMachineInClear.ts',
     'extension/src/utils/newStagedConfigPath.ts',
diff --git a/extension/skills/codebook/SKILL.md b/extension/skills/codebook/SKILL.md
index ae704fe86..3cbb373f3 100644
--- a/extension/skills/codebook/SKILL.md
+++ b/extension/skills/codebook/SKILL.md
@@ -2,7 +2,7 @@
 name: codebook
 description: Explain live code paths, save or replay learning, or generate and update a DeepWiki for the current editor workspace.
 metadata:
-  version: "1.0.49"
+  version: "1.0.50"
 ---
 
 # Codebook
diff --git a/extension/skills/codebook/render-wiki-diagrams.mjs b/extension/skills/codebook/render-wiki-diagrams.mjs
index 354d55611..55212b840 100644
--- a/extension/skills/codebook/render-wiki-diagrams.mjs
+++ b/extension/skills/codebook/render-wiki-diagrams.mjs
@@ -111,16 +111,27 @@ function edgeSvg(edge, prefix, path, labelX, labelY) {
 /** Renders grid positions and explicit connectors without inferring temporal order. @example flowSvg(diagram, 'diagram-auth') */
 function flowSvg(diagram, prefix) {
   const nodeHeight = Math.max(...diagram.nodes.map(node => wrap(node.label, 20).length)) * LAYOUT.lineHeight + LAYOUT.nodePadding * 2;
-  const horizontalGroups = new Map();
+  const labelGroups = new Map();
   const definitions = new Map(diagram.nodes.map(node => [node.id, node]));
-  for (const edge of diagram.edges) {
+  /** Names the gap between rows an edge's label sits in: above its row for a horizontal edge, the gap it leaves its source node through for a vertical one. */
+  const gapRowOf = edge => {
     const from = definitions.get(edge.from), to = definitions.get(edge.to);
-    if (from.id === to.id || from.row !== to.row) continue;
-    const key = [from.id, to.id].sort().join(':');
-    const group = horizontalGroups.get(key) ?? [];
-    group.push(edge); horizontalGroups.set(key, group);
+    if (from.row === to.row) return from.row - 1;
+    return to.row > from.row ? from.row : from.row - 1;
+  };
+  /** Names the label band an edge's label stacks in: every label with one midpoint (the column sum fixes it) in one gap between rows shares a band, horizontal and vertical edges alike, so labels of different edges never share a place. */
+  const labelBandOf = edge => `band:${definitions.get(edge.from).column + definitions.get(edge.to).column}:${gapRowOf(edge)}`;
+  // The bands a vertical edge crosses stack in the middle of their gap; a band of a row's horizontal edges alone keeps the row's reserved place above its nodes.
+  const crossedBands = new Set();
+  for (const edge of diagram.edges) {
+    // A self-loop has its own label place above its node.
+    if (edge.from === edge.to) continue;
+    const key = labelBandOf(edge);
+    const group = labelGroups.get(key) ?? [];
+    group.push(edge); labelGroups.set(key, group);
+    if (definitions.get(edge.from).row !== definitions.get(edge.to).row) crossedBands.add(key);
   }
-  const groupedHeight = [...horizontalGroups.values()].map(group => group.reduce((height, edge) => height + edgeLines(edge).length * LAYOUT.lineHeight, (group.length - 1) * LAYOUT.labelGap));
+  const groupedHeight = [...labelGroups.values()].map(group => group.reduce((height, edge) => height + edgeLines(edge).length * LAYOUT.lineHeight, (group.length - 1) * LAYOUT.labelGap));
   const labelHeight = Math.max(LAYOUT.lineHeight, ...diagram.edges.map(edge => edgeLines(edge).length * LAYOUT.lineHeight), ...groupedHeight);
   const rowStride = nodeHeight + labelHeight + LAYOUT.rowGap, columnStride = LAYOUT.nodeWidth + LAYOUT.columnGap;
   const positions = new Map(diagram.nodes.map(node => [node.id, { x: LAYOUT.margin + node.column * columnStride, y: LAYOUT.margin + labelHeight + node.row * rowStride, height: nodeHeight }]));
@@ -147,10 +158,12 @@ function flowSvg(diagram, prefix) {
     const midpointX = (startX + endX) / 2, midpointY = (startY + endY) / 2;
     const offsetX = horizontal ? 0 : lane, offsetY = horizontal ? lane : 0;
     const path = `M${startX} ${startY} C${midpointX + offsetX} ${startY + offsetY} ${midpointX + offsetX} ${endY + offsetY} ${endX} ${endY}`;
-    // Horizontal labels use the row's reserved band, clear of both nodes and their connector.
-    const group = horizontalGroups.get([edge.from, edge.to].sort().join(':')) ?? [edge];
+    // Horizontal labels use the row's reserved band, clear of both nodes and their connector; a vertical label stacks in the gap next to the node it leaves, so an edge across several rows never puts its label on a node between. A horizontal label whose midpoint a vertical edge also crosses in the gap above its row joins that stack.
+    const band = labelBandOf(edge);
+    const group = labelGroups.get(band) ?? [edge];
     const priorHeight = group.slice(0, group.indexOf(edge)).reduce((height, previous) => height + edgeLines(previous).length * LAYOUT.lineHeight + LAYOUT.labelGap, 0);
-    const labelY = horizontal ? from.y - labelHeight + LAYOUT.fontSize + priorHeight : midpointY + offsetY - labelHeight / 2;
+    const gapMiddleY = LAYOUT.margin + labelHeight + gapRowOf(edge) * rowStride + nodeHeight + (rowStride - nodeHeight) / 2;
+    const labelY = crossedBands.has(band) ? gapMiddleY - labelHeight / 2 + priorHeight : from.y - labelHeight + LAYOUT.fontSize + priorHeight;
     return edgeSvg(edge, prefix, path, midpointX + offsetX, labelY);
   }).join('');
   return { width, height, content: connectors + diagram.nodes.map(node => nodeSvg(node, positions.get(node.id))).join('') };
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index c88f1277c..a18b52baf 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.46'
+export const EXTENSION_VERSION = '0.2.47'
 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'
@@ -903,7 +903,7 @@ export const WIKI_UPDATE_LAST_RUN_STATE_KEY = 'codebook.wikiUpdateLastRun'
 /** What a VS Code Wiki update says when its output folder lies outside the opened project: in the confirmation and, handed to {@link describeWikiUpdate} as `outsideOutputApprovalsNote`, the running line of the page. The watch's status bar entry does not carry it ({@link WIKI_CHAT_WATCH_TOOLTIP}). */
 export const WIKI_OUTSIDE_OUTPUT_APPROVALS_NOTE =
   'This Wiki’s output lies outside the project, so the chat will ask to approve each step there; an output inside the project (codebook.wikiOutputDirectory) needs none.'
-/** What a learner does after they refused a step VS Code's chat asked them to approve, as a clause without its full stop: once the chat has asked, Codebook does not see it stop, so the watch goes on until Cancel. Handed to {@link describeWikiUpdate} as `refusedStepAdvice`, the running line of the page goes on from it with where Cancel is, the watch's status bar entry ({@link WIKI_CHAT_WATCH_STATUS_TEXT}), which names only its Cancel. */
+/** What a learner does after they refused a step VS Code's chat asked them to approve, as a clause without its full stop: once the chat has asked, Codebook does not see it stop, so the watch goes on until Stop watching. Handed to {@link describeWikiUpdate} as `refusedStepAdvice`, the running line of the page goes on from it with where Stop watching is, the watch's status bar entry ({@link WIKI_CHAT_WATCH_STATUS_TEXT}), which names only its Stop watching. */
 export const WIKI_REFUSED_STEP_ADVICE =
   'If you refuse a step of the chat, press Stop watching'
 /** The text of the status bar entry that is shown for as long as Codebook watches a VS Code Wiki generation or update, for every entry of the run: a spinning icon, what is watched and its Stop watching (Cycle 0055 D4: it stops the watch, not the chat, so it is not called Cancel), which a press on the entry runs ({@link WIKI_CHAT_WATCH_CANCEL_COMMAND}). The watch shows no notification: the editor stacks notifications at the window's lower right, over the Chat view in its default place, so any other notification pushes one that lasts the whole watch over the Allow and Skip buttons of an approval the chat asks for (measured in VS Code 1.140.0 with a notification of two lines and the editor's own recommendation below it). The status bar lies below every notification. */
@@ -931,6 +931,29 @@ export const WIKI_RUN_STARTING_SENTENCE =
 export const WIKI_UPDATE_WATCH_TIMEOUT_MS = 900_000
 /** Longest a Wiki generation runs in either host, the VS Code watch and the Cursor agent alike, before it ends as timed out: 55 minutes, set by Cycle 0055's E1 (the longest measured generation, 34 min 33 s in VS Code, × 1.5, rounded up to whole 5 minutes; Owner decision O9). A stopped VS Code generation's reservation lasts as long after its watch's end. */
 export const WIKI_GENERATE_TIMEOUT_MS = 3_300_000
+/** Longest the managed Cursor skill's verify and deploy may take while a start holds its marker: 30 seconds, after which the start ends without an agent and leaves the marker (removed, or a taken-over reservation written back) (Cycle 0056 task 13). */
+export const WIKI_SKILL_STEP_TIMEOUT_MS = 30_000
+/** The abort reason of a Cursor skill step the learner ended (Stop LLM Wiki Run) or the closing window ended; {@link describeWikiSkillStepEnd} words it. */
+export const WIKI_SKILL_STEP_STOPPED_REASON = 'stopped'
+/** The abort reason of a Cursor skill step that passed {@link WIKI_SKILL_STEP_TIMEOUT_MS}. */
+export const WIKI_SKILL_STEP_BOUND_REASON = 'bound'
+/** How a start's own bound ended it while it still waited for an earlier skill step of this window that never settled; not an abort reason (the abort says `bound`), {@link describeWikiSkillStepEnd} words it. */
+export const WIKI_SKILL_STEP_EARLIER_RUNNING_END = 'earlier-step-running'
+/** What {@link WIKI_SKILL_STEP_EARLIER_RUNNING_END} says happened and what ends it, without the next press; {@link describeWikiSkillStepEnd} adds `, then press <Generate|Update> LLM Wiki again.` (Cycle 0056 RT-B). */
+export const WIKI_SKILL_STEP_EARLIER_RUNNING_SENTENCE =
+  'Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it'
+/** How a start ended when its Cursor skill step began while Remove Managed Cursor Skill was under way in this window, so it neither verifies nor deploys the skill the removal takes away; not an abort reason, {@link describeWikiSkillStepEnd} words it (Cycle 0056 pass 3). */
+export const WIKI_SKILL_STEP_REMOVAL_END = 'skill-removal'
+/** What Codebook says when Remove Managed Cursor Skill meets a Cursor skill step of this window that is still running after the grace, so a late deploy could write the skill again; nothing is removed (Cycle 0056 RT3-C). */
+export const WIKI_SKILL_REMOVAL_STEP_RUNNING_SENTENCE =
+  'Codebook did not remove the managed Cursor skill: a Cursor skill step of this window is still running and could write the skill again. Reload the window (Developer: Reload Window) to end it, then run Codebook: Remove Managed Cursor Skill again.'
+/** The longest any run of any kind and host can last ({@link longestWikiRunMs}): a VS Code generation's chat opening plus its bound. A marker file whose kind cannot be read counts this long, never the update's shorter bound. Written from the raw bounds here because the helpers that name each bound read this module; `wikiRunBoundMs.test.ts` pins it against {@link longestWikiRunMs} over every kind and host, so a changed bound that this list misses fails there. */
+export const LONGEST_WIKI_RUN_MS = Math.max(
+  WIKI_GENERATE_TIMEOUT_MS,
+  WIKI_CHAT_OPEN_TIMEOUT_MS + WIKI_GENERATE_TIMEOUT_MS,
+  WIKI_CURSOR_UPDATE_TIMEOUT_MS,
+  WIKI_CHAT_OPEN_TIMEOUT_MS + WIKI_UPDATE_WATCH_TIMEOUT_MS,
+)
 /** The chat request a learner can paste to generate the LLM Wiki without Codebook's entry; every generate sentence that sends the learner to the chat names it. */
 export const WIKI_GENERATE_CHAT_REQUEST =
   '/codebook Generate the LLM Wiki for this project'
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index dc3d8f604..9bec21543 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -9,6 +9,7 @@ import {
   writeFile,
 } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
+import { setTimeout as delay } from 'node:timers/promises'
 import { URLSearchParams } from 'node:url'
 
 import * as vscode from 'vscode'
@@ -44,9 +45,15 @@ import {
   WIKI_MANIFEST_FILE,
   WIKI_OUTSIDE_OUTPUT_APPROVALS_NOTE,
   WIKI_RUN_STARTING_SENTENCE,
+  WIKI_SKILL_REMOVAL_STEP_RUNNING_SENTENCE,
+  WIKI_SKILL_STEP_BOUND_REASON,
+  WIKI_SKILL_STEP_REMOVAL_END,
+  WIKI_SKILL_STEP_STOPPED_REASON,
+  WIKI_SKILL_STEP_TIMEOUT_MS,
   WIKI_UPDATE_LAST_RUN_STATE_KEY,
   WIKI_UPDATE_MARKER_CHANGE_RETRIES,
   WIKI_UPDATE_MARKER_CHANGE_RETRY_DELAY_MS,
+  WIKI_UPDATE_MARKER_CLAIM_RETRY_DELAY_MS,
   WIKI_UPDATE_UNREADABLE_MANIFEST_GRACE_MS,
   WIKI_UPDATE_WATCH_POLL_MS,
   WIKI_UPDATE_WATCH_TIMEOUT_MS,
@@ -72,6 +79,7 @@ import { repositoryActionSchema } from './repositoryView'
 import { startServer } from './server'
 import { StudyService } from './service'
 import { StudyWorkspace, type UnsavedStudyArchive } from './studyWorkspace'
+import { agentExitOf, type WikiAgentExit } from './utils/agentExitOf'
 import { aiChatReadyMessage } from './utils/aiChatReadyMessage'
 import {
   answerDeepWikiQuestion,
@@ -80,7 +88,10 @@ import {
 import { assertNoLinkOnWikiPath } from './utils/assertNoLinkOnWikiPath'
 import { buildWikiGeneratePrompt } from './utils/buildWikiGeneratePrompt'
 import { buildWikiUpdatePrompt } from './utils/buildWikiUpdatePrompt'
-import { claimWikiUpdateMarker } from './utils/claimWikiUpdateMarker'
+import {
+  claimWikiUpdateMarker,
+  type TakenOverWikiReservation,
+} from './utils/claimWikiUpdateMarker'
 import {
   classifyWikiUpdateEnd,
   type WikiUpdateEndFacts,
@@ -96,6 +107,9 @@ import {
 import { cursorRemovalNotice } from './utils/cursorRemovalNotice'
 import { deepWikiOpenFailureNotice } from './utils/deepWikiOpenFailureNotice'
 import { describeBrokenWikiWatch } from './utils/describeBrokenWikiWatch'
+import { describeExistingWiki } from './utils/describeExistingWiki'
+import { describeJoinedWikiStart } from './utils/describeJoinedWikiStart'
+import { describeMissingWiki } from './utils/describeMissingWiki'
 import { describeOtherWikiWindow } from './utils/describeOtherWikiWindow'
 import {
   describeSecondWikiUpdateStart,
@@ -103,6 +117,7 @@ import {
 } from './utils/describeSecondWikiUpdateStart'
 import { describeWikiChatHandOver } from './utils/describeWikiChatHandOver'
 import { describeWikiGenerateConfirmation } from './utils/describeWikiGenerateConfirmation'
+import { describeWikiSkillStepEnd } from './utils/describeWikiSkillStepEnd'
 import { detectWikiPublishConflicts } from './utils/detectWikiPublishConflicts'
 import { endOfWikiChatStart } from './utils/endOfWikiChatStart'
 import { failureOfWikiChatReplyEnd } from './utils/failureOfWikiChatReplyEnd'
@@ -115,6 +130,7 @@ import {
   type FolderChangeCleanupFailure,
   type FolderChangeCleanupStep,
 } from './utils/folderChangeCleanupNotice'
+import { formatClockTime } from './utils/formatClockTime'
 import {
   formatCodebookDiagnostic,
   type CodebookDiagnostic,
@@ -146,6 +162,7 @@ import { resolveDeepWikiDirectory } from './utils/resolveDeepWikiDirectory'
 import { resolveDeepWikiSource } from './utils/resolveDeepWikiSource'
 import { resolveExternalNodeExecutable } from './utils/resolveExternalNodeExecutable'
 import { runCursorWikiUpdate } from './utils/runCursorWikiUpdate'
+import { runUnderAbortSignal } from './utils/runUnderAbortSignal'
 import {
   wikiLastRunSchema,
   type WikiLastRun,
@@ -159,8 +176,8 @@ import {
   type WikiChatStart,
 } from './utils/startWikiChatUpdate'
 import {
-  describeMissingWiki,
   startWikiGenerate,
+  type ClaimedWikiRunMarker,
   type WikiRunInTheWay,
 } from './utils/startWikiRun'
 import { thrownMessage } from './utils/thrownMessage'
@@ -171,11 +188,8 @@ import { wikiGenerateNotice } from './utils/wikiGenerateNotice'
 import { wikiManifestIdentity } from './utils/wikiManifestIdentity'
 import { wikiOutputLabel } from './utils/wikiOutputLabel'
 import { wikiRunBoundMs } from './utils/wikiRunBoundMs'
-import {
-  agentExitOf,
-  wikiRunRecord,
-  type WikiAgentExit,
-} from './utils/wikiRunRecord'
+import { wikiRunRecord } from './utils/wikiRunRecord'
+import { wikiSkillStepEndOf } from './utils/wikiSkillStepEndOf'
 import { OPEN_WIKI_ACTION, wikiUpdateNotice } from './utils/wikiUpdateNotice'
 import {
   WikiUpdateRun,
@@ -286,7 +300,30 @@ export function activate(
   /** How often the server was asked to stop from outside the handling of changed folders: by Stop Agent Server and by the closing window ({@link stopOnRequest}). A start that waited for that handling reads it before and after its wait. */
   let stopsAskedFor = 0
   let deepWikiReader: DeepWikiReader | undefined
-  let wikiUpdate: Promise<void> | undefined
+  /** The start of a Wiki run that is under way in this window, with its kind so that a press that joins it names it, and which of the two joined sentences ({@link describeJoinedWikiStart}) it has shown already: each once per running attempt. */
+  let wikiStart:
+    | {
+        attempt: Promise<void>
+        kind: WikiRunKind
+        shownJoinedNotices: Set<'plain' | 'choice'>
+      }
+    | undefined
+  /** The abort of the managed Cursor skill step a start is in, which Stop LLM Wiki Run and the step's bound end, with the moment the learner (or the closing window) stopped it; none outside that step. */
+  let wikiSkillStepStop:
+    { controller: AbortController; stoppedAtMs?: number } | undefined
+  // The latest Cursor skill step (verify and deploy) while it has not settled, also after a Stop or the bound ended the wait for it: a new step waits for it, so two deploys never write the managed skill at once (Cycle 0056 L3).
+  let wikiSkillStepInFlight: Promise<void> | undefined
+  /**
+   * Ends the Cursor skill step a start is in, and stamps the moment, so the sentence of the end names when the learner pressed Stop and not when the rejection was handled (Cycle 0056 A3); called by {@link cancelWikiRun}, by {@link stopExtension} and by the removal of the managed skill.
+   * @param step - The step's abort and stamp.
+   * @example stopWikiSkillStep(wikiSkillStepStop)
+   */
+  const stopWikiSkillStep = (
+    step: NonNullable<typeof wikiSkillStepStop>,
+  ): void => {
+    step.stoppedAtMs ??= Date.now()
+    step.controller.abort(WIKI_SKILL_STEP_STOPPED_REASON)
+  }
   // One update run per window, shared by the command, the `/update` link and the browser button.
   const wikiUpdateRun = new WikiUpdateRun()
   // The active run of either host: its one abort, and a promise that settles once its watch or its agent has stopped. `awaitsChat` marks a VS Code update that still waits for the chat's first sign, whose watch is not shown yet.
@@ -309,15 +346,24 @@ export function activate(
   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.
-  const wikiReservations = new Map<
-    string,
-    { release: () => Promise<boolean>; timer: NodeJS.Timeout }
-  >()
+  /** One reservation this window keeps on disk for a Wiki output: how to remove it, the timer that removes it at its bound, and what a start that takes it over writes back if it is refused. */
+  type WikiReservationEntry = {
+    release: () => Promise<boolean>
+    timer: NodeJS.Timeout
+    /** When that watch ended and the kind of its run. */
+    watchEndedAtMs: number
+    runKind: WikiRunKind
+    /** Whether this window wrote back another window's marker after a refused start: that marker is the original owner's, whose chat may still publish, so this window's shutdown leaves it on disk. A later start reads that owner's marker from the disk, never from this entry ({@link claimWikiRunMarker}). Absent for this window's own reservation. */
+    isWrittenBack?: boolean
+  }
+  // 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; also one written back for another window's stopped watch ({@link WikiReservationEntry.isWrittenBack}).
+  const wikiReservations = new Map<string, WikiReservationEntry>()
   // The latest change of this window's own marker on each Wiki output (its removal, or its turn into a stopped watch's reservation), while it runs (`running`) or waits for its next attempt, with the timer of that attempt.
   const wikiMarkerChanges = new Map<string, WikiMarkerChangeEntry>()
   // How many attempts of this window's own marker changes have ended on each Wiki output; a start whose claim met the marker in change compares it ({@link claimWikiMarkerForStart}).
   const endedWikiMarkerChanges = new Map<string, number>()
+  // Who hears that an attempt to change this window's own marker ended: the LLM Wiki view, which reads the marker's rows again then, because the run's end told it before the marker was changed and a missing file watcher reports no change of the marker.
+  const wikiMarkerChangeListeners = new Set<() => void>()
   /**
    * Makes a change of this window's own marker beside a Wiki (its removal, or its turn into a stopped watch's reservation), and while the change cannot be made asks for it again later; called by {@link settleWikiRunMarker} at a run's end and by {@link dropWikiReservation} at a reservation's bound or at shutdown.
    * Why: the change runs under the claim on the marker, which another window can hold longer than the change waits (a killed window of another machine leaves its claim for {@link WIKI_UPDATE_MARKER_CLAIM_EXPIRY_MS}), and the system can refuse the claim, the read of the marker under it (on Windows a scanner or an indexer can hold the file) or the change. A run's marker left as it stands counts for every other window as a running update, with no Update anyway, until the run's bound has passed. A later change of the same output, and a start that takes the marker over, replace a change that waits: they name what the marker must be now.
@@ -344,9 +390,19 @@ export function activate(
     )
     // A later change of this output, or a start that took its marker over, replaced this one meanwhile.
     if (wikiMarkerChanges.get(outputDirectory) !== pending) return
-    // A closing window keeps no timer: its shutdown makes the waiting changes once more.
-    if (isChanged || retriesLeft === 0 || isExtensionStopping) {
+    // A closing window keeps no timer, but a change that was not made stays registered: its shutdown asks for it again within the grace ({@link retryWikiMarkerChangesNow}), so a write-back that failed at the close is not lost.
+    if (!isChanged && retriesLeft > 0 && isExtensionStopping) return
+    if (isChanged || retriesLeft === 0) {
       wikiMarkerChanges.delete(outputDirectory)
+      // The change has settled, so the listeners read the marker once, after the counter a start compares counted this attempt.
+      for (const listener of [...wikiMarkerChangeListeners]) {
+        // A broken listener must not fail the change or hide it from the others.
+        try {
+          listener()
+        } catch {
+          // The listener's owner has nowhere to be told here.
+        }
+      }
       return
     }
     pending.timer = setTimeout(() => {
@@ -358,16 +414,21 @@ export function activate(
     clearTimeout(wikiMarkerChanges.get(outputDirectory)?.timer)
     wikiMarkerChanges.delete(outputDirectory)
   }
-  /** Makes every change of this window's markers that waits for its next attempt once more, now; called by {@link stopExtension} at shutdown, since a closing window keeps no timer and such a marker would otherwise count for other windows until it expires. A change that is running at that moment is not made twice. @example await retryWikiMarkerChangesNow() */
+  /** Makes every change of this window's markers that waits for its next attempt once more, now, and again until it is made or {@link WIKI_CURSOR_TERMINATION_GRACE_MS} has passed; called by {@link stopExtension} at shutdown, since a closing window keeps no timer and such a marker would otherwise count for other windows until it expires. The waiting changes are those with a timer and those that failed while the window was closing (no timer). A change that is running at that moment is not made twice. @example await retryWikiMarkerChangesNow() */
   const retryWikiMarkerChangesNow = async (): Promise<void> => {
     const waiting = [...wikiMarkerChanges.entries()].filter(
-      ([, pending]) => pending.timer !== undefined,
+      ([, pending]) => pending.running === undefined,
     )
+    const deadlineMs = Date.now() + WIKI_CURSOR_TERMINATION_GRACE_MS
     await Promise.all(
-      waiting.map(([outputDirectory, pending]) => {
+      waiting.map(async ([outputDirectory, pending]) => {
         clearTimeout(pending.timer)
         wikiMarkerChanges.delete(outputDirectory)
-        return pending.change().catch(() => false)
+        // The claim on the marker may be another window's for a moment; the change is asked for until the grace is over.
+        while (!(await pending.change().catch(() => false))) {
+          if (Date.now() >= deadlineMs) return
+          await delay(WIKI_UPDATE_MARKER_CLAIM_RETRY_DELAY_MS)
+        }
       }),
     )
   }
@@ -394,6 +455,8 @@ export function activate(
     wikiReservations.delete(outputDirectory)
     if (!reservation) return
     clearTimeout(reservation.timer)
+    // Another window's stopped watch that this window wrote back stays on disk at this window's close: its chat may still publish, and only this window's own reservations are dropped here. Its bound removes it for the windows that read it.
+    if (isWindowClosing && reservation.isWrittenBack) return
     // The disk marker is the reload's only protection when its stopped-watch record is not in storage.
     if (
       await doesReloadNeedWikiReservation(
@@ -439,7 +502,7 @@ export function activate(
     /** Removes this run's marker beside the Wiki, so another window may start; `false` while the claim on the marker could not be had and the marker stayed. */
     releaseMarker: () => Promise<boolean>
     /** Leaves the marker as the reservation of a watch that was stopped while its chat may still work, for other windows to read; `false` while the claim on the marker could not be had and the run's marker stayed. */
-    reserveMarker: (watchEndedAtMs: number) => Promise<boolean>
+    reserveMarker: ClaimedWikiRunMarker['reserve']
     startedAtMs: number
     /** Folder names of the candidates the run's looks saw that were written since its start; a stopped VS Code watch keeps them for the next start, which tells the chat's own publish by them ({@link hasWikiPublishEndedWait}). */
     seenCandidateNames: Set<string>
@@ -964,7 +1027,7 @@ export function activate(
     )
   }
   /**
-   * Shuts the extension down when the window closes: stops the agent server, disposes both readers, waits for a Wiki update it stopped, settles the Wiki reservations, makes once more each change of its Wiki markers that waits for its next attempt, and closes the DeepWiki reader; called by {@link deactivate}. A stopped watch whose record the workspace state does not hold keeps its bounded reservation for the reloaded window.
+   * Shuts the extension down when the window closes: stops the agent server, disposes both readers, waits for a Wiki update it stopped and for a start it ended in the Cursor skill step, settles the Wiki reservations, makes once more each change of its Wiki markers that waits for its next attempt, and closes the DeepWiki reader; called by {@link deactivate}. A stopped watch whose record the workspace state does not hold keeps its bounded reservation for the reloaded window.
    * Every step runs whatever the step before it did. A stop that threw used to end the first three steps, so the Repository Wiki reader's dispose, which waits for accepted publications and learner writes, and the Study reader's dispose, which ends its run and saves the playback position, did not run, and a write under way was not waited for before the extension host ended.
    * It is kept apart from {@link replaceReadersAfterFolderChange}: the two share only "stop, then dispose two readers", and that handling also hands archives over, clears the readers' variables, makes new readers and names each failed step for its notice, none of which a closing window may do.
    * @throws The first failure of its steps, after all of them ran, so that the editor still logs it.
@@ -975,6 +1038,9 @@ export function activate(
     // A closing window must not leave a watch or an unattended agent behind.
     const stoppedWikiRun = activeWikiRun
     stoppedWikiRun?.controller.abort(WIKI_UPDATE_WINDOW_CLOSING_ABORT_REASON)
+    // A start in the Cursor skill step has claimed the marker and has no run to abort: ending the step makes it leave the marker (removed, or a taken-over reservation written back), which is waited for below so that the reservation is registered before the reservations are dropped.
+    const startInSkillStep = wikiSkillStepStop ? wikiStart?.attempt : undefined
+    if (wikiSkillStepStop) stopWikiSkillStep(wikiSkillStepStop)
     const failures: unknown[] = []
     for (const step of [
       // Owned runtimes are released first; an in-flight or failing browser reader close cannot strand them.
@@ -990,6 +1056,13 @@ export function activate(
           stoppedWikiRun.settled.catch(() => undefined),
           WIKI_CURSOR_TERMINATION_GRACE_MS,
         ),
+      // The refused start's cleanup gets the same short grace; a start that does not leave in time is left to its marker's own bound.
+      (): Promise<unknown> | undefined =>
+        startInSkillStep &&
+        settledWithin(
+          startInSkillStep.catch(() => undefined),
+          WIKI_CURSOR_TERMINATION_GRACE_MS,
+        ),
       (): Promise<void> => dropWikiReservations(),
       // A marker whose change waits for its next attempt would otherwise count for other windows until it expires.
       (): Promise<void> => retryWikiMarkerChangesNow(),
@@ -1362,6 +1435,37 @@ export function activate(
           run.outputLabel,
         )
       : undefined
+  /**
+   * Registers this window's reservation of a Wiki output, so that its bound removes it, the window's shutdown drops it and a start that takes it over finds what to write back; called by {@link settleWikiRunMarker} for a stopped watch's reservation and by {@link leaveWikiMarkerOfRefusedStart} for one written back.
+   * Why: a reservation without its entry is not removed at its bound, not dropped at shutdown and not seen by the next start of this window, which would release it and lose the protection of the chat that may still publish (Cycle 0056 M1).
+   * @param outputDirectory - The Wiki output the reservation protects; the reservation of this output only is replaced, one this window left on another output keeps its own timer.
+   * @param reservation - How to remove the marker, when that watch ended, the kind of its run and whether it is another window's marker written back.
+   * @example registerWikiReservation('/repo/.codebook/wiki', { release, watchEndedAtMs: 1_790_000_900_000, runKind: 'generate' })
+   */
+  const registerWikiReservation = (
+    outputDirectory: string,
+    reservation: Omit<WikiReservationEntry, 'timer'>,
+  ): void => {
+    clearTimeout(wikiReservations.get(outputDirectory)?.timer)
+    // A reservation lasts the bound of its run's kind from the end of its watch, the one every reader of the marker uses ({@link wikiRunBoundMs}); only a VS Code watch leaves one. The bounds this module reads itself are passed, so a host test that shortens one reaches the timer.
+    const remainingMs =
+      reservation.watchEndedAtMs +
+      wikiRunBoundMs(reservation.runKind, 'vscode', {
+        generateMs: WIKI_GENERATE_TIMEOUT_MS,
+        cursorUpdateMs: WIKI_CURSOR_UPDATE_TIMEOUT_MS,
+        watchedUpdateMs: WIKI_UPDATE_WATCH_TIMEOUT_MS,
+      }) -
+      Date.now()
+    wikiReservations.set(outputDirectory, {
+      ...reservation,
+      timer: setTimeout(
+        () => {
+          void dropWikiReservation(outputDirectory)
+        },
+        Math.max(0, remainingMs),
+      ).unref(),
+    })
+  }
   /** Frees the Wiki for other windows at a run's end, or leaves the run's marker as the reservation of a chat that may still work; called by {@link finishWikiUpdate} last. It never rejects: a change of the marker that cannot be made now is asked for again later ({@link changeWikiMarker}), and one that still cannot be made is left to the marker's own expiry. @param endedAtMs - When the run ended, which the reservation names as the end of the watch. @param mayAgentStillWork - Whether the run's chat can still publish ({@link mayWikiChatStillPublish}). @example await settleWikiRunMarker(run, Date.now(), false) */
   const settleWikiRunMarker = async (
     run: WikiRun,
@@ -1376,21 +1480,10 @@ export function activate(
     await changeWikiMarker(run.outputDirectory, () =>
       run.reserveMarker(endedAtMs),
     )
-    // The reservation of this output only; one this window left on another output keeps its own timer.
-    clearTimeout(wikiReservations.get(run.outputDirectory)?.timer)
-    wikiReservations.set(run.outputDirectory, {
+    registerWikiReservation(run.outputDirectory, {
       release: run.releaseMarker,
-      // A reservation lasts the bound of its run's kind, the one every reader of the marker uses ({@link wikiRunBoundMs}); only a VS Code watch leaves one. The bounds this module reads itself are passed, so a host test that shortens one reaches the timer.
-      timer: setTimeout(
-        () => {
-          void dropWikiReservation(run.outputDirectory)
-        },
-        wikiRunBoundMs(run.kind, 'vscode', {
-          generateMs: WIKI_GENERATE_TIMEOUT_MS,
-          cursorUpdateMs: WIKI_CURSOR_UPDATE_TIMEOUT_MS,
-          watchedUpdateMs: WIKI_UPDATE_WATCH_TIMEOUT_MS,
-        }),
-      ).unref(),
+      watchEndedAtMs: endedAtMs,
+      runKind: run.kind,
     })
   }
   /** Records how a run of either host ended: lets {@link readWikiUpdateEnd} decide from the disk, stores its answer for the reader, frees the Wiki for other windows and keeps how the run ended for this window's next start. It never rejects: a run whose end cannot be read from the disk is recorded as failed without a word about the site ({@link unreadWikiUpdateEnd}), so no window stays "already updating", and a notice that cannot be shown does not keep the run's marker in place. @example await finishWikiUpdate(run, { cancelled: true }) */
@@ -1627,15 +1720,12 @@ export function activate(
   /** What the start checks of an update hand to the run they let begin. */
   type WikiUpdateStart = Pick<
     WikiRun,
-    | 'tokenAtStart'
-    | 'publicationAtStart'
-    | 'uncoveredAtStart'
-    | 'releaseMarker'
-    | 'reserveMarker'
-    | 'startedAtMs'
+    'tokenAtStart' | 'publicationAtStart' | 'uncoveredAtStart' | 'startedAtMs'
   > & {
     /** Whether the opened folder is inside a Git repository; the request names only the conditions that can hold in it. */
     hasGitRepository: boolean
+    /** The start's claimed marker, with the reservation its claim took over, which a refused start writes back as it was. */
+    claim: ClaimedWikiRunMarker
   }
   /**
    * Records a refused start of a Wiki update in a sentence Codebook wrote and tells the learner; called by {@link lookAtWikiStart} and {@link checkWikiUpdateStart} for each refusal they word themselves.
@@ -1677,7 +1767,7 @@ export function activate(
     // The refused attempt may still be unwinding when the button is pressed; the override is a start of its own, after it.
     Promise.resolve(attemptToAwaitBeforeOverride(refusedAttempt))
       .catch(() => undefined)
-      .then(() => updateDeepWiki(leftovers))
+      .then(() => updateDeepWiki(leftovers, true))
       .catch((error: unknown) => {
         void showNotice(
           'error',
@@ -1800,7 +1890,7 @@ export function activate(
     ) => void,
   ): Promise<WikiRunInTheWay | undefined> => {
     // The start this look belongs to, which its override waits for, and only for it.
-    const refusedAttempt = wikiUpdate
+    const refusedAttempt = wikiStart?.attempt
     const markerLook = await readLiveWikiUpdateMarker(
       outputDirectory,
       wikiWindowId,
@@ -1843,16 +1933,22 @@ export function activate(
    * @param host - The editor host that runs it.
    * @param runKind - The run's kind; a generation's marker records it, so every window reads its bounds ({@link wikiRunBoundMs}).
    * @param startedAtMs - When the run starts.
-   * @returns The claim's release and reservation, or the marker of another window that holds it.
+   * @returns The claim's release and reservation, with `takenOver` when the claim took a stopped watch's reservation over (so a start that is then refused writes it back as it was, {@link leaveWikiMarkerOfRefusedStart}); or the marker of another window that holds it.
    * @throws What {@link claimWikiUpdateMarker} throws.
-   * @example await claimWikiRunMarker('/repo/.codebook/wiki', 'vscode', 'generate', Date.now()) // => { release, reserve }
+   * @example await claimWikiRunMarker('/repo/.codebook/wiki', 'vscode', 'generate', Date.now()) // => { release, reserve, takenOver }
    */
   const claimWikiRunMarker = async (
     outputDirectory: string,
     host: WikiUpdateHost,
     runKind: WikiRunKind,
     startedAtMs: number,
-  ): ReturnType<typeof claimWikiMarkerForStart> => {
+  ): Promise<
+    | Extract<
+        Awaited<ReturnType<typeof claimWikiMarkerForStart>>,
+        { heldBy: unknown }
+      >
+    | ClaimedWikiRunMarker
+  > => {
     const claim = await claimWikiMarkerForStart(outputDirectory, {
       pid: process.pid,
       windowId: wikiWindowId,
@@ -1863,11 +1959,49 @@ export function activate(
     })
     if ('heldBy' in claim) return claim
     // This window's own reservation of this output, if it left one, is now this run's marker; its timer must not remove it. A reservation of another output shares no marker with this run and keeps its timer.
-    clearTimeout(wikiReservations.get(outputDirectory)?.timer)
+    const ownReservation = wikiReservations.get(outputDirectory)
+    clearTimeout(ownReservation?.timer)
     wikiReservations.delete(outputDirectory)
     // A change of an earlier run's marker that waits for its next attempt has nothing left to change: this run holds the marker now.
     cancelWikiMarkerChange(outputDirectory)
-    return claim
+    // What the claim removed under its own claim on the marker (another window's reservation, with its exact text), or else this window's own reservation, which reads as nobody's run to its own look. A reservation this window wrote back for another window is never restored from this window's memory: its owner may have removed it since, and only a claim that read it on the disk takes it over again.
+    const takenOver: TakenOverWikiReservation | undefined =
+      claim.replacedReservation ??
+      (ownReservation && !ownReservation.isWrittenBack
+        ? {
+            watchEndedAtMs: ownReservation.watchEndedAtMs,
+            runKind: ownReservation.runKind,
+          }
+        : undefined)
+    return { ...claim, takenOver }
+  }
+  /**
+   * Leaves the marker of a start that was refused after its claim: it is removed, or, when the claim took a stopped watch's reservation over, written back as that marker was (its owner, the watch's end and its run's kind) and registered as this window's reservation again ({@link registerWikiReservation}); the change is retried like every change of the marker ({@link changeWikiMarker}).
+   * @param outputDirectory - The Wiki output the start claimed.
+   * @param claim - The start's claimed marker.
+   * @example await leaveWikiMarkerOfRefusedStart('/repo/.codebook/wiki', start.claim)
+   */
+  const leaveWikiMarkerOfRefusedStart = async (
+    outputDirectory: string,
+    claim: ClaimedWikiRunMarker,
+  ): Promise<void> => {
+    const { takenOver } = claim
+    if (takenOver === undefined) {
+      await changeWikiMarker(outputDirectory, claim.release)
+      return
+    }
+    // The reservation keeps its end, its run's kind and its owner, so its bound is the one it had.
+    await changeWikiMarker(outputDirectory, () =>
+      claim.reserve(takenOver.watchEndedAtMs, takenOver),
+    )
+    // Written back or still waiting for a retry, it is this window's reservation again: its bound removes it and a second start finds it.
+    registerWikiReservation(outputDirectory, {
+      release: claim.release,
+      watchEndedAtMs: takenOver.watchEndedAtMs,
+      runKind: takenOver.runKind,
+      // Another window's marker was read from the disk under the claim; this window's own reservation names none.
+      isWrittenBack: takenOver.replacedMarker !== undefined,
+    })
   }
   /**
    * Makes the checks of a start once, for one generation of the Wiki: those of the Wiki folder ({@link inspectWikiToUpdate}), another window's marker, an earlier chat's leftover ({@link findUnacknowledgedWikiLeftover}), and last the claim of the marker; called by {@link checkWikiUpdateStart}, a second time when a publish landed while the first look ran.
@@ -1932,8 +2066,7 @@ export function activate(
       publicationAtStart,
       uncoveredAtStart: before?.freshness.addedPaths ?? [],
       hasGitRepository: !before?.freshness.addedFilesUnchecked,
-      releaseMarker: claim.release,
-      reserveMarker: claim.reserve,
+      claim,
       startedAtMs,
     }
   }
@@ -2083,18 +2216,33 @@ export function activate(
   }
   /**
    * Runs one start of a Wiki run, generation or update, unless one is under way in this window, coalescing repeated presses; called by {@link updateDeepWiki} and {@link generateDeepWiki}.
+   * @param kind - The kind of this start, which a press that joins it is told ({@link describeJoinedWikiStart}).
    * @param startRun - The run's start: its checks and, when they pass, its launch ({@link launchWikiRun}).
+   * @param isChoiceCarried - Whether this press carries the learner's choice ("Update anyway", "Generate anyway", the offer's "Update"), which a start it joins does not apply; the joined press is told so ({@link describeJoinedWikiStart}).
    * @returns The start under way when a press arrives during one (in Cursor the first call lasts the whole run); otherwise once this start settled.
    * @throws What the start threw.
-   * @example await runWikiAttempt(async () => { … })
+   * @example await runWikiAttempt('update', async () => { … })
    */
   const runWikiAttempt = async (
+    kind: WikiRunKind,
     startRun: () => Promise<void>,
+    isChoiceCarried = false,
   ): Promise<void> => {
-    if (wikiUpdate) {
+    if (wikiStart) {
       // In Cursor the first call lasts the whole run, so a second command arrives here and must be told, as one from the browser link is.
       if (wikiUpdateRun.isRunning()) showWikiUpdateRunning()
-      return wikiUpdate
+      else {
+        // A start that has not begun its run yet: the press joins it, and says so once per kind of sentence for this attempt; a press with a choice is told its choice was not applied.
+        const joinedNotice = isChoiceCarried ? 'choice' : 'plain'
+        if (!wikiStart.shownJoinedNotices.has(joinedNotice)) {
+          wikiStart.shownJoinedNotices.add(joinedNotice)
+          void showNotice(
+            'information',
+            describeJoinedWikiStart(wikiStart.kind, isChoiceCarried),
+          )
+        }
+      }
+      return wikiStart.attempt
     }
     const attempt = (async () => {
       // A run that outlives this call (the VS Code watch) still blocks a second start from any entry.
@@ -2104,11 +2252,16 @@ export function activate(
       }
       await startRun()
     })()
-    wikiUpdate = attempt
+    const ownStart = {
+      attempt,
+      kind,
+      shownJoinedNotices: new Set<'plain' | 'choice'>(),
+    }
+    wikiStart = ownStart
     try {
       await attempt
     } finally {
-      if (wikiUpdate === attempt) wikiUpdate = undefined
+      if (wikiStart === ownStart) wikiStart = undefined
     }
   }
   /**
@@ -2122,13 +2275,8 @@ export function activate(
     host: WikiUpdateHost,
     start: Pick<
       WikiRun,
-      | 'tokenAtStart'
-      | 'publicationAtStart'
-      | 'uncoveredAtStart'
-      | 'releaseMarker'
-      | 'reserveMarker'
-      | 'startedAtMs'
-    >,
+      'tokenAtStart' | 'publicationAtStart' | 'uncoveredAtStart' | 'startedAtMs'
+    > & { claim: ClaimedWikiRunMarker },
   ): WikiRun => ({
     kind,
     projectRoot,
@@ -2141,8 +2289,8 @@ export function activate(
     // The label is the absolute path exactly when the folder is not inside the project.
     isOutputOutsideProject:
       wikiOutput.outputLabel === wikiOutput.outputDirectory,
-    releaseMarker: start.releaseMarker,
-    reserveMarker: start.reserveMarker,
+    releaseMarker: start.claim.release,
+    reserveMarker: start.claim.reserve,
     startedAtMs: start.startedAtMs,
     seenCandidateNames: new Set(),
     // The bounds this module reads itself, so a host test that shortens one reaches the run.
@@ -2169,51 +2317,60 @@ export function activate(
       host: isCursorHost ? 'cursor' : 'vscode',
     }
   }
-  /** Starts a project-bound skill update from the browser or command, coalescing repeated clicks. @param acknowledgedLeftovers - Given when the learner pressed "Update anyway": the leftovers named by the refusals it was pressed on, one press after the other, which alone are ignored; every other leftover, there already or appeared since, refuses the start with a notice of its own, and another window's running update still refuses it. @example await updateDeepWiki() */
+  /** Starts a project-bound skill update from the browser or command, coalescing repeated clicks. @param acknowledgedLeftovers - Given when the learner pressed "Update anyway": the leftovers named by the refusals it was pressed on, one press after the other, which alone are ignored; every other leftover, there already or appeared since, refuses the start with a notice of its own, and another window's running update still refuses it. @param isChoiceCarried - Whether the press carries a choice (Update anyway, the offer's Update), which a start under way would not apply ({@link runWikiAttempt}). @example await updateDeepWiki() */
   const updateDeepWiki = (
     acknowledgedLeftovers: readonly WikiLeftover[] = [],
+    isChoiceCarried = false,
   ): Promise<void> =>
-    runWikiAttempt(async () => {
-      const { projectRoot, wikiOutput, host } = await wikiRunPlace()
-      let start: WikiUpdateStart | undefined
-      try {
-        start = await checkWikiUpdateStart(
-          projectRoot,
-          wikiOutput,
-          host,
-          acknowledgedLeftovers,
+    runWikiAttempt(
+      'update',
+      async () => {
+        const { projectRoot, wikiOutput, host } = await wikiRunPlace()
+        let start: WikiUpdateStart | undefined
+        try {
+          start = await checkWikiUpdateStart(
+            projectRoot,
+            wikiOutput,
+            host,
+            acknowledgedLeftovers,
+          )
+        } catch (error) {
+          // The page waits for this start; a check that threw must reach it as a failed start with the reason, not as silence, and the Output record names it as every refused start's does.
+          wikiUpdateRun.refuseStart(host, wikiOutput, {
+            kind: 'failed',
+            reason: thrownMessage(error),
+          })
+          writeWikiRunRecord({ runKind: 'update' })
+          throw error
+        }
+        if (!start) return
+        // The update request names the managed skill's procedure, so Cursor's agent gets the skill once the checks passed, as a generation's does (Eng decision 73).
+        // A window that began to close between the claim and the skill step has already looked for a step to stop and found none: it starts no verify or deploy, which nothing would end before the host does. The check below then leaves the marker.
+        if (isCursorHost && !isExtensionStopping)
+          await prepareCursorSkillForUpdate(start, host, wikiOutput)
+        // The checks and the skill take time (the freshness inspection hashes every source). A window that began to close meanwhile has already looked for a run to stop, so it starts none: no watch and no unattended agent.
+        if (isExtensionStopping) {
+          await leaveWikiMarkerOfRefusedStart(
+            wikiOutput.outputDirectory,
+            start.claim,
+          )
+          return
+        }
+        const { hasGitRepository } = start
+        const run = newWikiRun('update', projectRoot, wikiOutput, host, start)
+        await launchWikiRun(run, () =>
+          buildWikiUpdatePrompt({
+            manifestPath: join(wikiOutput.outputDirectory, WIKI_MANIFEST_FILE),
+            timeoutMs: run.timeoutMs,
+            // Nothing shows the Cursor CLI's reply to the learner, so its report is not asked for.
+            isReplyRead: !isCursorHost,
+            hasGitRepository,
+            uncoveredPaths: run.uncoveredAtStart,
+          }),
         )
-      } catch (error) {
-        // The page waits for this start; a check that threw must reach it as a failed start with the reason, not as silence, and the Output record names it as every refused start's does.
-        wikiUpdateRun.refuseStart(host, wikiOutput, {
-          kind: 'failed',
-          reason: thrownMessage(error),
-        })
-        writeWikiRunRecord({ runKind: 'update' })
-        throw error
-      }
-      if (!start) return
-      // The update request names the managed skill's procedure, so Cursor's agent gets the skill once the checks passed, as a generation's does (Eng decision 73).
-      if (isCursorHost)
-        await prepareCursorSkillForUpdate(start, host, wikiOutput)
-      // The checks and the skill take time (the freshness inspection hashes every source). A window that began to close meanwhile has already looked for a run to stop, so it starts none: no watch and no unattended agent.
-      if (isExtensionStopping) {
-        await start.releaseMarker().catch(() => undefined)
-        return
-      }
-      const { hasGitRepository } = start
-      const run = newWikiRun('update', projectRoot, wikiOutput, host, start)
-      await launchWikiRun(run, () =>
-        buildWikiUpdatePrompt({
-          manifestPath: join(wikiOutput.outputDirectory, WIKI_MANIFEST_FILE),
-          timeoutMs: run.timeoutMs,
-          // Nothing shows the Cursor CLI's reply to the learner, so its report is not asked for.
-          isReplyRead: !isCursorHost,
-          hasGitRepository,
-          uncoveredPaths: run.uncoveredAtStart,
-        }),
-      )
-    })
+      },
+      isChoiceCarried,
+    )
   /**
    * Tells the learner why a generation did not start, writes its Output record, and offers the override where there is one; called for every refusal of {@link startWikiGenerate} and for a start that threw.
    * A generation's refusal is not recorded as the update's state: the reader page that shows that state exists only for a published Wiki.
@@ -2221,6 +2378,7 @@ export function activate(
    * @param wikiOutput - The Wiki folder and its label.
    * @param reason - The refusal's sentence.
    * @param override - Starts the generation with the refusal's leftovers passed (Generate anyway).
+   * @param cause - The id of the block that refused the start; the Output record shows it, the sentence does not.
    * @example refuseWikiGenerate('vscode', wikiOutput, 'Another editor window is generating this Wiki …')
    */
   const refuseWikiGenerate = (
@@ -2228,6 +2386,7 @@ export function activate(
     wikiOutput: WikiUpdateOutput,
     reason: string,
     override?: () => void,
+    cause?: string,
   ): void => {
     try {
       output?.info(
@@ -2242,7 +2401,7 @@ export function activate(
             site: 'kept',
             ...wikiOutput,
           },
-          { runKind: 'generate' },
+          { runKind: 'generate', blockCause: cause },
         ),
       )
     } catch {
@@ -2266,7 +2425,7 @@ export function activate(
   ): void => {
     Promise.resolve(attemptToAwaitBeforeOverride(refusedAttempt))
       .catch(() => undefined)
-      .then(() => generateDeepWiki(leftovers))
+      .then(() => generateDeepWiki(leftovers, true))
       .catch(refuseThrownWikiGenerate)
   }
   /**
@@ -2291,7 +2450,7 @@ export function activate(
   const attemptToAwaitBeforeOverride = (
     refusedAttempt: Promise<void> | undefined,
   ): Promise<void> | undefined =>
-    wikiUpdate === refusedAttempt ? refusedAttempt : undefined
+    wikiStart?.attempt === refusedAttempt ? refusedAttempt : undefined
   /** Asks the learner to confirm a generation (Cycle 0055, D2) with the folder, the runner and the bound ({@link describeWikiGenerateConfirmation}). @returns `generate`, `change-location`, or `undefined` for a dismissal. @example await confirmWikiGenerate('/repo', wikiOutput) // => 'generate' */
   const confirmWikiGenerate = async (
     projectRoot: string,
@@ -2320,19 +2479,84 @@ export function activate(
       ? 'change-location'
       : undefined
   }
-  /** Readies the managed Cursor skill the generate request names, without starting the runtime MCP connection (Cycle 0055, Eng decision 73): an installed current skill is kept; a missing or outdated one is deployed alone ({@link deployCursorSkill}), which keeps a learner's own or edited same-name skill and throws its conflict. @throws The deployment's refusal. @example await prepareCursorWikiSkill() */
-  const prepareCursorWikiSkill = async (): Promise<void> => {
+  /**
+   * Readies the managed Cursor skill the run's request names, without starting the runtime MCP connection (Cycle 0055, Eng decision 73): an installed current skill is kept; a missing or outdated one is deployed alone ({@link deployCursorSkill}), which keeps a learner's own or edited same-name skill and throws its conflict.
+   * The step runs with the start's marker claimed and no agent yet, so it runs under an abort that Stop LLM Wiki Run and a bound of {@link WIKI_SKILL_STEP_TIMEOUT_MS} fire (Cycle 0056 task 13). A verify or deploy that settles after the abort is not awaited: its result is ignored, no agent starts, and a skill file it already wrote stays (the managed skill is then current); a new step waits for it, so two deploys never run at once (the wait ends with the new step's own Stop and bound).
+   * @param runKind - The kind of the start, which the stop and bound sentences name.
+   * @throws The deployment's refusal; the stop or bound sentence ({@link describeWikiSkillStepEnd}) after an abort.
+   * @example await prepareCursorWikiSkill('generate')
+   */
+  const prepareCursorWikiSkill = async (
+    runKind: WikiRunKind,
+  ): Promise<void> => {
+    const skillStep: NonNullable<typeof wikiSkillStepStop> = {
+      controller: new AbortController(),
+    }
+    const stop = skillStep.controller
+    wikiSkillStepStop = skillStep
+    const bound = setTimeout(() => {
+      stop.abort(WIKI_SKILL_STEP_BOUND_REASON)
+    }, WIKI_SKILL_STEP_TIMEOUT_MS)
+    // An earlier step that was stopped may still be writing the skill; this one starts after it (under the same stop and bound).
+    const earlierStep = wikiSkillStepInFlight
+    // Whether this step still waits for that earlier step: a bound that fires then says so, as no skill work of this step ever began.
+    let isWaitingForEarlierStep = earlierStep !== undefined
+    const step = (async (): Promise<void> => {
+      await earlierStep
+      isWaitingForEarlierStep = false
+      // A step that was stopped or bounded while it waited writes nothing.
+      stop.signal.throwIfAborted()
+      // A step that begins while Remove Managed Cursor Skill is under way would write back the skill it takes away; the removal waits only for the step it found running.
+      if (cursorRemoving)
+        throw new Error(
+          describeWikiSkillStepEnd(
+            WIKI_SKILL_STEP_REMOVAL_END,
+            runKind,
+            WIKI_SKILL_STEP_TIMEOUT_MS,
+            formatClockTime(Date.now()),
+          ),
+        )
+      try {
+        await verifyManagedCursorSkill(
+          context.extensionPath,
+          context.globalStorageUri.fsPath,
+        )
+      } catch (verifyError) {
+        // A verify that fails after the abort must not go on to write a skill nobody waits for.
+        if (stop.signal.aborted) throw verifyError
+        // A missing or outdated skill is deployed; another skill in the way refuses the start with the deployment's own sentence.
+        await deployCursorSkill(
+          context.extensionPath,
+          context.globalStorageUri.fsPath,
+        )
+      }
+    })()
+    const settled = step.then(
+      () => undefined,
+      () => undefined,
+    )
+    wikiSkillStepInFlight = settled
+    void settled.then(() => {
+      if (wikiSkillStepInFlight === settled) wikiSkillStepInFlight = undefined
+    })
     try {
-      await verifyManagedCursorSkill(
-        context.extensionPath,
-        context.globalStorageUri.fsPath,
-      )
-    } catch {
-      // A missing or outdated skill is deployed; another skill in the way refuses the start with the deployment's own sentence.
-      await deployCursorSkill(
-        context.extensionPath,
-        context.globalStorageUri.fsPath,
-      )
+      await runUnderAbortSignal(() => step, stop.signal)
+    } catch (error) {
+      // The abort's reason says who ended the step; any other failure is the step's own.
+      if (stop.signal.aborted)
+        throw new Error(
+          describeWikiSkillStepEnd(
+            wikiSkillStepEndOf(stop.signal.reason, isWaitingForEarlierStep),
+            runKind,
+            WIKI_SKILL_STEP_TIMEOUT_MS,
+            // The moment of the Stop, not of this handling.
+            formatClockTime(skillStep.stoppedAtMs ?? Date.now()),
+          ),
+        )
+      throw error
+    } finally {
+      clearTimeout(bound)
+      if (wikiSkillStepStop === skillStep) wikiSkillStepStop = undefined
     }
   }
   /**
@@ -2350,10 +2574,13 @@ export function activate(
     wikiOutput: WikiUpdateOutput,
   ): Promise<void> => {
     try {
-      await prepareCursorWikiSkill()
+      await prepareCursorWikiSkill('update')
     } catch (error) {
-      // A skill in the learner's way refuses the update, frees the marker the checks claimed, and leaves the refused start's Output record.
-      await start.releaseMarker().catch(() => undefined)
+      // A skill in the learner's way refuses the update, frees the marker the checks claimed (or writes a taken-over reservation back), and leaves the refused start's Output record.
+      await leaveWikiMarkerOfRefusedStart(
+        wikiOutput.outputDirectory,
+        start.claim,
+      )
       wikiUpdateRun.refuseStart(host, wikiOutput, {
         kind: 'failed',
         reason: thrownMessage(error),
@@ -2381,96 +2608,110 @@ export function activate(
   /**
    * Starts a first LLM Wiki generation from Codebook's entry (Codebook: Generate LLM Wiki), coalescing repeated presses: the start's checks, the confirmation, the folder, the agent and the marker ({@link startWikiGenerate}), then the run of kind `generate` ({@link launchWikiRun}) with the generate request ({@link buildWikiGeneratePrompt}).
    * @param acknowledgedLeftovers - Given when the learner pressed "Generate anyway": the leftovers named by the refusals it was pressed on, which alone are ignored.
+   * @param isChoiceCarried - Whether the press carries the learner's choice (Generate anyway), which a start under way would not apply ({@link runWikiAttempt}).
    * @throws What a start threw (a link on the folder's path, an unwritable parent folder, the Cursor skill's conflict); no marker is left.
    * @example await generateDeepWiki()
    */
   const generateDeepWiki = (
     acknowledgedLeftovers: readonly WikiLeftover[] = [],
+    isChoiceCarried = false,
   ): Promise<void> =>
-    runWikiAttempt(async () => {
-      const { projectRoot, wikiOutput, host } = await wikiRunPlace()
-      const { outputDirectory } = wikiOutput
-      const start = await startWikiGenerate({
-        wikiOutput,
-        assertPathHeld: () =>
-          assertNoLinkOnWikiPath(outputDirectory, projectRoot),
-        readPublishToken: () => readWikiPublishToken(outputDirectory),
-        findStartBlock: () =>
-          findWikiUpdateStartBlock(outputDirectory, projectRoot),
-        findRunInTheWay: () =>
-          findWikiRunInTheWay(
+    runWikiAttempt(
+      'generate',
+      async () => {
+        const { projectRoot, wikiOutput, host } = await wikiRunPlace()
+        const { outputDirectory } = wikiOutput
+        const start = await startWikiGenerate({
+          wikiOutput,
+          assertPathHeld: () =>
+            assertNoLinkOnWikiPath(outputDirectory, projectRoot),
+          readPublishToken: () => readWikiPublishToken(outputDirectory),
+          findStartBlock: () =>
+            findWikiUpdateStartBlock(outputDirectory, projectRoot),
+          findRunInTheWay: () =>
+            findWikiRunInTheWay(
+              outputDirectory,
+              acknowledgedLeftovers,
+              'generate',
+              startWikiGenerateAnyway,
+            ),
+          confirm: () => confirmWikiGenerate(projectRoot, wikiOutput),
+          openLocationSetting: async () =>
+            vscode.commands.executeCommand(
+              'workbench.action.openSettings',
+              '@id:codebook.wikiOutputDirectory',
+            ),
+          // The marker lies beside the output folder, in a folder a fresh project lacks; the output folder itself is the publisher's to make.
+          makeOutputParent: async () => {
+            await mkdir(dirname(outputDirectory), { recursive: true })
+          },
+          // A window that began to close between the claim and the skill step starts no verify or deploy (as for an update); the check after the start leaves the marker.
+          prepareAgent: () =>
+            isCursorHost && !isExtensionStopping
+              ? prepareCursorWikiSkill('generate')
+              : Promise.resolve(),
+          // The same bounded retry every change of this window's marker has; a closing window gets its one attempt.
+          leaveMarker: (claim) =>
+            leaveWikiMarkerOfRefusedStart(outputDirectory, claim),
+          claimMarker: (startedAtMs) =>
+            claimWikiRunMarker(outputDirectory, host, 'generate', startedAtMs),
+          describeHolder: (holder) =>
+            describeOtherWikiWindow(holder, 'generate'),
+          readPublicationIdentity: () =>
+            readWikiPublicationIdentity(outputDirectory),
+          hasGitRepository: () =>
+            isInGitRepository(projectRoot, outputDirectory),
+          // A link or a file there was refused by the path check; only a folder of its own without a manifest counts, and one that holds a Wiki gets the update's offer.
+          hasOutputFolderWithoutWiki: async () =>
+            (await lstat(outputDirectory).then(
+              (stat) => stat.isDirectory(),
+              () => false,
+            )) &&
+            (await readWikiPublishToken(outputDirectory).catch(
+              () => 'unreadable',
+            )) === undefined,
+          offerUpdate: () => {
+            // The generation that offers the update, which the update waits for, and only for it.
+            const offeringAttempt = wikiStart?.attempt
+            void showNotice(
+              'information',
+              describeExistingWiki(wikiOutput.outputLabel),
+              UPDATE_WIKI_ACTION,
+            ).then(
+              (choice) => {
+                if (choice === UPDATE_WIKI_ACTION)
+                  startWikiUpdateAnyway([], offeringAttempt)
+              },
+              () => undefined,
+            )
+          },
+          refuse: (reason, override, cause) =>
+            refuseWikiGenerate(host, wikiOutput, reason, override, cause),
+          now: Date.now,
+        })
+        if (!start) return
+        // A window that began to close while the learner confirmed starts no run its shutdown no longer finds.
+        if (isExtensionStopping) {
+          await leaveWikiMarkerOfRefusedStart(outputDirectory, start.claim)
+          return
+        }
+        const run = newWikiRun('generate', projectRoot, wikiOutput, host, {
+          ...start,
+          tokenAtStart: undefined,
+          uncoveredAtStart: [],
+        })
+        await launchWikiRun(run, () =>
+          buildWikiGeneratePrompt({
             outputDirectory,
-            acknowledgedLeftovers,
-            'generate',
-            startWikiGenerateAnyway,
-          ),
-        confirm: () => confirmWikiGenerate(projectRoot, wikiOutput),
-        openLocationSetting: async () =>
-          vscode.commands.executeCommand(
-            'workbench.action.openSettings',
-            '@id:codebook.wikiOutputDirectory',
-          ),
-        // The marker lies beside the output folder, in a folder a fresh project lacks; the output folder itself is the publisher's to make.
-        makeOutputParent: async () => {
-          await mkdir(dirname(outputDirectory), { recursive: true })
-        },
-        prepareAgent: () =>
-          isCursorHost ? prepareCursorWikiSkill() : Promise.resolve(),
-        claimMarker: (startedAtMs) =>
-          claimWikiRunMarker(outputDirectory, host, 'generate', startedAtMs),
-        describeHolder: (holder) => describeOtherWikiWindow(holder, 'generate'),
-        readPublicationIdentity: () =>
-          readWikiPublicationIdentity(outputDirectory),
-        hasGitRepository: () => isInGitRepository(projectRoot, outputDirectory),
-        // A link or a file there was refused by the path check; only a folder of its own without a manifest counts, and one that holds a Wiki gets the update's offer.
-        hasOutputFolderWithoutWiki: async () =>
-          (await lstat(outputDirectory).then(
-            (stat) => stat.isDirectory(),
-            () => false,
-          )) &&
-          (await readWikiPublishToken(outputDirectory).catch(
-            () => 'unreadable',
-          )) === undefined,
-        offerUpdate: () => {
-          // The generation that offers the update, which the update waits for, and only for it.
-          const offeringAttempt = wikiUpdate
-          void showNotice(
-            'information',
-            `An LLM Wiki already exists in ${wikiOutput.outputLabel}. Update it instead?`,
-            UPDATE_WIKI_ACTION,
-          ).then(
-            (choice) => {
-              if (choice === UPDATE_WIKI_ACTION)
-                startWikiUpdateAnyway([], offeringAttempt)
-            },
-            () => undefined,
-          )
-        },
-        refuse: (reason, override) =>
-          refuseWikiGenerate(host, wikiOutput, reason, override),
-        now: Date.now,
-      })
-      if (!start) return
-      // A window that began to close while the learner confirmed starts no run its shutdown no longer finds.
-      if (isExtensionStopping) {
-        await start.releaseMarker().catch(() => undefined)
-        return
-      }
-      const run = newWikiRun('generate', projectRoot, wikiOutput, host, {
-        ...start,
-        tokenAtStart: undefined,
-        uncoveredAtStart: [],
-      })
-      await launchWikiRun(run, () =>
-        buildWikiGeneratePrompt({
-          outputDirectory,
-          timeoutMs: run.timeoutMs,
-          // Nothing shows the Cursor CLI's reply to the learner, so its report is not asked for.
-          isReplyRead: !isCursorHost,
-          hasGitRepository: start.hasGitRepository,
-        }),
-      )
-    })
+            timeoutMs: run.timeoutMs,
+            // Nothing shows the Cursor CLI's reply to the learner, so its report is not asked for.
+            isReplyRead: !isCursorHost,
+            hasGitRepository: start.hasGitRepository,
+          }),
+        )
+      },
+      isChoiceCarried,
+    )
   if (vscode.window?.registerUriHandler)
     context.subscriptions.push(
       vscode.window.registerUriHandler({
@@ -2576,14 +2817,19 @@ export function activate(
       activeWikiRun.controller.abort()
       return
     }
+    // A start in the Cursor skill step ends at once, with its own sentence.
+    if (wikiSkillStepStop) {
+      stopWikiSkillStep(wikiSkillStepStop)
+      return
+    }
     // A run that is still starting has nothing to stop yet; the learner is told so instead of "nothing is running".
-    if (wikiUpdate) {
+    if (wikiStart) {
       void showNotice('information', WIKI_RUN_STARTING_SENTENCE)
       return
     }
     void showNotice(
       'information',
-      'No LLM Wiki generation or update is running in this window.',
+      'No LLM Wiki run is going on in this window.',
     )
   }
   context.subscriptions.push(
@@ -2605,6 +2851,17 @@ export function activate(
       const attempt = (async () => {
         cursorRemoving = true
         try {
+          // A Cursor skill step of this window that is still running would write the skill again after it is removed: the step is ended and waited for within the grace, and a step that does not settle in time leaves everything in place, with the learner told.
+          if (wikiSkillStepStop) stopWikiSkillStep(wikiSkillStepStop)
+          if (
+            !(await settledWithin(
+              wikiSkillStepInFlight,
+              WIKI_CURSOR_TERMINATION_GRACE_MS,
+            ))
+          ) {
+            void showNotice('warning', WIKI_SKILL_REMOVAL_STEP_RUNNING_SENTENCE)
+            return
+          }
           // Setup and auto reconnect must finish before removing their shared skill, registration, and catalog.
           await cursorSetup?.catch(() => {})
           await cursorRegistration?.attempt.catch(() => {})
@@ -2687,7 +2944,7 @@ export function activate(
           // A folder without a Wiki offers its generation instead of an error about a missing manifest (Cycle 0055, proposed change 3).
           const missingWiki = await findMissingWiki()
           if (missingWiki) {
-            await showMissingWikiNotice(missingWiki, wikiUpdate !== undefined)
+            await showMissingWikiNotice(missingWiki, wikiStart !== undefined)
             return
           }
           const { projectRoot, outputDirectory } = await currentDeepWiki()
@@ -2958,7 +3215,7 @@ export function activate(
           readMarker: (outputDirectory) =>
             readLiveWikiUpdateMarker(outputDirectory, LLM_WIKI_VIEW_WINDOW_ID),
           ownWindowId: wikiWindowId,
-          isStartUnderWay: () => wikiUpdate !== undefined,
+          isStartUnderWay: () => wikiStart !== undefined,
           hasPublishEndedWait: hasWikiPublishEndedWait,
           runStatus: () => wikiUpdateRun.status(),
           isAwaitingChat: () => activeWikiRun?.awaitsChat === true,
@@ -2983,7 +3240,15 @@ export function activate(
         }
       },
       findWatchedFolder: findNearestExistingAncestor,
-      onRunChange: (listener) => wikiUpdateRun.onDidChange(listener),
+      onRunChange: (listener) => {
+        // The view also reads again once an attempt to change the run's marker ended, so the reservation row shows without a file event.
+        const stopListeningToRun = wikiUpdateRun.onDidChange(listener)
+        wikiMarkerChangeListeners.add(listener)
+        return (): void => {
+          stopListeningToRun()
+          wikiMarkerChangeListeners.delete(listener)
+        }
+      },
       tellPublished: (outputLabel) =>
         showWikiActionNotice(
           'information',
diff --git a/extension/src/tests/bundledSkillTestRuns.test.ts b/extension/src/tests/bundledSkillTestRuns.test.ts
index 8de396171..f00326bd3 100644
--- a/extension/src/tests/bundledSkillTestRuns.test.ts
+++ b/extension/src/tests/bundledSkillTestRuns.test.ts
@@ -24,12 +24,12 @@ test('the bundled skill routes a question about a test, or about library behavio
 })
 
 // Value: protects=the skill's version being the one the release names, in one place; fails_when=the skill text changes without its version moving, or the version moves without this pin; why_new=F86 (the version was pinned inside the routing test); seam=none; no_claim=the wording of the skill
-test('the bundled skill declares version 1.0.49 in its metadata', async () => {
+test('the bundled skill declares version 1.0.50 in its metadata', async () => {
   // Arrange / Act
   const skill = await readBundledSkill()
 
   // Assert
-  assert.ok(skill.includes('metadata:\n  version: "1.0.49"\n'))
+  assert.ok(skill.includes('metadata:\n  version: "1.0.50"\n'))
 })
 
 // Value: protects=a test stop explained in chat, never through codebook_explain, which belongs to the browser profile; fails_when=the skill tells the chat to save every committed pause with codebook_explain, which refuses a test stop; why_new=1.0.45 said codebook_explain at every pause of any run (C49-7, AC9); seam=none; no_claim=the refusal codebook_explain gives a test stop (service tests)
diff --git a/extension/src/tests/claimWikiUpdateMarker.test.ts b/extension/src/tests/claimWikiUpdateMarker.test.ts
index e404676a9..197543a86 100644
--- a/extension/src/tests/claimWikiUpdateMarker.test.ts
+++ b/extension/src/tests/claimWikiUpdateMarker.test.ts
@@ -3883,3 +3883,104 @@ test('an entry where a prepared claim folder would lie that the look calls a dir
     },
   )
 })
+
+// Value: protects=Cycle 0056 pass 1 RT1, the owner of a reservation a claim took over; fails_when=the claim does not hand out the marker it removed, or a reservation written back with it carries the claiming window's host, process and window instead of the replaced marker's, so the VS Code watch bound no longer applies; no_claim=how the extension registers the written-back reservation (host tests); seam=a reservation written by hand
+test('a reservation taken over by a Cursor claim is written back as the VS Code window’s marker it was', async () => {
+  // Arrange
+  const wiki = await createWikiFolder()
+  const watchEndedAtMs = Date.now() - 1_000
+  const reservation = {
+    pid: process.pid,
+    windowId: 'window-a',
+    host: 'vscode',
+    startedAtMs: watchEndedAtMs - 60_000,
+    runKind: 'generate',
+    watchEndedAtMs,
+  }
+  try {
+    await writeFile(wiki.markerPath, JSON.stringify(reservation))
+    const claim = await claimWikiUpdateMarker(
+      wiki.outputDirectory,
+      {
+        pid: process.pid,
+        windowId: 'window-b',
+        host: 'cursor',
+        startedAtMs: Date.now(),
+      },
+      AS_THIS_WINDOW,
+    )
+    assert.ok('reserve' in claim)
+    assert.ok(claim.replacedReservation)
+
+    // Act
+    const answer = await claim.reserve(
+      claim.replacedReservation.watchEndedAtMs,
+      claim.replacedReservation,
+    )
+
+    // Assert
+    assert.equal(answer, true)
+    assert.deepEqual(
+      JSON.parse(await readFile(wiki.markerPath, 'utf8')),
+      reservation,
+    )
+  } finally {
+    await rm(wiki.directory, { recursive: true, force: true })
+  }
+})
+
+// Value: protects=Cycle 0056 pass 3 RT3-A, the original owner's release of a reservation another window took over and wrote back; fails_when=the written-back marker is re-serialized from the parsed marker (other key order), so the owner compares its own text, finds it is not its own and leaves the marker for its whole bound; no_claim=how the extension registers the write-back (host tests); seam=two real claims of one process under different window ids
+test('a reservation taken over and written back is the original owner’s text, so its release still removes the marker', async () => {
+  // Arrange
+  const wiki = await createWikiFolder()
+  try {
+    const ownerClaim = await claimWikiUpdateMarker(
+      wiki.outputDirectory,
+      {
+        pid: process.pid,
+        windowId: 'window-a',
+        host: 'vscode',
+        startedAtMs: Date.now() - 60_000,
+        runKind: 'generate',
+      },
+      AS_THIS_WINDOW,
+    )
+    assert.ok('reserve' in ownerClaim)
+    assert.equal(await ownerClaim.reserve(Date.now() - 1_000), true)
+    const ownerText = await readFile(wiki.markerPath, 'utf8')
+    const takingClaim = await claimWikiUpdateMarker(
+      wiki.outputDirectory,
+      {
+        pid: process.pid,
+        windowId: 'window-b',
+        host: 'cursor',
+        startedAtMs: Date.now(),
+      },
+      AS_THIS_WINDOW,
+    )
+    assert.ok('reserve' in takingClaim)
+    assert.ok(takingClaim.replacedReservation)
+
+    // Act: the taking window is refused and writes the reservation back; then the owner releases its own reservation.
+    await takingClaim.reserve(
+      takingClaim.replacedReservation.watchEndedAtMs,
+      takingClaim.replacedReservation,
+    )
+    const writtenBackText = await readFile(wiki.markerPath, 'utf8')
+    await ownerClaim.release()
+
+    // Assert
+    assert.deepEqual(
+      {
+        isWrittenBackTextTheOwners: writtenBackText === ownerText,
+        markerLeft: await readFile(wiki.markerPath, 'utf8').then(
+          () => true,
+          () => false,
+        ),
+      },
+      { isWrittenBackTextTheOwners: true, markerLeft: false },
+    )
+  } finally {
+    await rm(wiki.directory, { recursive: true, force: true })
+  }
+})
diff --git a/extension/src/tests/describeJoinedWikiStart.test.ts b/extension/src/tests/describeJoinedWikiStart.test.ts
new file mode 100644
index 000000000..7e7293486
--- /dev/null
+++ b/extension/src/tests/describeJoinedWikiStart.test.ts
@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { describeJoinedWikiStart } from '../utils/describeJoinedWikiStart'
+
+// Value: protects=Cycle 0056 task 2, the sentence of a press that joins a start under way; fails_when=it names the wrong run kind or loses the word that tells the press was joined; no_claim=when it is shown (host tests); seam=none
+test('a press that joins a start under way is told which start it joined', () => {
+  // Act
+  const sentences = [
+    describeJoinedWikiStart('generate'),
+    describeJoinedWikiStart('update'),
+  ]
+
+  // Assert
+  assert.deepEqual(sentences, [
+    'Codebook is already starting an LLM Wiki generation in this window; this press joins it.',
+    'Codebook is already starting an LLM Wiki update in this window; this press joins it.',
+  ])
+})
+
+// Value: protects=Cycle 0056 pass 3 A2, the sentence of a press that carries a choice into a start under way; fails_when=the press with a choice is told "this press joins it" although the start does not apply its choice, or the sentence names the wrong run kind or loses the instruction to choose again; no_claim=when it is shown (host tests); seam=none
+test('a press that carries a choice into a start under way is told the choice was not applied and to choose again', () => {
+  // Act
+  const sentences = [
+    describeJoinedWikiStart('generate', true),
+    describeJoinedWikiStart('update', true),
+  ]
+
+  // Assert
+  assert.deepEqual(sentences, [
+    'Codebook is already starting an LLM Wiki generation in this window, so this choice was not applied. If that start stops for the same reason, choose it again.',
+    'Codebook is already starting an LLM Wiki update in this window, so this choice was not applied. If that start stops for the same reason, choose it again.',
+  ])
+})
diff --git a/extension/src/tests/describeWikiGenerateBlock.test.ts b/extension/src/tests/describeWikiGenerateBlock.test.ts
index a9887c972..d290ee726 100644
--- a/extension/src/tests/describeWikiGenerateBlock.test.ts
+++ b/extension/src/tests/describeWikiGenerateBlock.test.ts
@@ -3,7 +3,7 @@ import { test } from 'node:test'
 
 import { describeWikiGenerateBlock } from '../utils/describeWikiGenerateBlock'
 
-// Value: protects=D5 and the publisher's refusals before a first generation; fails_when=a block a folder without a manifest can hold is told with an update's words, names no path, or names no next step; no_claim=finding the block (findWikiUpdateStartBlock tests); seam=none
+// Value: protects=D5 and the publisher's refusals before a first generation, and a learner who never reads a raw cause id in a sentence (Cycle 0056 task 10); fails_when=a block a folder without a manifest can hold is told with an update's words, names no path, names no next step, or a block that needs a manifest shows its cause id such as edited-page; no_claim=finding the block (findWikiUpdateStartBlock tests); seam=none
 test('each block a folder without a Wiki can hold is told with the generation’s next step, and a block that needs a manifest sends the learner to the update', () => {
   // Act
   const sentences = [
@@ -35,6 +35,21 @@ test('each block a folder without a Wiki can hold is told with the generation’
     '.codebook/wiki is a link or a file, not a folder of its own, so the publisher cannot write the Wiki there. Remove it, or set codebook.wikiOutputDirectory to another folder, then press Generate LLM Wiki again.',
     'A folder on the path to .codebook/wiki (.codebook) is a link or a file, or leads out of the project, so the publisher refuses to write there. Replace it with a real folder, or set codebook.wikiOutputDirectory to another folder, then press Generate LLM Wiki again.',
     '.codebook/wiki holds a link or special file (pipe), which the publisher refuses. Move it out of the folder, then press Generate LLM Wiki again.',
-    'The folder .codebook/wiki cannot take a new LLM Wiki (edited-page: index.html). Press Update LLM Wiki to see what is in the way.',
+    'The folder .codebook/wiki cannot take a new LLM Wiki: index.html is in the way. Press Update LLM Wiki for the details and the next step.',
   ])
 })
+
+// Value: protects=Cycle 0056 L5, a block that needs a manifest and names no path; fails_when=the sentence says the folder is in its own way ("X cannot take a new LLM Wiki: X is in the way"); no_claim=a block that names a path (test above); seam=none
+test('a block that needs a manifest and names no path does not call the folder itself the thing in the way', () => {
+  // Act
+  const sentence = describeWikiGenerateBlock(
+    { cause: 'edited-page', paths: [] },
+    '.codebook/wiki',
+  )
+
+  // Assert
+  assert.equal(
+    sentence,
+    'The folder .codebook/wiki cannot take a new LLM Wiki. Press Update LLM Wiki for the details and the next step.',
+  )
+})
diff --git a/extension/src/tests/describeWikiSkillStepEnd.test.ts b/extension/src/tests/describeWikiSkillStepEnd.test.ts
new file mode 100644
index 000000000..928941c0a
--- /dev/null
+++ b/extension/src/tests/describeWikiSkillStepEnd.test.ts
@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { WIKI_SKILL_STEP_TIMEOUT_MS } from '../constants'
+import { describeWikiSkillStepEnd } from '../utils/describeWikiSkillStepEnd'
+
+// Value: protects=Cycle 0056 task 13, the sentences a start ends with while Codebook readies the Cursor skill; fails_when=a sentence names the wrong run kind, names no bound or no next step, or the earlier-step sentence loses its reload instruction, or the removal sentence names no next step, or the bound is not 30 seconds; no_claim=when the step is stopped (host tests); seam=none
+test('a start ended while the Cursor skill was readied says who ended it and when, that no agent started and what to press next', () => {
+  // Act
+  const sentences = [
+    describeWikiSkillStepEnd(
+      'stopped',
+      'generate',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'stopped',
+      'update',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'bound',
+      'generate',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'bound',
+      'update',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'earlier-step-running',
+      'generate',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'earlier-step-running',
+      'update',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'skill-removal',
+      'generate',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+    describeWikiSkillStepEnd(
+      'skill-removal',
+      'update',
+      WIKI_SKILL_STEP_TIMEOUT_MS,
+      '21:10',
+    ),
+  ]
+
+  // Assert
+  assert.deepEqual(sentences, [
+    'The LLM Wiki generation was cancelled at 21:10 while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+    'The LLM Wiki update was cancelled at 21:10 while Codebook readied the Cursor skill; no agent was started. Press Update LLM Wiki when you want to start again.',
+    'Codebook stopped readying the Cursor skill after 30 seconds; no agent was started. Press Generate LLM Wiki again, or run Codebook: Set Up AI Chat.',
+    'Codebook stopped readying the Cursor skill after 30 seconds; no agent was started. Press Update LLM Wiki again, or run Codebook: Set Up AI Chat.',
+    'Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press Generate LLM Wiki again.',
+    'Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press Update LLM Wiki again.',
+    'Codebook is removing the managed Cursor skill in this window; no agent was started. Press Generate LLM Wiki again when the removal has finished, and Codebook installs its skill again.',
+    'Codebook is removing the managed Cursor skill in this window; no agent was started. Press Update LLM Wiki again when the removal has finished, and Codebook installs its skill again.',
+  ])
+})
diff --git a/extension/src/tests/llmWikiView.test.ts b/extension/src/tests/llmWikiView.test.ts
index b2f8a4967..44150902e 100644
--- a/extension/src/tests/llmWikiView.test.ts
+++ b/extension/src/tests/llmWikiView.test.ts
@@ -788,6 +788,31 @@ test('Stop watching in the view ends the generation and leaves a Waiting for cha
   )
 })
 
+// Value: protects=AC 2c (the Waiting for chat row after Stop watching shows without a file event, also when the view read before the reservation was written); fails_when=the view's only read after the run's end lands before the marker turns into a reservation and nothing reads again, so the row never shows; no_claim=the retry time's wording; seam=the change of the run's marker held open until the view read, no file event reported
+test('Stop watching shows Waiting for chat although the reservation is written after the view read the run end and no file event is reported', async (context) => {
+  // Arrange
+  const project = await openEmptyProject(context, {
+    chatReply: () => new Promise<never>(() => {}),
+    holdAtOpen: ['marker-change'],
+  })
+  const markerChange = project.hold('marker-change')
+  void project.runCommand(GENERATE_COMMAND)
+  await untilRow(project, 'run')
+
+  // Act
+  void project.runCommand('codebook.llmWiki.stopWatching')
+  await markerChange.started
+  await untilRow(project, 'run', false)
+  markerChange.release()
+  await untilRow(project, 'reservation')
+
+  // Assert
+  assert.deepEqual(
+    [idsOf(project), rowOf(project, 'reservation')?.label],
+    [['reservation', 'last-attempt', 'output'], 'Waiting for 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
diff --git a/extension/src/tests/runUnderAbortSignal.test.ts b/extension/src/tests/runUnderAbortSignal.test.ts
new file mode 100644
index 000000000..3b665a073
--- /dev/null
+++ b/extension/src/tests/runUnderAbortSignal.test.ts
@@ -0,0 +1,110 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { runUnderAbortSignal } from '../utils/runUnderAbortSignal'
+
+// Value: protects=Cycle 0056 task 13, the end of the wait for a step that cannot be cancelled; fails_when=a step that never settles keeps the wait open after the signal fired, a step that settles first loses its result, or a signal that fired before the step still starts it; no_claim=what the step does (host tests); seam=a step the test settles
+test('the wait for a step ends with the signal’s reason, a step that settles first gives its result, and a fired signal starts no step', async () => {
+  // Arrange
+  const fired = new AbortController()
+  fired.abort('stopped')
+  let startedAfterFiredSignal = false
+  const waiting = new AbortController()
+  const hanging = runUnderAbortSignal(
+    () => new Promise<never>(() => {}),
+    waiting.signal,
+  )
+
+  // Act
+  waiting.abort('bound')
+  const hangingEnd = await hanging.then(
+    () => 'resolved',
+    (reason: unknown) => reason,
+  )
+  const firstResult = await runUnderAbortSignal(
+    async () => 'done',
+    new AbortController().signal,
+  )
+  const firedEnd = await runUnderAbortSignal(async () => {
+    startedAfterFiredSignal = true
+    return 'started'
+  }, fired.signal).then(
+    () => 'resolved',
+    (reason: unknown) => reason,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { hangingEnd, firstResult, firedEnd, startedAfterFiredSignal },
+    {
+      hangingEnd: 'bound',
+      firstResult: 'done',
+      firedEnd: 'stopped',
+      startedAfterFiredSignal: false,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13, a step that fails after the wait ended; fails_when=its late failure is reported as an unhandled rejection that ends the extension host; no_claim=the step's side effects; seam=a step the test fails after the signal
+test('a step that fails after the signal ended the wait raises no unhandled rejection', async () => {
+  // Arrange
+  const unhandled: unknown[] = []
+  const onUnhandled = (reason: unknown): void => {
+    unhandled.push(reason)
+  }
+  process.on('unhandledRejection', onUnhandled)
+  const controller = new AbortController()
+  let failStep = (): void => {}
+  const waiting = runUnderAbortSignal(
+    () =>
+      new Promise<never>((_resolve, reject) => {
+        failStep = (): void => reject(new Error('late failure'))
+      }),
+    controller.signal,
+  )
+  controller.abort('stopped')
+  await waiting.catch(() => undefined)
+
+  // Act
+  failStep()
+  await new Promise((resolveFlush) => setImmediate(resolveFlush))
+  process.off('unhandledRejection', onUnhandled)
+
+  // Assert
+  assert.deepEqual(unhandled, [])
+})
+
+// Value: protects=Cycle 0056 L2, a Stop pressed in the tick the step settles; fails_when=the step's result wins the race by order alone and the start goes on to launch the agent after Stop; no_claim=a step that settles long after the signal (tests above); seam=a step that fires the signal as it settles
+test('a signal that fires in the tick the step settles still ends the wait with its reason', async () => {
+  // Arrange
+  const stopping = new AbortController()
+
+  // Act
+  const end = await runUnderAbortSignal(async () => {
+    queueMicrotask(() => stopping.abort('stopped'))
+    return 'done'
+  }, stopping.signal).then(
+    (result) => `resolved with ${result}`,
+    (reason: unknown) => reason,
+  )
+
+  // Assert
+  assert.equal(end, 'stopped')
+})
+
+// Value: protects=Cycle 0056 pass 2 T-A, a step that fails on its own before any signal; fails_when=the step's error is replaced by the signal's reason or swallowed; no_claim=a step that fails after the signal (test above); seam=a step that rejects at once
+test('a step that fails before the signal fired rethrows its own error', async () => {
+  // Arrange
+  const signal = new AbortController().signal
+
+  // Act
+  const end = await runUnderAbortSignal(async () => {
+    throw new Error('the deploy failed')
+  }, signal).then(
+    () => 'resolved',
+    (reason: unknown) => (reason instanceof Error ? reason.message : reason),
+  )
+
+  // Assert
+  assert.equal(end, 'the deploy failed')
+})
diff --git a/extension/src/tests/startWikiRun.test.ts b/extension/src/tests/startWikiRun.test.ts
index 9dba061f4..1da81c50f 100644
--- a/extension/src/tests/startWikiRun.test.ts
+++ b/extension/src/tests/startWikiRun.test.ts
@@ -1,8 +1,8 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
+import { describeMissingWiki } from '../utils/describeMissingWiki'
 import {
-  describeMissingWiki,
   startWikiGenerate,
   type WikiGenerateStartDependencies,
 } from '../utils/startWikiRun'
@@ -45,6 +45,10 @@ function standIns(
     prepareAgent: async (): Promise<void> => {
       steps.push('agent')
     },
+    // The window's bounded retry is its own; a stand-in releases the marker once.
+    leaveMarker: async (claim): Promise<void> => {
+      await claim.release().catch(() => false)
+    },
     claimMarker: async () => {
       steps.push('claim')
       return {
@@ -267,6 +271,33 @@ test('a publish lock in the way refuses the generation before the confirmation w
   )
 })
 
+// Value: protects=Cycle 0056 task 10, the cause id of a block, which the learner's sentence leaves out and the Output record keeps; fails_when=the refusal gets no cause id, so a learner who reports it has only the sentence; no_claim=how the Output record prints it (wikiRunRecord tests); seam=stand-ins
+test('a block in the way hands its cause id to the refusal beside the learner’s sentence', async () => {
+  // Arrange
+  const refusals: Array<{ reason: string; cause: string | undefined }> = []
+  const dependencies = standIns([], {
+    findStartBlock: async () => ({
+      cause: 'edited-page',
+      paths: ['index.html'],
+    }),
+    refuse: (reason, _override, cause): void => {
+      refusals.push({ reason, cause })
+    },
+  })
+
+  // Act
+  await startWikiGenerate(dependencies)
+
+  // Assert
+  assert.deepEqual(refusals, [
+    {
+      reason:
+        'The folder .codebook/wiki cannot take a new LLM Wiki: index.html is in the way. Press Update LLM Wiki for the details and the next step.',
+      cause: 'edited-page',
+    },
+  ])
+})
+
 // Value: protects=the earlier chat's leftover in the way of a generation; fails_when=the refusal loses its override or is shown after the confirmation; no_claim=which leftover (findUnacknowledgedWikiLeftover tests); seam=stand-ins
 test('another run in the way refuses the generation with its sentence and hands its override to the refusal', async () => {
   // Arrange
diff --git a/extension/src/tests/studyWorkspaceRemoval.test.ts b/extension/src/tests/studyWorkspaceRemoval.test.ts
index 6b192955a..da2a70a5e 100644
--- a/extension/src/tests/studyWorkspaceRemoval.test.ts
+++ b/extension/src/tests/studyWorkspaceRemoval.test.ts
@@ -10462,6 +10462,11 @@ test('a recorded run whose saves cannot look at its recording folder keeps its s
         ...input: Parameters<LearningLibrary['saveStudy']>
       ) {
         const recordingDirectory = input[1]?.recordingDirectory
+        // A background refresh can save this run before its recording exists (the save names no folder, so no look would refuse it). Saved, that save would leave the study kept and every later save would skip the look this test refuses (Cycle 0056 task 14); the library cannot be written until the test says so, as it cannot look at the folder.
+        if (recordingDirectory === undefined && isLookRefused)
+          throw Object.assign(new Error('EACCES: permission denied, lstat'), {
+            code: 'EACCES',
+          })
         if (recordingDirectory === undefined)
           return await saveStudy.apply(this, input)
         savesLookingAt.set(
diff --git a/extension/src/tests/utils/wikiUpdateWindow.ts b/extension/src/tests/utils/wikiUpdateWindow.ts
index 2df2eb678..30aeb6c1e 100644
--- a/extension/src/tests/utils/wikiUpdateWindow.ts
+++ b/extension/src/tests/utils/wikiUpdateWindow.ts
@@ -16,6 +16,8 @@ import { PREPARED_LOCK_SUFFIX } from '../../utils/preparedLockSuffix'
 import { readWikiPublicationIdentity } from '../../utils/readWikiPublicationIdentity'
 import { readWikiPublishToken } from '../../utils/readWikiPublishToken'
 import { readWikiWatchStamp } from '../../utils/readWikiWatchStamp'
+import * as refreshCursorMcpCatalogModule from '../../utils/refreshCursorMcpCatalog'
+import * as runUnderAbortSignalModule from '../../utils/runUnderAbortSignal'
 import { startWikiChatUpdate } from '../../utils/startWikiChatUpdate'
 import { waitForWikiPublish } from '../../utils/waitForWikiPublish'
 import type { WikiUpdateStatus } from '../../utils/wikiUpdateRun'
@@ -26,6 +28,25 @@ import { createFakeFileWatching, FakeRelativePattern } from './fakeFileWatching'
 import { listenTo } from './listenTo'
 import { loadModule } from './loadModule'
 
+/**
+ * Makes the `Date` a loaded module sees, whose `now()` answers a test's clock while `new Date(…)` stays real.
+ * @param clock - The test's present, in epoch milliseconds.
+ * @returns A `Date` subclass whose static `now` calls the clock.
+ * @example
+ * const ClockedDate = createClockedDate(() => 1_790_000_000_000)
+ * ClockedDate.now() // => 1_790_000_000_000 (a loaded module's `Date.now()` reads it)
+ */
+function createClockedDate(
+  clock: () => number,
+): new (...args: ConstructorParameters<typeof Date>) => Date {
+  class ClockedDate extends Date {
+    static override now(): number {
+      return clock()
+    }
+  }
+  return ClockedDate
+}
+
 /** 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. */
@@ -95,7 +116,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`), 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). */
+/** 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 before a start's claim on the marker begins (`claim-start`, after the start looked at the marker), 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'
@@ -104,6 +125,7 @@ export type HeldUpdateStep =
   | 'publish-token-read'
   | 'marker-change'
   | 'marker-write'
+  | 'claim-start'
   | 'claim-answer'
   | 'start-block'
   | 'publication-read'
@@ -186,6 +208,7 @@ export async function openWikiUpdateWindow(options: {
   cursorSkill?: {
     verify?: () => Promise<unknown>
     deploy?: () => Promise<unknown>
+    remove?: () => Promise<unknown>
   }
   answerConfirmation?: (
     message: string,
@@ -201,6 +224,12 @@ export async function openWikiUpdateWindow(options: {
   extraEditorCommands?: string[]
   /** Makes the editor refuse the file watcher of the LLM Wiki view with this message. */
   wikiWatcherFails?: string
+  /** Makes this many removals of the window's own run marker throw `EBUSY` before they work, as a scanner holding the file does on Windows; each is recorded in `markerChanges` as `threw`. */
+  markerReleaseFailures?: number
+  /** Makes this many turns of the window's own marker into a stopped watch's reservation (including a taken-over reservation written back) answer `false`, as when another window holds the claim on the marker at that moment; each is recorded in `markerChanges` with the answer `false`. */
+  markerReserveFailures?: number
+  /** Replaces `Date.now()` inside `extension.ts` itself (the utilities it requires keep the real clock), so a test can place the moment a Stop is pressed and the moment its rejection is handled in different minutes. */
+  clock?: () => number
 }): Promise<{
   chatRequests: Array<{ name: string; query: string }>
   executedCommands: string[]
@@ -218,6 +247,10 @@ export async function openWikiUpdateWindow(options: {
   skillCalls: string[]
   /** Every line the extension wrote to Output › Codebook, as `info: …` or `error: …`. */
   outputLines: string[]
+  /** How often the extension brought Output › Codebook to the front (`show()` on its channel). */
+  outputShownCount(): number
+  /** How many Cursor skill steps have begun to wait under their stop and bound: a step that follows an unsettled earlier one is then at its wait for that step. */
+  skillStepsStartedCount(): number
   /** 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. */
@@ -309,6 +342,10 @@ export async function openWikiUpdateWindow(options: {
   const confirmationDetails: string[] = []
   const skillCalls: string[] = []
   const outputLines: string[] = []
+  let outputShown = 0
+  let skillStepsStarted = 0
+  let markerReleaseFailuresLeft = options.markerReleaseFailures ?? 0
+  let markerReserveFailuresLeft = options.markerReserveFailures ?? 0
   const progressTitles: string[] = []
   const statusBarTexts: string[] = []
   const statusBarEntries: FakeStatusBarEntry[] = []
@@ -673,7 +710,9 @@ export async function openWikiUpdateWindow(options: {
           createOutputChannel: () => ({
             info: (line: string) => outputLines.push(`info: ${line}`),
             error: (line: string) => outputLines.push(`error: ${line}`),
-            show(): void {},
+            show(): void {
+              outputShown += 1
+            },
             dispose(): void {},
           }),
           showErrorMessage: (message: string, ...actions: string[]) =>
@@ -722,7 +761,30 @@ export async function openWikiUpdateWindow(options: {
           skillCalls.push('deploy')
           return options.cursorSkill?.deploy?.()
         },
-        removeManagedCursorSkill: async () => undefined,
+        // The removal records its call; nothing is removed from the learner's home.
+        removeManagedCursorSkill: async () => {
+          skillCalls.push('remove')
+          await options.cursorSkill?.remove?.()
+          return { status: 'removed' }
+        },
+      },
+      // Each Cursor skill step is counted when it begins to wait under its stop and bound; the step's body has by then run up to its first wait (for an earlier step, when one has not settled).
+      './utils/runUnderAbortSignal': {
+        ...runUnderAbortSignalModule,
+        runUnderAbortSignal: <Result>(
+          run: () => Promise<Result>,
+          signal: AbortSignal,
+        ): Promise<Result> => {
+          skillStepsStarted += 1
+          return runUnderAbortSignalModule.runUnderAbortSignal(run, signal)
+        },
+      },
+      // The removal's catalog step refuses at once, so a test of the skill's removal reads its warning and touches no Cursor config.
+      './utils/refreshCursorMcpCatalog': {
+        ...refreshCursorMcpCatalogModule,
+        captureOwnedCursorMcpCatalogGeneration: async () => {
+          throw new Error('No Cursor MCP catalog is used in this test.')
+        },
       },
       ...(options.constants
         ? { './constants': { ...constants, ...options.constants } }
@@ -762,20 +824,42 @@ export async function openWikiUpdateWindow(options: {
         claimWikiUpdateMarker: async (
           ...claimed: Parameters<typeof claimWikiUpdateMarker>
         ) => {
+          await passHold('claim-start')
           const claim = await claimWikiUpdateMarker(...claimed)
           looks.markerClaims += 1
           await passHold('claim-answer')
           if (!('release' in claim)) return claim
           return {
+            replacedReservation: claim.replacedReservation,
             release: async () => {
               await passHold('marker-change')
+              // A removal that the system refuses for now, as a scanner or an indexer holding the file does.
+              if (markerReleaseFailuresLeft > 0) {
+                markerReleaseFailuresLeft -= 1
+                return recordMarkerChange(
+                  'release',
+                  Promise.reject(
+                    Object.assign(new Error('EBUSY: resource busy or locked'), {
+                      code: 'EBUSY',
+                    }),
+                  ),
+                )
+              }
               return recordMarkerChange('release', claim.release())
             },
-            reserve: async (watchEndedAtMs: number) => {
+            reserve: async (
+              watchEndedAtMs: number,
+              takenOver?: Parameters<typeof claim.reserve>[1],
+            ) => {
               await passHold('marker-change')
+              // The claim on the marker could not be had at this moment: the marker stays as it was and the change is asked for again.
+              if (markerReserveFailuresLeft > 0) {
+                markerReserveFailuresLeft -= 1
+                return recordMarkerChange('reserve', Promise.resolve(false))
+              }
               return recordMarkerChange(
                 'reserve',
-                claim.reserve(watchEndedAtMs),
+                claim.reserve(watchEndedAtMs, takenOver),
               )
             },
           }
@@ -877,6 +961,8 @@ export async function openWikiUpdateWindow(options: {
           }),
       },
     },
+    // A test's clock reaches the `Date.now()` calls of `extension.ts` only; every other module keeps the real one.
+    options.clock ? { Date: createClockedDate(options.clock) } : {},
   )
   const contextSubscriptions: Array<{ dispose(): unknown }> = []
   boundary.activate({
@@ -915,6 +1001,8 @@ export async function openWikiUpdateWindow(options: {
     statusBarTexts,
     skillCalls,
     outputLines,
+    outputShownCount: (): number => outputShown,
+    skillStepsStartedCount: (): number => skillStepsStarted,
     async runCommand(name: string, ...args: unknown[]): Promise<void> {
       const command = commands.get(name)
       if (!command) throw new Error(`The window registered no ${name}.`)
diff --git a/extension/src/tests/wikiGenerateFlow.test.ts b/extension/src/tests/wikiGenerateFlow.test.ts
index 74306ac25..e99e14592 100644
--- a/extension/src/tests/wikiGenerateFlow.test.ts
+++ b/extension/src/tests/wikiGenerateFlow.test.ts
@@ -661,7 +661,7 @@ test('both no-Wiki notices, of Update LLM Wiki and of Open LLM Wiki in Browser,
   )
 })
 
-// Value: protects=D5, a second press while a generation runs; fails_when=the refusal calls the run an update or sends the learner to a browser reader the project does not have yet; no_claim=the other places of the progress (describeSecondWikiUpdateStart tests); seam=a Cursor agent held open
+// Value: protects=D5, a second press while a generation runs; fails_when=the refusal calls the run an update or sends the learner to a browser reader the project does not have yet, or the test reads the refusal after a fixed 200 ms race instead of awaiting its notice (Cycle 0056 task 6); no_claim=the other places of the progress (describeSecondWikiUpdateStart tests); seam=a Cursor agent held open
 test('a second Generate while a Cursor generation runs is refused with the sentence that Codebook is already generating, naming the notification', async (context) => {
   // Arrange: the agent works until the test lets it end.
   let endAgent = (): void => {}
@@ -680,14 +680,13 @@ test('a second Generate while a Cursor generation runs is refused with the sente
     6_000,
   )
 
-  // Act
-  await Promise.race([
-    project.runCommand(GENERATE_COMMAND),
-    new Promise((resolveWait) => setTimeout(resolveWait, 200)),
-  ])
+  // Act: the second press joins the run and settles with it, so the refusal is awaited as a notice, never as a fixed wait.
+  const second = project.runCommand(GENERATE_COMMAND)
+  await waitUntil(() => project.notices.length > 0, 'the refusal notice', 6_000)
   const refusal = project.notices[0]
   endAgent()
   await first
+  await second
 
   // Assert
   assert.equal(
@@ -1057,18 +1056,18 @@ test('closing a Cursor window while the managed skill is deployed for a generati
   const updating = await openCursorWindow()
   context.after(() => updating.close())
   await publishGeneratedWiki(updating.outputDirectory, updating.projectRoot)
-  const generatePressed = generating.runCommand(GENERATE_COMMAND)
-  const updatePressed = updating.runUpdateCommand()
+  // A closing window ends the skill step, so each press rejects at the close; the handlers stand from the start.
+  const generatePressed = generating
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  const updatePressed = updating.runUpdateCommand().catch(() => undefined)
   await Promise.all(deploymentsStarted)
 
   // Act: both windows close, then the deployments end.
   await generating.closeWindow()
   await updating.closeWindow()
   for (const endDeployment of heldDeployments) endDeployment()
-  await Promise.all([
-    generatePressed.catch(() => undefined),
-    updatePressed.catch(() => undefined),
-  ])
+  await Promise.all([generatePressed, updatePressed])
 
   // Assert
   assert.deepEqual(
diff --git a/extension/src/tests/wikiGenerateNotice.test.ts b/extension/src/tests/wikiGenerateNotice.test.ts
index 89255fd88..394f0efc7 100644
--- a/extension/src/tests/wikiGenerateNotice.test.ts
+++ b/extension/src/tests/wikiGenerateNotice.test.ts
@@ -108,7 +108,7 @@ test('each ended generation is told in its own sentence with the next step, and
     {
       severity: 'information',
       message:
-        'The LLM Wiki generation was stopped at 14:06, after an LLM Wiki was published in .codebook/wiki.',
+        'Codebook stopped watching the LLM Wiki generation at 14:06, after an LLM Wiki was published in .codebook/wiki.',
       actions: ['Open in Browser'],
     },
     {
@@ -194,3 +194,27 @@ test('a generation notice takes link syntax in a reason apart', () => {
     'LLM Wiki generation failed at 14:06: See [the log] (command:x).',
   )
 })
+
+// Value: protects=one verb for one stop in every notice of a generation (Cycle 0056 task 9): VS Code says Codebook stopped watching, Cursor says cancelled; fails_when=the notice of a stop after a publication says stopped in Cursor or says nothing of watching in VS Code, or the same act reads cancelled in one notice and stopped in its sibling; no_claim=the update's sentences, which keep their own words (describeWikiUpdate tests), and the bound's notice, which is no stop by the learner; seam=none
+test('a stop of a generation, with or without a publication before it, uses stopped watching in VS Code and cancelled in Cursor', () => {
+  // Arrange
+  const stops: WikiUpdateStatus[] = [
+    { ...ENDED, state: 'cancelled', site: 'kept' },
+    { ...ENDED, state: 'cancelled', site: 'replaced' },
+    { ...ENDED, host: 'cursor', state: 'cancelled', site: 'kept' },
+    { ...ENDED, host: 'cursor', state: 'cancelled', site: 'replaced' },
+  ]
+
+  // Act
+  const messages = stops.map(
+    (status) => wikiGenerateNotice(status, at)?.message,
+  )
+
+  // Assert
+  assert.deepEqual(messages, [
+    'Codebook stopped watching the LLM Wiki generation at 14:06. The chat may still publish; Codebook: Open LLM Wiki in Browser opens the Wiki once it does. To stop it, stop the request in the chat.',
+    'Codebook stopped watching the LLM Wiki generation at 14:06, after an LLM Wiki was published in .codebook/wiki.',
+    'LLM Wiki generation cancelled at 14:06. Cursor Agent was stopped; nothing was published.',
+    'The LLM Wiki generation was cancelled at 14:06, after an LLM Wiki was published in .codebook/wiki.',
+  ])
+})
diff --git a/extension/src/tests/wikiRunBoundMs.test.ts b/extension/src/tests/wikiRunBoundMs.test.ts
index 9853f7f2e..1316c242f 100644
--- a/extension/src/tests/wikiRunBoundMs.test.ts
+++ b/extension/src/tests/wikiRunBoundMs.test.ts
@@ -1,11 +1,9 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
-import {
-  LONGEST_WIKI_RUN_MS,
-  longestWikiRunMs,
-  wikiRunBoundMs,
-} from '../utils/wikiRunBoundMs'
+import { LONGEST_WIKI_RUN_MS } from '../constants'
+import { longestWikiRunMs } from '../utils/longestWikiRunMs'
+import { wikiRunBoundMs } from '../utils/wikiRunBoundMs'
 
 // Value: protects=Eng decision 74, every place that reads a run's bound; fails_when=a generation gets an update's 15 minutes in either host, an update's bounds change, or a marker of an earlier version (no kind) is read with a generation's bound; no_claim=where each place reads it (marker, leftover and host tests); seam=none
 test('a generation is bounded at 55 minutes in both hosts, while an update keeps 15 minutes in each and a run without a kind is an update', () => {
@@ -59,3 +57,20 @@ test('the longest a run lasts adds the chat’s 30 second opening in VS Code, an
     anyRun: 3_330_000,
   })
 })
+
+// Value: protects=Cycle 0056 pass 1 M4, the constant an unreadable marker file counts for; fails_when=LONGEST_WIKI_RUN_MS differs from the longest run over every kind and host (a bound or the chat's opening changed and the hand-listed constant did not); no_claim=where the constant is read (readLiveWikiUpdateMarker tests); seam=none
+test('the longest run any marker can stand for equals the longest of every kind and host', () => {
+  // Act
+  const longestOfEveryRun = Math.max(
+    longestWikiRunMs('generate', 'vscode'),
+    longestWikiRunMs('generate', 'cursor'),
+    longestWikiRunMs('update', 'vscode'),
+    longestWikiRunMs('update', 'cursor'),
+    longestWikiRunMs(undefined, 'vscode'),
+    longestWikiRunMs(undefined, 'cursor'),
+  )
+
+  // Assert
+  assert.equal(LONGEST_WIKI_RUN_MS, longestOfEveryRun)
+  assert.equal(LONGEST_WIKI_RUN_MS, 3_330_000)
+})
diff --git a/extension/src/tests/wikiRunLifecycleFlow.test.ts b/extension/src/tests/wikiRunLifecycleFlow.test.ts
new file mode 100644
index 000000000..27eefd901
--- /dev/null
+++ b/extension/src/tests/wikiRunLifecycleFlow.test.ts
@@ -0,0 +1,2072 @@
+import assert from 'node:assert/strict'
+import { mkdir, readFile, rm, utimes, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { test, type TestContext } from 'node:test'
+import { setTimeout as sleepFor } from 'node:timers/promises'
+
+import { WIKI_CURSOR_TERMINATION_GRACE_MS } from '../constants'
+import { waitUntil } from '../runtimeSupport/utils/waitUntil'
+import { claimWikiUpdateMarker } from '../utils/claimWikiUpdateMarker'
+import { formatClockTime } from '../utils/formatClockTime'
+import { WikiUpdateTimeoutError } from '../utils/wikiUpdateTimeoutError'
+
+import {
+  exists,
+  openProjectWithoutWiki,
+  publishGeneratedWiki,
+} from './utils/openProjectWithoutWiki'
+import type { CancellableProgress } from './utils/wikiUpdateWindow'
+
+const GENERATE_COMMAND = 'codebook.generateDeepWiki'
+const UPDATE_COMMAND = 'codebook.updateDeepWiki'
+const CANCEL_COMMAND = 'codebook.cancelWikiRun'
+const SHOW_OUTPUT_COMMAND = 'codebook.showWikiOutput'
+
+/** Lets every promise reaction that is already queued run, so a step that settled late has had its turn. */
+const flushQueuedReactions = (): Promise<void> =>
+  new Promise((resolveFlush) => setImmediate(resolveFlush))
+
+/** The window a test opened, as {@link openProjectWithoutWiki} returns it. */
+type ProjectWindow = Awaited<ReturnType<typeof openProjectWithoutWiki>>
+
+/** Replaces the learner's local time in a cancellation sentence, which differs by minute and locale. */
+const withoutClockTime = (sentence: string): string =>
+  sentence.replace(/at \d{1,2}:\d{2}(?:\s[AP]M)?/, 'at HH:MM')
+
+/**
+ * Waits until the window has written a taken-over reservation back, the observable end of a refused start that took one over.
+ * Why: the run's own claim already changes the marker's window id before the write-back, so a wait on the marker's content reads a state that is not yet the end under load; the answer of the window's own `reserve` is.
+ */
+const waitForWriteBack = async (
+  project: ProjectWindow,
+  wanted = 1,
+): Promise<void> => {
+  await waitUntil(
+    () =>
+      project.markerChanges.filter(
+        (change) => change.kind === 'reserve' && change.answer === true,
+      ).length >= wanted,
+    'the written-back reservation',
+    6_000,
+  )
+}
+
+/** Reads the window's own run marker as JSON, or `undefined` while none stands. */
+const readMarker = async (
+  markerPath: string,
+): Promise<Record<string, unknown> | undefined> =>
+  JSON.parse(await readFile(markerPath, 'utf8').catch(() => 'null')) ??
+  undefined
+
+/** Writes the reservation another VS Code window left when its generation stopped watching its chat. */
+async function writeOtherWindowReservation(
+  projectRoot: string,
+  markerPath: string,
+  watchEndedAtMs: number,
+  runKind: 'generate' | 'update' = 'generate',
+): Promise<void> {
+  await mkdir(join(projectRoot, '.codebook'), { recursive: true })
+  await writeFile(
+    markerPath,
+    JSON.stringify({
+      pid: process.pid,
+      windowId: 'the-other-window',
+      host: 'vscode',
+      startedAtMs: watchEndedAtMs - 60_000,
+      watchEndedAtMs,
+      // An update's marker never carried the field.
+      ...(runKind === 'generate' ? { runKind } : {}),
+    }),
+  )
+}
+
+// Value: protects=Cycle 0056 task 2, a press that joins a start under way; fails_when=Update LLM Wiki pressed while a Generate's start checks run joins it in silence, names the wrong run kind or says it more than once; no_claim=the press that meets a running run (describeSecondWikiUpdateStart tests); seam=the start-block step held open
+test('Update LLM Wiki pressed while a Generate’s start checks run says once that the press joins the generation', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki()
+  context.after(() => project.close())
+  const startChecks = project.hold('start-block')
+  const generating = project.runCommand(GENERATE_COMMAND)
+  await startChecks.started
+
+  // Act
+  const joining = project.runCommand(UPDATE_COMMAND)
+  await waitUntil(
+    () => project.notices.length > 0,
+    'the joined press’s notice',
+    6_000,
+  )
+  startChecks.release()
+  await generating
+  await joining
+
+  // Assert
+  assert.deepEqual(project.notices, [
+    'Codebook is already starting an LLM Wiki generation in this window; this press joins it.',
+  ])
+})
+
+// Value: protects=Cycle 0056 task 2 the other way round; fails_when=Generate pressed while an Update's start checks run joins it in silence or calls the update a generation; no_claim=the refusal of a Generate on a folder that holds a Wiki (wikiGenerateFlow tests); seam=the freshness inspection held open
+test('Generate LLM Wiki pressed while an Update’s start checks run says once that the press joins the update', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki()
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const startChecks = project.hold('freshness-inspection')
+  const updating = project.runCommand(UPDATE_COMMAND)
+  await startChecks.started
+
+  // Act
+  const joining = project.runCommand(GENERATE_COMMAND)
+  await waitUntil(
+    () => project.notices.length > 0,
+    'the joined press’s notice',
+    6_000,
+  )
+  startChecks.release()
+  await updating
+  await joining
+
+  // Assert
+  assert.deepEqual(project.notices, [
+    'Codebook is already starting an LLM Wiki update in this window; this press joins it.',
+  ])
+})
+
+// Value: protects=Cycle 0056 task 4, Codebook: Show LLM Wiki Output; fails_when=the command does not bring Output › Codebook to the front; no_claim=what the channel holds (wikiRunRecord tests); seam=the stubbed output channel
+test('Show LLM Wiki Output brings Output › Codebook to the front', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki()
+  context.after(() => project.close())
+  const shownBefore = project.outputShownCount()
+
+  // Act
+  await project.runCommand(SHOW_OUTPUT_COMMAND)
+
+  // Assert
+  assert.deepEqual(
+    { shownBefore, shownAfter: project.outputShownCount() },
+    { shownBefore: 0, shownAfter: 1 },
+  )
+})
+
+// Value: protects=Cycle 0056 task 4, Stop LLM Wiki Run in a window that runs and starts nothing; fails_when=the command stays silent, says a run is starting, or shows the old sentence that names generation or update; no_claim=the stop of a run (wikiGenerateFlow tests); seam=none
+test('Stop LLM Wiki Run in a window with no run says that no run is going on', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki()
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand(CANCEL_COMMAND)
+
+  // Assert
+  assert.deepEqual(project.notices, [
+    'No LLM Wiki run is going on in this window.',
+  ])
+})
+
+// Value: protects=Cycle 0056 task 5, the learner's Cancel of a Cursor generation; fails_when=Cancel does not abort the agent's signal (which ends its process group in the runner), the end is not told as cancelled, or the marker stays; no_claim=that the runner kills the process group (runCursorWikiUpdate tests); seam=a Cursor agent that ends when its signal aborts
+test('Cancel in the notification of a Cursor generation aborts the agent, tells the cancellation, records it and removes the marker', async (context) => {
+  // Arrange
+  const cancellable: CancellableProgress[] = []
+  let agentSignal: AbortSignal | undefined
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cancellable,
+    cursorAgent: (_root, _prompt, signal) =>
+      new Promise<string>((_resolveAgent, rejectAgent) => {
+        agentSignal = signal
+        signal?.addEventListener(
+          'abort',
+          () => rejectAgent(new Error('The Wiki generation was cancelled.')),
+          { once: true },
+        )
+      }),
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND)
+  await waitUntil(
+    () => cancellable.length > 0,
+    'the progress notification',
+    6_000,
+  )
+  const markerWhileRunning = await exists(project.markerPath)
+
+  // Act
+  cancellable[0]?.cancel()
+  await generating
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      markerWhileRunning,
+      agentWasAborted: agentSignal?.aborted,
+      notices: project.notices.map((notice) =>
+        notice.replace(/at \d{1,2}:\d{2}(?: [AP]M)?/, 'at HH:MM'),
+      ),
+      recordedEnds: project.outputLines.map(
+        (line) => /end=(\S+)/.exec(line)?.[1],
+      ),
+    },
+    {
+      markerWhileRunning: true,
+      agentWasAborted: true,
+      notices: [
+        'LLM Wiki generation cancelled at HH:MM. Cursor Agent was stopped; nothing was published.',
+      ],
+      recordedEnds: ['cancelled'],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 5, the 55 minute bound of a Cursor generation; fails_when=the agent is given another bound, or its bound error does not end the generation as timed out with the bound sentence and Generate LLM Wiki, or the marker stays; no_claim=that the runner times out after the bound (runCursorWikiUpdate tests); seam=a Cursor agent that spends the bound it is handed on a test clock and then throws the runner's timeout error
+test('a Cursor generation whose agent reaches the 55 minute bound ends as timed out with the bound sentence and removes its marker', async (context) => {
+  // Arrange: the test clock lets the agent spend its whole bound at once.
+  const clock = { spentMs: 0 }
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorAgent: async (_root, _prompt, _signal, timeoutMs = 0) => {
+      clock.spentMs += timeoutMs
+      throw new WikiUpdateTimeoutError('The Wiki generation timed out.')
+    },
+  })
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      spentMs: clock.spentMs,
+      errors: project.errors,
+      offered: project.offeredActions.map(({ actions }) => actions),
+      recordedEnds: project.outputLines.map(
+        (line) => /end=(\S+)/.exec(line)?.[1],
+      ),
+    },
+    {
+      spentMs: 3_300_000,
+      errors: [
+        'Codebook stopped waiting for the LLM Wiki generation after 55 minutes. Cursor Agent was stopped; nothing was published.',
+      ],
+      offered: [['Generate LLM Wiki']],
+      recordedEnds: ['timed-out'],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 11, a start that is refused after its claim while the system refuses the marker's removal once; fails_when=the first failed removal is the last, so the marker stands until its bound and blocks every window; no_claim=the retry's timing in production (the constant is shortened here); seam=a removal that throws EBUSY once and a retry delay of 20 ms
+test('a start refused after its claim removes its marker on the retry when the first removal fails', async (context) => {
+  // Arrange: a learner's own skill is in the way, and the first removal of the marker throws EBUSY.
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    markerReleaseFailures: 1,
+    constants: { WIKI_UPDATE_MARKER_CHANGE_RETRY_DELAY_MS: 20 },
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.markerChanges.at(1)?.answer !== undefined,
+    'the retry’s answer',
+    3_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      changes: project.markerChanges.map((change) => [
+        change.kind,
+        change.answer,
+      ]),
+      markerLeft: await exists(project.markerPath),
+    },
+    {
+      changes: [
+        ['release', 'threw'],
+        ['release', true],
+      ],
+      markerLeft: false,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 12 for a generation, the reservation of another window's stopped watch that Generate anyway took over, and its run kind (pass 1 SM6); fails_when=a Cursor skill conflict removes the marker, so the reservation's protection is gone while that chat may still publish, or the written-back generation loses its generate kind and so its 55 minute bound; no_claim=the bound the written-back reservation keeps (readLiveWikiUpdateMarker tests); seam=a reservation written by hand and the skill steps stubbed
+test('a skill conflict after Generate anyway writes the taken-over reservation back with its watch end', async (context) => {
+  // Arrange: another window's generation stopped watching a moment ago; the learner presses Generate anyway.
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND)
+  await waitUntil(
+    () => project.errors.length > 1,
+    'the skill conflict’s notice',
+    6_000,
+  )
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      conflictTold: project.errors[1],
+      reservationEndsAt: marker?.watchEndedAtMs,
+      reservationRunKind: marker?.runKind,
+    },
+    {
+      conflictTold:
+        'Codebook did not start the LLM Wiki generation: A Cursor skill named codebook that Codebook does not own is in the way.',
+      reservationEndsAt: watchEndedAtMs,
+      reservationRunKind: 'generate',
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 M1, the protection of a reservation written back after a refused start; fails_when=the second press of Generate anyway releases the written-back reservation because this window no longer knows it, so the chat that may still publish loses its marker; no_claim=the first write-back (test above); seam=a reservation written by hand and the skill steps stubbed
+test('a second Generate anyway that meets the skill conflict again keeps the written-back reservation with its original end', async (context) => {
+  // Arrange: another window's generation stopped watching a moment ago; the skill is in the way both times.
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+
+  // Act: the press meets the conflict again and its command rejects with it.
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.errors.length > 2,
+    'the second skill conflict’s notice',
+    6_000,
+  )
+  await flushQueuedReactions()
+  await waitUntil(
+    () => project.markerChanges.filter((change) => change.answer).length >= 2,
+    'the second write-back',
+    6_000,
+  )
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      reservationEndsAt: marker?.watchEndedAtMs,
+      changes: project.markerChanges.map((change) => change.kind),
+    },
+    { reservationEndsAt: watchEndedAtMs, changes: ['reserve', 'reserve'] },
+  )
+})
+
+// Value: protects=Cycle 0056 M1, the bound of a written-back reservation; fails_when=a reservation written back after a refused start is never removed at its bound, so it blocks every other window until the marker's own expiry; no_claim=the bound of a reservation the run left itself (marker bookkeeping tests); seam=the watch bound shortened to 600 ms and a reservation that ended 400 ms ago
+test('a reservation written back after a skill conflict is removed at its watch bound', async (context) => {
+  // Arrange: the other window's watch ended 400 ms ago and this window's bound is 600 ms.
+  const watchEndedAtMs = Date.now() - 400
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_UPDATE_WATCH_TIMEOUT_MS: 600 },
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+    'update',
+  )
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the removal at the bound',
+    6_000,
+  )
+
+  // Assert
+  assert.equal(await exists(project.markerPath), false)
+})
+
+// Value: protects=Cycle 0056 CR1, the kind of a taken-over reservation; fails_when=an update's reservation taken over by Generate anyway is written back as a generation's (a runKind of generate and so the generation's longer bound), or an update's reservation gets a runKind field its format never had; no_claim=a generation's reservation written back (test above); seam=an update's reservation written by hand and the skill steps stubbed
+test('an update’s reservation taken over by Generate anyway is written back as an update’s, without a run kind', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+    'update',
+  )
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      reservationEndsAt: marker?.watchEndedAtMs,
+      hasRunKind: 'runKind' in (marker ?? {}),
+    },
+    { reservationEndsAt: watchEndedAtMs, hasRunKind: false },
+  )
+})
+
+// Value: protects=Cycle 0056 L1, the reservation a claim takes over; fails_when=the written-back end is the one read before the claim although another window replaced the reservation meanwhile; no_claim=a marker nobody replaced (tests above); seam=the claim held before it begins while the other window writes a later reservation
+test('a reservation another window writes between the start’s look and its claim is the one written back after a skill conflict', async (context) => {
+  // Arrange: the first reservation ended long ago; a later one replaces it while the start waits to claim.
+  const firstEndedAtMs = Date.now() - 4_000
+  const laterEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    firstEndedAtMs,
+  )
+  const claimStart = project.hold('claim-start')
+
+  // Act
+  const pressing = project.runCommand(GENERATE_COMMAND)
+  await claimStart.started
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    laterEndedAtMs,
+  )
+  claimStart.release()
+  await pressing
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.equal(marker?.watchEndedAtMs, laterEndedAtMs)
+})
+
+// Value: protects=Cycle 0056 task 12 for an update, the same reservation taken over by Update anyway; fails_when=the refused update removes the marker instead of writing the reservation back; no_claim=a reservation of this window's own stopped watch (the marker bookkeeping tests); seam=a reservation written by hand and the skill steps stubbed
+test('a skill conflict after Update anyway writes the taken-over reservation back with its watch end', async (context) => {
+  // Arrange: a Wiki stands, and another window's generation stopped watching a moment ago.
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Update anyway') ? 'Update anyway' : undefined,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill was changed.')
+      },
+      deploy: async () => {
+        throw new Error(
+          'A Cursor skill named codebook that Codebook does not own is in the way.',
+        )
+      },
+    },
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  // The Wiki was published before the watch ended, so that chat is still waited for.
+  const publishedAt = new Date(watchEndedAtMs - 10_000)
+  await utimes(
+    join(project.outputDirectory, 'codebook-wiki.json'),
+    publishedAt,
+    publishedAt,
+  )
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+
+  // Act
+  await project.runUpdateCommand()
+  await waitUntil(
+    () => project.errors.length > 1,
+    'the skill conflict’s notice',
+    6_000,
+  )
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      conflictTold: project.errors.at(-1),
+      reservationEndsAt: marker?.watchEndedAtMs,
+    },
+    {
+      conflictTold:
+        'Codebook could not start the Wiki update: A Cursor skill named codebook that Codebook does not own is in the way.',
+      reservationEndsAt: watchEndedAtMs,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13, Stop LLM Wiki Run during the Cursor skill step of a generation; fails_when=Stop only says the run is starting while the step goes on with the marker claimed, or the start ends without the stop sentence, or an agent starts; no_claim=the skill file a step wrote before the stop (it stays, and the managed skill is then current); seam=a verify step that never settles
+test('Stop LLM Wiki Run during a generation’s Cursor skill step ends the start with the stop sentence, releases the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+  const markerWhileReadying = await exists(project.markerPath)
+
+  // Act
+  await project.runCommand(CANCEL_COMMAND)
+  await generating
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      markerWhileReadying,
+      errors: project.errors.map(withoutClockTime),
+      notices: project.notices,
+      agentRuns,
+    },
+    {
+      markerWhileReadying: true,
+      errors: [
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+      ],
+      notices: [],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13 for an update; fails_when=Stop during the skill step of an update names a generation, leaves the marker or starts the agent; no_claim=the generation's wording (test above); seam=a verify step that never settles
+test('Stop LLM Wiki Run during an update’s Cursor skill step ends the start with the stop sentence for an update and releases the marker', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Done.'
+    },
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const updating = project.runUpdateCommand().catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+
+  // Act
+  await project.runCommand(CANCEL_COMMAND)
+  await updating
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { errors: project.errors.map(withoutClockTime), agentRuns },
+    {
+      errors: [
+        'Codebook could not start the Wiki update: The LLM Wiki update was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Update LLM Wiki when you want to start again.',
+      ],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13, the bound of the Cursor skill step; fails_when=a skill step that never settles holds the marker and the start for ever, or the sentence names no bound and no next step; no_claim=the production bound of 30 seconds (the constant test and the sentence unit test); seam=a verify step that never settles and a bound shortened to one second
+test('a generation whose Cursor skill step passes its bound ends the start with the bound sentence, releases the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_SKILL_STEP_TIMEOUT_MS: 1_000 },
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { errors: project.errors, agentRuns },
+    {
+      errors: [
+        'Codebook did not start the LLM Wiki generation: Codebook stopped readying the Cursor skill after 1 second; no agent was started. Press Generate LLM Wiki again, or run Codebook: Set Up AI Chat.',
+      ],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13, a deploy that settles after the stop; fails_when=its late result starts the agent, shows a second notice or leaves the marker; no_claim=the skill file the deploy wrote (it stays); seam=a deploy the test settles after the stop
+test('a Cursor skill deploy that settles after Stop LLM Wiki Run starts no agent and tells nothing more', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  let settleDeploy = (): void => {}
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () =>
+        new Promise<void>((resolveDeploy) => {
+          settleDeploy = resolveDeploy
+        }),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the deploy step',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await generating
+
+  // Act
+  settleDeploy()
+  await flushQueuedReactions()
+
+  // Assert
+  assert.deepEqual(
+    {
+      skillCalls: project.skillCalls,
+      errors: project.errors.length,
+      agentRuns,
+      markerLeft: await exists(project.markerPath),
+    },
+    {
+      skillCalls: ['verify', 'deploy'],
+      errors: 1,
+      agentRuns: 0,
+      markerLeft: false,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 task 13, a verify that fails after the stop; fails_when=the late failure goes on to deploy a skill the learner stopped waiting for; no_claim=a deploy that was already under way (test above); seam=a verify the test fails after the stop
+test('a Cursor skill verify that fails after Stop LLM Wiki Run does not go on to deploy', async (context) => {
+  // Arrange
+  let failVerify = (): void => {}
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: () =>
+        new Promise<never>((_resolveVerify, rejectVerify) => {
+          failVerify = (): void =>
+            rejectVerify(new Error('The managed Cursor skill is missing.'))
+        }),
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await generating
+
+  // Act
+  failVerify()
+  await flushQueuedReactions()
+
+  // Assert
+  assert.deepEqual(project.skillCalls, ['verify'])
+})
+
+// Value: protects=Cycle 0056 L3, one deploy of the managed Cursor skill at a time; fails_when=a press after Stop starts another verify and deploy while the stopped step's deploy still writes the skill; no_claim=the stopped step's own end (tests above); seam=a deploy the test settles, and the harness's count of skill steps that began their wait
+test('a Generate pressed after Stop waits for the stopped deploy to settle, so two deploys never run at once', async (context) => {
+  // Arrange
+  let runningDeploys = 0
+  let mostRunningDeploys = 0
+  const settleDeploys: Array<() => void> = []
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () =>
+        new Promise<void>((resolveDeploy) => {
+          runningDeploys += 1
+          mostRunningDeploys = Math.max(mostRunningDeploys, runningDeploys)
+          settleDeploys.push(() => {
+            runningDeploys -= 1
+            resolveDeploy()
+          })
+        }),
+    },
+    cursorAgent: async () => 'Published.',
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+
+  // Act: the second press starts while the first deploy has not settled.
+  const secondPress = project
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  // The second step has begun and stands at its wait for the stopped one, whose deploy has not settled.
+  await waitUntil(
+    () => project.skillStepsStartedCount() === 2,
+    'the second skill step’s wait for the first',
+    6_000,
+  )
+  await flushQueuedReactions()
+  const callsWhileFirstSettles = [...project.skillCalls]
+  settleDeploys[0]?.()
+  await waitUntil(() => settleDeploys.length === 2, 'the second deploy', 6_000)
+  await project.runCommand(CANCEL_COMMAND)
+  await secondPress
+  settleDeploys[1]?.()
+
+  // Assert
+  assert.deepEqual(
+    { callsWhileFirstSettles, mostRunningDeploys },
+    { callsWhileFirstSettles: ['verify', 'deploy'], mostRunningDeploys: 1 },
+  )
+})
+
+/** Stubs of the managed Cursor skill whose verify and deploy both refuse, as a skill of the learner's own in the way does. */
+const SKILL_IN_THE_WAY = {
+  verify: async (): Promise<void> => {
+    throw new Error('The managed Cursor skill was changed.')
+  },
+  deploy: async (): Promise<void> => {
+    throw new Error(
+      'A Cursor skill named codebook that Codebook does not own is in the way.',
+    )
+  },
+}
+
+// Value: protects=Cycle 0056 pass 1 RT1, the owner of a taken-over reservation that is written back; fails_when=a VS Code window's reservation taken over by a Cursor start is written back as the Cursor start's own (host cursor, this window), so the VS Code watch bound no longer applies to it and it can block every window as long as the Cursor process lives; no_claim=the bound's removal (test below); seam=a reservation written by hand and the skill steps stubbed
+test('a VS Code reservation taken over by a Cursor start and written back after a skill conflict stays that VS Code window’s', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: SKILL_IN_THE_WAY,
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      host: marker?.host,
+      windowId: marker?.windowId,
+      pid: marker?.pid,
+      startedAtMs: marker?.startedAtMs,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+    },
+    {
+      host: 'vscode',
+      windowId: 'the-other-window',
+      pid: process.pid,
+      startedAtMs: watchEndedAtMs - 60_000,
+      watchEndedAtMs,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 SM1 and T2, the closing window's write-back of an update's taken-over reservation; fails_when=a window that begins to close during an Update anyway's claim removes the other window's reservation instead of writing it back, or writes it back as its own; no_claim=the skill step's stop at the close (test below); seam=the claim held open while the window closes
+test('Update anyway over another window’s reservation, with this window closing during the claim, writes the reservation back as it was', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Update anyway') ? 'Update anyway' : undefined,
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const publishedAt = new Date(watchEndedAtMs - 10_000)
+  await utimes(
+    join(project.outputDirectory, 'codebook-wiki.json'),
+    publishedAt,
+    publishedAt,
+  )
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  const claimAnswer = project.hold('claim-answer')
+  const updating = project.runUpdateCommand().catch(() => undefined)
+  await claimAnswer.started
+
+  // Act: the window closes while the claim has answered and the start has not read the answer.
+  await project.closeWindow()
+  claimAnswer.release()
+  await updating
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      host: marker?.host,
+      windowId: marker?.windowId,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      hasRunKind: 'runKind' in (marker ?? {}),
+    },
+    {
+      host: 'vscode',
+      windowId: 'the-other-window',
+      watchEndedAtMs,
+      hasRunKind: true,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 SM2 and T2, the closing window's write-back of a generation's taken-over reservation; fails_when=a window that begins to close during a Generate anyway's claim removes the other window's reservation, or writes it back without its generation kind; no_claim=the skill step's stop at the close (test below); seam=the claim held open while the window closes
+test('Generate anyway over another window’s reservation, with this window closing during the claim, writes the reservation back as it was', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  const claimAnswer = project.hold('claim-answer')
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await claimAnswer.started
+
+  // Act
+  await project.closeWindow()
+  claimAnswer.release()
+  await generating
+  await waitForWriteBack(project)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      host: marker?.host,
+      windowId: marker?.windowId,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      runKind: marker?.runKind,
+    },
+    {
+      host: 'vscode',
+      windowId: 'the-other-window',
+      watchEndedAtMs,
+      runKind: 'generate',
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 RT2, a window that closes during the Cursor skill step; fails_when=the closing window leaves the start's claimed marker in place until its bound although no run exists, so every other window is refused for up to 55 minutes; no_claim=the reservation's later removal at the bound (test above); seam=a verify step that never settles
+test('a window that closes during a generation’s Cursor skill step ends the step, removes the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+  const markerWhileReadying = await exists(project.markerPath)
+
+  // Act: the marker is read the moment the window's shutdown is done, not when the step's bound would have ended it.
+  await project.closeWindow()
+  const markerLeft = await exists(project.markerPath)
+  await generating
+
+  // Assert
+  assert.deepEqual(
+    {
+      markerWhileReadying,
+      markerLeft,
+      agentRuns,
+    },
+    { markerWhileReadying: true, markerLeft: false, agentRuns: 0 },
+  )
+})
+
+/** Holds a Cursor skill step open in a window that took another window's reservation over, closes the window, and returns the marker on disk right after the shutdown and how often the agent ran. */
+async function closeWindowDuringSkillStepOverReservation(
+  context: TestContext,
+  kind: 'generate' | 'update',
+  watchEndedAtMs: number,
+  windowOptions: { markerReserveFailures?: number } = {},
+): Promise<{
+  marker: Record<string, unknown> | undefined
+  agentRuns: number
+}> {
+  let agentRuns = 0
+  const anyway = kind === 'update' ? 'Update anyway' : 'Generate anyway'
+  const project = await openProjectWithoutWiki({
+    ...windowOptions,
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes(anyway) ? anyway : undefined,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Done.'
+    },
+  })
+  context.after(() => project.close())
+  if (kind === 'update') {
+    await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+    const publishedAt = new Date(watchEndedAtMs - 10_000)
+    await utimes(
+      join(project.outputDirectory, 'codebook-wiki.json'),
+      publishedAt,
+      publishedAt,
+    )
+  }
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  const starting =
+    kind === 'update'
+      ? project.runUpdateCommand().catch(() => undefined)
+      : project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+  // The marker is read the moment the window's shutdown is done, not when the step's bound would have ended it.
+  await project.closeWindow()
+  const marker = await readMarker(project.markerPath)
+  await starting
+  return { marker, agentRuns }
+}
+
+// Value: protects=Cycle 0056 pass 2 SM-A, the reservation of another window's stopped watch that a closing window wrote back; fails_when=the closing window drops the reservation it wrote back after Update anyway, so the other window's chat that may still publish loses its protection, or the written-back marker is this window's; no_claim=this window's own reservation at close (stopExtension tests); seam=a verify step that never settles and a reservation written by hand
+test('a window that closes during an update’s Cursor skill step after Update anyway leaves the other window’s reservation on disk', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+
+  // Act
+  const { marker, agentRuns } = await closeWindowDuringSkillStepOverReservation(
+    context,
+    'update',
+    watchEndedAtMs,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      windowId: marker?.windowId,
+      host: marker?.host,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      runKind: marker?.runKind,
+      agentRuns,
+    },
+    {
+      windowId: 'the-other-window',
+      host: 'vscode',
+      watchEndedAtMs,
+      runKind: 'generate',
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 2 SM-B, the generation twin of SM-A; fails_when=a window that closes during a Generate anyway's skill step drops the other window's reservation it wrote back; no_claim=the update's wording (test above); seam=a verify step that never settles and a reservation written by hand
+test('a window that closes during a generation’s Cursor skill step after Generate anyway leaves the other window’s reservation on disk', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+
+  // Act
+  const { marker, agentRuns } = await closeWindowDuringSkillStepOverReservation(
+    context,
+    'generate',
+    watchEndedAtMs,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      windowId: marker?.windowId,
+      host: marker?.host,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      runKind: marker?.runKind,
+      agentRuns,
+    },
+    {
+      windowId: 'the-other-window',
+      host: 'vscode',
+      watchEndedAtMs,
+      runKind: 'generate',
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 2 SM-C, a window that closes while the skill's deploy never settles; fails_when=shutdown waits for the hung deploy beyond the termination grace, leaves the start's marker, or lets an agent start; no_claim=a hung verify (tests above); seam=a verify that reports a missing skill and a deploy that never settles
+test('a window that closes while the Cursor skill deploy never settles shuts down within the grace, removes the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the hung deploy',
+    6_000,
+  )
+
+  // Act
+  const closeStartedAtMs = Date.now()
+  await project.closeWindow()
+  const shutdownMs = Date.now() - closeStartedAtMs
+  const markerLeft = await exists(project.markerPath)
+  await generating
+
+  // Assert: the limit is the grace itself, so a loaded machine cannot flake the claim "within the grace".
+  assert.deepEqual(
+    {
+      isShutdownInsideGrace: shutdownMs < WIKI_CURSOR_TERMINATION_GRACE_MS,
+      markerLeft,
+      agentRuns,
+    },
+    { isShutdownInsideGrace: true, markerLeft: false, agentRuns: 0 },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 SM3, the bound of the Cursor skill step in an update; fails_when=an update whose skill step passes its bound holds the marker for ever, names a generation or no bound, or starts the agent; no_claim=the generation's bound (test above); seam=a verify step that never settles and a bound shortened to one second
+test('an update whose Cursor skill step passes its bound ends the start with the bound sentence for an update, releases the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_SKILL_STEP_TIMEOUT_MS: 1_000 },
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Done.'
+    },
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+
+  // Act
+  await project.runUpdateCommand().catch(() => undefined)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { errors: project.errors, agentRuns },
+    {
+      errors: [
+        'Codebook could not start the Wiki update: Codebook stopped readying the Cursor skill after 1 second; no agent was started. Press Update LLM Wiki again, or run Codebook: Set Up AI Chat.',
+      ],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 SM4, the bound while the skill's deploy hangs; fails_when=a deploy that never settles holds the start and its marker past the bound, or the bound sentence is not told; no_claim=a verify that hangs (test above); seam=a verify that reports a missing skill, a deploy that never settles and a bound shortened to one second
+test('a generation whose Cursor skill deploy never settles ends at the bound with the bound sentence, releases the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_SKILL_STEP_TIMEOUT_MS: 1_000 },
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { errors: project.errors, skillCalls: project.skillCalls, agentRuns },
+    {
+      errors: [
+        'Codebook did not start the LLM Wiki generation: Codebook stopped readying the Cursor skill after 1 second; no agent was started. Press Generate LLM Wiki again, or run Codebook: Set Up AI Chat.',
+      ],
+      skillCalls: ['verify', 'deploy'],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 1 SM5, a press while an earlier stopped verify still hangs; fails_when=the second step does not wait for the hung verify (a second verify starts) or its own Stop does not end it with the stop sentence and a removed marker; no_claim=an earlier deploy (L3 test); seam=a verify that never settles
+test('a Generate pressed while a stopped step’s verify still hangs waits for it and ends with its own Stop', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the first verify',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+  const secondPress = project
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  await waitUntil(
+    async () => await exists(project.markerPath),
+    'the second start’s claim',
+    6_000,
+  )
+
+  // Act: a Stop before the second step began only says the run is starting, so it is pressed until the step ends.
+  await waitUntil(
+    async () => {
+      await project.runCommand(CANCEL_COMMAND)
+      return project.errors.length >= 2
+    },
+    'the second step’s stop sentence',
+    6_000,
+  )
+  await secondPress
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      skillCalls: project.skillCalls,
+      errors: project.errors.map(withoutClockTime),
+    },
+    {
+      skillCalls: ['verify'],
+      errors: [
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+      ],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 2 RT-B, the bound firing while an earlier stopped deploy never settles; fails_when=the second start says only that it timed out although the cause is the hung step of this window, leaves its marker, or starts an agent; no_claim=a Stop of the second step (test above); seam=a deploy that never settles and a bound shortened to one second
+test('a Generate pressed after a stopped step whose deploy never settles ends at its own bound saying the earlier step is still running and releases the marker', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_SKILL_STEP_TIMEOUT_MS: 1_000 },
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      skillCalls: project.skillCalls,
+      lastError: project.errors.at(-1),
+      agentRuns,
+    },
+    {
+      skillCalls: ['verify', 'deploy'],
+      lastError:
+        'Codebook did not start the LLM Wiki generation: Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press Generate LLM Wiki again.',
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 2 RT-A, the owner of a reservation that two refused starts in a row write back; fails_when=the second refused start writes this window's record (host cursor, this window's id) over the other window's VS Code reservation; no_claim=the first write-back (test above); seam=a reservation written by hand and the skill steps stubbed
+test('two refused starts in a row over a VS Code window’s reservation leave it that window’s marker', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: SKILL_IN_THE_WAY,
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitForWriteBack(project, 2)
+
+  // Assert
+  const marker = await readMarker(project.markerPath)
+  assert.deepEqual(
+    {
+      host: marker?.host,
+      windowId: marker?.windowId,
+      startedAtMs: marker?.startedAtMs,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      runKind: marker?.runKind,
+    },
+    {
+      host: 'vscode',
+      windowId: 'the-other-window',
+      startedAtMs: watchEndedAtMs - 60_000,
+      watchEndedAtMs,
+      runKind: 'generate',
+    },
+  )
+})
+
+/** Presses Stop LLM Wiki Run until the window has told this many ends of a start, which is when the step under way took the stop (a Stop before the step began only says the run is starting). */
+const stopUntilErrorsTold = async (
+  project: ProjectWindow,
+  errorCount: number,
+): Promise<void> => {
+  await waitUntil(
+    async () => {
+      await project.runCommand(CANCEL_COMMAND)
+      return project.errors.length >= errorCount
+    },
+    `the ${errorCount}. stop sentence`,
+    6_000,
+  )
+}
+
+// Value: protects=Cycle 0056 pass 3 SM3-A, a generation start of a window that closed between its claim and the Cursor skill step; fails_when=the step still runs verify or deploy for up to 30 seconds after the window began to close, or the marker stays, or an agent starts; no_claim=a window that closes inside the step (tests above); seam=the claim's answer held open while the window closes
+test('a window that closes between a generation’s claim and its Cursor skill step runs no verify or deploy, removes the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const claimAnswer = project.hold('claim-answer')
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await claimAnswer.started
+
+  // Act
+  await project.closeWindow()
+  claimAnswer.release()
+  await generating
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { skillCalls: project.skillCalls, agentRuns },
+    { skillCalls: [], agentRuns: 0 },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 SM3-B, the update twin of SM3-A; fails_when=an update start of a window that closed after its claim still runs verify or deploy, leaves the marker or starts an agent; no_claim=the generation's start (test above); seam=the claim's answer held open while the window closes
+test('a window that closes between an update’s claim and its Cursor skill step runs no verify or deploy, removes the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Done.'
+    },
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const claimAnswer = project.hold('claim-answer')
+  const updating = project.runUpdateCommand().catch(() => undefined)
+  await claimAnswer.started
+
+  // Act
+  await project.closeWindow()
+  claimAnswer.release()
+  await updating
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { skillCalls: project.skillCalls, agentRuns },
+    { skillCalls: [], agentRuns: 0 },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 SM3-C, a window that closes while a second press waits for an earlier hung deploy; fails_when=shutdown waits for the hung deploy beyond the grace, the second start's marker stays, or an agent starts; no_claim=the second press's own Stop (tests above); seam=a deploy that never settles
+test('a window that closes while a second press waits for an earlier hung deploy shuts down within the grace, removes the marker and starts no agent', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+  const secondPress = project
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  await waitUntil(
+    async () => await exists(project.markerPath),
+    'the second start’s claim',
+    6_000,
+  )
+  // The second start has no verify to show for itself; a moment lets it reach its wait for the first deploy.
+  await flushQueuedReactions()
+  await waitUntil(() => project.errors.length === 1, 'the first end', 6_000)
+
+  // Act
+  const closeStartedAtMs = Date.now()
+  await project.closeWindow()
+  const shutdownMs = Date.now() - closeStartedAtMs
+  await secondPress
+  const markerLeft = await exists(project.markerPath)
+
+  // Assert
+  assert.deepEqual(
+    {
+      isShutdownInsideGrace: shutdownMs < WIKI_CURSOR_TERMINATION_GRACE_MS,
+      markerLeft,
+      skillCalls: project.skillCalls,
+      agentRuns,
+    },
+    {
+      isShutdownInsideGrace: true,
+      markerLeft: false,
+      skillCalls: ['verify', 'deploy'],
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 SM3-D, three presses against one hung deploy; fails_when=the third press starts a deploy beside the hung one (it waits for the second step, which waits for the first) or any press ends without its own stop sentence; no_claim=the second press alone (L3 test); seam=a deploy that never settles
+test('three presses against one hung deploy start one deploy only and each ends with its own stop sentence', async (context) => {
+  // Arrange
+  let deployCalls = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => {
+        deployCalls += 1
+        return new Promise<void>(() => {})
+      },
+    },
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+
+  // Act
+  const secondPress = project
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  await stopUntilErrorsTold(project, 2)
+  await secondPress
+  const thirdPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await stopUntilErrorsTold(project, 3)
+  await thirdPress
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    { deployCalls, errors: project.errors.map(withoutClockTime) },
+    {
+      deployCalls: 1,
+      errors: [
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+        'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+      ],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 T3-B, Stop pressed while the second step waits for the hung earlier deploy; fails_when=the waiting step answers the earlier-step sentence (which blames the earlier step and sends the learner to Reload Window) instead of its own cancellation; no_claim=the bound ending a waiting step (RT-B tests); seam=a deploy that never settles
+test('Stop LLM Wiki Run while a second step waits for a hung earlier deploy tells the cancellation, not that an earlier step is running', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+  })
+  context.after(() => project.close())
+  const firstPress = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+
+  // Act
+  const secondPress = project
+    .runCommand(GENERATE_COMMAND)
+    .catch(() => undefined)
+  await stopUntilErrorsTold(project, 2)
+  await secondPress
+
+  // Assert
+  assert.equal(
+    withoutClockTime(project.errors[1] ?? ''),
+    'Codebook did not start the LLM Wiki generation: The LLM Wiki generation was cancelled at HH:MM while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.',
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 T3-B, the update twin of RT-B; fails_when=an update that waits for a hung earlier deploy and reaches its bound says only that it timed out, names a generation, leaves its marker or starts an agent; no_claim=the generation's wording (RT-B test above); seam=a deploy that never settles and a bound shortened to one second
+test('an Update pressed after a stopped step whose deploy never settles ends at its own bound saying the earlier step is still running and releases the marker', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_SKILL_STEP_TIMEOUT_MS: 1_000 },
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Done.'
+    },
+  })
+  context.after(() => project.close())
+  await publishGeneratedWiki(project.outputDirectory, project.projectRoot)
+  const firstPress = project.runUpdateCommand().catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the first deploy',
+    6_000,
+  )
+  await project.runCommand(CANCEL_COMMAND)
+  await firstPress
+
+  // Act
+  await project.runUpdateCommand().catch(() => undefined)
+  await waitUntil(
+    async () => !(await exists(project.markerPath)),
+    'the marker’s removal',
+    6_000,
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      skillCalls: project.skillCalls,
+      lastError: project.errors.at(-1),
+      agentRuns,
+    },
+    {
+      skillCalls: ['verify', 'deploy'],
+      lastError:
+        'Codebook could not start the Wiki update: Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press Update LLM Wiki again.',
+      agentRuns: 0,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 RT3-A, the original owner's release of a reservation that another window took over and wrote back; fails_when=the written-back marker is not the owner's text byte for byte, so the owner's release, bound timer or close finds "not my text" and leaves the marker for the whole bound; no_claim=the claim's byte-identical write-back (claimWikiUpdateMarker test); seam=a real claim of another window and the skill steps stubbed
+test('a reservation written back after a refused start is still removed by the window that left it', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: SKILL_IN_THE_WAY,
+  })
+  context.after(() => project.close())
+  await mkdir(join(project.projectRoot, '.codebook'), { recursive: true })
+  const ownerClaim = await claimWikiUpdateMarker(project.outputDirectory, {
+    pid: process.pid,
+    windowId: 'window-a',
+    host: 'vscode',
+    startedAtMs: Date.now() - 60_000,
+    runKind: 'generate',
+  })
+  assert.ok('reserve' in ownerClaim)
+  await ownerClaim.reserve(Date.now() - 1_000)
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+  const markerWhileWrittenBack = await readMarker(project.markerPath)
+
+  // Act: the window that left the reservation ends its bound or closes.
+  await ownerClaim.release()
+
+  // Assert
+  assert.deepEqual(
+    {
+      windowIdWhileWrittenBack: markerWhileWrittenBack?.windowId,
+      markerLeft: await exists(project.markerPath),
+    },
+    { windowIdWhileWrittenBack: 'window-a', markerLeft: false },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 A1, a written-back reservation that its owner has removed since; fails_when=a second refused start restores the owner's finished reservation from this window's memory, so every window is blocked for up to the generate bound by a chat that has ended; no_claim=a reservation still on disk (RT-A test above); seam=a reservation written by hand and removed by hand
+test('a second refused start after the original owner removed its written-back reservation leaves no marker', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? 'Generate anyway' : undefined,
+    cursorSkill: SKILL_IN_THE_WAY,
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    watchEndedAtMs,
+  )
+  await project.runCommand(GENERATE_COMMAND)
+  await waitForWriteBack(project)
+  // The other window's chat ended and its window removed the reservation.
+  await rm(project.markerPath)
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+
+  // Assert
+  assert.equal(await exists(project.markerPath), false)
+})
+
+// Value: protects=Cycle 0056 pass 3 RT3-B and the adversarial P2, a write-back that fails while the window closes; fails_when=the failed write-back is dropped at the close, so the marker stays this window's start marker and the other window's chat loses its protection; no_claim=a write-back that works at once (SM-A tests); seam=the window's turn of the marker answering false twice, as when another window holds the claim
+test('a window that closes while the claim on the marker is held writes the other window’s reservation back within the grace', async (context) => {
+  // Arrange
+  const watchEndedAtMs = Date.now() - 1_000
+  const { marker, agentRuns } = await closeWindowDuringSkillStepOverReservation(
+    context,
+    'generate',
+    watchEndedAtMs,
+    { markerReserveFailures: 2 },
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      windowId: marker?.windowId,
+      watchEndedAtMs: marker?.watchEndedAtMs,
+      agentRuns,
+    },
+    { windowId: 'the-other-window', watchEndedAtMs, agentRuns: 0 },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 RT3-C, Remove Managed Cursor Skill during a hung Cursor skill step; fails_when=the skill is removed while the step's deploy is still running, so the late deploy writes the skill the learner just removed; no_claim=the removal itself (extension and editorChatOnboarding tests); seam=a deploy that settles after the removal began
+test('Remove Managed Cursor Skill waits for the Cursor skill step it ended and removes the skill after that deploy settled', async (context) => {
+  // Arrange
+  const order: string[] = []
+  let settleDeploy = (): void => {}
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () =>
+        new Promise<void>((resolveDeploy) => {
+          settleDeploy = (): void => {
+            order.push('deploy-settled')
+            resolveDeploy()
+          }
+        }),
+      remove: async () => {
+        order.push('remove-called')
+      },
+    },
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the deploy',
+    6_000,
+  )
+
+  // Act: the removal ends the step and waits for its deploy; it removes nothing while that deploy runs.
+  const removing = project.runCommand('codebook.removeManagedCursorSkill')
+  await sleepFor(100)
+  const callsWhileDeployRuns = [...order]
+  settleDeploy()
+  await removing
+  await generating
+
+  // Assert
+  assert.deepEqual(
+    { callsWhileDeployRuns, order },
+    {
+      callsWhileDeployRuns: [],
+      order: ['deploy-settled', 'remove-called'],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 RT3-C, a Cursor skill step that does not settle within the grace; fails_when=the skill is removed anyway (and re-created by the late deploy) or the learner is not told why nothing was removed; no_claim=a deploy that settles in time (test above); seam=a deploy that never settles and the grace shortened to 300 ms
+test('Remove Managed Cursor Skill tells the learner and removes nothing while a Cursor skill step is still running after the grace', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    constants: { WIKI_CURSOR_TERMINATION_GRACE_MS: 300 },
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      deploy: () => new Promise<void>(() => {}),
+    },
+  })
+  context.after(() => project.close())
+  void project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('deploy'),
+    'the deploy',
+    6_000,
+  )
+
+  // Act
+  await project.runCommand('codebook.removeManagedCursorSkill')
+
+  // Assert
+  assert.deepEqual(
+    { skillCalls: project.skillCalls, warnings: project.warnings },
+    {
+      skillCalls: ['verify', 'deploy'],
+      warnings: [
+        'Codebook did not remove the managed Cursor skill: a Cursor skill step of this window is still running and could write the skill again. Reload the window (Developer: Reload Window) to end it, then run Codebook: Remove Managed Cursor Skill again.',
+      ],
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 (the fixer's residual race of RT3-C), a Generate pressed while Remove Managed Cursor Skill runs; fails_when=the new start verifies and deploys the skill the removal is taking away, or starts an agent, or leaves its marker; no_claim=a step that was already running when the removal began (tests above); seam=the removal held inside its skill removal
+test('a Generate pressed while Remove Managed Cursor Skill is under way readies no skill, starts no agent and says why', async (context) => {
+  // Arrange
+  let agentRuns = 0
+  let finishRemoval = (): void => {}
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: {
+      verify: async () => {
+        throw new Error('The managed Cursor skill is missing.')
+      },
+      remove: () =>
+        new Promise<void>((resolveRemoval) => {
+          finishRemoval = resolveRemoval
+        }),
+    },
+    cursorAgent: async () => {
+      agentRuns += 1
+      return 'Published.'
+    },
+  })
+  context.after(() => project.close())
+  const removing = project.runCommand('codebook.removeManagedCursorSkill')
+  await waitUntil(
+    () => project.skillCalls.includes('remove'),
+    'the removal',
+    6_000,
+  )
+
+  // Act
+  await project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  finishRemoval()
+  await removing
+
+  // Assert
+  assert.deepEqual(
+    {
+      skillCalls: project.skillCalls,
+      lastError: project.errors.at(-1),
+      agentRuns,
+      markerLeft: await exists(project.markerPath),
+    },
+    {
+      skillCalls: ['remove'],
+      lastError:
+        'Codebook did not start the LLM Wiki generation: Codebook is removing the managed Cursor skill in this window; no agent was started. Press Generate LLM Wiki again when the removal has finished, and Codebook installs its skill again.',
+      agentRuns: 0,
+      markerLeft: false,
+    },
+  )
+})
+
+// Value: protects=Cycle 0056 pass 3 A2, a plain press that joins a start under way; fails_when=every further press shows the joined notice again (the README says once); no_claim=the first notice's wording (tests above); seam=the start checks held open
+test('two plain presses that join a start under way show the joined notice once', async (context) => {
+  // Arrange
+  const project = await openProjectWithoutWiki()
+  context.after(() => project.close())
+  const startChecks = project.hold('start-block')
+  const generating = project.runCommand(GENERATE_COMMAND)
+  await startChecks.started
+
+  // Act: a press that joins returns the start it joined, so none is awaited before the start is released.
+  const joiningPresses = [
+    project.runCommand(GENERATE_COMMAND),
+    project.runCommand(UPDATE_COMMAND),
+  ]
+  await flushQueuedReactions()
+  startChecks.release()
+  await Promise.all([generating, ...joiningPresses])
+
+  // Assert
+  assert.deepEqual(project.notices, [
+    'Codebook is already starting an LLM Wiki generation in this window; this press joins it.',
+  ])
+})
+
+// Value: protects=Cycle 0056 pass 3 A2, a press with a choice that joins a start under way; fails_when=Generate anyway pressed during a start under way is told "this press joins it" although its acknowledgement is dropped, or is told nothing; no_claim=the plain press (test above); seam=the button of a refusal pressed later, and the start checks of a second press held open
+test('Generate anyway pressed while another start is under way says that the choice was not applied', async (context) => {
+  // Arrange
+  let pressGenerateAnyway = (): void => {}
+  const pressed = new Promise<string>((resolvePress) => {
+    pressGenerateAnyway = (): void => resolvePress('Generate anyway')
+  })
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    chooseAction: (_message, actions) =>
+      actions.includes('Generate anyway') ? pressed : undefined,
+    cursorSkill: SKILL_IN_THE_WAY,
+  })
+  context.after(() => project.close())
+  await writeOtherWindowReservation(
+    project.projectRoot,
+    project.markerPath,
+    Date.now() - 1_000,
+  )
+  await project.runCommand(GENERATE_COMMAND)
+  const startChecks = project.hold('start-block')
+  const secondPress = project.runCommand(GENERATE_COMMAND)
+  await startChecks.started
+
+  // Act
+  pressGenerateAnyway()
+  await waitUntil(
+    () => project.notices.length > 0,
+    'the notice of the press with a choice',
+    6_000,
+  )
+  startChecks.release()
+  await secondPress
+
+  // Assert
+  assert.deepEqual(project.notices, [
+    'Codebook is already starting an LLM Wiki generation in this window, so this choice was not applied. If that start stops for the same reason, choose it again.',
+  ])
+})
+
+// Value: protects=Cycle 0056 pass 3 A3, the time a skill-step cancellation names; fails_when=the sentence names the moment the rejection was handled, a minute later than the Stop when the two straddle a minute boundary; no_claim=the sentence's wording (describeWikiSkillStepEnd tests); seam=a clock frozen mid-minute that jumps 61 seconds the moment the abort has fired
+test('the cancellation of a Cursor skill step names the time Stop LLM Wiki Run was pressed', async (context) => {
+  // Arrange
+  let stopPressedAtMs: number | undefined
+  let clockAdvanceMs = 0
+  const project = await openProjectWithoutWiki({
+    cursor: true,
+    cursorSkill: { verify: () => new Promise<never>(() => {}) },
+    clock: () =>
+      stopPressedAtMs === undefined
+        ? Date.now()
+        : stopPressedAtMs + clockAdvanceMs,
+  })
+  context.after(() => project.close())
+  const generating = project.runCommand(GENERATE_COMMAND).catch(() => undefined)
+  await waitUntil(
+    () => project.skillCalls.includes('verify'),
+    'the skill step',
+    6_000,
+  )
+  // Stop is pressed in the middle of a minute; the rejection of the waiting step is handled 61 seconds later by this clock, in the next minute.
+  const pressedAtMs = Math.floor(Date.now() / 60_000) * 60_000 + 30_000
+  stopPressedAtMs = pressedAtMs
+  const abort = AbortController.prototype.abort
+  context.mock.method(
+    AbortController.prototype,
+    'abort',
+    function (this: AbortController, reason?: unknown): void {
+      abort.call(this, reason)
+      clockAdvanceMs = 61_000
+    },
+  )
+
+  // Act
+  await project.runCommand(CANCEL_COMMAND)
+  await generating
+  context.mock.restoreAll()
+
+  // Assert
+  assert.deepEqual(
+    {
+      namesStopMinute: project.errors[0]?.includes(
+        `cancelled at ${formatClockTime(pressedAtMs)} while`,
+      ),
+      isLaterMinuteDifferent:
+        formatClockTime(pressedAtMs) !== formatClockTime(pressedAtMs + 61_000),
+    },
+    { namesStopMinute: true, isLaterMinuteDifferent: true },
+  )
+})
diff --git a/extension/src/tests/wikiRunRecord.test.ts b/extension/src/tests/wikiRunRecord.test.ts
index df87a223f..4a3d6cdb1 100644
--- a/extension/src/tests/wikiRunRecord.test.ts
+++ b/extension/src/tests/wikiRunRecord.test.ts
@@ -1,7 +1,8 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
-import { agentExitOf, wikiRunRecord } from '../utils/wikiRunRecord'
+import { agentExitOf } from '../utils/agentExitOf'
+import { wikiRunRecord } from '../utils/wikiRunRecord'
 
 // Value: protects=AC 12 and Eng decision 81, the Output record a learner copies into an issue; fails_when=the record holds the failure's own text (an agent's reply, a chat's error reply, a thrown error), names no exit code, or shows the home folder in full; no_claim=the notice, which shows the sentence; seam=a seeded fake secret in the reason
 test('the record of a failed Cursor generation names its kind, host, times, end, a Codebook summary, the exit code and the folder under ~, and none of the failure’s text', () => {
@@ -32,8 +33,8 @@ test('the record of a failed Cursor generation names its kind, host, times, end,
   )
 })
 
-// Value: protects=each end's summary in Codebook's own words; fails_when=a summary repeats a reason, or an end has no summary; no_claim=the end's classification (classify tests); seam=none
-test('each end of a run is summarized in Codebook’s own words, a refused start without a start time and a signal named where the agent had no exit code', () => {
+// Value: protects=each end's summary in Codebook's own words, also an already current Wiki, a publication that failed a check, one verb per host for a stop (Cycle 0056 tasks 7 and 9), the cause id of a block that only the Output record shows (task 10) and an output folder that is the home folder; fails_when=a summary repeats a reason, an end has no summary, a Cursor stop reads stopped or a VS Code stop reads cancelled, the cause id is lost, or the home folder is shown by name; no_claim=the end's classification (classify tests); seam=none
+test('each end of a run is summarized in Codebook’s own words: a refused start without a start time, a signal where the agent had no exit code, a Wiki already current, a publication that failed a check, one verb per host for a stop, the cause id of a block, and the home folder as ~', () => {
   // Arrange
   const shared = {
     host: 'vscode' as const,
@@ -86,6 +87,44 @@ test('each end of a run is summarized in Codebook’s own words, a refused start
       },
       '/Users/learner',
     ),
+    wikiRunRecord(
+      {
+        state: 'already-current',
+        finishedAt: shared.finishedAt,
+        outputDirectory: shared.outputDirectory,
+        outputLabel: shared.outputLabel,
+      },
+      { runKind: 'update' },
+      '/Users/learner',
+    ),
+    wikiRunRecord(
+      {
+        ...shared,
+        state: 'failed',
+        reason: 'A publication that failed a check.',
+        site: 'replaced',
+      },
+      { runKind: 'update', startedAt: '2026-10-26T04:00:00.000Z' },
+      '/Users/learner',
+    ),
+    wikiRunRecord(
+      { ...shared, state: 'cancelled', site: 'kept' },
+      { runKind: 'generate', startedAt: '2026-10-26T04:00:00.000Z' },
+      '/Users/learner',
+    ),
+    wikiRunRecord(
+      {
+        ...shared,
+        state: 'failed',
+        reason: 'The folder cannot take a new LLM Wiki.',
+        isCodebookSentence: true,
+        site: 'kept',
+        outputDirectory: '/Users/learner',
+        outputLabel: '/Users/learner',
+      },
+      { runKind: 'generate', blockCause: 'edited-page' },
+      '/Users/learner',
+    ),
   ]
 
   // Assert
@@ -94,6 +133,10 @@ test('each end of a run is summarized in Codebook’s own words, a refused start
     'LLM Wiki update ended: host=vscode started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=conflict summary="stopped by files the publisher will not overwrite (learner-file)" output=/elsewhere/wiki',
     'LLM Wiki generate ended: host=vscode started=not started ended=2026-10-26T05:00:00.000Z end=failed summary="failed; the notice names the cause" output=/elsewhere/wiki',
     'LLM Wiki generate ended: host=vscode started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=timed-out summary="stopped at its bound" exit=SIGTERM output=/elsewhere/wiki',
+    'LLM Wiki update ended: host=unknown started=not started ended=2026-10-26T05:00:00.000Z end=already-current summary="nothing to update: the Wiki matches the source" output=/elsewhere/wiki',
+    'LLM Wiki update ended: host=vscode started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=failed summary="a publication appeared but failed a check" output=/elsewhere/wiki',
+    'LLM Wiki generate ended: host=vscode started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=cancelled summary="stopped watching by the learner or the closing window" output=/elsewhere/wiki',
+    'LLM Wiki generate ended: host=vscode started=not started ended=2026-10-26T05:00:00.000Z end=failed summary="failed; the notice names the cause" cause=edited-page output=~',
   ])
 })
 
@@ -143,7 +186,7 @@ test('on Windows the record shortens the home folder whatever the case of its dr
   // Assert
   assert.equal(
     record,
-    'LLM Wiki update ended: host=cursor started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=cancelled summary="stopped by the learner or the closing window" output=~\\Repo\\.codebook\\wiki',
+    'LLM Wiki update ended: host=cursor started=2026-10-26T04:00:00.000Z ended=2026-10-26T05:00:00.000Z end=cancelled summary="cancelled by the learner or the closing window" output=~\\Repo\\.codebook\\wiki',
   )
 })
 
diff --git a/extension/src/tests/wikiSkillStepEndOf.test.ts b/extension/src/tests/wikiSkillStepEndOf.test.ts
new file mode 100644
index 000000000..137c9bc16
--- /dev/null
+++ b/extension/src/tests/wikiSkillStepEndOf.test.ts
@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { wikiSkillStepEndOf } from '../utils/wikiSkillStepEndOf'
+
+// Value: protects=Cycle 0056 pass 3 M3-D, the end a skill step is worded by; fails_when=a bound during the wait for an earlier step is worded as a plain bound, a bound during the step's own work as the earlier-step sentence, or a Stop as a bound; no_claim=the sentences (describeWikiSkillStepEnd tests) and when the step aborts (host tests); seam=none
+test('a skill step ends as the earlier step still running only when its bound fired during the wait for that step', () => {
+  // Arrange
+  const cases = [
+    { reason: 'bound', isWaiting: true },
+    { reason: 'bound', isWaiting: false },
+    { reason: 'stopped', isWaiting: true },
+    { reason: 'stopped', isWaiting: false },
+    { reason: new Error('other'), isWaiting: false },
+  ]
+
+  // Act
+  const ends = cases.map(({ reason, isWaiting }) =>
+    wikiSkillStepEndOf(reason, isWaiting),
+  )
+
+  // Assert
+  assert.deepEqual(ends, [
+    'earlier-step-running',
+    'bound',
+    'stopped',
+    'stopped',
+    'stopped',
+  ])
+})
diff --git a/extension/src/utils/agentExitOf.ts b/extension/src/utils/agentExitOf.ts
new file mode 100644
index 000000000..cf858f41a
--- /dev/null
+++ b/extension/src/utils/agentExitOf.ts
@@ -0,0 +1,26 @@
+/** What an agent process's exit said, as data: the Cursor agent's exit code or signal ({@link CursorAgentExitError}); absent for a VS Code chat and for a run that ended otherwise. */
+export type WikiAgentExit = {
+  exitCode: number | null
+  exitSignal: string | null
+}
+
+/**
+ * Reads the exit code or signal off a failure of the Cursor agent's process ({@link CursorAgentExitError}), by its fields, so a stand-in of the runner in a test is read as the runner is.
+ * @param error - What the Cursor agent's run threw.
+ * @returns The exit code and signal where the failure carries them; `undefined` for any other failure.
+ * @example
+ * agentExitOf(Object.assign(new Error('…'), { exitCode: 1, exitSignal: null })) // => { exitCode: 1, exitSignal: null }
+ * agentExitOf(new Error('The Wiki update was cancelled.'))                    // => undefined
+ */
+export function agentExitOf(error: unknown): WikiAgentExit | undefined {
+  if (typeof error !== 'object' || error === null) return undefined
+  const exitCode: unknown = Reflect.get(error, 'exitCode')
+  const exitSignal: unknown = Reflect.get(error, 'exitSignal')
+  // Only a failure that carries the process's own answer has one; a cancel, a bound or a start failure carries none.
+  if (typeof exitCode !== 'number' && typeof exitSignal !== 'string')
+    return undefined
+  return {
+    exitCode: typeof exitCode === 'number' ? exitCode : null,
+    exitSignal: typeof exitSignal === 'string' ? exitSignal : null,
+  }
+}
diff --git a/extension/src/utils/claimWikiUpdateMarker.ts b/extension/src/utils/claimWikiUpdateMarker.ts
index 13f073f44..71b80ab85 100644
--- a/extension/src/utils/claimWikiUpdateMarker.ts
+++ b/extension/src/utils/claimWikiUpdateMarker.ts
@@ -40,6 +40,7 @@ import {
 import { readWikiRegularFile } from './readWikiRegularFile'
 import { removeWithoutFollowing } from './removeWithoutFollowing'
 import { systemErrorCode } from './systemErrorCode'
+import type { WikiRunKind } from './wikiUpdateRun'
 import { withoutBootTime } from './withoutBootTime'
 
 /** A marker that is in the way at the moment another window removes or replaces it under its claim: it is no run that holds the Wiki, and this window may not remove it either. @example const inChange: WikiUpdateMarkerInChange = { isMarkerInChange: true } */
@@ -49,11 +50,33 @@ type WikiUpdateMarkerInChange = { isMarkerInChange: true }
 type WikiUpdateHolder =
   WikiUpdateMarker | WikiUpdateMarkerBeingWritten | WikiUpdateMarkerInChange
 
+/** The reservation of a stopped watch that a start's claim took over, which a start refused after its claim writes back as it was: when the watch ended, the kind of the run it came from and, where another window's marker was read under the claim, that marker, so the written-back reservation keeps its owner (host, process, window, start) and so its own bound rather than the refused start's. */
+export type TakenOverWikiReservation = {
+  watchEndedAtMs: number
+  runKind: WikiRunKind
+  /** The marker the claim removed; absent for this window's own reservation, which the claim's record already names. */
+  replacedMarker?: WikiUpdateMarker
+  /** The text of that marker file exactly as it was read under the claim; a write-back restores these bytes, so the original owner's release, bound timer and close still find their own text ({@link changeOwnMarker}). Set with `replacedMarker`. */
+  replacedText?: string
+}
+
+/** What a refused start hands back to the `reserve` of {@link WikiUpdateMarkerClaim} to write a taken-over reservation back as it was: the run's kind and, where another window's marker was replaced, that marker and its exact text. The one shape the claim, the start ({@link WikiRunMarkerClaim}) and the extension's write-back share. */
+export type WikiReservationHandoff = Pick<
+  TakenOverWikiReservation,
+  'runKind' | 'replacedMarker' | 'replacedText'
+>
+
 /** The claimed marker of this window's run (`release` removes it when the run ends; `reserve` turns it into the reservation of a stopped watch, which other windows read until the watch bound; each answers `false` while this run's marker stayed as it was because the claim on it could not be had or the marker could not be read, and may be asked again), or what holds the Wiki instead: the marker of the other window's run, the time since which another window is writing its marker (with the marker file's path and its last counting moment when that file cannot be read), or the note that another window is changing the marker. */
 export type WikiUpdateMarkerClaim =
   | {
       release: () => Promise<boolean>
-      reserve: (watchEndedAtMs: number) => Promise<boolean>
+      /** Turns the marker into a reservation that ends its watch at `watchEndedAtMs`; `takenOver` names the reservation a refused start writes back, which keeps its kind and so the bound of the run it came from (`update` leaves `runKind` out, as an update's marker always did) and, where another window's marker was replaced, that marker's exact text, so its owner still recognizes it. */
+      reserve: (
+        watchEndedAtMs: number,
+        takenOver?: WikiReservationHandoff,
+      ) => Promise<boolean>
+      /** The reservation of a stopped watch that this claim removed from another window's marker to place its own, read under the claim; absent where it removed none (this window's own reservation reads as nobody's run and is not named here). The extension hands it on as `takenOver` of the start's claimed marker, the one name a refused start writes back from ({@link WikiReservationHandoff}). */
+      replacedReservation?: TakenOverWikiReservation
     }
   | { heldBy: WikiUpdateHolder }
 
@@ -125,6 +148,21 @@ function machineAndProcessOf(
   return { machineKey, hostKey, boot, processStart }
 }
 
+/**
+ * Gives a marker the run kind of a reservation written back; called by `reserve` of {@link claimWikiUpdateMarker}.
+ * @param record - The marker this claim wrote.
+ * @param runKind - The kind to keep: `generate` is written, `update` is left out as an update's marker always left it.
+ * @returns A copy of the marker with that kind.
+ * @example withRunKind({ pid: 4242, windowId: '3f6c', host: 'vscode', startedAtMs: 1, runKind: 'generate' }, 'update') // => { pid: 4242, windowId: '3f6c', host: 'vscode', startedAtMs: 1 }
+ */
+function withRunKind<Record extends { runKind?: unknown }>(
+  record: Record,
+  runKind: WikiRunKind,
+): Omit<Record, 'runKind'> & { runKind?: 'generate' } {
+  const { runKind: _ownRunKind, ...withoutKind } = record
+  return runKind === 'generate' ? { ...withoutKind, runKind } : withoutKind
+}
+
 /**
  * Lets only the failure "a marker file is already there" pass; called by {@link claimWikiUpdateMarker} with what its exclusive creation threw, before it looks at the marker in the way.
  * @param error - What the exclusive creation threw.
@@ -461,7 +499,7 @@ async function claimMarkerChange(
  * @param markerPath - `<output>.update-run.json`.
  * @param ownWindowId - The asking window's own id.
  * @param judgement - The identity of this process, the reader of process starts and the clock.
- * @returns Nothing. The marker stays when another window holds the claim (it is removing the marker itself), when the look under the claim finds another window's run, a marker being written or no marker, and when the claim was lost meanwhile; the exclusive creation that follows decides either way.
+ * @returns The stopped watch's reservation of another window that was removed (its end, run kind, marker and exact text, read under the claim), so a start that is refused later can write it back; `undefined` when a marker of nobody's run was removed, and when nothing was: the marker stays when another window holds the claim (it is removing the marker itself), when the look under the claim finds another window's run, a marker being written or no marker, and when the claim was lost meanwhile; the exclusive creation that follows decides either way.
  * @example
  * await removeUnownedMarker('/repo/.codebook/wiki', '/repo/.codebook/wiki.update-run.json', windowId, judgement)
  */
@@ -470,9 +508,9 @@ async function removeUnownedMarker(
   markerPath: string,
   ownWindowId: string,
   judgement: MarkerClaimJudgement,
-): Promise<void> {
+): Promise<TakenOverWikiReservation | undefined> {
   const claim = await claimMarkerChange(markerPath, 1, judgement)
-  if (!claim) return
+  if (!claim) return undefined
   try {
     // Another window may have taken the marker over since the look that brought this call; only a marker that this look reads as nobody's run is removed.
     const look = await readLiveWikiUpdateMarker(
@@ -481,8 +519,24 @@ async function removeUnownedMarker(
       atThisMoment(judgement),
     )
     // What the look read as nobody's is removed whatever it is: a file, a link as the link, a folder with its content.
-    if (isMarkerOfNobodysRun(look) && (await claim.isStillHeld()))
+    if (isMarkerOfNobodysRun(look) && (await claim.isStillHeld())) {
+      // Only a reservation of a stopped watch names an end worth writing back; its exact text is read under the claim, before the removal.
+      if (look.kind === 'live' && look.heldBy.watchEndedAtMs !== undefined) {
+        const reservationText = await readMarkerText(markerPath)
+        // A reservation that cannot be read now stays, as it cannot be written back as it was; the exclusive creation that follows refuses this start as a marker in change.
+        if (typeof reservationText === 'string') return undefined
+        await removeWithoutFollowing(markerPath)
+        return {
+          watchEndedAtMs: look.heldBy.watchEndedAtMs,
+          runKind: look.heldBy.runKind ?? 'update',
+          replacedMarker: look.heldBy,
+          replacedText: reservationText.text,
+        }
+      }
       await removeWithoutFollowing(markerPath)
+      return undefined
+    }
+    return undefined
   } finally {
     await claim.release()
   }
@@ -594,6 +648,8 @@ export async function claimWikiUpdateMarker(
   const record = { ...marker, ...machineAndProcessOf(judgement.identity) }
   /** What this claim last wrote into the marker file; only a file that still holds it is this claim's to remove. */
   let written = JSON.stringify(record)
+  /** The reservation the one removal of the first attempt took away. */
+  let replacedReservation: TakenOverWikiReservation | undefined
   // One retry: after a marker that was nobody's was removed the exclusive creation decides again.
   for (const isLastAttempt of [false, true]) {
     try {
@@ -607,8 +663,23 @@ export async function claimWikiUpdateMarker(
             await judgementFrom(inputs),
           )
         },
-        async reserve(watchEndedAtMs: number): Promise<boolean> {
-          const reservation = JSON.stringify({ ...record, watchEndedAtMs })
+        replacedReservation,
+        async reserve(
+          watchEndedAtMs: number,
+          takenOver?: WikiReservationHandoff,
+        ): Promise<boolean> {
+          // Another window's reservation is written back byte for byte as read under the claim: its owner compares its own text when it releases, and a re-serialized marker (the parsed key order) would read as not its own. Its host, process and window stay, so the VS Code watch keeps its bound.
+          const reservation =
+            takenOver?.replacedText ??
+            JSON.stringify({
+              ...(takenOver === undefined
+                ? record
+                : withRunKind(
+                    takenOver.replacedMarker ?? record,
+                    takenOver.runKind,
+                  )),
+              watchEndedAtMs,
+            })
           return changeOwnMarker(
             markerPath,
             written,
@@ -631,7 +702,7 @@ export async function claimWikiUpdateMarker(
       // What holds the Wiki ends the claim; a marker that is nobody's run is removed for the one retry.
       const holder = claimOfHolder(look, isLastAttempt)
       if (holder) return holder
-      await removeUnownedMarker(
+      replacedReservation = await removeUnownedMarker(
         outputDirectory,
         markerPath,
         marker.windowId,
diff --git a/extension/src/utils/describeExistingWiki.ts b/extension/src/utils/describeExistingWiki.ts
new file mode 100644
index 000000000..f321495c8
--- /dev/null
+++ b/extension/src/utils/describeExistingWiki.ts
@@ -0,0 +1,9 @@
+/**
+ * Words that a folder already holds an LLM Wiki and offers its update, for the notice a generation shows instead of overwriting it (Cycle 0055, D2).
+ * @param outputLabel - The Wiki folder as the learner reads it.
+ * @returns The sentence that names the folder and asks for the update.
+ * @example describeExistingWiki('.codebook/wiki') // => 'An LLM Wiki already exists in .codebook/wiki. Update it instead?'
+ */
+export function describeExistingWiki(outputLabel: string): string {
+  return `An LLM Wiki already exists in ${outputLabel}. Update it instead?`
+}
diff --git a/extension/src/utils/describeJoinedWikiStart.ts b/extension/src/utils/describeJoinedWikiStart.ts
new file mode 100644
index 000000000..4899584bc
--- /dev/null
+++ b/extension/src/utils/describeJoinedWikiStart.ts
@@ -0,0 +1,24 @@
+import { WIKI_RUN_KIND_WORDS } from './wikiRunKindWords'
+import type { WikiRunKind } from './wikiUpdateRun'
+
+/**
+ * Words a press that joined an LLM Wiki start already under way in this window, so the press is not met with silence.
+ * Why: a second press during a start's checks or its confirmation is coalesced into the first (`runWikiAttempt`); without a sentence the learner cannot tell it from a press that did nothing (Cycle 0056 task 2).
+ * Trigger: the extension shows it when Generate or Update LLM Wiki, or the browser reader's Update, arrives while a start of this window has not begun its run yet.
+ * A press that carries a choice ("Update anyway", "Generate anyway", the offer's "Update") joins the start without that choice: the sentence says so, because the start was checked without it and may refuse for the same reason (Cycle 0056 A2).
+ * @param runKind - The kind of the start that is under way, which the press joins.
+ * @param isChoiceCarried - Whether the press carried the learner's choice to go on anyway or to update instead, which the joined start does not apply.
+ * @returns The information sentence, naming the start's kind.
+ * @example
+ * describeJoinedWikiStart('generate') // => 'Codebook is already starting an LLM Wiki generation in this window; this press joins it.'
+ * describeJoinedWikiStart('update')   // => 'Codebook is already starting an LLM Wiki update in this window; this press joins it.'
+ * describeJoinedWikiStart('update', true) // => 'Codebook is already starting an LLM Wiki update in this window, so this choice was not applied. If that start stops for the same reason, choose it again.'
+ */
+export function describeJoinedWikiStart(
+  runKind: WikiRunKind,
+  isChoiceCarried = false,
+): string {
+  if (isChoiceCarried)
+    return `Codebook is already starting an LLM Wiki ${WIKI_RUN_KIND_WORDS[runKind].noun} in this window, so this choice was not applied. If that start stops for the same reason, choose it again.`
+  return `Codebook is already starting an LLM Wiki ${WIKI_RUN_KIND_WORDS[runKind].noun} in this window; this press joins it.`
+}
diff --git a/extension/src/utils/describeMissingWiki.ts b/extension/src/utils/describeMissingWiki.ts
new file mode 100644
index 000000000..41c8474f8
--- /dev/null
+++ b/extension/src/utils/describeMissingWiki.ts
@@ -0,0 +1,9 @@
+/**
+ * Words that a folder holds no LLM Wiki, for the notices of Open LLM Wiki in Browser and Update LLM Wiki, which offer Generate LLM Wiki beside it (Cycle 0055, proposed change 3).
+ * @param outputLabel - The Wiki folder as the learner reads it.
+ * @returns The sentence that names the folder.
+ * @example describeMissingWiki('.codebook/wiki') // => 'Codebook found no LLM Wiki in .codebook/wiki.'
+ */
+export function describeMissingWiki(outputLabel: string): string {
+  return `Codebook found no LLM Wiki in ${outputLabel}.`
+}
diff --git a/extension/src/utils/describeWikiGenerateBlock.ts b/extension/src/utils/describeWikiGenerateBlock.ts
index 53251dfaa..395d014b9 100644
--- a/extension/src/utils/describeWikiGenerateBlock.ts
+++ b/extension/src/utils/describeWikiGenerateBlock.ts
@@ -10,7 +10,7 @@ import type { WikiUpdateStartBlock } from './findWikiUpdateStartBlock'
  *
  * @param block - The cause and the paths the start check named.
  * @param outputLabel - The Wiki folder as the learner reads it.
- * @returns The sentence for the cause, naming the first path and the next step; for a cause no folder without a manifest can hold, the sentence that names the cause and sends the learner to the update.
+ * @returns The sentence for the cause, naming the first path and the next step. For a cause no folder without a manifest can hold, a sentence that names the first path (or, where the check named none, only the folder) as in the way and sends the learner to the update; it names no cause id.
  * @example
  * describeWikiGenerateBlock({ cause: 'held-publish-lock', paths: ['wiki.publish-lock.json'] }, '.codebook/wiki')
  * // => 'A publish of the LLM Wiki in .codebook/wiki may still be running or was stopped (wiki.publish-lock.json). Once it ends, press Generate LLM Wiki again; if it was stopped, ask the editor chat "/codebook Recover the unfinished LLM Wiki publish for this project" once its process exits.'
@@ -31,6 +31,10 @@ export function describeWikiGenerateBlock(
     case 'special-file':
       return `${outputLabel} holds a link or special file (${firstPath}), which the publisher refuses. Move it out of the folder, then press Generate LLM Wiki again.`
     default:
-      return `The folder ${outputLabel} cannot take a new LLM Wiki (${block.cause}: ${firstPath}). Press Update LLM Wiki to see what is in the way.`
+      // A cause that needs a manifest names no cause id here; the Output record keeps it.
+      // A check that named no path has nothing to point at, and the folder must not be named as the thing in its own way.
+      if (block.paths.length === 0)
+        return `The folder ${outputLabel} cannot take a new LLM Wiki. Press Update LLM Wiki for the details and the next step.`
+      return `The folder ${outputLabel} cannot take a new LLM Wiki: ${firstPath} is in the way. Press Update LLM Wiki for the details and the next step.`
   }
 }
diff --git a/extension/src/utils/describeWikiSkillStepEnd.ts b/extension/src/utils/describeWikiSkillStepEnd.ts
new file mode 100644
index 000000000..4c91b7447
--- /dev/null
+++ b/extension/src/utils/describeWikiSkillStepEnd.ts
@@ -0,0 +1,50 @@
+import type { WIKI_SKILL_STEP_BOUND_REASON } from '../constants'
+import {
+  WIKI_SKILL_STEP_EARLIER_RUNNING_END,
+  WIKI_SKILL_STEP_EARLIER_RUNNING_SENTENCE,
+  WIKI_SKILL_STEP_REMOVAL_END,
+  WIKI_SKILL_STEP_STOPPED_REASON,
+} from '../constants'
+
+import { secondsText } from './secondsText'
+import { SET_UP_AI_CHAT_COMMAND } from './startOverBy'
+import { WIKI_RUN_KIND_WORDS } from './wikiRunKindWords'
+import type { WikiRunKind } from './wikiUpdateRun'
+
+/** How a Cursor skill step ended: the abort reasons of {@link WIKI_SKILL_STEP_STOPPED_REASON} and {@link WIKI_SKILL_STEP_BOUND_REASON}, {@link WIKI_SKILL_STEP_EARLIER_RUNNING_END} where the bound passed while the step still waited for an earlier step, or {@link WIKI_SKILL_STEP_REMOVAL_END} where the step began during Remove Managed Cursor Skill. */
+export type WikiSkillStepEnd =
+  | typeof WIKI_SKILL_STEP_STOPPED_REASON
+  | typeof WIKI_SKILL_STEP_BOUND_REASON
+  | typeof WIKI_SKILL_STEP_EARLIER_RUNNING_END
+  | typeof WIKI_SKILL_STEP_REMOVAL_END
+
+/**
+ * Words how a start ended while Codebook readied the managed Cursor skill: the learner stopped it, the step passed its bound, or a removal of the skill was under way.
+ * Why: the skill step runs with the run's marker claimed and no agent yet; the learner needs to know the start is over, that no agent was started and what to press next (Cycle 0056 task 13).
+ * Trigger: {@link runUnderAbortSignal} rejects with the abort reason, and the extension turns it into this sentence for the start's refusal.
+ * @param end - `stopped` after Stop LLM Wiki Run, `bound` after the step's bound passed, `earlier-step-running` after the bound passed while the step still waited for an earlier step of this window that never settled, `skill-removal` when the step began while Remove Managed Cursor Skill was under way.
+ * @param runKind - The kind of the start.
+ * @param boundMs - The step's bound in milliseconds, named by the `bound` sentence.
+ * @param stoppedAt - When the learner stopped it, as the learner's local time ({@link formatClockTime}); the `stopped` sentence names it as every Cursor cancellation does.
+ * @returns The sentence of the end.
+ * @example
+ * describeWikiSkillStepEnd('stopped', 'generate', 30_000, '21:10') // => 'The LLM Wiki generation was cancelled at 21:10 while Codebook readied the Cursor skill; no agent was started. Press Generate LLM Wiki when you want to start again.'
+ * describeWikiSkillStepEnd('earlier-step-running', 'update', 30_000, '21:10') // => 'Codebook could not ready the Cursor skill: an earlier Cursor skill step in this window is still running. Reload the window (Developer: Reload Window) to end it, then press Update LLM Wiki again.'
+ * describeWikiSkillStepEnd('bound', 'update', 30_000, '21:10')     // => 'Codebook stopped readying the Cursor skill after 30 seconds; no agent was started. Press Update LLM Wiki again, or run Codebook: Set Up AI Chat.'
+ * describeWikiSkillStepEnd('skill-removal', 'generate', 30_000, '21:10') // => 'Codebook is removing the managed Cursor skill in this window; no agent was started. Press Generate LLM Wiki again when the removal has finished, and Codebook installs its skill again.'
+ */
+export function describeWikiSkillStepEnd(
+  end: WikiSkillStepEnd,
+  runKind: WikiRunKind,
+  boundMs: number,
+  stoppedAt: string,
+): string {
+  const { noun, button } = WIKI_RUN_KIND_WORDS[runKind]
+  if (end === WIKI_SKILL_STEP_STOPPED_REASON)
+    return `The LLM Wiki ${noun} was cancelled at ${stoppedAt} while Codebook readied the Cursor skill; no agent was started. Press ${button} LLM Wiki when you want to start again.`
+  if (end === WIKI_SKILL_STEP_EARLIER_RUNNING_END)
+    return `${WIKI_SKILL_STEP_EARLIER_RUNNING_SENTENCE}, then press ${button} LLM Wiki again.`
+  if (end === WIKI_SKILL_STEP_REMOVAL_END)
+    return `Codebook is removing the managed Cursor skill in this window; no agent was started. Press ${button} LLM Wiki again when the removal has finished, and Codebook installs its skill again.`
+  return `Codebook stopped readying the Cursor skill after ${secondsText(boundMs)}; no agent was started. Press ${button} LLM Wiki again, or run ${SET_UP_AI_CHAT_COMMAND}.`
+}
diff --git a/extension/src/utils/describeWikiUpdate.ts b/extension/src/utils/describeWikiUpdate.ts
index 30b9158b6..1b319a178 100644
--- a/extension/src/utils/describeWikiUpdate.ts
+++ b/extension/src/utils/describeWikiUpdate.ts
@@ -28,7 +28,7 @@ export type WikiUpdateWording = {
   recoveryRequest: string
   /** Why VS Code's chat asks to approve each step of an update whose output lies outside the project, as the editor's confirmation says it ({@link WIKI_OUTSIDE_OUTPUT_APPROVALS_NOTE}); the function is embedded into the page and cannot import the constant. */
   outsideOutputApprovalsNote: string
-  /** What a learner does after they refused a step of VS Code's chat ({@link WIKI_REFUSED_STEP_ADVICE}), without its full stop; the running line of a VS Code update goes on from it with where Cancel is and what happens otherwise. The function is embedded into the page and cannot import the constant. */
+  /** What a learner does after they refused a step of VS Code's chat ({@link WIKI_REFUSED_STEP_ADVICE}), without its full stop; the running line of a VS Code update goes on from it with where Stop watching is and what happens otherwise. The function is embedded into the page and cannot import the constant. */
   refusedStepAdvice: string
   /** Where the reader finds the freshness label, as the end of "check the freshness label …": `above` on the page, `in the browser reader` in an editor notification. */
   freshnessLabelPlace: string
@@ -59,7 +59,7 @@ type WikiUpdateStatusOf<State extends WikiUpdateStatus['state']> = Extract<
  * ```ts
  * describeWikiUpdate(
  *   { state: 'cancelled', host: 'cursor', finishedAt: '2026-10-03T12:10:00.000Z', site: 'kept', outputDirectory: '/repo/.codebook/wiki', outputLabel: '.codebook/wiki' },
- *   { formatTime: () => '21:10', pathLimit: 3, reasonLimitChars: 200, msPerMinute: 60_000, recoveryRequest: '/codebook Recover the unfinished LLM Wiki publish for this project', outsideOutputApprovalsNote: 'This Wiki’s output lies outside the project, so the chat will ask to approve each step there; an output inside the project (codebook.wikiOutputDirectory) needs none.', refusedStepAdvice: 'If you refuse a step of the chat, press Cancel', freshnessLabelPlace: 'above' },
+ *   { formatTime: () => '21:10', pathLimit: 3, reasonLimitChars: 200, msPerMinute: 60_000, recoveryRequest: '/codebook Recover the unfinished LLM Wiki publish for this project', outsideOutputApprovalsNote: 'This Wiki’s output lies outside the project, so the chat will ask to approve each step there; an output inside the project (codebook.wikiOutputDirectory) needs none.', refusedStepAdvice: 'If you refuse a step of the chat, press Stop watching', freshnessLabelPlace: 'above' },
  * )
  * // => { lead: 'Update cancelled', rest: ' at 21:10. Cursor Agent was stopped. The last usable site is kept.', detail: [], output: 'Output: .codebook/wiki', offerReload: false }
  * ```
@@ -161,7 +161,7 @@ export function describeWikiUpdate(
         (running.isOutputOutsideProject
           ? ' ' + wording.outsideOutputApprovalsNote
           : '') +
-        // Once the chat asked for an approval Codebook does not see it stop: a learner who refused a step and stays on this page would wait out the bound. The watch's Cancel is its entry in the status bar.
+        // Once the chat asked for an approval Codebook does not see it stop: a learner who refused a step and stays on this page would wait out the bound. The watch's Stop watching is its entry in the status bar.
         ' ' +
         wording.refusedStepAdvice +
         ' in the editor’s status bar; otherwise Codebook keeps watching for the whole ' +
diff --git a/extension/src/utils/findUnacknowledgedWikiLeftover.ts b/extension/src/utils/findUnacknowledgedWikiLeftover.ts
index 57347bd3b..40c82ce7d 100644
--- a/extension/src/utils/findUnacknowledgedWikiLeftover.ts
+++ b/extension/src/utils/findUnacknowledgedWikiLeftover.ts
@@ -12,6 +12,7 @@ import {
   type WikiLastRun,
 } from './selectActiveWikiCandidate'
 import { wikiRunBoundMs } from './wikiRunBoundMs'
+import { WIKI_RUN_KIND_WORDS } from './wikiRunKindWords'
 import type { WikiRunKind } from './wikiUpdateRun'
 
 /** One refusal of a Wiki update's start for an earlier chat that may still publish: the leftovers of that one chat the refusal names, which its "Update anyway" passes, and the sentence that names them. */
@@ -74,7 +75,7 @@ async function reservationRefusal(
         startedAtMs: otherWindow.startedAtMs,
       },
     ],
-    reason: `The VS Code chat another editor window asked at ${formatClockTime(otherWindow.startedAtMs, {})} may still be ${otherWindow.runKind === 'generate' ? 'generating' : 'updating'} this Wiki; that window stopped watching it at ${formatClockTime(watchEndedAtMs, {})} and Codebook waits for it until ${formatWaitEnd(watchEndedAtMs + watchTimeoutMs)}. If that chat was stopped, choose ${overrideActionOf(runKind)} in the editor’s notification.`,
+    reason: `The VS Code chat another editor window asked at ${formatClockTime(otherWindow.startedAtMs, {})} may still be ${WIKI_RUN_KIND_WORDS[otherWindow.runKind ?? 'update'].verb} this Wiki; that window stopped watching it at ${formatClockTime(watchEndedAtMs, {})} and Codebook waits for it until ${formatWaitEnd(watchEndedAtMs + watchTimeoutMs)}. If that chat was stopped, choose ${overrideActionOf(runKind)} in the editor’s notification.`,
   }
 }
 
@@ -125,7 +126,7 @@ function ownChatReason(
   const staged = seenCandidate
     ? ` (candidate ${seenCandidate.name}, written ${formatClockTime(seenCandidate.writtenAtMs, {})})`
     : ''
-  return `The VS Code chat this window asked at ${formatClockTime(awaitedOwnRun.startedAtMs, {})} may still be ${awaitedOwnRun.runKind === 'generate' ? 'generating' : 'updating'} this Wiki${staged}; Codebook stopped watching it at ${formatClockTime(awaitedOwnRun.endedAtMs, {})} and waits for it until ${formatWaitEnd(waitEndsAtMs)}. If that chat was stopped, choose ${overrideAction} in the editor’s notification.`
+  return `The VS Code chat this window asked at ${formatClockTime(awaitedOwnRun.startedAtMs, {})} may still be ${WIKI_RUN_KIND_WORDS[awaitedOwnRun.runKind ?? 'update'].verb} this Wiki${staged}; Codebook stopped watching it at ${formatClockTime(awaitedOwnRun.endedAtMs, {})} and waits for it until ${formatWaitEnd(waitEndsAtMs)}. If that chat was stopped, choose ${overrideAction} in the editor’s notification.`
 }
 
 /**
diff --git a/extension/src/utils/llmWikiView.ts b/extension/src/utils/llmWikiView.ts
index 8b5bfeb1b..f3708c2ff 100644
--- a/extension/src/utils/llmWikiView.ts
+++ b/extension/src/utils/llmWikiView.ts
@@ -56,7 +56,7 @@ export type LlmWikiViewOptions = {
   }) => 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. */
+  /** Subscribes to changes of this window's run state and to the end of each attempt to change its run marker (removal, or turn into a reservation); 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
diff --git a/extension/src/utils/longestWikiRunMs.ts b/extension/src/utils/longestWikiRunMs.ts
new file mode 100644
index 000000000..0229296b3
--- /dev/null
+++ b/extension/src/utils/longestWikiRunMs.ts
@@ -0,0 +1,23 @@
+import { WIKI_CHAT_OPEN_TIMEOUT_MS } from '../constants'
+
+import { wikiRunBoundMs } from './wikiRunBoundMs'
+import type { WikiRunKind, WikiUpdateHost } from './wikiUpdateRun'
+
+/**
+ * Names the longest a run of one kind and host can last from its marker's start to its end; called by the marker reader for a run's marker that may have expired.
+ * @param runKind - The run's kind; `undefined` reads as an update.
+ * @param host - The editor host that runs it.
+ * @returns The Cursor agent's bound, or in VS Code the chat's opening ({@link WIKI_CHAT_OPEN_TIMEOUT_MS}) and the watch's bound.
+ * @example
+ * longestWikiRunMs('generate', 'vscode') // => 3_330_000
+ * longestWikiRunMs('update', 'cursor')   // => 900_000
+ */
+export function longestWikiRunMs(
+  runKind: WikiRunKind | undefined,
+  host: WikiUpdateHost,
+): number {
+  // A VS Code run first waits for the chat to open, then watches for the publish.
+  return host === 'cursor'
+    ? wikiRunBoundMs(runKind, host)
+    : WIKI_CHAT_OPEN_TIMEOUT_MS + wikiRunBoundMs(runKind, host)
+}
diff --git a/extension/src/utils/readLiveWikiUpdateMarker.ts b/extension/src/utils/readLiveWikiUpdateMarker.ts
index 96f014c7a..03c8a4aef 100644
--- a/extension/src/utils/readLiveWikiUpdateMarker.ts
+++ b/extension/src/utils/readLiveWikiUpdateMarker.ts
@@ -3,6 +3,7 @@ import { lstat } from 'node:fs/promises'
 import { z } from 'zod'
 
 import {
+  LONGEST_WIKI_RUN_MS,
   WIKI_METADATA_FILE_LIMIT_BYTES,
   WIKI_UPDATE_MARKER_CLOCK_TOLERANCE_MS,
   WIKI_UPDATE_MARKER_EXPIRY_GRACE_MS,
@@ -14,14 +15,11 @@ import { canJudgeOwnerHere } from './canJudgeOwnerHere'
 import { currentStorageOwner } from './currentStorageOwner'
 import { isProcessGone } from './isProcessGone'
 import { isRecordedOwnerGone } from './isRecordedOwnerGone'
+import { longestWikiRunMs } from './longestWikiRunMs'
 import { readProcessStart, type ProcessStartReader } from './readProcessStart'
 import type { StorageOwnerIdentity } from './readRecordedOwner'
 import { readWikiRegularFile } from './readWikiRegularFile'
-import {
-  LONGEST_WIKI_RUN_MS,
-  longestWikiRunMs,
-  wikiRunBoundMs,
-} from './wikiRunBoundMs'
+import { wikiRunBoundMs } from './wikiRunBoundMs'
 
 /** What a running Wiki update writes beside the output folder: who runs it and since when. */
 const wikiUpdateMarkerSchema = z.object({
diff --git a/extension/src/utils/readLlmWikiViewFacts.ts b/extension/src/utils/readLlmWikiViewFacts.ts
index 37e66004e..63a722000 100644
--- a/extension/src/utils/readLlmWikiViewFacts.ts
+++ b/extension/src/utils/readLlmWikiViewFacts.ts
@@ -2,6 +2,7 @@ import { basename } from 'node:path'
 
 import { WIKI_UPDATE_RECOVERY_REQUEST } from '../constants'
 
+import type { WikiAgentExit } from './agentExitOf'
 import { describeWikiGenerateBlock } from './describeWikiGenerateBlock'
 import type { WikiUpdateStartBlock } from './findWikiUpdateStartBlock'
 import type { AwaitedWikiChat } from './hasWikiPublishEndedWait'
@@ -16,7 +17,6 @@ import type {
 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'
 
diff --git a/extension/src/utils/runCursorWikiUpdate.ts b/extension/src/utils/runCursorWikiUpdate.ts
index 15264f218..931d55da5 100644
--- a/extension/src/utils/runCursorWikiUpdate.ts
+++ b/extension/src/utils/runCursorWikiUpdate.ts
@@ -5,8 +5,6 @@ import {
   WIKI_CURSOR_SHUTDOWN_GRACE_MS,
   WIKI_CURSOR_TERMINATION_GRACE_MS,
   WIKI_CURSOR_UPDATE_OUTPUT_LIMIT_BYTES,
-  WIKI_GENERATE_CHAT_REQUEST,
-  WIKI_UPDATE_CHAT_REQUEST,
   WIKI_UPDATE_WINDOW_CLOSING_ABORT_REASON,
 } from '../constants'
 
@@ -15,37 +13,10 @@ import {
   CURSOR_AGENT_LOOKUP_DESCRIPTION,
   resolveCursorAgentExecutable,
 } from './resolveCursorAgentExecutable'
+import { WIKI_RUN_KIND_WORDS, type WikiRunKindWords } from './wikiRunKindWords'
 import type { WikiRunKind } from './wikiUpdateRun'
 import { WikiUpdateTimeoutError } from './wikiUpdateTimeoutError'
 
-/** The words a Cursor agent run's sentences use for its kind, so a generation's sentences never call it an update (Cycle 0055, D5). */
-type CursorRunWords = {
-  /** The run as a noun: `update` or `generation`. */
-  noun: string
-  /** The run as the verb of "Cursor Agent timed out … the Wiki": `updating` or `generating`. */
-  verb: string
-  /** The button the learner presses to run it again. */
-  button: string
-  /** The chat request a learner can paste in Cursor chat to see the agent's own message. */
-  chatRequest: string
-}
-
-/** {@link CursorRunWords} of each run kind. */
-const CURSOR_RUN_WORDS: Record<WikiRunKind, CursorRunWords> = {
-  update: {
-    noun: 'update',
-    verb: 'updating',
-    button: 'Update',
-    chatRequest: WIKI_UPDATE_CHAT_REQUEST,
-  },
-  generate: {
-    noun: 'generation',
-    verb: 'generating',
-    button: 'Generate',
-    chatRequest: WIKI_GENERATE_CHAT_REQUEST,
-  },
-}
-
 /** The failure of a Cursor agent process that closed without a clean exit and that Codebook did not stop, with its exit code or signal as data, so the run's Output record names them without the sentence ({@link unfinishedExitError}). */
 export class CursorAgentExitError extends Error {
   /**
@@ -74,7 +45,7 @@ export function parseCursorWikiUpdateResult(
   output: string,
   runKind: WikiRunKind = 'update',
 ): string {
-  const words = CURSOR_RUN_WORDS[runKind]
+  const words = WIKI_RUN_KIND_WORDS[runKind]
   let envelope: CursorCliResult
   try {
     envelope = JSON.parse(output.trim())
@@ -102,11 +73,11 @@ export function parseCursorWikiUpdateResult(
  * @param words - The words of the run's kind.
  * @throws A plain error saying that the Wiki update or generation was cancelled, when the signal is aborted.
  * @example
- * throwIfWikiUpdateCancelled(controller.signal, CURSOR_RUN_WORDS.update) // returns while the learner has not cancelled
+ * throwIfWikiUpdateCancelled(controller.signal, WIKI_RUN_KIND_WORDS.update) // returns while the learner has not cancelled
  */
 function throwIfWikiUpdateCancelled(
   signal: AbortSignal | undefined,
-  words: CursorRunWords,
+  words: WikiRunKindWords,
 ): void {
   if (signal?.aborted) throw new Error(`The Wiki ${words.noun} was cancelled.`)
 }
@@ -118,15 +89,15 @@ function throwIfWikiUpdateCancelled(
  * @param words - The words of the run's kind, whose chat request the sentence names.
  * @returns The error whose sentence says how the agent stopped and where its own message can be read, with the code and the signal as data; the page alone says what was kept.
  * @example
- * unfinishedExitError(1, null, CURSOR_RUN_WORDS.update).message
+ * unfinishedExitError(1, null, WIKI_RUN_KIND_WORDS.update).message
  * // => 'Cursor Agent stopped with exit code 1 before finishing. Run "/codebook Update LLM Wiki" in Cursor chat to see its own message.'
- * unfinishedExitError(null, 'SIGTERM', CURSOR_RUN_WORDS.generate).message
+ * unfinishedExitError(null, 'SIGTERM', WIKI_RUN_KIND_WORDS.generate).message
  * // => 'Cursor Agent stopped on signal SIGTERM before finishing. Run "/codebook Generate the LLM Wiki for this project" in Cursor chat to see its own message.'
  */
 function unfinishedExitError(
   code: number | null,
   exitSignal: NodeJS.Signals | null,
-  words: CursorRunWords,
+  words: WikiRunKindWords,
 ): CursorAgentExitError {
   return new CursorAgentExitError(
     `Cursor Agent stopped ${code === null ? `on signal ${exitSignal ?? 'unknown'}` : `with exit code ${code}`} before finishing. Run "${words.chatRequest}" in Cursor chat to see its own message.`,
@@ -143,7 +114,7 @@ export async function runCursorWikiUpdate(
   timeoutMs: number,
   runKind: WikiRunKind = 'update',
 ): Promise<string> {
-  const words = CURSOR_RUN_WORDS[runKind]
+  const words = WIKI_RUN_KIND_WORDS[runKind]
   if (Buffer.byteLength(prompt, 'utf8') > WIKI_CURSOR_PROMPT_LIMIT_BYTES)
     throw new Error(`The Wiki ${words.noun} request is too large.`)
   throwIfWikiUpdateCancelled(signal, words)
diff --git a/extension/src/utils/runUnderAbortSignal.ts b/extension/src/utils/runUnderAbortSignal.ts
new file mode 100644
index 000000000..26d4d630a
--- /dev/null
+++ b/extension/src/utils/runUnderAbortSignal.ts
@@ -0,0 +1,35 @@
+/**
+ * Runs a step that cannot be cancelled and ends the wait for it the moment an abort signal fires.
+ * Why: the managed Cursor skill's verify and deploy run with the start's marker claimed; Stop LLM Wiki Run and a bound must end the start at once, without waiting for a step that may hang (Cycle 0056 task 13).
+ * Trigger: the extension wraps the skill step in it; tests wrap stand-ins.
+ * @param step - Starts the work; it is called once, and not at all when the signal has fired already.
+ * @param signal - Ends the wait when it fires.
+ * @returns What the step resolved with, when it settled before the signal.
+ * @throws The signal's reason when it fired first or in the same tick the step settled (a Stop pressed then still wins); what the step threw when it failed first. A step that settles after the signal is not awaited: its result is ignored and its failure swallowed.
+ * @example
+ * await runUnderAbortSignal(() => deploy(), controller.signal)
+ */
+export async function runUnderAbortSignal<Result>(
+  step: () => Promise<Result>,
+  signal: AbortSignal,
+): Promise<Result> {
+  // A signal that fired before the step began leaves nothing to start.
+  signal.throwIfAborted()
+  const stepping = step()
+  // A step that fails after the signal won the race has nobody left to tell.
+  stepping.catch(() => undefined)
+  let endWaiting = (): void => {}
+  const aborted = new Promise<never>((_resolve, reject) => {
+    const onAbort = (): void => reject(signal.reason)
+    signal.addEventListener('abort', onAbort, { once: true })
+    endWaiting = (): void => signal.removeEventListener('abort', onAbort)
+  })
+  try {
+    const result = await Promise.race([stepping, aborted])
+    // A signal that fired in the tick the step settled lost the race by order alone; the stop still counts.
+    signal.throwIfAborted()
+    return result
+  } finally {
+    endWaiting()
+  }
+}
diff --git a/extension/src/utils/startWikiRun.ts b/extension/src/utils/startWikiRun.ts
index d5cde4b51..5a9d2240e 100644
--- a/extension/src/utils/startWikiRun.ts
+++ b/extension/src/utils/startWikiRun.ts
@@ -1,18 +1,12 @@
+import type {
+  TakenOverWikiReservation,
+  WikiReservationHandoff,
+} from './claimWikiUpdateMarker'
 import { describeOutputFolderWithoutWiki } from './describeOutputFolderWithoutWiki'
 import { describeWikiGenerateBlock } from './describeWikiGenerateBlock'
 import type { WikiUpdateStartBlock } from './findWikiUpdateStartBlock'
 import type { WikiUpdateOutput } from './wikiUpdateRun'
 
-/**
- * Words that a folder holds no LLM Wiki, for the notices of Open LLM Wiki in Browser and Update LLM Wiki, which offer Generate LLM Wiki beside it (Cycle 0055, proposed change 3).
- * @param outputLabel - The Wiki folder as the learner reads it.
- * @returns The sentence that names the folder.
- * @example describeMissingWiki('.codebook/wiki') // => 'Codebook found no LLM Wiki in .codebook/wiki.'
- */
-export function describeMissingWiki(outputLabel: string): string {
-  return `Codebook found no LLM Wiki in ${outputLabel}.`
-}
-
 /** Another window's running generation or update, a stopped VS Code watch's reservation or an earlier chat's leftover in the way of a new run: the sentence of the refusal and, where the learner may go on anyway, what the override starts. */
 export type WikiRunInTheWay = { reason: string; override?: () => void }
 
@@ -20,10 +14,21 @@ export type WikiRunInTheWay = { reason: string; override?: () => void }
 export type WikiRunMarkerClaim<Holder> =
   | {
       release: () => Promise<boolean>
-      reserve: (watchEndedAtMs: number) => Promise<boolean>
+      reserve: (
+        watchEndedAtMs: number,
+        takenOver?: WikiReservationHandoff,
+      ) => Promise<boolean>
+      /** The stopped watch's reservation the claim took over (its end, the kind of its run and its marker); a refused start writes it back as it was ({@link leaveMarker}). */
+      takenOver?: TakenOverWikiReservation
     }
   | { heldBy: Holder }
 
+/** The run's own marker, as {@link WikiRunMarkerClaim} hands it out. */
+export type ClaimedWikiRunMarker = Exclude<
+  WikiRunMarkerClaim<unknown>,
+  { heldBy: unknown }
+>
+
 /**
  * What {@link startWikiGenerate} asks of the editor window, each as a closure of the extension's activation, so the start's order lives here and host tests pass stand-ins (Cycle 0055, `WikiRunDependencies`).
  */
@@ -44,8 +49,10 @@ export type WikiGenerateStartDependencies<Holder> = {
   openLocationSetting: () => Promise<unknown>
   /** Makes the folder that holds the output and its marker, never the output folder itself ({@link placeStorageLock} makes no folder for the marker). */
   makeOutputParent: () => Promise<void>
-  /** Readies the agent once the marker is claimed and no Wiki appeared, so a start that is refused or offers the update writes no skill: in Cursor the managed skill ({@link verifyManagedCursorSkill}, {@link deployCursorSkill}), whose conflict throws and releases the marker; nothing in VS Code. */
+  /** Readies the agent once the marker is claimed and no Wiki appeared, so a start that is refused or offers the update writes no skill: in Cursor the managed skill ({@link verifyManagedCursorSkill}, {@link deployCursorSkill}), whose conflict throws and leaves the marker (removed, or a taken-over reservation written back); nothing in VS Code. */
   prepareAgent: () => Promise<void>
+  /** Leaves the marker of a start that did not go ahead: removes it, or writes a taken-over reservation back as it was and keeps it counted down to its bound, with the bounded retry every change of this window's marker has ({@link claimWikiUpdateMarker}'s answers `true` once nothing is left to change); never rejects. */
+  leaveMarker: (claim: ClaimedWikiRunMarker) => Promise<void>
   /** Claims the run's marker for a generation that starts at the given time. */
   claimMarker: (startedAtMs: number) => Promise<WikiRunMarkerClaim<Holder>>
   /** The sentence of a refusal for another window that holds the marker ({@link describeOtherWikiWindow}). */
@@ -58,8 +65,8 @@ export type WikiGenerateStartDependencies<Holder> = {
   hasOutputFolderWithoutWiki: () => Promise<boolean>
   /** Offers the update where a Wiki already stands: `An LLM Wiki already exists in <folder>. Update it instead?` */
   offerUpdate: () => void
-  /** Tells the learner why the generation did not start, with the override where there is one. */
-  refuse: (reason: string, override?: () => void) => void
+  /** Tells the learner why the generation did not start, with the override where there is one; `cause` is the id of a block, which only the Output record shows. */
+  refuse: (reason: string, override?: () => void, cause?: string) => void
   /** The present (epoch milliseconds). */
   now: () => number
 }
@@ -68,21 +75,21 @@ export type WikiGenerateStartDependencies<Holder> = {
 export type WikiGenerateStart = {
   /** The publication identity at the start, `undefined` where no receipt stands; only another one at the end is the generation's publication. */
   publicationAtStart: string | undefined
-  releaseMarker: () => Promise<boolean>
-  reserveMarker: (watchEndedAtMs: number) => Promise<boolean>
+  /** The run's own marker: its release, its turn into a reservation and the reservation the claim took over, where it did. */
+  claim: ClaimedWikiRunMarker
   startedAtMs: number
   /** Whether the opened folder is in a Git repository; `undefined` when Git could not be asked. */
   hasGitRepository: boolean | undefined
 }
 
 /**
- * Looks for a Wiki once more and readies the agent for a claimed generation, and releases its marker when a step fails, so a start that throws leaves no marker; called by {@link startWikiGenerate} after the claim.
+ * Looks for a Wiki once more and readies the agent for a claimed generation, and leaves its marker when a step fails (removed, or a taken-over reservation written back; {@link WikiGenerateStartDependencies.leaveMarker}), so a start that throws leaves no marker of its own; called by {@link startWikiGenerate} after the claim.
  * Why: the agent is readied only for a start that goes ahead, so a refused start or the update's offer writes no Cursor skill, and a skill in the learner's way never hides the refusal of another window's run; the slower reads were made before the claim, so the marker stands for no run only this briefly (/ship review, Cycle 0055 pt1).
  * @param dependencies - The editor window's closures.
  * @param claim - The run's own marker.
  * @param begun - What the start read before the claim, and when the generation started.
- * @returns The start, or `undefined` after the marker was released for a Wiki that appeared between the first look and the claim (the update is offered).
- * @throws What readying the agent or the look threw (a Cursor skill in the way), after the marker was released.
+ * @returns The start, or `undefined` after the marker was left for a Wiki that appeared between the first look and the claim (the update is offered).
+ * @throws What readying the agent or the look threw (a Cursor skill in the way), after the marker was left.
  * @example await beginClaimedGeneration(dependencies, claim, { publicationAtStart: undefined, hasGitRepository: true, startedAtMs: 1_790_000_000_000 }) // => { publicationAtStart: undefined, … }
  */
 async function beginClaimedGeneration<Holder>(
@@ -96,13 +103,13 @@ async function beginClaimedGeneration<Holder>(
   try {
     // A Wiki that appeared between the first look and the claim is updated, never overwritten.
     if ((await dependencies.readPublishToken()) !== undefined) {
-      await claim.release().catch(() => false)
+      await dependencies.leaveMarker(claim)
       dependencies.offerUpdate()
       return undefined
     }
     // A folder without a Wiki that appeared around the claim is refused too: the publisher would refuse it after the agent's work (CodeRabbit, PR #133).
     if (await dependencies.hasOutputFolderWithoutWiki()) {
-      await claim.release().catch(() => false)
+      await dependencies.leaveMarker(claim)
       dependencies.refuse(
         describeOutputFolderWithoutWiki(dependencies.wikiOutput.outputLabel),
       )
@@ -111,12 +118,11 @@ async function beginClaimedGeneration<Holder>(
     await dependencies.prepareAgent()
     return {
       ...begun,
-      releaseMarker: claim.release,
-      reserveMarker: claim.reserve,
+      claim,
     }
   } catch (error) {
     // A start that throws after its claim leaves no marker behind.
-    await claim.release().catch(() => false)
+    await dependencies.leaveMarker(claim)
     throw error
   }
 }
@@ -132,8 +138,11 @@ async function refusedForBlockOrRun<Holder>(
 ): Promise<boolean> {
   const block = await dependencies.findStartBlock()
   if (block) {
+    // The cause id goes to the Output record beside the learner's sentence.
     dependencies.refuse(
       describeWikiGenerateBlock(block, dependencies.wikiOutput.outputLabel),
+      undefined,
+      block.cause,
     )
     return true
   }
@@ -160,7 +169,7 @@ async function refusedForBlockOrRun<Holder>(
  * @returns The start with its claimed marker; `undefined` when the start did not go ahead and the learner was told (a refusal, an offer of the update, a dismissed confirmation, Change location).
  * @throws What the path check, the folder, the agent's preparation or the claim threw; the caller tells the learner. No marker is left.
  * @example
- * await startWikiGenerate(dependencies) // => { publicationAtStart: undefined, releaseMarker, reserveMarker, startedAtMs: 1_790_000_000_000, hasGitRepository: true }
+ * await startWikiGenerate(dependencies) // => { publicationAtStart: undefined, claim, startedAtMs: 1_790_000_000_000, hasGitRepository: true }
  */
 export async function startWikiGenerate<Holder>(
   dependencies: WikiGenerateStartDependencies<Holder>,
diff --git a/extension/src/utils/wikiGenerateNotice.ts b/extension/src/utils/wikiGenerateNotice.ts
index 040c971ed..1a376472c 100644
--- a/extension/src/utils/wikiGenerateNotice.ts
+++ b/extension/src/utils/wikiGenerateNotice.ts
@@ -63,7 +63,11 @@ function cancelledNotice(
   if (cancelled.site === 'replaced')
     return {
       severity: 'information',
-      message: `The LLM Wiki generation was stopped at ${at}, after an LLM Wiki was published in ${cancelled.outputLabel}.`,
+      // One verb per host, as in the sibling notice below: VS Code stopped watching, Cursor cancelled.
+      message:
+        cancelled.host === 'cursor'
+          ? `The LLM Wiki generation was cancelled at ${at}, after an LLM Wiki was published in ${cancelled.outputLabel}.`
+          : `Codebook stopped watching the LLM Wiki generation at ${at}, after an LLM Wiki was published in ${cancelled.outputLabel}.`,
       actions: [OPEN_WIKI_IN_BROWSER_ACTION],
     }
   return {
diff --git a/extension/src/utils/wikiRunBoundMs.ts b/extension/src/utils/wikiRunBoundMs.ts
index 707597edd..2848b8ba6 100644
--- a/extension/src/utils/wikiRunBoundMs.ts
+++ b/extension/src/utils/wikiRunBoundMs.ts
@@ -1,5 +1,4 @@
 import {
-  WIKI_CHAT_OPEN_TIMEOUT_MS,
   WIKI_CURSOR_UPDATE_TIMEOUT_MS,
   WIKI_GENERATE_TIMEOUT_MS,
   WIKI_UPDATE_WATCH_TIMEOUT_MS,
@@ -37,31 +36,3 @@ export function wikiRunBoundMs(
   if (runKind === 'generate') return bounds.generateMs
   return host === 'cursor' ? bounds.cursorUpdateMs : bounds.watchedUpdateMs
 }
-
-/**
- * Names the longest a run of one kind and host can last from its marker's start to its end; called by the marker reader for a run's marker that may have expired.
- * @param runKind - The run's kind; `undefined` reads as an update.
- * @param host - The editor host that runs it.
- * @returns The Cursor agent's bound, or in VS Code the chat's opening ({@link WIKI_CHAT_OPEN_TIMEOUT_MS}) and the watch's bound.
- * @example
- * longestWikiRunMs('generate', 'vscode') // => 3_330_000
- * longestWikiRunMs('update', 'cursor')   // => 900_000
- */
-export function longestWikiRunMs(
-  runKind: WikiRunKind | undefined,
-  host: WikiUpdateHost,
-): number {
-  // A VS Code run first waits for the chat to open, then watches for the publish.
-  return host === 'cursor'
-    ? wikiRunBoundMs(runKind, host)
-    : WIKI_CHAT_OPEN_TIMEOUT_MS + wikiRunBoundMs(runKind, host)
-}
-
-/** The longest any run of any kind and host can last ({@link longestWikiRunMs}); a marker file whose kind cannot be read counts this long, never the update's shorter bound. */
-export const LONGEST_WIKI_RUN_MS = Math.max(
-  ...(['generate', 'update'] as const).flatMap((runKind) =>
-    (['vscode', 'cursor'] as const).map((host) =>
-      longestWikiRunMs(runKind, host),
-    ),
-  ),
-)
diff --git a/extension/src/utils/wikiRunKindWords.ts b/extension/src/utils/wikiRunKindWords.ts
new file mode 100644
index 000000000..e56e6dab3
--- /dev/null
+++ b/extension/src/utils/wikiRunKindWords.ts
@@ -0,0 +1,38 @@
+import {
+  WIKI_GENERATE_CHAT_REQUEST,
+  WIKI_UPDATE_CHAT_REQUEST,
+} from '../constants'
+
+import type { WikiRunKind } from './wikiUpdateRun'
+
+/** The words the sentences of a Wiki run use for its kind, so a generation's sentences never call it an update (Cycle 0055, D5). */
+export type WikiRunKindWords = {
+  /** The run as a noun: `update` or `generation`. */
+  noun: string
+  /** The run as the verb of "Cursor Agent timed out … the Wiki": `updating` or `generating`. */
+  verb: string
+  /** The button the learner presses to run it again: `Update` or `Generate`. */
+  button: string
+  /** The chat request a learner can paste in Cursor chat to see the agent's own message. */
+  chatRequest: string
+}
+
+/**
+ * {@link WikiRunKindWords} of each run kind: the one table that {@link describeWikiSkillStepEnd}, {@link describeJoinedWikiStart} and {@link runCursorWikiUpdate} word their kind from.
+ * @example
+ * WIKI_RUN_KIND_WORDS.generate.button // => 'Generate'
+ */
+export const WIKI_RUN_KIND_WORDS: Record<WikiRunKind, WikiRunKindWords> = {
+  update: {
+    noun: 'update',
+    verb: 'updating',
+    button: 'Update',
+    chatRequest: WIKI_UPDATE_CHAT_REQUEST,
+  },
+  generate: {
+    noun: 'generation',
+    verb: 'generating',
+    button: 'Generate',
+    chatRequest: WIKI_GENERATE_CHAT_REQUEST,
+  },
+}
diff --git a/extension/src/utils/wikiRunRecord.ts b/extension/src/utils/wikiRunRecord.ts
index 175f89992..b6f6b6cac 100644
--- a/extension/src/utils/wikiRunRecord.ts
+++ b/extension/src/utils/wikiRunRecord.ts
@@ -6,35 +6,9 @@ import {
   DELETE_CHARACTER_CODE,
 } from '../constants'
 
+import type { WikiAgentExit } from './agentExitOf'
 import type { WikiRunKind, WikiUpdateStatus } from './wikiUpdateRun'
 
-/** What an agent process's exit said, as data: the Cursor agent's exit code or signal ({@link CursorAgentExitError}); absent for a VS Code chat and for a run that ended otherwise. */
-export type WikiAgentExit = {
-  exitCode: number | null
-  exitSignal: string | null
-}
-
-/**
- * Reads the exit code or signal off a failure of the Cursor agent's process ({@link CursorAgentExitError}), by its fields, so a stand-in of the runner in a test is read as the runner is.
- * @param error - What the Cursor agent's run threw.
- * @returns The exit code and signal where the failure carries them; `undefined` for any other failure.
- * @example
- * agentExitOf(Object.assign(new Error('…'), { exitCode: 1, exitSignal: null })) // => { exitCode: 1, exitSignal: null }
- * agentExitOf(new Error('The Wiki update was cancelled.'))                    // => undefined
- */
-export function agentExitOf(error: unknown): WikiAgentExit | undefined {
-  if (typeof error !== 'object' || error === null) return undefined
-  const exitCode: unknown = Reflect.get(error, 'exitCode')
-  const exitSignal: unknown = Reflect.get(error, 'exitSignal')
-  // Only a failure that carries the process's own answer has one; a cancel, a bound or a start failure carries none.
-  if (typeof exitCode !== 'number' && typeof exitSignal !== 'string')
-    return undefined
-  return {
-    exitCode: typeof exitCode === 'number' ? exitCode : null,
-    exitSignal: typeof exitSignal === 'string' ? exitSignal : null,
-  }
-}
-
 /** One ended run as its record takes it: the state the run ended in; its start and the Cursor agent's exit come beside it in {@link wikiRunRecord}'s `details`. */
 type EndedWikiRun = Exclude<WikiUpdateStatus, { state: 'idle' | 'running' }>
 
@@ -54,7 +28,10 @@ function endSummary(ended: EndedWikiRun): string {
     case 'already-current':
       return 'nothing to update: the Wiki matches the source'
     case 'cancelled':
-      return 'stopped by the learner or the closing window'
+      // One verb per host, as the notices and the view say it: Codebook stops watching a VS Code chat and cancels a Cursor agent.
+      return ended.host === 'cursor'
+        ? 'cancelled by the learner or the closing window'
+        : 'stopped watching by the learner or the closing window'
     case 'timed-out':
       return 'stopped at its bound'
     case 'conflict':
@@ -133,6 +110,7 @@ function withoutControlCharacters(path: string): string {
  * @param details.runKind - The run's kind.
  * @param details.startedAt - When the run started, as an ISO timestamp; absent for a refused start.
  * @param details.agentExit - The Cursor agent's exit code or signal, where its process gave one.
+ * @param details.blockCause - The id of the block that refused a generation's start (`findWikiUpdateStartBlock`); the learner's sentence leaves it out.
  * @param homeDirectory - The learner's home folder; tests pass their own.
  * @param platform - The system whose paths these are; tests pass their own.
  * @returns One line: `LLM Wiki <kind> ended: host=… started=… ended=… end=… summary="…" [exit=…] output=…`.
@@ -148,6 +126,7 @@ export function wikiRunRecord(
     runKind: WikiRunKind
     startedAt?: string
     agentExit?: WikiAgentExit
+    blockCause?: string
   },
   homeDirectory: string = homedir(),
   platform: NodeJS.Platform = process.platform,
@@ -157,5 +136,6 @@ export function wikiRunRecord(
   const exit = details.agentExit
     ? ` exit=${details.agentExit.exitCode ?? details.agentExit.exitSignal ?? 'unknown'}`
     : ''
-  return `LLM Wiki ${details.runKind} ended: host=${host} started=${details.startedAt ?? 'not started'} ended=${ended.finishedAt} end=${ended.state} summary="${endSummary(ended)}"${exit} output=${withoutControlCharacters(pathWithHomeShortened(ended.outputDirectory, homeDirectory, platform))}`
+  const cause = details.blockCause ? ` cause=${details.blockCause}` : ''
+  return `LLM Wiki ${details.runKind} ended: host=${host} started=${details.startedAt ?? 'not started'} ended=${ended.finishedAt} end=${ended.state} summary="${endSummary(ended)}"${exit}${cause} output=${withoutControlCharacters(pathWithHomeShortened(ended.outputDirectory, homeDirectory, platform))}`
 }
diff --git a/extension/src/utils/wikiSkillStepEndOf.ts b/extension/src/utils/wikiSkillStepEndOf.ts
new file mode 100644
index 000000000..aa1382cc4
--- /dev/null
+++ b/extension/src/utils/wikiSkillStepEndOf.ts
@@ -0,0 +1,30 @@
+import {
+  WIKI_SKILL_STEP_BOUND_REASON,
+  WIKI_SKILL_STEP_EARLIER_RUNNING_END,
+  WIKI_SKILL_STEP_STOPPED_REASON,
+} from '../constants'
+
+import type { WikiSkillStepEnd } from './describeWikiSkillStepEnd'
+
+/**
+ * Names how an aborted Cursor skill step ended, from its abort reason and whether it still waited for an earlier step.
+ * Why: the bound and the learner's Stop (or the closing window) abort the same step, and a bound that fires while the step only waits for an earlier hung step has a different cause and a different next step ({@link describeWikiSkillStepEnd}).
+ * Trigger: the extension's skill step calls it when its wait was aborted, before it words the end.
+ * @param abortReason - The reason the step's abort carried: {@link WIKI_SKILL_STEP_BOUND_REASON} from the bound, {@link WIKI_SKILL_STEP_STOPPED_REASON} from Stop LLM Wiki Run and from the closing window.
+ * @param isWaitingForEarlierStep - Whether the step had not yet begun its own verify because an earlier step of this window had not settled.
+ * @returns `earlier-step-running` for a bound that fired during the wait, `bound` for any other bound, `stopped` for every other reason.
+ * @example
+ * wikiSkillStepEndOf('bound', true)   // => 'earlier-step-running'
+ * wikiSkillStepEndOf('bound', false)  // => 'bound'
+ * wikiSkillStepEndOf('stopped', true) // => 'stopped'
+ */
+export function wikiSkillStepEndOf(
+  abortReason: unknown,
+  isWaitingForEarlierStep: boolean,
+): WikiSkillStepEnd {
+  if (abortReason !== WIKI_SKILL_STEP_BOUND_REASON)
+    return WIKI_SKILL_STEP_STOPPED_REASON
+  return isWaitingForEarlierStep
+    ? WIKI_SKILL_STEP_EARLIER_RUNNING_END
+    : WIKI_SKILL_STEP_BOUND_REASON
+}