diff --git a/docs/plans/2026-09-26-undo-close-derived-identity.md b/docs/plans/2026-09-26-undo-close-derived-identity.md
new file mode 100644
index 000000000..1a286d490
--- /dev/null
+++ b/docs/plans/2026-09-26-undo-close-derived-identity.md
@@ -0,0 +1,10 @@
+# Undo Close keeps a derived TLDR identity (#1347)
+
+## Problem
+Undo Close respawns a closed agent with `tldrIdentity: meta.tldrIdentity`. An agent whose identity is DERIVED has no explicit field. That happens when reporting domains are on but main created the agent, or its metadata arrived after it acquired TLDR or Goal. The rule is `tldrIdentityForSession`: the identity is the session id. Undo Close passes `undefined` for such an agent, so `spawn` mints a fresh UUID: the restored agent gets a new TLDR/Goal identity, and Agent Analytics (#1342 keys by it) splits its time. Reload Agents already passes `tldrIdentityForSession(oldId, meta)`.
+
+## Decision
+The Undo Close respawn uses `tldrIdentityForSession(closedSessionId, meta)`, the same rule as reload. `respawn` now takes the closed id; every caller has it (a single pane's entry, a project member).
+
+## Test
+`undoCloseFailure.renderer.test.tsx`: a closed agent with a reporting domain and no explicit identity is respawned with its closed session id as `tldrIdentity`; an explicit identity is still passed through unchanged. Red on main.
diff --git a/docs/plans/2026-09-27-cli-update-could-not-start.md b/docs/plans/2026-09-27-cli-update-could-not-start.md
new file mode 100644
index 000000000..69bb4a547
--- /dev/null
+++ b/docs/plans/2026-09-27-cli-update-could-not-start.md
@@ -0,0 +1,81 @@
+# An update that cannot start says so and stays dismissable (#1425)
+
+Size: short plan. The root cause is known and the change is bounded
+(found by #1423's review b).
+
+## Outcome
+
+When **Update Now** or an automatic update cannot start, the CLI update
+banner stops showing an undismissable "Updating…" row forever. It shows a
+dismissable failure in fixed words, with **Update now** to retry. A click
+whose IPC call rejects is also said instead of dropped.
+
+## Evidence (verified 2026-09-27, do not re-derive)
+
+- `CliUpdateOrchestrator.runUpdate` publishes `updating`, then awaits
+  `openLog(cli)`, which `mkdir`s `CLI_UPDATE_LOG_DIR` outside any catch.
+  An EACCES or ENOSPC there rejects, and the snapshot stays `updating`.
+  `describeState` marks `updating` as `undismissable`.
+- Every later await in `runUpdate` already swallows or returns a result:
+  - `appendLog` and `appendDiagnostics` catch;
+  - `readInstalledVersion` returns `{ ok }`;
+  - the command runs inside a try.
+
+  So `openLog` is the one throw that strands the state.
+- `CliUpdateBanner` fires `cliUpdatesUpdateNow` with `void` in both the
+  `notify` and the user-`deferred` rows. The IPC handler's rejection
+  (`updateOnce` throwing) is dropped, and nothing is said.
+- #1423 already gave banner actions a result contract: `onClick` may
+  resolve `false`, and the row then shows `failureText`, keyed by
+  `resultKey`.
+- `failed.logPath` is read only by the `cli-updates:open-log` handler and
+  the banner's `resultKey`.
+
+## Change
+
+- `@shared/types/cliUpdate`:
+  - `failed.logPath: string | null` (null = there is no log, because the
+    update never started);
+  - `CliUpdateFailureReason` adds `'could-not-start'`.
+- `runUpdate`: `openLog` runs in a try. On rejection it warns the cause
+  in main's log (never the renderer; q22) and publishes
+  `failed { reason: 'could-not-start', logPath: null }`, then returns
+  without running the command.
+  - Ruling: do not run the update without a log. A state dir we cannot
+    write to (ENOSPC, EACCES) makes a package install likely to fail too,
+    and a failure with no log would leave the user nothing to look at.
+    Cost if wrong: one retry after the user fixes the disk.
+- `cli-updates:open-log`: a `failed` state with `logPath === null` opens
+  nothing and answers `false`. The banner shows no View Log for it anyway.
+- Banner:
+  - `could-not-start` reads: "Couldn't start the <label> update: Agent
+    Code couldn't create its update log." The hint names disk space or
+    permissions on the Agent Code data folder. The action is **Update
+    now**, as a retry. Fixed words only.
+  - Every Update now action awaits `cliUpdatesUpdateNow`, resolves
+    `false` on rejection, and has `failureText` "Couldn't start the
+    update. Try again."
+
+## Tests (fail-first)
+
+- Orchestrator test: `mkdir` of the log dir rejects (EACCES). The snapshot
+  goes `updating` → `failed { reason: 'could-not-start', logPath: null }`,
+  the update command is never run, and nothing stays `updating`. Before
+  the fix: `updateOnce` rejects and the state stays `updating`.
+- Banner renderer test:
+  - a rejecting `cliUpdatesUpdateNow` shows the failure alert;
+  - `describeState` for `could-not-start` is dismissable, shows the fixed
+    sentence and offers Update now.
+  - Before the fix: no alert, and there is no such state.
+- `cli-updates:open-log` with a null `logPath` answers `false` without
+  calling `shell.openPath`.
+
+## Verification
+
+`npx tsc -b` and the scoped vitest runs. Boundary: the app is never
+launched, and a read-only state dir is simulated at the `fs` boundary.
+
+## Out of scope
+
+- Pruning `cli-update-logs` (nothing prunes it; unchanged).
+- The phone has no CLI update surface.
diff --git a/docs/plans/2026-09-27-conversation-prompts-unreadable.md b/docs/plans/2026-09-27-conversation-prompts-unreadable.md
new file mode 100644
index 000000000..9606f492a
--- /dev/null
+++ b/docs/plans/2026-09-27-conversation-prompts-unreadable.md
@@ -0,0 +1,82 @@
+# View Prompts says an unreadable conversation, not "no prompts" (#1306)
+
+Short plan: a bug with a known root cause (#1306, class C3, P3). Fixes #1306.
+
+## Outcome
+View Prompts on a conversation whose transcript or store is there but unreadable (damaged, or permission-broken) says "Couldn't read this conversation's prompts." instead of "no prompts". The issue asked to check every source: all five had the pattern.
+
+## Root cause (verified in source, origin/main)
+- **Pi** (`pi.ts`): `catch { return [] }` around resolution and branch reading. The package's resolution also skips a file whose header it cannot read, so an unreadable session reads as "no such session".
+- **Grok** (`grok.ts`): `catch { return [] }` around the snapshot load.
+- **Claude and Codex** read through `extractPromptsFromFile` (`promptFolder.ts`), which turned every stat and read failure into an empty answer.
+- **OpenCode** (`opencode.ts`): a store that could not be opened answered `[]`.
+- `ViewPromptsModal` showed the raw IPC message for a rejection (q22).
+
+## Design (contract)
+- **`ConversationPromptsUnreadable`** (`sources/types.ts`): a typed error with a fixed message and the cause.
+- **The rule for every source:** no file (yet) answers `[]`, because a fresh session has no transcript and View Prompts then shows the live feed. A file or store that is there but unreadable throws.
+  - `promptFolder` returns empty only for ENOENT/ENOTDIR, and rethrows anything else.
+  - Pi checks whether a file named for the session exists but cannot be opened.
+  - OpenCode throws only when `opencode.db` exists.
+- **The service's `prompts`** logs the cause in main and rethrows. Search already catches per conversation, so an unreadable one degrades to label-only.
+- **`ViewPromptsModal`** shows the fixed sentence.
+
+## Tests (real files: the recorded conversation corpus, made unreadable with chmod)
+- **`promptsUnreadable.system.test.ts`:** Claude, Codex, OpenCode (a non-database store) and Grok each throw the typed error, and a missing file is still `[]`.
+- **`pi.system.test.ts`:** the same for Pi.
+- **`service.system.test.ts`:** View Prompts rejects, and search still finds another conversation.
+- **`ViewPromptsModal.renderer.test.tsx`:** fixed words, no IPC text.
+- All red on main.
+
+## Out of scope
+- Discovery's own handling of unreadable files (it already counts them as `unreadable`).
+
+## Steering q116: finding the file is part of the rule
+- **The discovery step still mapped every failure to "not here".** That covered Claude's direct `stat` and the projects walk, Codex's rollout walk, and Pi's session listing, and it ran before the typed read handling, so a transient EACCES/EIO on a known conversation still read as "no prompts". Each now treats only ENOENT/ENOTDIR as absence and raises `ConversationPromptsUnreadable` for anything else.
+- **The Codex and Pi packages swallow their own `readdir` errors.** They answer "none", so each source probes its root directories first: Codex's `sessions`, and Pi's sessions root and per-cwd directory. The packages are unchanged.
+- **Tests (fail then recover, through `prompts()`):** an unlistable Claude project directory, then a successful read; an unlistable Codex sessions tree, then "no such thread" (a missing tree stays `[]`); an unlistable Pi session directory, then `[]`. All three are red on the previous head.
+- **History:** the branch is rebuilt so its first commit holds only this plan (worker-common line 33).
+
+## Review round 1 (a, b, c: FIX-BEFORE-MERGE), fixed fail-first
+
+- a, b (major): unknown still read as `[]` one level down.
+  - **Cause:** `existsSync` answers false for EACCES. That hit Codex's
+    known and indexed rollouts and OpenCode's database in a locked
+    directory.
+  - **Codex:** its walk skipped a locked `sessions/YYYY/MM/DD`, and an
+    index that is there but won't open, with no rollout found, gave `[]`.
+  - **Pi:** a session named for the id with a damaged header gave `[]`.
+  - **Grok:** a transcript without its `summary.json` gave `[]`.
+  - **Claude/Codex:** a transcript whose every line is garbage gave `[]`.
+  - Fixed in 0974c69b with `isPresent` and `assertTreeListable` (absent
+    vs unknown), `TranscriptUnparseable` in the prompt folder, a Pi header
+    parse check and a Grok sibling check. Six tests, all red on the
+    previous head.
+  - Also: an OpenCode query that fails after the open is typed, and a Grok
+    read racing its writer retries twice.
+- c (major, test gap): the Pi probe's "absent → `[]`" half. Pinned on a
+  fresh home with no `.pi`.
+- c (minor): ENOTDIR (a path through a plain file) is pinned as absence,
+  and the service's cause log is asserted.
+- c residuals, not changed:
+  - the prompt folder's stat catch is unreachable through the sources;
+  - the stat/read vanish race is untested;
+  - the Codex and Pi package-walk catches are unreachable (the packages
+    swallow their own errors, and the probes cover the real path);
+  - the modal showing the error above "no prompts found" is pre-existing.
+- b (minor), declined: an unrelated inaccessible Claude project aborts the
+  fallback walk. That is the stated contract (unknown is never "no
+  prompts"), and c judged it a design stance, not a defect.
+
+## Verification a (FIX-BEFORE-MERGE), fixed fail-first
+
+- **Codex:** the conversation's own rollout with an unreadable mode, in a
+  listable tree, still read as absent. The locator skips a file it cannot
+  open, and the tree check only listed directories. `assertTreeListable`
+  now also fails on a file named for this conversation.
+- **Pi:** a named file whose first row parses but is not this session's
+  header (another type, another id) still read as absent. Only a real
+  `session` header for this id can say "another cwd".
+- **Tests:** the OpenCode typed query error and the prompt folder's
+  cache-hit check are pinned.
+- Each of the four mutations is red.
diff --git a/docs/plans/2026-09-27-goal-loop-shutdown-dispose.md b/docs/plans/2026-09-27-goal-loop-shutdown-dispose.md
new file mode 100644
index 000000000..00130e188
--- /dev/null
+++ b/docs/plans/2026-09-27-goal-loop-shutdown-dispose.md
@@ -0,0 +1,34 @@
+# Dispose the goal loop at quit (#1372)
+
+## Evidence
+- **Mechanism, recorded:** #1341 (CI run 36156560842). `GoalLoopService` persists loop state with fire-and-forget `void this.persist()`. When its owner tore down first, the late write failed: 13 `[goal-loop] persisting loop state failed: ENOENT … rename …goal-loop.json.<uuid>.tmp` warnings, 12 `rename` and 1 `open`. There the owner was a test's `afterEach`. At quit it is the process exit, and there is no log line, because the process is gone.
+- **The drain exists:** #1371 added `GoalLoopService.dispose()`, which cancels timers, detaches the session manager, and awaits in-flight persists and continuations. It was left out of the shutdown inventory on purpose, because that inventory has its own owner and test (#1371 body).
+- **The gap, read from source:** `installApplicationShutdown` (`src/main/applicationShutdown.ts`) has no goal-loop stage, and `index.ts` keeps the service in a startup local, so shutdown cannot reach it.
+- **Not recorded:** a real quit that lost loop state. No production incident exists; this closes the window the #1341 mechanism leaves open at quit.
+
+## Constraints on placement
+- **After sessions stop:** a turn boundary from a live session starts a persist (and possibly a continuation), so disposing before `killAll()` settles could lose that last write.
+- **After the built-in MCP host stops:** `goal_loop_start` / `goal_loop_complete` reach the service through MCP tools, and a call after `dispose()` would be ignored.
+- **Before quit is allowed:** its drain must settle.
+That is the support-disposal wave beside control and caffeinate.
+
+## Change
+- `ApplicationShutdownServices.disposeGoalLoop` runs in that wave.
+- `index.ts` publishes `disposeGoalLoop` once the service exists (the `disposeControlHost` pattern).
+
+## Tests (fail-first)
+- `applicationShutdown.test.ts`, with deferred inventory services:
+  - dispose is not called while sessions are stopping or while the MCP host is stopping;
+  - quit waits for its drain.
+  - It fails on the pre-change inventory, and a mutation that disposes it in the first wave, beside sessions, also fails.
+- The existing veto test iterates every inventory entry, so an editor veto disposes nothing.
+- This models the inventory, not a real quit (the app is never launched in this loop).
+
+## Overlap
+W3's #1430 work (`.worktrees/worktree-timeout-consumers`) also edits `src/main/index.ts`, in different hunks (`resolveRepoRoot` / conversation setup). Merge order is the manager's call; the two changes do not interact.
+
+## Review a finding (fixed)
+`dispose()` waited only for work the service TRACKED. The public mutators (`goal_loop_start` / `goal_loop_complete` over MCP) awaited `persist()` without tracking it, so quit could still cut off their write, and the next launch turned a completed loop into paused(interrupted). `persist()` now tracks every write, awaited or not. Fail-first: complete and startLoop parked on a gated write keep `dispose()` pending; both are red without the tracking.
+
+## Residual
+The `index.ts` wiring (`disposeGoalLoop: () => disposeGoalLoop?.()`) is not unit-tested: `index.ts` has no composition test for any inventory entry. Review a's mutation that disconnects it survives. Adding one is out of scope under the freeze.
diff --git a/docs/plans/2026-09-27-orchestration-late-bootstrap.md b/docs/plans/2026-09-27-orchestration-late-bootstrap.md
new file mode 100644
index 000000000..2a55cff88
--- /dev/null
+++ b/docs/plans/2026-09-27-orchestration-late-bootstrap.md
@@ -0,0 +1,69 @@
+# Deliver the bootstrap prompt to a late-created orchestration child (#1370)
+
+## Problem
+`orchestration_create_agent` waits at most 30 s for the renderer's `create-agent` answer (`OrchestrationBridge.dispatchRendererRequest`). The renderer answers only after the child's provider has started, and a healthy but slow start can take longer: the bundled OpenCode took 16.7, 18.3 and 43.1 s under CPU contention (#1367 review a).
+
+When the deadline passes:
+- the caller gets `OrchestrationOutcomeUnknownError` ("do not repeat");
+- the MCP handler returns without delivering the prompt;
+- the late answer is adopted (`adoptLateResponse`) with `bootstrapPromptDelivered: false`.
+
+The parent is left with an idle child that never received its brief. It was told not to repeat the create, and nothing tells it the brief is missing.
+
+## Decision (the issue's option a)
+**When a timed-out create is adopted late, deliver its bootstrap prompt then**, through exactly the path a punctual create uses.
+- The tool handler hands the bridge a late-create continuation along with the request. The bridge keeps it on the abandoned pending entry and runs it from `adoptLateResponse`.
+- The handler's bootstrap delivery is extracted into one function that both paths call: deliver → `armPromptWhenReady` when the composer is not ready → mark the bootstrap delivered. The punctual and late paths therefore cannot drift.
+- The late path has no caller to answer, so its outcome (delivered / pending / failed) goes to the incident journal. The adoption incident now records whether a bootstrap was attempted.
+- **The timeout reply says so:** when a prompt was given, the outcome-unknown message adds that a child created late will receive its prompt automatically and must not be sent it again. Otherwise the parent's natural move, re-sending the brief after `list_agents` shows the child, would deliver it twice.
+
+**Rejected: option b** (deriving the create deadline from the provider's start budget). MCP clients have their own tool-call timeouts, and a Codex parent's defaults are shorter than 120 s. A longer deadline would turn "unknown" into the client's own opaque timeout.
+
+## Tests
+- `src/main/orchestration/timeoutOutcome.test.ts`: a create with a late-create continuation times out, then the renderer answers. The continuation runs once, with the adopted (enriched) agent. A FAILED late answer runs nothing. A create that answered in time never runs it.
+- The handler level: the create tool with a prompt, a renderer that answers after the deadline, and `deliverPromptToAgent` observed receiving the bootstrap for the late child. The timeout reply carries the "do not send it again" wording.
+- Fail-first: both are red on `origin/main`.
+
+## Review round 1 (a, codex at `2e4bd384`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **a1, major:** a late delivery refused as not-ready, on a provider with no readiness gate (OpenCode, Grok), left the child idle, though the parent had been told delivery was automatic | valid | The late path retries on a bounded backoff (2, 4, 8, 16, 30 s, about a minute). It stops as soon as any prompt has landed on the child, so there is never a second copy, and it records `create_agent_late_bootstrap_never_ready` if the child never gets ready. The punctual path is unchanged: its parent sees the failure and retries. The timeout reply no longer promises delivery outright; it says Agent Code retries while the child starts, and to check `orchestration_read_agent` for `promptSubmitted` before sending the brief. Tests: ready on the third try, never ready (6 attempts, then the incident, then nothing more), and a prompt landing some other way (stops). The "no landed check" mutant is red. |
+| **a2, major:** the late continuation could start the brief after the parent was closed mid-spawn | valid | `adoptLateResponse` checks the parent with the same `windowForSession` lease dispatch uses, and skips the delivery with an incident (`create_agent_late_bootstrap_parent_gone`). The child itself is left for the user: closing an agent is not this path's call. Test red at the previous head; the "no parent check" mutant is red. |
+| **a survivor:** `supersedesPendingPrompt: false` | noted | a judges `false` correct (a newer parent prompt keeps precedence). The late path never arms for providers without a readiness gate, and the retry loop's landed-prompt check covers the late-versus-parent race it would otherwise decide. |
+
+## Review round 1, b (codex at `cacd7ec0`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **b1, major:** the parent was checked once, at adoption; a parent that closed during a retry delay still had its brief delivered | valid | `OrchestrationBridge.isParentAttached` (the dispatch lease), checked before EVERY late attempt, with a `create_agent_late_bootstrap_parent_gone` incident. System test red with the check removed. |
+| **b2, minor:** the FAILED late-answer fixtures lacked `type`, so the `!response.ok` guard was never reached, and its removal survived | valid | Both fixtures carry `type: 'create-agent'`; removing the guard is red (2 tests). |
+| **b survivor:** removing every `lateCreates.delete` passed (the long-lived bridge would keep each create's continuation) | valid | Pinned: the map empties after an in-time create and after a late one. Removing the deletes is red. |
+
+## Review round 1, c (codex at `cacd7ec0`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **c1, major:** a parent closing during a retry delay still got its brief delivered | valid, **already fixed** in `5f54f8c0` (b1) | The parent is re-checked before every late attempt; c reviewed the prior head. |
+| **c2, minor:** the timeout reply promised more than the contract (a renderer that never answers means no delivery at all) | valid | The reply now says delivery is *attempted* if the renderer later confirms the child, names the ways it can fail, and tells the parent to check `orchestration_list_agents` and `orchestration_read_agent` (`promptSubmitted`) before sending. |
+| **c survivor:** shrinking the last backoff delay to 1 ms passed (only the total count was checked) | valid | Each wait is pinned exactly (no attempt 1 ms early, one exactly on time), with microtasks drained without moving the clock. The last-delay and first-delay mutants are both red. |
+
+## Review round 2 (a, b, c codex at `ed86637b`): all FIX-BEFORE-MERGE, the final round
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **a + b, major:** on a provider WITH a readiness gate (Claude, Codex), the late attempt arms a waiter that could deliver after the parent detached; the per-attempt check does not govern it | valid | `SessionManager.deliverPromptWhenReady` takes a `shouldDeliver` guard, asked the moment the gate opens, before anything is written; a refusal is `do-not-retry` with nothing written. The late path arms its waiter with the parent-lease check. Manager unit tests (refuse writes nothing / allow delivers as before) and a system test that the late waiter carries the guard. Red at `ed86637b`. |
+| **c, major:** the renderer files the child before its create answer reaches main, so the parent can send first; adoption reset the child's record to zero and the late bootstrap sent a second brief | valid | Adoption keeps an existing delivery record. A system test sends through the real `orchestration_send_prompt` before the late answer: one delivery in all. Red at `ed86637b`. |
+| **c, minor:** a reservation collision (the parent's send in flight) ended the late loop | valid | A `reservation` / `delivery-in-flight` result on the late path retries, re-checking the landed count and the parent first. Red at `ed86637b`. |
+| **b, minor:** the stop test called `notePromptSubmitted` directly, so removing it from `send_prompt` survived | valid | The test sends through the real `orchestration_send_prompt` during a retry delay; the bookkeeping mutant is red. |
+
+## After #1369 merged (q85 / q86)
+
+- **Main merged into this branch** (`36830732`), because W2's patch builds on #1369. The one conflict was in `adoptLateResponse`: this PR's record-preserving set is kept, alongside #1369's `noteCreatedChild`, which files the child under the parent's LIVE id.
+- **W2's patch applied** (`temp/q85/1375-late-warning.patch`):
+  - a new incident kind `orchestration.bootstrap_mark_failed`, recorded on the late path only;
+  - the punctual path keeps its reply warning;
+  - the combined case: a late create whose parent is REPLACED during the late window.
+
+  Its `deliverBootstrap(…, late)` signature matched this PR's, so the ours side was kept for the signature, and W2's journal branch and tests were merged in.
+- **`isParentAttached` resolves through #1369's alias chain** (`currentParentId`): a parent replaced during the late window is carried to its successor, and the brief follows it. Only a parent with no live successor counts as gone. Without this, W2's replaced-parent test fails, because the brief would have been skipped as parent-gone. Removing the resolution is red.
diff --git a/docs/plans/2026-09-27-provider-switch-projection-fidelity.md b/docs/plans/2026-09-27-provider-switch-projection-fidelity.md
new file mode 100644
index 000000000..8dca931c9
--- /dev/null
+++ b/docs/plans/2026-09-27-provider-switch-projection-fidelity.md
@@ -0,0 +1,77 @@
+# Carry the native projection report through switch, duplicate and rewind (#927)
+
+Short plan: bug with a known root cause. Part of #918's B06; see `docs/superpowers/plans/2026-09-12-session-operation-ownership.md` §6.2.
+
+## Outcome
+`switchProvider`, `duplicateSession` and `rewindSession` each call a real native-resume projector. Each writes `projection.values` and throws `projection.report` away, so nobody can see what the projector preserved, dropped, demoted, repaired or synthesized. A switch returns only `shrinkSummary`, which describes context REDUCTION (the fit ladder) and is null whenever nothing had to be shrunk, even when the projection itself lost content.
+
+After this change, all three results carry a bounded, curated `projectionFidelity` summary of the real report, through IPC to the renderer. A switch or duplicate that loses material content says so in its existing pane toast, even when the context reduction reports no shrink.
+
+## Evidence (verified 2026-09-27 against the recorded Stage 0 sequences; do not re-derive)
+All 13 `packages/agent-transcript-parser/fixtures/evidence/observed-sequences/*` cases were projected through the REAL projectors (Claude 2.1.0 / Codex 0.157.1 profiles):
+- **Every Codex case loses something in both directions,** including Codex → Codex, which is what a duplicate or rewind does.
+  - The codes seen: `opaque.dropped` 1–30, and to Claude also `message.developer.dropped`, `reasoning.foreign-dropped` and `tool-call.input-object-repaired`.
+- **Claude → Codex:** `reasoning.encrypted-content-demoted` (19–485), `tool-result.error-status-demoted`, `compaction.foreign-summary-demoted` and `content.image.dropped`.
+- **Claude → Claude:** mostly lossless; `claude-sequence-oversized-turns` drops 110 opaque records and repairs 4 tool results.
+- **Framing** (`session-meta.synthesized`, `turn-framing.synthesized`) appears on every Codex target. It is identity and framing, not user-visible loss.
+- `ProjectionChange.message` is projector prose; `code` is a closed vocabulary (`native-resume.<entry>.<outcome>`). `evidence` carries source claims.
+
+## Design (contract)
+- **`src/shared/types/projectionFidelity.ts`:**
+  - `NativeProjectionFidelity = { profile: 'native-resume', sourceProvider, targetProvider, providerProfileId, providerEvidence: { sourceCommit?, cliVersion?, observedAt? }, counts: Record<kind, number>, codes: Array<{ kind, code, count, sourceLines: number[] }>, sourceLinesOmitted: number }`.
+  - One `codes` row per distinct (kind, code). `sourceLines` is capped at 20 per row, and the rest is COUNTED in `sourceLinesOmitted`, never silently dropped.
+  - **Excluded on purpose:** `message` and `evidence`. The summary crosses IPC and reaches the UI, where only curated text may appear (q22/q39); the code identifies each change without projector prose or source content.
+- **`src/main/providerSwitch/projectionFidelity.ts`:** `summarizeProjectionReport(result: NativeResumeProjectionResult): NativeProjectionFidelity`. It is pure and is called right after each `projectNativeResume`, before `write`, so the summary exists even if publication fails later. (Receipts are B07; nothing here pretends to persist one.)
+- **Results:** `SwitchProviderResult` (the `switched` arm), `DuplicateSessionResult` and `RewindSessionResult` gain `projectionFidelity: NativeProjectionFidelity`. The preload types use the shared type.
+- **`materialProjectionLoss(f): string | null`**, one line for toasts, or null.
+  - **OWNER-APPROVED (B6 proxy, 2026-09-27):** material means `dropped` changes other than `native-resume.opaque.dropped`, plus every `demoted` change.
+  - Opaque records, repairs and synthesized framing are not disclosed in the toast; they remain inspectable in the result.
+  - **Format, OWNER-APPROVED (B6 proxy, 2026-09-27):** `history: 12 dropped, 19 demoted`. It is wording only, no data change.
+- **Renderer:**
+  - The switch pane toast (`workspace/hook/actions/provider.ts`) appends the line and uses the longer lossy duration when it is present.
+  - The bulk switch summary (`bulkProviderSwitch.ts`) adds it to its notes.
+  - The duplicate command's toast (`sessionCommands.ts`) appends it too.
+  - Rewind carries the field for inspection. Its own toast lives in `pane.ts`, which open PR #1369 (another worker) edits, so it is not touched here; see Out of scope.
+
+## Tests
+- **Real reports, real projectors:** `switchProvider`, `duplicateSession` and `rewindSession` tests use a recorded sequence through the REAL transcript engine projector.
+  - Only disk writes and lookups stay mocked, because a projection mock returning only `values` cannot prove this contract (B06 exit gate).
+  - Each asserts the result's `projectionFidelity` equals `summarizeProjectionReport` of that real projection, with non-zero loss.
+  - The switch case has a null `shrinkSummary`, so loss is visible without context reduction.
+  - All red on main: the field is absent.
+- **`summarizeProjectionReport` on a real report:** grouping, the 20-line cap with the omitted count, and no `message`/`evidence` fields in the output.
+- **`materialProjectionLoss`** on recorded counts: Codex → Claude and Claude → Codex are material; `codex-sequence-compaction` → Codex (opaque only) is null.
+- **Renderer:**
+  - the switch toast includes the line for a material fidelity result;
+  - the bulk notes include it;
+  - the duplicate toast includes it.
+
+## Verification boundary
+Main-process tests drive the real entry points with real projectors; the app is not launched. The toast wording is OWNER-APPROVED (B6 proxy, 2026-09-27).
+
+## Out of scope
+- **B07 receipts / operation records:** no receipt store exists yet. The summary is on the result, which is what the client can inspect today.
+- **The rewind toast in `pane.ts`:** open PR #1369 edits that file. The rewind result carries the field for a follow-up.
+- **Draft-restoration reports** (#929) and literal-markup provenance (#930).
+
+## Review round 1 (a and c: FIX-BEFORE-MERGE; b: FIX, test gaps) and steering q90
+- **a (major): a publication that rejects after the effect loses the summary.** It may have linked the native file.
+  - **Ruling:** narrow the claim instead of carrying the summary on the failure. Electron's IPC keeps only an error's message, so a summary on a thrown error never reaches the renderer. A new failure arm on all three results is #918 B07's receipt work.
+  - The comments now say the summary is returned only on success.
+  - A recorded-sequence test pins it: a write that rejects after receiving the projection rejects the operation with that error and returns no success-shaped result.
+- **c (major): the control entry points discarded the summary.**
+  - `agents.switchProvider` and `agents.rewind` (through the `result` helper) and `agents.duplicate` now return `projectionFidelity`, and their descriptions name it. Duplicate is no longer called "exact".
+  - The rewind action returns it and names material loss in its toast.
+  - Correction: the rewind toast lives in `provider.ts`, not in `pane.ts` as this plan first said, so it is in scope.
+- **a (major): toast order.** Material loss now comes before the shrink prose, because PaneToast clamps to three lines.
+- **Pins, each killing its surviving mutation:**
+  - the populated main → renderer relay (`providerSwitchCore`);
+  - the forward bulk note;
+  - the unplaced (row-menu) duplicate toast;
+  - the control relay, through the real rewind action;
+  - the rewind toast;
+  - exact source lines per code, the profile id, and `counts` copied rather than aliased.
+- **b:** the false comment "every recorded sequence loses something" is corrected (two Claude sequences are lossless).
+- **Still for the owner:**
+  - the material rule (b notes that `reasoning.encrypted-content-demoted` and `tool-result.error-status-demoted` keep their content, so every Claude → Codex switch toasts a demotion line);
+  - the wording.
diff --git a/docs/plans/2026-09-27-skills-curated-errors.md b/docs/plans/2026-09-27-skills-curated-errors.md
new file mode 100644
index 000000000..b2f0c46e9
--- /dev/null
+++ b/docs/plans/2026-09-27-skills-curated-errors.md
@@ -0,0 +1,81 @@
+# Skills surfaces show curated errors, not raw filesystem text (#1427)
+
+**Verified on origin/main `6dd23a49`.** Two real-filesystem tests reproduce the leak:
+- **A read-only `.claude` folder:** the target row read `EACCES: permission denied, mkdir '<home>/.claude/skills'`.
+- **A state file under a file:** the recovery banner read `…: ENOTDIR: not a directory, lstat '<path>/conventions.json'`.
+
+The cause is `safeErrorMessage`, which returned `error.message` unchanged. Its copies lived in the service, `persistence`, `skillPathSafety` and `githubSkillSource`, and three more sites in `githubSkillSource` / `installedSkillMaterializer` passed `error.message` directly.
+
+## Decision
+One mapper, `userFacingError.ts` `userFacingSkillError(error, context)`, replaces all four copies and the three direct sites.
+
+| Input | Shown |
+|---|---|
+| A Node system error (an errno `code` plus `syscall` or `errno`) | A fixed sentence per code: permissions, read-only, disk full, missing, in the way, busy, out of files, network. Any other code gets the generic sentence. |
+| Any other `Error` whose message has no absolute path and is at most 300 characters | The message, **kept**: it is the service's own curated text (validation, product-skill conflicts) that users need. |
+| Anything else (a path in the text, too long, not an Error) | The generic sentence. |
+
+The raw error always goes to the main log whenever the text is rewritten (q22).
+
+**Not changed:**
+- Fields that carry a path **on purpose**: `recovery.stateFilePath` (the reveal action) and target `displayPath`. Only prose `message` fields are curated.
+- #1424's fixed recovery-reset sentence stays as it is.
+
+## Tests
+- **System (`AgentCodeConventionsService.system.test.ts`):** the read-only skills folder and a state file whose parent is a file. Both are red on main; the pass-through mutant is red (2 failed).
+- **Unit (`userFacingError.test.ts`):**
+  - a real `rmdir` ENOENT is mapped and logged;
+  - curated text is kept and not logged;
+  - path-bearing (POSIX, `/private/var`, Windows) and oversized text is replaced;
+  - an unknown errno and a non-Error value get the generic sentence;
+  - a network errno.
+- Every `agentCodeConventions` suite passes, and `npx tsc -b` prints 0 lines.
+
+## Review round 1 (a, codex at `c8463b71`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **a1, major:** the four Reveal handlers returned `shell.openPath`'s raw string (`Failed to open /Users/…`) | valid | **Fixed:** `revealFailureMessage` gives a fixed sentence and logs Electron's text. All four handlers are pinned in `recoveryReveal.test.ts`; red against the old handlers. |
+| **a2, major:** unclassified git and fetch errors passed through, because the mapper kept ANY short message | valid | **Fixed at the source:** git's fallback, fetch, the YAML parse message (now "near line N") and `toJS` failures each get a fixed sentence with the raw error logged. **Fixed in the mapper:** only text from exactly a plain `Error` or the package's `GitHubSkillSourceError` can be kept. Child-process errors (`cmd` / `stderr`) and library subclasses (`TypeError`, `SyntaxError`, YAML) get the generic sentence, as does any multi-line text. |
+| **a3, major:** the path filter missed `/tmp`, `~/`, `../`, quoted `/tmp` and `\\server` | valid | **Fixed:** `PATH_LIKE` catches all five, plus drive letters and `file://`. Every spelling is pinned. |
+| **a4, minor:** IPC rejections shown via `cause.message` in the renderer; the YAML parser text | valid | **The YAML half is fixed here. The renderer half is filed as #1459:** it spans about 15 renderer catch sites, a separate surface, filed under the PR freeze. |
+| **a survivors:** the git fallback, and logging only system errors | valid | **Pinned:** a real child-process failure drives the fallback, and every generic rewrite asserts its log. Both mutants red, as are "keep any Error" and "no child-process rule". |
+
+**Why not an allowlist class for every throw:** marking all 67 plain `throw new Error` sites is a large diff the freeze rules out. The constructor rule has the same effect for library errors, and those throws are this package's own fixed text.
+
+## Review round 1, b (codex at `c8463b71`, the pre-fix head): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **b1 + b3, major:** skillPathSafety's symlink and not-a-directory errors put the path in the message. A root-level `/tmp` was shown as is; a longer path lost the reason to the generic sentence. | valid | The messages are path-free and specific ("A folder on the skill path is a symbolic link, which Agent Code does not follow." / "A file is in the way where a folder on the skill path should be."). The path rides on `error.path`, which the mapper logs. Real-filesystem symlink test; red at `5d5e8c8d`. |
+| **b2, major:** fetch's `TypeError('fetch failed')` was kept raw, with no log | valid (already fixed in `5d5e8c8d`) | Pinned: a Node-shaped fetch rejection gets the fixed sentence and its cause is logged. The raw-message mutant is red. |
+| **b4, minor:** errno sentences named "skill" locations for state-file failures | valid | Every sentence is location-neutral (the row says where), and the generic one too. Each code is pinned to its exact words; b's ENOTDIR→ENOENT mutant is red. |
+| **b5, minor:** classified git failures dropped the raw error from the log | valid | `classifyGitHubSkillSourceError` logs the raw error once for every branch. Test red at `5d5e8c8d`. |
+
+## Review round 1, c (codex at `356c14b8`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **c1, major:** a bracketed path (`Provider failed [/Users/…]`) was kept, because `[` was not a listed delimiter | valid | `PATH_LIKE` treats ANY non-word character before the slash as a path start (bracket, brace, angle, comma and semicolon forms pinned). Prose with a letter before the slash (`and/or`, `file/folder`) and relative package paths are pinned as kept. The old-regex mutant is red. |
+| **c2, minor:** the logging of some rewrites was unpinned (suppressing it for ENOTDIR, or for TypeError, passed) | valid | Every errno code in the table and the TypeError case assert the raw error is logged, and the ENOTDIR system test asserts its log. Both mutants red. |
+| **c3, minor:** the per-code table was only partly pinned (EDQUOT → the network sentence passed) | valid | All 18 codes are pinned to their exact sentences; the mutant is red. |
+
+c also confirmed both #1427 system tests fail on origin/main for the stated reason.
+
+## Review round 2 (the final round), c (codex at `a037caff`): FIX-BEFORE-MERGE
+
+| Finding | Verdict | Change |
+|---|---|---|
+| **c1, major:** a period before an absolute path (`failed./var/…`) was kept, because `.` and `-` counted as word characters | valid | `PATH_LIKE` is blunt: a `/`, `./` or `../` after anything that is not a letter, digit or `_` is a path start, whatever follows (`/]` too). A spaced ` / ` in prose is rewritten, which fails closed; no curated message has one. Red at `a037caff`. |
+| **c2, minor:** the 60 s fetch abort logged nothing | valid | The AbortError is logged before the fixed sentence. Fake-timer test, red at `a037caff`. |
+| **c3, minor:** the YAML parser branch logged nothing | valid | The parser's first error is logged. Red at `a037caff`. |
+| **c4, minor:** the file-in-the-way reason had no test | valid | A real-filesystem test (a file where `.agents` should be); the path-in-message mutant is red. |
+
+## Review round 2, a and b (codex at `a037caff`)
+
+| Finding | Verdict | Change |
+|---|---|---|
+| a1 / b1 / b2: the YAML parse and fetch-timeout rewrites were not logged; b's "remove the timeout branch" survivor | valid, **already fixed** in `ad031252` (c2, c3) | Both log. The fake-timer test asserts the timeout sentence, so deleting the branch is red. |
+| **a2 / b1, minor:** the YAML line number never appeared (`linePos` is unset with prettyErrors off) | valid | The line is computed from the error's offset (the frontmatter starts on file line 2). Tests now REQUIRE `near line 3` for a broken flow sequence and for a duplicate key; the old `linePos` mutant is red. |
+| **a3, minor:** a foreign class NAMED GitHubSkillSourceError passed the own-text check | valid | By identity: a plain `Error`, or `instanceof GitHubSkillSourceError`. The mapper can import it now, because githubSkillSource no longer imports the mapper, so there is no cycle. A foreign same-name class gets the generic sentence and is logged. |
+| a / b survivor: the FILE_COMPONENT wording | valid, **already fixed** in `ad031252` (c4) | A real-filesystem test pins it. |
diff --git a/docs/plans/2026-09-27-workflow-expired-run.md b/docs/plans/2026-09-27-workflow-expired-run.md
new file mode 100644
index 000000000..7cb12bacb
--- /dev/null
+++ b/docs/plans/2026-09-27-workflow-expired-run.md
@@ -0,0 +1,21 @@
+# Workflow run whose stored data is gone (#1348)
+
+## Evidence
+- `WorkflowBridge.getSnapshot` returns `null` only for `run-not-found` in the scope it was asked; every other failure throws.
+- The renderer store turned that `null` into `phase: 'error'` ("not found in this project") with Retry. `WorkflowRunView` then fell back to the reference's launch-time status, so a `failed` reference kept **Resume**, which can only fail with `run-not-found`.
+- The history dialog showed the same run as "Unknown · Status unavailable" / "Timestamp unavailable", which reads as a fault.
+
+## Change
+- A new store phase, `missing`, distinct from `error` (a failed read that proves nothing keeps Retry and the reference's actions).
+- `model/missingRun.ts` names it for both surfaces. **Expired** when the reference carries its own `cwd`: it was looked up in its own project, so its stored data is gone (usually retention; a moved project folder looks the same, so the text does not claim the cause). **Unavailable** when it does not: it was looked up in the session's project, which proves only absence there.
+- Run view: that label replaces the status, no Resume, no Cancel, no Retry, one line saying why. Dialog: "Inactive · Expired", with the same line in place of the timestamps.
+
+## Not done
+- No day count in the text: the windows live in workflow-mcp and differ by lineage, so a copied number would drift.
+- Resume racing retention (the run removed after the view loaded) still shows the store's `run-not-found` message. That window is minutes wide against a 30-day retention, and a message match on the error text would be fragile.
+
+## Review round 1 (a + b), fixed
+- **One label.** workflow-mcp looks the manifest up GLOBALLY by run id before checking the project scope (a run in another project is `scope-forbidden`, not null), so `null` always means the run is gone from this app's store. The Expired/Unavailable split by `cwd` misdescribed that and is removed: every missing run is Expired.
+- **No action while loading.** Resume and Cancel appear only once the store has answered. While loading, the header shows the reference's launch-time status, and a Resume clicked then on a run that turned out to be gone failed with run-not-found.
+- **The selector agrees.** A tab labelled Active from its launch-time reference now checks, once, whether its run still exists (`useMissingRunIds`: only tabs that claim to be active, at most three). A missing run's tab is Inactive · Expired. A failed read changes nothing.
+
diff --git a/src/main/agentCodeConventions/AgentCodeConventionsService.system.test.ts b/src/main/agentCodeConventions/AgentCodeConventionsService.system.test.ts
index c26dd76dc..03f4b51c0 100644
--- a/src/main/agentCodeConventions/AgentCodeConventionsService.system.test.ts
+++ b/src/main/agentCodeConventions/AgentCodeConventionsService.system.test.ts
@@ -728,3 +728,71 @@ describe('recovery reset that cannot remove the state file', () => {
     }
   })
 })
+
+// #1427: every user-visible message on the Skills surfaces is curated (q22,
+// q39). safeErrorMessage passed Node's own text through, so an EACCES or
+// ENOTDIR reached the UI as `EACCES: permission denied, mkdir '/Users/…'`.
+// Real filesystem only; the raw error stays in the main log.
+describe('user-visible errors name the problem, never the path or the OS text (#1427)', () => {
+  it('a read-only skills folder', async () => {
+    const { root, service } = await harness()
+    const skills = join(root, '.claude')
+    await mkdir(skills, { recursive: true })
+    await chmod(skills, 0o500)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      await service.save({ expectedRevision: 0, enabled: true, markdown: '# Rules' })
+      const failed = (await service.getSnapshot()).targets.filter(target => target.state === 'error')
+      expect(failed.length).toBeGreaterThan(0)
+      for (const target of failed) {
+        expect(target.message).not.toContain(root)
+        expect(target.message).not.toMatch(/EACCES|EPERM|permission denied,/)
+        expect(target.message).toMatch(/permission/i)
+      }
+      expect(warn).toHaveBeenCalled()
+    } finally {
+      await chmod(skills, 0o700)
+      warn.mockRestore()
+    }
+  })
+
+  it('a state file whose parent is a file', async () => {
+    const root = await temporaryDirectory()
+    await writeFileWithParents(join(root, 'blocker'), 'a file where a folder should be')
+    const service = new AgentCodeConventionsService({
+      stateFilePath: join(root, 'blocker', 'conventions.json'),
+      homeDirectory: root,
+      resolveTargets: async () => ({ targets: [], unsupportedProviders: [] }),
+    })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      await service.initialize()
+      const saved = await service.save({ expectedRevision: 0, enabled: false, markdown: '# Rules' })
+      // Only the MESSAGE fields: `recovery.stateFilePath` and each target's
+      // `displayPath` carry a path on purpose (the reveal action, the target
+      // list); prose must not.
+      const messages: string[] = []
+      const collect = (value: unknown): void => {
+        if (Array.isArray(value)) value.forEach(collect)
+        else if (value && typeof value === 'object') {
+          for (const [key, inner] of Object.entries(value)) {
+            if (key === 'message' && typeof inner === 'string') messages.push(inner)
+            else collect(inner)
+          }
+        }
+      }
+      collect(saved)
+      collect(await service.getSnapshot())
+      expect(messages.length).toBeGreaterThan(0)
+      for (const message of messages) {
+        expect(message).not.toContain(root)
+        expect(message).not.toMatch(/ENOTDIR|not a directory,/)
+      }
+      // The raw error goes to the log (review of #1456, c: suppressing only
+      // the ENOTDIR log passed every test).
+      expect(warn).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ code: 'ENOTDIR' }))
+    } finally {
+      warn.mockRestore()
+    }
+  })
+})
diff --git a/src/main/agentCodeConventions/AgentCodeConventionsService.ts b/src/main/agentCodeConventions/AgentCodeConventionsService.ts
index 0b0999ca4..24e132f4b 100644
--- a/src/main/agentCodeConventions/AgentCodeConventionsService.ts
+++ b/src/main/agentCodeConventions/AgentCodeConventionsService.ts
@@ -145,6 +145,7 @@ import {
   type SetAgentCodeInstalledSkillProvidersRequest,
 } from '@shared/types/agentCodeInstalledSkills.js'
 import type { AgentCodeCustomSkillRecord } from '@shared/types/agentCodeConventions.js'
+import { userFacingSkillError } from './userFacingError.js'
 
 // See docs/design/agent-code-conventions.md for the canonical ownership and
 // reconciliation invariants enforced by this service.
@@ -291,7 +292,7 @@ export class AgentCodeManagedSkillsService {
           providers: [],
           displayPath: this.displayPath(this.stateFilePath),
           state: 'error',
-          message: safeErrorMessage(error),
+          message: userFacingSkillError(error),
         }]
         for (const skill of Object.values(this.document.customSkills)) {
           this.customTargetStatuses.set(skill.id, [{
@@ -299,7 +300,7 @@ export class AgentCodeManagedSkillsService {
             providers: [],
             displayPath: this.displayPath(this.stateFilePath),
             state: 'error',
-            message: safeErrorMessage(error),
+            message: userFacingSkillError(error),
           }])
         }
         for (const skill of Object.values(this.document.installedSkills)) {
@@ -308,7 +309,7 @@ export class AgentCodeManagedSkillsService {
             providers: [],
             displayPath: this.displayPath(this.stateFilePath),
             state: 'error',
-            message: safeErrorMessage(error),
+            message: userFacingSkillError(error),
           }])
         }
       }
@@ -1915,7 +1916,7 @@ export class AgentCodeManagedSkillsService {
       } catch (error) {
         this.installedTargetStatuses.set(
           skill.id,
-          targets.targets.map(target => this.installedStatus(target, 'error', safeErrorMessage(error))),
+          targets.targets.map(target => this.installedStatus(target, 'error', userFacingSkillError(error))),
         )
         return
       }
@@ -1949,7 +1950,7 @@ export class AgentCodeManagedSkillsService {
         } catch (error) {
           this.installedTargetStatuses.set(
             skill.id,
-            targets.targets.map(target => this.installedStatus(target, 'error', safeErrorMessage(error))),
+            targets.targets.map(target => this.installedStatus(target, 'error', userFacingSkillError(error))),
           )
           return
         }
@@ -1974,7 +1975,7 @@ export class AgentCodeManagedSkillsService {
       } catch (error) {
         this.installedTargetStatuses.set(
           skill.id,
-          targets.targets.map(target => this.installedStatus(target, 'error', safeErrorMessage(error))),
+          targets.targets.map(target => this.installedStatus(target, 'error', userFacingSkillError(error))),
         )
         return
       }
@@ -2100,7 +2101,7 @@ export class AgentCodeManagedSkillsService {
           providers: [],
           displayPath: this.displayPath(this.stateFilePath),
           state: 'error',
-          message: safeErrorMessage(error),
+          message: userFacingSkillError(error),
         })
         this.installedTargetStatuses.set(skill.id, statuses)
       }
@@ -2207,7 +2208,7 @@ export class AgentCodeManagedSkillsService {
     return {
       ok: false,
       code: 'io-error',
-      message: safeErrorMessage(error),
+      message: userFacingSkillError(error),
       snapshot: this.installedSnapshot(),
     }
   }
@@ -3004,7 +3005,7 @@ export class AgentCodeManagedSkillsService {
       delete this.document.pendingOperations[item.target.id]
       return this.status(item.target, 'installed')
     } catch (error) {
-      return this.status(item.target, 'error', safeErrorMessage(error))
+      return this.status(item.target, 'error', userFacingSkillError(error))
     }
   }
 
@@ -3089,7 +3090,7 @@ export class AgentCodeManagedSkillsService {
       // Keep the journal on unexpected failure. In particular, a crash-safe
       // delete may have captured bytes in its operation-derived quarantine;
       // dropping the pending id would make that exact sidecar unrecoverable.
-      return baseStatus('error', safeErrorMessage(error))
+      return baseStatus('error', userFacingSkillError(error))
     }
   }
 
@@ -3147,7 +3148,7 @@ export class AgentCodeManagedSkillsService {
       delete this.document.pendingOperations[item.key]
       return this.customStatus(item.target, 'installed')
     } catch (error) {
-      return this.customStatus(item.target, 'error', safeErrorMessage(error))
+      return this.customStatus(item.target, 'error', userFacingSkillError(error))
     }
   }
 
@@ -3235,7 +3236,7 @@ export class AgentCodeManagedSkillsService {
       delete this.document.pendingOperations[key]
       return baseStatus('not-installed')
     } catch (error) {
-      return baseStatus('error', safeErrorMessage(error))
+      return baseStatus('error', userFacingSkillError(error))
     }
   }
 
@@ -3388,14 +3389,14 @@ export class AgentCodeManagedSkillsService {
       this.targetResolutionError = null
       return true
     } catch (error) {
-      this.targetResolutionError = safeErrorMessage(error)
+      this.targetResolutionError = userFacingSkillError(error)
       this.targets = { targets: [], unsupportedProviders: [] }
       this.targetStatuses = [{
         id: 'provider-target-resolution',
         providers: [],
         displayPath: '',
         state: 'error',
-        message: safeErrorMessage(error),
+        message: userFacingSkillError(error),
       }]
       // A previous successful audit may have left every custom AND installed
       // target marked Installed. Once discovery itself fails, those paths are
@@ -3409,7 +3410,7 @@ export class AgentCodeManagedSkillsService {
         providers: [],
         displayPath: '',
         state: 'error',
-        message: safeErrorMessage(error),
+        message: userFacingSkillError(error),
       }
       for (const skill of Object.values(this.document.customSkills)) {
         this.customTargetStatuses.set(skill.id, [{ ...resolutionError }])
@@ -3430,7 +3431,7 @@ export class AgentCodeManagedSkillsService {
         providers: [],
         displayPath: this.displayPath(this.stateFilePath),
         state: 'error',
-        message: safeErrorMessage(error),
+        message: userFacingSkillError(error),
       })
     }
   }
@@ -3448,13 +3449,13 @@ export class AgentCodeManagedSkillsService {
       // would leave bytes that Agent Code can neither prove nor safely clean.
       // Availability loses to ownership truth at this exact boundary.
       statuses.push(target
-        ? this.status(target, 'error', safeErrorMessage(error))
+        ? this.status(target, 'error', userFacingSkillError(error))
         : {
             id: 'managed-skills-state',
             providers: [],
             displayPath: this.displayPath(this.stateFilePath),
             state: 'error',
-            message: safeErrorMessage(error),
+            message: userFacingSkillError(error),
           })
       return false
     }
@@ -3641,7 +3642,7 @@ export class AgentCodeManagedSkillsService {
     return {
       ok: false,
       code: 'io-error',
-      message: safeErrorMessage(error),
+      message: userFacingSkillError(error),
       snapshot: this.snapshot(),
     }
   }
@@ -3650,7 +3651,7 @@ export class AgentCodeManagedSkillsService {
     return {
       ok: false,
       code: 'io-error',
-      message: safeErrorMessage(error),
+      message: userFacingSkillError(error),
       snapshot: this.customSnapshot(),
     }
   }
@@ -3696,17 +3697,13 @@ export { AgentCodeManagedSkillsService as AgentCodeConventionsService }
 // WHY a fixed sentence for a failed recovery reset (#1424 review a): the
 // unlink error carries the state file's absolute path and the OS code, and
 // the recovery panel shows the result's message as it is. The raw error stays
-// in the main log for diagnosis (q22). The rest of this service still passes
-// error.message through; that wider sweep is a separate issue.
+// in the main log for diagnosis (q22). Every other message in this service
+// goes through userFacingSkillError (#1427).
 function recoveryResetError(error: unknown): Error {
   console.warn('[agent-code-conventions] recovery reset failed:', error)
   return new Error("Couldn't remove the unreadable state file. Check that Agent Code's data folder is writable, then try again.")
 }
 
-function safeErrorMessage(error: unknown): string {
-  if (error instanceof Error && error.message) return error.message
-  return 'Unknown filesystem error'
-}
 
 function installedDiscoveryError(error: unknown): {
   ok: false
@@ -3716,7 +3713,7 @@ function installedDiscoveryError(error: unknown): {
   if (error instanceof GitHubSkillSourceError) {
     return { ok: false, code: error.code, message: error.message }
   }
-  return { ok: false, code: 'io-error', message: safeErrorMessage(error) }
+  return { ok: false, code: 'io-error', message: userFacingSkillError(error) }
 }
 
 function installedAcquisitionError(error: unknown): AgentCodeInstalledSkillsMutationResult {
diff --git a/src/main/agentCodeConventions/githubSkillSource.test.ts b/src/main/agentCodeConventions/githubSkillSource.test.ts
index 3f9b0b925..ebbd3101a 100644
--- a/src/main/agentCodeConventions/githubSkillSource.test.ts
+++ b/src/main/agentCodeConventions/githubSkillSource.test.ts
@@ -645,4 +645,109 @@ describe('bounded GitHub transport', () => {
       1_024,
     )).rejects.toThrow(/acquisition limit/)
   })
+
+  // Review of #1456 (a): an unclassified git failure and the YAML parser's
+  // wording both reached Add Skill as raw text. A real child-process failure,
+  // with a temporary path in its stderr, drives the fallback.
+  it('answers an unclassified git failure with a fixed sentence, never its stderr or path', async () => {
+    const { execFile } = await import('node:child_process')
+    const { promisify } = await import('node:util')
+    const failure = await promisify(execFile)(process.execPath, ['-e', "process.stderr.write('fatal: unexpected git failure at /tmp/clone-4f2a'); process.exit(128)"])
+      .then(() => null, (caught: unknown) => caught)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const rejected = await new GitHubSkillSource({
+        runGit: vi.fn(async () => { throw failure }),
+        fetchBytes: vi.fn(async () => Buffer.alloc(0)),
+      }).discover(request('https://github.com/example/skills')).then(() => null, (caught: unknown) => caught)
+      expect(rejected).toBeInstanceOf(GitHubSkillSourceError)
+      expect((rejected as GitHubSkillSourceError).message).toBe('Could not inspect the GitHub skill source.')
+      expect(warn).toHaveBeenCalledWith(expect.any(String), failure)
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('reports invalid YAML frontmatter by line, not in the parser\'s words', () => {
+    const thrown = (() => { try { parseSkillFrontmatter('---\nname: [x\ndescription: y\n---\n# Body\n'); return null } catch (caught) { return caught } })()
+    expect(thrown).toBeInstanceOf(GitHubSkillSourceError)
+    // The line is REQUIRED now (review of #1456, round 2 a and b: it never appeared): `name: [x`
+    // opens a flow sequence on file line 2, and the parser reports it where the next line begins.
+    expect((thrown as Error).message).toBe('SKILL.md contains invalid YAML frontmatter near line 3.')
+  })
+
+  // Review of #1456 (b): a classified git failure replaced git's error with a
+  // fixed sentence and dropped the raw one from the log.
+  it('logs the raw git error behind a classified message', async () => {
+    const failure = Object.assign(new Error('Command failed: git ls-remote'), { code: 128, cmd: 'git ls-remote', stderr: 'fatal: repository does not exist' })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const rejected = await new GitHubSkillSource({
+        runGit: vi.fn(async () => { throw failure }),
+        fetchBytes: vi.fn(async () => Buffer.alloc(0)),
+      }).discover(request('https://github.com/example/skills')).then(() => null, (caught: unknown) => caught)
+      expect((rejected as Error).message).toBe('The public GitHub repository or ref was not found.')
+      expect(warn).toHaveBeenCalledWith(expect.any(String), failure)
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  // Review of #1456 (b), a surviving mutation: Node's own fetch rejection
+  // (`TypeError('fetch failed', { cause })`) reached the UI as `fetch failed`.
+  it('answers a fetch that cannot connect with a fixed sentence and logs the cause', async () => {
+    const cause = Object.assign(new Error('getaddrinfo ENOTFOUND api.github.com'), { code: 'ENOTFOUND', syscall: 'getaddrinfo' })
+    const rejection = new TypeError('fetch failed', { cause })
+    vi.stubGlobal('fetch', vi.fn(async () => { throw rejection }))
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const rejected = await fetchBoundedGitHubBytes('https://api.github.com/repos/example/skills', 1024).then(() => null, (caught: unknown) => caught)
+      expect(rejected).toBeInstanceOf(GitHubSkillSourceError)
+      expect((rejected as Error).message).toBe('Could not download that skill from GitHub.')
+      expect(warn).toHaveBeenCalledWith(expect.any(String), rejection)
+    } finally {
+      warn.mockRestore()
+      vi.unstubAllGlobals()
+    }
+  })
+
+  // Review of #1456, round 2 (c): the 60 s abort and the YAML parser branch
+  // replaced their raw diagnostics with fixed sentences and logged nothing.
+  it('logs the raw error behind a download that times out', async () => {
+    vi.useFakeTimers()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    vi.stubGlobal('fetch', vi.fn((_url: unknown, init: { signal: AbortSignal }) => new Promise((_resolve, reject) => {
+      init.signal.addEventListener('abort', () => reject(Object.assign(new Error('This operation was aborted'), { name: 'AbortError' })))
+    })))
+    try {
+      const pending = fetchBoundedGitHubBytes('https://api.github.com/repos/example/skills', 1024).then(() => null, (caught: unknown) => caught)
+      await vi.advanceTimersByTimeAsync(60_000)
+      const rejected = await pending
+      expect((rejected as Error).message).toBe('GitHub content acquisition timed out.')
+      expect(warn).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ name: 'AbortError' }))
+    } finally {
+      warn.mockRestore()
+      vi.unstubAllGlobals()
+      vi.useRealTimers()
+    }
+  })
+
+  it('logs the YAML parser\'s own detail behind the invalid-frontmatter sentence', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      expect(() => parseSkillFrontmatter('---\nname: [x\ndescription: y\n---\n# Body\n')).toThrow(/invalid YAML frontmatter/)
+      expect(warn).toHaveBeenCalled()
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('names the line of a duplicate key', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      expect(() => parseSkillFrontmatter('---\nname: x\nname: y\n---\n# Body\n')).toThrow('SKILL.md contains invalid YAML frontmatter near line 3.')
+    } finally {
+      warn.mockRestore()
+    }
+  })
 })
diff --git a/src/main/agentCodeConventions/githubSkillSource.ts b/src/main/agentCodeConventions/githubSkillSource.ts
index 48e8f98c8..e601fbaae 100644
--- a/src/main/agentCodeConventions/githubSkillSource.ts
+++ b/src/main/agentCodeConventions/githubSkillSource.ts
@@ -859,14 +859,24 @@ export function parseSkillFrontmatter(text: string): {
   if (end < 0) {
     throw new GitHubSkillSourceError('validation', 'SKILL.md frontmatter has no closing delimiter.')
   }
-  const document = parseDocument(lines.slice(1, end).join('\n'), {
+  const frontmatterText = lines.slice(1, end).join('\n')
+  const document = parseDocument(frontmatterText, {
     prettyErrors: false,
     uniqueKeys: true,
   })
   if (document.errors.length > 0) {
+    // The parser's own wording is raw library text (review of #1456, a); the
+    // line number is what a user needs to find the mistake.
+    // From the error's character offset, not `linePos`: with prettyErrors off the parser leaves
+    // `linePos` unset, so the line was never shown (review of #1456, round 2 a and b). The
+    // frontmatter starts on the file's second line, after the opening `---`.
+    const offset = document.errors[0]!.pos?.[0]
+    const line = typeof offset === 'number' ? frontmatterText.slice(0, offset).split('\n').length + 1 : undefined
+    // The parser's own detail goes to the log (review of #1456, round 2 c).
+    console.warn('[github-skill-source] invalid SKILL.md frontmatter:', document.errors[0])
     throw new GitHubSkillSourceError(
       'validation',
-      `SKILL.md contains invalid YAML frontmatter: ${document.errors[0]!.message}`,
+      `SKILL.md contains invalid YAML frontmatter${typeof line === 'number' ? ` near line ${line}` : ''}.`,
     )
   }
   let frontmatter: unknown
@@ -877,9 +887,13 @@ export function parseSkillFrontmatter(text: string): {
     // Codex rejects. Map output also avoids object-prototype key hazards.
     frontmatter = document.toJS({ mapAsMap: true, maxAliasCount: 0 })
   } catch (error) {
+    // toJS refuses aliases (maxAliasCount: 0) and values it cannot convert;
+    // its wording is library text, so the user gets the category and the log
+    // gets the detail (review of #1456, a).
+    console.warn('[github-skill-source] frontmatter conversion failed:', error)
     throw new GitHubSkillSourceError(
       'validation',
-      `SKILL.md contains unsafe YAML frontmatter: ${safeErrorMessage(error)}`,
+      'SKILL.md contains unsafe YAML frontmatter, such as aliases or values Agent Code cannot read.',
     )
   }
   if (!(frontmatter instanceof Map)) {
@@ -1126,6 +1140,10 @@ function summarizeValues(prefix: string, values: string[]): string {
 
 function classifyGitHubSkillSourceError(error: unknown): GitHubSkillSourceError {
   if (error instanceof GitHubSkillSourceError) return error
+  // Every branch below replaces git's own error with a fixed sentence, so the
+  // raw one (exit code, stderr) is logged here, once, for all of them (review
+  // of #1456, b: the classified branches used to drop it).
+  console.warn('[github-skill-source] git failed:', error)
   const nodeError = error as NodeJS.ErrnoException & { stderr?: string | Buffer }
   if (nodeError.code === 'ENOENT') {
     return new GitHubSkillSourceError('git-unavailable', 'Git is required to inspect GitHub skills.')
@@ -1142,14 +1160,10 @@ function classifyGitHubSkillSourceError(error: unknown): GitHubSkillSourceError
   if (typeof detail === 'string' && /could not resolve|failed to connect|timed out|network/i.test(detail)) {
     return new GitHubSkillSourceError('network', 'Could not reach GitHub to inspect that skill source.')
   }
-  return new GitHubSkillSourceError(
-    'io-error',
-    error instanceof Error && error.message ? error.message : 'Could not inspect the GitHub skill source.',
-  )
-}
-
-function safeErrorMessage(error: unknown): string {
-  return error instanceof Error && error.message ? error.message : String(error)
+  // An unclassified git failure is raw process output (`Command failed: git
+  // …` plus stderr, sometimes the clone's temporary path): a fixed sentence,
+  // the raw error already logged above (#1427; review of #1456, a).
+  return new GitHubSkillSourceError('io-error', 'Could not inspect the GitHub skill source.')
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -1211,9 +1225,14 @@ export async function fetchBoundedGitHubBytes(url: string, maxBytes: number): Pr
   } catch (error) {
     if (error instanceof GitHubSkillSourceError) throw error
     if (controller.signal.aborted) {
+      // The fixed sentence replaces fetch's AbortError; log it (review of #1456, round 2 c).
+      console.warn('[github-skill-source] download timed out:', error)
       throw new GitHubSkillSourceError('network', 'GitHub content acquisition timed out.')
     }
-    throw new GitHubSkillSourceError('network', safeErrorMessage(error))
+    // fetch's own error is transport text (`fetch failed`, undici causes):
+    // a fixed sentence, the raw error in the main log (review of #1456, a).
+    console.warn('[github-skill-source] download failed:', error)
+    throw new GitHubSkillSourceError('network', 'Could not download that skill from GitHub.')
   } finally {
     clearTimeout(timeout)
   }
diff --git a/src/main/agentCodeConventions/installedSkillMaterializer.ts b/src/main/agentCodeConventions/installedSkillMaterializer.ts
index f229df4f2..84e42472b 100644
--- a/src/main/agentCodeConventions/installedSkillMaterializer.ts
+++ b/src/main/agentCodeConventions/installedSkillMaterializer.ts
@@ -16,6 +16,7 @@ import {
 import { journalCaptureDirectory, journalTemporaryPath, SkillPathSafety } from './skillPathSafety.js'
 import type { InstalledSkillPackageStore } from './installedSkillPackageStore.js'
 import type { AgentCodeConventionsTarget } from './targets.js'
+import { userFacingSkillError } from './userFacingError.js'
 
 export type InstalledPackagePreflight =
   | { kind: 'writable' }
@@ -187,7 +188,7 @@ export class InstalledSkillMaterializer {
       return {
         ok: false,
         kind: 'error',
-        message: error instanceof Error ? error.message : 'Unknown installed skill filesystem error',
+        message: userFacingSkillError(error, 'installed-skill-materializer'),
       }
     }
   }
@@ -282,7 +283,7 @@ export class InstalledSkillMaterializer {
     } catch (error) {
       return conflictForPath(
         directory,
-        error instanceof Error ? error.message : 'Could not inspect the installed skill destination.',
+        error instanceof Error ? userFacingSkillError(error, 'installed-skill-materializer') : 'Could not inspect the installed skill destination.',
       )
     }
   }
diff --git a/src/main/agentCodeConventions/persistence.ts b/src/main/agentCodeConventions/persistence.ts
index baeb3b756..5114d652b 100644
--- a/src/main/agentCodeConventions/persistence.ts
+++ b/src/main/agentCodeConventions/persistence.ts
@@ -28,6 +28,7 @@ import {
   findAgentCodeInstalledSkillPathCollision,
   isSafeAgentCodeInstalledSkillPath,
 } from '@shared/types/agentCodeInstalledSkills.js'
+import { userFacingSkillError } from './userFacingError.js'
 
 export type AgentCodeConventionsStateReadResult =
   | { kind: 'ok'; document: AgentCodeConventionsDocument }
@@ -425,7 +426,7 @@ export async function readAgentCodeConventionsState(
     return {
       kind: 'recovery-required',
       document: createEmptyAgentCodeConventionsDocument(),
-      message: `Agent Code could not safely read managed skill state: ${safeErrorMessage(error)}`,
+      message: `Agent Code could not safely read managed skill state: ${userFacingSkillError(error)}`,
       stateFilePath,
     }
   }
@@ -478,7 +479,3 @@ export async function resetAgentCodeConventionsState(stateFilePath: string): Pro
   })
 }
 
-function safeErrorMessage(error: unknown): string {
-  if (error instanceof Error && error.message) return error.message
-  return 'unknown filesystem error'
-}
diff --git a/src/main/agentCodeConventions/skillPathSafety.system.test.ts b/src/main/agentCodeConventions/skillPathSafety.system.test.ts
index 1680d3463..b623a1091 100644
--- a/src/main/agentCodeConventions/skillPathSafety.system.test.ts
+++ b/src/main/agentCodeConventions/skillPathSafety.system.test.ts
@@ -1,7 +1,7 @@
-import { mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises'
+import { mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from 'fs/promises'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { afterEach, describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { journalTemporaryPath, SkillPathSafety } from './skillPathSafety.js'
 import { sha256Text } from './renderSkill.js'
@@ -96,4 +96,39 @@ describe('SkillPathSafety', () => {
     await expect(readFile(target.skillFile, 'utf8')).resolves.toBe('external replacement')
     await expect(stat(quarantine)).rejects.toMatchObject({ code: 'ENOENT' })
   })
+
+  // Review of #1456 (b): a symlinked folder on the skill path threw a message
+  // that named the path, which was then shown (a root-level `/tmp`) or
+  // replaced by the generic sentence, losing the reason. The reason is shown,
+  // the path only logged.
+  it('names a symlinked folder on the skill path without showing the path', async () => {
+    const { root, target, safety } = await fixture()
+    const real = join(root, 'real-agents')
+    await mkdir(real)
+    await symlink(real, join(root, '.agents'))
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const inspected = await safety.inspectTarget(target) as { message?: string }
+      expect(inspected.message).toBe('A folder on the skill path is a symbolic link, which Agent Code does not follow.')
+      expect(inspected.message).not.toContain(root)
+      expect(warn).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ path: join(root, '.agents') }))
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  // Review of #1456, round 2 (c): the file-in-the-way reason had no test, so a
+  // path slipping back into its message survived.
+  it('names a file in the way of a skill folder without showing the path', async () => {
+    const { root, target, safety } = await fixture()
+    await writeFile(join(root, '.agents'), 'a file where a folder should be')
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const inspected = await safety.inspectTarget(target) as { message?: string }
+      expect(inspected.message).toBe('A file is in the way where a folder on the skill path should be.')
+      expect(warn).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ path: join(root, '.agents') }))
+    } finally {
+      warn.mockRestore()
+    }
+  })
 })
diff --git a/src/main/agentCodeConventions/skillPathSafety.ts b/src/main/agentCodeConventions/skillPathSafety.ts
index 3b14972cd..3fbb11e5a 100644
--- a/src/main/agentCodeConventions/skillPathSafety.ts
+++ b/src/main/agentCodeConventions/skillPathSafety.ts
@@ -12,6 +12,7 @@ import {
 } from '@shared/types/agentCodeConventions.js'
 import { sha256Text } from './renderSkill.js'
 import type { AgentCodeConventionsTarget } from './targets.js'
+import { userFacingSkillError } from './userFacingError.js'
 
 export type FileInspection =
   | {
@@ -86,7 +87,7 @@ export class SkillPathSafety {
       }
       return this.inspectRegularFile(target.skillFile, file)
     } catch (error) {
-      return this.pathConflict(target.skillFile, safeErrorMessage(error))
+      return this.pathConflict(target.skillFile, userFacingSkillError(error))
     }
   }
 
@@ -98,7 +99,7 @@ export class SkillPathSafety {
     try {
       await this.assertNoSymlinkComponents(dirname(path))
     } catch (error) {
-      return this.pathConflict(path, safeErrorMessage(error))
+      return this.pathConflict(path, userFacingSkillError(error))
     }
     const file = await lstat(path).catch(error => {
       if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null
@@ -222,8 +223,8 @@ export class SkillPathSafety {
         throw error
       })
       if (!stat) return
-      if (stat.isSymbolicLink()) throw new Error(`Symbolic-link path component is not supported: ${cursor}`)
-      if (!stat.isDirectory()) throw new Error(`Path component is not a directory: ${cursor}`)
+      if (stat.isSymbolicLink()) throw pathComponentError(SYMLINK_COMPONENT, cursor)
+      if (!stat.isDirectory()) throw pathComponentError(FILE_COMPONENT, cursor)
     }
   }
 
@@ -255,7 +256,7 @@ export class SkillPathSafety {
         fingerprint,
         bytes: stat.size,
         executable: (stat.mode & 0o111) !== 0,
-        readError: safeErrorMessage(error),
+        readError: userFacingSkillError(error),
       }
     }
   }
@@ -309,9 +310,9 @@ export class SkillPathSafety {
         stat = await lstat(cursor)
       }
       if (stat.isSymbolicLink()) {
-        throw new Error(`Symbolic-link path component is not supported: ${cursor}`)
+        throw pathComponentError(SYMLINK_COMPONENT, cursor)
       }
-      if (!stat.isDirectory()) throw new Error(`Path component is not a directory: ${cursor}`)
+      if (!stat.isDirectory()) throw pathComponentError(FILE_COMPONENT, cursor)
     }
   }
 
@@ -339,7 +340,14 @@ function sha256Bytes(value: Buffer): string {
   return createHash('sha256').update(value).digest('hex')
 }
 
-function safeErrorMessage(error: unknown): string {
-  if (error instanceof Error && error.message) return error.message
-  return 'Unknown filesystem error'
+// The reason is curated and shown; the offending path rides on `path` for the
+// main log only (#1427; review of #1456, b). The first versions put the path
+// in the message, which was then either shown (a root-level `/tmp`) or thrown
+// away with the reason (the generic sentence). userFacingSkillError keeps
+// this message and logs the error, path included.
+const SYMLINK_COMPONENT = 'A folder on the skill path is a symbolic link, which Agent Code does not follow.'
+const FILE_COMPONENT = 'A file is in the way where a folder on the skill path should be.'
+
+function pathComponentError(message: string, path: string): Error {
+  return Object.assign(new Error(message), { path })
 }
diff --git a/src/main/agentCodeConventions/userFacingError.test.ts b/src/main/agentCodeConventions/userFacingError.test.ts
new file mode 100644
index 000000000..b1302276b
--- /dev/null
+++ b/src/main/agentCodeConventions/userFacingError.test.ts
@@ -0,0 +1,153 @@
+import { mkdtemp, rm, rmdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { GENERIC_SKILL_ERROR, REVEAL_FAILED, revealFailureMessage, userFacingSkillError } from './userFacingError.js'
+
+const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+afterEach(() => warn.mockClear())
+
+// #1427: what a Skills surface may show for an error. Real errors from the
+// filesystem where the shape matters, so the errno/syscall detection is tested
+// against what Node actually throws.
+describe('userFacingSkillError', () => {
+  it('turns a real Node system error into a fixed sentence with no path, and logs the raw error', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'skills-error-'))
+    try {
+      const error = await rmdir(join(root, 'missing')).then(() => null, (caught: unknown) => caught)
+      const message = userFacingSkillError(error)
+      expect(message).toBe('A file or folder Agent Code needs is missing.')
+      expect(message).not.toContain(root)
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining(message), error)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('keeps the service’s own curated text and does not log it', () => {
+    expect(userFacingSkillError(new Error('A managed skill already uses the reserved TLDR name.'))).toBe('A managed skill already uses the reserved TLDR name.')
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it('replaces text that carries any path spelling, spans lines, or runs long, and logs what it replaced', () => {
+    for (const text of [
+      "could not open '/Users/someone/.claude/skills/x/SKILL.md'",
+      'failed at /private/var/folders/tv/T/clone-1/SKILL.md',
+      'C:\\Users\\someone\\skills',
+      // Review of #1456 (a): these five passed the first path filter.
+      'Failed at /tmp',
+      'Failed at ~/skills',
+      'Failed at ../skills',
+      "Failed at '/tmp'",
+      'Failed at \\\\server\\share',
+      'C:/Users/Ann',
+      'file:///tmp/x',
+      // Review of #1456 (c): any non-word character before the slash starts a path.
+      'Provider failed [/Users/Alice/secret]',
+      'failed {/tmp}',
+      'failed </tmp>',
+      'failed a,/tmp',
+      'failed x;/tmp',
+      // Review of #1456, round 2 (c): a period before the slash, and an odd first character after it.
+      'Provider failed./var/folders/x/private',
+      'Failed to open /]private',
+      'failed-/tmp',
+      'first line\nsecond line',
+      'x'.repeat(301),
+    ]) {
+      warn.mockClear()
+      const raw = new Error(text)
+      expect(userFacingSkillError(raw)).toBe(GENERIC_SKILL_ERROR)
+      // Review of #1456 (a), a surviving mutation: logging only for system
+      // errors left these rewrites with no diagnostic trail.
+      expect(warn).toHaveBeenCalledWith(expect.any(String), raw)
+    }
+  })
+
+  it('keeps prose that only looks like a path, and relative package paths', () => {
+    for (const text of ['Choose one and/or the other.', 'Check the file/folder.', 'The package contains a symbolic link: scripts/a.sh']) {
+      expect(userFacingSkillError(new Error(text))).toBe(text)
+    }
+  })
+
+  it('never keeps a child-process error or a library error, even without a path', async () => {
+    const { execFile } = await import('node:child_process')
+    const { promisify } = await import('node:util')
+    // A real child-process failure: its `code` is the exit number, so the
+    // errno rule misses it, and its message is `Command failed: …` + stderr.
+    const child = await promisify(execFile)(process.execPath, ['-e', "process.stderr.write('fatal: unexpected git failure'); process.exit(128)"])
+      .then(() => null, (caught: unknown) => caught)
+    expect(userFacingSkillError(child)).toBe(GENERIC_SKILL_ERROR)
+    // The same shape with empty stderr is ONE line and path-free (`Command
+    // failed: git ls-remote`); only the child-process rule refuses it.
+    const quiet = Object.assign(new Error('Command failed: git ls-remote'), { cmd: 'git ls-remote', code: 128, stderr: '' })
+    expect(userFacingSkillError(quiet)).toBe(GENERIC_SKILL_ERROR)
+    const fetchFailed = new TypeError('fetch failed')
+    expect(userFacingSkillError(fetchFailed)).toBe(GENERIC_SKILL_ERROR)
+    // Review of #1456 (c), a surviving mutation: suppressing the log for a
+    // TypeError passed. Every rewrite must leave its raw error in the log.
+    expect(warn).toHaveBeenCalledWith(expect.any(String), fetchFailed)
+    expect(userFacingSkillError(new SyntaxError('Unexpected token } in JSON at position 5'))).toBe(GENERIC_SKILL_ERROR)
+  })
+
+  it('answers a failed Reveal with a fixed sentence and logs Electron\'s text', () => {
+    expect(revealFailureMessage('Failed to open /Users/Alice/.claude/skills', 'test')).toBe(REVEAL_FAILED)
+    expect(warn).toHaveBeenCalledWith(expect.any(String), 'Failed to open /Users/Alice/.claude/skills')
+  })
+
+  it('maps an unknown errno and a non-Error value to the generic sentence', () => {
+    const odd = Object.assign(new Error('EWEIRD: something, open \'/x/y\''), { code: 'EWEIRD', syscall: 'open' })
+    expect(userFacingSkillError(odd)).toBe(GENERIC_SKILL_ERROR)
+    expect(userFacingSkillError('a string')).toBe(GENERIC_SKILL_ERROR)
+    expect(userFacingSkillError(undefined)).toBe(GENERIC_SKILL_ERROR)
+  })
+
+  it('treats a network system error as a network failure', () => {
+    const offline = Object.assign(new Error('getaddrinfo ENOTFOUND api.github.com'), { code: 'ENOTFOUND', syscall: 'getaddrinfo' })
+    expect(userFacingSkillError(offline)).toBe('Agent Code could not reach the network.')
+  })
+
+  // Review of #1456 (b), a surviving mutation: swapping ENOTDIR's sentence for
+  // ENOENT's passed. Each code is pinned to its exact, location-neutral words.
+  it.each([
+    ['EACCES', 'Agent Code does not have permission to use this location.'],
+    ['EPERM', 'Agent Code does not have permission to use this location.'],
+    ['EROFS', 'This location is on a read-only volume.'],
+    ['ENOSPC', 'There is no space left on the disk.'],
+    ['EDQUOT', 'There is no space left on the disk.'],
+    ['ENOENT', 'A file or folder Agent Code needs is missing.'],
+    ['ENOTDIR', 'A file is in the way where a folder should be.'],
+    ['EISDIR', 'A folder is in the way where a file should be.'],
+    ['EEXIST', 'Something already exists where Agent Code needs to write.'],
+    ['ENOTEMPTY', 'Something already exists where Agent Code needs to write.'],
+    ['EBUSY', 'The file is busy. Try again in a moment.'],
+    ['EMFILE', 'The system is out of open files. Try again in a moment.'],
+    ['ENFILE', 'The system is out of open files. Try again in a moment.'],
+    ['ENOTFOUND', 'Agent Code could not reach the network.'],
+    ['EAI_AGAIN', 'Agent Code could not reach the network.'],
+    ['ECONNREFUSED', 'Agent Code could not reach the network.'],
+    ['ECONNRESET', 'Agent Code could not reach the network.'],
+    ['ETIMEDOUT', 'Agent Code could not reach the network.'],
+  ])('%s has its own sentence', (code, sentence) => {
+    const error = Object.assign(new Error(`${code}: something, open '/x/y'`), { code, syscall: 'open' })
+    expect(userFacingSkillError(error)).toBe(sentence)
+    // Review of #1456 (c): every code's raw error reaches the log.
+    expect(warn).toHaveBeenCalledWith(expect.any(String), error)
+  })
+
+  it('shows a curated reason without its path, and logs the path', () => {
+    const error = Object.assign(new Error('A folder on the skill path is a symbolic link, which Agent Code does not follow.'), { path: '/tmp' })
+    expect(userFacingSkillError(error)).toBe(error.message)
+    expect(warn).toHaveBeenCalledWith(expect.any(String), error)
+  })
+
+  // Review of #1456, round 2 (a): a foreign class that happens to share the
+  // package error's NAME is not this package's text.
+  it('does not keep a foreign error just because its class name matches', () => {
+    class GitHubSkillSourceError extends Error {}
+    const foreign = new GitHubSkillSourceError('A library returned a sensitive value')
+    expect(userFacingSkillError(foreign)).toBe(GENERIC_SKILL_ERROR)
+    expect(warn).toHaveBeenCalledWith(expect.any(String), foreign)
+  })
+})
diff --git a/src/main/agentCodeConventions/userFacingError.ts b/src/main/agentCodeConventions/userFacingError.ts
new file mode 100644
index 000000000..b3ed0fae1
--- /dev/null
+++ b/src/main/agentCodeConventions/userFacingError.ts
@@ -0,0 +1,111 @@
+import { GitHubSkillSourceError } from './githubSkillSource.js'
+
+/**
+ * The text a Skills, Conventions or Custom Skills surface may show for an
+ * error (#1427, q22/q39).
+ *
+ * WHY this and not `error.message`: the old `safeErrorMessage` passed Node's
+ * own text through, so the UI showed `EACCES: permission denied, mkdir
+ * '/Users/…/.claude/skills'`, with the user's home path and OS jargon, in
+ * target rows, mutation results and the recovery banner.
+ *
+ * The rules, in order:
+ *   1. A Node system error (an errno `code` string plus `syscall` or `errno`):
+ *      one fixed sentence per code.
+ *   2. A child-process error (it carries `cmd` or `stderr`; its `code` is the
+ *      exit NUMBER, so rule 1 misses it): generic. Its message is
+ *      `Command failed: …` plus raw stderr.
+ *   3. Kept only when the error is exactly a plain `Error` or the package's
+ *      `GitHubSkillSourceError`, i.e. text this package wrote, AND the text is
+ *      one bounded line with no path in it. Library errors (TypeError from
+ *      fetch, SyntaxError, the YAML parser's) are subclasses and get the
+ *      generic sentence, as does anything else.
+ * The first version kept ANY short message without a recognised path, and
+ * review of #1456 (a) showed raw git stderr, `/tmp`, `~/…`, `../…` and
+ * `\\server` shares passing through. The raw error always goes to the main
+ * log whenever the text is rewritten, because the fixed sentence is useless
+ * for diagnosis.
+ */
+// Location-neutral on purpose (review of #1456, b): the same mapper covers
+// skill folders, Agent Code's own state file and GitHub downloads, so a
+// sentence must be true for all of them. The row it appears in says where.
+const SENTENCES: Record<string, string> = {
+  EACCES: 'Agent Code does not have permission to use this location.',
+  EPERM: 'Agent Code does not have permission to use this location.',
+  EROFS: 'This location is on a read-only volume.',
+  ENOSPC: 'There is no space left on the disk.',
+  EDQUOT: 'There is no space left on the disk.',
+  ENOENT: 'A file or folder Agent Code needs is missing.',
+  ENOTDIR: 'A file is in the way where a folder should be.',
+  EISDIR: 'A folder is in the way where a file should be.',
+  EEXIST: 'Something already exists where Agent Code needs to write.',
+  ENOTEMPTY: 'Something already exists where Agent Code needs to write.',
+  EBUSY: 'The file is busy. Try again in a moment.',
+  EMFILE: 'The system is out of open files. Try again in a moment.',
+  ENFILE: 'The system is out of open files. Try again in a moment.',
+  ENOTFOUND: 'Agent Code could not reach the network.',
+  EAI_AGAIN: 'Agent Code could not reach the network.',
+  ECONNREFUSED: 'Agent Code could not reach the network.',
+  ECONNRESET: 'Agent Code could not reach the network.',
+  ETIMEDOUT: 'Agent Code could not reach the network.',
+}
+export const GENERIC_SKILL_ERROR = 'Agent Code could not read or write the files it needs.'
+const MAX_KEPT_MESSAGE = 300
+// Anything that starts like a path. The rule is deliberately blunt (review of
+// #1456, rounds 1 and 2 c): a `/` or `./` / `../` at the start or after ANY
+// character that is not a letter, digit or `_` is a path start, whatever
+// follows it; so is `~/`, a UNC `\\\\`, a drive letter and `file://`. Listing
+// delimiters missed `[` in round 1; excluding `.` and `-` missed `failed./var`
+// in round 2. Prose with a letter before the slash (`and/or`, `file/folder`,
+// a package-relative `scripts/a.sh`) stays readable; a spaced ` / ` in prose
+// is treated as a path and rewritten, which fails closed.
+const PATH_LIKE = /(^|[^\w])\.{0,2}\/|~[\/\\]|\\\\|[A-Za-z]:[\/\\]|file:\/\//
+
+function systemCode(error: unknown): string | null {
+  if (!(error instanceof Error)) return null
+  const { code, syscall, errno } = error as NodeJS.ErrnoException
+  return typeof code === 'string' && /^E[A-Z_]+$/.test(code) && (typeof syscall === 'string' || typeof errno === 'number') ? code : null
+}
+
+function isChildProcessError(error: Error): boolean {
+  return 'cmd' in error || 'stderr' in error
+}
+
+function isOwnCuratedText(error: unknown): error is Error {
+  if (!(error instanceof Error) || !error.message) return false
+  if (isChildProcessError(error)) return false
+  // By identity, not by name (review of #1456, round 2 a): a library class that happens to be
+  // called GitHubSkillSourceError is not this package's text. A plain Error is this package's
+  // own throw; GitHubSkillSourceError (and its discovery-limit subclass) is checked by instanceof.
+  const own = error.constructor === Error || error instanceof GitHubSkillSourceError
+  return own
+    && error.message.length <= MAX_KEPT_MESSAGE
+    && !error.message.includes('\n')
+    && !PATH_LIKE.test(error.message)
+}
+
+export function userFacingSkillError(error: unknown, context = 'agent-code-conventions'): string {
+  const code = systemCode(error)
+  if (code === null && isOwnCuratedText(error)) {
+    // A curated reason that carries its offending path on the side (see
+    // skillPathSafety's pathComponentError): shown without it, logged with it.
+    if (typeof (error as { path?: unknown }).path === 'string') console.warn(`[${context}] ${error.message}`, error)
+    return error.message
+  }
+  const sentence = code === null ? GENERIC_SKILL_ERROR : SENTENCES[code] ?? GENERIC_SKILL_ERROR
+  console.warn(`[${context}] ${sentence}`, error)
+  return sentence
+}
+
+/**
+ * The Reveal result when `shell.openPath` fails (review of #1456, a). Electron
+ * returns the failure as a string such as `Failed to open /Users/…/skills`,
+ * and the four Reveal handlers returned it as the IPC `message`, where the
+ * Skills rows show it. The raw text goes to the main log instead.
+ */
+export const REVEAL_FAILED = 'Agent Code could not open this folder.'
+
+export function revealFailureMessage(raw: string, context: string): string {
+  console.warn(`[${context}] reveal failed:`, raw)
+  return REVEAL_FAILED
+}
diff --git a/src/main/applicationShutdown.test.ts b/src/main/applicationShutdown.test.ts
index cc46f7536..8c868f45d 100644
--- a/src/main/applicationShutdown.test.ts
+++ b/src/main/applicationShutdown.test.ts
@@ -34,6 +34,7 @@ function harness() {
     disposeControl: vi.fn(async (): Promise<void> => undefined),
     disposeWorkflowBridge: vi.fn(async (): Promise<void> => undefined),
     disposeCaffeinate: vi.fn(async (): Promise<void> => undefined),
+    disposeGoalLoop: vi.fn(async (): Promise<void> => undefined),
     stopHeapWatchdog: vi.fn(async (): Promise<void> => undefined),
     stopDetachedTmuxSweep: vi.fn(async (): Promise<void> => undefined),
     drainWorkspace: vi.fn(async (): Promise<void> => undefined),
@@ -188,6 +189,32 @@ describe('application shutdown composition', () => {
     expect(h.services.stopBuiltInMcp).toHaveBeenCalledOnce()
   })
 
+  // #1372: GoalLoopService.dispose() (#1371) cancels its timers and drains an
+  // in-flight loop-state persist. Nothing awaited it, so a persist started just
+  // before quit could be cut off. It must run only after sessions stop (no new
+  // turn boundary) and the built-in MCP host stops (no new goal_loop tool
+  // call), and quit must wait for it.
+  it('disposes the goal loop after sessions and the built-in MCP host stop, and holds quit for its drain', async () => {
+    const h = harness()
+    const sessions = deferred()
+    const mcp = deferred()
+    const goalLoop = deferred()
+    h.sessionStop.mockImplementation(() => sessions.promise)
+    h.services.stopBuiltInMcp.mockImplementation(() => mcp.promise)
+    h.services.disposeGoalLoop.mockImplementation(() => goalLoop.promise)
+    h.install()
+    h.app.quit()
+    expect(h.services.disposeGoalLoop).not.toHaveBeenCalled()
+    sessions.resolve()
+    await vi.waitFor(() => expect(h.services.stopBuiltInMcp).toHaveBeenCalledOnce())
+    expect(h.services.disposeGoalLoop).not.toHaveBeenCalled()
+    mcp.resolve()
+    await vi.waitFor(() => expect(h.services.disposeGoalLoop).toHaveBeenCalledOnce())
+    expect(h.onQuitAllowed).not.toHaveBeenCalled()
+    goalLoop.resolve()
+    await vi.waitFor(() => expect(h.onQuitAllowed).toHaveBeenCalledOnce())
+  })
+
   it('closes an initializing workflow immediately, while startup settlement still gates support disposal', async () => {
     const h = harness()
     const startup = deferred()
diff --git a/src/main/applicationShutdown.ts b/src/main/applicationShutdown.ts
index 51935ca60..57efb0943 100644
--- a/src/main/applicationShutdown.ts
+++ b/src/main/applicationShutdown.ts
@@ -20,6 +20,10 @@ export interface ApplicationShutdownServices {
   disposeControl: Stop
   disposeWorkflowBridge: Stop
   disposeCaffeinate: Stop
+  /** GoalLoopService.dispose() (#1371, #1372): cancels its timers and drains an
+   *  in-flight loop-state persist or continuation. Without it a persist begun
+   *  just before quit could be cut off and the loop state lost. */
+  disposeGoalLoop: Stop
   stopHeapWatchdog: Stop
   /** The periodic detached-tmux reaper (#1030 item 4). Stopping it is pure
    *  timer teardown — it must NEVER kill tmux sessions at quit, because those
@@ -141,6 +145,11 @@ export function installApplicationShutdown(options: {
       run('control', services.disposeControl),
       run('workflow-bridge', services.disposeWorkflowBridge),
       run('caffeinate', services.disposeCaffeinate),
+      // In this wave, not earlier (#1372): sessions have stopped, so no turn
+      // boundary can start a new persist after dispose, and the built-in MCP
+      // host has stopped, so no goal_loop tool call arrives on a disposed
+      // service. Its drain then settles before quit is allowed.
+      run('goal-loop', services.disposeGoalLoop),
       run('heap-watchdog', services.stopHeapWatchdog),
     ])
     await join([
diff --git a/src/main/conversations/prompts/promptFolder.ts b/src/main/conversations/prompts/promptFolder.ts
index 20e75ba59..8211c063e 100644
--- a/src/main/conversations/prompts/promptFolder.ts
+++ b/src/main/conversations/prompts/promptFolder.ts
@@ -56,6 +56,30 @@ type CacheEntry = {
   seam?: Buffer
   /** Bytes read by the most recent extraction (test/diagnostic hook). */
   lastBytesRead?: number
+  /** Complete lines folded so far that parsed as a JSON record, and that did
+   *  not (#1434 review b). A transcript whose EVERY complete line is garbage
+   *  is damaged, not a conversation without prompts; only a whole-file fold
+   *  (parsedFrom === 0) can say "every", so the verdict waits for it. */
+  parsedRecords?: number
+  malformedRecords?: number
+}
+
+/** A transcript that is present and readable but in which not one complete
+ *  line parses (#1434 review b). The source maps it to
+ *  ConversationPromptsUnreadable, exactly like an I/O failure: "no prompts"
+ *  would claim a damaged conversation is an empty one. A file with at least
+ *  one good record keeps today's behaviour (bad lines are skipped). */
+export class TranscriptUnparseable extends Error {
+  constructor(file: string) {
+    super(`no complete line of ${file} parses as a JSON record`)
+    this.name = 'TranscriptUnparseable'
+  }
+}
+
+function assertParseable(entry: CacheEntry, file: string): void {
+  if (entry.parsedFrom === 0 && (entry.parsedRecords ?? 0) === 0 && (entry.malformedRecords ?? 0) > 0) {
+    throw new TranscriptUnparseable(file)
+  }
 }
 
 // WHY a byte range instead of "the whole file, keyed by mtime" (#735): both
@@ -202,9 +226,14 @@ async function extractPromptsUnlocked(
     const st = await stat(file)
     size = st.size
     mtime = st.mtime.getTime()
-  } catch {
+  } catch (error) {
     span.end({ result: 'stat-failed' })
-    return { prompts: [], cwd: '' }
+    // WHY only a MISSING file is "no prompts" (#1306): a file that is there
+    // but cannot be read is not an empty conversation. The error propagates
+    // to the source, which says it (View Prompts) or skips the row (search).
+    const code = (error as NodeJS.ErrnoException | undefined)?.code
+    if (code === 'ENOENT' || code === 'ENOTDIR') return { prompts: [], cwd: '' }
+    throw error
   }
   if (
     entry &&
@@ -222,6 +251,7 @@ async function extractPromptsUnlocked(
     (entry.parsedFrom === 0 || entry.prompts.length >= wanted)
   ) {
     span.end({ result: 'cache-hit', prompts: entry.prompts.length })
+    assertParseable(entry, file)
     return { prompts: entry.prompts.slice().reverse(), cwd: entry.cwd }
   }
   if (!entry) {
@@ -258,9 +288,14 @@ async function extractPromptsUnlocked(
       entry.cwd = await readHeadCwd(file, size)
       entry.headCwdChecked = true
     }
-  } catch {
+  } catch (error) {
     span.end({ result: 'read-failed' })
-    return { prompts: [], cwd: '' }
+    // A file that vanished between stat and read is missing; anything else
+    // (a permission change, an I/O error) is unreadable and propagates
+    // (#1306). The cache entry is not updated on this path.
+    const code = (error as NodeJS.ErrnoException | undefined)?.code
+    if (code === 'ENOENT') return { prompts: [], cwd: '' }
+    throw error
   }
   entry.mtime = mtime
   entry.size = size
@@ -273,6 +308,7 @@ async function extractPromptsUnlocked(
     parsedFrom: entry.parsedFrom,
     hasCwd: entry.cwd.length > 0,
   })
+  assertParseable(entry, file)
   return { prompts: entry.prompts.slice().reverse(), cwd: entry.cwd }
 }
 
@@ -308,6 +344,8 @@ async function foldForward(
   if (lastNewline < 0) return buf.length
   const text = buf.subarray(0, lastNewline + 1).toString('utf8')
   const folded = foldLines(kind, text, lastPromptText(entry.prompts))
+  entry.parsedRecords = (entry.parsedRecords ?? 0) + folded.parsed
+  entry.malformedRecords = (entry.malformedRecords ?? 0) + folded.malformed
   entry.prompts.push(...folded.prompts)
   if (!entry.cwd && folded.cwd) entry.cwd = folded.cwd
   entry.parsedTo = entry.parsedTo + lastNewline + 1
@@ -373,6 +411,8 @@ async function foldBackward(
     }
     const text = buf.subarray(from, to).toString('utf8')
     const folded = foldLines(kind, text, null)
+    entry.parsedRecords = (entry.parsedRecords ?? 0) + folded.parsed
+    entry.malformedRecords = (entry.malformedRecords ?? 0) + folded.malformed
     // Seam: the adjacent-duplicate rule keeps the OLDER occurrence, so if the
     // newest folded prompt repeats the oldest one already held, the held one
     // is the later duplicate and goes.
@@ -418,14 +458,20 @@ function foldLines(
   kind: AgentProviderKind,
   jsonl: string,
   previousText: string | null,
-): { prompts: FoldedPrompt[]; cwd: string } {
+): { prompts: FoldedPrompt[]; cwd: string; parsed: number; malformed: number } {
   const chronological: FoldedPrompt[] = []
   let cwd = ''
   let lastText = previousText
+  let parsed = 0
+  let malformed = 0
   for (const line of jsonl.split('\n')) {
     if (!line.trim()) continue
     const obj = parseJsonRecord(line)
-    if (!obj) continue
+    if (!obj) {
+      malformed += 1
+      continue
+    }
+    parsed += 1
     if (!cwd) cwd = recordCwd(kind, obj)
     const prompt = kind === 'claude' ? foldClaudeRecord(obj) : foldCodexRecord(obj)
     if (!prompt) continue
@@ -433,7 +479,7 @@ function foldLines(
     chronological.push(prompt)
     lastText = prompt.text
   }
-  return { prompts: chronological, cwd }
+  return { prompts: chronological, cwd, parsed, malformed }
 }
 
 function recordCwd(kind: AgentProviderKind, obj: Record<string, unknown>): string {
diff --git a/src/main/conversations/service.system.test.ts b/src/main/conversations/service.system.test.ts
index 52ea3ef6f..1ef00d6e3 100644
--- a/src/main/conversations/service.system.test.ts
+++ b/src/main/conversations/service.system.test.ts
@@ -1,11 +1,14 @@
+import { appendFile, chmod } from 'node:fs/promises'
 import { join } from 'node:path'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 
 import { ClaudeHistoryIndex } from './sources/claudeHistory.js'
 import { ClaudeConversationSource } from './sources/claude.js'
 import { CodexConversationSource } from './sources/codex.js'
 import { OpencodeConversationSource } from './sources/opencode.js'
 import { ConversationService } from './service.js'
+import { ConversationPromptsUnreadable } from './sources/types.js'
+import { sanitizePath } from '@shared/runtime/projectDir.js'
 import { setMainOperationSink } from '@main/performance/operations.js'
 import { corpusWorktreesPorcelain, installConversationCorpus, type InstalledCorpus } from '../../../testing/support/conversations/installCorpus.js'
 
@@ -61,6 +64,33 @@ describe('ConversationService', () => {
     expect(children.every(c => c.parentNativeId === codexParent!.nativeId)).toBe(true)
   })
 
+  // #1306: an unreadable conversation file now throws from its source. View
+  // Prompts rejects with the typed error; search degrades that one row to
+  // label-only and still lists the rest.
+  it('rejects View Prompts for an unreadable file, and search still lists', async () => {
+    const s = service()
+    const all = await s.list({ cwd: '/fixture/repo', scope: 'repository', includeChildren: true, limit: 5000 })
+    const claudeRows = all.rows.filter(r => r.provider === 'claude' && (r.promptCount ?? 0) > 1 && r.cwd)
+    const row = claudeRows[0]!
+    const other = claudeRows[1]!
+    const needle = (await s.prompts({ provider: 'claude', nativeId: other.nativeId, cwd: other.cwd! }))[0]!.text.slice(0, 10)
+    const file = join(corpus.claudeConfigDir, 'projects', sanitizePath(row.cwd!), `${row.nativeId}.jsonl`)
+    await appendFile(file, '\n')
+    await chmod(file, 0o000)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      await expect(s.prompts({ provider: 'claude', nativeId: row.nativeId, cwd: row.cwd! })).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+      // The cause is logged in main, once (#1434 review c: the log was not
+      // asserted, so removing the service's catch passed every test).
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('prompts'), expect.anything())
+      const hits = await s.list({ cwd: '/fixture/repo', scope: 'repository', query: needle, includeChildren: true, limit: 5000 })
+      expect(hits.rows.some(r => r.nativeId === other.nativeId)).toBe(true)
+    } finally {
+      await chmod(file, 0o600)
+      warn.mockRestore()
+    }
+  })
+
   it('serves a second listing from cache without re-discovering within the freshness window', async () => {
     const s = service()
     const first = await s.list({ cwd: '/fixture/repo', scope: 'repository', limit: 20 })
diff --git a/src/main/conversations/service.ts b/src/main/conversations/service.ts
index 2b069d1d3..5253f1ba4 100644
--- a/src/main/conversations/service.ts
+++ b/src/main/conversations/service.ts
@@ -197,7 +197,12 @@ export class ConversationService {
   async prompts(request: ConversationPromptsRequest): Promise<ConversationPrompt[]> {
     const source = this.source(request.provider)
     if (!source) return []
-    const raw = await source.prompts(request.nativeId, request.cwd, { need: 'all' })
+    const raw = await source.prompts(request.nativeId, request.cwd, { need: 'all' }).catch((error: unknown) => {
+      // #1306: the cause (a path, an OS code) stays in the main log; the
+      // renderer gets the typed error and says it in fixed words.
+      console.warn(`[conversations] ${request.provider} prompts unreadable:`, (error as { cause?: unknown }).cause ?? error)
+      throw error
+    })
     // The folder reports wrappers verbatim; the prompt list shows what the
     // user typed, so unwrap here and drop injected messages.
     return raw.flatMap(p => {
diff --git a/src/main/conversations/sources/claude.ts b/src/main/conversations/sources/claude.ts
index e48be53d2..7b0fa19b1 100644
--- a/src/main/conversations/sources/claude.ts
+++ b/src/main/conversations/sources/claude.ts
@@ -8,7 +8,7 @@ import { streamJsonl } from '@shared/runtime/streamJsonl.js'
 import { performanceService } from '@main/performance/PerformanceService.js'
 import { extractPromptsFromFile } from '@main/conversations/prompts/promptFolder.js'
 import type { ClaudeHistoryIndex } from './claudeHistory.js'
-import type { ConversationSource, SourceConversation, SourceScope, PromptReadOptions } from './types.js'
+import { ConversationPromptsUnreadable, isMissingFileError, type ConversationSource, type SourceConversation, type SourceScope, type PromptReadOptions } from './types.js'
 
 // Claude Code stores one directory per cwd under ~/.claude/projects, named by
 // sanitizePath(cwd), and one `<uuid>.jsonl` per session inside it. There is
@@ -343,29 +343,44 @@ export class ClaudeConversationSource implements ConversationSource {
   async prompts(nativeId: string, cwd: string, options: PromptReadOptions = {}): Promise<ConversationPrompt[]> {
     const direct = join(this.deps.projectsDir, sanitizePath(cwd), `${nativeId}.jsonl`)
     let file: string | null = null
+    // WHY only ENOENT/ENOTDIR mean "not here" (#1306, steering q116): every
+    // other stat or readdir failure (EACCES, EIO) is UNKNOWN, and answering
+    // [] for it is the "no prompts" this issue is about.
+    const notHere = (error: unknown): boolean => {
+      if (isMissingFileError(error)) return true
+      throw new ConversationPromptsUnreadable('claude', error)
+    }
     try {
       await stat(direct)
       file = direct
-    } catch {
+    } catch (error) {
+      notHere(error)
       // A conversation listed from a worktree dir is asked for with its own
       // cwd, so the direct path is the common case; the walk is the rare one.
+      let dirs: string[] = []
       try {
-        for (const dir of await readdir(this.deps.projectsDir)) {
-          const candidate = join(this.deps.projectsDir, dir, `${nativeId}.jsonl`)
-          try {
-            await stat(candidate)
-            file = candidate
-            break
-          } catch {
-            // keep looking
-          }
+        dirs = await readdir(this.deps.projectsDir)
+      } catch (listError) {
+        notHere(listError)
+      }
+      for (const dir of dirs) {
+        const candidate = join(this.deps.projectsDir, dir, `${nativeId}.jsonl`)
+        try {
+          await stat(candidate)
+          file = candidate
+          break
+        } catch (candidateError) {
+          notHere(candidateError)
         }
-      } catch {
-        file = null
       }
     }
     if (!file) return []
+    // #1306: a found file that cannot be read is said, typed, not raw.
     const { prompts } = await extractPromptsFromFile('claude', nativeId, file, options.need ?? 'all', { maxBytes: options.maxBytes })
+      .catch((error: unknown) => {
+        if (isMissingFileError(error)) return { prompts: [] }
+        throw new ConversationPromptsUnreadable('claude', error)
+      })
     return prompts.map(p => ({ text: p.text, timestamp: p.ts }))
   }
 }
diff --git a/src/main/conversations/sources/codex.ts b/src/main/conversations/sources/codex.ts
index c126cd85d..6bc9d4c6f 100644
--- a/src/main/conversations/sources/codex.ts
+++ b/src/main/conversations/sources/codex.ts
@@ -9,7 +9,7 @@ import { performanceService } from '@main/performance/PerformanceService.js'
 import { extractPromptsFromFile } from '@main/conversations/prompts/promptFolder.js'
 import { findCodexRolloutPathByThreadId } from 'codex-headless'
 import { newestCodexStateDb, openReadOnlySqlite } from './sqlite.js'
-import type { ConversationSource, SourceConversation, SourceScope, PromptReadOptions } from './types.js'
+import { assertTreeListable, ConversationPromptsUnreadable, isMissingFileError, isPresent, type ConversationSource, type SourceConversation, type SourceScope, type PromptReadOptions } from './types.js'
 
 // Codex keeps its own index at ~/.codex/state_N.sqlite (`threads`,
 // `thread_spawn_edges`), maintained by the CLI and backfilled from rollouts.
@@ -535,27 +535,59 @@ export class CodexConversationSource implements ConversationSource {
   }
 
   async prompts(nativeId: string, _cwd: string, options: PromptReadOptions = {}): Promise<ConversationPrompt[]> {
+    // isPresent, not existsSync (#1434 round 1, a/b): existsSync answers false
+    // for EACCES too, so a known rollout under a locked directory read as
+    // "absent" and the conversation as having no prompts.
     const known = this.rolloutPaths.get(nativeId)
-    let file: string | null = known && existsSync(known) ? known : null
+    let file: string | null = known && await isPresent('codex', known) ? known : null
     const dbPath = file ? null : newestCodexStateDb(this.deps.codexHome)
     const opened = dbPath ? openReadOnlySqlite(dbPath, { threads: ['id', 'rollout_path'] }) : null
+    // An index that is THERE but cannot be opened (corrupt, locked, an older
+    // schema) cannot tell us where the rollout is. The walk below may still
+    // find it; if it does not, "not found" is unknown, not "no prompts".
+    const indexUnknown = dbPath !== null && opened !== null && !opened.ok && await isPresent('codex', dbPath)
     if (opened?.ok) {
       try {
         const row = opened.db.prepare('select rollout_path from threads where id = ?').get(nativeId) as { rollout_path: string } | undefined
-        if (row && existsSync(row.rollout_path)) file = row.rollout_path
+        if (row && await isPresent('codex', row.rollout_path)) file = row.rollout_path
       } finally {
         opened.close()
       }
     }
     if (!file) {
+      const sessionsDir = join(this.deps.codexHome, 'sessions')
+      // The package's walk swallows its own readdir errors (it answers null),
+      // so an unreadable sessions tree would still read as "no prompts". Probe
+      // the root here: absent is "not here", anything else is unknown.
       try {
-        file = await findCodexRolloutPathByThreadId(join(this.deps.codexHome, 'sessions'), nativeId)
-      } catch {
+        await readdir(sessionsDir)
+      } catch (error) {
+        if (!isMissingFileError(error)) throw new ConversationPromptsUnreadable('codex', error)
+      }
+      try {
+        file = await findCodexRolloutPathByThreadId(sessionsDir, nativeId)
+      } catch (error) {
+        // Only absence is "not here" (#1306, steering q116): a rollout walk
+        // that fails for any other reason is unknown, never "no prompts".
+        if (!isMissingFileError(error)) throw new ConversationPromptsUnreadable('codex', error)
         file = null
       }
+      if (!file) {
+        // The package's walk skips every directory below the root it cannot
+        // list (RolloutLocator.collectMatches), so "not found" can mean "in a
+        // locked sessions/YYYY/MM/DD". Prove the tree was listable before
+        // calling it absent (#1434 round 1, a/b). Only on this miss path.
+        await assertTreeListable('codex', sessionsDir, 3, name => name.endsWith('.jsonl') && name.includes(nativeId))
+        if (indexUnknown) throw new ConversationPromptsUnreadable('codex', new Error('the Codex state index exists but could not be opened, and no rollout was found by walking'))
+      }
     }
     if (!file) return []
+    // #1306: a found rollout that cannot be read is said, typed, not raw.
     const { prompts } = await extractPromptsFromFile('codex', nativeId, file, options.need ?? 'all', { maxBytes: options.maxBytes })
+      .catch((error: unknown) => {
+        if (isMissingFileError(error)) return { prompts: [] }
+        throw new ConversationPromptsUnreadable('codex', error)
+      })
     return prompts.map(p => ({ text: p.text, timestamp: p.ts }))
   }
 }
diff --git a/src/main/conversations/sources/grok.ts b/src/main/conversations/sources/grok.ts
index b279c205c..fa0ce778e 100644
--- a/src/main/conversations/sources/grok.ts
+++ b/src/main/conversations/sources/grok.ts
@@ -7,7 +7,8 @@ import { loadGrokSnapshotAt } from '@main/providerSwitch/grokTranscript.js'
 
 import type { ConversationPrompt } from '@shared/conversations/types.js'
 import { performanceService } from '@main/performance/PerformanceService.js'
-import type { ConversationSource, SourceConversation, SourceScope } from './types.js'
+import { ConversationPromptsUnreadable, isMissingFileError, isPresent, type ConversationSource, type SourceConversation, type SourceScope } from './types.js'
+import { dirname, join } from 'node:path'
 
 // Grok conversation discovery: native's own sessions index. Every session
 // directory under the Grok home carries a summary.json (id, cwd, titles,
@@ -52,11 +53,39 @@ export class GrokConversationSource implements ConversationSource {
     // actually typed — never workspace metadata, never raw tags. Newest first
     // per the source contract (search reads the first 40). The resolve itself
     // can throw on a deleted cwd, hence the whole body inside the try.
-    let snapshot: Awaited<ReturnType<typeof loadGrokSnapshotAt>>
+    let snapshot: Awaited<ReturnType<typeof loadGrokSnapshotAt>> | undefined
+    let path: string
     try {
-      snapshot = await loadGrokSnapshotAt(resolveGrokTranscriptPath(cwd, nativeId, this.deps.grokHome))
-    } catch {
-      return []
+      path = resolveGrokTranscriptPath(cwd, nativeId, this.deps.grokHome)
+    } catch (error) {
+      if (isMissingFileError(error)) return []
+      throw new ConversationPromptsUnreadable('grok', error)
+    }
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        snapshot = await loadGrokSnapshotAt(path)
+        break
+      } catch (error) {
+        if (isMissingFileError(error)) {
+          // #1306: only a MISSING session is "no prompts". The loader reads
+          // summary.json first, so a lost summary beside a transcript that is
+          // still there used to read as missing too (#1434 round 1, a): an
+          // incomplete store, not an empty conversation. Either file present
+          // means this session exists and could not be read.
+          const either = await isPresent('grok', path) || await isPresent('grok', join(dirname(path), 'summary.json'))
+          if (either) throw new ConversationPromptsUnreadable('grok', error)
+          return []
+        }
+        // A read racing Grok's own writer (an unterminated last record, or the
+        // file changing during the read) is normal while it works, not damage
+        // (#1434 round 1, a, minor). Two short retries let the turn settle;
+        // a transcript still unstable after that is said, never "no prompts".
+        if (attempt < 2 && isGrokWriteInProgress(error)) {
+          await new Promise(resolve => setTimeout(resolve, 150))
+          continue
+        }
+        throw new ConversationPromptsUnreadable('grok', error)
+      }
     }
     const texts: string[] = []
     for (const entry of snapshot.conversation.entries) {
@@ -101,3 +130,11 @@ export class GrokConversationSource implements ConversationSource {
     }
   }
 }
+
+/** The two refusals loadGrokSnapshotAt raises while Grok's writer is mid-turn
+ *  (providerSwitch/grokTranscript.ts readStableGrokFile / the unterminated-
+ *  record guard). Matched on their fixed text: they are our own messages. */
+function isGrokWriteInProgress(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : ''
+  return message.includes('changed while reading') || message.includes('unterminated record')
+}
diff --git a/src/main/conversations/sources/opencode.ts b/src/main/conversations/sources/opencode.ts
index 89b3a391f..3781d2d1e 100644
--- a/src/main/conversations/sources/opencode.ts
+++ b/src/main/conversations/sources/opencode.ts
@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -5,7 +6,7 @@ import type { ConversationPrompt } from '@shared/conversations/types.js'
 import { parseJsonRecord } from '@shared/lib/asRecord.js'
 import { performanceService } from '@main/performance/PerformanceService.js'
 import { openReadOnlySqlite } from './sqlite.js'
-import type { ConversationSource, SourceConversation, SourceScope } from './types.js'
+import { ConversationPromptsUnreadable, isPresent, type ConversationSource, type SourceConversation, type SourceScope } from './types.js'
 
 // OpenCode keeps every session in ~/.local/share/opencode/opencode.db:
 // `session` (id, parent_id, directory, title, time_created, time_updated,
@@ -133,13 +134,30 @@ export class OpencodeConversationSource implements ConversationSource {
   // discovery reads gives every user text part in one statement. Rewind keeps
   // the export because it needs the export's message positions as addresses.
   async prompts(nativeId: string, _cwd: string): Promise<ConversationPrompt[]> {
-    const opened = openReadOnlySqlite(join(this.deps.dataDir, 'opencode.db'), OPENCODE_COLUMNS)
-    if (!opened.ok) return []
+    const dbPath = join(this.deps.dataDir, 'opencode.db')
+    const opened = openReadOnlySqlite(dbPath, OPENCODE_COLUMNS)
+    if (!opened.ok) {
+      // #1306: no database at all is "no prompts"; one that is there but
+      // cannot be opened or read is said (the reason names the path, so it
+      // stays on the error's cause, never in the message). isPresent, not
+      // existsSync (#1434 round 1, a/b): existsSync answers false when the
+      // data directory itself is inaccessible, which read as "no database".
+      if (!(await isPresent('opencode', dbPath))) return []
+      throw new ConversationPromptsUnreadable('opencode', new Error(opened.reason))
+    }
     try {
-      const rows = opened.db.prepare(
-        `select p.data as part, m.data as message, m.time_created as created from part p join message m on m.id = p.message_id
-         where m.session_id = ? order by m.time_created desc, p.time_created desc`,
-      ).all(nativeId) as unknown as Array<{ part: string; message: string; created: number | null }>
+      // A read that fails after the open succeeded (a damaged page, a lock
+      // taken mid-query) is unknown too, and typed (#1434 round 1 suspicion
+      // a/b): a raw SQLite error must not reach the source contract.
+      let rows: Array<{ part: string; message: string; created: number | null }>
+      try {
+        rows = opened.db.prepare(
+          `select p.data as part, m.data as message, m.time_created as created from part p join message m on m.id = p.message_id
+           where m.session_id = ? order by m.time_created desc, p.time_created desc`,
+        ).all(nativeId) as unknown as Array<{ part: string; message: string; created: number | null }>
+      } catch (error) {
+        throw new ConversationPromptsUnreadable('opencode', error)
+      }
       const out: ConversationPrompt[] = []
       for (const r of rows) {
         const message = parseJsonRecord(r.message)
diff --git a/src/main/conversations/sources/opencodeQueryError.test.ts b/src/main/conversations/sources/opencodeQueryError.test.ts
new file mode 100644
index 000000000..80f67208d
--- /dev/null
+++ b/src/main/conversations/sources/opencodeQueryError.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// #1434 verification a: a SQLite failure AFTER a successful open (a damaged
+// page past the schema probe, a lock taken mid-query) must reach the source
+// contract typed, not raw. A real database that fails only at that step is not
+// reliably manufacturable, so the sqlite boundary answers "opened" with a
+// statement that throws — the one thing replaced.
+vi.mock('./sqlite.js', () => ({
+  openReadOnlySqlite: () => ({
+    ok: true,
+    db: { prepare: () => ({ all: () => { throw new Error('database disk image is malformed') } }) },
+    close: () => undefined,
+  }),
+}))
+
+import { OpencodeConversationSource } from './opencode.js'
+import { ConversationPromptsUnreadable } from './types.js'
+
+describe('OpenCode prompts when the query fails after the open', () => {
+  it('is typed as unreadable, never a raw SQLite error', async () => {
+    await expect(new OpencodeConversationSource({ dataDir: '/tmp/unused' }).prompts('ses_x', '/fixture/repo')).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+  })
+})
diff --git a/src/main/conversations/sources/pi.system.test.ts b/src/main/conversations/sources/pi.system.test.ts
index 31fa93757..a44b0928a 100644
--- a/src/main/conversations/sources/pi.system.test.ts
+++ b/src/main/conversations/sources/pi.system.test.ts
@@ -1,4 +1,4 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { basename, join } from 'node:path'
 
@@ -8,6 +8,7 @@ import { encodeCwdForSessionDir } from 'pi-terminal-headless'
 
 import { resolveFamily } from '../family.js'
 import { PiConversationSource } from './pi.js'
+import { ConversationPromptsUnreadable } from './types.js'
 
 // The Pi conversation source over Stage 0 recordings of the real pi 0.87.1,
 // laid out the way pi lays them out: one directory per cwd under
@@ -77,6 +78,23 @@ describe('Pi conversation source', () => {
     expect(await source.prompts('no-such-session', repo)).toEqual([])
   })
 
+  // #1306: a session file that is THERE but cannot be read used to answer
+  // [] like a missing one, so View Prompts said "no prompts". A missing file
+  // still answers [] (a new session has none yet); an unreadable one throws.
+  it('says an unreadable session file instead of answering no prompts', async () => {
+    const { home, place } = sandbox()
+    const repo = join(home, 'repo')
+    const tree = place(Object.values(loadLiveFixture('tree').files)[0]!, repo)
+    const source = new PiConversationSource({ env: {}, homeDirectory: home })
+    chmodSync(tree.file, 0o000)
+    try {
+      await expect(source.prompts(tree.id, repo)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    } finally {
+      chmodSync(tree.file, 0o600)
+    }
+    expect(await source.prompts('no-such-session', repo)).toEqual([])
+  })
+
   it('a /name the user gave the session is its custom title', async () => {
     const { home, place } = sandbox()
     const repo = join(home, 'repo')
diff --git a/src/main/conversations/sources/pi.ts b/src/main/conversations/sources/pi.ts
index 1cfc91444..c5cfc7c58 100644
--- a/src/main/conversations/sources/pi.ts
+++ b/src/main/conversations/sources/pi.ts
@@ -1,11 +1,11 @@
-import { open, stat } from 'node:fs/promises'
+import { open, readdir, stat } from 'node:fs/promises'
 import { basename } from 'node:path'
 
-import { listAllPiSessionFiles, readPiBranch, resolvePiSessionFile, sessionIdFromFileName } from 'pi-terminal-headless'
+import { listAllPiSessionFiles, readPiBranch, resolvePiSessionDir, resolvePiSessionFile, resolvePiSessionsRoot, sessionIdFromFileName } from 'pi-terminal-headless'
 
 import type { ConversationPrompt } from '@shared/conversations/types.js'
 import { performanceService } from '@main/performance/PerformanceService.js'
-import type { ConversationSource, SourceConversation, SourceScope } from './types.js'
+import { ConversationPromptsUnreadable, isMissingFileError, type ConversationSource, type SourceConversation, type SourceScope } from './types.js'
 
 // Pi conversation discovery, straight from Pi's session files — the same
 // files pi's own /resume picker lists. There is no separate index: each
@@ -124,8 +124,60 @@ export class PiConversationSource implements ConversationSource {
   /** Every user prompt on the session's active branch, newest first. */
   async prompts(nativeId: string, cwd: string): Promise<ConversationPrompt[]> {
     try {
-      const file = await resolvePiSessionFile({ env: this.deps.env ?? process.env, cwd, sessionId: nativeId, ...(this.deps.homeDirectory ? { homeDirectory: this.deps.homeDirectory } : {}) })
-      if (!file) return []
+      const env = { env: this.deps.env ?? process.env, ...(this.deps.homeDirectory ? { homeDirectory: this.deps.homeDirectory } : {}) }
+      // The package's listings swallow their own readdir errors (they answer
+      // "none"), so probe the two directories here (#1306, steering q116):
+      // absent is "not here", anything else is unknown, never "no prompts".
+      for (const dir of [(await resolvePiSessionsRoot(env)).root, await resolvePiSessionDir({ ...env, cwd })]) {
+        try {
+          await readdir(dir)
+        } catch (error) {
+          if (!isMissingFileError(error)) throw new ConversationPromptsUnreadable('pi', error)
+        }
+      }
+      const file = await resolvePiSessionFile({ ...env, cwd, sessionId: nativeId })
+      if (!file) {
+        // WHY look again (#1306): resolution mirrors Pi, which skips a file
+        // whose header it cannot read, so an UNREADABLE session reads as "no
+        // such session". A file named for this session that cannot even be
+        // opened is that case, and is said; a readable one whose header
+        // simply does not match this cwd is genuinely not this session.
+        // A listing that fails for anything but absence is unknown, never
+        // "no prompts" (steering q116).
+        const named = (await listAllPiSessionFiles(env).catch((error: unknown) => {
+          if (isMissingFileError(error)) return [] as string[]
+          throw new ConversationPromptsUnreadable('pi', error)
+        }))
+          .find(candidate => sessionIdFromFileName(basename(candidate)) === nativeId)
+        if (named) {
+          // The resolver skipped a file named for this session. Either it is
+          // unreadable, its header is damaged, or its header is readable and
+          // names another cwd. Only the last is "not this session"; the first
+          // two are this conversation, present and unreadable (#1434 round 1,
+          // a: a `{bad json}` header used to read as "no prompts").
+          let header: string
+          try {
+            header = await readFirstLine(named)
+          } catch (error) {
+            throw new ConversationPromptsUnreadable('pi', error)
+          }
+          let parsed: unknown
+          try {
+            parsed = JSON.parse(header)
+          } catch (error) {
+            throw new ConversationPromptsUnreadable('pi', error)
+          }
+          // Only a real session header (type 'session', this id) can say "not
+          // this session" — its cwd simply differs. Any other first row (a
+          // message row, another id, no type) means the header itself is
+          // damaged: present, unreadable (#1434 verification a).
+          const row = parsed as { type?: unknown; id?: unknown } | null
+          if (!row || typeof row !== 'object' || row.type !== 'session' || row.id !== nativeId) {
+            throw new ConversationPromptsUnreadable('pi', new Error('the session header is damaged'))
+          }
+        }
+        return []
+      }
       const { rows } = await readPiBranch(file)
       const prompts: ConversationPrompt[] = []
       for (const row of rows) {
@@ -139,8 +191,11 @@ export class PiConversationSource implements ConversationSource {
         if (text.trim()) prompts.push({ text, timestamp: typeof message.timestamp === 'number' ? message.timestamp : null })
       }
       return prompts.reverse()
-    } catch {
-      return []
+    } catch (error) {
+      // #1306: only a missing file is "no prompts"; a damaged one is said.
+      if (error instanceof ConversationPromptsUnreadable) throw error
+      if (isMissingFileError(error)) return []
+      throw new ConversationPromptsUnreadable('pi', error)
     }
   }
 
@@ -175,3 +230,19 @@ export class PiConversationSource implements ConversationSource {
     }
   }
 }
+
+/** The first line of a session file (its header), bounded: a header is one
+ *  small JSON record, so 64 KiB without a newline is itself damage. */
+async function readFirstLine(file: string): Promise<string> {
+  const handle = await open(file, 'r')
+  try {
+    const buf = Buffer.alloc(64 * 1024)
+    const { bytesRead } = await handle.read(buf, 0, buf.length, 0)
+    const text = buf.subarray(0, bytesRead).toString('utf8')
+    const newline = text.indexOf('\n')
+    if (newline < 0 && bytesRead === buf.length) throw new Error('the session header exceeds 64 KiB')
+    return newline < 0 ? text : text.slice(0, newline)
+  } finally {
+    await handle.close()
+  }
+}
diff --git a/src/main/conversations/sources/promptsUnreadable.system.test.ts b/src/main/conversations/sources/promptsUnreadable.system.test.ts
new file mode 100644
index 000000000..73bdd4032
--- /dev/null
+++ b/src/main/conversations/sources/promptsUnreadable.system.test.ts
@@ -0,0 +1,334 @@
+import { appendFile, chmod, mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { existsSync } from 'node:fs'
+
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import { resolveGrokTranscriptPath } from 'grok-code-headless'
+import { encodeCwdForSessionDir } from 'pi-terminal-headless'
+
+import { sanitizePath } from '@shared/runtime/projectDir.js'
+import { resolveFamily } from '../family.js'
+import { ClaudeHistoryIndex } from './claudeHistory.js'
+import { ClaudeConversationSource } from './claude.js'
+import { CodexConversationSource } from './codex.js'
+import { PiConversationSource } from './pi.js'
+import { GrokConversationSource } from './grok.js'
+import { OpencodeConversationSource } from './opencode.js'
+import { ConversationPromptsUnreadable } from './types.js'
+import { corpusWorktreesPorcelain, installConversationCorpus } from '../../../../testing/support/conversations/installCorpus.js'
+
+// #1306: a conversation whose transcript or store is THERE but unreadable
+// answered [] from every source, so View Prompts said "no prompts" for a
+// damaged file. Each source now throws ConversationPromptsUnreadable for it,
+// and a missing file still answers [] (a new session has none yet). The Pi
+// source is pinned in pi.system.test.ts.
+//
+// Real files: the recorded conversation corpus, made unreadable with chmod
+// (or, for OpenCode's store, replaced by bytes that are not a database).
+
+const cleanups: Array<() => Promise<void>> = []
+let corpus: Awaited<ReturnType<typeof installConversationCorpus>>
+let listWorktrees: () => Promise<Array<{ path: string }>>
+beforeAll(async () => {
+  corpus = await installConversationCorpus()
+  cleanups.push(corpus.cleanup)
+  const porcelain = await corpusWorktreesPorcelain()
+  const worktrees = porcelain.split('\n').filter(l => l.startsWith('worktree ')).map(l => ({ path: l.slice('worktree '.length) }))
+  listWorktrees = async () => worktrees
+})
+afterAll(async () => { for (const c of cleanups.splice(0)) await c() })
+
+// The prompt folder caches by size and mtime, and a cached answer for an
+// unchanged file is correct. The file changes first (as a live transcript
+// does), so the read after it is a real read of an unreadable file.
+async function unreadable<T>(file: string, run: () => Promise<T>): Promise<T> {
+  await appendFile(file, '\n')
+  await chmod(file, 0o000)
+  try {
+    return await run()
+  } finally {
+    await chmod(file, 0o600)
+  }
+}
+
+describe('a conversation file that is there but unreadable', () => {
+  it('Claude says so; a missing one is still no prompts', async () => {
+    const history = new ClaudeHistoryIndex(join(corpus.claudeConfigDir, 'history.jsonl'))
+    await history.refresh()
+    const source = new ClaudeConversationSource({ projectsDir: join(corpus.claudeConfigDir, 'projects'), history })
+    const family = await resolveFamily('/fixture/repo', 'cwd', { listWorktrees })
+    const row = (await source.discover({ scope: 'cwd', family })).find(r => (r.promptCount ?? 0) > 0 && r.cwd)!
+    const file = join(corpus.claudeConfigDir, 'projects', sanitizePath(row.cwd!), `${row.nativeId}.jsonl`)
+    await expect(unreadable(file, () => source.prompts(row.nativeId, row.cwd!))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect(await source.prompts('00000000-0000-0000-0000-000000000000', row.cwd!)).toEqual([])
+  })
+
+  it('Codex says so for a known rollout', async () => {
+    const source = new CodexConversationSource({ codexHome: corpus.codexHome })
+    const family = await resolveFamily('/fixture/repo', 'repository', { listWorktrees })
+    const rows = await source.discover({ scope: 'repository', family })
+    const paths = (source as unknown as { rolloutPaths: Map<string, string> }).rolloutPaths
+    // A rollout the corpus actually holds (some recorded paths point elsewhere).
+    const row = rows.find(r => paths.has(r.nativeId) && existsSync(paths.get(r.nativeId)!))!
+    const file = paths.get(row.nativeId)!
+    expect(file).toBeTruthy()
+    await expect(unreadable(file, () => source.prompts(row.nativeId, row.cwd ?? ''))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+  })
+
+  it('OpenCode says so when its store is not a database; no store at all is no prompts', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const damaged = join(corpus.opencodeDataDir, '..', 'opencode-damaged')
+      await mkdir(damaged, { recursive: true })
+      await writeFile(join(damaged, 'opencode.db'), 'this is not an sqlite database')
+      await expect(new OpencodeConversationSource({ dataDir: damaged }).prompts('ses_x', '/fixture/repo')).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+      expect(await new OpencodeConversationSource({ dataDir: join(damaged, 'absent') }).prompts('ses_x', '/fixture/repo')).toEqual([])
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('Grok says so; a missing one is still no prompts', async () => {
+    const grokHome = join(corpus.opencodeDataDir, '..', 'grok-home')
+    // Grok resolves the cwd's real path, so it must exist.
+    const cwd = join(corpus.opencodeDataDir, '..', 'grok-project')
+    await mkdir(cwd, { recursive: true })
+    const id = '11111111-1111-4111-8111-111111111111'
+    const file = resolveGrokTranscriptPath(cwd, id, grokHome)
+    await mkdir(join(file, '..'), { recursive: true })
+    // A session the loader accepts: its summary names it, format version 1.
+    await writeFile(join(file, '..', 'summary.json'), JSON.stringify({ info: { id, cwd }, chat_format_version: 1 }))
+    await writeFile(file, '')
+    const source = new GrokConversationSource({ grokHome })
+    await expect(unreadable(file, () => source.prompts(id, cwd))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect(await source.prompts('22222222-2222-4222-8222-222222222222', cwd)).toEqual([])
+  })
+})
+
+// Steering q116: the step BEFORE the read (finding the file) also mapped every
+// failure to "not here". A stat or readdir that fails for anything but absence
+// is unknown and is said; after the directory recovers, the same call reads.
+describe('finding a conversation file that cannot be listed', () => {
+  async function unlisted<T>(dir: string, run: () => Promise<T>): Promise<T> {
+    await chmod(dir, 0o000)
+    try {
+      return await run()
+    } finally {
+      await chmod(dir, 0o700)
+    }
+  }
+
+  it('Claude: an unlistable project directory is unreadable, then reads once it recovers', async () => {
+    const history = new ClaudeHistoryIndex(join(corpus.claudeConfigDir, 'history.jsonl'))
+    await history.refresh()
+    const source = new ClaudeConversationSource({ projectsDir: join(corpus.claudeConfigDir, 'projects'), history })
+    const family = await resolveFamily('/fixture/repo', 'cwd', { listWorktrees })
+    const row = (await source.discover({ scope: 'cwd', family })).find(r => (r.promptCount ?? 0) > 1 && r.cwd)!
+    const dir = join(corpus.claudeConfigDir, 'projects', sanitizePath(row.cwd!))
+    await expect(unlisted(dir, () => source.prompts(row.nativeId, row.cwd!))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect((await source.prompts(row.nativeId, row.cwd!)).length).toBeGreaterThan(0)
+  })
+
+  it('Codex: an unlistable sessions tree is unreadable; a missing one is no prompts', async () => {
+    const codexHome = join(corpus.opencodeDataDir, '..', 'codex-unlistable')
+    await mkdir(join(codexHome, 'sessions'), { recursive: true })
+    const source = new CodexConversationSource({ codexHome })
+    await expect(unlisted(join(codexHome, 'sessions'), () => source.prompts('019-thread', ''))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect(await source.prompts('019-thread', '')).toEqual([])
+    expect(await new CodexConversationSource({ codexHome: join(codexHome, 'absent') }).prompts('019-thread', '')).toEqual([])
+  })
+
+  it('Pi: an unlistable session directory is unreadable, then answers once it recovers', async () => {
+    const home = join(corpus.opencodeDataDir, '..', 'pi-home')
+    const cwd = join(home, 'project')
+    const dir = join(home, '.pi', 'agent', 'sessions', encodeCwdForSessionDir(cwd))
+    await mkdir(dir, { recursive: true })
+    const source = new PiConversationSource({ env: {}, homeDirectory: home })
+    await expect(unlisted(dir, () => source.prompts('session-1', cwd))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect(await source.prompts('session-1', cwd)).toEqual([])
+  })
+})
+
+// #1434 review round 1 (a, b): paths where "unknown" still became "no prompts"
+// one level below the first fix — existsSync reads EACCES as absent, the
+// providers' own walks and resolvers skip what they cannot read, and a
+// transcript whose every line is garbage folded to nothing. Real files: the
+// recorded corpus's rollouts and databases, locked or damaged.
+describe('round 1: unknown is never "no prompts"', () => {
+  const scratch = (name: string) => join(corpus.opencodeDataDir, '..', `r1-${name}`)
+  async function locked<T>(dir: string, run: () => Promise<T>): Promise<T> {
+    await chmod(dir, 0o000)
+    try {
+      return await run()
+    } finally {
+      await chmod(dir, 0o700)
+    }
+  }
+
+  it('Codex: a known rollout under a locked day directory is unreadable, and reads once it opens', async () => {
+    const source = new CodexConversationSource({ codexHome: corpus.codexHome })
+    const family = await resolveFamily('/fixture/repo', 'repository', { listWorktrees })
+    const rows = await source.discover({ scope: 'repository', family })
+    const paths = (source as unknown as { rolloutPaths: Map<string, string> }).rolloutPaths
+    const row = rows.find(r => paths.has(r.nativeId) && existsSync(paths.get(r.nativeId)!))!
+    const before = await source.prompts(row.nativeId, row.cwd ?? '')
+    const day = join(paths.get(row.nativeId)!, '..')
+    await expect(locked(day, () => source.prompts(row.nativeId, row.cwd ?? ''))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    expect(await source.prompts(row.nativeId, row.cwd ?? '')).toEqual(before)
+  })
+
+  it('Codex: a state index that is there but cannot be opened, with no rollout found, is unreadable', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const codexHome = scratch('codex-bad-index')
+      await mkdir(join(codexHome, 'sessions'), { recursive: true })
+      await writeFile(join(codexHome, 'state_5.sqlite'), 'this is not an sqlite database')
+      await expect(new CodexConversationSource({ codexHome }).prompts('019-missing', '')).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+      // No index at all and no rollout: genuinely not here.
+      const bare = scratch('codex-no-index')
+      await mkdir(join(bare, 'sessions'), { recursive: true })
+      expect(await new CodexConversationSource({ codexHome: bare }).prompts('019-missing', '')).toEqual([])
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('OpenCode: a real database in an inaccessible directory is unreadable, not absent', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const dataDir = scratch('opencode-locked')
+      await mkdir(dataDir, { recursive: true })
+      const { copyFile } = await import('node:fs/promises')
+      await copyFile(join(corpus.opencodeDataDir, 'opencode.db'), join(dataDir, 'opencode.db'))
+      const source = new OpencodeConversationSource({ dataDir })
+      await expect(locked(dataDir, () => source.prompts('ses_x', '/fixture/repo'))).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+      expect(await source.prompts('ses_x', '/fixture/repo')).toEqual([])
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it('Pi: a session named for this id whose header is damaged is unreadable; a readable header for another cwd is not this session', async () => {
+    const home = scratch('pi-home')
+    const cwd = join(home, 'project')
+    const dir = join(home, '.pi', 'agent', 'sessions', encodeCwdForSessionDir(cwd))
+    await mkdir(dir, { recursive: true })
+    const source = new PiConversationSource({ env: {}, homeDirectory: home })
+    await writeFile(join(dir, '2026-09-27T00-00-00-000Z_thread-1.jsonl'), '{bad json}\n')
+    await expect(source.prompts('thread-1', cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    await writeFile(join(dir, '2026-09-27T00-00-00-000Z_thread-2.jsonl'), `${JSON.stringify({ type: 'session', id: 'thread-2', cwd: '/elsewhere' })}\n`)
+    expect(await source.prompts('thread-2', cwd)).toEqual([])
+  })
+
+  it('Grok: a transcript whose summary is gone is unreadable; a transcript mid-write settles and reads', async () => {
+    const grokHome = scratch('grok-home')
+    const cwd = scratch('grok-project')
+    await mkdir(cwd, { recursive: true })
+    const lost = '33333333-3333-4333-8333-333333333333'
+    const lostFile = resolveGrokTranscriptPath(cwd, lost, grokHome)
+    await mkdir(join(lostFile, '..'), { recursive: true })
+    await writeFile(lostFile, '')
+    const source = new GrokConversationSource({ grokHome })
+    await expect(source.prompts(lost, cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+
+    const writing = '44444444-4444-4444-8444-444444444444'
+    const file = resolveGrokTranscriptPath(cwd, writing, grokHome)
+    await mkdir(join(file, '..'), { recursive: true })
+    await writeFile(join(file, '..', 'summary.json'), JSON.stringify({ info: { id: writing, cwd }, chat_format_version: 1 }))
+    await writeFile(file, '{"partial":')
+    // Grok's writer finishes the record while the reader waits.
+    setTimeout(() => { void writeFile(file, '') }, 100)
+    expect(await source.prompts(writing, cwd)).toEqual([])
+  })
+
+  it('Claude: a transcript whose every line is garbage is unreadable; one good record keeps it readable', async () => {
+    const projectsDir = scratch('claude-projects')
+    const cwd = '/fixture/garbled'
+    const dir = join(projectsDir, sanitizePath(cwd))
+    await mkdir(dir, { recursive: true })
+    const source = new ClaudeConversationSource({ projectsDir, history: new ClaudeHistoryIndex(join(projectsDir, 'history.jsonl')) })
+    await writeFile(join(dir, '55555555-5555-4555-8555-555555555555.jsonl'), '{not-json}\n{also not json}\n')
+    await expect(source.prompts('55555555-5555-4555-8555-555555555555', cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    // And again from the prompt folder's cache (#1434 verification a: the
+    // cache-hit path's check was unpinned).
+    await expect(source.prompts('55555555-5555-4555-8555-555555555555', cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    // A recorded transcript with one garbage line in front: still readable,
+    // the same prompts as the original (bad lines are skipped, as before).
+    const recorded = new ClaudeConversationSource({ projectsDir: join(corpus.claudeConfigDir, 'projects'), history: new ClaudeHistoryIndex(join(corpus.claudeConfigDir, 'history.jsonl')) })
+    const family = await resolveFamily('/fixture/repo', 'cwd', { listWorktrees })
+    const real = (await recorded.discover({ scope: 'cwd', family })).find(r => (r.promptCount ?? 0) > 0 && r.cwd)!
+    const { readFile } = await import('node:fs/promises')
+    const original = await readFile(join(corpus.claudeConfigDir, 'projects', sanitizePath(real.cwd!), `${real.nativeId}.jsonl`), 'utf8')
+    const mixedDir = join(projectsDir, sanitizePath(real.cwd!))
+    await mkdir(mixedDir, { recursive: true })
+    await writeFile(join(mixedDir, `${real.nativeId}.jsonl`), `{not-json}\n${original}`)
+    const expected = await recorded.prompts(real.nativeId, real.cwd!)
+    expect(expected.length).toBeGreaterThan(0)
+    expect(await source.prompts(real.nativeId, real.cwd!)).toEqual(expected)
+  })
+})
+
+// #1434 review c: the ABSENT half of the rule, on a real fresh install (the
+// Pi probe's `missing -> []` survived a mutation because every fixture created
+// the directories first), and ENOTDIR — a path component that is a plain file
+// — which is absence too, never "unreadable".
+describe('round 1 c: absence stays "no prompts"', () => {
+  it('Pi on a home with no .pi at all answers no prompts', async () => {
+    const home = join(corpus.opencodeDataDir, '..', 'r1c-fresh-pi-home')
+    await mkdir(home, { recursive: true })
+    const source = new PiConversationSource({ env: {}, homeDirectory: home })
+    expect(await source.prompts('session-1', join(home, 'project'))).toEqual([])
+  })
+
+  it('a store path through a plain file (ENOTDIR) is absent, not unreadable', async () => {
+    const file = join(corpus.opencodeDataDir, '..', 'r1c-plain-file')
+    await writeFile(file, 'not a directory')
+    expect(await new OpencodeConversationSource({ dataDir: join(file, 'opencode') }).prompts('ses_x', '/fixture/repo')).toEqual([])
+    expect(await new CodexConversationSource({ codexHome: join(file, 'codex') }).prompts('019-x', '')).toEqual([])
+  })
+})
+
+// #1434 verification a.
+describe('verification: the conversation file itself', () => {
+  it('Codex: its own rollout with an unreadable mode in a listable tree is unreadable, not absent', async () => {
+    const { copyFile } = await import('node:fs/promises')
+    const id = 'ff781eb7-f74e-4308-8edb-bda07505686f'
+    const codexHome = join(corpus.opencodeDataDir, '..', 'v-codex-locked-file')
+    const day = join(codexHome, 'sessions', '2026', '04', '13')
+    await mkdir(day, { recursive: true })
+    const file = join(day, `rollout-2026-04-13T16-52-23-${id}.jsonl`)
+    // A real recorded rollout (the corpus's), no index, no cached path.
+    await copyFile(join(__dirname, '../../../../testing/fixtures/conversations/codex/sessions/2026/04/13', `rollout-2026-04-13T16-52-23-${id}.jsonl`), file)
+    const source = new CodexConversationSource({ codexHome })
+    const readable = await source.prompts(id, '')
+    await chmod(file, 0o000)
+    try {
+      await expect(new CodexConversationSource({ codexHome }).prompts(id, '')).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+    } finally {
+      await chmod(file, 0o600)
+    }
+    expect(await new CodexConversationSource({ codexHome }).prompts(id, '')).toEqual(readable)
+  })
+
+  it('Pi: a named file whose first row is not this session\'s header is damaged, not absent', async () => {
+    const home = join(corpus.opencodeDataDir, '..', 'v-pi-home')
+    const cwd = join(home, 'project')
+    const dir = join(home, '.pi', 'agent', 'sessions', encodeCwdForSessionDir(cwd))
+    await mkdir(dir, { recursive: true })
+    await writeFile(join(dir, '2026-09-27T00-00-00-000Z_thread-3.jsonl'), `${JSON.stringify({ type: 'message', id: 'thread-3', cwd })}\n`)
+    await expect(new PiConversationSource({ env: {}, homeDirectory: home }).prompts('thread-3', cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+  })
+
+  it('Pi: a parseable session header with an invalid id is damaged, not absent', async () => {
+    // #1434 verification b's exact repro: Pi's own resolver rejects a header
+    // whose id is not a string (sessionPaths.ts), so the locator skips it. Only
+    // a real header for THIS id may mean "another cwd"; `id: null` is damage.
+    const home = join(corpus.opencodeDataDir, '..', 'v-pi-home-null-id')
+    const cwd = join(home, 'project')
+    const dir = join(home, '.pi', 'agent', 'sessions', encodeCwdForSessionDir(cwd))
+    await mkdir(dir, { recursive: true })
+    await writeFile(join(dir, '2026-09-27T00-00-00-000Z_thread-1.jsonl'), `${JSON.stringify({ type: 'session', id: null, cwd })}\n`)
+    await expect(new PiConversationSource({ env: {}, homeDirectory: home }).prompts('thread-1', cwd)).rejects.toBeInstanceOf(ConversationPromptsUnreadable)
+  })
+})
diff --git a/src/main/conversations/sources/types.ts b/src/main/conversations/sources/types.ts
index 54f811a25..6c9b6b1f1 100644
--- a/src/main/conversations/sources/types.ts
+++ b/src/main/conversations/sources/types.ts
@@ -1,6 +1,8 @@
 import type { ConversationPrompt, ConversationScope } from '@shared/conversations/types.js'
 import type { AgentProviderKind } from '@shared/types/providerKind.js'
 import type { RepositoryFamily } from '@main/conversations/family.js'
+import { readdir, stat } from 'fs/promises'
+import { join } from 'path'
 
 // Raw, provider-shaped ingredients. No label, no kind, no order: the catalog
 // decides those (docs/decomposition/conversations.md §4). An adapter reports
@@ -48,6 +50,85 @@ export type PromptReadOptions = {
   maxBytes?: number
 }
 
+/**
+ * A conversation whose transcript or store EXISTS but cannot be read (#1306).
+ * Sources used to answer `[]` for it, so View Prompts said "no prompts" for a
+ * damaged file. The rule every source follows:
+ *   - no file (yet): `[]`. A freshly started session has no transcript, and
+ *     View Prompts then shows the live feed's prompts; that is not a failure;
+ *   - a file or store that is there but unreadable: throw this.
+ * Search catches it per conversation (label-only search for that row); View
+ * Prompts surfaces it. The cause stays on the error for the main-side log; the
+ * message is fixed, because it crosses IPC to the UI (q22).
+ */
+export class ConversationPromptsUnreadable extends Error {
+  constructor(readonly provider: string, readonly cause: unknown) {
+    super('The conversation file could not be read')
+    this.name = 'ConversationPromptsUnreadable'
+  }
+}
+
+/** True for the "no such file" family: a missing transcript is not a failure. */
+export function isMissingFileError(error: unknown): boolean {
+  const code = (error as NodeJS.ErrnoException | undefined)?.code
+  return code === 'ENOENT' || code === 'ENOTDIR'
+}
+
+/**
+ * Whether a path is there, telling ABSENT from UNKNOWN (#1434 round 1, a/b).
+ *
+ * WHY not existsSync: it answers false for EACCES too, so an inaccessible
+ * database or rollout read as "absent" and the prompts as `[]` — the exact
+ * #1306 failure, one level up. Absence (ENOENT/ENOTDIR) is false; anything
+ * else is unknown and throws the typed error, never "no prompts".
+ */
+export async function isPresent(provider: AgentProviderKind, path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch (error) {
+    if (isMissingFileError(error)) return false
+    throw new ConversationPromptsUnreadable(provider, error)
+  }
+}
+
+/**
+ * List every directory under `root`, `depth` levels down, and throw the typed
+ * error on the first one that cannot be listed (#1434 round 1, a/b).
+ *
+ * WHY: the providers' own walks (codex-headless's rollout locator) swallow
+ * every readdir error below their root, so a locked `sessions/2026/01/01`
+ * made a known conversation read as "not here". This runs only on the MISS
+ * path — after the walk found nothing — so its cost is paid only when the
+ * answer would otherwise be the unsafe "no prompts". An absent root is fine.
+ */
+export async function assertTreeListable(
+  provider: AgentProviderKind,
+  root: string,
+  depth: number,
+  /** A file this conversation would be stored in. #1434 verification a: the
+   *  locator also skips a FILE it cannot open, so a listable tree holding the
+   *  conversation's own file under an unreadable mode read as "absent". A name
+   *  that matches here means the file is present and the walk could not read
+   *  it: unknown, never "no prompts". */
+  namesThisConversation?: (name: string) => boolean,
+): Promise<void> {
+  let entries
+  try {
+    entries = await readdir(root, { withFileTypes: true })
+  } catch (error) {
+    if (isMissingFileError(error)) return
+    throw new ConversationPromptsUnreadable(provider, error)
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (depth > 0) await assertTreeListable(provider, join(root, entry.name), depth - 1, namesThisConversation)
+    } else if (namesThisConversation?.(entry.name)) {
+      throw new ConversationPromptsUnreadable(provider, new Error('the conversation file is present but the provider walk could not read it'))
+    }
+  }
+}
+
 export interface ConversationSource {
   readonly provider: AgentProviderKind
   discover(scope: SourceScope): Promise<SourceConversation[]>
diff --git a/src/main/goalLoop/GoalLoopService.test.ts b/src/main/goalLoop/GoalLoopService.test.ts
index 879bdab2d..59c6c47c5 100644
--- a/src/main/goalLoop/GoalLoopService.test.ts
+++ b/src/main/goalLoop/GoalLoopService.test.ts
@@ -104,6 +104,36 @@ describe('GoalLoopService drain (#1341)', () => {
     expect(deliver).toHaveBeenCalledTimes(1)
   })
 
+  // #1449 review a: a PUBLIC mutator (goal_loop_complete / goal_loop_start
+  // through MCP) awaited persist() without tracking it, so dispose() saw
+  // nothing in flight and quit could cut the write off; the next launch then
+  // turned the completed loop into paused(interrupted).
+  for (const [name, act] of [
+    ['complete', (svc: GoalLoopService) => svc.complete('s1', 'done', 'Shipped.')],
+    ['startLoop', (svc: GoalLoopService) => svc.startLoop('s2', { goal: 'G2.', loopPrompt: 'P2.' })],
+  ] as const) {
+    it(`dispose waits for a public ${name} whose write is in flight`, async () => {
+      const directory = await mkdtemp(join(tmpdir(), 'agent-code-goal-loop-'))
+      directories.push(directory)
+      const store = new GatedStore(join(directory, 'goal-loop.json'))
+      const { svc } = await service(undefined, store)
+      await svc.startLoop('s1', { goal: 'G.', loopPrompt: 'P.' })
+      let open!: () => void
+      store.gate = new Promise(resolve => { open = resolve })
+      const mutation = act(svc)
+      await new Promise(resolve => setImmediate(resolve))
+      let disposed = false
+      const disposing = svc.dispose().then(() => { disposed = true })
+      await new Promise(resolve => setImmediate(resolve))
+      expect(disposed).toBe(false)
+      open()
+      await mutation
+      await disposing
+      const written = await readFile(join(directory, 'goal-loop.json'), 'utf8')
+      expect(written).toContain(name === 'complete' ? '"ended"' : '"s2"')
+    })
+  }
+
   it('a disposed service ignores a held loop\'s quiet edge, which continues directly', async () => {
     // The process-state edge calls requestContinue with no timer in between, so only the service's
     // own disposed check stands between it and a delivery.
diff --git a/src/main/goalLoop/GoalLoopService.ts b/src/main/goalLoop/GoalLoopService.ts
index 0fef7022c..8f2565e4a 100644
--- a/src/main/goalLoop/GoalLoopService.ts
+++ b/src/main/goalLoop/GoalLoopService.ts
@@ -1139,7 +1139,21 @@ export class GoalLoopService extends EventEmitter {
     settle?.()
   }
 
-  private async persist(): Promise<void> {
+  /**
+   * Every persist is in flight until it lands, awaited or not (#1449 review a).
+   * The public mutators (goal_loop_start / goal_loop_complete via MCP) awaited
+   * their write without tracking it, so dispose() at quit saw nothing in
+   * flight and the process could exit mid-write; the next launch then read the
+   * old state and turned a completed loop into paused(interrupted). Tracking
+   * here, at the one write path, covers every caller present and future.
+   */
+  private persist(): Promise<void> {
+    const work = this.persistNow()
+    this.track(work)
+    return work
+  }
+
+  private async persistNow(): Promise<void> {
     // Bound the map (and so the file, whose reader rejects more than
     // GOAL_LOOP_STORE_LIMIT entries). Eviction order, least valuable first:
     // oldest ended, then oldest paused. ACTIVE loops are never evicted — each
diff --git a/src/main/incident/journalTypes.ts b/src/main/incident/journalTypes.ts
index 4dedb304f..d2ad58faa 100644
--- a/src/main/incident/journalTypes.ts
+++ b/src/main/incident/journalTypes.ts
@@ -122,6 +122,11 @@ export type AppRunIncidentKind =
   | 'orchestration.late_response_adopted'
   | 'claude.proxy_transport_gap'
   | 'orchestration.prompt_delivery_failed'
+  // A bootstrap prompt WAS delivered but its "delivered" mark could not be
+  // persisted, on a path with no tool reply to carry the warning (a create
+  // adopted after its caller's deadline, #1370 / q85). The child may later be
+  // reported as never bootstrapped.
+  | 'orchestration.bootstrap_mark_failed'
   | 'mcp.host_start_failed'
   // Remote mobile companion (src/main/remote/) — declared here because this
   // union is the app-wide incident vocabulary; the remote subsystem imports
diff --git a/src/main/index.ts b/src/main/index.ts
index 4e64c78b8..39c137d5f 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -315,6 +315,9 @@ let disposeExternalControl: (() => Promise<void>) | null = null
 // actually buys is catching a future `disposeControl: () => { dispose() }`
 // that drops the promise on the floor at the CALL SITE.
 let disposeControlHost: (() => Promise<void>) | null = null
+// Published by startup once the service exists (#1372). Null means startup
+// never got that far, so there is nothing to drain.
+let disposeGoalLoop: (() => Promise<void>) | null = null
 let shutdownWorkspaceStore: WorkspaceFileStore | null = null
 
 class StartupInterruptedByQuit extends Error {}
@@ -1243,6 +1246,7 @@ async function startApp(): Promise<void> {
   const goalLoopStore = new GoalLoopStore(join(STATE_DIR, 'goal-loop.json'))
   const goalLoopService = new GoalLoopService({ manager, store: goalLoopStore })
   await goalLoopService.start()
+  disposeGoalLoop = () => goalLoopService.dispose()
   registerGoalLoopIpc(goalLoopService)
   // Lane browser pocket (#1142). One controller for the app: it owns live CDP
   // sessions and per-pocket queues that must outlive the per-request MCP
@@ -1737,6 +1741,7 @@ const sessionShutdownGate = installApplicationShutdown({
     disposeControl: () => disposeControlHost?.(),
     disposeWorkflowBridge: () => workflowBridge?.dispose(),
     disposeCaffeinate: () => caffeinateController.dispose(),
+    disposeGoalLoop: () => disposeGoalLoop?.(),
     stopHeapWatchdog: stopMainHeapWatchdog,
     stopDetachedTmuxSweep: () => { detachedTmuxSweep?.stop(); detachedTmuxSweep = null },
     drainWorkspace: () => shutdownWorkspaceStore?.drainAdmittedWrites(),
diff --git a/src/main/ipc/agentCodeConventions.ts b/src/main/ipc/agentCodeConventions.ts
index 9ac6b53f8..acfb3d32c 100644
--- a/src/main/ipc/agentCodeConventions.ts
+++ b/src/main/ipc/agentCodeConventions.ts
@@ -8,6 +8,7 @@ import type {
   ClearAgentCodeConventionsRequest,
   SaveAgentCodeConventionsRequest,
 } from '@shared/types/agentCodeConventions.js'
+import { revealFailureMessage } from '@main/agentCodeConventions/userFacingError.js'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -76,7 +77,7 @@ export function registerAgentCodeConventionsIpc(
     if (file?.isFile()) shell.showItemInFolder(path)
     else {
       const error = await shell.openPath(dirname(path))
-      if (error) return { ok: false, message: error }
+      if (error) return { ok: false, message: revealFailureMessage(error, 'agent-code-conventions') }
     }
     return { ok: true }
   })
diff --git a/src/main/ipc/agentCodeCustomSkills.ts b/src/main/ipc/agentCodeCustomSkills.ts
index 6208b222b..8a1a48f77 100644
--- a/src/main/ipc/agentCodeCustomSkills.ts
+++ b/src/main/ipc/agentCodeCustomSkills.ts
@@ -12,6 +12,7 @@ import type {
   UpdateAgentCodeCustomSkillRequest,
 } from '@shared/types/agentCodeCustomSkills.js'
 import { isAgentProviderKind } from '@shared/types/providerKind.js'
+import { revealFailureMessage } from '@main/agentCodeConventions/userFacingError.js'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -118,7 +119,7 @@ export function registerAgentCodeCustomSkillsIpc(service: AgentCodeConventionsSe
       if (file?.isFile()) shell.showItemInFolder(path)
       else {
         const error = await shell.openPath(dirname(path))
-        if (error) return { ok: false, message: error }
+        if (error) return { ok: false, message: revealFailureMessage(error, 'agent-code-custom-skills') }
       }
       return { ok: true }
     },
diff --git a/src/main/ipc/agentCodeInstalledSkills.ts b/src/main/ipc/agentCodeInstalledSkills.ts
index 052332cbf..a5c713ba2 100644
--- a/src/main/ipc/agentCodeInstalledSkills.ts
+++ b/src/main/ipc/agentCodeInstalledSkills.ts
@@ -11,6 +11,7 @@ import {
   type SetAgentCodeInstalledSkillEnabledRequest,
   type SetAgentCodeInstalledSkillProvidersRequest,
 } from '@shared/types/agentCodeInstalledSkills.js'
+import { revealFailureMessage } from '@main/agentCodeConventions/userFacingError.js'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -127,7 +128,7 @@ export function registerAgentCodeInstalledSkillsIpc(service: AgentCodeConvention
       const stat = await lstat(path).catch(() => null)
       if (!stat?.isDirectory()) return { ok: false, message: 'Installed skill target no longer exists.' }
       const error = await shell.openPath(path)
-      return error ? { ok: false, message: error } : { ok: true }
+      return error ? { ok: false, message: revealFailureMessage(error, 'agent-code-installed-skills') } : { ok: true }
     },
   )
   ipcMain.handle('agent-code-installed-skills:reveal-source', async (_event, skillId: unknown) => {
@@ -135,7 +136,7 @@ export function registerAgentCodeInstalledSkillsIpc(service: AgentCodeConvention
     const path = await service.resolveInstalledSkillSource(skillId)
     if (!path) return { ok: false, message: 'Installed skill source snapshot is unavailable.' }
     const error = await shell.openPath(path)
-    return error ? { ok: false, message: error } : { ok: true }
+    return error ? { ok: false, message: revealFailureMessage(error, 'agent-code-installed-skills') } : { ok: true }
   })
   ipcMain.handle('agent-code-installed-skills:reveal-recovery', async () => {
     const path = await service.resolveRecoveryFile()
diff --git a/src/main/ipc/cliUpdates.test.ts b/src/main/ipc/cliUpdates.test.ts
index 25e0986ee..067a14c30 100644
--- a/src/main/ipc/cliUpdates.test.ts
+++ b/src/main/ipc/cliUpdates.test.ts
@@ -59,3 +59,15 @@ it('opens nothing for a path, an unknown CLI, or a CLI whose state is not failed
   expect(await openLog('codex')).toBe(false)
   expect(shell.openPath).not.toHaveBeenCalled()
 })
+
+// #1425: an update that could not start has no log; there is nothing to open.
+it('opens nothing for a could-not-start failure, which has no log', async () => {
+  shell.openPath.mockResolvedValue('')
+  snapshot.claude = { ...failed, reason: 'could-not-start', logPath: null }
+  try {
+    expect(await openLog('claude')).toBe(false)
+    expect(shell.openPath).not.toHaveBeenCalled()
+  } finally {
+    snapshot.claude = failed
+  }
+})
diff --git a/src/main/ipc/cliUpdates.ts b/src/main/ipc/cliUpdates.ts
index ffdc508ce..4ad52751b 100644
--- a/src/main/ipc/cliUpdates.ts
+++ b/src/main/ipc/cliUpdates.ts
@@ -73,7 +73,9 @@ export function registerCliUpdatesIpc(orchestrator: CliUpdateOrchestrator): void
     // the one path it wrote: the current failed state's log. Anything else
     // (an unknown CLI, a state that is not `failed`) opens nothing.
     const state = cli === 'claude' || cli === 'codex' ? orchestrator.getSnapshot()[cli] : undefined
-    if (state?.kind !== 'failed') return false
+    // #1425: a `could-not-start` failure has no log (the attempt stopped
+    // before creating one); there is nothing to open.
+    if (state?.kind !== 'failed' || state.logPath === null) return false
     // shell.openPath RESOLVES with '' on success and an error string on
     // failure. WHY the answer is returned (#1250 row 10): this used to discard
     // the string on the belief that "the OS shell surfaces its own error
diff --git a/src/main/ipc/recoveryReveal.test.ts b/src/main/ipc/recoveryReveal.test.ts
index 3c013eaca..e98ec253b 100644
--- a/src/main/ipc/recoveryReveal.test.ts
+++ b/src/main/ipc/recoveryReveal.test.ts
@@ -57,3 +57,49 @@ describe('recovery-file reveal', () => {
     expect(shell.showItemInFolder).toHaveBeenCalledWith(statePath)
   })
 })
+
+// Review of #1456 (a), #1427: when shell.openPath fails, Electron returns a
+// string such as `Failed to open /Users/…/skills`, and the four Reveal
+// handlers returned it as the IPC message the Skills rows show. A real
+// directory in the scratch dir; openPath (the OS) is the replaced edge.
+describe('target and source reveal', () => {
+  const raw = 'Failed to open /Users/Alice/.claude/skills'
+  const reveals: Array<[string, unknown[]]> = [
+    ['agent-code-conventions:reveal-target', ['claude-personal-skills']],
+    ['agent-code-custom-skills:reveal-target', ['skill-1', 'claude-personal-skills']],
+    ['agent-code-installed-skills:reveal-target', ['skill-1', 'claude-personal-skills']],
+    ['agent-code-installed-skills:reveal-source', ['skill-1']],
+  ]
+  beforeEach(async () => {
+    const target = join(dir, 'skills', 'agent-code-conventions')
+    await mkdir(target, { recursive: true })
+    handlers.clear()
+    shell.openPath.mockReset()
+    const service = {
+      resolveRevealTarget: async () => target,
+      resolveCustomSkillRevealTarget: async () => target,
+      resolveInstalledSkillRevealTarget: async () => target,
+      resolveInstalledSkillSource: async () => target,
+    } as never
+    registerAgentCodeConventionsIpc(service)
+    registerAgentCodeCustomSkillsIpc(service)
+    registerAgentCodeInstalledSkillsIpc(service)
+  })
+
+  it.each(reveals)('%s answers a failed open in fixed words and logs Electron\'s text', async (channel, args) => {
+    shell.openPath.mockResolvedValue(raw)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const result = await handlers.get(channel)!({}, ...args) as { ok: boolean; message?: string }
+      expect(result).toEqual({ ok: false, message: 'Agent Code could not open this folder.' })
+      expect(warn).toHaveBeenCalledWith(expect.any(String), raw)
+    } finally {
+      warn.mockRestore()
+    }
+  })
+
+  it.each(reveals)('%s reports success when the folder opens', async (channel, args) => {
+    shell.openPath.mockResolvedValue('')
+    expect(await handlers.get(channel)!({}, ...args)).toEqual({ ok: true })
+  })
+})
diff --git a/src/main/orchestration/OrchestrationBridge.ts b/src/main/orchestration/OrchestrationBridge.ts
index 6a8d7e65a..6072c804b 100644
--- a/src/main/orchestration/OrchestrationBridge.ts
+++ b/src/main/orchestration/OrchestrationBridge.ts
@@ -96,10 +96,13 @@ export class OrchestrationOutcomeUnknownError extends Error {
     readonly requestId: string,
     readonly requestType: OrchestrationRendererRequest['type'],
     readonly parentSessionId: string,
+    /** Appended to the message when the caller must also be told what happens next (#1370). */
+    note?: string,
   ) {
     super(
       `The renderer did not answer ${requestType} in time. It may still complete, so the outcome is UNKNOWN: `
-      + `do not repeat it. Call orchestration_list_agents for this parent to see what exists before acting.`,
+      + `do not repeat it. Call orchestration_list_agents for this parent to see what exists before acting.`
+      + (note ? ` ${note}` : ''),
     )
     this.name = 'OrchestrationOutcomeUnknownError'
   }
@@ -253,6 +256,18 @@ export class OrchestrationBridge {
    * every POST — a map owned by the server would never see the duplicate.
    */
   private readonly createCallsInFlight = new Map<string, Promise<unknown>>()
+  /**
+   * What to do with a child whose create answered AFTER the caller gave up, keyed by requestId
+   * (#1370). The tool handler registers its bootstrap delivery here; `adoptLateResponse` runs it.
+   *
+   * WHY: a healthy provider can take longer than the 30 s bridge deadline to start (OpenCode took
+   * 43 s under load). The caller then got "outcome unknown — do not repeat", the handler returned
+   * without delivering the prompt, and the late child was adopted idle, with no brief, and nothing
+   * told the parent. Running the same delivery the punctual path runs, at adoption time, keeps the
+   * promise the create made. An entry lives only while its request is outstanding: it is removed
+   * when the create answers in time, fails outright, or is adopted.
+   */
+  private readonly lateCreates = new Map<string, (agent: OrchestrationAgentRecord) => Promise<void>>()
   private readonly closedAgents = new Map<string, ClosedAgentRecord>()
   private readonly parentSessionByChildSession = new Map<string, string>()
   /**
@@ -291,6 +306,8 @@ export class OrchestrationBridge {
     runId?: string
     builtInMcpDomains?: BuiltInMcpDomain[]
     inheritParentContext?: boolean
+    /** Runs if this create times out and the renderer's answer is adopted late (#1370). */
+    onLateCreate?: (agent: OrchestrationAgentRecord) => Promise<void>
   }): Promise<OrchestrationAgentRecord> {
     // WHY validate before sending a renderer request: an unsupported launch
     // must fail before a child or ownership record can exist. The factory is
@@ -300,12 +317,39 @@ export class OrchestrationBridge {
     if (params.providerRuntime === 'terminal' && !getMainProvider(params.kind).createTerminalSession) {
       throw new Error(`${getMainProvider(params.kind).name} does not support a terminal runtime`)
     }
+    // The continuation is main-side only: a function cannot cross into the renderer.
+    const { onLateCreate, ...requestParams } = params
     const attempt: OrchestrationRendererRequest = {
       requestId: randomUUID(),
       type: 'create-agent',
-      ...params,
+      ...requestParams,
+    }
+    if (onLateCreate) this.lateCreates.set(attempt.requestId, onLateCreate)
+    let response: OrchestrationRendererResponse
+    try {
+      response = await this.request(attempt)
+    } catch (error) {
+      if (!(error instanceof OrchestrationOutcomeUnknownError)) {
+        this.lateCreates.delete(attempt.requestId)
+        throw error
+      }
+      // Still outstanding: keep the continuation for a late answer, and tell the caller about it,
+      // or its natural next move — sending the brief once list_agents shows the child — would
+      // deliver it twice.
+      if (!onLateCreate) throw error
+      throw new OrchestrationOutcomeUnknownError(
+        error.requestId,
+        error.requestType,
+        error.parentSessionId,
+        // Honest about what automatic means (review of #1375, a and c): delivery
+        // is only ATTEMPTED, and only if the renderer later confirms a live
+        // child; a renderer that never answers, a child never ready, or a
+        // parent that closed means no delivery. So the parent is told how to
+        // check rather than promised one.
+        'If the renderer later confirms the child, Agent Code tries to deliver its bootstrap prompt automatically, retrying for about a minute while it starts. That can fail (the child never answers, is never ready, or you close first), so check orchestration_list_agents and orchestration_read_agent (promptSubmitted) before sending the brief yourself, or it may arrive twice.',
+      )
     }
-    const response = await this.request(attempt)
+    this.lateCreates.delete(attempt.requestId)
     if (!response.ok) throw new Error(response.message)
     if (response.type !== 'create-agent') {
       throw new Error(`Unexpected orchestration response: ${response.type}`)
@@ -522,6 +566,18 @@ export class OrchestrationBridge {
     this.invalidateStatusCacheForSession(sessionId)
   }
 
+  /**
+   * Whether an Agent Code window still owns this parent session: the same lease
+   * check dispatch uses. The late bootstrap asks before EVERY attempt, not only
+   * at adoption (review of #1375, round 1 b): a parent can close during a retry
+   * delay, and its brief must not then start an ownerless child.
+   */
+  isParentAttached(parentSessionId: string): boolean {
+    // Through the alias chain (#1369): a parent REPLACED during the late window is carried to its
+    // successor, and the brief follows it; only a parent with no live successor is gone.
+    return Boolean(windowForSession(this.currentParentId(parentSessionId)))
+  }
+
   promptSubmissionCount(sessionId: string): number {
     return this.promptDeliveries.get(sessionId)?.promptSubmissionCount ?? 0
   }
@@ -607,12 +663,20 @@ export class OrchestrationBridge {
    * status cache keeps a stale answer.
    */
   private adoptLateResponse(response: OrchestrationRendererResponse): void {
+    const onLateCreate = this.lateCreates.get(response.requestId)
+    this.lateCreates.delete(response.requestId)
     if (!response.ok || response.type !== 'create-agent') return
     const parentSessionId = response.agent.orchestrationParentId
-    this.promptDeliveries.set(response.agent.sessionId, {
-      createdAt: Date.now(),
-      promptSubmissionCount: 0,
-    })
+    // Only when there is no record yet (review of #1375, round 2 c): the renderer files the child
+    // BEFORE its create answer reaches main, so the parent can find it with list_agents and
+    // send_prompt to it first. Overwriting that record with a zero count erased the submission,
+    // and the late bootstrap then delivered a second brief.
+    if (!this.promptDeliveries.has(response.agent.sessionId)) {
+      this.promptDeliveries.set(response.agent.sessionId, {
+        createdAt: Date.now(),
+        promptSubmissionCount: 0,
+      })
+    }
     this.noteCreatedChild(response.agent.sessionId, parentSessionId)
     this.journal?.recordIncident({
       kind: 'orchestration.late_response_adopted',
@@ -626,8 +690,35 @@ export class OrchestrationBridge {
         // running work nobody is waiting on. Worth an incident even though
         // recovery succeeded.
         bootstrapPromptDelivered: false,
+        // Whether the create's own bootstrap delivery now runs for it (#1370).
+        bootstrapFollows: onLateCreate !== undefined,
       },
     })
+    if (!onLateCreate) return
+    // The parent may have closed while the renderer was still spawning: the
+    // renderer checks the parent BEFORE its slow spawn and files the child
+    // after it, so a close in between can miss the child (review of #1375,
+    // a). Starting the parent's brief then puts an ownerless agent to work.
+    // The same lease check dispatch uses decides it; the child itself is left
+    // for the user, because closing an agent is not this path's call.
+    if (!this.isParentAttached(parentSessionId)) {
+      this.journal?.recordIncident({
+        kind: 'orchestration.prompt_delivery_failed',
+        severity: 'warn',
+        reason: 'create_agent_late_bootstrap_parent_gone',
+        context: { sessionId: response.agent.sessionId, parentSessionId },
+      })
+      return
+    }
+    const agent = this.enrichAgent(response.agent)
+    void onLateCreate(agent).catch((error: unknown) => {
+      this.journal?.recordIncident({
+        kind: 'orchestration.prompt_delivery_failed',
+        severity: 'error',
+        reason: 'create_agent_late_bootstrap',
+        context: { sessionId: agent.sessionId, message: error instanceof Error ? error.message : 'unknown error' },
+      })
+    })
   }
 
   private async cachedListAgents(params: {
diff --git a/src/main/orchestration/timeoutOutcome.test.ts b/src/main/orchestration/timeoutOutcome.test.ts
index b7823c646..0c152bdd6 100644
--- a/src/main/orchestration/timeoutOutcome.test.ts
+++ b/src/main/orchestration/timeoutOutcome.test.ts
@@ -33,7 +33,7 @@ vi.mock('@main/window/windowRegistry.js', () => ({
 
 const { OrchestrationBridge, OrchestrationOutcomeUnknownError } = await import('./OrchestrationBridge.js')
 
-type Incident = { kind: string; context?: Record<string, unknown> }
+type Incident = { kind: string; reason?: string; context?: Record<string, unknown> }
 let incidents: Incident[]
 let bridge: InstanceType<typeof OrchestrationBridge>
 
@@ -173,7 +173,120 @@ describe('a late answer is reconciled, never dropped', () => {
     await vi.advanceTimersByTimeAsync(30_000)
     await settled
 
-    bridge.resolve({ requestId: request.requestId, ok: false, message: 'no window' } as never)
+    // A real failed answer carries its type (review of #1375, b: without it the fixture never
+    // reached the `!response.ok` guard, and removing that guard survived).
+    bridge.resolve({ requestId: request.requestId, ok: false, type: 'create-agent', message: 'no window' } as never)
     expect(incidents.map(incident => incident.kind)).not.toContain('orchestration.late_response_adopted')
   })
 })
+
+// #1370: a healthy provider can take longer than the 30 s deadline to start. The timed-out create
+// told the caller "do not repeat", and the late child was adopted idle, without the brief the
+// create promised. The create's own bootstrap delivery now runs when the late answer is adopted.
+describe('a late-created child still gets its bootstrap prompt (#1370)', () => {
+  it('runs the create\'s late continuation once, with the adopted child, and says so up front', async () => {
+    const late = vi.fn(async (_agent: { sessionId: string }) => {})
+    const create = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const settled = create.catch((error: unknown) => error)
+    const request = lastSent('create-agent') as { requestId: string; onLateCreate?: unknown }
+    // The continuation is main-side only; the renderer never sees it.
+    expect(request).not.toHaveProperty('onLateCreate')
+    await vi.advanceTimersByTimeAsync(30_000)
+    const error = await settled
+    expect(error).toBeInstanceOf(OrchestrationOutcomeUnknownError)
+    // Otherwise the parent's next move — sending the brief once list_agents shows the child —
+    // would deliver it twice.
+    expect(String(error)).toMatch(/If the renderer later confirms the child, Agent Code tries to deliver its bootstrap prompt/)
+    expect(String(error)).toMatch(/check orchestration_list_agents and orchestration_read_agent \(promptSubmitted\) before sending the brief yourself/)
+    expect(late).not.toHaveBeenCalled()
+
+    bridge.resolve({ requestId: request.requestId, ok: true, type: 'create-agent', agent: child('child-late') } as never)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(late).toHaveBeenCalledTimes(1)
+    expect(late.mock.calls[0]![0]).toMatchObject({ sessionId: 'child-late' })
+    const adopted = incidents.find(incident => incident.kind === 'orchestration.late_response_adopted')
+    expect(adopted?.context).toMatchObject({ bootstrapFollows: true })
+  })
+
+  it('runs nothing for a FAILED late answer', async () => {
+    const late = vi.fn(async () => {})
+    const create = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const settled = create.catch((error: unknown) => error)
+    const request = lastSent('create-agent') as { requestId: string }
+    await vi.advanceTimersByTimeAsync(30_000)
+    await settled
+    // A real failed answer carries its type (review of #1375, b: without it the fixture never
+    // reached the `!response.ok` guard, and removing that guard survived).
+    bridge.resolve({ requestId: request.requestId, ok: false, type: 'create-agent', message: 'no window' } as never)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(late).not.toHaveBeenCalled()
+  })
+
+  it('never runs it for a create that answered in time', async () => {
+    const late = vi.fn(async () => {})
+    const create = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const request = lastSent('create-agent') as { requestId: string }
+    bridge.resolve({ requestId: request.requestId, ok: true, type: 'create-agent', agent: child('child-fast') } as never)
+    await expect(create).resolves.toMatchObject({ sessionId: 'child-fast' })
+    await vi.advanceTimersByTimeAsync(30_000)
+    expect(late).not.toHaveBeenCalled()
+  })
+
+  // Review of #1375 (a): the parent closed while the renderer was spawning.
+  // Its brief must not start an ownerless agent.
+  it('runs nothing when the parent is gone by the time the child arrives', async () => {
+    const late = vi.fn(async () => {})
+    const create = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const settled = create.catch((error: unknown) => error)
+    const request = lastSent('create-agent') as { requestId: string }
+    await vi.advanceTimersByTimeAsync(30_000)
+    await settled
+    windowOwner.mockImplementation(sessionId => (sessionId === 'parent-1' ? null : 'window-1'))
+    try {
+      bridge.resolve({ requestId: request.requestId, ok: true, type: 'create-agent', agent: child('child-late') } as never)
+      await vi.advanceTimersByTimeAsync(0)
+      expect(late).not.toHaveBeenCalled()
+      const skipped = incidents.find(incident => incident.reason === 'create_agent_late_bootstrap_parent_gone')
+      expect(skipped?.context).toMatchObject({ sessionId: 'child-late', parentSessionId: 'parent-1' })
+    } finally {
+      windowOwner.mockImplementation(() => 'window-1')
+    }
+  })
+
+  it('reports a late delivery that throws as an incident instead of losing it', async () => {
+    const create = bridge.createAgent({
+      parentSessionId: 'parent-1', kind: 'claude', onLateCreate: async () => { throw new Error('composer gone') },
+    })
+    const settled = create.catch((error: unknown) => error)
+    const request = lastSent('create-agent') as { requestId: string }
+    await vi.advanceTimersByTimeAsync(30_000)
+    await settled
+    bridge.resolve({ requestId: request.requestId, ok: true, type: 'create-agent', agent: child('child-late') } as never)
+    await vi.advanceTimersByTimeAsync(0)
+    const failed = incidents.find(incident => incident.kind === 'orchestration.prompt_delivery_failed')
+    expect(failed?.context).toMatchObject({ sessionId: 'child-late', message: 'composer gone' })
+  })
+
+  // Review of #1375 (b), a surviving mutation: removing every `lateCreates.delete` passed. The
+  // bridge is long-lived, and each create's continuation captures its brief and handler, so the
+  // map must empty however the create ends.
+  it('forgets every create continuation once the create is settled, in time or late', async () => {
+    const lateCreates = (bridge as unknown as { lateCreates: Map<string, unknown> }).lateCreates
+    const late = vi.fn(async () => {})
+    const fast = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const fastRequest = lastSent('create-agent') as { requestId: string }
+    bridge.resolve({ requestId: fastRequest.requestId, ok: true, type: 'create-agent', agent: child('child-fast') } as never)
+    await fast
+    expect(lateCreates.size).toBe(0)
+
+    const slow = bridge.createAgent({ parentSessionId: 'parent-1', kind: 'claude', onLateCreate: late })
+    const settled = slow.catch((error: unknown) => error)
+    const slowRequest = lastSent('create-agent') as { requestId: string }
+    await vi.advanceTimersByTimeAsync(30_000)
+    await settled
+    expect(lateCreates.size).toBe(1)
+    bridge.resolve({ requestId: slowRequest.requestId, ok: true, type: 'create-agent', agent: child('child-late') } as never)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(lateCreates.size).toBe(0)
+  })
+})
diff --git a/src/main/providerSwitch/duplicateSession.test.ts b/src/main/providerSwitch/duplicateSession.test.ts
index 82ae59d1f..008744b24 100644
--- a/src/main/providerSwitch/duplicateSession.test.ts
+++ b/src/main/providerSwitch/duplicateSession.test.ts
@@ -28,6 +28,8 @@ vi.mock('@main/providerSwitch/transcriptEngine.js', () => ({
 
 import { duplicateSession } from './duplicateSession.js'
 import { projectGrokNativeResume } from 'agent-transcript-parser'
+import { losslessProjection } from './testing/losslessProjection.js'
+import { summarizeProjectionReport } from './projectionFidelity.js'
 
 const conversation = {
   schemaVersion: 1 as const,
@@ -46,7 +48,7 @@ describe('duplicateSession neutral integration', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mocks.read.mockResolvedValue(conversation)
-    mocks.project.mockResolvedValue({ values: [{ sessionId: 'new-session' }] })
+    mocks.project.mockResolvedValue(losslessProjection([{ sessionId: 'new-session' }]))
     mocks.sessionId.mockReturnValue('new-session')
     mocks.write.mockResolvedValue('/target/new-session.jsonl')
   })
@@ -68,11 +70,12 @@ describe('duplicateSession neutral integration', () => {
         targetSessionId: '00000000-0000-4000-8000-000000000098',
       }),
     )
-    expect(mocks.write).toHaveBeenCalledWith('/target', { values: [{ sessionId: 'new-session' }] })
+    expect(mocks.write).toHaveBeenCalledWith('/target', losslessProjection([{ sessionId: 'new-session' }]))
     expect(result).toEqual({
       provider: 'claude',
       newProviderSessionId: 'new-session',
       newFilePath: '/target/new-session.jsonl',
+      projectionFidelity: summarizeProjectionReport(losslessProjection([{ sessionId: 'new-session' }])),
     })
   })
 
@@ -128,7 +131,7 @@ describe('duplicate keeps the source conversation\'s own model', () => {
     // Call history from the suites above would otherwise be inspected here.
     for (const mock of Object.values(mocks)) mock.mockReset()
     mocks.read.mockResolvedValue({ entries: [{ kind: 'message', role: 'user' }], sourceSessionIds: ['ses_source'] })
-    mocks.project.mockResolvedValue({ values: [{}] })
+    mocks.project.mockResolvedValue(losslessProjection([{}]))
     mocks.write.mockResolvedValue('/fixture/new.json')
     mocks.sessionId.mockReturnValue('ses_new')
   })
diff --git a/src/main/providerSwitch/duplicateSession.ts b/src/main/providerSwitch/duplicateSession.ts
index 295442c21..0fb2e9df9 100644
--- a/src/main/providerSwitch/duplicateSession.ts
+++ b/src/main/providerSwitch/duplicateSession.ts
@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto'
 
 import type { AgentProviderKind } from '@shared/types/providerKind.js'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity.js'
 
 import { getHostTranscriptAdapter } from '@main/providerSwitch/transcriptEngine.js'
+import { summarizeProjectionReport } from '@main/providerSwitch/projectionFidelity.js'
 
 export type DuplicateSessionRequest = {
   provider: AgentProviderKind
@@ -16,6 +18,9 @@ export type DuplicateSessionResult = {
   provider: AgentProviderKind
   newProviderSessionId: string
   newFilePath: string
+  /** What the projector did to the copy (#927). A same-provider duplicate
+   *  is not automatically lossless: Codex -> Codex drops opaque records. */
+  projectionFidelity: NativeProjectionFidelity
 }
 
 export async function duplicateSession(
@@ -64,7 +69,8 @@ export async function duplicateSession(
     now: new Date().toISOString(),
     ...(sourceProfile ? { targetProfile: sourceProfile } : {}),
   })
+  const projectionFidelity = summarizeProjectionReport(projection)
   const newProviderSessionId = adapter.sessionId(projection)
   const newFilePath = await adapter.write(targetCwd, projection)
-  return { provider: request.provider, newProviderSessionId, newFilePath }
+  return { provider: request.provider, newProviderSessionId, newFilePath, projectionFidelity }
 }
diff --git a/src/main/providerSwitch/projectionFidelity.system.test.ts b/src/main/providerSwitch/projectionFidelity.system.test.ts
new file mode 100644
index 000000000..d09c6246f
--- /dev/null
+++ b/src/main/providerSwitch/projectionFidelity.system.test.ts
@@ -0,0 +1,184 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  claudeNativeResumeProjector,
+  codexNativeResumeProjector,
+  estimateConversationCharacters,
+} from 'agent-transcript-parser'
+import type { ConversationDocument } from 'agent-transcript-parser'
+
+// #927: switch, duplicate and rewind must hand back what the REAL
+// native-resume projector reported. The #918 B06 exit gate says a mock
+// returning only `values` cannot establish this contract. So here the
+// projector is the parser's own, run over recorded Stage 0 sequences, and only
+// the disk edges (read, write, session id, target profile) are stubbed.
+
+const state = vi.hoisted(() => ({
+  conversation: null as ConversationDocument | null,
+  written: [] as unknown[],
+  failWrite: null as Error | null,
+}))
+
+vi.mock('node:crypto', () => ({ randomUUID: () => '00000000-0000-4000-8000-000000000927' }))
+
+vi.mock('@main/providerSwitch/transcriptEngine.js', () => ({
+  getHostTranscriptAdapter(provider: string) {
+    if (provider !== 'claude' && provider !== 'codex') throw new Error(`unexpected provider ${provider}`)
+    return {
+      provider,
+      read: async () => state.conversation,
+      targetProfile: async () => ({
+        model: provider === 'claude' ? 'claude-sonnet-5' : 'gpt-5',
+        modelProvider: 'openai',
+        // Derived from the fixture, never a real-world budget (the fixtures
+        // are value-redacted; see testing/fixtureConversations.ts).
+        budgetCharacters: estimateConversationCharacters(state.conversation!) * 10,
+      }),
+      projectNativeResume: async (conversation: ConversationDocument, context: { cwd: string; targetSessionId: string; now: string }) => (
+        provider === 'claude'
+          ? claudeNativeResumeProjector.projectNativeResume(conversation, { ...context, version: '2.1.0', model: 'claude-sonnet-5' })
+          : codexNativeResumeProjector.projectNativeResume(conversation, { ...context, cliVersion: '0.157.1', modelProvider: 'openai', model: 'gpt-5' })
+      ),
+      sessionId: () => 'new-session',
+      write: async (_cwd: string, publication: unknown) => {
+        state.written.push(publication)
+        if (state.failWrite) throw state.failWrite
+        return '/recorded/new-session.jsonl'
+      },
+      draft: (content: unknown) => ({ promptText: JSON.stringify(content).slice(0, 20), promptMode: 'prompt', promptImages: [], promptAttachments: [] }),
+    }
+  },
+}))
+
+import { materialProjectionLoss } from '@shared/types/projectionFidelity.js'
+import { duplicateSession } from './duplicateSession.js'
+import { summarizeProjectionReport } from './projectionFidelity.js'
+import { rewindSession } from './rewindSession.js'
+import { switchProvider } from './switchProvider.js'
+import { loadFixtureConversation } from './testing/fixtureConversations.js'
+
+beforeEach(() => {
+  state.written = []
+  state.failWrite = null
+})
+
+// The fidelity a caller receives must be the summary of the projection that
+// was actually WRITTEN, not of some other run.
+function writtenFidelity() {
+  expect(state.written).toHaveLength(1)
+  return summarizeProjectionReport(state.written[0] as Parameters<typeof summarizeProjectionReport>[0])
+}
+
+describe('projection fidelity through each real caller (#927)', () => {
+  // Recorded: claude-sequence-oversized -> Codex has no compaction, so the
+  // context reduction reports nothing (`shrinkSummary` null, strategy
+  // native), while the projector demotes 19 entries (encrypted reasoning,
+  // tool-result error status). Before #927 this switch toasted as lossless.
+  it('switch returns the real report even when context reduction reports nothing', async () => {
+    state.conversation = await loadFixtureConversation('claude-sequence-oversized', 'claude')
+    const result = await switchProvider({ sourceKind: 'claude', targetKind: 'codex', sourceProviderSessionId: 'source', cwd: '/recorded' })
+    expect(result.kind).toBe('switched')
+    if (result.kind !== 'switched') return
+    expect(result.strategy).toBe('native')
+    expect(result.shrinkSummary).toBeNull()
+    expect(result.projectionFidelity).toEqual(writtenFidelity())
+    expect(result.projectionFidelity.codes.map(row => row.code)).toEqual(expect.arrayContaining([
+      'native-resume.reasoning.encrypted-content-demoted',
+      'native-resume.tool-result.error-status-demoted',
+    ]))
+    expect(materialProjectionLoss(result.projectionFidelity)).toBe('history: 19 demoted')
+  })
+
+  // Recorded: codex-sequence-compacted-once -> Claude drops developer messages
+  // and foreign reasoning: material drops.
+  it('switch names material drops in its loss line', async () => {
+    state.conversation = await loadFixtureConversation('codex-sequence-compacted-once', 'codex')
+    const result = await switchProvider({ sourceKind: 'codex', targetKind: 'claude', sourceProviderSessionId: 'source', cwd: '/recorded' })
+    if (result.kind !== 'switched') throw new Error('expected a switch')
+    expect(result.projectionFidelity).toEqual(writtenFidelity())
+    expect(result.projectionFidelity.codes.map(row => row.code)).toEqual(expect.arrayContaining([
+      'native-resume.message.developer.dropped',
+      'native-resume.reasoning.foreign-dropped',
+    ]))
+    expect(materialProjectionLoss(result.projectionFidelity)).toMatch(/^history: \d+ dropped$/)
+  })
+
+  // A same-provider duplicate is not automatically lossless: Codex -> Codex
+  // drops the rollout's opaque records. That loss is reported, but it is not
+  // MATERIAL, so the toast stays quiet (UNCONFIRMED default).
+  it('duplicate returns the report of a same-provider copy', async () => {
+    state.conversation = await loadFixtureConversation('codex-sequence-compaction', 'codex')
+    const result = await duplicateSession({ provider: 'codex', sourceProviderSessionId: 'source', cwd: '/recorded' })
+    expect(result.projectionFidelity).toEqual(writtenFidelity())
+    expect(result.projectionFidelity.codes).toEqual(expect.arrayContaining([
+      expect.objectContaining({ kind: 'dropped', code: 'native-resume.opaque.dropped' }),
+    ]))
+    expect(materialProjectionLoss(result.projectionFidelity)).toBeNull()
+  })
+
+  it('rewind returns the report of the rewound copy', async () => {
+    const conversation = await loadFixtureConversation('codex-sequence-compacted-once', 'codex')
+    state.conversation = conversation
+    const prompts = conversation.entries.filter(entry => entry.kind === 'message' && entry.role === 'user')
+    const anchor = prompts[prompts.length - 1]!
+    const result = await rewindSession({
+      provider: 'codex',
+      sourceProviderSessionId: 'source',
+      cwd: '/recorded',
+      anchor: { provider: 'codex', line: anchor.source.line!, sessionId: conversation.sourceSessionIds[0]! },
+    })
+    expect(result.projectionFidelity).toEqual(writtenFidelity())
+    expect(result.projectionFidelity.counts.preserved).toBeGreaterThan(0)
+  })
+})
+
+// #1384 review a / steering q90: the narrowed contract. The summary is
+// returned only on success. A publication that rejects AFTER the projection
+// (possibly after linking the native file) rejects the whole operation with
+// the write's error and carries no summary; accounting for that ambiguous
+// outcome is #918 B07's receipt. Pinned so a later change cannot quietly
+// return a success-shaped result for a failed publication.
+describe('a rejected publication', () => {
+  it('rejects the operation with the write error and returns no summary', async () => {
+    state.conversation = await loadFixtureConversation('claude-sequence-oversized', 'claude')
+    const failing = new Error('publication failed after link')
+    state.failWrite = failing
+    await expect(switchProvider({ sourceKind: 'claude', targetKind: 'codex', sourceProviderSessionId: 'source', cwd: '/recorded' })).rejects.toBe(failing)
+    await expect(duplicateSession({ provider: 'codex', sourceProviderSessionId: 'source', cwd: '/recorded' })).rejects.toBe(failing)
+    // The write really received the projection: the effect may exist.
+    expect(state.written.length).toBe(2)
+  })
+})
+
+describe('summarizeProjectionReport on a real report', () => {
+  // Recorded: claude-sequence-oversized-turns -> Codex, 485 demoted encrypted
+  // reasoning blocks: enough changes of one code to exercise the line cap.
+  it('groups by code, caps listed lines with an exact omitted count, and carries no prose or evidence', async () => {
+    const conversation = await loadFixtureConversation('claude-sequence-oversized-turns', 'claude')
+    const projection = codexNativeResumeProjector.projectNativeResume(conversation, {
+      cwd: '/recorded', targetSessionId: '00000000-0000-4000-8000-000000000927', now: '2026-09-27T00:00:00.000Z',
+      cliVersion: '0.157.1', modelProvider: 'openai', model: 'gpt-5',
+    })
+    const fidelity = summarizeProjectionReport(projection)
+    expect(fidelity.codes.reduce((sum, row) => sum + row.count, 0)).toBe(projection.report.changes.length)
+    expect(fidelity.counts).toEqual(projection.report.counts)
+    for (const row of fidelity.codes) expect(row.sourceLines.length).toBeLessThanOrEqual(20)
+    const listed = fidelity.codes.reduce((sum, row) => sum + row.sourceLines.length, 0)
+    const withLines = projection.report.changes.filter(change => change.sourceLine !== null).length
+    expect(listed + fidelity.sourceLinesOmitted).toBe(withLines)
+    expect(fidelity.sourceLinesOmitted).toBeGreaterThan(0)
+    expect(JSON.stringify(fidelity)).not.toMatch(/"message"|"evidence"/)
+    // #1384 review a/b: the evidence itself, not only its shape. Each row's
+    // lines are the real source addresses of that (kind, code), in order; the
+    // profile is the projector's own; `counts` is a copy, not the report's
+    // object (a later reuse of the report must not rewrite a summary).
+    for (const row of fidelity.codes) {
+      const lines = projection.report.changes
+        .filter(change => change.kind === row.kind && change.code === row.code && change.sourceLine !== null)
+        .map(change => change.sourceLine)
+      expect(row.sourceLines).toEqual(lines.slice(0, 20))
+    }
+    expect(fidelity.providerProfileId).toBe(projection.providerProfile.id)
+    expect(fidelity.counts).not.toBe(projection.report.counts)
+    expect(materialProjectionLoss(fidelity)).toMatch(/demoted/)
+  })
+})
diff --git a/src/main/providerSwitch/projectionFidelity.ts b/src/main/providerSwitch/projectionFidelity.ts
new file mode 100644
index 000000000..934e4232e
--- /dev/null
+++ b/src/main/providerSwitch/projectionFidelity.ts
@@ -0,0 +1,56 @@
+import type { NativeResumeProjectionResult } from 'agent-transcript-parser'
+
+import {
+  PROJECTION_FIDELITY_MAX_LINES,
+  type NativeProjectionFidelity,
+  type ProjectionFidelityCode,
+} from '@shared/types/projectionFidelity.js'
+
+/**
+ * The bounded, curated summary of a real native-resume projection (#927).
+ *
+ * Called right after `projectNativeResume` and before `write`. It is returned
+ * only on SUCCESS: if the write or publication rejects, the operation
+ * rejects with that error and the summary is not carried (Electron's IPC
+ * keeps only an error's message). A rejected publication can still have
+ * linked the native file (see `publishNativeTranscript`), so that outcome is
+ * ambiguous, and accounting for it is #918 B07's receipt, not this summary.
+ * (#1384 review a showed the first version of this comment claimed more.)
+ * Pure: it
+ * reads the report and copies what it keeps, so a later reuse of the
+ * projector's objects cannot change a summary already handed out (#918 §6.2).
+ * See `@shared/types/projectionFidelity` for why messages and evidence are
+ * left out.
+ */
+export function summarizeProjectionReport(projection: NativeResumeProjectionResult): NativeProjectionFidelity {
+  const { report, providerProfile } = projection
+  const rows = new Map<string, ProjectionFidelityCode>()
+  let sourceLinesOmitted = 0
+  for (const change of report.changes) {
+    const key = `${change.kind}\u0000${change.code}`
+    let row = rows.get(key)
+    if (!row) {
+      row = { kind: change.kind, code: change.code, count: 0, sourceLines: [] }
+      rows.set(key, row)
+    }
+    row.count += 1
+    if (change.sourceLine === null) continue
+    if (row.sourceLines.length < PROJECTION_FIDELITY_MAX_LINES) row.sourceLines.push(change.sourceLine)
+    else sourceLinesOmitted += 1
+  }
+  const evidence = providerProfile.evidence
+  return {
+    profile: 'native-resume',
+    sourceProvider: report.sourceProvider,
+    targetProvider: report.targetProvider,
+    providerProfileId: providerProfile.id,
+    providerEvidence: {
+      ...(evidence.sourceCommit ? { sourceCommit: evidence.sourceCommit } : {}),
+      ...(evidence.cliVersion ? { cliVersion: evidence.cliVersion } : {}),
+      ...(evidence.observedAt ? { observedAt: evidence.observedAt } : {}),
+    },
+    counts: { ...report.counts },
+    codes: [...rows.values()],
+    sourceLinesOmitted,
+  }
+}
diff --git a/src/main/providerSwitch/rewindSession.test.ts b/src/main/providerSwitch/rewindSession.test.ts
index 1369357ce..f0b1d7807 100644
--- a/src/main/providerSwitch/rewindSession.test.ts
+++ b/src/main/providerSwitch/rewindSession.test.ts
@@ -30,6 +30,7 @@ vi.mock('@main/providerSwitch/transcriptEngine.js', () => ({
 
 import { listRewindPrompts, rewindSession } from './rewindSession.js'
 import { projectGrokNativeResume } from 'agent-transcript-parser'
+import { losslessProjection } from './testing/losslessProjection.js'
 
 const sourceConversation = {
   schemaVersion: 1 as const,
@@ -70,7 +71,7 @@ describe('rewindSession neutral integration', () => {
       promptImages: [],
       promptAttachments: [],
     })
-    mocks.project.mockResolvedValue({ values: [{ type: 'session_meta' }] })
+    mocks.project.mockResolvedValue(losslessProjection([{ type: 'session_meta' }]))
     mocks.sessionId.mockReturnValue('new-session')
     mocks.write.mockResolvedValue('/target/rollout.jsonl')
   })
diff --git a/src/main/providerSwitch/rewindSession.ts b/src/main/providerSwitch/rewindSession.ts
index be70c07ed..aa8ac5999 100644
--- a/src/main/providerSwitch/rewindSession.ts
+++ b/src/main/providerSwitch/rewindSession.ts
@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto'
 
 import type { RewindAttachment } from '@main/providerSwitch/rewindAttachments.js'
 import type { AgentProviderKind } from '@shared/types/providerKind.js'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity.js'
 import type {
   ListRewindPromptsRequest,
   RewindPrompt,
@@ -10,6 +11,7 @@ import type {
 import { rewindConversation } from 'agent-transcript-parser'
 
 import { getHostTranscriptAdapter } from '@main/providerSwitch/transcriptEngine.js'
+import { summarizeProjectionReport } from '@main/providerSwitch/projectionFidelity.js'
 
 export type RewindSessionRequest = {
   provider: AgentProviderKind
@@ -49,6 +51,8 @@ export type RewindSessionResult = {
   /** Every attachment the rewound prompt had, bytes excluded — see above. */
   promptAttachments: RewindSessionAttachment[]
   promptTimestamp: string | null
+  /** What the projector did to the rewound copy (#927). */
+  projectionFidelity: NativeProjectionFidelity
 }
 
 /**
@@ -126,6 +130,7 @@ export async function rewindSession(
     now: new Date().toISOString(),
     ...(sourceProfile ? { targetProfile: sourceProfile } : {}),
   })
+  const projectionFidelity = summarizeProjectionReport(projection)
   const newProviderSessionId = adapter.sessionId(projection)
   const draft = adapter.draft(rewind.draft)
 
@@ -152,5 +157,6 @@ export async function rewindSession(
         entry.source.line === rewind.anchor.line
       ))?.timestamp ?? null
       : null,
+    projectionFidelity,
   }
 }
diff --git a/src/main/providerSwitch/switchProvider.test.ts b/src/main/providerSwitch/switchProvider.test.ts
index 697c8bd1e..9fbd9c7ae 100644
--- a/src/main/providerSwitch/switchProvider.test.ts
+++ b/src/main/providerSwitch/switchProvider.test.ts
@@ -47,6 +47,7 @@ vi.mock('@main/providerSwitch/transcriptEngine.js', () => ({
 import { describeShrink, switchProvider } from './switchProvider.js'
 import type { ShrinkReport } from 'agent-transcript-parser'
 import { loadFixtureConversation } from './testing/fixtureConversations.js'
+import { summarizeProjectionReport } from './projectionFidelity.js'
 
 const conversation = {
   schemaVersion: 1 as const,
@@ -141,6 +142,7 @@ describe('switchProvider neutral hub integration', () => {
       truncatedBeforeSwitch: false,
       strategy: 'native',
       shrinkSummary: null,
+      projectionFidelity: summarizeProjectionReport(projection),
     })
   })
 
diff --git a/src/main/providerSwitch/switchProvider.ts b/src/main/providerSwitch/switchProvider.ts
index b79dc3e8b..545544a15 100644
--- a/src/main/providerSwitch/switchProvider.ts
+++ b/src/main/providerSwitch/switchProvider.ts
@@ -3,6 +3,7 @@
 import { randomUUID } from 'node:crypto'
 
 import type { AgentProviderKind } from '@shared/types/providerKind.js'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity.js'
 import {
   compactionAvailability,
   conversationAfterLatestPortableCompaction,
@@ -16,6 +17,7 @@ import type {
 } from 'agent-transcript-parser'
 
 import { getHostTranscriptAdapter } from '@main/providerSwitch/transcriptEngine.js'
+import { summarizeProjectionReport } from '@main/providerSwitch/projectionFidelity.js'
 
 export type SwitchProviderRequest = {
   sourceKind: AgentProviderKind
@@ -108,6 +110,10 @@ export type SwitchProviderResult =
        * the host is the only layer that can put the loss in front of a user.
        */
       shrinkSummary: string | null
+      /** What the native-resume projector preserved, dropped, demoted,
+       *  repaired or synthesized (#927). Independent of `shrinkSummary`: a
+       *  switch that needed no shrinking can still be a lossy projection. */
+      projectionFidelity: NativeProjectionFidelity
     }
   | {
       kind: 'source-empty'
@@ -364,6 +370,10 @@ export async function switchProvider(
     now: new Date().toISOString(),
     targetProfile,
   })
+  // Summarized before the write, from the projection that is written. It is
+  // returned only on success; a rejected publication is an ambiguous outcome
+  // for #918 B07's receipts (see summarizeProjectionReport).
+  const projectionFidelity = summarizeProjectionReport(projection)
   const targetProviderSessionId = target.sessionId(projection)
   const targetFilePath = await target.write(targetCwd, projection)
 
@@ -376,6 +386,7 @@ export async function switchProvider(
     truncatedBeforeSwitch,
     strategy,
     shrinkSummary,
+    projectionFidelity,
   }
 }
 
diff --git a/src/main/providerSwitch/testing/losslessProjection.ts b/src/main/providerSwitch/testing/losslessProjection.ts
new file mode 100644
index 000000000..62bc33e0a
--- /dev/null
+++ b/src/main/providerSwitch/testing/losslessProjection.ts
@@ -0,0 +1,27 @@
+import type { NativeResumeProjectionResult } from 'agent-transcript-parser'
+
+// A native-resume projection with an EMPTY report, for host tests whose
+// subject is not fidelity (identity, cwd, profile, write order).
+//
+// WHY a helper and not `{ values }`: since #927 every operation summarizes
+// `projection.report`, and a projection without one is a shape no real
+// projector returns. Tests that DO assert fidelity must not use this: they run
+// the real projector over a recorded sequence (projectionFidelity.system.test).
+export function losslessProjection(
+  values: Record<string, unknown>[],
+  provider = 'codex',
+): NativeResumeProjectionResult {
+  return {
+    profile: 'native-resume',
+    targetProvider: provider,
+    providerProfile: { id: 'test', provider, evidence: {} },
+    values,
+    report: {
+      profile: 'native-resume',
+      sourceProvider: provider,
+      targetProvider: provider,
+      changes: [],
+      counts: { preserved: 0, dropped: 0, demoted: 0, synthesized: 0, repaired: 0, retargeted: 0, opaque: 0 },
+    },
+  }
+}
diff --git a/src/main/sessionManager.pendingPrompt.test.ts b/src/main/sessionManager.pendingPrompt.test.ts
index a5858a2ca..ba9f0ae08 100644
--- a/src/main/sessionManager.pendingPrompt.test.ts
+++ b/src/main/sessionManager.pendingPrompt.test.ts
@@ -129,6 +129,27 @@ describe('a bootstrap prompt waits for a child that is not ready YET (#854)', ()
     expect(session.asked()).toBe(answers.length + 1)
   })
 
+  // Review of #1375, round 2 (a, b): a late create bootstrap's waiter can fire long after its
+  // parent closed; its guard is asked the moment the gate opens, and nothing is written if it says no.
+  it('writes nothing when its shouldDeliver guard refuses at the moment the gate opens', async () => {
+    const session = scriptedSession([warming(), { kind: 'ready', waitedMs: 1 } as GateAnswer])
+    const manager = managerWith(session)
+    let parentAttached = true
+    const pending = manager.deliverPromptWhenReady('child', 'the brief', undefined, { shouldDeliver: () => parentAttached })
+    parentAttached = false
+    const result = await pending
+    expect(result).toMatchObject({ ok: false, stage: 'before-write', disposition: 'do-not-retry', promptWritten: false })
+    expect(session.write).not.toHaveBeenCalled()
+  })
+
+  it('delivers as before when its guard allows it', async () => {
+    const session = scriptedSession([{ kind: 'ready', waitedMs: 1 } as GateAnswer])
+    const manager = managerWith(session)
+    const result = await manager.deliverPromptWhenReady('child', 'the brief', undefined, { shouldDeliver: () => true })
+    expect(result.ok).toBe(true)
+    expect(session.write.mock.calls.map(([data]) => data)).toEqual(['the brief', '\r'])
+  })
+
   it('gives up when the session cannot accept prompts at all', async () => {
     // The control that keeps "wait for it" from meaning "wait forever". A
     // terminal verdict is the provider saying there is nothing to wait for.
diff --git a/src/main/sessionManager.ts b/src/main/sessionManager.ts
index cc7eca2c4..7e24d19cb 100644
--- a/src/main/sessionManager.ts
+++ b/src/main/sessionManager.ts
@@ -4772,6 +4772,15 @@ export class SessionManager extends EventEmitter {
        * refusal there would be a genuine double-arm worth surfacing.
        */
       supersedesPendingPrompt?: boolean
+      /**
+       * Asked the moment the gate answers `ready`, before anything is written:
+       * false refuses the delivery with nothing written. The late create
+       * bootstrap passes its parent-lease check (review of #1375, round 2 a
+       * and b): a waiter armed while the parent was attached must not start
+       * the brief in a child whose parent has since closed, and closing a
+       * parent does not cancel its children's waiters.
+       */
+      shouldDeliver?: () => boolean
     },
   ): Promise<PromptDeliveryResult> {
     if (options?.supersedesPendingPrompt) {
@@ -4893,6 +4902,14 @@ export class SessionManager extends EventEmitter {
           if (this.pendingPromptDeliveries.get(sessionId) === pending) {
             this.pendingPromptDeliveries.delete(sessionId)
           }
+          if (options?.shouldDeliver && !options.shouldDeliver()) {
+            return {
+              ok: false, stage: 'before-write', code: 'not-ready', retrySafe: true,
+              disposition: 'do-not-retry',
+              promptWritten: false, enterWritten: false,
+              message: 'The prompt was not delivered: whoever asked for it is gone.',
+            }
+          }
           return await this.deliverPromptToAgent(sessionId, prompt, undefined, record)
         }
         // `timeout` is OUR re-arm expiring, not the session's verdict — a
diff --git a/src/main/setup/cliUpdateOrchestrator.couldNotStart.test.ts b/src/main/setup/cliUpdateOrchestrator.couldNotStart.test.ts
new file mode 100644
index 000000000..18fe5d47c
--- /dev/null
+++ b/src/main/setup/cliUpdateOrchestrator.couldNotStart.test.ts
@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// #1425 (found by #1423's review b): runUpdate published `updating`, then
+// awaited openLog's mkdir outside any catch. A read-only or full state dir
+// rejected there and the snapshot stayed `updating` — an undismissable
+// "Updating…" row forever, and a dropped IPC rejection for Update Now.
+//
+// The fs boundary is where the failure really happens, so that is the one
+// thing replaced: mkdir of the log folder rejects the way macOS does for a
+// folder the user cannot write (EACCES). The update command runner is a spy
+// that must never be reached — an update without a log is not attempted.
+const fsState = vi.hoisted(() => ({ mkdirError: null as NodeJS.ErrnoException | null, writeError: null as NodeJS.ErrnoException | null }))
+vi.mock('fs/promises', async importOriginal => {
+  const actual = await importOriginal<typeof import('fs/promises')>()
+  return {
+    ...actual,
+    mkdir: async (...args: Parameters<typeof actual.mkdir>) => {
+      if (fsState.mkdirError) throw fsState.mkdirError
+      return actual.mkdir(...args)
+    },
+    writeFile: async (...args: Parameters<typeof actual.writeFile>) => {
+      if (fsState.writeError) throw fsState.writeError
+      return actual.writeFile(...args)
+    },
+  }
+})
+const runShellCommand = vi.hoisted(() => vi.fn(async () => ({ stdout: '', stderr: '' })))
+vi.mock('@main/setup/shell.js', () => ({ runShellCommand }))
+vi.mock('@main/setup/toolchain.js', () => ({ getToolPath: (cli: string) => `/usr/local/bin/${cli}` }))
+vi.mock('@main/setup/cliVersion.js', async importOriginal => ({
+  ...(await importOriginal<typeof import('@main/setup/cliVersion.js')>()),
+  readInstalledVersion: async () => ({ ok: true, version: '2.1.281' }),
+}))
+vi.mock('@main/setup/setupState.js', () => ({
+  loadSetupState: async () => ({ cliUpdateCache: { claude: { latestVersion: '2.1.282' }, codex: { latestVersion: '2.1.282' } } }),
+  updateCliUpdateCache: async () => undefined,
+}))
+vi.mock('@main/setup/cliInstallMethod.js', () => ({ detectCliInstallMethod: async () => 'npm' }))
+
+import { CliUpdateOrchestrator } from './cliUpdateOrchestrator.js'
+
+describe('an update that cannot start (#1425)', () => {
+  it('fails as could-not-start with no log, instead of staying Updating', async () => {
+    fsState.mkdirError = Object.assign(new Error("EACCES: permission denied, mkdir '/state/cli-update-logs'"), { code: 'EACCES' })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const orchestrator = new CliUpdateOrchestrator({ list: () => [], getSessionKind: () => 'claude' } as never, { acquireUpdateLease: () => () => undefined })
+      const kinds: string[] = []
+      orchestrator.on('state', snapshot => { kinds.push(snapshot.claude.kind) })
+
+      const snapshot = await orchestrator.updateOnce('claude')
+
+      expect(snapshot.claude).toMatchObject({
+        kind: 'failed', reason: 'could-not-start', logPath: null, from: '2.1.281', wantedLatest: '2.1.282', installMethod: 'npm',
+      })
+      // It did announce the attempt, and it did not stop there.
+      expect(kinds).toEqual(['updating', 'failed'])
+      expect(runShellCommand).not.toHaveBeenCalled()
+      // The OS text stays in main's log (q22), never in the state.
+      expect(JSON.stringify(snapshot.claude)).not.toContain('EACCES')
+      expect(warn).toHaveBeenCalled()
+    } finally {
+      fsState.mkdirError = null
+      warn.mockRestore()
+    }
+  })
+})
+
+// #1447 review a: the folder was the only thing checked. A folder that already
+// exists but will not take a new file (EACCES on the folder, ENOSPC) let the
+// update run with no log, and View Log then pointed at a file that never was.
+describe('an update whose log file cannot be created (#1447 review a)', () => {
+  it('fails as could-not-start and never runs the command', async () => {
+    fsState.writeError = Object.assign(new Error("ENOSPC: no space left on device, open '/state/cli-update-logs/claude-x.log'"), { code: 'ENOSPC' })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    runShellCommand.mockClear()
+    try {
+      const orchestrator = new CliUpdateOrchestrator({ list: () => [], getSessionKind: () => 'claude' } as never, { acquireUpdateLease: () => () => undefined })
+      const snapshot = await orchestrator.updateOnce('claude')
+      expect(snapshot.claude).toMatchObject({ kind: 'failed', reason: 'could-not-start', logPath: null })
+      expect(runShellCommand).not.toHaveBeenCalled()
+    } finally {
+      fsState.writeError = null
+      warn.mockRestore()
+    }
+  })
+})
+
+// #1447 review a: publishing a state is synchronous (emit -> the IPC broadcast
+// -> webContents.send). A listener that throws on `updating` (a window torn
+// down mid-send) aborted runUpdate before any later state, leaving the
+// snapshot `updating` for good. Publication failures must not steer the
+// update's own state machine.
+describe('a state listener that throws (#1447 review a)', () => {
+  it('does not strand updating', async () => {
+    fsState.mkdirError = Object.assign(new Error('EACCES'), { code: 'EACCES' })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    try {
+      const orchestrator = new CliUpdateOrchestrator({ list: () => [], getSessionKind: () => 'claude' } as never, { acquireUpdateLease: () => () => undefined })
+      orchestrator.on('state', snapshot => { if (snapshot.claude.kind === 'updating') throw new Error('Object has been destroyed') })
+      const snapshot = await orchestrator.updateOnce('claude')
+      expect(snapshot.claude.kind).toBe('failed')
+      expect(orchestrator.getSnapshot().claude.kind).not.toBe('updating')
+    } finally {
+      fsState.mkdirError = null
+      warn.mockRestore()
+    }
+  })
+})
diff --git a/src/main/setup/cliUpdateOrchestrator.ts b/src/main/setup/cliUpdateOrchestrator.ts
index 09c161fca..988cabea9 100644
--- a/src/main/setup/cliUpdateOrchestrator.ts
+++ b/src/main/setup/cliUpdateOrchestrator.ts
@@ -432,7 +432,32 @@ export class CliUpdateOrchestrator extends EventEmitter {
       startedAt: Date.now(),
     })
 
-    const logPath = await this.openLog(cli)
+    // #1425: `updating` is already published, and it is undismissable in the
+    // banner — so a failure here must END in another state, never leave this
+    // one standing. openLog's mkdir is the one await in this method that can
+    // throw (every later step catches or returns a result; see appendLog,
+    // appendDiagnostics, readInstalledVersion). A folder we cannot create
+    // (EACCES on the data folder, ENOSPC) means we do not run the update at
+    // all: a package install into a full or unwritable disk is likely to
+    // fail too, and a failure with no log would leave the user nothing to
+    // look at. The OS text stays here; the state carries a fixed reason.
+    let logPath: string
+    try {
+      logPath = await this.openLog(cli)
+    } catch (err) {
+      console.warn('[cli-update] could not create the update log; the update was not started:', err)
+      this.updateSnapshot(cli, {
+        kind: 'failed',
+        cli,
+        from: ctx.from,
+        wantedLatest: ctx.to,
+        installMethod: ctx.installMethod,
+        reason: 'could-not-start',
+        logPath: null,
+        finishedAt: Date.now(),
+      })
+      return
+    }
     const command = updateCommandFor(cli, ctx.installMethod)
     let commandFailed = false
     let timedOut = false
@@ -556,7 +581,19 @@ export class CliUpdateOrchestrator extends EventEmitter {
 
   private updateSnapshot(cli: CliUpdateKind, state: CliUpdateState): void {
     this.snapshot = { ...this.snapshot, [cli]: state }
-    this.emit('state', this.snapshot)
+    // WHY publication is contained (#1447 review a): emit is synchronous and
+    // its listener broadcasts to every window through webContents.send, which
+    // throws for a window torn down mid-send. That exception used to escape
+    // into runUpdate right after `updating` was published and abort it before
+    // any later state — leaving the snapshot (the source of truth, already
+    // committed above) and the other windows on an undismissable "Updating…".
+    // The state machine decides the state; a failed publication is logged and
+    // the next publication (or the renderer's snapshot fetch) catches up.
+    try {
+      this.emit('state', this.snapshot)
+    } catch (error) {
+      console.warn('[cli-update] publishing the update state failed:', error)
+    }
   }
 
   private async openLog(cli: CliUpdateKind): Promise<string> {
@@ -565,7 +602,16 @@ export class CliUpdateOrchestrator extends EventEmitter {
     // file per attempt so a re-run doesn't overwrite the last failure's
     // log while a user is trying to inspect it.
     const stamp = new Date().toISOString().replace(/[:.]/g, '-')
-    return join(CLI_UPDATE_LOG_DIR, `${cli}-${stamp}.log`)
+    const logPath = join(CLI_UPDATE_LOG_DIR, `${cli}-${stamp}.log`)
+    // WHY the file is CREATED here, not just named (#1447 review a): a folder
+    // that already exists but will not take a new file (EACCES on it, ENOSPC)
+    // passed mkdir, the update ran, every appendLog was swallowed, and View
+    // Log pointed at a file that was never written. Creating it up front is
+    // the real "can we keep a log" check; it throws into runUpdate's
+    // could-not-start path before the command runs. `wx` never truncates an
+    // earlier attempt's log that happens to share the name.
+    await writeFile(logPath, `[Agent Code] ${cli} update log, ${new Date().toISOString()}\n`, { flag: 'wx' })
+    return logPath
   }
 }
 
diff --git a/src/mcp/runtime/createBuiltInMcpServer.ts b/src/mcp/runtime/createBuiltInMcpServer.ts
index 69cab25a9..aadcd5602 100644
--- a/src/mcp/runtime/createBuiltInMcpServer.ts
+++ b/src/mcp/runtime/createBuiltInMcpServer.ts
@@ -1023,25 +1023,19 @@ function orchestrationCreateAgentCallKey(
       return await bridge.createAgentCallOnce(
         orchestrationCreateAgentCallKey(scope.sessionId, args),
         async () => {
-        const agent = await bridge.createAgent({
-          parentSessionId: scope.sessionId,
-          kind: args.kind as OrchestrationAgentKind,
-          ...(args.providerRuntime ? { providerRuntime: args.providerRuntime } : {}),
-          cwd: args.cwd,
-          title: args.title,
-          role: args.role,
-          runId: args.runId,
-          // WHY force clean children even if an older tool caller passes true:
-          // the inheritance implementation is intentionally disabled in this PR.
-          // Keeping the schema field avoids breaking stale provider tool caches,
-          // but honoring it would re-enable the broken clone/translate path.
-          inheritParentContext: false,
-          builtInMcpDomains: args.builtInMcpDomains as BuiltInMcpDomain[] | undefined,
-        })
-
-        if (args.prompt && args.prompt.trim().length > 0) {
+        // The bootstrap delivery, shared by a punctual create and a late-adopted one (#1370): a create
+        // that outlived the 30 s bridge deadline is adopted when the renderer finally answers, and
+        // gets exactly this delivery then, through `onLateCreate`. For the late path the returned
+        // tool result has no reader; every failure branch below also records an incident, which is
+        // where a late outcome is seen.
+        // `late`: the child arrived after the deadline, and nobody reads this reply (review of
+        // #1375, a). A child that is simply not ready yet, on a provider with no readiness gate to
+        // arm a waiter on (OpenCode, Grok, #854), then answers LATE_NOT_READY instead of a failure
+        // reply: the punctual path's parent can see that failure and retry, the late path's cannot,
+        // so `deliverLateBootstrap` retries it instead.
+        const deliverBootstrap = async (agent: OrchestrationAgentRecord, task: string, late: boolean) => {
           const prompt = buildOrchestrationBootstrapPrompt({
-            task: args.prompt,
+            task,
           })
           const delivery = await manager.deliverPromptToAgent(agent.sessionId, prompt)
           // A child that is not ready YET is not a failed child (#854).
@@ -1082,6 +1076,9 @@ function orchestrationCreateAgentCallKey(
             // Nothing can be waiting yet for a child that did not exist a
             // moment ago, and a refusal here would be a real double-arm.
             supersedesPendingPrompt: false,
+            // Late only: the waiter can fire long after this call, so it re-checks the parent at
+            // the moment of delivery (review of #1375, round 2 a and b).
+            ...(late ? { shouldDeliver: () => bridge.isParentAttached(scope.sessionId) } : {}),
           })) {
             return toolText({
               ok: true,
@@ -1094,6 +1091,12 @@ function orchestrationCreateAgentCallKey(
               message: `The child was created and its prompt is waiting for its composer (${delivery.message}). It will be delivered as soon as the child can accept it — do not send it again; use orchestration_read_agent to see when it lands.`,
             })
           }
+          if (late && !delivery.ok && isNotReadyYet(delivery)) return LATE_NOT_READY
+          // A collision with another delivery to this child (typically the parent's own
+          // send_prompt holding the reservation) is transient too: the late loop re-checks the
+          // landed count and the parent before trying again, instead of giving up on a
+          // collision whose other side may itself fail (review of #1375, round 2 c).
+          if (late && !delivery.ok && delivery.stage === 'reservation' && delivery.code === 'delivery-in-flight') return LATE_NOT_READY
           if (!delivery.ok) {
             let cleanupAttempted = false
             let agentClosed = false
@@ -1177,17 +1180,93 @@ function orchestrationCreateAgentCallKey(
               promptSubmitted: true,
             })
           } catch (err) {
+            const warning = err instanceof Error && err.message.length > 0
+              ? err.message
+              : 'Could not persist orchestration bootstrap delivery state.'
+            // WHY an incident only on the late path (q85): a punctual create
+            // returns this warning to its caller, who reads it. A late create's
+            // result goes to `onLateCreate`, whose caller already got "outcome
+            // unknown" and has left; nothing reads its return value, and
+            // `adoptLateResponse` only journals a REJECTED continuation, so the
+            // warning vanished while the child could later be reported as
+            // never bootstrapped. The journal is the late path's only reader.
+            if (late) {
+              dependencies.appRunJournal?.recordIncident({
+                kind: 'orchestration.bootstrap_mark_failed',
+                severity: 'warn',
+                reason: 'create_agent_late_bootstrap',
+                context: { sessionId: agent.sessionId, parentSessionId: scope.sessionId, message: warning },
+              })
+            }
             return toolText({
               ok: true,
               agent,
               promptSubmitted: true,
               bootstrapPromptDelivered: true,
-              bootstrapPromptPersistenceWarning: err instanceof Error && err.message.length > 0
-                ? err.message
-                : 'Could not persist orchestration bootstrap delivery state.',
+              bootstrapPromptPersistenceWarning: warning,
             })
           }
         }
+        // The late child's bootstrap (#1370), retried while the child is merely not ready yet
+        // (review of #1375, a): its parent was told delivery is automatic, so a single refused
+        // attempt must not leave it idle. Bounded (about a minute in all), and it stops as soon as
+        // any prompt has landed on the child, so a parent that sent the brief itself after
+        // checking orchestration_read_agent never gets a second copy.
+        const deliverLateBootstrap = async (late: OrchestrationAgentRecord, task: string): Promise<void> => {
+          for (let attempt = 0; ; attempt += 1) {
+            if (bridge.promptSubmissionCount(late.sessionId) > 0) return
+            // Before every attempt, not only at adoption: a parent that closed during the
+            // retry delay must not have its brief start an ownerless child (review of #1375, b).
+            if (!bridge.isParentAttached(scope.sessionId)) {
+              dependencies.appRunJournal?.recordIncident({
+                kind: 'orchestration.prompt_delivery_failed',
+                severity: 'warn',
+                reason: 'create_agent_late_bootstrap_parent_gone',
+                context: { sessionId: late.sessionId, parentSessionId: scope.sessionId, attempts: attempt },
+              })
+              return
+            }
+            const reply = await deliverBootstrap(late, task, true)
+            if (reply !== LATE_NOT_READY) return
+            const delay = LATE_BOOTSTRAP_RETRY_DELAYS_MS[attempt]
+            if (delay === undefined) {
+              dependencies.appRunJournal?.recordIncident({
+                kind: 'orchestration.prompt_delivery_failed',
+                severity: 'error',
+                reason: 'create_agent_late_bootstrap_never_ready',
+                context: { sessionId: late.sessionId, attempts: attempt + 1 },
+              })
+              return
+            }
+            await new Promise(resolveDelay => setTimeout(resolveDelay, delay))
+          }
+        }
+        const agent = await bridge.createAgent({
+          parentSessionId: scope.sessionId,
+          kind: args.kind as OrchestrationAgentKind,
+          ...(args.providerRuntime ? { providerRuntime: args.providerRuntime } : {}),
+          cwd: args.cwd,
+          title: args.title,
+          role: args.role,
+          runId: args.runId,
+          // WHY force clean children even if an older tool caller passes true:
+          // the inheritance implementation is intentionally disabled in this PR.
+          // Keeping the schema field avoids breaking stale provider tool caches,
+          // but honoring it would re-enable the broken clone/translate path.
+          inheritParentContext: false,
+          builtInMcpDomains: args.builtInMcpDomains as BuiltInMcpDomain[] | undefined,
+          ...(args.prompt && args.prompt.trim().length > 0
+            ? { onLateCreate: (late: OrchestrationAgentRecord) => deliverLateBootstrap(late, args.prompt!) }
+            : {}),
+        })
+
+        const task = args.prompt && args.prompt.trim().length > 0 ? args.prompt : undefined
+        if (task) {
+          const reply = await deliverBootstrap(agent, task, false)
+          // Only the late path can see LATE_NOT_READY.
+          if (reply === LATE_NOT_READY) throw new Error('unreachable: a punctual create never answers LATE_NOT_READY')
+          return reply
+        }
 
         return toolText({
           ok: true,
@@ -1870,6 +1949,11 @@ const EXPIRED = Symbol('wait-agents-expired')
  * for it — and a future provider that writes before it decides it is not ready
  * would otherwise inherit that silently.
  */
+/** See `deliverBootstrap`'s `late` parameter. */
+const LATE_NOT_READY = Symbol('late-bootstrap-not-ready')
+/** Waits between late bootstrap attempts: about a minute in all (review of #1375, a). */
+const LATE_BOOTSTRAP_RETRY_DELAYS_MS = [2_000, 4_000, 8_000, 16_000, 30_000]
+
 function isNotReadyYet(delivery: Extract<PromptDeliveryResult, { ok: false }>): boolean {
   if (delivery.promptWritten || delivery.enterWritten) return false
   // The stage check is also what keeps the RESERVATION refusal out (#1134
@@ -1925,6 +2009,8 @@ function armPromptWhenReady(input: {
   incidentReason: 'create_agent_bootstrap_pending' | 'send_prompt_pending'
   /** See `SessionManager.deliverPromptWhenReady`'s option of the same name. */
   supersedesPendingPrompt: boolean
+  /** See `SessionManager.deliverPromptWhenReady`'s option of the same name. */
+  shouldDeliver?: () => boolean
 }): { supersededPendingPrompt: boolean } | null {
   const { dependencies, bridge, manager, delivery, sessionId } = input
   if (
@@ -1941,7 +2027,12 @@ function armPromptWhenReady(input: {
     sessionId,
     input.prompt,
     event => { if (event === 'pending-superseded') supersededPendingPrompt = true },
-    input.supersedesPendingPrompt ? { supersedesPendingPrompt: true } : undefined,
+    input.supersedesPendingPrompt || input.shouldDeliver
+      ? {
+        ...(input.supersedesPendingPrompt ? { supersedesPendingPrompt: true } : {}),
+        ...(input.shouldDeliver ? { shouldDeliver: input.shouldDeliver } : {}),
+      }
+      : undefined,
   )
   // Visible to `list_agents` / `wait_agents` as `prompt_sent` until it
   // settles (#1134 review) — see `PromptDeliveryMetadata.pendingPrompt`.
diff --git a/src/mcp/runtime/orchestrationLateBootstrap.system.test.ts b/src/mcp/runtime/orchestrationLateBootstrap.system.test.ts
new file mode 100644
index 000000000..bf6eafdfe
--- /dev/null
+++ b/src/mcp/runtime/orchestrationLateBootstrap.system.test.ts
@@ -0,0 +1,418 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// ---------------------------------------------------------------------------
+// #1370. A healthy provider can take longer than the bridge's 30 s create deadline to start (the
+// bundled OpenCode took 43.1 s under CPU contention, #1367 review a). The caller got "outcome
+// unknown — do not repeat", the tool handler returned without delivering the prompt, and when the
+// renderer finally answered, the child was adopted idle: no brief, and nothing told the parent.
+//
+// This drives the REAL MCP server, tool handler and OrchestrationBridge over an in-memory
+// transport. The true edges are faked: `sendToWindow` (the renderer, which here answers the create
+// only when the test says so) and the session manager (no provider process).
+// ---------------------------------------------------------------------------
+
+const renderer = {
+  requests: [] as Array<Record<string, unknown>>,
+  heldCreate: null as null | Record<string, unknown>,
+  // Whether a window still owns the parent (the lease the bridge checks).
+  parentAttached: true,
+  // A replaced pane's id has no window any more (its lease went with it).
+  retired: new Set<string>(),
+  // The renderer refuses to persist the bootstrap mark.
+  failMark: false,
+}
+
+vi.mock('@main/window/windowRegistry.js', () => ({
+  windowForSession: (sessionId: string) =>
+    renderer.retired.has(sessionId) || (!renderer.parentAttached && sessionId === 'parent-1') ? null : 'test-window',
+  sendToWindow: (_windowId: string, _channel: string, request: Record<string, unknown>) => {
+    renderer.requests.push(request)
+    if (request.type === 'create-agent') {
+      // The slow provider start: held until the test answers it, after the deadline.
+      renderer.heldCreate = request
+      return true
+    }
+    queueMicrotask(() => {
+      // The parent's own orchestration_send_prompt path (review of #1375, round 2 b): it reads the
+      // child and wakes it before delivering.
+      if (request.type === 'read-agent') {
+        bridge.resolve({
+          requestId: request.requestId as string, ok: true, type: 'read-agent',
+          output: { agent: agent(request.sessionId as string), messages: [] },
+        } as never)
+        return
+      }
+      if (request.type === 'ensure-agent-live') {
+        bridge.resolve({
+          requestId: request.requestId as string, ok: true, type: 'ensure-agent-live', agent: agent(request.sessionId as string),
+        } as never)
+        return
+      }
+      if (request.type === 'mark-bootstrap-prompt-delivered' && renderer.failMark) {
+        bridge.resolve({ requestId: request.requestId as string, ok: false, type: 'mark-bootstrap-prompt-delivered', message: 'workspace store is read-only' } as never)
+        return
+      }
+      if (request.type === 'mark-bootstrap-prompt-delivered') {
+        bridge.resolve({
+          requestId: request.requestId as string, ok: true, type: 'mark-bootstrap-prompt-delivered',
+          agent: agent(request.sessionId as string, true),
+        } as never)
+        return
+      }
+      bridge.resolve({ requestId: request.requestId as string, ok: true, type: request.type, agents: [] } as never)
+    })
+    return true
+  },
+}))
+
+const { OrchestrationBridge } = await import('@main/orchestration/OrchestrationBridge.js')
+const { createBuiltInMcpServer } = await import('@mcp/runtime/createBuiltInMcpServer.js')
+
+let bridge: InstanceType<typeof OrchestrationBridge>
+
+function agent(sessionId: string, bootstrapped = false) {
+  return {
+    sessionId, kind: 'claude', cwd: '/tmp/project',
+    orchestrationParentId: 'parent-1', orchestrationRootId: 'parent-1',
+    ...(bootstrapped ? { orchestrationBootstrapPromptDelivered: true } : {}),
+  }
+}
+
+beforeEach(() => {
+  renderer.requests.length = 0
+  renderer.heldCreate = null
+  renderer.parentAttached = true
+  renderer.retired.clear()
+  renderer.failMark = false
+  bridge = new OrchestrationBridge()
+  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+})
+afterEach(() => { vi.useRealTimers() })
+
+describe('create_agent whose child starts after the 30 s deadline (#1370)', () => {
+  it('delivers the bootstrap prompt to the late child, and tells the caller not to send it again', async () => {
+    const deliverPromptToAgent = vi.fn(async () => ({ ok: true }))
+    const sessionManager = {
+      deliverPromptToAgent,
+      canWaitForPromptReadiness: vi.fn(() => true),
+      deliverPromptWhenReady: vi.fn(async () => ({ ok: true })),
+      getSessionKind: vi.fn(() => 'claude'),
+    }
+    const server = createBuiltInMcpServer(
+      { sessionId: 'parent-1', cwd: '/tmp/project', domains: ['orchestration'] },
+      { orchestrationBridge: bridge as never, sessionManager: sessionManager as never },
+    )
+    const client = new Client({ name: 'late-bootstrap-test', version: '0.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    try {
+      await server.connect(serverTransport)
+      await client.connect(clientTransport)
+      const call = client.callTool({ name: 'orchestration_create_agent', arguments: { kind: 'claude', prompt: 'review the PR' } })
+      await vi.waitFor(() => expect(renderer.heldCreate).not.toBeNull())
+      await vi.advanceTimersByTimeAsync(30_000)
+      const reply = await call
+      const text = ((reply.content as Array<{ text: string }>)[0]!).text
+      expect(text).toMatch(/UNKNOWN/)
+      expect(text).toMatch(/tries to deliver its bootstrap prompt automatically/)
+      expect(text).toMatch(/orchestration_read_agent \(promptSubmitted\)/)
+      expect(deliverPromptToAgent).not.toHaveBeenCalled()
+
+      // The provider finally starts and the renderer answers.
+      bridge.resolve({
+        requestId: renderer.heldCreate!.requestId as string, ok: true, type: 'create-agent', agent: agent('child-late'),
+      } as never)
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      const [sessionId, prompt] = deliverPromptToAgent.mock.calls[0] as unknown as [string, string]
+      expect(sessionId).toBe('child-late')
+      expect(prompt).toContain('review the PR')
+      // And it is recorded as the child's bootstrap, exactly as a punctual create would record it.
+      await vi.waitFor(() => expect(renderer.requests.map(request => request.type)).toContain('mark-bootstrap-prompt-delivered'))
+    } finally {
+      await client.close()
+      await server.close()
+    }
+  })
+
+  // Review of #1375 (a): a provider with no readiness gate (OpenCode, Grok) answers a warming
+  // composer with not-ready. The punctual path hands that failure to the parent to retry; the late
+  // path's parent was told delivery is automatic, so the late path retries it itself.
+  const notReady = {
+    ok: false, stage: 'before-write', code: 'not-ready', message: 'composer is still starting',
+    retrySafe: true, disposition: 'retry-same-session', promptWritten: false, enterWritten: false,
+  }
+
+  async function lateCreate(
+    deliverPromptToAgent: ReturnType<typeof vi.fn>,
+    journal?: { recordIncident: ReturnType<typeof vi.fn> },
+    options: { readinessGate?: boolean; deliverPromptWhenReady?: ReturnType<typeof vi.fn>; holdAnswer?: boolean } = {},
+  ) {
+    const sessionManager = {
+      deliverPromptToAgent,
+      canWaitForPromptReadiness: vi.fn(() => options.readinessGate === true),
+      deliverPromptWhenReady: options.deliverPromptWhenReady ?? vi.fn(async () => ({ ok: true })),
+      getSessionKind: vi.fn(() => 'opencode'),
+    }
+    const server = createBuiltInMcpServer(
+      { sessionId: 'parent-1', cwd: '/tmp/project', domains: ['orchestration'] },
+      { orchestrationBridge: bridge as never, sessionManager: sessionManager as never, ...(journal ? { appRunJournal: journal as never } : {}) },
+    )
+    const client = new Client({ name: 'late-bootstrap-test', version: '0.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    await server.connect(serverTransport)
+    await client.connect(clientTransport)
+    const call = client.callTool({ name: 'orchestration_create_agent', arguments: { kind: 'opencode', prompt: 'review the PR' } })
+    await vi.waitFor(() => expect(renderer.heldCreate).not.toBeNull())
+    await vi.advanceTimersByTimeAsync(30_000)
+    await call
+    const answer = () => bridge.resolve({
+      requestId: renderer.heldCreate!.requestId as string, ok: true, type: 'create-agent', agent: agent('child-late'),
+    } as never)
+    if (!options.holdAnswer) answer()
+    return {
+      client,
+      answer,
+      sendPrompt: (prompt: string) => client.callTool({ name: 'orchestration_send_prompt', arguments: { sessionId: 'child-late', prompt } }),
+      close: async () => { await client.close(); await server.close() },
+    }
+  }
+
+  it('retries a late child that is not ready yet until the brief lands', async () => {
+    const deliverPromptToAgent = vi.fn()
+      .mockResolvedValueOnce(notReady)
+      .mockResolvedValueOnce(notReady)
+      .mockResolvedValue({ ok: true })
+    const run = await lateCreate(deliverPromptToAgent)
+    try {
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      await vi.advanceTimersByTimeAsync(2_000)
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(2))
+      await vi.advanceTimersByTimeAsync(4_000)
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(3))
+      await vi.waitFor(() => expect(renderer.requests.map(request => request.type)).toContain('mark-bootstrap-prompt-delivered'))
+      expect(bridge.promptSubmissionCount('child-late')).toBe(1)
+    } finally {
+      await run.close()
+    }
+  })
+
+  it('gives up after about a minute and records it', async () => {
+    const deliverPromptToAgent = vi.fn(async () => notReady)
+    const journal = { recordIncident: vi.fn() }
+    const run = await lateCreate(deliverPromptToAgent, journal)
+    try {
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      // Each wait is pinned, not only the total (review of #1375, c: shrinking the last delay to
+      // 1 ms survived): an attempt must NOT come early, and must come on time.
+      // `settle` drains the delivery's promise chain WITHOUT moving the clock: vi.waitFor would
+      // advance fake time while it polls and blur the exact boundaries checked here.
+      const settle = async () => { for (let i = 0; i < 20; i++) await vi.advanceTimersByTimeAsync(0) }
+      await settle()
+      const delays = [2_000, 4_000, 8_000, 16_000, 30_000]
+      for (const [index, delay] of delays.entries()) {
+        await vi.advanceTimersByTimeAsync(delay - 1)
+        await settle()
+        expect(deliverPromptToAgent).toHaveBeenCalledTimes(index + 1)
+        await vi.advanceTimersByTimeAsync(1)
+        await settle()
+        expect(deliverPromptToAgent).toHaveBeenCalledTimes(index + 2)
+      }
+      await vi.waitFor(() => expect(journal.recordIncident).toHaveBeenCalledWith(expect.objectContaining({ reason: 'create_agent_late_bootstrap_never_ready' })))
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(6)
+      await vi.advanceTimersByTimeAsync(120_000)
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(6)
+    } finally {
+      await run.close()
+    }
+  })
+
+  // Through the parent's REAL orchestration_send_prompt, not the bookkeeping call it makes (review
+  // of #1375, round 2 b: removing that call from send_prompt survived the old version of this test).
+  it('stops retrying once the parent sends the brief itself during a retry delay', async () => {
+    const deliverPromptToAgent = vi.fn()
+      .mockResolvedValueOnce(notReady)
+      .mockResolvedValue({ ok: true })
+    const run = await lateCreate(deliverPromptToAgent)
+    try {
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      await run.sendPrompt('review the PR, sent by hand')
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(2)
+      await vi.advanceTimersByTimeAsync(60_000)
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(2)
+      expect(bridge.promptSubmissionCount('child-late')).toBe(1)
+    } finally {
+      await run.close()
+    }
+  })
+
+  // Review of #1375, round 2 c: the renderer files the child before its create answer reaches main,
+  // so the parent can send to it first. Adoption used to reset the child's record to zero and the
+  // late bootstrap then sent a second brief.
+  it('sends no second brief when the parent sent one before the late answer arrived', async () => {
+    const deliverPromptToAgent = vi.fn(async () => ({ ok: true }))
+    const run = await lateCreate(deliverPromptToAgent, undefined, { holdAnswer: true })
+    try {
+      await run.sendPrompt('review the PR, sent by hand')
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(1)
+      run.answer()
+      await vi.advanceTimersByTimeAsync(60_000)
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(1)
+      expect(bridge.promptSubmissionCount('child-late')).toBe(1)
+    } finally {
+      await run.close()
+    }
+  })
+
+  // Review of #1375, round 2 c: a collision with another delivery (the parent's send holding the
+  // reservation) ended the late loop, though that other delivery could itself fail.
+  it('keeps retrying after a reservation collision', async () => {
+    const collision = {
+      ok: false, stage: 'reservation', code: 'delivery-in-flight', message: 'another delivery is in flight',
+      retrySafe: true, disposition: 'retry-same-session', promptWritten: false, enterWritten: false,
+    }
+    const deliverPromptToAgent = vi.fn()
+      .mockResolvedValueOnce(collision)
+      .mockResolvedValue({ ok: true })
+    const run = await lateCreate(deliverPromptToAgent)
+    try {
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      await vi.advanceTimersByTimeAsync(2_000)
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(2))
+      expect(bridge.promptSubmissionCount('child-late')).toBe(1)
+    } finally {
+      await run.close()
+    }
+  })
+
+  // Review of #1375, round 2 a and b: on a provider WITH a readiness gate the late attempt arms a
+  // waiter, which can deliver long after. It must be armed with the parent check, so a parent that
+  // closes in the meantime stops it at the moment of delivery.
+  it('arms a late readiness waiter that re-checks the parent before delivering', async () => {
+    let armed: { shouldDeliver?: () => boolean } | undefined
+    const deliverPromptWhenReady = vi.fn((_id: string, _prompt: string, _record: unknown, opts?: { shouldDeliver?: () => boolean }) => {
+      armed = opts
+      return new Promise(() => {})
+    })
+    const deliverPromptToAgent = vi.fn(async () => notReady)
+    const run = await lateCreate(deliverPromptToAgent, undefined, { readinessGate: true, deliverPromptWhenReady })
+    try {
+      await vi.waitFor(() => expect(deliverPromptWhenReady).toHaveBeenCalledTimes(1))
+      expect(armed?.shouldDeliver?.()).toBe(true)
+      renderer.parentAttached = false
+      expect(armed?.shouldDeliver?.()).toBe(false)
+    } finally {
+      await run.close()
+    }
+  })
+
+  // Review of #1375 (b): the parent was checked once, at adoption. A parent that closed during a
+  // retry delay still had its brief delivered to the now-ownerless child.
+  it('stops retrying when the parent closes during a retry delay', async () => {
+    const deliverPromptToAgent = vi.fn(async () => notReady)
+    const journal = { recordIncident: vi.fn() }
+    const run = await lateCreate(deliverPromptToAgent, journal)
+    try {
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      renderer.parentAttached = false
+      await vi.advanceTimersByTimeAsync(60_000)
+      expect(deliverPromptToAgent).toHaveBeenCalledTimes(1)
+      expect(journal.recordIncident).toHaveBeenCalledWith(expect.objectContaining({ reason: 'create_agent_late_bootstrap_parent_gone' }))
+    } finally {
+      await run.close()
+    }
+  })
+
+  // q85 / #1369 integration: the parent is REPLACED while the create is still
+  // outstanding (a reload during a 43 s start). The late delivery must still
+  // reach the child, and its bootstrap mark, which the handler addresses with
+  // the retired parent id it captured, must reach the successor's window.
+  it('delivers and marks the late bootstrap after the parent was replaced', async () => {
+    const deliverPromptToAgent = vi.fn(async () => ({ ok: true }))
+    const sessionManager = {
+      deliverPromptToAgent,
+      canWaitForPromptReadiness: vi.fn(() => true),
+      deliverPromptWhenReady: vi.fn(async () => ({ ok: true })),
+      getSessionKind: vi.fn(() => 'claude'),
+    }
+    const server = createBuiltInMcpServer(
+      { sessionId: 'parent-1', cwd: '/tmp/project', domains: ['orchestration'] },
+      { orchestrationBridge: bridge as never, sessionManager: sessionManager as never },
+    )
+    const client = new Client({ name: 'late-bootstrap-swap-test', version: '0.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    try {
+      await server.connect(serverTransport)
+      await client.connect(clientTransport)
+      const call = client.callTool({ name: 'orchestration_create_agent', arguments: { kind: 'claude', prompt: 'review the PR' } })
+      await vi.waitFor(() => expect(renderer.heldCreate).not.toBeNull())
+      await vi.advanceTimersByTimeAsync(30_000)
+      await call
+
+      // The parent pane is replaced: the renderer commits it and tells main.
+      renderer.retired.add('parent-1')
+      bridge.carryParent('parent-1', 'parent-2')
+      bridge.resolve({
+        requestId: renderer.heldCreate!.requestId as string, ok: true, type: 'create-agent',
+        agent: { ...agent('child-late'), orchestrationParentId: 'parent-2', orchestrationRootId: 'parent-2' },
+      } as never)
+      await vi.waitFor(() => expect(deliverPromptToAgent).toHaveBeenCalledTimes(1))
+      await vi.waitFor(() => expect(renderer.requests.map(request => request.type)).toContain('mark-bootstrap-prompt-delivered'))
+      const mark = renderer.requests.find(request => request.type === 'mark-bootstrap-prompt-delivered')!
+      expect(mark.parentSessionId).toBe('parent-2')
+    } finally {
+      await client.close()
+      await server.close()
+    }
+  })
+
+  // q85: the late path's persistence warning. A punctual create returns it in
+  // the tool reply; a late create's reply is gone (its caller got "outcome
+  // unknown"), so the incident journal is its only reader.
+  it.each([
+    ['late', true],
+    ['punctual', false],
+  ] as const)('reports a failed bootstrap mark on the %s path', async (_name, late) => {
+    renderer.failMark = true
+    const recordIncident = vi.fn()
+    const deliverPromptToAgent = vi.fn(async () => ({ ok: true }))
+    const sessionManager = {
+      deliverPromptToAgent,
+      canWaitForPromptReadiness: vi.fn(() => true),
+      deliverPromptWhenReady: vi.fn(async () => ({ ok: true })),
+      getSessionKind: vi.fn(() => 'claude'),
+    }
+    const server = createBuiltInMcpServer(
+      { sessionId: 'parent-1', cwd: '/tmp/project', domains: ['orchestration'] },
+      { orchestrationBridge: bridge as never, sessionManager: sessionManager as never, appRunJournal: { recordIncident } as never },
+    )
+    const client = new Client({ name: 'late-bootstrap-mark-test', version: '0.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    try {
+      await server.connect(serverTransport)
+      await client.connect(clientTransport)
+      const call = client.callTool({ name: 'orchestration_create_agent', arguments: { kind: 'claude', prompt: 'review the PR' } })
+      await vi.waitFor(() => expect(renderer.heldCreate).not.toBeNull())
+      if (late) await vi.advanceTimersByTimeAsync(30_000)
+      const answer = () => bridge.resolve({ requestId: renderer.heldCreate!.requestId as string, ok: true, type: 'create-agent', agent: agent('child-mark') } as never)
+      if (!late) answer()
+      const text = ((await call).content as Array<{ text: string }>)[0]!.text
+      if (late) answer()
+      await vi.waitFor(() => expect(renderer.requests.map(request => request.type)).toContain('mark-bootstrap-prompt-delivered'))
+      const marked = () => recordIncident.mock.calls.map(([incident]) => incident as { kind: string; context: Record<string, unknown> })
+        .filter(incident => incident.kind === 'orchestration.bootstrap_mark_failed')
+      if (late) {
+        await vi.waitFor(() => expect(marked()).toHaveLength(1))
+        expect(marked()[0]!.context).toMatchObject({ sessionId: 'child-mark', message: 'workspace store is read-only' })
+      } else {
+        // The caller reads the warning; no duplicate incident.
+        expect(text).toContain('workspace store is read-only')
+        await vi.advanceTimersByTimeAsync(0)
+        expect(marked()).toHaveLength(0)
+      }
+    } finally {
+      await client.close()
+      await server.close()
+    }
+  })
+})
diff --git a/src/preload/api/provider.ts b/src/preload/api/provider.ts
index 71af48ba1..5dba1ae39 100644
--- a/src/preload/api/provider.ts
+++ b/src/preload/api/provider.ts
@@ -1,4 +1,5 @@
 import type { AgentProviderKind } from '@shared/types/providerKind.js'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity.js'
 import type {
   ListRewindPromptsRequest,
   RewindPrompt,
@@ -67,6 +68,9 @@ export const providerApi = {
     /** One human-readable line describing what `shrunk` cost, else null. The
      *  renderer shows it per pane and counts strategies in a batch summary. */
     shrinkSummary: string | null
+    /** The native-resume projector's report, summarized (#927). Independent
+     *  of `shrinkSummary`, which only covers context reduction. */
+    projectionFidelity: NativeProjectionFidelity
   } | {
     /** A provider id can identify a pre-created but still blank session. */
     kind: 'source-empty'
@@ -128,6 +132,8 @@ export const providerApi = {
     provider: AgentProviderKind
     newProviderSessionId: string
     newFilePath: string
+    /** What the projector did to the copy (#927). */
+    projectionFidelity: NativeProjectionFidelity
   }> => ipcRenderer.invoke('session:duplicate', params),
 
   /**
@@ -198,5 +204,7 @@ export const providerApi = {
       name: string | null
     }>
     promptTimestamp: string | null
+    /** What the projector did to the rewound copy (#927). */
+    projectionFidelity: NativeProjectionFidelity
   }> => ipcRenderer.invoke('session:rewind-to-prompt', params),
 }
diff --git a/src/renderer/src/features/cli-updates/CliUpdateBanner.renderer.test.tsx b/src/renderer/src/features/cli-updates/CliUpdateBanner.renderer.test.tsx
index 731099353..9c0c0ff63 100644
--- a/src/renderer/src/features/cli-updates/CliUpdateBanner.renderer.test.tsx
+++ b/src/renderer/src/features/cli-updates/CliUpdateBanner.renderer.test.tsx
@@ -104,3 +104,48 @@ describe('CliUpdateBanner View Log', () => {
     expect(screen.queryByRole('alert')).toBeNull()
   })
 })
+
+// #1425: an update that could not start used to leave an undismissable
+// "Updating…" row forever (main), and a rejected Update now request was dropped
+// by `void` (renderer). The first is now its own failed state; the second is
+// said on the row that was clicked.
+describe('CliUpdateBanner: an update that could not start', () => {
+  const couldNotStart = { kind: 'failed' as const, cli: 'claude' as const, from: '2.1.281', wantedLatest: '2.1.282', installMethod: 'npm' as const, reason: 'could-not-start' as const, logPath: null, finishedAt: 5 }
+
+  it('says so in fixed words, offers a retry instead of a log, and can be dismissed', async () => {
+    const updateNow = vi.fn(async () => DEFAULT_CLI_UPDATE_SNAPSHOT)
+    Object.defineProperty(window, 'api', { configurable: true, value: { ...(window as { api?: object }).api, cliUpdatesUpdateNow: updateNow } })
+    useCliUpdateStore.setState({ snapshot: { ...DEFAULT_CLI_UPDATE_SNAPSHOT, claude: couldNotStart }, dismissed: new Set() })
+    render(<CliUpdateBanner />)
+    expect(screen.getByText("Couldn't start the Claude Code update: Agent Code couldn't create its update log. Still at 2.1.281.")).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'View Log' })).toBeNull()
+    await act(async () => { fireEvent.click(screen.getByRole('button', { name: 'Update now' })) })
+    expect(updateNow).toHaveBeenCalledWith('claude')
+    // A request that resolves says nothing (#1447 review c: the success half
+    // of the action was unpinned).
+    expect(screen.queryByRole('alert')).toBeNull()
+    expect(describeState('claude', couldNotStart)?.undismissable).not.toBe(true)
+    // The hint is user-visible copy too: fixed words, no OS text (q22).
+    expect(describeState('claude', couldNotStart)?.hint).toBe('Check that the disk has free space and that the Agent Code data folder is writable, then choose Update now.')
+  })
+
+  it('keys each attempt separately, so a dismissed failure does not hide the next click\'s', () => {
+    expect(dismissKey('claude', couldNotStart)).not.toBe(dismissKey('claude', { ...couldNotStart, finishedAt: 6 }))
+  })
+
+  it.each([
+    ['the offer', { kind: 'notify' as const, cli: 'claude' as const, installed: '2.1.281', latest: '2.1.282', severity: 'patch' as const, installMethod: 'npm' as const, checkedAt: 1 }, 'Update Now'],
+    ['a deferral of the user\'s click', { ...deferred('claude'), requestedByUser: true as const }, 'Update now'],
+    // #1447 review b: the could-not-start row's own retry must say a rejection too.
+    ['the could-not-start retry', { kind: 'failed' as const, cli: 'claude' as const, from: '2.1.281', wantedLatest: '2.1.282', installMethod: 'npm' as const, reason: 'could-not-start' as const, logPath: null, finishedAt: 5 }, 'Update now'],
+  ] as const)('says a rejected Update now request on %s instead of dropping it', async (_name, state, label) => {
+    const updateNow = vi.fn(async () => { throw new Error('Error invoking remote method \'cli-updates:update-now\': EACCES /state') })
+    Object.defineProperty(window, 'api', { configurable: true, value: { ...(window as { api?: object }).api, cliUpdatesUpdateNow: updateNow } })
+    useCliUpdateStore.setState({ snapshot: { ...DEFAULT_CLI_UPDATE_SNAPSHOT, claude: state }, dismissed: new Set() })
+    render(<CliUpdateBanner />)
+    await act(async () => { fireEvent.click(screen.getByRole('button', { name: label })) })
+    // Fixed words; the IPC/OS text never reaches the screen (q22).
+    expect(screen.getByRole('alert')).toHaveTextContent("Couldn't start the update. Try again.")
+    expect(screen.getByRole('alert').textContent).not.toContain('EACCES')
+  })
+})
diff --git a/src/renderer/src/features/cli-updates/CliUpdateBanner.tsx b/src/renderer/src/features/cli-updates/CliUpdateBanner.tsx
index 1bfd37cec..f4d877a34 100644
--- a/src/renderer/src/features/cli-updates/CliUpdateBanner.tsx
+++ b/src/renderer/src/features/cli-updates/CliUpdateBanner.tsx
@@ -48,6 +48,24 @@ type BannerEntry = {
 
 // Fixed words (q22): the OS failure text stays in main's diagnostic log.
 export const CLI_UPDATE_LOG_NOT_OPENED = "Couldn't open the update log. It may have been cleaned up; the next failed update writes a new one."
+// #1425: an Update now click whose request itself failed (main rejected
+// before any state could say so) used to be dropped by `void`.
+export const CLI_UPDATE_NOT_STARTED = "Couldn't start the update. Try again."
+
+/** Every Update now action (#1425). Awaited so a rejected request is said
+ *  (resolves false → the row's failureText) instead of dropped. The snapshot
+ *  main answers with arrives over the state event as well, so success needs
+ *  nothing more here. */
+function updateNowAction(cli: CliUpdateKind, resultKey: string): NonNullable<BannerEntry['action']> {
+  return {
+    label: 'Update now',
+    // One-shot update: bypasses the automatic/notify/off preference for this
+    // click only, leaving the persisted behavior untouched.
+    onClick: () => window.api.cliUpdatesUpdateNow(cli).then(() => true, () => false),
+    failureText: CLI_UPDATE_NOT_STARTED,
+    resultKey,
+  }
+}
 
 export function describeState(cli: CliUpdateKind, state: CliUpdateState): BannerEntry | null {
   const label = cli === 'claude' ? 'Claude Code' : 'Codex'
@@ -72,6 +90,17 @@ export function describeState(cli: CliUpdateKind, state: CliUpdateState): Banner
         text: `${label} updated to ${state.to}.`,
       }
     case 'failed': {
+      if (state.reason === 'could-not-start') {
+        // #1425: the attempt stopped before running anything, so there is no
+        // log to view; the row offers the retry instead. Dismissable, unlike
+        // the `updating` row this used to leave standing forever.
+        return {
+          tone: 'warning',
+          text: `Couldn't start the ${label} update: Agent Code couldn't create its update log. Still at ${state.from}.`,
+          hint: 'Check that the disk has free space and that the Agent Code data folder is writable, then choose Update now.',
+          action: updateNowAction(cli, `could-not-start:${state.finishedAt}`),
+        }
+      }
       const reasonHint =
         state.reason === 'timeout'
           ? 'timed out'
@@ -110,7 +139,7 @@ export function describeState(cli: CliUpdateKind, state: CliUpdateState): Banner
           failureText: CLI_UPDATE_LOG_NOT_OPENED,
           // A new failed run writes a new log: an earlier "couldn't open"
           // says nothing about it (#1423 review a).
-          resultKey: state.logPath,
+          resultKey: state.logPath ?? undefined,
         },
         hint,
       }
@@ -119,15 +148,7 @@ export function describeState(cli: CliUpdateKind, state: CliUpdateState): Banner
       return {
         tone: 'info',
         text: `${label} ${state.installed} → ${state.latest} available.`,
-        action: {
-          label: 'Update Now',
-          onClick: () => {
-            // One-shot update: bypasses the automatic/notify/off
-            // preference for this click only, leaving the persisted
-            // behavior untouched.
-            void window.api.cliUpdatesUpdateNow(cli)
-          },
-        },
+        action: { ...updateNowAction(cli, `notify:${state.latest}`), label: 'Update Now' },
       }
     case 'deferred':
       // Automatic deferrals stay silent ("we'll do it later" needs no
@@ -141,12 +162,7 @@ export function describeState(cli: CliUpdateKind, state: CliUpdateState): Banner
       return {
         tone: 'info',
         text: `${label} ${state.wantedLatest} is ready, but ${label} agents are running. Close them, then choose Update now (now ${state.from}).`,
-        action: {
-          label: 'Update now',
-          onClick: () => {
-            void window.api.cliUpdatesUpdateNow(cli)
-          },
-        },
+        action: updateNowAction(cli, `deferred:${state.checkedAt}`),
       }
     case 'idle':
     case 'up-to-date':
diff --git a/src/renderer/src/features/cli-updates/store.ts b/src/renderer/src/features/cli-updates/store.ts
index a871e8074..509713212 100644
--- a/src/renderer/src/features/cli-updates/store.ts
+++ b/src/renderer/src/features/cli-updates/store.ts
@@ -77,7 +77,14 @@ export function dismissKey(cli: CliUpdateKind, state: CliUpdateState): string {
     case 'updated':
       return `${cli}:updated:${state.to}`
     case 'failed':
-      return `${cli}:failed:${state.wantedLatest}`
+      // A could-not-start row offers Update now as its retry (#1425), so it
+      // is keyed per ATTEMPT, like a user deferral: a dismissed failure must
+      // not swallow the answer to the next click. Other failures stay per
+      // version — their retry is the next launch, and re-showing the same
+      // failure every launch after a dismissal would nag.
+      return state.reason === 'could-not-start'
+        ? `${cli}:failed:${state.wantedLatest}:${state.finishedAt}`
+        : `${cli}:failed:${state.wantedLatest}`
     case 'deferred':
       // A user-requested deferral is keyed per CLICK (#1265 review A): the
       // row's Update now retries, and a dismissed explanation must not
diff --git a/src/renderer/src/features/global-editor/hooks/useEditorBeforeUnloadGuard.renderer.test.tsx b/src/renderer/src/features/global-editor/hooks/useEditorBeforeUnloadGuard.renderer.test.tsx
index 14db5655f..4b6f495f4 100644
--- a/src/renderer/src/features/global-editor/hooks/useEditorBeforeUnloadGuard.renderer.test.tsx
+++ b/src/renderer/src/features/global-editor/hooks/useEditorBeforeUnloadGuard.renderer.test.tsx
@@ -35,7 +35,7 @@ it('keeps the real editor veto ahead of all application service disposal', async
     stopDictation: supportStop, flushObservations: supportStop, sweepOwnedProxies: supportStop,
     stopBuiltInMcp: supportStop, stopRemote: supportStop, stopLsp: supportStop,
     stopExternalControl: supportStop, disposeControl: supportStop,
-    disposeWorkflowBridge: supportStop, disposeCaffeinate: supportStop, stopHeapWatchdog: supportStop,
+    disposeWorkflowBridge: supportStop, disposeCaffeinate: supportStop, disposeGoalLoop: supportStop, stopHeapWatchdog: supportStop,
     stopDetachedTmuxSweep: supportStop,
     drainWorkspace: supportStop, drainDictationHistory: supportStop,
     flushRecordings: supportStop, flushDictationDebug: supportStop,
diff --git a/src/renderer/src/features/tldr/sessionContinuity.renderer.test.tsx b/src/renderer/src/features/tldr/sessionContinuity.renderer.test.tsx
index 237b2a884..7e2693b89 100644
--- a/src/renderer/src/features/tldr/sessionContinuity.renderer.test.tsx
+++ b/src/renderer/src/features/tldr/sessionContinuity.renderer.test.tsx
@@ -36,7 +36,7 @@ describe('TLDR identity through real session actions', () => {
     const saved = { text: 'The original work is complete. PR #123 is merged.', revision: 1, updatedAt: '2026-09-11T00:00:00.000Z' }
     window.api = {
       ...originalApi, spawnSession, killOwnedSession: vi.fn(async () => true),
-      rewindToPrompt: vi.fn(async () => ({ provider: 'codex' as const, newProviderSessionId: 'native-rewound', newFilePath: '/recorded/rewound.jsonl', promptText: 'Earlier prompt', promptTimestamp: null, promptMode: 'prompt' as const, promptImages: [], promptAttachments: [] })),
+      rewindToPrompt: vi.fn(async () => ({ provider: 'codex' as const, newProviderSessionId: 'native-rewound', newFilePath: '/recorded/rewound.jsonl', promptText: 'Earlier prompt', promptTimestamp: null, promptMode: 'prompt' as const, promptImages: [], promptAttachments: [], projectionFidelity: { profile: 'native-resume' as const, sourceProvider: 'codex', targetProvider: 'codex', providerProfileId: 'test', providerEvidence: {}, counts: { preserved: 0, dropped: 0, demoted: 0, synthesized: 0, repaired: 0, retargeted: 0, opaque: 0 }, codes: [], sourceLinesOmitted: 0 } })),
       stripCodexCyberPolicy: vi.fn(async () => ({ provider: 'codex' as const, newProviderSessionId: 'native-rewound', newFilePath: '/recorded/rewound.jsonl' })),
       readTldrs: vi.fn(async (ids: string[]): Promise<Record<string, TldrRecord>> => ids.includes('summary-source') ? { 'summary-source': saved } : {}),
       onTldrChanged: () => () => {},
diff --git a/src/renderer/src/features/workflows/model/missingRun.ts b/src/renderer/src/features/workflows/model/missingRun.ts
new file mode 100644
index 000000000..065f4a4e9
--- /dev/null
+++ b/src/renderer/src/features/workflows/model/missingRun.ts
@@ -0,0 +1,93 @@
+import { useEffect, useRef, useState } from 'react'
+
+import type { WorkflowClient, WorkflowRunReference } from '../client/WorkflowClient'
+import { workflowRunActivity } from './workflowRunStatus'
+
+/**
+ * What to call a referenced workflow run that the store reports NOT FOUND
+ * (#1348), shared by the run view, the selector and the history dialog so
+ * they agree.
+ *
+ * WHY this exists: history is built from transcript references, and those
+ * outlive the run directory. Workflow retention (#1275) removes a run's stored
+ * data after its window, so an old reference points at nothing. The surfaces
+ * used to present that as a fault ("Unknown", "not found" with a Retry), and
+ * the run view kept Resume, which can only fail with run-not-found.
+ *
+ * WHY one label (#1440 review b): main answers `null` only for
+ * `run-not-found`, and workflow-mcp looks the manifest up GLOBALLY by run id
+ * before it checks the project scope (`WorkflowService.status`: a run in
+ * another project is `scope-forbidden`, not null). So null always means the
+ * run is gone from this app's store. The first version split it into
+ * "Expired" and "Unavailable in this project" by whether the reference named
+ * a cwd, which misdescribed the protocol.
+ *
+ * WHY the detail does not claim retention did it: a run folder removed by
+ * hand answers the same way, so retention is named only as the usual cause.
+ * No day count either: the windows live in workflow-mcp and differ by
+ * lineage, and a copied number would drift.
+ *
+ * A failed READ is not "not found" and never comes through here: it stays an
+ * error with Retry, and the reference's own actions stay available.
+ */
+export const MISSING_RUN = {
+  label: 'Expired',
+  detail: 'This run’s stored data is gone (workflow retention removes old runs). It can no longer be opened or resumed.',
+} as const
+
+/**
+ * The run ids among `references` whose runs are gone, for the selector's tabs
+ * (#1440 reviews a+b). A tab labels a run Active from its launch-time
+ * reference status, so an expired `queued` run stayed Active beside a dialog
+ * that said Expired. Only references that CLAIM to be active are checked: the
+ * selector shows at most three, and an inactive claim needs no correction.
+ *
+ * WHY per run and not one batch (round-2 review b): the first version re-read
+ * every visible tab through one Promise.all whenever the set changed. A later
+ * transient failure on a tab already proven Expired then cleared it back to
+ * Active, and one slow read held back another tab's answer. Now:
+ *   - each run is asked ONCE, and its answer lands as soon as it arrives;
+ *   - "missing" is never taken back (a failed read proves nothing);
+ *   - a failed read is forgotten, so the run may be asked again on a later
+ *     change of the visible set;
+ *   - a result arriving after unmount is dropped.
+ */
+export function useMissingRunIds(
+  client: WorkflowClient,
+  references: readonly WorkflowRunReference[],
+  cwd: string | null,
+): ReadonlySet<string> {
+  const [missing, setMissing] = useState<ReadonlySet<string>>(() => new Set())
+  const asked = useRef(new Set<string>())
+  const mounted = useRef(true)
+  useEffect(() => {
+    mounted.current = true
+    return () => { mounted.current = false }
+  }, [])
+  const claimsActive = references
+    .filter(reference => workflowRunActivity(reference.status) === 'active' && (reference.cwd ?? cwd))
+    .map(reference => `${reference.runId}\u0000${reference.cwd ?? cwd}`)
+  const key = claimsActive.join('\u0001')
+  // Answers belong to the client that gave them: a new client (rare) starts over.
+  const answeredBy = useRef(client)
+  useEffect(() => {
+    if (answeredBy.current !== client) {
+      answeredBy.current = client
+      asked.current = new Set()
+      setMissing(new Set())
+    }
+    if (!client.available) return
+    for (const entry of claimsActive) {
+      if (asked.current.has(entry)) continue
+      asked.current.add(entry)
+      const [runId, scopeCwd] = entry.split('\u0000') as [string, string]
+      client.getSnapshot({ cwd: scopeCwd, runId }).then(snapshot => {
+        if (snapshot !== null || !mounted.current || answeredBy.current !== client) return
+        setMissing(previous => previous.has(runId) ? previous : new Set(previous).add(runId))
+      }, () => { asked.current.delete(entry) })
+    }
+    // `key` is the content of claimsActive; the array itself is new each render.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [client, key])
+  return missing
+}
diff --git a/src/renderer/src/features/workflows/model/workflowRunStore.ts b/src/renderer/src/features/workflows/model/workflowRunStore.ts
index d5aef0bdd..f235e0bfc 100644
--- a/src/renderer/src/features/workflows/model/workflowRunStore.ts
+++ b/src/renderer/src/features/workflows/model/workflowRunStore.ts
@@ -13,7 +13,12 @@ import type {
 } from '../client/WorkflowClient'
 
 export type WorkflowRunView = {
-  phase: 'loading' | 'ready' | 'unavailable' | 'error'
+  /**
+   * `missing`: main answered that this run does not exist in its scope (#1348;
+   * see model/missingRun.ts). Distinct from `error`, which is a failed read that
+   * proves nothing about the run and keeps Retry.
+   */
+  phase: 'loading' | 'ready' | 'unavailable' | 'error' | 'missing'
   snapshot: WorkflowState
   /** Oldest-to-newest immutable ancestors; `snapshot` remains the live run authority. */
   history: WorkflowState[]
@@ -149,11 +154,10 @@ export class WorkflowRunStore {
       if (generation !== this.generation) return
       if (!envelope) {
         this.setView({
-          phase: 'error',
+          phase: 'missing',
           snapshot: this.view.snapshot,
           history: this.view.history,
           cursor: this.view.cursor,
-          error: 'Workflow run was not found in this project.',
         })
         return
       }
diff --git a/src/renderer/src/features/workflows/ui/WorkflowHistoryDialog.tsx b/src/renderer/src/features/workflows/ui/WorkflowHistoryDialog.tsx
index e8b20f2e4..f94acb48b 100644
--- a/src/renderer/src/features/workflows/ui/WorkflowHistoryDialog.tsx
+++ b/src/renderer/src/features/workflows/ui/WorkflowHistoryDialog.tsx
@@ -11,6 +11,7 @@ import { Button } from '@renderer/components/ui/button'
 
 import type { WorkflowRunReference } from '../client/WorkflowClient'
 import { useWorkflowClient } from '../client/WorkflowClientContext'
+import { MISSING_RUN } from '../model/missingRun'
 import {
   workflowRunActivity,
   workflowRunStatusLabel,
@@ -22,6 +23,8 @@ type WorkflowHistoryDetails = {
   updatedAt?: string
   loading: boolean
   error?: boolean
+  /** Main reported the run not found (#1348, model/missingRun.ts). */
+  missing?: boolean
 }
 
 const HISTORY_PAGE_SIZE = 50
@@ -64,6 +67,9 @@ async function readHistoryDetails(
 
   try {
     const snapshot = await client.getSnapshot({ cwd: effectiveCwd, runId: reference.runId })
+    // Main answers null only for run-not-found (#1348): the run is missing,
+    // not unknown. Keep the launch-time status out of it, as below.
+    if (snapshot === null) return { loading: false, missing: true }
     const manifest = snapshot?.manifest
     // WHY a successful null clears launch-time status: transcript references are durable discovery
     // records, not durable status authority. If the corresponding manifest has been pruned, a
@@ -189,13 +195,16 @@ export function WorkflowHistoryDialog({
                 status: reference.status,
                 loading: false,
               }
-              const activity = workflowRunActivity(details.status)
+              const missing = details.missing ? MISSING_RUN : null
+              // A run whose data is gone is certainly not running, whatever
+              // its reference said at launch (#1348).
+              const activity = missing ? 'inactive' : workflowRunActivity(details.status)
               const activityLabel = activity === 'active'
                 ? 'Active'
                 : activity === 'inactive'
                   ? 'Inactive'
                   : 'Unknown'
-              const statusLabel = workflowRunStatusLabel(details.status)
+              const statusLabel = missing ? missing.label : workflowRunStatusLabel(details.status)
               return (
                 <article
                   key={reference.runId}
@@ -242,6 +251,8 @@ export function WorkflowHistoryDialog({
                           Retry
                         </button>
                       </span>
+                    ) : missing ? (
+                      <span>{missing.detail}</span>
                     ) : details.createdAt ? (
                       <>
                         <Timestamp label="Started" value={details.createdAt} />
diff --git a/src/renderer/src/features/workflows/ui/WorkflowRunRow.renderer.test.tsx b/src/renderer/src/features/workflows/ui/WorkflowRunRow.renderer.test.tsx
index 8418fd544..bad5420c1 100644
--- a/src/renderer/src/features/workflows/ui/WorkflowRunRow.renderer.test.tsx
+++ b/src/renderer/src/features/workflows/ui/WorkflowRunRow.renderer.test.tsx
@@ -257,6 +257,81 @@ function clientFor(state: WorkflowState): WorkflowClient {
 }
 
 describe('WorkflowRunView', () => {
+  // #1348: a transcript reference outlives its run directory (retention,
+  // #1275). The store answered "not found" as a generic error, the header fell
+  // back to the reference's `failed` status, and Resume stayed; it could only
+  // fail with run-not-found.
+  const missingClient = (): WorkflowClient => ({ ...clientFor(completedState()), async getSnapshot() { return null } })
+
+  it('shows a run whose stored data is gone as expired, with no Resume or Retry', async () => {
+    render(
+      <WorkflowClientProvider value={missingClient()}>
+        <WorkflowRunView reference={{ runId: 'run-ui', cwd: '/repo', status: 'failed' }} cwd="/repo" onReferenceChange={() => {}} />
+      </WorkflowClientProvider>,
+    )
+    expect(await screen.findByText('Expired')).toBeInTheDocument()
+    expect(screen.getByText(/stored data is gone/i)).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Resume' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Retry' })).toBeNull()
+  })
+
+  // #1440 review a: while the snapshot is still loading, the header falls
+  // back to the reference's `failed`, and Resume was clickable into a
+  // run-not-found. No action is offered until the store has answered.
+  it('offers no Resume while the snapshot is still loading, and none once it says expired', async () => {
+    let answer!: (value: null) => void
+    const pending: WorkflowClient = { ...clientFor(completedState()), getSnapshot: () => new Promise(resolve => { answer = resolve }) }
+    render(
+      <WorkflowClientProvider value={pending}>
+        <WorkflowRunView reference={{ runId: 'run-ui', cwd: '/repo', status: 'failed' }} cwd="/repo" onReferenceChange={() => {}} />
+      </WorkflowClientProvider>,
+    )
+    expect(await screen.findByText('Loading workflow activity…')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Resume' })).toBeNull()
+    answer(null)
+    expect(await screen.findByText('Expired')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Resume' })).toBeNull()
+  })
+
+  // #1440 review c: a reference that launched `running` but whose run is gone
+  // offers no Cancel either (it would silently do nothing).
+  it('offers no Cancel for a missing run that its reference says is running', async () => {
+    render(
+      <WorkflowClientProvider value={missingClient()}>
+        <WorkflowRunView reference={{ runId: 'run-ui', cwd: '/repo', status: 'running' }} cwd="/repo" onReferenceChange={() => {}} />
+      </WorkflowClientProvider>,
+    )
+    expect(await screen.findByText('Expired')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Cancel' })).toBeNull()
+  })
+
+  // The lookup is global by run id (review b), so a reference without its
+  // own cwd whose run is gone is expired too.
+  it('calls a missing run without its own cwd expired as well', async () => {
+    render(
+      <WorkflowClientProvider value={missingClient()}>
+        <WorkflowRunView reference={{ runId: 'run-ui', status: 'failed' }} cwd="/repo" onReferenceChange={() => {}} />
+      </WorkflowClientProvider>,
+    )
+    expect(await screen.findByText('Expired')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Resume' })).toBeNull()
+  })
+
+  // Unknown is not missing: a failed READ (IPC, storage) proves nothing about
+  // the run, so the user keeps Retry and the Resume the reference allows.
+  it('keeps Retry and Resume when the snapshot read fails rather than reporting the run missing', async () => {
+    const failing: WorkflowClient = { ...clientFor(completedState()), async getSnapshot() { throw new Error('storage offline') } }
+    render(
+      <WorkflowClientProvider value={failing}>
+        <WorkflowRunView reference={{ runId: 'run-ui', cwd: '/repo', status: 'failed' }} cwd="/repo" onReferenceChange={() => {}} />
+      </WorkflowClientProvider>,
+    )
+    expect(await screen.findByText('storage offline')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Retry' })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: 'Resume' })).toBeInTheDocument()
+    expect(screen.queryByText('Expired')).toBeNull()
+  })
+
   it('distinguishes a soft stall from work that requires operator recovery', async () => {
     const state = recoveryHealthState()
     render(
diff --git a/src/renderer/src/features/workflows/ui/WorkflowRunRow.tsx b/src/renderer/src/features/workflows/ui/WorkflowRunRow.tsx
index 5f709979c..776f56ed5 100644
--- a/src/renderer/src/features/workflows/ui/WorkflowRunRow.tsx
+++ b/src/renderer/src/features/workflows/ui/WorkflowRunRow.tsx
@@ -5,6 +5,7 @@ import { Button } from '@renderer/components/ui/button'
 
 import type { WorkflowRunReference } from '../client/WorkflowClient'
 import { useWorkflowClient } from '../client/WorkflowClientContext'
+import { MISSING_RUN } from '../model/missingRun'
 import { mergeWorkflowLineage } from '../model/workflowLineage'
 import { useWorkflowRun } from '../model/workflowRunStore'
 import { WorkflowPhaseSection } from './WorkflowPhaseSection'
@@ -76,7 +77,16 @@ export function WorkflowRunView({
   const status = view.phase !== 'ready' && view.cursor === 0
     ? reference.status ?? snapshot.status
     : snapshot.status
-  const active = status === 'pending' || status === 'running' || status === 'cancellation_requested'
+  // A run the store reports missing has no live status, and the reference's
+  // launch-time `failed` would keep offering Resume, which can only fail with
+  // run-not-found (#1348). Its label replaces the status; nothing is active.
+  const missing = view.phase === 'missing' ? MISSING_RUN : null
+  // No action until the store has answered (#1440 review a): while loading,
+  // the header shows the reference's launch-time status, and a Resume or
+  // Cancel clicked then on a run that turns out to be gone failed with
+  // run-not-found.
+  const answered = view.phase !== 'loading'
+  const active = answered && !missing && (status === 'pending' || status === 'running' || status === 'cancellation_requested')
   const now = useRunClock(active)
   const elapsed = elapsedLabel(snapshot.startedAt, snapshot.completedAt, now)
   const workflow = snapshot.workflow ?? reference.workflow
@@ -145,7 +155,7 @@ export function WorkflowRunView({
   }
 
   const unassigned = agentsByPhase.get('__unassigned__') ?? []
-  const canResume = ['failed', 'cancelled', 'interrupted'].includes(status)
+  const canResume = answered && !missing && ['failed', 'cancelled', 'interrupted'].includes(status)
 
   return (
     <div
@@ -165,7 +175,7 @@ export function WorkflowRunView({
                 {withVisibleControls(workflow?.title ?? workflow?.name ?? 'Workflow')}
               </span>
               <span className="text-[10px] uppercase tracking-wider text-muted">
-                {runStatusLabel(status)}
+                {missing ? missing.label : runStatusLabel(status)}
               </span>
             </div>
             {workflow?.description ? (
@@ -231,6 +241,9 @@ export function WorkflowRunView({
             Live workflow details are unavailable in this client.
           </div>
         ) : null}
+        {missing ? (
+          <div className="mt-3 text-[11px] text-muted">{missing.detail}</div>
+        ) : null}
         {view.phase === 'error' ? (
           <div className="mt-3 flex items-center gap-2 text-[11px] text-danger">
             <span>{view.error}</span>
diff --git a/src/renderer/src/features/workflows/ui/WorkflowViewSelector.renderer.test.tsx b/src/renderer/src/features/workflows/ui/WorkflowViewSelector.renderer.test.tsx
index c7aa21542..ae2620dbb 100644
--- a/src/renderer/src/features/workflows/ui/WorkflowViewSelector.renderer.test.tsx
+++ b/src/renderer/src/features/workflows/ui/WorkflowViewSelector.renderer.test.tsx
@@ -171,7 +171,11 @@ describe('WorkflowViewSelector', () => {
 
     fireEvent.click(screen.getByRole('button', { name: 'Show All' }))
     expect(await screen.findByRole('dialog', { name: 'Workflow History' })).toBeInTheDocument()
-    await waitFor(() => expect(getSnapshot).toHaveBeenCalledTimes(5))
+    // Five dialog reads (one per history entry) plus the selector's single
+    // check of the one tab that claims to be running (run-5), which is how a
+    // tab learns its run is gone (#1440). Completed tabs are not checked.
+    await waitFor(() => expect(getSnapshot).toHaveBeenCalledTimes(6))
+    expect(getSnapshot.mock.calls.filter(([scope]) => scope.runId === 'run-5')).toHaveLength(2)
     await waitFor(() => expect(screen.queryByText('Loading timestamps…')).not.toBeInTheDocument())
 
     expect(screen.getAllByRole('listitem')).toHaveLength(5)
@@ -197,10 +201,12 @@ describe('WorkflowViewSelector', () => {
     const historyReferences: WorkflowRunReference[] = [
       { runId: 'run-missing', cwd: '/repo', status: 'queued', workflow: { name: 'missing' } },
       { runId: 'run-error', cwd: '/repo', status: 'running', workflow: { name: 'error' } },
+      // No cwd of its own: still a global lookup by run id (#1440 review b).
+      { runId: 'run-elsewhere', status: 'failed', workflow: { name: 'elsewhere' } },
     ]
     let errorAttempts = 0
     const getSnapshot = vi.fn<WorkflowClient['getSnapshot']>(async ({ cwd, runId }) => {
-      if (runId === 'run-missing') return null
+      if (runId === 'run-missing' || runId === 'run-elsewhere') return null
       errorAttempts += 1
       if (errorAttempts === 1) throw new Error('IPC unavailable')
       return {
@@ -229,7 +235,10 @@ describe('WorkflowViewSelector', () => {
     render(
       <WorkflowClientProvider value={client}>
         <WorkflowViewSelector
-          references={historyReferences}
+          // The tabs show only the missing run: the selector reads what its
+          // tabs claim is live, and run-error's read sequence belongs to the
+          // dialog below.
+          references={historyReferences.filter(reference => reference.runId === 'run-missing')}
           historyReferences={historyReferences}
           cwd="/repo"
           selectedRunId={null}
@@ -238,6 +247,12 @@ describe('WorkflowViewSelector', () => {
       </WorkflowClientProvider>,
     )
 
+    // #1440 reviews a+b: the TAB must agree with the dialog. A reference that
+    // launched `queued` but whose run is gone is not Active.
+    const missingTab = screen.getByRole('tab', { name: /missing/ })
+    await waitFor(() => expect(missingTab).toHaveAttribute('data-workflow-activity', 'inactive'))
+    expect(within(missingTab).getByLabelText('Status: Inactive (Expired)')).toBeInTheDocument()
+
     fireEvent.click(screen.getByRole('button', { name: 'Show All' }))
     await waitFor(() => expect(screen.queryByText('Loading timestamps…')).not.toBeInTheDocument())
     const historyList = screen.getByRole('list', { name: 'Previous workflow runs' })
@@ -245,8 +260,14 @@ describe('WorkflowViewSelector', () => {
       .closest('[role="listitem"]') as HTMLElement
     const errorRow = within(historyList).getByText('error')
       .closest('[role="listitem"]') as HTMLElement
-    expect(within(missingRow).getByText('Unknown · Status unavailable')).toBeInTheDocument()
-    expect(within(missingRow).getByText('Timestamp unavailable')).toBeInTheDocument()
+    // #1348: a run whose stored data is gone is expired and inactive, not a
+    // fault, whatever its launch-time `queued` said. The lookup is global by
+    // run id (review b), so a reference without its own cwd is expired too.
+    expect(within(missingRow).getByText('Inactive · Expired')).toBeInTheDocument()
+    expect(within(missingRow).getByText(/stored data is gone/)).toBeInTheDocument()
+    const elsewhereRow = within(historyList).getByText('elsewhere')
+      .closest('[role="listitem"]') as HTMLElement
+    expect(within(elsewhereRow).getByText('Inactive · Expired')).toBeInTheDocument()
     expect(within(errorRow).getByText('Unknown · Status unavailable')).toBeInTheDocument()
     expect(within(errorRow).getByRole('alert')).toHaveTextContent('Could not load details.')
 
@@ -307,4 +328,84 @@ describe('WorkflowViewSelector', () => {
     await waitFor(() => expect(getSnapshot).toHaveBeenCalledTimes(16))
     expect(maxActive).toBe(8)
   })
+
+  // #1440 round-2 review b: the tab check must hold each run's answer on its
+  // own. Batching every visible tab through one Promise.all let a later
+  // transient failure clear a tab already proven Expired, and let one slow
+  // read hold back another tab's answer.
+  describe('selector expiry check', () => {
+    const ref = (runId: string): WorkflowRunReference => ({ runId, cwd: '/repo', status: 'running', workflow: { name: runId } })
+    const tab = (name: string) => screen.getByRole('tab', { name: new RegExp(name) })
+    const mount = (client: WorkflowClient, references: WorkflowRunReference[]) => (
+      <WorkflowClientProvider value={client}>
+        <WorkflowViewSelector references={references} cwd="/repo" selectedRunId={null} onSelect={vi.fn()} />
+      </WorkflowClientProvider>
+    )
+
+    it('keeps a proven Expired tab when a later check of it would fail, and asks each run once', async () => {
+      const calls: string[] = []
+      const client: WorkflowClient = {
+        ...unavailableWorkflowClient,
+        available: true,
+        getSnapshot: vi.fn<WorkflowClient['getSnapshot']>(async ({ runId }) => {
+          calls.push(runId)
+          if (runId === 'run-a' && calls.filter(id => id === 'run-a').length > 1) throw new Error('IPC unavailable')
+          if (runId === 'run-a') return null
+          return { runId, cwd: '/repo', cursor: 0, state: createWorkflowState(runId) }
+        }),
+      }
+      const { rerender } = render(mount(client, [ref('run-a')]))
+      await waitFor(() => expect(tab('run-a')).toHaveAttribute('data-workflow-activity', 'inactive'))
+      rerender(mount(client, [ref('run-a'), ref('run-b')]))
+      await waitFor(() => expect(calls).toContain('run-b'))
+      await new Promise(resolve => setTimeout(resolve, 0))
+      expect(tab('run-a')).toHaveAttribute('data-workflow-activity', 'inactive')
+      expect(calls.filter(id => id === 'run-a')).toHaveLength(1)
+    })
+
+    // #1440 review c: the failure path. A failed read proves nothing (the
+    // tab stays Active) and is forgotten, so a later change asks again.
+    it('keeps a tab active when its read fails, and asks again on a later change', async () => {
+      let failures = 1
+      const calls: string[] = []
+      const client: WorkflowClient = {
+        ...unavailableWorkflowClient,
+        available: true,
+        getSnapshot: vi.fn<WorkflowClient['getSnapshot']>(async ({ runId }) => {
+          calls.push(runId)
+          if (runId === 'run-a' && failures-- > 0) throw new Error('IPC unavailable')
+          return runId === 'run-a' ? null : { runId, cwd: '/repo', cursor: 0, state: createWorkflowState(runId) }
+        }),
+      }
+      const { rerender } = render(mount(client, [ref('run-a')]))
+      await waitFor(() => expect(calls).toEqual(['run-a']))
+      await new Promise(resolve => setTimeout(resolve, 0))
+      expect(tab('run-a')).toHaveAttribute('data-workflow-activity', 'active')
+      rerender(mount(client, [ref('run-a'), ref('run-b')]))
+      await waitFor(() => expect(tab('run-a')).toHaveAttribute('data-workflow-activity', 'inactive'))
+      expect(calls.filter(id => id === 'run-a')).toHaveLength(2)
+    })
+
+    // #1440 review c: a reference that names its own project is looked up
+    // there, not in the session's.
+    it('asks in the reference\'s own project when it names one', async () => {
+      const getSnapshot = vi.fn<WorkflowClient['getSnapshot']>(async () => null)
+      const client: WorkflowClient = { ...unavailableWorkflowClient, available: true, getSnapshot }
+      render(mount(client, [{ ...ref('run-elsewhere'), cwd: '/other-project' }]))
+      await waitFor(() => expect(getSnapshot).toHaveBeenCalled())
+      expect(getSnapshot.mock.calls[0]![0]).toMatchObject({ cwd: '/other-project', runId: 'run-elsewhere' })
+    })
+
+    it('shows one tab expired while another tab\'s read is still pending', async () => {
+      const client: WorkflowClient = {
+        ...unavailableWorkflowClient,
+        available: true,
+        getSnapshot: vi.fn<WorkflowClient['getSnapshot']>(({ runId }) => runId === 'run-slow' ? new Promise(() => {}) : Promise.resolve(null)),
+      }
+      render(mount(client, [ref('run-slow'), ref('run-gone')]))
+      await waitFor(() => expect(tab('run-gone')).toHaveAttribute('data-workflow-activity', 'inactive'))
+      expect(tab('run-slow')).toHaveAttribute('data-workflow-activity', 'active')
+    })
+  })
 })
+
diff --git a/src/renderer/src/features/workflows/ui/WorkflowViewSelector.tsx b/src/renderer/src/features/workflows/ui/WorkflowViewSelector.tsx
index 02909874f..9b1750285 100644
--- a/src/renderer/src/features/workflows/ui/WorkflowViewSelector.tsx
+++ b/src/renderer/src/features/workflows/ui/WorkflowViewSelector.tsx
@@ -1,6 +1,8 @@
 import { useState } from 'react'
 
 import type { WorkflowRunReference } from '../client/WorkflowClient'
+import { useWorkflowClient } from '../client/WorkflowClientContext'
+import { MISSING_RUN, useMissingRunIds } from '../model/missingRun'
 import { workflowRunActivity, workflowRunStatusLabel } from '../model/workflowRunStatus'
 import { WorkflowHistoryDialog } from './WorkflowHistoryDialog'
 
@@ -26,6 +28,7 @@ export function WorkflowViewSelector({
   onSelect: (runId: string | null) => void
 }): React.JSX.Element | null {
   const [historyOpen, setHistoryOpen] = useState(false)
+  const missing = useMissingRunIds(useWorkflowClient(), references, cwd)
   if (references.length === 0) return null
 
   // Vertical tablist keys (plan K5, ledger N7), the SettingsSidebar shape:
@@ -100,7 +103,9 @@ export function WorkflowViewSelector({
 
         {references.map(reference => {
           const selected = selectedRunId === reference.runId
-          const activity = workflowRunActivity(reference.status)
+          // A run whose data is gone is not running, whatever it launched as.
+          const expired = missing.has(reference.runId)
+          const activity = expired ? 'inactive' : workflowRunActivity(reference.status)
           const activityLabel = activity === 'active'
             ? 'Active'
             : activity === 'inactive'
@@ -134,7 +139,7 @@ export function WorkflowViewSelector({
               </span>
               <span className="min-w-0 truncate">{workflowLabel(reference)}</span>
               <span
-                aria-label={`Status: ${activityLabel} (${workflowRunStatusLabel(reference.status)})`}
+                aria-label={`Status: ${activityLabel} (${expired ? MISSING_RUN.label : workflowRunStatusLabel(reference.status)})`}
                 className={`rounded-chip ml-auto shrink-0 border px-1.5 py-0.5 text-[10px] leading-none ${
                   activity === 'active'
                     ? 'border-accent/35 text-accent'
diff --git a/src/renderer/src/features/workspace/commands/sessionCommands.renderer.test.ts b/src/renderer/src/features/workspace/commands/sessionCommands.renderer.test.ts
index a7ea8ecc7..54609cc95 100644
--- a/src/renderer/src/features/workspace/commands/sessionCommands.renderer.test.ts
+++ b/src/renderer/src/features/workspace/commands/sessionCommands.renderer.test.ts
@@ -4,6 +4,7 @@ import type { CommandContext } from '@renderer/features/command-palette/types'
 import type { Workspace } from '@renderer/workspace/workspaceStore'
 import { sessionCommands } from '@renderer/features/workspace/commands/sessionCommands'
 import { oneLaneStage } from '@renderer/workspace/testing/stageFixtures'
+import { DEMOTING_SWITCH_FIDELITY, OPAQUE_ONLY_DUPLICATE_FIDELITY } from '@renderer/workspace/hook/actions/testing/recordedProjectionFidelity'
 
 const originalApiDescriptor = Object.getOwnPropertyDescriptor(window, 'api')
 
@@ -76,6 +77,55 @@ describe('Duplicate Agent command', () => {
     expect(closePalette).toHaveBeenCalledOnce()
   })
 
+  // #927: a duplicate is re-projected, not byte-copied, and can lose content.
+  // Material loss is named on the source pane; the recorded opaque-only Codex
+  // copy stays silent because the placed copy is its own evidence.
+  it.each([
+    ['names material projection loss on the source pane', DEMOTING_SWITCH_FIDELITY, 'Duplicated · history: 19 demoted'],
+    ['stays silent when only opaque records were dropped', OPAQUE_ONLY_DUPLICATE_FIDELITY, null],
+  ] as const)('%s', async (_label, projectionFidelity, toast) => {
+    const duplicateSession = vi.fn().mockResolvedValue({ newProviderSessionId: 'provider-clone', projectionFidelity })
+    Object.defineProperty(window, 'api', { configurable: true, value: { duplicateSession } })
+    const showPaneToast = vi.fn()
+    const workspace = {
+      state: {
+        activeTabId: 'tab-klay',
+        stage: oneLaneStage('source'), pinnedSessionIds: [],
+        sessions: { source: { cwd: '/projects/klay', kind: 'codex', providerSessionId: 'provider-source', projectId: 'tab-klay', joinedAt: 0 } },
+        tabs: [{ id: 'tab-klay' }],
+      },
+      splitFocused: vi.fn().mockResolvedValue(undefined),
+      showPaneToast,
+    } as unknown as Workspace
+    const context = { workspace, ui: { closePalette: vi.fn() }, flags: {} } as unknown as CommandContext
+    const command = sessionCommands.find(candidate => candidate.id === 'duplicate-agent')!
+    await command.run(context)
+    if (toast) expect(showPaneToast).toHaveBeenCalledWith('source', toast, 8000)
+    else expect(showPaneToast).not.toHaveBeenCalled()
+  })
+
+  // #1384 review b/c: the Sessions-row menu's duplicate (explicit target) is
+  // left unplaced and says so in its own toast; the loss rides that toast.
+  it('names material projection loss in the unplaced (row-menu) duplicate toast', async () => {
+    const duplicateSession = vi.fn().mockResolvedValue({ newProviderSessionId: 'provider-clone', projectionFidelity: DEMOTING_SWITCH_FIDELITY })
+    Object.defineProperty(window, 'api', { configurable: true, value: { duplicateSession } })
+    const showPaneToast = vi.fn()
+    const workspace = {
+      state: {
+        activeTabId: 'tab-klay',
+        stage: oneLaneStage('source'), pinnedSessionIds: [],
+        sessions: { source: { cwd: '/projects/klay', kind: 'codex', providerSessionId: 'provider-source', projectId: 'tab-klay', joinedAt: 0 } },
+        tabs: [{ id: 'tab-klay' }],
+      },
+      createDetachedDispatchAgent: vi.fn().mockResolvedValue('clone-pane'),
+      splitFocused: vi.fn(),
+      showPaneToast,
+    } as unknown as Workspace
+    const context = { workspace, target: 'source', ui: { closePalette: vi.fn() }, flags: {} } as unknown as CommandContext
+    await sessionCommands.find(candidate => candidate.id === 'duplicate-agent')!.run(context)
+    expect(showPaneToast).toHaveBeenCalledWith('source', 'Duplicated — the copy is marked new in the Sessions list · history: 19 demoted', 8000)
+  })
+
   it('never hands a clone the root-management grant', async () => {
     const duplicateSession = vi.fn().mockResolvedValue({ newProviderSessionId: 'provider-clone' })
     Object.defineProperty(window, 'api', { configurable: true, value: { duplicateSession } })
diff --git a/src/renderer/src/features/workspace/commands/sessionCommands.ts b/src/renderer/src/features/workspace/commands/sessionCommands.ts
index b8e8281c0..5309139fe 100644
--- a/src/renderer/src/features/workspace/commands/sessionCommands.ts
+++ b/src/renderer/src/features/workspace/commands/sessionCommands.ts
@@ -28,6 +28,7 @@ import {
   ROOT_MANAGEMENT_DOMAIN,
   rootManagementReloadLabels,
 } from '@renderer/features/workspace/lib/rootManagement'
+import { materialProjectionLoss } from '@shared/types/projectionFidelity'
 
 function targetSupportsBuiltInMcpDomain(
   workspace: CommandContext['workspace'],
@@ -821,12 +822,17 @@ export const sessionCommands: CommandDef[] = [
       if (!getProviderFeatures(kind).transcriptDuplicate) return
       if (!isAgentProviderKind(kind) || !meta?.providerSessionId) return
       try {
-        const { newProviderSessionId } = await window.api.duplicateSession({
+        const { newProviderSessionId, projectionFidelity } = await window.api.duplicateSession({
           provider: kind,
           sourceProviderSessionId: meta.providerSessionId,
           cwd: meta.cwd,
         })
         ui.closePalette()
+        // #927: a duplicate is not automatically lossless. The projector
+        // rebuilds the transcript, and a Codex -> Codex copy already drops
+        // opaque records. Only MATERIAL loss is named (see
+        // materialProjectionLoss); the full summary is on the result.
+        const duplicateLoss = materialProjectionLoss(projectionFidelity)
         // Open the clone as a SIBLING pane (vertical split) of the
         // source. Using `workspace.newTab` would push the clone into
         // a new tab and hide the source behind a tab switch — not
@@ -874,9 +880,13 @@ export const sessionCommands: CommandDef[] = [
           // Unplaced means nothing on screen changed, so say where it went.
           // (A targeted pane toast also shows globally while the source is
           // off screen — see targetedCommandContext.)
-          workspace.showPaneToast(sessionId, 'Duplicated — the copy is marked new in the Sessions list', 4000)
+          workspace.showPaneToast(sessionId, `Duplicated — the copy is marked new in the Sessions list${duplicateLoss ? ` · ${duplicateLoss}` : ''}`, duplicateLoss ? 8000 : 4000)
         } else {
           await workspace.splitFocused(kind, continuation)
+          // The placed copy is its own evidence, so a clean duplicate stays
+          // silent here. A lossy one is not a faithful copy, and the source
+          // pane says so (#927).
+          if (duplicateLoss) workspace.showPaneToast(sessionId, `Duplicated · ${duplicateLoss}`, 8000)
         }
       } catch (err) {
         // Surface the failure as a pane toast, not just console.warn. Native
diff --git a/src/renderer/src/features/workspace/ui/ViewPromptsModal.renderer.test.tsx b/src/renderer/src/features/workspace/ui/ViewPromptsModal.renderer.test.tsx
index f64396a2d..195dd4d65 100644
--- a/src/renderer/src/features/workspace/ui/ViewPromptsModal.renderer.test.tsx
+++ b/src/renderer/src/features/workspace/ui/ViewPromptsModal.renderer.test.tsx
@@ -37,6 +37,22 @@ describe('ViewPromptsModal', () => {
     expect(listConversationPrompts).toHaveBeenCalledWith({ provider: 'claude', nativeId: 'native-1', cwd: '/repo/project' })
   })
 
+  // #1306: main now rejects when the conversation file is there but
+  // unreadable (it used to answer "no prompts"). The modal says so in fixed
+  // words, never the IPC text (q22).
+  it('says an unreadable conversation in fixed words, not the IPC text', async () => {
+    Object.defineProperty(window, 'api', { configurable: true, value: {
+      listConversationPrompts: vi.fn(async () => { throw new Error("Error invoking remote method 'conversations:prompts': ConversationPromptsUnreadable: The conversation file could not be read") }),
+    } })
+    const workspace = {
+      state: { sessions: { s: { kind: 'pi', cwd: '/repo/project', providerSessionId: 'native-1' } } },
+      getRuntime: () => ({ entries: [], hasOlderHistory: false, loadingOlderHistory: false }),
+    } as unknown as Workspace
+    render(<ViewPromptsModal open sessionId="s" workspace={workspace} onClose={vi.fn()} />)
+    expect(await screen.findByText("Couldn't read this conversation's prompts.")).toBeInTheDocument()
+    expect(document.body.textContent).not.toContain('Error invoking remote method')
+  })
+
   it('focuses a scroller that is a Tab stop, and closes from one Close ⎋ button', async () => {
     // Plan S8: the read-only viewer's scroller was tabIndex -1, so after
     // tabbing to the footer Shift+Tab could never get back to scrolling; the
diff --git a/src/renderer/src/features/workspace/ui/ViewPromptsModal.tsx b/src/renderer/src/features/workspace/ui/ViewPromptsModal.tsx
index 5461d701b..9e5250221 100644
--- a/src/renderer/src/features/workspace/ui/ViewPromptsModal.tsx
+++ b/src/renderer/src/features/workspace/ui/ViewPromptsModal.tsx
@@ -34,6 +34,9 @@ type Props = {
   onClose: () => void
 }
 
+
+export const PROMPTS_UNREADABLE = "Couldn't read this conversation's prompts."
+
 export function ViewPromptsModal({
   open,
   sessionId,
@@ -67,7 +70,11 @@ export function ViewPromptsModal({
       .catch((error: unknown) => {
         if (cancelled) return
         setFromDisk(null)
-        setLoadError(error instanceof Error && error.message.length > 0 ? error.message : 'Could not read prompts.')
+        // Fixed words (q22, #1306): the rejection is IPC text, and main's
+        // cause can name a path. Main now rejects when the conversation file
+        // is there but unreadable, instead of answering "no prompts".
+        void error
+        setLoadError(PROMPTS_UNREADABLE)
       })
       .finally(() => {
         if (!cancelled) setLoading(false)
diff --git a/src/renderer/src/workspace/control/lifecycle.renderer.test.tsx b/src/renderer/src/workspace/control/lifecycle.renderer.test.tsx
index d1893215b..9a50d3f12 100644
--- a/src/renderer/src/workspace/control/lifecycle.renderer.test.tsx
+++ b/src/renderer/src/workspace/control/lifecycle.renderer.test.tsx
@@ -6,6 +6,7 @@ import { useProviderActions } from '@renderer/workspace/hook/actions/provider'
 import { makeRefs, sessionActionsWithSpawn } from '@renderer/workspace/hook/actions/testing/paneActionsHarness'
 import type { Workspace } from '@renderer/workspace/hook'
 import { lifecycleControlCapabilities } from './lifecycle'
+import { DEMOTING_SWITCH_FIDELITY } from '@renderer/workspace/hook/actions/testing/recordedProjectionFidelity'
 
 const original = useAppStore.getState()
 const originalApi = window.api
@@ -66,7 +67,7 @@ it('reports a domain refusal instead of treating a resolved void transaction as
 
 it('keeps draft edits made during native rewind recoverable by undo', async () => {
   const { invoke, revision, replaceSession, report, refs } = setup()
-  window.api.rewindToPrompt = vi.fn<typeof window.api.rewindToPrompt>().mockResolvedValue({ provider: 'codex', newProviderSessionId: 'rewound-native', newFilePath: '/recorded/rewound.jsonl', promptText: 'Historical prompt', promptImages: [], promptAttachments: [], promptMode: 'prompt', promptTimestamp: null })
+  window.api.rewindToPrompt = vi.fn<typeof window.api.rewindToPrompt>().mockResolvedValue({ provider: 'codex', newProviderSessionId: 'rewound-native', newFilePath: '/recorded/rewound.jsonl', promptText: 'Historical prompt', promptImages: [], promptAttachments: [], promptMode: 'prompt', promptTimestamp: null, projectionFidelity: { profile: 'native-resume' as const, sourceProvider: 'codex', targetProvider: 'codex', providerProfileId: 'test', providerEvidence: {}, counts: { preserved: 0, dropped: 0, demoted: 0, synthesized: 0, repaired: 0, retargeted: 0, opaque: 0 }, codes: [], sourceLinesOmitted: 0 } })
   // The actual replacement contract is independently exercised in
   // sessionReplacementHandoff: this boundary returns its latest carried draft,
   // including edits made after the original lifecycle inspection.
@@ -80,6 +81,19 @@ it('keeps draft edits made during native rewind recoverable by undo', async () =
   expect(useAppStore.getState().workspaceRuntimes.replacement).toMatchObject({ draftInput: 'Historical prompt', pendingRewindUndo: { previousDraftInput: 'Edited during replacement' } })
 })
 
+// #1384 review c / steering q90: a control caller that rewinds an agent reads
+// the projection report from operations.read. Before, the lifecycle result
+// helper kept only the IDs, and the rewind action dropped the report before
+// anything could inspect it.
+it('relays the rewound copy\'s projection fidelity to the control result', async () => {
+  const { invoke, revision, report } = setup()
+  window.api.rewindToPrompt = vi.fn<typeof window.api.rewindToPrompt>().mockResolvedValue({ provider: 'codex', newProviderSessionId: 'rewound-native', newFilePath: '/recorded/rewound.jsonl', promptText: 'Historical prompt', promptImages: [], promptAttachments: [], promptMode: 'prompt', promptTimestamp: null, projectionFidelity: DEMOTING_SWITCH_FIDELITY })
+  await invoke('agents.rewind', { sessionId: 'source', revision: await revision(), address: { provider: 'codex', sessionId: 'native-source', line: 1 } })
+  await vi.waitFor(() => expect(report).toHaveBeenCalledWith(expect.objectContaining({ capabilityId: 'operations.finish', input: {
+    callId: 'original-call', result: { ok: true, value: { sourceSessionId: 'source', newSessionId: 'replacement', status: 'completed', projectionFidelity: DEMOTING_SWITCH_FIDELITY } },
+  } })))
+})
+
 it('refuses to rewind a native terminal agent (Pi), whose TUI has no composer for the rewound prompt', async () => {
   const { invoke, revision, replaceSession } = setup()
   // Restored kind-only, as the catalog and switches create Pi panes.
diff --git a/src/renderer/src/workspace/control/lifecycle.ts b/src/renderer/src/workspace/control/lifecycle.ts
index 2fce452fc..9a1a93ada 100644
--- a/src/renderer/src/workspace/control/lifecycle.ts
+++ b/src/renderer/src/workspace/control/lifecycle.ts
@@ -11,6 +11,7 @@ import { AGENT_PROVIDER_KINDS, effectiveProviderRuntime, isAgentProviderKind, pr
 import { getProviderFeatures } from '@providers/shared/featureCapabilities'
 import { resolveTabSessions } from '@renderer/workspace/queries'
 import { startControlTask } from './startTask'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity'
 
 const target = z.object({ sessionId: z.string().min(1).describe('Exact Agent Code sessionId from agents.search; not the native transcript ID.') }).strict()
 const revision = z.string().describe('Revision from agents.lifecycleRead. Refresh it after any lifecycle or draft change.')
@@ -48,10 +49,19 @@ export function lifecycleControlCapabilities(getWorkspace: () => Workspace) {
     if (current.revision !== input.revision) throw new ControlError('stale_cursor', 'Agent lifecycle or draft changed; read agents.lifecycleRead again')
     return current
   }
-  const result = (value: { status: string; reason?: string; message?: string; newSessionId?: string }, sourceSessionId: string) => {
+  // `projectionFidelity` is relayed when the operation re-projected a
+  // transcript (switch, rewind; #927). Before, this helper kept only the IDs,
+  // so a control caller that switched or rewound an agent had no way to see
+  // what the projector dropped or demoted; the UI toast was the only record.
+  const result = (value: { status: string; reason?: string; message?: string; newSessionId?: string; projectionFidelity?: NativeProjectionFidelity | null }, sourceSessionId: string) => {
     if (value.status === 'skipped') throw new ControlError('unavailable', value.reason ?? 'Operation declined')
     if (value.status === 'failed' || !value.newSessionId) throw new ControlError('failed', value.message ?? 'Replacement was not observed', 'unknown')
-    return { sourceSessionId, newSessionId: value.newSessionId, status: value.status }
+    return {
+      sourceSessionId,
+      newSessionId: value.newSessionId,
+      status: value.status,
+      ...(value.projectionFidelity ? { projectionFidelity: value.projectionFidelity } : {}),
+    }
   }
   return [
     defineCapability({ id: 'agents.resume', title: 'Resume a native session in a project', execution: 'window', effect: 'mutation', completion: 'accepted', target: { kind: 'project', field: 'tabId' },
@@ -73,8 +83,8 @@ export function lifecycleControlCapabilities(getWorkspace: () => Workspace) {
         })
       },
     }),
-    defineCapability({ id: 'agents.duplicate', title: 'Branch an exact agent conversation', execution: 'window', effect: 'mutation', completion: 'accepted', target: { kind: 'session', field: 'sessionId' },
-      description: 'Copy an idle native conversation to a new native identity and create an agent in the chosen project. Preserves provider/runtime and enabled built-in domain names; leaves the source and its draft intact. Requires a fresh lifecycle revision and an explicit target project/anchor in the same window. Use operations.read for both new IDs, then agents.show to put the copy in a lane. It fills the captured focused lane only when that lane is empty (selectCreated:false never places it). A failed placement can leave a native transcript copy; do not blindly retry unknown outcomes.',
+    defineCapability({ id: 'agents.duplicate', title: 'Branch an agent conversation', execution: 'window', effect: 'mutation', completion: 'accepted', target: { kind: 'session', field: 'sessionId' },
+      description: 'Copy an idle native conversation to a new native identity and create an agent in the chosen project. Preserves provider/runtime and enabled built-in domain names; leaves the source and its draft intact. Requires a fresh lifecycle revision and an explicit target project/anchor in the same window. Use operations.read for both new IDs and the projectionFidelity of the copy (what re-projecting the transcript preserved, dropped or demoted; a copy is not byte-exact), then agents.show to put the copy in a lane. It fills the captured focused lane only when that lane is empty (selectCreated:false never places it). A failed placement can leave a native transcript copy; do not blindly retry unknown outcomes.',
       input: target.extend({ revision, tabId: z.string(), anchorSessionId: z.string(), selectCreated: z.boolean().default(true).describe('False preserves the active tab and all lane selections.') }), output: accepted,
       handler: (input, context) => {
         const check = () => {
@@ -96,7 +106,7 @@ export function lifecycleControlCapabilities(getWorkspace: () => Workspace) {
           const newSessionId = await getWorkspace().createDetachedSession({ kind: value.provider, providerRuntime: meta.providerRuntime },
             { tabId: input.tabId, anchorSessionId: input.anchorSessionId }, { cwd: value.cwd, resumeSessionId: clone.newProviderSessionId, builtInMcpOverrides: clonedMcpOverrides(meta) }, { selectCreated: input.selectCreated })
           if (!newSessionId) throw new ControlError('failed', `Native copy ${clone.newProviderSessionId} exists but no placement was committed`, 'unknown')
-          return { sourceSessionId: input.sessionId, newSessionId, nativeSessionId: clone.newProviderSessionId }
+          return { sourceSessionId: input.sessionId, newSessionId, nativeSessionId: clone.newProviderSessionId, projectionFidelity: clone.projectionFidelity }
         })
       },
     }),
@@ -107,7 +117,7 @@ export function lifecycleControlCapabilities(getWorkspace: () => Workspace) {
       handler: ({ sessionId }) => inspect(sessionId),
     }),
     defineCapability({ id: 'agents.switchProvider', title: 'Switch an exact agent provider', execution: 'window', effect: 'mutation', completion: 'accepted', target: { kind: 'session', field: 'sessionId' },
-      description: 'Move an observed agent to one of agents.lifecycleRead switchChoices through the normal translation, capacity/compaction and replacement transaction. May open a confirmation or take minutes. Returns a task callId; use operations.read for the new Agent Code session ID or failure. Draft and supported internal MCP-domain continuity follow the ordinary UI operation. Never assume the source ID remains valid.',
+      description: 'Move an observed agent to one of agents.lifecycleRead switchChoices through the normal translation, capacity/compaction and replacement transaction. May open a confirmation or take minutes. Returns a task callId; use operations.read for the new Agent Code session ID, the projectionFidelity summary (what the projector preserved, dropped or demoted), or failure. Draft and supported internal MCP-domain continuity follow the ordinary UI operation. Never assume the source ID remains valid.',
       input: target.extend({ revision, provider: z.enum(AGENT_PROVIDER_KINDS), runtime: z.enum(['terminal']).optional().describe('Supply only when the chosen switchChoices entry declares this runtime; omit for structured rendering.') }), output: accepted,
       handler: (input, context) => {
         const current = guard(input)
@@ -125,7 +135,7 @@ export function lifecycleControlCapabilities(getWorkspace: () => Workspace) {
       },
     }),
     defineCapability({ id: 'agents.rewind', title: 'Rewind an exact agent to a native prompt', execution: 'window', effect: 'mutation', completion: 'accepted', target: { kind: 'session', field: 'sessionId' },
-      description: 'Create a new native transcript ending before an exact prompt address from nativeHistory.prompts, and replace this idle agent in place. The original transcript remains intact. The selected historical prompt becomes the new unsent draft, replacing the current draft; undoRewind can restore the prior conversation/draft until the next submission. First read agents.lifecycleRead. Use operations.read for the final newSessionId; acceptance alone is not completion.',
+      description: 'Create a new native transcript ending before an exact prompt address from nativeHistory.prompts, and replace this idle agent in place. The original transcript remains intact. The selected historical prompt becomes the new unsent draft, replacing the current draft; undoRewind can restore the prior conversation/draft until the next submission. First read agents.lifecycleRead. Use operations.read for the final newSessionId and the projectionFidelity of the rewound copy; acceptance alone is not completion.',
       input: target.extend({ revision, address: address.describe('Exact address from nativeHistory.prompts for this native session; never infer line numbers from rendered feed rows.') }), output: accepted,
       handler: (input, context) => {
         const check = () => { const value = guard(input); if (!value.nativeSessionId || value.processActive) throw new ControlError('unavailable', 'Rewind requires an idle resumable agent')
diff --git a/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.renderer.test.ts b/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.renderer.test.ts
index cb6090dcb..27327fa70 100644
--- a/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.renderer.test.ts
+++ b/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.renderer.test.ts
@@ -6,6 +6,7 @@ import type { WorkspaceRefs } from '@renderer/workspace/hook/refs'
 import type { SessionActions } from '@renderer/workspace/hook/actions/session'
 import type { ProviderSwitchBatch } from '@renderer/workspace/types'
 import { useBulkProviderSwitchActions } from '@renderer/workspace/hook/actions/bulkProviderSwitch'
+import { DEMOTING_SWITCH_FIDELITY } from '@renderer/workspace/hook/actions/testing/recordedProjectionFidelity'
 
 const { switchAgentProvider } = vi.hoisted(() => ({ switchAgentProvider: vi.fn() }))
 // WHY the constant is restated here instead of pulled through `importOriginal`:
@@ -260,6 +261,19 @@ describe('bulk switch reporting', () => {
     expect(toastDurations[0]).toBe(10_000)
   })
 
+  // #927: a return whose fit shrank nothing can still be a lossy projection.
+  // The recorded Claude -> Codex summary demotes 19 entries with a null
+  // shrinkSummary; before #927 the batch toasted it as clean.
+  it('surfaces projection loss even when nothing was shrunk', async () => {
+    switchAgentProvider.mockResolvedValue({ status: 'switched', shrinkSummary: null, projectionFidelity: DEMOTING_SWITCH_FIDELITY })
+    const { result, toasts, toastDurations } = harness(batchOf('a'))
+
+    await result.current.returnLastProviderSwitchBatch()
+
+    expect(toasts[0]).toContain('history: 19 demoted')
+    expect(toastDurations[0]).toBe(10_000)
+  })
+
   it('keeps the default duration when nothing was lost', async () => {
     switchAgentProvider.mockResolvedValue({ status: 'switched', shrinkSummary: null })
     const { result, toastDurations } = harness(batchOf('a'))
@@ -273,6 +287,23 @@ describe('bulk switch reporting', () => {
 // #1271: a batch holds the app (the modal locks input) for up to five minutes
 // per agent. A stop requested during the batch ends it after the agent in
 // flight, and the summary says what was not attempted.
+// #1384 review b/c: the FORWARD batch has no per-pane toast, so its summary
+// note is that flow's only disclosure of projection loss.
+describe('switchAgentsToProvider projection loss', () => {
+  it('names the loss a native (unshrunk) switch reported', async () => {
+    const { result, state, toasts, toastDurations } = harness(null)
+    ;(state.sessions as Record<string, unknown>).a = { cwd: '/recorded', kind: 'claude', title: 'a' }
+    switchAgentProvider.mockResolvedValue({
+      status: 'switched', strategy: 'native', shrinkSummary: null, newSessionId: 'a-new', projectionFidelity: DEMOTING_SWITCH_FIDELITY,
+    })
+    await result.current.switchAgentsToProvider(['a'] as never, 'codex', {
+      allowSourceTurns: false, compactOnArrival: false, sourceCompactionConfirmed: false,
+    })
+    expect(toasts.at(-1)).toContain('history: 19 demoted')
+    expect(toastDurations.at(-1)).toBe(10_000)
+  })
+})
+
 describe('switchAgentsToProvider stop', () => {
   it('stops before the next agent and reports the rest as not attempted', async () => {
     const { result, state, toasts } = harness(null)
diff --git a/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.ts b/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.ts
index a57997e54..c9cb50f59 100644
--- a/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.ts
+++ b/src/renderer/src/workspace/hook/actions/bulkProviderSwitch.ts
@@ -10,6 +10,7 @@ import type { SessionActions } from '@renderer/workspace/hook/actions/session'
 import { LOSSY_SWITCH_TOAST_MS, switchAgentProvider } from '@renderer/workspace/hook/actions/providerSwitchCore'
 import type { SwitchStrategy } from '@renderer/workspace/hook/actions/providerSwitchCore'
 import { pluralAgents } from '@renderer/features/workspace/lib/sessionDisplay'
+import { materialProjectionLoss } from '@shared/types/projectionFidelity'
 
 // Bulk provider switch + remembered-batch return.
 //
@@ -211,6 +212,10 @@ export function useBulkProviderSwitchActions(
         } else if (meta && originalKind) {
           counts[result.strategy] += 1
           if (result.shrinkSummary) notes.add(result.shrinkSummary)
+          // #927: projection loss is reported beside the shrink note, not
+          // folded into the strategy; see the single-pane toast in provider.ts.
+          const loss = materialProjectionLoss(result.projectionFidelity)
+          if (loss) notes.add(loss)
           switched.push({
             sessionId: result.newSessionId,
             cwd: meta.cwd,
@@ -320,6 +325,8 @@ export function useBulkProviderSwitchActions(
       if (result.status === 'switched') {
         returned += 1
         if (result.shrinkSummary) notes.add(result.shrinkSummary)
+        const loss = materialProjectionLoss(result.projectionFidelity)
+        if (loss) notes.add(loss)
       } else if (result.status === 'failed') {
         failed += 1
         notes.add(result.message)
diff --git a/src/renderer/src/workspace/hook/actions/provider.projectionLoss.renderer.test.tsx b/src/renderer/src/workspace/hook/actions/provider.projectionLoss.renderer.test.tsx
new file mode 100644
index 000000000..262efac90
--- /dev/null
+++ b/src/renderer/src/workspace/hook/actions/provider.projectionLoss.renderer.test.tsx
@@ -0,0 +1,100 @@
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@renderer/app-state/store'
+import { emptyRuntime } from '@renderer/session-runtime/state'
+import { makeRefs, sessionActionsWithSpawn } from '@renderer/workspace/hook/actions/testing/paneActionsHarness'
+import { DEMOTING_SWITCH_FIDELITY } from '@renderer/workspace/hook/actions/testing/recordedProjectionFidelity'
+
+// #927: the single-pane switch toast names the projector's material loss.
+// The transaction itself is mocked: this pins how the pane TELLS the user,
+// using a real summary copied from a recorded projection (see
+// recordedProjectionFidelity). The projection itself is pinned in main's
+// projectionFidelity.system.test.
+const { switchAgentProvider } = vi.hoisted(() => ({ switchAgentProvider: vi.fn() }))
+vi.mock('@renderer/workspace/hook/actions/providerSwitchCore', async importOriginal => ({
+  ...await importOriginal<typeof import('@renderer/workspace/hook/actions/providerSwitchCore')>(),
+  switchAgentProvider,
+}))
+
+import { useProviderActions } from '@renderer/workspace/hook/actions/provider'
+import { LOSSY_SWITCH_TOAST_MS } from '@renderer/workspace/hook/actions/providerSwitchCore'
+
+const original = useAppStore.getState()
+const originalApi = window.api
+afterEach(() => {
+  cleanup()
+  useAppStore.setState(original, true)
+  window.api = originalApi
+  switchAgentProvider.mockReset()
+})
+
+function setup() {
+  useAppStore.setState({
+    workspaceState: {
+      ...original.workspaceState,
+      activeTabId: 'project',
+      tabs: [{ id: 'project', title: 'Project' }],
+      sessions: { source: { kind: 'claude', cwd: '/source', providerSessionId: 'native-source', projectId: 'project', joinedAt: 0 } },
+    },
+    workspaceRuntimes: { source: emptyRuntime() },
+  })
+  const refs = makeRefs(useAppStore.getState().workspaceState)
+  refs.latestRuntimesRef.current = useAppStore.getState().workspaceRuntimes
+  const showPaneToast = vi.fn()
+  const mounted = renderHook(() => useProviderActions(
+    refs,
+    useAppStore.getState().setWorkspaceRuntimes,
+    showPaneToast,
+    sessionActionsWithSpawn(vi.fn(), { replaceSession: vi.fn().mockResolvedValue('replacement') } as never),
+  ))
+  return { mounted, showPaneToast }
+}
+
+it('names projection loss on a native (unshrunk) switch, for long enough to read', async () => {
+  switchAgentProvider.mockResolvedValue({
+    status: 'switched', newSessionId: 'target', targetKind: 'codex', strategy: 'native', shrinkSummary: null,
+    projectionFidelity: DEMOTING_SWITCH_FIDELITY,
+  })
+  const { mounted, showPaneToast } = setup()
+  await act(async () => { await mounted.result.current.switchSessionProvider('source', 'codex') })
+  expect(showPaneToast).toHaveBeenCalledWith('target', expect.stringMatching(/^Switched to .+ · history: 19 demoted$/), LOSSY_SWITCH_TOAST_MS)
+})
+
+it('keeps a lossless switch quiet', async () => {
+  switchAgentProvider.mockResolvedValue({
+    status: 'switched', newSessionId: 'target', targetKind: 'codex', strategy: 'native', shrinkSummary: null, projectionFidelity: null,
+  })
+  const { mounted, showPaneToast } = setup()
+  await act(async () => { await mounted.result.current.switchSessionProvider('source', 'codex') })
+  expect(showPaneToast).toHaveBeenCalledWith('target', expect.not.stringContaining('history'), undefined)
+})
+
+// #1384 review a / steering q90: PaneToast clamps to three lines. A recorded
+// oversized switch's shrink summary is a long sentence, so the loss goes
+// BEFORE it rather than trailing out of sight.
+it('puts projection loss before a long shrink summary', async () => {
+  switchAgentProvider.mockResolvedValue({
+    status: 'switched', newSessionId: 'target', targetKind: 'codex', strategy: 'shrunk',
+    shrinkSummary: '1 attachment omitted, 130 oldest entries dropped (17k → 13k chars)',
+    projectionFidelity: DEMOTING_SWITCH_FIDELITY,
+  })
+  const { mounted, showPaneToast } = setup()
+  await act(async () => { await mounted.result.current.switchSessionProvider('source', 'codex') })
+  const message = showPaneToast.mock.calls.at(-1)![1] as string
+  expect(message.indexOf('history: 19 demoted')).toBeGreaterThan(0)
+  expect(message.indexOf('history: 19 demoted')).toBeLessThan(message.indexOf('shrunk'))
+})
+
+// #1384 review c: a rewind re-projects the kept prefix, and its toast names
+// material loss first, like the switch toast.
+it('names projection loss in the rewind toast', async () => {
+  const { mounted, showPaneToast } = setup()
+  window.api = { ...window.api, rewindToPrompt: vi.fn().mockResolvedValue({
+    provider: 'claude', newProviderSessionId: 'rewound-native', newFilePath: '/recorded/rewound.jsonl', promptText: 'Earlier', promptImages: [],
+    promptAttachments: [], promptMode: 'prompt', promptTimestamp: null, projectionFidelity: DEMOTING_SWITCH_FIDELITY,
+  }) } as typeof window.api
+  await act(async () => {
+    await mounted.result.current.rewindSessionToPrompt('source', { provider: 'claude', sessionId: 'native-source', line: 1, uuid: 'u' } as never)
+  })
+  expect(showPaneToast).toHaveBeenCalledWith('replacement', 'Rewound to prompt · history: 19 demoted - Undo Rewind available until next submit', 6000)
+})
diff --git a/src/renderer/src/workspace/hook/actions/provider.ts b/src/renderer/src/workspace/hook/actions/provider.ts
index 5293fee53..0490b8592 100644
--- a/src/renderer/src/workspace/hook/actions/provider.ts
+++ b/src/renderer/src/workspace/hook/actions/provider.ts
@@ -1,4 +1,5 @@
 import { describeRewindAttachmentLoss } from '@renderer/workspace/hook/actions/rewindAttachmentLoss'
+import { materialProjectionLoss, type NativeProjectionFidelity } from '@shared/types/projectionFidelity'
 import { sessionMcpOverrides } from '@renderer/workspace/mcpDomains'
 import { getRendererProviderCapabilities } from '@providers/registry.renderer.capabilities'
 import { tldrIdentityForSession } from '@renderer/features/tldr/identity'
@@ -38,7 +39,14 @@ import { providerChoiceLabel } from '@renderer/workspace/providerChoices'
 // Promise<void> cannot distinguish a declined operation from a replacement;
 // the transport must not infer success from a toast or a changed session census.
 export type AgentLifecycleResult =
-  | { status: 'completed'; sourceSessionId: SessionId; newSessionId: SessionId }
+  | {
+      status: 'completed'
+      sourceSessionId: SessionId
+      newSessionId: SessionId
+      /** Present for a rewind, which re-projects the transcript (#927). The
+       *  control plane relays it so an external caller can inspect it. */
+      projectionFidelity?: NativeProjectionFidelity
+    }
   | { status: 'skipped'; reason: string }
   | { status: 'failed'; message: string }
 
@@ -96,9 +104,22 @@ export function useProviderActions(
       // lossless case should not add noise to every switch; the two lossy
       // strategies name themselves, and `shrunk` carries the one line saying
       // what the ladder had to remove.
-      const note = result.strategy === 'native'
-        ? ''
-        : ` · ${result.strategy}${result.shrinkSummary ? ` (${result.shrinkSummary})` : ''}`
+      // #927: the projector's own loss rides the same toast. It is independent
+      // of the strategy: a `native` fit (nothing shrunk) can still drop or
+      // demote content the target cannot carry (Codex -> Claude drops foreign
+      // reasoning and developer messages on every recorded sequence), so
+      // before this a lossy switch could toast as a clean one.
+      //
+      // The loss goes FIRST (#1384 review a, steering q90): PaneToast clamps
+      // to three lines, and a shrink summary can be a long sentence ("1
+      // attachment omitted, 130 oldest entries dropped (17k -> 13k chars)"),
+      // which pushed a trailing "history: 132 demoted" out of sight on a
+      // recorded oversized switch.
+      const loss = materialProjectionLoss(result.projectionFidelity)
+      const note = (loss ? ` · ${loss}` : '')
+        + (result.strategy === 'native'
+          ? ''
+          : ` · ${result.strategy}${result.shrinkSummary ? ` (${result.shrinkSummary})` : ''}`)
       showPaneToast(
         result.newSessionId,
         `Switched to ${providerChoiceLabel(result.targetKind, targetProviderRuntime)}${note}`,
@@ -308,11 +329,16 @@ export function useProviderActions(
         const attachmentLoss = describeRewindAttachmentLoss(result.promptAttachments, {
           composerCarriesImages: getRendererProviderCapabilities(kind).supportsImageAttachments,
         })
+        // #927: a rewind re-projects the kept prefix and can lose content too.
+        // Named first, like the switch toast, so the three-line clamp cannot
+        // hide it behind the attachment sentence.
+        const projectionLoss = materialProjectionLoss(result.projectionFidelity)
+        const rewound = projectionLoss ? `Rewound to prompt · ${projectionLoss}` : 'Rewound to prompt'
         showPaneToast(
           newSessionId,
           attachmentLoss
-            ? `Rewound to prompt, but ${attachmentLoss} Undo Rewind available until next submit`
-            : 'Rewound to prompt - Undo Rewind available until next submit',
+            ? `${rewound}, but ${attachmentLoss} Undo Rewind available until next submit`
+            : `${rewound} - Undo Rewind available until next submit`,
           // WHY a longer toast for the loss case (#1100 review): the default is
           // 2000 ms and `PaneToast` clamps to three lines, which for a sentence
           // naming two files and two reasons is a message nobody finishes
@@ -320,9 +346,9 @@ export function useProviderActions(
           // are 5-6 s (a copied command, a saved path), and this is the same
           // kind of thing. The ordinary success toast keeps the default,
           // because "it worked" needs no reading time.
-          attachmentLoss ? 6000 : undefined,
+          attachmentLoss || projectionLoss ? 6000 : undefined,
         )
-        return { status: 'completed', sourceSessionId, newSessionId }
+        return { status: 'completed', sourceSessionId, newSessionId, projectionFidelity: result.projectionFidelity }
       } catch (err) {
         const message =
           err instanceof Error && err.message.length > 0
diff --git a/src/renderer/src/workspace/hook/actions/providerSwitchCore.renderer.test.ts b/src/renderer/src/workspace/hook/actions/providerSwitchCore.renderer.test.ts
index 0bf95fef9..53e0d15da 100644
--- a/src/renderer/src/workspace/hook/actions/providerSwitchCore.renderer.test.ts
+++ b/src/renderer/src/workspace/hook/actions/providerSwitchCore.renderer.test.ts
@@ -4,6 +4,7 @@ import type { WorkspaceSetRuntimes } from '@renderer/workspace/hook/context'
 import type { WorkspaceRefs } from '@renderer/workspace/hook/refs'
 import type { SessionActions } from '@renderer/workspace/hook/actions/session'
 import { switchAgentProvider } from '@renderer/workspace/hook/actions/providerSwitchCore'
+import { DEMOTING_SWITCH_FIDELITY } from '@renderer/workspace/hook/actions/testing/recordedProjectionFidelity'
 
 const originalApiDescriptor = Object.getOwnPropertyDescriptor(window, 'api')
 
@@ -197,6 +198,8 @@ describe('switchAgentProvider', () => {
       // translated at all (#821).
       strategy: 'native',
       shrinkSummary: null,
+      // Nothing was projected, so there is no report to carry (#927).
+      projectionFidelity: null,
     })
 
     expect(switchProvider).toHaveBeenCalledWith(expect.objectContaining({
@@ -365,6 +368,7 @@ describe('switchAgentProvider', () => {
       truncatedBeforeSwitch: false,
       strategy: 'raw',
       shrinkSummary: null,
+      projectionFidelity: DEMOTING_SWITCH_FIDELITY,
     })
     const replaceSession = vi.fn().mockResolvedValue('target-pane')
     const compactAfterSwitch = vi.fn().mockResolvedValue({ ok: false, message: 'Claude did not accept /compact: composer unavailable' })
@@ -422,7 +426,9 @@ describe('switchAgentProvider', () => {
     })
 
     // The switch itself succeeded and says nothing about the follow-up.
-    expect(result).toMatchObject({ status: 'switched', newSessionId: 'target-pane' })
+    // #1384 review b/c: the populated report main returned reaches every
+    // renderer consumer through this relay (an `undefined` relay survived).
+    expect(result).toMatchObject({ status: 'switched', newSessionId: 'target-pane', projectionFidelity: DEMOTING_SWITCH_FIDELITY })
     // Addressed to the NEW pane, with the target transcript the switch wrote.
     expect(compactAfterSwitch).toHaveBeenCalledWith({
       sessionId: 'target-pane',
diff --git a/src/renderer/src/workspace/hook/actions/providerSwitchCore.ts b/src/renderer/src/workspace/hook/actions/providerSwitchCore.ts
index c52a83248..58101fad4 100644
--- a/src/renderer/src/workspace/hook/actions/providerSwitchCore.ts
+++ b/src/renderer/src/workspace/hook/actions/providerSwitchCore.ts
@@ -13,6 +13,7 @@ import {
   enabledProviderSwitchChoices,
 } from '@renderer/workspace/providerChoices'
 import { enabledAgentProviderKindsSnapshot } from '@renderer/features/providers/store'
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity'
 
 // Single-agent provider switch — the shared core.
 //
@@ -48,6 +49,9 @@ export type SwitchAgentProviderResult =
       strategy: SwitchStrategy
       /** One human-readable line describing what `shrunk` cost, else null. */
       shrinkSummary: string | null
+      /** The projector's report, summarized (#927); null when nothing was
+       *  projected (an empty source is replaced without a transcript). */
+      projectionFidelity: NativeProjectionFidelity | null
     }
   | { status: 'skipped'; reason: string }
   | { status: 'failed'; message: string }
@@ -221,7 +225,7 @@ export async function switchAgentProvider(params: {
     // `native` is the honest strategy for an empty source: no transcript was
     // translated, so nothing could be lost. Reporting null instead would make
     // the batch tally under-count agents that switched perfectly well.
-    return { status: 'switched', newSessionId, targetKind, strategy: 'native', shrinkSummary: null }
+    return { status: 'switched', newSessionId, targetKind, strategy: 'native', shrinkSummary: null, projectionFidelity: null }
   }
 
   const sourceRuntime = refs.latestRuntimesRef.current[sessionId]
@@ -446,6 +450,7 @@ export async function switchAgentProvider(params: {
       targetKind: result.targetKind,
       strategy: result.strategy,
       shrinkSummary: result.shrinkSummary,
+      projectionFidelity: result.projectionFidelity,
     }
   } catch (err) {
     const message =
diff --git a/src/renderer/src/workspace/hook/actions/testing/recordedProjectionFidelity.ts b/src/renderer/src/workspace/hook/actions/testing/recordedProjectionFidelity.ts
new file mode 100644
index 000000000..36505c0f2
--- /dev/null
+++ b/src/renderer/src/workspace/hook/actions/testing/recordedProjectionFidelity.ts
@@ -0,0 +1,45 @@
+import type { NativeProjectionFidelity } from '@shared/types/projectionFidelity'
+
+// Renderer tests cannot run the parser's projectors, so these are the REAL
+// summaries, copied from `summarizeProjectionReport` over the recorded Stage 0
+// sequences (projected to Codex 0.157.1 as projectionFidelity.system.test.ts
+// does) (#927). Only `sourceLines` is trimmed to two per row. Counts, codes,
+// profile and evidence are exactly as produced.
+
+/** claude-sequence-oversized -> Codex: nothing shrunk, 19 entries demoted. */
+export const DEMOTING_SWITCH_FIDELITY: NativeProjectionFidelity = {
+  profile: 'native-resume',
+  sourceProvider: 'claude',
+  targetProvider: 'codex',
+  providerProfileId: 'codex-rollout-source-8035cb03',
+  providerEvidence: { sourceCommit: '8035cb03f1a5061d0342cb8fa3a10a18068ca683' },
+  counts: { preserved: 67, dropped: 0, demoted: 19, synthesized: 2, repaired: 0, retargeted: 0, opaque: 0 },
+  codes: [
+    { kind: 'synthesized', code: 'native-resume.session-meta.synthesized', count: 1, sourceLines: [] },
+    { kind: 'synthesized', code: 'native-resume.turn-framing.synthesized', count: 1, sourceLines: [] },
+    { kind: 'preserved', code: 'native-resume.message.preserved', count: 6, sourceLines: [0, 14] },
+    { kind: 'preserved', code: 'native-resume.reasoning.preserved', count: 9, sourceLines: [1, 8] },
+    { kind: 'demoted', code: 'native-resume.reasoning.encrypted-content-demoted', count: 9, sourceLines: [1, 8] },
+    { kind: 'preserved', code: 'native-resume.tool-call.preserved', count: 26, sourceLines: [2, 4] },
+    { kind: 'preserved', code: 'native-resume.tool-result.preserved', count: 26, sourceLines: [3, 6] },
+    { kind: 'demoted', code: 'native-resume.tool-result.error-status-demoted', count: 10, sourceLines: [3, 6] },
+  ],
+  sourceLinesOmitted: 12,
+}
+
+/** codex-sequence-compaction -> Codex (a duplicate): only an opaque record
+ *  dropped, which is not material. */
+export const OPAQUE_ONLY_DUPLICATE_FIDELITY: NativeProjectionFidelity = {
+  profile: 'native-resume',
+  sourceProvider: 'codex',
+  targetProvider: 'codex',
+  providerProfileId: 'codex-rollout-source-8035cb03',
+  providerEvidence: { sourceCommit: '8035cb03f1a5061d0342cb8fa3a10a18068ca683' },
+  counts: { preserved: 1, dropped: 1, demoted: 0, synthesized: 1, repaired: 0, retargeted: 0, opaque: 0 },
+  codes: [
+    { kind: 'synthesized', code: 'native-resume.session-meta.synthesized', count: 1, sourceLines: [] },
+    { kind: 'dropped', code: 'native-resume.opaque.dropped', count: 1, sourceLines: [0] },
+    { kind: 'preserved', code: 'native-resume.compaction.preserved', count: 1, sourceLines: [1] },
+  ],
+  sourceLinesOmitted: 0,
+}
diff --git a/src/renderer/src/workspace/hook/actions/undoClose.ts b/src/renderer/src/workspace/hook/actions/undoClose.ts
index bea5532a8..12a350a1c 100644
--- a/src/renderer/src/workspace/hook/actions/undoClose.ts
+++ b/src/renderer/src/workspace/hook/actions/undoClose.ts
@@ -1,3 +1,4 @@
+import { tldrIdentityForSession } from '@renderer/features/tldr/identity'
 import { carryOrchestrationParents, carryWorkflowRuns, handOverGoalLoops, stopGoalLoops } from '@renderer/workspace/hook/actions/successorCarry'
 import { carriedRelationships } from '@renderer/workspace/idRemap'
 import { sessionDisplayTitle } from '@renderer/workspace/sessionDisplayTitle'
@@ -195,7 +196,7 @@ export function useUndoCloseAction(
   // when main refused because the cwd is gone (see RespawnOutcome). `spawned`
   // says whether a backend now exists that a bail-out must kill.
   const respawn = useCallback(
-    async (meta: SessionMeta): Promise<RespawnOutcome> => {
+    async (meta: SessionMeta, closedSessionId: SessionId): Promise<RespawnOutcome> => {
       const kind: SessionKind = meta.kind ?? DEFAULT_PROVIDER
       if (kind === 'extension-view') {
         return { sessionId: crypto.randomUUID() as SessionId, spawned: false }
@@ -217,7 +218,12 @@ export function useUndoCloseAction(
           // undo-restored transcript silently lose tools. The effective list is
           // deliberately not restored — the restored session is a NEW provider
           // process, so it resolves those choices against current Settings.
-          tldrIdentity: meta.tldrIdentity,
+          // The same rule as Reload Agents (#1347): an identity can be
+          // DERIVED (reporting domains on, no explicit field), and then it
+          // is the closed session id. Passing only the explicit field gave
+          // such an agent a fresh identity: new TLDR/Goal claims, and its
+          // analytics split in two.
+          tldrIdentity: tldrIdentityForSession(closedSessionId, meta),
           builtInMcpOverrides: sessionMcpOverrides(meta),
         })
         return { sessionId, spawned: true }
@@ -260,7 +266,7 @@ export function useUndoCloseAction(
       if (projectId === undefined) return 'stale'
       if (!refs.stateRef.current.tabs.some(tab => tab.id === projectId)) return 'stale'
 
-      const respawned = await respawn(meta)
+      const respawned = await respawn(meta, entry.sessionId)
       if (respawned === 'folder-missing') {
         // WHY 'stale' and not 'retryable-failure' (#1264 R2-1): the entry
         // would be pushed back and re-fail forever — a worktree removed after
@@ -374,7 +380,7 @@ export function useUndoCloseAction(
       // missing session could corrupt, so the gentler rule covers everyone.
       let foldersMissing = 0
       for (const member of entry.sessions) {
-        const respawned = await respawn(member.meta)
+        const respawned = await respawn(member.meta, member.sessionId)
         if (respawned === 'folder-missing') foldersMissing++
         if (typeof respawned === 'string') continue
         idMap.set(member.sessionId, respawned.sessionId)
diff --git a/src/renderer/src/workspace/hook/actions/undoCloseFailure.renderer.test.tsx b/src/renderer/src/workspace/hook/actions/undoCloseFailure.renderer.test.tsx
index fa00ce5f3..d19830287 100644
--- a/src/renderer/src/workspace/hook/actions/undoCloseFailure.renderer.test.tsx
+++ b/src/renderer/src/workspace/hook/actions/undoCloseFailure.renderer.test.tsx
@@ -227,3 +227,47 @@ it('does not push a deleted-folder member back with its group when a sibling fai
   expect(harness.showToast).toHaveBeenLastCalledWith('Could not restore "ProviderDown": Session failed to start. Check provider setup and retry.', 8000)
   harness.unmount()
 })
+
+// #1347: an agent whose TLDR/Goal identity is DERIVED (a reporting domain on,
+// no explicit field) is identified by its session id (tldrIdentityForSession).
+// Undo Close passed only the explicit field, so the restored agent got a fresh
+// identity and Agent Analytics split its time; Reload Agents already used the
+// derived rule.
+it('restores an agent with its derived TLDR identity, and an explicit one unchanged', async () => {
+  const { state, refs, writer } = setup()
+  refs.undoStackRef.current.pop()
+  refs.undoStackRef.current.push({
+    type: 'session', closedAt: Date.now(), sessionId: 'explicit-pane',
+    sessionMeta: { cwd: '/projects/agent-code', kind: 'claude', title: 'Explicit', projectId: 'tab-parent', joinedAt: 1, tldrIdentity: 'tldr-explicit', builtInMcpDomains: ['tldr'] },
+  })
+  refs.undoStackRef.current.push({
+    type: 'session', closedAt: Date.now(), sessionId: 'derived-pane',
+    sessionMeta: { cwd: '/projects/agent-code', kind: 'claude', title: 'Derived', projectId: 'tab-parent', joinedAt: 1, builtInMcpDomains: ['tldr'] },
+  })
+  const spawn = vi.fn().mockResolvedValueOnce('restored-derived').mockResolvedValueOnce('restored-explicit')
+  const harness = mount(state, refs, writer, spawn)
+  await act(async () => { await harness.undo() })
+  await act(async () => { await harness.undo() })
+  expect(spawn.mock.calls.map(([, opts]) => (opts as { tldrIdentity?: string }).tldrIdentity)).toEqual(['derived-pane', 'tldr-explicit'])
+  harness.unmount()
+})
+
+// #1356 review b: the project-restore call site passes each MEMBER's closed id;
+// a fresh id there survived the single-pane case above.
+it('restores each agent of a project with its own derived TLDR identity', async () => {
+  const { state, refs, writer } = setup()
+  refs.undoStackRef.current.pop()
+  const meta = { cwd: '/projects/agent-code', kind: 'claude' as const, projectId: 'closed-tab', joinedAt: 1, builtInMcpDomains: ['goal'] as never }
+  refs.undoStackRef.current.push({
+    type: 'tab', closedAt: Date.now(), tab: { id: 'closed-tab', title: 'agent-code' }, tabIndex: 0,
+    // Two DERIVED members (#1356 verification c): with only one, passing the
+    // first member's closed id for every member went unnoticed.
+    sessions: [{ sessionId: 'derived-member', meta }, { sessionId: 'second-derived-member', meta }, { sessionId: 'explicit-member', meta: { ...meta, tldrIdentity: 'tldr-explicit-member' } }],
+  })
+  const spawn = vi.fn().mockResolvedValueOnce('restored-one').mockResolvedValueOnce('restored-two').mockResolvedValueOnce('restored-three')
+  const harness = mount(state, refs, writer, spawn)
+  await act(async () => { await harness.undo() })
+  expect(spawn.mock.calls.map(([, opts]) => (opts as { tldrIdentity?: string }).tldrIdentity)).toEqual(['derived-member', 'second-derived-member', 'tldr-explicit-member'])
+  harness.unmount()
+})
+
diff --git a/src/shared/types/cliUpdate.ts b/src/shared/types/cliUpdate.ts
index 83740b4e3..6b9b60345 100644
--- a/src/shared/types/cliUpdate.ts
+++ b/src/shared/types/cliUpdate.ts
@@ -98,7 +98,10 @@ export type CliUpdateState =
       wantedLatest: string
       installMethod: CliInstallMethod
       reason: CliUpdateFailureReason
-      logPath: string
+      /** The attempt's log. Null only for `could-not-start` (#1425): the
+       *  attempt stopped before it could create one, so there is nothing to
+       *  open and the banner offers a retry instead of View Log. */
+      logPath: string | null
       finishedAt: number
     }
   /** Update was skipped because a session of this kind is currently spawned
@@ -153,6 +156,11 @@ export type CliUpdateFailureReason =
    *  the CLI is not installed or the PATH entry points at something
    *  unexpected. */
   | 'unparseable-version'
+  /** The update never ran: Agent Code could not create its log for the
+   *  attempt (a full disk, or an Agent Code data folder it cannot write).
+   *  #1425: this used to leave the state `updating` forever. No log exists;
+   *  the cause is in main's diagnostic output only (q22). */
+  | 'could-not-start'
 
 /** User preference for how aggressive the auto-updater should be. Persisted
  *  in setup.json (not the renderer's settings.json) because setup.json is
diff --git a/src/shared/types/projectionFidelity.ts b/src/shared/types/projectionFidelity.ts
new file mode 100644
index 000000000..e9ce20f4f
--- /dev/null
+++ b/src/shared/types/projectionFidelity.ts
@@ -0,0 +1,86 @@
+// What a provider switch, duplicate or rewind actually carried over (#927).
+//
+// WHY this exists: all three operations run the conversation through a REAL
+// native-resume projector (agent-transcript-parser), which reports every
+// entry it preserved, dropped, demoted, repaired or synthesized. Before #927
+// the host wrote `projection.values` and threw `projection.report` away, so
+// the only account a user or a caller ever saw was the switch's
+// `shrinkSummary`. That describes context REDUCTION (the fit ladder) and is
+// null whenever nothing had to be shrunk, even when the projection itself
+// dropped content. Every recorded Codex sequence loses something in both
+// directions, a Codex -> Codex duplicate included (opaque records). Two
+// recorded Claude sequences (prompts, tool-cycle) lose nothing either way, so
+// "lossless" is a real outcome too (#1384 review b corrected the first
+// version of this sentence).
+//
+// WHY a curated summary and not the parser's report as-is: this crosses IPC
+// and reaches pane toasts. `ProjectionChange.message` is projector prose, and
+// `evidence` carries source claims. Neither belongs in user-visible text
+// (q22/q39: curated, bounded). The `code` is a closed vocabulary
+// (`native-resume.<entry>.<outcome>`) that identifies each change without
+// either. Source line numbers are kept (they locate the change) but bounded,
+// with the rest COUNTED, never silently dropped (#918 §6.2: shortening a
+// summary must not delete the fidelity record).
+
+export type ProjectionChangeKind =
+  | 'preserved'
+  | 'dropped'
+  | 'demoted'
+  | 'synthesized'
+  | 'repaired'
+  | 'retargeted'
+  | 'opaque'
+
+export type ProjectionFidelityCode = {
+  kind: ProjectionChangeKind
+  /** The projector's closed change code, e.g. `native-resume.opaque.dropped`. */
+  code: string
+  count: number
+  /** Source line of each change, first `PROJECTION_FIDELITY_MAX_LINES` only. */
+  sourceLines: number[]
+}
+
+export type NativeProjectionFidelity = {
+  profile: 'native-resume'
+  sourceProvider: string
+  targetProvider: string
+  /** The projector profile the guarantee is stated against. */
+  providerProfileId: string
+  providerEvidence: { sourceCommit?: string; cliVersion?: string; observedAt?: string }
+  counts: Record<ProjectionChangeKind, number>
+  /** One row per distinct (kind, code), in first-seen order. */
+  codes: ProjectionFidelityCode[]
+  /** Source lines beyond the per-code cap, counted rather than listed. */
+  sourceLinesOmitted: number
+}
+
+export const PROJECTION_FIDELITY_MAX_LINES = 20
+
+// Loss a user should be told about in the operation's toast.
+//
+// UNCONFIRMED product default (#927 plan): material = `dropped` changes other
+// than opaque records, plus every `demoted` change.
+// - Opaque records are the provider's non-conversation rows (telemetry,
+//   environment and turn bookkeeping), dropped by every Codex projection
+//   (1-30 per recorded case). Naming them on every switch would train users to
+//   ignore the line.
+// - Repairs fix shape (an input object, content blocks) without losing
+//   content.
+// - Synthesized framing is the target's own session and turn identity.
+// All of those stay in the result for inspection; only the toast skips them.
+const QUIET_DROP_CODES = new Set(['native-resume.opaque.dropped'])
+
+export function materialProjectionLoss(fidelity: NativeProjectionFidelity | null | undefined): string | null {
+  if (!fidelity) return null
+  let dropped = 0
+  let demoted = 0
+  for (const row of fidelity.codes) {
+    if (row.kind === 'dropped' && !QUIET_DROP_CODES.has(row.code)) dropped += row.count
+    if (row.kind === 'demoted') demoted += row.count
+  }
+  const parts: string[] = []
+  if (dropped > 0) parts.push(`${dropped} dropped`)
+  if (demoted > 0) parts.push(`${demoted} demoted`)
+  // UNCONFIRMED wording: "history: 12 dropped, 19 demoted".
+  return parts.length > 0 ? `history: ${parts.join(', ')}` : null
+}