diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2e52c9fb9..67f7f35ba 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.2.42.0] - 2026-10-26 (development candidate)
+
+Cycle 0052 pt3 ([Issue #124](https://github.com/laststance/codebook/issues/124)), the last of three pull requests of a bug-fix cycle: a live test run survives a value it cannot read, and a browser run's refusals and seals say what happened.
+
+**A live test run keeps going past a value it cannot read.**
+
+- **A value the chat asks for at a test stop is read also when it is a name the stopped file imports**, such as `revalidatePath.mock.calls.length` of a mocked `next/cache` or a mocked database client's `db.insert.mock.calls`: Codebook reads it through the module Vitest binds it to, as the export the file's import declaration names, so an alias reads its module's original export and a default import its default export, each from that declaration's own module, never from another module that happens to export the same name; a name the file does not import, or an import whose module the stop cannot see, stays unavailable rather than guessed. A getter on the asked path runs once, as it does when you expand it in the Variables view.
+- **A required value that still cannot be read no longer ends the run.** The stop keeps its other values and names the missing one, and the continuation that reached it (the chat's `codebook_continue`, or your Continue in the Study pane) answers `EVIDENCE_UNAVAILABLE` naming it while the run stays paused there, so it can go on without it or stop the run; `codebook://help/errors` says so in its recovery. A getter the debugger cannot expand, or expands to no single value, leaves only its own value unavailable (never its `(...)` placeholder), and a local variable keeps priority over an import of the same name even when its value cannot be read.
+- **A run that went on without a required value seals its history partial**, with a reason that names the value and its stop: the study reads partial although the test passed.
+
+**A browser run says where a stop can go and why it ended.**
+
+- **A stop in another page's component** (one a link from the launched page navigates to) is refused before input with a sentence that names the stop's file and the launched page, and says to start the run at the stop's page (`entryPath`) or to choose a stop in the launched page's own components.
+- **A run refused during its preparation, or failed later, seals its recording with that failure's own words** (`The run failed: <cause>. Recorded prefix retained.`, a long cause cut so that the sentence keeps its end), not as an interrupted run; a run whose release did not complete keeps `Runtime cleanup incomplete; recorded prefix retained.`
+- **A browser replay whose open fails** also writes one `open:recording` entry to **Output › Codebook**, with the study, the profile and the cause.
+
+**Other fixes.**
+
+- **A node-history reference with an unknown study id** (a mistyped id, for example, or a history removed while it is read) is refused as `NOT_FOUND`, naming the id and telling the agent to copy the `studyId` or `historyUri` from `codebook://node-history`, instead of a failed operation with a raw file error.
+- **Update anyway chosen right after this window's own update run ended** starts the update: it waits for that run's marker change instead of refusing itself as another window's update.
+
+**Compatibility.** The MCP API stays 1.8, the bundled skill is unchanged (1.0.47) and no stored format changes. This closes Issue #124's tasks; nothing is carried.
+
 ## [0.2.41.0] - 2026-10-25 (development candidate)
 
 Cycle 0052 pt2 ([Issue #124](https://github.com/laststance/codebook/issues/124)), the second of three pull requests of a bug-fix cycle: a test replay's moves, notices and summary page.
diff --git a/README.md b/README.md
index cb16eb3c8..fa83bba88 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.41.0** once the second pull request of [Cycle 0052](https://github.com/laststance/codebook/issues/124) is merged; until then 0.2.40.0 ([PR #125](https://github.com/laststance/codebook/pull/125)) is the delivered one, and the active cycle Issue says where the delivery stands. 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 is a bug-fix cycle that closes 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.42.0** once the third pull request of [Cycle 0052](https://github.com/laststance/codebook/issues/124) is merged; until then 0.2.41.0 ([PR #126](https://github.com/laststance/codebook/pull/126)) is the delivered one, and the active cycle Issue says where the delivery stands. 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 is a bug-fix cycle that closes every defect Cycle 0051 carried, in three pull requests: the first makes replays leave, open and reload without stale frames and makes their entries and exits behave as the learner chose; the second fixes a test replay's moves and its summary page; the third the live runtime's unreadable facts, a browser run's refusals and the tests' hygiene. The MCP API is 1.8. What each earlier cycle delivered, with its tests, trials and limits, is in the [change history](CHANGELOG.md) and in that cycle's record, kept under the tag [`docs-archive-2026-10-20`](https://github.com/laststance/codebook/tree/docs-archive-2026-10-20/docs/cycles); from Cycle 0048 on, the cycle's Issue holds its tasks and state, and its pull requests the results.
 
 The specification is [goal version 10](PRODUCT_GOAL.md), and the implementation targets external repositories. Historical fixture or coupled-Wiki success is not proof of that destination.
 
diff --git a/VERSION b/VERSION
index 3df837325..ae1fc44f6 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.2.41.0
+0.2.42.0
diff --git a/extension/README.md b/extension/README.md
index 99983e202..eb3e6282a 100644
--- a/extension/README.md
+++ b/extension/README.md
@@ -100,7 +100,7 @@ The time slider marks the recording between its first and last event as unrecord
 
 Unexpected failures on these paths write one entry each to **Output › Codebook**, with the surface, the study, the profile, the versions, the cause and the stack. The causes they show name the extension's storage, the workspace and the home folder as `<storage>`, `<workspace>` and `~`, also after the runtime is released; some other messages can still show full local paths. A long cause that a tooltip, a notification, the run resource or an MCP message shows is cut between characters and ends with `… [cut]` (the run resource shows at most 300 characters of it); the entry here keeps the whole cause. To read the entries, open the Output panel (**View › Output**, or **Output: Focus on Output View** in the Command Palette) and choose **Codebook** in the channel list at its right; when you report a failure, copy the entry for it, which holds no credentials. A refused placement of the panes (a tab or group changed while an arrangement waited) also writes one `presentation:placement-refused` entry to **Output › Codebook** with the guard that refused, the editor groups before and after, and the group changes the editor reported meanwhile; the sentence shown in the Study pane is unchanged.
 
-The bundled skill (1.0.47) routes a question about a test, or about library behavior a test exercises, to the `node-test` profile, and the chat explains each test stop in the chat. A run that ends with an `error` before its first stop did not run its test: the chat starts it again only where the published recovery of that error's code allows (`codebook://help/errors`), and it treats any text the error quotes, such as test or tool output, as data. The chat claims saved learning only when the run reads `studyOutcome` `demonstrated`, `nodeTest.learningCoverage` `complete` and an empty `nodeTest.captureMissing` (a run resource without those fields supports no such claim), says when a test did not pass and names its exit code or signal, and points you to **Save learning replay** and **Open replay**. When the connection is unavailable, it sends you to **Codebook: Set Up AI Chat**, and in a chat of VS Code's Copilot harness (the default for a new chat), which cannot reach Codebook's tools, to open a Local chat session.
+The bundled skill (1.0.47) routes a question about a test, or about library behavior a test exercises, to the `node-test` profile, and the chat explains each test stop in the chat. A value the chat asks for at a test stop is also read when it is a name the stopped file imports (`revalidatePath.mock.calls.length` of a mocked `next/cache`, for example), through the module Vitest binds it to, as the export its import declaration names: an alias reads the module's original export and a default import its default export, each from that declaration's own module, never from another module that happens to export the same name; a namespace import, a name the file does not import, and an import whose module the stop cannot see stay unavailable rather than guessed. A getter on the asked path (a Vitest mock's `mock`, for example) runs once, as it does when you expand it in the Variables view; a getter the debugger cannot expand, or expands to no single value, leaves only that value unavailable, never its `(...)` placeholder, and a local variable whose value cannot be read still takes priority over an import of the same name. A required value that still cannot be read no longer ends the run: the stop keeps its other values and names the missing one among its debugger limitations, and the `codebook_continue` that reached it (or your Continue in the Study pane) answers `EVIDENCE_UNAVAILABLE` naming it while the run stays paused there, so the chat, or you, can continue without it; the run's history then seals partial, with a reason that names the value and its stop, and the study reads partial although the test passed. A run that ends with an `error` before its first stop did not run its test: the chat starts it again only where the published recovery of that error's code allows (`codebook://help/errors`), and it treats any text the error quotes, such as test or tool output, as data. The chat claims saved learning only when the run reads `studyOutcome` `demonstrated`, `nodeTest.learningCoverage` `complete` and an empty `nodeTest.captureMissing` (a run resource without those fields supports no such claim), says when a test did not pass and names its exit code or signal, and points you to **Save learning replay** and **Open replay**. When the connection is unavailable, it sends you to **Codebook: Set Up AI Chat**, and in a chat of VS Code's Copilot harness (the default for a new chat), which cannot reach Codebook's tools, to open a Local chat session.
 
 #### Quick start: a test replay
 
@@ -169,7 +169,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.` 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 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 21 minutes 30 seconds after its last write, as long as any marker counts; 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 21 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.` 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 21 minutes 30 seconds after its last write, as long as any marker counts; 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 21 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 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 (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.
 
@@ -338,13 +338,13 @@ For actual-editor Playwright CLI video, set `CODEBOOK_EDITOR_CDP=1` only on the
 
 ## Run one configured repository action
 
-Minimum versions: **extension 0.2.0+ / MCP API 1.4+**. The current preview is the version in this package's manifest (`extension/package.json`) with **MCP API 1.8** (`codebook_status` reports the installed build). API 1.8 changed what a `node-test` run reports: it reads `demonstrated` in `finalOutcome` once its test passed after every declared stop, and in `studyOutcome` and `recordedStudyOutcome` once its history sealed complete (before, it read `partial` at most); its run resource adds `nodeTest.testResult` (`passed`, `failed`, `signal` or `none`), `nodeTest.learningCoverage` (`complete`, `partial` or `none`) and `nodeTest.learningMissing`, and `nextActions` lists `save-node-learning` until the coverage is complete (and only for a history that holds an entry). Both the run resource and the node-history resource also list `nodeTest.captureMissing`, the recorded evidence the replay lacks (a stop whose debugger state was not captured, or an execution that ended before its result), which no explanation adds and which makes Save read partially saved; an agent claims saved learning only when `captureMissing` is empty. Causes the run resource shows (`nodeTest.historyReason`, `recording.reason`, `recording.contextReason`) are cut to 300 characters and name no private storage path. A node-test stop whose position does not fit its retained citation is refused during preparation with a sentence that names the stop (`source` or `additionalStops[n]`), its `anchorIndex`, the cited path and lines and the one condition that failed (anchor, path, hash, line or column), and what to send. The column of a declared node-test stop is a preference: when the debugger binds the declared line at another column, the stop is accepted and captured at that column, and only a binding on another line refuses it; that refusal names the declared and the bound position and says that the stop is captured on its declared line. A declared node-test stop in the cited test file itself is reached as well when the debugger reports no entry pause before it: its first pause is the stop, and Codebook captures it instead of continuing past it. A node-test start's checks (a changed stop source, a cited source the editor holds with other text, a changed test file, a path that is not a file, a root Vitest missing, older than 4 or without its program) run during preparation and end the run with a typed `error` before its first stop, which records no history and frees the run's slot and key; `codebook_status` names a missing or older root Vitest before any start, and a root `node_modules/vitest` that links outside the repository is not run. `codebook_stop` answers `HISTORY_SEAL_FAILED` when it could not seal the history of the run it ended, and `codebook_playback` refuses a test replay with `PLAYBACK_PROFILE_UNSUPPORTED`. `codebook_explain_node_history` refuses a step that cites another event than it claims with `INVALID_REFERENCE`, naming what that event is, and the node-test help (`codebook://help/node-test`) holds a complete start example and the ordered walkthrough of the calls. A test that ends with a non-zero exit code or a signal keeps that result even without Vitest's report, and a passing run whose first release failed seals complete once a retried Stop releases it. A test history whose seal fails with a transient file-system code (`EMFILE`, `ENFILE`, `EBUSY`, `EAGAIN` or `EPERM`) is sealed once more after 200 ms before the run reports `HISTORY_SEAL_FAILED`; a repeated `codebook_stop` makes no further attempt. No stored format changed in 1.8: test histories, learning materials and reader positions written by an earlier 0.2 version open unchanged. API 1.7 changed two answers: `codebook_source`, and `codebook_read_resource` for a book's cited source, answer the source's lines as `numberedText` and no longer as `text`, because the two copies doubled every source answer. An MCP `resources/read` of a cited source's URI still answers its exact text. No request states an API version, so a client written for API 1.6 gets these answers too: where it read `text`, it reads `numberedText` (each line after its one-based number and a tab, the lines joined by a line feed). API 1.7 also added a second reason a run resource names, and its evidence is refused with, once the run's saved study was removed: `The archive of this run's saved study is no longer in the study library: its files were removed by hand or by another Codebook window.`, beside `The learner moved this saved study to the Trash.` for a study deleted in this window (see [Delete a saved study](#delete-a-saved-study)). API 1.6 added, without changing the meaning of an existing field: `declaredSource`, the position you declared (`requestedSource` is its older name); `armed`, the place Codebook requested the breakpoint at when that differs; `place`, one sentence that names the line a stop paused on when the debugger bound it on another line than you declared; and `answer: "next"` in the run resource's `continueArguments`, with which a continuation answers with the next state (the next observation, the observed result or the failure). API 1.6 also added `numberedText` to the answer of `codebook_source` and to the answer of `codebook_read_resource` for a book's cited source: the source's lines, each after its one-based number and a tab. Cycle 0029 delivered private preview **0.2.12** and Cycle 0018 **0.2.2**. `repository-browser` appears in `codebook_status.profiles` and its exact input schema at `codebook://help/repository-browser`. External-client execution, source/value pauses, recording/restart, interrupted evidence and native reader flows have separate development evidence in both editors. [Cycle 0017 installed evidence](https://github.com/laststance/codebook/blob/273660c49bb1aa5a88082ab6d43cd1ebae6ee7cf/docs/cycles/evidence/0017/native-validation.md) adds one unchanged real-repository action, live/replay modes and Wiki returns in both editors; its Cursor restart failure was later repaired in the bounded Cycle 0018 schedule. Neither result establishes G12 editor-chat use or full-product acceptance.
+Minimum versions: **extension 0.2.0+ / MCP API 1.4+**. The current preview is the version in this package's manifest (`extension/package.json`) with **MCP API 1.8** (`codebook_status` reports the installed build). API 1.8 changed what a `node-test` run reports: it reads `demonstrated` in `finalOutcome` once its test passed after every declared stop, and in `studyOutcome` and `recordedStudyOutcome` once its history sealed complete (before, it read `partial` at most); its run resource adds `nodeTest.testResult` (`passed`, `failed`, `signal` or `none`), `nodeTest.learningCoverage` (`complete`, `partial` or `none`) and `nodeTest.learningMissing`, and `nextActions` lists `save-node-learning` until the coverage is complete (and only for a history that holds an entry). Both the run resource and the node-history resource also list `nodeTest.captureMissing`, the recorded evidence the replay lacks (a stop whose debugger state was not captured, or an execution that ended before its result), which no explanation adds and which makes Save read partially saved; an agent claims saved learning only when `captureMissing` is empty. A node-history resource (`codebook://node-history/<studyId>`, its events or its learning material) or a `codebook_explain_node_history` call that names a study id this workspace holds no history for (a mistyped id, for example, or a history removed while it is read) is refused as `NOT_FOUND` with a sentence that names the id and tells the agent to copy the `studyId` or `historyUri` from `codebook://node-history`; the published recovery of `NOT_FOUND` says the same. Causes the run resource shows (`nodeTest.historyReason`, `recording.reason`, `recording.contextReason`) are cut to 300 characters and name no private storage path. A node-test stop whose position does not fit its retained citation is refused during preparation with a sentence that names the stop (`source` or `additionalStops[n]`), its `anchorIndex`, the cited path and lines and the one condition that failed (anchor, path, hash, line or column), and what to send. The column of a declared node-test stop is a preference: when the debugger binds the declared line at another column, the stop is accepted and captured at that column, and only a binding on another line refuses it; that refusal names the declared and the bound position and says that the stop is captured on its declared line. A declared node-test stop in the cited test file itself is reached as well when the debugger reports no entry pause before it: its first pause is the stop, and Codebook captures it instead of continuing past it. A node-test start's checks (a changed stop source, a cited source the editor holds with other text, a changed test file, a path that is not a file, a root Vitest missing, older than 4 or without its program) run during preparation and end the run with a typed `error` before its first stop, which records no history and frees the run's slot and key; `codebook_status` names a missing or older root Vitest before any start, and a root `node_modules/vitest` that links outside the repository is not run. `codebook_stop` answers `HISTORY_SEAL_FAILED` when it could not seal the history of the run it ended, and `codebook_playback` refuses a test replay with `PLAYBACK_PROFILE_UNSUPPORTED`. `codebook_explain_node_history` refuses a step that cites another event than it claims with `INVALID_REFERENCE`, naming what that event is, and the node-test help (`codebook://help/node-test`) holds a complete start example and the ordered walkthrough of the calls. A test that ends with a non-zero exit code or a signal keeps that result even without Vitest's report, and a passing run whose first release failed seals complete once a retried Stop releases it. A test history whose seal fails with a transient file-system code (`EMFILE`, `ENFILE`, `EBUSY`, `EAGAIN` or `EPERM`) is sealed once more after 200 ms before the run reports `HISTORY_SEAL_FAILED`; a repeated `codebook_stop` makes no further attempt. No stored format changed in 1.8: test histories, learning materials and reader positions written by an earlier 0.2 version open unchanged. API 1.7 changed two answers: `codebook_source`, and `codebook_read_resource` for a book's cited source, answer the source's lines as `numberedText` and no longer as `text`, because the two copies doubled every source answer. An MCP `resources/read` of a cited source's URI still answers its exact text. No request states an API version, so a client written for API 1.6 gets these answers too: where it read `text`, it reads `numberedText` (each line after its one-based number and a tab, the lines joined by a line feed). API 1.7 also added a second reason a run resource names, and its evidence is refused with, once the run's saved study was removed: `The archive of this run's saved study is no longer in the study library: its files were removed by hand or by another Codebook window.`, beside `The learner moved this saved study to the Trash.` for a study deleted in this window (see [Delete a saved study](#delete-a-saved-study)). API 1.6 added, without changing the meaning of an existing field: `declaredSource`, the position you declared (`requestedSource` is its older name); `armed`, the place Codebook requested the breakpoint at when that differs; `place`, one sentence that names the line a stop paused on when the debugger bound it on another line than you declared; and `answer: "next"` in the run resource's `continueArguments`, with which a continuation answers with the next state (the next observation, the observed result or the failure). The same version also added `numberedText` to the answer of `codebook_source` and to the answer of `codebook_read_resource` for a book's cited source: the source's lines, each after its one-based number and a tab. Cycle 0029 delivered private preview **0.2.12** and Cycle 0018 **0.2.2**. `repository-browser` appears in `codebook_status.profiles` and its exact input schema at `codebook://help/repository-browser`. External-client execution, source/value pauses, recording/restart, interrupted evidence and native reader flows have separate development evidence in both editors. [Cycle 0017 installed evidence](https://github.com/laststance/codebook/blob/273660c49bb1aa5a88082ab6d43cd1ebae6ee7cf/docs/cycles/evidence/0017/native-validation.md) adds one unchanged real-repository action, live/replay modes and Wiki returns in both editors; its Cursor restart failure was later repaired in the bounded Cycle 0018 schedule. Neither result establishes G12 editor-chat use or full-product acceptance.
 
 The current adapter is `next-dev-webpack`: a trusted local Git root with dependencies already installed, an executable Next development server, a same-origin `entryPath` (default `/`), default `.next/dev` output, and webpack modules/maps that retain the exact original selected source. Codebook starts the owned server on `127.0.0.1` at the project's own port (Next is started with `--hostname 127.0.0.1`) and opens the app in the recorded browser at `http://localhost:<port>`, the origin that `AUTH_URL`, OAuth callbacks and cookies usually name. `localhost`, `127.0.0.1` and `[::1]` at that port count as the same application origin, so a sign-in redirect between them keeps the run going while another port or host still ends it. Because a host may resolve `localhost` to `::1`, Codebook also listens on `[::1]:<port>` for the whole run and forwards its bytes to the owned server (each direction ends as its source ends, so a client that half-closes still gets the reply), so no other process can answer there. The listener starts after the owned `next dev` has bound its port and reported ready, and never starts when that readiness fails or is cancelled; it closes with the run. If something else already holds `[::1]:<port>`, preparation is refused as a busy port naming `[::1]`; if the system does not let Codebook listen there it is refused as not permitted, and any other listen failure is refused with its error code. On a host without IPv6 loopback no `[::1]` listener is made and `[::1]` is not accepted. The recorded browser resolves `localhost` as the system does, so the app's own calls to your other local services, on `::1` or `127.0.0.1`, reach them as they do in your own browser; Chrome itself runs on a dynamic loopback endpoint. The port is the one the project's own `dev` script would start `next dev` on, and Codebook asserts it only for a fixed set of forms. The `dev` script, and each script it runs, may be one or more statements joined by `&&` or `;`, each one of these: `export PORT=4000`, or a `PORT=4000` or plain `NAME=value` assignment as a prefix before a command; a `next dev` command reached by `next`, `npx next`, `bunx next`, `pnpm exec next`, `yarn next` or a `node_modules/.bin/next` path (the path form only on its own or after `pnpm exec`, since `npx` and `bunx` take a package name and fail on a path), optionally after `PORT=4000`, `cross-env` or `env` with assignments only, with Next's own `dev` flags and literal values (`-p`/`--port` as `-p 4000`, `-p4000`, `--port 4000` or `--port=4000`, the last one winning, `-H`/`--hostname`, `--turbo`, `--turbopack`, `--webpack`, `--experimental-https` and its `--experimental-https-*` options); a script run with no arguments (`npm run x`, `pnpm run x`, `yarn run x`, `bun run x`; `pnpm x` and `yarn x` without `run` are followed only for `dev`, `start`, `serve`, `web`, `app`, `client`, `frontend` and a name with a `:`, since pnpm and yarn have many commands and aliases of their own (`deploy`, `ci`, `t`, `access`, `rebuild`) that run before or instead of a script of that name, and some of them change between versions: write `pnpm run deploy`), followed two levels deep at most; or one `concurrently` whose quoted commands are each read the same way and exactly one of which is a `next dev` command. The port is the last `-p`/`--port`, else the `PORT` the script exports or assigns before the command, else Next's default 3000, and `PORT` from the editor's own environment is not consulted. The `dev` script is read as text and never run. A `package.json` that is not a regular file (a FIFO, for example) or is larger than 1 MiB is not read, and `applicationPortSource` says so. A `dev` script that runs more than 256 statements in all, counting every line of it and of each script it runs, is unread, and `applicationPortSource` says the dev script runs more statements than Codebook reads. The last statement may end with one `;`. The script is read with the meaning of the shell that runs it: `sh` on macOS and Linux, `cmd` on Windows, where npm, pnpm and yarn run scripts with `cmd`. On Windows only the forms that mean the same under `cmd` are read: bare `next` or an `npx`-style launcher with `next dev` and literal flags (a program written as a path with `/`, such as `node_modules/.bin/next`, is unread), `cross-env PORT=4000 next dev`, delegations and a `concurrently` with double-quoted commands; single quotes, a `PORT=4000` or `NAME=value` prefix, `export`, `env`, `;` and a variable named `port` in any case other than `PORT` (Windows ignores the case of variable names) are unread there, and `applicationPortSource` names `cmd`. An empty `dev` script is told as empty. A word that has a quote before its `=` (`"PORT=4000" next dev`) is no assignment. Everything else is unread: any other program or option, a pnpm command whose meaning depends on the installed pnpm version (`pnpm rebuild`), a pipe, `&` or `||`, a group or subshell, `$`, a backtick, a redirection or heredoc, a comment, a backslash or a line break, `if`/`while`/`!`/`time`, `sh -c`, `cmd /c`, `dotenv`, `node`, `set`, `unset`, a bare `PORT=4000;`, a `${PORT:-4000}` default, arguments given to a delegated script, and a script that never runs `next dev`. For an unread script no port is asserted: Next's default 3000 is taken and `applicationPortSource` says so and quotes the statement that left the forms above by its structure only. Only names from fixed lists are quoted (the words of the forms above by their base name, Next's `dev` flags, `PORT=…` and plain `NAME=…` assignment names before the program, and `package.json` script names, without control characters and cut); every value, operand, path, token, header, `user:pass@host` and base64 text is shown as `…`, so declare the port with `-p` in the `dev` script in one of the forms above to name it. `.env` files are not read for the port, because Next reads `PORT` before it loads them. Bun is the exception: it loads `.env` files into the environment of the scripts it runs, so a `next dev` without a `-p`/`--port` flag and without a `PORT` assigned in the script is unread (Next's default 3000 is taken and `applicationPortSource` names Bun's `.env` loading) when it is reached by `bun run <script>` or the project is a Bun project: `bun.lock` or `bun.lockb` looked for in the opened folder and the folders above it up to the first folder that holds `.git` (a folder or a file), at most 16 folders counting the opened one, and when no `.git` is found in that range only the opened folder's lockfile counts (only the file's existence is checked), or a `packageManager` of `bun@…` in the opened `package.json`; an explicit `-p`/`--port`, or a `PORT` the script sets in a form read above, is still read, and only a `next dev` without a port flag in such a project is unread. A Yarn Berry (Yarn 2 and later) project, found by a `packageManager` of `yarn@2` or later or by a `.yarnrc.yml` looked for in the same folders and range, reads `export PORT=4000` as unread and `applicationPortSource` names Yarn's portable shell, which has no `export`; `PORT=4000 next dev`, quotes, `;` and `env` are still read, as Yarn runs them, but a `;;` and a `;` followed by blanks at the end of the line, which Yarn's shell rejects, are unread with the same note. A Yarn Berry project uses Yarn's portable shell on Windows too, not `cmd`, so those forms are read there as on macOS and Linux and `export` is unread with the Yarn note; a `packageManager` of `yarn@1` (or another manager) wins over a stray `.yarnrc.yml`. Each script is read with the shell of the program that runs it: Yarn's portable shell for the `dev` line of a Berry project and for scripts reached by `yarn run` or `yarn <name>`, `cmd` on Windows (`sh` elsewhere) for scripts reached by `npm run`, `pnpm run` and the quoted commands of `concurrently`, so `npm run b` with `b` set to `PORT=4000 next dev` is unread on Windows even in a Berry project. On Windows, Bun runs scripts with its own shell, or with `cmd` when `run.shell` is `system` in `bunfig.toml`, so the same text can mean different things: a `dev` script of a Bun project and any `bun run` are unread there, and `applicationPortSource` names Bun's shell. Stop your own dev server on that port first: when it is busy, preparation is refused with the port named and the app is never moved to another port. A port held by an earlier Codebook run that is still stopping is waited for briefly and then named as that run's, and a port that another Codebook run has just claimed and still runs is refused as that run's even before its server has bound, and a port the system does not let Codebook listen on (below 1024 without administrator rights) is refused as not permitted rather than as in use. A bind failure of any other kind on that port (such as `EADDRNOTAVAIL`) is refused with the port and the error code only. The run resource reports the origin it used as `applicationOrigin` (`http://localhost:<port>`) and which step gave the port as `applicationPortSource`. Existing development locks are rejected and preserved. If a previous owned run has ended but `.next/dev/lock` remains, check the recorded owner PID and listening port before retrying. Preserve any live or unknown owner. Only after both are confirmed gone, retain the stale lock as a diagnostic artifact and move it out of the way, then start with a new operation identity. Codebook does not automatically delete locks. It does not reuse an unrelated app/debugger, execute caller-supplied shell commands, supply arbitrary debugger expressions, or modify the application's source to add instrumentation. SSH, container, tunnel and virtual workspaces, alternate build directories, Turbopack and multiple actions are outside this adapter's declared scope. One action supports up to eight ordered stops. Version 1 retains browser stops within one citation. Version 2 declares each stop's participant and citation, including server-action modules in the owned Next worker. Server breakpoint registration may be pending before input; actual pauses must verify executed module bytes, source maps and native coordinates. Installed host compatibility remains subject to native validation.
 
 1. Follow **Learn this repository** to read actual source and publish an immutable article. Leave `learningItemId` absent so the article uses `repository/<bookId>/<nodeId>`; a foreign learning alias cannot receive configured runtime evidence. Keep every citation's path, full hash and inclusive line range.
 2. Read the configured help resource (through `codebook_read_resource` if direct resource access is unavailable) and the discovered `codebook_start` input schema. Build `configuration` with `version: 1`, `adapter: "next-dev-webpack"`, the exact `book` identity (`bookId`, `revision`, `nodeId`, `anchorIndex`), and `source` (`path`, `hash`, one-based `line` and `column`). The selected source position must lie within that selected article citation. Preparation validates **all** article citations before starting the application. Select a one-based line/column for an executable statement reached by the requested action, such as the handler body or a state-driven render after a library callback. JSX attributes, declarations and proximity to the UI are not enough for a debugger binding. The line is the declaration and the column is a preference: Codebook accepts the debugger's verified binding anywhere on that line and reports the bound position as `source` beside `requestedSource` in the observation's inspection resource. Declare the column where the statement begins. When the debugger binds a stop on a later line although the line the breakpoint was requested on has a break location, Codebook requests the breakpoint once more, at that line's break location before the requested column; the stop fails while it is armed only when that second request is bound on a later line again or the line has no break location before the requested column. A binding that is first known at a pause (a server stop whose registration was still pending when it was armed) is not refused for this: the stop is accepted where it paused, and its inspection's `place` names the column that can pause on the requested line. A declared line without a mapped position (a blank line, or a comment the generated module kept) is requested at the first mapped position after it within the stop's citation, because the debugger verifies no breakpoint on such a line, and is accepted there under the next rule; preparation fails before input only when no later line of the stop's citation can carry a position either. The sealed map decides that; when it is too large to scan completely, the source text does: a line that is blank or only a comment carries none. A blank line has no column to choose: any column declared on it is taken as the line's start, and the run's journal records `breakpoint.column-on-blank-line` with the field, the declared and the taken position. The binding rule is counted from the line the breakpoint is requested on: the declared line, or the first mapped line after a declared line without a mapped position. When the debugger cannot pause on the requested line it binds the first place after it. Codebook accepts that binding when it lies on a later line within the stop's citation and no line between the requested line and the bound line has a mapped position (a comment the generated module kept is not one). When a mapped line lies between them, Codebook asks the debugger for the module's break locations and counts only a line that has one between the place the breakpoint was requested at and the place it was bound at in the generated module: a mapped line the debugger cannot pause on, such as a function head or its parameters, is passed over, and so is a line whose break location the build placed elsewhere in the generated module, such as a call it appends at the module's end and maps to a function's name. This also holds for a binding first known at a pause, where the place the program is paused at is the bound place; when either generated place cannot be determined, every line with a break location counts. The run's journal records `breakpoint.rule-from-break-locations` with the lines that counted and, when both are known, the two generated places (and `breakpoint.requested-again-after-break-locations` when a server registration is requested again for it). When the debugger cannot list break locations, the mapped lines decide. Codebook uses an accepted binding like a moved column: `source` names the bound line. Let the citation cover every line of the statement the stop is in, so that a moved binding stays inside it. A moved binding can lie in a branch the action skips; the stop then fails at the 20-second deadline, whose text names the bound place once the adapter has reported it (a server stop still registered as pending gets it from the adapter's breakpoint event when its module loads). Any other verified binding on another line fails at once; for a server stop that was still registered as pending, whose binding is checked when it pauses, that failure comes about 3 seconds after the pause. Declare the bound place instead, in a citation that covers it. A browser stop whose binding never verifies times out after 20 seconds while it is being armed; a server stop may stay registered as pending and fails only when no verified pause arrives within 20 seconds of the input or of the preceding continuation. Binding failures name the declared stop and list bounded source-map positions in that stop's citation when available. These are mapping hints, not proof that a debugger can bind or that the action reaches them; inspect the cited source and choose a relevant executable statement before retrying.
-3. Optionally set `entryPath` to the actual same-origin page path, including its query string. Preparation compiles that page and resolves its generated Next route manifest; redirects fail explicitly. A non-root `entryPath` must answer 200 without a redirect and replaces the root-page readiness check, so an application without a root page runs through its selected entry. `initialInputs` may contain up to 16 distinct `{selector,text}` pairs. Codebook focuses a unique visible editable text control, inserts text through the browser input protocol, and verifies the result before arming the learning breakpoint. A changed/ambiguous/obscured control or uncertain insert fails without retrying it. Configuration and captured values belong to private learning storage; sanitized reports must omit input content.
+3. Optionally set `entryPath` to the actual same-origin page path, including its query string. Preparation compiles that page and resolves its generated Next route manifest; redirects fail explicitly. A non-root `entryPath` must answer 200 without a redirect and replaces the root-page readiness check, so an application without a root page runs through its selected entry. A browser stop is armed before input in the client code that the launched page loads, so a stop in a component of another page (one that a link from the launched page navigates to) is refused before input with a sentence that names the stop's file and the launched page and says to start the run at the stop's page (`entryPath`) or to choose a stop in the launched page's own components; a run refused during its preparation, or failed later, seals its recording with that failure's own words (`The run failed: <cause>. Recorded prefix retained.`, a long cause cut so that the sentence keeps its end), and a run whose release did not complete with `Runtime cleanup incomplete; recorded prefix retained.` `initialInputs` may contain up to 16 distinct `{selector,text}` pairs. Codebook focuses a unique visible editable text control, inserts text through the browser input protocol, and verifies the result before arming the learning breakpoint. A changed/ambiguous/obscured control or uncertain insert fails without retrying it. Configuration and captured values belong to private learning storage; sanitized reports must omit input content.
 4. Declare `action.title`, one unique CSS `selector`, and nonempty `before`/`after` condition arrays. Conditions are `{kind:"visible",selector}`, `{kind:"text",selector,equals}`, or `{kind:"attribute",selector,attribute,equals}`; comparisons use literals, never patterns, and all conditions must hold. A text condition compares the element's whole `textContent`, trimmed and with whitespace runs collapsed on both sides, so `Log in` matches a button whose markup is `Log in <Icon />`; the texts of child elements are joined without a space (`<b>Total</b><i>5</i>` reads `Total5`), and CSS `white-space`, zero-width spaces and soft hyphens are not applied; when the element holds the expected text beside other text, the timeout says so without exposing page text. A text condition whose selector matches several elements holds when one of them reads the expected text, and when none does its timeout says how many elements matched; a `visible` or `attribute` condition and the click target need a selector that matches exactly one element. A condition timeout names its phase: correct a before condition against the fresh page before input, an after condition against the page the action leaves. Codebook also reads the after conditions just before the click; when they already hold there, the run ends with "Configured after conditions were already true before application input" and sends no input, so declare an after condition only the action makes true. The click target must be visible, enabled and not obscured. DOM expectations describe completion; they are not expected debugger values. Before conditions must hold in a fresh browser: do not assume the operating system's appearance or previous local storage. Use `initialStorage` only when the source establishes a key/value that makes the starting state deterministic. A `visible` condition also needs nonzero element geometry. For class membership, use a CSS class selector when the element may have other class tokens; an attribute condition compares the whole class string exactly.
 5. Declare one to ten `inspections` with `path`, `mode` (`value` or `type`) and `required`. At least one required `value` is needed. Paths contain up to four simple identifier segments; calls, computed property expressions, reserved roots and prototype access are rejected. For example, `{path:"nextTheme",mode:"value",required:true}` requests the actual primitive value of an in-scope variable; it does not assume that value is `"dark"`. Required unavailable/unsafe/oversized values fail. A required value is read when the debugger pauses, before the stop's line runs, so a binding that the stop's own line declares has no value there; Codebook then requests the stop on the first line within the stop's citation that can pause after the statement that line begins, and names that line in the inspection's `armed` and `place`, so require a value that already exists before the stop's line when you want the state before that line runs; when no later line of the citation can pause, the statement does not end within the citation, Codebook does not recognize the declaration (it reads only the first const or let with an initializer on the stop's line, not a pattern over several lines or a second declarator), or the sealed map is too large to scan completely and the debugger lists no place after the statement where it can pause, the stop stays on its line and its failure names the line to follow; a server stop in such a map whose module the server has not loaded when the stop is armed cannot be asked for that place, so it is refused when it is armed, before its breakpoint is set, and its failure names the first line after the statement; when you know the statement spans several lines, declare the stop on a statement after it. A value that is an object or a function is captured as the marker `{type:"object"}` or `{type:"function"}` and the run goes on; its members are not captured, so declare a primitive member (such as `credentials.email`) to capture one. Optional unavailability remains explicit. Optional `initialStorage` contains bounded key/value pairs for this run's owned origin only.
    With version 1, optional `additionalStops` appends up to seven `{line,column,inspections}` entries within the same selected citation. For cross-file or server stops use `version: 2`, add the first stop's `participant` (`browser` or `server`), and declare each additional stop as `{participant,source:{path,hash,line,column},anchorIndex,inspections}`. Each source must match its retained article citation. Every stop requires a value inspection and must be reached in order by this single action. Codebook arms only the next expected stop, the first before input and each later one inside the continuation that precedes it, so a later stop pauses only when its line executes after that continuation. The original `source`, `book.anchorIndex` and `inspections` define the first stop. A declared server stop is captured in whichever webpack layer's copy of its module runs: Next.js in development parses one source file once per layer (for example `(action-browser)`, `(middleware)` and `(rsc)`), and Codebook reads each copy's own text and source map, accepts it only when its map retains the exact frozen original, and places the pause by that copy's own map. The snapshot of a stop captured in such a copy serves that copy's JavaScript and source map from its `source/javascript` and `source/map` resources, which match the snapshot's `javascriptHash` and `mapHash`. A copy that cannot be read in time or verified is refused, and a pause held in it ends the run with a sentence that names the script and the reason.
@@ -380,7 +380,7 @@ Opening saved learning starts a read-only **Codebook · Recorded learning** debu
 
 A slow start does not fail a replay. Loading a recording and starting or retiring the historical session do not count against the five-second paint bound; that bound applies to each frame's painting, and a presentation that never reaches painting ends after 23 seconds. If the editor needs more than five seconds to start the historical session, the moment that waited for it fails, and the session is adopted when its start completes: the next moment is presented without reopening the recording. A session you stopped meanwhile is not adopted. If the editor does not stop the historical session within five seconds, the session becomes unavailable and reopening the learning replay starts a new one. Closing the reader does not wait on the native debugger or on a frame that never paints beyond those bounds. It waits at most five seconds in all for its pending storage writes (a running study's final checkpoint, the saved replay position, the archive writes and the library queue); a write still pending then keeps running and the reader closes.
 
-**Open replay** pressed while another window has the desktop focus waits up to 10 seconds for the Codebook work window to gain the focus and then opens the Learning summary. When the focus does not come, the replay is refused with `Focus the Codebook work window before reading the learning summary: another window kept the desktop focus for 10 s. Click in this editor window, then choose Open replay again.`, and the status bar's **Open replay** shows that reason as a notification (`Codebook could not open the learning replay: …`).
+**Open replay** pressed while another window has the desktop focus waits up to 10 seconds for the Codebook work window to gain the focus and then opens the Learning summary. When the focus does not come, the replay is refused with `Focus the Codebook work window before reading the learning summary: another window kept the desktop focus for 10 s. Click in this editor window, then choose Open replay again.`, and the status bar's **Open replay** shows that reason as a notification (`Codebook could not open the learning replay: …`) and writes it to **Output › Codebook** as one `open:recording` entry with the study, the profile and the cause. A browser replay whose open fails for any other cause (its recording could not load, for example) also writes one `open:recording` entry beside the load-failure notification, so you can copy the cause into a report.
 
 The Learning summary has its own icon in the Activity Bar in both editors, because Cursor rejects the secondary side bar container an extension contributes. In Cursor it opens in the primary side bar. In VS Code, the first time you open a replay yourself in a profile (never an agent's open), Codebook moves the summary once into the Chat container on the right with VS Code's internal `vscode.moveViews` command; a place you choose afterwards is never changed back, and if the command is refused or missing the summary stays in the Activity Bar and Output › Codebook says so. Nothing is offered in VS Code. Once per editor session, until you have taken the step in that workspace, Cursor shows the notification `Cursor opens the Codebook Learning summary in its primary side bar. To keep it on the right, move it once: choose "New Secondary Side Bar Entry" in the list that opens.` with the button **Move Learning Summary…**. Cursor removes an unanswered notification by itself, so the same step stays within reach as the title action **Codebook: Move Learning Summary…** of the Learning summary view and under that name in Cursor's Command Palette. Each opens the editor's own Move View list for the summary. When **Show Variables** opens Run and Debug in the side bar the summary shares, the offer reads `Run and Debug took the Learning summary's place in Cursor's side bar. Move the summary to the right once to keep both in view.`, with the same button, at most once per editor session.
 
@@ -404,7 +404,7 @@ Bounded installed development trials in VS Code 1.139.1 and Cursor 3.23.5 ([Cycl
 | Book/progress corruption or capacity               | Preserve the affected files, repair the named storage problem, then explicitly retry. No history is deleted or silently replaced.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `HISTORY_SEAL_FAILED`                              | A test run's history, or a browser recording, could not be sealed when `codebook_stop` ended the run. The run is stopped and its resources are released; nothing reruns. Do not call `codebook_stop` again and do not claim saved learning; tell the learner the save failed. The recorded part, when readable, opens from Saved studies. Start a new run only if the learner asks.                                                                                                                                                                                                                                                                                                                                        |
 | `PLAYBACK_PROFILE_UNSUPPORTED`                     | `codebook_playback` was given a test replay: it controls browser recordings only. Do not start, continue or stop a run to open it; ask the learner to open it from **Open replay** or Saved studies.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `EVIDENCE_UNAVAILABLE` or failed run               | Inspect cause and available history, stop owned resources, and retain partial evidence. Missing images or persistence failures never imply complete success.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `EVIDENCE_UNAVAILABLE` or failed run               | Inspect cause and available history, stop owned resources, and retain partial evidence. Missing images or persistence failures never imply complete success. A `codebook_continue` refused because the debugger could not read a required fact leaves the test run paused at that stop: read `nodeTest.stops` and the current `participants.server.continueArguments`, then continue with those arguments without the fact, or stop the run.                                                                                                                                                                                                                                                                               |
 | A completed run shows `resuming`                   | Its final save of events and run record is under way: until it settles, the run has no result and no `observed`, and a failed save fails the run. Read the run again.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | Missing prerequisite                               | Status names the dependency/configuration key. Correct it before deliberately starting another study.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | Session capacity                                   | A ninth client replaces the least recently seen idle session; `429` with `MCP session limit exceeded; every session has a request in flight. Retry after one completes.` is answered only while all eight have a request in flight: retry then. The replaced client's next request is answered `404` with `Unknown MCP session. Initialize a new transport, then read codebook_status.` A client `DELETE` releases its transport only. It does not stop a study.                                                                                                                                                                                                                                                           |
diff --git a/extension/package.json b/extension/package.json
index fbcd112ba..3300fb1c6 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.41",
+  "version": "0.2.42",
   "private": true,
   "engines": {
     "vscode": "^1.120.0",
diff --git a/extension/scripts/study-bootstrap-qa.mjs b/extension/scripts/study-bootstrap-qa.mjs
index d0bd8fa10..f51cec27d 100644
--- a/extension/scripts/study-bootstrap-qa.mjs
+++ b/extension/scripts/study-bootstrap-qa.mjs
@@ -1158,6 +1158,59 @@ async function check(page, options, collected) {
               value.revision === revisionAt(5),
           ),
       })
+      // Value: protects=a browser replay's Replay from start sends a seek to the recording's first millisecond, and the readout then reads the start time the host presents; fails_when=Replay from start sends another request or position, or the readout keeps the earlier time (Cycle 0052 task 22, the state cell browser replay × Replay from start); why_new=Replay from start was covered for test replays only; seam=none; no_claim=the host's seek (studyWorkspace tests)
+      await publish(replay)
+      await page.evaluate(() => {
+        window.sent = []
+      })
+      await page.locator('[data-playback="start"]').click()
+      const fromStart = await page.evaluate(() =>
+        window.sent.filter((message) => message.type === 'playback'),
+      )
+      await publish({
+        ...replay,
+        recording: { ...replay.recording, presentedMs: 0 },
+      })
+      const readoutAtStart = await page
+        .locator('#playback-position')
+        .textContent()
+      cases.push({
+        name: "a browser replay's Replay from start seeks the recording's start and the readout then shows its start time",
+        actual: { fromStart, readoutAtStart },
+        passed:
+          fromStart.length === 1 &&
+          fromStart[0].action === 'seek' &&
+          fromStart[0].positionMs === 0 &&
+          readoutAtStart === 'Presented 0.00 s / 8.00 s',
+      })
+      // Value: protects=a browser replay's Pause sends pause, and the toggle then reads Play once the host presents it paused; fails_when=the toggle sends play or nothing while the recording plays, or keeps reading Pause after the host paused (Cycle 0052 task 22, the state cell browser replay × Pause); why_new=Pause was covered for test replays only; seam=none; no_claim=the host's pause (studyWorkspace tests)
+      await publish({
+        ...replay,
+        recording: { ...replay.recording, mode: 'playing' },
+      })
+      const toggleWhilePlaying = await page
+        .locator('#playback-toggle')
+        .textContent()
+      await page.evaluate(() => {
+        window.sent = []
+      })
+      await page.locator('#playback-toggle').click()
+      const pausing = await page.evaluate(() =>
+        window.sent.filter((message) => message.type === 'playback'),
+      )
+      await publish(replay)
+      const toggleAfterPause = await page
+        .locator('#playback-toggle')
+        .textContent()
+      cases.push({
+        name: "a browser replay's Pause sends pause and the toggle then reads Play",
+        actual: { toggleWhilePlaying, pausing, toggleAfterPause },
+        passed:
+          toggleWhilePlaying === 'Pause' &&
+          pausing.length === 1 &&
+          pausing[0].action === 'pause' &&
+          toggleAfterPause === 'Play',
+      })
       await page.locator('#understood').focus()
       const reading = await page.evaluate(() => ({
         bottom: document.getElementById('understood').getBoundingClientRect()
diff --git a/extension/scripts/tests/package.test.mjs b/extension/scripts/tests/package.test.mjs
index 5036f7390..fea50bd1f 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.41')
+  assert.equal(checked.extension.version, '0.2.42')
   assert.equal(checked.extension.apiVersion, '1.8')
   assert.equal(checked.entries, 32)
   assert.equal(receipt.dependencies.length, 16)
diff --git a/extension/src/constants.ts b/extension/src/constants.ts
index 5bfefef7c..4914df813 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.41'
+export const EXTENSION_VERSION = '0.2.42'
 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'
@@ -1062,6 +1062,12 @@ export const TEST_OUTPUT_END_TOLERANCE_PX = 2
 export const TEST_OUTPUT_STATE_REPORT_INTERVAL_MS = 500
 /** Longest debugger type name a saved Node fact keeps; the type is supplementary, so a longer one is omitted rather than failing the run. */
 export const NODE_TEST_FACT_TYPE_LIMIT_CHARS = 256
+/**
+ * Names of the variables in which Vitest's module runner holds a whole imported module: a test file that calls `vi.mock` binds `__vi_import_<n>__`, any other module `__vite_ssr_import_<n>__` (Vite 8, Vitest 5). An imported name such as `revalidatePath` has no variable of its own; its value is an export of one of these (Cycle 0052 task 5).
+ */
+export const NODE_TEST_MODULE_BINDING_NAME = /^__vi(?:te_ssr)?_import_\d+__$/
+/** The debugger's name for the object a JavaScript Proxy wraps; a module that `vi.mock` replaces is a Proxy whose exports sit under it. */
+export const DEBUGGER_PROXY_TARGET_NAME = '[[Target]]'
 /** Oldest Vitest major whose file listing, exclusion, name matching and JSON report were verified for exact node-test selection (4.1.11 and 5.0.2). */
 export const NODE_TEST_MINIMUM_VITEST_MAJOR = 4
 /** Deepest cited title path: enclosing `describe` titles plus the test title. */
diff --git a/extension/src/errors.ts b/extension/src/errors.ts
index 53f07c94f..87cacdde6 100644
--- a/extension/src/errors.ts
+++ b/extension/src/errors.ts
@@ -3,7 +3,7 @@ import { newerStudyFormatMessage } from './utils/newerStudyFormatMessage'
 
 export const ERROR_RECOVERY = {
   NOT_FOUND:
-    'Read codebook_status and use a resource reference from the selected instance and run.',
+    'Read codebook_status and use a resource reference from the selected instance and run; for a Node test history, copy its studyId or historyUri from codebook://node-history.',
   STALE_INSTANCE:
     'Copy the current connection from the editor, initialize, and read codebook_status. Never replay input automatically.',
   STALE_PAUSE:
@@ -32,7 +32,7 @@ export const ERROR_RECOVERY = {
   RUNTIME_FAILED:
     'Read the terminal reason and captured history. Stop owned resources; do not retry the click automatically.',
   EVIDENCE_UNAVAILABLE:
-    'Inspect the evidence failure and storage availability. Do not treat missing evidence as success.',
+    'Inspect the evidence failure and storage availability. Do not treat missing evidence as success. When codebook_continue names a required fact the debugger could not read, the run stays paused at that stop: read nodeTest.stops and the current participants.server.continueArguments of the run resource, then call codebook_continue with those arguments to go on without it (the earlier ones now answer STALE_PAUSE), or stop the run.',
   SERVER_STOPPING:
     'Wait for the editor stop command to finish, then explicitly start and copy a new connection.',
   PREREQUISITE_MISSING:
diff --git a/extension/src/extension.ts b/extension/src/extension.ts
index 99b7d7016..283656462 100644
--- a/extension/src/extension.ts
+++ b/extension/src/extension.ts
@@ -150,6 +150,13 @@ import { WikiUpdateTimeoutError } from './utils/wikiUpdateTimeoutError'
 
 let stopExtension: (() => Promise<void>) | undefined
 
+/** One change of this window's own Wiki update marker (its removal, or its turn into a stopped watch's reservation): the change, the timer of its next attempt while it waits, and the attempt while it runs. */
+type WikiMarkerChangeEntry = {
+  change: () => Promise<boolean>
+  timer?: NodeJS.Timeout
+  running?: Promise<boolean>
+}
+
 /** Registers explicit trusted commands without reading auto-run instructions from repository files. @example VS Code calls activate(context) */
 export function activate(
   context: Pick<vscode.ExtensionContext, 'extensionPath' | 'subscriptions'> & {
@@ -267,11 +274,10 @@ export function activate(
     string,
     { release: () => Promise<boolean>; timer: NodeJS.Timeout }
   >()
-  // 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 or waits for its next attempt, with the timer of that attempt.
-  const wikiMarkerChanges = new Map<
-    string,
-    { change: () => Promise<boolean>; timer?: NodeJS.Timeout }
-  >()
+  // 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>()
   /**
    * 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.
@@ -287,10 +293,15 @@ export function activate(
     retriesLeft = WIKI_UPDATE_MARKER_CHANGE_RETRIES,
   ): Promise<void> => {
     clearTimeout(wikiMarkerChanges.get(outputDirectory)?.timer)
-    const pending: { change: () => Promise<boolean>; timer?: NodeJS.Timeout } =
-      { change }
+    const pending: WikiMarkerChangeEntry = { change }
     wikiMarkerChanges.set(outputDirectory, pending)
-    const isChanged = await change().catch(() => false)
+    pending.running = change().catch(() => false)
+    const isChanged = await pending.running
+    pending.running = undefined
+    endedWikiMarkerChanges.set(
+      outputDirectory,
+      (endedWikiMarkerChanges.get(outputDirectory) ?? 0) + 1,
+    )
     // 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.
@@ -1491,6 +1502,32 @@ export function activate(
     }
     return { tokenAtStart, publicationAtStart, before }
   }
+  /**
+   * Claims the Wiki's marker for a start of this window, and claims it once more after this window's own marker change that held the claim at that moment; called by {@link lookAtWikiStart} last.
+   * Why: the end of this window's previous run removes its marker, or turns it into a stopped watch's reservation, under the claim on the marker ({@link settleWikiRunMarker}). A start of this window that claims in that moment (Update anyway chosen right after the run ended, or the change slowed by the disk) meets the marker in change, which is no other window's, and would refuse itself with "Another editor window is starting or ending an update of this Wiki" (Cycle 0052 task 27).
+   * @param outputDirectory - The Wiki output the start claims.
+   * @param marker - This window's marker for the run ({@link claimWikiUpdateMarker}).
+   * @returns What the claim answered; after this window's own change ran meanwhile, what the second claim answered. A marker in change that no change of this window explains stays the first answer.
+   * @throws What {@link claimWikiUpdateMarker} throws.
+   * @example
+   * await claimWikiMarkerForStart('/repo/.codebook/wiki', { pid: process.pid, windowId, host: 'vscode', startedAtMs: Date.now() }) // => { release, reserve }
+   */
+  const claimWikiMarkerForStart = async (
+    outputDirectory: string,
+    marker: Parameters<typeof claimWikiUpdateMarker>[1],
+  ): Promise<Awaited<ReturnType<typeof claimWikiUpdateMarker>>> => {
+    const endedBefore = endedWikiMarkerChanges.get(outputDirectory) ?? 0
+    const claim = await claimWikiUpdateMarker(outputDirectory, marker)
+    if (!('heldBy' in claim) || !('isMarkerInChange' in claim.heldBy))
+      return claim
+    const running = wikiMarkerChanges.get(outputDirectory)?.running
+    // This window's own change still holds the claim: the start waits until it has ended.
+    if (running) await running
+    // No change of this window ran meanwhile, so another window changes the marker.
+    else if ((endedWikiMarkerChanges.get(outputDirectory) ?? 0) === endedBefore)
+      return claim
+    return claimWikiUpdateMarker(outputDirectory, marker)
+  }
   /**
    * 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.
    * @param projectRoot - Canonical opened project.
@@ -1568,7 +1605,7 @@ export function activate(
     if ((await readWikiPublishToken(outputDirectory)) !== tokenAtStart)
       return 'published-meanwhile'
     const startedAtMs = Date.now()
-    const claim = await claimWikiUpdateMarker(outputDirectory, {
+    const claim = await claimWikiMarkerForStart(outputDirectory, {
       pid: process.pid,
       windowId: wikiWindowId,
       host,
diff --git a/extension/src/nodeTestHistoryStore.ts b/extension/src/nodeTestHistoryStore.ts
index 4c186c9bd..1a69c2356 100644
--- a/extension/src/nodeTestHistoryStore.ts
+++ b/extension/src/nodeTestHistoryStore.ts
@@ -630,7 +630,7 @@ export class NodeTestHistoryStore {
   }
 
   /**
-   * Says whether this workspace's history directory holds a folder for a study id, listed or not, without reading its files; read by {@link StudyService.playback}, so a test replay of an earlier session is refused before this window has listed it (F9).
+   * Says whether this workspace's history directory holds a folder for a study id, listed or not, without reading its files; read by {@link StudyService.playback}, so a test replay of an earlier session is refused before this window has listed it (F9), and by the history's resources ({@link readResource}) and {@link StudyService.explainNodeHistory}, which refuse an id without a folder as unknown ({@link unknownNodeHistoryError}).
    * Synchronous on purpose: {@link StudyService.playback} answers synchronously, and this one existence check of the editor's local storage, made once per agent playback command, takes about a microsecond (F246).
    * @param studyId - A study id an agent sent.
    * @returns `true` for a study id named like a history whose folder exists.
diff --git a/extension/src/ownedNodeTestRun.ts b/extension/src/ownedNodeTestRun.ts
index a5bc62119..ceaf38749 100644
--- a/extension/src/ownedNodeTestRun.ts
+++ b/extension/src/ownedNodeTestRun.ts
@@ -40,6 +40,7 @@ import { listVitestTestFiles } from './utils/listVitestTestFiles'
 import { prepareNodeTestLaunch } from './utils/prepareNodeTestLaunch'
 import type { PreparedNodeTestLaunch } from './utils/prepareNodeTestLaunch'
 import { selectCheckedNodeFrame } from './utils/selectCheckedNodeFrame'
+import { sourceImportBindings } from './utils/sourceImportBindings'
 import { thrownMessage } from './utils/thrownMessage'
 import { verifyVitestTestResult } from './utils/verifyVitestTestResult'
 
@@ -540,6 +541,7 @@ export class OwnedNodeTestRun {
    *
    * A pause Codebook did not make, such as the learner's own breakpoint, is never resumed here. It is reported once as `node-test.learner-paused`,
    * and the time the test spends held there does not count against the stop budget. Called by {@link prepareOwned} and {@link advance}.
+   * A required fact the debugger cannot read fails nothing: the stop is accepted with the facts that could be read and names the missing one among its debugger limitations, and the service refuses the continuation that reached it (Cycle 0052 task 5).
    *
    * @param index - Declared stop to capture.
    * @param fromIndex - First native pause that can belong to this stop.
@@ -688,10 +690,16 @@ export class OwnedNodeTestRun {
       throw new Error(
         'Native debugger supplied no variable scope at the source stop.',
       )
+    // The stopped module's imports tell which export each imported name reads (Cycle 0052 task 70); these bytes are verified with the second read after the capture (task 97).
+    const capturedSourceBytes = await readFile(selected.file)
+    const sourceImports = sourceImportBindings(
+      capturedSourceBytes.toString('utf8'),
+    )
     const result = await inspectNodeTestVariables(
       bound.session,
       scopes.scopes,
       selected.inspections,
+      sourceImports,
       signal,
     )
     signal.throwIfAborted()
@@ -711,7 +719,11 @@ export class OwnedNodeTestRun {
     assertCurrent()
     const sourceBytes = await readFile(selected.file)
     assertCurrent()
-    if (sha256(sourceBytes) !== selected.source.hash)
+    // Both reads must be the declared source: the imports were read from the first, the snapshot cites the second.
+    if (
+      sha256(capturedSourceBytes) !== selected.source.hash ||
+      sha256(sourceBytes) !== selected.source.hash
+    )
       throw new Error(
         'Node test source changed during historical debugger capture.',
       )
@@ -745,6 +757,11 @@ export class OwnedNodeTestRun {
       },
     })
     assertCurrent()
+    // A required fact the debugger could not read is named among the stop's limitations: the stop keeps its other facts and the run stays paused here (Cycle 0052 task 5).
+    for (const fact of result.unavailable)
+      debuggerSnapshot.limitations.push(
+        `Required fact ${fact} could not be read at this stop.`,
+      )
     this.acceptedPause = target.stop
     const stop = (this.acceptedStop = {
       index,
diff --git a/extension/src/resources.ts b/extension/src/resources.ts
index 0d6082bcb..eb724346d 100644
--- a/extension/src/resources.ts
+++ b/extension/src/resources.ts
@@ -45,6 +45,7 @@ import { readRecordingResource } from './utils/readRecordingResource'
 import { readRepositoryResource } from './utils/readRepositoryResource'
 import { secondsText } from './utils/secondsText'
 import { snapshotSourceHashes } from './utils/snapshotSourceHashes'
+import { withKnownNodeHistory } from './utils/withKnownNodeHistory'
 
 /** The active-progress deadline in the whole seconds the repository-browser help names, so the help follows {@link ACTIVE_TIMEOUT_MS}. */
 const ACTIVE_TIMEOUT_SECONDS = ACTIVE_TIMEOUT_MS / MILLISECONDS_PER_SECOND
@@ -146,7 +147,12 @@ export async function readResource(
         'NOT_FOUND',
         'Node history storage is unavailable for this workspace.',
       )
-    const history = await service.nodeHistoryStore.read(nodeHistoryMatch[1])
+    const store = service.nodeHistoryStore,
+      studyId = nodeHistoryMatch[1]
+    // An unknown id, or a history removed while or right after it is read, is a reference to correct, not a failed study operation (Cycle 0052 tasks 60, 75, 95); each read below is checked the same way.
+    const history = await withKnownNodeHistory(store, studyId, () =>
+      store.read(studyId),
+    )
     const baseUri = `codebook://node-history/${nodeHistoryMatch[1]}`
     if (nodeHistoryMatch[2] === 'events')
       return readJsonPage(`${baseUri}/events`, history.entries)
@@ -160,8 +166,8 @@ export async function readResource(
       nodeHistoryMatch[2] === 'learning-material' ||
       nodeHistoryMatch[2]?.startsWith('learning-material/pages/')
     ) {
-      const material = await service.nodeHistoryStore.readLearningMaterial(
-        nodeHistoryMatch[1],
+      const material = await withKnownNodeHistory(store, studyId, () =>
+        store.readLearningMaterial(studyId),
       )
       const data = material ?? {
         studyId: nodeHistoryMatch[1],
@@ -175,8 +181,8 @@ export async function readResource(
       return readJsonPage(`${baseUri}/learning-material`, data, cursor)
     }
     // The result and the learning coverage come from the store's one summary, which Saved studies and Save read too (Design 13); only the history's own page needs them, not its events or learning material pages (F14).
-    const summary = await service.nodeHistoryStore.summarize(
-      nodeHistoryMatch[1],
+    const summary = await withKnownNodeHistory(store, studyId, () =>
+      store.summarize(studyId),
     )
     const learning = {
       testResult: summary?.testResult ?? 'none',
@@ -254,7 +260,7 @@ export async function readResource(
         "A stop's saved explanation is a learning-material step that references that stop; the result needs a step that references it too. nodeTest.learningCoverage reads none without material, partial while a stop or the result lacks a step, and complete once every one has one; nodeTest.learningMissing lists the missing parts as {kind: summary}, {kind: stop, stop: <n>} and {kind: result}, and nextActions lists save-node-learning until coverage is complete. nodeTest.captureMissing lists the evidence no explanation can add, as {kind: stop-state, stop: <n>} and {kind: execution}; the learner's Save reads partially saved while it is not empty, so claim saved learning only when it is empty too.",
       sequence: [
         'Read the returned manifest to verify the accepted configuration, complete article citation and test file/hash. Poll the run URI until a checked source stop appears or the run has an error. Read nodeTest.stops and the immutable node-stops/<index> snapshot, source and facts.',
-        'Copy the current participants.server.continueArguments to continue. Every declared stop is required and captured in order. The final continuation runs the actual test and returns its exit code and bounded output.',
+        "Copy the current participants.server.continueArguments to continue. Every declared stop is required and captured in order. A required inspection is read through the debugger's variables, a name the stopped file imports through the module Vitest binds it to, as the export its import declaration names, from that declaration's own module (a namespace import, or an import whose module the stop cannot see, stays unread); one that still cannot be read is named among that stop's debugger limitations, and the codebook_continue that reached the stop answers EVIDENCE_UNAVAILABLE naming it while the run stays paused there with its other facts: copy the new continueArguments to go on without it, or stop the run; the history then seals partial. The final continuation runs the actual test and returns its exit code and bounded output.",
         'Stop releases the owned Node process and debugger and seals the history. A private workspace-bound history journal preserves ordered output, source/facts/debugger stops and the actual result; discover it at codebook://node-history, then read the returned history URI and follow its events pages. Use codebook_explain_node_history to save an agent-authored question, summary and sequence with exact stop/output/result sequence references; read learningMaterialUri first and use its revision as expectedRevision. The learner opens the sealed history as a test replay.',
       ],
       learnerPauses:
diff --git a/extension/src/service.ts b/extension/src/service.ts
index 90bd00190..8bcb290b3 100644
--- a/extension/src/service.ts
+++ b/extension/src/service.ts
@@ -27,6 +27,7 @@ import {
   MAX_UI_TEXT_CHARS,
   NODE_TEST_MINIMUM_EXTENSION_VERSION,
   NODE_TEST_PROFILE,
+  RECORDING_REASON_LIMIT_CHARS,
   REPOSITORY_BROWSER_ACTION,
   REPOSITORY_BROWSER_PROFILE,
   REPOSITORY_CONFIG_LIMIT_BYTES,
@@ -81,6 +82,7 @@ import type {
   StudyEnvironment,
   StudyRuntime,
 } from './runtime'
+import type { RecordedEvent } from './runtimeSupport/evidence'
 import { sha256 } from './runtimeSupport/utils/sha256'
 import {
   explainNodeHistorySchema,
@@ -146,6 +148,7 @@ import { studyErrorNamingCause } from './utils/studyErrorNamingCause'
 import { systemErrorCode } from './utils/systemErrorCode'
 import { thrownMessage } from './utils/thrownMessage'
 import { waitForNextRunState } from './utils/waitForNextRunState'
+import { withKnownNodeHistory } from './utils/withKnownNodeHistory'
 
 /** What the run resource tells an agent after the result while no explanation of the run carries a learning summary; `codebook://help/studies` describes the step in the last entry of its sequence. */
 const SAVE_LEARNING_SUMMARY_ADVICE =
@@ -1556,6 +1559,7 @@ export class StudyService {
     record: StudyRecord,
     run: NodeTestRuntime,
   ): Promise<void> {
+    let refusal: StudyError | undefined
     try {
       if (run.hasNextStop()) {
         const next = await run.advance()
@@ -1563,25 +1567,14 @@ export class StudyService {
         record.nodeStops?.push(next)
         // A deadline that passed during the advance already marked the test failed: the late stop is journaled, the phase stays (F77).
         if (record.nodePhase === 'advancing') record.nodePhase = 'paused'
-        return
-      }
-      const result = await run.complete()
-      record.nodeResult = result
-      await record.nodeHistoryWriter?.appendResult(result, result.elapsedMs)
-      // The same for a result that arrives after the deadline's failure (F77).
-      if (record.nodePhase === 'advancing') record.nodePhase = 'completed'
-      // The exit already says the test did not pass; the run's error names why Vitest's report could not confirm the cited test.
-      if (result.reportFailure !== undefined) {
-        record.error = this.sanitizedError(
-          new StudyError(
-            'RUNTIME_FAILED',
-            `${describeNodeTestResult(result)}, and Vitest's test report could not confirm the cited test: ${result.reportFailure}`,
-          ),
+        // Only a run that stays paused at the stop can tell the agent to continue without the fact; a deadline that failed it, or a stop under way, speaks through the run resource.
+        if (
+          record.nodePhase === 'paused' &&
+          !record.stopping &&
+          !record.stopped
         )
-        queueMicrotask(() => {
-          void this.stopRecord(record).catch(() => undefined)
-        })
-      }
+          refusal = this.unreadRequiredFactsRefusal(record, next)
+      } else await this.completeNodeTest(record, run)
     } catch (error) {
       // A stop cancelled this continuation: the run ends as stopped, without an error of its own.
       if (record.stopping || record.stopped)
@@ -1599,6 +1592,88 @@ export class StudyService {
       })
       throw record.error
     }
+    // The stop is kept and the run stays paused there with its other facts; only this continuation is refused, so the agent can go on without the fact (Cycle 0052 task 5, O4).
+    if (refusal) throw refusal
+  }
+
+  /**
+   * Lists the required facts a journaled test stop lacks, as `<mode>:<path>`: the required inspections declared for that stop with no fact of theirs, which the debugger could not read; called by {@link StudyService.unreadRequiredFactsRefusal} and {@link StudyService.sealNodeHistory}.
+   * @param record - The Node test run.
+   * @param stop - One of its stops.
+   * @returns The unread facts in declaration order; none for a run without a prepared configuration.
+   * @example this.unreadRequiredFacts(record, stop) // => ['value:revalidatePath.mock.calls.length']
+   */
+  private unreadRequiredFacts(
+    record: StudyRecord,
+    stop: NodeTestSourceStop,
+  ): string[] {
+    const configuration = record.nodePrepared?.configuration
+    if (!configuration) return []
+    const declared = [
+      configuration.inspections,
+      ...(configuration.additionalStops ?? []).map(
+        (additional) => additional.inspections,
+      ),
+    ][stop.index]
+    return (declared ?? [])
+      .filter(
+        (inspection) =>
+          inspection.required &&
+          !stop.facts.some(
+            (fact) =>
+              fact.path === inspection.path && fact.mode === inspection.mode,
+          ),
+      )
+      .map((inspection) => `${inspection.mode}:${inspection.path}`)
+  }
+
+  /**
+   * Words the refusal of a Node test continuation that reached a stop whose required facts the debugger could not read, so the agent, or the learner who pressed Continue in the Study pane, learns which fact is missing while the run stays paused at that stop (Cycle 0052 task 5, O4: MCP 1.8's error codes, no schema change; task 73: no agent-only words, since the Study pane shows the same line); called by {@link StudyService.continueNodeTest} after the stop is journaled.
+   * @param record - The Node test run.
+   * @param stop - The stop the continuation reached.
+   * @returns An `EVIDENCE_UNAVAILABLE` {@link StudyError} naming each required `<mode>:<path>` the stop lacks, or `undefined` when it has them all.
+   * @example this.unreadRequiredFactsRefusal(record, stop)?.message // => 'The continuation reached the stop at app/lib/actions.ts:131, but the debugger could not read its required fact value:revalidatePath.mock.calls.length. …'
+   */
+  private unreadRequiredFactsRefusal(
+    record: StudyRecord,
+    stop: NodeTestSourceStop,
+  ): StudyError | undefined {
+    const missing = this.unreadRequiredFacts(record, stop)
+    if (missing.length === 0) return undefined
+    const named = missing.join(', ')
+    return new StudyError(
+      'EVIDENCE_UNAVAILABLE',
+      `The continuation reached the stop at ${stop.source.path}:${stop.frame.line}, but the debugger could not read its required ${missing.length === 1 ? 'fact' : 'facts'} ${named}. The run stays paused at this stop with its other facts: continue without ${missing.length === 1 ? 'it' : 'them'}, or stop the run.`,
+    )
+  }
+
+  /**
+   * Runs a Node test to its end after its last declared stop and journals the result; called by {@link StudyService.continueNodeTest} for the final continuation.
+   * @param record - The Node test run.
+   * @param run - Its owned runtime.
+   * @example await this.completeNodeTest(record, run)
+   */
+  private async completeNodeTest(
+    record: StudyRecord,
+    run: NodeTestRuntime,
+  ): Promise<void> {
+    const result = await run.complete()
+    record.nodeResult = result
+    await record.nodeHistoryWriter?.appendResult(result, result.elapsedMs)
+    // The same for a result that arrives after the deadline's failure (F77).
+    if (record.nodePhase === 'advancing') record.nodePhase = 'completed'
+    // The exit already says the test did not pass; the run's error names why Vitest's report could not confirm the cited test.
+    if (result.reportFailure !== undefined) {
+      record.error = this.sanitizedError(
+        new StudyError(
+          'RUNTIME_FAILED',
+          `${describeNodeTestResult(result)}, and Vitest's test report could not confirm the cited test: ${result.reportFailure}`,
+        ),
+      )
+      queueMicrotask(() => {
+        void this.stopRecord(record).catch(() => undefined)
+      })
+    }
   }
 
   /** Stops a run through its shared cleanup barrier; historical resources remain available. @example await service.stop({instanceId,runId}) */
@@ -1940,11 +2015,15 @@ export class StudyService {
         'PREREQUISITE_MISSING',
         'Workspace-bound Node history storage is unavailable.',
       )
+    const store = this.nodeHistoryStore
     try {
-      const material = await this.nodeHistoryStore.saveLearningMaterial(
-        parsed.studyId,
-        parsed.expectedRevision,
-        parsed.content,
+      // An unknown id, or a history removed while it is saved, is a reference to correct, as at the history's resources (Cycle 0052 tasks 60, 75).
+      const material = await withKnownNodeHistory(store, parsed.studyId, () =>
+        store.saveLearningMaterial(
+          parsed.studyId,
+          parsed.expectedRevision,
+          parsed.content,
+        ),
       )
       await this.cacheNodeLearning(parsed.studyId, material)
       this.presentationController?.nodeHistoryLearningMaterialSaved(
@@ -3591,6 +3670,43 @@ export class StudyService {
     return !record.stopping && record.recording?.isSealed === true
   }
 
+  /**
+   * Words why a browser run's recording ends before its run completed, for the recording's gap and its seal: the run's own failure as its `run.failed` event names it, or a release that did not complete; called by {@link StudyService.stopRecord}.
+   * A run refused during its preparation used to read "Runtime interrupted or cleanup incomplete" in its recording although nothing was interrupted (Cycle 0052 task 7a).
+   * @param failure - The run's `run.failed` event, if it has one.
+   * @param error - The run's error, whose bare cause reads better than its wrapped message ("The study operation failed. Cause: …").
+   * @returns The sentence, its cause cut so that the whole sentence fits {@link RECORDING_REASON_LIMIT_CHARS}.
+   * @example
+   * this.recordingStopReason(failedEvent, record.error) // => 'The run failed: Selected source app/ui/login-form.tsx is not in the client code … Recorded prefix retained.'
+   * this.recordingStopReason(undefined, undefined) // => 'Runtime cleanup incomplete; recorded prefix retained.'
+   */
+  private recordingStopReason(
+    failure: RecordedEvent | undefined,
+    error: StudyError | undefined,
+  ): string {
+    if (!failure) return 'Runtime cleanup incomplete; recorded prefix retained.'
+    const detail = failure.detail
+    const reason =
+      error?.causeDetail ??
+      (typeof detail === 'object' &&
+      detail !== null &&
+      'reason' in detail &&
+      typeof detail.reason === 'string'
+        ? detail.reason
+        : undefined)
+    // A failure journaled without words still says the run failed rather than that it was interrupted.
+    if (reason === undefined) return 'The run failed. Recorded prefix retained.'
+    const sentence = (cause: string): string =>
+      `The run failed: ${cause}. Recorded prefix retained.`
+    // The recording keeps RECORDING_REASON_LIMIT_CHARS of a reason: a long cause is cut, never the sentence's end (Cycle 0052 task 74).
+    return sentence(
+      cutTextToFit(
+        this.sanitizedCause(reason).replace(/\.$/, ''),
+        (cause) => sentence(cause).length <= RECORDING_REASON_LIMIT_CHARS,
+      ),
+    )
+  }
+
   /** Serializes release after acquisitions and accepted explanation writes settle. @example await this.stopRecord(record) */
   private async stopRecord(record: StudyRecord): Promise<void> {
     if (record.stopped) return
@@ -3623,7 +3739,7 @@ export class StudyService {
             if (failure || !runtime.resourcesReleased)
               record.recording.stopFrames(
                 failure?.elapsedMs ?? record.runtime.evidence.elapsedMs(),
-                'Runtime interrupted or cleanup incomplete; recorded prefix retained.',
+                this.recordingStopReason(failure, record.error),
               )
             try {
               const seal = await record.recording.finish(
@@ -3686,7 +3802,7 @@ export class StudyService {
 
   /**
    * Seals a test run's history once its release and its continuation have ended; called by {@link StudyService.stopRecord}.
-   * The seal is `complete` from the test's own facts (EN4): its last continuation completed, every declared stop was captured and the result verifiably passed. Then the run's learning coverage is counted from the stops and the result the writer wrote and the material this window saved (EN2). A seal that throws leaves the journal as an interrupted prefix and the run's `HISTORY_SEAL_FAILED`, with its sanitized cause and one Output › Codebook entry.
+   * The seal is `complete` from the test's own facts (EN4): its last continuation completed, every declared stop was captured with every required fact read, and the result verifiably passed. A run that went on without a required fact (Cycle 0052 task 5) seals partial, naming the facts (task 72). Then the run's learning coverage is counted from the stops and the result the writer wrote and the material this window saved (EN2). A seal that throws leaves the journal as an interrupted prefix and the run's `HISTORY_SEAL_FAILED`, with its sanitized cause and one Output › Codebook entry.
    * @param record - The test run.
    * @param writer - Its history writer, still recording.
    * @example await this.sealNodeHistory(record, record.nodeHistoryWriter)
@@ -3701,11 +3817,24 @@ export class StudyService {
     const passed =
       nodeTestResultKind(record.nodeResult) === 'passed' &&
       record.nodeResult?.reportFailure === undefined
-    const complete =
+    const capturedAll =
       record.nodePhase === 'completed' &&
       passed &&
       record.nodeStops?.length === expectedStops
-    const reason = complete ? undefined : this.partialHistoryReason(record)
+    const unread = (record.nodeStops ?? []).flatMap((stop) =>
+      this.unreadRequiredFacts(record, stop).map(
+        (fact) => `${fact} at ${stop.source.path}:${stop.frame.line}`,
+      ),
+    )
+    // A history whose stops lack a required fact lacks evidence the question asked for, however the test ended.
+    const complete = capturedAll && unread.length === 0
+    const reason = complete
+      ? undefined
+      : capturedAll
+        ? this.sanitizedCause(
+            `The test passed, but the debugger could not read the required ${unread.length === 1 ? 'fact' : 'facts'} ${unread.join(', ')}.`,
+          )
+        : this.partialHistoryReason(record)
     try {
       record.nodeHistoryHash = await this.finishNodeHistory(
         writer,
diff --git a/extension/src/studyWorkspace.ts b/extension/src/studyWorkspace.ts
index db91d1ab9..9b576f973 100644
--- a/extension/src/studyWorkspace.ts
+++ b/extension/src/studyWorkspace.ts
@@ -11562,7 +11562,7 @@ export class StudyWorkspace {
    * @example await workspace.openLearningReplay(studyId)
    */
   async openLearningReplay(studyId: string): Promise<void> {
-    // A test replay opens in the Study pane, not through the browser replay's controller.
+    // A test replay opens in its summary composition through its own entry, not through the browser replay's controller (Cycle 0051, DS-A).
     if (this.isTestReplayStudy(studyId))
       return this.openNodeHistoryFromHost(studyId)
     await this.openRecording(studyId)
@@ -11589,6 +11589,13 @@ export class StudyWorkspace {
     // A learner's preview tab that blocks the open is answered with a choice and a retry, not a toast (F158).
     const answer = await this.resolveForeignPreviewRefusal(state.reason)
     if (answer === 'retry') return this.openLearningReplay(studyId)
+    // The failure also goes to Output › Codebook, as a test replay's failed open does, so the learner can copy it into a report (Cycle 0052 task 59), also after the keep-open refusal told it (task 81).
+    this.diagnostics?.log({
+      surface: 'open:recording',
+      studyId,
+      profile: REPOSITORY_BROWSER_PROFILE,
+      cause: sanitizeCause(state.reason, this.privateRoots()),
+    })
     // The keep-open refusal has told the learner already; a second notice would repeat it.
     if (answer === 'told') return
     // The controller keeps a failure as its string form, which starts with the error's name.
@@ -20031,15 +20038,17 @@ export class StudyWorkspace {
             }
             view.webview.html = studyHtml('moments')
             // Disposed or replaced panel documents cannot send actions into a later replay.
-            view.webview.onDidReceiveMessage((message) => {
-              if (this.moments === view)
-                void this.receivePaneMessage(message, 'moments', view).catch(
-                  (error) => {
-                    if (this.moments === view)
-                      this.report(this.panelFailureKind(message), error)
-                  },
-                )
-            })
+            // The listener returns its handling, which the editor ignores, so a test can tell when a message's handling ended (Cycle 0052 task 8).
+            view.webview.onDidReceiveMessage((message) =>
+              this.moments === view
+                ? this.receivePaneMessage(message, 'moments', view).catch(
+                    (error) => {
+                      if (this.moments === view)
+                        this.report(this.panelFailureKind(message), error)
+                    },
+                  )
+                : undefined,
+            )
             view.onDidDispose(() => {
               if (this.moments === view) {
                 this.moments = undefined
diff --git a/extension/src/tests/configuredAdapter.test.ts b/extension/src/tests/configuredAdapter.test.ts
index 65f4a5fba..20ac62e22 100644
--- a/extension/src/tests/configuredAdapter.test.ts
+++ b/extension/src/tests/configuredAdapter.test.ts
@@ -167,6 +167,7 @@ for (const path of ['src/ordinary.tsx', 'components/deep/another.ts'])
     )
   })
 
+// Value: protects=a stop in another page's component is refused before browser input with a sentence that names the stop's file, the launched page and where a stop can go (the launched page's own code, or a run started at the stop's page), so the agent does not retry blind; fails_when=the refusal names neither the file nor the page and only says to verify the page, as N51's Cursor run retried three times (Cycle 0052 task 7b); why_new=the boundary stays (a browser stop is armed before input in the code the launched page loads) and its sentence now says so; seam=a development build whose root page loads another component; no_claim=a stop armed after a client-side navigation, which the profile does not support
 test('a source from another route reports the root-page mismatch before browser input', async (context) => {
   // Arrange
   const { directory, track } = await repositoryHarness(context)
@@ -200,7 +201,10 @@ test('a source from another route reports the root-page mismatch before browser
       line: 1,
       column: 1,
     }),
-    /Selected source is absent from the selected application route chunks; verify that it belongs to the launched page/,
+    {
+      message:
+        'Selected source src/dashboard/Header.tsx is not in the client code that the launched page (entryPath "/") loads, and a browser stop can only be armed in that code before input; start the run at the page whose component holds the stop (set entryPath to it) or choose a stop in the launched page\'s own components',
+    },
   )
 })
 
diff --git a/extension/src/tests/configuredRuntimeRecording.test.ts b/extension/src/tests/configuredRuntimeRecording.test.ts
index a75837da7..95dc069a3 100644
--- a/extension/src/tests/configuredRuntimeRecording.test.ts
+++ b/extension/src/tests/configuredRuntimeRecording.test.ts
@@ -700,8 +700,9 @@ test('a completed run whose final save fails records the failure and seals its r
       ],
       recordingSeal: {
         status: 'partial',
+        // The seal names the run's own failure (Cycle 0052 task 7a).
         reason:
-          'Runtime interrupted or cleanup incomplete; recorded prefix retained.',
+          'The run failed: ENOSPC: no space left on device, write. Recorded prefix retained.',
       },
     },
   )
@@ -1086,3 +1087,377 @@ test('an agent whose last continuation is acknowledged only after the completed
   )
   await service.stop(receipt)
 })
+
+// Value: protects=the recording of a browser run whose preparation was refused names that refusal when it is sealed, so the saved study and the agent read why nothing was recorded; fails_when=the seal reads "Runtime interrupted or cleanup incomplete; recorded prefix retained." for a run that was refused before input and stopped by the agent, as N51's three Cursor runs did (Cycle 0052 task 7a); why_new=the seal had one sentence for any journaled failure and for an incomplete release; seam=the controlled runtime's preparation, which refuses with the route-chunk sentence; no_claim=the native browser and debugger
+test('a run refused during its preparation seals its recording with the refusal, not as interrupted', async (context) => {
+  // Arrange: a recorded run of the real coordinator whose preparation is refused.
+  let service: StudyService | undefined, books: RepositoryBookStore | undefined
+  context.after(async () => {
+    await service?.shutdown()
+    books?.dispose()
+  })
+  const harness = await configuredRuntimeHarness(context),
+    directory = join(harness.directory, '.learning')
+  const library = new LearningLibrary(directory, '0'.repeat(64)),
+    store = new RecordingStore(directory, library.workspaceKey)
+  books = new RepositoryBookStore(harness.sources, library)
+  await books.publish({
+    bookId: 'interface',
+    expectedRevision: 0,
+    key: 'article',
+    document: {
+      title: 'Interface',
+      summary: 'Two citations.',
+      nodes: [
+        {
+          id: 'theme',
+          title: 'Theme',
+          sections: [{ title: 'Theme', text: 'Source-derived explanation.' }],
+          anchors: harness.definition.descriptor.anchors,
+          observations: [],
+        },
+      ],
+      edges: [],
+    },
+  })
+  service = new StudyService(
+    {
+      workspace: harness.directory,
+      host: {
+        id: 'vscode',
+        productVersion: 'test',
+        apiVersion: 'test',
+        commit: 'test',
+      },
+      build: {
+        revision: 'controlled-runtime',
+        dirty: false,
+        sourceHash: '0'.repeat(64),
+      },
+      prerequisites: async () => ({ ready: true, missing: [] }),
+      createRuntime: async () => harness.run,
+    },
+    join(harness.directory, '.service'),
+  )
+  service.repository = books
+  service.recordings = store
+  context.mock.method(harness.run, 'prepare', async () => {
+    throw new Error(
+      'Selected source app/ui/login-form.tsx is not in the client code that the launched page (entryPath "/") loads, and a browser stop can only be armed in that code before input; start the run at the page whose component holds the stop (set entryPath to it) or choose a stop in the launched page\'s own components',
+    )
+  })
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'refused-at-preparation'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: 'repository-browser',
+    key: startKey,
+    configuration: harness.definition.configuration,
+  })
+  const record = service.record(receipt)
+  await record.preparation
+
+  // Act: the agent stops the refused run, as N51's did.
+  await service.stop(receipt).catch(() => undefined)
+  await waitUntil(() => record.stopped, 'the refused run is released')
+
+  // Assert
+  assert.deepEqual(
+    {
+      status: record.recordingSeal?.status,
+      reason: record.recordingSeal?.reason,
+    },
+    {
+      status: 'partial',
+      reason:
+        'The run failed: Selected source app/ui/login-form.tsx is not in the client code that the launched page (entryPath "/") loads, and a browser stop can only be armed in that code before input; start the run at the page whose component holds the stop (set entryPath to it) or choose a stop in the launched page\'s own components. Recorded prefix retained.',
+    },
+  )
+})
+
+// Value: protects=the recording of a browser run that journaled no failure but whose resources were not released is sealed with the cleanup sentence, so the saved study says the cleanup was incomplete and not that the run failed or was interrupted; fails_when=the sentence changes back to "Runtime interrupted or cleanup incomplete; recorded prefix retained." (Cycle 0052 task 7a) or the unreleased run is sealed without a reason; why_new=no test pins the seal of an incomplete release, only those of journaled failures; seam=the controlled runtime's view, which reports resourcesReleased false; no_claim=a real failed release of the native browser or debugger
+test('a run stopped with its resources not released and no failure seals its recording as cleanup incomplete', async (context) => {
+  // Arrange: a recorded run of the real coordinator whose view reports that its resources are still held.
+  let service: StudyService | undefined, books: RepositoryBookStore | undefined
+  context.after(async () => {
+    await service?.shutdown()
+    books?.dispose()
+  })
+  const harness = await configuredRuntimeHarness(context),
+    directory = join(harness.directory, '.learning')
+  const library = new LearningLibrary(directory, '0'.repeat(64)),
+    store = new RecordingStore(directory, library.workspaceKey)
+  books = new RepositoryBookStore(harness.sources, library)
+  await books.publish({
+    bookId: 'interface',
+    expectedRevision: 0,
+    key: 'article',
+    document: {
+      title: 'Interface',
+      summary: 'Two citations.',
+      nodes: [
+        {
+          id: 'theme',
+          title: 'Theme',
+          sections: [{ title: 'Theme', text: 'Source-derived explanation.' }],
+          anchors: harness.definition.descriptor.anchors,
+          observations: [],
+        },
+      ],
+      edges: [],
+    },
+  })
+  service = new StudyService(
+    {
+      workspace: harness.directory,
+      host: {
+        id: 'vscode',
+        productVersion: 'test',
+        apiVersion: 'test',
+        commit: 'test',
+      },
+      build: {
+        revision: 'controlled-runtime',
+        dirty: false,
+        sourceHash: '0'.repeat(64),
+      },
+      prerequisites: async () => ({ ready: true, missing: [] }),
+      createRuntime: async () => harness.run,
+    },
+    join(harness.directory, '.service'),
+  )
+  service.repository = books
+  service.recordings = store
+  const view = harness.run.view.bind(harness.run)
+  context.mock.method(harness.run, 'view', () => ({
+    ...view(),
+    resourcesReleased: false,
+  }))
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'unreleased-resources'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: 'repository-browser',
+    key: startKey,
+    configuration: harness.definition.configuration,
+  })
+  const record = service.record(receipt)
+  await record.preparation
+
+  // Act: the agent stops the run whose release leaves resources held.
+  await service.stop(receipt).catch(() => undefined)
+  await waitUntil(() => record.stopped, 'the unreleased run is stopped')
+
+  // Assert
+  assert.deepEqual(
+    {
+      status: record.recordingSeal?.status,
+      reason: record.recordingSeal?.reason,
+    },
+    {
+      status: 'partial',
+      reason: 'Runtime cleanup incomplete; recorded prefix retained.',
+    },
+  )
+})
+
+// Value: protects=the recording of a browser run whose journaled failure names no reason and that has no error of its own is sealed as a failed run, not as an interrupted one; fails_when=the reasonless failure is sealed with "Runtime interrupted or cleanup incomplete; recorded prefix retained." again or with an empty cause (Cycle 0052 task 7a); why_new=pt3 /ship review (state machines, testing): the reasonless branch of the seal had no test; seam=the controlled runtime's view, which adds a run.failed event without a reason; no_claim=which runtime paths journal a failure without a reason (none known)
+test('a run whose journaled failure names no reason seals its recording as a failed run', async (context) => {
+  // Arrange: a recorded run of the real coordinator whose view reports a failure without a reason.
+  let service: StudyService | undefined, books: RepositoryBookStore | undefined
+  context.after(async () => {
+    await service?.shutdown()
+    books?.dispose()
+  })
+  const harness = await configuredRuntimeHarness(context),
+    directory = join(harness.directory, '.learning')
+  const library = new LearningLibrary(directory, '0'.repeat(64)),
+    store = new RecordingStore(directory, library.workspaceKey)
+  books = new RepositoryBookStore(harness.sources, library)
+  await books.publish({
+    bookId: 'interface',
+    expectedRevision: 0,
+    key: 'article',
+    document: {
+      title: 'Interface',
+      summary: 'Two citations.',
+      nodes: [
+        {
+          id: 'theme',
+          title: 'Theme',
+          sections: [{ title: 'Theme', text: 'Source-derived explanation.' }],
+          anchors: harness.definition.descriptor.anchors,
+          observations: [],
+        },
+      ],
+      edges: [],
+    },
+  })
+  service = new StudyService(
+    {
+      workspace: harness.directory,
+      host: {
+        id: 'vscode',
+        productVersion: 'test',
+        apiVersion: 'test',
+        commit: 'test',
+      },
+      build: {
+        revision: 'controlled-runtime',
+        dirty: false,
+        sourceHash: '0'.repeat(64),
+      },
+      prerequisites: async () => ({ ready: true, missing: [] }),
+      createRuntime: async () => harness.run,
+    },
+    join(harness.directory, '.service'),
+  )
+  service.repository = books
+  service.recordings = store
+  const view = harness.run.view.bind(harness.run)
+  context.mock.method(harness.run, 'view', () => {
+    const current = view()
+    const last = current.events.at(-1)
+    return last
+      ? {
+          ...current,
+          events: [
+            ...current.events,
+            { ...last, type: 'run.failed', detail: {} },
+          ],
+        }
+      : current
+  })
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'reasonless-failure'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: 'repository-browser',
+    key: startKey,
+    configuration: harness.definition.configuration,
+  })
+  const record = service.record(receipt)
+  await record.preparation
+
+  // Act: the agent stops the run.
+  await service.stop(receipt).catch(() => undefined)
+  await waitUntil(() => record.stopped, 'the run is stopped')
+
+  // Assert
+  assert.deepEqual(
+    {
+      status: record.recordingSeal?.status,
+      reason: record.recordingSeal?.reason,
+    },
+    {
+      status: 'partial',
+      reason: 'The run failed. Recorded prefix retained.',
+    },
+  )
+})
+
+// Value: protects=the recording of a browser run whose failure has a long reason keeps the whole seal sentence: the cause is cut so that the sentence, ending with "Recorded prefix retained.", fits the recording's reason limit; fails_when=the recording cuts the sentence itself at its limit, so the saved study loses the words that say the recorded prefix is kept (Cycle 0052 task 74); why_new=pt3 /ship Step 11 (Claude adversarial): the cause was interpolated uncut and the recording sliced the sentence; seam=the controlled runtime's view, which adds a run.failed event with a 1,900-character reason; no_claim=which runtime failures are that long
+test('a run whose failure has a reason longer than the recording keeps seals its recording with the cause cut and the sentence whole', async (context) => {
+  // Arrange: a recorded run of the real coordinator whose view reports a failure with a long reason.
+  let service: StudyService | undefined, books: RepositoryBookStore | undefined
+  context.after(async () => {
+    await service?.shutdown()
+    books?.dispose()
+  })
+  const harness = await configuredRuntimeHarness(context),
+    directory = join(harness.directory, '.learning')
+  const library = new LearningLibrary(directory, '0'.repeat(64)),
+    store = new RecordingStore(directory, library.workspaceKey)
+  books = new RepositoryBookStore(harness.sources, library)
+  await books.publish({
+    bookId: 'interface',
+    expectedRevision: 0,
+    key: 'article',
+    document: {
+      title: 'Interface',
+      summary: 'Two citations.',
+      nodes: [
+        {
+          id: 'theme',
+          title: 'Theme',
+          sections: [{ title: 'Theme', text: 'Source-derived explanation.' }],
+          anchors: harness.definition.descriptor.anchors,
+          observations: [],
+        },
+      ],
+      edges: [],
+    },
+  })
+  service = new StudyService(
+    {
+      workspace: harness.directory,
+      host: {
+        id: 'vscode',
+        productVersion: 'test',
+        apiVersion: 'test',
+        commit: 'test',
+      },
+      build: {
+        revision: 'controlled-runtime',
+        dirty: false,
+        sourceHash: '0'.repeat(64),
+      },
+      prerequisites: async () => ({ ready: true, missing: [] }),
+      createRuntime: async () => harness.run,
+    },
+    join(harness.directory, '.service'),
+  )
+  service.repository = books
+  service.recordings = store
+  const view = harness.run.view.bind(harness.run)
+  context.mock.method(harness.run, 'view', () => {
+    const current = view()
+    const last = current.events.at(-1)
+    return last
+      ? {
+          ...current,
+          events: [
+            ...current.events,
+            {
+              ...last,
+              type: 'run.failed',
+              detail: {
+                reason: `The page answered: ${'a long diagnostic line '.repeat(80)}`,
+              },
+            },
+          ],
+        }
+      : current
+  })
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'long-failure-reason'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: 'repository-browser',
+    key: startKey,
+    configuration: harness.definition.configuration,
+  })
+  const record = service.record(receipt)
+  await record.preparation
+
+  // Act: the agent stops the run.
+  await service.stop(receipt).catch(() => undefined)
+  await waitUntil(() => record.stopped, 'the run is stopped')
+
+  // Assert
+  const reason = record.recordingSeal?.reason ?? ''
+  assert.deepEqual(
+    {
+      status: record.recordingSeal?.status,
+      opening: reason.slice(0, 40),
+      ending: reason.slice(-34),
+      fitsTheLimit: reason.length <= 1_024,
+    },
+    {
+      status: 'partial',
+      opening: 'The run failed: The page answered: a lon',
+      ending: '… [cut]. Recorded prefix retained.',
+      fitsTheLimit: true,
+    },
+  )
+})
diff --git a/extension/src/tests/configuredService.test.ts b/extension/src/tests/configuredService.test.ts
index f6d871c65..46611bd0a 100644
--- a/extension/src/tests/configuredService.test.ts
+++ b/extension/src/tests/configuredService.test.ts
@@ -26,6 +26,7 @@ import {
   observeResult,
 } from './utils/configuredServiceHarness'
 import { loadModule } from './utils/loadModule'
+import { RUN_RELEASE_BOUND_MS } from './utils/runReleaseBound'
 
 const receiptSchema = z.object({
   instanceId: z.string(),
@@ -753,7 +754,7 @@ test('a run whose preparation fails and whose release then fails keeps the prepa
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the failed release after the failed preparation',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const resource = await readResource(service, receipt.runUri)
   // The harness's own shutdown releases the run once the test has read it.
@@ -822,7 +823,7 @@ test('a run that the maintenance turn ends for an evidence write failure names t
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the release after the evidence failure',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const resource = await readResource(service, receipt.runUri)
   // The harness's own shutdown releases the run once the test has read it.
@@ -896,7 +897,7 @@ test('a run whose saved study was removed while it ran ends at the maintenance t
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the release after the evidence failure',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const resource = await readResource(service, receipt.runUri)
   // The harness's own shutdown releases the run once the test has read it.
@@ -973,7 +974,7 @@ test('a run whose saved study was removed while it ran keeps a release failure t
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the release after the evidence failure',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const resource = await readResource(service, receipt.runUri)
   const retryFailure = await service
@@ -1043,7 +1044,7 @@ test('a run whose saved study was found removed after its evidence write failed
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the release after the evidence failure',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const errorNamedPathBefore = Boolean(
     record.error?.message.includes(runtime.evidence.directory),
@@ -1129,7 +1130,7 @@ test('a completed run whose release failed after its saved study was removed by
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the failed release of the completed run',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const errorBefore = {
     message: record.error?.message,
@@ -1207,7 +1208,7 @@ test("a removed study's kept run failure is served by no resource: its events an
   await waitUntil(
     () => Boolean(record.cleanupError) && !record.stopping,
     'the release after the evidence failure',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   service.excludeHistory(record, 'archive-removed')
   const path = runtime.evidence.directory
@@ -1347,7 +1348,7 @@ test('a run whose study was removed during its preparation and found removed aft
   await waitUntil(
     () => !record.stopping && (record.stopped || Boolean(record.cleanupError)),
     'the release after the failed preparation',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const path = runtimes[0]!.evidence.directory
   const terminalNamedPathBefore = Boolean(
@@ -1445,7 +1446,7 @@ test('a run whose study was found removed while its preparation was failing name
   await waitUntil(
     () => !record.stopping && (record.stopped || Boolean(record.cleanupError)),
     'the release after the failed preparation',
-    1_000,
+    RUN_RELEASE_BOUND_MS,
   )
   const path = runtimes[0]!.evidence.directory
   const run = await readResource(service, receipt.runUri)
diff --git a/extension/src/tests/inspectNodeTestVariables.test.ts b/extension/src/tests/inspectNodeTestVariables.test.ts
index 33db695e9..34344cbe7 100644
--- a/extension/src/tests/inspectNodeTestVariables.test.ts
+++ b/extension/src/tests/inspectNodeTestVariables.test.ts
@@ -4,7 +4,9 @@ import { test } from 'node:test'
 import type { DebugProtocol } from '@vscode/debugprotocol'
 import type * as vscode from 'vscode'
 
+import { ACTIVE_TIMEOUT_MS } from '../runtimeSupport/constants'
 import { inspectNodeTestVariables } from '../utils/inspectNodeTestVariables'
+import { sourceImportBindings } from '../utils/sourceImportBindings'
 
 test('a Node pause keeps declared nested facts without retaining unrelated local values', async () => {
   // Arrange
@@ -49,6 +51,7 @@ test('a Node pause keeps declared nested facts without retaining unrelated local
       { path: 'listener', mode: 'value', required: true },
       { path: 'state.count', mode: 'value', required: true },
     ],
+    sourceImportBindings(''),
     AbortSignal.timeout(1_000),
   )
   // Assert
@@ -107,6 +110,7 @@ test('a Node pause does not inspect global variables when the declared local fac
     session,
     scopes,
     [{ path: 'listener', mode: 'value', required: true }],
+    sourceImportBindings(''),
     AbortSignal.timeout(1_000),
   )
   // Assert
@@ -116,21 +120,27 @@ test('a Node pause does not inspect global variables when the declared local fac
   ])
 })
 
-test('a Node pause refuses a missing required value', async () => {
+// Value: protects=a required fact the debugger cannot read is returned by name instead of ending the stop's capture, so the run can keep its other facts and stay paused there; fails_when=the inspector throws for it, which ended the whole live run with RUNTIME_FAILED (Cycle 0052 task 5); why_new=restates the earlier refusal test: the refusal moved to codebook_continue (O4); seam=a fake debug session whose scopes hold no variable; no_claim=the service's refusal (nodeTestService)
+test('a Node pause returns a required value it cannot read by name instead of failing', async () => {
   // Arrange
   const session = {
     customRequest: async () => ({ variables: [] }),
   } as unknown as Pick<vscode.DebugSession, 'customRequest'>
   const scopes = [{ name: 'Local', variablesReference: 1, expensive: false }]
-  // Act / Assert
-  await assert.rejects(
-    inspectNodeTestVariables(
-      session,
-      scopes,
-      [{ path: 'listener', mode: 'value', required: true }],
-      AbortSignal.timeout(1_000),
-    ),
-    /Required Node debugger fact is unavailable/,
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    scopes,
+    [{ path: 'listener', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:listener'] },
   )
 })
 
@@ -156,6 +166,7 @@ test('a Node pause keeps a declared value whose debugger type name is too long t
     session,
     scopes,
     [{ path: 'totals', mode: 'value', required: true }],
+    sourceImportBindings(''),
     AbortSignal.timeout(1_000),
   )
 
@@ -165,3 +176,1504 @@ test('a Node pause keeps a declared value whose debugger type name is too long t
     { path: 'totals', mode: 'value', display: 'Map(3)' },
   ])
 })
+
+/**
+ * Builds a fake debug session that answers `variables` requests from a fixed table, as the native JavaScript debugger would.
+ * @param table - The children of each variables reference.
+ * @returns The session's `customRequest`.
+ * @example sessionAnswering(new Map([[1, [{ name: 'a', value: '1', variablesReference: 0 }]]]))
+ */
+function sessionAnswering(
+  table: Map<number, DebugProtocol.Variable[]>,
+): Pick<vscode.DebugSession, 'customRequest'> {
+  return {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => ({ variables: table.get(arguments_.variablesReference) ?? [] }),
+  }
+}
+
+const VITEST_SCOPES = [
+  { name: 'Local', variablesReference: 1, expensive: false },
+  { name: 'Block', variablesReference: 2, expensive: false },
+  { name: 'Global', variablesReference: 9, expensive: false },
+]
+
+// Value: protects=a required fact whose root is a name the test imports from a module that vi.mock replaced is read through the module's binding: the root has no variable of its own (Vitest binds the whole module as __vi_import_<n>__, a Proxy whose exports sit under [[Target]]), and the walk then reads mock → calls → length as for a local mock; fails_when=the inspector finds roots by lexical name only, so revalidatePath.mock.calls.length is unavailable and the live run ended (N51-V5, Cycle 0052 task 5); why_new=the root cause recorded in #124 (a live V8 probe of nextjs-dashboard's actions.test.ts under Vitest 5.0.2); seam=a fake debug session answering with the probed shapes; no_claim=the native debugger's own naming of [[Target]] (N52 live)
+test('a Node pause reads a required value of a name the test imports from a mocked module', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, [{ name: 'set', value: 'ƒ (...args)', variablesReference: 0 }]],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 3,
+          },
+          {
+            name: '__vi_import_0__',
+            value: 'Proxy(Object)',
+            variablesReference: 4,
+          },
+        ],
+      ],
+      [3, [{ name: 'expect', value: '(...)', variablesReference: 0 }]],
+      [
+        4,
+        [
+          { name: '[[Handler]]', value: 'Object', variablesReference: 40 },
+          { name: '[[Target]]', value: 'Object', variablesReference: 41 },
+          { name: '[[IsRevoked]]', value: 'false', variablesReference: 0 },
+        ],
+      ],
+      [
+        41,
+        [
+          {
+            name: 'revalidatePath',
+            value: 'ƒ (...args)',
+            type: 'function',
+            variablesReference: 42,
+          },
+        ],
+      ],
+      [
+        42,
+        [{ name: 'mock', value: '{calls: Array(1)}', variablesReference: 43 }],
+      ],
+      [43, [{ name: 'calls', value: 'Array(1)', variablesReference: 44 }]],
+      [
+        44,
+        [
+          {
+            name: '0',
+            value: "['/dashboard/invoices']",
+            variablesReference: 45,
+          },
+          { name: 'length', value: '1', type: 'number', variablesReference: 0 },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      {
+        path: 'revalidatePath.mock.calls.length',
+        mode: 'value',
+        required: true,
+      },
+    ],
+    sourceImportBindings(
+      "import { expect } from 'vitest'\nimport { revalidatePath } from 'next/cache'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        {
+          path: 'revalidatePath.mock.calls.length',
+          mode: 'value',
+          display: '1',
+          type: 'number',
+        },
+      ],
+      unavailable: [],
+    },
+  )
+})
+
+// Value: protects=a required fact whose root a module exports as a live binding is read: an unmocked module is a namespace whose exports are getters, which the debugger shows as lazy values, and the inspector expands the lazy value once, as the Variables view does, instead of saving its "(...)" placeholder; fails_when=the imported root is not found, or the placeholder "(...)" is saved as the value (Cycle 0052 task 5); why_new=the probe showed unmocked imports as Module namespaces with accessor exports; seam=a fake debug session answering a lazy variable with its one resolved child; no_claim=which getters the native debugger marks lazy (N52 live)
+test('a Node pause reads a required value of a name the test imports from an unmocked module', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 5,
+          },
+        ],
+      ],
+      [
+        5,
+        [
+          {
+            name: 'ITEMS_PER_PAGE',
+            value: '(...)',
+            variablesReference: 50,
+            presentationHint: { lazy: true },
+          },
+        ],
+      ],
+      [
+        50,
+        [
+          {
+            name: 'ITEMS_PER_PAGE',
+            value: '6',
+            type: 'number',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'ITEMS_PER_PAGE', mode: 'value', required: true }],
+    sourceImportBindings("import { ITEMS_PER_PAGE } from './data'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(result.facts, [
+    { path: 'ITEMS_PER_PAGE', mode: 'value', display: '6', type: 'number' },
+  ])
+})
+
+// Value: protects=an imported name is read from its own declaration's module binding, never from another imported module that exports the same name: the fact shows the value the source actually imports; fails_when=every module binding's export of the name is a candidate, so a second module's export makes the fact unavailable or, when the right binding is out of scope, answers for it (Cycle 0052 tasks 5, 96); why_new=hosted CodeRabbit review of 267e5bce (Major, inspectNodeTestVariables.ts:245-253); seam=a fake debug session whose two module bindings both export formatCurrency, and the stopped source's import declarations; no_claim=Vite's numbering itself (sourceImportBindings tests)
+test('a Node pause reads an imported name from its own import declaration module, not from another module exporting the same name', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 6,
+          },
+          {
+            name: '__vite_ssr_import_1__',
+            value: 'Module',
+            variablesReference: 7,
+          },
+        ],
+      ],
+      [
+        6,
+        [
+          {
+            name: 'formatDate',
+            value: 'ƒ formatDate(date)',
+            variablesReference: 0,
+          },
+          {
+            name: 'formatCurrency',
+            value: 'ƒ formatCurrency(amount)',
+            variablesReference: 0,
+          },
+        ],
+      ],
+      [
+        7,
+        [
+          {
+            name: 'formatCurrency',
+            value: 'ƒ formatCurrency(cents)',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'formatCurrency', mode: 'value', required: true }],
+    sourceImportBindings(
+      "import { formatDate } from './dates'\nimport { formatCurrency } from './utils'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        {
+          path: 'formatCurrency',
+          mode: 'value',
+          display: 'ƒ formatCurrency(cents)',
+        },
+      ],
+      unavailable: [],
+    },
+  )
+})
+
+// Value: protects=an imported name whose own module binding the stop's scopes do not hold stays unavailable, even when another module binding in scope exports the same name; fails_when=the other binding's export answers for it and a wrong value is saved as a required fact (Cycle 0052 task 96); why_new=hosted CodeRabbit review of 267e5bce (Major); seam=a fake debug session whose only module binding in scope belongs to another declaration and exports the name too; no_claim=which scopes V8 shows at a stop
+test('a Node pause leaves an imported name unavailable when its own module binding is out of scope, though another binding exports it', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 6,
+          },
+        ],
+      ],
+      [
+        6,
+        [
+          {
+            name: 'formatDate',
+            value: 'ƒ formatDate(date)',
+            variablesReference: 0,
+          },
+          {
+            name: 'formatCurrency',
+            value: 'ƒ formatCurrency(amount)',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'formatCurrency', mode: 'value', required: true }],
+    sourceImportBindings(
+      "import { formatDate } from './dates'\nimport { formatCurrency } from './utils'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:formatCurrency'] },
+  )
+})
+
+// Value: protects=an import the TypeScript compiler dropped (one used only as a type, without `import type`) shifts Vite's numbering of the later declarations; the shift is caught and the name stays unavailable instead of reading the next module's export; fails_when=the numbering is trusted without checking that each earlier binding holds its own declaration's exports, so `db` is read from another module (Cycle 0052 task 96); why_new=hosted CodeRabbit review of 267e5bce (Major); seam=a fake debug session whose bindings are numbered as if the first import had been dropped; no_claim=which imports a given compiler drops
+test('a Node pause leaves an imported name unavailable when a dropped earlier import shifted the module numbering', async () => {
+  // Arrange: next/server was dropped, so binding 0 is @/db and binding 1 is another module that exports db too.
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 6,
+          },
+          {
+            name: '__vite_ssr_import_1__',
+            value: 'Module',
+            variablesReference: 7,
+          },
+        ],
+      ],
+      [6, [{ name: 'db', value: 'Object', variablesReference: 0 }]],
+      [7, [{ name: 'db', value: 'OtherDatabase', variablesReference: 0 }]],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'db', mode: 'value', required: true }],
+    sourceImportBindings(
+      "import { NextRequest } from 'next/server'\nimport { db } from '@/db'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:db'] },
+  )
+})
+
+// Value: protects=a local variable keeps priority over an import of the same name, as JavaScript scoping does: the fact reads the local value; fails_when=the module binding's export replaces a local variable that shadows it (Cycle 0052 task 5); why_new=the import lookup must only run when no scope variable has the name; seam=a fake debug session with a local and an import of one name; no_claim=closure scopes of other frames
+test('a Node pause reads a local variable before an imported name it shadows', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [
+        1,
+        [
+          {
+            name: 'status',
+            value: "'paid'",
+            type: 'string',
+            variablesReference: 0,
+          },
+        ],
+      ],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Object',
+            variablesReference: 6,
+          },
+        ],
+      ],
+      [
+        6,
+        [
+          {
+            name: 'status',
+            value: "'imported'",
+            type: 'string',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'status', mode: 'value', required: true }],
+    sourceImportBindings("import { status } from './status'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(result.facts, [
+    { path: 'status', mode: 'value', display: "'paid'", type: 'string' },
+  ])
+})
+
+// Value: protects=a declared path that passes through a getter the debugger shows as lazy ("(...)") is walked on: the lazy step is expanded once and the next segment is read from its value; fails_when=only the first and last step expand a lazy value, so a path such as mock.calls.length stops at the "(...)" placeholder and the required fact is unavailable (Cycle 0052 task 5); why_new=the unmocked-module test expands one lazy value at the end of a root, none in the middle of a path; seam=a fake debug session answering a lazy middle step with its one resolved child; no_claim=which getters the native debugger marks lazy (N52 live)
+test('a Node pause reads a required value behind a lazy getter in the middle of its path', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [
+        1,
+        [
+          {
+            name: 'revalidatePath',
+            value: 'ƒ (...args)',
+            variablesReference: 3,
+          },
+        ],
+      ],
+      [
+        3,
+        [
+          {
+            name: 'mock',
+            value: '(...)',
+            variablesReference: 30,
+            presentationHint: { lazy: true },
+          },
+        ],
+      ],
+      [30, [{ name: 'mock', value: 'Object', variablesReference: 31 }]],
+      [
+        31,
+        [
+          {
+            name: 'callCount',
+            value: '2',
+            type: 'number',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'revalidatePath.mock.callCount', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        {
+          path: 'revalidatePath.mock.callCount',
+          mode: 'value',
+          display: '2',
+          type: 'number',
+        },
+      ],
+      unavailable: [],
+    },
+  )
+})
+
+// Value: protects=a Node stop whose required value sits behind a lazy getter the debugger cannot expand (the getter throws in the test process, or the adapter refuses the request): the fact reads unavailable and the stop keeps its other facts; fails_when=the rejected expansion escapes the inspector, so the whole advance fails and the live run ends instead of the agent hearing which fact is missing; why_new=pt3 /ship review (Red Team): the lazy expansion added for imported names runs getters and its rejection was not caught; seam=a fake debug session that rejects the expansion of one reference; no_claim=how the native adapter answers a throwing getter (it may answer with the error as a value instead)
+test('a Node pause reports a required value behind a lazy getter the debugger cannot expand as unavailable and keeps its other facts', async () => {
+  // Arrange
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 30)
+        throw new Error('Cannot access the getter before initialization')
+      const table = new Map<number, DebugProtocol.Variable[]>([
+        [
+          1,
+          [
+            {
+              name: 'status',
+              value: "'paid'",
+              type: 'string',
+              variablesReference: 0,
+            },
+            {
+              name: 'config',
+              value: 'Object',
+              variablesReference: 3,
+            },
+          ],
+        ],
+        [
+          3,
+          [
+            {
+              name: 'limit',
+              value: '(...)',
+              variablesReference: 30,
+              presentationHint: { lazy: true },
+            },
+          ],
+        ],
+      ])
+      return { variables: table.get(arguments_.variablesReference) ?? [] }
+    },
+  }
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      { path: 'config.limit', mode: 'value', required: true },
+      { path: 'status', mode: 'value', required: true },
+    ],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        { path: 'status', mode: 'value', display: "'paid'", type: 'string' },
+      ],
+      unavailable: ['value:config.limit'],
+    },
+  )
+})
+
+// Value: protects=an imported name whose module binding two of the stop's scopes both list: it is one import, so the fact is read, not left unavailable as ambiguous; fails_when=each scope's listing of the same binding counts as another module exporting the name, so a required fact such as db.insert.mock.calls reads unavailable; why_new=pt3 /ship review (Red Team): bindings were collected per scope without telling a repeated listing from a second module; seam=a fake debug session in which the Block and Closure scopes list the same __vi_import_0__ binding; no_claim=which native scope layouts repeat a binding
+test('a Node pause reads an imported name once when two scopes list the same module binding', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vi_import_0__',
+            value: 'Proxy(Object)',
+            variablesReference: 40,
+          },
+        ],
+      ],
+      [
+        5,
+        [
+          {
+            name: '__vi_import_0__',
+            value: 'Proxy(Object)',
+            variablesReference: 41,
+          },
+        ],
+      ],
+      [40, [{ name: 'db', value: 'Object', variablesReference: 50 }]],
+      [41, [{ name: 'db', value: 'Object', variablesReference: 50 }]],
+      [
+        50,
+        [
+          {
+            name: 'inserted',
+            value: '0',
+            type: 'number',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    [
+      { name: 'Local', variablesReference: 1, expensive: false },
+      { name: 'Block', variablesReference: 2, expensive: false },
+      { name: 'Closure', variablesReference: 5, expensive: false },
+    ],
+    [{ path: 'db.inserted', mode: 'value', required: true }],
+    sourceImportBindings("import { db } from '@/db'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        { path: 'db.inserted', mode: 'value', display: '0', type: 'number' },
+      ],
+      unavailable: [],
+    },
+  )
+})
+
+// Value: protects=a Node stop whose lazy expansion gets a malformed answer from the debugger: the pass fails as before, rather than reading the fact as merely unavailable and keeping a stop on a broken session; fails_when=the lazy expansion swallows every failure (a timeout, a cancellation, a malformed answer), so a broken debugger reads as a missing fact and the agent is told to continue; why_new=pt3 /ship review pass 2 (Red Team): the first catch took every failure for a throwing getter; seam=a fake debug session that answers the lazy reference without a variable list; no_claim=a timeout, which takes the active timeout to reach
+test('a Node pause whose lazy expansion gets a malformed debugger answer fails instead of reporting the fact unavailable', async () => {
+  // Arrange
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) =>
+      arguments_.variablesReference === 30
+        ? {}
+        : {
+            variables:
+              arguments_.variablesReference === 1
+                ? [
+                    {
+                      name: 'limit',
+                      value: '(...)',
+                      variablesReference: 30,
+                      presentationHint: { lazy: true },
+                    },
+                  ]
+                : [],
+          },
+  }
+
+  // Act
+  const outcome = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'limit', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+
+  // Assert
+  assert.equal(outcome, 'Error: Native debugger supplied no variable list.')
+})
+
+// Value: protects=a Node stop cancelled while a lazy value is being expanded: the pass ends with the cancellation instead of returning the fact as unavailable; fails_when=the lazy expansion swallows the cancellation and the pass returns partial facts for a run that was stopped; why_new=pt3 /ship review pass 2 (testing): the cancellation path of the lazy expansion had no test; seam=a fake debug session whose answer to the lazy reference never comes, and the run's abort controller, aborted by the test; no_claim=the native debugger's own cancellation
+test('a Node pause cancelled while a lazy value is expanded ends with the cancellation', async () => {
+  // Arrange
+  const controller = new AbortController()
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 30) {
+        controller.abort()
+        return new Promise(() => {})
+      }
+      return Promise.resolve({
+        variables:
+          arguments_.variablesReference === 1
+            ? [
+                {
+                  name: 'limit',
+                  value: '(...)',
+                  variablesReference: 30,
+                  presentationHint: { lazy: true },
+                },
+              ]
+            : [],
+      })
+    },
+  }
+
+  // Act
+  const outcome = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'limit', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    controller.signal,
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+
+  // Assert
+  assert.equal(outcome, 'Error: Cancelled owned Node debugger variables')
+})
+
+// Value: protects=JavaScript shadowing at a Node stop: a scope variable whose lazy value the debugger cannot read still shadows a same-named import, so the fact reads unavailable instead of taking the imported module's value; fails_when=an unreadable scope variable counts as absent and the walk falls through to the import, recording another module's value under the local name; why_new=pt3 /ship review pass 2 (Red Team); seam=a fake debug session with a refused lazy local and a module binding exporting the same name; no_claim=how often a local getter throws natively
+test('a Node pause leaves a required local whose lazy value cannot be read unavailable instead of reading an import of the same name', async () => {
+  // Arrange
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 30)
+        throw new Error('Cannot access the getter before initialization')
+      const table = new Map<number, DebugProtocol.Variable[]>([
+        [
+          1,
+          [
+            {
+              name: 'status',
+              value: '(...)',
+              variablesReference: 30,
+              presentationHint: { lazy: true },
+            },
+          ],
+        ],
+        [
+          2,
+          [
+            {
+              name: '__vite_ssr_import_0__',
+              value: 'Module',
+              variablesReference: 40,
+            },
+          ],
+        ],
+        [
+          40,
+          [
+            {
+              name: 'status',
+              value: "'imported'",
+              type: 'string',
+              variablesReference: 0,
+            },
+          ],
+        ],
+      ])
+      return { variables: table.get(arguments_.variablesReference) ?? [] }
+    },
+  }
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'status', mode: 'value', required: true }],
+    sourceImportBindings("import { status } from './status'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:status'] },
+  )
+})
+
+// Value: protects=the debugger's load at a Node stop: two module bindings that reach one shared reference, read together, ask the debugger for that reference once; fails_when=the pass caches only finished answers, so bindings read together send duplicate variables requests for the same reference; why_new=pt3 /ship review pass 2 (performance): the bindings became concurrent reads; seam=a fake debug session that counts the requests per reference; no_claim=the adapter's own request handling
+test('a Node pause asks the debugger once for a reference two module bindings reach together', async () => {
+  // Arrange
+  const requests = new Map<number, number>()
+  const table = new Map<number, DebugProtocol.Variable[]>([
+    [1, []],
+    [
+      2,
+      [
+        {
+          name: '__vi_import_0__',
+          value: 'Proxy(Object)',
+          variablesReference: 40,
+        },
+        {
+          name: '__vi_import_1__',
+          value: 'Proxy(Object)',
+          variablesReference: 41,
+        },
+      ],
+    ],
+    [40, [{ name: '[[Target]]', value: 'Object', variablesReference: 60 }]],
+    [41, [{ name: '[[Target]]', value: 'Object', variablesReference: 60 }]],
+    [
+      60,
+      [{ name: 'shared', value: '1', type: 'number', variablesReference: 0 }],
+    ],
+  ])
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      const reference = arguments_.variablesReference
+      requests.set(reference, (requests.get(reference) ?? 0) + 1)
+      return { variables: table.get(reference) ?? [] }
+    },
+  }
+
+  // Act
+  await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'again', mode: 'value', required: false }],
+    sourceImportBindings(
+      "import { shared } from './a'\nimport { shared as again } from './b'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.equal(requests.get(60), 1)
+})
+
+// Value: protects=a Node stop whose lazy local the debugger never answers: the pass fails with the timeout instead of reading the fact as unavailable and keeping a stop on a stalled session; fails_when=the lazy expansion swallows the timeout like the adapter's error answer, so a hung debugger reads as a missing fact and the agent is told to continue; why_new=pt3 /ship review pass 3 (testing, state machines): the timeout path of the expansion's rethrow had no test; seam=a fake debug session that never answers the lazy reference, and node:test's mocked setTimeout advanced by the active timeout; no_claim=how long the native adapter takes
+test('a Node pause whose lazy local the debugger never answers fails with the timeout instead of reporting the fact unavailable', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setTimeout'] })
+  let markExpansionRequested!: () => void
+  const expansionRequested = new Promise<void>((resolve) => {
+    markExpansionRequested = resolve
+  })
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 30) {
+        markExpansionRequested()
+        return new Promise(() => {})
+      }
+      return Promise.resolve({
+        variables:
+          arguments_.variablesReference === 1
+            ? [
+                {
+                  name: 'limit',
+                  value: '(...)',
+                  variablesReference: 30,
+                  presentationHint: { lazy: true },
+                },
+              ]
+            : [],
+      })
+    },
+  }
+  const outcome = inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'limit', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    new AbortController().signal,
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+  await expansionRequested
+
+  // Act
+  context.mock.timers.tick(ACTIVE_TIMEOUT_MS)
+
+  // Assert
+  assert.equal(
+    await outcome,
+    'Error: Timed out waiting for owned Node debugger variables',
+  )
+})
+
+// Value: protects=a Node stop whose imported name sits behind a getter the debugger cannot expand (an unmocked module's export that throws in the test process): the fact reads unavailable and the stop keeps its other facts; fails_when=the import's lazy expansion lets the adapter's error answer escape, so the whole advance fails and the live run ends instead of the agent hearing which fact is missing; why_new=pt3 /ship review pass 3 (state machines): the refused expansion was tested for a local and a path step only; seam=a fake debug session that rejects the expansion of the module export's reference; no_claim=how the native adapter answers a throwing getter
+test('a Node pause reports a required imported name whose getter the debugger cannot expand as unavailable and keeps its other facts', async () => {
+  // Arrange
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 50)
+        throw new Error('ITEMS_PER_PAGE is not initialized')
+      const table = new Map<number, DebugProtocol.Variable[]>([
+        [
+          1,
+          [
+            {
+              name: 'status',
+              value: "'paid'",
+              type: 'string',
+              variablesReference: 0,
+            },
+          ],
+        ],
+        [
+          2,
+          [
+            {
+              name: '__vite_ssr_import_0__',
+              value: 'Module',
+              variablesReference: 5,
+            },
+          ],
+        ],
+        [
+          5,
+          [
+            {
+              name: 'ITEMS_PER_PAGE',
+              value: '(...)',
+              variablesReference: 50,
+              presentationHint: { lazy: true },
+            },
+          ],
+        ],
+      ])
+      return { variables: table.get(arguments_.variablesReference) ?? [] }
+    },
+  }
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      { path: 'ITEMS_PER_PAGE', mode: 'value', required: true },
+      { path: 'status', mode: 'value', required: true },
+    ],
+    sourceImportBindings("import { ITEMS_PER_PAGE } from './data'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [
+        { path: 'status', mode: 'value', display: "'paid'", type: 'string' },
+      ],
+      unavailable: ['value:ITEMS_PER_PAGE'],
+    },
+  )
+})
+
+// Value: protects=a Node stop whose imported name's getter the debugger never answers: the pass fails with the timeout instead of reading the fact as unavailable; fails_when=the import's lazy expansion swallows the timeout, so a hung debugger reads as a missing fact; why_new=pt3 /ship review pass 3 (state machines): the timeout cell of an imported name had no test; seam=a fake debug session that never answers the module export's lazy reference, and node:test's mocked setTimeout advanced by the active timeout; no_claim=how long the native adapter takes
+test('a Node pause whose imported getter the debugger never answers fails with the timeout instead of reporting the fact unavailable', async (context) => {
+  // Arrange
+  context.mock.timers.enable({ apis: ['setTimeout'] })
+  let markExpansionRequested!: () => void
+  const expansionRequested = new Promise<void>((resolve) => {
+    markExpansionRequested = resolve
+  })
+  const table = new Map<number, DebugProtocol.Variable[]>([
+    [1, []],
+    [
+      2,
+      [
+        {
+          name: '__vite_ssr_import_0__',
+          value: 'Module',
+          variablesReference: 5,
+        },
+      ],
+    ],
+    [
+      5,
+      [
+        {
+          name: 'ITEMS_PER_PAGE',
+          value: '(...)',
+          variablesReference: 50,
+          presentationHint: { lazy: true },
+        },
+      ],
+    ],
+  ])
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 50) {
+        markExpansionRequested()
+        return new Promise(() => {})
+      }
+      return Promise.resolve({
+        variables: table.get(arguments_.variablesReference) ?? [],
+      })
+    },
+  }
+  const outcome = inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'ITEMS_PER_PAGE', mode: 'value', required: true }],
+    sourceImportBindings("import { ITEMS_PER_PAGE } from './data'"),
+    new AbortController().signal,
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+  await expansionRequested
+
+  // Act
+  context.mock.timers.tick(ACTIVE_TIMEOUT_MS)
+
+  // Assert
+  assert.equal(
+    await outcome,
+    'Error: Timed out waiting for owned Node debugger variables',
+  )
+})
+
+// Value: protects=a Node stop cancelled while an imported name's getter is being expanded: the pass ends with the cancellation instead of returning the fact as unavailable; fails_when=the import's lazy expansion swallows the cancellation and the pass returns partial facts for a run that was stopped; why_new=pt3 /ship review pass 3 (state machines): the cancellation cell of an imported name had no test; seam=a fake debug session whose answer to the module export's lazy reference never comes, and the run's abort controller, aborted by the test; no_claim=the native debugger's own cancellation
+test('a Node pause cancelled while an imported getter is expanded ends with the cancellation', async () => {
+  // Arrange
+  const controller = new AbortController()
+  const table = new Map<number, DebugProtocol.Variable[]>([
+    [1, []],
+    [
+      2,
+      [
+        {
+          name: '__vite_ssr_import_0__',
+          value: 'Module',
+          variablesReference: 5,
+        },
+      ],
+    ],
+    [
+      5,
+      [
+        {
+          name: 'ITEMS_PER_PAGE',
+          value: '(...)',
+          variablesReference: 50,
+          presentationHint: { lazy: true },
+        },
+      ],
+    ],
+  ])
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 50) {
+        controller.abort()
+        return new Promise(() => {})
+      }
+      return Promise.resolve({
+        variables: table.get(arguments_.variablesReference) ?? [],
+      })
+    },
+  }
+
+  // Act
+  const outcome = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'ITEMS_PER_PAGE', mode: 'value', required: true }],
+    sourceImportBindings("import { ITEMS_PER_PAGE } from './data'"),
+    controller.signal,
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+
+  // Assert
+  assert.equal(outcome, 'Error: Cancelled owned Node debugger variables')
+})
+
+// Value: protects=a Node stop whose imported name's getter gets a malformed answer from the debugger: the pass fails, rather than reading the fact as merely unavailable and keeping a stop on a broken session; fails_when=the import's lazy expansion swallows the malformed answer, so a broken debugger reads as a missing fact and the agent is told to continue; why_new=pt3 /ship review pass 3 (state machines): the malformed-answer cell of an imported name had no test; seam=a fake debug session that answers the module export's lazy reference without a variable list; no_claim=which native adapters answer that way
+test('a Node pause whose imported getter gets a malformed debugger answer fails instead of reporting the fact unavailable', async () => {
+  // Arrange
+  const table = new Map<number, DebugProtocol.Variable[]>([
+    [1, []],
+    [
+      2,
+      [
+        {
+          name: '__vite_ssr_import_0__',
+          value: 'Module',
+          variablesReference: 5,
+        },
+      ],
+    ],
+    [
+      5,
+      [
+        {
+          name: 'ITEMS_PER_PAGE',
+          value: '(...)',
+          variablesReference: 50,
+          presentationHint: { lazy: true },
+        },
+      ],
+    ],
+  ])
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) =>
+      arguments_.variablesReference === 50
+        ? {}
+        : { variables: table.get(arguments_.variablesReference) ?? [] },
+  }
+
+  // Act
+  const outcome = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'ITEMS_PER_PAGE', mode: 'value', required: true }],
+    sourceImportBindings("import { ITEMS_PER_PAGE } from './data'"),
+    AbortSignal.timeout(1_000),
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+
+  // Assert
+  assert.equal(outcome, 'Error: Native debugger supplied no variable list.')
+})
+
+// Value: protects=a lazy value whose expansion the debugger refused once is asked again by a later fact of the same stop, so a refusal that does not repeat (a getter that threw only the first time) leaves only the first fact unavailable; fails_when=the pass keeps the failed request, so every later fact through that reference reads unavailable without asking the debugger; why_new=pt3 /ship review pass 3 (testing): the eviction of a failed request from the pass's request cache had no test; seam=a fake debug session that refuses the lazy reference's first expansion and answers its second, counting the requests; no_claim=whether a native getter's failure repeats
+test('a Node pause asks again for a lazy value whose earlier expansion the debugger refused', async () => {
+  // Arrange
+  let expansions = 0
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      if (arguments_.variablesReference === 30) {
+        expansions += 1
+        if (expansions === 1)
+          throw new Error('Cannot access the getter before initialization')
+        return {
+          variables: [
+            {
+              name: 'limit',
+              value: '6',
+              type: 'number',
+              variablesReference: 0,
+            },
+          ],
+        }
+      }
+      return {
+        variables:
+          arguments_.variablesReference === 1
+            ? [
+                {
+                  name: 'limit',
+                  value: '(...)',
+                  variablesReference: 30,
+                  presentationHint: { lazy: true },
+                },
+              ]
+            : [],
+      }
+    },
+  }
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      { path: 'limit', mode: 'value', required: true },
+      { path: 'limit', mode: 'type', required: true },
+    ],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    {
+      facts: result.facts,
+      unavailable: result.unavailable,
+      expansions,
+    },
+    {
+      facts: [
+        { path: 'limit', mode: 'type', display: 'number', type: 'number' },
+      ],
+      unavailable: ['value:limit'],
+      expansions: 2,
+    },
+  )
+})
+
+// Value: protects=the debugger after a failed Node stop: once one module binding's read fails the pass, the other bindings read together with it ask the debugger nothing more; fails_when=the other bindings' reads go on after the pass has failed, sending variables requests (a Proxy's [[Target]]) to a session whose stop the run is ending; why_new=pt3 /ship review pass 3 (Red Team): Promise.all rejects on the first failure while its siblings keep reading; seam=a fake debug session that answers one binding malformed and holds the other's answer until the pass has failed, recording every requested reference; no_claim=what the native adapter does with a request it gets late
+test('a Node pause whose module binding read fails sends the debugger no further request for the other bindings', async () => {
+  // Arrange
+  const requested: number[] = []
+  let releaseHeldBinding!: () => void
+  const heldBinding = new Promise<void>((resolve) => {
+    releaseHeldBinding = resolve
+  })
+  const table = new Map<number, DebugProtocol.Variable[]>([
+    [1, []],
+    [
+      2,
+      [
+        {
+          name: '__vi_import_0__',
+          value: 'Proxy(Object)',
+          variablesReference: 40,
+        },
+        {
+          name: '__vi_import_1__',
+          value: 'Proxy(Object)',
+          variablesReference: 41,
+        },
+      ],
+    ],
+    [41, [{ name: '[[Target]]', value: 'Object', variablesReference: 60 }]],
+    [60, [{ name: 'db', value: 'Object', variablesReference: 0 }]],
+  ])
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async (
+      _command: string,
+      arguments_: { variablesReference: number },
+    ) => {
+      const reference = arguments_.variablesReference
+      requested.push(reference)
+      if (reference === 40) return {}
+      if (reference === 41) await heldBinding
+      return { variables: table.get(reference) ?? [] }
+    },
+  }
+  const outcome = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'db', mode: 'value', required: true }],
+    sourceImportBindings("import { a } from './a'\nimport { db } from '@/db'"),
+    AbortSignal.timeout(1_000),
+  ).then(
+    () => 'read',
+    (error: unknown) => String(error),
+  )
+
+  // Act: the held binding's answer arrives after the pass failed.
+  releaseHeldBinding()
+  await new Promise((resolve) => setImmediate(resolve))
+
+  // Assert
+  assert.deepEqual(
+    { outcome, requested },
+    {
+      outcome: 'Error: Native debugger supplied no variable list.',
+      requested: [1, 2, 40, 41],
+    },
+  )
+})
+
+// Value: protects=the diagnosis of a Node stop whose scope read the debug adapter refuses: the pass fails with the adapter's own error kept as the cause, under the same message as before; fails_when=the refusal is re-wrapped without its cause, so a log or a debugger of the extension loses the adapter's error and its stack; why_new=pt3 /ship review pass 3 (maintainability): the wrapper kept the adapter's error only as text; seam=a fake debug session that rejects the Local scope's read; no_claim=how the run words the failure (StudyService sanitizes it)
+test('a Node pause whose scope read the debugger refuses fails with the adapter error as its cause', async () => {
+  // Arrange
+  const adapterError = new Error('Unable to find thread for evaluation')
+  const session: Pick<vscode.DebugSession, 'customRequest'> = {
+    customRequest: async () => {
+      throw adapterError
+    },
+  }
+
+  // Act
+  const failure = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'status', mode: 'value', required: true }],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  ).then(
+    () => undefined,
+    (error: unknown) => error,
+  )
+
+  // Assert
+  assert.ok(failure instanceof Error)
+  assert.deepEqual(
+    {
+      message: failure.message,
+      causeIsAdapterError: failure.cause === adapterError,
+    },
+    {
+      message:
+        'Native debugger refused the variables request: Error: Unable to find thread for evaluation',
+      causeIsAdapterError: true,
+    },
+  )
+})
+
+// Value: protects=an aliased import at a Node stop reads the module export the alias stands for, not another module's export named like the alias; fails_when=the export is matched by the local name, so `import { actual as count } from './a'` records b's `count` (99) instead of a's `actual` (7) as the fact, with nothing unavailable (Cycle 0052 task 70); why_new=pt3 /ship Step 11 (Claude adversarial, Codex adversarial and structured review), Codex's repro; seam=a fake debug session with two module bindings, and the stopped source's import declarations; no_claim=Vite's binding order
+test('a Node pause reads an aliased import as the export the alias stands for, not another module export of the alias name', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 40,
+          },
+          {
+            name: '__vite_ssr_import_1__',
+            value: 'Module',
+            variablesReference: 41,
+          },
+        ],
+      ],
+      [
+        40,
+        [{ name: 'actual', value: '7', type: 'number', variablesReference: 0 }],
+      ],
+      [
+        41,
+        [
+          { name: 'helper', value: 'ƒ helper()', variablesReference: 0 },
+          { name: 'count', value: '99', type: 'number', variablesReference: 0 },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'count', mode: 'value', required: true }],
+    sourceImportBindings(
+      "import { actual as count } from './a'\nimport { helper } from './b'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    {
+      facts: [{ path: 'count', mode: 'value', display: '7', type: 'number' }],
+      unavailable: [],
+    },
+  )
+})
+
+// Value: protects=a name the stopped source does not import, or imports as a namespace, is never read from whichever module binding happens to export that name: the fact reads unavailable; fails_when=any module binding's export of the name answers for it, recording a module's value under a name the source does not bind to it (Cycle 0052 task 70); why_new=pt3 /ship Step 11 (Claude adversarial, Codex adversarial): the lookup did not ask the source; seam=a fake debug session whose module binding exports both names, and the stopped source's import declarations; no_claim=names bound by `require`
+test('a Node pause leaves a name the source does not import, or imports as a namespace, unavailable even when a module exports it', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vite_ssr_import_0__',
+            value: 'Module',
+            variablesReference: 40,
+          },
+        ],
+      ],
+      [
+        40,
+        [
+          { name: 'count', value: '99', type: 'number', variablesReference: 0 },
+          { name: 'schema', value: 'Object', variablesReference: 0 },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      { path: 'count', mode: 'value', required: true },
+      { path: 'schema', mode: 'value', required: true },
+    ],
+    sourceImportBindings("import * as schema from './schema'"),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:count', 'value:schema'] },
+  )
+})
+
+// Value: protects=a default import at a Node stop is read as its module's default export; fails_when=the default import's local name is looked up as an export, so `import db from '@/db'` reads unavailable, or another module's `db` export answers for it (Cycle 0052 task 70); why_new=pt3 /ship Step 11 (Claude adversarial: default imports never resolved); seam=a fake debug session whose module binding exports `default` and whose other binding exports `db`; no_claim=CommonJS interop shapes
+test('a Node pause reads a default import as its module default export', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [1, []],
+      [
+        2,
+        [
+          {
+            name: '__vi_import_0__',
+            value: 'Proxy(Object)',
+            variablesReference: 40,
+          },
+          {
+            name: '__vite_ssr_import_1__',
+            value: 'Module',
+            variablesReference: 41,
+          },
+        ],
+      ],
+      [40, [{ name: '[[Target]]', value: 'Object', variablesReference: 50 }]],
+      [50, [{ name: 'default', value: 'Object', variablesReference: 51 }]],
+      [
+        51,
+        [
+          {
+            name: 'inserted',
+            value: '1',
+            type: 'number',
+            variablesReference: 0,
+          },
+        ],
+      ],
+      [41, [{ name: 'db', value: 'Object', variablesReference: 60 }]],
+      [
+        60,
+        [
+          {
+            name: 'inserted',
+            value: '5',
+            type: 'number',
+            variablesReference: 0,
+          },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [{ path: 'db.inserted', mode: 'value', required: true }],
+    sourceImportBindings(
+      "import db from '@/db'\nimport { users } from '@/db/schema'",
+    ),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(result.facts, [
+    { path: 'db.inserted', mode: 'value', display: '1', type: 'number' },
+  ])
+})
+
+// Value: protects=a lazy value whose expansion the debugger answers with no single value: the fact reads unavailable instead of saving the "(...)" placeholder as the value; fails_when=the unresolved lazy variable is returned as it is, so its "(...)" passes as a read required fact and lands in the immutable history with nothing unavailable (Cycle 0052 task 71); why_new=pt3 /ship Step 11 (Codex adversarial), Codex's repro with an empty answer; seam=a fake debug session that answers the lazy references with no variables and with two; no_claim=which adapters answer that way
+test('a Node pause reports a lazy value the debugger expands to no single value as unavailable instead of saving its placeholder', async () => {
+  // Arrange
+  const session = sessionAnswering(
+    new Map<number, DebugProtocol.Variable[]>([
+      [
+        1,
+        [
+          {
+            name: 'count',
+            value: '(...)',
+            variablesReference: 30,
+            presentationHint: { lazy: true },
+          },
+          {
+            name: 'total',
+            value: '(...)',
+            variablesReference: 31,
+            presentationHint: { lazy: true },
+          },
+        ],
+      ],
+      [30, []],
+      [
+        31,
+        [
+          { name: 'total', value: '1', variablesReference: 0 },
+          { name: 'total', value: '2', variablesReference: 0 },
+        ],
+      ],
+    ]),
+  )
+
+  // Act
+  const result = await inspectNodeTestVariables(
+    session,
+    VITEST_SCOPES,
+    [
+      { path: 'count', mode: 'value', required: true },
+      { path: 'total', mode: 'value', required: true },
+    ],
+    sourceImportBindings(''),
+    AbortSignal.timeout(1_000),
+  )
+
+  // Assert
+  assert.deepEqual(
+    { facts: result.facts, unavailable: result.unavailable },
+    { facts: [], unavailable: ['value:count', 'value:total'] },
+  )
+})
diff --git a/extension/src/tests/nodeHistoryResources.test.ts b/extension/src/tests/nodeHistoryResources.test.ts
index feddd2ce3..0c04c2a2f 100644
--- a/extension/src/tests/nodeHistoryResources.test.ts
+++ b/extension/src/tests/nodeHistoryResources.test.ts
@@ -1,7 +1,9 @@
 import assert from 'node:assert/strict'
+import { rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { test } from 'node:test'
 
+import { StudyError } from '../errors'
 import { NodeTestHistoryStore } from '../nodeTestHistoryStore'
 import { readResource } from '../resources'
 
@@ -117,3 +119,325 @@ test('a history’s events and learning-material pages read no summary, and its
     await harness.close()
   }
 })
+
+// Value: protects=an agent that mistypes one character of a history's study id: the history's resources and codebook_explain_node_history refuse it as NOT_FOUND, naming the id and the catalog to copy a valid one from; fails_when=the store's raw ENOENT reaches the agent as RUNTIME_FAILED "The study operation failed." with a recovery about owned resources and clicks, as N52 saw in VS Code (Copilot Chat read 4735 for 473e in a history's id); why_new=Cycle 0052 task 60 (N52 pt3, VS Code); seam=a real store over a temporary folder that holds one other history; no_claim=a malformed id, which the URI pattern and the input schema refuse first
+test('a history resource or an explanation that names a study id this workspace holds no history for is refused as NOT_FOUND, naming the id and the catalog', async () => {
+  // Arrange: the workspace holds one history; the agent names an id of the same form that no history has.
+  const { harness } = await serviceWithOneHistory()
+  const unknownStudyId =
+    '11111111-1111-4111-8111-111111111111_22222222-2222-4222-8222-222222222222'
+  try {
+    // Act
+    const answers = await Promise.all(
+      [
+        readResource(
+          harness.service,
+          `codebook://node-history/${unknownStudyId}`,
+        ),
+        readResource(
+          harness.service,
+          `codebook://node-history/${unknownStudyId}/learning-material`,
+        ),
+        harness.service.explainNodeHistory({
+          studyId: unknownStudyId,
+          expectedRevision: 0,
+          content: {
+            question: 'Why did the selected theme become dark?',
+            title: 'Theme update',
+            summary: 'The captured stop shows the dark value.',
+            participants: [
+              { id: 'test', label: 'Test' },
+              { id: 'theme', label: 'Theme' },
+            ],
+            steps: [
+              {
+                id: 'step-1',
+                from: 'test',
+                to: 'theme',
+                label: 'Reads the theme',
+                explanation: 'Observed at this event.',
+                evidence: 'observed',
+                reference: { type: 'output', sequence: 1, channel: 'stdout' },
+              },
+            ],
+          },
+        }),
+      ].map((answer) =>
+        answer.then(
+          () => 'answered',
+          (error: unknown) =>
+            error instanceof StudyError
+              ? {
+                  code: error.code,
+                  message: error.message,
+                  recovery: error.describe().recovery,
+                }
+              : String(error),
+        ),
+      ),
+    )
+
+    // Assert
+    const refusal = {
+      code: 'NOT_FOUND',
+      message:
+        'No Node test history 11111111-1111-4111-8111-111111111111_22222222-2222-4222-8222-222222222222 is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.',
+      recovery:
+        'Read codebook_status and use a resource reference from the selected instance and run; for a Node test history, copy its studyId or historyUri from codebook://node-history.',
+    }
+    assert.deepEqual(answers, [refusal, refusal, refusal])
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history that is removed while the read runs (moved to the Trash from Saved studies, for example): the resource is refused as NOT_FOUND, naming the id and the catalog, as for an id never saved; fails_when=the store's raw ENOENT reaches the agent as RUNTIME_FAILED "The study operation failed.", the answer task 60 replaced for an unknown id (Cycle 0052 task 75); why_new=pt3 /ship Step 11 (Claude adversarial): the history folder was checked only before the read; seam=a store whose read removes the history's folder first; no_claim=a history whose folder stays but whose journal cannot be read, which is a failed read
+test('a history resource whose history is removed while it is read is refused as NOT_FOUND, naming the id and the catalog', async () => {
+  // Arrange: the store's read finds the history's folder gone, as when the learner trashes it at that moment.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const read = store.read.bind(store)
+  store.read = async (id) => {
+    await rm(historyFolder, { recursive: true, force: true })
+    return read(id)
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history's learning material while the history is removed (after its journal was read, before its material was): the resource is refused as NOT_FOUND, not answered as a history whose material was never saved; fails_when=the material read finds no file because the folder is gone and the resource answers status not-saved for a history that no longer exists (Cycle 0052 task 78); why_new=local CodeRabbit round 2 on b42256f1 (resources.ts): task 75 caught only reads that throw; seam=a store whose material read removes the history's folder first; no_claim=a material that was never saved, which still reads not-saved
+test('a history’s learning-material resource whose history is removed while it is read is refused as NOT_FOUND, not answered as not saved', async () => {
+  // Arrange: the history's folder is gone when its material is read.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const readLearningMaterial = store.readLearningMaterial.bind(store)
+  store.readLearningMaterial = async (id) => {
+    await rm(historyFolder, { recursive: true, force: true })
+    return readLearningMaterial(id)
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}/learning-material`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history's own page while the history is removed (after its journal was read, before its summary was): the resource is refused as NOT_FOUND, not answered with every summary value read as none; fails_when=the summary read finds no files because the folder is gone and the page answers testResult none and learningCoverage none for a history that no longer exists (Cycle 0052 task 86); why_new=hosted CodeRabbit on PR #127 (outside-diff, resources.ts:154): tasks 75 and 78 covered the journal and the material reads only; seam=a store whose summary read removes the history's folder first; no_claim=a history whose summary cannot be verified while its folder stays, which still reads none
+test('a history page whose history is removed while its summary is read is refused as NOT_FOUND, not answered with empty summary values', async () => {
+  // Arrange: the history's folder is gone when its summary is read.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const summarize = store.summarize.bind(store)
+  store.summarize = async (...input) => {
+    await rm(historyFolder, { recursive: true, force: true })
+    return summarize(...input)
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history's own page while the history is removed after its summary came back (from the store's cache, or a read that ended before the removal): the resource is refused as NOT_FOUND, not answered with the summary of a history that no longer exists; fails_when=the folder is checked only when the summary is empty, so a summary returned just before the removal answers the page (Cycle 0052 task 90); why_new=hosted CodeRabbit review of d851ae4a (outside-diff, resources.ts:189-195); seam=a store whose summary read removes the history's folder after it read the summary; no_claim=a removal after the page was answered
+test('a history page whose history is removed right after its summary was read is refused as NOT_FOUND', async () => {
+  // Arrange: the summary comes back, then the history's folder is gone.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const summarize = store.summarize.bind(store)
+  store.summarize = async (...input) => {
+    const summary = await summarize(...input)
+    await rm(historyFolder, { recursive: true, force: true })
+    return summary
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history's learning material while the history is removed right after its material was read: the resource is refused as NOT_FOUND, not answered with the material of a history that no longer exists; fails_when=the folder is checked only when no material came back, so material read just before the removal answers the page (Cycle 0052 task 94); why_new=hosted CodeRabbit review of 5551addd (outside-diff, resources.ts:170-176); seam=a store whose material read removes the history's folder after it read the material; no_claim=a removal after the page was answered
+test('a history’s learning-material resource whose history is removed right after its material was read is refused as NOT_FOUND', async () => {
+  // Arrange: the history has saved material; it comes back, then the history's folder is gone.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  await store.saveLearningMaterial(studyId, 0, {
+    question: 'Why did the selected theme become dark?',
+    title: 'Theme update',
+    summary: 'The captured output shows the run.',
+    participants: [
+      { id: 'test', label: 'Test' },
+      { id: 'theme', label: 'Theme' },
+    ],
+    steps: [
+      {
+        id: 'step-1',
+        from: 'test',
+        to: 'theme',
+        label: 'Reads the theme',
+        explanation: 'Observed at this event.',
+        evidence: 'observed',
+        reference: { type: 'output', sequence: 1, channel: 'stdout' },
+      },
+    ],
+  })
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const readLearningMaterial = store.readLearningMaterial.bind(store)
+  store.readLearningMaterial = async (id) => {
+    const material = await readLearningMaterial(id)
+    await rm(historyFolder, { recursive: true, force: true })
+    return material
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}/learning-material`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=an agent reading a test history's events while the history is removed right after its journal was read: the resource is refused as NOT_FOUND, not answered with the events of a history that no longer exists; fails_when=the folder is checked only before the read and when it fails, so a journal read just before the removal answers the history and events pages (Cycle 0052 task 95); why_new=hosted CodeRabbit review of d0b78db7 (outside-diff, resources.ts:154-156); seam=a store whose journal read removes the history's folder after it read the journal; no_claim=a removal after the page was answered
+test('a history’s events resource whose history is removed right after its journal was read is refused as NOT_FOUND', async () => {
+  // Arrange: the journal comes back, then the history's folder is gone.
+  const { harness, store, studyId } = await serviceWithOneHistory()
+  const historyFolder = join(
+    harness.directory,
+    '.learning',
+    'node-tests.v1',
+    studyId,
+  )
+  const read = store.read.bind(store)
+  store.read = async (id) => {
+    const history = await read(id)
+    await rm(historyFolder, { recursive: true, force: true })
+    return history
+  }
+  try {
+    // Act
+    const answer = await readResource(
+      harness.service,
+      `codebook://node-history/${studyId}/events`,
+    ).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? { code: error.code, message: error.message }
+          : String(error),
+    )
+
+    // Assert
+    assert.deepEqual(answer, {
+      code: 'NOT_FOUND',
+      message: `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+    })
+  } finally {
+    await harness.close()
+  }
+})
diff --git a/extension/src/tests/nodeTestRunLifecycle.test.ts b/extension/src/tests/nodeTestRunLifecycle.test.ts
index 3bb34d37b..80bb3ad8a 100644
--- a/extension/src/tests/nodeTestRunLifecycle.test.ts
+++ b/extension/src/tests/nodeTestRunLifecycle.test.ts
@@ -59,6 +59,8 @@ type FakeRunSteps = {
   releaseFailureText?: () => string
   /** The Saved Study Limit in force and how many saved studies the library holds; the history store counts both. */
   storage?: { limit: number; savedStudies: number }
+  /** The last declared stop arrives without its required fact, as one the inspector could not read. */
+  lastStopUnread?: boolean
 }
 
 /**
@@ -82,6 +84,10 @@ async function testRunHarness(steps: FakeRunSteps = {}) {
   service.environment.build.sourceHash = 'f'.repeat(64)
   const base = harness.configuration
   const declaredStops = steps.stops ?? 1
+  // Each stop declares the required fact its fake stop carries, as the owned run's inspector would have read it (Cycle 0052 task 5: a stop without its required fact refuses the continuation that reached it).
+  const inspections: NodeTestConfiguration['inspections'] = [
+    { path: 'delayMs', mode: 'value', required: true },
+  ]
   const configuration: NodeTestConfiguration = {
     version: 1,
     adapter: 'vitest-node',
@@ -90,14 +96,14 @@ async function testRunHarness(steps: FakeRunSteps = {}) {
     testTitles: ['job scheduler', 'runs a delayed job after its timer'],
     testHash: 'a'.repeat(64),
     source: base.source,
-    inspections: base.inspections.slice(0, 1),
+    inspections,
     ...(declaredStops === 2
       ? {
           additionalStops: [
             {
               ...base.source,
               anchorIndex: 0,
-              inspections: base.inspections.slice(0, 1),
+              inspections,
             },
           ],
         }
@@ -113,9 +119,10 @@ async function testRunHarness(steps: FakeRunSteps = {}) {
     source: base.source,
     frame: { id: 10 + index, name: 'schedule', line: 1, column: 1 },
     variables: [{ name: 'delayMs', value: '5000' }],
-    facts: [
-      { path: 'delayMs', mode: 'value', display: '5000', type: 'number' },
-    ],
+    facts:
+      steps.lastStopUnread && index === declaredStops - 1
+        ? []
+        : [{ path: 'delayMs', mode: 'value', display: '5000', type: 'number' }],
     debuggerSnapshot: {
       version: 1,
       frames: [
@@ -1499,7 +1506,7 @@ test('a learning material saved while the test run records is kept on the run an
   }
 })
 
-// Value: protects=codebook_explain_node_history telling a stale material revision (IDEMPOTENCY_CONFLICT) from a citation that merely names a path containing the words "revision changed" (INVALID_REFERENCE stays); fails_when=the conflict is recognized by searching the error text, so a stop in src/revision changed.ts turns INVALID_REFERENCE into IDEMPOTENCY_CONFLICT, or a real stale revision stops being a conflict; why_new=explainNodeHistory mapped the error by its text (F44); seam=the history store's save is replaced by one that throws; no_claim=the store's own revision check (nodeTestHistoryStore tests)
+// Value: protects=codebook_explain_node_history telling a stale material revision (IDEMPOTENCY_CONFLICT) from a citation that merely names a path containing the words "revision changed" (INVALID_REFERENCE stays); fails_when=the conflict is recognized by searching the error text, so a stop in src/revision changed.ts turns INVALID_REFERENCE into IDEMPOTENCY_CONFLICT, or a real stale revision stops being a conflict; why_new=explainNodeHistory mapped the error by its text (F44); seam=the history store's save is replaced by one that throws, and its folder check by one that finds the folder; no_claim=the store's own revision check (nodeTestHistoryStore tests)
 test('explain_node_history answers IDEMPOTENCY_CONFLICT for a stale revision and keeps INVALID_REFERENCE for a citation whose path says "revision changed"', async () => {
   // Arrange
   const run = await testRunHarness()
@@ -1510,6 +1517,8 @@ test('explain_node_history answers IDEMPOTENCY_CONFLICT for a stale revision and
   ])
   const input = { studyId, expectedRevision: 0, content }
   try {
+    // The store holds a folder for the id, so the save is reached (an unknown id is refused before it, Cycle 0052 task 60).
+    store.holdsHistoryFolder = () => true
     store.saveLearningMaterial = async () => {
       throw new StudyError(
         'INVALID_REFERENCE',
@@ -2060,6 +2069,98 @@ test('a continuation that finishes after the deadline marked the test failed lea
   }
 })
 
+// Value: protects=an agent whose continuation reaches a stop without its required fact after the whole-run deadline already failed the test: the answer does not say the run stays paused, and the run reads failed with the deadline; fails_when=continueNodeTest refuses with EVIDENCE_UNAVAILABLE "The run stays paused at this stop" for a run that is failed and released; why_new=pt3 /ship review (state machines): the refusal was computed from the journaled stop whatever the run's phase; seam=the owned run's advance is held until the deadline passed, and its last stop carries no fact; no_claim=the real debugger's timing
+test('a continuation that reaches a stop without its required fact after the deadline failed the test does not say the run stays paused', async () => {
+  // Arrange
+  let nowMs = 1_000_000
+  let letAdvanceFinish!: () => void
+  const advanceHeld = new Promise<void>((resolve) => {
+    letAdvanceFinish = resolve
+  })
+  const run = await testRunHarness({
+    stops: 2,
+    advanceHeld,
+    now: () => nowMs,
+    lastStopUnread: true,
+  })
+  try {
+    const { record } = await run.start()
+    const advancing = continueCurrentPause(run.service, record)
+    const answer = advancing.then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? `${error.code}: ${error.message}`
+          : String(error),
+    )
+    await waitUntil(() => record.nodePhase === 'advancing', 'the advance')
+    nowMs = record.deadlineAt + 1
+
+    // Act
+    run.service.maintain()
+    letAdvanceFinish()
+    const continuation = await answer
+    await waitUntil(() => record.stopped, 'the run released')
+
+    // Assert: the continuation is answered as before task 5 (F77); the run resource names the deadline.
+    assert.equal(continuation, 'answered')
+    assert.equal(record.nodePhase, 'failed')
+    assert.equal(
+      run.service.state(record).error?.message,
+      'Study wall deadline expired; history only.',
+    )
+  } finally {
+    await run.harness.close()
+  }
+})
+
+// Value: protects=an agent whose continuation reaches a stop without its required fact while the learner's Stop is already under way: the answer does not say the run stays paused, and the run ends stopped; fails_when=continueNodeTest refuses with EVIDENCE_UNAVAILABLE "The run stays paused at this stop" for a run that is being stopped; why_new=pt3 /ship review pass 2 (state machines, testing): the guard's stopping branch had no test; seam=the history writer's journal write of the reached stop, held until the Stop began, and a last stop without its fact; no_claim=a stop that ends before the continuation settles, which the run's own barrier rules out
+test('a continuation that reaches a stop without its required fact while a stop is under way does not say the run stays paused', async () => {
+  // Arrange
+  const run = await testRunHarness({ stops: 2, lastStopUnread: true })
+  try {
+    const { record } = await run.start()
+    const writer = record.nodeHistoryWriter!
+    const appendStop = writer.appendStop.bind(writer)
+    let reachWrite!: () => void
+    let letWriteFinish!: () => void
+    const writeReached = new Promise<void>((resolve) => {
+      reachWrite = resolve
+    })
+    const writeMayFinish = new Promise<void>((resolve) => {
+      letWriteFinish = resolve
+    })
+    writer.appendStop = async (stop): Promise<void> => {
+      reachWrite()
+      await writeMayFinish
+      return appendStop(stop)
+    }
+    const answer = continueCurrentPause(run.service, record).then(
+      () => 'answered',
+      (error: unknown) =>
+        error instanceof StudyError
+          ? `${error.code}: ${error.message}`
+          : String(error),
+    )
+    await writeReached
+
+    // Act: the learner's Stop begins while the reached stop is being journaled.
+    const stopping = run.service
+      .stop({ instanceId: run.service.instanceId, runId: record.id })
+      .catch(() => undefined)
+    letWriteFinish()
+    const continuation = await answer
+    await stopping
+
+    // Assert
+    assert.equal(continuation, 'answered')
+    assert.equal(record.stopped, true)
+    assert.equal(record.error, undefined)
+  } finally {
+    await run.harness.close()
+  }
+})
+
 // Value: protects=the node-history resource summarizing the history only for its own page: its events and learning-material pages read no summary; fails_when=every page of the resource summarizes the history first, so paging through a long journal repeats a summary for each page; why_new=the resource summarized before branching (F77 part 3, F14); seam=the store's summarize is counted; no_claim=the summary's content (the coverage tests)
 test('the node-history resource summarizes only for the history page, not for its events or learning-material pages', async (context) => {
   // Arrange
diff --git a/extension/src/tests/nodeTestService.test.ts b/extension/src/tests/nodeTestService.test.ts
index 478623dd9..304548f03 100644
--- a/extension/src/tests/nodeTestService.test.ts
+++ b/extension/src/tests/nodeTestService.test.ts
@@ -890,3 +890,462 @@ test('a failed advance to the next Node stop names that failure in the continuat
     await harness.close()
   }
 })
+
+// Value: protects=a live Node test run survives a required fact the debugger cannot read: the continuation that reached the stop is refused with EVIDENCE_UNAVAILABLE naming the fact, the stop is journaled with its other facts, the run stays paused there without an error, and the next codebook_continue goes on to the result; fails_when=the run ends with RUNTIME_FAILED at that stop (N51-V5: value:revalidatePath.mock.calls.length), the stop is lost, or the run cannot be continued after the refusal (Cycle 0052 task 5, O4); why_new=the inspector used to throw, which the continuation's catch turned into a failed run; seam=environment.createNodeTestRun, whose advance returns a stop that lacks its required fact; no_claim=the native debugger's reading of the fact (inspectNodeTestVariables, N52 live)
+test('a Node test continuation that reaches a stop without its required fact is refused while the run stays paused there and continues on', async () => {
+  // Arrange
+  const harness = await createHarness(),
+    { service } = harness
+  service.nodeHistoryStore = new NodeTestHistoryStore(
+    join(harness.directory, '.learning'),
+    '0'.repeat(64),
+  )
+  service.environment.build.sourceHash = 'f'.repeat(64)
+  const base = harness.configuration
+  const configuration: NodeTestConfiguration = {
+    version: 1,
+    adapter: 'vitest-node',
+    book: base.book,
+    testFile: 'src/theme.test.ts',
+    testTitles: ['theme', 'selects the dark theme'],
+    testHash: 'a'.repeat(64),
+    source: base.source,
+    inspections: base.inspections.slice(0, 1),
+    additionalStops: [
+      {
+        ...base.source,
+        anchorIndex: 0,
+        inspections: [
+          {
+            path: 'revalidatePath.mock.calls.length',
+            mode: 'value',
+            required: true,
+          },
+        ],
+      },
+    ],
+  }
+  const stopAt = (index: number, facts: unknown[], limitations: string[]) =>
+    ({
+      index,
+      runId: 'node-run',
+      sessionId: 'owned-session',
+      threadId: 7,
+      elapsedMs: 10 + index,
+      worker: {},
+      source: configuration.source,
+      frame: { id: 10 + index, name: 'notifyManager', line: 1, column: 1 },
+      variables: [{ name: 'listener', value: '() => undefined' }],
+      facts,
+      debuggerSnapshot: {
+        version: 1,
+        frames: [
+          {
+            name: 'notifyManager',
+            line: 1,
+            column: 1,
+            scopes: [{ name: 'Local', variables: [0] }],
+          },
+        ],
+        variables: [
+          { name: 'listener', value: '() => undefined', children: [] },
+        ],
+        limitations,
+      },
+    }) as unknown as NodeTestSourceStop
+  let advanced = false
+  const runtime: NodeTestRuntime = {
+    id: 'node-run',
+    async prepare() {
+      return stopAt(
+        0,
+        [{ path: 'nextTheme', mode: 'value', display: 'dark', type: 'string' }],
+        [],
+      )
+    },
+    hasNextStop() {
+      return !advanced
+    },
+    async advance() {
+      advanced = true
+      return stopAt(
+        1,
+        [],
+        [
+          'Required fact value:revalidatePath.mock.calls.length could not be read at this stop.',
+        ],
+      )
+    },
+    async complete() {
+      return {
+        exitCode: 0,
+        signal: null,
+        output: 'Tests 1 passed',
+        elapsedMs: 40,
+      }
+    },
+    async stop() {},
+  }
+  service.environment.createNodeTestRun = async () => runtime
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'node-unread-required-fact'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: NODE_TEST_PROFILE,
+    key: startKey,
+    configuration,
+  })
+  const record = service.record(receipt)
+  try {
+    await record.preparation
+    const atFirstStop = service.state(record)
+
+    // Act: the continuation reaches the second stop, whose required fact the debugger could not read.
+    const rejection = await service
+      .continue(atFirstStop.participants.server!.continueArguments!)
+      .then(
+        () => undefined,
+        (error: unknown) => error,
+      )
+    const atSecondStop = service.state(record)
+    const afterRefusal = {
+      stopped: record.stopped,
+      error: record.error,
+      phase: record.nodePhase,
+      stops: record.nodeStops?.length,
+    }
+    const goingOn = await service.continue(
+      atSecondStop.participants.server!.continueArguments!,
+    )
+
+    // Assert
+    assert.ok(rejection instanceof StudyError)
+    assert.deepEqual(
+      {
+        code: rejection.code,
+        message: rejection.message,
+        recovery: rejection.describe().recovery,
+        afterRefusal,
+        goingOn: goingOn.accepted,
+        result: record.nodeResult?.exitCode,
+      },
+      {
+        code: 'EVIDENCE_UNAVAILABLE',
+        message:
+          'The continuation reached the stop at src/theme.ts:1, but the debugger could not read its required fact value:revalidatePath.mock.calls.length. The run stays paused at this stop with its other facts: continue without it, or stop the run.',
+        recovery:
+          'Inspect the evidence failure and storage availability. Do not treat missing evidence as success. When codebook_continue names a required fact the debugger could not read, the run stays paused at that stop: read nodeTest.stops and the current participants.server.continueArguments of the run resource, then call codebook_continue with those arguments to go on without it (the earlier ones now answer STALE_PAUSE), or stop the run.',
+        afterRefusal: {
+          stopped: false,
+          error: undefined,
+          phase: 'paused',
+          stops: 2,
+        },
+        goingOn: true,
+        result: 0,
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=a test run that went on without a required fact the debugger could not read, then passed: its history seals partial with a reason naming the fact and its stop, so the study reads partial while the test's own result stays demonstrated; fails_when=the history seals complete and the study reads demonstrated although the stop lacks evidence the question asked for, with nothing in the run resource naming the gap (Cycle 0052 task 72); why_new=pt3 /ship Step 11 (Claude adversarial, Codex adversarial): task 5 let the run go on, and the seal counted only stops and the result; seam=environment.createNodeTestRun, whose advance returns a stop that lacks its required fact, and a real history store; no_claim=the Study pane's wording of the reason (wordNodeCaptureReason)
+test('a Node test run that went on without a required fact seals its history partial, naming the fact', async () => {
+  // Arrange
+  const harness = await createHarness(),
+    { service } = harness
+  service.nodeHistoryStore = new NodeTestHistoryStore(
+    join(harness.directory, '.learning'),
+    '0'.repeat(64),
+  )
+  service.environment.build.sourceHash = 'f'.repeat(64)
+  const base = harness.configuration
+  const configuration: NodeTestConfiguration = {
+    version: 1,
+    adapter: 'vitest-node',
+    book: base.book,
+    testFile: 'src/theme.test.ts',
+    testTitles: ['theme', 'selects the dark theme'],
+    testHash: 'a'.repeat(64),
+    source: base.source,
+    inspections: base.inspections.slice(0, 1),
+    additionalStops: [
+      {
+        ...base.source,
+        anchorIndex: 0,
+        inspections: [
+          {
+            path: 'revalidatePath.mock.calls.length',
+            mode: 'value',
+            required: true,
+          },
+        ],
+      },
+    ],
+  }
+  const stopAt = (index: number, facts: unknown[], limitations: string[]) =>
+    ({
+      index,
+      runId: 'node-run',
+      sessionId: 'owned-session',
+      threadId: 7,
+      elapsedMs: 10 + index,
+      worker: {},
+      source: configuration.source,
+      frame: { id: 10 + index, name: 'notifyManager', line: 1, column: 1 },
+      variables: [{ name: 'listener', value: '() => undefined' }],
+      facts,
+      debuggerSnapshot: {
+        version: 1,
+        frames: [
+          {
+            name: 'notifyManager',
+            line: 1,
+            column: 1,
+            scopes: [{ name: 'Local', variables: [0] }],
+          },
+        ],
+        variables: [
+          { name: 'listener', value: '() => undefined', children: [] },
+        ],
+        limitations,
+      },
+    }) as unknown as NodeTestSourceStop
+  let advanced = false
+  const runtime: NodeTestRuntime = {
+    id: 'node-run',
+    async prepare() {
+      return stopAt(
+        0,
+        [{ path: 'nextTheme', mode: 'value', display: 'dark', type: 'string' }],
+        [],
+      )
+    },
+    hasNextStop() {
+      return !advanced
+    },
+    async advance() {
+      advanced = true
+      return stopAt(
+        1,
+        [],
+        [
+          'Required fact value:revalidatePath.mock.calls.length could not be read at this stop.',
+        ],
+      )
+    },
+    async complete() {
+      return {
+        exitCode: 0,
+        signal: null,
+        output: 'Tests 1 passed',
+        elapsedMs: 40,
+      }
+    },
+    async stop() {},
+  }
+  service.environment.createNodeTestRun = async () => runtime
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'node-went-on-without-required-fact'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: NODE_TEST_PROFILE,
+    key: startKey,
+    configuration,
+  })
+  const record = service.record(receipt)
+  try {
+    await record.preparation
+    const atFirstStop = service.state(record)
+    await service
+      .continue(atFirstStop.participants.server!.continueArguments!)
+      .catch(() => undefined)
+    const atSecondStop = service.state(record)
+
+    // Act: the run goes on without the fact to its passing result and is released.
+    await service.continue(atSecondStop.participants.server!.continueArguments!)
+    service.maintain()
+    await waitUntil(() => record.stopped, 'Node profile cleanup', 1_000)
+
+    // Assert
+    const state = service.state(record)
+    assert.deepEqual(
+      {
+        historyStatus: state.nodeTest?.historyStatus,
+        reason: state.recording.reason,
+        finalOutcome: state.finalOutcome,
+        studyOutcome: state.studyOutcome,
+        recordedStudyOutcome: state.recordedStudyOutcome,
+      },
+      {
+        historyStatus: 'partial',
+        reason:
+          'The test passed, but the debugger could not read the required fact value:revalidatePath.mock.calls.length at src/theme.ts:1.',
+        finalOutcome: 'demonstrated',
+        studyOutcome: 'partial',
+        recordedStudyOutcome: 'partial',
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=a stop that lacks two required facts is refused with one EVIDENCE_UNAVAILABLE naming both, comma-separated, in the plural wording, the run stays paused and continues on, the stop is journaled with its other facts, the run stays paused there without an error, and the next codebook_continue goes on to the result; fails_when=the refusal names only the first fact, joins them without a comma, or keeps the singular wording; why_new=the existing test pins one missing fact only; seam=environment.createNodeTestRun, whose advance returns a stop that lacks its required fact; no_claim=the native debugger's reading of the facts
+test('a Node test continuation that reaches a stop without two required facts is refused naming both while the run stays paused there and continues on', async () => {
+  // Arrange
+  const harness = await createHarness(),
+    { service } = harness
+  service.nodeHistoryStore = new NodeTestHistoryStore(
+    join(harness.directory, '.learning'),
+    '0'.repeat(64),
+  )
+  service.environment.build.sourceHash = 'f'.repeat(64)
+  const base = harness.configuration
+  const configuration: NodeTestConfiguration = {
+    version: 1,
+    adapter: 'vitest-node',
+    book: base.book,
+    testFile: 'src/theme.test.ts',
+    testTitles: ['theme', 'selects the dark theme'],
+    testHash: 'a'.repeat(64),
+    source: base.source,
+    inspections: base.inspections.slice(0, 1),
+    additionalStops: [
+      {
+        ...base.source,
+        anchorIndex: 0,
+        inspections: [
+          {
+            path: 'revalidatePath.mock.calls.length',
+            mode: 'value',
+            required: true,
+          },
+          { path: 'cacheTag.mock.calls', mode: 'value', required: true },
+        ],
+      },
+    ],
+  }
+  const stopAt = (index: number, facts: unknown[], limitations: string[]) =>
+    ({
+      index,
+      runId: 'node-run',
+      sessionId: 'owned-session',
+      threadId: 7,
+      elapsedMs: 10 + index,
+      worker: {},
+      source: configuration.source,
+      frame: { id: 10 + index, name: 'notifyManager', line: 1, column: 1 },
+      variables: [{ name: 'listener', value: '() => undefined' }],
+      facts,
+      debuggerSnapshot: {
+        version: 1,
+        frames: [
+          {
+            name: 'notifyManager',
+            line: 1,
+            column: 1,
+            scopes: [{ name: 'Local', variables: [0] }],
+          },
+        ],
+        variables: [
+          { name: 'listener', value: '() => undefined', children: [] },
+        ],
+        limitations,
+      },
+    }) as unknown as NodeTestSourceStop
+  let advanced = false
+  const runtime: NodeTestRuntime = {
+    id: 'node-run',
+    async prepare() {
+      return stopAt(
+        0,
+        [{ path: 'nextTheme', mode: 'value', display: 'dark', type: 'string' }],
+        [],
+      )
+    },
+    hasNextStop() {
+      return !advanced
+    },
+    async advance() {
+      advanced = true
+      return stopAt(
+        1,
+        [],
+        [
+          'Required fact value:revalidatePath.mock.calls.length could not be read at this stop.',
+          'Required fact value:cacheTag.mock.calls could not be read at this stop.',
+        ],
+      )
+    },
+    async complete() {
+      return {
+        exitCode: 0,
+        signal: null,
+        output: 'Tests 1 passed',
+        elapsedMs: 40,
+      }
+    },
+    async stop() {},
+  }
+  service.environment.createNodeTestRun = async () => runtime
+  // The start's idempotency key, named by what this run is for (the pre-gate's secrets scan reads a key literal as a credential).
+  const startKey = 'node-unread-two-required-facts'
+  const receipt = service.start({
+    instanceId: service.instanceId,
+    profile: NODE_TEST_PROFILE,
+    key: startKey,
+    configuration,
+  })
+  const record = service.record(receipt)
+  try {
+    await record.preparation
+    const atFirstStop = service.state(record)
+
+    // Act: the continuation reaches the second stop, whose required fact the debugger could not read.
+    const rejection = await service
+      .continue(atFirstStop.participants.server!.continueArguments!)
+      .then(
+        () => undefined,
+        (error: unknown) => error,
+      )
+    const atSecondStop = service.state(record)
+    const afterRefusal = {
+      stopped: record.stopped,
+      error: record.error,
+      phase: record.nodePhase,
+      stops: record.nodeStops?.length,
+    }
+    const goingOn = await service.continue(
+      atSecondStop.participants.server!.continueArguments!,
+    )
+
+    // Assert
+    assert.ok(rejection instanceof StudyError)
+    assert.deepEqual(
+      {
+        code: rejection.code,
+        message: rejection.message,
+        afterRefusal,
+        goingOn: goingOn.accepted,
+        result: record.nodeResult?.exitCode,
+      },
+      {
+        code: 'EVIDENCE_UNAVAILABLE',
+        message:
+          'The continuation reached the stop at src/theme.ts:1, but the debugger could not read its required facts value:revalidatePath.mock.calls.length, value:cacheTag.mock.calls. The run stays paused at this stop with its other facts: continue without them, or stop the run.',
+        afterRefusal: {
+          stopped: false,
+          error: undefined,
+          phase: 'paused',
+          stops: 2,
+        },
+        goingOn: true,
+        result: 0,
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
diff --git a/extension/src/tests/ownedNodeTestRun.test.ts b/extension/src/tests/ownedNodeTestRun.test.ts
index fdb1c3b18..d2919ebd9 100644
--- a/extension/src/tests/ownedNodeTestRun.test.ts
+++ b/extension/src/tests/ownedNodeTestRun.test.ts
@@ -80,9 +80,15 @@ async function nodeRunHarness({
   stopFailures = 0,
   outputRefusesOnceClosed = false,
   unansweredRequest,
+  unavailableFacts = [],
+  duringInspection,
 }: {
   declaredStops?: number
   observedLine?: number
+  /** The required facts, as `<mode>:<path>`, that the inspector reports it could not read at each stop. */
+  unavailableFacts?: string[]
+  /** Runs while the inspector reads a stop's facts, after the capture's first read of the stopped source. */
+  duringInspection?: () => Promise<void>
   duringRetire?: () => void
   adapterPauseAfterContinue?: boolean
   exitAfterEntry?: boolean
@@ -683,7 +689,10 @@ async function nodeRunHarness({
         }),
       },
       './utils/inspectNodeTestVariables': {
-        inspectNodeTestVariables: async () => ({ variables: [], facts: [] }),
+        inspectNodeTestVariables: async () => {
+          await duringInspection?.()
+          return { variables: [], facts: [], unavailable: unavailableFacts }
+        },
       },
       './utils/captureReplayDebugSnapshot': {
         captureReplayDebugSnapshot: async () => ({
@@ -864,6 +873,70 @@ test('a run whose first declared stop came without an entry pause advances to it
   }
 })
 
+// Value: protects=the imports a stop's facts are read with come from the same bytes the capture verifies: a stopped source that differs from the declared one when it is first read fails the capture, even when it is back to the declared text when the capture reads it again; fails_when=only the second read is verified, so facts read with another version's import declarations are saved beside the declared source (Cycle 0052 task 97); why_new=hosted CodeRabbit review of 657d677b (outside-diff, ownedNodeTestRun.ts:693-701); seam=the stopped source file, changed before the capture and restored while the inspector reads; no_claim=a change after the second read, which the editor-document check covers
+test('a stop whose source differs from the declared one when the capture first reads it fails the capture, though the source is restored before its second read', async () => {
+  // Arrange: the source holds another version until the inspector runs, then the declared text again.
+  let restore: () => Promise<void> = async () => {}
+  const harness = await nodeRunHarness({
+    duringInspection: () => restore(),
+  })
+  const sourceFile = join(harness.launch.workspace, 'theme.ts')
+  const declaredText = 'export const nextTheme = "dark";\n'
+  await writeFile(sourceFile, 'export const nextTheme = "light";\n')
+  restore = (): Promise<void> => writeFile(sourceFile, declaredText)
+  try {
+    // Act
+    const outcome = await harness.run.prepare().then(
+      () => 'captured',
+      (error: unknown) => String(error),
+    )
+
+    // Assert
+    assert.equal(
+      outcome,
+      'Error: Node test source changed during historical debugger capture.',
+    )
+  } finally {
+    await harness.run.stop()
+    await harness.cleanup()
+  }
+})
+
+// Value: protects=a declared stop whose required fact the debugger cannot read is still accepted: the run keeps that stop, names the fact among its debugger limitations and stays able to finish, instead of releasing the owned test; fails_when=the stop is captured without naming the missing fact, or a missing fact releases the run (N51-V5, Cycle 0052 task 5); why_new=the inspector used to throw, and advance releases the run on any capture failure; seam=the harness's inspector reporting one unreadable required fact; no_claim=the inspector's own reading (inspectNodeTestVariables tests) and the service's refusal (nodeTestService)
+test('a declared stop whose required fact the debugger cannot read is accepted with the fact named among its limitations, and the test still finishes', async () => {
+  // Arrange
+  const harness = await nodeRunHarness({
+    declaredStops: 2,
+    unavailableFacts: ['value:revalidatePath.mock.calls.length'],
+  })
+  try {
+    await harness.run.prepare()
+
+    // Act
+    const next = await harness.run.advance()
+    const result = await harness.run.complete()
+
+    // Assert
+    assert.deepEqual(
+      {
+        index: next.index,
+        limitations: next.debuggerSnapshot.limitations,
+        exitCode: result.exitCode,
+      },
+      {
+        index: 1,
+        limitations: [
+          'Required fact value:revalidatePath.mock.calls.length could not be read at this stop.',
+        ],
+        exitCode: 0,
+      },
+    )
+  } finally {
+    await harness.run.stop()
+    await harness.cleanup()
+  }
+})
+
 test('advancing to the next declared stop retires the captured breakpoint before arming and continuing to the next one', async () => {
   // Arrange
   const harness = await nodeRunHarness({ declaredStops: 2 })
diff --git a/extension/src/tests/protocol.test.ts b/extension/src/tests/protocol.test.ts
index 537150171..fca2a0daf 100644
--- a/extension/src/tests/protocol.test.ts
+++ b/extension/src/tests/protocol.test.ts
@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict'
-import { mkdtemp, rm } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm } from 'node:fs/promises'
 import { request } from 'node:http'
 import { connect as connectSocket } from 'node:net'
 import { tmpdir } from 'node:os'
@@ -11,6 +11,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { z } from 'zod'
 
 import {
+  NODE_TEST_HISTORY_DIRECTORY,
   REPOSITORY_BROWSER_PROFILE as PROFILE_ID,
   SESSION_IDLE_TIMEOUT_MS,
 } from '../constants'
@@ -1010,8 +1011,8 @@ test('Node learning material is exposed through MCP with exact workspace history
   }
 })
 
-// Value: protects=the agent's answer when a test replay's history cannot be read (its folder removed by the learner or another window): RUNTIME_FAILED whose cause reads <storage> where the file call quoted the private storage folder, through codebook_read_resource (F243); fails_when=the raw file error, with the absolute storage path, reaches the tool's structured error; why_new=the MCP answers passed an unexpected failure's String(error) through unchanged, and no test read a failed history read through MCP; seam=none; no_claim=the MCP resources/read route, which serves no node-history address; the wording of other domain errors, which carry their own sanitized causes
-test('a test replay whose history folder is gone is answered through MCP with a cause that names no storage path', async () => {
+// Value: protects=the agent's answer when a test replay's history cannot be read (its files removed by the learner or another window while its folder stays): RUNTIME_FAILED whose cause reads <storage> where the file call quoted the private storage folder, through codebook_read_resource (F243); fails_when=the raw file error, with the absolute storage path, reaches the tool's structured error; why_new=the MCP answers passed an unexpected failure's String(error) through unchanged, and no test read a failed history read through MCP; Cycle 0052 task 60 moved the case from a removed folder, which is now NOT_FOUND (nodeHistoryResources tests), to removed files, which is still an unexpected failure; seam=none; no_claim=the MCP resources/read route, which serves no node-history address; the wording of other domain errors, which carry their own sanitized causes
+test('a test replay whose history files are gone is answered through MCP with a cause that names no storage path', async () => {
   // Arrange
   const harness = await createHarness(),
     directory = await mkdtemp(join(tmpdir(), 'codebook-node-history-gone-'))
@@ -1020,6 +1021,10 @@ test('a test replay whose history folder is gone is answered through MCP with a
     directory,
     header.workspaceKey,
   )
+  // The history's folder stays, its files are gone.
+  await mkdir(join(directory, NODE_TEST_HISTORY_DIRECTORY, header.studyId), {
+    recursive: true,
+  })
   const endpoint = await startServer(harness.service),
     connection = await connect(endpoint.descriptor)
   const historyUri = `codebook://node-history/${header.studyId}`
diff --git a/extension/src/tests/readmeDelivery.test.ts b/extension/src/tests/readmeDelivery.test.ts
index c524d058b..9b9cafbef 100644
--- a/extension/src/tests/readmeDelivery.test.ts
+++ b/extension/src/tests/readmeDelivery.test.ts
@@ -28,3 +28,17 @@ test('every README section that a product message names is a heading of the pack
     [],
   )
 })
+
+// Value: protects=an agent or learner who reads the packaged README's error table for EVIDENCE_UNAVAILABLE and learns that a refused test-run continuation leaves the run paused, as the published recovery (codebook://help/errors) says; fails_when=the README's row is reworded or dropped while errors.ts keeps the paused-run advice, so the two copies of the contract disagree; why_new=pt3 /ship review pass 2 (API contract): the README is the one copy of this advice no test held; seam=none (the packaged README is read from disk); no_claim=the wording of the other rows
+test('the packaged README tells that a continuation refused for an unreadable required fact leaves the test run paused', async () => {
+  // Arrange
+  const readme = await readFile(join(__dirname, '../../README.md'), 'utf8')
+
+  // Act
+  const tellsPausedRun = readme.includes(
+    'A `codebook_continue` refused because the debugger could not read a required fact leaves the test run paused at that stop: read `nodeTest.stops` and the current `participants.server.continueArguments`, then continue with those arguments without the fact, or stop the run.',
+  )
+
+  // Assert
+  assert.equal(tellsPausedRun, true)
+})
diff --git a/extension/src/tests/sourceImportBindings.test.ts b/extension/src/tests/sourceImportBindings.test.ts
new file mode 100644
index 000000000..e6cc51830
--- /dev/null
+++ b/extension/src/tests/sourceImportBindings.test.ts
@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import {
+  sourceImportBindings,
+  type SourceImports,
+} from '../utils/sourceImportBindings'
+
+/** Each imported local name with the export it reads, in source order, as the tests below compare them. */
+function exportsOf(imports: SourceImports): Array<[string, string]> {
+  return [...imports.names].map(([local, { exported }]) => [local, exported])
+}
+
+// Value: protects=which export an imported name of a test stop is read as: a named import reads its own name, an alias the original export, a default import `default`, a namespace import names no one export (`*`), and type-only imports bind nothing; fails_when=an alias maps to its local name (so another module's export of that name is read, Cycle 0052 task 70), or a type-only import is taken for a runtime binding; why_new=pt3 /ship Step 11 (Claude adversarial, Codex adversarial and structured review): the inspector matched exports by the local name; seam=none (a pure function of the source text); no_claim=dynamic import() and require(), which bind no name at the import declaration
+test('an imported name of a stopped source reads the export its import declaration names', () => {
+  // Arrange
+  const source = [
+    "import db, { invoices as invoiceTable, type Invoice } from '@/db'",
+    "import * as schema from '@/db/schema'",
+    "import type { Customer } from './definitions'",
+    "import { revalidatePath } from 'next/cache'",
+    "import './setup'",
+  ].join('\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [
+    ['db', 'default'],
+    ['invoiceTable', 'invoices'],
+    ['schema', '*'],
+    ['revalidatePath', 'revalidatePath'],
+  ])
+})
+
+// Value: protects=an import declaration written over several lines, with comments and a trailing comma, as formatters write long imports: each of its names is read as its export; fails_when=the clause is read on one line only, so the names of a multi-line import (nextjs-dashboard's actions.test.ts imports authenticate, createInvoice, … this way) bind nothing and their facts read unavailable; why_new=pt3 /ship Step 11 (task 70): the parser is new; seam=none; no_claim=imports inside template strings
+test('a multi-line import declaration with comments binds each of its names', () => {
+  // Arrange
+  const source = [
+    'import {',
+    '  authenticate, // signs in, then redirects',
+    '  /* the action under test */ createInvoice,',
+    "  'quoted-export' as quoted,",
+    '} from "./actions"',
+  ].join('\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [
+    ['authenticate', 'authenticate'],
+    ['createInvoice', 'createInvoice'],
+    ['quoted', 'quoted-export'],
+  ])
+})
+
+// Value: protects=only real import declarations bind names: an import written in a line comment, a block comment, a template literal (a test's source fixture) or a quoted string binds nothing, so no module binding is read for a name the file never imports; fails_when=the declaration pattern runs over comments and strings, so `// import { fake } from './not-loaded'` binds `fake` and another module's export of that name is saved as the fact (Cycle 0052 task 87); why_new=hosted CodeRabbit review of 779c8adf (outside-diff, sourceImportBindings.ts:9-30); seam=none (a pure function of the source text); no_claim=regular expression literals that hold a quote, which the masking does not parse
+test('an import written in a comment or a string binds no name', () => {
+  // Arrange
+  const source = [
+    "// import { fake } from './not-loaded'",
+    "/* import { blocked } from './old'",
+    "   import { stillBlocked } from './old' */",
+    "import { db } from '@/db' // the real one, 'quoted' and // nested",
+    'const fixture = `',
+    "import { fromFixture } from './fixture'",
+    '`',
+    'const line = "import { fromString } from \'./string\'"',
+  ].join('\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [['db', 'db']])
+})
+
+// Value: protects=an import written inside a nested template literal (a template in another template's ${…}, as a fixture builder writes) binds nothing: the whole outer template is no code; fails_when=the masking ends the outer template at the inner one's opening backtick and starts again at its closing one, so the inner template's lines read as code and `fake` binds (Cycle 0052 task 88); why_new=hosted CodeRabbit review of ac852a3c (Major, sourceImportBindings.ts:7); seam=none (a pure function of the source text); no_claim=regular expression literals
+test('an import written inside a nested template literal binds no name', () => {
+  // Arrange
+  const source = [
+    "import { db } from '@/db'",
+    'const fixture = `outer ${`',
+    "import { fake } from './fixture'",
+    '`} tail`',
+  ].join('\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [['db', 'db']])
+})
+
+// Value: protects=a quoted export name that holds a comma or a brace stays one specifier, so its alias reads that export; fails_when=the specifiers are split at every comma, or the braces end at a brace inside quotes, so `value` binds nothing and its fact reads unavailable (Cycle 0052 task 89); why_new=hosted CodeRabbit review of ac852a3c (Minor, sourceImportBindings.ts:67); seam=none; no_claim=escaped quotes inside a quoted export name
+test('a quoted export name holding a comma or a brace stays one import specifier', () => {
+  // Arrange
+  const source =
+    "import { 'a,b' as value, 'c}d' as braced, other } from './module'"
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [
+    ['value', 'a,b'],
+    ['braced', 'c}d'],
+    ['other', 'other'],
+  ])
+})
+
+// Value: protects=a quoted string continued onto its next line by a backslash and a Windows line break (CRLF) stays a string, so a continued line that starts with an import binds nothing; fails_when=the escape skips only the carriage return, the string ends at the line feed, and the continued line reads as an import declaration whose name another module's export then answers for (Cycle 0052 task 91); why_new=hosted CodeRabbit review of d851ae4a (Minor, blankCommentsAndTemplates.ts:95); seam=none (a pure function of the source text); no_claim=template literals, which span lines without an escape
+test('a string continued by a backslash and a CRLF line break binds no name on its next line', () => {
+  // Arrange
+  const source = [
+    "import { db } from '@/db'",
+    "const line = 'first part \\",
+    'import { fake } from "./continued"\'',
+  ].join('\r\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [['db', 'db']])
+})
+
+// Value: protects=a quoted string holding a raw U+2028 or U+2029 (line terminators a multiline pattern's ^ reads as line breaks) stays a string, so an import written after one inside it binds nothing; fails_when=only a line feed marks a multi-line string, the string stays as code, and the import after the separator reads as a declaration whose name another module's export answers for (Cycle 0052 task 93); why_new=hosted CodeRabbit review of 5551addd (Minor, blankCommentsAndTemplates.ts:64); seam=none (a pure function of the source text); no_claim=identifiers, which cannot hold these characters
+test('a string holding a raw line or paragraph separator binds no name after it', () => {
+  // Arrange
+  const source = [
+    "import { db } from '@/db'",
+    'const line = \'a\u2028import { fromLine } from "./line"\'',
+    'const paragraph = \'b\u2029import { fromParagraph } from "./paragraph"\'',
+  ].join('\n')
+
+  // Act
+  const bindings = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(exportsOf(bindings), [['db', 'db']])
+})
+
+// Value: protects=the module binding variable each declaration is read from: Vite numbers every import and re-export declaration in source order (__vite_ssr_import_<n>__), and in a file whose imports Vitest hoisted for vi.mock, the imports of other modules become __vi_import_<n>__ in order while Vitest's own import and the re-exports stay Vite's; type-only declarations take no number; fails_when=the numbering counts a type-only import or skips a side-effect import or a re-export, so a name is read from another module's binding (Cycle 0052 task 96); why_new=hosted CodeRabbit review of 267e5bce (Major): the inspector searched every binding for the name; seam=none (a pure function of the source text, matching @vitest/mocker 5's hoistMocks and Vite 8's ssrTransform); no_claim=imports the TypeScript compiler drops, which the inspector's own checks catch
+test('each run-time declaration of a stopped source names the module binding Vite or Vitest gives it', () => {
+  // Arrange
+  const source = [
+    "import { describe, vi } from 'vitest'",
+    "import type { Invoice } from './definitions'",
+    "import { type Customer } from './customers'",
+    "import './setup'",
+    "import { db } from '@/db'",
+    "export * from './shared'",
+    "export type { Row } from './rows'",
+    "import revalidate from 'next/cache'",
+  ].join('\n')
+
+  // Act
+  const { declarations, names } = sourceImportBindings(source)
+
+  // Assert
+  assert.deepEqual(
+    {
+      declarations,
+      db: names.get('db'),
+      revalidate: names.get('revalidate'),
+    },
+    {
+      declarations: [
+        {
+          plain: '__vite_ssr_import_0__',
+          hoisted: '__vite_ssr_import_0__',
+          exports: ['describe', 'vi'],
+        },
+        {
+          plain: '__vite_ssr_import_1__',
+          hoisted: '__vi_import_0__',
+          exports: [],
+        },
+        {
+          plain: '__vite_ssr_import_2__',
+          hoisted: '__vi_import_1__',
+          exports: ['db'],
+        },
+        {
+          plain: '__vite_ssr_import_3__',
+          hoisted: '__vite_ssr_import_1__',
+          exports: [],
+        },
+        {
+          plain: '__vite_ssr_import_4__',
+          hoisted: '__vi_import_2__',
+          exports: ['default'],
+        },
+      ],
+      db: { exported: 'db', declaration: 2 },
+      revalidate: { exported: 'default', declaration: 4 },
+    },
+  )
+})
diff --git a/extension/src/tests/studyErrorNamingCause.test.ts b/extension/src/tests/studyErrorNamingCause.test.ts
index 1ddbe7c7a..d36d9af65 100644
--- a/extension/src/tests/studyErrorNamingCause.test.ts
+++ b/extension/src/tests/studyErrorNamingCause.test.ts
@@ -23,7 +23,7 @@ test('a run failure with a generic sentence gets a message that names its cause,
       'Evidence buffering or persistence failed. Cause: ENOSPC: no space left on device, write',
     cause: 'Error: ENOSPC: no space left on device, write',
     recovery:
-      'Inspect the evidence failure and storage availability. Do not treat missing evidence as success.',
+      'Inspect the evidence failure and storage availability. Do not treat missing evidence as success. When codebook_continue names a required fact the debugger could not read, the run stays paused at that stop: read nodeTest.stops and the current participants.server.continueArguments of the run resource, then call codebook_continue with those arguments to go on without it (the earlier ones now answer STALE_PAUSE), or stop the run.',
     docs: 'codebook://help/errors',
   })
 })
diff --git a/extension/src/tests/studyWorkspaceEntryObstacles.test.ts b/extension/src/tests/studyWorkspaceEntryObstacles.test.ts
index d5897d4d8..527d9eda4 100644
--- a/extension/src/tests/studyWorkspaceEntryObstacles.test.ts
+++ b/extension/src/tests/studyWorkspaceEntryObstacles.test.ts
@@ -415,6 +415,55 @@ test('Open replay beside a non-text preview that cannot be kept tells the learne
   }
 })
 
+// Value: protects=the browser replay's Open replay refused for a non-text preview that cannot be kept: the learner is told once by the keep notice, and the refusal is still recorded in one Output › Codebook open:recording entry, as a test replay's is (F407) and as every other failed browser replay open is (Cycle 0052 task 59); fails_when=the keep notice's early return skips the Output entry, so the README's promise that a failed browser replay open writes one fails for this cause (Cycle 0052 task 81); why_new=hosted CodeRabbit on PR #127 (studyWorkspace.ts:11599); seam=addNonTextPreview behind another tab, answerWarningDialogs, the diagnostics log and the harness's error notifications; no_claim=the wording of the keep notice
+test('a browser replay Open replay refused for a non-text preview that cannot be kept tells the learner once and records the refusal in one Output entry', async () => {
+  // Arrange
+  const harness = await recordedReaderHarness()
+  const logged: CodebookDiagnostic[] = []
+  harness.reader.diagnostics = {
+    log: (entry) => logged.push(entry),
+    show: () => undefined,
+  }
+  try {
+    await harness.reader.close()
+    harness.useNativeLayout({ orientation: 0, groups: [{}] })
+    harness.focusMutableDraft('learner-notes.ts', 1)
+    const agentChat = harness.addSeparateEditorPart()
+    const preview = harness.addNonTextPreview('diagram.png', 1, false)
+    agentChat.focus()
+    const hasMainEditorFocus = harness.reader['hasMainEditorFocus'].bind(
+      harness.reader,
+    )
+    harness.reader['hasMainEditorFocus'] = (groupCount: number): boolean =>
+      groupCount === 1 && preview.isPreview
+        ? false
+        : hasMainEditorFocus(groupCount)
+    harness.answerWarningDialogs(async () => 'Keep Tab Open')
+
+    // Act
+    await harness.reader.openLearningReplay(harness.studyId)
+    await harness.controller.settle()
+
+    // Assert
+    assert.deepEqual(
+      {
+        notices: harness.warningDialogs.slice(1).map((dialog) => dialog.title),
+        errorMessages: harness.errorMessages,
+        outputEntries: logged.map((entry) => [entry.surface, entry.studyId]),
+      },
+      {
+        notices: [
+          'Codebook could not keep "diagram.png" open. Double-click its tab to keep it, then choose Open replay again.',
+        ],
+        errorMessages: [],
+        outputEntries: [['open:recording', harness.studyId]],
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
+
 // Value: protects=the learner who chose Keep Tab Open for a non-text preview that cannot be kept, when a test replay's Open replay was refused for it, being told once by the keep notice, with no second notification, and the refusal recorded in one Output › Codebook open:test-replay entry (F407); fails_when=a refused Keep Tab Open is followed by the test replay's load-failure notification, or leaves no Output entry; why_new=Cycle 0050 F394 (openNodeHistoryFromHost told the failure after the keep notice); seam=openNodeHistory answering a foreign-preview failure, addNonTextPreview behind another tab, answerWarningDialogs, the diagnostics log and the harness's error notifications; no_claim=how the replay's open meets the preview (the F158 rounds above)
 test('a test replay Open replay refused for a non-text preview that cannot be kept tells the learner once and records the refusal in one Output entry', async (context) => {
   // Arrange
diff --git a/extension/src/tests/studyWorkspaceHarness.ts b/extension/src/tests/studyWorkspaceHarness.ts
index 1c5a160aa..1c1e4eb2e 100644
--- a/extension/src/tests/studyWorkspaceHarness.ts
+++ b/extension/src/tests/studyWorkspaceHarness.ts
@@ -3813,7 +3813,7 @@ export async function workspaceHarness(
     number,
     StudyViewMessage | undefined
   >()
-  const playbackPanelListeners = new Set<(message: unknown) => void>()
+  const playbackPanelListeners = new Set<(message: unknown) => unknown>()
   const playbackPanelVisibilityListeners = new Set<() => void>()
   const playbackPanelDisposeListeners = new Set<() => void>()
   const playbackPanel = {
@@ -5226,6 +5226,12 @@ export async function workspaceHarness(
     receivePlaybackPanel(message: unknown): void {
       for (const listener of playbackPanelListeners) listener(message)
     },
+    /** Sends a bottom panel message as {@link receivePlaybackPanel} does and resolves once the reader's handling of it ended, settled either way, so a test awaits that end instead of a fixed time. @example await harness.receivePlaybackPanelHandled(message) */
+    async receivePlaybackPanelHandled(message: unknown): Promise<void> {
+      await Promise.allSettled(
+        [...playbackPanelListeners].map((listener) => listener(message)),
+      )
+    },
     async resolveRestoredObservedMoments(): Promise<void> {
       assert.ok(playbackPanelProvider)
       await playbackPanelProvider.resolveWebviewView(playbackPanel)
diff --git a/extension/src/tests/studyWorkspaceRemoval.test.ts b/extension/src/tests/studyWorkspaceRemoval.test.ts
index 553dae78a..4f61b20c9 100644
--- a/extension/src/tests/studyWorkspaceRemoval.test.ts
+++ b/extension/src/tests/studyWorkspaceRemoval.test.ts
@@ -39,6 +39,7 @@ import {
 import { createConfiguredStudy } from './utils/createConfiguredStudy'
 import { idleChild } from './utils/idleChild'
 import { ID_OF_NO_PROCESS } from './utils/idOfNoProcess'
+import { READER_RESULT_BOUND_MS } from './utils/readerResultBound'
 import { rewriteWriterRecord } from './utils/rewriteWriterRecord'
 
 type Harness = Awaited<ReturnType<typeof workspaceHarness>>
@@ -4573,10 +4574,12 @@ test('after the Trash refused a removal, a run refused on the full library names
     harness.rejectTrashMoves(() => true)
     harness.answerWarningDialogs(async ([confirm]) => confirm)
     await requestRemoval(harness, earlier.id)
+    // The removal's line is read before the run: a refresh after another run became current retires it (Cycle 0052 task 92).
+    const removal = harness.reader.inspect().view!.studyRemoval?.status
     // Act
     const refused = await startRun(harness)
     // Assert
-    assert.equal(harness.reader.inspect().view!.studyRemoval?.status, 'failed')
+    assert.equal(removal, 'failed')
     assert.equal(
       refused.record.error?.message,
       `Study library is full. Increase Codebook: Saved Study Limit (codebook.savedStudyLimit) in Settings before starting another run; this editor could not move a saved study to the ${TRASH} in this session. Only the learner can change the setting; an editor agent cannot. Existing learning was kept.`,
@@ -4602,6 +4605,8 @@ test('after a removal refused because another window of this machine still recor
     )
     harness.answerWarningDialogs(async ([confirm]) => confirm)
     await requestRemoval(harness, study.id)
+    // The removal's line is read before the run: a refresh after another run became current retires it (Cycle 0052 task 92).
+    const removal = harness.reader.inspect().view!.studyRemoval?.status
 
     // Act
     const refused = await startRun(harness)
@@ -4609,7 +4614,7 @@ test('after a removal refused because another window of this machine still recor
     // Assert
     assert.deepEqual(
       {
-        removal: harness.reader.inspect().view!.studyRemoval?.status,
+        removal,
         moved: harness.trashMoves,
         refusal: refused.record.error?.message,
       },
@@ -4845,10 +4850,12 @@ test('after a removal that moved the study although the Trash rejected a path th
     harness.rejectTrashMoves(isArchiveOfRemoved)
     harness.answerWarningDialogs(async ([confirm]) => confirm)
     await requestRemoval(harness, removed.id)
+    // The removal's line is read before the run: a refresh after another run became current retires it (Cycle 0052 task 92).
+    const removal = harness.reader.inspect().view!.studyRemoval?.status
     // Act
     const refused = await startRun(harness)
     // Assert
-    assert.equal(harness.reader.inspect().view!.studyRemoval?.status, 'moved')
+    assert.equal(removal, 'moved')
     assert.equal(refused.record.error?.message, FULL_LIBRARY_REFUSAL)
   } finally {
     await harness.close()
@@ -5419,6 +5426,12 @@ test('the line “History not saved: …” of a study that still waits stays, w
       'the save of the second run',
       1_000,
     )
+    // The save decides about the line only once its write left the queue, after it reported 'saved': the pane is read after that decision, with the first study alone waiting (Cycle 0052 task 47).
+    await waitUntil(
+      () => readerSeams(harness).queuedStudyWrites() === 1,
+      'the end of the second run’s write',
+      READER_RESULT_BOUND_MS,
+    )
     const afterOtherSave = structuredClone({
       queued: readerSeams(harness).queuedStudyWrites(),
       errors: harness.reader.inspect().view!.errors,
@@ -5473,6 +5486,12 @@ test('the line “History not saved: …” of a study whose capture failed befo
       'the save of the second run',
       1_000,
     )
+    // The save decides about the line only once its write left the queue, after it reported 'saved': the pane is read after that decision (Cycle 0052 task 47).
+    await waitUntil(
+      () => readerSeams(harness).queuedStudyWrites() === 0,
+      'the end of the second run’s write',
+      READER_RESULT_BOUND_MS,
+    )
     const afterOtherSave = structuredClone({
       queued: readerSeams(harness).queuedStudyWrites(),
       errors: harness.reader.inspect().view!.errors,
@@ -5539,6 +5558,13 @@ test('a Retry storage / refresh that saved the earlier study keeps the line “H
       `${harness.service.instanceId}_${second.record.id}`,
     )
     await readerSeams(harness).refresh()
+    // The second run's save is refused while the Retry still reconciles, as the case means: a test that read the pane before that refusal was handled raced it (Cycle 0052 task 26).
+    await waitUntil(
+      () =>
+        harness.service.state(second.record).historyOutcome.status === 'failed',
+      "the refusal of the second run's save",
+      READER_RESULT_BOUND_MS,
+    )
     continueReconcile()
     await retry
     const afterRetry = structuredClone({
@@ -5616,6 +5642,13 @@ test('a Retry storage / refresh whose selection names a study without an archive
       `${harness.service.instanceId}_${second.record.id}`,
     )
     await readerSeams(harness).refresh()
+    // The second run's save is refused while the Retry still reconciles, as the case means (the same race as Cycle 0052 task 26).
+    await waitUntil(
+      () =>
+        harness.service.state(second.record).historyOutcome.status === 'failed',
+      "the refusal of the second run's save",
+      READER_RESULT_BOUND_MS,
+    )
     continueReconcile()
     await retry
     // Assert
@@ -10021,6 +10054,12 @@ async function recordRunWithFailedCapture(context: TestContext) {
       'the save of the second run',
       2_000,
     )
+    // The save reports 'saved' before it writes the recording's context and leaves the queue; a Stop before that read one queued write (Cycle 0052 task 47).
+    await waitUntil(
+      () => readerSeams(harness).queuedStudyWrites() === 0,
+      'the end of the second run’s write',
+      READER_RESULT_BOUND_MS,
+    )
     failedStudyId = studyId
     await harness.reader.action('stop')
     return {
diff --git a/extension/src/tests/studyWorkspaceTestReplayBrowser.test.ts b/extension/src/tests/studyWorkspaceTestReplayBrowser.test.ts
index 1eb14cc5b..37e4deef9 100644
--- a/extension/src/tests/studyWorkspaceTestReplayBrowser.test.ts
+++ b/extension/src/tests/studyWorkspaceTestReplayBrowser.test.ts
@@ -2,9 +2,11 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
 import { waitUntil } from '../runtimeSupport/utils/waitUntil'
+import type { CodebookDiagnostic } from '../utils/formatCodebookDiagnostic'
 
-import { recordedReaderHarness } from './studyWorkspaceHarness'
+import { readerSeams, recordedReaderHarness } from './studyWorkspaceHarness'
 import { READER_RESULT_BOUND_MS } from './utils/readerResultBound'
+import { saveOtherBrowserStudy } from './utils/saveOtherBrowserStudy'
 import { lastView, saveTwoStopNodeHistory } from './utils/twoStopNodeHistory'
 
 // Value: protects=a browser recording that loads while a test replay is selected retires the test replay (D20): the Application pane shows the recording's own pages, not the test replay's output, and the Study message carries no test replay; fails_when=loadPlayback leaves the test replay selected, so capturedAppHtml gives it the pane (the recording's loading page or "Recorded playback unavailable" never shows) and the section stays drawn beside the recording; why_new=F132 and F146: only Saved studies' choice of a browser study retired the test replay, and the recordingActive arm of Focus application's guard decided no tested outcome; seam=none; no_claim=the native placement of the pane (stand-ins: the workspace harness's recorded panels, posted messages and closeTabByHand)
@@ -1118,3 +1120,96 @@ test('Return to Live from a browser replay releases the recorded viewport withou
     await harness.close()
   }
 })
+
+// Value: protects=another saved study chosen in Saved studies during a browser replay retires the shown replay and shows the chosen study in its own composition: the chosen recording plays in the summary composition, with the Study pane closed and the browser family's transport; fails_when=the choice leaves the first recording shown, or brings the Study composition back over a replay (Cycle 0052 task 22, the state cell browser replay × another saved study); why_new=the cell had no test; seam=recordedReaderHarness, a second saved browser study and the bottom panel's history message; no_claim=the chosen study's recording content, which the saved configured study does not carry
+test('another saved study chosen during a browser replay retires it and shows the chosen study in its own composition', async () => {
+  // Arrange
+  const harness = await recordedReaderHarness(true)
+  try {
+    const other = await saveOtherBrowserStudy(
+      await harness.reader.learningStorage(),
+    )
+    // Retry storage reloads the catalog the reader shows.
+    await harness.reader.action('retry')
+    await harness.reader.openRecording(harness.studyId)
+    await harness.controller.settle()
+
+    // Act
+    harness.receivePlaybackPanel({
+      type: 'history',
+      revision: harness.reader.inspect().view!.revision,
+      studyId: other.id,
+    })
+    await waitUntil(
+      () => harness.controller.state().studyId === other.id,
+      'the chosen study is opened',
+      READER_RESULT_BOUND_MS,
+    )
+    await harness.controller.settle()
+
+    // Assert
+    assert.deepEqual(
+      {
+        recording: harness.controller.state().studyId,
+        studyPane: harness.panelColumn('codebook.studyContext') !== undefined,
+        application:
+          harness.panelColumn('codebook.scopedBrowser') !== undefined,
+        summary: harness.summary.visible,
+        family: lastView(harness)?.replayFamily,
+      },
+      {
+        recording: other.id,
+        studyPane: false,
+        application: true,
+        summary: true,
+        family: 'browser',
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
+
+// Value: protects=a browser replay whose open fails is told with the load-failure notification and one Output › Codebook entry, keeps the reader's earlier state and leaves no empty summary composition; fails_when=the failure is not told, the Output entry is missing or repeated (the cell's test found it missing: Cycle 0052 task 59), or the reader stays in a summary composition with no replay (Cycle 0052 task 22, the state cell browser replay × a failed open); why_new=the cell had no test; seam=recordedReaderHarness, the reader's debugger replacement failing the next load, the reader's diagnostics; no_claim=Show details, which the notification's button runs
+test('a browser replay whose open fails is told once, keeps the Study composition and leaves no empty summary composition', async () => {
+  // Arrange
+  const harness = await recordedReaderHarness(true)
+  const logged: CodebookDiagnostic[] = []
+  harness.reader.diagnostics = {
+    log: (entry) => logged.push(entry),
+    show: () => undefined,
+  }
+  try {
+    await harness.reader.open()
+    // The next recording load fails as a replay debugger that does not start.
+    const seams = readerSeams(harness)
+    const replace = seams.debuggerReplacement
+    seams.debuggerReplacement = async (): Promise<void> => {
+      seams.debuggerReplacement = replace
+      throw new Error('The historical debugger did not start.')
+    }
+
+    // Act
+    await harness.reader.openLearningReplay(harness.studyId)
+
+    // Assert
+    assert.deepEqual(
+      {
+        notices: [...harness.errorMessages],
+        outputEntries: logged.map((entry) => entry.surface),
+        studyPane: harness.panelColumn('codebook.studyContext') !== undefined,
+        family: lastView(harness)?.replayFamily,
+      },
+      {
+        notices: [
+          'Codebook could not open the learning replay: The historical debugger did not start.',
+        ],
+        outputEntries: ['open:recording'],
+        studyPane: true,
+        family: undefined,
+      },
+    )
+  } finally {
+    await harness.close()
+  }
+})
diff --git a/extension/src/tests/studyWorkspaceTestReplayComposition.test.ts b/extension/src/tests/studyWorkspaceTestReplayComposition.test.ts
index 485eda049..8aa6efbfd 100644
--- a/extension/src/tests/studyWorkspaceTestReplayComposition.test.ts
+++ b/extension/src/tests/studyWorkspaceTestReplayComposition.test.ts
@@ -8,8 +8,6 @@ import { test } from 'node:test'
 import {
   NODE_TEST_HISTORY_DIRECTORY,
   REPOSITORY_BROWSER_PROFILE as PROFILE_ID,
-  STUDY_REMOVAL_REFUSALS,
-  SUMMARY_PLACEMENT_OFFER,
 } from '../constants'
 import { ReplayDebuggerStartError, StudyError } from '../errors'
 import { sha256 } from '../runtimeSupport/utils/sha256'
@@ -198,7 +196,9 @@ for (const entry of ['Open replay', 'Saved studies'] as const) {
       await waitUntil(
         () =>
           harness.informationMessages.some(
-            (notice) => notice.message === SUMMARY_PLACEMENT_OFFER,
+            (notice) =>
+              notice.message ===
+              'Cursor opens the Codebook Learning summary in its primary side bar. To keep it on the right, move it once: choose "New Secondary Side Bar Entry" in the list that opens.',
           ),
         'the Move View offer is made',
         READER_RESULT_BOUND_MS,
@@ -858,13 +858,26 @@ test('choosing another saved test replay while the first plays with its summary
       studyId: first.studyId,
       action: 'play',
     })
+    const firstPlayback = harness.reader['nodeHistoryPlaybackController']!
+    await waitUntil(
+      () => firstPlayback.state().mode === 'playing',
+      'the first replay plays',
+      READER_RESULT_BOUND_MS,
+    )
 
     // Act
     await harness.reader.openLearningReplay(second.studyId)
     await landsOn(harness, 2, 'the second replay lands on its first stop')
     const shownAfterOpen = lastView(harness)?.nodeHistory?.header.studyId
-    // gstack-timing-ok: a stopped timer is shown by nothing happening; 600 ms outlasts the whole 400 ms history's playback.
-    await new Promise((resolve) => setTimeout(resolve, 600))
+    // The first replay's playback is retired: its timer stops with its controller, which holds no event any more (Cycle 0052 task 8: no fixed wait).
+    await waitUntil(
+      () =>
+        firstPlayback['timer'] === undefined &&
+        firstPlayback.state().mode === 'paused' &&
+        firstPlayback.state().endMs === undefined,
+      "the first replay's playback is retired",
+      READER_RESULT_BOUND_MS,
+    )
 
     // Assert
     assert.equal(shownAfterOpen, second.studyId)
@@ -889,12 +902,25 @@ test('Return to Live while a test replay plays with its summary hidden stops its
       studyId: history.studyId,
       action: 'play',
     })
+    const playback = harness.reader['nodeHistoryPlaybackController']!
+    await waitUntil(
+      () => playback.state().mode === 'playing',
+      'the test replay plays',
+      READER_RESULT_BOUND_MS,
+    )
 
     // Act
     await harness.reader.action('return-current')
     const messagesAtReturn = harness.playbackPanelMessages.length
-    // gstack-timing-ok: a stopped timer is shown by nothing happening; 600 ms outlasts the whole 400 ms history's playback.
-    await new Promise((resolve) => setTimeout(resolve, 600))
+    // The retired replay's timer stops with its controller, which holds no event any more (Cycle 0052 task 8: no fixed wait).
+    await waitUntil(
+      () =>
+        playback['timer'] === undefined &&
+        playback.state().mode === 'paused' &&
+        playback.state().endMs === undefined,
+      "the test replay's playback is retired",
+      READER_RESULT_BOUND_MS,
+    )
 
     // Assert
     assert.equal(
@@ -932,7 +958,7 @@ test('a delete request for the shown test replay is refused and the replay keeps
     // Assert
     assert.equal(
       lastView(harness)?.studyRemoval?.text,
-      STUDY_REMOVAL_REFUSALS.nodeHistory,
+      'Test replays cannot be deleted here yet.',
     )
     assert.equal(
       lastView(harness)?.nodeHistory?.header.studyId,
@@ -1018,7 +1044,7 @@ test('moves from the bottom panel and the Learning summary while a move presents
   try {
     const history = await openByOpenReplay(harness)
     const held = harness.holdHistoricalDebugPresentation(true)
-    harness.receivePlaybackPanel({
+    const supersededMove = harness.receivePlaybackPanelHandled({
       type: 'node-history-step',
       revision: lastView(harness)!.revision,
       studyId: history.studyId,
@@ -1037,8 +1063,8 @@ test('moves from the bottom panel and the Learning summary while a move presents
     })
     await landsOn(harness, 5, 'the latest request reaches the result')
     held.reject(new Error('Historical debugger presentation was superseded.'))
-    // gstack-timing-ok: the superseded presentation's rejection settles in the next turns, and the case shows that it reports nothing.
-    await new Promise((resolve) => setTimeout(resolve, 100))
+    // The superseded move's own handling ends after its presentation's rejection (Cycle 0052 task 8: no fixed wait).
+    await supersededMove
 
     // Assert
     assert.equal(lastView(harness)?.nodeHistoryPosition?.sequence, 5)
diff --git a/extension/src/tests/studyWorkspaceTestReplayPane.test.ts b/extension/src/tests/studyWorkspaceTestReplayPane.test.ts
index 6e2b4cd38..ce1755f28 100644
--- a/extension/src/tests/studyWorkspaceTestReplayPane.test.ts
+++ b/extension/src/tests/studyWorkspaceTestReplayPane.test.ts
@@ -111,7 +111,7 @@ test('Show recorded output puts a closed Application pane back above the recorde
     { column: 1, tabs: ['Captured-theme.ts'] },
   ])
   assert.deepEqual(after.groups, before.groups)
-  // The Application group and the source's share the left column, and the Study pane's group stays the right column.
+  // The Application group and the source's share the left column, and the composition's third group stays the right column (the summary composition has no Study pane, Cycle 0051 DS-A).
   assert.deepEqual(after.layout, before.layout)
 })
 
diff --git a/extension/src/tests/utils/readerResultBound.ts b/extension/src/tests/utils/readerResultBound.ts
index acecdd3cd..fefc421d0 100644
--- a/extension/src/tests/utils/readerResultBound.ts
+++ b/extension/src/tests/utils/readerResultBound.ts
@@ -1,7 +1,7 @@
 /**
  * How long a test waits for the reader's own work to show (a render, a store read, a debugger presentation) before it reads the wait as a hang.
  * Why: a loaded machine takes seconds for what an idle one does at once, so a one-second wait for a result fails although the result comes (Cycle 0050 F231); a reader that never shows it still fails, at this bound.
- * Read by the Study workspace tests whose waits failed under load.
+ * Read by the Study workspace and Wiki update tests whose waits failed under load.
  * @example await waitUntil(() => shown(), 'the restored stop', READER_RESULT_BOUND_MS)
  */
 export const READER_RESULT_BOUND_MS = 10_000
diff --git a/extension/src/tests/utils/runReleaseBound.ts b/extension/src/tests/utils/runReleaseBound.ts
new file mode 100644
index 000000000..150a53e37
--- /dev/null
+++ b/extension/src/tests/utils/runReleaseBound.ts
@@ -0,0 +1,7 @@
+/**
+ * How long a service test waits for a run's release to end (its final evidence write, its cleanup, its failure) before it reads the wait as a hang.
+ * Why: a release that takes about 50 ms on an idle machine took over one second inside `pnpm health`'s instrumented coverage run, so a one-second wait failed although the release came (Cycle 0052 task 58); a release that never ends still fails, at this bound.
+ * Read by the configured service tests that wait for a release.
+ * @example await waitUntil(() => Boolean(record.cleanupError) && !record.stopping, 'the failed release', RUN_RELEASE_BOUND_MS)
+ */
+export const RUN_RELEASE_BOUND_MS = 10_000
diff --git a/extension/src/tests/utils/startLiveTestRun.ts b/extension/src/tests/utils/startLiveTestRun.ts
index 8ef71c257..86c70c721 100644
--- a/extension/src/tests/utils/startLiveTestRun.ts
+++ b/extension/src/tests/utils/startLiveTestRun.ts
@@ -40,12 +40,12 @@ export async function startLiveTestRun(
       testHash: 'a'.repeat(64),
       testTitles: ['job scheduler', 'runs a delayed job after its timer'],
       source: configuration.source,
-      inspections: configuration.inspections.slice(0, 1),
+      inspections: [{ path: 'delayMs', mode: 'value', required: true }],
       additionalStops: [
         {
           ...configuration.source,
           anchorIndex: 0,
-          inspections: configuration.inspections.slice(0, 1),
+          inspections: [{ path: 'delayMs', mode: 'value', required: true }],
         },
       ],
     },
diff --git a/extension/src/tests/utils/wikiUpdateWindow.ts b/extension/src/tests/utils/wikiUpdateWindow.ts
index de6901c0b..9fb18f986 100644
--- a/extension/src/tests/utils/wikiUpdateWindow.ts
+++ b/extension/src/tests/utils/wikiUpdateWindow.ts
@@ -1,16 +1,18 @@
+import * as fileSystem from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { setTimeout as sleepFor } from 'node:timers/promises'
 
 import * as constants from '../../constants'
 import { readDeepWikiManifest } from '../../deepWikiReader'
 import type * as ExtensionModule from '../../extension'
-import { claimWikiUpdateMarker } from '../../utils/claimWikiUpdateMarker'
+import type * as ClaimWikiUpdateMarkerModule from '../../utils/claimWikiUpdateMarker'
 import { findWikiUpdateStartBlock } from '../../utils/findWikiUpdateStartBlock'
 import {
   inspectDeepWikiFreshness,
   type WikiFreshness,
 } from '../../utils/inspectDeepWikiFreshness'
 import { listWikiCandidates } from '../../utils/listWikiCandidates'
+import { PREPARED_LOCK_SUFFIX } from '../../utils/preparedLockSuffix'
 import { readWikiPublishToken } from '../../utils/readWikiPublishToken'
 import { readWikiWatchStamp } from '../../utils/readWikiWatchStamp'
 import { startWikiChatUpdate } from '../../utils/startWikiChatUpdate'
@@ -65,7 +67,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). */
+/** 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`). */
 export type HeldUpdateStep =
   | 'freshness-inspection'
   | 'chat-open'
@@ -73,6 +75,8 @@ export type HeldUpdateStep =
   | 'journal-wait'
   | 'publish-token-read'
   | 'marker-change'
+  | 'marker-write'
+  | 'claim-answer'
 
 /**
  * Opens an editor window (the real extension with a stubbed `vscode`) on a project whose Wiki already exists, and records everything the learner would see of an update.
@@ -101,7 +105,7 @@ export type HeldUpdateStep =
  * @param options.publishTokenReadFails - Makes the read of the publish token among the start checks reject with this message.
  * @param options.openWikiFails - Makes the command that opens the browser Wiki (the button "Open LLM Wiki" of a notification runs it) reject with this message.
  * @param options.realFreshnessCheck - Runs the real freshness check against the project on disk instead of answering what `setFreshness` was given.
- * @returns What the window showed (chat requests, every editor command the extension ran in order (`executedCommands`: its name, and for the chat request the name followed by " with the update request"), notifications by severity, the buttons each notification offered, confirmations with their detail text, progress titles, the text of every status bar entry it showed (`statusBarTexts`) and of those on screen now (`visibleStatusBarTexts`)), how often its looks read the watch stamp (`stampReads` counts the reads that began, `stampReadsDone` those that returned, so a test can wait for a look instead of for an amount of time) and listed the candidates, each change of its own update marker with what it answered (`markerChanges`), the two update entries, the state snapshot, `openWorkspace` (makes the window answer another folder as its opened project from then on), `hold` (keeps one awaited step of the next start open until `release()`, so a test can close the window in the middle of it) `openDocument`, `openTerminal` and `runTerminalCommand` (what the editor reports when a file is opened, by the chat or by the learner, a terminal opens or a command starts there), `signListenerCount` (how many listeners for these events the extension holds) and `close`.
+ * @returns What the window showed (chat requests, every editor command the extension ran in order (`executedCommands`: its name, and for the chat request the name followed by " with the update request"), notifications by severity, the buttons each notification offered, confirmations with their detail text, progress titles, the text of every status bar entry it showed (`statusBarTexts`) and of those on screen now (`visibleStatusBarTexts`)), how often its looks read the watch stamp (`stampReads` counts the reads that began, `stampReadsDone` those that returned, so a test can wait for a look instead of for an amount of time) and listed the candidates, how often a start's claim on the marker answered (`markerClaims`), each change of its own update marker with what it answered (`markerChanges`), the two update entries, the state snapshot, `openWorkspace` (makes the window answer another folder as its opened project from then on), `hold` (keeps one awaited step of the next start open until `release()`, so a test can close the window in the middle of it) `openDocument`, `openTerminal` and `runTerminalCommand` (what the editor reports when a file is opened, by the chat or by the learner, a terminal opens or a command starts there), `signListenerCount` (how many listeners for these events the extension holds) and `close`.
  *
  * @example
  * ```ts
@@ -162,6 +166,7 @@ export async function openWikiUpdateWindow(options: {
     candidateListings: number
     stampReads: number
     stampReadsDone: number
+    markerClaims: number
   }
   markerChanges: WikiMarkerChange[]
   openWorkspace(nextProjectRoot: string): void
@@ -223,7 +228,12 @@ export async function openWikiUpdateWindow(options: {
   const progressTitles: string[] = []
   const statusBarTexts: string[] = []
   const statusBarEntries: FakeStatusBarEntry[] = []
-  const looks = { candidateListings: 0, stampReads: 0, stampReadsDone: 0 }
+  const looks = {
+    candidateListings: 0,
+    stampReads: 0,
+    stampReadsDone: 0,
+    markerClaims: 0,
+  }
   const markerChanges: WikiMarkerChange[] = []
   /** Records one change of this window's marker, and what it answered once it settled. */
   const recordMarkerChange = (
@@ -320,6 +330,21 @@ export async function openWikiUpdateWindow(options: {
     resolve(__dirname, '../../extension.js'),
     Object.keys(options.constants ?? {}),
   )
+  // The real claim on the marker, whose write of a reservation beside the marker a test can hold while the change holds the claim.
+  const { claimWikiUpdateMarker } = await loadModule<
+    typeof ClaimWikiUpdateMarkerModule
+  >(resolve(__dirname, '../../utils/claimWikiUpdateMarker.js'), {
+    'node:fs/promises': {
+      ...fileSystem,
+      writeFile: async (
+        ...written: Parameters<typeof fileSystem.writeFile>
+      ) => {
+        if (String(written[0]).includes(PREPARED_LOCK_SUFFIX))
+          await passHold('marker-write')
+        return fileSystem.writeFile(...written)
+      },
+    },
+  })
   const boundary = await loadModule<typeof ExtensionModule>(
     resolve(__dirname, '../../extension.js'),
     {
@@ -467,12 +492,14 @@ export async function openWikiUpdateWindow(options: {
           return candidates
         },
       },
-      // The real claim on the marker runs; the window records each change of its marker (its removal, its turn into a stopped watch's reservation) and what that change answered, and a test can hold that change open.
+      // The real claim on the marker runs; the window counts the claims that answered, records each change of its marker (its removal, its turn into a stopped watch's reservation) and what that change answered, and a test can hold that change open.
       './utils/claimWikiUpdateMarker': {
         claimWikiUpdateMarker: async (
           ...claimed: Parameters<typeof claimWikiUpdateMarker>
         ) => {
           const claim = await claimWikiUpdateMarker(...claimed)
+          looks.markerClaims += 1
+          await passHold('claim-answer')
           if (!('release' in claim)) return claim
           return {
             release: async () => {
diff --git a/extension/src/tests/wikiUpdateFlow.test.ts b/extension/src/tests/wikiUpdateFlow.test.ts
index 1741f53ca..26631ac7d 100644
--- a/extension/src/tests/wikiUpdateFlow.test.ts
+++ b/extension/src/tests/wikiUpdateFlow.test.ts
@@ -3378,6 +3378,42 @@ test('a stopped watch whose reservation could not be written because another win
   }
 })
 
+// Value: protects=the learner who presses Update again in the same window while the end of its earlier update still waits to remove that run's marker (its first attempt met another window's claim, which is free by now): the new update starts, and nothing names another editor window; fails_when=the start takes this window's own leftover marker, whose removal waits for its next attempt, for another window's update or for one in change, and refuses the press; why_new=pt3 /ship review (state machines): a start during this window's own waiting marker change had no test; seam=a claim of another machine's window on the marker, freed by the test, and the delay before the next attempt, set longer than the test; no_claim=other windows during that wait (the tests above)
+test('Update pressed again in the same window while its earlier update’s marker removal waits for its next attempt starts the update', async () => {
+  // Arrange: an update whose end could not remove its marker because a window of another machine held the claim on it; the claim is then freed, and the removal's next attempt is still far away.
+  const wiki = await openWikiWindow({
+    constants: { WIKI_UPDATE_MARKER_CHANGE_RETRY_DELAY_MS: 600_000 },
+  })
+  try {
+    const claimDirectory = await holdMarkerClaimAsAWindowOfAnotherMachine(
+      wiki.outputDirectory,
+    )
+    await wiki.clickUpdate()
+    wiki.setFreshness(CURRENT)
+    await wiki.publish('b'.repeat(64))
+    const ended = await waitForEnd(wiki.status)
+    await waitForMarkerAnswer(wiki, false)
+    await rm(claimDirectory, { recursive: true })
+    wiki.setFreshness({
+      status: 'changed',
+      changedPaths: ['src/a.ts'],
+      addedPaths: [],
+    })
+
+    // Act
+    await wiki.clickUpdate()
+
+    // Assert
+    assert.equal(ended.state, 'succeeded')
+    assert.deepEqual(wiki.errors, [])
+    assert.equal(wiki.status().state, 'running')
+    assert.equal(wiki.chatRequests.length, 2)
+    assert.deepEqual(wiki.markerChanges, [{ kind: 'release', answer: false }])
+  } finally {
+    await wiki.close()
+  }
+})
+
 // Value: protects=other editor windows after a window closes while the removal of its marker waits for its next attempt; fails_when=the closing window leaves that attempt to a timer that never runs, so its marker stays on disk as a running update and refuses every other window until the run's bound has passed; why_new=Cycle 0046 second ship, red team RT3; seam=the delay before the next attempt, set longer than the test
 test('a window that closes while the removal of its marker waits for its next attempt makes that attempt as it closes, and the marker leaves the disk with the window', async () => {
   // Arrange: a claim on the marker held by a window of another machine, and an update whose end could not remove its marker.
diff --git a/extension/src/tests/wikiUpdatePublisherFlow.test.ts b/extension/src/tests/wikiUpdatePublisherFlow.test.ts
index deec49009..079cd091a 100644
--- a/extension/src/tests/wikiUpdatePublisherFlow.test.ts
+++ b/extension/src/tests/wikiUpdatePublisherFlow.test.ts
@@ -3,9 +3,11 @@ import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import { test } from 'node:test'
 
+import { waitUntil } from '../runtimeSupport/utils/waitUntil'
 import type { WikiUpdateStatus } from '../utils/wikiUpdateRun'
 
 import { publishedWikiFixture } from './utils/publishedWikiFixture'
+import { READER_RESULT_BOUND_MS } from './utils/readerResultBound'
 import {
   openWikiUpdateWindow,
   type CancellableProgress,
@@ -45,6 +47,23 @@ async function waitForStatus(
 const hasEnded = (current: WikiUpdateStatus): boolean =>
   current.state !== 'running'
 
+/**
+ * Awaits a held step's start, failing with the step's name when it has not started within {@link READER_RESULT_BOUND_MS}, so a regression that never reaches the step fails the test instead of stopping it; called by the Update anyway tests that hold the reservation's write and the start's claim.
+ * @param hold - The step held by the window ({@link openPublishedWikiWindow}'s `hold`).
+ * @param step - The step's name for the failure.
+ * @example await heldStepStarted(reservationWrite, 'the write of the reservation')
+ */
+async function heldStepStarted(
+  hold: { started: Promise<void> },
+  step: string,
+): Promise<void> {
+  let hasStarted = false
+  void hold.started.then(() => {
+    hasStarted = true
+  })
+  await waitUntil(() => hasStarted, step, READER_RESULT_BOUND_MS)
+}
+
 /** An agent needs a moment before it stages anything; the pause also lets the file system's clock pass the run's start. */
 const agentTakesAMoment = (): Promise<void> =>
   new Promise((resolveWait) => setTimeout(resolveWait, 50))
@@ -428,6 +447,119 @@ test('after a VS Code watch ended on a learner’s file, Update anyway on the on
   }
 })
 
+// Value: protects=the learner who presses Update LLM Wiki and chooses Update anyway right after a VS Code watch ended on a file of theirs, while this window still turns the ended run's marker into a stopped watch's reservation; fails_when=the start's claim meets the marker in that turn, which is this window's own, and the start is refused with "Another editor window is starting or ending an update of this Wiki", so the update does not start; why_new=Cycle 0052 task 27 (the test above failed once inside pnpm health's coverage run: under load Update anyway's start claimed while the reservation was written); seam=the write of the reservation beside the marker, which the test holds while the turn holds the claim on the marker; no_claim=another window's change of the marker, which still refuses the start
+test('Update anyway chosen while this window still turns its ended run’s marker into a reservation starts the update once the turn is made, and no refusal names another editor window', async () => {
+  // Arrange: the first run ends as a conflict; the write of its reservation, under the claim on the marker, is held.
+  let isOverrideChosen = false
+  const wiki = await openPublishedWikiWindow({
+    chooseAction: (_message, actions) =>
+      isOverrideChosen
+        ? actions.find((action) => action === 'Update anyway')
+        : undefined,
+  })
+  await mkdir(join(wiki.outputDirectory, 'pages'))
+  await writeFile(join(wiki.outputDirectory, 'pages', 'notes.html'), 'mine')
+  const reservationWrite = wiki.hold('marker-write')
+  try {
+    await wiki.clickUpdate()
+    await agentTakesAMoment()
+    const stage = await wiki.prepare()
+    await wiki.writeCandidate(stage, {
+      heading: 'Second',
+      extraPages: ['pages/notes.html'],
+    })
+    const firstRun = await waitForStatus(wiki.status, hasEnded)
+    await heldStepStarted(reservationWrite, 'the write of the reservation')
+
+    // Act: the learner presses and chooses Update anyway on its refusal while the reservation is still written; Update anyway's start claims the marker; then the write ends.
+    isOverrideChosen = true
+    await wiki.runUpdateCommand()
+    const errorsAfterThePress = wiki.errors.length
+    await waitUntil(
+      () => wiki.looks.markerClaims >= 2,
+      'the claim of the start of Update anyway',
+      READER_RESULT_BOUND_MS,
+    )
+    reservationWrite.release()
+    await waitUntil(
+      () =>
+        wiki.status().state === 'running' ||
+        wiki.errors.length > errorsAfterThePress,
+      'the start of Update anyway or its refusal',
+      READER_RESULT_BOUND_MS,
+    )
+
+    // Assert
+    assert.equal(firstRun.state, 'conflict')
+    assert.deepEqual(wiki.errors.slice(errorsAfterThePress), [])
+    assert.equal(wiki.status().state, 'running')
+    assert.equal(wiki.chatRequests.length, 2)
+  } finally {
+    reservationWrite.release()
+    await wiki.close()
+  }
+})
+
+// Value: protects=Update anyway chosen while this window's ended run turned its marker into a reservation, when that turn ends between the start's claim meeting the marker in change and the start reading that answer: the start claims again and runs; fails_when=claimWikiMarkerForStart claims again only while the change still runs, so a change that ended just before is taken for another window's and the start is refused with "Another editor window is starting or ending an update of this Wiki" (Cycle 0052 task 27); why_new=pt3 /ship review (testing): the ended-change branch had no test; seam=the write of the reservation, held under the claim, and the moment after the start's claim answered, both held by the test; no_claim=how often this ordering occurs natively
+test('Update anyway whose claim met this window’s marker turn, which ended before the start read the answer, starts the update', async () => {
+  // Arrange: the first run ends as a conflict; the write of its reservation is held under the claim on the marker.
+  let isOverrideChosen = false
+  const wiki = await openPublishedWikiWindow({
+    chooseAction: (_message, actions) =>
+      isOverrideChosen
+        ? actions.find((action) => action === 'Update anyway')
+        : undefined,
+  })
+  await mkdir(join(wiki.outputDirectory, 'pages'))
+  await writeFile(join(wiki.outputDirectory, 'pages', 'notes.html'), 'mine')
+  const reservationWrite = wiki.hold('marker-write')
+  // Held from the act on; released in finally too, so a failed wait never leaves the start held while the window closes.
+  let claimAnswer: ReturnType<typeof wiki.hold> | undefined
+  try {
+    await wiki.clickUpdate()
+    await agentTakesAMoment()
+    const stage = await wiki.prepare()
+    await wiki.writeCandidate(stage, {
+      heading: 'Second',
+      extraPages: ['pages/notes.html'],
+    })
+    const firstRun = await waitForStatus(wiki.status, hasEnded)
+    await heldStepStarted(reservationWrite, 'the write of the reservation')
+    claimAnswer = wiki.hold('claim-answer')
+
+    // Act: Update anyway's claim meets the marker in change and is held before the start reads the answer; the turn then ends, and only after it the start reads the answer.
+    isOverrideChosen = true
+    await wiki.runUpdateCommand()
+    const errorsAfterThePress = wiki.errors.length
+    await heldStepStarted(claimAnswer, 'the answer of the start’s claim')
+    reservationWrite.release()
+    await waitUntil(
+      () => wiki.markerChanges.at(-1)?.answer !== undefined,
+      'the end of the reservation turn',
+      READER_RESULT_BOUND_MS,
+    )
+    claimAnswer.release()
+    await waitUntil(
+      () =>
+        wiki.status().state === 'running' ||
+        wiki.errors.length > errorsAfterThePress,
+      'the start of Update anyway or its refusal',
+      READER_RESULT_BOUND_MS,
+    )
+
+    // Assert
+    assert.equal(firstRun.state, 'conflict')
+    assert.deepEqual(wiki.markerChanges, [{ kind: 'reserve', answer: true }])
+    assert.deepEqual(wiki.errors.slice(errorsAfterThePress), [])
+    assert.equal(wiki.status().state, 'running')
+    assert.equal(wiki.chatRequests.length, 2)
+  } finally {
+    reservationWrite.release()
+    claimAnswer?.release()
+    await wiki.close()
+  }
+})
+
 // Value: protects=the one agent per Wiki after this window's VS Code watch was stopped before its chat staged anything and a candidate that watch never saw appeared since: two leftovers, each of which may still publish; fails_when=Update anyway on the refusal that names the candidate passes every leftover the check found, so the update starts past this window's own stopped chat, which no notification named; why_new=Cycle 0046 second ship, state-machine review P2SM1 (the SM2 fix had a test for a reservation named first only); seam=none (the real publisher stages the candidate); no_claim=which chat wrote the candidate
 test('Update anyway on a refusal that named a candidate the stopped watch never saw, while this window’s own stopped chat is also in the way, is refused again naming this window’s chat, with no chat request', async () => {
   // Arrange: this window's VS Code watch stops before its chat staged anything; a candidate the watch never saw appears afterwards.
diff --git a/extension/src/ui/studyHtml.ts b/extension/src/ui/studyHtml.ts
index 63e825be5..10505b1e9 100644
--- a/extension/src/ui/studyHtml.ts
+++ b/extension/src/ui/studyHtml.ts
@@ -786,11 +786,6 @@ function studyClient(
         sequence,
       })
   }
-  /**
-   * Carries out a shared transport button for a test replay (DS-C): Replay from start selects the first event, Previous and Next recorded stop step by stop, and Play or Pause runs the test replay's playback; called by the page's click handler while the summary composition shows a test replay.
-   * @param control - The button's `data-playback` value.
-   * @example playTestReplayControl('start')
-   */
   /**
    * Runs a shared transport control for the replay family the page shows (DS-C): a test replay's moves by event and stop, a browser recording's seeks and Play; called by the page's click handler for a `data-playback` button.
    * @param control - The button's `data-playback` value: `start`, `previous`, `next`, `play` or `pause`.
@@ -813,6 +808,11 @@ function studyClient(
       if (position !== undefined) playback('seek', position)
     } else if (control === 'play' || control === 'pause') playback(control)
   }
+  /**
+   * Carries out a shared transport button for a test replay (DS-C): Replay from start selects the first event, Previous and Next recorded stop step by stop, and Play or Pause runs the test replay's playback; called by {@link playTransportControl} while the page shows a test replay.
+   * @param control - The button's `data-playback` value.
+   * @example playTestReplayControl('start')
+   */
   const playTestReplayControl = (control: string): void => {
     if (control === 'start')
       selectTestReplayEvent(current?.nodeHistoryPlayback?.firstSequence)
@@ -2076,17 +2076,17 @@ function studyClient(
     focusHolder = undefined
     target.focus({ preventScroll: true })
   }
-  /**
-   * Gives a replay's Learning summary that the learner opens with the focus on the document body and no control ever focused in it (its first open, an empty history) its title heading, so the keyboard starts at the top of the summary and the reading position stays (DS-E); called at the window's focus event after {@link settleFocus}, which places a held control first.
-   * A summary in which the learner has used a control keeps the pane's own return rule, so a focus the learner took off a control stays off it. The Study pane and the bottom panel's pane keep their own rules.
-   * @example focusSummaryStart() // the focus on `#title` after Codebook: Show Learning Summary
-   */
   // Whether any control of this document has had the keyboard focus, which ends {@link focusSummaryStart}'s first-open rule.
   let controlEverFocused = false
   document.addEventListener('focusin', (event) => {
     if (event.target instanceof HTMLElement && event.target !== document.body)
       controlEverFocused = true
   })
+  /**
+   * Gives a replay's Learning summary that the learner opens with the focus on the document body and no control ever focused in it (its first open, an empty history) its title heading, so the keyboard starts at the top of the summary and the reading position stays (DS-E); called at the window's focus event after {@link settleFocus}, which places a held control first.
+   * A summary in which the learner has used a control keeps the pane's own return rule, so a focus the learner took off a control stays off it. The Study pane and the bottom panel's pane keep their own rules.
+   * @example focusSummaryStart() // the focus on `#title` after Codebook: Show Learning Summary
+   */
   const focusSummaryStart = (): void => {
     if (
       controlEverFocused ||
@@ -2474,12 +2474,6 @@ function studyClient(
    */
   const isReplayInBottomPanel = (message: StudyViewMessage): boolean =>
     isBottomPanel && Boolean(replayFamilyOf(message))
-  /**
-   * Names the shown test replay by its test file and title path, as Saved studies and a failed open's notification do; read by the message listener for the summary's heading (DS-B).
-   * @param message - The current Study message.
-   * @returns The test file and titles joined with ` › `, or the section's heading when the catalog does not list the replay.
-   * @example testReplayTitle(message) // => 'app/lib/data.test.ts › invoice data queries'
-   */
   /**
    * Draws the shared transport for the replay family the summary composition shows (DS-C): a test replay's controls, or a browser recording's, which give the slider back; called on every Study message.
    * @param message - The current Study message.
@@ -2522,6 +2516,12 @@ function studyClient(
     text('recording-save-state', '')
     element('evidence-details').hidden = true
   }
+  /**
+   * Names the shown test replay by its test file and title path, as Saved studies and a failed open's notification do; read by {@link readerHeading} for the summary's heading (DS-B).
+   * @param message - The current Study message.
+   * @returns The test file and titles joined with ` › `, or the section's heading when the catalog does not list the replay.
+   * @example testReplayTitle(message) // => 'app/lib/data.test.ts › invoice data queries'
+   */
   const testReplayTitle = (message: StudyViewMessage): string => {
     const studyId = message.nodeHistory?.header.studyId
     const summary = message.nodeHistoryCatalog?.find(
diff --git a/extension/src/utils/blankCommentsAndTemplates.ts b/extension/src/utils/blankCommentsAndTemplates.ts
new file mode 100644
index 000000000..01cf07cb6
--- /dev/null
+++ b/extension/src/utils/blankCommentsAndTemplates.ts
@@ -0,0 +1,123 @@
+/** Every character a multiline regular expression's `^` reads as a line break: ECMAScript's line terminators. */
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/
+
+/**
+ * Blanks a module source's comments, template literals (nested templates and their `${…}` parts included) and quoted strings continued onto another line, with spaces that keep every line break and character position, so that only code can read as an import declaration. Other quoted strings stay, since a declaration's specifier and its quoted export names are strings. Regular expression literals are not parsed.
+ * Why: an import written in a comment or in a test's source fixture bound a name, and a nested template's inner backticks ended the masking early (Cycle 0052 tasks 87, 88).
+ * Called by {@link sourceImportBindings}.
+ * @param sourceText - A module's source.
+ * @returns The source with its comments and template literals blanked.
+ * @example
+ * blankCommentsAndTemplates("a // b\nc `d ${`e`}`")
+ * // => 'a     \nc           '
+ */
+export function blankCommentsAndTemplates(sourceText: string): string {
+  const spans: Array<[number, number]> = []
+  scanCode(sourceText, 0, spans, false)
+  const characters = sourceText.split('')
+  for (const [from, to] of spans)
+    for (let index = from; index < to; index += 1)
+      if (characters[index] !== '\n') characters[index] = ' '
+  return characters.join('')
+}
+
+/**
+ * Walks code from `start` to the source's end or, inside a template's `${…}`, to the brace that closes it, recording the comments and templates it passes; called by {@link blankCommentsAndTemplates} and {@link templateEnd}.
+ * @returns The index after the code.
+ */
+function scanCode(
+  text: string,
+  start: number,
+  spans: Array<[number, number]>,
+  isInsideTemplate: boolean,
+): number {
+  let depth = 0,
+    index = start
+  while (index < text.length) {
+    const skipped = skipNonCode(text, index, spans)
+    if (skipped !== index) {
+      index = skipped
+      continue
+    }
+    if (text[index] === '{') depth += 1
+    else if (text[index] === '}') {
+      // Inside a template's `${…}`, the brace that closes it ends this code.
+      if (isInsideTemplate && depth === 0) return index + 1
+      depth -= 1
+    }
+    index += 1
+  }
+  return index
+}
+
+/**
+ * Skips the comment, quoted string or template literal that starts at `index`, recording comments and templates as spans to blank; called by {@link scanCode}.
+ * @returns The index after it, or `index` when none starts there.
+ */
+function skipNonCode(
+  text: string,
+  index: number,
+  spans: Array<[number, number]>,
+): number {
+  const pair = text.slice(index, index + 2),
+    character = text[index]
+  if (character === "'" || character === '"') {
+    const end = stringEnd(text, index)
+    // A string continued onto another line, or holding a raw U+2028/U+2029 that a multiline `^` reads as a line break, could start that line with `import`; one on a single line never starts a line, and a specifier never spans lines (Cycle 0052 tasks 91, 93).
+    if (LINE_TERMINATOR.test(text.slice(index, end))) spans.push([index, end])
+    return end
+  }
+  const end =
+    pair === '//'
+      ? lineEnd(text, index)
+      : pair === '/*'
+        ? blockCommentEnd(text, index)
+        : character === '`'
+          ? templateEnd(text, index)
+          : index
+  if (end !== index) spans.push([index, end])
+  return end
+}
+
+/** The index of the line break that ends a line comment, or the source's end. */
+function lineEnd(text: string, index: number): number {
+  const lineBreak = text.indexOf('\n', index)
+  return lineBreak === -1 ? text.length : lineBreak
+}
+
+/** The index after a block comment's `*\/`, or the source's end. */
+function blockCommentEnd(text: string, index: number): number {
+  const close = text.indexOf('*/', index + 2)
+  return close === -1 ? text.length : close + 2
+}
+
+/** The index after a quoted string's closing quote; an unclosed string ends at its line break. */
+function stringEnd(text: string, index: number): number {
+  const quote = text[index]
+  let cursor = index + 1
+  while (
+    cursor < text.length &&
+    text[cursor] !== quote &&
+    text[cursor] !== '\n'
+  )
+    cursor += escapeLength(text, cursor)
+  return text[cursor] === quote ? cursor + 1 : cursor
+}
+
+/** How far a string's cursor moves: past an escape and the character it escapes, a backslash and a CRLF line continuation being one escape (Cycle 0052 task 91); one character otherwise. */
+function escapeLength(text: string, cursor: number): number {
+  if (text[cursor] !== '\\') return 1
+  return text.startsWith('\r\n', cursor + 1) ? 3 : 2
+}
+
+/** The index after a template literal's closing backtick, its `${…}` parts (and the templates nested in them) passed whole; an unclosed one ends at the source's end. */
+function templateEnd(text: string, index: number): number {
+  let cursor = index + 1
+  while (cursor < text.length && text[cursor] !== '`') {
+    if (text[cursor] === '\\') cursor += 2
+    else if (text.startsWith('${', cursor))
+      cursor = scanCode(text, cursor + 2, [], true)
+    else cursor += 1
+  }
+  return Math.min(cursor + 1, text.length)
+}
diff --git a/extension/src/utils/describeNodeTestReplay.ts b/extension/src/utils/describeNodeTestReplay.ts
index 844960879..9c9a13d97 100644
--- a/extension/src/utils/describeNodeTestReplay.ts
+++ b/extension/src/utils/describeNodeTestReplay.ts
@@ -35,10 +35,10 @@ export const NODE_TEST_REPLAY_TEXT = {
   play: 'Play',
   pause: 'Pause',
   stepDetails: 'Step details',
-  /** The control under a clamped question, summary or capture reason that shows its whole text in place (Cycle 0051, DS-B), and its label while the whole text shows. */
   /** The shared transport's status line while a test replay plays and while it is paused (Cycle 0051, DS-C). */
   playingStatus: 'Test replay playing',
   pausedStatus: 'Test replay paused',
+  /** The control under a clamped question, summary or capture reason that shows its whole text in place (Cycle 0051, DS-B), and its label while the whole text shows. */
   showMore: 'Show more',
   showLess: 'Show less',
   /** The name of the shared transport's group of Previous event and Next event, shown for a test replay only (DS-C). */
diff --git a/extension/src/utils/inspectNodeTestVariables.ts b/extension/src/utils/inspectNodeTestVariables.ts
index 1d4e5a24b..1d8731b93 100644
--- a/extension/src/utils/inspectNodeTestVariables.ts
+++ b/extension/src/utils/inspectNodeTestVariables.ts
@@ -2,12 +2,19 @@ import type { DebugProtocol } from '@vscode/debugprotocol'
 import type * as vscode from 'vscode'
 
 import {
+  DEBUGGER_PROXY_TARGET_NAME,
   NODE_TEST_FACT_TYPE_LIMIT_CHARS,
+  NODE_TEST_MODULE_BINDING_NAME,
   REPOSITORY_LITERAL_LIMIT_CHARS,
 } from '../constants'
 import type { RepositoryInspection } from '../repositoryConfigSchemas'
 import { awaitResponse } from '../runtimeSupport/utils/awaitResponse'
 
+import type {
+  ModuleDeclarationBinding,
+  SourceImports,
+} from './sourceImportBindings'
+
 export type NodeTestFact = {
   path: string
   mode: RepositoryInspection['mode']
@@ -15,48 +22,54 @@ export type NodeTestFact = {
   type?: string
 }
 
-/** Reads only declared debugger paths through native DAP scopes; never evaluates an expression or retains other local values. Called at an owned source stop. @param session - Verified native debug session. @param scopes - Scopes of its checked source frame. @param inspections - Validated requested facts. @param signal - Run cancellation. @example await inspectNodeTestVariables(session, scopes, [{path:'listener',mode:'value',required:true}], signal) */
+/**
+ * Reads only the declared debugger paths of a Node test stop through native DAP scopes, never evaluating an expression or retaining other local values; called by {@link OwnedNodeTestRun} at an owned source stop.
+ * A path's root is the scope variable of that name, or, when none has it, a name the stopped source imports, read as the export it stands for in its own declaration's module binding ({@link sourceImportBindings}, {@link importedName}): Vitest binds each imported module whole ({@link NODE_TEST_MODULE_BINDING_NAME}), a mocked one as a Proxy whose exports sit under {@link DEBUGGER_PROXY_TARGET_NAME}, an unmocked one as a namespace of getters that the debugger shows lazily. A lazy value on the path (a getter, such as a Vitest spy's `mock`) is expanded once, which runs that getter in the test process as the Variables view does when the learner expands it (Cycle 0052 task 5).
+ * @param debugSession - Verified native debug session.
+ * @param scopes - Scopes of its checked source frame.
+ * @param inspections - Validated requested facts.
+ * @param sourceImports - The stopped source's import declarations and imported names ({@link sourceImportBindings}).
+ * @param signal - Run cancellation.
+ * @returns The facts read; the variables they came from; and, as `<mode>:<path>`, each required fact the debugger could not read (absent, ambiguous between two imported modules, empty or longer than {@link REPOSITORY_LITERAL_LIMIT_CHARS}), which the caller reports while the stop stays accepted. An unreadable optional fact is left out, as before.
+ * @example
+ * await inspectNodeTestVariables(debugSession, scopes, [{ path: 'revalidatePath.mock.calls.length', mode: 'value', required: true }], sourceImportBindings("import { revalidatePath } from 'next/cache'"), signal)
+ * // => { facts: [{ path: 'revalidatePath.mock.calls.length', mode: 'value', display: '1', type: 'number' }], variables: [...], unavailable: [] }
+ */
 export async function inspectNodeTestVariables(
-  session: Pick<vscode.DebugSession, 'customRequest'>,
+  debugSession: Pick<vscode.DebugSession, 'customRequest'>,
   scopes: DebugProtocol.Scope[],
   inspections: RepositoryInspection[],
+  sourceImports: SourceImports,
   signal: AbortSignal,
-): Promise<{ facts: NodeTestFact[]; variables: DebugProtocol.Variable[] }> {
-  const cache = new Map<number, DebugProtocol.Variable[]>()
-  const readVariables = async (
-    reference: number,
-  ): Promise<DebugProtocol.Variable[]> => {
-    if (!Number.isSafeInteger(reference) || reference <= 0) return []
-    const cached = cache.get(reference)
-    if (cached) return cached
-    const response = (await awaitResponse(
-      session.customRequest('variables', { variablesReference: reference }),
-      'owned Node debugger variables',
-      signal,
-    )) as DebugProtocol.VariablesResponse['body']
-    if (!Array.isArray(response?.variables))
-      throw new Error('Native debugger supplied no variable list.')
-    cache.set(reference, response.variables)
-    return response.variables
-  }
+): Promise<{
+  facts: NodeTestFact[]
+  variables: DebugProtocol.Variable[]
+  unavailable: string[]
+}> {
+  // A pass that fails ends the requests its other reads still have under way, so no binding read goes on asking a debugger whose stop has failed.
+  const failedPass = new AbortController()
+  const read = debuggerVariableReader(
+    debugSession,
+    AbortSignal.any([signal, failedPass.signal]),
+  )
+  // Only lexical runtime scopes can supply an operation fact; global state is unrelated to this stop.
+  const lexicalScopes = scopes.filter(
+    (scope) => !scope.name.toLowerCase().includes('global'),
+  )
   const facts: NodeTestFact[] = [],
-    selected: DebugProtocol.Variable[] = []
+    selected: DebugProtocol.Variable[] = [],
+    unavailable: string[] = []
   for (const inspection of inspections) {
     signal.throwIfAborted()
-    const [root, ...segments] = inspection.path.split('.')
-    let variable: DebugProtocol.Variable | undefined
-    for (const scope of scopes) {
-      // Only lexical runtime scopes can supply an operation fact; global state is unrelated to this stop.
-      if (scope.name.toLowerCase().includes('global')) continue
-      variable = (await readVariables(scope.variablesReference)).find(
-        (candidate) => candidate.name === root,
-      )
-      if (variable) break
-    }
-    for (const segment of segments)
-      variable = (await readVariables(variable?.variablesReference ?? 0)).find(
-        (candidate) => candidate.name === segment,
-      )
+    const variable = await readDeclaredPath(
+      read,
+      lexicalScopes,
+      sourceImports,
+      inspection.path,
+    ).catch((error: unknown) => {
+      failedPass.abort()
+      throw error
+    })
     const display =
       inspection.mode === 'type' ? variable?.type : variable?.value
     if (
@@ -64,10 +77,9 @@ export async function inspectNodeTestVariables(
       !display ||
       display.length > REPOSITORY_LITERAL_LIMIT_CHARS
     ) {
+      // A required fact is reported by name; the stop keeps the facts that could be read (Cycle 0052 task 5).
       if (inspection.required)
-        throw new Error(
-          `Required Node debugger fact is unavailable or too large: ${inspection.mode}:${inspection.path}`,
-        )
+        unavailable.push(`${inspection.mode}:${inspection.path}`)
       continue
     }
     // An oversized debugger type name is supplementary; omit it instead of making the saved stop invalid.
@@ -84,5 +96,245 @@ export async function inspectNodeTestVariables(
     })
     selected.push(variable)
   }
-  return { facts, variables: selected }
+  // A lazy value whose expansion failed reads as unavailable (settledLazy); a run cancelled meanwhile still ends the pass.
+  signal.throwIfAborted()
+  return { facts, variables: selected, unavailable }
+}
+
+/** Reads the children of one debugger variable reference, once per reference. */
+type DebuggerVariableReader = (
+  reference: number,
+) => Promise<DebugProtocol.Variable[]>
+
+/**
+ * Makes the cached reader of debugger variable children that one inspection pass shares; called by {@link inspectNodeTestVariables}.
+ * @param debugSession - The native debug session.
+ * @param signal - Run cancellation, or the end of a failed pass.
+ * @returns A reader answering an invalid or empty reference with no children.
+ * @example const read = debuggerVariableReader(debugSession, signal); await read(7) // => [{ name: 'count', value: '3', ... }]
+ */
+function debuggerVariableReader(
+  debugSession: Pick<vscode.DebugSession, 'customRequest'>,
+  signal: AbortSignal,
+): DebuggerVariableReader {
+  // The request of each reference, so bindings read together share one request for a reference they both reach.
+  const cache = new Map<number, Promise<DebugProtocol.Variable[]>>()
+  const request = async (
+    reference: number,
+  ): Promise<DebugProtocol.Variable[]> => {
+    // A cancelled or failed pass sends the debugger no further request.
+    signal.throwIfAborted()
+    const response = (await awaitResponse(
+      Promise.resolve(
+        debugSession.customRequest('variables', {
+          variablesReference: reference,
+        }),
+      ).catch((error: unknown) => {
+        // The adapter answered with an error (a getter that threw, for example); a timeout or a cancellation is not this.
+        throw new DebuggerRefusedVariables(error)
+      }),
+      'owned Node debugger variables',
+      signal,
+    )) as DebugProtocol.VariablesResponse['body']
+    if (!Array.isArray(response?.variables))
+      throw new Error('Native debugger supplied no variable list.')
+    return response.variables
+  }
+  return (reference) => {
+    if (!Number.isSafeInteger(reference) || reference <= 0)
+      return Promise.resolve([])
+    const cached = cache.get(reference)
+    if (cached) return cached
+    const reading = request(reference)
+    cache.set(reference, reading)
+    // A failed request is not kept: the reference may be asked again.
+    reading.catch(() => cache.delete(reference))
+    return reading
+  }
+}
+
+/** The debug adapter's error answer to a `variables` request, as opposed to a timeout, a cancellation or a malformed answer; {@link settledLazy} reads it as an unreadable step. The adapter's error stays its `cause`. */
+class DebuggerRefusedVariables extends Error {
+  constructor(cause: unknown) {
+    // The name stays `Error`, so a failure worded from it reads as other run failures do (withoutErrorName drops only `…Error: `); only `instanceof` tells it apart.
+    super(`Native debugger refused the variables request: ${String(cause)}`, {
+      cause,
+    })
+  }
+}
+
+/** What a stop's scopes hold under a path's root: its variable, `undefined` when its lazy value could not be read; the root then still shadows any import of that name. */
+type ScopeRoot = { variable: DebugProtocol.Variable | undefined }
+
+/**
+ * Walks one declared path, `root.segment.segment`, to its variable; called by {@link inspectNodeTestVariables}.
+ * @param read - The pass's variable reader.
+ * @param scopes - The stop's lexical scopes.
+ * @param sourceImports - The stopped source's import declarations and imported names.
+ * @param path - The declared path.
+ * @returns The variable at the end of the path, or `undefined` when a step is missing.
+ * @example await readDeclaredPath(read, scopes, sourceImportBindings("import { revalidatePath } from 'next/cache'"), 'revalidatePath.mock.calls.length') // => { name: 'length', value: '1', ... }
+ */
+async function readDeclaredPath(
+  read: DebuggerVariableReader,
+  scopes: DebugProtocol.Scope[],
+  sourceImports: SourceImports,
+  path: string,
+): Promise<DebugProtocol.Variable | undefined> {
+  const [root = '', ...segments] = path.split('.')
+  const local = await scopeVariable(read, scopes, root)
+  let variable = local
+    ? local.variable
+    : await importedName(read, scopes, sourceImports, root)
+  for (const segment of segments)
+    variable =
+      variable &&
+      (await settledLazy(
+        read,
+        (await read(variable.variablesReference)).find(
+          (candidate) => candidate.name === segment,
+        ),
+      ))
+  return variable
+}
+
+/**
+ * Finds the scope variable of a path's root, the first scope that has it winning, as JavaScript scoping does; called by {@link readDeclaredPath}.
+ * @param read - The pass's variable reader.
+ * @param scopes - The stop's lexical scopes, innermost first.
+ * @param name - The root's name.
+ * @returns The {@link ScopeRoot} of the first scope that has the name; `undefined` when no scope has it.
+ * @example await scopeVariable(read, scopes, 'set') // => { variable: { name: 'set', value: 'ƒ (...args)', ... } }
+ */
+async function scopeVariable(
+  read: DebuggerVariableReader,
+  scopes: DebugProtocol.Scope[],
+  name: string,
+): Promise<ScopeRoot | undefined> {
+  for (const scope of scopes) {
+    const variable = (await read(scope.variablesReference)).find(
+      (candidate) => candidate.name === name,
+    )
+    // A scope variable of the name shadows any import, also when its lazy value cannot be read.
+    if (variable) return { variable: await settledLazy(read, variable) }
+  }
+  return undefined
+}
+
+/**
+ * Reads a name the stopped module imports, as the export its import declaration names in that declaration's own module binding: the variable Vite or Vitest binds that module to ({@link ModuleDeclarationBinding}; Vitest's numbering when the stop's scopes hold any `__vi_import_<n>__`), read through a Proxy's {@link DEBUGGER_PROXY_TARGET_NAME} for a mocked module; called by {@link readDeclaredPath} when no scope variable has the root's name.
+ * No other module binding ever answers for the name (Cycle 0052 task 96). A name the source does not import, a namespace import, a binding the stop's scopes do not hold and an export that binding lacks leave the name unread, and so does any earlier declaration whose binding the scopes hold without the exports it names: the compiler dropped an import used only as a type, which shifts the numbering. A binding listed by two scopes counts once.
+ * @param read - The pass's variable reader.
+ * @param scopes - The stop's lexical scopes.
+ * @param sourceImports - The stopped source's import declarations and imported names ({@link sourceImportBindings}).
+ * @param name - The root's name.
+ * @returns The export's variable, or `undefined` when the name cannot be read from its own module binding.
+ * @example await importedName(read, scopes, sourceImportBindings("import { revalidatePath } from 'next/cache'"), 'revalidatePath') // => { name: 'revalidatePath', value: 'ƒ (...args)', ... }
+ */
+async function importedName(
+  read: DebuggerVariableReader,
+  scopes: DebugProtocol.Scope[],
+  sourceImports: SourceImports,
+  name: string,
+): Promise<DebugProtocol.Variable | undefined> {
+  const imported = sourceImports.names.get(name)
+  // Only a name the source imports from one module's export is read (Cycle 0052 task 70).
+  if (!imported || imported.exported === '*') return undefined
+  const bindings = await moduleBindingsInScope(read, scopes)
+  const isHoisted = [...bindings.keys()].some((binding) =>
+    binding.startsWith('__vi_import_'),
+  )
+  const bindingOf = (
+    declaration: ModuleDeclarationBinding | undefined,
+  ): DebugProtocol.Variable | undefined =>
+    declaration &&
+    bindings.get(isHoisted ? declaration.hoisted : declaration.plain)
+  const declarations = sourceImports.declarations.slice(
+    0,
+    imported.declaration + 1,
+  )
+  // Each declaration up to this one must find its own exports in its binding: a dropped import would shift the numbering. The bindings are independent requests, read together.
+  const hasEveryExport = await Promise.all(
+    declarations.map(async (declaration) => {
+      const binding = bindingOf(declaration)
+      if (!binding) return true
+      for (const exported of declaration.exports)
+        if (!(await moduleExport(read, binding, exported))) return false
+      return true
+    }),
+  )
+  const binding = bindingOf(declarations.at(-1))
+  if (!binding || hasEveryExport.includes(false)) return undefined
+  return settledLazy(read, await moduleExport(read, binding, imported.exported))
+}
+
+/**
+ * Lists the module bindings ({@link NODE_TEST_MODULE_BINDING_NAME}) a stop's scopes hold, by variable name; called by {@link importedName}.
+ * @returns Each binding once, the innermost scope's when two scopes list it.
+ * @example await moduleBindingsInScope(read, scopes) // => Map { '__vi_import_0__' => { name: '__vi_import_0__', value: 'Proxy(Object)', … } }
+ */
+async function moduleBindingsInScope(
+  read: DebuggerVariableReader,
+  scopes: DebugProtocol.Scope[],
+): Promise<Map<string, DebugProtocol.Variable>> {
+  const bindings = new Map<string, DebugProtocol.Variable>()
+  for (const scope of scopes)
+    for (const binding of await read(scope.variablesReference))
+      if (
+        NODE_TEST_MODULE_BINDING_NAME.test(binding.name) &&
+        !bindings.has(binding.name)
+      )
+        bindings.set(binding.name, binding)
+  return bindings
+}
+
+/**
+ * Reads one export of a module binding: a child of that name, or, for a mocked module's Proxy, the child of that name under its target; called by {@link importedName} for the name and for the checks of each declaration's exports.
+ * @param read - The pass's variable reader.
+ * @param binding - The module binding.
+ * @param name - The export's name.
+ * @returns The export's variable, or `undefined`.
+ * @example await moduleExport(read, { name: '__vi_import_1__', value: 'Proxy(Object)', variablesReference: 4 }, 'revalidatePath')
+ */
+async function moduleExport(
+  read: DebuggerVariableReader,
+  binding: DebugProtocol.Variable,
+  name: string,
+): Promise<DebugProtocol.Variable | undefined> {
+  const children = await read(binding.variablesReference)
+  const direct = children.find((child) => child.name === name)
+  if (direct) return direct
+  const target = children.find(
+    (child) => child.name === DEBUGGER_PROXY_TARGET_NAME,
+  )
+  return target
+    ? (await read(target.variablesReference)).find(
+        (child) => child.name === name,
+      )
+    : undefined
+}
+
+/**
+ * Expands a lazy debugger value (a getter the debugger shows as `(...)`) to the one value it stands for, as the Variables view does when the learner opens it; any other variable is returned as it is; called for every step of a declared path.
+ * @param read - The pass's variable reader.
+ * @param variable - The step's variable, if any.
+ * @returns The resolved variable, or `undefined` when the adapter refused the expansion or answered with no single value, so its `(...)` placeholder never stands for a value.
+ * @throws What the reader threw for a timeout, a cancellation or a malformed answer.
+ * @example await settledLazy(read, { name: 'ITEMS_PER_PAGE', value: '(...)', variablesReference: 50, presentationHint: { lazy: true } }) // => { name: 'ITEMS_PER_PAGE', value: '6', ... }
+ */
+async function settledLazy(
+  read: DebuggerVariableReader,
+  variable: DebugProtocol.Variable | undefined,
+): Promise<DebugProtocol.Variable | undefined> {
+  if (!variable?.presentationHint?.lazy) return variable
+  // Expanding a lazy value runs its getter in the test process: the adapter's error answer (a getter that threw) leaves the step unreadable instead of failing the stop; a timeout, a cancellation or a malformed answer still fails it.
+  const children = await read(variable.variablesReference).catch(
+    (error: unknown) => {
+      if (error instanceof DebuggerRefusedVariables) return undefined
+      throw error
+    },
+  )
+  const [value, ...others] = children ?? []
+  // The protocol answers a lazy value with exactly one variable; any other answer leaves the step unreadable (Cycle 0052 task 71).
+  return others.length === 0 ? value : undefined
 }
diff --git a/extension/src/utils/readDevelopmentBundle.ts b/extension/src/utils/readDevelopmentBundle.ts
index 56f6269f0..1f6789eda 100644
--- a/extension/src/utils/readDevelopmentBundle.ts
+++ b/extension/src/utils/readDevelopmentBundle.ts
@@ -157,10 +157,10 @@ export async function readDevelopmentBundle(
   if (performance.now() >= deadline)
     throw new Error('Build discovery resource limit exceeded')
   signal?.throwIfAborted()
-  // An unchanged tracked file may still belong to a route outside the launched page.
+  // An unchanged tracked file may still belong to a route outside the launched page: the stop is armed before input, in the code the launched page loads, so the refusal names that page and where a stop can go (Cycle 0052 task 7b).
   if (bundles.length !== 1)
     throw new Error(
-      'Selected source is absent from the selected application route chunks; verify that it belongs to the launched page',
+      `Selected source ${selected.path} is not in the client code that the launched page (entryPath "${entryPath}") loads, and a browser stop can only be armed in that code before input; start the run at the page whose component holds the stop (set entryPath to it) or choose a stop in the launched page's own components`,
     )
   return {
     bundle: bundles[0]!,
diff --git a/extension/src/utils/sourceImportBindings.ts b/extension/src/utils/sourceImportBindings.ts
new file mode 100644
index 000000000..cc18198fd
--- /dev/null
+++ b/extension/src/utils/sourceImportBindings.ts
@@ -0,0 +1,167 @@
+import { blankCommentsAndTemplates } from './blankCommentsAndTemplates'
+
+/** A static import declaration that starts a line of code, `import <clause> from '…'` or `import '…'`, across lines; its braces may hold quoted export names, a comma or a brace inside them included. */
+const IMPORT_DECLARATION =
+  /^[ \t]*import(?:\s+((?:[^'";{}]|\{(?:'[^']*'|"[^"]*"|[^}'"])*\})*?)\s*\bfrom)?\s*(['"])([^'"\n]*)\2/gm
+
+/** A re-export that starts a line of code and loads its module: `export * from '…'`, `export * as name from '…'` or `export { … } from '…'`, `export type` ones included so they can be left out. */
+const REEXPORT_DECLARATION =
+  /^[ \t]*export\s+(type\s+)?(\*(?:\s+as\s+[\w$]+)?|\{(?:'[^']*'|"[^"]*"|[^}'"])*\})\s*from\s*(['"])([^'"\n]*)\3/gm
+
+/** An import or re-export clause's braces, whose quoted export names may hold a brace. */
+const CLAUSE_BRACES = /\{((?:'[^']*'|"[^"]*"|[^}'"])*)\}/
+
+/** One specifier between a clause's braces: the text up to a comma outside quotes. */
+const SPECIFIER = /(?:'[^']*'|"[^"]*"|[^,'"])+/g
+
+/** One named specifier: the export (a name or a quoted string) and its local alias, if any. */
+const NAMED_SPECIFIER =
+  /^(?:([\w$]+)|'([^']*)'|"([^"]*)")(?:\s+as\s+([\w$]+))?$/
+
+/** The modules whose imports Vitest leaves static when it hoists a file's imports for its `vi.mock` calls (`@vitest/mocker`'s hoistMocks). */
+const HOISTED_MODULES = ['vitest', 'vite-plus/test']
+
+/** One declaration of the stopped module that loads another module at run time, as Vite and Vitest bind it. */
+export type ModuleDeclarationBinding = {
+  /** The variable Vite's SSR transform binds the module to: `__vite_ssr_import_<n>__`, numbered over the file's import and re-export declarations in source order. */
+  plain: string
+  /** The variable when Vitest hoisted the file's imports for its `vi.mock` calls: `__vi_import_<n>__` for an import of any other module, numbered over those imports; `__vite_ssr_import_<n>__` for an import of Vitest itself and for a re-export, numbered over those. */
+  hoisted: string
+  /** The exports the declaration names by name (`default` for a default import), which its module must have. */
+  exports: readonly string[]
+}
+
+/** What a stopped module's source says about its imports: each run-time declaration in source order, and each imported local name with the export it reads and its declaration's position. */
+export type SourceImports = {
+  declarations: readonly ModuleDeclarationBinding[]
+  names: ReadonlyMap<string, { exported: string; declaration: number }>
+}
+
+/** One run-time declaration found in the source, before it is numbered. */
+type FoundDeclaration = {
+  index: number
+  specifier: string
+  isReexport: boolean
+  locals: Array<[string, string]>
+  exports: string[]
+}
+
+/**
+ * Reads a stopped module's static import and re-export declarations: which module binding variable Vite or Vitest gives each one, which exports it names, and which export each imported local name reads (the name itself for a named import, the original for an alias, `default` for a default import, `*` for a namespace import). Type-only declarations bind nothing at run time and are left out.
+ * Why: Vitest binds each imported module whole, so an imported name has no variable of its own at a test stop, and only the source tells which export of which module binding a local name stands for; another module's export of the same name answered for it before (Cycle 0052 tasks 70, 96). Only real declarations count: an import written in a comment or a string, nested templates included, binds nothing (tasks 87, 88), and a quoted export name keeps its comma (task 89).
+ * Called by {@link OwnedNodeTestRun} with the source of each stop, for {@link inspectNodeTestVariables}.
+ * @param sourceText - The stopped module's source.
+ * @returns The declarations in source order and the imported names.
+ * @example
+ * sourceImportBindings("import { vi } from 'vitest'\nimport db, { a as b } from './m'")
+ * // => { declarations: [{ plain: '__vite_ssr_import_0__', hoisted: '__vite_ssr_import_0__', exports: ['vi'] }, { plain: '__vite_ssr_import_1__', hoisted: '__vi_import_0__', exports: ['default', 'a'] }], names: Map { 'vi' => …, 'db' => { exported: 'default', declaration: 1 }, 'b' => { exported: 'a', declaration: 1 } } }
+ */
+export function sourceImportBindings(sourceText: string): SourceImports {
+  // Comments and template literals become blanks (line breaks kept), and a quoted string never starts a line, so neither can read as a declaration.
+  const code = blankCommentsAndTemplates(sourceText)
+  const found = [...importDeclarations(code), ...reexportDeclarations(code)]
+    .filter((declaration) => declaration !== undefined)
+    .sort((left, right) => left.index - right.index)
+  const declarations: ModuleDeclarationBinding[] = [],
+    names = new Map<string, { exported: string; declaration: number }>()
+  let viImports = 0,
+    staticImports = 0
+  for (const [position, declaration] of found.entries()) {
+    // Vitest leaves its own imports and every re-export static; Vite numbers the static ones in source order.
+    const staysStatic =
+      declaration.isReexport || HOISTED_MODULES.includes(declaration.specifier)
+    declarations.push({
+      plain: `__vite_ssr_import_${position}__`,
+      hoisted: staysStatic
+        ? `__vite_ssr_import_${staticImports++}__`
+        : `__vi_import_${viImports++}__`,
+      exports: declaration.exports,
+    })
+    for (const [local, exported] of declaration.locals)
+      names.set(local, { exported, declaration: position })
+  }
+  return { declarations, names }
+}
+
+/**
+ * Finds the run-time import declarations of a blanked source; called by {@link sourceImportBindings}.
+ * @returns Each declaration, `undefined` for a type-only one.
+ */
+function importDeclarations(code: string): Array<FoundDeclaration | undefined> {
+  return [...code.matchAll(IMPORT_DECLARATION)].map((match) => {
+    const clause = match[1]
+    // `import type …` binds nothing at run time; `import '…'` loads its module for its effects.
+    if (clause !== undefined && /^type\s/.test(clause)) return undefined
+    const locals = clause === undefined ? [] : clauseBindings(clause)
+    // A clause of type specifiers only is dropped by the TypeScript compiler.
+    if (clause !== undefined && locals.length === 0) return undefined
+    return {
+      index: match.index,
+      specifier: match[3] ?? '',
+      isReexport: false,
+      locals,
+      exports: locals
+        .map(([, exported]) => exported)
+        .filter((exported) => exported !== '*'),
+    }
+  })
+}
+
+/**
+ * Finds the run-time re-export declarations of a blanked source; called by {@link sourceImportBindings}.
+ * @returns Each declaration, `undefined` for a type-only one.
+ */
+function reexportDeclarations(
+  code: string,
+): Array<FoundDeclaration | undefined> {
+  return [...code.matchAll(REEXPORT_DECLARATION)].map((match) => {
+    const named = CLAUSE_BRACES.exec(match[2] ?? '')
+    const exports = named ? namedBindings(named[1] ?? '') : []
+    // `export type …` and a brace list of type specifiers only load nothing at run time.
+    if (match[1] !== undefined || (named && exports.length === 0))
+      return undefined
+    return {
+      index: match.index,
+      specifier: match[4] ?? '',
+      isReexport: true,
+      locals: [],
+      exports: exports.map(([, exported]) => exported),
+    }
+  })
+}
+
+/**
+ * Reads one import clause's bindings: its default import, its namespace import and its named specifiers; called by {@link importDeclarations}.
+ * @param clause - The text between `import` and `from`.
+ * @returns Each local name with the export it reads.
+ * @example clauseBindings('db, { a as b }') // => [['db', 'default'], ['b', 'a']]
+ */
+function clauseBindings(clause: string): Array<[string, string]> {
+  const named = CLAUSE_BRACES.exec(clause)
+  const outside = named ? clause.replace(named[0], '') : clause
+  const bindings: Array<[string, string]> = []
+  const defaultName = /^([\w$]+)/.exec(outside.trim())?.[1]
+  if (defaultName) bindings.push([defaultName, 'default'])
+  const namespace = /\*\s*as\s+([\w$]+)/.exec(outside)?.[1]
+  if (namespace) bindings.push([namespace, '*'])
+  return [...bindings, ...namedBindings(named?.[1] ?? '')]
+}
+
+/**
+ * Reads the named specifiers between a clause's braces; called by {@link clauseBindings} and {@link reexportDeclarations}.
+ * @param braces - The text inside the braces.
+ * @returns Each local name with the export it reads; an inline `type` specifier binds nothing at run time and is left out.
+ * @example namedBindings(" a, b as c, type D, 'e-f' as g ") // => [['a', 'a'], ['c', 'b'], ['g', 'e-f']]
+ */
+function namedBindings(braces: string): Array<[string, string]> {
+  // The braces hold no comments by now ({@link sourceImportBindings} blanked them), so only a comma outside quotes splits specifiers.
+  return (braces.match(SPECIFIER) ?? []).flatMap(
+    (specifier): Array<[string, string]> => {
+      const parts = NAMED_SPECIFIER.exec(specifier.trim())
+      const exported = parts?.[1] ?? parts?.[2] ?? parts?.[3]
+      return parts && exported !== undefined
+        ? [[parts[4] ?? exported, exported]]
+        : []
+    },
+  )
+}
diff --git a/extension/src/utils/unknownNodeHistoryError.ts b/extension/src/utils/unknownNodeHistoryError.ts
new file mode 100644
index 000000000..c2268acca
--- /dev/null
+++ b/extension/src/utils/unknownNodeHistoryError.ts
@@ -0,0 +1,20 @@
+import { StudyError } from '../errors'
+
+/**
+ * Words the refusal of a Node test history reference that names no history of this workspace.
+ *
+ * Why: an agent that mistypes one character of a study id, or sends another workspace's, read the store's raw `ENOENT` as `RUNTIME_FAILED` ("The study operation failed.") with a recovery about owned resources and clicks, so it could not tell that only its reference was wrong (Cycle 0052 task 60).
+ * Trigger: {@link withKnownNodeHistory} calls it for the `codebook://node-history/<studyId>` resources and {@link StudyService.explainNodeHistory} when the store holds no folder for the id, before their read or save, or after it failed.
+ *
+ * @param studyId - The study id the agent sent.
+ * @returns A `NOT_FOUND` error that names the id and where to copy a valid one.
+ * @example
+ * throw unknownNodeHistoryError('8ec11caa-db39-4835-bc6c-c3810d95afcc_81e3d2d6-6bb6-4735-a560-e69b06d7b946')
+ * // message: 'No Node test history 8ec11caa-…-e69b06d7b946 is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.'
+ */
+export function unknownNodeHistoryError(studyId: string): StudyError {
+  return new StudyError(
+    'NOT_FOUND',
+    `No Node test history ${studyId} is saved in this workspace. Read codebook://node-history and copy the studyId or historyUri of the history you mean.`,
+  )
+}
diff --git a/extension/src/utils/withKnownNodeHistory.ts b/extension/src/utils/withKnownNodeHistory.ts
new file mode 100644
index 000000000..6cfeb1334
--- /dev/null
+++ b/extension/src/utils/withKnownNodeHistory.ts
@@ -0,0 +1,36 @@
+import type { NodeTestHistoryStore } from '../nodeTestHistoryStore'
+
+import { unknownNodeHistoryError } from './unknownNodeHistoryError'
+
+/**
+ * Runs one operation on a saved Node test history, refusing a study id this workspace holds no history for as unknown: before the operation, and when the history's folder is gone after it, whether it failed or answered.
+ * Why: a history removed while it is read (moved to the Trash from Saved studies, for example) failed with the store's raw `ENOENT` as `RUNTIME_FAILED`, the answer task 60 replaced for an unknown id (Cycle 0052 task 75).
+ * Called by the `codebook://node-history/<studyId>` resources ({@link readResource}) and {@link StudyService.explainNodeHistory}.
+ * @param store - The workspace's history store.
+ * @param studyId - The study id the agent sent.
+ * @param operation - The read or the save.
+ * @returns What the operation returned.
+ * @throws The `NOT_FOUND` error of {@link unknownNodeHistoryError} for an id without a history folder, before or after the operation, also when it answered; otherwise what the operation threw.
+ * @example
+ * const history = await withKnownNodeHistory(store, studyId, () => store.read(studyId))
+ */
+export async function withKnownNodeHistory<Value>(
+  store: Pick<NodeTestHistoryStore, 'holdsHistoryFolder'>,
+  studyId: string,
+  operation: () => Promise<Value>,
+): Promise<Value> {
+  // An id this workspace holds no history for (mistyped, or another workspace's) is a reference to correct, not a failed study operation.
+  if (!store.holdsHistoryFolder(studyId)) throw unknownNodeHistoryError(studyId)
+  let result: Value
+  try {
+    result = await operation()
+  } catch (error) {
+    // A history removed while the operation ran is as unknown as one never saved.
+    if (!store.holdsHistoryFolder(studyId))
+      throw unknownNodeHistoryError(studyId)
+    throw error
+  }
+  // So is one removed right after it answered: what it read belongs to a history that no longer exists (Cycle 0052 tasks 78, 86, 90, 94, 95).
+  if (!store.holdsHistoryFolder(studyId)) throw unknownNodeHistoryError(studyId)
+  return result
+}