refactor(config): drop the unreachable SetNotify wrapper

SetNotify was kept in #1001 as a thin replace-form wrapper over UpdateNotify for existing tests, but every product surface (the CLI `zero config notify` and the TUI /notify picker) calls UpdateNotify's merge form directly, so the advisory deadcode job reports it as unreachable. Move the replace helper into writer_test.go as the unexported setNotify, keep every test it served unchanged in behaviour, and point the two CLI doc comments at UpdateNotify. `make deadcode` no longer lists internal/config; the other advisory findings in that job are pre-existing and untouched.
feat(providers): add GMI Cloud provider preset and partner listing (#1127 )
2026-11-10 17:57:54 -10:00 · 2026-10-14 15:58:35 +08:00 · 2026-10-14 12:55:29 +08:00 · 2026-10-13 12:49:55 +08:00 · 2026-10-13 10:15:11 +08:00 · 2026-10-13 09:40:10 +08:00
234 changed files with 14569 additions and 12795 deletions
@@ -4,9 +4,15 @@

 <p align="center"><strong>A terminal coding agent you own.</strong></p>

+<p align="center">
+  <a href="https://trendshift.io/repositories/70679?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/70679/daily?language=Go" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+  <a href="https://trendshift.io/repositories/70679?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/70679/weekly?language=Go" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+  <a href="https://trendshift.io/repositories/70679?utm_source=repository-badge&amp;utm_medium=badge&amp;utm_campaign=badge-repository-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/repositories/70679" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+</p>
+
 <p align="center">
  <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-blue"></a>
-  <img alt="Go 1.26.6+" src="https://img.shields.io/badge/Go-1.26.6+-00ADD8?logo=go&logoColor=white">
+  <img alt="Go 1.26.9+" src="https://img.shields.io/badge/Go-1.26.9+-00ADD8?logo=go&logoColor=white">
  <img alt="25+ providers" src="https://img.shields.io/badge/providers-25+-34E2EA">
  <a href="https://discord.gg/CaQDS6wdFn"><img alt="Discord" src="https://img.shields.io/badge/Discord-join-5865F2?logo=discord&logoColor=white"></a>
  <br>
@@ -23,6 +29,70 @@ zero exec "fix the failing test in ./pkg"
 zero exec --output-format stream-json < turns.jsonl
 ```

+## Partners
+
+<table align="center">
+  <tr>
+    <td align="center" width="150" height="80">
+      <a href="https://twigpine.com">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://twigpine.com/logo-dark.png">
+          <img src="https://twigpine.com/logo.png" alt="Twigpine logo" width="72">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://mimo.mi.com">
+        <img src="https://mimo.xiaomi.com/mimo-v2-pro/assets/logo.svg" alt="Xiaomi MiMo logo" width="136">
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://novita.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/novita-logo-dark.svg">
+          <img src="docs/assets/novita-logo.svg" alt="Novita AI logo" width="136">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://concentrate.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/concentrate-logo-dark.svg">
+          <img src="docs/assets/concentrate-logo.svg" alt="Concentrate logo" width="64">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://exa.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/exa-logo-dark.svg">
+          <img src="docs/assets/exa-logo.svg" alt="Exa logo" width="110">
+        </picture>
+      </a>
+    </td>
+  </tr>
+  <tr>
+    <td align="center"><a href="https://twigpine.com"><strong>Twigpine</strong></a></td>
+    <td align="center"><a href="https://mimo.mi.com"><strong>Xiaomi MiMo</strong></a></td>
+    <td align="center"><a href="https://novita.ai/"><strong>Novita AI</strong></a></td>
+    <td align="center"><a href="https://concentrate.ai/"><strong>Concentrate</strong></a></td>
+    <td align="center"><a href="https://exa.ai/"><strong>Exa</strong></a></td>
+  </tr>
+  <tr>
+    <td align="center" width="150" height="80">
+      <a href="https://www.gmicloud.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/gmi-cloud-logo-dark.svg">
+          <img src="docs/assets/gmi-cloud-logo.svg" alt="GMI Cloud logo" width="120">
+        </picture>
+      </a>
+    </td>
+  </tr>
+  <tr>
+    <td align="center"><a href="https://www.gmicloud.ai/"><strong>GMI Cloud</strong></a></td>
+  </tr>
+</table>
+
 ## Why Zero

 - **Use the model you want.** Bring OpenAI, Anthropic, Gemini, Groq, OpenRouter,
@@ -76,7 +146,7 @@ irm https://raw.githubusercontent.com/Gitlawb/zero/main/scripts/install.ps1 | ie

 ### From source

-Source builds require Go 1.26.6+.
+Source builds require Go 1.26.9+.

 ```bash
 git clone https://github.com/Gitlawb/zero.git
@@ -133,6 +203,7 @@ export GEMINI_API_KEY=...
 export AIMLAPI_API_KEY=...
 export LONGCAT_API_KEY=...
 export FIREWORKS_API_KEY=...
+export GMI_API_KEY=...
 export MINIMAX_API_KEY=...
 export MINIMAXI_API_KEY=...
 ```
@@ -155,6 +226,12 @@ To configure Fireworks AI directly, run:
 zero providers setup fireworks --set-active
 ```

+To configure GMI Cloud directly, run:
+
+```bash
+zero providers setup gmicloud --set-active
+```
+
 MiniMax presets use the Anthropic-compatible endpoints for the global and China
 regions:

@@ -313,7 +390,7 @@ zero context          context-budget report
 zero repo-map         deterministic repository map
 zero repo-info        local repository summary
 zero search | find    search local session history
-zero sessions         inspect, resume, fork, and rewind sessions
+zero sessions         inspect, resume, fork, rewind, and prune sessions
 zero spec             manage spec-mode drafts
 zero specialist       manage specialist subagents
 zero skills           manage markdown instruction skills
@@ -331,6 +408,13 @@ zero update --check   check for newer releases
 zero upgrade          download, verify, and install the latest release
 ```

+Cron keeps the newest 1,000 run outcomes per job in `runs.jsonl`. Each new run
+atomically replaces the history with the retained tail; existing larger histories
+are trimmed on their next run. Archive the file before that run if you need older
+outcomes. This retention does not delete session directories or reset fire counts.
+Malformed records and legacy lines of 1 MiB or more are skipped when reading or
+compacting history; new records of that size are rejected.
+
 ## Extending Zero

 ### Project and personal instructions
@@ -4,9 +4,15 @@

 <p align="center"><strong>一个独属于你的终端编码智能体。</strong></p>

+<p align="center">
+  <a href="https://trendshift.io/repositories/70679?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/70679/daily?language=Go" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+  <a href="https://trendshift.io/repositories/70679?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/70679/weekly?language=Go" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+  <a href="https://trendshift.io/repositories/70679?utm_source=repository-badge&amp;utm_medium=badge&amp;utm_campaign=badge-repository-70679" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/repositories/70679" alt="Twigpine/zero | Trendshift" width="250" height="55"/></a>
+</p>
+
 <p align="center">
  <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-blue"></a>
-  <img alt="Go 1.26.6+" src="https://img.shields.io/badge/Go-1.26.6+-00ADD8?logo=go&logoColor=white">
+  <img alt="Go 1.26.9+" src="https://img.shields.io/badge/Go-1.26.9+-00ADD8?logo=go&logoColor=white">
  <img alt="25+ providers" src="https://img.shields.io/badge/providers-25+-34E2EA">
  <a href="https://discord.gg/CaQDS6wdFn"><img alt="Discord" src="https://img.shields.io/badge/Discord-join-5865F2?logo=discord&logoColor=white"></a>
  <br>
@@ -21,6 +27,70 @@ zero exec "修复 ./pkg 中失败的测试"
 zero exec --output-format stream-json < turns.jsonl
 ```

+## 合作伙伴
+
+<table align="center">
+  <tr>
+    <td align="center" width="150" height="80">
+      <a href="https://twigpine.com">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://twigpine.com/logo-dark.png">
+          <img src="https://twigpine.com/logo.png" alt="Twigpine logo" width="72">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://mimo.mi.com">
+        <img src="https://mimo.xiaomi.com/mimo-v2-pro/assets/logo.svg" alt="Xiaomi MiMo logo" width="136">
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://novita.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/novita-logo-dark.svg">
+          <img src="docs/assets/novita-logo.svg" alt="Novita AI logo" width="136">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://concentrate.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/concentrate-logo-dark.svg">
+          <img src="docs/assets/concentrate-logo.svg" alt="Concentrate logo" width="64">
+        </picture>
+      </a>
+    </td>
+    <td align="center" width="150" height="80">
+      <a href="https://exa.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/exa-logo-dark.svg">
+          <img src="docs/assets/exa-logo.svg" alt="Exa logo" width="110">
+        </picture>
+      </a>
+    </td>
+  </tr>
+  <tr>
+    <td align="center"><a href="https://twigpine.com"><strong>Twigpine</strong></a></td>
+    <td align="center"><a href="https://mimo.mi.com"><strong>Xiaomi MiMo</strong></a></td>
+    <td align="center"><a href="https://novita.ai/"><strong>Novita AI</strong></a></td>
+    <td align="center"><a href="https://concentrate.ai/"><strong>Concentrate</strong></a></td>
+    <td align="center"><a href="https://exa.ai/"><strong>Exa</strong></a></td>
+  </tr>
+  <tr>
+    <td align="center" width="150" height="80">
+      <a href="https://www.gmicloud.ai/">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="docs/assets/gmi-cloud-logo-dark.svg">
+          <img src="docs/assets/gmi-cloud-logo.svg" alt="GMI Cloud logo" width="120">
+        </picture>
+      </a>
+    </td>
+  </tr>
+  <tr>
+    <td align="center"><a href="https://www.gmicloud.ai/"><strong>GMI Cloud</strong></a></td>
+  </tr>
+</table>
+
 ## 为什么选择 Zero

 - **使用你想要的模型。** 支持 OpenAI、Anthropic、Gemini、Groq、OpenRouter、DeepSeek、Mistral、xAI、Qwen、Kimi、GitHub Models、Ollama、LM Studio、Atomic Chat，或任何 OpenAI/Anthropic 兼容端点。
@@ -57,7 +127,7 @@ irm https://raw.githubusercontent.com/Gitlawb/zero/main/scripts/install.ps1 | ie

 ### 从源码构建

-源码构建需要 Go 1.26.6+。
+源码构建需要 Go 1.26.9+。

 ```bash
 git clone https://github.com/Gitlawb/zero.git
@@ -106,6 +176,7 @@ export OPENAI_API_KEY=sk-...
 export ANTHROPIC_API_KEY=...
 export GEMINI_API_KEY=...
 export LONGCAT_API_KEY=...
+export GMI_API_KEY=...
 ```

 要直接配置美团 LongCat（LongCat-2.0），运行：
@@ -114,6 +185,12 @@ export LONGCAT_API_KEY=...
 zero providers setup longcat --set-active
 ```

+要直接配置 GMI Cloud，运行：
+
+```bash
+zero providers setup gmicloud --set-active
+```
+
 对于本地模型，运行 Ollama、LM Studio 或 [Atomic Chat](https://atomic.chat) 桌面应用，
 然后使用 `zero setup` 或 `zero providers detect`。使用 Atomic Chat 时，请先加载模型并启用
 本地 OpenAI 兼容 API（默认地址为 `http://127.0.0.1:1337/v1`），再选择 `atomic-chat-local`。
@@ -218,7 +295,7 @@ zero context          上下文预算报告
 zero repo-map         确定性仓库映射
 zero repo-info        本地仓库摘要
 zero search | find    搜索本地会话历史
-zero sessions         检查、恢复、分叉和回滚会话
+zero sessions         检查、恢复、分叉、回滚和清理会话
 zero spec             管理规范模式草稿
 zero specialist       管理专业子智能体
 zero skills           管理 Markdown 指令技能
@@ -153,7 +153,7 @@ describe a version that is no longer on disk. Prefer `mise upgrade`.
 go install github.com/Gitlawb/zero/cmd/zero@latest
 ```

-This builds from source, so it needs Go 1.26.6+ and it does not go through the
+This builds from source, so it needs Go 1.26.9+ and it does not go through the
 release archives. Two consequences worth knowing before you pick it:

 - On Linux you also need the sandbox helper, which is a separate binary and is
@@ -180,7 +180,7 @@ Build a local binary:
 go build -o zero ./cmd/zero
 ```

-Source builds require Go 1.26.6+.
+Source builds require Go 1.26.9+.

 ### Sandbox Helpers For Source Builds

@@ -0,0 +1,26 @@
+# Local per-model completion limits
+
+Add `modelRPM` to the existing Zero config file:
+
+```json
+{"modelRPM": {"gpt-4.1": 30, "claude-sonnet-4.5": 15}}
+```
+
+Keys resolve through the model registry; custom IDs match exactly after trimming
+whitespace. Missing keys and zero mean unlimited. Negative limits and conflicting
+aliases are configuration errors. Project config may add or tighten a user cap,
+but cannot relax it. Changes take effect on the next Zero process start.
+
+For `zero exec` and interactive agent turns, admission happens immediately before
+the wrapped turn session's `Stream`. N admissions fit in any sliding 60-second
+window; N+1 returns a local rate-limit error before entering that method. The
+error reports when a slot expires. Exec uses its existing provider-error exit
+code plus a local-limit hint. There is no sleep or hidden retry. Failed admitted
+requests still consume a slot.
+
+Sessions and model switches share a limiter in one process. Separate processes
+have independent windows; restarting clears them. This is not an account-wide
+cap. It counts Stream admissions, not all HTTP requests: setup/prewarm,
+compaction, provider-internal retries, discovery and direct calls outside that
+boundary are not counted. No TPM, cost budgets, persistence, cross-process
+coordination or new runtime/Python dependency is introduced.
@@ -6,6 +6,7 @@ Zero.
 ## User Docs

 - [Install](INSTALL.md)
+- [Local per-model completion limits](MODEL_RPM.md)
 - [Update flow](UPDATE.md)
 - [OAuth logins and subscription-backed providers](oauth-subscriptions.md)

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 80 80" width="80" height="80">
+      <circle cx="6.4" cy="6.4" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="6.4" r="1.3440793933950872" fill="#FFFFFF"/><circle cx="25.6" cy="6.4" r="2.03724340327418" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="6.4" r="2.5983501502741575" fill="#FFFFFF"/><circle cx="44.8" cy="6.4" r="3.087883576356698" fill="#FFFFFF"/><circle cx="54.4" cy="6.4" r="3.530261898078346" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="6.4" r="3.938362368365323" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="6.4" r="4.32" fill="#FFFFFF"/><circle cx="6.4" cy="16" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="16" r="1.2253406720005793" fill="#FFFFFF"/><circle cx="25.6" cy="16" r="1.8572691561702617" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="16" r="2.3688065860361402" fill="#FFFFFF"/><circle cx="44.8" cy="16" r="2.8150936284760535" fill="#FFFFFF"/><circle cx="54.4" cy="16" r="3.2183913448763177" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="16" r="3.5904393853139163" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="16" r="3.9383623683653233" fill="#FFFFFF"/><circle cx="6.4" cy="25.6" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="25.6" r="1.0983685811330859" fill="#FFFFFF"/><circle cx="25.6" cy="25.6" r="1.6648154545579388" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="25.6" r="2.1233464197636582" fill="#FFFFFF"/><circle cx="44.8" cy="25.6" r="2.5233883646560065" fill="#FFFFFF"/><circle cx="54.4" cy="25.6" r="2.8848956178295655" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="25.6" r="3.2183913448763177" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="25.6" r="3.530261898078346" fill="#FFFFFF"/><circle cx="6.4" cy="35.199999999999996" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="35.199999999999996" r="0.9607316398574451" fill="#FFFFFF"/><circle cx="25.6" cy="35.199999999999996" r="1.456196862502631" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="35.199999999999996" r="1.8572691561702614" fill="#FFFFFF"/><circle cx="44.8" cy="35.199999999999996" r="2.2071817085957024" fill="#FFFFFF"/><circle cx="54.4" cy="35.199999999999996" r="2.5233883646560065" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="35.199999999999996" r="2.815093628476053" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="35.199999999999996" r="3.087883576356698" fill="#FFFFFF"/><circle cx="6.4" cy="44.8" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="44.8" r="0.8084233550482692" fill="#FFFFFF"/><circle cx="25.6" cy="44.8" r="1.2253406720005793" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="44.8" r="1.56282951468281" fill="#FFFFFF"/><circle cx="44.8" cy="44.8" r="1.8572691561702617" fill="#FFFFFF"/><circle cx="54.4" cy="44.8" r="2.1233464197636582" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="44.8" r="2.3688065860361402" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="44.8" r="2.5983501502741584" fill="#FFFFFF"/><circle cx="6.4" cy="54.4" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="54.4" r="0.633846499460857" fill="#FFFFFF"/><circle cx="25.6" cy="54.4" r="0.9607316398574451" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="54.4" r="1.225340672000579" fill="#FFFFFF"/><circle cx="44.8" cy="54.4" r="1.456196862502631" fill="#FFFFFF"/><circle cx="54.4" cy="54.4" r="1.6648154545579388" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="54.4" r="1.8572691561702614" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="54.4" r="2.03724340327418" fill="#FFFFFF"/><circle cx="6.4" cy="63.99999999999999" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="63.99999999999999" r="0.4181827351271541" fill="#FFFFFF"/><circle cx="25.6" cy="63.99999999999999" r="0.6338464994608571" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="63.99999999999999" r="0.8084233550482695" fill="#FFFFFF"/><circle cx="44.8" cy="63.99999999999999" r="0.9607316398574454" fill="#FFFFFF"/><circle cx="54.4" cy="63.99999999999999" r="1.0983685811330863" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="63.99999999999999" r="1.2253406720005795" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="63.99999999999999" r="1.3440793933950876" fill="#FFFFFF"/><circle cx="6.4" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="16" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="25.6" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="35.199999999999996" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="44.8" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="54.4" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="63.99999999999999" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/><circle cx="73.60000000000001" cy="73.60000000000001" r="0.3456" fill="#FFFFFF"/>
+    </svg>
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 80 80" width="80" height="80">
+      <circle cx="6.4" cy="6.4" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="6.4" r="1.3440793933950872" fill="#0D0E10"/><circle cx="25.6" cy="6.4" r="2.03724340327418" fill="#0D0E10"/><circle cx="35.199999999999996" cy="6.4" r="2.5983501502741575" fill="#0D0E10"/><circle cx="44.8" cy="6.4" r="3.087883576356698" fill="#0D0E10"/><circle cx="54.4" cy="6.4" r="3.530261898078346" fill="#0D0E10"/><circle cx="63.99999999999999" cy="6.4" r="3.938362368365323" fill="#0D0E10"/><circle cx="73.60000000000001" cy="6.4" r="4.32" fill="#0D0E10"/><circle cx="6.4" cy="16" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="16" r="1.2253406720005793" fill="#0D0E10"/><circle cx="25.6" cy="16" r="1.8572691561702617" fill="#0D0E10"/><circle cx="35.199999999999996" cy="16" r="2.3688065860361402" fill="#0D0E10"/><circle cx="44.8" cy="16" r="2.8150936284760535" fill="#0D0E10"/><circle cx="54.4" cy="16" r="3.2183913448763177" fill="#0D0E10"/><circle cx="63.99999999999999" cy="16" r="3.5904393853139163" fill="#0D0E10"/><circle cx="73.60000000000001" cy="16" r="3.9383623683653233" fill="#0D0E10"/><circle cx="6.4" cy="25.6" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="25.6" r="1.0983685811330859" fill="#0D0E10"/><circle cx="25.6" cy="25.6" r="1.6648154545579388" fill="#0D0E10"/><circle cx="35.199999999999996" cy="25.6" r="2.1233464197636582" fill="#0D0E10"/><circle cx="44.8" cy="25.6" r="2.5233883646560065" fill="#0D0E10"/><circle cx="54.4" cy="25.6" r="2.8848956178295655" fill="#0D0E10"/><circle cx="63.99999999999999" cy="25.6" r="3.2183913448763177" fill="#0D0E10"/><circle cx="73.60000000000001" cy="25.6" r="3.530261898078346" fill="#0D0E10"/><circle cx="6.4" cy="35.199999999999996" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="35.199999999999996" r="0.9607316398574451" fill="#0D0E10"/><circle cx="25.6" cy="35.199999999999996" r="1.456196862502631" fill="#0D0E10"/><circle cx="35.199999999999996" cy="35.199999999999996" r="1.8572691561702614" fill="#0D0E10"/><circle cx="44.8" cy="35.199999999999996" r="2.2071817085957024" fill="#0D0E10"/><circle cx="54.4" cy="35.199999999999996" r="2.5233883646560065" fill="#0D0E10"/><circle cx="63.99999999999999" cy="35.199999999999996" r="2.815093628476053" fill="#0D0E10"/><circle cx="73.60000000000001" cy="35.199999999999996" r="3.087883576356698" fill="#0D0E10"/><circle cx="6.4" cy="44.8" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="44.8" r="0.8084233550482692" fill="#0D0E10"/><circle cx="25.6" cy="44.8" r="1.2253406720005793" fill="#0D0E10"/><circle cx="35.199999999999996" cy="44.8" r="1.56282951468281" fill="#0D0E10"/><circle cx="44.8" cy="44.8" r="1.8572691561702617" fill="#0D0E10"/><circle cx="54.4" cy="44.8" r="2.1233464197636582" fill="#0D0E10"/><circle cx="63.99999999999999" cy="44.8" r="2.3688065860361402" fill="#0D0E10"/><circle cx="73.60000000000001" cy="44.8" r="2.5983501502741584" fill="#0D0E10"/><circle cx="6.4" cy="54.4" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="54.4" r="0.633846499460857" fill="#0D0E10"/><circle cx="25.6" cy="54.4" r="0.9607316398574451" fill="#0D0E10"/><circle cx="35.199999999999996" cy="54.4" r="1.225340672000579" fill="#0D0E10"/><circle cx="44.8" cy="54.4" r="1.456196862502631" fill="#0D0E10"/><circle cx="54.4" cy="54.4" r="1.6648154545579388" fill="#0D0E10"/><circle cx="63.99999999999999" cy="54.4" r="1.8572691561702614" fill="#0D0E10"/><circle cx="73.60000000000001" cy="54.4" r="2.03724340327418" fill="#0D0E10"/><circle cx="6.4" cy="63.99999999999999" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="63.99999999999999" r="0.4181827351271541" fill="#0D0E10"/><circle cx="25.6" cy="63.99999999999999" r="0.6338464994608571" fill="#0D0E10"/><circle cx="35.199999999999996" cy="63.99999999999999" r="0.8084233550482695" fill="#0D0E10"/><circle cx="44.8" cy="63.99999999999999" r="0.9607316398574454" fill="#0D0E10"/><circle cx="54.4" cy="63.99999999999999" r="1.0983685811330863" fill="#0D0E10"/><circle cx="63.99999999999999" cy="63.99999999999999" r="1.2253406720005795" fill="#0D0E10"/><circle cx="73.60000000000001" cy="63.99999999999999" r="1.3440793933950876" fill="#0D0E10"/><circle cx="6.4" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="16" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="25.6" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="35.199999999999996" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="44.8" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="54.4" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="63.99999999999999" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/><circle cx="73.60000000000001" cy="73.60000000000001" r="0.3456" fill="#0D0E10"/>
+    </svg>
@@ -0,0 +1,6 @@
+<svg width="128" height="40" viewBox="0 0 413 129" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M106.417 9.30741C106.417 9.57392 106.324 9.83227 106.155 10.0388L61.5395 64.5L106.155 118.96C106.324 119.166 106.417 119.425 106.417 119.691V127.843C106.417 128.482 105.897 129 105.255 129H1.16175C0.520132 129 0 128.482 0 127.843V1.15695C0 0.517982 0.520131 0 1.16174 0H105.255C105.897 0 106.417 0.517984 106.417 1.15695V9.30741ZM19.0364 116.382H87.6921L53.363 74.4795L19.0364 116.382ZM12.6699 104.192L40.1426 70.6585H12.6699V104.192ZM12.6699 58.0409H39.8964L12.6699 24.8064V58.0409ZM53.363 54.5193L87.6921 12.6176H19.0364L53.363 54.5193Z" fill="white"/>
+<path d="M176.198 117.65C166.094 117.65 157.323 115.553 149.886 111.36C142.588 107.167 136.905 101.017 132.835 92.911C128.906 84.8045 126.941 75.0208 126.941 63.5599C126.941 53.3569 128.976 44.2022 133.046 36.0957C137.256 27.9892 143.01 21.6298 150.307 17.0175C157.744 12.4052 166.024 10.099 175.146 10.099C185.109 10.099 193.599 12.3353 200.616 16.8078C207.633 21.1406 212.965 27.3602 216.614 35.4667C220.263 43.4334 222.087 52.8677 222.087 63.7695V66.1766C222.087 66.8156 221.567 67.3336 220.925 67.3336H145.044C145.185 74.881 146.588 81.3802 149.254 86.8311C152.061 92.282 155.78 96.475 160.411 99.4101C165.182 102.205 170.515 103.603 176.409 103.603C183.285 103.603 189.179 102.066 194.091 98.9908C198.779 95.9225 201.741 91.008 202.977 84.2471C203.08 83.6853 203.565 83.267 204.139 83.267H219.737C220.429 83.267 220.969 83.8669 220.871 84.5494C220.038 90.3376 217.988 95.6406 214.72 100.458C211.211 105.63 206.159 109.823 199.564 113.037C193.108 116.112 185.32 117.65 176.198 117.65ZM202.721 54.5449C202.721 45.3203 200.265 37.9825 195.354 32.5316C190.582 27.0807 183.846 24.3552 175.146 24.3552C166.866 24.3552 160.06 27.2205 154.727 32.9509C149.395 38.6813 146.377 45.8794 145.676 54.5449H202.721Z" fill="white"/>
+<path d="M364.585 117.65C358.13 117.65 352.236 116.392 346.903 113.876C341.571 111.36 337.361 107.796 334.273 103.184C331.186 98.4317 329.642 92.9808 329.642 86.8311C329.642 77.7462 332.73 70.688 338.904 65.6564C345.219 60.485 353.359 57.0607 363.322 55.3835L385.004 52.0291C387.67 51.6098 389.705 51.0507 391.108 50.3519C392.652 49.5133 393.704 48.465 394.266 47.2071C394.967 45.8095 395.318 44.0624 395.318 41.9659C395.318 36.515 393.424 32.2521 389.635 29.1772C385.846 25.9626 380.934 24.3552 374.9 24.3552C367.322 24.3552 361.498 26.2421 357.428 30.0158C353.595 33.4387 351.443 38.1016 350.971 44.0046C350.922 44.622 350.412 45.1106 349.79 45.1106H334.014C333.353 45.1106 332.823 44.5605 332.872 43.9032C333.312 38.0771 335.042 32.6792 338.062 27.7096C341.29 22.3985 345.921 18.1356 351.955 14.921C358.13 11.7063 365.287 10.099 373.426 10.099C381.706 10.099 388.793 11.6364 394.687 14.7113C400.721 17.7862 405.282 22.1888 408.369 27.9193C411.456 33.6497 413 40.4284 413 48.2554V113.348C413 113.987 412.48 114.505 411.838 114.505H396.901C396.259 114.505 395.739 113.987 395.739 113.348V109.473C395.739 108.076 395.739 106.678 395.739 105.28C395.739 103.743 395.739 102.275 395.739 100.878C393.213 106.189 389.214 110.312 383.741 113.247C378.408 116.182 372.023 117.65 364.585 117.65ZM367.111 103.603C372.444 103.603 377.215 102.485 381.425 100.249C385.775 97.8727 389.143 94.6581 391.529 90.6048C394.055 86.4118 395.318 81.6597 395.318 76.3486V61.4634C394.757 62.302 393.564 63.0707 391.74 63.7695C389.915 64.4684 387.389 65.1672 384.162 65.866L369.427 68.5915C362.971 69.8494 357.849 71.9459 354.06 74.881C350.271 77.8161 348.377 81.7995 348.377 86.8311C348.377 91.8627 350.131 95.916 353.639 98.9908C357.288 102.066 361.779 103.603 367.111 103.603Z" fill="white"/>
+<path d="M285.673 62.9573L325.127 112.948C325.726 113.707 325.183 114.82 324.213 114.82H305.929C305.572 114.82 305.235 114.657 305.015 114.378L275.053 76.414L245.093 114.378C244.872 114.657 244.536 114.82 244.179 114.82H225.893C224.924 114.82 224.381 113.707 224.98 112.948L264.433 62.9573L227.177 15.7512C226.578 14.9921 227.121 13.8793 228.091 13.8793H246.375C246.732 13.8793 247.068 14.0423 247.289 14.3214L275.053 49.5006L302.818 14.3214C303.038 14.0423 303.375 13.8793 303.731 13.8793H322.016C322.985 13.8793 323.528 14.9921 322.929 15.7512L285.673 62.9573Z" fill="white"/>
+</svg>
@@ -0,0 +1,6 @@
+<svg width="128" height="40" viewBox="0 0 413 129" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M106.417 9.30741C106.417 9.57392 106.324 9.83227 106.155 10.0388L61.5395 64.5L106.155 118.96C106.324 119.166 106.417 119.425 106.417 119.691V127.843C106.417 128.482 105.897 129 105.255 129H1.16175C0.520132 129 0 128.482 0 127.843V1.15695C0 0.517982 0.520131 0 1.16174 0H105.255C105.897 0 106.417 0.517984 106.417 1.15695V9.30741ZM19.0364 116.382H87.6921L53.363 74.4795L19.0364 116.382ZM12.6699 104.192L40.1426 70.6585H12.6699V104.192ZM12.6699 58.0409H39.8964L12.6699 24.8064V58.0409ZM53.363 54.5193L87.6921 12.6176H19.0364L53.363 54.5193Z" fill="#0143D9"/>
+<path d="M176.198 117.65C166.094 117.65 157.323 115.553 149.886 111.36C142.588 107.167 136.905 101.017 132.835 92.911C128.906 84.8045 126.941 75.0208 126.941 63.5599C126.941 53.3569 128.976 44.2022 133.046 36.0957C137.256 27.9892 143.01 21.6298 150.307 17.0175C157.744 12.4052 166.024 10.099 175.146 10.099C185.109 10.099 193.599 12.3353 200.616 16.8078C207.633 21.1406 212.965 27.3602 216.614 35.4667C220.263 43.4334 222.087 52.8677 222.087 63.7695V66.1766C222.087 66.8156 221.567 67.3336 220.925 67.3336H145.044C145.185 74.881 146.588 81.3802 149.254 86.8311C152.061 92.282 155.78 96.475 160.411 99.4101C165.182 102.205 170.515 103.603 176.409 103.603C183.285 103.603 189.179 102.066 194.091 98.9908C198.779 95.9225 201.741 91.008 202.977 84.2471C203.08 83.6853 203.565 83.267 204.139 83.267H219.737C220.429 83.267 220.969 83.8669 220.871 84.5494C220.038 90.3376 217.988 95.6406 214.72 100.458C211.211 105.63 206.159 109.823 199.564 113.037C193.108 116.112 185.32 117.65 176.198 117.65ZM202.721 54.5449C202.721 45.3203 200.265 37.9825 195.354 32.5316C190.582 27.0807 183.846 24.3552 175.146 24.3552C166.866 24.3552 160.06 27.2205 154.727 32.9509C149.395 38.6813 146.377 45.8794 145.676 54.5449H202.721Z" fill="black"/>
+<path d="M364.585 117.65C358.13 117.65 352.236 116.392 346.903 113.876C341.571 111.36 337.361 107.796 334.273 103.184C331.186 98.4317 329.642 92.9808 329.642 86.8311C329.642 77.7462 332.73 70.688 338.904 65.6564C345.219 60.485 353.359 57.0607 363.322 55.3835L385.004 52.0291C387.67 51.6098 389.705 51.0507 391.108 50.3519C392.652 49.5133 393.704 48.465 394.266 47.2071C394.967 45.8095 395.318 44.0624 395.318 41.9659C395.318 36.515 393.424 32.2521 389.635 29.1772C385.846 25.9626 380.934 24.3552 374.9 24.3552C367.322 24.3552 361.498 26.2421 357.428 30.0158C353.595 33.4387 351.443 38.1016 350.971 44.0046C350.922 44.622 350.412 45.1106 349.79 45.1106H334.014C333.353 45.1106 332.823 44.5605 332.872 43.9032C333.312 38.0771 335.042 32.6792 338.062 27.7096C341.29 22.3985 345.921 18.1356 351.955 14.921C358.13 11.7063 365.287 10.099 373.426 10.099C381.706 10.099 388.793 11.6364 394.687 14.7113C400.721 17.7862 405.282 22.1888 408.369 27.9193C411.456 33.6497 413 40.4284 413 48.2554V113.348C413 113.987 412.48 114.505 411.838 114.505H396.901C396.259 114.505 395.739 113.987 395.739 113.348V109.473C395.739 108.076 395.739 106.678 395.739 105.28C395.739 103.743 395.739 102.275 395.739 100.878C393.213 106.189 389.214 110.312 383.741 113.247C378.408 116.182 372.023 117.65 364.585 117.65ZM367.111 103.603C372.444 103.603 377.215 102.485 381.425 100.249C385.775 97.8727 389.143 94.6581 391.529 90.6048C394.055 86.4118 395.318 81.6597 395.318 76.3486V61.4634C394.757 62.302 393.564 63.0707 391.74 63.7695C389.915 64.4684 387.389 65.1672 384.162 65.866L369.427 68.5915C362.971 69.8494 357.849 71.9459 354.06 74.881C350.271 77.8161 348.377 81.7995 348.377 86.8311C348.377 91.8627 350.131 95.916 353.639 98.9908C357.288 102.066 361.779 103.603 367.111 103.603Z" fill="black"/>
+<path d="M285.673 62.9573L325.127 112.948C325.726 113.707 325.183 114.82 324.213 114.82H305.929C305.572 114.82 305.235 114.657 305.015 114.378L275.053 76.414L245.093 114.378C244.872 114.657 244.536 114.82 244.179 114.82H225.893C224.924 114.82 224.381 113.707 224.98 112.948L264.433 62.9573L227.177 15.7512C226.578 14.9921 227.121 13.8793 228.091 13.8793H246.375C246.732 13.8793 247.068 14.0423 247.289 14.3214L275.053 49.5006L302.818 14.3214C303.038 14.0423 303.375 13.8793 303.731 13.8793H322.016C322.985 13.8793 323.528 14.9921 322.929 15.7512L285.673 62.9573Z" fill="black"/>
+</svg>
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 34 718 165" width="718" height="165" fill="#fff">
+  <path d="M123.292 132.486h-33.1c-2.644 0-4.808-2.395-4.808-5.363v-21.436c0-2.95 2.148-5.363 4.809-5.363h33.099c2.645 0 4.808-2.395 4.808-5.363V73.525c0-2.95 2.147-5.363 4.808-5.363h33.099c2.646 0 4.809-2.395 4.809-5.363V41.363c0-2.95-2.148-5.363-4.809-5.363H90.208c-2.645 0-4.808 2.395-4.808 5.363V62.8c0 2.95-2.147 5.363-4.808 5.363h-33.1c-2.645 0-4.808 2.395-4.808 5.363v21.436c0 2.95-2.147 5.363-4.808 5.363H4.808c-2.645 0-4.808 2.395-4.808 5.363v21.436c0 2.95 2.147 5.363 4.808 5.363h33.1c2.645 0 4.808 2.395 4.808 5.363v21.436c0 2.95 2.147 5.363 4.808 5.363h33.099c2.645 0 4.808 2.395 4.808 5.363v21.436c0 2.95 2.148 5.363 4.809 5.363h75.798c2.646 0 4.809-2.395 4.809-5.363v-21.436c0-2.95-2.148-5.363-4.809-5.363H132.94c-2.646 0-4.809-2.395-4.809-5.363v-21.436c0-2.95-2.147-5.363-4.808-5.363z"/>
+  <path d="M251.408 100.341c2.646 0 4.809 2.395 4.809 5.363v21.436c0 2.95-2.148 5.363-4.809 5.363H218.31c-2.646 0-4.809 2.395-4.809 5.363v21.436c0 2.95-2.147 5.363-4.808 5.363h-33.099c-2.645 0-4.808-2.395-4.808-5.363v-53.58c0-2.951 2.147-5.364 4.808-5.364h75.799zM510.68 40.105h-28.795v153.33h28.795zM717.43 40.105h-28.795v153.33h28.795z"/>
+  <path d="M532.41 40.105h-28.83l35.391 153.33H567.8zM653.242 40.105h-28.795v153.33h28.795z"/>
+  <path d="M596.594 193.435h-28.795l35.39-153.33h28.795zM452.028 114.062v27.042s-.139.174-.191.261h-83.069V114.08h83.295-.035z"/>
+  <path d="M452.028 141.347v35.651c-17.479 12.306-39.834 19.769-62.953 19.769-59.673 0-97.858-35.981-97.858-80.362s34.54-80.362 97.858-80.362c22.511 0 45.127 7.689 62.953 20.36v35.685c-13.105-16.42-37.856-28.743-62.953-28.743-44.052 0-70.695 20.846-70.695 53.077 0 32.232 28.691 53.077 70.695 53.077 25.323 0 49.727-11.906 62.744-28.1h.191v-.035z"/>
+</svg>
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 34 718 165" width="718" height="165" fill="#0D0E10">
+  <path d="M123.292 132.486h-33.1c-2.644 0-4.808-2.395-4.808-5.363v-21.436c0-2.95 2.148-5.363 4.809-5.363h33.099c2.645 0 4.808-2.395 4.808-5.363V73.525c0-2.95 2.147-5.363 4.808-5.363h33.099c2.646 0 4.809-2.395 4.809-5.363V41.363c0-2.95-2.148-5.363-4.809-5.363H90.208c-2.645 0-4.808 2.395-4.808 5.363V62.8c0 2.95-2.147 5.363-4.808 5.363h-33.1c-2.645 0-4.808 2.395-4.808 5.363v21.436c0 2.95-2.147 5.363-4.808 5.363H4.808c-2.645 0-4.808 2.395-4.808 5.363v21.436c0 2.95 2.147 5.363 4.808 5.363h33.1c2.645 0 4.808 2.395 4.808 5.363v21.436c0 2.95 2.147 5.363 4.808 5.363h33.099c2.645 0 4.808 2.395 4.808 5.363v21.436c0 2.95 2.148 5.363 4.809 5.363h75.798c2.646 0 4.809-2.395 4.809-5.363v-21.436c0-2.95-2.148-5.363-4.809-5.363H132.94c-2.646 0-4.809-2.395-4.809-5.363v-21.436c0-2.95-2.147-5.363-4.808-5.363z"/>
+  <path d="M251.408 100.341c2.646 0 4.809 2.395 4.809 5.363v21.436c0 2.95-2.148 5.363-4.809 5.363H218.31c-2.646 0-4.809 2.395-4.809 5.363v21.436c0 2.95-2.147 5.363-4.808 5.363h-33.099c-2.645 0-4.808-2.395-4.808-5.363v-53.58c0-2.951 2.147-5.364 4.808-5.364h75.799zM510.68 40.105h-28.795v153.33h28.795zM717.43 40.105h-28.795v153.33h28.795z"/>
+  <path d="M532.41 40.105h-28.83l35.391 153.33H567.8zM653.242 40.105h-28.795v153.33h28.795z"/>
+  <path d="M596.594 193.435h-28.795l35.39-153.33h28.795zM452.028 114.062v27.042s-.139.174-.191.261h-83.069V114.08h83.295-.035z"/>
+  <path d="M452.028 141.347v35.651c-17.479 12.306-39.834 19.769-62.953 19.769-59.673 0-97.858-35.981-97.858-80.362s34.54-80.362 97.858-80.362c22.511 0 45.127 7.689 62.953 20.36v35.685c-13.105-16.42-37.856-28.743-62.953-28.743-44.052 0-70.695 20.846-70.695 53.077 0 32.232 28.691 53.077 70.695 53.077 25.323 0 49.727-11.906 62.744-28.1h.191v-.035z"/>
+</svg>
@@ -0,0 +1,11 @@
+<svg width="151" height="30" viewBox="0 0 151 30" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_novita_dark)">
+<path d="M17.2639 0.640625V12.1297L0.03125 29.363H17.2639V17.8739H17.7376L28.7529 29.363H45.9875L17.2639 0.640625Z" fill="white"/>
+</g>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M126.329 25.5459H131.778V28.9895H127.454C124.427 28.9895 122.523 27.3247 122.523 24.2256V15.0698H119.438V11.5974H122.523L123.417 7.03393H126.3V11.5974H131.778V15.0698H126.329V25.5459ZM61.9158 6.0293L69.8449 23.7083H70.0753V6.0293H74.1983V28.9895H67.97L60.0409 11.3105H59.8105V28.9895H55.6875V6.0293H61.9158ZM84.78 29.334C79.734 29.334 76.5052 25.804 76.5052 20.3223C76.5052 14.8406 79.6764 11.2529 84.78 11.2529C89.8836 11.2529 92.9971 14.6966 92.9971 20.3223C92.9971 25.948 89.826 29.334 84.78 29.334ZM84.78 25.8904C87.0293 25.8904 88.903 25.115 88.9606 22.9053V17.7393C88.9606 15.4719 87.0581 14.6966 84.78 14.6966C82.5019 14.6966 80.5418 15.4719 80.5418 17.7393V22.9053C80.5994 25.1438 82.5307 25.8904 84.78 25.8904ZM97.4094 11.5686L101.907 25.3443H102.137L106.635 11.5686H110.787L104.587 28.9607H99.4547L93.284 11.5686H97.407H97.4094ZM112.922 11.5974H116.728V28.9895H112.922V11.5974ZM112.69 6.0293H116.957V9.30127H112.69V6.0293ZM141.12 29.3628C136.477 29.3628 133.508 25.8328 133.508 20.3223C133.508 14.8118 136.42 11.2817 141.12 11.2817C143.312 11.2817 145.099 12.1423 146.166 13.7495H146.397L147.147 11.5974H150.03V28.9895H147.147L146.397 26.8938H146.166C145.013 28.4146 143.081 29.3616 141.12 29.3616V29.3628ZM141.898 25.8904C144.176 25.8904 146.165 25.1726 146.223 22.9053V17.7393C146.223 15.4143 144.146 14.7542 141.812 14.7542C139.477 14.7542 137.545 15.4719 137.545 17.7393V22.9053C137.602 25.2014 139.592 25.8904 141.898 25.8904Z" fill="white"/>
+<defs>
+<clipPath id="clip0_novita_dark">
+<rect width="45.9562" height="28.7223" fill="white" transform="translate(0.0292969 0.640625)"/>
+</clipPath>
+</defs>
+</svg>
@@ -0,0 +1,11 @@
+<svg width="151" height="30" viewBox="0 0 151 30" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_125_11573)">
+<path d="M17.2639 0.640625V12.1297L0.03125 29.363H17.2639V17.8739H17.7376L28.7529 29.363H45.9875L17.2639 0.640625Z" fill="black"/>
+</g>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M126.329 25.5459H131.778V28.9895H127.454C124.427 28.9895 122.523 27.3247 122.523 24.2256V15.0698H119.438V11.5974H122.523L123.417 7.03393H126.3V11.5974H131.778V15.0698H126.329V25.5459ZM61.9158 6.0293L69.8449 23.7083H70.0753V6.0293H74.1983V28.9895H67.97L60.0409 11.3105H59.8105V28.9895H55.6875V6.0293H61.9158ZM84.78 29.334C79.734 29.334 76.5052 25.804 76.5052 20.3223C76.5052 14.8406 79.6764 11.2529 84.78 11.2529C89.8836 11.2529 92.9971 14.6966 92.9971 20.3223C92.9971 25.948 89.826 29.334 84.78 29.334ZM84.78 25.8904C87.0293 25.8904 88.903 25.115 88.9606 22.9053V17.7393C88.9606 15.4719 87.0581 14.6966 84.78 14.6966C82.5019 14.6966 80.5418 15.4719 80.5418 17.7393V22.9053C80.5994 25.1438 82.5307 25.8904 84.78 25.8904ZM97.4094 11.5686L101.907 25.3443H102.137L106.635 11.5686H110.787L104.587 28.9607H99.4547L93.284 11.5686H97.407H97.4094ZM112.922 11.5974H116.728V28.9895H112.922V11.5974ZM112.69 6.0293H116.957V9.30127H112.69V6.0293ZM141.12 29.3628C136.477 29.3628 133.508 25.8328 133.508 20.3223C133.508 14.8118 136.42 11.2817 141.12 11.2817C143.312 11.2817 145.099 12.1423 146.166 13.7495H146.397L147.147 11.5974H150.03V28.9895H147.147L146.397 26.8938H146.166C145.013 28.4146 143.081 29.3616 141.12 29.3616V29.3628ZM141.898 25.8904C144.176 25.8904 146.165 25.1726 146.223 22.9053V17.7393C146.223 15.4143 144.146 14.7542 141.812 14.7542C139.477 14.7542 137.545 15.4719 137.545 17.7393V22.9053C137.602 25.2014 139.592 25.8904 141.898 25.8904Z" fill="black"/>
+<defs>
+<clipPath id="clip0_125_11573">
+<rect width="45.9562" height="28.7223" fill="white" transform="translate(0.0292969 0.640625)"/>
+</clipPath>
+</defs>
+</svg>
@@ -1,6 +1,6 @@
 module github.com/Gitlawb/zero

-go 1.26.6
+go 1.26.9

 require (
 	charm.land/bubbles/v2 v2.1.1
@@ -15,6 +15,7 @@ import (

 	"github.com/Gitlawb/zero/internal/agent"
 	"github.com/Gitlawb/zero/internal/config"
+	"github.com/Gitlawb/zero/internal/modelregistry"
 	"github.com/Gitlawb/zero/internal/providercatalog"
 	"github.com/Gitlawb/zero/internal/providermodelcatalog"
 	"github.com/Gitlawb/zero/internal/providermodeldiscovery"
@@ -87,8 +88,6 @@ type Agent struct {
 type turnRecord struct {
 	user      string
 	assistant string
-	imported  bool
-	boundary  bool
 }

 type acpSession struct {
@@ -108,6 +107,14 @@ type acpSession struct {
 	restrictModels bool
 	cancel         context.CancelFunc
 	history        []turnRecord
+
+	// readOnly marks a session published by session/load for a kind that is
+	// not resumable (a child, side or spec sub-run). Load still replays its
+	// transcript, which is the render-only use a client needs, but a prompt
+	// would continue the sub-run as a standalone conversation, which every
+	// other resume path refuses (sessions.IsResumableKind). Set once when the
+	// session is first registered and never changed, so it is read without mu.
+	readOnly bool
 }

 // NewAgent builds the ACP server and registers its method handlers on conn.
@@ -206,7 +213,7 @@ func (a *Agent) handleSessionNew(ctx context.Context, params json.RawMessage) (a
 	if err != nil {
 		return nil, RPCError(codeInternalError, "create session: "+err.Error())
 	}
-	sess, _ := a.registerSession(meta.SessionID, root, nil, model, models, restrictModels)
+	sess, _ := a.registerSession(meta.SessionID, root, nil, model, models, restrictModels, false)
 	return NewSessionResult{
 		SessionID:     sess.id,
 		ConfigOptions: a.configOptions(sess),
@@ -259,8 +266,7 @@ func (a *Agent) activatePersistedSession(ctx context.Context, p LoadSessionParam
 	if operation == persistedSessionResume && !sessions.IsResumableKind(meta.SessionKind) {
 		return nil, RPCError(codeInvalidParams, "session is not resumable: "+p.SessionID)
 	}
-	persistedCwd := sessions.OperationalCwd(*meta)
-	if strings.TrimSpace(persistedCwd) == "" {
+	if strings.TrimSpace(meta.Cwd) == "" {
 		return nil, RPCError(codeInvalidParams, "session has no persisted workspace: "+p.SessionID)
 	}
 	// SAME RULE ON THE WAY IN. Omitting a relative entry from the listing is not
@@ -268,10 +274,10 @@ func (a *Agent) activatePersistedSession(ctx context.Context, p LoadSessionParam
 	// client that hands back that same directory as its cwd would be sold the
 	// invented root as a match. A workspace that cannot be identified is not one
 	// this session can be restored into.
-	if !filepath.IsAbs(persistedCwd) {
+	if !filepath.IsAbs(meta.Cwd) {
 		return nil, RPCError(codeInvalidParams, "session workspace is not an absolute path, so it cannot be identified: "+p.SessionID)
 	}
-	persistedRoot, err := a.deps.ResolveWorkspaceRoot(persistedCwd)
+	persistedRoot, err := a.deps.ResolveWorkspaceRoot(meta.Cwd)
 	if err != nil {
 		return nil, RPCError(codeInvalidParams, "persisted session workspace is unavailable: "+err.Error())
 	}
@@ -304,20 +310,26 @@ func (a *Agent) activatePersistedSession(ctx context.Context, p LoadSessionParam
 	if operation == persistedSessionResume && historyErr != nil {
 		return nil, RPCError(codeInternalError, "restore session history: "+historyErr.Error())
 	}
+	// Load stays best effort about a history it cannot read, but not about one
+	// prune holds: publishing it would leave the client using a session prune may
+	// be removing, one this process could not hold open.
+	if errors.Is(historyErr, sessions.ErrPruning) {
+		return nil, RPCError(codeInternalError, historyErr.Error())
+	}
 	model, models, restrictModels, err := a.resolveModelChoices(ctx, root)
 	if err != nil {
 		return nil, RPCError(codeInternalError, "config: "+err.Error())
 	}
-	persistedModel := strings.TrimSpace(meta.ModelID)
-	imported := sessions.IsImportedSession(*meta)
-	locallySelected := !imported || meta.ModelSelectedLocally
-	if persistedModel != "" && locallySelected && (!restrictModels || modelChoiceExists(models, persistedModel)) {
+	if persistedModel := strings.TrimSpace(meta.ModelID); persistedModel != "" && (!restrictModels || modelChoiceExists(models, persistedModel)) {
 		model = persistedModel
 		if !modelChoiceExists(models, persistedModel) {
 			models = append(models, SessionConfigOptionValue{Value: persistedModel, Name: persistedModel})
 		}
 	}
-	sess, existed := a.registerSession(meta.SessionID, root, history, model, models, restrictModels)
+	// Resume has already refused a non-resumable kind above, so only load can
+	// reach here with one, and it publishes that session for viewing only.
+	readOnly := !sessions.IsResumableKind(meta.SessionKind)
+	sess, existed := a.registerSession(meta.SessionID, root, history, model, models, restrictModels, readOnly)
 	if existed {
 		_, messages, historyWarning, historyErr = a.refreshSessionHistory(sess, requireHistoryLog)
 		if operation == persistedSessionResume && historyErr != nil {
@@ -395,8 +407,7 @@ func (a *Agent) handleSessionList(_ context.Context, params json.RawMessage) (an
 		// a session whose workspace has since been deleted, and a legacy entry
 		// holding a relative path, which was then reported as cwd "." even though
 		// ACP requires SessionInfo.cwd to be absolute.
-		operationalCwd := sessions.OperationalCwd(item)
-		if strings.TrimSpace(operationalCwd) == "" {
+		if strings.TrimSpace(item.Cwd) == "" {
 			continue
 		}
 		// A RELATIVE PERSISTED CWD HAS NO RECOVERABLE IDENTITY. Resolving one
@@ -406,10 +417,10 @@ func (a *Agent) handleSessionList(_ context.Context, params json.RawMessage) (an
 		// project's configuration, files and tools. The original base is not
 		// knowable from the metadata, so the honest answer is to omit the entry
 		// rather than to guess at it.
-		if !filepath.IsAbs(operationalCwd) {
+		if !filepath.IsAbs(item.Cwd) {
 			continue
 		}
-		itemRoot, err := a.deps.ResolveWorkspaceRoot(operationalCwd)
+		itemRoot, err := a.deps.ResolveWorkspaceRoot(item.Cwd)
 		if err != nil {
 			continue
 		}
@@ -440,6 +451,9 @@ func (a *Agent) handleSessionPrompt(ctx context.Context, params json.RawMessage)
 	if sess == nil {
 		return nil, RPCError(codeInvalidParams, "unknown session: "+p.SessionID)
 	}
+	if sess.readOnly {
+		return nil, RPCError(codeInvalidParams, "session is not resumable, so it was loaded for viewing only and cannot be prompted: "+p.SessionID)
+	}

 	// Serialize turns for this session so two prompts can't interleave history or
 	// fight over the single cancel slot. session/cancel still works concurrently
@@ -515,6 +529,30 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 	}
 	queue(messageEvent("user", userText))

+	visionCache := make(map[string]bool)
+	var visionCacheMu sync.Mutex
+	supportsVision := func(modelID string) bool {
+		modelID = strings.TrimSpace(modelID)
+		if modelID == "" {
+			return false
+		}
+		visionCacheMu.Lock()
+		defer visionCacheMu.Unlock()
+		if cached, ok := visionCache[modelID]; ok {
+			return cached
+		}
+		supported := a.modelSupportsVision(ctx, resolved.Provider, modelID)
+		visionCache[modelID] = supported
+		return supported
+	}
+	effectivePrompt := userText
+	if len(images) > 0 && !supportsVision(resolved.Provider.Model) {
+		msg := fmt.Sprintf("Model %s does not support image input; ignoring %d prompt image(s).", resolved.Provider.Model, len(images))
+		note.text("[zero] " + msg + "\n\n")
+		effectivePrompt = fmt.Sprintf("[Note: %s]\n\n%s", msg, userText)
+		images = nil
+	}
+
 	opts := agent.Options{
 		Cwd:            sess.cwd,
 		SessionID:      sess.id,
@@ -526,6 +564,7 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 		DeferThreshold: workspace.DeferThreshold,
 		MaxTurns:       resolved.MaxTurns,
 		Images:         images,
+		SupportsVision: supportsVision,
 		OnText:         note.text,
 		OnReasoning:    note.thought,
 		OnToolCall: func(call agent.ToolCall) {
@@ -544,7 +583,7 @@ func (a *Agent) runTurn(ctx context.Context, sess *acpSession, userText string,
 		},
 	}

-	agentPrompt := buildPrompt(sess.snapshotHistory(), userText)
+	agentPrompt := buildPrompt(sess.snapshotHistory(), effectivePrompt)
 	result, runErr := a.deps.RunAgent(ctx, agentPrompt, provider, opts)
 	if result.FinalAnswer != "" {
 		queue(messageEvent("assistant", result.FinalAnswer))
@@ -915,9 +954,20 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 	// enough: rehydration substitutes the compaction event in place of the events
 	// it replaced, so a loop that skips everything but EventMessage would drop the
 	// summary exactly as before. It is projected below. Reported by @jatmn.
+	//
+	// The session was picked from its metadata a moment ago. Make sure it is
+	// still there, and held, before restoring it: see sessions.HoldToContinue.
+	if err := a.deps.Store.HoldToContinue(sessionID); err != nil {
+		return nil, nil, nil, err
+	}
 	events, eventLogPresent, err := a.deps.Store.ReadRehydratedEventsWithPresence(sessionID)
 	var rehydrateWarning error
 	if err != nil {
+		if errors.Is(err, sessions.ErrPruning) {
+			// Not a rehydration failure: the raw read would continue the session
+			// without holding it while zero sessions prune may be removing it.
+			return nil, nil, nil, err
+		}
 		rehydrateWarning = err
 		events, eventLogPresent, err = a.deps.Store.ReadEventsWithPresence(sessionID)
 		if err != nil {
@@ -931,7 +981,6 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 	var messages []persistedMessage
 	activeToolCalls := make(map[string]string)
 	var pendingUser string
-	var pendingImported, pendingBoundary bool
 	havePending := false
 	for _, e := range events {
 		if e.Type == sessions.EventCompaction {
@@ -943,8 +992,7 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 				continue
 			}
 			var payload struct {
-				Summary         string `json:"summary"`
-				ImportedContext bool   `json:"importedEvent"`
+				Summary string `json:"summary"`
 			}
 			if json.Unmarshal(raw, &payload) != nil || strings.TrimSpace(payload.Summary) == "" {
 				continue
@@ -954,10 +1002,8 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 				role:    "assistant",
 				content: payload.Summary,
 			})
-			records = append(records, turnRecord{user: pendingUser, assistant: payload.Summary, imported: payload.ImportedContext})
+			records = append(records, turnRecord{user: pendingUser, assistant: payload.Summary})
 			pendingUser = ""
-			pendingImported = false
-			pendingBoundary = false
 			havePending = false
 			continue
 		}
@@ -999,10 +1045,8 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 			continue
 		}
 		var msg struct {
-			Role     string `json:"role"`
-			Content  string `json:"content"`
-			Imported bool   `json:"importedEvent"`
-			Boundary bool   `json:"importedReferenceBoundary"`
+			Role    string `json:"role"`
+			Content string `json:"content"`
 		}
 		if json.Unmarshal(raw, &msg) != nil {
 			continue
@@ -1011,27 +1055,19 @@ func (a *Agent) loadHistory(sessionID string, requireHistoryLog bool) ([]turnRec
 		case "user":
 			messages = append(messages, persistedMessage{eventID: persistedMessageIdentity(sessionID, e), role: msg.Role, content: msg.Content})
 			if havePending {
-				records = append(records, turnRecord{user: pendingUser, imported: pendingImported, boundary: pendingBoundary})
+				records = append(records, turnRecord{user: pendingUser})
 			}
 			pendingUser = msg.Content
-			pendingImported = msg.Imported
-			pendingBoundary = msg.Boundary
 			havePending = true
 		case "assistant":
 			messages = append(messages, persistedMessage{eventID: persistedMessageIdentity(sessionID, e), role: msg.Role, content: msg.Content})
-			records = append(records, turnRecord{
-				user: pendingUser, assistant: msg.Content,
-				imported: pendingImported || msg.Imported,
-				boundary: pendingBoundary || msg.Boundary,
-			})
+			records = append(records, turnRecord{user: pendingUser, assistant: msg.Content})
 			pendingUser = ""
-			pendingImported = false
-			pendingBoundary = false
 			havePending = false
 		}
 	}
 	if havePending {
-		records = append(records, turnRecord{user: pendingUser, imported: pendingImported, boundary: pendingBoundary})
+		records = append(records, turnRecord{user: pendingUser})
 	}
 	return records, messages, rehydrateWarning, nil
 }
@@ -1085,11 +1121,6 @@ func replayToolUpdate(event sessions.Event) *ToolCallUpdate {
 		Output:       payload.Output,
 		ChangedFiles: append([]string(nil), payload.ChangedFiles...),
 	})
-	if status == tools.StatusUnknown {
-		// ACP has no unknown result status. Omitting the optional status keeps
-		// this replay neutral instead of inventing successful completion.
-		upd.Status = ""
-	}
 	return &upd
 }

@@ -1142,14 +1173,7 @@ func buildPrompt(history []turnRecord, userText string) string {
 	}
 	var b strings.Builder
 	b.WriteString("Conversation so far:\n")
-	importedLabeled := false
 	for _, t := range history {
-		if t.imported && !importedLabeled {
-			b.WriteString("Context boundary: ")
-			b.WriteString(sessions.ImportedBoundaryText("another agent's"))
-			b.WriteString("\n")
-			importedLabeled = true
-		}
 		b.WriteString("User: ")
 		b.WriteString(t.user)
 		b.WriteString("\n")
@@ -1158,11 +1182,6 @@ func buildPrompt(history []turnRecord, userText string) string {
 			b.WriteString(t.assistant)
 			b.WriteString("\n")
 		}
-		if t.boundary {
-			importedLabeled = true
-		} else if !t.imported {
-			importedLabeled = false
-		}
 	}
 	b.WriteString("\n---\nContinue with this request:\n")
 	b.WriteString(userText)
@@ -1192,13 +1211,13 @@ func promptImages(blocks []ContentBlock) []zeroruntime.ImageBlock {
 // The bool reports that case so persisted activation can re-read and apply disk
 // history under turnMu. history is set BEFORE first publication so no concurrent
 // prompt can read a half-initialized session.
-func (a *Agent) registerSession(id, cwd string, history []turnRecord, model string, models []SessionConfigOptionValue, restrictModels bool) (*acpSession, bool) {
+func (a *Agent) registerSession(id, cwd string, history []turnRecord, model string, models []SessionConfigOptionValue, restrictModels bool, readOnly bool) (*acpSession, bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	if existing := a.sessions[id]; existing != nil {
 		return existing, true
 	}
-	sess := &acpSession{id: id, cwd: cwd, mode: agent.PermissionModeAuto, model: model, models: models, restrictModels: restrictModels, history: history}
+	sess := &acpSession{id: id, cwd: cwd, mode: agent.PermissionModeAuto, model: model, models: models, restrictModels: restrictModels, history: history, readOnly: readOnly}
 	a.sessions[id] = sess
 	return sess, false
 }
@@ -1343,3 +1362,32 @@ func sameWorkspace(left, right string) bool {
 	}
 	return os.SameFile(leftInfo, rightInfo)
 }
+
+func (a *Agent) modelSupportsVision(ctx context.Context, profile config.ProviderProfile, modelID string) bool {
+	trimmed := strings.TrimSpace(modelID)
+	if trimmed == "" {
+		return false
+	}
+	if a.deps.DiscoverModels != nil {
+		if discovered, err := a.deps.DiscoverModels(ctx, profile); err == nil {
+			for _, dm := range discovered {
+				if strings.EqualFold(strings.TrimSpace(dm.ID), trimmed) {
+					if len(dm.InputModalities) > 0 {
+						for _, mod := range dm.InputModalities {
+							if strings.EqualFold(strings.TrimSpace(mod), "image") {
+								return true
+							}
+						}
+						return false
+					}
+					break
+				}
+			}
+		}
+	}
+	reg, _ := modelregistry.DefaultRegistry()
+	if entry, known := reg.Resolve(trimmed); known {
+		return entry.Supports(modelregistry.ModelCapabilityVision)
+	}
+	return modelregistry.SupportsVision(reg, trimmed)
+}
@@ -1,7 +1,9 @@
 package acp

 import (
+	"bytes"
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -525,122 +527,6 @@ func TestACPCustomProviderAllowsUnadvertisedModel(t *testing.T) {
 	}
 }

-func TestACPLoadImportedSessionDoesNotRestoreUnadvertisedForeignModel(t *testing.T) {
-	deps := testDeps(t)
-	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
-		return config.ResolvedConfig{Provider: config.ProviderProfile{
-			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
-		}}, nil
-	}
-	workspace := t.TempDir()
-	meta, err := deps.Store.Create(sessions.CreateInput{
-		Title:   "legacy imported session",
-		Cwd:     workspace,
-		ModelID: "foreign-expensive-model",
-		Tag:     sessions.ImportedSessionTag("claude-code", "foreign-id"),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := newHarness(t, deps)
-	defer h.stop()
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	var loaded LoadSessionResult
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{
-		SessionID: meta.SessionID,
-		Cwd:       workspace,
-	}, &loaded); err != nil {
-		t.Fatalf("session/load: %v", err)
-	}
-	option := loaded.ConfigOptions[0]
-	if option.CurrentValue != "workspace-model" || modelChoiceExists(option.Options, "foreign-expensive-model") {
-		t.Fatalf("imported model gained ACP authority: %+v", option)
-	}
-}
-
-func TestACPLoadImportedSessionRestoresLaterLocalModelSelection(t *testing.T) {
-	deps := testDeps(t)
-	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
-		return config.ResolvedConfig{Provider: config.ProviderProfile{
-			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
-		}}, nil
-	}
-	clientCwd := t.TempDir()
-	meta, err := deps.Store.Create(sessions.CreateInput{
-		Title:         "modern imported session",
-		Cwd:           "/foreign/display",
-		WorkspaceKey:  clientCwd,
-		SourceModelID: "foreign-expensive-model",
-		Tag:           sessions.ImportedSessionTag("claude-code", "foreign-id"),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	h := newHarness(t, deps)
-	var loaded LoadSessionResult
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: clientCwd}, &loaded); err != nil {
-		t.Fatalf("initial session/load: %v", err)
-	}
-	if got := loaded.ConfigOptions[0].CurrentValue; got != "workspace-model" {
-		t.Fatalf("initial imported model = %q, want workspace default", got)
-	}
-	var selected SetSessionConfigOptionResult
-	if err := h.client.Call(ctx, MethodSessionSetConfigOption, SetSessionConfigOptionParams{
-		SessionID: meta.SessionID, ConfigID: configIDModel, Value: "local-choice",
-	}, &selected); err != nil {
-		t.Fatalf("set local model: %v", err)
-	}
-	if got := selected.ConfigOptions[0].CurrentValue; got != "local-choice" {
-		t.Fatalf("selected model = %q", got)
-	}
-	h.stop()
-
-	h = newHarness(t, deps)
-	defer h.stop()
-	loaded = LoadSessionResult{}
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: clientCwd}, &loaded); err != nil {
-		t.Fatalf("fresh session/load: %v", err)
-	}
-	option := loaded.ConfigOptions[0]
-	if option.CurrentValue != "local-choice" || !modelChoiceExists(option.Options, "local-choice") {
-		t.Fatalf("fresh load discarded persisted local choice: %+v", option)
-	}
-}
-
-func TestACPLoadNativeImportedPrefixTagRestoresItsModel(t *testing.T) {
-	deps := testDeps(t)
-	deps.ResolveConfig = func(_ string, _ config.Overrides) (config.ResolvedConfig, error) {
-		return config.ResolvedConfig{Provider: config.ProviderProfile{
-			Name: "Custom", CatalogID: "custom-openai-compatible", Model: "workspace-model",
-		}}, nil
-	}
-	workspace := t.TempDir()
-	meta, err := deps.Store.Create(sessions.CreateInput{
-		Title:   "native archived session",
-		Cwd:     workspace,
-		ModelID: "native-model",
-		Tag:     "imported:archive",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := newHarness(t, deps)
-	defer h.stop()
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	var loaded LoadSessionResult
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: workspace}, &loaded); err != nil {
-		t.Fatalf("session/load: %v", err)
-	}
-	option := loaded.ConfigOptions[0]
-	if option.CurrentValue != "native-model" || !modelChoiceExists(option.Options, "native-model") {
-		t.Fatalf("native tagged model was discarded as foreign: %+v", option)
-	}
-}
-
 func TestACPModelDiscoveryFiltersProviderIncompatibleModels(t *testing.T) {
 	a := &Agent{deps: Deps{
 		ResolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
@@ -963,6 +849,48 @@ func TestACPRunTurnClosesWorkspaceAfterSuccessAndFailure(t *testing.T) {
 	}
 }

+func TestACPWiresSupportsVision(t *testing.T) {
+	deps := testDeps(t)
+	var captured agent.Options
+	deps.RunAgent = func(_ context.Context, _ string, _ zeroruntime.Provider, opts agent.Options) (agent.Result, error) {
+		captured = opts
+		return agent.Result{FinalAnswer: "done"}, nil
+	}
+	deps.DiscoverModels = func(_ context.Context, _ config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
+		return []providermodeldiscovery.Model{
+			{ID: "custom-vision", InputModalities: []string{"text", "image"}},
+			{ID: "custom-text", InputModalities: []string{"text"}},
+		}, nil
+	}
+	h := newHarness(t, deps)
+	defer h.stop()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var newRes NewSessionResult
+	if err := h.client.Call(ctx, MethodSessionNew, NewSessionParams{Cwd: t.TempDir(), McpServers: []McpServer{}}, &newRes); err != nil {
+		t.Fatalf("session/new: %v", err)
+	}
+	var promptRes PromptResult
+	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+		SessionID: newRes.SessionID,
+		Prompt: []ContentBlock{
+			{Type: "text", Text: "hello"},
+		},
+	}, &promptRes); err != nil {
+		t.Fatalf("session/prompt: %v", err)
+	}
+	if captured.SupportsVision == nil {
+		t.Fatal("SupportsVision was not wired into agent.Options")
+	}
+	if !captured.SupportsVision("custom-vision") {
+		t.Fatal("SupportsVision(custom-vision) = false, want true")
+	}
+	if captured.SupportsVision("custom-text") {
+		t.Fatal("SupportsVision(custom-text) = true, want false")
+	}
+}
+
 // TestACPRejectsInvalidCwd confirms session/new fails when the workspace root
 // resolver rejects the client cwd (e.g. filesystem root).
 func TestACPRejectsInvalidCwd(t *testing.T) {
@@ -1139,6 +1067,7 @@ func TestACPSameConnectionReloadRefreshesRecoveredHistory(t *testing.T) {
 		prompts <- prompt
 		return agent.Result{FinalAnswer: "continued"}, nil
 	}
+
 	h := newHarness(t, deps)
 	defer h.stop()
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@@ -1195,88 +1124,7 @@ func TestACPSameConnectionReloadRefreshesRecoveredHistory(t *testing.T) {
 	}
 }

-func TestACPLoadUsesOperationalWorkspaceKeyForPersistedIdentity(t *testing.T) {
-	deps := testDeps(t)
-	displayCwd := filepath.Join(t.TempDir(), "[REDACTED]", "repo")
-	operationalCwd := t.TempDir()
-	meta, err := deps.Store.Create(sessions.CreateInput{
-		Title:        "imported session",
-		Cwd:          displayCwd,
-		WorkspaceKey: operationalCwd,
-		Tag:          sessions.ImportedSessionTag("claude-code", "foreign-id"),
-	})
-	if err != nil {
-		t.Fatalf("create session: %v", err)
-	}
-	var resolved []string
-	deps.ResolveWorkspaceRoot = func(cwd string) (string, error) {
-		resolved = append(resolved, cwd)
-		return cwd, nil
-	}
-	h := newHarness(t, deps)
-	defer h.stop()
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID}, &LoadSessionResult{}); err == nil {
-		t.Fatal("session/load accepted an imported session without an ACP client workspace")
-	}
-	if len(resolved) != 0 {
-		t.Fatalf("omitted client workspace reached resolver: %q", resolved)
-	}
-
-	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{
-		SessionID: meta.SessionID,
-		Cwd:       operationalCwd,
-	}, &LoadSessionResult{}); err != nil {
-		t.Fatalf("session/load: %v", err)
-	}
-	if len(resolved) != 2 || resolved[0] != operationalCwd || resolved[1] != operationalCwd {
-		t.Fatalf("session/load resolved workspaces %q, want persisted and requested %q", resolved, operationalCwd)
-	}
-}
-
 // drainText collects streamed chunks for a short window and concatenates them.
-func TestACPListAndLoadShareOperationalWorkspaceIdentity(t *testing.T) {
-	for _, createDisplay := range []bool{false, true} {
-		t.Run(fmt.Sprintf("display-exists-%v", createDisplay), func(t *testing.T) {
-			deps := testDeps(t)
-			root := t.TempDir()
-			operational := filepath.Join(root, "token-shaped-workspace")
-			display := filepath.Join(root, "[REDACTED]-workspace")
-			if err := os.MkdirAll(operational, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			if createDisplay {
-				if err := os.MkdirAll(display, 0o755); err != nil {
-					t.Fatal(err)
-				}
-			}
-			meta, err := deps.Store.Create(sessions.CreateInput{Cwd: display, WorkspaceKey: operational})
-			if err != nil {
-				t.Fatal(err)
-			}
-			h := newHarness(t, deps)
-			defer h.stop()
-			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-			defer cancel()
-
-			for _, params := range []ListSessionsParams{{}, {Cwd: operational}} {
-				var listed ListSessionsResult
-				if err := h.client.Call(ctx, MethodSessionList, params, &listed); err != nil {
-					t.Fatalf("session/list: %v", err)
-				}
-				if len(listed.Sessions) != 1 || listed.Sessions[0].Cwd != operational {
-					t.Fatalf("session/list = %+v, want operational cwd %q", listed.Sessions, operational)
-				}
-				if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: listed.Sessions[0].Cwd}, &LoadSessionResult{}); err != nil {
-					t.Fatalf("list-to-load round trip: %v", err)
-				}
-			}
-		})
-	}
-}
-
 func drainText(t *testing.T, ch <-chan string) string {
 	t.Helper()
 	return drainTextUntil(t, ch, func(text string) bool {
@@ -1447,6 +1295,85 @@ func TestACPResumeAppliesStandaloneSessionKindPolicy(t *testing.T) {
 			}, &LoadSessionResult{}); err != nil {
 				t.Fatalf("session/load should retain render-only access: %v", err)
 			}
+			// The check above only showed the refused resume never registered the
+			// session. Load does register it, so the prompt that matters is the one
+			// AFTER the load: render-only means the transcript can be read and the
+			// sub-run cannot be continued.
+			err = h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+				SessionID: created.SessionID, Prompt: []ContentBlock{TextBlock("must stay closed after load")},
+			}, &PromptResult{})
+			if !errors.As(err, &rpcErr) || rpcErr.Code != codeInvalidParams {
+				t.Fatalf("session/prompt after load of a %s session = %v, want invalid params", tc.name, err)
+			}
+		})
+	}
+}
+
+// LOAD PUBLISHES A SUB-RUN FOR VIEWING, NOT FOR CONTINUING. Every other resume
+// path (the TUI, exec sessions, the exec CLI, and ACP's own session/resume)
+// refuses a kind sessions.IsResumableKind rejects. session/load has a real
+// render-only use, a client rebuilding a transcript it can scroll, so it keeps
+// loading those sessions; what it must not do is publish one that accepts a
+// prompt, because the prompt would carry on a child, side or spec sub-run as a
+// standalone conversation. Checked in both directions, so a gate that refused
+// everything would fail on the resumable kinds.
+func TestACPLoadPublishesSubRunsReadOnly(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		kind     sessions.SessionKind
+		readOnly bool
+	}{
+		{name: "regular", kind: ""},
+		{name: "fork", kind: sessions.SessionKindFork},
+		{name: "child", kind: sessions.SessionKindChild, readOnly: true},
+		{name: "side", kind: sessions.SessionKindSide, readOnly: true},
+		{name: "spec draft", kind: sessions.SessionKindSpecDraft, readOnly: true},
+		{name: "spec impl", kind: sessions.SessionKindSpecImpl, readOnly: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := !sessions.IsResumableKind(tc.kind); got != tc.readOnly {
+				t.Fatalf("SETUP INVALID: IsResumableKind(%q) disagrees with this table (readOnly=%v), so the cases no longer mean what they say", tc.kind, tc.readOnly)
+			}
+			deps := testDeps(t)
+			workspace := t.TempDir()
+			created, err := deps.Store.Create(sessions.CreateInput{
+				SessionID: "load-" + strings.ReplaceAll(tc.name, " ", "-"), Cwd: workspace, SessionKind: tc.kind,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			h := newHarness(t, deps)
+			defer h.stop()
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+
+			if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{
+				SessionID: created.SessionID, Cwd: workspace,
+			}, &LoadSessionResult{}); err != nil {
+				t.Fatalf("session/load of a %s session: %v", tc.name, err)
+			}
+			err = h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+				SessionID: created.SessionID, Prompt: []ContentBlock{TextBlock("continue")},
+			}, &PromptResult{})
+			// A resumable session has to be genuinely promptable, not merely "not
+			// refused as view-only": any other failure would hide a broken
+			// writable path behind a passing test.
+			if !tc.readOnly {
+				if err != nil {
+					t.Fatalf("session/prompt after load of a %s session = %v, want success", tc.name, err)
+				}
+				return
+			}
+			// The decision is the RPC code; the message only distinguishes the
+			// view-only refusal from other invalid-params errors such as an
+			// unknown session id.
+			var rpcErr *rpcError
+			if !errors.As(err, &rpcErr) || rpcErr.Code != codeInvalidParams {
+				t.Fatalf("session/prompt after load of a %s session = %v, want invalid params", tc.name, err)
+			}
+			if !strings.Contains(rpcErr.Message, "loaded for viewing only") {
+				t.Fatalf("session/prompt after load of a %s session was refused for another reason: %v", tc.name, err)
+			}
 		})
 	}
 }
@@ -1914,9 +1841,8 @@ func TestACPCompactedHistoryReplacesCompactedTurnsWithTheirSummary(t *testing.T)
 	if _, err := deps.Store.AppendEvents(created.SessionID, []sessions.AppendEventInput{{
 		Type: sessions.EventCompaction,
 		Payload: map[string]any{
-			"summary":       summary,
-			"preserveLast":  1,
-			"importedEvent": true,
+			"summary":      summary,
+			"preserveLast": 1,
 			"compactableEvents": []map[string]any{
 				{"id": appended[0].ID, "sequence": appended[0].Sequence},
 				{"id": appended[1].ID, "sequence": appended[1].Sequence},
@@ -1977,9 +1903,6 @@ func TestACPCompactedHistoryReplacesCompactedTurnsWithTheirSummary(t *testing.T)
 	if !strings.Contains(prompt, summary) {
 		t.Fatalf("resumed prompt lost the compaction summary:\n%s", prompt)
 	}
-	if !strings.Contains(prompt, sessions.ImportedBoundaryText("another agent's")) {
-		t.Fatalf("resumed prompt lost imported reference-only provenance:\n%s", prompt)
-	}
 	if strings.Contains(prompt, "compacted answer") {
 		t.Fatalf("resumed prompt replayed a compacted-away turn:\n%s", prompt)
 	}
@@ -2002,10 +1925,6 @@ func TestACPLoadReplaysToolCallsPairedByTheirStoredOccurrence(t *testing.T) {
 		// An older record spells the id "id" rather than "toolCallId".
 		{Type: sessions.EventToolCall, Payload: map[string]any{"name": "bash", "id": "call-88", "arguments": `{"command":"go build"}`}},
 		{Type: sessions.EventToolResult, Payload: map[string]any{"name": "bash", "id": "call-88", "status": "error", "output": "build failed"}},
-		// A foreign result with no structured outcome must not become success just
-		// because its prose happens to sound successful.
-		{Type: sessions.EventToolCall, Payload: map[string]any{"name": "shell", "toolCallId": "call-unknown", "arguments": `{"command":"false"}`}},
-		{Type: sessions.EventToolResult, Payload: map[string]any{"name": "shell", "toolCallId": "call-unknown", "status": "unknown", "output": "command completed successfully"}},
 		// A start with no result is an interrupted call, not a completed one.
 		{Type: sessions.EventToolCall, Payload: map[string]any{"name": "grep", "toolCallId": "call-99", "arguments": `{"pattern":"TODO"}`}},
 		// No id at all: unpairable, so it must be skipped rather than replayed.
@@ -2033,8 +1952,6 @@ func TestACPLoadReplaysToolCallsPairedByTheirStoredOccurrence(t *testing.T) {
 		{UpdateToolCall, replayToolCallID(appended[3].ID), ToolStatusInProgress, nil},
 		{UpdateToolCallUpdate, replayToolCallID(appended[3].ID), ToolStatusFailed, nil},
 		{UpdateToolCall, replayToolCallID(appended[5].ID), ToolStatusInProgress, nil},
-		{UpdateToolCallUpdate, replayToolCallID(appended[5].ID), "", nil},
-		{UpdateToolCall, replayToolCallID(appended[7].ID), ToolStatusInProgress, nil},
 	}
 	for i, w := range wants {
 		select {
@@ -2624,3 +2541,265 @@ func payloadString(payload any, key string) string {
 	value, _ := decoded[key].(string)
 	return value
 }
+
+// Load is best effort about a history it cannot read, but a session that zero
+// sessions prune holds is refused by load and resume alike, and not published:
+// this process could not hold it open while prune may be removing it.
+func TestACPLoadAndResumeAreRefusedWhilePruneHoldsTheSession(t *testing.T) {
+	deps := testDeps(t)
+	cwd := t.TempDir()
+	meta, err := deps.Store.Create(sessions.CreateInput{Title: "ACP session", Cwd: cwd})
+	if err != nil {
+		t.Fatalf("create session: %v", err)
+	}
+	// Created by an earlier process, which has since exited.
+	deps.Store.Release(meta.SessionID)
+
+	release, locked, err := sessions.NewStore(sessions.StoreOptions{RootDir: deps.Store.RootDir}).HoldExclusive(meta.SessionID)
+	if err != nil || !locked {
+		t.Fatalf("take the lease the way prune does: locked=%v, %v", locked, err)
+	}
+	defer release()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	h := newHarness(t, deps)
+	defer h.stop()
+	if err := h.client.Call(ctx, MethodSessionLoad, LoadSessionParams{SessionID: meta.SessionID, Cwd: cwd, McpServers: []McpServer{}}, &LoadSessionResult{}); err == nil || !strings.Contains(err.Error(), "locked by zero sessions prune") {
+		t.Errorf("session/load while prune holds the session: err = %v, want it refused", err)
+	}
+	if err := h.client.Call(ctx, MethodSessionResume, ResumeSessionParams{SessionID: meta.SessionID, Cwd: cwd, McpServers: []McpServer{}}, &ResumeSessionResult{}); err == nil || !strings.Contains(err.Error(), "locked by zero sessions prune") {
+		t.Errorf("session/resume while prune holds the session: err = %v, want it refused", err)
+	}
+	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+		SessionID: meta.SessionID,
+		Prompt:    []ContentBlock{TextBlock("carry on")},
+	}, &PromptResult{}); err == nil {
+		t.Fatal("a session refused while prune held it was still promptable")
+	}
+}
+
+// Activation reads the session's metadata before it restores the history. A
+// session prune removes in between is refused as removed, which activation then
+// refuses to publish for load as well as resume, instead of restoring it as an
+// empty conversation.
+func TestACPLoadHistoryRefusesASessionRemovedAfterItWasPicked(t *testing.T) {
+	deps := testDeps(t)
+	meta, err := deps.Store.Create(sessions.CreateInput{Title: "ACP session", Cwd: t.TempDir()})
+	if err != nil {
+		t.Fatalf("create session: %v", err)
+	}
+	deps.Store.Release(meta.SessionID)
+	dir := filepath.Join(deps.Store.RootDir, meta.SessionID)
+	if err := os.Remove(filepath.Join(dir, sessions.MetadataFile)); err != nil {
+		t.Fatal(err)
+	}
+
+	a := &Agent{deps: deps}
+	if _, _, _, err := a.loadHistory(meta.SessionID, false); !errors.Is(err, sessions.ErrPruning) {
+		t.Errorf("load history of a session prune is removing: err = %v, want it refused", err)
+	}
+	if err := os.RemoveAll(dir); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, _, err := a.loadHistory(meta.SessionID, false); !errors.Is(err, sessions.ErrPruning) {
+		t.Errorf("load history of a session prune removed: err = %v, want it refused", err)
+	}
+}
+
+func TestACPPromptUnsupportedModelDropsImagesAndNotifies(t *testing.T) {
+	deps := testDeps(t)
+	deps.DiscoverModels = func(ctx context.Context, p config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
+		return []providermodeldiscovery.Model{
+			{ID: "fake-model", InputModalities: []string{"text"}},
+		}, nil
+	}
+	var capturedOpts agent.Options
+	var capturedPrompt string
+	deps.RunAgent = func(ctx context.Context, prompt string, provider zeroruntime.Provider, opts agent.Options) (agent.Result, error) {
+		capturedPrompt = prompt
+		capturedOpts = opts
+		return agent.Result{FinalAnswer: "Answered without images"}, nil
+	}
+
+	h := newHarness(t, deps)
+	defer h.stop()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var initRes InitializeResult
+	if err := h.client.Call(ctx, MethodInitialize, InitializeParams{ProtocolVersion: ProtocolVersion}, &initRes); err != nil {
+		t.Fatalf("initialize: %v", err)
+	}
+
+	var newRes NewSessionResult
+	if err := h.client.Call(ctx, MethodSessionNew, NewSessionParams{Cwd: t.TempDir(), McpServers: []McpServer{}}, &newRes); err != nil {
+		t.Fatalf("session/new: %v", err)
+	}
+
+	rawPng := "\x89PNG\r\n\x1a\nfake-image-bytes"
+	b64Png := base64.StdEncoding.EncodeToString([]byte(rawPng))
+	var promptRes PromptResult
+	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+		SessionID: newRes.SessionID,
+		Prompt: []ContentBlock{
+			TextBlock("look at this image"),
+			ImageBlock(b64Png, "image/png"),
+		},
+	}, &promptRes); err != nil {
+		t.Fatalf("session/prompt: %v", err)
+	}
+	if promptRes.StopReason != StopEndTurn {
+		t.Fatalf("stopReason = %q, want %q", promptRes.StopReason, StopEndTurn)
+	}
+
+	got := drainTextUntil(t, h.updates, func(text string) bool {
+		return strings.Contains(text, "does not support image input")
+	})
+	if !strings.Contains(got, "Model fake-model does not support image input; ignoring 1 prompt image(s).") {
+		t.Fatalf("streamed text = %q, want drop notice", got)
+	}
+	if len(capturedOpts.Images) != 0 {
+		t.Fatalf("captured %d images, want 0 (images should be withheld)", len(capturedOpts.Images))
+	}
+	if !strings.Contains(capturedPrompt, "[Note: Model fake-model does not support image input; ignoring 1 prompt image(s).]") {
+		t.Fatalf("captured prompt = %q, want prompt note", capturedPrompt)
+	}
+}
+
+func TestACPSessionPrompt_SupportsVisionMemoizedPerRun(t *testing.T) {
+	deps := testDeps(t)
+	var discoverCount int
+	var discoverMu sync.Mutex
+	deps.DiscoverModels = func(ctx context.Context, p config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
+		discoverMu.Lock()
+		discoverCount++
+		discoverMu.Unlock()
+		return []providermodeldiscovery.Model{
+			{ID: "fake-model", InputModalities: []string{"text", "image"}},
+		}, nil
+	}
+	deps.RunAgent = func(ctx context.Context, prompt string, provider zeroruntime.Provider, opts agent.Options) (agent.Result, error) {
+		for i := 0; i < 5; i++ {
+			if !opts.SupportsVision(opts.Model) {
+				t.Error("expected SupportsVision to report true")
+			}
+		}
+		return agent.Result{FinalAnswer: "Done"}, nil
+	}
+
+	h := newHarness(t, deps)
+	defer h.stop()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var initRes InitializeResult
+	if err := h.client.Call(ctx, MethodInitialize, InitializeParams{ProtocolVersion: ProtocolVersion}, &initRes); err != nil {
+		t.Fatalf("initialize: %v", err)
+	}
+
+	var newRes NewSessionResult
+	if err := h.client.Call(ctx, MethodSessionNew, NewSessionParams{Cwd: t.TempDir(), McpServers: []McpServer{}}, &newRes); err != nil {
+		t.Fatalf("session/new: %v", err)
+	}
+
+	discoverMu.Lock()
+	discoverCount = 0
+	discoverMu.Unlock()
+
+	rawPng := "\x89PNG\r\n\x1a\nfake-image-bytes"
+	b64Png := base64.StdEncoding.EncodeToString([]byte(rawPng))
+	var promptRes PromptResult
+	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+		SessionID: newRes.SessionID,
+		Prompt: []ContentBlock{
+			TextBlock("look at this"),
+			ImageBlock(b64Png, "image/png"),
+		},
+	}, &promptRes); err != nil {
+		t.Fatalf("session/prompt: %v", err)
+	}
+	if promptRes.StopReason != StopEndTurn {
+		t.Fatalf("stopReason = %q, want %q", promptRes.StopReason, StopEndTurn)
+	}
+
+	discoverMu.Lock()
+	count := discoverCount
+	discoverMu.Unlock()
+	if count != 1 {
+		t.Fatalf("DiscoverModels was called %d times, want exactly 1 call (memoized per run)", count)
+	}
+}
+
+func TestACPEndToEndImagePromptSupportedModel(t *testing.T) {
+	deps := testDeps(t)
+	deps.DiscoverModels = func(ctx context.Context, p config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
+		return []providermodeldiscovery.Model{
+			{ID: "discovered-vision-model", InputModalities: []string{"text", "image"}},
+		}, nil
+	}
+	deps.ResolveConfig = func(_ string, o config.Overrides) (config.ResolvedConfig, error) {
+		model := "discovered-vision-model"
+		if o.Provider.Model != "" {
+			model = o.Provider.Model
+		}
+		return config.ResolvedConfig{
+			Provider: config.ProviderProfile{Name: "fake", Model: model},
+			MaxTurns: 4,
+		}, nil
+	}
+	var capturedOpts agent.Options
+	var capturedPrompt string
+	deps.RunAgent = func(ctx context.Context, prompt string, provider zeroruntime.Provider, opts agent.Options) (agent.Result, error) {
+		capturedPrompt = prompt
+		capturedOpts = opts
+		return agent.Result{FinalAnswer: "I can see the image!"}, nil
+	}
+
+	h := newHarness(t, deps)
+	defer h.stop()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var initRes InitializeResult
+	if err := h.client.Call(ctx, MethodInitialize, InitializeParams{ProtocolVersion: ProtocolVersion}, &initRes); err != nil {
+		t.Fatalf("initialize: %v", err)
+	}
+
+	var newRes NewSessionResult
+	if err := h.client.Call(ctx, MethodSessionNew, NewSessionParams{Cwd: t.TempDir(), McpServers: []McpServer{}}, &newRes); err != nil {
+		t.Fatalf("session/new: %v", err)
+	}
+
+	rawPng := []byte("\x89PNG\r\n\x1a\nreal-png-bytes")
+	b64Png := base64.StdEncoding.EncodeToString(rawPng)
+	var promptRes PromptResult
+	if err := h.client.Call(ctx, MethodSessionPrompt, PromptParams{
+		SessionID: newRes.SessionID,
+		Prompt: []ContentBlock{
+			TextBlock("analyze this image"),
+			ImageBlock(b64Png, "image/png"),
+		},
+	}, &promptRes); err != nil {
+		t.Fatalf("session/prompt: %v", err)
+	}
+	if promptRes.StopReason != StopEndTurn {
+		t.Fatalf("stopReason = %q, want %q", promptRes.StopReason, StopEndTurn)
+	}
+
+	if len(capturedOpts.Images) != 1 {
+		t.Fatalf("captured %d images, want 1", len(capturedOpts.Images))
+	}
+	if capturedOpts.Images[0].MediaType != "image/png" {
+		t.Fatalf("mediaType = %q, want image/png", capturedOpts.Images[0].MediaType)
+	}
+	if !bytes.Equal(capturedOpts.Images[0].Data, rawPng) {
+		t.Fatalf("image bytes mismatch: got %v, want %v", capturedOpts.Images[0].Data, rawPng)
+	}
+	if strings.Contains(capturedPrompt, "does not support image input") {
+		t.Fatalf("prompt unexpectedly contains refusal note: %q", capturedPrompt)
+	}
+}
@@ -139,7 +139,7 @@ func browserToolTitle(command, rawArgs string) string {
 }

 // browserTitleTextSafe validates text after URL parsing has decoded escaped
-// UTF-8 in the host. Valid UTF-8 alone is not presentation-safe: control,
+// UTF-8 in the host. Valid UTF-8 alone is not presentation-safe: whitespace, control,
 // format/bidi, and line/paragraph separator runes can reorder or split the
 // permission label shown to a user. The execution URL remains unchanged.
 func browserTitleTextSafe(text string) bool {
@@ -147,7 +147,7 @@ func browserTitleTextSafe(text string) bool {
 		return false
 	}
 	for _, r := range text {
-		if unicode.IsControl(r) || unicode.Is(unicode.Cf, r) || unicode.Is(unicode.Zl, r) || unicode.Is(unicode.Zp, r) {
+		if unicode.IsSpace(r) || unicode.IsControl(r) || unicode.Is(unicode.Cf, r) || unicode.Is(unicode.Zl, r) || unicode.Is(unicode.Zp, r) {
 			return false
 		}
 	}
@@ -224,6 +224,9 @@ func TestBrowserPermissionTitlesMirrorSafeToolArguments(t *testing.T) {

 func TestBrowserOpenTitlesRejectDecodedUnicodePresentationControls(t *testing.T) {
 	for _, rawURL := range []string{
+		"https://safe.example%C2%A0evil.test/path",
+		"https://safe.example%E2%80%83evil.test/path",
+		"https://safe.example%E3%80%80evil.test/path",
 		"https://safe.example%E2%80%AEevil.test/path",
 		"https://safe.example%E2%81%A6evil.test/path",
 		"https://safe.example%C2%85evil.test/path",
@@ -243,6 +246,9 @@ func TestBrowserOpenTitlesRejectDecodedUnicodePresentationControls(t *testing.T)
 			if err != nil {
 				t.Fatal(err)
 			}
+			if title := browserToolTitle("open", string(args)); title != "browser open" {
+				t.Errorf("unsafe origin accepted before permission translation: %q", title)
+			}
 			updates := []ToolCallUpdate{
 				toolCallStart(agent.ToolCall{ID: "start", Name: "browser_open", Arguments: string(args)}),
 				permissionToolCall(agent.PermissionRequest{ToolCallID: "permission", ToolName: "browser_open", Args: map[string]any{"url": rawURL}}),
@@ -13,6 +13,7 @@ import (

 	"github.com/Gitlawb/zero/internal/execution"
 	"github.com/Gitlawb/zero/internal/hooks"
+	"github.com/Gitlawb/zero/internal/modelregistry"
 	"github.com/Gitlawb/zero/internal/redaction"
 	"github.com/Gitlawb/zero/internal/sandbox"
 	"github.com/Gitlawb/zero/internal/streamjson"
@@ -25,14 +26,18 @@ const maxTurnsAnswer = "Agent reached maximum number of turns without a final an
 const maxTurnsFinalAnswerPrompt = "You have reached the tool-turn limit. Do not call tools. Give a concise final answer now: summarize what you completed, what you found, and any remaining blockers."

 // maxStreamStallRetries bounds how many times a turn that timed out (idle/stall)
-// WITH NO OUTPUT yet is re-issued on a fresh connection before giving up. Only
-// the no-output case is retried (a partial turn would duplicate), so this is a
-// safe recovery for a stalled/dead pooled connection.
+// OR hit a mid-stream transport abort (#973) with no answer text yet is re-issued
+// on a fresh connection before giving up. Incomplete tool-call previews are
+// allowed through the gate (they are never dispatched before the error return).
+// The safety claim is only that visible answer prose is not duplicated on retry —
+// not that every partial stream shape is excluded. Covers a stalled/dead pooled
+// connection or a socket abort before tool dispatch.
 //
 // Set to 1 (not 2): each attempt can itself idle for the full stream timeout
 // (~5min) before the stall is even detected, so 2 retries left an interactive
 // session frozen for ~15min. One retry keeps the common single-hiccup recovery
-// while bounding the worst case to ~2× the idle timeout.
+// while bounding the worst case to ~2× the idle timeout. Mid-stream transport
+// aborts share this bound (do not raise it for #973).
 const maxStreamStallRetries = 1

 const (
@@ -374,7 +379,11 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 					rec.StampFirstToken()
 				}
 				if onText != nil {
-					forwardedVisibleText = true
+					// Zero-length chunks are not committed answer prose; counting
+					// them would block an eligible mid-stream abort retry.
+					if s != "" {
+						forwardedVisibleText = true
+					}
 					onText(s)
 				}
 			}
@@ -450,9 +459,14 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 			result.Messages = copyMessages(messages)
 			return result, ctx.Err()
 		}
-		// A stream idle/stall timeout is safely re-issued when the turn committed NO
-		// answer text — no forwarded visible prose (forwardedVisibleText) and no
-		// collected final text (collected.Text). This covers two cases:
+		// A stream idle/stall timeout OR mid-stream transport abort (#973 — wsarecv /
+		// connection reset / unexpected EOF / connection closed / broken pipe) is
+		// safely re-issued when the turn committed NO answer text — no forwarded
+		// visible prose (forwardedVisibleText) and no collected final text
+		// (collected.Text). The abort gate matches midStreamAbortNeedles only, not
+		// the full shouldReconnect list: connect-phase timeouts and connection
+		// refused are NOT retried here (a slow healthy server must not cost a
+		// second prefill). This covers three cases:
 		//   1. Nothing streamed at all before the connection died (the original
 		//      macOS stale-pooled-connection hang past the response-header timeout).
 		//   2. The model streamed transient reasoning and began a tool call (e.g. a
@@ -463,13 +477,27 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 		//      re-render is transient previews, not duplicated answer text. This is
 		//      why the gate no longer excludes collected.ToolCalls: an incomplete
 		//      tool call from a timed-out stream is discard-and-retry, not output.
+		//   3. Mid-stream socket abort after connect succeeded (Windows WSAECONNABORTED /
+		//      wsarecv, connection reset by peer). Same no-tool-executed safety: the
+		//      error returns before tool dispatch, so a bounded retry is safe.
 		// A turn that forwarded real prose is NOT retried (it would duplicate visible
 		// answer text) and falls through to the error return below. Capped +
 		// exponential backoff, with a user-visible notice per attempt.
 		for attempt := 1; attempt <= maxStreamStallRetries &&
-			isStreamTimeoutError(collected.Error) && !forwardedVisibleText &&
+			(isStreamTimeoutError(collected.Error) || isMidStreamTransportAbort(collected.Error)) &&
+			!forwardedVisibleText &&
 			collected.Text == ""; attempt++ {
-			if notify := stallRetryNoticeFor(options); notify != nil {
+			var notify reconnectNotifier
+			if isStreamTimeoutError(collected.Error) {
+				notify = stallRetryNoticeFor(options)
+			} else {
+				notify = reconnectNoticeFor(options)
+				// Count this post-connect reissue even when the replacement
+				// connect succeeds immediately. streamWithReconnect only
+				// increments reconnect_count after a failed connect attempt.
+				options.Trace.Counter(trace.CounterReconnectCount, 1)
+			}
+			if notify != nil {
 				notify(attempt, maxStreamStallRetries)
 			}
 			if err := sleepWithContext(ctx, backoffFor(attempt)); err != nil {
@@ -482,12 +510,22 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 			retryStream, retryErr := streamWithReconnect(ctx, provider, retryRequest, reconnectNoticeFor(options))
 			if retryErr != nil {
 				result.Messages = copyMessages(messages)
+				if ctx.Err() != nil {
+					return result, ctx.Err()
+				}
 				return result, retryErr
 			}
 			stallGenSpan := options.Trace.Span(trace.SpanGeneration)
 			collected = zeroruntime.CollectStreamWithOptions(ctx, retryStream, forwardingOpts)
 			stallGenSpan.End()
 		}
+		// Recheck ctx after a retried CollectStream: helpers.go stores
+		// ctx.Err().Error() in collected.Error, and errors.New of that string
+		// drops the context.Canceled sentinel ACP branches on.
+		if ctx.Err() != nil {
+			result.Messages = copyMessages(messages)
+			return result, ctx.Err()
+		}
 		if collected.Error != "" {
 			// Route a reissued stream's non-stall error through the SAME recovery as
 			// the initial stream (image-rejection wrapping / context-limit compaction)
@@ -498,6 +536,10 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 				result.Messages = copyMessages(messages)
 				return result, stop
 			}
+			if ctx.Err() != nil {
+				result.Messages = copyMessages(messages)
+				return result, ctx.Err()
+			}
 			if collected.Error != "" {
 				result.Messages = copyMessages(messages)
 				return result, errors.New(collected.Error)
@@ -646,9 +688,25 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 		// recorded. They travel as user messages, and a user message between two
 		// tool_results breaks strict provider replay — Anthropic coalesces them
 		// into one user block list and requires the tool_result blocks first, so
-		// interleaving yields [tool_result, text, image, tool_result] and a 400.
-		// Same reason the self-correction feedback below is deferred.
-		var toolImageMessages []zeroruntime.Message
+		// Images ride a following USER message rather than the tool result
+		// above. Every provider drops images on a tool-role message —
+		// Anthropic's tool_result content is a string, Gemini's is a
+		// functionResponse, and OpenAI guards its image parts to the user role
+		// — so attaching them there would silently deliver nothing. A separate
+		// message also keeps the one-tool-result-per-tool-call pairing intact,
+		// which the providers validate. Vision-gate evaluation is deferred until
+		// after any model switch this turn resolves, so images can reach an
+		// escalated vision-capable model.
+		var toolResultsWithImages []ToolResult
+		buildToolImageMessages := func() []zeroruntime.Message {
+			var out []zeroruntime.Message
+			for _, tr := range toolResultsWithImages {
+				if imageMessage, ok := toolResultImageMessage(tr, options); ok {
+					out = append(out, imageMessage)
+				}
+			}
+			return out
+		}
 		// Parallel read-ahead state: results for calls[precomputedStart:precomputedEnd]
 		// executed concurrently, consumed strictly in order below.
 		var precomputed []precomputedToolResult
@@ -705,15 +763,8 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 				IsError:            toolResult.Status == tools.StatusError,
 				ChangedFiles:       append([]string(nil), toolResult.ChangedFiles...),
 			})
-			// Images ride a following USER message rather than the tool result
-			// above. Every provider drops images on a tool-role message —
-			// Anthropic's tool_result content is a string, Gemini's is a
-			// functionResponse, and OpenAI guards its image parts to the user role
-			// — so attaching them there would silently deliver nothing. A separate
-			// message also keeps the one-tool-result-per-tool-call pairing intact,
-			// which the providers validate.
-			if imageMessage, ok := toolResultImageMessage(toolResult); ok {
-				toolImageMessages = append(toolImageMessages, imageMessage)
+			if len(toolResult.Images) > 0 {
+				toolResultsWithImages = append(toolResultsWithImages, toolResult)
 			}

 			// A tool may demand the run ABORT — a canceled/timed-out ask_user prompt
@@ -725,13 +776,13 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 			}
 			if abortErr != nil {
 				messages = appendAbortedToolResults(messages, collected.ToolCalls[index+1:])
-				messages = append(messages, toolImageMessages...)
+				messages = append(messages, buildToolImageMessages()...)
 				result.Messages = copyMessages(messages)
 				return result, abortErr
 			}
 			if stopReason := stopReasonFromToolResult(toolResult); stopReason != "" {
 				messages = appendAbortedToolResults(messages, collected.ToolCalls[index+1:])
-				messages = append(messages, toolImageMessages...)
+				messages = append(messages, buildToolImageMessages()...)
 				result.FinalAnswer = toolResult.ModelOutput()
 				result.StopReason = stopReason
 				result.Messages = copyMessages(messages)
@@ -755,7 +806,7 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 				// messages stay valid for a strict provider replay (Anthropic
 				// rejects a tool_use with no answering tool_result).
 				messages = appendAbortedToolResults(messages, collected.ToolCalls[index+1:])
-				messages = append(messages, toolImageMessages...)
+				messages = append(messages, buildToolImageMessages()...)
 				result.FinalAnswer = toolFailureStopAnswer(call.Name, outcome.Count)
 				result.Messages = copyMessages(messages)
 				return result, nil
@@ -774,10 +825,6 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 				postEditDiagnostics.enqueue(ctx, toolResult.ChangedFiles)
 			}
 		}
-		// Every tool_result for this turn is now recorded, including aborted
-		// placeholders, so the images can follow without splitting them.
-		messages = append(messages, toolImageMessages...)
-		toolImageMessages = nil

 		// Run post-edit self-correction once over the union of files this turn
 		// changed, then append any feedback after every tool_result is recorded so
@@ -865,6 +912,12 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 			}
 		}

+		// Every tool_result, self-correct notice, and model-switch update for this
+		// turn is now in place; evaluate and append image messages against the
+		// effective (potentially escalated) model.
+		messages = append(messages, buildToolImageMessages()...)
+		toolResultsWithImages = nil
+
 		// A turn can mix valid tool calls with a dropped (nameless) one. The valid
 		// calls executed above; surface the dropped call too so it is never
 		// silently ignored just because the turn also did real work. This is
@@ -3464,8 +3517,10 @@ func copyMessages(messages []Message) []Message {
 //
 // The text names the tool so the model can tell which call an image came from
 // when several ran in one turn — the images arrive detached from their tool
-// result, so nothing else associates them.
-func toolResultImageMessage(result ToolResult) (zeroruntime.Message, bool) {
+// result, so nothing else associates them. If the effective model cannot
+// accept images, the tool's text result is left unchanged and this follow-up
+// is a notice with no image parts, matching the CLI/TUI vision gate.
+func toolResultImageMessage(result ToolResult, options Options) (zeroruntime.Message, bool) {
 	images := make([]zeroruntime.ImageBlock, 0, len(result.Images))
 	for _, image := range result.Images {
 		if len(image.Data) == 0 {
@@ -3486,9 +3541,26 @@ func toolResultImageMessage(result ToolResult) (zeroruntime.Message, bool) {
 	if label == "" {
 		label = "tool"
 	}
+	if !modelAcceptsToolImages(options) {
+		return zeroruntime.Message{
+			Role:    zeroruntime.MessageRoleUser,
+			Content: "Image output from " + label + " was not sent because the current model does not support image input. Switch to a vision-capable model before retrying image delivery, including any images skipped by the tool's image budget.",
+		}, true
+	}
 	return zeroruntime.Message{
 		Role:    zeroruntime.MessageRoleUser,
 		Content: "Image output from " + label + ":",
 		Images:  images,
 	}, true
 }
+
+func modelAcceptsToolImages(options Options) bool {
+	if options.SupportsVision != nil {
+		return options.SupportsVision(options.Model)
+	}
+	registry, err := modelregistry.DefaultRegistry()
+	if err != nil {
+		return modelregistry.VisionCapableByName(options.Model)
+	}
+	return modelregistry.SupportsVision(registry, options.Model)
+}
@@ -0,0 +1,487 @@
+package agent
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/tools"
+	"github.com/Gitlawb/zero/internal/trace"
+	"github.com/Gitlawb/zero/internal/zeroruntime"
+)
+
+// midStreamAbortProvider connects successfully but emits a transport-abort
+// StreamEventError on the first abortBefore calls, then succeeds with "done".
+// hangOnCall, if > 0, makes that 1-based call block until ctx is done so a
+// cancel during the retried CollectStream can be reproduced.
+// connectFailFrom, if > 0, makes that 1-based call and later return a
+// reconnectable connect error so streamWithReconnect enters its backoff.
+type midStreamAbortProvider struct {
+	calls           int32
+	abortBefore     int32
+	abortError      string
+	partialText     string
+	emptyTextEvent  bool
+	partialToolCall string
+	hangOnCall      int32
+	connectFailFrom int32
+	connectErr      string
+	started         chan struct{}
+}
+
+func (p *midStreamAbortProvider) StreamCompletion(ctx context.Context, _ zeroruntime.CompletionRequest) (<-chan zeroruntime.StreamEvent, error) {
+	n := atomic.AddInt32(&p.calls, 1)
+	if p.connectFailFrom > 0 && n >= p.connectFailFrom {
+		if p.started != nil {
+			select {
+			case <-p.started:
+			default:
+				close(p.started)
+			}
+		}
+		errMsg := p.connectErr
+		if errMsg == "" {
+			errMsg = "connection reset by peer"
+		}
+		return nil, errors.New(errMsg)
+	}
+	if p.hangOnCall > 0 && n == p.hangOnCall {
+		if p.started != nil {
+			close(p.started)
+		}
+		ch := make(chan zeroruntime.StreamEvent)
+		go func() {
+			<-ctx.Done()
+			close(ch)
+		}()
+		return ch, nil
+	}
+	ch := make(chan zeroruntime.StreamEvent, 5)
+	if n <= p.abortBefore {
+		if p.emptyTextEvent {
+			ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventText, Content: ""}
+		}
+		if p.partialText != "" {
+			ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventText, Content: p.partialText}
+		}
+		if p.partialToolCall != "" {
+			ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "tc_1", ToolName: p.partialToolCall}
+			ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "tc_1", ArgumentsFragment: `{"path":"x.html","content":"<!doctype`}
+		}
+		errMsg := p.abortError
+		if errMsg == "" {
+			errMsg = "provider stream error: read: connection reset by peer"
+		}
+		ch <- zeroruntime.StreamEvent{
+			Type:  zeroruntime.StreamEventError,
+			Error: errMsg,
+		}
+		close(ch)
+		return ch, nil
+	}
+	ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventText, Content: "done"}
+	ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventDone}
+	close(ch)
+	return ch, nil
+}
+
+func TestRunRetriesMidStreamConnectionReset(t *testing.T) {
+	p := &midStreamAbortProvider{abortBefore: 1}
+	result, err := Run(context.Background(), "go", p, Options{Registry: tools.NewRegistry()})
+	if err != nil {
+		t.Fatalf("a mid-stream connection reset should retry to success, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+}
+
+func TestRunRetriesMidStreamWindowsAbort(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider stream error: read: wsarecv: An established connection was aborted by the software in your host machine",
+	}
+	result, err := Run(context.Background(), "go", p, Options{Registry: tools.NewRegistry()})
+	if err != nil {
+		t.Fatalf("a Windows mid-stream abort should retry to success, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+}
+
+// wsarecv alone (no "connection was aborted" substring) must still retry, so
+// deleting the wsarecv needle cannot go green.
+func TestRunRetriesMidStreamWsarecvNeedle(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider stream error: read: wsarecv: 10053",
+	}
+	result, err := Run(context.Background(), "go", p, Options{Registry: tools.NewRegistry()})
+	if err != nil {
+		t.Fatalf("wsarecv without 'connection was aborted' should retry to success, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+}
+
+func TestRunDoesNotRetryMidStreamAbortAfterPartialOutput(t *testing.T) {
+	sawText := 0
+	p := &midStreamAbortProvider{abortBefore: 1, partialText: "partial"}
+	_, err := Run(context.Background(), "go", p, Options{
+		Registry: tools.NewRegistry(),
+		OnText:   func(string) { sawText++ },
+	})
+	if err == nil {
+		t.Fatal("a mid-stream abort after partial output must NOT be retried; want an error")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 1 {
+		t.Fatalf("partial-then-abort must not retry, got %d calls", got)
+	}
+	if sawText == 0 {
+		t.Fatal("OnText must have fired so forwardedVisibleText is the named guard")
+	}
+}
+
+// A zero-length OnText chunk is not committed answer prose, so an eligible
+// transport abort still retries.
+func TestRunRetriesMidStreamAbortAfterEmptyTextEvent(t *testing.T) {
+	p := &midStreamAbortProvider{abortBefore: 1, emptyTextEvent: true}
+	result, err := Run(context.Background(), "go", p, Options{
+		Registry: tools.NewRegistry(),
+		OnText:   func(string) {},
+	})
+	if err != nil {
+		t.Fatalf("empty OnText must not block mid-stream abort retry, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+}
+
+func TestRunRetriesMidStreamAbortAfterIncompleteToolCall(t *testing.T) {
+	starts := 0
+	dispatched := 0
+	p := &midStreamAbortProvider{abortBefore: 1, partialToolCall: "write_file"}
+	result, err := Run(context.Background(), "go", p, Options{
+		Registry:        tools.NewRegistry(),
+		OnToolCallStart: func(string, string) { starts++ },
+		OnToolCallDelta: func(string, string) {},
+		OnToolCall:      func(ToolCall) { dispatched++ },
+	})
+	if err != nil {
+		t.Fatalf("a mid-stream abort mid-incomplete-tool-call should retry to success, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+	if starts != 1 {
+		t.Fatalf("the incomplete tool call should have been forwarded once before the abort, got %d starts", starts)
+	}
+	if dispatched != 0 {
+		t.Fatalf("OnToolCall must never fire for an incomplete aborted tool call (no dispatch), got %d", dispatched)
+	}
+}
+
+func TestRunGivesUpAfterMaxMidStreamAbortRetries(t *testing.T) {
+	if maxStreamStallRetries != 1 {
+		t.Fatalf("maxStreamStallRetries = %d, want 1 (#973 must not raise this bound)", maxStreamStallRetries)
+	}
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = time.Millisecond
+	p := &midStreamAbortProvider{abortBefore: 99}
+	_, err := Run(context.Background(), "go", p, Options{Registry: tools.NewRegistry()})
+	if err == nil {
+		t.Fatal("a persistent mid-stream abort must surface an error after exhausting retries")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry); pin the bound at 1, got %d", got)
+	}
+}
+
+func TestRunMidStreamAbortUsesReconnectNotice(t *testing.T) {
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = time.Millisecond
+	var notices string
+	p := &midStreamAbortProvider{abortBefore: 1}
+	result, err := Run(context.Background(), "go", p, Options{
+		Registry:    tools.NewRegistry(),
+		OnReasoning: func(s string) { notices += s },
+	})
+	if err != nil {
+		t.Fatalf("retry should succeed, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	lower := strings.ToLower(notices)
+	if !strings.Contains(lower, "connection lost") || !strings.Contains(lower, "reconnecting") {
+		t.Fatalf("transport abort must use reconnect wording, notices = %q", notices)
+	}
+	if strings.Contains(lower, "model stalled") {
+		t.Fatalf("transport abort must not use stall wording, notices = %q", notices)
+	}
+}
+
+func TestRunCancelDuringMidStreamRetryPreservesContextCanceled(t *testing.T) {
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = time.Millisecond
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	started := make(chan struct{})
+	p := &midStreamAbortProvider{abortBefore: 1, hangOnCall: 2, started: started}
+	errCh := make(chan error, 1)
+	go func() {
+		_, err := Run(ctx, "go", p, Options{Registry: tools.NewRegistry()})
+		errCh <- err
+	}()
+	select {
+	case <-started:
+	case <-time.After(5 * time.Second):
+		t.Fatal("timed out waiting for retried stream")
+	}
+	cancel()
+	err := <-errCh
+	if err == nil {
+		t.Fatal("want context.Canceled after cancel during retried stream")
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("cancel during retried stream must keep the sentinel, got %q (errors.Is Canceled = false)", err)
+	}
+}
+
+func TestRunCancelDuringReplacementConnectBackoffPreservesContextCanceled(t *testing.T) {
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = 200 * time.Millisecond
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	started := make(chan struct{})
+	p := &midStreamAbortProvider{abortBefore: 1, connectFailFrom: 2, started: started}
+	errCh := make(chan error, 1)
+	go func() {
+		_, err := Run(ctx, "go", p, Options{Registry: tools.NewRegistry()})
+		errCh <- err
+	}()
+	select {
+	case <-started:
+	case <-time.After(5 * time.Second):
+		t.Fatal("timed out waiting for replacement connect failure")
+	}
+	cancel()
+	err := <-errCh
+	if err == nil {
+		t.Fatal("want context.Canceled after cancel during replacement connect backoff")
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("cancel during replacement connect backoff must keep the sentinel, got %q (errors.Is Canceled = false)", err)
+	}
+}
+
+func TestRunMidStreamAbortRecordsReconnectCountOnImmediateReplacement(t *testing.T) {
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = time.Millisecond
+	rec := trace.NewRecorder("midstream-abort", "run-1", "test")
+	p := &midStreamAbortProvider{abortBefore: 1}
+	result, err := Run(context.Background(), "go", p, Options{
+		Registry: tools.NewRegistry(),
+		Trace:    rec,
+	})
+	if err != nil {
+		t.Fatalf("retry should succeed, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 immediate replacement), got %d", got)
+	}
+	gotTrace := rec.Finish()
+	if got := gotTrace.Counter(trace.CounterReconnectCount); got != 1 {
+		t.Fatalf("reconnect_count = %d, want 1 for a successful replacement connection", got)
+	}
+	if got := gotTrace.Counter(trace.CounterModelRequests); got != 2 {
+		t.Fatalf("model_requests = %d, want 2 (initial + replacement)", got)
+	}
+}
+
+func TestRunDoesNotRetryResponseHeaderTimeout(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 99,
+		abortError:  "net/http: timeout awaiting response headers",
+	}
+	_, err := Run(context.Background(), "go", p, Options{Registry: tools.NewRegistry()})
+	if err == nil {
+		t.Fatal("a response-header timeout must not be retried as a mid-stream abort")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 1 {
+		t.Fatalf("header timeout must not retry, got %d calls", got)
+	}
+}
+
+func TestIsMidStreamTransportAbort(t *testing.T) {
+	aborts := []string{
+		"provider stream error: read: connection reset by peer",
+		"provider stream error: unexpected EOF",
+		"provider stream error: read: wsarecv: 10053",
+		"provider stream error: read: wsarecv: An established connection was aborted by the software in your host machine",
+		"An existing connection was forcibly closed by the remote host",
+		"provider stream error: read: connection closed",
+		"write: broken pipe",
+		"provider stream error: server closed the connection",
+		"provider stream error: software caused connection abort",
+	}
+	for _, m := range aborts {
+		if !isMidStreamTransportAbort(m) {
+			t.Fatalf("want mid-stream transport abort: %q", m)
+		}
+	}
+	notAborts := []string{
+		"",
+		"context length exceeded",
+		"rate limit error: slow down",
+		"model not found",
+		"net/http: timeout awaiting response headers",
+		"dial tcp 10.0.0.1:443: connect: connection refused",
+		"i/o timeout",
+		"500 Internal Server Error",
+		"502 Bad Gateway",
+		"503 Service Unavailable",
+		"504 Gateway Timeout",
+		"provider request error: request does not satisfy oneOf schema",
+		"provider request error: connection closed is not a supported finish reason",
+		"provider error: connection closed is not a supported finish reason",
+		"provider error: upstream connection reset by peer",
+		"provider error: unexpected EOF while reading upstream response",
+		"provider error: 502 Bad Gateway",
+		"auth error: connection reset by peer",
+		"rate limit error: server closed",
+		"schema error: property oneOf is invalid",
+	}
+	for _, m := range notAborts {
+		if isMidStreamTransportAbort(m) {
+			t.Fatalf("must NOT classify as mid-stream transport abort: %q", m)
+		}
+	}
+}
+
+func TestRunDoesNotRetryClassifiedProviderErrorWithSocketPhrase(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider request error: connection closed is not a supported finish reason",
+	}
+	var notices string
+	opts := Options{
+		Registry:    tools.NewRegistry(),
+		OnReasoning: func(s string) { notices += s },
+	}
+	_, err := Run(context.Background(), "go", p, opts)
+	if err == nil {
+		t.Fatal("expected application error, got nil")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 1 {
+		t.Fatalf("classified provider error with 'connection closed' must not retry (got %d calls, want 1)", got)
+	}
+	if notices != "" {
+		t.Fatalf("expected no reconnect notices, got %q", notices)
+	}
+	if !strings.Contains(err.Error(), "connection closed") {
+		t.Fatalf("expected original error preserved, got %v", err)
+	}
+}
+
+func TestRunDoesNotRetryProviderErrorWithSocketPhrase(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider error: unexpected EOF while reading upstream response",
+	}
+	var notices string
+	opts := Options{
+		Registry:    tools.NewRegistry(),
+		OnReasoning: func(s string) { notices += s },
+	}
+	_, err := Run(context.Background(), "go", p, opts)
+	if err == nil {
+		t.Fatal("expected application error, got nil")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 1 {
+		t.Fatalf("provider error with 'unexpected EOF' must not retry (got %d calls, want 1)", got)
+	}
+	if notices != "" {
+		t.Fatalf("expected no reconnect notices, got %q", notices)
+	}
+	if got := err.Error(); got != p.abortError {
+		t.Fatalf("error = %q, want original provider error %q", got, p.abortError)
+	}
+}
+
+func TestRunDoesNotRetryApplicationErrorContainingEOFSubstring(t *testing.T) {
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider request error: request does not satisfy oneOf schema",
+	}
+	var notices string
+	opts := Options{
+		Registry:    tools.NewRegistry(),
+		OnReasoning: func(s string) { notices += s },
+	}
+	_, err := Run(context.Background(), "go", p, opts)
+	if err == nil {
+		t.Fatal("expected application error, got nil")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 1 {
+		t.Fatalf("application error with 'oneOf' must not retry (got %d calls, want 1)", got)
+	}
+	if notices != "" {
+		t.Fatalf("expected no reconnect notices, got %q", notices)
+	}
+	if !strings.Contains(err.Error(), "oneOf") {
+		t.Fatalf("expected original error preserved, got %v", err)
+	}
+}
+
+func TestRunRetriesMidStreamUnexpectedEOF(t *testing.T) {
+	defer func(orig time.Duration) { streamReconnectBase = orig }(streamReconnectBase)
+	streamReconnectBase = time.Millisecond
+	p := &midStreamAbortProvider{
+		abortBefore: 1,
+		abortError:  "provider stream error: unexpected EOF",
+	}
+	var notices string
+	opts := Options{
+		Registry:    tools.NewRegistry(),
+		OnReasoning: func(s string) { notices += s },
+	}
+	result, err := Run(context.Background(), "go", p, opts)
+	if err != nil {
+		t.Fatalf("unexpected EOF should retry to success, got %v", err)
+	}
+	if result.FinalAnswer != "done" {
+		t.Fatalf("final answer = %q, want %q", result.FinalAnswer, "done")
+	}
+	if got := atomic.LoadInt32(&p.calls); got != 2 {
+		t.Fatalf("want 2 calls (1 abort + 1 retry), got %d", got)
+	}
+	lower := strings.ToLower(notices)
+	if !strings.Contains(lower, "connection lost") || !strings.Contains(lower, "reconnecting") {
+		t.Fatalf("expected reconnect notice, got %q", notices)
+	}
+}
@@ -144,6 +144,15 @@ func shouldReconnect(ctx context.Context, err error) bool {
 		"i/o timeout",
 		"server closed",
 		"unexpected end",
+		// Windows mid-stream aborts (WSAECONNABORTED / wsarecv) — host or AV
+		// forcibly closes an established socket during CollectStream.
+		// "software caused connection abort" is the Unix/macOS ECONNABORTED
+		// text; it also appears in midStreamAbortNeedles, which must stay a
+		// subset of this list.
+		"wsarecv",
+		"connection was aborted",
+		"software caused connection abort",
+		"forcibly closed",
 	} {
 		if strings.Contains(msg, needle) {
 			return true
@@ -152,6 +161,86 @@ func shouldReconnect(ctx context.Context, err error) bool {
 	return false
 }

+// midStreamAbortNeedles are the transport-abort classes retried AFTER connect
+// succeeded and the stream body has started. This is a subset of shouldReconnect:
+// connect-phase signals (timeout, connection refused, "temporarily unavailable")
+// stay on the connect retry path, because matching them here would re-prefill a
+// healthy-but-slow server (ollama cloud header timeouts) and tell the user the
+// connection was lost. Issue #973 names WSAECONNABORTED / connection reset /
+// unexpected stream EOF.
+var midStreamAbortNeedles = []string{
+	"unexpected end",
+	"connection reset",
+	"broken pipe",
+	"connection closed",
+	"server closed",
+	"wsarecv",
+	"connection was aborted",
+	"software caused connection abort",
+	"forcibly closed",
+}
+
+var classifiedNonTransportPrefixes = []string{
+	"provider request error:",
+	"provider error:",
+	"auth error:",
+	"rate limit error:",
+}
+
+// isMidStreamTransportAbort reports whether a collected stream error string is a
+// retryable mid-stream transport abort. It does NOT delegate to shouldReconnect:
+// that list is a connect-phase argument ("no response was received"). The stream
+// body has already started here, so only abort/reset/EOF/close classes retry.
+//
+// Used for failures DURING the stream body AFTER a successful connect and BEFORE
+// tool dispatch — the incomplete turn committed no answer text and executed no
+// tools, so a bounded re-issue is safe (same safety rules as the stall path).
+func isMidStreamTransportAbort(message string) bool {
+	lowered := strings.ToLower(strings.TrimSpace(message))
+	if lowered == "" || isContextLimitError(lowered) {
+		return false
+	}
+	for _, prefix := range classifiedNonTransportPrefixes {
+		if strings.Contains(lowered, prefix) {
+			return false
+		}
+	}
+	if errhint.HasStatusCode(lowered, "500", "502", "503", "504") {
+		return false
+	}
+	if containsWordBoundary(lowered, "eof") {
+		return true
+	}
+	for _, needle := range midStreamAbortNeedles {
+		if strings.Contains(lowered, needle) {
+			return true
+		}
+	}
+	return false
+}
+
+func containsWordBoundary(text, word string) bool {
+	start := 0
+	for {
+		idx := strings.Index(text[start:], word)
+		if idx < 0 {
+			return false
+		}
+		pos := start + idx
+		endPos := pos + len(word)
+		leftBoundary := pos == 0 || !isAlphaNumByte(text[pos-1])
+		rightBoundary := endPos == len(text) || !isAlphaNumByte(text[endPos])
+		if leftBoundary && rightBoundary {
+			return true
+		}
+		start = pos + 1
+	}
+}
+
+func isAlphaNumByte(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
+}
+
 // backoffFor is the deterministic exponential base delay for a 1-based attempt,
 // capped at streamReconnectMax. Jitter is layered on separately (jitteredBackoff).
 func backoffFor(attempt int) time.Duration {
@@ -92,6 +92,12 @@ func TestShouldReconnectClassification(t *testing.T) {
 	disconnects := []string{
 		"unexpected EOF", "connection reset by peer", "broken pipe",
 		"i/o timeout", "server closed the connection", "connection refused",
+		// Windows socket aborts also remain reconnectable at connect time.
+		"wsarecv: An established connection was aborted by the software in your host machine",
+		"read: connection was aborted",
+		// Unix/macOS ECONNABORTED text.
+		"read: software caused connection abort",
+		"An existing connection was forcibly closed by the remote host",
 	}
 	for _, m := range disconnects {
 		if !shouldReconnect(ctx, errors.New(m)) {
@@ -10,6 +10,24 @@ import (
 	"github.com/Gitlawb/zero/internal/zeroruntime"
 )

+func TestNonVisionImageNoticeQualifiesBudgetRecovery(t *testing.T) {
+	result := ToolResult{
+		Name:   "mcp_screenshot",
+		Output: "One image exceeded this result's remaining image budget. Retrying with fewer images can recover this payload.",
+		Images: []zeroruntime.ImageBlock{{MediaType: "image/png", Data: []byte("image")}},
+	}
+	notice, ok := toolResultImageMessage(result, Options{
+		SupportsVision: func(string) bool { return false },
+	})
+	if !ok || len(notice.Images) != 0 {
+		t.Fatal("non-vision delivery must produce a text-only notice")
+	}
+	if !strings.Contains(notice.Content, "Switch to a vision-capable model before retrying") ||
+		!strings.Contains(notice.Content, "budget") {
+		t.Fatalf("notice does not qualify budget recovery: %s", notice.Content)
+	}
+}
+
 // imageTool returns a tool result carrying an image, the way a screenshot tool
 // should be able to.
 type imageTool struct {
@@ -62,6 +80,7 @@ func TestRunDeliversToolResultImagesToTheModel(t *testing.T) {
 	result, err := Run(context.Background(), "screenshot please", provider, Options{
 		Registry: registry,
 		MaxTurns: 2,
+		Model:    "gpt-4o",
 	})
 	if err != nil {
 		t.Fatalf("Run: %v", err)
@@ -86,11 +105,16 @@ func TestRunDeliversToolResultImagesToTheModel(t *testing.T) {

 	// The tool-result pairing must be untouched: one tool result per tool call.
 	toolResults := 0
+	var toolText string
 	for _, message := range result.Messages {
 		if message.Role == zeroruntime.MessageRoleTool {
 			toolResults++
+			toolText = message.Content
 		}
 	}
+	if toolText != "Captured a screenshot." {
+		t.Fatalf("tool text = %q, want preserved", toolText)
+	}
 	if toolResults != 1 {
 		t.Errorf("got %d tool-result messages for 1 tool call", toolResults)
 	}
@@ -136,7 +160,7 @@ func TestRunKeepsToolResultsContiguousWhenAToolReturnsAnImage(t *testing.T) {
 		{{Type: zeroruntime.StreamEventText, Content: "done"}, {Type: zeroruntime.StreamEventDone}},
 	}}

-	result, err := Run(context.Background(), "two calls", provider, Options{Registry: registry, MaxTurns: 2})
+	result, err := Run(context.Background(), "two calls", provider, Options{Registry: registry, MaxTurns: 2, Model: "gpt-4o"})
 	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
@@ -205,3 +229,176 @@ func messageShape(messages []zeroruntime.Message) string {
 	}
 	return "[" + strings.Join(parts, " ") + "]"
 }
+
+func TestRunDropsToolResultImagesForANonVisionModel(t *testing.T) {
+	registry := tools.NewRegistry()
+	registry.Register(imageTool{media: "image/png", data: []byte("\x89PNG\r\n\x1a\nfake")})
+	provider := &mockProvider{turns: [][]zeroruntime.StreamEvent{
+		{
+			{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "call_1", ToolName: "capture"},
+			{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "call_1", ArgumentsFragment: `{}`},
+			{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: "call_1"},
+			{Type: zeroruntime.StreamEventDone},
+		},
+		{{Type: zeroruntime.StreamEventText, Content: "ok"}, {Type: zeroruntime.StreamEventDone}},
+	}}
+
+	result, err := Run(context.Background(), "screenshot please", provider, Options{
+		Registry: registry,
+		MaxTurns: 2,
+		Model:    "totally-made-up-model",
+	})
+	if err != nil {
+		t.Fatalf("Run: %v", err)
+	}
+	var toolText string
+	var noticed bool
+	for _, message := range result.Messages {
+		if message.Role == zeroruntime.MessageRoleTool {
+			toolText = message.Content
+		}
+		if len(message.Images) > 0 {
+			t.Fatalf("non-vision model received image bytes on %q: %s", message.Role, messageShape(result.Messages))
+		}
+		if strings.Contains(message.Content, "does not support image input") {
+			noticed = true
+		}
+	}
+	if toolText != "Captured a screenshot." {
+		t.Fatalf("tool text = %q, want preserved on the non-vision path", toolText)
+	}
+	if !noticed {
+		t.Fatalf("non-vision model was not told the image was dropped; recorded %s", messageShape(result.Messages))
+	}
+}
+
+type switchAndCaptureTool struct {
+	targetModel string
+}
+
+func (switchAndCaptureTool) Name() string        { return "switch_and_capture" }
+func (switchAndCaptureTool) Description() string { return "Switches model and captures image" }
+func (switchAndCaptureTool) Parameters() tools.Schema {
+	return tools.Schema{Type: "object", Properties: map[string]tools.PropertySchema{}}
+}
+func (switchAndCaptureTool) Safety() tools.Safety {
+	return tools.Safety{Permission: tools.PermissionAllow}
+}
+func (t switchAndCaptureTool) Run(context.Context, map[string]any) tools.Result {
+	return tools.Result{
+		Status: tools.StatusOK,
+		Output: "[image returned by tool]",
+		Images: []zeroruntime.ImageBlock{{MediaType: "image/png", Data: []byte("\x89PNG\r\n\x1a\nfake")}},
+		Meta:   map[string]string{"escalate_to_model": t.targetModel},
+	}
+}
+
+func TestRunToolImagesRespectsModelSwitch(t *testing.T) {
+	t.Run("Non-vision to vision model escalation forwards images", func(t *testing.T) {
+		registry := tools.NewRegistry()
+		registry.Register(switchAndCaptureTool{targetModel: "gpt-4o"})
+
+		provider := &mockProvider{turns: [][]zeroruntime.StreamEvent{
+			{
+				{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "call_1", ToolName: "switch_and_capture"},
+				{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "call_1", ArgumentsFragment: `{}`},
+				{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: "call_1"},
+				{Type: zeroruntime.StreamEventDone},
+			},
+			{
+				{Type: zeroruntime.StreamEventText, Content: "I see it on gpt-4o."},
+				{Type: zeroruntime.StreamEventDone},
+			},
+		}}
+
+		switched := false
+		switcher := func(_ context.Context, modelID string) (Provider, error) {
+			switched = true
+			return provider, nil
+		}
+
+		result, err := Run(context.Background(), "test", provider, Options{
+			Registry:      registry,
+			MaxTurns:      2,
+			Model:         "non-vision-initial",
+			ModelSwitcher: switcher,
+			SupportsVision: func(modelID string) bool {
+				return modelID == "gpt-4o"
+			},
+		})
+		if err != nil {
+			t.Fatalf("Run: %v", err)
+		}
+		if !switched {
+			t.Fatal("expected model switch to occur")
+		}
+
+		var carrier *zeroruntime.Message
+		for index := range result.Messages {
+			if len(result.Messages[index].Images) > 0 {
+				carrier = &result.Messages[index]
+			}
+			if strings.Contains(result.Messages[index].Content, "does not support image input") {
+				t.Fatalf("images were unexpectedly dropped after switch to vision model: %v", result.Messages[index])
+			}
+		}
+		if carrier == nil {
+			t.Fatal("expected image carrier message after escalation to vision model")
+		}
+	})
+
+	t.Run("Vision to non-vision model switch drops images with notice", func(t *testing.T) {
+		registry := tools.NewRegistry()
+		registry.Register(switchAndCaptureTool{targetModel: "text-only-dest"})
+
+		provider := &mockProvider{turns: [][]zeroruntime.StreamEvent{
+			{
+				{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "call_1", ToolName: "switch_and_capture"},
+				{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "call_1", ArgumentsFragment: `{}`},
+				{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: "call_1"},
+				{Type: zeroruntime.StreamEventDone},
+			},
+			{
+				{Type: zeroruntime.StreamEventText, Content: "ok."},
+				{Type: zeroruntime.StreamEventDone},
+			},
+		}}
+
+		switcher := func(_ context.Context, modelID string) (Provider, error) {
+			return provider, nil
+		}
+
+		result, err := Run(context.Background(), "test", provider, Options{
+			Registry:      registry,
+			MaxTurns:      2,
+			Model:         "gpt-4o",
+			ModelSwitcher: switcher,
+			SupportsVision: func(modelID string) bool {
+				return modelID == "gpt-4o"
+			},
+		})
+		if err != nil {
+			t.Fatalf("Run: %v", err)
+		}
+
+		var noticed bool
+		var toolOutputSeen bool
+		for _, m := range result.Messages {
+			if len(m.Images) > 0 {
+				t.Fatalf("image delivered to non-vision destination model: %v", m)
+			}
+			if strings.Contains(m.Content, "does not support image input") {
+				noticed = true
+			}
+			if strings.Contains(m.Content, "[image returned by tool]") {
+				toolOutputSeen = true
+			}
+		}
+		if !noticed {
+			t.Fatal("expected drop notice when switching to non-vision model")
+		}
+		if !toolOutputSeen {
+			t.Fatal("expected tool output preserved in message history")
+		}
+	})
+}
@@ -341,6 +341,11 @@ type Options struct {
 	// nil for text-only runs (the seeded message then carries no images, exactly
 	// as before).
 	Images []zeroruntime.ImageBlock
+	// SupportsVision, when set, reports whether the effective model accepts
+	// image input. Tool-produced images are dropped at the shared delivery
+	// boundary when this is false. nil uses the curated catalog plus the
+	// name heuristic via modelregistry.SupportsVision.
+	SupportsVision func(modelID string) bool
 	// ContextWindow is the model's maximum input token budget. When > 0 the agent
 	// loop compacts long conversations once the estimated size crosses a fraction
 	// of this window. 0 DISABLES compaction entirely (every existing caller/test
@@ -1,409 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"path/filepath"
-	"sort"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// An imported session's tool work never reaches the model.
-//
-// sessions.promptContextEvents — the filter behind both `zero exec --resume` and
-// the TUI's /resume — passes only EventMessage, EventCompaction, EventError and
-// the session-lifecycle types. EventToolCall and EventToolResult are not in that
-// list, so every file the other agent read, every command it ran and every error
-// it hit is visible in the transcript and invisible to the model continuing the
-// work. On a real 22-event import that left 2 messages and 1,155 characters of
-// context.
-//
-// This file closes that gap without touching the shared filter: while
-// translating, it records what the tools actually did and emits the result as
-// an assistant EventMessage, a type the filter already passes.
-//
-// EventCompaction also passes the filter and was the first choice, but it
-// carries a second contract on the replay side — RehydrateEvents restructures
-// the transcript around the last one — so a summary with no CompactionPayload
-// bookkeeping is hoisted to the front on resume. EventMessage passes the digest
-// with no such side effect; see noteEvent.
-//
-// Zero's own compaction was the other alternative and is strictly worse here:
-// sessions.toolPayloadPreview allow-lists id/name/toolName/status and drops
-// "arguments" and "output", so a compaction summariser learns that a Read failed
-// but never which file or why. At translation time those values are still in
-// hand.
-
-// maxSummaryEventBytes keeps one summary event inside the digest's per-event
-// budget. sessions.summarizePayload truncates every event to 500 bytes, so
-// a single long summary would be sliced mid-sentence; several short ones each
-// arrive intact. The margin absorbs the payload's own framing.
-const maxSummaryEventBytes = 460
-
-// maxSummaryItems bounds one line's list before it collapses to a count. A
-// session that touched ninety files should say so rather than name eleven of
-// them and imply that was all.
-const maxSummaryItems = 12
-
-// activityLog accumulates what another agent's tools did during a translation.
-// It is filled from the same pass that builds the events, so it costs no extra
-// read of the transcript.
-type activityLog struct {
-	cwd string
-
-	calls  int
-	failed int
-
-	read     []string
-	changed  []string
-	commands []string
-	searches []string
-	failures []string
-
-	// pendingPath maps a call id to the file claim it would contribute, held
-	// until the call's RESULT is known. A path is committed to its bucket only
-	// once a success result confirms the tool ran: a Read of a path that does
-	// not exist must not appear under "Files read", and a Write whose result
-	// never arrives (an interrupted final call) must not appear under "Files
-	// changed" — both read as fact and are exactly the wrong thing to tell the
-	// next model. A claim still pending when the transcript ends is discarded.
-	pendingPath map[string]pathClaim
-
-	// toolCounts is the fallback when nothing could be extracted from a tool's
-	// arguments: naming the tools and how often they ran is still true, where
-	// guessing at a filename would not be.
-	toolCounts map[string]int
-
-	seen map[string]bool
-}
-
-// pathClaim is a file path a call would contribute to a bucket, remembered until
-// its result is known and only then committed.
-type pathClaim struct {
-	bucket string
-	value  string
-}
-
-func newActivityLog(cwd string) *activityLog {
-	return &activityLog{
-		cwd:         cwd,
-		toolCounts:  map[string]int{},
-		seen:        map[string]bool{},
-		pendingPath: map[string]pathClaim{},
-	}
-}
-
-// commitClaim records a pending file claim now that its call has succeeded.
-// Committing on success rather than withdrawing on failure is what keeps the
-// keying correct: a successful Write of a path and a later FAILED Edit of the
-// same path each carry their own call id, so the failure simply never commits
-// and cannot erase the success — the withdraw-by-value it replaced could.
-func (log *activityLog) commitClaim(claim pathClaim) {
-	list := &log.read
-	if claim.bucket == "changed" {
-		list = &log.changed
-	}
-	log.add(claim.bucket, list, claim.value)
-}
-
-// add appends value to list unless an equal value is already recorded under
-// bucket. Deduplicated because agents re-read the same file repeatedly and a
-// list of forty identical paths tells the reader nothing.
-func (log *activityLog) add(bucket string, list *[]string, value string) {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return
-	}
-	key := bucket + "\x00" + trimmed
-	if log.seen[key] {
-		return
-	}
-	log.seen[key] = true
-	*list = append(*list, trimmed)
-}
-
-// observeCall records one tool invocation.
-//
-// Classification is by ARGUMENT KEY, not by tool name. Tool names differ across
-// agents and versions (Read/read_file/view, Bash/exec/shell), but the parameter
-// carrying a path is reliably called some spelling of "path", and a command is
-// reliably "command". Keys are allow-listed rather than sniffed: an unknown
-// schema falls back to the tool-name count instead of guessing which field is a
-// filename (repo invariant #2, and #8 — these arguments are untrusted input).
-func (log *activityLog) observeCall(callID string, name string, arguments string) {
-	log.calls++
-	trimmedName := strings.TrimSpace(DisplayField(name))
-	if trimmedName == "" {
-		trimmedName = "unknown"
-	}
-
-	fields := map[string]any{}
-	if json.Unmarshal([]byte(arguments), &fields) != nil {
-		// Not a JSON object. Codex's custom_tool_call carries a bare script in
-		// "input", which is a command in every sense that matters here.
-		if script := strings.TrimSpace(arguments); script != "" {
-			log.add("cmd", &log.commands, log.shorten(script))
-			return
-		}
-		log.toolCounts[trimmedName]++
-		return
-	}
-
-	if command := firstStringField(fields, "command", "cmd", "script", "input"); command != "" {
-		log.add("cmd", &log.commands, log.shorten(command))
-		return
-	}
-	if pattern := firstStringField(fields, "pattern", "query", "search_query", "regex"); pattern != "" {
-		log.add("search", &log.searches, log.shorten(pattern))
-		return
-	}
-	if path := firstStringField(fields, "file_path", "filePath", "path", "notebook_path", "target_file"); path != "" {
-		bucket := "read"
-		if isMutatingToolName(trimmedName) {
-			bucket = "changed"
-		}
-		// Hold the claim, do not record it yet: it is committed only when this
-		// call's result confirms success (observeResult). A failed call never
-		// commits, and a call whose result never arrives stays pending and is
-		// dropped, so neither can claim a file it may not have touched.
-		log.pendingPath[callID] = pathClaim{bucket: bucket, value: log.relative(path)}
-		return
-	}
-	log.toolCounts[trimmedName]++
-}
-
-// observeResult records a tool's outcome. A success commits the call's held
-// file claim (see observeCall); a failure drops it and is itself recorded in the
-// failures bucket — the single most useful thing to carry forward, since it is
-// what the next model would otherwise repeat.
-func (log *activityLog) observeResult(callID string, name string, status tools.Status, output string) {
-	claim, hadClaim := log.pendingPath[callID]
-	delete(log.pendingPath, callID)
-	if status == tools.StatusOK {
-		// Success confirms the call ran: only now is its path recorded.
-		if hadClaim {
-			log.commitClaim(claim)
-		}
-		return
-	}
-	if status != tools.StatusError {
-		// A foreign format that supplies no outcome evidence is not proof of
-		// success or failure. Drop its pending factual claim while preserving the
-		// raw result event for history.
-		return
-	}
-	// The call did not do what it claimed, so its pending claim is dropped
-	// (never committed) and the failure itself is recorded below.
-	log.failed++
-	trimmedName := strings.TrimSpace(DisplayField(name))
-	if trimmedName == "" {
-		trimmedName = "unknown"
-	}
-	detail := log.shorten(output)
-	if detail == "" {
-		detail = "failed"
-	}
-	log.add("fail", &log.failures, trimmedName+": "+detail)
-}
-
-// isMutatingToolName reports whether a tool that takes a path changes the file.
-// Substring matching on the name is deliberate: it holds across Write/write_file/
-// FileWrite/apply_patch without a per-agent table to keep in sync.
-func isMutatingToolName(name string) bool {
-	lowered := strings.ToLower(name)
-	for _, marker := range []string{"write", "edit", "patch", "create", "append", "insert", "replace", "delete", "remove"} {
-		if strings.Contains(lowered, marker) {
-			return true
-		}
-	}
-	return false
-}
-
-// relative shortens an absolute path against the session's working directory,
-// so a summary reads "internal/tui/model.go" instead of consuming a third of its
-// character budget on a repeated home-directory prefix. A path outside the
-// workspace keeps its absolute form — that it lies elsewhere is the interesting
-// part.
-func (log *activityLog) relative(path string) string {
-	trimmed := strings.TrimSpace(path)
-	root := strings.TrimSpace(log.cwd)
-	if trimmed == "" || root == "" {
-		return log.shorten(trimmed)
-	}
-	if relative, err := filepath.Rel(root, trimmed); err == nil && !strings.HasPrefix(relative, "..") {
-		return log.shorten(relative)
-	}
-	return log.shorten(trimmed)
-}
-
-// shorten caps a single item so one long value cannot crowd out the rest of its
-// line.
-func (log *activityLog) shorten(value string) string {
-	const limit = 120
-	// Redact sees the complete value before this presentation copy loses later
-	// lines or its tail. Truncating first can cut away the syntax that lets the
-	// shared redactor recognize a credential. Keep the established first-line
-	// activity policy after that complete-value pass.
-	selected := firstLine(redact(value))
-	// DisplayField adds the presentation-only split-credential pass after the
-	// complete-value redactor has retained the established first-line boundary.
-	// Run it before Fields rejoins whitespace-separated credential fragments.
-	collapsed := strings.Join(strings.Fields(DisplayField(selected)), " ")
-	runes := []rune(collapsed)
-	if len(runes) <= limit {
-		return collapsed
-	}
-	return string(runes[:limit]) + "…"
-}
-
-func firstLine(value string) string {
-	if index := strings.IndexAny(value, "\r\n"); index >= 0 {
-		return value[:index]
-	}
-	return value
-}
-
-// firstStringField returns the first non-empty string among the named keys.
-func firstStringField(fields map[string]any, keys ...string) string {
-	for _, key := range keys {
-		if value, ok := fields[key].(string); ok && strings.TrimSpace(value) != "" {
-			return value
-		}
-	}
-	return ""
-}
-
-// summaryEvents renders the log as assistant EventMessage events, one per category.
-//
-// Several small events rather than one large one, because the resume digest
-// truncates each event at 500 characters — a single combined summary would lose
-// its tail. Failures come last so they sit closest to the user's new request.
-func (log *activityLog) summaryEvents() []sessions.AppendEventInput {
-	if log == nil || log.calls == 0 {
-		return nil
-	}
-
-	events := []sessions.AppendEventInput{}
-	headline := "Prior session activity: " + countPhrase(log.calls, "tool call")
-	if log.failed > 0 {
-		headline += ", " + countPhrase(log.failed, "failure")
-	}
-	headline += "."
-	if extra := log.toolBreakdown(); extra != "" {
-		headline += " " + extra
-	}
-	// THE BUDGET APPLIES TO THE ASSEMBLED LINE, NOT TO A PIECE OF IT. Only the
-	// breakdown was capped, so the count prefix rode on top of an already
-	// full-length tail: a session full of unrecognised tool names produced a
-	// 500-character note, which is exactly where sessions.summarizePayload cuts —
-	// the mid-sentence truncation maxSummaryEventChars exists to keep off.
-	events = append(events, noteEvent(truncateToBudget(headline, maxSummaryEventBytes)))
-
-	for _, section := range []struct {
-		label string
-		items []string
-	}{
-		{"Files read", log.read},
-		{"Files changed", log.changed},
-		{"Commands run", log.commands},
-		{"Searched for", log.searches},
-		{"Failures", log.failures},
-	} {
-		if line := summaryLine(section.label, section.items); line != "" {
-			events = append(events, noteEvent(line))
-		}
-	}
-	return events
-}
-
-// toolBreakdown names tools whose arguments yielded nothing, so an unrecognised
-// schema degrades to "Also: exec x4" rather than to silence.
-//
-// It returns the full list and does NOT cap it: the cap belongs to the caller,
-// which appends this to a count prefix. Capping here as well would truncate
-// twice and leave an ellipsis inside the line as well as at its end.
-func (log *activityLog) toolBreakdown() string {
-	if len(log.toolCounts) == 0 {
-		return ""
-	}
-	names := make([]string, 0, len(log.toolCounts))
-	for name := range log.toolCounts {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	parts := make([]string, 0, len(names))
-	for _, name := range names {
-		count := log.toolCounts[name]
-		if count > 1 {
-			parts = append(parts, name+" x"+itoaEvents(count))
-			continue
-		}
-		parts = append(parts, name)
-	}
-	return "Also: " + strings.Join(parts, ", ")
-}
-
-// summaryLine renders one category, collapsing to a count once the list grows
-// past what is useful or past the character budget. The overflow is always
-// stated: a truncated list that looks complete is how a reader concludes the
-// other agent touched four files when it touched forty.
-func summaryLine(label string, items []string) string {
-	if len(items) == 0 {
-		return ""
-	}
-	kept := items
-	dropped := 0
-	if len(kept) > maxSummaryItems {
-		dropped = len(kept) - maxSummaryItems
-		kept = kept[:maxSummaryItems]
-	}
-	for {
-		prefix := label + ": "
-		line := prefix + strings.Join(kept, ", ")
-		suffix := ""
-		if dropped > 0 {
-			suffix = " (+" + itoaEvents(dropped) + " more)"
-			line += suffix
-		}
-		if len(line) <= maxSummaryEventBytes {
-			return line
-		}
-		if len(kept) <= 1 {
-			itemBudget := maxSummaryEventBytes - len(prefix) - len(suffix)
-			if itemBudget <= 0 {
-				return truncateToBudget(prefix+suffix, maxSummaryEventBytes)
-			}
-			return prefix + truncateToBudget(kept[0], itemBudget) + suffix
-		}
-		dropped++
-		kept = kept[:len(kept)-1]
-	}
-}
-
-func truncateToBudget(value string, budget int) string {
-	if budget <= 0 {
-		return ""
-	}
-	if len(value) <= budget {
-		return value
-	}
-	const ellipsis = "…"
-	if budget < len(ellipsis) {
-		return strings.Repeat(".", budget)
-	}
-	end := budget - len(ellipsis)
-	for end > 0 && !utf8.RuneStart(value[end]) {
-		end--
-	}
-	return value[:end] + ellipsis
-}
-
-func countPhrase(count int, noun string) string {
-	if count == 1 {
-		return "1 " + noun
-	}
-	return itoaEvents(count) + " " + noun + "s"
-}
@@ -1,442 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"path/filepath"
-	"strings"
-	"testing"
-	"unicode/utf8"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-func summaryTexts(t *testing.T, events []sessions.AppendEventInput) []string {
-	t.Helper()
-	out := []string{}
-	for _, event := range events {
-		// Activity summaries are now assistant messages carrying the summary
-		// marker (see noteEvent), not EventCompaction.
-		if !NoteEventIsSummary(event.Payload) {
-			continue
-		}
-		out = append(out, str(t, event, "content"))
-	}
-	return out
-}
-
-func joinedSummary(t *testing.T, events []sessions.AppendEventInput) string {
-	t.Helper()
-	return strings.Join(summaryTexts(t, events), "\n")
-}
-
-// claudeToolLines builds a transcript with one tool_use/tool_result pair.
-func claudeToolLines(id, name, arguments, output string, failed bool) []string {
-	isError := "false"
-	if failed {
-		isError = "true"
-	}
-	return []string{
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"` + id +
-			`","name":"` + name + `","input":` + arguments + `}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"` + id +
-			`","is_error":` + isError + `,"content":"` + output + `"}]}}`,
-	}
-}
-
-func TestTheSummaryNamesFilesCommandsAndSearches(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Read", `{"file_path":"/w/parser.go"}`, "package main", false)...)
-	lines = append(lines, claudeToolLines("t2", "Edit", `{"file_path":"/w/lexer.go"}`, "ok", false)...)
-	lines = append(lines, claudeToolLines("t3", "Bash", `{"command":"go test ./..."}`, "PASS", false)...)
-	lines = append(lines, claudeToolLines("t4", "Grep", `{"pattern":"handleResume"}`, "3 hits", false)...)
-
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	summary := joinedSummary(t, events)
-
-	for _, want := range []string{
-		"4 tool calls",
-		"Files read: parser.go",   // relative to cwd, not the absolute path
-		"Files changed: lexer.go", // Edit is classified as mutating
-		"Commands run: go test ./...",
-		"Searched for: handleResume",
-	} {
-		if !strings.Contains(summary, want) {
-			t.Errorf("summary missing %q:\n%s", want, summary)
-		}
-	}
-}
-
-// TestAFailedCallDoesNotClaimItReadTheFile is the correctness fix the real
-// corpus prompted: a Read of a path that does not exist was still listed under
-// "Files read", which the next model would take as fact.
-func TestAFailedCallDoesNotClaimItReadTheFile(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Read", `{"file_path":"/home/wrong/parser.go"}`,
-		"File does not exist.", true)...)
-	lines = append(lines, claudeToolLines("t2", "Read", `{"file_path":"/w/parser.go"}`, "package main", false)...)
-
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	summary := joinedSummary(t, events)
-
-	if strings.Contains(summary, "/home/wrong/parser.go") && strings.Contains(summary, "Files read") {
-		for _, line := range summaryTexts(t, events) {
-			if strings.HasPrefix(line, "Files read") && strings.Contains(line, "/home/wrong/parser.go") {
-				t.Errorf("a path whose read FAILED is listed as read:\n%s", line)
-			}
-		}
-	}
-	if !strings.Contains(summary, "Files read: parser.go") {
-		t.Errorf("the successful read was lost:\n%s", summary)
-	}
-	// The failure itself must still be reported — that is the most useful line.
-	if !strings.Contains(summary, "Failures") || !strings.Contains(summary, "File does not exist") {
-		t.Errorf("the failure was not reported:\n%s", summary)
-	}
-}
-
-// TestEverySummaryEventSurvivesTheDigestIntact is the constraint that decided
-// the shape of this feature. sessions.summarizePayload truncates each event at
-// 500 bytes, so one combined summary would lose its tail; each event must fit.
-func TestEverySummaryEventSurvivesTheDigestIntact(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	for i := 0; i < 40; i++ {
-		lines = append(lines, claudeToolLines(
-			"t"+itoa(i), "Read",
-			`{"file_path":"/w/a/very/long/directory/name/that/eats/budget/file`+itoa(i)+`.go"}`,
-			"ok", false)...)
-	}
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	summaries := summaryTexts(t, events)
-	if len(summaries) == 0 {
-		t.Fatal("no summary events produced")
-	}
-	for _, summary := range summaries {
-		if length := len(summary); length > maxSummaryEventBytes {
-			t.Errorf("summary event is %d bytes, over the %d budget — it will be cut "+
-				"mid-sentence by the resume digest:\n%s", length, maxSummaryEventBytes, summary)
-		}
-	}
-	// And the overflow must be stated, not silently dropped.
-	if !strings.Contains(strings.Join(summaries, "\n"), "more)") {
-		t.Errorf("40 files collapsed to a short list with no overflow note:\n%s",
-			strings.Join(summaries, "\n"))
-	}
-}
-
-func TestMultibyteSummarySurvivesFormatExecPromptIntact(t *testing.T) {
-	home := t.TempDir()
-	lines := []string{`{"type":"user","cwd":"/w","sessionId":"multi","message":{"role":"user","content":"continue"}}`}
-	for i := 0; i < 20; i++ {
-		name := strings.Repeat("界", 24) + itoa(i) + ".go"
-		lines = append(lines, claudeToolLines("t"+itoa(i), "Read", `{"file_path":"/w/`+name+`"}`, "ok", false)...)
-	}
-	writeFile(t, filepath.Join(home, ".claude", "projects", "-w", "multi.jsonl"), strings.Join(lines, "\n")+"\n")
-
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := Import(store, ClaudeCode(testEnv(home, nil)), "multi", ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	events, err := store.ReadEvents(result.Session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var fileSummary string
-	for _, event := range events {
-		var payload map[string]any
-		if err := json.Unmarshal(event.Payload, &payload); err != nil || !NoteEventIsSummary(payload) {
-			continue
-		}
-		content, _ := payload["content"].(string)
-		if strings.HasPrefix(content, "Files read:") {
-			fileSummary = content
-		}
-	}
-	if fileSummary == "" || !strings.Contains(fileSummary, "more)") {
-		t.Fatalf("multibyte file summary lost its overflow disclosure: %q", fileSummary)
-	}
-	if len(fileSummary) > maxSummaryEventBytes {
-		t.Fatalf("summary is %d bytes, want at most %d: %q", len(fileSummary), maxSummaryEventBytes, fileSummary)
-	}
-	prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{Store: store, Resume: result.Session.SessionID})
-	if err != nil {
-		t.Fatal(err)
-	}
-	prompt := sessions.FormatExecPrompt("what remains?", prepared)
-	if !strings.Contains(prompt, fileSummary) {
-		t.Fatalf("FormatExecPrompt truncated a producer-approved summary:\nsummary=%q\nprompt=%s", fileSummary, prompt)
-	}
-}
-
-func TestSummaryLinePreservesOverflowDisclosureWhenOneItemExhaustsTheBudget(t *testing.T) {
-	items := []string{strings.Repeat("界", maxSummaryEventBytes)}
-	for i := 0; i < maxSummaryItems+4; i++ {
-		items = append(items, "file"+itoa(i)+".go")
-	}
-	line := summaryLine("Files read", items)
-	if len(line) > maxSummaryEventBytes || !utf8.ValidString(line) {
-		t.Fatalf("bounded summary is invalid or oversized: bytes=%d valid=%v %q", len(line), utf8.ValidString(line), line)
-	}
-	if !strings.Contains(line, "more)") {
-		t.Fatalf("a long first item erased the overflow disclosure: %q", line)
-	}
-}
-
-func TestTruncateToBudgetKeepsUTF8ValidAtEverySmallBudget(t *testing.T) {
-	for budget := 0; budget <= 4; budget++ {
-		got := truncateToBudget("界界", budget)
-		if len(got) > budget || !utf8.ValidString(got) {
-			t.Errorf("budget %d produced bytes=%d valid=%v %q", budget, len(got), utf8.ValidString(got), got)
-		}
-	}
-}
-
-// TestTheSummaryReachesTheModel is the whole point: these events must survive
-// sessions.promptContextEvents, the filter that drops tool events.
-func TestTheSummaryReachesTheModel(t *testing.T) {
-	home := t.TempDir()
-	lines := []string{`{"type":"user","cwd":"/w","sessionId":"s1","message":{"role":"user","content":"fix the parser"}}`}
-	lines = append(lines, claudeToolLines("t1", "Read", `{"file_path":"/w/parser.go"}`, "package main", false)...)
-	lines = append(lines, claudeToolLines("t2", "Bash", `{"command":"go test ./parser"}`, "FAIL", true)...)
-	writeFile(t, filepath.Join(home, ".claude", "projects", "-w", "s1.jsonl"),
-		strings.Join(lines, "\n")+"\n")
-
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := Import(store, ClaudeCode(testEnv(home, nil)), "s1", ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{Store: store, Resume: result.Session.SessionID})
-	if err != nil {
-		t.Fatal(err)
-	}
-	digest := sessions.FormatExecPrompt("what is left?", prepared)
-
-	// Before this feature the digest held only the two prose messages. These
-	// facts existed solely in tool events, which never reach the model.
-	for _, want := range []string{
-		"tool calls",
-		"parser.go",
-		"go test ./parser",
-		"Failures",
-	} {
-		if !strings.Contains(digest, want) {
-			t.Errorf("the resume digest is missing %q — the summary is not reaching "+
-				"the model:\n%s", want, digest)
-		}
-	}
-}
-
-func TestASessionWithNoToolCallsGetsNoSummary(t *testing.T) {
-	events, err := translateFamily1At("", writeTranscript(t,
-		`{"type":"user","cwd":"/w","message":{"role":"user","content":"hello"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"hi"}]}}`,
-	), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := summaryTexts(t, events); len(got) != 0 {
-		t.Errorf("got %d summary events for a conversation with no tools, want none: %v", len(got), got)
-	}
-}
-
-// TestAnUnknownToolSchemaDegradesToACount covers the case this design must not
-// get wrong: an agent whose arguments use names we have never seen. Naming the
-// tool and its count is true; guessing which field held a filename would not be.
-func TestAnUnknownToolSchemaDegradesToACount(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "MysteryTool", `{"wibble":"/w/secret.go","flim":3}`, "ok", false)...)
-	lines = append(lines, claudeToolLines("t2", "MysteryTool", `{"wibble":"/w/other.go"}`, "ok", false)...)
-
-	events, _ := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	summary := joinedSummary(t, events)
-
-	if !strings.Contains(summary, "MysteryTool x2") {
-		t.Errorf("an unrecognised schema should still be counted:\n%s", summary)
-	}
-	for _, guessed := range []string{"secret.go", "other.go", "Files read"} {
-		if strings.Contains(summary, guessed) {
-			t.Errorf("summary guessed %q out of an unknown argument schema:\n%s", guessed, summary)
-		}
-	}
-}
-
-func TestRepeatedWorkIsNotListedRepeatedly(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	for i := 0; i < 8; i++ {
-		lines = append(lines, claudeToolLines("t"+itoa(i), "Read", `{"file_path":"/w/same.go"}`, "ok", false)...)
-	}
-	events, _ := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	summary := joinedSummary(t, events)
-
-	if count := strings.Count(summary, "same.go"); count != 1 {
-		t.Errorf("same.go appears %d times, want 1 — re-reads must dedupe:\n%s", count, summary)
-	}
-	// The call count is still the true one.
-	if !strings.Contains(summary, "8 tool calls") {
-		t.Errorf("dedupe must not change the call count:\n%s", summary)
-	}
-}
-
-// TestSecretsInToolArgumentsAreRedacted: the summary is built from another
-// program's logs, so it goes through the same chokepoint as every other
-// imported string.
-func TestSecretsInToolArgumentsAreRedacted(t *testing.T) {
-	const leaked = "sk-ant-api03-AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLL"
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Bash", `{"command":"export K=`+leaked+`"}`, "ok", false)...)
-	lines = append(lines, claudeToolLines("t2", "Bash", `{"command":"run-command"}`, "stderr: "+leaked, true)...)
-
-	events, _ := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	encoded, err := json.Marshal(events)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(encoded), leaked) {
-		t.Errorf("a secret from a tool argument survived into the summary:\n%s", encoded)
-	}
-}
-
-func TestPathsOutsideTheWorkspaceKeepTheirAbsoluteForm(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Read", `{"file_path":"/w/inside.go"}`, "ok", false)...)
-	lines = append(lines, claudeToolLines("t2", "Read", `{"file_path":"/elsewhere/outside.go"}`, "ok", false)...)
-
-	events, _ := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	summary := joinedSummary(t, events)
-
-	if !strings.Contains(summary, "inside.go") || strings.Contains(summary, "/w/inside.go") {
-		t.Errorf("a file in the workspace should be shown relative:\n%s", summary)
-	}
-	if !strings.Contains(summary, "/elsewhere/outside.go") {
-		t.Errorf("a file outside the workspace should keep its absolute path — that "+
-			"it is elsewhere is the interesting part:\n%s", summary)
-	}
-}
-
-func TestSummaryEventsComeLastSoTheySitNearestTheNewRequest(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Read", `{"file_path":"/w/a.go"}`, "ok", false)...)
-
-	events, _ := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if len(events) < 2 {
-		t.Fatal("expected conversation events plus a summary")
-	}
-	if !NoteEventIsSummary(events[len(events)-1].Payload) {
-		t.Errorf("last event is %s, want the summary last so it survives the "+
-			"80-event window and reads as a footer", events[len(events)-1].Type)
-	}
-	// And the conversation itself still comes first.
-	if events[0].Type != sessions.EventMessage {
-		t.Errorf("first event is %s, want the original conversation to lead", events[0].Type)
-	}
-}
-
-// TestASuccessfulWriteSurvivesALaterFailedEditOfTheSamePath covers the
-// coarse-keying fix: the old code withdrew a failed call's claim BY VALUE, so a
-// failed Edit erased the record of an earlier successful Write to the same path
-// and the summary reported no files changed although the file was rewritten.
-func TestASuccessfulWriteSurvivesALaterFailedEditOfTheSamePath(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	lines = append(lines, claudeToolLines("t1", "Write", `{"file_path":"/w/config.yaml"}`, "wrote 40 lines", false)...)
-	lines = append(lines, claudeToolLines("t2", "Edit", `{"file_path":"/w/config.yaml"}`, "string not found", true)...)
-
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	summary := joinedSummary(t, events)
-	if !strings.Contains(summary, "Files changed: config.yaml") {
-		t.Errorf("the successful Write was erased by the later failed Edit of the same path:\n%s", summary)
-	}
-}
-
-// TestAnInterruptedWriteWithNoResultDoesNotClaimTheFile covers the
-// no-result fix: a tool call whose result never arrives (the session stopped
-// mid-call) must not report its file as changed — we never learned it ran.
-func TestAnInterruptedWriteWithNoResultDoesNotClaimTheFile(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	// The tool_use with no matching tool_result — the transcript ends here.
-	lines = append(lines, claudeToolLines("t1", "Write", `{"file_path":"/w/config.yaml"}`, "", false)[0])
-
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, line := range summaryTexts(t, events) {
-		if strings.HasPrefix(line, "Files changed") && strings.Contains(line, "config.yaml") {
-			t.Errorf("an interrupted write with no result is claimed as a file changed:\n%s", line)
-		}
-	}
-}
-
-// THE BUDGET HAS TO BIND ON THE ASSEMBLED LINE. The previous implementation
-// capped the tool breakdown and then prepended the call/failure counts, so the
-// headline left the budget by exactly the length of that prefix. The existing
-// budget test
-// never caught it because its tools all carry a recognised "file_path", which
-// routes them to the file buckets and leaves the breakdown empty — the overflow
-// only appears once the arguments are a schema this package does not know, which
-// is the fallback path the breakdown exists for.
-func TestTheActivityHeadlineIsTruncatedAfterItIsAssembled(t *testing.T) {
-	lines := []string{`{"type":"user","cwd":"/w","message":{"role":"user","content":"go"}}`}
-	for i := 0; i < 60; i++ {
-		lines = append(lines, claudeToolLines(
-			"t"+itoa(i), "unrecognised_tool_"+itoa(i), `{"unknown_argument_name":"x"}`, "ok", false)...)
-	}
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	summaries := summaryTexts(t, events)
-	if len(summaries) == 0 {
-		t.Fatal("no summary events produced")
-	}
-
-	headline := summaries[0]
-	// The prefix has to be there, or the breakdown alone would satisfy the budget
-	// for the wrong reason — that was the passing state before the fix.
-	if !strings.HasPrefix(headline, "Prior session activity: 60 tool calls.") {
-		t.Fatalf("the headline is not the count-prefixed line this test is about:\n%s", headline)
-	}
-	if !strings.Contains(headline, "Also: unrecognised_tool_") {
-		t.Fatalf("the breakdown never ran, so nothing could overflow:\n%s", headline)
-	}
-	if length := len(headline); length != maxSummaryEventBytes {
-		t.Errorf("headline is %d bytes, want it cut to exactly the %d budget:\n%s",
-			length, maxSummaryEventBytes, headline)
-	}
-	// Cut, not merely short: the ellipsis is what tells a reader the list goes on.
-	if !strings.HasSuffix(headline, "…") {
-		t.Errorf("an over-long headline was truncated without saying so:\n%s", headline)
-	}
-}
-
-func TestActivityItemsRedactCompleteValuesBeforeShortening(t *testing.T) {
-	secret := "ghp_" + strings.Repeat("Q", 36)
-	for _, presented := range []string{
-		secret,
-		"ghp_ " + strings.Repeat("Q", 36),
-	} {
-		log := newActivityLog("/workspace")
-		log.observeCall("call", "bash", `{"command":"`+strings.Repeat("x", 105)+` `+presented+`"}`)
-		events := log.summaryEvents()
-		joined := ""
-		for _, event := range events {
-			joined += str(t, event, "content") + "\n"
-		}
-		if strings.Contains(joined, secret) || !strings.Contains(joined, "[REDACTED]") {
-			t.Fatalf("activity summary exposed a secret after shortening:\n%s", joined)
-		}
-	}
-}
@@ -1,106 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// TestImportedControlBytesAreStripped pins the terminal-injection fix: a foreign
-// transcript is attacker-influenced, and an ESC or NUL in a message must not
-// survive into a transcript line or picker row (the #835/#876 class). The
-// content is built with Go escapes and JSON-encoded so the transcript carries
-// the real control bytes.
-func TestImportedControlBytesAreStripped(t *testing.T) {
-	malicious := "before\x1b[2J\x1b[1;1H FORGED \x00\x07\r after"
-	line, err := json.Marshal(map[string]any{
-		"type":    "user",
-		"message": map[string]any{"role": "user", "content": malicious},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	path := writeTranscript(t, string(line))
-
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Inspect the payload strings DIRECTLY, not a json.Marshal of the events —
-	// JSON encoding would escape a surviving control byte to "" and hide it.
-	var contentSeen string
-	for _, event := range events {
-		payload, ok := event.Payload.(map[string]any)
-		if !ok {
-			continue
-		}
-		for _, field := range payload {
-			s, ok := field.(string)
-			if !ok {
-				continue
-			}
-			if strings.ContainsAny(s, "\x1b\x00\x07\r") {
-				t.Errorf("a control byte survived translation into a payload string: %q", s)
-			}
-			if strings.Contains(s, "before") {
-				contentSeen = s
-			}
-		}
-	}
-	if contentSeen == "" || !strings.Contains(contentSeen, "after") {
-		t.Errorf("stripping removed visible text, not just control bytes: %q", contentSeen)
-	}
-}
-
-// TestStripControlKeepsTabAndNewline guards the one carve-out: transcripts
-// legitimately carry tab and newline, and dropping them would mangle real text.
-func TestStripControlKeepsTabAndNewline(t *testing.T) {
-	got, _ := stripControlWithBoundaries("a\tb\nc\rd\x1be\x00f")
-	if got != "a\tb\ncdef" {
-		t.Errorf("stripControl = %q, want tab and newline kept and ESC/NUL dropped", got)
-	}
-}
-
-// TestActivitySummaryIsAMessageNotACompaction pins the replay-contract fix.
-// EventCompaction drives RehydrateEvents, which hoists a bookkeeping-less summary
-// to the front of the transcript; the activity summary must not be that type.
-func TestActivitySummaryIsAMessageNotACompaction(t *testing.T) {
-	note := noteEvent("Prior session activity: 1 tool call.")
-	if note.Type == sessions.EventCompaction {
-		t.Fatal("activity summary is EventCompaction — RehydrateEvents will hoist it to the transcript front")
-	}
-	if note.Type != sessions.EventMessage {
-		t.Fatalf("activity summary type = %s, want EventMessage", note.Type)
-	}
-	if !NoteEventIsSummary(note.Payload) {
-		t.Fatal("activity summary carries no marker, so nothing can tell it from a real assistant turn")
-	}
-}
-
-// TestStructuralFieldsAreRedacted covers CodeRabbit's finding: role, name, and
-// toolCallId come from the foreign transcript too, so a credential hidden in any
-// of them must be redacted, not merely stripped of control bytes.
-func TestStructuralFieldsAreRedacted(t *testing.T) {
-	secret := "sk-ant-api03-" + strings.Repeat("A", 40)
-	identities := &importCallIdentities{}
-	events := []sessions.AppendEventInput{
-		messageEvent(secret, "hi"),                               // malicious role
-		toolCallEvent(identities, secret, secret, "{}"),          // malicious tool name + call id
-		toolResultEvent(identities, secret, secret, "ok", "out"), // malicious tool name + result id
-	}
-	encoded, err := json.Marshal(events)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(encoded), secret) {
-		t.Errorf("a secret in a structural field (role/name/toolCallId) survived translation:\n%s", encoded)
-	}
-	// Redaction is deterministic, so the call and its result must still pair up.
-	call := events[1].Payload.(map[string]any)["toolCallId"].(string)
-	result := events[2].Payload.(map[string]any)["toolCallId"].(string)
-	if call == "" || call != result {
-		t.Errorf("redacted call/result ids diverged and broke pairing: %q vs %q", call, result)
-	}
-}
@@ -1,78 +0,0 @@
-package agentsessions
-
-import (
-	"sync"
-	"time"
-)
-
-// discoveryTTL is how long a workspace's discovery result is reused.
-//
-// Discovery costs 50-300ms on a working machine — a bounded head read of every
-// transcript across four stores. That is affordable once, but /resume is opened,
-// dismissed and reopened constantly, and paying it on each keypress makes the
-// TUI hitch every time.
-//
-// Ten seconds is chosen to be shorter than a person can act on the staleness. A
-// session finished in another terminal appears on the next open rather than
-// this one; the alternative — no cache — makes every open hitch to avoid a case
-// nobody notices.
-const discoveryTTL = 10 * time.Second
-
-type discoveryEntry struct {
-	sessions []ForeignSession
-	problems []error
-	at       time.Time
-}
-
-var (
-	discoveryMu    sync.Mutex
-	discoveryCache = map[string]discoveryEntry{}
-	discoveryEpoch uint64
-	// discoveryNow is the clock, swapped in tests so TTL expiry is exercised
-	// without sleeping.
-	discoveryNow = time.Now
-	discoverAll  = DiscoverAll
-)
-
-// DiscoverAllCached is DiscoverAll with a short per-workspace memo. Callers on a
-// UI path should prefer it; a one-shot CLI command should not, since a fresh
-// process has nothing cached and the result would only ever be stale.
-func DiscoverAllCached(env Env, cwd string) ([]ForeignSession, []error) {
-	discoveryMu.Lock()
-	now := discoveryNow()
-	if entry, ok := discoveryCache[cwd]; ok && now.Sub(entry.at) < discoveryTTL {
-		// Copy: callers sort and filter the slice they are handed, and a shared
-		// backing array would let one caller reorder another's results.
-		discoveryMu.Unlock()
-		return append([]ForeignSession{}, entry.sessions...), entry.problems
-	}
-	epoch := discoveryEpoch
-	discoveryMu.Unlock()
-
-	// Discovery reads several external stores and can take hundreds of
-	// milliseconds. It must not hold the global cache lock: a miss for one
-	// workspace cannot stall a valid hit for another workspace.
-	found, problems := discoverAll(env, cwd)
-	discoveryMu.Lock()
-	defer discoveryMu.Unlock()
-	// Prefer a value another concurrent miss already published. If the cache was
-	// invalidated while discovery ran, return this result to the current caller
-	// but do not repopulate the cache with a pre-invalidation snapshot.
-	now = discoveryNow()
-	if entry, ok := discoveryCache[cwd]; ok && now.Sub(entry.at) < discoveryTTL {
-		return append([]ForeignSession{}, entry.sessions...), entry.problems
-	}
-	if epoch == discoveryEpoch {
-		discoveryCache[cwd] = discoveryEntry{sessions: found, problems: problems, at: now}
-	}
-	return append([]ForeignSession{}, found...), problems
-}
-
-// InvalidateDiscovery drops the memo so the next discovery re-reads the stores.
-// Called after an import, which changes which sessions are still un-imported.
-func InvalidateDiscovery() {
-	discoveryMu.Lock()
-	defer discoveryMu.Unlock()
-	discoveryEpoch++
-	discoveryCache = map[string]discoveryEntry{}
-}
@@ -1,157 +0,0 @@
-package agentsessions
-
-import (
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func withFakeClock(t *testing.T) *time.Time {
-	t.Helper()
-	clock := time.Date(2026, 8, 8, 10, 0, 0, 0, time.UTC)
-	previous := discoveryNow
-	discoveryNow = func() time.Time { return clock }
-	InvalidateDiscovery()
-	t.Cleanup(func() {
-		discoveryNow = previous
-		InvalidateDiscovery()
-	})
-	return &clock
-}
-
-func storeWithOneSession(t *testing.T) Env {
-	t.Helper()
-	home := t.TempDir()
-	writeFile(t, filepath.Join(home, ".claude", "projects", "-w", "a.jsonl"),
-		`{"type":"user","cwd":"/w","sessionId":"a","message":{"role":"user","content":"hi"}}`+"\n")
-	return testEnv(home, nil)
-}
-
-func TestASecondDiscoveryInsideTheWindowDoesNotReReadTheStores(t *testing.T) {
-	clock := withFakeClock(t)
-	env := storeWithOneSession(t)
-
-	first, _ := DiscoverAllCached(env, "/w")
-	if len(first) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(first))
-	}
-
-	// Delete the store outright. A cached answer still returns the session;
-	// a re-read could not.
-	env2 := testEnv(t.TempDir(), nil)
-	*clock = clock.Add(discoveryTTL - time.Second)
-	cached, _ := DiscoverAllCached(env2, "/w")
-	if len(cached) != 1 {
-		t.Errorf("got %d sessions inside the TTL, want the memoised 1", len(cached))
-	}
-
-	*clock = clock.Add(2 * time.Second) // now past the TTL
-	fresh, _ := DiscoverAllCached(env2, "/w")
-	if len(fresh) != 0 {
-		t.Errorf("got %d sessions after the TTL, want a fresh (empty) read", len(fresh))
-	}
-}
-
-func TestEachWorkspaceIsMemoisedSeparately(t *testing.T) {
-	withFakeClock(t)
-	env := storeWithOneSession(t)
-
-	if got, _ := DiscoverAllCached(env, "/w"); len(got) != 1 {
-		t.Fatalf("/w got %d, want 1", len(got))
-	}
-	// A different workspace must not be served /w's answer.
-	if got, _ := DiscoverAllCached(env, "/elsewhere"); len(got) != 0 {
-		t.Errorf("/elsewhere got %d sessions, want 0 — the memo is keyed by workspace", len(got))
-	}
-}
-
-func TestInvalidatingForcesAReRead(t *testing.T) {
-	withFakeClock(t)
-	env := storeWithOneSession(t)
-	if got, _ := DiscoverAllCached(env, "/w"); len(got) != 1 {
-		t.Fatalf("got %d, want 1", len(got))
-	}
-	InvalidateDiscovery()
-	empty := testEnv(t.TempDir(), nil)
-	if got, _ := DiscoverAllCached(empty, "/w"); len(got) != 0 {
-		t.Errorf("got %d after invalidation, want a fresh read", len(got))
-	}
-}
-
-// TestCallersCannotReorderEachOthersResults covers the aliasing bug a memo
-// invites: handing every caller the same backing array lets one caller's sort
-// or filter mutate what the next one sees.
-func TestCallersCannotReorderEachOthersResults(t *testing.T) {
-	withFakeClock(t)
-	home := t.TempDir()
-	for _, id := range []string{"a", "b", "c"} {
-		writeFile(t, filepath.Join(home, ".claude", "projects", "-w", id+".jsonl"),
-			`{"type":"user","cwd":"/w","sessionId":"`+id+`","message":{"role":"user","content":"hi"}}`+"\n")
-	}
-	env := testEnv(home, nil)
-
-	first, _ := DiscoverAllCached(env, "/w")
-	if len(first) != 3 {
-		t.Fatalf("got %d, want 3", len(first))
-	}
-	for i := range first {
-		first[i].ID = "clobbered"
-	}
-
-	second, _ := DiscoverAllCached(env, "/w")
-	for _, session := range second {
-		if session.ID == "clobbered" {
-			t.Fatal("one caller's mutation reached the next caller's results")
-		}
-	}
-}
-
-func TestSlowMissDoesNotBlockAnotherWorkspacesCacheHit(t *testing.T) {
-	withFakeClock(t)
-	discoveryMu.Lock()
-	discoveryCache["/cached"] = discoveryEntry{
-		sessions: []ForeignSession{{ID: "cached"}},
-		at:       discoveryNow(),
-	}
-	discoveryMu.Unlock()
-
-	previous := discoverAll
-	started := make(chan struct{})
-	release := make(chan struct{})
-	discoverAll = func(Env, string) ([]ForeignSession, []error) {
-		close(started)
-		<-release
-		return []ForeignSession{{ID: "slow"}}, nil
-	}
-	t.Cleanup(func() {
-		discoverAll = previous
-		select {
-		case <-release:
-		default:
-			close(release)
-		}
-	})
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		DiscoverAllCached(Env{}, "/slow")
-	}()
-	<-started
-
-	hit := make(chan []ForeignSession, 1)
-	go func() {
-		found, _ := DiscoverAllCached(Env{}, "/cached")
-		hit <- found
-	}()
-	select {
-	case found := <-hit:
-		if len(found) != 1 || found[0].ID != "cached" {
-			t.Fatalf("cache hit = %+v, want cached session", found)
-		}
-	case <-time.After(250 * time.Millisecond):
-		t.Fatal("a slow miss held the global cache lock and blocked an unrelated hit")
-	}
-	close(release)
-	<-done
-}
@@ -1,325 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"errors"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// codex reads Codex's rollout transcripts.
-//
-// Same idea as family 1, two differences that stop it sharing the code:
-//
-//   - The store is partitioned by DATE, not by working directory:
-//     ~/.codex/sessions/YYYY/MM/DD/rollout-<iso>-<uuid>.jsonl. There is no slug
-//     to narrow with, so scoping to a workspace always means indexing the lot —
-//     affordable only because indexing is a bounded head read.
-//   - Every record wraps its real content in a "payload" object, and the record
-//     kind that matters is payload.type rather than the outer type.
-type codex struct {
-	root string
-}
-
-// Codex reads Codex's rollout transcripts.
-func Codex(env Env) Adapter {
-	return codex{root: codexRoot(env)}
-}
-
-func (adapter codex) Name() string { return "codex" }
-
-// transcripts lists rollout files at exactly three levels below the root
-// (year/month/day). Fixed depth for the same reason as everywhere else in this
-// package: ~/.codex/auth.json holds a live OPENAI_API_KEY and an OAuth token,
-// and a walk from the codex home would reach it.
-func (adapter codex) transcripts() []string {
-	if strings.TrimSpace(adapter.root) == "" {
-		return nil
-	}
-	return globTranscripts(adapter.root, filepath.Join(adapter.root, "*", "*", "*", "rollout-*"+transcriptExt))
-}
-
-func (adapter codex) Discover(cwd string) ([]ForeignSession, error) {
-	found := []ForeignSession{}
-	for _, path := range adapter.transcripts() {
-		session, ok := indexCodexTranscript(adapter.Name(), adapter.root, path)
-		if !ok {
-			continue
-		}
-		if strings.TrimSpace(cwd) != "" && !sameDir(cwd, session.Cwd) {
-			continue
-		}
-		found = append(found, session)
-	}
-	sortByRecency(found)
-	return found, nil
-}
-
-func (adapter codex) Read(source ForeignSession, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	if source.Agent != adapter.Name() || source.ID != codexID(source.Path) {
-		return nil, errors.New("agentsessions: selected session does not belong to codex")
-	}
-	// One handle from identity check to final check: see openSelectedSource.
-	file, err := openSelectedSource(adapter.root, source)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	events, err := translateCodex(file, options)
-	if err != nil {
-		return nil, err
-	}
-	if err := validateSourceHandle(file, source); err != nil {
-		return nil, err
-	}
-	return events, nil
-}
-
-type codexRecord struct {
-	Type      string       `json:"type"`
-	Timestamp string       `json:"timestamp"`
-	Payload   codexPayload `json:"payload"`
-}
-
-// codexPayload is the union of the payload shapes this adapter reads:
-// session_meta, turn_context, and the several response_item kinds.
-//
-// Any field whose TYPE differs between those shapes must be json.RawMessage and
-// be decoded at the point of use. "summary" is the cautionary example: on a
-// reasoning item it is an array of blocks, on turn_context it is the plain
-// string "auto". Typing it as []codexBlock made encoding/json reject the entire
-// turn_context record — so the adapter silently lost the model id on every
-// session, with no error anywhere, because one unrelated field disagreed.
-type codexPayload struct {
-	// session_meta
-	SessionID string `json:"session_id"`
-	Cwd       string `json:"cwd"`
-	// turn_context
-	Model string `json:"model"`
-	// response_item
-	Type      string          `json:"type"`
-	Role      string          `json:"role"`
-	Content   []codexBlock    `json:"content"`
-	Summary   json.RawMessage `json:"summary"`
-	Name      string          `json:"name"`
-	CallID    string          `json:"call_id"`
-	Arguments string          `json:"arguments"`
-	Input     string          `json:"input"`
-	Output    json.RawMessage `json:"output"`
-}
-
-// codexContextTags are the wrappers Codex uses to inject harness state as if it
-// were a user turn. They are the same category as its "developer" messages —
-// the harness talking to itself — and are excluded from titles and from the
-// imported conversation.
-//
-// An explicit list rather than "any message starting with '<'": a user pasting
-// XML is saying something real, and guessing would silently drop their words.
-var codexContextTags = []string{"<environment_context>"}
-
-func isCodexContextInjection(text string) bool {
-	trimmed := strings.TrimSpace(text)
-	for _, tag := range codexContextTags {
-		if strings.HasPrefix(trimmed, tag) {
-			return true
-		}
-	}
-	return false
-}
-
-type codexBlock struct {
-	Type string `json:"type"`
-	Text string `json:"text"`
-}
-
-// codexUUID matches the session id Codex appends to every rollout filename.
-var codexUUID = regexp.MustCompile(`[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
-
-// codexID is the session id, taken from the tail of the filename.
-//
-// The full base name — rollout-2026-07-18T11-39-15-019f73d7-... — is not
-// something anyone wants to retype, and its trailing uuid is exactly the
-// session_id recorded inside the file. Falling back to the whole base name keeps
-// a renamed or reshaped file addressable rather than invisible.
-func codexID(path string) string {
-	base := transcriptID(path)
-	if found := codexUUID.FindString(base); found != "" {
-		return found
-	}
-	return base
-}
-
-func indexCodexTranscript(agent string, root string, path string) (ForeignSession, bool) {
-	session := ForeignSession{Agent: agent, ID: codexID(path), Path: path}
-	firstPrompt := ""
-
-	_, snapshot, err := scanHeadSnapshot(root, path, defaultHeadLimit, func(line []byte, _ bool) bool {
-		var record codexRecord
-		if json.Unmarshal(line, &record) != nil {
-			return true
-		}
-		if session.Cwd == "" {
-			session.Cwd = record.Payload.Cwd
-		}
-		if session.ModelID == "" {
-			session.ModelID = record.Payload.Model
-		}
-		if session.StartedAt.IsZero() {
-			session.StartedAt = parseTimestamp(record.Timestamp)
-		}
-		// The first thing the USER said, not the first message: Codex opens every
-		// session with several large "developer" messages carrying its own system
-		// instructions, and titling a session with those would label them all the
-		// same.
-		if firstPrompt == "" && record.Payload.Type == "message" && strings.EqualFold(record.Payload.Role, "user") {
-			if text := codexBlocksText(record.Payload.Content); !isCodexContextInjection(text) {
-				firstPrompt = text
-			}
-		}
-		return true
-	})
-	if err != nil {
-		return ForeignSession{}, false
-	}
-
-	session.Title = summarizeTitle(firstPrompt)
-	if strings.TrimSpace(session.Cwd) == "" {
-		return ForeignSession{}, false
-	}
-	session.source = snapshot
-	session.UpdatedAt = snapshot.modTime
-	if session.StartedAt.IsZero() {
-		session.StartedAt = session.UpdatedAt
-	}
-	return session, true
-}
-
-func translateCodex(file readSeekStater, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	return translateCodexWithByteLimit(file, options, importByteLimit)
-}
-
-// translateCodexWithByteLimit keeps the production cap fixed while allowing a
-// regression test to exercise tail truncation without allocating 32 MiB.
-func translateCodexWithByteLimit(file readSeekStater, options ReadOptions, maxBytes int) ([]sessions.AppendEventInput, error) {
-	events := newEventTail(effectiveMaxEvents(options.MaxEvents))
-	toolNames := map[string]string{}
-	identities := &importCallIdentities{}
-	activity := newActivityLog(options.Cwd)
-
-	omitted := 0
-	prefixOmitted, err := streamTailLines(file, importLineLimit, maxBytes, func(line []byte, truncated bool) bool {
-		// A RECORD TOO LONG EVEN FOR THE IMPORT CAP IS REPORTED, NOT DROPPED.
-		// Skipping it silently produced a transcript that looked complete: a
-		// question, no answer, then the follow-up. The marker is the honest
-		// answer — the bytes are gone either way, but the reader can see it.
-		if truncated {
-			omitted++
-			return true
-		}
-		var record codexRecord
-		if json.Unmarshal(line, &record) != nil || record.Type != "response_item" {
-			return true
-		}
-		payload := record.Payload
-
-		switch payload.Type {
-		case "message":
-			// "developer" messages are Codex's own system prompt — permissions
-			// boilerplate, collaboration-mode text, tool instructions. They are
-			// the harness talking to itself, not the work, and importing them
-			// would bury the conversation in another product's prompt.
-			role := strings.ToLower(strings.TrimSpace(payload.Role))
-			if role != "user" && role != "assistant" {
-				return true
-			}
-			text := codexBlocksText(payload.Content)
-			if strings.TrimSpace(text) == "" || isCodexContextInjection(text) {
-				return true
-			}
-			events.add(messageEvent(role, text))
-		case "reasoning":
-			if options.IncludeReasoning {
-				var summary []codexBlock
-				if json.Unmarshal(payload.Summary, &summary) == nil {
-					if text := codexBlocksText(summary); strings.TrimSpace(text) != "" {
-						events.add(messageEvent("reasoning", text))
-					}
-				}
-			}
-		case "function_call", "custom_tool_call":
-			// The two call shapes differ only in where the arguments live.
-			toolNames[payload.CallID] = payload.Name
-			arguments := firstNonBlank(payload.Arguments, payload.Input)
-			activity.observeCall(payload.CallID, payload.Name, arguments)
-			events.add(toolCallEvent(identities, payload.Name, payload.CallID, arguments))
-		case "function_call_output", "custom_tool_call_output":
-			name := toolNames[payload.CallID]
-			if name == "" {
-				name = "unknown"
-			}
-			// Codex records no structured success flag on an output. Preserve that
-			// uncertainty instead of turning arbitrary output text into either a
-			// success claim or a brittle error heuristic.
-			activity.observeResult(payload.CallID, name, tools.StatusUnknown, "")
-			events.add(toolResultEvent(identities, name, payload.CallID, tools.StatusUnknown, codexOutputText(payload.Output)))
-			delete(toolNames, payload.CallID)
-		}
-		return true
-	})
-	if err != nil {
-		return nil, err
-	}
-	// SAID OUT LOUD. A resumed conversation that quietly lost a record reads as
-	// complete to both the user and the model continuing it — the failure this
-	// makes visible is a question with no answer followed by a follow-up.
-	contextEvents := activity.summaryEvents()
-	if prefixOmitted {
-		contextEvents = append(contextEvents, omittedPrefixEvent())
-	}
-	if omitted > 0 {
-		contextEvents = append(contextEvents, omittedRecordsEvent(omitted))
-	}
-	return capTranslatedEventsDropped(events.values(), contextEvents, effectiveMaxEvents(options.MaxEvents), events.dropped), nil
-}
-
-// codexBlocksText flattens input_text/output_text blocks to plain text.
-func codexBlocksText(blocks []codexBlock) string {
-	parts := []string{}
-	for _, block := range blocks {
-		if strings.TrimSpace(block.Text) != "" {
-			parts = append(parts, block.Text)
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-// codexOutputText renders a tool output, which is a bare string on some record
-// kinds and an array of blocks on others.
-func codexOutputText(raw json.RawMessage) string {
-	if len(raw) == 0 {
-		return ""
-	}
-	var text string
-	if json.Unmarshal(raw, &text) == nil {
-		// Codex frequently stores the array as an ESCAPED STRING rather than as
-		// JSON, so a decoded string may itself be a blocks array.
-		var nested []codexBlock
-		if json.Unmarshal([]byte(text), &nested) == nil {
-			if flattened := codexBlocksText(nested); flattened != "" {
-				return flattened
-			}
-		}
-		return text
-	}
-	var blocks []codexBlock
-	if json.Unmarshal(raw, &blocks) == nil {
-		if flattened := codexBlocksText(blocks); flattened != "" {
-			return flattened
-		}
-	}
-	return string(raw)
-}
@@ -1,293 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func writeCodexStore(t *testing.T, lines ...string) (Env, string) {
-	t.Helper()
-	home := t.TempDir()
-	path := filepath.Join(home, ".codex", "sessions", "2026", "08", "01",
-		"rollout-2026-08-01T10-00-00-019f73d7-e215-7ce0-ab38-d9e6db354717.jsonl")
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-	return testEnv(home, nil), path
-}
-
-// TestATurnContextDoesNotBreakOnAFieldItSharesByNameOnly is a regression test
-// for a defect the real corpus exposed.
-//
-// "summary" is an array of blocks on a reasoning item and the bare string "auto"
-// on turn_context. Typing it as []codexBlock made encoding/json reject the whole
-// turn_context record, so the model id vanished from every Codex session — with
-// no error at any layer, because a record that fails to decode is simply skipped.
-//
-// Nothing about the model id itself is special here; the point is that ONE
-// mistyped field in a union struct silently discards every other field on that
-// record.
-func TestATurnContextDoesNotBreakOnAFieldItSharesByNameOnly(t *testing.T) {
-	env, _ := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"019f73d7-e215-7ce0-ab38-d9e6db354717","cwd":"/Users/someone/proj"}}`,
-		`{"type":"turn_context","payload":{"model":"gpt-5.6-sol","effort":"high","summary":"auto"}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"fix the parser"}]}}`,
-	)
-
-	found, err := Codex(env).Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(found) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(found))
-	}
-	if found[0].ModelID != "gpt-5.6-sol" {
-		t.Errorf("ModelID = %q, want gpt-5.6-sol — a string-valued \"summary\" on "+
-			"turn_context must not discard the rest of the record", found[0].ModelID)
-	}
-	if found[0].Cwd != "/Users/someone/proj" {
-		t.Errorf("Cwd = %q", found[0].Cwd)
-	}
-	if found[0].ID != "019f73d7-e215-7ce0-ab38-d9e6db354717" {
-		t.Errorf("ID = %q, want the uuid from the filename tail", found[0].ID)
-	}
-}
-
-// TestCodexHarnessChatterIsNotTheConversation covers the two ways Codex speaks
-// to itself through channels that look like conversation: "developer" messages
-// carrying its system prompt, and <environment_context> injected as a user turn.
-// Neither is the user's work, and both would otherwise dominate a title and the
-// imported transcript.
-func TestCodexHarnessChatterIsNotTheConversation(t *testing.T) {
-	env, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"s","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"developer","content":[{"type":"input_text","text":"You are Codex. Follow the permissions policy."}]}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"<environment_context>\n  <cwd>/w</cwd>\n</environment_context>"}]}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"install hermes on this pc"}]}}`,
-	)
-
-	found, _ := Codex(env).Discover("")
-	if len(found) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(found))
-	}
-	if found[0].Title != "install hermes on this pc" {
-		t.Errorf("Title = %q, want the first real human turn", found[0].Title)
-	}
-
-	events, err := translateCodexAt("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 1 {
-		t.Fatalf("got %d events, want only the human turn: %+v", len(events), events)
-	}
-	encoded, _ := json.Marshal(events)
-	for _, unwanted := range []string{"You are Codex", "environment_context"} {
-		if strings.Contains(string(encoded), unwanted) {
-			t.Errorf("harness chatter %q was imported as conversation", unwanted)
-		}
-	}
-}
-
-func TestCodexToolCallsPairUpAcrossBothCallShapes(t *testing.T) {
-	_, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"s","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"function_call","name":"wait","call_id":"call_1","arguments":"{\"ms\":10}"}}`,
-		`{"type":"response_item","payload":{"type":"function_call_output","call_id":"call_1","output":"done"}}`,
-		`{"type":"response_item","payload":{"type":"custom_tool_call","name":"exec","call_id":"call_2","input":"ls -la"}}`,
-		`{"type":"response_item","payload":{"type":"custom_tool_call_output","call_id":"call_2","output":"[{\"type\":\"input_text\",\"text\":\"a.go\"}]"}}`,
-	)
-	all, err := translateCodexAt("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	events := conversationEvents(all)
-	if len(events) != 4 {
-		t.Fatalf("got %d events, want 4", len(events))
-	}
-	// Both call shapes must carry their name through to their result.
-	for _, pair := range [][2]int{{0, 1}, {2, 3}} {
-		call, result := events[pair[0]], events[pair[1]]
-		if str(t, call, "toolCallId") != str(t, result, "toolCallId") {
-			t.Errorf("call/result ids differ: %q vs %q", str(t, call, "toolCallId"), str(t, result, "toolCallId"))
-		}
-		if str(t, call, "name") != str(t, result, "name") {
-			t.Errorf("result name %q does not match its call %q", str(t, result, "name"), str(t, call, "name"))
-		}
-		if status := str(t, result, "status"); status != "unknown" {
-			t.Errorf("Codex result status = %q, want unknown without structured outcome evidence", status)
-		}
-	}
-	// An output stored as an escaped JSON array must render as its text, not as
-	// raw JSON the reader has to decode by eye.
-	if got := str(t, events[3], "output"); got != "a.go" {
-		t.Errorf("escaped-array output = %q, want the flattened text", got)
-	}
-}
-
-func TestCodexUnknownToolOutcomePreservesOutputWithoutClaimingAFileChange(t *testing.T) {
-	_, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"s","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"function_call","name":"write_file","call_id":"call_1","arguments":"{\"path\":\"/w/config.go\"}"}}`,
-		`{"type":"response_item","payload":{"type":"function_call_output","call_id":"call_1","output":"permission denied"}}`,
-	)
-	events, err := translateCodexAt("", path, ReadOptions{Cwd: "/w"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	conversation := conversationEvents(events)
-	if len(conversation) != 2 {
-		t.Fatalf("conversation events = %d, want call/result: %+v", len(conversation), conversation)
-	}
-	result := conversation[1]
-	if got := str(t, result, "status"); got != "unknown" {
-		t.Fatalf("result status = %q, want unknown", got)
-	}
-	if got := str(t, result, "output"); got != "permission denied" {
-		t.Fatalf("raw result output = %q", got)
-	}
-	for _, summary := range summaryTexts(t, events) {
-		if strings.Contains(summary, "Files changed") || strings.Contains(summary, "config.go") {
-			t.Fatalf("unverified Codex output created a factual file claim: %q", summary)
-		}
-	}
-}
-
-func TestCodexByteTailDropsOrphanResultButKeepsLaterPairAndDisclosure(t *testing.T) {
-	const testByteLimit = 4 << 10
-	padding := strings.Repeat("x", testByteLimit)
-	_, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"s","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"function_call","name":"old_call","call_id":"old","arguments":"{}"}}`,
-		`{"type":"padding","payload":"`+padding+`"}`,
-		`{"type":"response_item","payload":{"type":"function_call_output","call_id":"old","output":"orphaned output"}}`,
-		`{"type":"response_item","payload":{"type":"function_call","name":"new_call","call_id":"new","arguments":"{}"}}`,
-		`{"type":"response_item","payload":{"type":"function_call_output","call_id":"new","output":"kept output"}}`,
-	)
-	events, err := translateCodexAtWithByteLimit("", path, ReadOptions{}, testByteLimit)
-	if err != nil {
-		t.Fatal(err)
-	}
-	conversation := conversationEvents(events)
-	if len(conversation) != 2 {
-		t.Fatalf("byte-tail conversation = %d events, want only later pair: %+v", len(conversation), conversation)
-	}
-	if str(t, conversation[0], "name") != "new_call" ||
-		str(t, conversation[1], "name") != "new_call" ||
-		str(t, conversation[0], "toolCallId") != str(t, conversation[1], "toolCallId") {
-		t.Fatalf("later valid pair was not retained: %+v", conversation)
-	}
-	for _, event := range conversation {
-		if str(t, event, "name") == "old_call" || str(t, event, "output") == "orphaned output" {
-			t.Fatalf("orphan result survived byte-tail normalization: %+v", event)
-		}
-	}
-	joined := strings.Join(summaryTexts(t, events), "\n")
-	if !strings.Contains(joined, "Older transcript records were not imported") {
-		t.Fatalf("byte-tail loss was not disclosed: %q", joined)
-	}
-}
-
-func TestCodexCapCannotLetActivitySummaryEvictSourceTail(t *testing.T) {
-	_, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"s","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"function_call","name":"read_file","call_id":"call_1","arguments":"{\"path\":\"parser.go\"}"}}`,
-		`{"type":"response_item","payload":{"type":"function_call_output","call_id":"call_1","output":"package parser"}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"final codex answer"}]}}`,
-	)
-	events, err := translateCodexAt("", path, ReadOptions{MaxEvents: 2})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 2 {
-		t.Fatalf("got %d capped events, want 2", len(events))
-	}
-	if note := str(t, events[0], "content"); !strings.Contains(note, "not imported") {
-		t.Fatalf("source truncation was silent: got %q", note)
-	}
-	if got := str(t, events[1], "content"); got != "final codex answer" {
-		t.Fatalf("source tail was evicted by generated context: got %q", got)
-	}
-}
-
-func TestCodexDiscoveryIsFixedDepth(t *testing.T) {
-	home := t.TempDir()
-	root := filepath.Join(home, ".codex", "sessions")
-	good := filepath.Join(root, "2026", "08", "01", "rollout-a-019f73d7-e215-7ce0-ab38-d9e6db354717.jsonl")
-	writeFile(t, good, `{"type":"session_meta","payload":{"session_id":"s","cwd":"/w"}}`+"\n")
-
-	// A live OPENAI_API_KEY lives at ~/.codex/auth.json, one level above the
-	// sessions root, plus decoy transcripts a walk would reach.
-	writeFile(t, filepath.Join(home, ".codex", "auth.json"), `{"OPENAI_API_KEY":"sk-MUST_NEVER_BE_READ"}`)
-	for _, stray := range []string{
-		filepath.Join(root, "stray.jsonl"),
-		filepath.Join(root, "2026", "deep.jsonl"),
-		filepath.Join(root, "2026", "08", "01", "nested", "deeper.jsonl"),
-		filepath.Join(home, ".codex", "leaked.jsonl"),
-	} {
-		writeFile(t, stray, `{"type":"session_meta","payload":{"session_id":"x","cwd":"/w"}}`+"\n")
-	}
-
-	paths := Codex(testEnv(home, nil)).(codex).transcripts()
-	if len(paths) != 1 || paths[0] != good {
-		t.Fatalf("transcripts = %v, want exactly [%s]", paths, good)
-	}
-}
-
-func TestTheRealCodexCorpusStillParses(t *testing.T) {
-	if os.Getenv("ZERO_TEST_LIVE_AGENT_SESSIONS") != "1" {
-		t.Skip("set ZERO_TEST_LIVE_AGENT_SESSIONS=1 to inspect the local Codex store")
-	}
-	env := OSEnv()
-	root := codexRoot(env)
-	if root == "" {
-		t.Skip("no home directory")
-	}
-	if _, err := os.Stat(root); err != nil {
-		t.Skip("no Codex store on this machine")
-	}
-	adapter := Codex(env)
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	total := len(adapter.(codex).transcripts())
-	if total == 0 {
-		t.Skip("store exists but holds no rollouts")
-	}
-	titled, modelled := 0, 0
-	for _, session := range found {
-		if session.Title != "" && session.Title != "untitled" && !isCodexContextInjection(session.Title) {
-			titled++
-		}
-		if session.ModelID != "" {
-			modelled++
-		}
-	}
-	t.Logf("indexed %d of %d rollouts; %d titled, %d with a model", len(found), total, titled, modelled)
-	if len(found) == 0 {
-		t.Fatal("no Codex sessions indexed from a non-empty store")
-	}
-	// REPORTED, NOT ASSERTED. What these counts measure is the shape of the store
-	// on the machine running them, which is not a property of this package: the
-	// same code reported "44 of 44 rollouts, 43 with a model" on one machine and
-	// "2 of 2, 0 with a model" on a reviewer's. Failing on the second is a red
-	// build for the contributor and a green one for CI, which is backwards — CI
-	// has no store and skips, so the assertion never ran where a regression would
-	// actually land.
-	//
-	// The shapes behind both numbers are pinned by construction in
-	// fixture_corpus_test.go, which runs everywhere and cannot skip. What this
-	// test is still good for is noticing a shape the fixtures do not cover, so it
-	// prints its counts and leaves the judgement to the reader.
-	if titled == 0 {
-		t.Logf("no session in the live store got a real title; if that is unexpected here, "+
-			"the context-injection filter may have drifted (%d rollouts)", total)
-	}
-	if modelled == 0 {
-		t.Logf("no session in the live store carries a model: every rollout here has its "+
-			"turn_context outside the head budget. TestARolloutWithALateTurnContextIndexesWithoutAModel "+
-			"pins that shape deterministically (%d rollouts)", total)
-	}
-}
@@ -1,39 +0,0 @@
-// Test seams: helpers only test code uses, kept out of the production binary.
-package agentsessions
-
-import "github.com/Gitlawb/zero/internal/sessions"
-
-// The production readers take an open handle (see openSelectedSource) so the
-// identity that was verified is the one that is read. Tests that only care
-// about translation still build a file and name it; these wrappers open it the
-// same way production does and hand the handle through.
-func translateFamily1At(root string, path string, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	file, err := openContained(root, path)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	return translateFamily1(file, options)
-}
-
-func translateCodexAt(root string, path string, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	return translateCodexAtWithByteLimit(root, path, options, importByteLimit)
-}
-
-func translateCodexAtWithByteLimit(root string, path string, options ReadOptions, maxBytes int) ([]sessions.AppendEventInput, error) {
-	file, err := openContained(root, path)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	return translateCodexWithByteLimit(file, options, maxBytes)
-}
-
-func streamTailLinesAt(root string, path string, maxLineBytes int, maxBytes int, visit func(line []byte, truncated bool) bool) (bool, error) {
-	file, err := openContained(root, path)
-	if err != nil {
-		return false, err
-	}
-	defer file.Close()
-	return streamTailLines(file, maxLineBytes, maxBytes, visit)
-}
@@ -1,342 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"errors"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// family1 is the layout two of the agents surveyed independently arrived at:
-// one JSONL file per session, in a directory named after the working directory,
-// with records carrying {type, cwd, timestamp, message:{role, content}} and
-// content blocks of text / thinking / tool_use / tool_result.
-//
-//	Claude Code   ~/.claude/projects/<slug>/<uuid>.jsonl
-//	Factory Droid ~/.factory/sessions/<slug>/<uuid>.jsonl
-//
-// They differ only in where the store lives and which record carries the title:
-// Claude Code writes an "ai-title" record, Factory puts a "title" on
-// "session_start". Everything else — the block vocabulary, the tool_use/
-// tool_result pairing, the role names — is byte-for-byte the same shape, which
-// is why one parser serves both. Pi shares the DIRECTORY layout and reuses
-// discoverFamily1 for it, but its message schema is its own: see pi.go.
-//
-// An adapter is therefore a name and a root.
-type family1 struct {
-	name string
-	root string
-}
-
-func (adapter family1) Name() string { return adapter.name }
-
-func (adapter family1) Discover(cwd string) ([]ForeignSession, error) {
-	return discoverFamily1(adapter.name, adapter.root, cwd, indexFamily1Transcript)
-}
-
-// Read translates one session into Zero events.
-//
-// Unlike Discover, this reports its errors: the user has named a specific
-// session, and returning an empty conversation because the file moved would be
-// a lie about what that session contained.
-func (adapter family1) Read(source ForeignSession, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	if source.Agent != adapter.name || source.ID != transcriptID(source.Path) {
-		return nil, errNotThisAgent(adapter.name)
-	}
-	// One handle from identity check to final check: see openSelectedSource.
-	file, err := openSelectedSource(adapter.root, source)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	events, err := translateFamily1(file, options)
-	if err != nil {
-		return nil, err
-	}
-	if err := validateSourceHandle(file, source); err != nil {
-		return nil, err
-	}
-	return events, nil
-}
-
-// ClaudeCode reads Claude Code's transcripts.
-func ClaudeCode(env Env) Adapter {
-	return family1{name: "claude-code", root: claudeCodeRoot(env)}
-}
-
-// FactoryDroid reads Factory's droid transcripts.
-func FactoryDroid(env Env) Adapter {
-	return family1{name: "factory", root: factoryRoot(env)}
-}
-
-// family1Record is the subset of a family-1 transcript record this package
-// reads. Unknown fields are ignored by encoding/json, which is what lets the
-// adapter survive the format gaining records it has never seen.
-type family1Record struct {
-	Type      string `json:"type"`
-	Cwd       string `json:"cwd"`
-	GitBranch string `json:"gitBranch"`
-	SessionID string `json:"sessionId"`
-	Timestamp string `json:"timestamp"`
-	UUID      string `json:"uuid"`
-	AITitle   string `json:"aiTitle"`
-	// Title is Factory's spelling of the same idea, carried on its
-	// session_start record rather than on a record of its own.
-	Title   string          `json:"title"`
-	Message *family1Message `json:"message"`
-}
-
-type family1Message struct {
-	Role    string          `json:"role"`
-	Model   string          `json:"model"`
-	Content json.RawMessage `json:"content"`
-}
-
-// family1Block is one content block. Message content is either a bare string or
-// an array of these.
-type family1Block struct {
-	Type      string          `json:"type"`
-	Text      string          `json:"text"`
-	Thinking  string          `json:"thinking"`
-	ID        string          `json:"id"`
-	Name      string          `json:"name"`
-	Input     json.RawMessage `json:"input"`
-	ToolUseID string          `json:"tool_use_id"`
-	Content   json.RawMessage `json:"content"`
-	IsError   bool            `json:"is_error"`
-}
-
-// discoverFamily1 is the shared body for the slugged-directory JSONL agents.
-//
-// The slug is a hint only. When a candidate directory exists it is searched
-// first, which turns 1,266 files into the ~223 that belong to this workspace;
-// when none matches, every project directory is indexed and the cwd recorded
-// INSIDE each transcript decides. That ordering matters because the slug cannot
-// be reversed — see slugCandidates.
-func discoverFamily1(
-	agent string,
-	root string,
-	cwd string,
-	index func(agent string, root string, path string) (ForeignSession, bool),
-) ([]ForeignSession, error) {
-	if strings.TrimSpace(root) == "" {
-		return nil, nil
-	}
-
-	// Discovery and the later selected-source open both rely on the directories
-	// returned by globSessionDirs, which Lstat-skips a symlinked project directory
-	// (following one could descend into a credential tree). The slug fast path
-	// must narrow WITHIN that same set, not join root/slug on its own.
-	sessionDirs := globSessionDirs(root)
-	dirs := []string{}
-	if strings.TrimSpace(cwd) != "" {
-		wanted := map[string]bool{}
-		for _, slug := range slugCandidates(cwd) {
-			wanted[slug] = true
-		}
-		for _, dir := range sessionDirs {
-			if wanted[filepath.Base(dir)] &&
-				len(globTranscripts(root, filepath.Join(dir, "*"+transcriptExt))) > 0 {
-				dirs = append(dirs, dir)
-			}
-		}
-	}
-	if len(dirs) == 0 {
-		dirs = sessionDirs
-	}
-
-	found := []ForeignSession{}
-	for _, dir := range dirs {
-		for _, path := range globTranscripts(root, filepath.Join(dir, "*"+transcriptExt)) {
-			session, ok := index(agent, root, path)
-			if !ok {
-				continue
-			}
-			// The transcript's own cwd is the authority, never the directory name.
-			if strings.TrimSpace(cwd) != "" && !sameDir(cwd, session.Cwd) {
-				continue
-			}
-			found = append(found, session)
-		}
-	}
-	sortByRecency(found)
-	return found, nil
-}
-
-// indexFamily1Transcript builds an index entry from a bounded read of the file's
-// head. It returns false for anything it cannot identify as a session, which is
-// how a partially written, empty, or reshaped file drops out of discovery
-// instead of failing it.
-func indexFamily1Transcript(agent string, root string, path string) (ForeignSession, bool) {
-	session := ForeignSession{
-		Agent: agent,
-		ID:    transcriptID(path),
-		Path:  path,
-	}
-	firstPrompt := ""
-
-	_, snapshot, err := scanHeadSnapshot(root, path, defaultHeadLimit, func(line []byte, truncated bool) bool {
-		var record family1Record
-		if json.Unmarshal(line, &record) != nil {
-			// A RECORD TOO LONG TO PARSE STILL CARRIES ITS METADATA AT THE FRONT.
-			// Skipping it whole is right for the body — the cap exists so a giant
-			// tool result is not held in memory — but cwd, the git branch and the
-			// timestamp sit before it, and dropping them with the body cost the
-			// entire session: with no workspace to bind to, discovery dropped a
-			// transcript the user can see on disk, and it looked exactly like a
-			// legitimate stub.
-			//
-			// Only for a TRUNCATED line. A genuinely malformed one is skipped as
-			// before: transcripts are appended live and the last line is routinely
-			// half-written, and guessing at fields there would invent them.
-			if truncated {
-				recovered := topLevelStrings(line, "cwd", "gitBranch", "timestamp")
-				if session.Cwd == "" {
-					session.Cwd = recovered["cwd"]
-				}
-				if session.GitBranch == "" {
-					session.GitBranch = recovered["gitBranch"]
-				}
-				if session.StartedAt.IsZero() {
-					session.StartedAt = parseTimestamp(recovered["timestamp"])
-				}
-			}
-			// One malformed line is not a malformed file: transcripts are
-			// appended live and the last line is routinely half-written.
-			return true
-		}
-		if session.Cwd == "" {
-			session.Cwd = record.Cwd
-		}
-		if session.GitBranch == "" {
-			session.GitBranch = record.GitBranch
-		}
-		if session.StartedAt.IsZero() {
-			session.StartedAt = parseTimestamp(record.Timestamp)
-		}
-		if record.Message != nil && session.ModelID == "" {
-			session.ModelID = record.Message.Model
-		}
-		// An agent-supplied title beats a truncated first prompt, so it wins when
-		// present: Claude Code writes one as an "ai-title" record, Factory as a
-		// "title" on "session_start". Pi writes none, so the prompt is used.
-		if title := firstNonBlank(record.AITitle, record.Title); title != "" {
-			session.Title = title
-		}
-		if firstPrompt == "" && record.Type == "user" && record.Message != nil {
-			firstPrompt = family1Text(record.Message.Content)
-		}
-		return true
-	})
-	if err != nil {
-		return ForeignSession{}, false
-	}
-
-	if session.Title == "" {
-		session.Title = summarizeTitle(firstPrompt)
-	}
-	// A file with no cwd is not a session transcript — most likely a sidecar the
-	// agent dropped into the same directory. Refusing it here keeps discovery
-	// from listing entries that Read could never make sense of.
-	if strings.TrimSpace(session.Cwd) == "" {
-		return ForeignSession{}, false
-	}
-	session.source = snapshot
-	session.UpdatedAt = snapshot.modTime
-	if session.StartedAt.IsZero() {
-		session.StartedAt = session.UpdatedAt
-	}
-	return session, true
-}
-
-// transcriptID is the session's identifier: the file's base name without its
-// extension.
-//
-// Deliberately NOT stored as a path. Read resolves an id by globbing and
-// comparing base names, so a hostile or mistyped id such as "../../auth" can
-// never be joined onto a root and opened — it simply matches nothing.
-func transcriptID(path string) string {
-	base := filepath.Base(path)
-	return strings.TrimSuffix(base, filepath.Ext(base))
-}
-
-// family1Text flattens a message's content to plain text. Content is either a
-// bare string or an array of typed blocks; tool calls and thinking contribute
-// nothing here, since this feeds titles and previews.
-func family1Text(raw json.RawMessage) string {
-	if len(raw) == 0 {
-		return ""
-	}
-	var text string
-	if json.Unmarshal(raw, &text) == nil {
-		return text
-	}
-	var blocks []family1Block
-	if json.Unmarshal(raw, &blocks) != nil {
-		return ""
-	}
-	parts := []string{}
-	for _, block := range blocks {
-		if block.Type == "text" && strings.TrimSpace(block.Text) != "" {
-			parts = append(parts, block.Text)
-		}
-	}
-	return strings.Join(parts, "\n")
-}
-
-func sortByRecency(items []ForeignSession) {
-	sort.SliceStable(items, func(left, right int) bool {
-		if !items[left].UpdatedAt.Equal(items[right].UpdatedAt) {
-			return items[left].UpdatedAt.After(items[right].UpdatedAt)
-		}
-		return items[left].ID < items[right].ID
-	})
-}
-
-func parseTimestamp(value string) time.Time {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return time.Time{}
-	}
-	for _, layout := range []string{time.RFC3339Nano, time.RFC3339} {
-		if parsed, err := time.Parse(layout, trimmed); err == nil {
-			return parsed
-		}
-	}
-	return time.Time{}
-}
-
-// summarizeTitle collapses a prompt to a single short line. Runes, not bytes,
-// so a multi-byte character is never split into invalid UTF-8.
-func summarizeTitle(prompt string) string {
-	// Sanitize the complete source before shortening it. Cutting first can remove
-	// the suffix or closing quote that makes a credential recognizable and leave
-	// a secret-bearing fragment in the persisted title.
-	collapsed := strings.Join(strings.Fields(DisplayField(prompt)), " ")
-	if collapsed == "" {
-		return "untitled"
-	}
-	const limit = 72
-	runes := []rune(collapsed)
-	if len(runes) <= limit {
-		return collapsed
-	}
-	return strings.TrimSpace(string(runes[:limit])) + "…"
-}
-
-func errNotThisAgent(name string) error {
-	return errors.New("agentsessions: selected session does not belong to " + name)
-}
-
-func firstNonBlank(values ...string) string {
-	for _, value := range values {
-		if trimmed := strings.TrimSpace(value); trimmed != "" {
-			return trimmed
-		}
-	}
-	return ""
-}
@@ -1,387 +0,0 @@
-package agentsessions
-
-import (
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// The fixtures below are hand-written to the shapes observed in a real
-// ~/.claude/projects corpus (record types, field names, nesting) rather than
-// copied from real transcripts, which carry the author's actual work. The
-// real-corpus test at the bottom of this file keeps the two honest: it runs
-// against the live store when one exists and skips when it does not.
-
-// writeClaudeStore lays out a projects/ tree and returns its root.
-func writeClaudeStore(t *testing.T, files map[string][]string) string {
-	t.Helper()
-	root := filepath.Join(t.TempDir(), "projects")
-	for relative, lines := range files {
-		writeFile(t, filepath.Join(root, relative), strings.Join(lines, "\n")+"\n")
-	}
-	return root
-}
-
-func TestDiscoverIndexesASessionFromABoundedHeadRead(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/aaa.jsonl": {
-			`{"type":"mode","mode":"default"}`,
-			`{"type":"user","cwd":"/Users/someone/proj","gitBranch":"main","sessionId":"aaa","timestamp":"2026-08-01T10:00:00.000Z","message":{"role":"user","content":"Fix the flaky retry test"}}`,
-			`{"type":"ai-title","aiTitle":"Fix flaky retry test","sessionId":"aaa"}`,
-			`{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"text","text":"On it."}]}}`,
-		},
-	})
-
-	got, err := discoverFamily1("claude-code", root, "/Users/someone/proj", indexFamily1Transcript)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(got))
-	}
-	session := got[0]
-	if session.ID != "aaa" {
-		t.Errorf("ID = %q, want aaa", session.ID)
-	}
-	if session.Cwd != "/Users/someone/proj" {
-		t.Errorf("Cwd = %q", session.Cwd)
-	}
-	if session.GitBranch != "main" {
-		t.Errorf("GitBranch = %q, want main", session.GitBranch)
-	}
-	if session.ModelID != "claude-opus-5" {
-		t.Errorf("ModelID = %q, want claude-opus-5", session.ModelID)
-	}
-	// The agent's own generated title beats a truncated first prompt.
-	if session.Title != "Fix flaky retry test" {
-		t.Errorf("Title = %q, want the ai-title record to win", session.Title)
-	}
-	if session.StartedAt.IsZero() {
-		t.Error("StartedAt was not populated from the first timestamp")
-	}
-}
-
-func TestTheFirstPromptIsTheTitleWhenTheAgentRecordedNone(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/bbb.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"bbb","message":{"role":"user","content":"  Investigate   the   crash \n in the parser  "}}`,
-		},
-	})
-	got, _ := discoverFamily1("claude-code", root, "", indexFamily1Transcript)
-	if len(got) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(got))
-	}
-	if got[0].Title != "Investigate the crash in the parser" {
-		t.Errorf("Title = %q, want the whitespace-collapsed prompt", got[0].Title)
-	}
-}
-
-// TestTheRecordedCwdBeatsTheDirectoryName is the property that makes the lossy
-// slug safe. Both directories below are plausible spellings of the requested
-// cwd, but only one transcript actually ran there.
-func TestTheRecordedCwdBeatsTheDirectoryName(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		// Same slug shape; different real directories.
-		"-Users-someone-dev-zero/real.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/dev/zero","sessionId":"real","message":{"role":"user","content":"in the right place"}}`,
-		},
-		"-Users-someone-dev-zero2/impostor.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/dev-zero","sessionId":"impostor","message":{"role":"user","content":"a different directory"}}`,
-		},
-	})
-
-	got, err := discoverFamily1("claude-code", root, "/Users/someone/dev/zero", indexFamily1Transcript)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != 1 || got[0].ID != "real" {
-		t.Fatalf("got %v, want only the transcript whose recorded cwd matches", ids(got))
-	}
-}
-
-// TestSubagentTranscriptsAreNotSessions pins the fixed-depth glob against the
-// real corpus shape: 997 of 1,266 files in the live store are sub-agent
-// transcripts under <session>/subagents/, and listing them as resumable
-// sessions would bury the 269 real ones.
-func TestSubagentTranscriptsAreNotSessions(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/parent.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"parent","message":{"role":"user","content":"top level"}}`,
-		},
-		"-Users-someone-proj/parent/subagents/agent-1.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"agent-1","message":{"role":"user","content":"delegated"}}`,
-		},
-	})
-	got, _ := discoverFamily1("claude-code", root, "/Users/someone/proj", indexFamily1Transcript)
-	if len(got) != 1 || got[0].ID != "parent" {
-		t.Fatalf("got %v, want only the top-level session", ids(got))
-	}
-}
-
-// TestNonTranscriptsAreSkippedRatherThanListed covers what the live corpus
-// actually contains alongside real sessions: single-record "bridge-session"
-// stubs (9 of 269 there), empty files, and half-written trailing lines from a
-// session being appended to right now.
-func TestNonTranscriptsAreSkippedRatherThanListed(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/good.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"good","message":{"role":"user","content":"real work"}}`,
-			`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"do`, // torn final line
-		},
-		"-Users-someone-proj/bridge.jsonl": {
-			`{"type":"bridge-session","sessionId":"bridge"}`,
-		},
-		"-Users-someone-proj/empty.jsonl":   {""},
-		"-Users-someone-proj/garbage.jsonl": {"not json at all", "{also not"},
-	})
-
-	got, err := discoverFamily1("claude-code", root, "", indexFamily1Transcript)
-	if err != nil {
-		t.Fatalf("discovery must not fail on junk beside real sessions: %v", err)
-	}
-	if len(got) != 1 || got[0].ID != "good" {
-		t.Fatalf("got %v, want only the real session — a torn trailing line must "+
-			"not discard the records before it", ids(got))
-	}
-}
-
-func TestDiscoveryOfAnAbsentStoreIsEmptyNotAnError(t *testing.T) {
-	got, err := discoverFamily1("claude-code", filepath.Join(t.TempDir(), "never-created"), "", indexFamily1Transcript)
-	if err != nil || len(got) != 0 {
-		t.Fatalf("got (%v, %v), want (empty, nil)", ids(got), err)
-	}
-	if got, err := discoverFamily1("claude-code", "", "", indexFamily1Transcript); err != nil || len(got) != 0 {
-		t.Fatalf("empty root: got (%v, %v), want (empty, nil)", ids(got), err)
-	}
-}
-
-func TestSessionsAreListedMostRecentFirst(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/old.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"old","message":{"role":"user","content":"first"}}`,
-		},
-		"-Users-someone-proj/new.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"new","message":{"role":"user","content":"second"}}`,
-		},
-	})
-	// Make the ordering unambiguous rather than relying on write order.
-	older := filepath.Join(root, "-Users-someone-proj", "old.jsonl")
-	if err := os.Chtimes(older, mustTime("2026-01-01T00:00:00Z"), mustTime("2026-01-01T00:00:00Z")); err != nil {
-		t.Fatal(err)
-	}
-	got, _ := discoverFamily1("claude-code", root, "", indexFamily1Transcript)
-	if len(got) != 2 || got[0].ID != "new" {
-		t.Fatalf("got %v, want the most recently updated session first", ids(got))
-	}
-}
-
-// Import resolves ids only from discovery results; it never joins caller text
-// onto the foreign store root.
-func TestImportCannotBeTalkedIntoOpeningAnArbitraryPath(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/aaa.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"aaa","message":{"role":"user","content":"x"}}`,
-		},
-	})
-	// A credential file one level above the store, exactly as every surveyed
-	// agent ships one.
-	secret := filepath.Join(filepath.Dir(root), "auth.json")
-	writeFile(t, secret, `{"access_token":"tok_MUST_NEVER_BE_READ"}`)
-	adapter := family1{name: "claude-code", root: root}
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-
-	for _, hostile := range []string{
-		"../auth",
-		"../../auth",
-		filepath.Join("..", "auth.json"),
-		secret,
-		strings.TrimSuffix(secret, ".json"),
-		"/etc/passwd",
-	} {
-		if _, err := Import(store, adapter, hostile, ReadOptions{}); err == nil {
-			t.Errorf("Import(%q) succeeded, want an error", hostile)
-		}
-	}
-
-	if _, err := Import(store, adapter, "aaa", ReadOptions{}); err != nil {
-		t.Errorf("Import(\"aaa\") = %v, want the discovered transcript", err)
-	}
-}
-
-// TestTheRealCorpusStillParses runs against the live store when there is one.
-// The fixtures above pin the logic; this pins the FORMAT — these are
-// undocumented files belonging to another product, and a shape change upstream
-// should surface here rather than as an empty list in front of a user.
-func TestTheRealCorpusStillParses(t *testing.T) {
-	if os.Getenv("ZERO_TEST_LIVE_AGENT_SESSIONS") != "1" {
-		t.Skip("set ZERO_TEST_LIVE_AGENT_SESSIONS=1 to inspect the local Claude Code store")
-	}
-	env := OSEnv()
-	adapter := ClaudeCode(env)
-	root := claudeCodeRoot(env)
-	if root == "" {
-		t.Skip("no home directory")
-	}
-	if _, err := os.Stat(root); err != nil {
-		t.Skip("no Claude Code store on this machine")
-	}
-
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatalf("discovering the real store failed: %v", err)
-	}
-	transcripts := 0
-	for _, dir := range globSessionDirs(root) {
-		transcripts += len(globTranscripts(root, filepath.Join(dir, "*"+transcriptExt)))
-	}
-	if transcripts == 0 {
-		t.Skip("store exists but holds no transcripts")
-	}
-
-	// Every indexed session must carry the fields the CLI will print. A format
-	// change that silently blanks one of these is the failure mode worth
-	// catching.
-	for _, session := range found {
-		// NAMED, NOT DUMPED. This walks the developer's REAL store, so %+v here
-		// printed their own session titles, working directories and file paths
-		// into the test output — and into any CI log or pasted failure report
-		// that carried it. The field that is empty is the whole diagnostic; the
-		// value that is missing is by definition not the interesting part.
-		var missing []string
-		for name, value := range map[string]string{"ID": session.ID, "Cwd": session.Cwd, "Title": session.Title} {
-			if value == "" {
-				missing = append(missing, name)
-			}
-		}
-		if len(missing) > 0 {
-			sort.Strings(missing)
-			t.Errorf("a live-store index entry is missing %v — every one of these is a field the CLI prints", missing)
-			break
-		}
-	}
-
-	// REPORTED, NOT ASSERTED — for the same reason as the Codex counterpart. This
-	// ratio describes the reviewer's disk, not this package: it read 98% here
-	// (the 7 misses all single-record bridge-session stubs) and 71% on a
-	// reviewer's smaller store, so the threshold decided who got a red build
-	// rather than whether anything was wrong. CI has no store and skips, so the
-	// assertion never ran where a regression would land.
-	//
-	// The two shapes behind a drop are pinned by construction in
-	// fixture_corpus_test.go, which runs everywhere — but they are pinned as two
-	// DIFFERENT things and the distinction matters to whoever reads this next.
-	// "No cwd in any record" is pinned as correct behaviour: such a session has
-	// no workspace to resume into. "A cwd only in a record past MaxLineBytes" is
-	// pinned as an OPEN DEFECT — the session is lost, and the test asserts that
-	// loss rather than its absence. Neither is a claim that the second case is
-	// handled.
-	if ratio := float64(len(found)) / float64(transcripts); ratio < 0.85 {
-		t.Logf("indexed %d of %d real transcripts (%.0f%%) in the live store. A low ratio here is "+
-			"worth looking at by hand: the known-legitimate exclusion is a session with no cwd in "+
-			"any record, and the known defect is a cwd that only appears past defaultHeadLimit.MaxLineBytes",
-			len(found), transcripts, ratio*100)
-	}
-	t.Logf("indexed %d of %d transcripts in the live store", len(found), transcripts)
-}
-
-func mustTime(value string) time.Time {
-	parsed, err := time.Parse(time.RFC3339, value)
-	if err != nil {
-		panic(err)
-	}
-	return parsed
-}
-
-func ids(items []ForeignSession) []string {
-	out := make([]string, 0, len(items))
-	for _, item := range items {
-		out = append(out, item.ID)
-	}
-	return out
-}
-
-// TestASymlinkedSlugDirectoryIsNotListedThenRefused pins the fix for the
-// list-then-refuse divergence. The slug fast path used to glob straight through
-// a symlinked project directory, while selected-source resolution skips it — so
-// Discover listed a session Import could not resolve. Both must agree; here, by
-// both declining to follow the symlink.
-func TestASymlinkedSlugDirectoryIsNotListedThenRefused(t *testing.T) {
-	root := filepath.Join(t.TempDir(), "projects")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	// The transcript lives outside the store, reachable only through a symlinked
-	// slug directory whose name matches cwd /w.
-	elsewhere := filepath.Join(t.TempDir(), "real")
-	writeFile(t, filepath.Join(elsewhere, "sneaky.jsonl"),
-		`{"type":"user","cwd":"/w","sessionId":"sneaky","message":{"role":"user","content":"hi"}}`+"\n")
-	if err := os.Symlink(elsewhere, filepath.Join(root, "-w")); err != nil {
-		t.Skipf("symlinks unavailable on this platform: %v", err)
-	}
-
-	adapter := family1{name: "claude-code", root: root}
-	found, err := adapter.Discover("/w")
-	if err != nil {
-		t.Fatal(err)
-	}
-	// CONTAINMENT FIRST, agreement second. Checking only that Discover and Read
-	// AGREE passes in two opposite worlds: the one where both correctly refuse a
-	// path reached through a symlink, and the one where both happily follow it
-	// out of the store. Agreement is the weaker half of the property and it was
-	// the only half asserted.
-	for _, session := range found {
-		if session.ID == "sneaky" {
-			t.Errorf("Discover followed a symlink out of the store and listed %q from %s", session.ID, elsewhere)
-		}
-	}
-	if _, err := adapter.Read(ForeignSession{Agent: adapter.Name(), ID: "sneaky", Path: filepath.Join(root, "-w", "sneaky.jsonl")}, ReadOptions{}); err == nil {
-		t.Errorf("Read followed a symlink out of the store and imported %s", elsewhere)
-	}
-	// AND THEN agreement, which is what the original fast path broke: it listed
-	// "sneaky" by globbing through the symlink while Read refused it.
-	for _, session := range found {
-		if _, err := adapter.Read(session, ReadOptions{}); err != nil {
-			t.Errorf("Discover listed %q but Read refuses it: %v — list-then-refuse", session.ID, err)
-		}
-	}
-}
-
-// THE LAST-ACTIVITY STAMP MUST STILL ARRIVE THROUGH THE REAL ROOT. fileModTime
-// now opens the transcript through os.Root instead of calling os.Stat, so a root
-// shape it could not open would leave every session on the zero time — sorted
-// last, showing no age — and nothing in this suite would notice, because
-// UpdatedAt had no coverage at all. Discovery through the adapter's own root is
-// the arrangement production uses; the containment test in jsonl_test.go covers
-// the refusal, this covers the success.
-func TestDiscoveryStampsASessionWithItsTranscriptModTime(t *testing.T) {
-	root := writeClaudeStore(t, map[string][]string{
-		"-Users-someone-proj/aaa.jsonl": {
-			`{"type":"user","cwd":"/Users/someone/proj","sessionId":"aaa","message":{"role":"user","content":"go"}}`,
-		},
-	})
-	stamp := time.Date(2026, 5, 4, 3, 2, 1, 0, time.UTC)
-	if err := os.Chtimes(filepath.Join(root, "-Users-someone-proj", "aaa.jsonl"), stamp, stamp); err != nil {
-		t.Fatal(err)
-	}
-
-	got, err := discoverFamily1("claude-code", root, "/Users/someone/proj", indexFamily1Transcript)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != 1 {
-		t.Fatalf("got %d sessions, want 1", len(got))
-	}
-	if !got[0].UpdatedAt.UTC().Equal(stamp) {
-		t.Errorf("UpdatedAt = %v, want the transcript's mtime %v", got[0].UpdatedAt.UTC(), stamp)
-	}
-	// No record in this fixture carries a timestamp, so StartedAt falls back to
-	// the same stamp rather than staying zero.
-	if !got[0].StartedAt.UTC().Equal(stamp) {
-		t.Errorf("StartedAt = %v, want the mtime fallback %v", got[0].StartedAt.UTC(), stamp)
-	}
-}
@@ -1,363 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// The TestTheReal*CorpusStillParses tests pin the on-disk FORMAT, but only on a
-// machine that has a live ~/.claude or ~/.codex store — in CI they Skip, so the
-// format goes unchecked exactly where regressions would land. These tests point
-// the real adapters at a checked-in fixture store under testdata via the same
-// redirect variables production honours (CLAUDE_CONFIG_DIR, CODEX_HOME), so the
-// format-pin runs deterministically and never skips. A shape change upstream
-// fails a test here instead of silently emptying a picker in front of a user.
-//
-// The fixtures carry generic, invented work — never a real transcript — so
-// nothing personal is checked in; the live-store tests keep them honest against
-// the real shapes.
-func fixtureEnv(t *testing.T, redirectVar string, dir string) Env {
-	t.Helper()
-	abs, err := filepath.Abs(filepath.Join("testdata", dir))
-	if err != nil {
-		t.Fatal(err)
-	}
-	return testEnv("", map[string]string{redirectVar: abs})
-}
-
-func TestTheClaudeCodeFixtureParsesEndToEnd(t *testing.T) {
-	adapter := ClaudeCode(fixtureEnv(t, "CLAUDE_CONFIG_DIR", "claude"))
-
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(found) == 0 {
-		t.Fatal("the checked-in Claude Code fixture indexed no sessions — the format pin is broken")
-	}
-	session := found[0]
-	for name, value := range map[string]string{
-		"ID": session.ID, "Cwd": session.Cwd, "Title": session.Title, "ModelID": session.ModelID,
-	} {
-		if value == "" {
-			t.Errorf("%s is empty in the fixture index — it is a field the CLI prints", name)
-		}
-	}
-
-	// Discover and Read must agree: a session the picker lists must import.
-	events, err := adapter.Read(session, ReadOptions{})
-	if err != nil {
-		t.Fatalf("Read of a discovered fixture session failed: %v", err)
-	}
-	if len(events) == 0 {
-		t.Fatal("Read produced no events from the fixture")
-	}
-}
-
-func TestTheCodexFixtureParsesEndToEnd(t *testing.T) {
-	adapter := Codex(fixtureEnv(t, "CODEX_HOME", "codex"))
-
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(found) == 0 {
-		t.Fatal("the checked-in Codex fixture indexed no sessions — the format pin is broken")
-	}
-	session := found[0]
-	if session.ID == "" || session.Cwd == "" || session.ModelID == "" {
-		t.Errorf("incomplete Codex fixture index entry: %+v", session)
-	}
-
-	events, err := adapter.Read(session, ReadOptions{})
-	if err != nil {
-		t.Fatalf("Read of a discovered Codex fixture session failed: %v", err)
-	}
-	if len(events) == 0 {
-		t.Fatal("Read produced no events from the Codex fixture")
-	}
-}
-
-// WHY THESE FIXTURES EXIST. The TestTheReal*CorpusStillParses tests below assert
-// STATISTICS over whatever store the machine running them happens to have, and
-// that is not a property of this package. The same code reported "44 of 44
-// rollouts, 43 with a model" and "360 of 367 transcripts" here while a reviewer
-// with a smaller store got "0 with a model" and "15 of 21 (71%)" and a red
-// build. Green for CI, red for the contributor, and the shapes that actually
-// caused it were never written down anywhere a test could find them.
-//
-// These pin the two shapes by construction, so the behaviour is checked on every
-// machine and a change to it fails here rather than in a reviewer's terminal.
-
-// A SESSION WITH NO cwd ANYWHERE IS NOT INDEXABLE, and that is correct. cwd is
-// only ever carried by user, attachment and system records; the preamble types
-// (queue-operation, last-prompt, mode, permission-mode, bridge-session) never
-// carry it. A transcript that never reached its first user turn therefore has no
-// workspace to bind to, and a picker row for it could not be resumed anywhere.
-//
-// This is the whole of the gap on the machine this was written on: all 7 of the
-// 367 unindexed transcripts were single-record bridge-session stubs.
-func TestASessionWithNoWorkspaceIsNotIndexed(t *testing.T) {
-	adapter := ClaudeCode(fixtureEnv(t, "CLAUDE_CONFIG_DIR", "drops"))
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	indexed := map[string]ForeignSession{}
-	for _, session := range found {
-		indexed[session.ID] = session
-	}
-	for _, id := range []string{"bridge", "preamble"} {
-		if session, listed := indexed[id]; listed {
-			t.Errorf("%q has no cwd in any record but was indexed as %+v — the picker would offer a session that cannot be resumed", id, session)
-		}
-	}
-	// THE CONTROL, so the two assertions above cannot pass because the whole
-	// fixture store failed to load and nothing was indexed at all.
-	good, listed := indexed["good"]
-	if !listed {
-		t.Fatalf("the control session was not indexed; the drop assertions above prove nothing. Indexed: %v", found)
-	}
-	if good.Cwd != "/w" || good.Title == "" || good.ModelID == "" {
-		t.Errorf("the control session lost a field the CLI prints: %+v", good)
-	}
-}
-
-// A WORKSPACE SURVIVES AN OVERLONG RECORD, at every size.
-//
-// This test has been wrong twice and the history is worth keeping. It first
-// asserted the workspace "is still found" using a 1 KiB record against a 64 KiB
-// cap — 64x under the boundary it was named for, so it only reacted if the
-// production constant was cut to 512. @Vasanthdev2004 measured what actually
-// happened (1 KiB indexes, 60 KiB indexes, 70 KiB does not, 200 KiB does not)
-// and it was the opposite of the name.
-//
-// It was then renamed to pin the loss honestly. CodeRabbit's answer to that was
-// the better one: recover the metadata instead of documenting its absence.
-//
-// THE MECHANISM. A record over MaxLineBytes still arrives as a prefix, and the
-// fields discovery needs — cwd, the branch, the timestamp — sit at the FRONT of
-// the object, before the message body that made it oversized. topLevelStrings
-// reads them off the prefix with a token stream that stops cleanly at the cut,
-// so what it recovers was genuinely complete and genuinely top-level. The body
-// is still discarded, which is the whole point of the cap.
-//
-// This mattered on the real corpus: the opening user record is already over the
-// cap in 30 of 367 transcripts here, and 73 of the 360 indexed sessions (20%)
-// were taking their cwd from a following attachment record purely by luck. One
-// without that rescue disappeared.
-func TestAWorkspaceInAnOverlongRecordIsRecovered(t *testing.T) {
-	for _, size := range []int{1 << 10, 60 << 10, 70 << 10, 200 << 10} {
-		root := t.TempDir()
-		dir := filepath.Join(root, "projects", "-w")
-		if err := os.MkdirAll(dir, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		record := map[string]any{
-			"type": "user", "cwd": "/w", "gitBranch": "main", "timestamp": "2026-01-01T00:00:01Z",
-			"message": map[string]any{"role": "user", "model": "m", "content": strings.Repeat("p", size)},
-		}
-		encoded, err := json.Marshal(record)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(dir, "s.jsonl"), append(encoded, '\n'), 0o644); err != nil {
-			t.Fatal(err)
-		}
-
-		found, err := ClaudeCode(testEnv("", map[string]string{"CLAUDE_CONFIG_DIR": root})).Discover("")
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(found) != 1 {
-			t.Fatalf("a %d-byte record (cap %d) yielded %d sessions; the workspace was not recovered",
-				len(encoded), defaultHeadLimit.MaxLineBytes, len(found))
-		}
-		if found[0].Cwd != "/w" {
-			t.Errorf("a %d-byte record indexed with Cwd %q, want /w", len(encoded), found[0].Cwd)
-		}
-		if found[0].GitBranch != "main" {
-			t.Errorf("a %d-byte record lost its branch: %q", len(encoded), found[0].GitBranch)
-		}
-	}
-}
-
-// AND A GENUINELY MALFORMED LINE IS STILL SKIPPED. The recovery above applies
-// only to a record the cap cut short. A half-written final line — which every
-// live-appended transcript has — must not have fields guessed out of it, or the
-// index would invent a workspace from whatever bytes happened to land.
-func TestAHalfWrittenRecordIsNotMinedForMetadata(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "projects", "-w")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	// THE TORN LINE COMES FIRST, so its cwd would win if it were mined. With the
-	// valid record first, session.Cwd is already set and the "only fill what is
-	// empty" guard hides the difference — an earlier version of this test made
-	// exactly that mistake and passed against a mutation that mined every
-	// unparsable line.
-	torn := `{"type":"user","cwd":"/somewhere-else","messa`
-	good := `{"type":"user","cwd":"/w","timestamp":"2026-01-01T00:00:00Z","message":{"role":"user","model":"m","content":"hi"}}`
-	if err := os.WriteFile(filepath.Join(dir, "s.jsonl"), []byte(torn+"\n"+good+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	found, err := ClaudeCode(testEnv("", map[string]string{"CLAUDE_CONFIG_DIR": root})).Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(found) != 1 {
-		t.Fatalf("expected the session to index from its valid record, got %d", len(found))
-	}
-	if found[0].Cwd != "/w" {
-		t.Errorf("the torn line's cwd was used: %q", found[0].Cwd)
-	}
-}
-
-// turn_context IS THE ONLY RECORD CARRYING THE MODEL, and it is not always near
-// the top. session_meta has no "model" key at all — enumerated across a real
-// 44-rollout store, only turn_context does — so a rollout whose turn_context
-// falls outside the bounded head scan indexes with an empty ModelID. This is the
-// shape behind a reviewer's "2 titled, 0 with a model": their rollouts had it
-// late, the ones here have it at line 4-8.
-//
-// The session is still listed, titled, addressable and importable; only the
-// model label is missing. That is the intended trade — Discover walks the entire
-// date-partitioned store on every picker open and must stay cheap — so this test
-// pins the CURRENT behaviour rather than asserting the model is recovered. If
-// the index is ever taught to recover it, this test should fail and be updated
-// deliberately, not silently drift.
-func TestARolloutWithALateTurnContextIndexesWithoutAModel(t *testing.T) {
-	adapter := Codex(fixtureEnv(t, "CODEX_HOME", "codex-late"))
-	found, err := adapter.Discover("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(found) != 1 {
-		t.Fatalf("expected exactly the one late-turn_context rollout, got %d: %v", len(found), found)
-	}
-	session := found[0]
-	// The session is NOT lost — that is the part that matters.
-	if session.Cwd == "" {
-		t.Errorf("a rollout with a late turn_context lost its workspace too: %+v", session)
-	}
-	if session.ModelID != "" {
-		t.Errorf("ModelID is %q; the head scan is not supposed to reach a turn_context past the line budget. "+
-			"If the index was deliberately taught to recover it, update this test and the comment above it.", session.ModelID)
-	}
-	// And it still imports, which is what "not lost" has to mean in practice.
-	events, err := adapter.Read(session, ReadOptions{})
-	if err != nil {
-		t.Fatalf("a rollout indexed without a model failed to import: %v", err)
-	}
-	if len(events) == 0 {
-		t.Error("the late-turn_context rollout imported no events")
-	}
-}
-
-// AN ORDINARY LONG MESSAGE IS NOT AN EDGE CASE, and it was being deleted from
-// the imported conversation without a word. Both translators passed the
-// DISCOVERY per-line cap (64 KiB) to streamLines — a budget that exists because
-// the index pays it once per file across the whole store — so a single assistant
-// reply over 64 KiB was truncated into invalid JSON, skipped, and Read returned
-// nil error.
-//
-// The result was worse than incomplete: the restored transcript read as a
-// question, no answer, then the user's follow-up. Both the user and the model
-// continuing the session would see a conversation that looks whole.
-func TestAnOrdinaryLongMessageSurvivesImport(t *testing.T) {
-	adapter, _ := longMessageStore(t, 65*1024)
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover long-message session: %v (%d results)", err, len(found))
-	}
-	events, err := adapter.Read(found[0], ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 3 {
-		t.Fatalf("a %d KiB assistant reply was dropped from the import: got %d events, want 3", 65, len(events))
-	}
-	if got := payloadText(t, events[1]); len(got) < 60*1024 {
-		t.Errorf("the long reply was imported truncated: %d bytes", len(got))
-	}
-}
-
-// PAST THE IMPORT CAP TOO, THE LOSS IS NAMED. The cap is still a cap — a
-// transcript cannot be allowed to exhaust memory — but a record that exceeds it
-// produces a marker rather than a hole, so the gap is visible to whoever reads
-// the session next.
-func TestARecordPastTheImportCapIsReportedNotDropped(t *testing.T) {
-	adapter, _ := longMessageStore(t, 9<<20)
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover oversized session: %v (%d results)", err, len(found))
-	}
-	events, err := adapter.Read(found[0], ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var reported bool
-	for _, event := range events {
-		if event.Type == sessions.EventError && strings.Contains(payloadText(t, event), "could not be read") {
-			reported = true
-		}
-	}
-	if !reported {
-		t.Errorf("a record past the import cap vanished silently; events=%d", len(events))
-	}
-}
-
-func longMessageStore(t *testing.T, size int) (Adapter, string) {
-	t.Helper()
-	root := t.TempDir()
-	dir := filepath.Join(root, "projects", "-w")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	body := strings.Repeat("x", size)
-	records := []any{
-		map[string]any{"type": "user", "cwd": "/w", "timestamp": "2026-01-01T00:00:00Z",
-			"message": map[string]any{"role": "user", "model": "m", "content": "short question"}},
-		map[string]any{"type": "assistant", "cwd": "/w", "timestamp": "2026-01-01T00:00:01Z",
-			"message": map[string]any{"role": "assistant", "content": body}},
-		map[string]any{"type": "user", "cwd": "/w", "timestamp": "2026-01-01T00:00:02Z",
-			"message": map[string]any{"role": "user", "content": "follow up"}},
-	}
-	file, err := os.Create(filepath.Join(dir, "s.jsonl"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, record := range records {
-		encoded, err := json.Marshal(record)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := file.Write(append(encoded, '\n')); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := file.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return ClaudeCode(testEnv("", map[string]string{"CLAUDE_CONFIG_DIR": root})), root
-}
-
-func payloadText(t *testing.T, event sessions.AppendEventInput) string {
-	t.Helper()
-	payload, ok := event.Payload.(map[string]any)
-	if !ok {
-		t.Fatalf("unexpected payload shape %T", event.Payload)
-	}
-	for _, key := range []string{"content", "message"} {
-		if value, ok := payload[key].(string); ok {
-			return value
-		}
-	}
-	return ""
-}
@@ -1,279 +0,0 @@
-package agentsessions
-
-import (
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// TestAnImportedSessionIsResumable is the end-to-end join this whole package
-// exists to reach: a foreign transcript becomes a Zero session that Zero's own
-// resume machinery accepts, with no special-casing anywhere downstream.
-//
-// It runs the real sessions.PrepareExec and sessions.FormatExecPrompt — the
-// same functions behind `zero exec --resume` and the TUI's /resume — so a change
-// to either that broke imported sessions would fail here rather than in front of
-// a user. The only thing it does not do is call a provider.
-func TestAnImportedSessionIsResumable(t *testing.T) {
-	home := t.TempDir()
-	transcript := filepath.Join(home, ".claude", "projects", "-Users-someone-proj", "abc123.jsonl")
-	writeFile(t, transcript, strings.Join([]string{
-		`{"type":"user","cwd":"/Users/someone/proj","gitBranch":"fix/parser","sessionId":"abc123","timestamp":"2026-08-01T10:00:00.000Z","message":{"role":"user","content":"The parser drops trailing commas"}}`,
-		`{"type":"ai-title","aiTitle":"Fix trailing comma parsing","sessionId":"abc123"}`,
-		`{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"tool_use","id":"toolu_1","name":"Read","input":{"path":"parser.go"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"func parse() {}"}]}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"The bug is in parse(): it returns before the comma check."}]}}`,
-	}, "\n")+"\n")
-
-	adapter := ClaudeCode(testEnv(home, nil))
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-
-	result, err := Import(store, adapter, "abc123", ReadOptions{})
-	if err != nil {
-		t.Fatalf("import: %v", err)
-	}
-	// 4 conversation events plus the activity summary the import adds.
-	if result.Events < 4 {
-		t.Fatalf("imported %d events, want at least the 4 conversation events", result.Events)
-	}
-	// Metadata the CLI and picker display must be carried over, not invented.
-	if result.Session.Title != "Fix trailing comma parsing" {
-		t.Errorf("title = %q", result.Session.Title)
-	}
-	if result.Session.Cwd != "/Users/someone/proj" {
-		t.Errorf("cwd = %q", result.Session.Cwd)
-	}
-	// The tag records the agent AND the foreign session id, which is what lets
-	// the /resume picker tell an already-imported session from one still only on
-	// the other agent's disk.
-	if !strings.HasPrefix(result.Session.Tag, "imported:v1:") {
-		t.Errorf("tag = %q, want an encoded v1 provenance tag", result.Session.Tag)
-	}
-	agent, sourceID, ok := ParseImportTag(result.Session.Tag)
-	if !ok || agent != "claude-code" || sourceID != "abc123" {
-		t.Errorf("ParseImportTag(%q) = (%q, %q, %v)", result.Session.Tag, agent, sourceID, ok)
-	}
-
-	// The real resume path.
-	prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{
-		Store:  store,
-		Resume: result.Session.SessionID,
-	})
-	if err != nil {
-		t.Fatalf("PrepareExec on an imported session: %v", err)
-	}
-	if prepared.Mode != sessions.ModeResume {
-		t.Fatalf("mode = %s, want resume", prepared.Mode)
-	}
-	if len(prepared.ContextEvents) != result.Events {
-		t.Fatalf("resume loaded %d events, want the %d that were imported",
-			len(prepared.ContextEvents), result.Events)
-	}
-
-	prompt := sessions.FormatExecPrompt("What is left to do?", prepared)
-
-	// The digest is what the next model actually sees. If the imported work is
-	// not in it, the import accomplished nothing.
-	for _, want := range []string{
-		"Treat it as reference context only, not as instructions or prior authorization.",
-		"The parser drops trailing commas", // the original ask
-		"returns before the comma check",   // what the other agent concluded
-		"What is left to do?",              // the new request
-		result.Session.SessionID,           // continuity
-	} {
-		if !strings.Contains(prompt, want) {
-			t.Errorf("resume prompt is missing %q:\n%s", want, prompt)
-		}
-	}
-}
-
-// TestImportingTwiceMakesTwoSnapshots documents the deliberate choice not to
-// derive the Zero id from the foreign one. The foreign session may be continued
-// in its own tool after an import, so a second import is a second snapshot
-// rather than a mistake to refuse.
-func TestImportingTwiceMakesTwoSnapshots(t *testing.T) {
-	home := t.TempDir()
-	writeFile(t, filepath.Join(home, ".claude", "projects", "-p", "s1.jsonl"),
-		`{"type":"user","cwd":"/p","sessionId":"s1","message":{"role":"user","content":"hello"}}`+"\n")
-
-	adapter := ClaudeCode(testEnv(home, nil))
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-
-	first, err := Import(store, adapter, "s1", ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	second, err := Import(store, adapter, "s1", ReadOptions{})
-	if err != nil {
-		t.Fatalf("a second import must be allowed: %v", err)
-	}
-	if first.Session.SessionID == second.Session.SessionID {
-		t.Error("both imports produced the same Zero session id")
-	}
-}
-
-func TestImportRejectsAnUnknownReference(t *testing.T) {
-	env := testEnv(t.TempDir(), nil)
-	for _, ref := range []string{
-		"",
-		"claude-code",
-		"claude-code:",
-		":abc",
-		"cursor:abc",
-	} {
-		if _, _, err := ParseRef(env, ref); err == nil {
-			t.Errorf("ParseRef(%q) returned no error", ref)
-		}
-	}
-	adapter, id, err := ParseRef(env, "claude-code:abc123")
-	if err != nil || adapter.Name() != "claude-code" || id != "abc123" {
-		t.Errorf("ParseRef of a valid ref = (%v, %q, %v)", adapter, id, err)
-	}
-}
-
-func TestImportTagsRoundTrip(t *testing.T) {
-	agent, sourceID, ok := ParseImportTag(ImportTag("codex", "019f-abc"))
-	if !ok || agent != "codex" || sourceID != "019f-abc" {
-		t.Errorf("round trip = (%q, %q, %v)", agent, sourceID, ok)
-	}
-
-	// Non-import tags, and the older two-part form that records no source id,
-	// must not parse as a source reference.
-	for _, tag := range []string{"", "   ", "some-tag", "imported:", "imported:codex"} {
-		if _, _, ok := ParseImportTag(tag); ok {
-			t.Errorf("ParseImportTag(%q) reported a source id it does not have", tag)
-		}
-	}
-
-	// ImportedAgent is deliberately more forgiving: a session imported before
-	// the tag carried a source id must still group under its agent in the
-	// picker rather than silently becoming a Zero-native session.
-	for tag, want := range map[string]string{
-		"imported:codex":           "codex",
-		"imported:claude-code:abc": "claude-code",
-		"":                         "",
-		"unrelated":                "",
-	} {
-		if got := ImportedAgent(tag); got != want {
-			t.Errorf("ImportedAgent(%q) = %q, want %q", tag, got, want)
-		}
-	}
-}
-
-func TestImportTagEncodesUntrustedProvenanceBeforeDisplay(t *testing.T) {
-	agent := "co\x1bdex"
-	sourceID := "session-\u202ejson\u2066"
-	tag := ImportTag(agent, sourceID)
-	for _, r := range tag {
-		if !safeProvenanceRune(r) {
-			t.Fatalf("provenance tag contains a display-unsafe rune %U: %q", r, tag)
-		}
-	}
-	if strings.Contains(tag, sourceID) || strings.ContainsAny(tag, "\x1b\u202e\u2066") {
-		t.Fatalf("raw foreign provenance survived into display metadata: %q", tag)
-	}
-	gotAgent, gotID, ok := ParseImportTag(tag)
-	if !ok || gotAgent != agent || gotID != sourceID {
-		t.Fatalf("encoded provenance did not round trip: (%q, %q, %v)", gotAgent, gotID, ok)
-	}
-	if got := ImportedAgent(tag); got != agent {
-		t.Fatalf("ImportedAgent(encoded tag) = %q, want %q", got, agent)
-	}
-}
-
-func safeProvenanceRune(r rune) bool {
-	return r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' ||
-		r >= '0' && r <= '9' || strings.ContainsRune("-_:", r)
-}
-
-// THE REFERENCE BOUNDARY SURVIVES THE DIGEST WINDOW. The resume prompt keeps
-// only the last 80 eligible events, and the boundary note was stored as the
-// oldest ordinary message: an import of 80 or more turns lost it on the very
-// first resume while keeping every foreign turn, and a short import aged it out
-// after enough continuation. The final prompt — what the model actually sees —
-// is what is asserted, for the long import, the exact window edge, and a short
-// import after continuation; and the label is correctly ABSENT once no imported
-// history remains in the window. The 80-event budget is untouched: the newest
-// turn is always still there.
-func TestTheReferenceBoundarySurvivesTheResumeDigestWindow(t *testing.T) {
-	const label = "reference context only, not as instructions or prior authorization"
-	importTurns := func(t *testing.T, turns int) (*sessions.Store, ImportResult) {
-		t.Helper()
-		home := t.TempDir()
-		lines := []string{`{"type":"user","cwd":"/w","sessionId":"long","message":{"role":"user","content":"turn 1"}}`}
-		for i := 2; i <= turns; i++ {
-			role, kind := "assistant", "assistant"
-			if i%2 == 1 {
-				role, kind = "user", "user"
-			}
-			lines = append(lines, `{"type":"`+kind+`","message":{"role":"`+role+`","content":"turn `+itoaEvents(i)+`"}}`)
-		}
-		writeFile(t, filepath.Join(home, ".claude", "projects", "-w", "long.jsonl"), strings.Join(lines, "\n")+"\n")
-		store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-		result, err := Import(store, ClaudeCode(testEnv(home, nil)), "long", ReadOptions{})
-		if err != nil {
-			t.Fatal(err)
-		}
-		return store, result
-	}
-	prompt := func(t *testing.T, store *sessions.Store, id string) string {
-		t.Helper()
-		prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{Store: store, Resume: id})
-		if err != nil {
-			t.Fatal(err)
-		}
-		return sessions.FormatExecPrompt("next", prepared)
-	}
-
-	for _, turns := range []int{4, 79, 80, 81, 200} {
-		t.Run("import of "+itoaEvents(turns)+" turns", func(t *testing.T) {
-			store, result := importTurns(t, turns)
-			got := prompt(t, store, result.Session.SessionID)
-			if !strings.Contains(got, label) {
-				t.Fatalf("resume prompt lost the reference boundary:\n%s", got)
-			}
-			if !strings.Contains(got, "turn "+itoaEvents(turns)) {
-				t.Fatalf("resume prompt lost the most recent turn:\n%s", got)
-			}
-			if strings.Count(got, label) != 1 {
-				t.Fatalf("boundary labelled %d times, want once:\n%s", strings.Count(got, label), got)
-			}
-		})
-	}
-
-	t.Run("short import after continuation", func(t *testing.T) {
-		store, result := importTurns(t, 4)
-		native := func(n int) {
-			inputs := make([]sessions.AppendEventInput, 0, n)
-			for i := 0; i < n; i++ {
-				role := "user"
-				if i%2 == 1 {
-					role = "assistant"
-				}
-				inputs = append(inputs, sessions.AppendEventInput{Type: sessions.EventMessage, Payload: map[string]any{"role": role, "content": "native " + itoaEvents(i)}})
-			}
-			if _, err := store.AppendEvents(result.Session.SessionID, inputs); err != nil {
-				t.Fatal(err)
-			}
-		}
-		// Enough native turns to push the boundary note out of the 80-event
-		// window while imported turns are still inside it.
-		native(80 - (result.Events - 1))
-		got := prompt(t, store, result.Session.SessionID)
-		if !strings.Contains(got, label) {
-			t.Fatalf("boundary was lost while imported history was still in the window:\n%s", got)
-		}
-		if !strings.Contains(got, "turn 4") {
-			t.Fatalf("imported history that should still be retained is gone:\n%s", got)
-		}
-		// And enough to push every imported turn out: then there is nothing
-		// foreign left to label, and labelling would be a false claim.
-		native(100)
-		got = prompt(t, store, result.Session.SessionID)
-		if strings.Contains(got, label) {
-			t.Fatalf("boundary was asserted with no imported history in the window:\n%s", got)
-		}
-	})
-}
@@ -1,433 +0,0 @@
-package agentsessions
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// headLimit bounds a discovery-time read of a transcript.
-//
-// Discovery lists sessions; it must never pay for their contents. A working
-// machine here holds 439 MB of Claude Code transcripts across 1,266 files, one
-// of them 73 MB on its own, so "just parse it and take the first few fields"
-// turns `sessions discover` into something nobody runs twice.
-//
-// All three bounds are needed, and MaxBytes is the one that actually saves us:
-// a single transcript line can be megabytes (one large tool result), so a
-// line-count bound alone would still stream the whole file looking for the 64th
-// newline. MaxBytes is enforced by an io.LimitReader around the file, which
-// caps bytes pulled off disk regardless of where the newlines fall.
-type headLimit struct {
-	MaxLines     int
-	MaxBytes     int64
-	MaxLineBytes int
-}
-
-// defaultHeadLimit is sized from the real corpus, and MaxBytes in particular was
-// set by measurement rather than by taste.
-//
-// Across sampled Claude Code transcripts the record carrying cwd/gitBranch/
-// sessionId is line 3 and the ai-title record line 8, so 64 lines is ample. The
-// byte budget is the subtle one: it is a budget for the whole scan, so a single
-// outsized record spends it and starves the records after it. Three real
-// sessions in a 269-file corpus open with a ~334 KB queue-operation record and
-// were dropped entirely at a 256 KiB budget — the scan never reached line 3.
-//
-// 2 MiB clears that case with room to spare while still bounding a 73 MB
-// transcript to a ~36x smaller read. The budget only ever binds on pathological
-// files; a normal transcript's first 64 lines are a few KB in total and the line
-// count ends the scan long before the bytes do.
-// importLineLimit is the per-record cap for a FULL import, which is a
-// deliberate one-off read of one file the user named — not the index's sweep of
-// every transcript on disk. The discovery cap is 64 KiB because it is paid once
-// per file across the whole store; applying it to an import silently deleted
-// ordinary long messages from the conversation being restored. Still bounded, so
-// a corrupt file cannot exhaust memory.
-const importLineLimit = 8 << 20
-
-var defaultHeadLimit = headLimit{
-	MaxLines:     64,
-	MaxBytes:     2 << 20,
-	MaxLineBytes: 64 << 10,
-}
-
-// countingReader records how many bytes were actually pulled from the file, so
-// tests can assert the bound holds rather than trusting that it does.
-type countingReader struct {
-	inner io.Reader
-	count int64
-}
-
-func (reader *countingReader) Read(buffer []byte) (int, error) {
-	read, err := reader.inner.Read(buffer)
-	reader.count += int64(read)
-	return read, err
-}
-
-// scanHeadSnapshot binds discovery metadata and its source identity to the same
-// open file handle. Taking the snapshot in a second open leaves a replacement
-// window where metadata can describe one transcript while Read is authorized
-// to import another.
-func scanHeadSnapshot(root string, path string, limit headLimit, visit func(line []byte, truncated bool) bool) (int64, sourceSnapshot, error) {
-	file, err := openContained(root, path)
-	if err != nil {
-		return 0, sourceSnapshot{}, err
-	}
-	defer file.Close()
-	before, err := file.Stat()
-	if err != nil {
-		return 0, sourceSnapshot{}, err
-	}
-	if !before.Mode().IsRegular() {
-		return 0, sourceSnapshot{}, errors.New("agentsessions: transcript is not a regular file")
-	}
-
-	counter := &countingReader{inner: io.LimitReader(file, limit.MaxBytes)}
-	reader := bufio.NewReaderSize(counter, 64<<10)
-
-	for line := 0; line < limit.MaxLines; line++ {
-		content, truncated, err := readBoundedLineTruncated(reader, limit.MaxLineBytes)
-		if (len(content) > 0 || truncated) && !visit(content, truncated) {
-			break
-		}
-		if err != nil {
-			// EOF IS THE ONLY CLEAN STOP. Every other read error — a truncated
-			// file, an I/O failure, a directory replaced mid-scan — was reported
-			// as a successful partial scan, so a session indexed off whatever
-			// bytes happened to arrive before the failure looked exactly like one
-			// indexed off a whole file. The caller cannot decline what it is not
-			// told about.
-			if err == io.EOF {
-				break
-			}
-			return counter.count, sourceSnapshot{}, err
-		}
-	}
-	after, err := file.Stat()
-	if err != nil {
-		return counter.count, sourceSnapshot{}, err
-	}
-	if !os.SameFile(before, after) || before.Size() != after.Size() || !before.ModTime().Equal(after.ModTime()) {
-		return counter.count, sourceSnapshot{}, errors.New("agentsessions: transcript changed during discovery")
-	}
-	return counter.count, sourceSnapshot{info: after, size: after.Size(), modTime: after.ModTime()}, nil
-}
-
-// openContained opens path through a handle on root, so the containment checked
-// when the path was globbed still holds at the moment of the read.
-//
-// THE GAP IS BETWEEN THE CHECK AND THE OPEN. globTranscripts already refuses a
-// symlink wearing a transcript extension, but that verdict is about the state of
-// the tree at glob time; anything can replace an entry before the file is
-// actually opened, and os.Open would follow it out of the store. os.Root
-// resolves every component itself and refuses to leave, so the window closes.
-//
-// An empty root opens directly, which is what the unit tests for this file need
-// — they build a single transcript in a temp dir with no store around it.
-func openContained(root string, path string) (*os.File, error) {
-	if strings.TrimSpace(root) == "" {
-		return os.Open(path)
-	}
-	relative, err := filepath.Rel(root, path)
-	if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
-		return nil, fmt.Errorf("transcript %s is outside the store root %s", path, root)
-	}
-	handle, err := os.OpenRoot(root)
-	if err != nil {
-		return nil, err
-	}
-	defer handle.Close()
-	return handle.Open(relative)
-}
-
-// streamTailLines visits complete records from at most the final maxBytes of a
-// transcript. Foreign session files are append-only in practice, and resume
-// needs their tail; bounding the window prevents one explicitly selected but
-// enormous transcript from turning import into an unbounded disk/CPU job.
-//
-// prefixOmitted reports that older bytes were deliberately skipped. If the
-// window begins in a record, that partial record is consumed and withheld so a
-// JSON fragment can never masquerade as a complete event.
-//
-// It reads from an OPEN HANDLE rather than a path: the handle is the file whose
-// identity was proved against the discovery snapshot (openSelectedSource), and
-// reading by path again would be a second, unverified lookup. See
-// validateSourceHandle for why that mattered.
-func streamTailLines(file readSeekStater, maxLineBytes int, maxBytes int, visit func(line []byte, truncated bool) bool) (prefixOmitted bool, err error) {
-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return false, err
-	}
-	info, err := file.Stat()
-	if err != nil {
-		return false, err
-	}
-	extent := info.Size()
-	start := int64(0)
-	if maxBytes > 0 && extent > int64(maxBytes) {
-		prefixOmitted = true
-		start = extent - int64(maxBytes)
-		if _, err := file.Seek(start-1, io.SeekStart); err != nil {
-			return false, err
-		}
-		previous := []byte{0}
-		if _, err := io.ReadFull(file, previous); err != nil {
-			return false, err
-		}
-		if _, err := file.Seek(start, io.SeekStart); err != nil {
-			return false, err
-		}
-		if previous[0] != '\n' {
-			reader := bufio.NewReaderSize(io.LimitReader(file, extent-start), 64<<10)
-			if _, _, err := readBoundedLineTruncated(reader, 0); err != nil && err != io.EOF {
-				return false, err
-			}
-			return prefixOmitted, streamReaderLines(reader, maxLineBytes, visit)
-		}
-	} else if _, err := file.Seek(start, io.SeekStart); err != nil {
-		return false, err
-	}
-
-	return prefixOmitted, streamReaderLines(
-		bufio.NewReaderSize(io.LimitReader(file, extent-start), 64<<10),
-		maxLineBytes,
-		visit,
-	)
-}
-
-func streamReaderLines(reader *bufio.Reader, maxLineBytes int, visit func(line []byte, truncated bool) bool) error {
-	for {
-		content, truncated, err := readBoundedLineTruncated(reader, maxLineBytes)
-		if (len(content) > 0 || truncated) && !visit(content, truncated) {
-			return nil
-		}
-		if err != nil {
-			if err == io.EOF {
-				return nil
-			}
-			return err
-		}
-	}
-}
-
-// readBoundedLineTruncated consumes through the next newline, returns at most
-// keep bytes of it, and reports whether anything was discarded.
-//
-// bufio.Scanner is deliberately not used: it fails the whole scan on a token
-// longer than its buffer, and these transcripts routinely contain lines far
-// past any sensible buffer size. Here an overlong line is consumed and
-// truncated, so one giant record costs a skip rather than the entire file.
-//
-// THE CALLER HAS TO BE ABLE TO TELL. A truncated record is returned as invalid
-// JSON, and every caller reacted by skipping it — which is right for the index,
-// where a session is still listed, and wrong for an import, where the skipped
-// bytes were the conversation itself. Without this the two cases are
-// indistinguishable, so the import path could not report what it had lost.
-func readBoundedLineTruncated(reader *bufio.Reader, keep int) ([]byte, bool, error) {
-	var kept []byte
-	total := 0
-	for {
-		chunk, err := reader.ReadSlice('\n')
-		total += len(chunk)
-		if room := keep - len(kept); room > 0 {
-			if room > len(chunk) {
-				room = len(chunk)
-			}
-			// ReadSlice returns a view into the reader's buffer, invalidated by
-			// the next read, so this must copy.
-			kept = append(kept, chunk[:room]...)
-		}
-		if err == bufio.ErrBufferFull {
-			continue
-		}
-		// THE LINE TERMINATOR IS NOT CONTENT. Counting it made a record whose
-		// content exactly fills keep report as truncated, and a CRLF file was one
-		// byte worse — so an import emitted "could not be read" for records that
-		// had in fact been read in full, which is a false alarm in the one place
-		// this signal exists to be trusted.
-		return bytes.TrimRight(kept, "\r\n"), total-terminatorBytes(chunk) > keep, err
-	}
-}
-
-// terminatorBytes is the length of the trailing newline on a chunk, 0 when the
-// final line of a file has none.
-func terminatorBytes(chunk []byte) int {
-	if len(chunk) == 0 || chunk[len(chunk)-1] != '\n' {
-		return 0
-	}
-	if len(chunk) > 1 && chunk[len(chunk)-2] == '\r' {
-		return 2
-	}
-	return 1
-}
-
-// readSeekStater is what a bounded transcript read needs from its handle. It is
-// satisfied by *os.File; naming it keeps the translators' contract explicit.
-type readSeekStater interface {
-	io.ReadSeeker
-	Stat() (os.FileInfo, error)
-}
-
-// afterSourceOpen is a test seam: called with the transcript path once the
-// import handle is open and verified, before any byte is read. A test uses it
-// to replace the directory entry inside that exact interval. nil in production.
-var afterSourceOpen func(path string)
-
-// openSelectedSource opens the transcript discovery selected and proves, ON THE
-// HANDLE THAT WILL BE READ, that it is still that file. The caller closes it.
-//
-// A PATHNAME IS A LOOKUP, NOT AN IDENTITY. Read used to validate the selected
-// path through one handle, translate through a second open, and validate
-// through a third. Each was a fresh lookup of the same name, so a concurrent
-// writer could rename A aside, place a contained file B under A's name for the
-// translation open, and restore A before the final check: both snapshot checks
-// observed A and passed, while the bytes actually consumed came from B and
-// were accepted under A's metadata and provenance. Not an escape from the
-// store — B was inside the root — but the wrong file under the right name.
-//
-// One open, one identity. The discovery snapshot binds metadata to the inode
-// discovery read; this binds the read to that same inode before the first byte
-// and (validateSourceHandle) after the last one. The rooted open, regular-file
-// check and bounded read are unchanged. Reported by @jatmn.
-func openSelectedSource(root string, source ForeignSession) (*os.File, error) {
-	if source.source.info == nil {
-		return nil, errors.New("agentsessions: session source was not produced by discovery")
-	}
-	file, err := openContained(root, source.Path)
-	if err != nil {
-		return nil, fmt.Errorf("agentsessions: reopen selected session source: %w", err)
-	}
-	if err := validateSourceHandle(file, source); err != nil {
-		_ = file.Close()
-		return nil, err
-	}
-	if afterSourceOpen != nil {
-		afterSourceOpen(source.Path)
-	}
-	return file, nil
-}
-
-// validateSourceHandle compares an OPEN handle with the discovery snapshot:
-// same inode, same size, same modification time, still a regular file. Called
-// before reading and again after, on the same handle, so continued writes
-// during the read are refused as the existing changed-source failure rather
-// than committed as a torn import.
-func validateSourceHandle(file *os.File, source ForeignSession) error {
-	if source.source.info == nil {
-		return errors.New("agentsessions: session source was not produced by discovery")
-	}
-	current, err := file.Stat()
-	if err != nil {
-		return fmt.Errorf("agentsessions: stat selected session source: %w", err)
-	}
-	if !current.Mode().IsRegular() {
-		return errors.New("agentsessions: transcript is not a regular file")
-	}
-	if !os.SameFile(source.source.info, current) ||
-		source.source.size != current.Size() ||
-		!source.source.modTime.Equal(current.ModTime()) {
-		return errors.New("agentsessions: selected session source changed after discovery; discover it again before importing")
-	}
-	return nil
-}
-
-// topLevelStrings pulls named top-level string fields out of a JSON object that
-// may be TRUNCATED, returning whatever appeared before the cut.
-//
-// WHY THIS EXISTS. A record longer than the per-line cap comes back as a prefix,
-// fails json.Unmarshal, and is skipped whole. That is the right call for the
-// record's content — the point of the cap is not to hold a giant tool result in
-// memory — but the small metadata fields sit at the FRONT of the object, and
-// throwing them away with the body cost the whole session: when the only
-// cwd-bearing record was oversized, discovery had no workspace to bind to and
-// dropped a transcript the user could see on disk.
-//
-// A token stream rather than a regex, because a regex over truncated JSON cannot
-// tell a top-level "cwd" from one nested inside a message body or an escaped
-// string that merely looks like a key. json.Decoder stops cleanly at the cut, so
-// anything recovered here was genuinely complete and genuinely top-level, and
-// anything after it is simply absent.
-func topLevelStrings(prefix []byte, wanted ...string) map[string]string {
-	found := map[string]string{}
-	if len(wanted) == 0 {
-		return found
-	}
-	want := map[string]bool{}
-	for _, name := range wanted {
-		want[name] = true
-	}
-
-	decoder := json.NewDecoder(bytes.NewReader(prefix))
-	opening, err := decoder.Token()
-	if err != nil || opening != json.Delim('{') {
-		return found
-	}
-	for len(found) < len(want) {
-		keyToken, err := decoder.Token()
-		if err != nil || keyToken == json.Delim('}') {
-			return found
-		}
-		key, ok := keyToken.(string)
-		if !ok {
-			return found
-		}
-		if !want[key] {
-			if skipValue(decoder) != nil {
-				return found
-			}
-			continue
-		}
-		valueToken, err := decoder.Token()
-		if err != nil {
-			return found
-		}
-		if value, ok := valueToken.(string); ok {
-			found[key] = value
-			continue
-		}
-		// A non-string value under a wanted key: step over whatever it opened.
-		if delim, ok := valueToken.(json.Delim); ok && (delim == '{' || delim == '[') {
-			if skipRest(decoder, 1) != nil {
-				return found
-			}
-		}
-	}
-	return found
-}
-
-// skipValue consumes exactly one value, descending through nested objects and
-// arrays so the next token read is the following key.
-func skipValue(decoder *json.Decoder) error {
-	token, err := decoder.Token()
-	if err != nil {
-		return err
-	}
-	if delim, ok := token.(json.Delim); ok && (delim == '{' || delim == '[') {
-		return skipRest(decoder, 1)
-	}
-	return nil
-}
-
-func skipRest(decoder *json.Decoder, depth int) error {
-	for depth > 0 {
-		token, err := decoder.Token()
-		if err != nil {
-			return err
-		}
-		if delim, ok := token.(json.Delim); ok {
-			switch delim {
-			case '{', '[':
-				depth++
-			case '}', ']':
-				depth--
-			}
-		}
-	}
-	return nil
-}
@@ -1,333 +0,0 @@
-package agentsessions
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// TestScanHeadReadsFarLessThanTheWholeFile is the test that keeps `sessions
-// discover` usable. The live corpus is 439 MB across 1,266 files with a single
-// 73 MB transcript in it; an indexer that reads whole files turns a listing into
-// a coffee break.
-//
-// It asserts on BYTES READ rather than on elapsed time, so it fails for the
-// right reason on a slow machine and cannot be silenced by faster hardware.
-func TestScanHeadReadsFarLessThanTheWholeFile(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "huge.jsonl")
-
-	// A transcript whose metadata is where it really is (line 3) followed by a
-	// great deal of conversation, mimicking a long session.
-	bulk := strings.Repeat("x", 200<<10)
-	lines := []string{
-		`{"type":"mode","mode":"default"}`,
-		`{"type":"queue-operation","operation":"enqueue"}`,
-		`{"type":"user","cwd":"/Users/someone/proj","sessionId":"huge","message":{"role":"user","content":"go"}}`,
-	}
-	for i := 0; i < 200; i++ {
-		lines = append(lines, `{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"`+bulk+`"}]}}`)
-	}
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-
-	fileSize := fileSizeOf(t, path)
-	if fileSize < 32<<20 {
-		t.Fatalf("fixture is only %d bytes; it must dwarf the head budget to prove anything", fileSize)
-	}
-
-	read, _, err := scanHeadSnapshot("", path, defaultHeadLimit, func([]byte, bool) bool { return true })
-	if err != nil {
-		t.Fatal(err)
-	}
-	if read > defaultHeadLimit.MaxBytes {
-		t.Errorf("scanHead read %d bytes, over its own %d-byte budget", read, defaultHeadLimit.MaxBytes)
-	}
-	if read >= fileSize/8 {
-		t.Errorf("scanHead read %d of %d bytes — discovery is reading the transcript, not indexing it", read, fileSize)
-	}
-
-	// And the point of the budget: the metadata is still found.
-	session, ok := indexFamily1Transcript("claude-code", "", path)
-	if !ok || session.Cwd != "/Users/someone/proj" {
-		t.Fatalf("indexing a large transcript failed: ok=%v session=%+v", ok, session)
-	}
-}
-
-// TestAnOversizedFirstRecordDoesNotStarveTheScan pins the defect the live
-// corpus exposed: three real sessions there open with a ~334 KB
-// queue-operation record. At the original 256 KiB budget the scan spent
-// everything on that one line and never reached the record carrying cwd, so the
-// sessions vanished from discovery with no error anywhere.
-func TestAnOversizedFirstRecordDoesNotStarveTheScan(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "fat-head.jsonl")
-	writeFile(t, path, strings.Join([]string{
-		`{"type":"queue-operation","operation":"enqueue","content":"` + strings.Repeat("q", 334<<10) + `"}`,
-		`{"type":"mode","mode":"default"}`,
-		`{"type":"user","cwd":"/Users/someone/proj","sessionId":"fat-head","message":{"role":"user","content":"still here"}}`,
-	}, "\n")+"\n")
-
-	session, ok := indexFamily1Transcript("claude-code", "", path)
-	if !ok {
-		t.Fatal("a session whose first record is huge was dropped from discovery")
-	}
-	if session.Cwd != "/Users/someone/proj" {
-		t.Errorf("Cwd = %q, want the record after the oversized one to be reached", session.Cwd)
-	}
-}
-
-// TestALineTooLongToKeepIsSkippedNotFatal covers a single record larger than
-// MaxLineBytes. bufio.Scanner would fail the entire scan here; the records
-// after it must still be read.
-func TestALineTooLongToKeepIsSkippedNotFatal(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "long-line.jsonl")
-	writeFile(t, path, strings.Join([]string{
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"` + strings.Repeat("y", 128<<10) + `"}]}}`,
-		`{"type":"user","cwd":"/Users/someone/proj","sessionId":"long-line","message":{"role":"user","content":"after the wall"}}`,
-	}, "\n")+"\n")
-
-	session, ok := indexFamily1Transcript("claude-code", "", path)
-	if !ok || session.Cwd != "/Users/someone/proj" {
-		t.Fatalf("a record past an over-long line was not read: ok=%v session=%+v", ok, session)
-	}
-}
-
-func TestScanHeadStopsWhenTheVisitorIsDone(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "stop.jsonl")
-	lines := make([]string, 0, 100)
-	for i := 0; i < 100; i++ {
-		lines = append(lines, `{"type":"user","content":"`+strings.Repeat("z", 4096)+`"}`)
-	}
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-
-	seen := 0
-	read, _, err := scanHeadSnapshot("", path, defaultHeadLimit, func([]byte, bool) bool {
-		seen++
-		return seen < 2
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if seen != 2 {
-		t.Errorf("visited %d lines, want to stop after 2", seen)
-	}
-	if read > 64<<10 {
-		t.Errorf("read %d bytes after an early stop; the reader buffer should bound this", read)
-	}
-}
-
-func TestScanHeadHonoursItsLineBudget(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "many.jsonl")
-	lines := make([]string, 0, 500)
-	for i := 0; i < 500; i++ {
-		lines = append(lines, `{"type":"noise"}`)
-	}
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-
-	seen := 0
-	if _, _, err := scanHeadSnapshot("", path, defaultHeadLimit, func([]byte, bool) bool { seen++; return true }); err != nil {
-		t.Fatal(err)
-	}
-	if seen != defaultHeadLimit.MaxLines {
-		t.Errorf("visited %d lines, want exactly MaxLines=%d", seen, defaultHeadLimit.MaxLines)
-	}
-}
-
-func TestScanHeadOnAMissingFileIsAnError(t *testing.T) {
-	// Unlike globbing, an unreadable file that discovery has already decided
-	// exists is worth reporting to the caller, which drops that one entry.
-	if _, _, err := scanHeadSnapshot("", filepath.Join(t.TempDir(), "absent.jsonl"), defaultHeadLimit, func([]byte, bool) bool { return true }); err == nil {
-		t.Error("scanHead on a missing file returned no error")
-	}
-}
-
-func TestStreamTailLinesReadsEverythingWithinItsBudget(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "all.jsonl")
-	lines := make([]string, 0, 300)
-	for i := 0; i < 300; i++ {
-		lines = append(lines, `{"type":"message","n":`+itoa(i)+`}`)
-	}
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-
-	seen := 0
-	if _, err := streamTailLinesAt("", path, 64<<10, importByteLimit, func([]byte, bool) bool { seen++; return true }); err != nil {
-		t.Fatal(err)
-	}
-	if seen != 300 {
-		t.Errorf("streamTailLinesAt visited %d lines, want all 300 within the byte budget", seen)
-	}
-}
-
-func TestStreamTailLinesToleratesAMissingTrailingNewline(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "no-newline.jsonl")
-	// A live transcript is appended to constantly; the last record frequently
-	// has no terminator yet.
-	writeFile(t, path, `{"type":"a"}`+"\n"+`{"type":"b"}`)
-
-	seen := 0
-	if _, err := streamTailLinesAt("", path, 64<<10, importByteLimit, func([]byte, bool) bool { seen++; return true }); err != nil {
-		t.Fatal(err)
-	}
-	if seen != 2 {
-		t.Errorf("visited %d lines, want 2 — the unterminated final record must not be lost", seen)
-	}
-}
-
-func TestStreamTailLinesBoundsTheReadAndDropsAPartialLeadingRecord(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "large.jsonl")
-	writeFile(t, path, strings.Repeat("x", 100)+"\nsecond\nthird\n")
-
-	var got []string
-	omitted, err := streamTailLinesAt("", path, 64<<10, 20, func(line []byte, truncated bool) bool {
-		if truncated {
-			t.Fatal("short tail record was reported truncated")
-		}
-		got = append(got, string(line))
-		return true
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !omitted {
-		t.Fatal("bounded tail read did not disclose that an older prefix was skipped")
-	}
-	if strings.Join(got, ",") != "second,third" {
-		t.Fatalf("tail records = %v, want only complete records second and third", got)
-	}
-}
-
-func TestStreamTailLinesDoesNotReadPastCapturedLiveExtent(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "live.jsonl")
-	writeFile(t, path, "first\n")
-
-	var got []string
-	appended := false
-	_, err := streamTailLinesAt("", path, 64<<10, 32<<20, func(line []byte, truncated bool) bool {
-		if truncated {
-			t.Fatal("short live record was reported truncated")
-		}
-		got = append(got, string(line))
-		if !appended {
-			appended = true
-			file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if _, err := file.WriteString("appended-after-stat\n"); err != nil {
-				t.Fatal(err)
-			}
-			if err := file.Close(); err != nil {
-				t.Fatal(err)
-			}
-		}
-		return true
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Join(got, ",") != "first" {
-		t.Fatalf("captured tail records = %v, want only the pre-stat extent", got)
-	}
-}
-
-// THE LINE TERMINATOR IS NOT CONTENT. A record whose content exactly fills the
-// per-line cap has been read in full, and reporting it truncated made the import
-// path emit "could not be read" for records it had in fact read — a false alarm
-// in the one signal that exists to be trusted. CRLF made it one byte worse,
-// since both bytes were counted.
-func TestARecordThatExactlyFillsTheCapIsNotTruncated(t *testing.T) {
-	const keep = 64
-	for _, eol := range []string{"\n", "\r\n"} {
-		for _, size := range []int{keep - 1, keep, keep + 1} {
-			path := filepath.Join(t.TempDir(), "x.jsonl")
-			if err := os.WriteFile(path, append([]byte(strings.Repeat("a", size)), []byte(eol)...), 0o644); err != nil {
-				t.Fatal(err)
-			}
-			var truncated bool
-			if _, err := streamTailLinesAt("", path, keep, importByteLimit, func(_ []byte, wasTruncated bool) bool {
-				truncated = truncated || wasTruncated
-				return true
-			}); err != nil {
-				t.Fatal(err)
-			}
-			if want := size > keep; truncated != want {
-				t.Errorf("content=%d cap=%d eol=%q reported truncated=%v, want %v", size, keep, eol, truncated, want)
-			}
-		}
-	}
-}
-
-// EOF IS THE ONLY CLEAN STOP. Any other read error used to end the scan and
-// return success, so a session indexed off however many bytes arrived before an
-// I/O failure was indistinguishable from one indexed off a whole file.
-func TestScanHeadReportsAReadFailure(t *testing.T) {
-	dir := t.TempDir()
-	if _, _, err := scanHeadSnapshot("", filepath.Join(dir, "gone.jsonl"), defaultHeadLimit, func([]byte, bool) bool { return true }); err == nil {
-		t.Error("scanning a missing transcript reported success")
-	}
-	// A directory opens but cannot be read as a file: a read error that is not EOF.
-	if _, _, err := scanHeadSnapshot("", dir, defaultHeadLimit, func([]byte, bool) bool { return true }); err == nil {
-		t.Error("scanning a directory reported success; a non-EOF read error was swallowed")
-	}
-}
-
-// CONTAINMENT HOLDS AT OPEN TIME, not merely at glob time. globTranscripts
-// refuses a symlink wearing a transcript extension, but that verdict describes
-// the tree when it was taken — anything can replace the entry before the open,
-// and os.Open would follow it out of the store.
-func TestScanHeadRefusesAPathOutsideTheRoot(t *testing.T) {
-	root := t.TempDir()
-	outside := filepath.Join(t.TempDir(), "secret.jsonl")
-	if err := os.WriteFile(outside, []byte(`{"type":"user","cwd":"/w"}`+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := scanHeadSnapshot(root, outside, defaultHeadLimit, func([]byte, bool) bool { return true }); err == nil {
-		t.Errorf("scanHead read %q from outside the store root %q", outside, root)
-	}
-}
-
-// THE IMPORT READ IS CONTAINED TOO, and it matters more here than in the index.
-// scanHead only builds a picker row; this path reads a transcript's actual
-// content and writes it into the user's own Zero session, so a symlink swapped
-// in after the glob would copy whatever it points at into their store.
-func TestStreamTailLinesRefusesAPathOutsideTheRoot(t *testing.T) {
-	root := t.TempDir()
-	outside := filepath.Join(t.TempDir(), "elsewhere.jsonl")
-	if err := os.WriteFile(outside, []byte(`{"type":"user"}`+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	seen := 0
-	_, err := streamTailLinesAt(root, outside, 1<<20, importByteLimit, func([]byte, bool) bool { seen++; return true })
-	if err == nil {
-		t.Errorf("streamTailLinesAt read %q from outside the store root %q", outside, root)
-	}
-	if seen != 0 {
-		t.Errorf("streamTailLinesAt handed the caller %d lines from outside the root", seen)
-	}
-}
-
-func TestScanHeadSnapshotRejectsMutationDuringDiscovery(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "changing.jsonl")
-	if err := os.WriteFile(path, []byte("first\nsecond\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	mutated := false
-	_, _, err := scanHeadSnapshot("", path, defaultHeadLimit, func(_ []byte, _ bool) bool {
-		if !mutated {
-			mutated = true
-			file, openErr := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0)
-			if openErr != nil {
-				t.Fatal(openErr)
-			}
-			if _, writeErr := file.WriteString("replacement\n"); writeErr != nil {
-				t.Fatal(writeErr)
-			}
-			if closeErr := file.Close(); closeErr != nil {
-				t.Fatal(closeErr)
-			}
-		}
-		return true
-	})
-	if err == nil || !strings.Contains(err.Error(), "changed during discovery") {
-		t.Fatalf("scanHeadSnapshot error = %v, want mutation rejection", err)
-	}
-}
@@ -1,298 +0,0 @@
-package agentsessions
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-// Env is the environment agentsessions resolves store roots against. Tests
-// supply a synthetic one; production uses OSEnv. Keeping this behind a struct
-// means no test has to mutate os.Setenv (which the repo's own suite is
-// sensitive to) to exercise the redirect variables.
-type Env struct {
-	Home string
-	// Getenv resolves the redirect variables below. Nil behaves as "unset".
-	Getenv func(string) string
-}
-
-// OSEnv is the real environment.
-func OSEnv() Env {
-	home, _ := os.UserHomeDir()
-	return Env{Home: home, Getenv: os.Getenv}
-}
-
-func (env Env) lookup(name string) string {
-	if env.Getenv == nil {
-		return ""
-	}
-	return strings.TrimSpace(env.Getenv(name))
-}
-
-// underHome joins parts onto the home directory, returning "" when home is
-// unknown so callers degrade to "no store" rather than probing a relative path
-// off the process working directory.
-func (env Env) underHome(parts ...string) string {
-	home := strings.TrimSpace(env.Home)
-	if home == "" {
-		return ""
-	}
-	return filepath.Join(append([]string{home}, parts...)...)
-}
-
-// Each of these honours the agent's documented redirect variable rather than
-// hardcoding ~. A user with CLAUDE_CONFIG_DIR or CODEX_HOME set has their
-// transcripts somewhere else entirely, and hardcoding would silently discover
-// nothing while looking like it worked.
-
-func claudeCodeRoot(env Env) string {
-	if dir := env.lookup("CLAUDE_CONFIG_DIR"); filepath.IsAbs(dir) {
-		return filepath.Join(dir, "projects")
-	}
-	return env.underHome(".claude", "projects")
-}
-
-func codexRoot(env Env) string {
-	if dir := env.lookup("CODEX_HOME"); filepath.IsAbs(dir) {
-		return filepath.Join(dir, "sessions")
-	}
-	return env.underHome(".codex", "sessions")
-}
-
-func factoryRoot(env Env) string {
-	return env.underHome(".factory", "sessions")
-}
-
-// piRoot is the one to be careful with: ~/.pi/agent/auth.json is the direct
-// sibling of ~/.pi/agent/sessions/. Rooting discovery at ~/.pi/agent instead of
-// ~/.pi/agent/sessions would put a live credential file one glob away.
-func piRoot(env Env) string {
-	return env.underHome(".pi", "agent", "sessions")
-}
-
-// transcriptExt is the only file extension this package will open. Every
-// credential file found in these trees (auth.json, oauth_creds.json,
-// .credentials.json, auth.v2.key, config.json) ends in something else, so
-// pinning the extension is a cheap, total defence — but it is a backstop, not
-// the primary one. The primary defence is that the globs below are fixed-depth
-// and rooted at a sessions directory.
-const transcriptExt = ".jsonl"
-
-// globTranscripts expands a fixed-depth glob and returns only the results that
-// are genuinely safe to open.
-//
-// filepath.Glob never recurses, so the shape of the pattern already bounds what
-// can match. Two further filters matter:
-//
-//   - the extension must be exactly .jsonl, so no credential file can match even
-//     if an agent later drops one into a sessions directory;
-//   - the entry must be a REGULAR file by Lstat, which rejects symlinks. Without
-//     this, a symlink named transcript.jsonl pointing at ~/.codex/auth.json would
-//     satisfy both the pattern and the extension check and be read as a
-//     transcript. Lstat does not follow the link, so the symlink is seen for
-//     what it is.
-//
-// A malformed pattern or an unreadable directory yields no results rather than
-// an error: discovery is fail-soft by design (see Adapter).
-func globTranscripts(root string, pattern string) []string {
-	if strings.TrimSpace(root) == "" || strings.TrimSpace(pattern) == "" {
-		return nil
-	}
-	matches, err := filepath.Glob(pattern)
-	if err != nil {
-		return nil
-	}
-	safe := make([]string, 0, len(matches))
-	for _, match := range matches {
-		if !strings.EqualFold(filepath.Ext(match), transcriptExt) {
-			continue
-		}
-		if pathHasSymlink(root, match) {
-			continue
-		}
-		info, err := os.Lstat(match)
-		if err != nil || !info.Mode().IsRegular() {
-			continue
-		}
-		safe = append(safe, match)
-	}
-	return safe
-}
-
-// pathHasSymlink rejects a match when any component beneath the trusted store
-// root is a symlink. The eventual read also goes through os.Root (openContained),
-// which binds containment at open time and closes the check/open race; this
-// discovery-time check prevents a symlinked project/date directory from being
-// indexed in the first place. On Windows, Lstat does not identify junctions as
-// ModeSymlink; this function is therefore only a best-effort index filter there.
-// The os.Root read is the containment boundary on every platform.
-func pathHasSymlink(root string, match string) bool {
-	relative, err := filepath.Rel(root, match)
-	if err != nil || relative == "." || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
-		return true
-	}
-	current := root
-	for _, component := range strings.Split(relative, string(filepath.Separator)) {
-		if component == "" || component == "." {
-			continue
-		}
-		current = filepath.Join(current, component)
-		info, err := os.Lstat(current)
-		if err != nil || info.Mode()&os.ModeSymlink != 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// globSessionDirs lists the immediate subdirectories of root — one fixed level,
-// never a walk. Used when no slug candidate matches and every project directory
-// has to be considered.
-func globSessionDirs(root string) []string {
-	if strings.TrimSpace(root) == "" {
-		return nil
-	}
-	matches, err := filepath.Glob(filepath.Join(root, "*"))
-	if err != nil {
-		return nil
-	}
-	dirs := make([]string, 0, len(matches))
-	for _, match := range matches {
-		// Lstat, not Stat: a symlinked project directory could point anywhere,
-		// including a tree of credentials, and following it would put arbitrary
-		// paths one glob below a directory we do trust.
-		info, err := os.Lstat(match)
-		if err != nil || !info.IsDir() {
-			continue
-		}
-		dirs = append(dirs, match)
-	}
-	return dirs
-}
-
-// slugCandidates returns the directory names an agent might have used for cwd.
-//
-// These agents name a directory after the working directory by replacing path
-// separators with hyphens. That mapping is LOSSY and cannot be reversed:
-// "-Users-kratos-dev-zero" is what both /Users/kratos/dev/zero and
-// /Users/kratos/dev-zero produce. It is therefore used only to NARROW the
-// search — a hit means "look here first", never "this is the session's cwd".
-// The cwd is always taken from the record body instead (see jsonl.go), and
-// callers fall back to scanning every slug directory when no candidate matches.
-//
-// Different agents mangle more than just the separator (some also fold "." and
-// "_"), and none of them document it. Rather than guess at a scheme that may
-// change, this returns several plausible spellings and treats a miss as a cache
-// miss rather than an error.
-func slugCandidates(cwd string) []string {
-	cleaned := filepath.Clean(strings.TrimSpace(cwd))
-	if cleaned == "" || cleaned == "." {
-		return nil
-	}
-	separatorOnly := strings.ReplaceAll(cleaned, string(filepath.Separator), "-")
-	folded := strings.NewReplacer(
-		string(filepath.Separator), "-",
-		".", "-",
-		"_", "-",
-	).Replace(cleaned)
-
-	candidates := []string{separatorOnly}
-	if folded != separatorOnly {
-		candidates = append(candidates, folded)
-	}
-	return candidates
-}
-
-// normalizeDir resolves a directory to a stable form for comparison, following
-// symlinks so that /tmp and /private/tmp (or any other symlinked prefix) do not
-// read as different workspaces. A path that cannot be resolved — typically
-// because the directory has since been deleted, which is common in old
-// transcripts — degrades to a lexical clean rather than dropping the session.
-func normalizeDir(path string) string {
-	return normalizeDirForOS(path, runtime.GOOS)
-}
-
-func normalizeDirForOS(path string, goos string) string {
-	return normalizeDirWithFS(path, goos, os.Stat, filepath.EvalSymlinks)
-}
-
-func normalizeDirWithFS(
-	path string,
-	goos string,
-	stat func(string) (os.FileInfo, error),
-	evalSymlinks func(string) (string, error),
-) string {
-	trimmed := strings.TrimSpace(path)
-	if trimmed == "" {
-		return ""
-	}
-	cleaned := filepath.Clean(trimmed)
-	// A foreign transcript controls this value. Windows path resolution can dial
-	// UNC shares (and mapped drives) while merely building /resume, so discovery
-	// never performs filesystem I/O for Windows paths. Exact lexical matching is
-	// still useful and case-folded below; any stronger containment decision is
-	// deferred to the rooted open used when the transcript is actually read.
-	if goos == "windows" {
-		return cleaned
-	}
-	// EvalSymlinks is useful for local aliases such as /tmp -> /private/tmp, but
-	// only after a local stat proves the path currently exists. Missing or stale
-	// transcript paths stay lexical and cannot trigger resolver-specific probes.
-	if _, err := stat(cleaned); err != nil {
-		return cleaned
-	}
-	resolved, err := evalSymlinks(cleaned)
-	if err != nil {
-		return cleaned
-	}
-	return resolved
-}
-
-// sameDir reports whether two directory paths refer to the same workspace.
-func sameDir(left string, right string) bool {
-	return sameDirForOS(left, right, runtime.GOOS)
-}
-
-func sameDirForOS(left string, right string, goos string) bool {
-	return sameDirWithFS(left, right, goos, os.Stat, filepath.EvalSymlinks)
-}
-
-// sameDirWithFS is the comparison with its filesystem access injectable, so a
-// test can prove that a Windows path is compared WITHOUT touching the resolver.
-func sameDirWithFS(
-	left string,
-	right string,
-	goos string,
-	stat func(string) (os.FileInfo, error),
-	evalSymlinks func(string) (string, error),
-) bool {
-	normalizedLeft := normalizeDirWithFS(left, goos, stat, evalSymlinks)
-	normalizedRight := normalizeDirWithFS(right, goos, stat, evalSymlinks)
-	if normalizedLeft == "" || normalizedRight == "" {
-		return false
-	}
-	if goos == "windows" {
-		return strings.EqualFold(normalizedLeft, normalizedRight)
-	}
-	return normalizedLeft == normalizedRight
-}
-
-// SameWorkspace reports whether two workspace paths name the same directory,
-// under the policy discovery already uses for foreign paths.
-//
-// EXPORTED BECAUSE THE TUI WAS COMPARING WITH A DIFFERENT POLICY. Discovery
-// deliberately never resolves a Windows path (normalizeDirWithFS): a transcript
-// controls that value, and EvalSymlinks on "\\server\share\repo" dials the
-// share — SMB authentication and a stalled UI on an unavailable host — merely
-// to decide whether a row belongs in /resume. The TUI's own comparison then
-// reintroduced exactly that call, for the same foreign value, on the Update
-// loop: once while formatting the post-import note, and again for every
-// persisted WorkspaceKey while filtering the picker and choosing the latest
-// session. Checking runtime.GOOS after the resolver had already run could not
-// prevent the effect. One comparison, one policy: lexical and case-insensitive
-// on Windows, stat-then-resolve elsewhere so local aliases such as
-// /tmp -> /private/tmp still match. Reported by @jatmn.
-func SameWorkspace(left string, right string) bool {
-	return sameDir(left, right)
-}
@@ -1,377 +0,0 @@
-package agentsessions
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func testEnv(home string, vars map[string]string) Env {
-	return Env{Home: home, Getenv: func(name string) string { return vars[name] }}
-}
-
-func TestRootsHonourTheAgentsRedirectVariables(t *testing.T) {
-	home := t.TempDir()
-	elsewhere := t.TempDir()
-
-	plain := testEnv(home, nil)
-	if got, want := claudeCodeRoot(plain), filepath.Join(home, ".claude", "projects"); got != want {
-		t.Errorf("claudeCodeRoot = %q, want %q", got, want)
-	}
-	if got, want := codexRoot(plain), filepath.Join(home, ".codex", "sessions"); got != want {
-		t.Errorf("codexRoot = %q, want %q", got, want)
-	}
-
-	// A user with these set keeps their transcripts somewhere else entirely.
-	// Hardcoding ~ would discover nothing while looking like it worked.
-	redirected := testEnv(home, map[string]string{
-		"CLAUDE_CONFIG_DIR": elsewhere,
-		"CODEX_HOME":        elsewhere,
-	})
-	if got, want := claudeCodeRoot(redirected), filepath.Join(elsewhere, "projects"); got != want {
-		t.Errorf("CLAUDE_CONFIG_DIR ignored: got %q, want %q", got, want)
-	}
-	if got, want := codexRoot(redirected), filepath.Join(elsewhere, "sessions"); got != want {
-		t.Errorf("CODEX_HOME ignored: got %q, want %q", got, want)
-	}
-}
-
-func TestRelativeRedirectVariablesAreRejected(t *testing.T) {
-	env := testEnv(t.TempDir(), map[string]string{
-		"CLAUDE_CONFIG_DIR": ".config/claude",
-		"CODEX_HOME":        ".codex",
-	})
-	if got, want := claudeCodeRoot(env), filepath.Join(env.Home, ".claude", "projects"); got != want {
-		t.Fatalf("relative CLAUDE_CONFIG_DIR resolved from process cwd: got %q, want %q", got, want)
-	}
-	if got, want := codexRoot(env), filepath.Join(env.Home, ".codex", "sessions"); got != want {
-		t.Fatalf("relative CODEX_HOME resolved from process cwd: got %q, want %q", got, want)
-	}
-}
-
-func TestAnUnknownHomeYieldsNoRootRatherThanARelativePath(t *testing.T) {
-	// With no home, a naive filepath.Join would produce ".claude/projects" and
-	// probe relative to the process working directory — a different user's
-	// checkout, in the worst case. Every root must come back empty instead.
-	blank := Env{}
-	for name, root := range map[string]string{
-		"claude":  claudeCodeRoot(blank),
-		"codex":   codexRoot(blank),
-		"factory": factoryRoot(blank),
-		"pi":      piRoot(blank),
-	} {
-		if root != "" {
-			t.Errorf("%s root with no home = %q, want empty", name, root)
-		}
-	}
-}
-
-// credentialFilenames are the real filenames found beside real transcripts on a
-// working machine. Every one of the seven agents surveyed keeps at least one of
-// these in the same tree as its sessions.
-var credentialFilenames = []string{
-	"auth.json",
-	"auth.v2.key",
-	"auth.v2.file",
-	".credentials.json",
-	"oauth_creds.json",
-	"config.json",
-	"credentials",
-}
-
-// TestDiscoveryGlobsNeverMatchACredentialFile is the reason this package uses
-// fixed-depth globs instead of filepath.WalkDir.
-//
-// The layout below mirrors ~/.pi/agent/, where auth.json is the direct sibling
-// of sessions/ — the tightest real case. If a future change swaps the glob for
-// a walk, or roots it one directory higher, this test fails.
-func TestDiscoveryGlobsNeverMatchACredentialFile(t *testing.T) {
-	home := t.TempDir()
-	agentDir := filepath.Join(home, ".pi", "agent")
-	sessionsDir := filepath.Join(agentDir, "sessions", "-Users-someone-proj")
-	if err := os.MkdirAll(sessionsDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	// A real transcript, which must be found.
-	transcript := filepath.Join(sessionsDir, "2026-01-01T00-00-00Z_abc.jsonl")
-	writeFile(t, transcript, `{"type":"session","cwd":"/Users/someone/proj"}`)
-
-	// Decoy transcripts at depths the fixed-depth glob must not reach. These
-	// pin the MECHANISM rather than the outcome: the credential filenames below
-	// are already caught by the extension check, so without these a directory
-	// walk substituted for the glob would still pass. Each of these is a
-	// well-formed .jsonl that only a walk (or a wrong root) can find.
-	offDepth := []string{
-		filepath.Join(agentDir, "sessions", "stray.jsonl"),                 // too shallow
-		filepath.Join(sessionsDir, "nested", "deep.jsonl"),                 // too deep
-		filepath.Join(sessionsDir, "nested", "deeper", "deepest.jsonl"),    // deeper still
-		filepath.Join(agentDir, "leaked.jsonl"),                            // above the sessions root
-		filepath.Join(agentDir, "checkpoints", "proj", "checkpoint.jsonl"), // sibling tree
-	}
-	for _, path := range offDepth {
-		writeFile(t, path, `{"type":"session","cwd":"/Users/someone/proj"}`)
-	}
-
-	// Credentials planted at every level a careless root or a walk would reach:
-	// beside the transcript, in the sessions root, and — the ~/.pi/agent case —
-	// one level above the sessions directory.
-	planted := []string{}
-	for _, dir := range []string{sessionsDir, filepath.Join(agentDir, "sessions"), agentDir} {
-		for _, name := range credentialFilenames {
-			path := filepath.Join(dir, name)
-			writeFile(t, path, `{"access_token":"tok_MUST_NEVER_BE_READ"}`)
-			planted = append(planted, path)
-		}
-	}
-
-	env := testEnv(home, nil)
-	matches := globTranscripts(piRoot(env), filepath.Join(piRoot(env), "*", "*"+transcriptExt))
-
-	if len(matches) != 1 || matches[0] != transcript {
-		t.Fatalf("glob = %v, want exactly [%s] — anything extra means discovery "+
-			"is reaching beyond one fixed depth below the sessions root", matches, transcript)
-	}
-	for _, got := range matches {
-		for _, path := range offDepth {
-			if got == path {
-				t.Errorf("discovery reached an off-depth file (a walk, not a glob): %s", got)
-			}
-		}
-	}
-	// Belt and braces: neither the exact planted paths nor any file merely
-	// *named* like a credential may appear, so a future glob that reaches a
-	// different directory still fails here.
-	for _, got := range matches {
-		for _, path := range planted {
-			if got == path {
-				t.Errorf("glob matched a credential file: %s", got)
-			}
-		}
-		for _, name := range credentialFilenames {
-			if strings.EqualFold(filepath.Base(got), name) {
-				t.Errorf("glob matched a credential filename: %s", got)
-			}
-		}
-	}
-}
-
-// TestGlobRejectsASymlinkWearingATranscriptExtension closes the gap the
-// extension check alone leaves open: the name says .jsonl, the target is a
-// credential file. Lstat does not follow the link, so the entry is seen for
-// what it is and dropped.
-func TestGlobRejectsASymlinkWearingATranscriptExtension(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink creation needs elevation on Windows")
-	}
-	root := t.TempDir()
-	dir := filepath.Join(root, "-Users-someone-proj")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	secret := filepath.Join(root, "auth.json")
-	writeFile(t, secret, `{"access_token":"tok_MUST_NEVER_BE_READ"}`)
-
-	disguised := filepath.Join(dir, "innocent.jsonl")
-	if err := os.Symlink(secret, disguised); err != nil {
-		t.Fatal(err)
-	}
-	real := filepath.Join(dir, "real.jsonl")
-	writeFile(t, real, `{"type":"session"}`)
-
-	matches := globTranscripts(root, filepath.Join(root, "*", "*"+transcriptExt))
-	if len(matches) != 1 || matches[0] != real {
-		t.Fatalf("glob = %v, want exactly [%s] — the symlink must be rejected", matches, real)
-	}
-}
-
-func TestGlobRejectsTranscriptBelowSymlinkedDirectory(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink creation needs elevation on Windows")
-	}
-	root := t.TempDir()
-	outside := t.TempDir()
-	outsideTranscript := filepath.Join(outside, "escaped.jsonl")
-	writeFile(t, outsideTranscript, `{"type":"session"}`)
-	linkedDir := filepath.Join(root, "project")
-	if err := os.Symlink(outside, linkedDir); err != nil {
-		t.Fatal(err)
-	}
-
-	matches := globTranscripts(root, filepath.Join(root, "*", "*"+transcriptExt))
-	if len(matches) != 0 {
-		t.Fatalf("glob followed a symlinked directory outside the store: %v", matches)
-	}
-	if _, err := openContained(root, filepath.Join(linkedDir, "escaped.jsonl")); err == nil {
-		t.Fatal("rooted open followed a symlink outside the store")
-	}
-}
-
-func TestGlobDegradesToEmptyRatherThanFailing(t *testing.T) {
-	// A store that was never created, and a pattern that cannot compile. Both
-	// mean "this adapter has nothing", never an error that fails the command
-	// for the other six agents.
-	root := t.TempDir()
-	if got := globTranscripts(root, filepath.Join(root, "absent", "*", "*.jsonl")); len(got) != 0 {
-		t.Errorf("missing root = %v, want empty", got)
-	}
-	if got := globTranscripts(root, filepath.Join(root, "[", "*.jsonl")); len(got) != 0 {
-		t.Errorf("malformed pattern = %v, want empty", got)
-	}
-	if got := globTranscripts("", ""); len(got) != 0 {
-		t.Errorf("empty pattern = %v, want empty", got)
-	}
-}
-
-func TestGlobIgnoresNonTranscriptExtensions(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "proj")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range []string{"a.json", "b.db", "c.jsonl.bak", "d.txt", "keep.jsonl"} {
-		writeFile(t, filepath.Join(dir, name), "{}")
-	}
-	matches := globTranscripts(root, filepath.Join(root, "*", "*"))
-	if len(matches) != 1 || filepath.Base(matches[0]) != "keep.jsonl" {
-		t.Fatalf("glob = %v, want only keep.jsonl", matches)
-	}
-}
-
-func TestSlugCandidatesNarrowButAreNeverAuthoritative(t *testing.T) {
-	got := slugCandidates("/Users/kratos/dev/zero")
-	if len(got) == 0 || got[0] != "-Users-kratos-dev-zero" {
-		t.Fatalf("slugCandidates = %v, want the separator-folded form first", got)
-	}
-
-	// The lossiness this guards against: two different directories produce the
-	// same slug, which is why the cwd is always re-read from the record body.
-	if slugCandidates("/Users/kratos/dev/zero")[0] != slugCandidates("/Users/kratos/dev-zero")[0] {
-		t.Fatal("expected these two cwds to collide — if they no longer do, the " +
-			"comment in paths.go about slug lossiness needs revisiting")
-	}
-
-	if got := slugCandidates(""); got != nil {
-		t.Errorf("slugCandidates(\"\") = %v, want nil", got)
-	}
-}
-
-func TestSameDirFollowsSymlinks(t *testing.T) {
-	root := t.TempDir()
-	real := filepath.Join(root, "real")
-	if err := os.MkdirAll(real, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if !sameDir(real, real+string(filepath.Separator)+".") {
-		t.Error("a path and its own clean form should match")
-	}
-	if sameDir(real, filepath.Join(root, "other")) {
-		t.Error("different directories should not match")
-	}
-	if sameDir("", real) || sameDir(real, "") {
-		t.Error("an empty path should never match anything")
-	}
-
-	if runtime.GOOS != "windows" {
-		link := filepath.Join(root, "link")
-		if err := os.Symlink(real, link); err != nil {
-			t.Fatal(err)
-		}
-		if !sameDir(link, real) {
-			t.Error("a symlinked workspace should resolve to the same directory")
-		}
-	}
-}
-
-func TestSameDirUsesCaseInsensitiveComparisonOnWindows(t *testing.T) {
-	if !sameDirForOS("/Work/Project", "/work/project", "windows") {
-		t.Fatal("Windows workspace comparison rejected a case-only spelling difference")
-	}
-	if sameDirForOS("/Work/Project", "/work/other", "windows") {
-		t.Fatal("Windows workspace comparison accepted different paths")
-	}
-}
-
-func TestWindowsForeignPathsNeverTouchTheFilesystemDuringNormalization(t *testing.T) {
-	path := `\\192.0.2.201\share\loot`
-	called := false
-	got := normalizeDirWithFS(path, "windows",
-		func(string) (os.FileInfo, error) {
-			called = true
-			return nil, errors.New("must not stat a foreign Windows path")
-		},
-		func(string) (string, error) {
-			called = true
-			return "", errors.New("must not resolve a foreign Windows path")
-		},
-	)
-	if called {
-		t.Fatal("Windows path normalization performed filesystem I/O")
-	}
-	if got != filepath.Clean(path) {
-		t.Fatalf("normalizeDirWithFS = %q, want lexical %q", got, filepath.Clean(path))
-	}
-}
-
-func writeFile(t *testing.T, path string, content string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func fileSizeOf(t *testing.T, path string) int64 {
-	t.Helper()
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return info.Size()
-}
-
-func itoa(value int) string { return strconv.Itoa(value) }
-
-// COMPARING A FOREIGN WINDOWS PATH MUST NOT TOUCH THE FILESYSTEM. A transcript
-// controls its cwd, and resolving "\\server\share\repo" on Windows dials the
-// share. Discovery already compares such paths lexically; the TUI's picker,
-// latest-session filter and post-import note now go through the same helper,
-// so this is the one place that policy is proved. The resolver seams here fail
-// the test if they are ever called for a Windows path.
-func TestAForeignWindowsPathIsComparedWithoutResolverIO(t *testing.T) {
-	fatalStat := func(path string) (os.FileInfo, error) {
-		t.Fatalf("stat was called for a foreign Windows path: %q", path)
-		return nil, nil
-	}
-	fatalEval := func(path string) (string, error) {
-		t.Fatalf("EvalSymlinks was called for a foreign Windows path: %q", path)
-		return "", nil
-	}
-	if !sameDirWithFS(`\\server\share\repo`, `\\SERVER\share\REPO`, "windows", fatalStat, fatalEval) {
-		t.Error("case-insensitive UNC match failed")
-	}
-	if sameDirWithFS(`\\server\share\repo`, `\\server\share\other`, "windows", fatalStat, fatalEval) {
-		t.Error("different UNC paths compared equal")
-	}
-	if !sameDirWithFS(`C:\Proj\repo`, `c:\proj\REPO`, "windows", fatalStat, fatalEval) {
-		t.Error("case-insensitive drive path match failed")
-	}
-	// Elsewhere a local alias still resolves — after a stat proves it exists —
-	// so /tmp -> /private/tmp keeps matching for the TUI.
-	if runtime.GOOS != "windows" {
-		target := t.TempDir()
-		link := filepath.Join(t.TempDir(), "link")
-		if err := os.Symlink(target, link); err != nil {
-			t.Skip(err)
-		}
-		if !SameWorkspace(link, target) {
-			t.Errorf("a symlinked local workspace no longer matches its target")
-		}
-	}
-}
@@ -1,246 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"strings"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// pi reads Pi's agent transcripts: ~/.pi/agent/sessions/<slug>/<ts>_<uuid>.jsonl.
-//
-// PI SHARES FAMILY 1'S DIRECTORY LAYOUT AND NOT ITS MESSAGE SCHEMA. It was
-// routed through the Claude parser on the strength of the layout, and the
-// parser's block vocabulary (tool_use / tool_result, is_error, snake_case ids)
-// is simply not what Pi writes:
-//
-//	header   {"type":"session","id":…,"timestamp":…,"cwd":…}
-//	entry    {"type":"message","id":…,"parentId":…,"timestamp":…,"message":{…}}
-//	user     {"role":"user","content":"…" | [{"type":"text","text":…}]}
-//	assistant{"role":"assistant","model":…,"content":[{"type":"text"|"thinking"|"toolCall",…}]}
-//	toolCall {"type":"toolCall","id":…,"name":…,"arguments":{…object…}}
-//	result   {"role":"toolResult","toolCallId":…,"toolName":…,"isError":bool,"content":[{"type":"text",…}]}
-//
-// The shared parser recognized none of the tool records and rejected the
-// toolResult role outright, so a Pi session containing a request and a completed
-// tool call imported "successfully" with no call, no result and no activity
-// summary — the work needed to continue it silently omitted — and the outer
-// type of "message" on every entry meant the title check for type "user" never
-// fired, so every Pi session was "untitled". Both were one wrong assumption.
-// Reported by @jatmn.
-//
-// Bounded reading, event construction, redaction, the reasoning opt-in and the
-// activity summary stay shared; only the vendor's parsing differs.
-type pi struct {
-	root string
-}
-
-// Pi reads Pi's agent transcripts.
-func Pi(env Env) Adapter {
-	return pi{root: piRoot(env)}
-}
-
-func (adapter pi) Name() string { return "pi" }
-
-func (adapter pi) Discover(cwd string) ([]ForeignSession, error) {
-	return discoverFamily1(adapter.Name(), adapter.root, cwd, indexPiTranscript)
-}
-
-func (adapter pi) Read(source ForeignSession, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	if source.Agent != adapter.Name() || source.ID != transcriptID(source.Path) {
-		return nil, errNotThisAgent(adapter.Name())
-	}
-	// One handle from identity check to final check: see openSelectedSource.
-	file, err := openSelectedSource(adapter.root, source)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	events, err := translatePi(file, options)
-	if err != nil {
-		return nil, err
-	}
-	if err := validateSourceHandle(file, source); err != nil {
-		return nil, err
-	}
-	return events, nil
-}
-
-// piEntry is one line of a Pi session file: the session header or an entry.
-// Unknown entry types (thinking_level_change, model_change, compaction, …)
-// carry no message and drop out naturally.
-type piEntry struct {
-	Type      string     `json:"type"`
-	Cwd       string     `json:"cwd"`
-	Timestamp string     `json:"timestamp"`
-	Message   *piMessage `json:"message"`
-}
-
-type piMessage struct {
-	Role    string          `json:"role"`
-	Model   string          `json:"model"`
-	Content json.RawMessage `json:"content"`
-	// toolResult fields.
-	ToolCallID string `json:"toolCallId"`
-	ToolName   string `json:"toolName"`
-	IsError    bool   `json:"isError"`
-}
-
-type piBlock struct {
-	Type      string          `json:"type"`
-	Text      string          `json:"text"`
-	Thinking  string          `json:"thinking"`
-	ID        string          `json:"id"`
-	Name      string          `json:"name"`
-	Arguments json.RawMessage `json:"arguments"`
-}
-
-// indexPiTranscript builds an index entry from a bounded read of the head. The
-// workspace and start time come from the session header; the title is the
-// first user prompt, which is inside a "message" entry, not a "user" record.
-func indexPiTranscript(agent string, root string, path string) (ForeignSession, bool) {
-	session := ForeignSession{Agent: agent, ID: transcriptID(path), Path: path}
-	firstPrompt := ""
-	_, snapshot, err := scanHeadSnapshot(root, path, defaultHeadLimit, func(line []byte, truncated bool) bool {
-		var entry piEntry
-		if json.Unmarshal(line, &entry) != nil {
-			if truncated {
-				recovered := topLevelStrings(line, "cwd", "timestamp")
-				if session.Cwd == "" {
-					session.Cwd = recovered["cwd"]
-				}
-				if session.StartedAt.IsZero() {
-					session.StartedAt = parseTimestamp(recovered["timestamp"])
-				}
-			}
-			return true
-		}
-		if session.Cwd == "" {
-			session.Cwd = entry.Cwd
-		}
-		if session.StartedAt.IsZero() {
-			session.StartedAt = parseTimestamp(entry.Timestamp)
-		}
-		if entry.Type != "message" || entry.Message == nil {
-			return true
-		}
-		if session.ModelID == "" && entry.Message.Role == "assistant" {
-			session.ModelID = entry.Message.Model
-		}
-		if firstPrompt == "" && entry.Message.Role == "user" {
-			firstPrompt = piBlocksText(entry.Message.Content)
-		}
-		return true
-	})
-	if err != nil {
-		return ForeignSession{}, false
-	}
-	session.Title = summarizeTitle(firstPrompt)
-	if strings.TrimSpace(session.Cwd) == "" {
-		return ForeignSession{}, false
-	}
-	session.source = snapshot
-	session.UpdatedAt = snapshot.modTime
-	if session.StartedAt.IsZero() {
-		session.StartedAt = session.UpdatedAt
-	}
-	return session, true
-}
-
-// translatePi converts a Pi session into Zero events. Same lossy-in-one-direction
-// policy as translateFamily1: the conversation and the tool work are kept, the
-// provider's private machinery (signatures, usage, diagnostics) is dropped.
-func translatePi(file readSeekStater, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	events := newEventTail(effectiveMaxEvents(options.MaxEvents))
-	identities := &importCallIdentities{}
-	activity := newActivityLog(options.Cwd)
-	omitted := 0
-	prefixOmitted, err := streamTailLines(file, importLineLimit, importByteLimit, func(line []byte, truncated bool) bool {
-		if truncated {
-			omitted++
-			return true
-		}
-		var entry piEntry
-		if json.Unmarshal(line, &entry) != nil || entry.Type != "message" || entry.Message == nil {
-			return true
-		}
-		message := entry.Message
-		switch strings.ToLower(strings.TrimSpace(message.Role)) {
-		case "user":
-			if text := piBlocksText(message.Content); strings.TrimSpace(text) != "" {
-				events.add(messageEvent("user", text))
-			}
-		case "assistant":
-			var blocks []piBlock
-			if json.Unmarshal(message.Content, &blocks) != nil {
-				return true
-			}
-			for _, block := range blocks {
-				switch block.Type {
-				case "text":
-					if strings.TrimSpace(block.Text) != "" {
-						events.add(messageEvent("assistant", block.Text))
-					}
-				case "thinking":
-					if options.IncludeReasoning && strings.TrimSpace(block.Thinking) != "" {
-						events.add(messageEvent("reasoning", block.Thinking))
-					}
-				case "toolCall":
-					arguments := string(block.Arguments)
-					activity.observeCall(block.ID, block.Name, arguments)
-					events.add(toolCallEvent(identities, block.Name, block.ID, arguments))
-				}
-			}
-		case "toolresult":
-			// Pi records the outcome explicitly, so it is carried as fact: only a
-			// confirmed success commits an activity claim (observeResult).
-			status := tools.StatusOK
-			if message.IsError {
-				status = tools.StatusError
-			}
-			name := strings.TrimSpace(message.ToolName)
-			if name == "" {
-				name = "unknown"
-			}
-			output := piBlocksText(message.Content)
-			activity.observeResult(message.ToolCallID, name, status, output)
-			events.add(toolResultEvent(identities, name, message.ToolCallID, status, output))
-		}
-		return true
-	})
-	if err != nil {
-		return nil, err
-	}
-	contextEvents := activity.summaryEvents()
-	if prefixOmitted {
-		contextEvents = append(contextEvents, omittedPrefixEvent())
-	}
-	if omitted > 0 {
-		contextEvents = append(contextEvents, omittedRecordsEvent(omitted))
-	}
-	return capTranslatedEventsDropped(events.values(), contextEvents, effectiveMaxEvents(options.MaxEvents), events.dropped), nil
-}
-
-// piBlocksText flattens Pi content, which is a bare string or an array of
-// blocks, to its text. Images and tool calls contribute nothing here.
-func piBlocksText(raw json.RawMessage) string {
-	if len(raw) == 0 {
-		return ""
-	}
-	var text string
-	if json.Unmarshal(raw, &text) == nil {
-		return text
-	}
-	var blocks []piBlock
-	if json.Unmarshal(raw, &blocks) != nil {
-		return ""
-	}
-	parts := []string{}
-	for _, block := range blocks {
-		if block.Type == "text" && strings.TrimSpace(block.Text) != "" {
-			parts = append(parts, block.Text)
-		}
-	}
-	return strings.Join(parts, "\n")
-}
@@ -1,154 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// A source-shaped Pi session: the real outer wrapper (a "session" header, then
-// "message" entries carrying id/parentId), a visible user prompt, an assistant
-// toolCall with object arguments, a matching toolResult with isError false, a
-// second call whose result reports isError true, and an unrelated entry type.
-func writePiSession(t *testing.T, home string) string {
-	t.Helper()
-	const ts = "2026-09-01T10:00:00.000Z"
-	lines := []string{
-		`{"type":"session","version":3,"id":"abc","timestamp":"` + ts + `","cwd":"/w"}`,
-		`{"type":"message","id":"m1","parentId":null,"timestamp":"` + ts + `","message":{"role":"user","content":"Fix the parser","timestamp":1}}`,
-		`{"type":"message","id":"m2","parentId":"m1","timestamp":"` + ts + `","message":{"role":"assistant","model":"gpt-x","api":"a","provider":"p","content":[{"type":"thinking","thinking":"private chain"},{"type":"text","text":"Reading it."},{"type":"toolCall","id":"tc1","name":"read","arguments":{"path":"parser.go"}}],"stopReason":"toolUse","timestamp":2}}`,
-		`{"type":"message","id":"m3","parentId":"m2","timestamp":"` + ts + `","message":{"role":"toolResult","toolCallId":"tc1","toolName":"read","content":[{"type":"text","text":"func parse() {}"}],"isError":false,"timestamp":3}}`,
-		`{"type":"message","id":"m4","parentId":"m3","timestamp":"` + ts + `","message":{"role":"assistant","model":"gpt-x","content":[{"type":"toolCall","id":"tc2","name":"write","arguments":{"path":"parser.go","content":"new"}}],"stopReason":"toolUse","timestamp":4}}`,
-		`{"type":"message","id":"m5","parentId":"m4","timestamp":"` + ts + `","message":{"role":"toolResult","toolCallId":"tc2","toolName":"write","content":[{"type":"text","text":"permission denied"}],"isError":true,"timestamp":5}}`,
-		`{"type":"message","id":"m6","parentId":"m5","timestamp":"` + ts + `","message":{"role":"assistant","model":"gpt-x","content":[{"type":"text","text":"The write failed."}],"stopReason":"stop","timestamp":6}}`,
-		`{"type":"model_change","id":"m7","parentId":"m6","timestamp":"` + ts + `","provider":"p","modelId":"gpt-y"}`,
-	}
-	path := filepath.Join(home, ".pi", "agent", "sessions", "-w", "2026-09-01T10-00-00_abc.jsonl")
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-	return path
-}
-
-// PI'S SCHEMA IS ITS OWN, AND ITS TOOL WORK HAS TO SURVIVE TRANSLATION. Routed
-// through the Claude parser, a Pi session with a request and a completed tool
-// call imported "successfully" with no call, no result and no activity summary,
-// and every Pi session was "untitled" because the title check looked for an
-// outer type of "user" that Pi never writes. This pins the vendor's real shapes
-// end to end: index, import, stored pairing and outcome, activity claims, and
-// the resume digest.
-func TestPiSessionsImportTheirRealToolSchema(t *testing.T) {
-	home := t.TempDir()
-	path := writePiSession(t, home)
-	adapter := Pi(testEnv(home, nil))
-
-	found, err := adapter.Discover("/w")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover: %v (%d results)", err, len(found))
-	}
-	if found[0].Title != "Fix the parser" || found[0].Cwd != "/w" || found[0].ModelID != "gpt-x" {
-		t.Fatalf("index = %+v, want title from the first prompt, cwd from the header, model from the assistant", found[0])
-	}
-
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := Import(store, adapter, transcriptID(path), ReadOptions{})
-	if err != nil {
-		t.Fatalf("import: %v", err)
-	}
-	events, err := store.ReadEvents(result.Session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	type call struct{ name, id string }
-	type outcome struct{ status, output string }
-	calls := map[string]call{}
-	results := map[string]outcome{}
-	var texts []string
-	var summaries []string
-	for _, event := range events {
-		var payload map[string]any
-		if err := json.Unmarshal(event.Payload, &payload); err != nil {
-			t.Fatal(err)
-		}
-		get := func(key string) string { value, _ := payload[key].(string); return value }
-		switch event.Type {
-		case sessions.EventToolCall:
-			calls[get("toolCallId")] = call{name: get("name"), id: get("toolCallId")}
-		case sessions.EventToolResult:
-			results[get("toolCallId")] = outcome{status: get("status"), output: get("output")}
-		case sessions.EventMessage:
-			if NoteEventIsSummary(payload) {
-				summaries = append(summaries, get("content"))
-				continue
-			}
-			texts = append(texts, get("role")+": "+get("content"))
-		}
-	}
-	if len(calls) != 2 || len(results) != 2 {
-		t.Fatalf("calls=%d results=%d, want both tool calls with their results: %v / %v", len(calls), len(results), calls, results)
-	}
-	var okRead, failedWrite bool
-	for id, c := range calls {
-		r, paired := results[id]
-		if !paired {
-			t.Fatalf("call %s (%s) has no paired result", id, c.name)
-		}
-		switch c.name {
-		case "read":
-			okRead = r.status == string(tools.StatusOK) && r.output == "func parse() {}"
-		case "write":
-			failedWrite = r.status == string(tools.StatusError) && r.output == "permission denied"
-		}
-	}
-	if !okRead || !failedWrite {
-		t.Fatalf("outcomes were not carried: calls=%v results=%v", calls, results)
-	}
-	joined := strings.Join(texts, "\n")
-	for _, want := range []string{"user: Fix the parser", "assistant: Reading it.", "assistant: The write failed."} {
-		if !strings.Contains(joined, want) {
-			t.Errorf("conversation is missing %q:\n%s", want, joined)
-		}
-	}
-	if strings.Contains(joined, "private chain") {
-		t.Errorf("reasoning was imported without being asked for:\n%s", joined)
-	}
-	summary := strings.Join(summaries, "\n")
-	// Only the confirmed failure is a factual claim; the failed write must not
-	// be reported as a change to parser.go.
-	if !strings.Contains(summary, "permission denied") {
-		t.Errorf("activity summary does not carry the failed call:\n%s", summary)
-	}
-	if strings.Contains(strings.ToLower(summary), "changed") && strings.Contains(summary, "parser.go") {
-		t.Errorf("a failed write was claimed as a change:\n%s", summary)
-	}
-
-	// The reasoning opt-in still works for Pi's "thinking" blocks.
-	withReasoning, err := adapter.Read(found[0], ReadOptions{IncludeReasoning: true})
-	if err != nil {
-		t.Fatal(err)
-	}
-	sawReasoning := false
-	for _, event := range withReasoning {
-		payload, _ := event.Payload.(map[string]any)
-		if payload["role"] == "reasoning" && strings.Contains(payload["content"].(string), "private chain") {
-			sawReasoning = true
-		}
-	}
-	if !sawReasoning {
-		t.Error("IncludeReasoning did not surface Pi's thinking block")
-	}
-
-	// And the real resume path sees the work.
-	prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{Store: store, Resume: result.Session.SessionID})
-	if err != nil {
-		t.Fatal(err)
-	}
-	prompt := sessions.FormatExecPrompt("continue", prepared)
-	for _, want := range []string{"Fix the parser", "The write failed.", "reference context only"} {
-		if !strings.Contains(prompt, want) {
-			t.Errorf("resume prompt is missing %q:\n%s", want, prompt)
-		}
-	}
-}
@@ -1,413 +0,0 @@
-package agentsessions
-
-import (
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// A NORMALIZER THAT REMOVES BYTES IS ALSO A REASSEMBLER, SO IT CANNOT RUN LAST.
-//
-// redact() strips control bytes and matches secrets by shape. The order decides
-// whether it works at all: matching first lets a transcript split a credential
-// with a byte the stripper then deletes, rejoining the halves after the patterns
-// have already declined to match them. Every shape leaked that way.
-//
-// This is the same defect as #835, where an MCP failure reason was redacted
-// before the terminal sanitizer rejoined its halves, so the test is written to
-// fail loudly rather than to describe the current behaviour.
-//
-// A foreign transcript is untrusted input by construction, which is what makes
-// this worth a dedicated test: the whole feature is reading one.
-func TestASecretSplitByAControlByteIsStillRedacted(t *testing.T) {
-	secrets := []struct {
-		name  string
-		value string
-	}{
-		// Shapes redaction recognizes. Synthetic, and long enough to match the
-		// real patterns rather than a near-miss that would pass for the wrong
-		// reason.
-		{name: "anthropic key", value: "sk-ant-api03-" + strings.Repeat("A", 24)},
-		{name: "github pat", value: "ghp_" + strings.Repeat("B", 36)},
-		{name: "aws access key", value: "AKIA" + strings.Repeat("C", 16)},
-	}
-	// Every byte stripControl removes, because each one rejoins the halves. Tab
-	// and newline are deliberately absent: those survive stripping, so they
-	// separate rather than reassemble.
-	splitters := []struct {
-		name string
-		byte string
-	}{
-		{name: "NUL", byte: "\x00"},
-		{name: "ESC", byte: "\x1b"},
-		{name: "backspace", byte: "\x08"},
-		{name: "DEL", byte: "\x7f"},
-		{name: "C1 (0x85)", byte: string(rune(0x85))},
-	}
-
-	for _, secret := range secrets {
-		t.Run(secret.name, func(t *testing.T) {
-			// The control arm. If redaction cannot catch the unsplit value then
-			// the split cases below would pass for the wrong reason.
-			if got := redact("token " + secret.value + " end"); strings.Contains(got, secret.value) {
-				t.Fatalf("redaction does not recognize this shape at all, so the split cases prove nothing: %q", got)
-			}
-
-			for _, splitter := range splitters {
-				t.Run(splitter.name, func(t *testing.T) {
-					// An empty splitter would make every Contains check below vacuously
-					// true. Assert it rather than trust the literal survived editing.
-					if splitter.byte == "" {
-						t.Fatal("splitter byte is empty; the literal was lost and this case proves nothing")
-					}
-					half := len(secret.value) / 2
-					split := secret.value[:half] + splitter.byte + secret.value[half:]
-
-					got := redact("token " + split + " end")
-
-					// The assertion is about the text a READER ends up with. The
-					// splitter is gone by then either way, so checking for the
-					// intact secret in the output is checking exactly what would
-					// reach a picker row or a transcript line.
-					if strings.Contains(got, secret.value) {
-						t.Errorf("a credential split by %s was reassembled after redaction and reached the output: %q", splitter.name, got)
-					}
-					if strings.Contains(got, splitter.byte) {
-						t.Errorf("the control byte survived into the output: %q", got)
-					}
-				})
-			}
-		})
-	}
-}
-
-// The counterpart, so the fix cannot be "strip everything and call it redaction".
-// A separator that survives stripping does NOT rejoin, and the text around a
-// secret has to come through intact either way.
-func TestRedactKeepsTheSurroundingText(t *testing.T) {
-	got := redact("before sk-ant-api03-" + strings.Repeat("A", 24) + " after")
-	for _, want := range []string{"before", "after"} {
-		if !strings.Contains(got, want) {
-			t.Errorf("redaction ate the surrounding text, leaving %q", got)
-		}
-	}
-	if !strings.Contains(got, "[REDACTED]") {
-		t.Errorf("the secret was not redacted at all: %q", got)
-	}
-	// A newline separates rather than rejoins, so the halves must NOT become the
-	// secret, and the newline itself is legitimate transcript content.
-	//
-	// THE COMMENT ABOVE WAS THE ONLY THING ASSERTING THE FIRST HALF OF THAT. The
-	// newline check alone passes just as well if the matcher spans the newline
-	// and redacts both halves as one secret — the separator would survive inside
-	// a "[REDACTED]" that ate the text around it. Both halves are named here, and
-	// so is the absence of any redaction at all, because the failure this guards
-	// against is over-redaction: a credential cannot contain a raw newline, so
-	// treating a newline-split pair as one destroys legitimate transcript content
-	// while protecting nothing. It is also what stops stripControl being widened
-	// to strip newlines, which would make the NUL case above pass for the wrong
-	// reason.
-	halves := []string{"sk-ant-api03-", strings.Repeat("A", 24)}
-	split := redact("before " + halves[0] + "\n" + halves[1] + " after")
-	if !strings.Contains(split, "\n") {
-		t.Errorf("a newline was stripped from transcript text: %q", split)
-	}
-	for _, half := range halves {
-		if !strings.Contains(split, half) {
-			t.Errorf("a newline-separated half %q was consumed as part of a secret, leaving %q", half, split)
-		}
-	}
-	if strings.Contains(split, "[REDACTED]") {
-		t.Errorf("two halves separated by a newline were redacted as one secret: %q", split)
-	}
-}
-
-// A FORMAT CHARACTER IS NOT A CONTROL CHARACTER, and unicode.IsControl agrees —
-// which is the problem. U+202E RIGHT-TO-LEFT OVERRIDE reorders everything after
-// it, so a title or a tool name can be made to render as something entirely
-// different while every byte stays innocent: "gnp.txt.exe" preceded by an
-// override reads as an image file. Category Cf is invisible by definition and
-// nothing in a transcript needs it.
-func TestABidiOverrideIsStrippedFromTitlesAndToolNames(t *testing.T) {
-	for _, hidden := range []string{"\u202e", "\u200b", "\u2066", "\u2069", "\ufeff"} {
-		title := "deploy " + hidden + "gnp.txt.exe"
-		if got := DisplayField(title); strings.Contains(got, hidden) {
-			t.Errorf("a format character %q survived DisplayField: %q", hidden, got)
-		}
-		toolName := "read" + hidden + "_file"
-		got, _ := stripControlWithBoundaries(toolName)
-		if strings.Contains(got, hidden) {
-			t.Errorf("a format character %q survived stripControl: %q", hidden, got)
-		}
-	}
-	// The legible text still comes through — this is stripping, not deletion.
-	if got := DisplayField("deploy \u202egnp.txt.exe"); !strings.Contains(got, "gnp.txt.exe") {
-		t.Errorf("stripping the override ate the filename: %q", got)
-	}
-	// And a newline in a transcript body is still legitimate content, so
-	// stripControl must not have widened into it.
-	got, _ := stripControlWithBoundaries("line one\nline two")
-	if !strings.Contains(got, "\n") {
-		t.Errorf("stripControl removed a legitimate newline: %q", got)
-	}
-}
-
-// THE OTHER DIRECTION OF THE SAME COMPOSITION. Stripping controls can assemble
-// a split key the patterns could not see (the test above), and it can also
-// ERASE the word boundary an intact key needs: "progress\rsk-ant-…" was a
-// recognizable key after a carriage return and became "progresssk-ant-…", a
-// mid-word run \bsk-ant- refuses to match, so the whole key persisted through
-// messageEvent. Both must hold at once; reversing the two calls would trade one
-// for the other, so redaction runs on both sides of normalization.
-func TestAnIntactKeyAfterARemovedSeparatorIsStillRedacted(t *testing.T) {
-	keys := []struct{ name, value string }{
-		{"anthropic key", "sk-ant-api03-" + strings.Repeat("A", 24)},
-		{"github pat", "ghp_" + strings.Repeat("B", 36)},
-		{"aws access key", "AKIA" + strings.Repeat("C", 16)},
-	}
-	separators := []struct{ name, value string }{{"CR", "\r"}, {"NUL", "\x00"}, {"ESC", "\x1b"}, {"DEL", "\x7f"}, {"C1", "\u0085"}}
-	for _, key := range keys {
-		for _, sep := range separators {
-			input := "progress" + sep.value + key.value + " done"
-			for _, probe := range []struct {
-				name string
-				got  string
-			}{
-				{"redact", redact(input)},
-				{"message", str(t, messageEvent("user", input), "content")},
-				{"tool result", str(t, toolResultEvent(&importCallIdentities{}, "bash", "c1", "ok", input), "output")},
-			} {
-				if strings.Contains(probe.got, key.value) {
-					t.Errorf("%s / %s / %s: intact key survived: %q", key.name, sep.name, probe.name, probe.got)
-				}
-				if !strings.Contains(probe.got, "progress") || !strings.Contains(probe.got, "done") {
-					t.Errorf("%s / %s / %s: surrounding text was eaten: %q", key.name, sep.name, probe.name, probe.got)
-				}
-			}
-		}
-	}
-	// Legitimate layout is still kept in transcript text.
-	if got := redact("line one\nline\ttwo"); got != "line one\nline\ttwo" {
-		t.Errorf("newline/tab were not preserved: %q", got)
-	}
-	if got := redact("prefix\x00sk-note"); !strings.Contains(got, "sk-note") {
-		t.Errorf("a short prefix-shaped prose token was over-redacted: %q", got)
-	}
-}
-
-func TestCombinedRemovedSeparatorsCannotHideSplitCredentials(t *testing.T) {
-	secret := "ghp_" + strings.Repeat("A", 36)
-	for _, separator := range []struct {
-		name  string
-		value string
-	}{
-		{name: "NUL", value: "\x00"},
-		{name: "ESC", value: "\x1b"},
-		{name: "DEL", value: "\x7f"},
-		{name: "C1", value: "\u0085"},
-	} {
-		t.Run(separator.name, func(t *testing.T) {
-			input := "progress" + separator.value + secret[:22] + separator.value + secret[22:]
-			for _, probe := range []struct {
-				name string
-				got  string
-			}{
-				{name: "transcript", got: redact(input)},
-				{name: "stored message", got: str(t, messageEvent("user", input), "content")},
-				{name: "stored tool result", got: str(t, toolResultEvent(&importCallIdentities{}, "shell", "call", tools.StatusOK, input), "output")},
-				{name: "display", got: DisplayField(input)},
-			} {
-				if strings.Contains(probe.got, secret) {
-					t.Fatalf("%s reassembled and exposed a split credential: %q", probe.name, probe.got)
-				}
-				if !strings.Contains(probe.got, "progress") || !strings.Contains(probe.got, "[REDACTED]") {
-					t.Fatalf("%s did not preserve readable text and a redaction marker: %q", probe.name, probe.got)
-				}
-			}
-		})
-	}
-
-	input := "progress\x00" + secret[:22] + "\x00" + secret[22:]
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(sessions.CreateInput{SessionID: "combined_redaction"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := store.AppendEvents(session.SessionID, []sessions.AppendEventInput{
-		messageEvent("user", input),
-		toolResultEvent(&importCallIdentities{}, "shell", "call", tools.StatusOK, input),
-	}); err != nil {
-		t.Fatal(err)
-	}
-	events, err := store.ReadEvents(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, event := range events {
-		payload := string(event.Payload)
-		if strings.Contains(payload, secret) || !strings.Contains(payload, "[REDACTED]") {
-			t.Fatalf("persisted %s payload did not retain the redaction boundary: %s", event.Type, payload)
-		}
-	}
-}
-
-func TestDisplayFieldDoesNotLeakCredentialFragmentsAcrossNormalizedSeparators(t *testing.T) {
-	key := "sk-proj-" + strings.Repeat("B", 87)
-	separators := []struct {
-		name  string
-		value string
-	}{
-		{name: "ESC", value: "\x1b"},
-		{name: "NUL", value: "\x00"},
-		{name: "NEL", value: "\u0085"},
-		{name: "zero width space", value: "\u200b"},
-		{name: "right-to-left override", value: "\u202e"},
-		{name: "carriage return", value: "\r"},
-		{name: "tab", value: "\t"},
-		{name: "CRLF", value: "\r\n"},
-		{name: "space", value: " "},
-		{name: "two spaces", value: "  "},
-		{name: "CSI color", value: "\x1b[31m"},
-		{name: "OSC title", value: "\x1b]0;title\a"},
-	}
-
-	for _, separator := range separators {
-		t.Run(separator.name, func(t *testing.T) {
-			got := DisplayField("problem " + key[:48] + separator.value + key[48:] + " end")
-			assertNoCredentialRun(t, got, key, 8)
-			if !strings.Contains(got, "problem") || !strings.Contains(got, "end") || !strings.Contains(got, "[REDACTED]") {
-				t.Fatalf("DisplayField did not retain readable context and a redaction marker: %q", got)
-			}
-		})
-	}
-
-	got := DisplayField("problem " + key[:13] + "\x1b[31m" + key[13:] + " end")
-	assertNoCredentialRun(t, got, key, 8)
-	if !strings.Contains(got, "problem") || !strings.Contains(got, "end") || !strings.Contains(got, "[REDACTED]") {
-		t.Fatalf("DisplayField did not retain context for an early CSI split: %q", got)
-	}
-
-	for _, splitPoints := range [][]int{{20, 60}, {10, 20, 30, 40, 50, 60, 70, 80, 90}} {
-		var split strings.Builder
-		start := 0
-		for _, end := range splitPoints {
-			split.WriteString(key[start:end])
-			split.WriteByte('\t')
-			start = end
-		}
-		split.WriteString(key[start:])
-		got := DisplayField("problem " + split.String() + " end")
-		assertNoCredentialRun(t, got, key, 8)
-		if !strings.Contains(got, "problem") || !strings.Contains(got, "end") || !strings.Contains(got, "[REDACTED]") {
-			t.Fatalf("DisplayField did not retain context for split points %v: %q", splitPoints, got)
-		}
-	}
-}
-
-func TestDisplayFieldFragmentProbeIsBounded(t *testing.T) {
-	// Repeated split prefix-shaped text forces the expensive branch at many
-	// starting positions. The injected detector makes the work count exact and
-	// independent of machine speed.
-	input := strings.Repeat("g h p _ a ", 2048)
-	probes := 0
-	maxProbe := 0
-	got, _ := redactDisplaySpaceSplitsWithProbe(input, nil, func(candidate string) bool {
-		probes++
-		if len(candidate) > maxProbe {
-			maxProbe = len(candidate)
-		}
-		return false
-	})
-	if got != input {
-		t.Fatal("a detector that found no secret changed the field")
-	}
-	if maxProbe > maxDisplaySecretProbeBytes {
-		t.Fatalf("largest probe = %d bytes, want at most %d", maxProbe, maxDisplaySecretProbeBytes)
-	}
-	// There are fewer than len(input) possible starts, and each start can add at
-	// most maxDisplaySecretProbeBytes one-byte fragments before it must stop.
-	if probes > len(input)*maxDisplaySecretProbeBytes {
-		t.Fatalf("detector called %d times for %d bytes", probes, len(input))
-	}
-}
-
-func TestDisplayFieldPrefixFilterKeepsEverySupportedSecretFamily(t *testing.T) {
-	secrets := []string{
-		"sk-ant-api03-" + strings.Repeat("A", 24),
-		"github_pat_" + strings.Repeat("A", 22),
-		"ghp_" + strings.Repeat("A", 36),
-		"glpat-" + strings.Repeat("A", 12),
-		"AIza" + strings.Repeat("A", 35),
-		"xoxb-" + strings.Repeat("A", 10),
-		"AKIA" + strings.Repeat("A", 16),
-		"eyJ" + strings.Repeat("A", 10) + ".eyJ" + strings.Repeat("B", 10) + "." + strings.Repeat("C", 10),
-	}
-	for _, secret := range secrets {
-		split := len(secret) / 2
-		got := DisplayField(secret[:split] + "\t" + secret[split:])
-		if !strings.Contains(got, "[REDACTED]") {
-			t.Errorf("split %q was not redacted: %q", secret, got)
-		}
-		assertNoCredentialRun(t, got, secret, 8)
-	}
-}
-
-func TestLongSplitJWTFailsClosedAtTheDisplayProbeLimit(t *testing.T) {
-	jwt := "eyJ" + strings.Repeat("A", 20) + "." + strings.Repeat("B", 300) + "." + strings.Repeat("C", 24)
-	if contiguous := DisplayField(jwt); !strings.Contains(contiguous, "[REDACTED]") {
-		t.Fatalf("contiguous JWT control was not recognized: %q", contiguous)
-	}
-	split := jwt[:180] + "\t" + jwt[180:]
-	for _, probe := range []struct {
-		name string
-		got  string
-	}{
-		{"display", DisplayField(split)},
-		{"title ingress", summarizeTitle("session " + split)},
-	} {
-		if !strings.Contains(probe.got, "[REDACTED]") {
-			t.Fatalf("%s did not fail closed for delayed JWT recognition: %q", probe.name, probe.got)
-		}
-		assertNoCredentialRun(t, probe.got, jwt, 8)
-	}
-}
-
-func TestTitlesRedactCompleteValuesBeforeShortening(t *testing.T) {
-	pat := "ghp_" + strings.Repeat("P", 36)
-	for _, input := range []string{
-		strings.Repeat("x", 55) + " " + pat,
-		strings.Repeat("y", 50) + ` {"password":"demoPass"}`,
-	} {
-		got := summarizeTitle(input)
-		if strings.Contains(got, pat) || strings.Contains(got, "demoPass") {
-			t.Fatalf("shortened title exposed a value recognizable only before truncation: %q", got)
-		}
-		if !strings.Contains(got, "[REDACT") {
-			t.Fatalf("shortened title lost the complete-value redaction marker: %q", got)
-		}
-	}
-}
-
-func BenchmarkRedactControlDense(b *testing.B) {
-	for _, pairs := range []int{1000, 2000, 4000, 8000} {
-		input := strings.Repeat("a\x00", pairs)
-		b.Run(strconv.Itoa(pairs), func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				_ = redact(input)
-			}
-		})
-	}
-}
-
-func assertNoCredentialRun(t *testing.T, got, credential string, runLength int) {
-	t.Helper()
-	for start := 0; start+runLength <= len(credential); start++ {
-		run := credential[start : start+runLength]
-		if strings.Contains(got, run) {
-			t.Fatalf("output leaked credential run %q at byte %d: %q", run, start, got)
-		}
-	}
-}
@@ -1,280 +0,0 @@
-package agentsessions
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// Adapters returns every adapter in a stable order.
-//
-// Adding an agent is meant to be this line plus one file. The order is the
-// order results are listed in when two sessions share a timestamp, so it stays
-// deterministic rather than depending on map iteration.
-func Adapters(env Env) []Adapter {
-	return []Adapter{
-		ClaudeCode(env),
-		FactoryDroid(env),
-		Pi(env),
-		Codex(env),
-	}
-}
-
-// DiscoverAll indexes every adapter's store and returns the sessions belonging
-// to cwd, most recently updated first. An empty cwd means every session.
-//
-// One adapter failing never denies the user the others: these are undocumented
-// formats owned by other products, and one of them changing shape must not take
-// discovery down with it. Errors are returned alongside the results so a caller
-// can mention them without withholding what did work.
-func DiscoverAll(env Env, cwd string) ([]ForeignSession, []error) {
-	found := []ForeignSession{}
-	problems := []error{}
-	for _, adapter := range Adapters(env) {
-		// Source IDs are adapter-global public identities. Establish uniqueness
-		// across the complete readable store before applying the workspace view;
-		// otherwise discover can advertise a ref that import later finds
-		// ambiguous, and durable agent:id provenance collapses two sources.
-		discovered, err := adapter.Discover("")
-		if err != nil {
-			problems = append(problems, errors.New(adapter.Name()+": "+err.Error()))
-			continue
-		}
-		counts := make(map[string]int, len(discovered))
-		for _, session := range discovered {
-			counts[session.ID]++
-		}
-		ambiguous := map[string]bool{}
-		for _, session := range discovered {
-			if counts[session.ID] > 1 {
-				if !ambiguous[session.ID] && (strings.TrimSpace(cwd) == "" || sameDir(cwd, session.Cwd)) {
-					problems = append(problems, fmt.Errorf("%s: session id %q is ambiguous across multiple transcripts", adapter.Name(), DisplayField(session.ID)))
-					ambiguous[session.ID] = true
-				}
-				continue
-			}
-			if strings.TrimSpace(cwd) != "" && !sameDir(cwd, session.Cwd) {
-				continue
-			}
-			found = append(found, session)
-		}
-	}
-	sortByRecency(found)
-	return found, problems
-}
-
-// ParseRef splits an "<agent>:<id>" reference and resolves the adapter.
-//
-// The agent prefix is required rather than inferred. Two agents can hold
-// sessions with the same id — they are all uuids — and guessing which one the
-// user meant would silently import the wrong conversation.
-func ParseRef(env Env, ref string) (Adapter, string, error) {
-	trimmed := strings.TrimSpace(ref)
-	name, id, found := strings.Cut(trimmed, ":")
-	if !found {
-		return nil, "", errors.New("expected <agent>:<id>, for example claude-code:" +
-			"3f2a1b4c-... — run `zero sessions discover` to list them")
-	}
-	name = strings.TrimSpace(name)
-	id = strings.TrimSpace(id)
-	if name == "" || id == "" {
-		return nil, "", errors.New("both an agent and a session id are required, as <agent>:<id>")
-	}
-	for _, adapter := range Adapters(env) {
-		if strings.EqualFold(adapter.Name(), name) {
-			return adapter, id, nil
-		}
-	}
-	return nil, "", errors.New("unknown agent " + name + "; known agents: " + strings.Join(AdapterNames(env), ", "))
-}
-
-// AdapterNames lists the agents this build can read.
-func AdapterNames(env Env) []string {
-	names := []string{}
-	for _, adapter := range Adapters(env) {
-		names = append(names, adapter.Name())
-	}
-	return names
-}
-
-// importTagPrefix marks a Zero session as a copy of another agent's transcript.
-const importTagPrefix = "imported:"
-
-// ImportTag is the provenance stamp an imported session carries:
-// "imported:v1:<base64url agent>:<base64url foreign session id>".
-//
-// The foreign id is part of the tag, not a second metadata field, so there is
-// exactly one record of where a session came from (repo invariant #5 — two
-// places holding the same fact will drift). It is what lets a caller tell an
-// already-imported session apart from one still only on the other agent's disk,
-// which the /resume picker needs in order not to list both.
-func ImportTag(agent string, sourceID string) string {
-	return sessions.ImportedSessionTag(agent, sourceID)
-}
-
-// ParseImportTag splits an import tag back into its agent and source id.
-// Reports false for a tag that is not an import stamp, including the older
-// two-part "imported:<agent>" form, which records no source id to return.
-func ParseImportTag(tag string) (agent string, sourceID string, ok bool) {
-	return sessions.ParseImportedSessionTag(tag)
-}
-
-// ForeignSourceRefFromTag returns the display-level "agent:id" identity used
-// to suppress a foreign picker row after it has been imported. Unlike
-// ParseImportTag, this deliberately recognizes the legacy
-// "imported:<agent>:<plaintext id>" spelling written by older builds. It is
-// not an authority check: callers deciding whether a session may inherit
-// foreign state must continue to use the strict versioned parser.
-func ForeignSourceRefFromTag(tag string) (string, bool) {
-	if agent, sourceID, ok := ParseImportTag(tag); ok {
-		return agent + ":" + sourceID, true
-	}
-	trimmed := strings.TrimSpace(tag)
-	rest := strings.TrimPrefix(trimmed, importTagPrefix)
-	if rest == trimmed || strings.HasPrefix(rest, "v1:") {
-		return "", false
-	}
-	agent, sourceID, found := strings.Cut(rest, ":")
-	agent = strings.TrimSpace(agent)
-	sourceID = strings.TrimSpace(sourceID)
-	if !found || agent == "" || sourceID == "" {
-		return "", false
-	}
-	return agent + ":" + sourceID, true
-}
-
-// ImportedAgent is the agent a session was imported from, or "" for a session
-// Zero produced itself. Unlike ParseImportTag this accepts the older
-// "imported:<agent>" form, so sessions imported before the tag carried a source
-// id still group under the right agent.
-func ImportedAgent(tag string) string {
-	if agent, _, ok := ParseImportTag(tag); ok {
-		return agent
-	}
-	rest := strings.TrimSpace(tag)
-	trimmed := strings.TrimPrefix(rest, importTagPrefix)
-	if trimmed == rest {
-		return ""
-	}
-	agent, _, _ := strings.Cut(trimmed, ":")
-	return strings.TrimSpace(agent)
-}
-
-// ImportResult reports what an import produced.
-type ImportResult struct {
-	Session sessions.Metadata
-	Events  int
-	Source  ForeignSession
-}
-
-var ErrNoImportableContent = errors.New("foreign session has no importable content")
-
-// Import copies one foreign session into the Zero session store and returns the
-// new Zero session.
-//
-// The store assigns the id rather than deriving one from the foreign id. An
-// import is a SNAPSHOT of another agent's transcript at a moment in time, and
-// that session may well be continued in its own tool afterwards; a second
-// import is therefore a legitimate second snapshot, not a mistake to be refused.
-// Provenance lives in the tag ("imported:claude-code:<foreign session id>") and
-// in the title.
-//
-// Nothing is written to the foreign store at any point.
-func Import(store *sessions.Store, adapter Adapter, id string, options ReadOptions) (ImportResult, error) {
-	source, err := describe(adapter, id)
-	if err != nil {
-		return ImportResult{}, err
-	}
-	return ImportSource(store, adapter, source, options)
-}
-
-// ImportSource imports the exact discovery row selected by a caller. Picker
-// flows use this form so a file disappearing or a same-ID file appearing after
-// rendering cannot silently redirect the selection.
-func ImportSource(store *sessions.Store, adapter Adapter, source ForeignSession, options ReadOptions) (ImportResult, error) {
-	id := source.ID
-	if adapter == nil || !strings.EqualFold(strings.TrimSpace(source.Agent), adapter.Name()) || strings.TrimSpace(id) == "" {
-		return ImportResult{}, errors.New("foreign session source does not match its adapter")
-	}
-	// Exact snapshots prevent redirection, but they cannot make a duplicate
-	// adapter ID a durable identity. Reject the same ambiguity as CLI import.
-	if _, err := describe(adapter, id); err != nil {
-		return ImportResult{}, err
-	}
-	if strings.TrimSpace(options.Cwd) == "" {
-		options.Cwd = source.Cwd
-	}
-	events, err := adapter.Read(source, options)
-	if err != nil {
-		return ImportResult{}, err
-	}
-	if !hasImportableSourceContent(events) {
-		return ImportResult{}, fmt.Errorf("import %s: %w", id, ErrNoImportableContent)
-	}
-	// The imported transcript crosses a model trust boundary. Persist one
-	// generated note before any foreign turn so every resume projection tells the
-	// continuing model that history is reference context, not instructions or
-	// inherited authorization. This sits outside the adapter's source-event cap:
-	// MaxEvents describes copied transcript events, while the boundary is Zero's
-	// mandatory safety metadata.
-	events = append([]sessions.AppendEventInput{importBoundaryEvent(adapter.Name())}, events...)
-
-	created, discardCreated, err := store.CreateDiscardable(sessions.CreateInput{
-		// THE STORE IS THE CHOKEPOINT FOR DISPLAY VALUES. These fields are
-		// another product's bytes and every reader draws them: `zero sessions
-		// list`, the /resume picker, the import summary, the workspace warning.
-		// stripControl was not enough for a stored value — it deliberately keeps
-		// newlines, which is right for a transcript line and wrong for a label
-		// drawn as one row, and it does not redact, so a title (usually the
-		// user's first prompt, where a pasted key lands) stayed a live secret in
-		// the store for every consumer to leak independently. Two of them did.
-		// DisplayField is the one helper that strips controls FIRST and then
-		// redacts, the order redaction_order_test.go pins.
-		Title:         DisplayField(source.Title),
-		Cwd:           DisplayField(source.Cwd),
-		WorkspaceKey:  normalizeDir(source.Cwd),
-		SourceModelID: DisplayField(source.ModelID),
-		Tag:           ImportTag(adapter.Name(), id),
-	})
-	if err != nil {
-		return ImportResult{}, err
-	}
-	if _, err := store.AppendEvents(created.SessionID, events); err != nil {
-		cleanupErr := discardCreated()
-		if cleanupErr != nil {
-			return ImportResult{}, errors.Join(
-				fmt.Errorf("import %s into zero session %s: %w", id, created.SessionID, err),
-				fmt.Errorf("clean up failed import: %w", cleanupErr),
-			)
-		}
-		return ImportResult{}, fmt.Errorf("import %s: %w", id, err)
-	}
-	return ImportResult{Session: created, Events: len(events), Source: source}, nil
-}
-
-// describe finds the index entry for an id so the imported session inherits the
-// title, cwd and model. Discovery is unfiltered here because the session being
-// imported need not belong to the current directory — importing a session from
-// another workspace is a reasonable thing to want.
-func describe(adapter Adapter, id string) (ForeignSession, error) {
-	found, err := adapter.Discover("")
-	if err != nil {
-		return ForeignSession{}, err
-	}
-	matches := []ForeignSession{}
-	for _, session := range found {
-		if session.ID == id {
-			matches = append(matches, session)
-		}
-	}
-	if len(matches) == 1 {
-		return matches[0], nil
-	}
-	if len(matches) > 1 {
-		return ForeignSession{}, fmt.Errorf("%s session id %q is ambiguous across %d transcripts; remove or rename the duplicate before importing", adapter.Name(), DisplayField(id), len(matches))
-	}
-	return ForeignSession{}, errors.New("no " + adapter.Name() + " session with id " + id +
-		" — run `zero sessions discover --all` to list them")
-}
@@ -1,415 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-type invalidImportAdapter struct{}
-
-func (invalidImportAdapter) Name() string { return "invalid" }
-func (invalidImportAdapter) Discover(string) ([]ForeignSession, error) {
-	return []ForeignSession{{Agent: "invalid", ID: "broken", Title: "broken"}}, nil
-}
-
-func TestDuplicateAdapterIDsAreRejectedAcrossDiscoveryAndImportScopes(t *testing.T) {
-	home := t.TempDir()
-	older := filepath.Join(home, ".claude", "projects", "-old", "duplicate.jsonl")
-	newer := filepath.Join(home, ".claude", "projects", "-new", "duplicate.jsonl")
-	writeFile(t, older, `{"type":"user","cwd":"/old","sessionId":"duplicate","message":{"role":"user","content":"older content","model":"older-model"}}`+"\n")
-	writeFile(t, newer, `{"type":"user","cwd":"/new","sessionId":"duplicate","message":{"role":"user","content":"newer content","model":"newer-model"}}`+"\n")
-	oldTime := time.Now().Add(-time.Hour)
-	newTime := time.Now()
-	if err := os.Chtimes(older, oldTime, oldTime); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chtimes(newer, newTime, newTime); err != nil {
-		t.Fatal(err)
-	}
-	adapter := ClaudeCode(testEnv(home, nil))
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 2 {
-		t.Fatalf("discover duplicate IDs: %v (%d results)", err, len(found))
-	}
-	if found[0].Cwd != "/new" {
-		t.Fatalf("newest selected row = %+v, want /new", found[0])
-	}
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	if _, err := ImportSource(store, adapter, found[0], ReadOptions{}); err == nil || !strings.Contains(err.Error(), "ambiguous") {
-		t.Fatalf("exact-source import error = %v, want adapter-global duplicate ambiguity", err)
-	}
-
-	if _, err := Import(store, adapter, "duplicate", ReadOptions{}); err == nil || !strings.Contains(err.Error(), "ambiguous") {
-		t.Fatalf("ID-only import error = %v, want duplicate ambiguity", err)
-	}
-	listed, problems := DiscoverAll(testEnv(home, nil), "")
-	for _, session := range listed {
-		if session.Agent == "claude-code" && session.ID == "duplicate" {
-			t.Fatalf("ambiguous duplicate was presented as importable: %+v", session)
-		}
-	}
-	if !strings.Contains(fmt.Sprint(problems), "ambiguous") {
-		t.Fatalf("duplicate discovery problems = %v, want ambiguity", problems)
-	}
-	for _, cwd := range []string{"/old", "/new"} {
-		listed, problems := DiscoverAll(testEnv(home, nil), cwd)
-		if len(listed) != 0 || !strings.Contains(fmt.Sprint(problems), "ambiguous") {
-			t.Fatalf("scoped discovery for %s = %+v, %v; want no advertised duplicate and an ambiguity warning", cwd, listed, problems)
-		}
-	}
-	metas, err := store.List()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(metas) != 0 {
-		t.Fatalf("ambiguous imports left durable provenance: %+v", metas)
-	}
-}
-
-func TestImportRejectsTranscriptChangedAfterDiscovery(t *testing.T) {
-	home := t.TempDir()
-	path := filepath.Join(home, ".claude", "projects", "-w", "changing.jsonl")
-	writeFile(t, path, `{"type":"user","cwd":"/w","sessionId":"changing","message":{"role":"user","content":"before"}}`+"\n")
-	adapter := ClaudeCode(testEnv(home, nil))
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover: %v (%d results)", err, len(found))
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := file.WriteString(`{"type":"assistant","cwd":"/w","message":{"role":"assistant","content":"after"}}` + "\n"); err != nil {
-		t.Fatal(err)
-	}
-	if err := file.Close(); err != nil {
-		t.Fatal(err)
-	}
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	if _, err := ImportSource(store, adapter, found[0], ReadOptions{}); err == nil || !strings.Contains(err.Error(), "changed after discovery") {
-		t.Fatalf("changed-source import error = %v", err)
-	}
-	metas, err := store.List()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(metas) != 0 {
-		t.Fatalf("changed source left an imported session: %+v", metas)
-	}
-}
-func (invalidImportAdapter) Read(ForeignSession, ReadOptions) ([]sessions.AppendEventInput, error) {
-	return []sessions.AppendEventInput{{Type: sessions.EventMessage, Payload: map[string]any{
-		"role": "user", "content": "hello", "invalid": make(chan int),
-	}}}, nil
-}
-
-type staticImportAdapter struct {
-	events []sessions.AppendEventInput
-}
-
-func (staticImportAdapter) Name() string { return "static" }
-func (a staticImportAdapter) Discover(string) ([]ForeignSession, error) {
-	return []ForeignSession{{Agent: a.Name(), ID: "one", Title: "one", Cwd: "/w"}}, nil
-}
-func (a staticImportAdapter) Read(ForeignSession, ReadOptions) ([]sessions.AppendEventInput, error) {
-	return append([]sessions.AppendEventInput{}, a.events...), nil
-}
-
-func TestImportRejectsDiagnosticOnlyContentButKeepsPartialHistory(t *testing.T) {
-	diagnostic := sessions.AppendEventInput{
-		Type: sessions.EventError, Payload: map[string]any{"message": "one source record was omitted"},
-	}
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: t.TempDir()})
-	if _, err := Import(store, staticImportAdapter{events: []sessions.AppendEventInput{diagnostic}}, "one", ReadOptions{}); !errors.Is(err, ErrNoImportableContent) {
-		t.Fatalf("diagnostic-only import error = %v, want ErrNoImportableContent", err)
-	}
-	metas, err := store.List()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(metas) != 0 {
-		t.Fatalf("diagnostic-only import created a local session: %+v", metas)
-	}
-
-	partial := staticImportAdapter{events: []sessions.AppendEventInput{
-		{Type: sessions.EventMessage, Payload: map[string]any{"role": "user", "content": "retained question"}},
-		diagnostic,
-	}}
-	result, err := Import(store, partial, "one", ReadOptions{})
-	if err != nil {
-		t.Fatalf("partial import: %v", err)
-	}
-	events, err := store.ReadEvents(result.Session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 3 || events[0].Type != sessions.EventMessage || events[1].Type != sessions.EventMessage || events[2].Type != sessions.EventError {
-		t.Fatalf("partial import events = %+v", events)
-	}
-	var boundary map[string]any
-	if err := json.Unmarshal(events[0].Payload, &boundary); err != nil {
-		t.Fatal(err)
-	}
-	if !NoteEventIsBoundary(boundary) || !strings.Contains(fmt.Sprint(boundary["content"]), "reference context only") {
-		t.Fatalf("first event is not the import trust boundary: %+v", boundary)
-	}
-	prepared, err := sessions.PrepareExec(sessions.PrepareExecOptions{Store: store, Resume: result.Session.SessionID})
-	if err != nil {
-		t.Fatal(err)
-	}
-	prompt := sessions.FormatExecPrompt("continue", prepared)
-	if !strings.Contains(prompt, "reference context only") || !strings.Contains(prompt, "retained question") {
-		t.Fatalf("resumed prompt lost boundary or retained history:\n%s", prompt)
-	}
-}
-
-// WHAT THE STORE HOLDS IS WHAT EVERY CONSUMER DRAWS. The import used
-// stripControl on the title and nothing at all on the cwd, which left two
-// separate hazards in the record itself: stripControl deliberately keeps
-// newlines — right for a transcript line, wrong for a label rendered as one row
-// — and it does not redact, so a title (usually the user's first prompt, which
-// is exactly where a pasted key lands) stayed a live credential for `zero
-// sessions list`, the /resume picker and the import summary to leak
-// independently. Sanitizing per consumer is how one of them gets forgotten;
-// this pins the chokepoint instead.
-func TestAnImportedSessionStoresADisplaySafeTitleAndCwd(t *testing.T) {
-	home := t.TempDir()
-	transcript := filepath.Join(home, ".claude", "projects", "-w", "hostile.jsonl")
-	// \u001b, \u0007 and \u000d are how a control byte actually reaches these
-	// fields: encoding/json rejects a raw one inside a string, so a transcript
-	// that carries an escape carries it escaped.
-	writeFile(t, transcript, strings.Join([]string{
-		`{"type":"user","cwd":"/w/\u001b[2Kmoved\u000dhidden/proj","sessionId":"hostile","message":{"role":"user","content":"hi","model":"claude\u001b[2K-opus\nsk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA"}}`,
-		`{"type":"ai-title","aiTitle":"deploy\u0007 it\nwith key sk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA","sessionId":"hostile"}`,
-	}, "\n")+"\n")
-
-	adapter := ClaudeCode(testEnv(home, nil))
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := Import(store, adapter, "hostile", ReadOptions{})
-	if err != nil {
-		t.Fatalf("import: %v", err)
-	}
-
-	// Exact values, not "contains no escape": the readable text has to survive,
-	// or a sanitizer that deleted the field would pass. The newline became a
-	// SPACE rather than vanishing, which is what leaves the word boundary the
-	// secret pattern anchors on — see DisplayField.
-	const wantTitle = "deploy it with key [REDACTED]"
-	if result.Session.Title != wantTitle {
-		t.Errorf("stored title = %q, want %q", result.Session.Title, wantTitle)
-	}
-	// The complete ANSI erase-line sequence is gone and the return left a space
-	// behind it, so the stored path is one line and still legible.
-	const wantCwd = "/w/moved hidden/proj"
-	if result.Session.Cwd != wantCwd {
-		t.Errorf("stored cwd = %q, want %q", result.Session.Cwd, wantCwd)
-	}
-	const wantWorkspaceKey = "/w/\x1b[2Kmoved\rhidden/proj"
-	if result.Session.WorkspaceKey != filepath.Clean(wantWorkspaceKey) {
-		t.Errorf("workspace key = %q, want %q", result.Session.WorkspaceKey, filepath.Clean(wantWorkspaceKey))
-	}
-	const wantModel = "claude-opus [REDACTED]"
-	if result.Session.ModelID != "" || result.Session.SourceModelID != wantModel {
-		t.Errorf("stored operational/source model = %q / %q, want empty / %q", result.Session.ModelID, result.Session.SourceModelID, wantModel)
-	}
-
-	// And the record on disk, not merely the value handed back: the metadata is
-	// re-read by every later `zero sessions` verb and by /resume.
-	reloaded, err := store.Get(result.Session.SessionID)
-	if err != nil || reloaded == nil {
-		t.Fatalf("reloading the imported session: %v", err)
-	}
-	if reloaded.Title != wantTitle || reloaded.Cwd != wantCwd || reloaded.WorkspaceKey != filepath.Clean(wantWorkspaceKey) || reloaded.ModelID != "" || reloaded.SourceModelID != wantModel {
-		t.Errorf("reloaded title/cwd/operational/source model = %q / %q / %q / %q, want %q / %q / empty / %q",
-			reloaded.Title, reloaded.Cwd, reloaded.ModelID, reloaded.SourceModelID, wantTitle, wantCwd, wantModel)
-	}
-	if got := sessions.OperationalCwd(*reloaded); got != filepath.Clean(wantWorkspaceKey) {
-		t.Errorf("operational cwd = %q, want canonical key %q", got, filepath.Clean(wantWorkspaceKey))
-	}
-	if got := sessions.OperationalCwd(sessions.Metadata{Cwd: "/legacy/workspace"}); got != "/legacy/workspace" {
-		t.Errorf("older metadata operational cwd = %q", got)
-	}
-}
-
-// A TITLE IS THE USER'S FIRST PROMPT, so a credential in it arrives on a line of
-// its own far more often than inline — and the separator is what decided whether
-// redaction fired. Every secret pattern anchors on \b, so deleting the newline
-// glued the preceding word onto the shape and the match stopped happening;
-// "key:" happened to still match because a colon is already a boundary, which is
-// how a test written with punctuation would have passed while the real case
-// leaked. Both spellings are pinned here.
-func TestACredentialAfterALineBreakIsStillRedactedInAMetadataField(t *testing.T) {
-	key := "sk-ant-api03-" + strings.Repeat("A", 24)
-	for _, separator := range []struct {
-		name  string
-		value string
-	}{
-		{name: "newline", value: "\n"},
-		{name: "tab", value: "\t"},
-		{name: "carriage return", value: "\r"},
-	} {
-		t.Run(separator.name, func(t *testing.T) {
-			// "key" ends in a word character, so deleting the separator destroys
-			// the boundary. This is the spelling that leaked.
-			got := DisplayField("rotate the key" + separator.value + key)
-			if strings.Contains(got, key) {
-				t.Errorf("a credential after a %s reached a display field verbatim: %q", separator.name, got)
-			}
-			if got != "rotate the key [REDACTED]" {
-				t.Errorf("DisplayField = %q, want %q", got, "rotate the key [REDACTED]")
-			}
-		})
-	}
-}
-
-func TestImportRemovesSessionWhenAppendingEventsFails(t *testing.T) {
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: t.TempDir()})
-	if _, err := Import(store, invalidImportAdapter{}, "broken", ReadOptions{}); err == nil {
-		t.Fatal("import with an unencodable event unexpectedly succeeded")
-	}
-	metas, err := store.List()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(metas) != 0 {
-		t.Fatalf("failed import left a durable session behind: %+v", metas)
-	}
-}
-
-// THE FILE THAT WAS VERIFIED IS THE FILE THAT IS READ. Read used to check the
-// selected path through one handle, translate through a second open and check
-// through a third; a writer that renamed A aside, placed B under A's name for
-// the middle open and restored A before the last check passed both snapshot
-// checks while B's bytes were imported under A's provenance. The seam schedules
-// exactly that replacement between the verified open and the first byte read.
-func TestImportReadsTheFileItVerifiedNotTheNameItWasGiven(t *testing.T) {
-	home := t.TempDir()
-	path := filepath.Join(home, ".claude", "projects", "-w", "swap.jsonl")
-	writeFile(t, path, `{"type":"user","cwd":"/w","sessionId":"swap","message":{"role":"user","content":"genuine A"}}`+"\n")
-	adapter := ClaudeCode(testEnv(home, nil))
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover: %v (%d results)", err, len(found))
-	}
-	aside := path + ".aside"
-	afterSourceOpen = func(opened string) {
-		if opened != path {
-			return
-		}
-		if err := os.Rename(path, aside); err != nil {
-			t.Fatal(err)
-		}
-		writeFile(t, path, `{"type":"user","cwd":"/w","sessionId":"swap","message":{"role":"user","content":"impostor B"}}`+"\n")
-	}
-	t.Cleanup(func() { afterSourceOpen = nil })
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := ImportSource(store, adapter, found[0], ReadOptions{})
-	if err != nil {
-		t.Fatalf("import of the verified handle failed: %v", err)
-	}
-	events, err := store.ReadEvents(result.Session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := ""
-	for _, event := range events {
-		joined += string(event.Payload)
-	}
-	if !strings.Contains(joined, "genuine A") || strings.Contains(joined, "impostor B") {
-		t.Fatalf("imported bytes did not come from the verified file:\n%s", joined)
-	}
-}
-
-// A source written DURING the read is refused on the same handle, as the
-// existing changed-source failure, and nothing is committed.
-func TestImportRefusesASourceWrittenDuringTheRead(t *testing.T) {
-	home := t.TempDir()
-	path := filepath.Join(home, ".claude", "projects", "-w", "grow.jsonl")
-	writeFile(t, path, `{"type":"user","cwd":"/w","sessionId":"grow","message":{"role":"user","content":"before"}}`+"\n")
-	adapter := ClaudeCode(testEnv(home, nil))
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover: %v (%d results)", err, len(found))
-	}
-	afterSourceOpen = func(opened string) {
-		if opened != path {
-			return
-		}
-		file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := file.WriteString(`{"type":"assistant","message":{"role":"assistant","content":"after"}}` + "\n"); err != nil {
-			t.Fatal(err)
-		}
-		if err := file.Close(); err != nil {
-			t.Fatal(err)
-		}
-		// Keep the timestamp moving even on coarse filesystems.
-		future := time.Now().Add(2 * time.Second)
-		_ = os.Chtimes(path, future, future)
-	}
-	t.Cleanup(func() { afterSourceOpen = nil })
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	if _, err := ImportSource(store, adapter, found[0], ReadOptions{}); err == nil || !strings.Contains(err.Error(), "changed after discovery") {
-		t.Fatalf("import of a source written during the read = %v, want changed-source refusal", err)
-	}
-	metas, err := store.List()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(metas) != 0 {
-		t.Fatalf("a refused import left a session: %+v", metas)
-	}
-}
-
-// The Codex reader shares the handle contract: same verified handle from the
-// identity check to the last byte, same refusal of a source that moves.
-func TestCodexImportReadsTheFileItVerifiedNotTheNameItWasGiven(t *testing.T) {
-	env, path := writeCodexStore(t,
-		`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"019f73d7-e215-7ce0-ab38-d9e6db354717","cwd":"/w"}}`,
-		`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"genuine A"}]}}`,
-	)
-	adapter := Codex(env)
-	found, err := adapter.Discover("")
-	if err != nil || len(found) != 1 {
-		t.Fatalf("discover: %v (%d results)", err, len(found))
-	}
-	afterSourceOpen = func(opened string) {
-		if opened != path {
-			return
-		}
-		if err := os.Rename(path, path+".aside"); err != nil {
-			t.Fatal(err)
-		}
-		writeFile(t, path, strings.Join([]string{
-			`{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"019f73d7-e215-7ce0-ab38-d9e6db354717","cwd":"/w"}}`,
-			`{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"impostor B"}]}}`,
-		}, "\n")+"\n")
-	}
-	t.Cleanup(func() { afterSourceOpen = nil })
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	result, err := ImportSource(store, adapter, found[0], ReadOptions{})
-	if err != nil {
-		t.Fatalf("import of the verified handle failed: %v", err)
-	}
-	events, err := store.ReadEvents(result.Session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := ""
-	for _, event := range events {
-		joined += string(event.Payload)
-	}
-	if !strings.Contains(joined, "genuine A") || strings.Contains(joined, "impostor B") {
-		t.Fatalf("imported bytes did not come from the verified file:\n%s", joined)
-	}
-}
@@ -1,9 +0,0 @@
-{"type":"mode","mode":"default"}
-{"type":"user","cwd":"/Users/example/workspace/demo","gitBranch":"main","sessionId":"fixture-session","timestamp":"2026-08-01T10:00:00.000Z","message":{"role":"user","content":"Add a --verbose flag to the CLI and cover it with a test"}}
-{"type":"ai-title","aiTitle":"Add --verbose flag to the CLI","sessionId":"fixture-session"}
-{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"text","text":"I'll start by reading the CLI entrypoint."}]}}
-{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"tool_use","id":"call-1","name":"Read","input":{"file_path":"/Users/example/workspace/demo/cmd/main.go"}}]}}
-{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"call-1","is_error":false,"content":"package main\n\nfunc main() {}"}]}}
-{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"tool_use","id":"call-2","name":"Edit","input":{"file_path":"/Users/example/workspace/demo/cmd/main.go"}}]}}
-{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"call-2","is_error":false,"content":"edited"}]}}
-{"type":"assistant","message":{"role":"assistant","model":"claude-opus-5","content":[{"type":"text","text":"Done — the flag is wired up and the test passes."}]}}
@@ -1,72 +0,0 @@
-{"type": "session_meta", "payload": {"id": "00000000-0000-4000-8000-000000000002", "cwd": "/w", "timestamp": "2026-08-01T10:00:00Z"}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 0"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 1"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 2"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 3"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 4"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 5"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 6"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 7"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 8"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 9"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 10"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 11"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 12"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 13"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 14"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 15"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 16"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 17"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 18"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 19"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 20"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 21"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 22"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 23"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 24"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 25"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 26"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 27"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 28"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 29"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 30"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 31"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 32"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 33"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 34"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 35"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 36"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 37"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 38"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 39"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 40"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 41"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 42"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 43"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 44"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 45"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 46"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 47"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 48"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 49"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 50"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 51"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 52"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 53"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 54"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 55"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 56"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 57"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 58"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 59"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 60"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 61"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 62"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 63"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 64"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 65"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 66"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 67"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 68"}]}}
-{"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "step 69"}]}}
-{"type": "turn_context", "payload": {"model": "gpt-5.6-sol", "cwd": "/w"}}
@@ -1,6 +0,0 @@
-{"type":"session_meta","timestamp":"2026-08-01T10:00:00.000Z","payload":{"session_id":"fixture0-0000-0000-0000-000000000001","cwd":"/Users/example/workspace/demo"}}
-{"type":"turn_context","payload":{"model":"gpt-5.6-sol","effort":"high","summary":"auto"}}
-{"type":"response_item","payload":{"type":"message","role":"user","content":[{"type":"input_text","text":"Add a --verbose flag to the CLI and cover it with a test"}]}}
-{"type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"I'll add the flag and a test."}]}}
-{"type":"response_item","payload":{"type":"function_call","name":"shell","arguments":"{\"command\":\"go test ./...\"}","call_id":"fc-1"}}
-{"type":"response_item","payload":{"type":"function_call_output","call_id":"fc-1","output":"ok"}}
@@ -1 +0,0 @@
-{"type":"bridge-session","sessionId":"b0000000-0000-4000-8000-000000000001","bridgeSessionId":"bridge_01","lastSequenceNum":0}
@@ -1,2 +0,0 @@
-{"type":"queue-operation","timestamp":"2026-01-01T00:00:00Z"}
-{"type":"user","cwd":"/w","timestamp":"2026-01-01T00:00:01Z","message":{"role":"user","model":"m","content":"port the parser"}}
@@ -1,2 +0,0 @@
-{"type": "queue-operation", "timestamp": "2026-01-01T00:00:00Z"}
-{"type": "user", "cwd": "/w", "timestamp": "2026-01-01T00:00:01Z", "message": {"role": "user", "model": "m", "content": "pppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp"}}
@@ -1,3 +0,0 @@
-{"type":"last-prompt","prompt":""}
-{"type":"mode","mode":"default"}
-{"type":"permission-mode","permissionMode":"default"}
@@ -1,944 +0,0 @@
-package agentsessions
-
-import (
-	"crypto/hmac"
-	"crypto/rand"
-	"crypto/sha256"
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"github.com/Gitlawb/zero/internal/redaction"
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// The payload field names below are a CONTRACT with the TUI, not a convention.
-// internal/tui/session.go's transcriptRowsFromSessionEvents reads exactly these
-// keys ("role", "content", "name", "toolCallId", "arguments", "status",
-// "output"); a misspelling renders an empty row and reports no error anywhere.
-// Every event this package produces is built by one of the four constructors
-// here so there is a single place for those names to be right.
-//
-// These constructors are also the redaction chokepoint (repo invariant #6).
-// Imported text is untrusted input (invariant #8) — a foreign transcript can
-// contain a key the other agent echoed into its own log — and routing every
-// event through here means no future caller can add an unredacted path without
-// deleting a call they can see.
-
-// redact runs secret redaction AND control-stripping on imported text. Every
-// field a foreign transcript supplies routes through here — the content-bearing
-// ones and the structural ones (role, name, toolCallId) alike — because a
-// malicious transcript can hide a credential in any of them and Zero then
-// persists and renders it. This is the redaction chokepoint (invariant #6): no
-// imported byte reaches a picker row or transcript line as a secret or as a live
-// control sequence.
-// THE ORDER IS THE WHOLE GUARANTEE. Strip first, then match.
-//
-// RedactString matches secrets by SHAPE, and stripControl deletes a control byte
-// without leaving a gap, so it is also a REASSEMBLER. Running it second meant a
-// transcript could split a credential with a NUL, an ESC or any C1 byte, sail
-// past the shape patterns because neither half looks like a key, and then have
-// the halves rejoined on the way out. Every shape leaked that way: sk-ant-,
-// ghp_, AKIA. Normalizing first means the patterns see the text after the
-// control classes this sanitizer actually removes (C0, DEL, C1, and selected
-// format runes). Combining marks and other non-control Unicode remain unchanged
-// and are not claimed as part of this redaction boundary.
-//
-// Same defect as #835, where an MCP failure reason was redacted before the
-// terminal sanitizer rejoined its halves. Any normalizer that removes bytes
-// without leaving a gap has to run BEFORE whatever matches on them.
-//
-// AND ALSO AFTER IT — BOTH DIRECTIONS HOLD AT ONCE. Stripping changes what the
-// matcher can see in two opposite ways. Removing a control INSIDE a key
-// assembles a key the patterns could not see before (the case above). Removing
-// a control immediately BEFORE an intact key erases the word boundary every
-// pattern anchors on: "progress\rsk-ant-api03-…" was a recognizable key after a
-// carriage return, and became "progresssk-ant-api03-…" — a mid-word run that
-// \bsk-ant- refuses to match — so the whole key persisted through messageEvent.
-// NUL and every other deleted separator reproduce it. DisplayField already ran
-// redaction on both sides of normalization for metadata; the transcript
-// constructors did not, and a transcript is where a pasted key actually lands.
-// Pass one catches the intact key while its separator still stands, pass two
-// catches the split key once the separator is gone. Reported by @jatmn.
-func redact(value string) string {
-	if value == "" {
-		return ""
-	}
-	normalized, boundaries := stripControlWithBoundaries(value)
-	return redactAtRemovedBoundaries(normalized, boundaries)
-}
-
-func stripControlWithBoundaries(value string) (string, []int) {
-	var b strings.Builder
-	b.Grow(len(value))
-	boundaries := []int{}
-	for _, r := range value {
-		switch {
-		case r == '\t' || r == '\n':
-			b.WriteRune(r)
-		case r < 0x20 || r == 0x7f || (r >= 0x80 && r <= 0x9f):
-			boundaries = appendBoundary(boundaries, b.Len())
-		// FORMAT CHARACTERS ARE NOT CONTROL CHARACTERS, and unicode.IsControl
-		// says so — but U+202E RIGHT-TO-LEFT OVERRIDE reorders everything after
-		// it, so a tool name or title can be made to render as something else
-		// entirely while the bytes stay innocent. Category Cf is invisible by
-		// definition; nothing in a transcript needs it.
-		case unicode.Is(unicode.Cf, r):
-			boundaries = appendBoundary(boundaries, b.Len())
-		default:
-			b.WriteRune(r)
-		}
-	}
-	return b.String(), boundaries
-}
-
-func appendBoundary(boundaries []int, position int) []int {
-	if len(boundaries) == 0 || boundaries[len(boundaries)-1] != position {
-		return append(boundaries, position)
-	}
-	return boundaries
-}
-
-// redactAtRemovedBoundaries preserves the fact that a removed control separated
-// two adjacent bytes. The ordinary post-normalization pass catches credentials
-// assembled across an internal control. At a former boundary, a known secret
-// prefix also owns the complete adjacent token even when deleting the control
-// glued preceding prose to it and erased the redactor's word boundary.
-//
-// Each boundary and each byte in a matched token is visited at most a constant
-// number of times. The previous implementation redacted every remaining suffix
-// once per removed byte, making a control-dense accepted value quadratic.
-func redactAtRemovedBoundaries(value string, boundaries []int) string {
-	const boundaryHint = "\ue000"
-	spans := make([]byteSpan, 0)
-	coveredThrough := 0
-	for _, position := range boundaries {
-		if position < coveredThrough || position < 0 || position >= len(value) {
-			continue
-		}
-		if !fullDisplaySecretPrefixAt(value[position:]) {
-			continue
-		}
-		probeEnd := position
-		for probeEnd < len(value) && probeEnd-position < maxDisplaySecretProbeBytes && isTextSecretByte(value[probeEnd]) {
-			probeEnd++
-		}
-		candidate := value[position:probeEnd]
-		probe := redaction.RedactString(boundaryHint+candidate, redaction.Options{})
-		detected := strings.Contains(probe, redaction.RedactedSecret)
-		if !detected && len(candidate) >= maxDisplaySecretProbeBytes {
-			// A supported delayed-match shape (notably a long JWT) can still be
-			// incomplete at the work cap. Abandoning it would fail open.
-			detected = true
-		}
-		if !detected {
-			continue
-		}
-		end := probeEnd
-		for end < len(value) && isTextSecretByte(value[end]) {
-			end++
-		}
-		spans = append(spans, byteSpan{start: position, end: end})
-		coveredThrough = end
-	}
-	for index := len(spans) - 1; index >= 0; index-- {
-		span := spans[index]
-		value = value[:span.start] + redaction.RedactedSecret + value[span.end:]
-	}
-	return redaction.RedactString(value, redaction.Options{})
-}
-
-type byteSpan struct {
-	start int
-	end   int
-}
-
-// Every fixed-prefix text credential reaches its minimum recognizable shape
-// within 40 joined bytes. The larger cap leaves room for OpenAI's digit-based
-// false-positive filter while making work per possible start independent of the
-// discovery-line size. An unresolved sk- candidate at the cap fails closed.
-const maxDisplaySecretProbeBytes = 256
-
-var displaySecretPrefixes = []string{
-	"sk-", "github_pat_", "ghp_", "gho_", "ghu_", "ghs_", "ghr_",
-	"glpat-", "AIza", "xoxb-", "xoxa-", "xoxp-", "xoxr-", "xoxs-",
-	"AKIA", "ASIA", "eyJ",
-}
-
-// redactDisplaySpaceSplits catches credentials whose bytes were separated by
-// layout controls. DisplayField keeps those controls as a space for legibility,
-// but an attacker can put one inside a key: the ordinary matcher then redacts a
-// recognizable prefix and leaves the suffix on screen. Ask the shared redactor
-// whether the adjacent ASCII fragments form a known secret, then replace the
-// complete original span (including the display space).
-//
-// It also remaps the remaining removed-control boundaries. Their byte offsets
-// feed redactAtRemovedBoundaries, so leaving offsets from before a replacement
-// could redact unrelated text later in the field.
-func redactDisplaySpaceSplits(value string, boundaries []int) (string, []int) {
-	const boundaryHint = "\ue000"
-	return redactDisplaySpaceSplitsWithProbe(value, boundaries, func(candidate string) bool {
-		probe := redaction.RedactString(boundaryHint+candidate, redaction.Options{})
-		return strings.Contains(probe, redaction.RedactedSecret) ||
-			(len(candidate) >= maxDisplaySecretProbeBytes && fullDisplaySecretPrefixAt(candidate))
-	})
-}
-
-func redactDisplaySpaceSplitsWithProbe(value string, boundaries []int, detectsSecret func(string) bool) (string, []int) {
-	type fragment struct{ start, end int }
-	fragments := []fragment{}
-	for index := 0; index < len(value); {
-		if !isTextSecretByte(value[index]) {
-			index++
-			continue
-		}
-		start := index
-		for index < len(value) && isTextSecretByte(value[index]) {
-			index++
-		}
-		fragments = append(fragments, fragment{start: start, end: index})
-	}
-
-	spans := []byteSpan{}
-	for start := 0; start < len(fragments); start++ {
-		var candidate strings.Builder
-		for end := start; end < len(fragments); end++ {
-			if end > start {
-				gap := value[fragments[end-1].end:fragments[end].start]
-				if strings.Trim(gap, " ") != "" {
-					break
-				}
-			}
-			fragmentText := value[fragments[end].start:fragments[end].end]
-			remaining := maxDisplaySecretProbeBytes - candidate.Len()
-			if len(fragmentText) > remaining {
-				fragmentText = fragmentText[:remaining]
-			}
-			candidate.WriteString(fragmentText)
-			probeText := candidate.String()
-			if !displaySecretPrefixPossible(probeText) {
-				break
-			}
-			detected := detectsSecret(probeText)
-			if !detected {
-				if candidate.Len() >= maxDisplaySecretProbeBytes {
-					break
-				}
-				continue
-			}
-
-			// Once a secret-shaped prefix is recognized, consume following long
-			// fragments separated only by layout. Leaving those fragments visible
-			// recreates the split-key leak; a short prose word after the key remains
-			// readable and cannot expose the eight-byte run this boundary protects.
-			last := end
-			for next := end + 1; next < len(fragments); next++ {
-				gap := value[fragments[next-1].end:fragments[next].start]
-				if strings.Trim(gap, " ") != "" || fragments[next].end-fragments[next].start < 8 {
-					break
-				}
-				last = next
-			}
-			spans = append(spans, byteSpan{start: fragments[start].start, end: fragments[last].end})
-			start = last
-			break
-		}
-	}
-	if len(spans) == 0 {
-		return value, boundaries
-	}
-
-	// Boundaries are discovered left-to-right, so overlapping spans can only
-	// extend the previous span. Merging first prevents duplicate markers when a
-	// credential contains more than one layout control.
-	merged := spans[:0]
-	for _, span := range spans {
-		if len(merged) > 0 && span.start <= merged[len(merged)-1].end {
-			if span.end > merged[len(merged)-1].end {
-				merged[len(merged)-1].end = span.end
-			}
-			continue
-		}
-		merged = append(merged, span)
-	}
-
-	for i := len(merged) - 1; i >= 0; i-- {
-		span := merged[i]
-		value = value[:span.start] + redaction.RedactedSecret + value[span.end:]
-		delta := len(redaction.RedactedSecret) - (span.end - span.start)
-		for j, position := range boundaries {
-			switch {
-			case position >= span.start && position <= span.end:
-				boundaries[j] = -1
-			case position > span.end:
-				boundaries[j] += delta
-			}
-		}
-	}
-	kept := boundaries[:0]
-	for _, position := range boundaries {
-		if position >= 0 {
-			kept = append(kept, position)
-		}
-	}
-	return value, kept
-}
-
-func displaySecretPrefixPossible(candidate string) bool {
-	for _, prefix := range displaySecretPrefixes {
-		if strings.HasPrefix(prefix, candidate) || strings.HasPrefix(candidate, prefix) {
-			return true
-		}
-	}
-	return false
-}
-
-func fullDisplaySecretPrefixAt(candidate string) bool {
-	for _, prefix := range displaySecretPrefixes {
-		if strings.HasPrefix(candidate, prefix) {
-			return true
-		}
-	}
-	return false
-}
-
-func isTextSecretByte(value byte) bool {
-	return value >= 'a' && value <= 'z' ||
-		value >= 'A' && value <= 'Z' ||
-		value >= '0' && value <= '9' ||
-		value == '_' || value == '-' || value == '.'
-}
-
-// displayEscapeEnd returns the first byte after one ANSI CSI or OSC sequence.
-// A foreign title can contain a real escape such as ESC[31m; deleting only ESC
-// leaves the printable "[31m" bytes between credential fragments and defeats
-// the post-normalization matcher. Other ESC spellings retain their printable
-// byte and only lose the introducer, matching the prior behavior.
-func displayEscapeEnd(value string, start int) int {
-	if start+1 >= len(value) {
-		return start + 1
-	}
-	switch value[start+1] {
-	case '[':
-		for index := start + 2; index < len(value); index++ {
-			if value[index] >= 0x40 && value[index] <= 0x7e {
-				return index + 1
-			}
-		}
-		return len(value)
-	case ']':
-		for index := start + 2; index < len(value); index++ {
-			if value[index] == '\a' {
-				return index + 1
-			}
-			if value[index] == 0x1b && index+1 < len(value) && value[index+1] == '\\' {
-				return index + 2
-			}
-		}
-		return len(value)
-	default:
-		return start + 1
-	}
-}
-
-// Every event a translation produces carries sessions.ImportedEventKey. The
-// resume digest keeps only the last 80 eligible events, so the boundary note
-// persisted ahead of the transcript aged out of the window on the first resume
-// of any import longer than that, while the foreign turns it was labelling
-// stayed. The marker is what lets FormatExecPrompt tell, from the retained
-// window alone, that what it is about to hand the model is foreign — and
-// regenerate the label rather than depend on one event surviving truncation,
-// compaction, or a fork. Reported by @jatmn.
-func messageEvent(role string, content string) sessions.AppendEventInput {
-	return sessions.AppendEventInput{
-		Type: sessions.EventMessage,
-		Payload: map[string]any{
-			"role":                    redact(role),
-			"content":                 redact(content),
-			sessions.ImportedEventKey: true,
-		},
-	}
-}
-
-type importCallIdentities struct {
-	key []byte
-}
-
-func (identities *importCallIdentities) opaque(foreign string) string {
-	if len(identities.key) == 0 {
-		identities.key = []byte(rand.Text())
-	}
-	digest := hmac.New(sha256.New, identities.key)
-	_, _ = digest.Write([]byte(foreign))
-	return fmt.Sprintf("import-call-%x", digest.Sum(nil))
-}
-
-func toolCallEvent(identities *importCallIdentities, name string, foreignCallID string, arguments string) sessions.AppendEventInput {
-	return sessions.AppendEventInput{
-		Type: sessions.EventToolCall,
-		Payload: map[string]any{
-			"name": redact(name),
-			// Identity is structural, not display text. Foreign ids may contain
-			// secrets, and redaction is deliberately many-to-one, so persisting a
-			// redacted foreign id can collapse distinct call/result pairs. This
-			// per-import opaque id is non-secret and one-to-one.
-			"toolCallId":              identities.opaque(foreignCallID),
-			"arguments":               redactArguments(arguments),
-			sessions.ImportedEventKey: true,
-		},
-	}
-}
-
-// redactArguments sanitizes a tool call's arguments as the VALUES a consumer
-// will decode, not as the bytes they are serialized in.
-//
-// arguments is JSON from every adapter that has structured calls, and JSON
-// escapes are a representation the sanitizer above cannot see through: a
-// foreign path of "\u001b[2J FORGED \u0067hp_AAAA…" contains no ESC byte and
-// no recognizable key prefix while it is encoded, so redact() passed it whole —
-// and the TUI's argHint → firstArgValue then json-decoded it on resume into an
-// actual escape followed by a complete PAT, in the tool row. A scan of the
-// encoded text can prove nothing about strings that will be unescaped later.
-// The sanitizer has to run where the value exists: decode, redact every string
-// leaf (nested included — an argument object is routinely a tree), re-encode.
-// Reported by @jatmn.
-//
-// Not JSON — Codex's custom_tool_call carries a bare script in "input" — is
-// text and is sanitized as text, exactly as before. A JSON value that is not an
-// object or array (a bare string) decodes to its leaf and is handled the same
-// way. The encoded result stays valid JSON for its existing consumers.
-func redactArguments(arguments string) string {
-	trimmed := strings.TrimSpace(arguments)
-	if trimmed == "" {
-		return ""
-	}
-	var decoded any
-	if err := json.Unmarshal([]byte(trimmed), &decoded); err != nil {
-		return redact(arguments)
-	}
-	// First normalize every decoded key and value using the imported-text policy,
-	// then retain the complete object shape while applying sensitive-key rules.
-	// A leaf-only walk cannot know that an opaque value belongs to "password",
-	// and leaving map keys untouched can persist a credential in a property name.
-	sanitized := redaction.RedactValue(redactJSONValue(decoded), redaction.Options{})
-	encoded, err := json.Marshal(sanitized)
-	if err != nil {
-		return redact(arguments)
-	}
-	return string(encoded)
-}
-
-// redactJSONValue walks a decoded JSON value and applies imported-text
-// normalization to string leaves and object keys. Ordinary schema keys remain
-// unchanged; credential-bearing keys are intentionally rewritten before the
-// object-aware redactor handles sensitive key/value relationships.
-func redactJSONValue(value any) any {
-	switch typed := value.(type) {
-	case string:
-		return redact(typed)
-	case []any:
-		for index := range typed {
-			typed[index] = redactJSONValue(typed[index])
-		}
-		return typed
-	case map[string]any:
-		redacted := make(map[string]any, len(typed))
-		for key := range typed {
-			redacted[redact(key)] = redactJSONValue(typed[key])
-		}
-		return redacted
-	default:
-		return value
-	}
-}
-
-func toolResultEvent(identities *importCallIdentities, name string, foreignCallID string, status tools.Status, output string) sessions.AppendEventInput {
-	return sessions.AppendEventInput{
-		Type: sessions.EventToolResult,
-		Payload: map[string]any{
-			"name":                    redact(name),
-			"toolCallId":              identities.opaque(foreignCallID),
-			"status":                  string(status),
-			"output":                  redact(output),
-			sessions.ImportedEventKey: true,
-		},
-	}
-}
-
-// noteEventSummaryKey marks a message as a Zero-generated activity summary
-// rather than a translated foreign-transcript turn. The TUI and the resume
-// digest also reads "role" and "content", so the marker itself is metadata even
-// though the generated summary remains visible to both the user and the model.
-// NoteEventIsSummary lets consumers distinguish it from a foreign turn.
-const noteEventSummaryKey = "importedActivitySummary"
-
-// importBoundaryKey is owned by internal/sessions rather than here, because the
-// resume digest has to recognize the boundary without importing this package.
-const importBoundaryKey = sessions.ImportedBoundaryKey
-
-func importBoundaryEvent(agentName string) sessions.AppendEventInput {
-	return sessions.AppendEventInput{
-		Type: sessions.EventMessage,
-		Payload: map[string]any{
-			"role":            "user",
-			"content":         sessions.ImportedBoundaryText(DisplayField(agentName)),
-			importBoundaryKey: true,
-		},
-	}
-}
-
-// NoteEventIsBoundary reports whether an event is Zero's generated trust
-// boundary rather than content copied from the foreign transcript.
-func NoteEventIsBoundary(payload any) bool {
-	m, ok := payload.(map[string]any)
-	if !ok {
-		return false
-	}
-	flag, _ := m[importBoundaryKey].(bool)
-	return flag
-}
-
-func hasImportableSourceContent(events []sessions.AppendEventInput) bool {
-	for _, event := range events {
-		switch event.Type {
-		case sessions.EventToolCall, sessions.EventToolResult:
-			return true
-		case sessions.EventMessage:
-			if NoteEventIsSummary(event.Payload) || NoteEventIsBoundary(event.Payload) {
-				continue
-			}
-			payload, ok := event.Payload.(map[string]any)
-			if !ok {
-				encoded, err := json.Marshal(event.Payload)
-				if err != nil || json.Unmarshal(encoded, &payload) != nil {
-					continue
-				}
-			}
-			role, _ := payload["role"].(string)
-			content, _ := payload["content"].(string)
-			if (role == "user" || role == "assistant") && strings.TrimSpace(content) != "" {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// NoteEventIsSummary reports whether an event is a Zero-generated activity
-// summary message (see noteEvent) rather than a translated transcript turn. It
-// takes any so callers can pass an AppendEventInput.Payload directly.
-func NoteEventIsSummary(payload any) bool {
-	m, ok := payload.(map[string]any)
-	if !ok {
-		return false
-	}
-	flag, _ := m[noteEventSummaryKey].(bool)
-	return flag
-}
-
-// noteEvent carries an imported-session activity summary as an assistant
-// message. NOT EventCompaction: that type has a second contract on the replay
-// side. RehydrateEvents restructures the transcript around the last
-// EventCompaction, and an activity summary with no CompactionPayload bookkeeping
-// (no CompactableEvents, CompactedThroughSequence 0) makes rehydration hoist
-// this note to the FRONT of the transcript. EventMessage still passes
-// promptContextEvents — the resume digest — without that restructuring. The
-// summary marker keeps it distinguishable from a real assistant turn.
-func noteEvent(summary string) sessions.AppendEventInput {
-	return sessions.AppendEventInput{
-		Type: sessions.EventMessage,
-		Payload: map[string]any{
-			"role":                    "assistant",
-			"content":                 redact(summary),
-			noteEventSummaryKey:       true,
-			sessions.ImportedEventKey: true,
-		},
-	}
-}
-
-// translateFamily1 converts a family-1 transcript into Zero events.
-//
-// The mapping is deliberately lossy in one direction only: everything that
-// affects what a reader (human or model) needs in order to continue the work is
-// kept, and everything that belongs to the other model's private machinery is
-// dropped. Zero's own resume renders these events to a text digest anyway
-// (sessions.FormatExecPrompt), so perfect structural fidelity would buy nothing.
-func translateFamily1(file readSeekStater, options ReadOptions) ([]sessions.AppendEventInput, error) {
-	events := newEventTail(effectiveMaxEvents(options.MaxEvents))
-	// A tool result names only the id of the call it answers, so the call's name
-	// has to be carried forward. Every family-1 agent writes the tool_use before
-	// the matching tool_result, so this is populated by the time it is read.
-	toolNames := map[string]string{}
-	identities := &importCallIdentities{}
-	activity := newActivityLog(options.Cwd)
-
-	omitted := 0
-	prefixOmitted, err := streamTailLines(file, importLineLimit, importByteLimit, func(line []byte, truncated bool) bool {
-		// A RECORD TOO LONG EVEN FOR THE IMPORT CAP IS REPORTED, NOT DROPPED.
-		// Skipping it silently produced a transcript that looked complete: a
-		// question, no answer, then the follow-up. The marker is the honest
-		// answer — the bytes are gone either way, but the reader can see it.
-		if truncated {
-			omitted++
-			return true
-		}
-		var record family1Record
-		if json.Unmarshal(line, &record) != nil || record.Message == nil {
-			// Torn or unrecognised lines are skipped, not fatal: transcripts are
-			// appended live and the final line is routinely half-written.
-			return true
-		}
-		role := roleFor(record)
-		if role == "" {
-			return true
-		}
-
-		// Content is either a bare string (a plain user prompt) or an array of
-		// typed blocks.
-		var text string
-		if json.Unmarshal(record.Message.Content, &text) == nil {
-			if strings.TrimSpace(text) != "" {
-				events.add(messageEvent(role, text))
-			}
-			return true
-		}
-
-		var blocks []family1Block
-		if json.Unmarshal(record.Message.Content, &blocks) != nil {
-			return true
-		}
-		for _, block := range blocks {
-			switch block.Type {
-			case "text":
-				if strings.TrimSpace(block.Text) != "" {
-					events.add(messageEvent(role, block.Text))
-				}
-			case "thinking":
-				// The other model's reasoning. Dropped by default: it is private
-				// to that provider, frequently larger than the visible
-				// conversation, and a different model continuing this work will
-				// not be picking up that chain of thought.
-				if options.IncludeReasoning && strings.TrimSpace(block.Thinking) != "" {
-					events.add(messageEvent("reasoning", block.Thinking))
-				}
-			case "tool_use":
-				toolNames[block.ID] = block.Name
-				activity.observeCall(block.ID, block.Name, string(block.Input))
-				events.add(toolCallEvent(identities, block.Name, block.ID, string(block.Input)))
-			case "tool_result":
-				name := toolNames[block.ToolUseID]
-				if name == "" {
-					name = "unknown"
-				}
-				status := tools.StatusOK
-				if block.IsError {
-					status = tools.StatusError
-				}
-				output := family1ResultText(block.Content)
-				activity.observeResult(block.ToolUseID, name, status, output)
-				events.add(toolResultEvent(identities, name, block.ToolUseID, status, output))
-				delete(toolNames, block.ToolUseID)
-			}
-		}
-		return true
-	})
-	if err != nil {
-		return nil, err
-	}
-	// SAID OUT LOUD. A resumed conversation that quietly lost a record reads as
-	// complete to both the user and the model continuing it — the failure this
-	// makes visible is a question with no answer followed by a follow-up.
-	contextEvents := activity.summaryEvents()
-	if prefixOmitted {
-		contextEvents = append(contextEvents, omittedPrefixEvent())
-	}
-	if omitted > 0 {
-		contextEvents = append(contextEvents, omittedRecordsEvent(omitted))
-	}
-	return capTranslatedEventsDropped(events.values(), contextEvents, effectiveMaxEvents(options.MaxEvents), events.dropped), nil
-}
-
-// roleFor admits only visible conversation roles. System, developer, and other
-// harness records belong to the foreign agent and must not become instructions
-// or user-visible turns in Zero.
-func roleFor(record family1Record) string {
-	if record.Message == nil {
-		return ""
-	}
-	switch role := strings.ToLower(strings.TrimSpace(record.Message.Role)); role {
-	case "user", "assistant":
-		return role
-	default:
-		return ""
-	}
-}
-
-// family1ResultText flattens a tool result's content, which may be a bare string
-// or an array of blocks.
-func family1ResultText(raw json.RawMessage) string {
-	if len(raw) == 0 {
-		return ""
-	}
-	var text string
-	if json.Unmarshal(raw, &text) == nil {
-		return text
-	}
-	if flattened := family1Text(raw); flattened != "" {
-		return flattened
-	}
-	// Structured content with no text blocks (an image result, say). Keeping the
-	// raw JSON is better than an empty row: the reader at least learns that the
-	// call returned something and what shape it was.
-	return string(raw)
-}
-
-// capEvents keeps the LAST max events, because the tail is what a resume needs
-// — the most recent exchanges describe where the work actually stopped.
-//
-// The drop is announced rather than silent. A truncated import that looks
-// complete is how someone concludes the other agent never did the work.
-func capEvents(events []sessions.AppendEventInput, max int) []sessions.AppendEventInput {
-	return capEventsDropped(events, max, 0)
-}
-
-func capEventsDropped(events []sessions.AppendEventInput, max int, alreadyDropped int) []sessions.AppendEventInput {
-	if alreadyDropped == 0 && (max <= 0 || len(events) <= max) {
-		return events
-	}
-	if max <= 0 {
-		out := []sessions.AppendEventInput{noteEvent(plural(alreadyDropped, "earlier event") +
-			" from this session were not imported; all retained events are shown.")}
-		return append(out, events...)
-	}
-	if max == 1 {
-		// A one-event budget cannot disclose loss and retain source content. Keep
-		// the latest source event, matching the public tail guarantee.
-		if len(events) > 0 {
-			return []sessions.AppendEventInput{events[len(events)-1]}
-		}
-		return []sessions.AppendEventInput{noteEvent(plural(alreadyDropped, "earlier event") + " from this session were not imported.")}
-	}
-	// The note itself occupies one of the max slots, so one more original event
-	// (the oldest of the tail) is dropped to make room for it. The reported
-	// count must include that event: len(events)-max alone understates the loss
-	// by one, and a truncation that reads as smaller than it was is how someone
-	// concludes the other agent did less than it did.
-	shownCount := min(len(events), max-1)
-	shown := events[len(events)-shownCount:]
-	baseShown := len(shown)
-	shown, orphaned := withoutOrphanToolResults(shown)
-	dropped := alreadyDropped + len(events) - baseShown + orphaned
-	out := make([]sessions.AppendEventInput, 0, max)
-	out = append(out, noteEvent(plural(dropped, "earlier event")+
-		" from this session were not imported; the most recent "+
-		itoaEvents(len(shown))+" are shown."))
-	return append(out, shown...)
-}
-
-// capTranslatedEvents applies MaxEvents without allowing generated summaries
-// to evict the actual transcript tail. Context receives spare/reserved slots,
-// but at least the final source event always survives when source exists.
-func capTranslatedEventsDropped(source, contextEvents []sessions.AppendEventInput, max int, alreadyDropped int) []sessions.AppendEventInput {
-	// Re-establish call/result structure after every lossy source boundary. A
-	// byte-tail read can omit the call while retaining its result even when the
-	// event cap never fires; event-cap loss is already represented by
-	// alreadyDropped and includes paired results removed here.
-	var orphaned int
-	source, orphaned = withoutOrphanToolResults(source)
-	alreadyDropped += orphaned
-	if alreadyDropped == 0 && (max <= 0 || len(source)+len(contextEvents) <= max) {
-		return append(append([]sessions.AppendEventInput{}, source...), contextEvents...)
-	}
-	if len(source) == 0 {
-		return capEvents(contextEvents, max)
-	}
-	if len(contextEvents) == 0 {
-		if max == 1 {
-			// A one-event budget cannot hold both a disclosure and source content.
-			// Preserve the promised transcript tail instead of returning only the
-			// generated omission marker.
-			return []sessions.AppendEventInput{source[len(source)-1]}
-		}
-		return capEventsDropped(source, max, alreadyDropped)
-	}
-	contextSlots := min(len(contextEvents), max-1)
-	if contextSlots < 0 {
-		contextSlots = 0
-	}
-	sourceSlots := max - contextSlots
-	// If source must be truncated and the budget has room, reserve a second
-	// source slot for capEvents' disclosure note. Keeping only the final source
-	// event would satisfy the tail guarantee while silently hiding that earlier
-	// transcript events were dropped.
-	if (len(source) > sourceSlots || alreadyDropped > 0) && max >= 2 && sourceSlots < 2 {
-		sourceSlots = 2
-		contextSlots = max - sourceSlots
-	}
-	var keptSource []sessions.AppendEventInput
-	if sourceSlots <= 1 {
-		// A one-event budget cannot hold both a disclosure and source content.
-		// The flag promises transcript-tail events, so the final source event wins;
-		// larger budgets retain the explicit omission marker below.
-		keptSource = append(keptSource, source[len(source)-1])
-	} else {
-		keptSource = capEventsDropped(source, sourceSlots, alreadyDropped)
-	}
-	return append(keptSource, contextEvents[len(contextEvents)-contextSlots:]...)
-}
-
-const (
-	defaultImportMaxEvents = 4096
-	importByteLimit        = 32 << 20
-)
-
-func effectiveMaxEvents(requested int) int {
-	if requested > 0 {
-		return requested
-	}
-	return defaultImportMaxEvents
-}
-
-type eventTail struct {
-	events  []sessions.AppendEventInput
-	max     int
-	start   int
-	dropped int
-}
-
-func newEventTail(max int) *eventTail {
-	return &eventTail{
-		events: make([]sessions.AppendEventInput, 0, min(max, 128)),
-		max:    max,
-	}
-}
-
-func (tail *eventTail) add(event sessions.AppendEventInput) {
-	if len(tail.events) < tail.max {
-		tail.events = append(tail.events, event)
-		return
-	}
-	tail.events[tail.start] = event
-	tail.start = (tail.start + 1) % len(tail.events)
-	tail.dropped++
-}
-
-func (tail *eventTail) values() []sessions.AppendEventInput {
-	if tail.start == 0 {
-		return tail.events
-	}
-	out := make([]sessions.AppendEventInput, 0, len(tail.events))
-	out = append(out, tail.events[tail.start:]...)
-	return append(out, tail.events[:tail.start]...)
-}
-
-func withoutOrphanToolResults(events []sessions.AppendEventInput) ([]sessions.AppendEventInput, int) {
-	calls := map[string]bool{}
-	out := make([]sessions.AppendEventInput, 0, len(events))
-	dropped := 0
-	for _, event := range events {
-		payload, _ := event.Payload.(map[string]any)
-		id, _ := payload["toolCallId"].(string)
-		if event.Type == sessions.EventToolCall {
-			calls[id] = true
-		}
-		if event.Type == sessions.EventToolResult {
-			if !calls[id] {
-				dropped++
-				continue
-			}
-		}
-		out = append(out, event)
-	}
-	return out, dropped
-}
-
-func omittedPrefixEvent() sessions.AppendEventInput {
-	return noteEvent("Older transcript records were not imported; only a bounded tail of this foreign session was read.")
-}
-
-func itoaEvents(value int) string { return strconv.Itoa(value) }
-
-func plural(count int, noun string) string {
-	if count == 1 {
-		return "1 " + noun
-	}
-	return itoaEvents(count) + " " + noun + "s"
-}
-
-// omittedRecordsEvent names what an import could not carry across.
-//
-// It is an EventError rather than a message because it is not part of the
-// conversation and must not read as one: a model continuing this session should
-// see a note about the transcript, not a turn somebody took. The count is the
-// honest limit of what can be said — the bytes were never parsed, so their role,
-// author and content are all unknown.
-func omittedRecordsEvent(count int) sessions.AppendEventInput {
-	noun := "record"
-	if count != 1 {
-		noun = "records"
-	}
-	return sessions.AppendEventInput{
-		Type: sessions.EventError,
-		Payload: map[string]any{
-			"message": fmt.Sprintf("%d %s in the source transcript exceeded the import size limit and could not be read. "+
-				"This imported conversation is missing that content.", count, noun),
-		},
-	}
-}
-
-// DisplayField makes one foreign metadata value safe to draw in a terminal.
-//
-// TWO SEPARATE HAZARDS. The value is a field another product
-// wrote into its own file: it can carry terminal escapes that repaint the rows
-// around it, and it can carry something shaped like a credential — a title is
-// often the user's first prompt, which is where a pasted key ends up.
-//
-// Controls are normalized before redaction so a secret split by one cannot
-// evade the shape match.
-// Layout goes as well, unlike the transcript
-// helper, because a metadata field is drawn as one row and a newline in it moves
-// the rest of the line somewhere the caller did not intend.
-//
-// TAB, NEWLINE AND RETURN BECOME A SPACE RATHER THAN VANISHING, and that gap is
-// load-bearing in the opposite direction to the stripping above. Every secret
-// pattern anchors on \b, so deleting the separator in "key<TAB>sk-ant-…" glued a
-// word character onto the shape and the match no longer fired — a title is
-// usually the user's first prompt, and a pasted key on the line after "key:" is
-// exactly how one arrives. Substituting keeps the field one row while leaving the
-// boundary the patterns need. It costs nothing that was being protected:
-// redaction_order_test.go already establishes that a credential cannot contain a
-// raw newline, so joining across one never reassembled a real secret. The
-// invisible bytes — C0, DEL, C1, Cf — are still DELETED, because those are the
-// ones an escape can hide inside a key.
-func DisplayField(value string) string {
-	var b strings.Builder
-	b.Grow(len(value))
-	boundaries := []int{}
-	for index := 0; index < len(value); {
-		if value[index] == 0x1b {
-			boundaries = appendBoundary(boundaries, b.Len())
-			index = displayEscapeEnd(value, index)
-			continue
-		}
-		r, size := utf8.DecodeRuneInString(value[index:])
-		index += size
-		if r == '\t' || r == '\n' || r == '\r' {
-			boundaries = appendBoundary(boundaries, b.Len())
-			b.WriteRune(' ')
-			continue
-		}
-		// Cf as well as control: see stripControl. A bidi override in a picker row
-		// reorders the rows's visible text without changing a byte of it.
-		if unicode.IsControl(r) || unicode.Is(unicode.Cf, r) {
-			boundaries = appendBoundary(boundaries, b.Len())
-			continue
-		}
-		b.WriteRune(r)
-	}
-	normalized, boundaries := redactDisplaySpaceSplits(b.String(), boundaries)
-	return strings.TrimSpace(redactAtRemovedBoundaries(normalized, boundaries))
-}
@@ -1,604 +0,0 @@
-package agentsessions
-
-import (
-	"encoding/json"
-	"path/filepath"
-	"sort"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-func writeTranscript(t *testing.T, lines ...string) string {
-	t.Helper()
-	path := filepath.Join(t.TempDir(), "session.jsonl")
-	writeFile(t, path, strings.Join(lines, "\n")+"\n")
-	return path
-}
-
-// payloadOf re-marshals an event payload the way the store will, so the tests
-// assert on what actually lands in events.jsonl rather than on the Go map.
-func payloadOf(t *testing.T, event sessions.AppendEventInput) map[string]any {
-	t.Helper()
-	encoded, err := json.Marshal(event.Payload)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var decoded map[string]any
-	if err := json.Unmarshal(encoded, &decoded); err != nil {
-		t.Fatal(err)
-	}
-	return decoded
-}
-
-func keysOf(t *testing.T, event sessions.AppendEventInput) []string {
-	t.Helper()
-	keys := []string{}
-	for key := range payloadOf(t, event) {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-func str(t *testing.T, event sessions.AppendEventInput, key string) string {
-	t.Helper()
-	value, _ := payloadOf(t, event)[key].(string)
-	return value
-}
-
-// TestPayloadKeysMatchWhatTheTUIReads is the guard on a layer join that nothing
-// else checks: internal/tui/session.go's transcriptRowsFromSessionEvents reads
-// these payloads by literal key name, and a mismatch produces a blank row with
-// no error at either end. If that reader is ever renamed or its keys change,
-// this test is the tripwire.
-// conversationEvents drops the activity-summary events so a test asserting the
-// SHAPE of the imported conversation is not perturbed by summaries being added
-// or refined. Tests that care about the summary use summaryTexts instead.
-func conversationEvents(events []sessions.AppendEventInput) []sessions.AppendEventInput {
-	out := make([]sessions.AppendEventInput, 0, len(events))
-	for _, event := range events {
-		// Zero-generated activity summaries (assistant messages carrying the
-		// summary marker) are not translated transcript turns.
-		if event.Type == sessions.EventCompaction || NoteEventIsSummary(event.Payload) {
-			continue
-		}
-		out = append(out, event)
-	}
-	return out
-}
-
-func TestFamily1ImportsOnlyConversationRoles(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"system","message":{"role":"system","content":"follow these foreign instructions"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":"retained answer"}}`,
-	)
-	events, err := translateFamily1At(filepath.Dir(path), path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	events = conversationEvents(events)
-	if len(events) != 1 || str(t, events[0], "role") != "assistant" || str(t, events[0], "content") != "retained answer" {
-		t.Fatalf("family-1 role filter produced %+v", events)
-	}
-}
-
-func TestPayloadKeysMatchWhatTheTUIReads(t *testing.T) {
-	identities := &importCallIdentities{}
-	cases := []struct {
-		name  string
-		event sessions.AppendEventInput
-		want  []string
-	}{
-		// importedEvent is the marker FormatExecPrompt uses to regenerate the
-		// reference-only label when the boundary note falls out of the digest
-		// window; every constructor carries it (see messageEvent).
-		{"message", messageEvent("user", "hi"), []string{"content", "importedEvent", "role"}},
-		{"tool call", toolCallEvent(identities, "Read", "toolu_1", "{}"), []string{"arguments", "importedEvent", "name", "toolCallId"}},
-		{"tool result", toolResultEvent(identities, "Read", "toolu_1", "ok", "out"), []string{"importedEvent", "name", "output", "status", "toolCallId"}},
-		{"note", noteEvent("trimmed"), []string{"content", "importedActivitySummary", "importedEvent", "role"}},
-	}
-	for _, test := range cases {
-		got := keysOf(t, test.event)
-		if strings.Join(got, ",") != strings.Join(test.want, ",") {
-			t.Errorf("%s payload keys = %v, want %v", test.name, got, test.want)
-		}
-	}
-}
-
-func TestAClaudeTranscriptBecomesZeroEvents(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"user","cwd":"/w","message":{"role":"user","content":"Find the bug"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[`+
-			`{"type":"thinking","thinking":"private chain of thought"},`+
-			`{"type":"text","text":"Looking now."},`+
-			`{"type":"tool_use","id":"toolu_1","name":"Read","input":{"path":"main.go"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[`+
-			`{"type":"tool_result","tool_use_id":"toolu_1","content":"package main"}]}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Found it."}]}}`,
-	)
-
-	all, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	events := conversationEvents(all)
-
-	wantTypes := []sessions.EventType{
-		sessions.EventMessage,    // user prompt
-		sessions.EventMessage,    // assistant text
-		sessions.EventToolCall,   // Read
-		sessions.EventToolResult, // its result
-		sessions.EventMessage,    // assistant answer
-	}
-	if len(events) != len(wantTypes) {
-		t.Fatalf("got %d events, want %d: %+v", len(events), len(wantTypes), events)
-	}
-	for i, want := range wantTypes {
-		if events[i].Type != want {
-			t.Errorf("event %d type = %s, want %s", i, events[i].Type, want)
-		}
-	}
-
-	if got := str(t, events[0], "role"); got != "user" {
-		t.Errorf("first event role = %q, want user", got)
-	}
-	if got := str(t, events[1], "role"); got != "assistant" {
-		t.Errorf("second event role = %q, want assistant", got)
-	}
-	if got := str(t, events[2], "name"); got != "Read" {
-		t.Errorf("tool call name = %q, want Read", got)
-	}
-	// The tool result names only an id; the name has to be carried from the call.
-	if got := str(t, events[3], "name"); got != "Read" {
-		t.Errorf("tool result name = %q, want the call's name carried forward", got)
-	}
-	if got := str(t, events[3], "output"); got != "package main" {
-		t.Errorf("tool result output = %q", got)
-	}
-	// Reasoning is dropped by default.
-	for _, event := range events {
-		if strings.Contains(str(t, event, "content"), "private chain of thought") {
-			t.Error("the other model's reasoning was imported despite IncludeReasoning being off")
-		}
-	}
-}
-
-// TestACallAndItsResultSharePairingID pins the property the TUI depends on to
-// draw a call and its result as one exchange.
-func TestACallAndItsResultSharePairingID(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"toolu_abc","name":"Bash","input":{"cmd":"ls"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_abc","content":"a.go"}]}}`,
-	)
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	events = conversationEvents(events)
-	// The call then its result lead; any activity-summary messages follow.
-	if len(events) < 2 || events[0].Type != sessions.EventToolCall || events[1].Type != sessions.EventToolResult {
-		t.Fatalf("want the call then its result as the first two events; got %+v", events)
-	}
-	call, result := str(t, events[0], "toolCallId"), str(t, events[1], "toolCallId")
-	if call == "" || call != result {
-		t.Errorf("call id %q and result id %q must match and be non-empty", call, result)
-	}
-	if call == "toolu_abc" {
-		t.Errorf("foreign id was persisted instead of an opaque local identity: %q", call)
-	}
-}
-
-func TestDistinctSecretShapedCallIDsRemainDistinctAndPaired(t *testing.T) {
-	first := "sk-ant-api03-" + strings.Repeat("A", 40)
-	second := "sk-ant-api03-" + strings.Repeat("B", 40)
-	path := writeTranscript(t,
-		`{"type":"assistant","message":{"role":"assistant","content":[`+
-			`{"type":"tool_use","id":"`+first+`","name":"Read","input":{"path":"a"}},`+
-			`{"type":"tool_use","id":"`+second+`","name":"Read","input":{"path":"b"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[`+
-			`{"type":"tool_result","tool_use_id":"`+first+`","content":"first-result"},`+
-			`{"type":"tool_result","tool_use_id":"`+second+`","content":"second-result"}]}}`,
-	)
-	events := conversationEvents(mustTranslate(t, path))
-	if len(events) != 4 {
-		t.Fatalf("translated %d source events, want two calls and two results", len(events))
-	}
-	firstCall, secondCall := str(t, events[0], "toolCallId"), str(t, events[1], "toolCallId")
-	firstResult, secondResult := str(t, events[2], "toolCallId"), str(t, events[3], "toolCallId")
-	if firstCall == secondCall || firstCall != firstResult || secondCall != secondResult {
-		t.Fatalf("opaque pairing collapsed or crossed: calls %q/%q results %q/%q", firstCall, secondCall, firstResult, secondResult)
-	}
-	encoded, _ := json.Marshal(events)
-	if strings.Contains(string(encoded), first) || strings.Contains(string(encoded), second) {
-		t.Fatal("foreign secret-shaped identity survived persistence")
-	}
-}
-
-func TestAFailedToolCallKeepsItsErrorStatus(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"Bash","input":{}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","is_error":true,"content":"exit status 1"}]}}`,
-	)
-	events := conversationEvents(mustTranslate(t, path))
-	// The call then its result lead; any activity-summary messages follow.
-	if len(events) < 2 || events[0].Type != sessions.EventToolCall || events[1].Type != sessions.EventToolResult {
-		t.Fatalf("got %d events, want the call then its result", len(events))
-	}
-	if got := str(t, events[1], "status"); got != "error" {
-		t.Errorf("status = %q, want error — a failure that imports as a success "+
-			"tells the next model the work succeeded", got)
-	}
-}
-
-func TestReasoningIsKeptWhenAskedFor(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"thinking","thinking":"weighing options"}]}}`,
-	)
-	if events, _ := translateFamily1At("", path, ReadOptions{}); len(events) != 0 {
-		t.Errorf("got %d events by default, want reasoning dropped", len(events))
-	}
-	events, _ := translateFamily1At("", path, ReadOptions{IncludeReasoning: true})
-	if len(events) != 1 || !strings.Contains(str(t, events[0], "content"), "weighing options") {
-		t.Errorf("IncludeReasoning did not keep the reasoning block: %+v", events)
-	}
-}
-
-// TestSecretsInAForeignTranscriptAreRedacted is the second load-bearing
-// security test. These transcripts are another program's logs; whatever that
-// program echoed into them is untrusted input the moment Zero copies it into
-// its own event log.
-func TestSecretsInAForeignTranscriptAreRedacted(t *testing.T) {
-	const leaked = "sk-ant-api03-AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLL"
-	path := writeTranscript(t,
-		`{"type":"user","message":{"role":"user","content":"my key is `+leaked+`"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"Bash","input":{"cmd":"export K=`+leaked+`"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"echoed `+leaked+`"}]}}`,
-	)
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	// The three translated turns lead; the activity summary (now assistant
-	// messages, not EventCompaction — see noteEvent) follows them.
-	convo := conversationEvents(events)
-	if len(convo) < 3 {
-		t.Fatalf("got %d conversation events, want at least the 3 translated turns", len(convo))
-	}
-	if convo[0].Type != sessions.EventMessage || convo[1].Type != sessions.EventToolCall || convo[2].Type != sessions.EventToolResult {
-		t.Fatalf("first three events are not the translated turns: %+v", convo[:3])
-	}
-	// Every field that carries free text must be scrubbed, not just the obvious one.
-	encoded, err := json.Marshal(events)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(encoded), leaked) {
-		t.Errorf("a secret survived translation into the event payloads:\n%s", encoded)
-	}
-	if !strings.Contains(string(encoded), "REDACTED") {
-		t.Errorf("nothing was redacted at all; expected the redactor to fire:\n%s", encoded)
-	}
-}
-
-func TestATruncatedTranscriptStillImportsWhatCameBefore(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"user","message":{"role":"user","content":"first"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"second"}]}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"tor`, // torn
-	)
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatalf("a torn final line must not fail the import: %v", err)
-	}
-	if len(events) != 2 {
-		t.Fatalf("got %d events, want the 2 complete records", len(events))
-	}
-}
-
-func TestCappingKeepsTheTailAndSaysSo(t *testing.T) {
-	lines := []string{}
-	for i := 0; i < 50; i++ {
-		lines = append(lines, `{"type":"user","message":{"role":"user","content":"turn `+itoa(i)+`"}}`)
-	}
-	path := writeTranscript(t, lines...)
-
-	events, err := translateFamily1At("", path, ReadOptions{MaxEvents: 10})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 10 {
-		t.Fatalf("got %d events, want exactly the 10 requested", len(events))
-	}
-	// The cap must never be silent: an import that looks complete but is not is
-	// how someone concludes the other agent never did the work.
-	if events[0].Type != sessions.EventMessage {
-		t.Errorf("first event = %s, want a note announcing the trim", events[0].Type)
-	}
-	note := str(t, events[0], "content")
-	if !strings.Contains(note, "not imported") {
-		t.Errorf("trim note = %q, want it to say events were dropped", note)
-	}
-	// The count must include the event sacrificed to the note's own slot: 50
-	// events, 10 kept slots, one taken by the note → 41 dropped and 9 shown, not
-	// the 40/9 the off-by-one reported.
-	if !strings.Contains(note, "41 earlier events") {
-		t.Errorf("trim note = %q, want it to report 41 dropped — the note's own slot "+
-			"displaces one more event than len-max", note)
-	}
-	if !strings.Contains(note, "most recent 9 are shown") {
-		t.Errorf("trim note = %q, want it to report 9 shown", note)
-	}
-	// turn 40 is the event whose slot the note took; the tail starts at turn 41.
-	if first := str(t, events[1], "content"); first != "turn 41" {
-		t.Errorf("first kept event = %q, want turn 41 (turn 40 gave its slot to the note)", first)
-	}
-	// And what survives must be the END of the session, not the beginning.
-	last := str(t, events[len(events)-1], "content")
-	if last != "turn 49" {
-		t.Errorf("last kept event = %q, want the final turn — the tail is what a "+
-			"resume needs", last)
-	}
-}
-
-func TestMaxEventsOneKeepsTheFinalSourceEvent(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"user","message":{"role":"user","content":"first"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":"final answer"}}`,
-	)
-	events, err := translateFamily1At("", path, ReadOptions{MaxEvents: 1})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 1 {
-		t.Fatalf("got %d events, want the one requested source event", len(events))
-	}
-	if got := str(t, events[0], "content"); got != "final answer" {
-		t.Fatalf("sole capped event = %q, want final source answer", got)
-	}
-}
-
-func TestCappingCannotLetActivitySummaryEvictSourceTail(t *testing.T) {
-	path := writeTranscript(t,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"Read","input":{"path":"parser.go"}}]}}`,
-		`{"type":"user","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":"package parser"}]}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"final source answer"}]}}`,
-	)
-	events, err := translateFamily1At("", path, ReadOptions{MaxEvents: 2})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 2 {
-		t.Fatalf("got %d capped events, want 2", len(events))
-	}
-	if note := str(t, events[0], "content"); !strings.Contains(note, "not imported") {
-		t.Fatalf("source truncation was silent: got %q", note)
-	}
-	if got := str(t, events[1], "content"); got != "final source answer" {
-		t.Fatalf("source tail was evicted by generated context: got %q", got)
-	}
-}
-
-func TestNoCapKeepsEverything(t *testing.T) {
-	lines := []string{}
-	for i := 0; i < 30; i++ {
-		lines = append(lines, `{"type":"user","message":{"role":"user","content":"turn `+itoa(i)+`"}}`)
-	}
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 30 {
-		t.Errorf("got %d events, want all 30 when MaxEvents is unset", len(events))
-	}
-}
-
-func TestUnsetMaxEventsUsesABoundedDefaultAndDisclosesTheDrop(t *testing.T) {
-	lines := make([]string, 0, defaultImportMaxEvents+5)
-	for i := 0; i < defaultImportMaxEvents+5; i++ {
-		lines = append(lines, `{"type":"user","message":{"role":"user","content":"turn `+itoa(i)+`"}}`)
-	}
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != defaultImportMaxEvents {
-		t.Fatalf("default import returned %d events, want bounded %d", len(events), defaultImportMaxEvents)
-	}
-	if note := str(t, events[0], "content"); !strings.Contains(note, "not imported") {
-		t.Fatalf("default event cap silently dropped history: %q", note)
-	}
-	if last := str(t, events[len(events)-1], "content"); last != "turn "+itoa(defaultImportMaxEvents+4) {
-		t.Fatalf("default cap lost the newest event: %q", last)
-	}
-}
-
-func TestExplicitMaxEventsAboveTheDefaultIsHonoured(t *testing.T) {
-	want := defaultImportMaxEvents + 5
-	lines := make([]string, 0, want)
-	for i := 0; i < want; i++ {
-		lines = append(lines, `{"type":"user","message":{"role":"user","content":"turn `+itoa(i)+`"}}`)
-	}
-	events, err := translateFamily1At("", writeTranscript(t, lines...), ReadOptions{MaxEvents: want})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != want {
-		t.Fatalf("explicit cap returned %d events, want all %d requested events", len(events), want)
-	}
-}
-
-func TestCapDoesNotKeepAToolResultAfterDroppingItsCall(t *testing.T) {
-	identities := &importCallIdentities{}
-	events := []sessions.AppendEventInput{
-		messageEvent("user", "old context"),
-		toolCallEvent(identities, "Read", "foreign-1", `{}`),
-		messageEvent("assistant", "finished"),
-		toolResultEvent(identities, "Read", "foreign-1", "ok", "done"),
-	}
-	capped := capEvents(events, 3)
-	for _, event := range capped {
-		if event.Type == sessions.EventToolResult {
-			t.Fatal("cap retained a tool result after its matching call was displaced by the omission note")
-		}
-	}
-	if got := str(t, capped[len(capped)-1], "content"); got != "finished" {
-		t.Fatalf("cap lost final answer while removing orphan result: %q", got)
-	}
-}
-
-func TestReadRejectsAnUnknownSession(t *testing.T) {
-	adapter := ClaudeCode(testEnv(t.TempDir(), nil))
-	if _, err := adapter.Read(ForeignSession{Agent: adapter.Name(), ID: "nope", Path: "nope.jsonl"}, ReadOptions{}); err == nil {
-		t.Error("Read of an unknown id returned no error — the caller named a " +
-			"specific session and an empty result would misrepresent it")
-	}
-}
-
-func mustTranslate(t *testing.T, path string) []sessions.AppendEventInput {
-	t.Helper()
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return events
-}
-
-// ARGUMENTS ARE SANITIZED AS VALUES, NOT AS BYTES. A tool_use input is stored
-// as serialized JSON, and a scan of that serialization cannot see through its
-// escapes: "\u001b[2J FORGED \u0067hp_AAAA…" holds no ESC byte and no "ghp_"
-// while encoded, so it passed the sanitizer whole — and the TUI's argHint →
-// firstArgValue decoded it on resume into a live escape and a complete PAT in
-// the tool row. The assertion here decodes the stored value the way that
-// consumer does; checking the encoded string for a literal secret would pass
-// against the very bug.
-func TestToolArgumentsAreSanitizedAfterDecoding(t *testing.T) {
-	pat := "ghp_" + strings.Repeat("A", 36)
-	forged := `\u001b[2J FORGED \u0067hp_` + strings.Repeat("A", 36)
-	path := writeTranscript(t,
-		`{"type":"user","cwd":"/w","sessionId":"s","message":{"role":"user","content":"go"}}`,
-		`{"type":"assistant","message":{"role":"assistant","content":[`+
-			`{"type":"tool_use","id":"t1","name":"Read","input":{"path":"`+forged+`","opts":{"token":"`+forged+`"},"list":["ok","`+forged+`"]}},`+
-			`{"type":"tool_use","id":"t2","name":"Read","input":{"path":"parser.go","count":3,"flag":true}}]}}`,
-	)
-	events, err := translateFamily1At("", path, ReadOptions{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var calls []sessions.AppendEventInput
-	for _, event := range events {
-		if event.Type == sessions.EventToolCall {
-			calls = append(calls, event)
-		}
-	}
-	if len(calls) != 2 {
-		t.Fatalf("tool calls = %d, want 2", len(calls))
-	}
-	decode := func(event sessions.AppendEventInput) map[string]any {
-		raw := str(t, event, "arguments")
-		if !json.Valid([]byte(raw)) {
-			t.Fatalf("stored arguments are not valid JSON: %q", raw)
-		}
-		var args map[string]any
-		if err := json.Unmarshal([]byte(raw), &args); err != nil {
-			t.Fatal(err)
-		}
-		return args
-	}
-	hostile := decode(calls[0])
-	leaves := []string{hostile["path"].(string), hostile["list"].([]any)[1].(string)}
-	for i, leaf := range leaves {
-		if strings.Contains(leaf, "\x1b") {
-			t.Errorf("decoded leaf %d still carries ESC: %q", i, leaf)
-		}
-		if strings.Contains(leaf, pat) {
-			t.Errorf("decoded leaf %d still carries the PAT: %q", i, leaf)
-		}
-		if !strings.Contains(leaf, "FORGED") {
-			t.Errorf("decoded leaf %d lost its ordinary text: %q", i, leaf)
-		}
-	}
-	if token := hostile["opts"].(map[string]any)["token"]; token != "[REDACTED]" {
-		t.Errorf("sensitive-key value was not redacted as a complete credential: %#v", token)
-	}
-	if hostile["list"].([]any)[0] != "ok" {
-		t.Errorf("an ordinary array element was altered: %v", hostile["list"])
-	}
-	ordinary := decode(calls[1])
-	if ordinary["path"] != "parser.go" || ordinary["count"] != float64(3) || ordinary["flag"] != true {
-		t.Errorf("ordinary arguments did not survive: %v", ordinary)
-	}
-
-	// The constructor is the one chokepoint both adapters use. Codex hands it a
-	// JSON argument STRING (function_call) and, for custom_tool_call, a bare
-	// script; both go through the same value-level sanitizing.
-	identities := &importCallIdentities{}
-	codexJSON := str(t, toolCallEvent(identities, "shell", "c1", `{"command":"echo `+forged+`"}`), "arguments")
-	var codexArgs map[string]any
-	if err := json.Unmarshal([]byte(codexJSON), &codexArgs); err != nil {
-		t.Fatalf("codex arguments not valid JSON: %q", codexJSON)
-	}
-	if command := codexArgs["command"].(string); strings.Contains(command, "\x1b") || strings.Contains(command, pat) {
-		t.Errorf("codex JSON argument leaf survived decoding: %q", command)
-	}
-	script := str(t, toolCallEvent(identities, "apply_patch", "c2", "echo \x1b[2J "+pat+" >> notes"), "arguments")
-	if strings.Contains(script, "\x1b") || strings.Contains(script, pat) || !strings.Contains(script, ">> notes") {
-		t.Errorf("free-form script arguments were not sanitized as text: %q", script)
-	}
-}
-
-func TestStructuredToolArgumentsPreserveObjectAwareRedactionThroughStorage(t *testing.T) {
-	opaque := "opaque-secret-review-123"
-	credentialKey := "ghp_" + strings.Repeat("A", 36)
-	escapedCredential := "ghp_" + strings.Repeat("B", 36)
-	arguments, err := json.Marshal(map[string]any{
-		"password": opaque,
-		"nested": []any{map[string]any{
-			credentialKey:       "ordinary value",
-			"escapedCredential": escapedCredential,
-			"path":              "/work/main.go",
-			"command":           "go test ./...",
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	arguments = []byte(strings.Replace(
-		string(arguments),
-		`"`+credentialKey+`"`,
-		`"\u0067`+strings.TrimPrefix(credentialKey, "g")+`"`,
-		1,
-	))
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(sessions.CreateInput{SessionID: "structured_arguments"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := store.AppendEvent(session.SessionID, toolCallEvent(&importCallIdentities{}, "shell", "foreign-call", string(arguments))); err != nil {
-		t.Fatal(err)
-	}
-	events, err := store.ReadEvents(session.SessionID)
-	if err != nil || len(events) != 1 {
-		t.Fatalf("read stored event: len=%d err=%v", len(events), err)
-	}
-	var payload map[string]any
-	if err := json.Unmarshal(events[0].Payload, &payload); err != nil {
-		t.Fatal(err)
-	}
-	storedArguments, _ := payload["arguments"].(string)
-	var decoded map[string]any
-	if err := json.Unmarshal([]byte(storedArguments), &decoded); err != nil {
-		t.Fatalf("stored arguments are not valid JSON: %v: %q", err, storedArguments)
-	}
-	encoded, _ := json.Marshal(decoded)
-	for _, secret := range []string{opaque, credentialKey, escapedCredential} {
-		if strings.Contains(string(encoded), secret) {
-			t.Fatalf("stored decoded arguments retained secret %q: %s", secret, encoded)
-		}
-	}
-	nested := decoded["nested"].([]any)[0].(map[string]any)
-	if nested["path"] != "/work/main.go" || nested["command"] != "go test ./..." {
-		t.Fatalf("ordinary schema values were not preserved: %#v", nested)
-	}
-}
@@ -1,110 +0,0 @@
-// Package agentsessions reads the session transcripts other coding agents
-// (Claude Code, Codex, Factory Droid, Pi, …) leave on the local disk and
-// translates them into Zero session events, so work started elsewhere can be
-// continued in Zero.
-//
-// Three rules hold for every adapter in this package, and the tests enforce
-// them rather than trusting the code to be careful:
-//
-//  1. READ ONLY. Nothing here writes to, moves, or locks another agent's store.
-//
-//  2. PATH-EXACT, NEVER A WALK. Every one of these agents keeps live
-//     credentials in the same directory tree as its transcripts —
-//     ~/.codex/auth.json, ~/.grok/auth.json, ~/.factory/auth.v2.key, and
-//     most pointedly ~/.pi/agent/auth.json, which is the sibling of
-//     ~/.pi/agent/sessions/. A filepath.WalkDir rooted one level too high
-//     reads a live OAuth token. So discovery uses fixed-depth globs against a
-//     specific extension and nothing else. This is repo invariant #2
-//     (allow-lists, not deny-lists) applied to filesystem input.
-//
-//  3. IMPORTED TEXT IS UNTRUSTED (invariant #8). Every string crossing into
-//     Zero's event log goes through internal/redaction first (invariant #6:
-//     redaction is a chokepoint, not a sprinkle) — a foreign transcript can
-//     easily contain a key the other agent echoed into its own log.
-package agentsessions
-
-import (
-	"os"
-	"time"
-
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// ForeignSession is the index entry for one session belonging to another agent.
-// It is built during discovery from a deliberately cheap read — enough to list
-// and choose, never the whole transcript. A single Claude Code transcript on a
-// working machine can exceed 70 MB, so anything that requires parsing the full
-// file belongs in Read, not here.
-type ForeignSession struct {
-	// Agent is the adapter name ("claude-code", "codex", …).
-	Agent string
-	// ID identifies the session within that agent. It is the adapter's own
-	// identifier, not a path, so it survives being printed and pasted back.
-	ID string
-	// Title is a short human label, usually derived from the first user prompt.
-	Title string
-	// Cwd is the working directory the session ran in, taken from the record
-	// body rather than from the directory name. See paths.go: the slugged
-	// directory name these agents use is lossy and cannot be reversed.
-	Cwd string
-	// GitBranch is the branch recorded at the time, when the agent stores one.
-	GitBranch string
-	// ModelID is the model the other agent was using, when recorded.
-	ModelID string
-	// StartedAt and UpdatedAt bound the session in time. UpdatedAt falls back to
-	// the file's modification time, which avoids reading the tail of a large
-	// transcript just to learn when it stopped.
-	StartedAt time.Time
-	UpdatedAt time.Time
-	// Path is the file or directory backing the session, shown for
-	// troubleshooting and used by Read to reopen it.
-	Path string
-	// source binds this index row to the exact regular file observed during
-	// discovery. It is intentionally unexported: paths and foreign IDs are
-	// display/provenance, not authority for opening an arbitrary file.
-	source sourceSnapshot
-}
-
-type sourceSnapshot struct {
-	info    os.FileInfo
-	size    int64
-	modTime time.Time
-}
-
-// ReadOptions tunes a full read. The zero value is the intended default:
-// reasoning dropped, with a defensive event cap.
-type ReadOptions struct {
-	// MaxEvents caps how many events a session contributes, keeping the LAST
-	// MaxEvents. The tail is what matters for continuing work — the most recent
-	// exchanges are the ones a resume needs. Zero uses the package's bounded
-	// default; a positive value is used as the explicit cap.
-	MaxEvents int
-	// Cwd is the session's working directory, used only to shorten absolute
-	// paths in the activity summary. Empty just means paths stay absolute.
-	Cwd string
-	// IncludeReasoning keeps the other model's thinking/reasoning blocks. Off by
-	// default: they are provider-private, frequently larger than the visible
-	// conversation, and of no use to a different model that will not be
-	// continuing that chain of thought.
-	IncludeReasoning bool
-}
-
-// Adapter is one foreign agent's on-disk session store.
-//
-// Every adapter is independently skippable. A store that is absent, unreadable,
-// or has quietly changed shape must yield zero sessions rather than failing the
-// command — these are undocumented formats belonging to other products, and one
-// vendor shipping a new layout must not break discovery for the other six.
-// That fail-soft rule applies to DISCOVERY only; Read reports its errors, since
-// by then the user has named a specific session and silence would be a lie.
-type Adapter interface {
-	// Name is the stable identifier used in "<agent>:<id>" and in output.
-	Name() string
-	// Discover returns the sessions this adapter believes belong to cwd. An
-	// empty cwd means "every session this adapter can see".
-	Discover(cwd string) ([]ForeignSession, error)
-	// Read translates the exact session returned by Discover into Zero events.
-	// Implementations verify the source identity before and after reading so
-	// metadata and content cannot come from independently-resolved files.
-	Read(source ForeignSession, options ReadOptions) ([]sessions.AppendEventInput, error)
-}
@@ -4,6 +4,7 @@ package background

 import (
 	"fmt"
+	"os"
 	"os/exec"

 	"github.com/Gitlawb/zero/internal/execution"
@@ -46,7 +47,13 @@ func terminateOwnedProcess(cmd *exec.Cmd) (bool, error) {
 		terminateErr = terminateProcessForTest(cmd.Process.Pid)
 	})
 	if err != nil {
-		return false, fmt.Errorf("pin process %d for termination: %w", cmd.Process.Pid, err)
+		// WithHandle refuses only a process that has already been waited or
+		// released, so it has finished. Say so in the form exec.Cmd understands:
+		// a Cancel error wrapping os.ErrProcessDone is "nothing to cancel", where
+		// the unexported "already released" error it would otherwise carry made
+		// Wait report a spurious cancel failure. A dead root has no tree left to
+		// find either way.
+		return true, fmt.Errorf("pin process %d for termination: %w: %w", cmd.Process.Pid, os.ErrProcessDone, err)
 	}
 	return alreadyExited, terminateErr
 }
@@ -73,6 +73,29 @@ func TerminateCommand(cmd *exec.Cmd) error {
 	return nil
 }

+// TerminateCommandGroup stops a started command's process group on POSIX, or its
+// process tree on Windows, WITHOUT reaping it.
+//
+// It is TerminateCommand without the Wait, for a caller whose Wait already runs
+// somewhere else: a worker pool waiting on the command in its own goroutine, or
+// the command's own Cancel hook, which exec.Cmd invokes while its Wait is in
+// progress. TerminateCommand would be a second Wait there. Both used to pass
+// cmd.Process.Pid to TerminateProcess, which rediscovers the group at signal time
+// with Getpgid, and once the leader has exited that lookup fails, so only the dead
+// leader was signalled and its descendants kept running. When cmd was configured
+// by ConfigureChildProcessGroup the group now comes from that launch-time
+// configuration instead. On Windows it is the tree kill TerminateProcess performs,
+// with the process handle pinned while it runs so the PID cannot be recycled
+// underneath it; once the command has been waited that pin fails with an error
+// wrapping os.ErrProcessDone.
+func TerminateCommandGroup(cmd *exec.Cmd) error {
+	if cmd == nil || cmd.Process == nil {
+		return nil
+	}
+	_, err := terminateOwnedProcess(cmd)
+	return err
+}
+
 // classifyWaitError treats a non-zero exit status as success: a process being
 // terminated is expected to report one (or a signal), so the only interesting
 // failure is Wait itself not working.
@@ -0,0 +1,71 @@
+package background
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// TerminateCommandGroup LEAVES THE WAIT TO ITS CALLER. Its callers already have a
+// Wait running or about to run: the daemon pool waits on its workers, and
+// exec.Cmd calls the Cancel hook from inside Wait. Reaping here, the way
+// TerminateCommand does, would make their Wait fail with "Wait was already
+// called" instead of reporting how the command ended.
+func TestTerminateCommandGroupLeavesTheWaitToTheCaller(t *testing.T) {
+	cmd := exec.Command("sleep", "30")
+	if runtime.GOOS == "windows" {
+		cmd = exec.Command("powershell.exe", "-NoProfile", "-NonInteractive", "-Command", "Start-Sleep -Seconds 30")
+	}
+	ConfigureChildProcessGroup(cmd)
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+	if err := TerminateCommandGroup(cmd); err != nil {
+		_ = cmd.Process.Kill()
+		_ = cmd.Wait()
+		t.Fatalf("TerminateCommandGroup: %v", err)
+	}
+
+	waited := make(chan error, 1)
+	go func() { waited <- cmd.Wait() }()
+	select {
+	case err := <-waited:
+		var exitErr *exec.ExitError
+		if err != nil && !errors.As(err, &exitErr) {
+			t.Fatalf("the caller's own Wait failed after TerminateCommandGroup: %v", err)
+		}
+	case <-time.After(10 * time.Second):
+		_ = cmd.Process.Kill()
+		t.Fatal("the command was still running 10s after TerminateCommandGroup")
+	}
+}
+
+// A command that was never started, or a nil one, is nothing to stop.
+func TestTerminateCommandGroupWithNoProcessIsANoOp(t *testing.T) {
+	if err := TerminateCommandGroup(nil); err != nil {
+		t.Fatalf("nil command: %v", err)
+	}
+	if err := TerminateCommandGroup(exec.Command("sleep", "1")); err != nil {
+		t.Fatalf("unstarted command: %v", err)
+	}
+}
+
+// After the caller has waited, Windows cannot pin the process any more. The error
+// must still read as "already finished", which is what exec.Cmd's Cancel contract
+// and the pool both treat as nothing wrong.
+func TestTerminateCommandGroupAfterWaitReportsProcessDone(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("POSIX signals the group, which is simply gone after the wait")
+	}
+	cmd := exec.Command("cmd.exe", "/c", "exit", "0")
+	ConfigureChildProcessGroup(cmd)
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if err := TerminateCommandGroup(cmd); err != nil && !errors.Is(err, os.ErrProcessDone) {
+		t.Fatalf("after Wait the error is %v, want nil or one wrapping os.ErrProcessDone", err)
+	}
+}
@@ -695,7 +695,7 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 	// Refresh the models.dev pricing/limits cache in the background when stale;
 	// the overlay is read at registry construction from the cache file, so this
 	// benefits the next run and never blocks or fails this one.
-	go func() { _ = modelregistry.RefreshModelsDevCache(context.Background()) }()
+	modelregistry.StartModelsDevRefresh()

 	workspaceRoot, err := deps.getwd()
 	if err != nil {
@@ -727,7 +727,13 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 			resolved.Provider = usable
 			resolved.ActiveProvider = usable.Name
 		} else {
-			resolved = config.ResolvedConfig{}
+			// Fresh-onboarding reset, but the user's notification preference is
+			// NOT config-to-redo: clearing it here would surface as an empty
+			// Options.Notify, and the TUI's unconfigured default (both/unfocused)
+			// would then resurrect alerts a user explicitly turned off while the
+			// setup wizard runs (maintainer review, PR #1001). Carry the stored
+			// block through; other wizard-visible state starts clean as before.
+			resolved = config.ResolvedConfig{Notify: resolved.Notify}
 			forceSetup = true
 		}
 	}
@@ -959,7 +965,12 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 	// notice when project hooks/plugins were dropped for an untrusted workspace.
 	hookDispatcher, hookSkip := newHookDispatcherWithExtra(workspaceRoot, pluginActivation.hooks, trustRoot, executionRunner)
 	emitTrustNotice(stderr, hookSkip, pluginActivation.trustSkip, mcpSkip)
+	// From the engine the session's commands run through, so the notice
+	// describes the sandbox they actually get.
+	startupNotices := []string{sandboxEngine.DegradedNotice()}
+	modelRPM := zeroruntime.NewModelRPMLimiter(resolved.ModelRPM)
 	return deps.runTUI(context.Background(), tui.Options{
+		ModelRPM:             modelRPM,
 		Cwd:                  workspaceRoot,
 		Version:              version,
 		Theme:                theme,
@@ -982,7 +993,7 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 			if provider == nil {
 				return nil
 			}
-			if optimized, ok := providers.OptimizedTurnSessions(profile, provider, providers.Options{}); ok {
+			if optimized, ok := providers.ConfiguredTurnSessions(profile, provider, providers.Options{ModelRPM: modelRPM}); ok {
 				return optimized
 			}
 			return providers.DefaultTurnSessions(profile, provider, providers.Options{})
@@ -1046,6 +1057,7 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 		PermissionMode:            permissionMode,
 		Notify:                    resolved.Notify,
 		KeyBindings:               resolved.KeyBindings,
+		StartupNotices:            startupNotices,
 		STT:                       resolved.STT,
 		BuildDictationTranscriber: newDictationTranscriberFactory(resolved, userConfigPath, sttServerManager),
 		ShutdownDictationServer:   sttServerManager.Shutdown,
@@ -343,8 +343,10 @@ func TestRunNoArgsFallsBackToUsableProviderWhenNoneMarkedActive(t *testing.T) {
 			// config.json has providers configured but none marked active (e.g. a
 			// blank/stale activeProvider field) — Resolve returns the successfully
 			// normalized providers list alongside ErrNoActiveProvider.
-			return config.ResolvedConfig{Providers: []config.ProviderProfile{usable}},
-				fmt.Errorf("%w: active provider %q not found", config.ErrNoActiveProvider, "")
+			return config.ResolvedConfig{
+				Providers: []config.ProviderProfile{usable},
+				ModelRPM:  map[string]int{"gpt-test": 1},
+			}, fmt.Errorf("%w: active provider %q not found", config.ErrNoActiveProvider, "")
 		},
 		newProvider: func(profile config.ProviderProfile) (zeroruntime.Provider, error) {
 			providerProfile = profile
@@ -374,6 +376,77 @@ func TestRunNoArgsFallsBackToUsableProviderWhenNoneMarkedActive(t *testing.T) {
 	}
 	if providerProfile.Name != "work" {
 		t.Fatalf("provider used = %q, want fallback to the usable saved provider %q", providerProfile.Name, "work")
+
+	}
+	if launchedOptions.ModelRPM == nil {
+		t.Fatal("ModelRPM = nil, want limiter preserved through provider fallback")
+	}
+}
+
+// Maintainer regression (PR #1001): a stored explicit notify opt-out must
+// survive the provider-recovery startup path. With a stale activeProvider and
+// another usable saved provider, Resolve returns the partial config alongside
+// ErrNoActiveProvider and the recovery branch forwards it — dropping the
+// notify policy there would surface an empty Options.Notify, and the TUI's
+// unconfigured default (both) would resurrect alerts the user explicitly
+// turned off. The same recovery branch that clears the resolved config for
+// the setup wizard carries the stored notify block through.
+func TestRunNoArgsPreservesNotifyOptOutThroughProviderRecovery(t *testing.T) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cwd := t.TempDir()
+	setCLIUserConfigRoot(t)
+	userConfigPath := filepath.Join(t.TempDir(), "zero", "config.json")
+	var launchedOptions tui.Options
+	launched := false
+
+	usable := config.ProviderProfile{
+		Name:         "work",
+		ProviderKind: config.ProviderKindOpenAI,
+		BaseURL:      config.OpenAIBaseURL,
+		APIKey:       "sk-test",
+		Model:        "gpt-test",
+	}
+
+	exitCode := runWithDeps([]string{}, &stdout, &stderr, appDeps{
+		getwd: func() (string, error) {
+			return cwd, nil
+		},
+		resolveConfig: func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+			// Stale activeProvider + usable saved provider, and the user's
+			// config.json explicitly opts out of notifications. The fixed
+			// resolver carries the parsed notify block through the error path.
+			return config.ResolvedConfig{
+				Providers: []config.ProviderProfile{usable},
+				Notify:    config.NotifyConfig{Mode: "off", FocusMode: "always"},
+			}, fmt.Errorf("%w: active provider %q not found", config.ErrNoActiveProvider, "ghost")
+		},
+		newProvider: func(profile config.ProviderProfile) (zeroruntime.Provider, error) {
+			return &cliFakeProvider{}, nil
+		},
+		userConfigPath: func() (string, error) {
+			return userConfigPath, nil
+		},
+		registerMCPTools: func(context.Context, *tools.Registry, config.MCPConfig, mcp.RegisterOptions) (mcpToolRuntime, error) {
+			return noopMCPRuntime{}, nil
+		},
+		runTUI: func(ctx context.Context, options tui.Options) int {
+			launched = true
+			launchedOptions = options
+			return 0
+		},
+	})
+
+	if exitCode != 0 {
+		t.Fatalf("exit code = %d, want 0, stderr=%q", exitCode, stderr.String())
+	}
+	if !launched {
+		t.Fatal("TUI was not launched")
+	}
+	// The explicit opt-out reaches the TUI intact — NOT the both/unfocused
+	// unconfigured default.
+	if launchedOptions.Notify.Mode != "off" || launchedOptions.Notify.FocusMode != "always" {
+		t.Fatalf("Options.Notify = %+v, want the stored off/always opt-out preserved through recovery", launchedOptions.Notify)
 	}
 }

@@ -26,6 +26,30 @@ type modelSummary = zerocommands.ModelSnapshot
 type providerCatalogSummary = zerocommands.ProviderCatalogSnapshot

 func runConfig(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int {
+	// The first non-flag argument is a subcommand. With no positional argument
+	// (or only flag arguments), the read-only summary path runs — this keeps
+	// `zero config` and `zero config --json` working unchanged.
+	command := "summary"
+	rest := args
+	if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
+		command = strings.ToLower(strings.TrimSpace(args[0]))
+		rest = args[1:]
+	}
+	switch command {
+	case "summary":
+		return runConfigSummary(rest, stdout, stderr, deps)
+	case "notify":
+		return runConfigNotify(rest, stdout, stderr, deps)
+	case "help":
+		if err := writeConfigHelp(stdout); err != nil {
+			return exitCrash
+		}
+		return exitSuccess
+	}
+	return writeExecUsageError(stderr, fmt.Sprintf("unknown config command %q", command))
+}
+
+func runConfigSummary(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int {
 	options, help, err := parseCommandCenterArgs(args, false, false)
 	if err != nil {
 		return writeExecUsageError(stderr, err.Error())
@@ -466,8 +490,12 @@ func formatProviderCatalogValue(value string, fallback string) string {
 func writeConfigHelp(w io.Writer) error {
 	_, err := fmt.Fprint(w, `Usage:
  zero config [flags]
+  zero config notify [flags]

-Inspects resolved Go configuration without printing secrets.
+Inspects resolved Go configuration without printing secrets. The notify
+subcommand reads or updates the stored global notification preference,
+which controls both the completion and needs-input alerts —
+run "zero config notify --help" for details.

 Flags:
      --json      Print JSON summary
@@ -40,7 +40,11 @@ var completionRoot = completionNode{
 		},
 		{names: []string{"daemon"}, children: leafNodes("start", "stop", "status", "run", "attach", "serve-remote", "link")},
 		{names: []string{"setup"}},
-		{names: []string{"config"}},
+		{names: []string{"config"}, flags: []string{"-h", "--help", "--json"}, children: []completionNode{
+			{names: []string{"notify"}, flags: []string{
+				"-h", "--help", "--mode", "--focus", "--reset", "--json",
+			}},
+		}},
 		{names: []string{"models"}, children: []completionNode{{names: []string{"list", "ls"}}}},
 		{names: []string{"providers"}, children: []completionNode{
 			{names: []string{"current"}}, {names: []string{"list"}}, {names: []string{"catalog"}},
@@ -165,6 +165,11 @@ func TestCompletionTreeCoversAliasesNestingAndCommonFlags(t *testing.T) {
 	assertCandidates(t, byPath["completions"], "bash", "zsh", "fish", "powershell", "elvish")
 	assertCandidates(t, byPath["plugins"], "list", "add", "info", "remove", "rm")
 	assertCandidates(t, byPath["plugin"], "list", "add", "info", "remove", "rm")
+	// `config` gained the notify subcommand; the completion tree must expose
+	// it (and its flags) so shell completion cannot go stale for new CLI
+	// surfaces (maintainer review, PR #1001).
+	assertCandidates(t, byPath["config"], "notify", "--json", "--help")
+	assertCandidates(t, byPath["config notify"], "--mode", "--focus", "--reset", "--json", "--help")
 }

 func assertCandidates(t *testing.T, got []string, wants ...string) {
@@ -0,0 +1,177 @@
+package cli
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/Gitlawb/zero/internal/config"
+)
+
+// runConfigNotify implements `zero config notify`: with no flags it prints the
+// stored mode/focusMode; --mode/--focus update them via the same
+// config.UpdateNotify writer the TUI /notify command uses, so all surfaces stay
+// in lockstep; --reset blanks both fields so the TUI's effective default
+// applies again (an unconfigured headless run stays silent).
+//
+// The command manages a user preference, so it talks ONLY to the user's own
+// config file (config.UserNotify / config.UpdateNotify) and never runs the full
+// config resolution: resolving providers would fail with ErrNoActiveProvider
+// for a brand-new user, locking them out of setting notifications before they
+// have even configured a provider (CodeRabbit review, PR #1001). The display
+// therefore reports the USER'S stored values — a project config that
+// overrides notify for one repo is not shown here, by the same logic the
+// maintainer applied to the write path.
+func runConfigNotify(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int {
+	options, help, err := parseConfigNotifyArgs(args)
+	if err != nil {
+		return writeExecUsageError(stderr, err.Error())
+	}
+	if help {
+		if err := writeConfigNotifyHelp(stdout); err != nil {
+			return exitCrash
+		}
+		return exitSuccess
+	}
+
+	configPath, err := deps.userConfigPath()
+	if err != nil {
+		return writeAppError(stderr, err.Error(), exitCrash)
+	}
+
+	if options.mode != "" || options.focus != "" || options.reset {
+		// One serialized read-merge-write transaction: the lock covers
+		// reading the stored block, applying only the explicit fields, and
+		// replacing the file, so two concurrent partial updates (e.g.
+		// --mode off and --focus always from two terminals) cannot lose
+		// each other's change (maintainer review, PR #1001). Omitted
+		// fields preserve the values stored in the user's OWN file — blank
+		// stays blank; --reset is the only path that clears both fields.
+		_, err := config.UpdateNotify(configPath, func(current config.NotifyConfig) config.NotifyConfig {
+			if options.reset {
+				return config.NotifyConfig{}
+			}
+			if options.mode != "" {
+				current.Mode = options.mode
+			}
+			if options.focus != "" {
+				current.FocusMode = options.focus
+			}
+			return current
+		})
+		if err != nil {
+			return writeAppError(stderr, err.Error(), exitUsage)
+		}
+	}
+
+	// Report the stored values (blank renders as "(default)").
+	current, err := config.UserNotify(configPath)
+	if err != nil {
+		return writeAppError(stderr, err.Error(), exitUsage)
+	}
+	if options.json {
+		if err := writePrettyJSON(stdout, map[string]any{
+			"mode":      current.Mode,
+			"focusMode": current.FocusMode,
+		}); err != nil {
+			return exitCrash
+		}
+		return exitSuccess
+	}
+	lines := []string{
+		"Notify",
+		"mode:      " + displayCLIValue(current.Mode, "(default)"),
+		"focusMode: " + displayCLIValue(current.FocusMode, "(default)"),
+	}
+	if _, err := fmt.Fprintln(stdout, strings.Join(lines, "\n")); err != nil {
+		return exitCrash
+	}
+	return exitSuccess
+}
+
+type configNotifyOptions struct {
+	mode  string
+	focus string
+	reset bool
+	json  bool
+}
+
+func parseConfigNotifyArgs(args []string) (configNotifyOptions, bool, error) {
+	options := configNotifyOptions{}
+	for index := 0; index < len(args); index++ {
+		arg := args[index]
+		switch {
+		case arg == "-h" || arg == "--help" || arg == "help":
+			return options, true, nil
+		case arg == "--json":
+			options.json = true
+		case arg == "--reset":
+			options.reset = true
+		case arg == "--mode":
+			value, next, err := nextFlagValue(args, index, arg)
+			if err != nil {
+				return options, false, err
+			}
+			options.mode = value
+			index = next
+		case strings.HasPrefix(arg, "--mode="):
+			value, err := requiredInlineFlagValue(arg, "--mode")
+			if err != nil {
+				return options, false, err
+			}
+			options.mode = value
+		case arg == "--focus":
+			value, next, err := nextFlagValue(args, index, arg)
+			if err != nil {
+				return options, false, err
+			}
+			options.focus = value
+			index = next
+		case strings.HasPrefix(arg, "--focus="):
+			value, err := requiredInlineFlagValue(arg, "--focus")
+			if err != nil {
+				return options, false, err
+			}
+			options.focus = value
+		case strings.HasPrefix(arg, "-"):
+			return options, false, execUsageError{fmt.Sprintf("unknown flag %q", arg)}
+		default:
+			return options, false, execUsageError{fmt.Sprintf("unexpected argument %q", arg)}
+		}
+	}
+	return options, false, nil
+}
+
+func writeConfigNotifyHelp(w io.Writer) error {
+	_, err := fmt.Fprint(w, "Usage:\n"+
+		"  zero config notify [flags]\n"+
+		"\n"+
+		"Print or update the stored global notification preference.\n"+
+		"\n"+
+		"The preference controls BOTH notification kinds: the turn-completion\n"+
+		"(\"Zero: ready\") alert and the needs-input alert. mode off silences both;\n"+
+		"the focus mode (unfocused, always, focused) applies to both.\n"+
+		"\n"+
+		"When run with no flag, prints the stored mode and focusMode; a field you\n"+
+		"never set shows as (default) — the TUI alerts with bell + notification,\n"+
+		"firing only when the terminal is unfocused, while an unconfigured\n"+
+		"headless run stays silent. Omitted flags preserve the values stored in\n"+
+		"YOUR config file; --reset clears both so the TUI's effective default\n"+
+		"applies again. If --reset is combined with --mode/--focus, --reset wins\n"+
+		"and the explicit values are ignored.\n"+
+		"\n"+
+		"Examples:\n"+
+		"  zero config notify\n"+
+		"  zero config notify --json\n"+
+		"  zero config notify --mode both --focus unfocused\n"+
+		"  zero config notify --mode off\n"+
+		"  zero config notify --reset         # clear the stored preference\n"+
+		"\n"+
+		"Flags:\n"+
+		"      --mode <off|bell|notify|both>       Notification mechanism (both kinds)\n"+
+		"      --focus <unfocused|always|focused>  When the alert fires\n"+
+		"      --reset                             Clear the stored preference so the TUI effective default applies\n"+
+		"      --json                              Machine-readable output\n"+
+		"  -h, --help                              Show this help\n")
+	return err
+}
@@ -0,0 +1,481 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Gitlawb/zero/internal/config"
+)
+
+// `zero config notify` with no flag and a fresh config: nothing is configured,
+// the resolver leaves the fields blank (defaults deliberately live in the TUI,
+// not the resolver — maintainer review, PR #1001), and the command reports
+// "(default)" for both.
+func TestRunConfigNotifyPrintsUnconfiguredAsDefault(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	// A valid openai profile so the resolver does not error with
+	// ErrNoActiveProvider. The notify defaults are applied independently of
+	// the provider resolution path.
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}]
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	if !strings.Contains(stdout.String(), "mode:      (default)") {
+		t.Errorf("stdout should show unconfigured mode as (default), got: %s", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), "focusMode: (default)") {
+		t.Errorf("stdout should show unconfigured focus as (default), got: %s", stdout.String())
+	}
+}
+
+// `zero config notify --json` emits a machine-readable payload. A configured
+// pair round-trips; unconfigured fields are empty strings (never defaults
+// filled in), so scripts can distinguish "user chose" from "default".
+func TestRunConfigNotifyPrintsJSON(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}],
+		"notify": {"mode": "bell", "focusMode": "always"}
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--json"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	var payload map[string]any
+	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
+		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
+	}
+	if payload["mode"] != "bell" {
+		t.Errorf("mode = %v, want bell", payload["mode"])
+	}
+	if payload["focusMode"] != "always" {
+		t.Errorf("focusMode = %v, want always", payload["focusMode"])
+	}
+}
+
+// The unconfigured JSON shape: fields are empty strings, never defaults
+// filled in, so scripts can tell "user chose" from "default".
+func TestRunConfigNotifyPrintsJSONUnconfigured(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}]
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--json"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	var payload map[string]any
+	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
+		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
+	}
+	if payload["mode"] != "" {
+		t.Errorf("mode = %v, want empty (unconfigured)", payload["mode"])
+	}
+	if payload["focusMode"] != "" {
+		t.Errorf("focusMode = %v, want empty (unconfigured)", payload["focusMode"])
+	}
+}
+
+// `zero config notify --mode off` writes the new value to disk and prints
+// confirmation. The user can read it back by running the command again.
+func TestRunConfigNotifyWritesModeChange(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}],
+		"notify": {"mode": "both", "focusMode": "always"}
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--mode", "off"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "off" {
+		t.Errorf("Notify.Mode = %q, want off", cfg.Notify.Mode)
+	}
+	// A mode-only update must preserve the configured focusMode, not wipe it.
+	if cfg.Notify.FocusMode != "always" {
+		t.Errorf("Notify.FocusMode = %q, want preserved %q", cfg.Notify.FocusMode, "always")
+	}
+	if !strings.Contains(stdout.String(), "mode:      off") {
+		t.Errorf("stdout should confirm the change, got: %s", stdout.String())
+	}
+}
+
+// A focus-only update preserves the configured mode.
+func TestRunConfigNotifyFocusOnlyPreservesMode(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}],
+		"notify": {"mode": "bell", "focusMode": "unfocused"}
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--focus", "always"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "bell" {
+		t.Errorf("Notify.Mode = %q, want preserved %q", cfg.Notify.Mode, "bell")
+	}
+	if cfg.Notify.FocusMode != "always" {
+		t.Errorf("Notify.FocusMode = %q, want always", cfg.Notify.FocusMode)
+	}
+}
+
+// Maintainer regression (PR #1001): a partial update must seed from the USER'S
+// OWN file, never from the resolved view. A project .zero/config.json setting
+// mode=off resolves into the session, but `--focus always` inside that repo
+// must NOT copy the project's off into the user's global config.
+func TestRunConfigNotifyDoesNotCopyProjectNotifyIntoUserConfig(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "user.json")
+	projectPath := filepath.Join(t.TempDir(), "project.json")
+	if err := os.WriteFile(configPath, []byte(`{"activeProvider": "openai"}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(projectPath, []byte(`{"notify": {"mode": "off"}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	// Resolve EXACTLY the way production does: user config + project config
+	// merged, so resolved.Notify.Mode is the project's "off".
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{
+			UserConfigPath:    configPath,
+			ProjectConfigPath: projectPath,
+			Env:               map[string]string{"OPENAI_API_KEY": "sk-test"},
+		})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--focus", "always"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	// The user's file must keep an unspecified mode unspecified — the
+	// project's "off" stays in the project file where it belongs.
+	if cfg.Notify.Mode != "" {
+		t.Errorf("user Notify.Mode = %q, want blank (project's off must not leak into the user file)", cfg.Notify.Mode)
+	}
+	if cfg.Notify.FocusMode != "always" {
+		t.Errorf("Notify.FocusMode = %q, want always", cfg.Notify.FocusMode)
+	}
+	// The project file is untouched.
+	project := readFileConfig(t, projectPath)
+	if project.Notify.Mode != "off" {
+		t.Errorf("project Notify.Mode = %q, want untouched off", project.Notify.Mode)
+	}
+}
+
+// Maintainer regression (PR #1001): with a clean config, `--mode off` must not
+// also pin focusMode as an explicit choice — blank means "use the built-in
+// default", and a partial update keeps it that way.
+func TestRunConfigNotifyDoesNotPinDefaultsAsExplicitChoices(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	if err := os.WriteFile(configPath, []byte(`{"activeProvider": "openai"}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--mode", "off"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "off" {
+		t.Errorf("Notify.Mode = %q, want off", cfg.Notify.Mode)
+	}
+	if cfg.Notify.FocusMode != "" {
+		t.Errorf("Notify.FocusMode = %q, want blank (unspecified stays unspecified; the default must not be pinned)", cfg.Notify.FocusMode)
+	}
+}
+
+// `--mode` and `--focus` together update both fields in one call.
+func TestRunConfigNotifyWritesModeAndFocus(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}]
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--mode", "both", "--focus", "unfocused"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "both" || cfg.Notify.FocusMode != "unfocused" {
+		t.Errorf("Notify = %+v, want mode=both focusMode=unfocused", cfg.Notify)
+	}
+}
+
+// `--mode loud` is a usage error. The config must not be mutated.
+func TestRunConfigNotifyRejectsInvalidMode(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}],
+		"notify": {"mode": "off"}
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--mode", "loud"}, &stdout, &stderr, deps)
+	if exitCode == exitSuccess {
+		t.Fatalf("expected failure for invalid mode, got success; stdout=%s", stdout.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "off" {
+		t.Errorf("Notify.Mode = %q, want off (unchanged after failed write)", cfg.Notify.Mode)
+	}
+}
+
+// `--reset` blanks both fields so the TUI's effective default applies again
+// (an unconfigured headless run stays silent). Useful for "go back to the
+// recommended setup" after a custom value.
+func TestRunConfigNotifyResetClearsStoredValues(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	seed := `{
+		"activeProvider": "openai",
+		"providers": [{
+			"name": "openai",
+			"providerKind": "openai",
+			"baseUrl": "https://api.openai.com/v1",
+			"model": "gpt-4.1",
+			"apiKeyEnv": "OPENAI_API_KEY"
+		}],
+		"notify": {"mode": "off", "focusMode": "always"}
+	}`
+	if err := os.WriteFile(configPath, []byte(seed), 0o600); err != nil {
+		t.Fatalf("seed config: %v", err)
+	}
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{"OPENAI_API_KEY": "sk-test"}})
+	}
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify", "--reset"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "" || cfg.Notify.FocusMode != "" {
+		t.Errorf("Notify after reset = %+v, want empty (defaults apply)", cfg.Notify)
+	}
+}
+
+// CodeRabbit regression (PR #1001): the command manages a user preference and
+// must not require provider resolution. A brand-new user with NO provider
+// configured (the resolver would return ErrNoActiveProvider) can still read,
+// set, and reset their notification preference.
+func TestRunConfigNotifyWorksWithoutAnyProviderConfigured(t *testing.T) {
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	if err := os.WriteFile(configPath, []byte(`{}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// resolveConfig fails the way the real resolver does for a fresh user —
+	// the command must never call it, so a panic-free stub is enough to prove
+	// the point; use the failing resolver to catch any regression to the
+	// resolve-first shape.
+	deps := commandCenterDeps(t)
+	deps.userConfigPath = func() (string, error) { return configPath, nil }
+	deps.resolveConfig = func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
+		return config.Resolve(config.ResolveOptions{UserConfigPath: configPath, Env: map[string]string{}})
+	}
+
+	// Read works and shows defaults.
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config", "notify"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("read: exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	if !strings.Contains(stdout.String(), "mode:      (default)") {
+		t.Errorf("read should show (default), got: %s", stdout.String())
+	}
+
+	// Write works.
+	stdout.Reset()
+	exitCode = runWithDeps([]string{"config", "notify", "--mode", "bell", "--focus", "always"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("write: exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg := readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "bell" || cfg.Notify.FocusMode != "always" {
+		t.Fatalf("write: Notify = %+v, want bell/always", cfg.Notify)
+	}
+
+	// JSON read reflects the stored pair.
+	stdout.Reset()
+	exitCode = runWithDeps([]string{"config", "notify", "--json"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("json: exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	var payload map[string]any
+	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
+		t.Fatalf("json output invalid: %v\n%s", err, stdout.String())
+	}
+	if payload["mode"] != "bell" || payload["focusMode"] != "always" {
+		t.Errorf("json = mode %v focus %v, want bell/always", payload["mode"], payload["focusMode"])
+	}
+
+	// Reset works.
+	stdout.Reset()
+	exitCode = runWithDeps([]string{"config", "notify", "--reset"}, &stdout, &stderr, deps)
+	if exitCode != exitSuccess {
+		t.Fatalf("reset: exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	cfg = readFileConfig(t, configPath)
+	if cfg.Notify.Mode != "" || cfg.Notify.FocusMode != "" {
+		t.Errorf("reset: Notify = %+v, want empty", cfg.Notify)
+	}
+}
+
+// `zero config` (no subcommand) still works after the dispatch change.
+func TestRunConfigSummaryStillWorks(t *testing.T) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	exitCode := runWithDeps([]string{"config"}, &stdout, &stderr, commandCenterDeps(t))
+	if exitCode != exitSuccess {
+		t.Fatalf("exit = %d, want %d: %s", exitCode, exitSuccess, stderr.String())
+	}
+	if !strings.Contains(stdout.String(), "Config") {
+		t.Errorf("stdout should show the config summary, got: %s", stdout.String())
+	}
+}
@@ -2,6 +2,10 @@ package cli

 import (
 	"bytes"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -39,3 +43,115 @@ func TestFireJobClaimPreventsDoubleFire(t *testing.T) {
 		t.Fatalf("NextRunAt must advance past now, got %s", d.NextRunAt)
 	}
 }
+
+func TestFireJobOverlappingAdjacentSlots(t *testing.T) {
+	for _, olderFirst := range []bool{false, true} {
+		name := "newer completes first"
+		if olderFirst {
+			name = "older completes first"
+		}
+		t.Run(name, func(t *testing.T) {
+			root := t.TempDir()
+			stores := []*cron.Store{
+				cron.NewStore(cron.StoreOptions{RootDir: root}),
+				cron.NewStore(cron.StoreOptions{RootDir: root}),
+			}
+			now := time.Date(2026, 6, 9, 9, 0, 0, 0, time.UTC)
+			job, err := stores[0].Add(cron.Job{Expr: "* * * * *", Prompt: "fire me", NextRunAt: now, FireCount: 7})
+			if err != nil {
+				t.Fatal(err)
+			}
+			var release, done [2]chan struct{}
+			for i := range stores {
+				release[i], done[i] = make(chan struct{}), make(chan struct{})
+				// Always release blocked runners, including on assertion failures.
+				defer func() {
+					select {
+					case <-release[i]:
+					default:
+						close(release[i])
+					}
+					<-done[i]
+				}()
+				started := make(chan struct{})
+				go func() {
+					defer close(done[i])
+					fireJob(stores[i], func() time.Time { return now.Add(time.Duration(i) * time.Minute) }, job, io.Discard, io.Discard,
+						func(_ []string, _, _ io.Writer) int {
+							close(started)
+							<-release[i]
+							return i // Include a failed execution in the accounting.
+						})
+				}()
+				select {
+				case <-started:
+				case <-done[i]:
+					t.Fatal("runner did not claim its slot")
+				}
+			}
+			order := []int{1, 0}
+			if olderFirst {
+				order = []int{0, 1}
+			}
+			for n, i := range order {
+				close(release[i])
+				<-done[i]
+				current, err := stores[0].Get(job.ID)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if current.FireCount != 8+n || !current.NextRunAt.Equal(now.Add(2*time.Minute)) {
+					t.Fatalf("after completion %d: FireCount=%d NextRunAt=%s; want count %d and next %s", n+1, current.FireCount, current.NextRunAt, 8+n, now.Add(2*time.Minute))
+				}
+				claimed, err := claimFire(stores[1], now.Add(time.Minute), job.ID)
+				if err != nil || claimed {
+					t.Fatalf("already claimed slot became available: claimed=%v err=%v", claimed, err)
+				}
+			}
+			runs, err := stores[0].Runs(job.ID, 0)
+			if err != nil || len(runs) != 2 {
+				t.Fatalf("runs=%v err=%v", runs, err)
+			}
+			for n, i := range order {
+				if !runs[n].At.Equal(now.Add(time.Duration(i)*time.Minute)) || runs[n].ExitCode != i {
+					t.Fatalf("unexpected run record: %+v", runs[n])
+				}
+			}
+		})
+	}
+}
+
+func TestFireJobCompletionReadErrorDoesNotOverwriteState(t *testing.T) {
+	root := t.TempDir()
+	store := cron.NewStore(cron.StoreOptions{RootDir: root})
+	now := time.Date(2026, 6, 9, 9, 0, 0, 0, time.UTC)
+	job, err := store.Add(cron.Job{Expr: "* * * * *", Prompt: "fire me", NextRunAt: now})
+	if err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(root, job.ID, "metadata.json")
+	var stdout, stderr bytes.Buffer
+	fireJob(store, func() time.Time { return now }, job, &stdout, &stderr,
+		func(_ []string, _, _ io.Writer) int {
+			// A corrupt read must not cause completion to replace unknown newer state
+			// with the stale pre-execution job. This works without permission tricks.
+			if err := os.WriteFile(metadata, []byte("unreadable job"), 0o600); err != nil {
+				t.Fatal(err)
+			}
+			return 0
+		})
+	data, err := os.ReadFile(metadata)
+	if err != nil || string(data) != "unreadable job" {
+		t.Fatalf("completion overwrote unreadable state: %q, err=%v", data, err)
+	}
+	if !strings.Contains(stderr.String(), "failed to persist job state") {
+		t.Fatalf("missing persistence warning: %s", stderr.String())
+	}
+	if want := "fired " + job.ID + " -> exit 0 (next: unknown)\n"; stdout.String() != want {
+		t.Fatalf("completion summary = %q; want %q", stdout.String(), want)
+	}
+	runs, err := store.Runs(job.ID, 0)
+	if err != nil || len(runs) != 1 || runs[0].ExitCode != 0 {
+		t.Fatalf("execution should still be recorded: runs=%v err=%v", runs, err)
+	}
+}
@@ -129,17 +129,15 @@ func reconcileOverdue(store *cron.Store, now func() time.Time, ids []string, std
 	}
 }

-// fireJob runs one job via the exec runner, records the outcome, advances the
-// schedule, and persists. The foreground loop is single-goroutine, so the
-// previous fire has already returned before the next tick — no overlap.
+// fireJob claims one job, runs it via the exec runner, and records the outcome.
+// Separate scheduler processes can have adjacent slots executing concurrently.
 func fireJob(store *cron.Store, now func() time.Time, job cron.Job, stdout io.Writer, stderr io.Writer, exec execRunner) {
 	fired := now()
 	// Atomically claim this fire before running it so concurrent schedulers (or
 	// --once overlapping the forever loop) can't both execute the same due job: the
 	// winner advances NextRunAt under the per-job lock, and a loser sees the
-	// advanced time and skips. The post-exec advance recomputes the same
-	// NextRunAt (sched.Next(fired) is deterministic), so the claim serializes the
-	// fire decision without changing any persisted schedule state (M9).
+	// advanced time and skips. Only the claim writes schedule state; completion
+	// must not overwrite a later slot's claim with this run's stale job copy.
 	claimed, claimErr := claimFire(store, fired, job.ID)
 	if claimErr != nil {
 		if errors.Is(claimErr, cron.ErrJobNotFound) {
@@ -178,44 +176,25 @@ func fireJob(store *cron.Store, now func() time.Time, job cron.Job, stdout io.Wr
 		rec.Error = cronTruncate(detail, 500)
 	}

-	job.FireCount++
-	// Advance the schedule. If the expression can no longer produce a future run
-	// (became invalid, or is an impossible spec whose Next is zero), pause the job
-	// so it cannot re-fire on every tick.
+	// Explain schedules that claimFire paused because they cannot advance.
 	if sched, perr := cron.Parse(job.Expr); perr != nil {
-		job.Status = cron.StatusPaused
 		if rec.Error == "" {
 			rec.Error = "invalid schedule; job paused: " + perr.Error()
 		}
 	} else if nxt := sched.Next(fired.Truncate(time.Minute)); nxt.IsZero() {
-		job.Status = cron.StatusPaused
 		if rec.Error == "" {
 			rec.Error = "schedule no longer fires; job paused"
 		}
-	} else {
-		// Minute-aligned input keeps this advance identical to claimFire's and lets
-		// the DST fall-back collapse guard engage (AUDIT-M4).
-		job.NextRunAt = nxt
 	}
-	// Re-read and persist the advanced state ATOMICALLY under the per-job lock. The
-	// job may have been paused or removed while it executed, and this in-memory copy
-	// is stale from tick start. Mutate closes the read-modify-write window a single
-	// scheduler alone could only narrow (Store.Mutate took a cross-process lock): a
-	// concurrent scheduler or an external pause/remove landing here can no longer be
-	// clobbered.
+	// Count this completion against current state under the cross-process lock.
+	// The claim already advanced or paused the schedule. Leave that state alone:
+	// another scheduler may have claimed a later slot or a user may have edited it.
 	persisted, err := store.Mutate(job.ID, func(current cron.Job, readErr error) (cron.Job, error) {
 		if readErr != nil {
-			// A transient read failure (IO/permission) is NOT removal — persist the
-			// computed next state anyway so the schedule advances and the job does not
-			// re-fire next tick.
-			fmt.Fprintf(stderr, "warning: could not re-read job %s before persist: %v\n", job.ID, readErr)
-			return job, nil
-		}
-		current.FireCount = job.FireCount
-		current.NextRunAt = job.NextRunAt
-		if current.Status != cron.StatusPaused {
-			current.Status = job.Status
+			// Never replace unknown newer state with the pre-execution snapshot.
+			return current, readErr
 		}
+		current.FireCount++
 		return current, nil
 	})
 	if errors.Is(err, cron.ErrJobNotFound) {
@@ -229,19 +208,21 @@ func fireJob(store *cron.Store, now func() time.Time, job cron.Job, stdout io.Wr
 	if aerr := store.AppendRun(job.ID, rec); aerr != nil {
 		fmt.Fprintf(stderr, "warning: failed to record run for %s: %v\n", job.ID, aerr)
 	}
+	next := "unknown"
 	if err != nil {
 		fmt.Fprintf(stderr, "warning: failed to persist job state for %s: %v\n", job.ID, err)
-		persisted = job
+	} else {
+		next = formatCronTime(persisted.NextRunAt)
 	}
-	fmt.Fprintf(stdout, "fired %s -> exit %d (next: %s)\n", job.ID, code, formatCronTime(persisted.NextRunAt))
+	fmt.Fprintf(stdout, "fired %s -> exit %d (next: %s)\n", job.ID, code, next)
 }

 // claimFire atomically claims a due job's fire under the per-job lock and reports
 // whether THIS caller should run it. It returns false only when the job was paused
 // externally or another scheduler already advanced NextRunAt past `fired` (so a
 // valid recurring job never double-fires). A valid due job has its NextRunAt
-// advanced here to claim the slot; an invalid or exhausted schedule is left for the
-// caller to fire-once and pause (preserving existing single-scheduler behavior).
+// advanced here to claim the slot; an invalid or exhausted schedule is paused
+// here and the caller still fires once (preserving single-scheduler behavior).
 func claimFire(store *cron.Store, fired time.Time, id string) (bool, error) {
 	claimed := true
 	_, err := store.Mutate(id, func(current cron.Job, readErr error) (cron.Job, error) {
@@ -268,8 +249,8 @@ func claimFire(store *cron.Store, fired time.Time, id string) (bool, error) {
 		}
 		// Unparseable or unadvanceable schedule (an impossible spec whose Next is
 		// zero): pause the job inside this same locked claim so a concurrent scheduler
-		// sees a non-active job and does NOT also fire it. The winner still fires once
-		// and fireJob's post-exec keeps it paused. Without this, both callers leave
+		// sees a non-active job and does NOT also fire it. The winner still fires once.
+		// Without this, both callers leave
 		// NextRunAt unchanged, both see the job due, and both fire the same slot
 		// (AUDIT-M5).
 		current.Status = cron.StatusPaused
@@ -53,7 +53,7 @@ func TestCronRunOnceFiresDueJobs(t *testing.T) {
 	if d.FireCount != 1 || !d.NextRunAt.After(now) {
 		t.Fatalf("due job not advanced: %+v", d)
 	}
-	runs, _ := store.Runs(due.ID)
+	runs, _ := store.Runs(due.ID, 0)
 	if len(runs) != 1 {
 		t.Fatalf("expected 1 run record, got %d", len(runs))
 	}
@@ -146,7 +146,7 @@ func TestCronRunPausesUnadvanceableJob(t *testing.T) {
 	if d.Status != cron.StatusPaused {
 		t.Fatalf("unadvanceable job must be paused, got status=%q", d.Status)
 	}
-	runs, _ := store.Runs(job.ID)
+	runs, _ := store.Runs(job.ID, 0)
 	if len(runs) != 1 || runs[0].Error == "" {
 		t.Fatalf("expected one run record with an error, got %+v", runs)
 	}
@@ -181,7 +181,7 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 	// Refresh the models.dev pricing/limits cache in the background when stale;
 	// the overlay is read at registry construction from the cache file, so this
 	// benefits the next run and never blocks or fails this one.
-	go func() { _ = modelregistry.RefreshModelsDevCache(context.Background()) }()
+	modelregistry.StartModelsDevRefresh()

 	// A mode seeds model/effort/max-turns/tool filters as a preset. Expand it up
 	// front — before tool-filter validation and the --list-tools branch — so a
@@ -347,6 +347,17 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 	} else if notice != "" {
 		_, _ = fmt.Fprintln(stderr, "[zero] "+notice)
 	}
+	// Before any tool runs, and before the MCP servers and plugins below start
+	// through the same sandbox, so a run that goes ahead with reduced isolation
+	// says so where its output starts, not only when someone runs `zero doctor`.
+	// A notice that cannot be written stops the run, as the image and effort
+	// notices further down do: going ahead would mean reduced isolation and no
+	// warning delivered.
+	if notice := sandboxEngine.DegradedNotice(); notice != "" {
+		if _, err := fmt.Fprintln(stderr, "[zero] "+notice); err != nil {
+			return exitCrash
+		}
+	}
 	executionRunner.SetPreparer(sandboxEngine)
 	if permissionMode != agent.PermissionModePlan {
 		mcpRuntime, mcpSkip, err = registerMCPToolsForWorkspace(context.Background(), workspaceRoot, registry, deps, execMCPAutonomy(options), trustRoot, executionRunner)
@@ -452,20 +463,20 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 	// escalation so post-switch turns are attributed to the escalated model.
 	currentModel := resolved.Provider.Model
 	// Optimized OpenAI turn sessions (ZERO_OPENAI_TURN_SESSION, default off). nil
-	// when gated off or the profile is ineligible: agent.Run then wraps the
-	// provider in its default adapter. This is the run's STARTING session provider
-	// and is used whether or not escalation is enabled.
-	turnSessions, _ := providers.OptimizedTurnSessions(resolved.Provider, provider, providers.Options{})
+	// when gated off or ineligible, unless a configured RPM limiter needs to
+	// wrap the default adapter. The limiter is shared across model switches.
+	sessionOptions := providers.Options{ModelRPM: zeroruntime.NewModelRPMLimiter(resolved.ModelRPM)}
+	turnSessions, _ := providers.ConfiguredTurnSessions(resolved.Provider, provider, sessionOptions)
 	// Both switchers come from one shared builder so exec and the interactive TUI
 	// cannot drift on the nil contracts the agent loop depends on. The session
-	// switcher is nil unless this run STARTED optimized, which is what keeps a
-	// default-adapter run on the default adapter.
+	// switcher preserves the starting transport and shares the RPM limiter.
 	var modelSwitcher func(context.Context, string) (agent.Provider, error)
 	var modelSessionSwitcher func(context.Context, string) (zeroruntime.TurnSessionProvider, error)
 	if options.allowEscalation {
 		modelSwitcher, modelSessionSwitcher = providers.EscalationSwitchers(
 			resolved.Provider, provider, deps.newProvider,
 			func(modelID string) { currentModel = modelID },
+			sessionOptions,
 		)
 	}

@@ -660,6 +671,9 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 		ContextWindowFor: func(modelID string) int {
 			return modelregistry.AgentContextWindow(modelContextWindow(modelRegistry, modelID))
 		},
+		SupportsVision: func(modelID string) bool {
+			return modelregistry.SupportsVision(modelRegistry, modelID)
+		},
 		ReasoningEffort: forwardEffort,
 		Trace:           traceRecorder,
 		Cwd:             workspaceRoot,
@@ -70,8 +70,8 @@ func TestRunExecListsFilteredToolsWithoutPromptOrProvider(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("expected exit code %d, got %d: %s", exitSuccess, exitCode, stderr.String())
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}
 	if providerBuilt {
 		t.Fatal("provider should not be constructed for --list-tools")
@@ -108,8 +108,8 @@ func TestRunExecListsToolsAsStreamJSONWhenRequested(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("expected exit code %d, got %d: %s", exitSuccess, exitCode, stderr.String())
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}
 	if providerBuilt {
 		t.Fatal("provider should not be constructed for --list-tools")
@@ -176,8 +176,8 @@ func TestRunExecListsMCPToolsWithoutProviderConstruction(t *testing.T) {
 	if !closed {
 		t.Fatal("MCP runtime was not closed after --list-tools")
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}
 	if !strings.Contains(stdout.String(), "mcp_docs_lookup") || !strings.Contains(stdout.String(), "Lookup documentation") {
 		t.Fatalf("expected MCP tool in list output, got %q", stdout.String())
@@ -323,8 +323,8 @@ func TestRunExecStreamJSONOutputsRunEndAndRecordsSession(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("expected exit code %d, got %d: %s", exitSuccess, exitCode, stderr.String())
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}

 	events := decodeJSONLines(t, stdout.String())
@@ -388,8 +388,8 @@ func TestRunExecStreamJSONEmitsAndRecordsPermissionEvents(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("expected exit code %d, got %d: %s", exitSuccess, exitCode, stderr.String())
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}

 	events := decodeJSONLines(t, stdout.String())
@@ -460,7 +460,7 @@ func TestRunExecStreamJSONEmitsAndRecordsPermissionEvents(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("approved exec exit = %d, stderr = %q", exitCode, stderr.String())
 	}
-	if stderr.String() != "" {
+	if stderr.String() != hostSandboxNotice(t) {
 		t.Fatalf("approved exec wrote stderr = %q", stderr.String())
 	}
 	approvedEvents := decodeJSONLines(t, stdout.String())
@@ -118,12 +118,15 @@ func runExecSpecDraft(run execSpecDraftRun) int {
 	hookDispatcher, hookSkip := newHookDispatcher(run.workspaceRoot, run.trustRoot, execution.NewRunner(run.sandboxEngine))
 	emitTrustNotice(run.stderr, hookSkip, run.mcpSkip)
 	result, err := agent.Run(runCtx, run.prompt, run.provider, agent.Options{
-		MaxTurns:        run.resolved.MaxTurns,
-		ContextWindow:   resolveAgentContextWindow(runCtx, run.modelRegistry, run.resolved.Provider),
-		SessionID:       draftSession.SessionID,
-		SessionTitle:    run.sessionTitle,
-		ProviderName:    run.resolved.Provider.Name,
-		Model:           run.resolved.Provider.Model,
+		MaxTurns:      run.resolved.MaxTurns,
+		ContextWindow: resolveAgentContextWindow(runCtx, run.modelRegistry, run.resolved.Provider),
+		SessionID:     draftSession.SessionID,
+		SessionTitle:  run.sessionTitle,
+		ProviderName:  run.resolved.Provider.Name,
+		Model:         run.resolved.Provider.Model,
+		SupportsVision: func(modelID string) bool {
+			return modelregistry.SupportsVision(run.modelRegistry, modelID)
+		},
 		ReasoningEffort: run.reasoningEffort,
 		Profile:         run.profilePolicy,
 		Cwd:             run.workspaceRoot,
@@ -568,8 +568,8 @@ func TestRunExecAcceptsLegacyModelProfileFlags(t *testing.T) {
 	if !strings.Contains(stdout, "hello") {
 		t.Fatalf("expected prompt output, got %q", stdout)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}
 }

@@ -696,8 +696,8 @@ func TestRunExecAssemblesInlineAndFilePromptRelativeToCwd(t *testing.T) {
 	if !strings.Contains(stdout, "inline prompt\n\nfile prompt") {
 		t.Fatalf("expected inline and file prompt joined by blank line, got %q", stdout)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}
 }

@@ -715,8 +715,8 @@ func TestRunExecAcceptsFileOnlyPrompt(t *testing.T) {
 	if !strings.Contains(stdout, "file only prompt") {
 		t.Fatalf("expected file prompt output, got %q", stdout)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}
 }

@@ -798,8 +798,8 @@ func TestRunExecJSONOutputsNDJSONEvents(t *testing.T) {
 	if exitCode != 0 {
 		t.Fatalf("expected exit code 0, got %d: %s", exitCode, stderr)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}

 	events := decodeJSONLines(t, stdout)
@@ -833,8 +833,8 @@ func TestRunExecResolvesCanonicalModelAlias(t *testing.T) {
 	if exitCode != 0 {
 		t.Fatalf("expected exit code 0, got %d: %s", exitCode, stderr)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr for active model, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice for active model, got %q", stderr)
 	}
 	events := decodeJSONLines(t, stdout)
 	if got := events[0]["model"]; got != "gpt-4.1" {
@@ -926,8 +926,8 @@ func TestRunExecJSONUnsafeOutputsWarningEvent(t *testing.T) {
 	if exitCode != 0 {
 		t.Fatalf("expected exit code 0, got %d: %s", exitCode, stderr)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}

 	events := decodeJSONLines(t, stdout)
@@ -970,10 +970,10 @@ func TestRunExecUsesProjectConfigAndOpenAICompatibleProvider(t *testing.T) {
 			"name": "local",
 			"provider_kind": "openai-compatible",
 			"base_url": "` + server.URL + `",
-			"api_key": "sk-local",
-			"model": "local-model"
-		}]
-	}`
+		"api_key": "sk-local",
+		"model": "local-model"
+	}]
+}`
 	if err := os.WriteFile(filepath.Join(configDir, "config.json"), []byte(writeConfig), 0o600); err != nil {
 		t.Fatal(err)
 	}
@@ -988,8 +988,8 @@ func TestRunExecUsesProjectConfigAndOpenAICompatibleProvider(t *testing.T) {
 	if strings.TrimSpace(stdout.String()) != "provider ok" {
 		t.Fatalf("stdout = %q, want provider response", stdout.String())
 	}
-	if stderr.Len() != 0 {
-		t.Fatalf("expected empty stderr, got %q", stderr.String())
+	if stderr.String() != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr.String())
 	}
 	if gotAuth != "Bearer sk-local" {
 		t.Fatalf("Authorization = %q, want project config token", gotAuth)
@@ -1204,8 +1204,8 @@ func TestRunExecAutoHighEmitsUnsafeWarning(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("expected exit code %d, got %d: %s", exitSuccess, exitCode, stderr)
 	}
-	if stderr != "" {
-		t.Fatalf("expected empty stderr, got %q", stderr)
+	if stderr != hostSandboxNotice(t) {
+		t.Fatalf("expected no stderr beyond this host's sandbox notice, got %q", stderr)
 	}

 	events := decodeJSONLines(t, stdout)
@@ -69,7 +69,7 @@ func TestRunExecListToolsHonorsDisabledLocalControlConfig(t *testing.T) {
 	if exitCode != exitSuccess {
 		t.Fatalf("exitCode = %d stdout=%s stderr=%s", exitCode, stdout.String(), stderr.String())
 	}
-	if stderr.Len() != 0 {
+	if stderr.String() != hostSandboxNotice(t) {
 		t.Fatalf("stderr = %q, want empty", stderr.String())
 	}
 	var payload struct {
@@ -0,0 +1,83 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"github.com/Gitlawb/zero/internal/config"
+	"github.com/Gitlawb/zero/internal/mcp"
+	"github.com/Gitlawb/zero/internal/tools"
+	"github.com/Gitlawb/zero/internal/tui"
+	"github.com/Gitlawb/zero/internal/zeroruntime"
+	"strings"
+	"testing"
+)
+
+type rpmExecProvider struct{ calls int }
+
+func (p *rpmExecProvider) StreamCompletion(context.Context, zeroruntime.CompletionRequest) (<-chan zeroruntime.StreamEvent, error) {
+	p.calls++
+	ch := make(chan zeroruntime.StreamEvent, 4)
+	if p.calls == 1 {
+		ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "fixture", ToolName: "read_file"}
+		ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "fixture", ArgumentsFragment: `{"path":"missing-fixture.txt"}`}
+		ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: "fixture"}
+	} else {
+		ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventText, Content: "unexpected second completion"}
+	}
+	ch <- zeroruntime.StreamEvent{Type: zeroruntime.StreamEventDone}
+	close(ch)
+	return ch, nil
+}
+func rpmTestDeps(t *testing.T, p *rpmExecProvider) appDeps {
+	t.Helper()
+	root := t.TempDir()
+	for _, k := range []string{"HOME", "USERPROFILE", "APPDATA", "LOCALAPPDATA", "XDG_CONFIG_HOME", "XDG_CACHE_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME"} {
+		t.Setenv(k, root)
+	}
+	return appDeps{getwd: func() (string, error) { return root, nil }, resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
+		c := execResolvedConfig()
+		c.ModelRPM = map[string]int{c.Provider.Model: 1}
+		return c, nil
+	}, newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) { return p, nil }, registerMCPTools: func(context.Context, *tools.Registry, config.MCPConfig, mcp.RegisterOptions) (mcpToolRuntime, error) {
+		return noopMCPRuntime{}, nil
+	}}
+}
+func TestRunExecRPMRefusesSecondCompletion(t *testing.T) {
+	p := &rpmExecProvider{}
+	deps := rpmTestDeps(t, p)
+	var out, err bytes.Buffer
+	code := runWithDeps([]string{"exec", "fixture"}, &out, &err, deps)
+	if code != exitProvider || p.calls != 1 || !strings.Contains(err.String(), "Local modelRPM cap reached") {
+		t.Fatalf("exit=%d calls=%d stdout=%s stderr=%s", code, p.calls, out.String(), err.String())
+	}
+}
+func TestInteractiveRPMFactorySharesWindow(t *testing.T) {
+	p := &rpmExecProvider{}
+	deps := rpmTestDeps(t, p)
+	launched := false
+	deps.runTUI = func(ctx context.Context, o tui.Options) int {
+		launched = true
+		if o.ModelRPM == nil {
+			t.Fatal("TUI escalation lacks limiter")
+		}
+		for i := 0; i < 2; i++ {
+			ss := o.NewTurnSessionProvider(o.ProviderProfile, p)
+			s, e := ss.OpenTurnSession(ctx)
+			if e != nil {
+				t.Fatal(e)
+			}
+			_, e = s.Stream(ctx, zeroruntime.CompletionRequest{})
+			var hit *zeroruntime.RPMLimitError
+			if (i == 0 && e != nil) || (i == 1 && !errors.As(e, &hit)) {
+				t.Fatalf("run=%d err=%v", i, e)
+			}
+		}
+		return exitSuccess
+	}
+	var out, err bytes.Buffer
+	code := runWithDeps(nil, &out, &err, deps)
+	if !launched || code != exitSuccess || p.calls != 1 {
+		t.Fatalf("launched=%v exit=%d calls=%d stderr=%s", launched, code, p.calls, err.String())
+	}
+}
@@ -397,23 +397,11 @@ func TestRunSearchJSONRedactsQueryAndSessionMetadata(t *testing.T) {
 	}

 	session, err := store.Create(sessions.CreateInput{
-		SessionID:        "json_metadata_secret",
-		Title:            "Title " + metadataSecret,
-		Cwd:              "/repo/" + metadataSecret,
-		WorkspaceKey:     "/raw-repo/" + metadataSecret,
-		ModelID:          "model-" + metadataSecret,
-		SourceModelID:    "source-model-" + metadataSecret,
-		Provider:         "provider-token=" + metadataSecret,
-		Tag:              "tag-" + metadataSecret,
-		SpecUserComment:  "comment-" + metadataSecret,
-		SpecRejectReason: "reason-" + metadataSecret,
-		Goal: &sessions.Goal{
-			Objective:    "objective-" + metadataSecret,
-			Status:       sessions.GoalStatusBlocked,
-			CreatedAt:    "2026-06-04T18:00:00Z",
-			UpdatedAt:    "2026-06-04T18:00:00Z",
-			StatusReason: "blocked-by-" + metadataSecret,
-		},
+		SessionID: "json_metadata_secret",
+		Title:     "Title " + metadataSecret,
+		Cwd:       "/repo/" + metadataSecret,
+		ModelID:   "model-" + metadataSecret,
+		Provider:  "provider-token=" + metadataSecret,
 	})
 	if err != nil {
 		t.Fatalf("Create returned error: %v", err)
@@ -438,21 +426,6 @@ func TestRunSearchJSONRedactsQueryAndSessionMetadata(t *testing.T) {
 	if !strings.Contains(stdout.String(), "[REDACTED]") {
 		t.Fatalf("expected redacted metadata marker in JSON output: %q", stdout.String())
 	}
-	var result struct {
-		Hits []struct {
-			Session sessions.Metadata `json:"session"`
-		} `json:"hits"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &result); err != nil {
-		t.Fatalf("decode search result: %v", err)
-	}
-	if len(result.Hits) != 1 || result.Hits[0].Session.WorkspaceKey != "" {
-		t.Fatalf("search JSON exposed operational workspace identity: %#v", result.Hits)
-	}
-	persisted, err := store.Get(session.SessionID)
-	if err != nil || persisted == nil || persisted.WorkspaceKey != "/raw-repo/"+metadataSecret {
-		t.Fatalf("stored workspace identity was corrupted: metadata=%#v err=%v", persisted, err)
-	}
 }

 func TestRunDoctorReportsConfigValidationForMalformedFile(t *testing.T) {
@@ -20,6 +20,7 @@ func TestProviderCatalogRuntimeProvidersShowOnboardingSetupHints(t *testing.T) {
 		{id: "groq", name: "Groq", transport: "openai-compatible", defaultModel: "llama-3.3-70b-versatile"},
 		{id: "longcat", name: "LongCat", transport: "openai-compatible", defaultModel: "LongCat-2.0"},
 		{id: "fireworks", name: "Fireworks AI", transport: "openai-compatible", defaultModel: "accounts/fireworks/models/kimi-k2p7-code"},
+		{id: "gmicloud", name: "GMI Cloud", transport: "openai-compatible", defaultModel: "Qwen/Qwen3.8-Max"},
 		{id: "ollama-cloud", name: "Ollama Cloud", transport: "openai-compatible", defaultModel: "qwen3-coder:480b"},
 		{id: "ollama", name: "Ollama Local", transport: "openai-compatible", defaultModel: "llama3.1"},
 	}
@@ -0,0 +1,237 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/Gitlawb/zero/internal/config"
+	"github.com/Gitlawb/zero/internal/mcp"
+	"github.com/Gitlawb/zero/internal/sandbox"
+	"github.com/Gitlawb/zero/internal/tools"
+	"github.com/Gitlawb/zero/internal/tui"
+	"github.com/Gitlawb/zero/internal/zeroruntime"
+)
+
+// hostSandboxNotice is the degraded-sandbox line exec prints on THIS machine for
+// a run under the default sandbox policy, or "" where the sandbox is not
+// degraded. Exec tests that expect a quiet stderr compare against it rather than
+// against "": unless a test pins a backend, the run gets the host's own, and a
+// Linux runner without the sandbox helper is degraded where macOS and Windows
+// are not.
+func hostSandboxNotice(t *testing.T) string {
+	t.Helper()
+	engine := sandbox.NewEngine(sandbox.EngineOptions{
+		WorkspaceRoot: t.TempDir(),
+		Policy:        sandbox.DefaultPolicy(),
+		Backend:       sandbox.SelectBackend(sandbox.BackendOptions{}),
+	})
+	notice := engine.DegradedNotice()
+	if notice == "" {
+		return ""
+	}
+	return "[zero] " + notice + "\n"
+}
+
+// clearSandboxNestingMarkers keeps a test that pins the notice from inheriting
+// the nesting markers when the suite itself runs inside a Zero sandbox.
+func clearSandboxNestingMarkers(t *testing.T) {
+	t.Helper()
+	t.Setenv(sandbox.EnvSandboxed, "")
+	t.Setenv(sandbox.EnvSandboxBackend, "")
+}
+
+// unavailableTestSandbox is the backend a Linux box without the helper gets,
+// pinned so a test sees the degraded case on every platform.
+func unavailableTestSandbox(sandbox.BackendOptions) sandbox.Backend {
+	return sandbox.Backend{Name: sandbox.BackendUnavailable, Platform: "linux", Fallback: true, Message: "Linux sandbox helper is not available"}
+}
+
+const unavailableTestSandboxNotice = "[zero] Sandbox enforcement is degraded: Linux sandbox helper is not available. See `zero sandbox policy --effective`.\n"
+
+func runExecWithSandbox(t *testing.T, args []string, backend func(sandbox.BackendOptions) sandbox.Backend, sandboxConfig config.SandboxConfig) (int, string, string) {
+	t.Helper()
+	isolateCLIUserState(t)
+	var stdout, stderr bytes.Buffer
+	cwd := t.TempDir()
+	exitCode := runWithDeps(args, &stdout, &stderr, appDeps{
+		getwd: func() (string, error) { return cwd, nil },
+		resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
+			return config.ResolvedConfig{
+				ActiveProvider: "echo",
+				Provider: config.ProviderProfile{
+					Name:         "echo",
+					ProviderKind: config.ProviderKindOpenAICompatible,
+					BaseURL:      "http://127.0.0.1/v1",
+					Model:        "echo-model",
+				},
+				MaxTurns: 3,
+				Sandbox:  sandboxConfig,
+			}, nil
+		},
+		newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
+			return echoExecProvider{}, nil
+		},
+		selectSandboxBackend: backend,
+	})
+	return exitCode, stdout.String(), stderr.String()
+}
+
+// A RUN THAT GOES AHEAD WITH REDUCED ISOLATION SAYS SO. Before this only `zero
+// doctor` and `zero sandbox policy` did, so `zero exec` ran every tool with the
+// native sandbox effectively off and printed nothing about it. #1041.
+func TestExecSaysOnStderrWhenTheSandboxIsDegraded(t *testing.T) {
+	clearSandboxNestingMarkers(t)
+	exitCode, _, stderr := runExecWithSandbox(t, []string{"exec", "hello"}, unavailableTestSandbox, config.SandboxConfig{})
+	if exitCode != 0 {
+		t.Fatalf("exit code = %d, stderr %q", exitCode, stderr)
+	}
+	if stderr != unavailableTestSandboxNotice {
+		t.Fatalf("stderr = %q, want exactly the degraded notice %q", stderr, unavailableTestSandboxNotice)
+	}
+}
+
+// The notice goes to stderr in the JSON modes as well, so stdout stays one JSON
+// object per line for whatever reads it.
+func TestExecKeepsTheDegradedNoticeOffStdoutInJSONMode(t *testing.T) {
+	clearSandboxNestingMarkers(t)
+	exitCode, stdout, stderr := runExecWithSandbox(t, []string{"exec", "--output-format", "json", "hello"}, unavailableTestSandbox, config.SandboxConfig{})
+	if exitCode != 0 {
+		t.Fatalf("exit code = %d, stderr %q", exitCode, stderr)
+	}
+	if stderr != unavailableTestSandboxNotice {
+		t.Fatalf("stderr = %q, want exactly the degraded notice", stderr)
+	}
+	for _, line := range strings.Split(strings.TrimSpace(stdout), "\n") {
+		var event map[string]any
+		if err := json.Unmarshal([]byte(line), &event); err != nil {
+			t.Fatalf("stdout carries a line that is not JSON: %q (%v)", line, err)
+		}
+	}
+}
+
+// A sandbox the user turned off is their choice, not a degradation.
+func TestExecSaysNothingWhenTheSandboxIsTurnedOff(t *testing.T) {
+	clearSandboxNestingMarkers(t)
+	off := false
+	exitCode, _, stderr := runExecWithSandbox(t, []string{"exec", "hello"}, unavailableTestSandbox, config.SandboxConfig{Enabled: &off})
+	if exitCode != 0 {
+		t.Fatalf("exit code = %d, stderr %q", exitCode, stderr)
+	}
+	if stderr != "" {
+		t.Fatalf("stderr = %q, want nothing for a disabled sandbox", stderr)
+	}
+}
+
+// countingExecProvider is echoExecProvider, counting the completions it streams.
+type countingExecProvider struct {
+	echoExecProvider
+	streamed *int
+}
+
+func (provider countingExecProvider) StreamCompletion(ctx context.Context, request zeroruntime.CompletionRequest) (<-chan zeroruntime.StreamEvent, error) {
+	*provider.streamed++
+	return provider.echoExecProvider.StreamCompletion(ctx, request)
+}
+
+// A degraded notice that cannot be written stops the run before the model is
+// asked for anything, as the image and effort notices do, instead of going ahead
+// with reduced isolation and no warning delivered.
+func TestExecStopsWhenTheDegradedNoticeCannotBeWritten(t *testing.T) {
+	clearSandboxNestingMarkers(t)
+	isolateCLIUserState(t)
+	var stdout bytes.Buffer
+	cwd := t.TempDir()
+	streamed := 0
+	exitCode := runWithDeps([]string{"exec", "hello"}, &stdout, failingWriter{}, appDeps{
+		getwd: func() (string, error) { return cwd, nil },
+		resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
+			return config.ResolvedConfig{
+				ActiveProvider: "echo",
+				Provider: config.ProviderProfile{
+					Name:         "echo",
+					ProviderKind: config.ProviderKindOpenAICompatible,
+					BaseURL:      "http://127.0.0.1/v1",
+					Model:        "echo-model",
+				},
+				MaxTurns: 3,
+			}, nil
+		},
+		newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
+			return countingExecProvider{streamed: &streamed}, nil
+		},
+		selectSandboxBackend: unavailableTestSandbox,
+	})
+	if exitCode != exitCrash {
+		t.Fatalf("exit code = %d, want %d when the degraded notice cannot be written", exitCode, exitCrash)
+	}
+	if streamed != 0 {
+		t.Fatalf("the model was asked %d times: the run went ahead without its warning", streamed)
+	}
+}
+
+// launchTUIWithSandbox runs the root command the way a bare `zero` does, with
+// the sandbox backend pinned to the unavailable one, and returns the options the
+// TUI would have started with.
+func launchTUIWithSandbox(t *testing.T, sandboxConfig config.SandboxConfig) tui.Options {
+	t.Helper()
+	isolateCLIUserState(t)
+	var stdout, stderr bytes.Buffer
+	cwd := t.TempDir()
+	var launched tui.Options
+	exitCode := runWithDeps([]string{}, &stdout, &stderr, appDeps{
+		getwd: func() (string, error) { return cwd, nil },
+		resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
+			return config.ResolvedConfig{MaxTurns: 12, Sandbox: sandboxConfig}, nil
+		},
+		newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
+			t.Fatal("newProvider should not be called without a resolved provider")
+			return nil, nil
+		},
+		registerMCPTools: func(context.Context, *tools.Registry, config.MCPConfig, mcp.RegisterOptions) (mcpToolRuntime, error) {
+			return noopMCPRuntime{}, nil
+		},
+		selectSandboxBackend: unavailableTestSandbox,
+		runTUI: func(_ context.Context, options tui.Options) int {
+			launched = options
+			return 0
+		},
+	})
+	if exitCode != 0 {
+		t.Fatalf("exit code = %d, stderr %q", exitCode, stderr.String())
+	}
+	return launched
+}
+
+// The TUI shows the same notice when the session opens, taken from the engine
+// its commands run through.
+func TestTUILaunchCarriesTheDegradedNotice(t *testing.T) {
+	clearSandboxNestingMarkers(t)
+	for _, testCase := range []struct {
+		name    string
+		sandbox config.SandboxConfig
+		want    bool
+	}{
+		{name: "degraded", want: true},
+		{name: "turned off", sandbox: config.SandboxConfig{Enabled: func() *bool { off := false; return &off }()}},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			launched := launchTUIWithSandbox(t, testCase.sandbox)
+			var notices []string
+			for _, notice := range launched.StartupNotices {
+				if strings.TrimSpace(notice) != "" {
+					notices = append(notices, notice)
+				}
+			}
+			want := strings.TrimSuffix(strings.TrimPrefix(unavailableTestSandboxNotice, "[zero] "), "\n")
+			if testCase.want && (len(notices) != 1 || notices[0] != want) {
+				t.Fatalf("StartupNotices = %q, want exactly %q", notices, want)
+			}
+			if !testCase.want && len(notices) != 0 {
+				t.Fatalf("StartupNotices = %q, want none", notices)
+			}
+		})
+	}
+}
@@ -5,24 +5,21 @@ import (
 	"io"
 	"strings"

-	"github.com/Gitlawb/zero/internal/agentsessions"
 	"github.com/Gitlawb/zero/internal/redaction"
 	"github.com/Gitlawb/zero/internal/sessions"
 	"github.com/Gitlawb/zero/internal/zerocommands"
 )

 type sessionCommandOptions struct {
-	json             bool
-	kind             sessions.SessionKind
-	sequence         int
-	eventID          string
-	excludeTarget    bool
-	preserveLast     int
-	maxPromptChars   int
-	allWorkspaces    bool
-	agent            string
-	maxEvents        int
-	includeReasoning bool
+	json           bool
+	kind           sessions.SessionKind
+	sequence       int
+	eventID        string
+	excludeTarget  bool
+	preserveLast   int
+	maxPromptChars int
+	olderThan      string
+	dryRun         bool
 }

 func runSessions(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int {
@@ -77,16 +74,11 @@ func runSessions(args []string, stdout io.Writer, stderr io.Writer, deps appDeps
 			return writeExecUsageError(stderr, "sessions compact-plan requires a session id")
 		}
 		return runSessionsCompactPlan(store, remaining[0], options, stdout, stderr)
-	case "discover":
+	case "prune":
 		if len(remaining) != 0 {
-			return writeExecUsageError(stderr, "sessions discover does not accept positional arguments")
+			return writeExecUsageError(stderr, "sessions prune does not accept positional arguments")
 		}
-		return runSessionsDiscover(options, stdout, stderr)
-	case "import":
-		if len(remaining) != 1 {
-			return writeExecUsageError(stderr, "sessions import requires a reference of the form <agent>:<id>")
-		}
-		return runSessionsImport(store, remaining[0], options, stdout, stderr)
+		return runSessionsPrune(store, options, stdout, stderr, deps)
 	default:
 		return writeExecUsageError(stderr, fmt.Sprintf("unknown sessions command %q", command))
 	}
@@ -106,21 +98,8 @@ func parseSessionsArgs(args []string) (string, []string, sessionCommandOptions,
 			options.json = true
 		case "--exclude-target":
 			options.excludeTarget = true
-		case "--all":
-			options.allWorkspaces = true
-		case "--include-reasoning":
-			options.includeReasoning = true
-		case "--agent":
-			value, next, err := nextFlagValue(args, index, arg)
-			if err != nil {
-				return command, remaining, options, false, err
-			}
-			agent, err := parseNonEmptySessionsFlag("--agent", value)
-			if err != nil {
-				return command, remaining, options, false, err
-			}
-			options.agent = agent
-			index = next
+		case "--dry-run":
+			options.dryRun = true
 		case "--kind":
 			value, next, err := nextFlagValue(args, index, arg)
 			if err != nil {
@@ -198,6 +177,21 @@ func parseSessionsArgs(args []string) (string, []string, sessionCommandOptions,
 				}
 				options.preserveLast = preserveLast
 				continue
+			case arg == "--older-than":
+				value, next, err := nextFlagValue(args, index, arg)
+				if err != nil {
+					return command, remaining, options, false, err
+				}
+				options.olderThan = value
+				index = next
+				continue
+			case strings.HasPrefix(arg, "--older-than="):
+				value, err := parseNonEmptySessionsFlag("--older-than", strings.TrimPrefix(arg, "--older-than="))
+				if err != nil {
+					return command, remaining, options, false, err
+				}
+				options.olderThan = value
+				continue
 			case arg == "--max-prompt-chars":
 				value, next, err := nextFlagValue(args, index, arg)
 				if err != nil {
@@ -217,32 +211,6 @@ func parseSessionsArgs(args []string) (string, []string, sessionCommandOptions,
 				}
 				options.maxPromptChars = maxPromptChars
 				continue
-			case strings.HasPrefix(arg, "--agent="):
-				agent, err := parseNonEmptySessionsFlag("--agent", strings.TrimPrefix(arg, "--agent="))
-				if err != nil {
-					return command, remaining, options, false, err
-				}
-				options.agent = agent
-				continue
-			case arg == "--max-events":
-				value, next, err := nextFlagValue(args, index, arg)
-				if err != nil {
-					return command, remaining, options, false, err
-				}
-				maxEvents, err := parsePositiveIntFlag(arg, value)
-				if err != nil {
-					return command, remaining, options, false, err
-				}
-				options.maxEvents = maxEvents
-				index = next
-				continue
-			case strings.HasPrefix(arg, "--max-events="):
-				maxEvents, err := parsePositiveIntFlag("--max-events", strings.TrimSpace(strings.TrimPrefix(arg, "--max-events=")))
-				if err != nil {
-					return command, remaining, options, false, err
-				}
-				options.maxEvents = maxEvents
-				continue
 			}
 			if strings.HasPrefix(arg, "-") {
 				return command, remaining, options, false, execUsageError{fmt.Sprintf("unknown sessions flag %q", arg)}
@@ -281,7 +249,7 @@ func parseSessionKindFlag(value string) (sessions.SessionKind, error) {

 func isSessionsCommand(command string) bool {
 	switch command {
-	case "list", "children", "lineage", "tree", "rewind-plan", "rewind", "compact-plan", "discover", "import":
+	case "list", "children", "lineage", "tree", "rewind-plan", "rewind", "compact-plan", "prune":
 		return true
 	default:
 		return false
@@ -300,11 +268,8 @@ func validateSessionCommandFlags(command string, options sessionCommandOptions)
 	if hasCompactionFlag && command != "compact-plan" {
 		return execUsageError{"--preserve-last and --max-prompt-chars are only valid for sessions compact-plan"}
 	}
-	if (options.allWorkspaces || strings.TrimSpace(options.agent) != "") && command != "discover" {
-		return execUsageError{"--all and --agent are only valid for sessions discover"}
-	}
-	if (options.maxEvents > 0 || options.includeReasoning) && command != "import" {
-		return execUsageError{"--max-events and --include-reasoning are only valid for sessions import"}
+	if (options.olderThan != "" || options.dryRun) && command != "prune" {
+		return execUsageError{"--older-than and --dry-run are only valid for sessions prune"}
 	}
 	return nil
 }
@@ -432,7 +397,7 @@ func runSessionsRewind(store *sessions.Store, sessionID string, options sessionC
 	if session == nil {
 		return writeExecUsageError(stderr, "Zero session not found: "+redact(sessionID))
 	}
-	workspaceRoot := strings.TrimSpace(sessions.OperationalCwd(*session))
+	workspaceRoot := strings.TrimSpace(session.Cwd)
 	if workspaceRoot == "" {
 		return writeExecUsageError(stderr, "session has no recorded workspace (cwd); cannot restore files")
 	}
@@ -561,7 +526,7 @@ func formatSessionSnapshotLine(session zerocommands.SessionSnapshot) string {
 		details = append(details, "spec_id="+redact(session.SpecID))
 	}
 	if session.Tag != "" {
-		details = append(details, "tag="+agentsessions.DisplayField(session.Tag))
+		details = append(details, "tag="+redact(session.Tag))
 	}
 	if session.Depth > 0 {
 		details = append(details, fmt.Sprintf("depth=%d", session.Depth))
@@ -570,7 +535,7 @@ func formatSessionSnapshotLine(session zerocommands.SessionSnapshot) string {
 		details = append(details, "parent="+redact(session.ParentSessionID))
 	}
 	if session.ModelID != "" {
-		details = append(details, "model="+agentsessions.DisplayField(session.ModelID))
+		details = append(details, "model="+redact(session.ModelID))
 	}
 	if len(details) > 0 {
 		parts = append(parts, "("+strings.Join(details, ", ")+")")
@@ -594,8 +559,7 @@ Commands:
  rewind-plan <id>      Preview events kept and dropped by a rewind
  rewind <id>           Restore workspace files and truncate the log to a checkpoint
  compact-plan <id>     Preview events compacted and preserved by compaction
-  discover              List sessions from other coding agents on this machine
-  import <agent>:<id>   Copy one of those sessions into Zero, then --resume it
+  prune                 Remove sessions last updated before a cutoff

 Flags:
      --json            Print JSON output
@@ -605,15 +569,13 @@ Flags:
      --exclude-target  Drop the target event (rewind-plan, rewind)
      --preserve-last <n> Keep recent events in compact-plan
      --max-prompt-chars <n> Limit compact-plan summary prompt
-      --all             Include every workspace, not just this one (discover)
-      --agent <name>    Only this agent (discover)
-      --max-events <n>  Keep only the last n events (import)
-      --include-reasoning Keep the other model's thinking blocks (import)
+      --older-than <age>  Prune cutoff, as days (30d) or a duration (720h); at least 1d.
+                        Without it, prune uses sessions.retentionDays from your user config.
+      --dry-run         List what prune would remove, and why it keeps the rest
  -h, --help            Show this help

-discover and import are read-only with respect to the other agent: Zero reads
-its transcripts, never its credentials, and never writes to its store. The
-imported session runs on Zero's own provider and your own key.
+prune only runs when you run it. It never removes a session another Zero process
+has open, or an ancestor of a session it keeps, and --dry-run shows why.
 `)
 	return err
 }
@@ -1,335 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/Gitlawb/zero/internal/agentsessions"
-	"github.com/Gitlawb/zero/internal/redaction"
-	"github.com/Gitlawb/zero/internal/sessions"
-)
-
-// runSessionsDiscover lists sessions belonging to other coding agents.
-//
-// Read-only in every sense: it opens transcripts, never credentials, and never
-// writes to another agent's store. See internal/agentsessions for why the file
-// access is glob-bounded rather than a directory walk.
-func runSessionsDiscover(options sessionCommandOptions, stdout io.Writer, stderr io.Writer) int {
-	cwd := ""
-	if !options.allWorkspaces {
-		// Scope to this workspace by default. On a machine with a thousand
-		// transcripts, an unscoped list is not a list anyone can use.
-		working, err := os.Getwd()
-		if err != nil {
-			return writeAppError(stderr, "resolve working directory: "+err.Error(), exitCrash)
-		}
-		cwd = working
-	}
-
-	found, problems := agentsessions.DiscoverAll(agentsessions.OSEnv(), cwd)
-	found = filterDiscoveredByAgent(found, options.agent)
-
-	if options.json {
-		if err := writePrettyJSON(stdout, redaction.RedactValue(discoveredSnapshots(found), redaction.Options{})); err != nil {
-			return exitCrash
-		}
-		return reportDiscoveryProblems(stderr, problems)
-	}
-	if _, err := fmt.Fprintln(stdout, formatDiscoveredSessions(found, cwd)); err != nil {
-		return exitCrash
-	}
-	return reportDiscoveryProblems(stderr, problems)
-}
-
-// reportDiscoveryProblems mentions adapters that failed without failing the
-// command. What did work is still worth having.
-func reportDiscoveryProblems(stderr io.Writer, problems []error) int {
-	for _, problem := range problems {
-		// AN ERROR STRING IS NOT AUTOMATICALLY SAFE. These wrap paths and ids read
-		// out of another agent's store, so the untrusted bytes arrive here wearing
-		// an error's clothing rather than a field's.
-		fmt.Fprintln(stderr, "warning: "+agentsessions.DisplayField(problem.Error()))
-	}
-	return exitSuccess
-}
-
-func filterDiscoveredByAgent(found []agentsessions.ForeignSession, agent string) []agentsessions.ForeignSession {
-	wanted := strings.TrimSpace(agent)
-	if wanted == "" {
-		return found
-	}
-	filtered := make([]agentsessions.ForeignSession, 0, len(found))
-	for _, session := range found {
-		if strings.EqualFold(session.Agent, wanted) {
-			filtered = append(filtered, session)
-		}
-	}
-	return filtered
-}
-
-type discoveredSnapshot struct {
-	Agent     string `json:"agent"`
-	Ref       string `json:"ref"`
-	ID        string `json:"id"`
-	Title     string `json:"title"`
-	Cwd       string `json:"cwd"`
-	GitBranch string `json:"gitBranch,omitempty"`
-	ModelID   string `json:"modelId,omitempty"`
-	StartedAt string `json:"startedAt,omitempty"`
-	UpdatedAt string `json:"updatedAt,omitempty"`
-	Path      string `json:"path"`
-}
-
-func discoveredSnapshots(found []agentsessions.ForeignSession) []discoveredSnapshot {
-	out := make([]discoveredSnapshot, 0, len(found))
-	for _, session := range found {
-		out = append(out, discoveredSnapshot{
-			Agent:     agentsessions.DisplayField(session.Agent),
-			Ref:       agentsessions.DisplayField(session.Agent + ":" + session.ID),
-			ID:        agentsessions.DisplayField(session.ID),
-			Title:     agentsessions.DisplayField(session.Title),
-			Cwd:       agentsessions.DisplayField(session.Cwd),
-			GitBranch: agentsessions.DisplayField(session.GitBranch),
-			ModelID:   agentsessions.DisplayField(session.ModelID),
-			StartedAt: formatDiscoveredTime(session.StartedAt),
-			UpdatedAt: formatDiscoveredTime(session.UpdatedAt),
-			Path:      agentsessions.DisplayField(session.Path),
-		})
-	}
-	return out
-}
-
-func formatDiscoveredTime(value time.Time) string {
-	if value.IsZero() {
-		return ""
-	}
-	return value.UTC().Format(time.RFC3339)
-}
-
-// describeAge renders a last-activity stamp the way a person scanning a list
-// wants it: a clock time for today, a date for anything older.
-func describeAge(value time.Time, now time.Time) string {
-	if value.IsZero() {
-		return ""
-	}
-	local, reference := value.Local(), now.Local()
-	switch {
-	case local.Year() == reference.Year() && local.YearDay() == reference.YearDay():
-		return "today " + local.Format("15:04")
-	case local.Year() == reference.Year():
-		return local.Format("Jan _2 15:04")
-	default:
-		return local.Format("2006-01-02")
-	}
-}
-
-func formatDiscoveredSessions(found []agentsessions.ForeignSession, cwd string) string {
-	if len(found) == 0 {
-		where := "this workspace"
-		if strings.TrimSpace(cwd) == "" {
-			where = "any workspace"
-		}
-		return "No sessions from other coding agents were found for " + where + ".\n" +
-			"Agents this build can read: " + strings.Join(agentsessions.AdapterNames(agentsessions.OSEnv()), ", ") + "."
-	}
-
-	lines := []string{fmt.Sprintf("%d session(s) from other coding agents:", len(found)), ""}
-	for _, session := range found {
-		age := ""
-		if !session.UpdatedAt.IsZero() {
-			age = describeAge(session.UpdatedAt, time.Now())
-		}
-		// EVERY FIELD HERE IS ANOTHER PRODUCT'S BYTES. The id, title, branch and
-		// model all come out of a file this program did not write, and they were
-		// printed straight to the terminal: an escape repaints the listing, and a
-		// title is frequently the user's first prompt, which is exactly where a
-		// pasted credential ends up. The --json path is structurally escaped and
-		// redacted already; this is the human-readable one.
-		header := session.Agent + ":" + agentsessions.DisplayField(session.ID)
-		lines = append(lines, header)
-		detail := "    " + agentsessions.DisplayField(session.Title)
-		lines = append(lines, detail)
-		meta := []string{}
-		if session.GitBranch != "" {
-			meta = append(meta, "branch "+agentsessions.DisplayField(session.GitBranch))
-		}
-		if session.ModelID != "" {
-			meta = append(meta, agentsessions.DisplayField(session.ModelID))
-		}
-		if age != "" {
-			meta = append(meta, age)
-		}
-		if len(meta) > 0 {
-			lines = append(lines, "    "+strings.Join(meta, "  ·  "))
-		}
-		lines = append(lines, "")
-	}
-	lines = append(lines,
-		"Import one with:  zero sessions import <agent>:<id>",
-		"Then continue it: zero exec --resume <zero-session-id> \"…\"",
-	)
-	return strings.Join(lines, "\n")
-}
-
-// runSessionsImport copies one foreign session into Zero's own store, after
-// which every existing session verb — resume, fork, rewind, compact — works on
-// it unchanged.
-func runSessionsImport(store *sessions.Store, ref string, options sessionCommandOptions, stdout io.Writer, stderr io.Writer) int {
-	env := agentsessions.OSEnv()
-	adapter, id, err := agentsessions.ParseRef(env, ref)
-	if err != nil {
-		// The ref is user-supplied and echoed back by ParseRef's message.
-		return writeExecUsageError(stderr, agentsessions.DisplayField(err.Error()))
-	}
-
-	result, err := agentsessions.Import(store, adapter, id, agentsessions.ReadOptions{
-		MaxEvents:        options.maxEvents,
-		IncludeReasoning: options.includeReasoning,
-	})
-	if err != nil {
-		return writeAppError(stderr, agentsessions.DisplayField(err.Error()), exitCrash)
-	}
-
-	if options.json {
-		if err := writePrettyJSON(stdout, redaction.RedactValue(map[string]any{
-			"sessionId": result.Session.SessionID,
-			"title":     agentsessions.DisplayField(result.Session.Title),
-			"cwd":       agentsessions.DisplayField(result.Session.Cwd),
-			"events":    result.Events,
-			"source":    discoveredSnapshots([]agentsessions.ForeignSession{result.Source})[0],
-		}, redaction.Options{})); err != nil {
-			return exitCrash
-		}
-		return exitSuccess
-	}
-
-	lines := importSummaryLines(result)
-	if warning := importWorkspaceWarning(result.Source.Cwd); warning != "" {
-		lines = append(lines, "", warning)
-	}
-	lines = append(lines, "",
-		"Continue it with:",
-		"  zero exec --resume "+result.Session.SessionID+" \"Summarise where this left off and what remains\"",
-	)
-	if _, err := fmt.Fprintln(stdout, strings.Join(lines, "\n")); err != nil {
-		return exitCrash
-	}
-	return exitSuccess
-}
-
-// importSummaryLines renders the human-readable block for one import. The
-// --json branch beside it is structurally escaped and redacted; this is the one
-// that writes another product's bytes to a terminal, so every foreign field goes
-// through DisplayField.
-//
-// A SEPARATE FUNCTION SO THE SANITIZING CAN BE PROVED. The title and cwd come
-// back from a store that Import now cleans on the way in, so reached only
-// through runSessionsImport these calls are unobservable — a test would pass
-// with or without them and pin nothing. They are not redundant: Import began
-// sanitizing at this change, so every session imported by an earlier build still
-// holds exactly what the foreign transcript said, and this block is what draws
-// it. Taking an ImportResult directly is what lets a test supply that record.
-func importSummaryLines(result agentsessions.ImportResult) []string {
-	return []string{
-		"Imported " + result.Source.Agent + " session " + agentsessions.DisplayField(result.Source.ID),
-		"",
-		"  zero session: " + result.Session.SessionID,
-		"  title:        " + displayOrNone(agentsessions.DisplayField(result.Session.Title)),
-		"  cwd:          " + displayOrNone(agentsessions.DisplayField(result.Session.Cwd)),
-		fmt.Sprintf("  events:       %d", result.Events),
-	}
-}
-
-// importWorkspaceWarning flags a session that ran somewhere else. Resuming it
-// here is allowed — that is a reasonable thing to want — but the file paths in
-// its transcript will refer to a different tree, and silence about that is how
-// someone spends ten minutes wondering why nothing matches.
-func importWorkspaceWarning(sessionCwd string) string {
-	recorded := strings.TrimSpace(sessionCwd)
-	if recorded == "" {
-		return ""
-	}
-	working, err := os.Getwd()
-	if err != nil {
-		return ""
-	}
-	return importWorkspaceWarningForOS(recorded, working, runtime.GOOS)
-}
-
-func importWorkspaceWarningForOS(recorded string, working string, goos string) string {
-	if pathsEqualForOS(working, recorded, goos) {
-		return ""
-	}
-	// The comparison above runs on the recorded path because that is the
-	// functional question; the SENTENCE prints another agent's bytes, so it goes
-	// through the same sanitizer as every other displayed foreign field.
-	return "Note: this session ran in " + agentsessions.DisplayField(recorded) + ", not the current directory.\n" +
-		"      Paths mentioned in it refer to that tree."
-}
-
-func pathsEqualForOS(left string, right string, goos string) bool {
-	if goos == "windows" && windowsPathCategory(left) != windowsPathCategory(right) {
-		return false
-	}
-	left = cleanPathForOS(left, goos)
-	right = cleanPathForOS(right, goos)
-	if left == "." || right == "." {
-		return false
-	}
-	if goos == "windows" {
-		if strings.EqualFold(left, right) {
-			return true
-		}
-	} else if left == right {
-		return true
-	}
-	// Semantic identity is meaningful only when goos describes the host running
-	// the comparison. Tests also exercise foreign path syntax (for example,
-	// Windows paths on Unix), where handing those strings to os.Stat would inspect
-	// unrelated host paths. On the native host, SameFile recognizes symlinks,
-	// junctions, short names, and other aliases that lexical cleaning cannot.
-	if goos != runtime.GOOS {
-		return false
-	}
-	leftInfo, leftErr := os.Stat(left)
-	rightInfo, rightErr := os.Stat(right)
-	return leftErr == nil && rightErr == nil && os.SameFile(leftInfo, rightInfo)
-}
-
-func windowsPathCategory(value string) string {
-	value = strings.TrimSpace(strings.ReplaceAll(value, `\`, "/"))
-	if len(value) >= 2 && value[1] == ':' && ((value[0] >= 'a' && value[0] <= 'z') || (value[0] >= 'A' && value[0] <= 'Z')) {
-		if len(value) >= 3 && value[2] == '/' {
-			return "drive-rooted"
-		}
-		return "drive-relative"
-	}
-	if strings.HasPrefix(value, "//") {
-		return "unc"
-	}
-	if strings.HasPrefix(value, "/") {
-		return "root-relative"
-	}
-	return "relative"
-}
-
-func cleanPathForOS(value string, goos string) string {
-	value = strings.TrimSpace(value)
-	if goos == "windows" {
-		return path.Clean(strings.ReplaceAll(value, `\`, "/"))
-	}
-	return filepath.Clean(value)
-}
-
-func displayOrNone(value string) string {
-	if strings.TrimSpace(value) == "" {
-		return "(none)"
-	}
-	return value
-}
@@ -1,359 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/agentsessions"
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/zerocommands"
-)
-
-func writeImportFixture(t *testing.T, path string, content string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func isolateAgentSessionRoots(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	t.Setenv("APPDATA", filepath.Join(home, "AppData", "Roaming"))
-	t.Setenv("LOCALAPPDATA", filepath.Join(home, "AppData", "Local"))
-	t.Setenv("CLAUDE_CONFIG_DIR", filepath.Join(home, ".claude"))
-	t.Setenv("CODEX_HOME", filepath.Join(home, ".codex"))
-}
-
-func importUserRecord(t *testing.T, cwd, sessionID string) string {
-	t.Helper()
-	record, err := json.Marshal(map[string]any{
-		"type":      "user",
-		"cwd":       cwd,
-		"sessionId": sessionID,
-		"message":   map[string]any{"role": "user", "content": "hello"},
-	})
-	if err != nil {
-		t.Fatalf("marshal import fixture: %v", err)
-	}
-	return string(record) + "\n"
-}
-
-func TestSessionListSanitizesPersistedModelMetadata(t *testing.T) {
-	secret := "sk-ant-api03-" + strings.Repeat("A", 24)
-	line := formatSessionSnapshotLine(zerocommands.SessionSnapshot{
-		SessionID: "session-1",
-		ModelID:   "claude\x1b[2K-opus\n" + secret,
-		Tag:       "imported:codex:filename\x1b[2K\n" + secret,
-	})
-	if strings.Contains(line, "\x1b") || strings.Contains(line, secret) {
-		t.Fatalf("unsafe model metadata reached the session list: %q", line)
-	}
-	if !strings.Contains(line, "model=claude-opus [REDACTED]") {
-		t.Fatalf("session list lost safe model text: %q", line)
-	}
-	if !strings.Contains(line, "tag=imported:codex:filename [REDACTED]") {
-		t.Fatalf("session list did not sanitize the raw imported provenance tag: %q", line)
-	}
-}
-
-// THE HUMAN-READABLE SUMMARY IS ANOTHER PRODUCT'S BYTES ON A TERMINAL. The
-// --json branch above it is structurally escaped and redacted; this branch
-// printed the title and the cwd exactly as the foreign store wrote them, so an
-// escape repainted the block and a title — usually the user's first prompt, and
-// so the likeliest place for a pasted key — was shown verbatim. The listing
-// alongside it already sanitized every field it drew, which is what made the
-// omission easy to miss.
-func TestImportSummarySanitizesTheTitleAndCwdItPrints(t *testing.T) {
-	home := t.TempDir()
-	writeImportFixture(t, filepath.Join(home, ".claude", "projects", "-w", "hostile.jsonl"),
-		strings.Join([]string{
-			`{"type":"user","cwd":"/w/\u001b[2Kmoved/proj","sessionId":"hostile","message":{"role":"user","content":"hi"}}`,
-			`{"type":"ai-title","aiTitle":"rotate the key\nsk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA","sessionId":"hostile"}`,
-		}, "\n")+"\n")
-	// Every root the discovery code resolves, not only the redirect variable:
-	// claudeCodeRoot falls back to HOME, and the other three adapters have no
-	// redirect at all, so leaving HOME alone would index the developer's own
-	// transcripts.
-	isolateAgentSessionRoots(t, home)
-
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := runSessionsImport(store, "claude-code:hostile", sessionCommandOptions{}, stdout, stderr); code != exitSuccess {
-		t.Fatalf("import exited %d: %s", code, stderr.String())
-	}
-	out := stdout.String()
-
-	// Exact lines. "contains no escape" would pass for output that dropped the
-	// fields entirely, and the point is that they stay readable.
-	for _, want := range []string{
-		"  title:        rotate the key [REDACTED]\n",
-		"  cwd:          /w/moved/proj\n",
-	} {
-		if !strings.Contains(out, want) {
-			t.Errorf("import summary is missing %q:\n%s", want, out)
-		}
-	}
-	if strings.Contains(out, "\x1b") {
-		t.Errorf("a terminal escape reached the import summary:\n%q", out)
-	}
-	if strings.Contains(out, "sk-ant-api03-") {
-		t.Errorf("a credential-shaped title reached the import summary:\n%q", out)
-	}
-}
-
-// The warning is built from the recorded cwd, which is the same foreign bytes
-// one sentence later — CodeRabbit named it separately for that reason. Called
-// directly rather than through the command so the assertion is on the sentence
-// itself and cannot be satisfied by an earlier guard declining the input.
-func TestImportWorkspaceWarningSanitizesTheRecordedPath(t *testing.T) {
-	warning := importWorkspaceWarning("/elsewhere/\x1b[31mred\x1b[0m/proj")
-	const want = "Note: this session ran in /elsewhere/red/proj, not the current directory.\n" +
-		"      Paths mentioned in it refer to that tree."
-	if warning != want {
-		t.Errorf("warning = %q, want %q", warning, want)
-	}
-
-	// The comparison behind it still runs on the recorded path, so a session
-	// imported from this very directory stays silent.
-	working, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := importWorkspaceWarning(working); got != "" {
-		t.Errorf("a session recorded in the current directory warned anyway: %q", got)
-	}
-}
-
-func TestImportWorkspaceWarningUsesWindowsCaseInsensitivePaths(t *testing.T) {
-	if got := importWorkspaceWarningForOS(`C:\Work\Temp\..\Project`, `c:\work\project`, "windows"); got != "" {
-		t.Fatalf("Windows-equivalent paths produced a warning: %q", got)
-	}
-	if got := importWorkspaceWarningForOS(`/Work/Other`, `/work/project`, "windows"); got == "" {
-		t.Fatal("different Windows paths produced no warning")
-	}
-	if got := importWorkspaceWarningForOS(`C:`, `C:\`, "windows"); got == "" {
-		t.Fatal("drive-relative and drive-rooted Windows paths compared equal")
-	}
-	if got := importWorkspaceWarningForOS(`\\server\share`, `\server\share`, "windows"); got == "" {
-		t.Fatal("UNC and root-relative Windows paths compared equal")
-	}
-}
-
-func TestImportWorkspaceWarningRecognizesNativeDirectoryAliases(t *testing.T) {
-	realDir := t.TempDir()
-	alias := filepath.Join(t.TempDir(), "project-alias")
-	if err := os.Symlink(realDir, alias); err != nil {
-		t.Skipf("symlink unavailable: %v", err)
-	}
-	if got := importWorkspaceWarningForOS(realDir, alias, runtime.GOOS); got != "" {
-		t.Fatalf("same native directory through symlink produced warning: %q", got)
-	}
-	if got := importWorkspaceWarningForOS(realDir, t.TempDir(), runtime.GOOS); got == "" {
-		t.Fatal("distinct native directories produced no warning")
-	}
-}
-
-func TestRunSessionsDiscoverFiltersAgentAndWritesJSON(t *testing.T) {
-	home := t.TempDir()
-	workspace := filepath.Join(home, "workspace")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	writeImportFixture(t, filepath.Join(home, ".claude", "projects", "-workspace", "claude.jsonl"),
-		importUserRecord(t, workspace, "claude"))
-	isolateAgentSessionRoots(t, home)
-	previous, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chdir(workspace); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chdir(previous) })
-
-	for _, test := range []struct {
-		agent string
-		want  int
-	}{{agent: "claude-code", want: 1}, {agent: "codex", want: 0}} {
-		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-		code := runSessionsDiscover(sessionCommandOptions{agent: test.agent, json: true}, stdout, stderr)
-		if code != exitSuccess {
-			t.Fatalf("discover --agent %s exited %d: %s", test.agent, code, stderr.String())
-		}
-		var found []discoveredSnapshot
-		if err := json.Unmarshal(stdout.Bytes(), &found); err != nil {
-			t.Fatalf("discover JSON did not decode: %v\n%s", err, stdout.String())
-		}
-		if len(found) != test.want {
-			t.Fatalf("discover --agent %s returned %d rows, want %d: %+v", test.agent, len(found), test.want, found)
-		}
-	}
-}
-
-func TestSessionJSONCommandsNormalizeBidiFormatCharacters(t *testing.T) {
-	home := t.TempDir()
-	workspace := filepath.Join(home, "workspace")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	record, err := json.Marshal(map[string]any{
-		"type": "user", "cwd": workspace, "gitBranch": "fix/\u202ebidi", "sessionId": "bidi",
-		"message": map[string]any{"role": "user", "model": "model-\u202eunsafe", "content": "deploy \u202egnp.txt.exe"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	writeImportFixture(t, filepath.Join(home, ".claude", "projects", "-workspace", "bidi.jsonl"), string(record)+"\n")
-	isolateAgentSessionRoots(t, home)
-	previous, err := os.Getwd()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chdir(workspace); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = os.Chdir(previous) })
-
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := runSessionsDiscover(sessionCommandOptions{json: true}, stdout, stderr); code != exitSuccess {
-		t.Fatalf("discover exited %d: %s", code, stderr.String())
-	}
-	if strings.ContainsRune(stdout.String(), '\u202e') {
-		t.Fatalf("discover JSON retained a terminal-active format character: %q", stdout.String())
-	}
-	var discovered []discoveredSnapshot
-	if err := json.Unmarshal(stdout.Bytes(), &discovered); err != nil || len(discovered) != 1 {
-		t.Fatalf("decode discover JSON: rows=%d err=%v output=%s", len(discovered), err, stdout.String())
-	}
-	if discovered[0].Title != "deploy gnp.txt.exe" || discovered[0].GitBranch != "fix/bidi" || discovered[0].ModelID != "model-unsafe" {
-		t.Fatalf("discover JSON lost safe text while normalizing: %+v", discovered[0])
-	}
-
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-	stdout.Reset()
-	stderr.Reset()
-	if code := runSessionsImport(store, "claude-code:bidi", sessionCommandOptions{json: true}, stdout, stderr); code != exitSuccess {
-		t.Fatalf("import exited %d: %s", code, stderr.String())
-	}
-	if strings.ContainsRune(stdout.String(), '\u202e') {
-		t.Fatalf("import JSON retained a terminal-active format character: %q", stdout.String())
-	}
-	var imported struct {
-		Title  string             `json:"title"`
-		Source discoveredSnapshot `json:"source"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &imported); err != nil {
-		t.Fatalf("decode import JSON: %v\n%s", err, stdout.String())
-	}
-	if imported.Title != "deploy gnp.txt.exe" || imported.Source.GitBranch != "fix/bidi" || imported.Source.ModelID != "model-unsafe" {
-		t.Fatalf("import JSON lost safe text while normalizing: %+v", imported)
-	}
-}
-
-func TestRunSessionsImportRejectsEmptyTranslationsWithoutDurableState(t *testing.T) {
-	home := t.TempDir()
-	writeImportFixture(t, filepath.Join(home, ".claude", "projects", "-w", "empty.jsonl"),
-		`{"type":"user","cwd":"/w","sessionId":"empty","message":{"role":"user","content":""}}`+"\n")
-	isolateAgentSessionRoots(t, home)
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-
-	for attempt := 1; attempt <= 2; attempt++ {
-		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-		if code := runSessionsImport(store, "claude-code:empty", sessionCommandOptions{}, stdout, stderr); code != exitCrash {
-			t.Fatalf("attempt %d exited %d, want %d; stdout=%q stderr=%q", attempt, code, exitCrash, stdout.String(), stderr.String())
-		}
-		if !strings.Contains(stderr.String(), "no importable content") {
-			t.Fatalf("attempt %d did not explain the empty translation: %q", attempt, stderr.String())
-		}
-		metas, err := store.List()
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(metas) != 0 {
-			t.Fatalf("attempt %d left durable empty sessions: %+v", attempt, metas)
-		}
-	}
-}
-
-func TestRunSessionsImportReportsUsageAndReadFailures(t *testing.T) {
-	home := t.TempDir()
-	isolateAgentSessionRoots(t, home)
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: filepath.Join(t.TempDir(), "sessions")})
-
-	for _, test := range []struct {
-		ref      string
-		wantCode int
-	}{{ref: "unknown:id", wantCode: exitUsage}, {ref: "claude-code:missing", wantCode: exitCrash}} {
-		stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-		if code := runSessionsImport(store, test.ref, sessionCommandOptions{}, stdout, stderr); code != test.wantCode {
-			t.Fatalf("import %s exited %d, want %d; stderr=%q", test.ref, code, test.wantCode, stderr.String())
-		}
-		if stderr.Len() == 0 {
-			t.Fatalf("import %s failed without an error message", test.ref)
-		}
-	}
-}
-
-// A SESSION IMPORTED BY AN EARLIER BUILD STILL HOLDS THE RAW BYTES. Import only
-// began sanitizing what it stores at this change, so the summary has to clean
-// its own output rather than trust the record — and through runSessionsImport
-// that is unobservable, because the session it just wrote is already clean. This
-// supplies the record an older build left behind.
-func TestTheImportSummaryCleansAStoredTitleAndCwdItDidNotWrite(t *testing.T) {
-	result := agentsessions.ImportResult{
-		Session: sessions.Metadata{
-			SessionID: "zero_1",
-			Title:     "rotate the key\nsk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA",
-			Cwd:       "/w/\x1b[2Kmoved/proj",
-		},
-		Events: 3,
-		Source: agentsessions.ForeignSession{Agent: "claude-code", ID: "abc\x1b[2Kdef"},
-	}
-	got := importSummaryLines(result)
-	want := []string{
-		"Imported claude-code session abcdef",
-		"",
-		"  zero session: zero_1",
-		"  title:        rotate the key [REDACTED]",
-		"  cwd:          /w/moved/proj",
-		"  events:       3",
-	}
-	if len(got) != len(want) {
-		t.Fatalf("summary has %d lines, want %d: %q", len(got), len(want), got)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Errorf("line %d = %q, want %q", i, got[i], want[i])
-		}
-	}
-}
-
-// An empty title and cwd still read as "(none)" rather than as a blank column —
-// sanitizing must not have swallowed the placeholder.
-func TestTheImportSummaryStillSaysNoneForAnEmptyTitleAndCwd(t *testing.T) {
-	got := importSummaryLines(agentsessions.ImportResult{
-		Session: sessions.Metadata{SessionID: "zero_1"},
-		Source:  agentsessions.ForeignSession{Agent: "codex", ID: "x"},
-	})
-	for _, want := range []string{"  title:        (none)", "  cwd:          (none)"} {
-		found := false
-		for _, line := range got {
-			if line == want {
-				found = true
-			}
-		}
-		if !found {
-			t.Errorf("summary is missing %q: %q", want, got)
-		}
-	}
-}
@@ -0,0 +1,171 @@
+package cli
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/config"
+	"github.com/Gitlawb/zero/internal/redaction"
+	"github.com/Gitlawb/zero/internal/sessions"
+)
+
+// maxPruneDays keeps a day count from overflowing time.Duration.
+const maxPruneDays = 36500
+
+// runSessionsPrune removes sessions last updated before a cutoff, or with
+// --dry-run lists what would go and why. It runs only when asked (#971).
+func runSessionsPrune(store *sessions.Store, options sessionCommandOptions, stdout io.Writer, stderr io.Writer, deps appDeps) int {
+	olderThan, err := pruneCutoff(options, deps)
+	if err != nil {
+		return writeExecUsageError(stderr, err.Error())
+	}
+	report, err := store.Prune(sessions.PruneOptions{OlderThan: olderThan, DryRun: options.dryRun})
+	if err != nil {
+		return writeSessionCommandError(stderr, err)
+	}
+	if options.json {
+		if err := writePrettyJSON(stdout, redaction.RedactValue(report, redaction.Options{})); err != nil {
+			return exitCrash
+		}
+	} else if _, err := fmt.Fprint(stdout, formatPruneReport(report)); err != nil {
+		return exitCrash
+	}
+	if len(report.Failed) > 0 {
+		return exitCrash
+	}
+	return exitSuccess
+}
+
+// pruneCutoff is --older-than, or else sessions.retentionDays from the user's
+// own config, and never below sessions.MinimumPruneAge. Project config has no
+// say in it: see config.SessionsConfig.
+func pruneCutoff(options sessionCommandOptions, deps appDeps) (time.Duration, error) {
+	var age time.Duration
+	if options.olderThan != "" {
+		parsed, err := parsePruneAge(options.olderThan)
+		if err != nil {
+			return 0, err
+		}
+		age = parsed
+	} else {
+		days := 0
+		if deps.userConfigPath != nil {
+			path, err := deps.userConfigPath()
+			if err != nil {
+				return 0, fmt.Errorf("sessions prune could not find your config: %w", err)
+			}
+			settings, err := config.ReadSessionsConfig(path)
+			if err != nil {
+				return 0, fmt.Errorf("sessions prune could not read sessions.retentionDays: %w", err)
+			}
+			days = settings.RetentionDays
+		}
+		if days == 0 {
+			return 0, execUsageError{"sessions prune needs a cutoff: pass --older-than (for example --older-than 30d) or set sessions.retentionDays in your user config"}
+		}
+		if days > maxPruneDays {
+			return 0, execUsageError{fmt.Sprintf("sessions.retentionDays %d is more than %d", days, maxPruneDays)}
+		}
+		age = time.Duration(days) * 24 * time.Hour
+	}
+	if age < sessions.MinimumPruneAge {
+		return 0, execUsageError{fmt.Sprintf("sessions prune does not remove anything updated in the last %d hours; use --older-than 1d or more", int(sessions.MinimumPruneAge.Hours()))}
+	}
+	return age, nil
+}
+
+// parsePruneAge accepts a whole number of days ("30d") or a Go duration
+// ("720h").
+func parsePruneAge(value string) (time.Duration, error) {
+	invalid := execUsageError{fmt.Sprintf("invalid --older-than %q: expected days like 30d or a duration like 720h", value)}
+	trimmed := strings.TrimSpace(value)
+	if days, ok := strings.CutSuffix(trimmed, "d"); ok {
+		count, err := strconv.Atoi(days)
+		if err != nil || count <= 0 || count > maxPruneDays {
+			return 0, invalid
+		}
+		return time.Duration(count) * 24 * time.Hour, nil
+	}
+	age, err := time.ParseDuration(trimmed)
+	if err != nil || age <= 0 {
+		return 0, invalid
+	}
+	return age, nil
+}
+
+func formatPruneReport(report sessions.PruneReport) string {
+	var out strings.Builder
+	verb := "Removed"
+	if report.DryRun {
+		verb = "Would remove"
+	}
+	if len(report.Removed) == 0 {
+		fmt.Fprintf(&out, "No sessions to remove: nothing last updated before %s can go.\n", report.Cutoff)
+	} else {
+		var total int64
+		for _, entry := range report.Removed {
+			total += entry.Bytes
+		}
+		fmt.Fprintf(&out, "%s %d %s last updated before %s (%s):\n", verb, len(report.Removed), plural(len(report.Removed), "session", "sessions"), report.Cutoff, formatPruneBytes(total))
+		for _, entry := range report.Removed {
+			fmt.Fprintf(&out, "  %s\n", formatPruneEntry(entry, redact(entry.Title)))
+		}
+	}
+	if len(report.Kept) > 0 {
+		fmt.Fprintf(&out, "Kept %d old enough to remove:\n", len(report.Kept))
+		for _, entry := range report.Kept {
+			fmt.Fprintf(&out, "  %s\n", formatPruneEntry(entry, entry.Reason))
+		}
+	}
+	if len(report.Failed) > 0 {
+		failed := "Could not remove"
+		if report.DryRun {
+			failed = "Could not check"
+		}
+		fmt.Fprintf(&out, "%s %d:\n", failed, len(report.Failed))
+		for _, entry := range report.Failed {
+			fmt.Fprintf(&out, "  %s\n", formatPruneEntry(entry, redact(entry.Reason)))
+		}
+	}
+	if report.DryRun {
+		out.WriteString("Dry run: nothing was removed.\n")
+	}
+	return out.String()
+}
+
+func formatPruneEntry(entry sessions.PruneEntry, note string) string {
+	updated := entry.UpdatedAt
+	if len(updated) >= len("2006-01-02") {
+		updated = updated[:len("2006-01-02")]
+	}
+	line := redact(entry.SessionID) + "  " + updated
+	if note = strings.TrimSpace(note); note != "" {
+		line += "  " + note
+	}
+	return line
+}
+
+func formatPruneBytes(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d B", bytes)
+	}
+	value, suffix := float64(bytes)/unit, "KB"
+	for _, next := range []string{"MB", "GB", "TB"} {
+		if value < unit {
+			break
+		}
+		value, suffix = value/unit, next
+	}
+	return fmt.Sprintf("%.1f %s", value, suffix)
+}
+
+func plural(count int, one, many string) string {
+	if count == 1 {
+		return one
+	}
+	return many
+}
@@ -0,0 +1,220 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/sessions"
+)
+
+// pruneCLIFixture is a session root holding one session last written in 2020
+// and one written now, neither held open, plus deps whose user config path is
+// the returned file (which does not exist until a test writes it).
+func pruneCLIFixture(t *testing.T) (string, string, appDeps) {
+	t.Helper()
+	root := t.TempDir()
+	for _, session := range []struct {
+		id string
+		at func() time.Time
+	}{
+		{"old-session", func() time.Time { return time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) }},
+		{"recent-session", time.Now},
+	} {
+		store := sessions.NewStore(sessions.StoreOptions{RootDir: root, Now: session.at})
+		if _, err := store.Create(sessions.CreateInput{SessionID: session.id, Title: "title of " + session.id}); err != nil {
+			t.Fatalf("create %s: %v", session.id, err)
+		}
+		store.Release(session.id)
+	}
+	configPath := filepath.Join(t.TempDir(), "config.json")
+	deps := appDeps{
+		newSessionStore: func() *sessions.Store { return sessions.NewStore(sessions.StoreOptions{RootDir: root}) },
+		userConfigPath:  func() (string, error) { return configPath, nil },
+	}
+	return root, configPath, deps
+}
+
+func runPruneCLI(t *testing.T, deps appDeps, args ...string) (int, string, string) {
+	t.Helper()
+	var stdout, stderr bytes.Buffer
+	code := runWithDeps(append([]string{"sessions"}, args...), &stdout, &stderr, deps)
+	return code, stdout.String(), stderr.String()
+}
+
+func pruneSessionExists(t *testing.T, root, id string) bool {
+	t.Helper()
+	_, err := os.Stat(filepath.Join(root, id))
+	return err == nil
+}
+
+func TestSessionsPruneDryRunListsWithoutRemoving(t *testing.T) {
+	root, _, deps := pruneCLIFixture(t)
+	code, stdout, stderr := runPruneCLI(t, deps, "prune", "--older-than", "30d", "--dry-run")
+	if code != exitSuccess {
+		t.Fatalf("exit %d, stderr %q", code, stderr)
+	}
+	for _, want := range []string{"Would remove 1 session", "old-session", "Dry run: nothing was removed."} {
+		if !strings.Contains(stdout, want) {
+			t.Errorf("output does not contain %q:\n%s", want, stdout)
+		}
+	}
+	if strings.Contains(stdout, "recent-session") {
+		t.Errorf("the recent session was listed:\n%s", stdout)
+	}
+	if !pruneSessionExists(t, root, "old-session") {
+		t.Fatal("a dry run removed the session")
+	}
+}
+
+// A dry run removes nothing, so a session it could not check is not reported
+// as one it could not remove.
+func TestSessionsPruneDryRunReportsFailuresAsUnchecked(t *testing.T) {
+	failed := []sessions.PruneEntry{{SessionID: "old-session", UpdatedAt: "2020-01-01T00:00:00Z", Reason: "the session disappeared while pruning"}}
+	dryRun := formatPruneReport(sessions.PruneReport{Cutoff: "2026-08-27T00:00:00Z", DryRun: true, Failed: failed})
+	if !strings.Contains(dryRun, "Could not check 1:") || strings.Contains(dryRun, "Could not remove") {
+		t.Errorf("dry run report:\n%s", dryRun)
+	}
+	run := formatPruneReport(sessions.PruneReport{Cutoff: "2026-08-27T00:00:00Z", Failed: failed})
+	if !strings.Contains(run, "Could not remove 1:") {
+		t.Errorf("report:\n%s", run)
+	}
+}
+
+func TestSessionsPruneRemovesOnlyOldSessions(t *testing.T) {
+	root, _, deps := pruneCLIFixture(t)
+	code, stdout, stderr := runPruneCLI(t, deps, "prune", "--older-than=30d")
+	if code != exitSuccess {
+		t.Fatalf("exit %d, stderr %q", code, stderr)
+	}
+	if !strings.Contains(stdout, "Removed 1 session") || !strings.Contains(stdout, "old-session") {
+		t.Fatalf("output does not report the removal:\n%s", stdout)
+	}
+	if pruneSessionExists(t, root, "old-session") {
+		t.Fatal("the old session is still there")
+	}
+	if !pruneSessionExists(t, root, "recent-session") {
+		t.Fatal("the recent session was removed")
+	}
+}
+
+func TestSessionsPruneReportsJSON(t *testing.T) {
+	_, _, deps := pruneCLIFixture(t)
+	code, stdout, stderr := runPruneCLI(t, deps, "prune", "--older-than", "720h", "--json")
+	if code != exitSuccess {
+		t.Fatalf("exit %d, stderr %q", code, stderr)
+	}
+	var report sessions.PruneReport
+	if err := json.Unmarshal([]byte(stdout), &report); err != nil {
+		t.Fatalf("output is not a prune report: %v\n%s", err, stdout)
+	}
+	if len(report.Removed) != 1 || report.Removed[0].SessionID != "old-session" || report.DryRun {
+		t.Fatalf("report = %+v", report)
+	}
+}
+
+func TestSessionsPruneRefusesABadOrShortCutoff(t *testing.T) {
+	root, _, deps := pruneCLIFixture(t)
+	for _, tc := range []struct {
+		value string
+		want  string
+	}{
+		{"12h", "last 24 hours"},
+		{"0d", "invalid --older-than"},
+		{"soon", "invalid --older-than"},
+		{"-5d", "invalid --older-than"},
+	} {
+		code, _, stderr := runPruneCLI(t, deps, "prune", "--older-than="+tc.value)
+		if code != exitUsage || !strings.Contains(stderr, tc.want) {
+			t.Errorf("--older-than %s: exit %d, stderr %q, want a usage error naming %q", tc.value, code, stderr, tc.want)
+		}
+	}
+	if !pruneSessionExists(t, root, "old-session") {
+		t.Fatal("a refused prune removed a session")
+	}
+}
+
+func TestSessionsPruneNeedsACutoff(t *testing.T) {
+	root, _, deps := pruneCLIFixture(t)
+	code, _, stderr := runPruneCLI(t, deps, "prune")
+	if code != exitUsage || !strings.Contains(stderr, "needs a cutoff") {
+		t.Fatalf("exit %d, stderr %q, want a usage error asking for a cutoff", code, stderr)
+	}
+	if !pruneSessionExists(t, root, "old-session") {
+		t.Fatal("prune without a cutoff removed a session")
+	}
+}
+
+func TestSessionsPruneUsesTheUserRetentionSetting(t *testing.T) {
+	root, configPath, deps := pruneCLIFixture(t)
+	if err := os.WriteFile(configPath, []byte(`{"sessions":{"retentionDays":30}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	code, stdout, stderr := runPruneCLI(t, deps, "prune")
+	if code != exitSuccess {
+		t.Fatalf("exit %d, stderr %q", code, stderr)
+	}
+	if !strings.Contains(stdout, "Removed 1 session") || pruneSessionExists(t, root, "old-session") {
+		t.Fatalf("the user retention setting was not applied:\n%s", stdout)
+	}
+}
+
+// A REPOSITORY CANNOT CHOOSE WHAT PRUNE DELETES. Sessions are the user's, not
+// the project's, so sessions.retentionDays in a workspace's .zero/config.json
+// is not a cutoff, even when prune runs from inside that workspace.
+func TestSessionsPruneIgnoresRetentionInProjectConfig(t *testing.T) {
+	root, _, deps := pruneCLIFixture(t)
+	workspace := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(workspace, ".zero"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, ".zero", "config.json"), []byte(`{"sessions":{"retentionDays":1}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	deps.getwd = func() (string, error) { return workspace, nil }
+	t.Chdir(workspace)
+
+	code, _, stderr := runPruneCLI(t, deps, "prune")
+	if code != exitUsage || !strings.Contains(stderr, "needs a cutoff") {
+		t.Fatalf("exit %d, stderr %q: the project's retention setting was used", code, stderr)
+	}
+	if !pruneSessionExists(t, root, "old-session") {
+		t.Fatal("a project config setting removed a session")
+	}
+}
+
+func TestSessionsPruneFlagsBelongToPrune(t *testing.T) {
+	_, _, deps := pruneCLIFixture(t)
+	for _, args := range [][]string{{"list", "--dry-run"}, {"list", "--older-than", "30d"}} {
+		code, _, stderr := runPruneCLI(t, deps, args...)
+		if code != exitUsage || !strings.Contains(stderr, "only valid for sessions prune") {
+			t.Errorf("%v: exit %d, stderr %q", args, code, stderr)
+		}
+	}
+}
+
+// An empty cutoff is a usage error, never a fall back to sessions.retentionDays.
+func TestSessionsPruneRejectsAnEmptyCutoff(t *testing.T) {
+	root, configPath, deps := pruneCLIFixture(t)
+	if err := os.WriteFile(configPath, []byte(`{"sessions":{"retentionDays":1}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	for _, args := range [][]string{
+		{"prune", "--older-than", ""},
+		{"prune", "--older-than", "   "},
+		{"prune", "--older-than="},
+		{"list", "--older-than", ""},
+	} {
+		code, _, stderr := runPruneCLI(t, deps, args...)
+		if code != exitUsage || !strings.Contains(stderr, "--older-than requires a value") {
+			t.Errorf("%q: exit %d, stderr %q, want a usage error", args, code, stderr)
+		}
+	}
+	if !pruneSessionExists(t, root, "old-session") {
+		t.Fatal("an empty cutoff fell back to the retention setting and removed a session")
+	}
+}
@@ -62,6 +62,10 @@ func TestCLILaunchHelpersLeaveUserStateAlone(t *testing.T) {
 		{"execAdvertisesEscalateModel", func(t *testing.T) {
 			_ = execAdvertisesEscalateModel(t, []string{"--allow-escalation", "exec", "say hi"})
 		}},
+		{"runExecWithSandbox", func(t *testing.T) {
+			_, _, _ = runExecWithSandbox(t, []string{"exec", "hello"}, unavailableTestSandbox, config.SandboxConfig{})
+		}},
+		{"launchTUIWithSandbox", func(t *testing.T) { _ = launchTUIWithSandbox(t, config.SandboxConfig{}) }},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
 			seedRoot, configPath, seeded, before := seedEmulatedUserConfig(t)
@@ -244,6 +244,86 @@ func petJSONObject(encodedPet []byte) []byte {
 	return append(result, '}')
 }

+// setNotifyJSONObject replaces only the notify member's value, keeping the
+// original bytes of every unrelated member so a notification save cannot
+// reorder, reformat, or drop the user's other settings — including values whose
+// EXPLICIT presence matters (tools.deferThreshold: 0, mcp servers'
+// disabled: false) and keys the typed FileConfig does not model at all. The
+// typed serializer cannot round-trip explicit zeros (omitempty drops them), so
+// notification writes go through this byte-preserving editor instead
+// (maintainer review, PR #1001). An empty notify block removes the member
+// entirely so a reset leaves no `"notify": {}` husk behind.
+//
+// A hand-edited file may contain DUPLICATE notify members. Go's decoder
+// MERGES the fields of duplicate object members into the same struct, so an
+// earlier duplicate's field survives a replacement that omits it — e.g.
+// {"notify":{"mode":"off"},"notify":{"focusMode":"focused"}} + a
+// replacement {"focusMode":"always"} would leave mode "off" effective.
+// The nonempty path therefore removes EVERY duplicate and inserts the
+// replacement fresh (full-replace semantics: nothing inherited), and the
+// reset path removes every member the same way. UpdateNotify's partial
+// merge is unaffected: it seeds omitted fields from the stored value BEFORE
+// calling this editor, so the value it passes is already complete.
+// Mirrors setPetPreferenceJSON's duplicate handling.
+func setNotifyJSONObject(data []byte, notify NotifyConfig) ([]byte, error) {
+	encoded, err := json.Marshal(notify)
+	if err != nil {
+		return nil, fmt.Errorf("encode notify preference: %w", err)
+	}
+
+	rootStart := skipJSONSpace(data, 0)
+	root, err := parseJSONObject(data, rootStart)
+	if err != nil {
+		return nil, err
+	}
+	notifyIndex := lastJSONMember(root.members, "notify")
+	// Count duplicates: the ordinary file has exactly one notify member, and
+	// for it a positional replace keeps the key where the user put it and
+	// preserves their formatting (byte-preserving contract). The
+	// remove-all-and-reinsert path below is ONLY for files that actually
+	// contain duplicates, where Go's field-merging decode would otherwise let
+	// an earlier block's fields leak into the replacement.
+	duplicates := 0
+	for _, member := range root.members {
+		if member.key == "notify" {
+			duplicates++
+		}
+	}
+	if string(encoded) == "{}" {
+		for notifyIndex >= 0 {
+			data = removeJSONMember(data, root, notifyIndex)
+			rootStart = skipJSONSpace(data, 0)
+			root, err = parseJSONObject(data, rootStart)
+			if err != nil {
+				return nil, err
+			}
+			notifyIndex = lastJSONMember(root.members, "notify")
+		}
+		return data, nil
+	}
+	if duplicates <= 1 {
+		if notifyIndex < 0 {
+			return insertJSONMember(data, root, "notify", encoded), nil
+		}
+		// Single member: replace its value in place — no key movement, no
+		// reformatting of the surrounding bytes.
+		return replaceJSONRange(data, root.members[notifyIndex].valueStart, root.members[notifyIndex].valueEnd, encoded), nil
+	}
+	// Multiple duplicates: Go merges their fields at decode time, so the
+	// replacement must not inherit anything — remove every duplicate and
+	// insert the complete value fresh.
+	for notifyIndex >= 0 {
+		data = removeJSONMember(data, root, notifyIndex)
+		rootStart = skipJSONSpace(data, 0)
+		root, err = parseJSONObject(data, rootStart)
+		if err != nil {
+			return nil, err
+		}
+		notifyIndex = lastJSONMember(root.members, "notify")
+	}
+	return insertJSONMember(data, root, "notify", encoded), nil
+}
+
 func replaceJSONRange(data []byte, start, end int, replacement []byte) []byte {
 	result := make([]byte, 0, len(data)-(end-start)+len(replacement))
 	result = append(result, data[:start]...)
@@ -0,0 +1,48 @@
+package config
+
+import (
+	"fmt"
+	"github.com/Gitlawb/zero/internal/modelregistry"
+	"strings"
+)
+
+func normalizeModelRPM(limits map[string]int) (map[string]int, error) {
+	if len(limits) == 0 {
+		return nil, nil
+	}
+	registry, err := modelregistry.DefaultRegistry()
+	if err != nil {
+		return nil, err
+	}
+	out := make(map[string]int, len(limits))
+	for key, n := range limits {
+		model := strings.TrimSpace(key)
+		if model == "" || n < 0 {
+			return nil, fmt.Errorf("invalid modelRPM entry %q: model must be non-empty and limit >= 0", key)
+		}
+		if id, ok := registry.ResolveID(model); ok {
+			model = id
+		}
+		if old, exists := out[model]; exists && old != n {
+			return nil, fmt.Errorf("conflicting modelRPM entries resolve to %q", model)
+		}
+		out[model] = n
+	}
+	return out, nil
+}
+
+// Project config can tighten a user cap but cannot relax it.
+func mergeModelRPM(dst *map[string]int, src map[string]int, tighten bool) {
+	if len(src) == 0 {
+		return
+	}
+	if *dst == nil {
+		*dst = make(map[string]int)
+	}
+	for model, n := range src {
+		old := (*dst)[model]
+		if !tighten || old == 0 || (n > 0 && n < old) {
+			(*dst)[model] = n
+		}
+	}
+}
@@ -0,0 +1,54 @@
+package config
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func TestModelRPMRoundTrip(t *testing.T) {
+	var c FileConfig
+	if e := json.Unmarshal([]byte(`{"modelRPM":{" OPENAI:GPT-4.1 ":2,"custom":0},"future":true}`), &c); e != nil {
+		t.Fatal(e)
+	}
+	want := map[string]int{"gpt-4.1": 2, "custom": 0}
+	if !reflect.DeepEqual(c.ModelRPM, want) {
+		t.Fatal(c.ModelRPM)
+	}
+	b, e := json.Marshal(c)
+	if e != nil {
+		t.Fatal(e)
+	}
+	var d FileConfig
+	if e = json.Unmarshal(b, &d); e != nil {
+		t.Fatal(e)
+	}
+	if !reflect.DeepEqual(d.ModelRPM, want) || string(d.Extra["future"]) != "true" {
+		t.Fatalf("round trip=%s", b)
+	}
+}
+func TestModelRPMInvalid(t *testing.T) {
+	for _, s := range []string{`{"modelRPM":{"":1}}`, `{"modelRPM":{"a":-1}}`, `{"modelRPM":{"a":1.5}}`, `{"modelRPM":{"a":"2"}}`, `{"modelRPM":{"gpt-4.1":1,"openai:gpt-4.1":2}}`} {
+		var c FileConfig
+		if e := json.Unmarshal([]byte(s), &c); e == nil {
+			t.Fatalf("accepted %s", s)
+		}
+	}
+}
+func TestModelRPMProjectCanOnlyTighten(t *testing.T) {
+	user := writeConfig(t, `{"modelRPM":{"gpt-4.1":2},"activeProvider":"test","providers":[{"name":"test","provider":"openai","model":"gpt-4.1"}]}`)
+	for _, n := range []string{"0", "1", "5"} {
+		project := writeConfig(t, `{"modelRPM":{"openai:gpt-4.1":`+n+`}}`)
+		c, e := Resolve(ResolveOptions{UserConfigPath: user, ProjectConfigPath: project, Env: map[string]string{}})
+		if e != nil {
+			t.Fatal(e)
+		}
+		want := 2
+		if n == "1" {
+			want = 1
+		}
+		if c.ModelRPM["gpt-4.1"] != want {
+			t.Fatal(c.ModelRPM)
+		}
+	}
+}
@@ -104,6 +104,9 @@ func Resolve(options ResolveOptions) (ResolvedConfig, error) {
 		// trusted global-config merge, which must keep honouring the setting.
 		commandConfig.Sandbox.Enabled = nil
 		commandConfig.CrossSessionInbound = ""
+		// External provider commands cannot relax the user cap.
+		mergeModelRPM(&cfg.ModelRPM, commandConfig.ModelRPM, true)
+		commandConfig.ModelRPM = nil
 		mergeConfig(&cfg, commandConfig)
 	}

@@ -157,11 +160,31 @@ func Resolve(options ResolveOptions) (ResolvedConfig, error) {
 		// On ErrNoActiveProvider, providers may still hold the successfully
 		// normalized (but active-less) profile list — keep it so a caller can fall
 		// back to an already-configured usable provider instead of treating this
-		// like a config with nothing set up at all.
-		return ResolvedConfig{Providers: providers}, err
+		// like a config with nothing set up at all. The non-provider fields parsed
+		// before the failure (notify, sandbox, tools, preferences, ...) are kept
+		// too: the TUI's provider-recovery path forwards this partial config, and
+		// dropping them would let the TUI's unconfigured notify default overwrite
+		// a stored explicit opt-out on startup (maintainer review, PR #1001).
+		partial := ResolvedConfig{
+			ModelRPM:            cfg.ModelRPM,
+			Providers:           providers,
+			MaxTurns:            cfg.MaxTurns,
+			MCP:                 cfg.MCP,
+			Sandbox:             cfg.Sandbox,
+			Notify:              cfg.Notify,
+			Tools:               cfg.Tools,
+			Swarm:               cfg.Swarm,
+			Preferences:         cfg.Preferences,
+			KeyBindings:         cfg.KeyBindings,
+			LocalControl:        cfg.LocalControl,
+			STT:                 cfg.STT,
+			CrossSessionInbound: cfg.CrossSessionInbound,
+		}
+		return partial, err
 	}

 	return ResolvedConfig{
+		ModelRPM:            cfg.ModelRPM,
 		ActiveProvider:      active.Name,
 		Providers:           providers,
 		Provider:            active,
@@ -230,6 +253,7 @@ func loadConfigFile(path string) (FileConfig, error) {
 }

 func mergeConfig(dst *FileConfig, src FileConfig) {
+	mergeModelRPM(&dst.ModelRPM, src.ModelRPM, false)
 	if activeProvider := strings.TrimSpace(src.ActiveProvider); activeProvider != "" {
 		dst.ActiveProvider = activeProvider
 	}
@@ -291,6 +315,7 @@ func mergeConfig(dst *FileConfig, src FileConfig) {
 }

 func mergeProjectConfig(dst *FileConfig, src FileConfig) error {
+	mergeModelRPM(&dst.ModelRPM, src.ModelRPM, true)
 	if activeProvider := strings.TrimSpace(src.ActiveProvider); activeProvider != "" {
 		dst.ActiveProvider = activeProvider
 	}
@@ -1109,6 +1109,34 @@ func TestResolveProviderCommandOverridesEnvProviderFields(t *testing.T) {
 	}
 }

+func TestResolveProviderCommandCannotRelaxUserModelRPM(t *testing.T) {
+	userPath := writeConfig(t, `{
+		"modelRPM": {
+			"gpt-command": 5
+		}
+	}`)
+
+	command := writeCommand(t, commandScript{
+		Stdout: `{"activeProvider":"cmd","providers":[{"name":"cmd","provider":"openai","apiKey":"sk-command","model":"gpt-command"}],"modelRPM":{"gpt-command":10}}`,
+	})
+
+	resolved, err := Resolve(ResolveOptions{
+		UserConfigPath:  userPath,
+		ProviderCommand: command,
+		Env:             map[string]string{},
+	})
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+
+	if got := resolved.ModelRPM["gpt-command"]; got != 5 {
+		t.Fatalf(
+			"ModelRPM[gpt-command] = %d, want user cap 5 preserved against provider-command relaxation",
+			got,
+		)
+	}
+}
+
 func TestResolveAllowsNoConfiguredProviders(t *testing.T) {
 	resolved, err := Resolve(ResolveOptions{Env: map[string]string{}})
 	if err != nil {
@@ -1151,8 +1179,13 @@ func TestResolveRejectsActiveProviderWithoutConfiguredProfiles(t *testing.T) {
 	if HasProviderProfile(resolved.Provider) {
 		t.Fatalf("Provider = %#v, want zero value", resolved.Provider)
 	}
-	if resolved.MaxTurns != 0 {
-		t.Fatalf("MaxTurns = %d, want zero on failed resolve", resolved.MaxTurns)
+	// The error path now carries the parsed non-provider fields through
+	// (maintainer review, PR #1001): the TUI's provider-recovery startup
+	// forwards this partial config, and a zero MaxTurns there would silently
+	// discard the user's turn budget. Matches the no-providers SUCCESS path,
+	// which has always defaulted MaxTurns.
+	if resolved.MaxTurns != defaultMaxTurns {
+		t.Fatalf("MaxTurns = %d, want default %d carried through the partial resolve", resolved.MaxTurns, defaultMaxTurns)
 	}
 }

@@ -1161,10 +1194,13 @@ func TestResolveKeepsNormalizedProvidersWhenNoneMarkedActive(t *testing.T) {
 	// activeProvider is blank/stale — a caller like the interactive TUI still
 	// needs the normalized list to fall back to an already-usable provider
 	// instead of forcing a full re-onboarding wizard.
-	path := writeConfig(t, `{"providers":[
-		{"name":"work","provider_kind":"openai","apiKey":"sk-test","model":"gpt-test"},
-		{"name":"other","provider_kind":"openai","apiKey":"sk-other","model":"gpt-test"}
-	]}`)
+	path := writeConfig(t, `{
+    "modelRPM":{"gpt-test":1},
+    "providers":[
+        {"name":"work","provider_kind":"openai","apiKey":"sk-test","model":"gpt-test"},
+        {"name":"other","provider_kind":"openai","apiKey":"sk-other","model":"gpt-test"}
+    ]
+}`)

 	resolved, err := Resolve(ResolveOptions{ProjectConfigPath: path, Env: map[string]string{}})
 	if !errors.Is(err, ErrNoActiveProvider) {
@@ -1173,6 +1209,9 @@ func TestResolveKeepsNormalizedProvidersWhenNoneMarkedActive(t *testing.T) {
 	if len(resolved.Providers) != 2 {
 		t.Fatalf("Providers = %#v, want the 2 normalized profiles preserved despite the error", resolved.Providers)
 	}
+	if got := resolved.ModelRPM["gpt-test"]; got != 1 {
+		t.Fatalf("ModelRPM[gpt-test] = %d, want 1 preserved despite ErrNoActiveProvider", got)
+	}
 }

 func TestResolveTrimsProviderProfileAliasesBeforeFallback(t *testing.T) {
@@ -1864,14 +1903,43 @@ func TestResolveNotifyInvalidFocusMode(t *testing.T) {
 	}
 }

-func TestResolveNotifyDefaultEmpty(t *testing.T) {
-	path := writeConfig(t, `{}`)
-	resolved, err := Resolve(ResolveOptions{UserConfigPath: path, Env: map[string]string{}})
+// An unconfigured notify block must resolve EMPTY. Defaults live in the TUI
+// (effectiveTUINotifyMode) and in `zero config notify`'s display, not in the
+// resolver: a filled-in default here leaks into headless `zero exec` (BEL +
+// OSC-9 bytes on stderr under -o json) and into the CLI/TUI preserve paths,
+// which must treat "user never chose" differently from "user chose both"
+// (maintainer review, PR #1001).
+func TestResolveNotifyUnconfiguredStaysEmpty(t *testing.T) {
+	// No config file at all.
+	resolved, err := Resolve(ResolveOptions{Env: map[string]string{}})
 	if err != nil {
 		t.Fatalf("Resolve: %v", err)
 	}
 	if resolved.Notify.Mode != "" || resolved.Notify.FocusMode != "" {
-		t.Fatalf("unset notify should be empty, got %+v", resolved.Notify)
+		t.Fatalf("no config file: notify = %+v, want empty (resolver must not default)", resolved.Notify)
+	}
+
+	for name, body := range map[string]string{
+		"empty config": `{}`,
+		"empty block":  `{"notify":{}}`,
+		"mode only":    `{"notify":{"mode":"off"}}`,
+	} {
+		t.Run(name, func(t *testing.T) {
+			resolved, err := Resolve(ResolveOptions{UserConfigPath: writeConfig(t, body), Env: map[string]string{}})
+			if err != nil {
+				t.Fatalf("Resolve: %v", err)
+			}
+			if name == "mode only" {
+				if resolved.Notify.Mode != "off" {
+					t.Errorf("notify.mode = %q, want preserved off", resolved.Notify.Mode)
+				}
+			} else if resolved.Notify.Mode != "" {
+				t.Errorf("notify.mode = %q, want empty (resolver must not default)", resolved.Notify.Mode)
+			}
+			if resolved.Notify.FocusMode != "" {
+				t.Errorf("notify.focusMode = %q, want empty (resolver must not default)", resolved.Notify.FocusMode)
+			}
+		})
 	}
 }

@@ -2254,6 +2322,19 @@ func TestResolveRejectsInvalidCrossSessionInbound(t *testing.T) {
 }

 func TestResolveReportsExplicitMaxTurns(t *testing.T) {
+	// A nil ResolveOptions.Env means "read the real process environment" (see
+	// envValue), so a case that leaves it nil inherits whatever the developer
+	// happens to export. ANTHROPIC_BASE_URL alone is enough: applyProviderEnv
+	// synthesizes a second, keyless "anthropic" profile from a base URL on its
+	// own, the single-provider shortcut in normalizeProviders stops applying,
+	// and Resolve fails with `active provider "" not found` before this test
+	// reaches its assertion. Every variable the resolver reads does it, so the
+	// cases below state an EMPTY environment rather than no environment, and
+	// these three are set to a hostile value so the test proves it.
+	t.Setenv("ANTHROPIC_BASE_URL", "https://proxy.example/v1")
+	t.Setenv("OPENAI_API_KEY", "from-the-developer-shell")
+	t.Setenv(MaxTurnsEnv, "7")
+
 	const providerJSON = `{
 		"activeProvider": "p",
 		"providers": [{"name": "p", "provider_kind": "openai-compatible", "base_url": "https://x.example/v1", "apiKey": "k", "model": "m"}]
@@ -2266,10 +2347,15 @@ func TestResolveReportsExplicitMaxTurns(t *testing.T) {
 		set  bool
 	}{
 		{"built-in default only", ResolveOptions{
+			Env:       map[string]string{},
 			Overrides: Overrides{Provider: ProviderProfile{Name: "p", ProviderKind: "openai-compatible", BaseURL: "https://x.example/v1", APIKey: "k", Model: "m"}},
 		}, false},
-		{"user config", ResolveOptions{UserConfigPath: writeConfig(t, providerWithTurns)}, true},
+		{"user config", ResolveOptions{
+			Env:            map[string]string{},
+			UserConfigPath: writeConfig(t, providerWithTurns),
+		}, true},
 		{"project config", ResolveOptions{
+			Env:               map[string]string{},
 			UserConfigPath:    writeConfig(t, providerJSON),
 			ProjectConfigPath: writeConfig(t, `{"maxTurns": 40}`),
 		}, true},
@@ -2278,6 +2364,7 @@ func TestResolveReportsExplicitMaxTurns(t *testing.T) {
 			Overrides: Overrides{Provider: ProviderProfile{Name: "p", ProviderKind: "openai-compatible", BaseURL: "https://x.example/v1", APIKey: "k", Model: "m"}},
 		}, true},
 		{"cli override", ResolveOptions{
+			Env: map[string]string{},
 			Overrides: Overrides{
 				MaxTurns: 42,
 				Provider: ProviderProfile{Name: "p", ProviderKind: "openai-compatible", BaseURL: "https://x.example/v1", APIKey: "k", Model: "m"},
@@ -0,0 +1,20 @@
+package config
+
+import (
+	"errors"
+	"os"
+)
+
+// ReadSessionsConfig reads the sessions settings from the config file at path,
+// which callers pass as the user config. A missing file is an empty config. See
+// SessionsConfig for why nothing else supplies these settings.
+func ReadSessionsConfig(path string) (SessionsConfig, error) {
+	cfg, err := loadConfigFile(path)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return SessionsConfig{}, nil
+		}
+		return SessionsConfig{}, err
+	}
+	return cfg.Sessions, nil
+}
@@ -0,0 +1,76 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestSessionsConfigRoundTripsAsAKnownKey(t *testing.T) {
+	var cfg FileConfig
+	if err := json.Unmarshal([]byte(`{"sessions":{"retentionDays":14}}`), &cfg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if cfg.Sessions.RetentionDays != 14 {
+		t.Fatalf("retentionDays = %d, want 14", cfg.Sessions.RetentionDays)
+	}
+	if _, stray := cfg.Extra["sessions"]; stray {
+		t.Fatal("sessions was kept as an unknown key as well as parsed")
+	}
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	if !strings.Contains(string(data), `"sessions":{"retentionDays":14}`) {
+		t.Fatalf("marshalled config lost the setting: %s", data)
+	}
+	empty, err := json.Marshal(FileConfig{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(empty), "sessions") {
+		t.Fatalf("an unset sessions block was written out: %s", empty)
+	}
+}
+
+func TestSessionsConfigRejectsANegativeRetention(t *testing.T) {
+	var cfg FileConfig
+	err := json.Unmarshal([]byte(`{"sessions":{"retentionDays":-1}}`), &cfg)
+	if err == nil || !strings.Contains(err.Error(), "retentionDays") {
+		t.Fatalf("a negative retention was accepted: %v", err)
+	}
+}
+
+// A write that changes something else must not drop the setting.
+func TestSessionsConfigSurvivesAnUnrelatedWrite(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.json")
+	if err := os.WriteFile(path, []byte(`{"sessions":{"retentionDays":21}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := SetTheme(path, "dark"); err != nil {
+		t.Fatalf("SetTheme: %v", err)
+	}
+	settings, err := ReadSessionsConfig(path)
+	if err != nil {
+		t.Fatalf("ReadSessionsConfig: %v", err)
+	}
+	if settings.RetentionDays != 21 {
+		t.Fatalf("after an unrelated write retentionDays = %d, want 21", settings.RetentionDays)
+	}
+}
+
+func TestReadSessionsConfig(t *testing.T) {
+	dir := t.TempDir()
+	if settings, err := ReadSessionsConfig(filepath.Join(dir, "missing.json")); err != nil || settings != (SessionsConfig{}) {
+		t.Fatalf("a missing config = %+v, %v; want empty and no error", settings, err)
+	}
+	broken := filepath.Join(dir, "broken.json")
+	if err := os.WriteFile(broken, []byte(`{"sessions":`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := ReadSessionsConfig(broken); err == nil {
+		t.Fatal("a config that does not parse was read as empty")
+	}
+}
@@ -177,6 +177,19 @@ const (
 	STTProviderDeepgram STTProviderKind = "deepgram"
 )

+// SessionsConfig holds settings for Zero's saved sessions.
+//
+// READ FROM THE USER'S OWN CONFIG ONLY. It decides what `zero sessions prune`
+// deletes, and sessions belong to the user rather than to a repository, so a
+// project's .zero/config.json has no say: the resolver does not merge it, and
+// the prune command reads it straight from the user config file.
+type SessionsConfig struct {
+	// RetentionDays is the cutoff `zero sessions prune` uses when it is given no
+	// --older-than. Unset (0) means prune needs an explicit cutoff; nothing is
+	// ever removed without one being asked for.
+	RetentionDays int `json:"retentionDays,omitempty"`
+}
+
 // STTConfig configures speech-to-text dictation. All fields are optional; empty
 // values take the documented defaults. Booleans that need a real tri-state
 // (distinguishing "unset" from "false") use *bool, matching PreferencesConfig.Recaps.
@@ -351,6 +364,7 @@ func (cfg *ToolsConfig) UnmarshalJSON(data []byte) error {
 }

 type FileConfig struct {
+	ModelRPM            map[string]int     `json:"modelRPM,omitempty"`
 	ActiveProvider      string             `json:"activeProvider,omitempty"`
 	Providers           []ProviderProfile  `json:"providers,omitempty"`
 	MaxTurns            int                `json:"maxTurns,omitempty"`
@@ -364,6 +378,7 @@ type FileConfig struct {
 	LocalControl        LocalControlConfig `json:"localControl,omitempty"`
 	STT                 STTConfig          `json:"stt,omitempty"`
 	CrossSessionInbound string             `json:"crossSessionInbound,omitempty"`
+	Sessions            SessionsConfig     `json:"sessions,omitempty"`
 	// maxTurnsSet records that some merge source supplied a positive maxTurns —
 	// i.e. the value is configured, not the built-in default. Unexported like
 	// Tools.deferThresholdSet: merge bookkeeping, not a config key.
@@ -375,6 +390,7 @@ type FileConfig struct {

 func (cfg FileConfig) MarshalJSON() ([]byte, error) {
 	type rawConfig struct {
+		ModelRPM            map[string]int      `json:"modelRPM,omitempty"`
 		ActiveProvider      string              `json:"activeProvider,omitempty"`
 		Providers           []ProviderProfile   `json:"providers,omitempty"`
 		MaxTurns            int                 `json:"maxTurns,omitempty"`
@@ -388,8 +404,10 @@ func (cfg FileConfig) MarshalJSON() ([]byte, error) {
 		LocalControl        *LocalControlConfig `json:"localControl,omitempty"`
 		STT                 *STTConfig          `json:"stt,omitempty"`
 		CrossSessionInbound string              `json:"crossSessionInbound,omitempty"`
+		Sessions            *SessionsConfig     `json:"sessions,omitempty"`
 	}
 	raw := rawConfig{
+		ModelRPM:            cfg.ModelRPM,
 		ActiveProvider:      cfg.ActiveProvider,
 		Providers:           cfg.Providers,
 		MaxTurns:            cfg.MaxTurns,
@@ -408,6 +426,9 @@ func (cfg FileConfig) MarshalJSON() ([]byte, error) {
 	if !cfg.STT.Empty() {
 		raw.STT = &cfg.STT
 	}
+	if cfg.Sessions != (SessionsConfig{}) {
+		raw.Sessions = &cfg.Sessions
+	}
 	known, err := json.Marshal(raw)
 	if err != nil || len(cfg.Extra) == 0 {
 		return known, err
@@ -465,6 +486,7 @@ type Overrides struct {
 }

 type ResolvedConfig struct {
+	ModelRPM       map[string]int
 	ActiveProvider string
 	Providers      []ProviderProfile
 	Provider       ProviderProfile
@@ -533,6 +555,7 @@ type MCPOAuthConfig struct {

 func (cfg *FileConfig) UnmarshalJSON(data []byte) error {
 	type rawConfig struct {
+		ModelRPM            map[string]int             `json:"modelRPM"`
 		ActiveProvider      string                     `json:"activeProvider"`
 		Providers           []ProviderProfile          `json:"providers"`
 		MaxTurns            int                        `json:"maxTurns"`
@@ -546,6 +569,7 @@ func (cfg *FileConfig) UnmarshalJSON(data []byte) error {
 		LocalControl        LocalControlConfig         `json:"localControl"`
 		STT                 STTConfig                  `json:"stt"`
 		CrossSessionInbound string                     `json:"crossSessionInbound"`
+		Sessions            SessionsConfig             `json:"sessions"`
 		MCPServers          map[string]MCPServerConfig `json:"mcpServers"`
 		MCPServersSnake     map[string]MCPServerConfig `json:"mcp_servers"`
 	}
@@ -567,6 +591,11 @@ func (cfg *FileConfig) UnmarshalJSON(data []byte) error {
 		extra = nil
 	}
 	cfg.ActiveProvider = raw.ActiveProvider
+	limits, err := normalizeModelRPM(raw.ModelRPM)
+	if err != nil {
+		return err
+	}
+	cfg.ModelRPM = limits
 	cfg.Providers = raw.Providers
 	// A negative maxTurns is unambiguously invalid; without this it would be
 	// silently dropped by the `MaxTurns > 0` merge gates and fall back to the
@@ -587,6 +616,10 @@ func (cfg *FileConfig) UnmarshalJSON(data []byte) error {
 	cfg.LocalControl = raw.LocalControl
 	cfg.STT = raw.STT
 	cfg.CrossSessionInbound = raw.CrossSessionInbound
+	if raw.Sessions.RetentionDays < 0 {
+		return fmt.Errorf("invalid sessions.retentionDays %d: must be >= 0", raw.Sessions.RetentionDays)
+	}
+	cfg.Sessions = raw.Sessions
 	cfg.Extra = extra
 	if cfg.MCP.Servers == nil && (len(raw.MCPServers) > 0 || len(raw.MCPServersSnake) > 0) {
 		cfg.MCP.Servers = map[string]MCPServerConfig{}
@@ -9,6 +9,7 @@ import (
 	"sort"
 	"strings"

+	"github.com/Gitlawb/zero/internal/notify"
 	"github.com/Gitlawb/zero/internal/providercatalog"
 )

@@ -756,6 +757,128 @@ func SetTheme(path string, theme string) (result FileConfig, err error) {
 	return cfg, nil
 }

+// UserNotify returns the notify block stored in the user's own config file at
+// path, trimmed. A missing file or missing/empty block returns the zero value:
+// callers that need to preserve "whatever the user already chose" on a partial
+// update must seed from THIS value, not from the resolved view — the resolver
+// merges project config and the TUI applies its own defaults, so seeding from
+// resolved copies choices the user never made into their global file (a
+// project's mode: off, or a pinned default) and across every other project.
+func UserNotify(path string) (NotifyConfig, error) {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return NotifyConfig{}, nil
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return NotifyConfig{}, nil
+		}
+		return NotifyConfig{}, fmt.Errorf("read config %s: %w", path, err)
+	}
+	var cfg FileConfig
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		return NotifyConfig{}, fmt.Errorf("invalid config JSON %s: %w", path, err)
+	}
+	cfg.Notify.Mode = strings.TrimSpace(cfg.Notify.Mode)
+	cfg.Notify.FocusMode = strings.TrimSpace(cfg.Notify.FocusMode)
+	return cfg.Notify, nil
+}
+
+// validateNotify trims both fields and checks them against the accepted vocab
+// (mode in {off,bell,notify,both}; focusMode in {unfocused,always,focused}) so
+// a bad caller cannot write a value the resolver would later reject at
+// startup. An empty Mode or FocusMode is stored as-is — blank means "use the
+// built-in defaults" (the TUI's effectiveTUINotifyMode maps an empty mode to
+// both; the notify package treats an empty focusMode as unfocused), not "off".
+func validateNotify(value NotifyConfig) (NotifyConfig, error) {
+	value.Mode = strings.TrimSpace(value.Mode)
+	value.FocusMode = strings.TrimSpace(value.FocusMode)
+	if mode := value.Mode; mode != "" {
+		switch notify.Mode(mode) {
+		case notify.ModeOff, notify.ModeBell, notify.ModeNotify, notify.ModeBoth:
+		default:
+			return NotifyConfig{}, fmt.Errorf("invalid notify.mode %q: expected off, bell, notify, or both", mode)
+		}
+	}
+	if focus := value.FocusMode; focus != "" {
+		switch notify.FocusMode(focus) {
+		case notify.FocusUnfocused, notify.FocusAlways, notify.FocusFocused:
+		default:
+			return NotifyConfig{}, fmt.Errorf("invalid notify.focusMode %q: expected unfocused, always, or focused", focus)
+		}
+	}
+	return value, nil
+}
+
+// UpdateNotify runs one SERIALIZED read-modify-write transaction on the user's
+// notify block. merge receives the currently stored block and returns the
+// block to store; it must preserve any field the caller is not explicitly
+// changing. The lock covers reading the stored block, applying merge, and
+// replacing the file, so two concurrent partial updates (for example
+// `--mode off` and `--focus always` from two terminals) cannot interleave
+// their reads and writes and silently undo each other's explicit change
+// (maintainer review, PR #1001 reproduced a 50/50 lost-update without it).
+//
+// The write replaces ONLY the notify member's bytes (setNotifyJSONObject),
+// preserving every unrelated value and its explicit presence — including
+// explicit zeros/falses like tools.deferThreshold: 0 or an MCP server's
+// disabled: false, which the typed serializer's omitempty cannot round-trip —
+// through the existing temp-file-and-rename atomic publish. Locking only the
+// final write would leave the stale-field merge outside the transaction, so
+// the whole sequence runs under one lock — the SAME lockConfigFileFn authority
+// every other config mutator uses (provider/theme/credential/MCP writes), not
+// a private lock: two authorities over the same file would not contend
+// (maintainer review, PR #1001). The release error is joined into the
+// result like every other writer: a failed unlock would leave the advisory
+// lock held and later updates blocked while the caller is told success.
+func UpdateNotify(path string, merge func(current NotifyConfig) NotifyConfig) (result NotifyConfig, err error) {
+	path = strings.TrimSpace(path)
+	if path == "" {
+		return NotifyConfig{}, fmt.Errorf("config path is required")
+	}
+	if merge == nil {
+		return NotifyConfig{}, fmt.Errorf("merge function is required")
+	}
+	release, err := lockConfigFileFn(path)
+	if err != nil {
+		return NotifyConfig{}, err
+	}
+	// Joined, not chosen between: a release failure annotates the result
+	// instead of masking the mutation error that actually explains what went
+	// wrong. Reporting success after a failed release would claim a state the
+	// next update cannot reproduce.
+	defer func() { err = errors.Join(err, release()) }()
+
+	current, err := UserNotify(path)
+	if err != nil {
+		return NotifyConfig{}, err
+	}
+	next, err := validateNotify(merge(current))
+	if err != nil {
+		return NotifyConfig{}, err
+	}
+
+	// Read the raw file and edit only the notify member. A missing file starts
+	// from an empty object so a first-time write does not need a pre-seeded
+	// config.
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return NotifyConfig{}, fmt.Errorf("read config %s: %w", path, err)
+		}
+		data = []byte("{}")
+	}
+	updated, err := setNotifyJSONObject(data, next)
+	if err != nil {
+		return NotifyConfig{}, fmt.Errorf("invalid config JSON %s: %w", path, err)
+	}
+	if err := writeConfigData(path, updated); err != nil {
+		return NotifyConfig{}, err
+	}
+	return next, nil
+}
+
 // SetPet persists only the terminal-pet preference while preserving every
 // unrelated user setting through the config writer's atomic replace path.
 func SetPet(path string, pet string) (result FileConfig, err error) {
@@ -3,6 +3,7 @@ package config
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/fs"
 	"os"
 	"os/exec"
@@ -10,6 +11,7 @@ import (
 	"reflect"
 	"runtime"
 	"strings"
+	"sync"
 	"testing"
 )

@@ -426,6 +428,286 @@ func TestSetThemePreservesUnknownTopLevelFields(t *testing.T) {
 	}
 }

+// setNotify replaces the stored notify block with value through UpdateNotify
+// and returns the re-read config, so the tests below can assert on a
+// FileConfig-shaped result. Every product surface uses UpdateNotify's merge
+// form directly; this replace form exists only for these tests.
+func setNotify(path string, value NotifyConfig) (FileConfig, error) {
+	next, err := UpdateNotify(path, func(NotifyConfig) NotifyConfig { return value })
+	if err != nil {
+		return FileConfig{}, err
+	}
+	cfg, err := loadConfigFile(path)
+	if err != nil {
+		return FileConfig{}, err
+	}
+	cfg.Notify = next
+	return cfg, nil
+}
+
+func TestSetNotifyPersistsValidValues(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	writeConfigFixture(t, path, FileConfig{
+		ActiveProvider: "openai",
+		Providers: []ProviderProfile{
+			{Name: "openai", ProviderKind: ProviderKindOpenAI, Model: "gpt-4.1"},
+		},
+	}, 0o600)
+
+	cfg, err := setNotify(path, NotifyConfig{Mode: "  both  ", FocusMode: "  unfocused  "})
+	if err != nil {
+		t.Fatalf("setNotify() error = %v", err)
+	}
+	if cfg.Notify.Mode != "both" || cfg.Notify.FocusMode != "unfocused" {
+		t.Fatalf("Notify = %+v, want mode=both focusMode=unfocused (trimmed)", cfg.Notify)
+	}
+	persisted := readConfigFixture(t, path)
+	if persisted.Notify.Mode != "both" || persisted.Notify.FocusMode != "unfocused" {
+		t.Fatalf("persisted Notify = %+v, want mode=both focusMode=unfocused", persisted.Notify)
+	}
+	if persisted.ActiveProvider != "openai" || len(persisted.Providers) != 1 {
+		t.Fatalf("provider config was not preserved by setNotify: %#v", persisted)
+	}
+}
+
+func TestSetNotifyRejectsInvalidMode(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	writeConfigFixture(t, path, FileConfig{ActiveProvider: "openai"}, 0o600)
+	if _, err := setNotify(path, NotifyConfig{Mode: "loud", FocusMode: "unfocused"}); err == nil {
+		t.Fatal("expected error for invalid notify.mode")
+	}
+}
+
+func TestSetNotifyRejectsInvalidFocusMode(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	writeConfigFixture(t, path, FileConfig{ActiveProvider: "openai"}, 0o600)
+	if _, err := setNotify(path, NotifyConfig{Mode: "off", FocusMode: "sideways"}); err == nil {
+		t.Fatal("expected error for invalid notify.focusMode")
+	}
+}
+
+func TestSetNotifyRejectsEmptyConfigPath(t *testing.T) {
+	if _, err := setNotify("", NotifyConfig{Mode: "off"}); err == nil {
+		t.Fatal("expected error for empty config path")
+	}
+}
+
+func TestSetNotifyBlankValuesPreservedAsDefaults(t *testing.T) {
+	// An empty mode/focusMode stored on disk is a valid "use the built-in
+	// defaults" signal — setNotify must not reject blanks, and they must round
+	// trip unchanged.
+	path := filepath.Join(t.TempDir(), "zero.json")
+	writeConfigFixture(t, path, FileConfig{ActiveProvider: "openai"}, 0o600)
+	if _, err := setNotify(path, NotifyConfig{}); err != nil {
+		t.Fatalf("setNotify({}) should accept blank values, got error: %v", err)
+	}
+	persisted := readConfigFixture(t, path)
+	if persisted.Notify.Mode != "" || persisted.Notify.FocusMode != "" {
+		t.Fatalf("blank notify values should round-trip, got %+v", persisted.Notify)
+	}
+}
+
+// Maintainer regression (PR #1001): a notification save must preserve unrelated
+// values whose EXPLICIT presence matters. The typed serializer's omitempty
+// cannot round-trip tools.deferThreshold: 0 (explicit "never defer" vs unset
+// "use default 3") or an MCP server's disabled: false (explicitly enabled), so
+// UpdateNotify edits only the notify member's bytes instead. The
+// assertions run against the RAW file, because reading through FileConfig
+// would hide exactly the presence loss being tested.
+func TestSetNotifyPreservesExplicitUnrelatedValues(t *testing.T) {
+	dir := t.TempDir()
+
+	for name, body := range map[string]string{
+		"explicit zero deferThreshold": `{
+	"tools": {"deferThreshold": 0},
+	"mcp": {"servers": {"firecrawl": {"command": "npx", "disabled": false}}}
+}`,
+		"unknown keys stay untouched": `{
+	"activeProvider": "openai",
+	"customTopLevel": {"nested": [1, 2, 3]},
+	"notify": {"mode": "both"}
+}`,
+	} {
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(dir, name+".json")
+			if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
+				t.Fatal(err)
+			}
+
+			if _, err := setNotify(path, NotifyConfig{Mode: "off", FocusMode: "always"}); err != nil {
+				t.Fatalf("setNotify: %v", err)
+			}
+
+			raw, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var obj map[string]json.RawMessage
+			if err := json.Unmarshal(raw, &obj); err != nil {
+				t.Fatalf("decode: %v", err)
+			}
+			if strings.Contains(name, "explicit zero") {
+				tools, ok := obj["tools"]
+				if !ok || !strings.Contains(string(tools), `"deferThreshold": 0`) {
+					t.Errorf("tools.deferThreshold: 0 lost through a notify write; tools = %s", string(tools))
+				}
+				mcp, ok := obj["mcp"]
+				if !ok || !strings.Contains(string(mcp), `"disabled": false`) {
+					t.Errorf("mcp disabled: false lost through a notify write; mcp = %s", string(mcp))
+				}
+			}
+			if strings.Contains(name, "unknown keys") {
+				if _, ok := obj["customTopLevel"]; !ok {
+					t.Error("unknown top-level key lost through a notify write")
+				}
+			}
+		})
+	}
+}
+
+// Maintainer regression (PR #1001, CodeRabbit follow-up): a hand-edited config
+// may contain DUPLICATE notify members (JSON decoders tolerate them and the
+// last occurrence wins). A reset must remove EVERY notify member — removing
+// only the last leaves the earlier block as the new effective preference, so
+// `zero config notify --reset` would report success while the old value still
+// applies.
+func TestSetNotifyResetRemovesEveryDuplicateNotifyMember(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	duplicated := `{"notify":{"mode":"off"},"activeProvider":"openai","notify":{"mode":"bell"}}`
+	if err := os.WriteFile(path, []byte(duplicated), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := setNotify(path, NotifyConfig{}); err != nil {
+		t.Fatalf("setNotify({}) reset: %v", err)
+	}
+
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var obj map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &obj); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if _, still := obj["notify"]; still {
+		t.Fatalf("reset left a notify member behind: %s", string(raw))
+	}
+	if obj["activeProvider"] == nil || string(obj["activeProvider"]) != `"openai"` {
+		t.Errorf("unrelated member lost through the reset: %s", string(raw))
+	}
+
+	// A reset on a file with NO notify member is a no-op, and a partial update
+	// against duplicates replaces the LAST member (the effective one under
+	// last-occurrence-wins decoding).
+	if err := os.WriteFile(path, []byte(duplicated), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := setNotify(path, NotifyConfig{Mode: "off", FocusMode: "always"}); err != nil {
+		t.Fatalf("setNotify replace: %v", err)
+	}
+	raw, err = os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stored, err := UserNotify(path)
+	if err != nil {
+		t.Fatalf("UserNotify: %v", err)
+	}
+	if stored.Mode != "off" || stored.FocusMode != "always" {
+		t.Fatalf("after replace, effective notify = %+v, want off/always (last member replaced)", stored)
+	}
+	if !strings.Contains(string(raw), `"activeProvider"`) {
+		t.Errorf("unrelated member lost through the replace: %s", string(raw))
+	}
+}
+
+// Maintainer regression (PR #1001): concurrent partial updates must not lose
+// each other's explicit change. Two `zero config notify` calls (--mode off and
+// --focus always) racing from both/unfocused previously interleaved their
+// read-merge-write and one write silently undid the other (reproduced 50/50
+// without the lock). UpdateNotify serializes the whole transaction.
+func TestUpdateNotifyConcurrentPartialUpdatesLoseNoField(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	if err := os.WriteFile(path, []byte(`{"notify":{"mode":"both","focusMode":"unfocused"}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	var wg sync.WaitGroup
+	errs := make(chan error, 2)
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		if _, err := UpdateNotify(path, func(current NotifyConfig) NotifyConfig {
+			current.Mode = "off"
+			return current
+		}); err != nil {
+			errs <- fmt.Errorf("mode update: %w", err)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		if _, err := UpdateNotify(path, func(current NotifyConfig) NotifyConfig {
+			current.FocusMode = "always"
+			return current
+		}); err != nil {
+			errs <- fmt.Errorf("focus update: %w", err)
+		}
+	}()
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		t.Fatalf("concurrent update failed: %v", err)
+	}
+
+	stored, err := UserNotify(path)
+	if err != nil {
+		t.Fatalf("read stored: %v", err)
+	}
+	// BOTH explicit changes must survive: mode from writer 1, focus from
+	// writer 2. The old race let the second writer's stale focus
+	// ("unfocused") or stale mode ("both") win.
+	if stored.Mode != "off" {
+		t.Errorf("mode = %q, want off (concurrent focus update must not clobber it)", stored.Mode)
+	}
+	if stored.FocusMode != "always" {
+		t.Errorf("focusMode = %q, want always (concurrent mode update must not clobber it)", stored.FocusMode)
+	}
+}
+
+// UserNotify reads the notify block from the user's own file. Partial updates
+// seed from this value so they preserve what the USER chose (blank included)
+// instead of copying a project config's setting or a pinned default into the
+// global file (maintainer review, PR #1001).
+func TestUserNotify(t *testing.T) {
+	dir := t.TempDir()
+
+	// Missing file: zero value, no error.
+	got, err := UserNotify(filepath.Join(dir, "missing.json"))
+	if err != nil {
+		t.Fatalf("missing file should not error: %v", err)
+	}
+	if got.Mode != "" || got.FocusMode != "" {
+		t.Fatalf("missing file = %+v, want zero value", got)
+	}
+
+	// Present block: trimmed values returned.
+	path := filepath.Join(dir, "zero.json")
+	writeConfigFixture(t, path, FileConfig{Notify: NotifyConfig{Mode: "  bell  ", FocusMode: " always "}}, 0o600)
+	got, err = UserNotify(path)
+	if err != nil {
+		t.Fatalf("UserNotify: %v", err)
+	}
+	if got.Mode != "bell" || got.FocusMode != "always" {
+		t.Fatalf("UserNotify = %+v, want bell/always (trimmed)", got)
+	}
+
+	// Blank path: zero value, no error.
+	if got, err = UserNotify(""); err != nil || got.Mode != "" || got.FocusMode != "" {
+		t.Fatalf("blank path = %+v err=%v, want zero value", got, err)
+	}
+}
+
 func TestRecapsPreferenceRoundTrips(t *testing.T) {
 	// Default (unset) is ON.
 	if !(PreferencesConfig{}).RecapsEnabled() {
@@ -1078,3 +1360,109 @@ func TestEditProviderRejectsCollisionAndUnknown(t *testing.T) {
 		t.Fatalf("config was rewritten by a rejected edit")
 	}
 }
+
+// Maintainer regression (PR #1001): notify writes must contend with EXISTING
+// config mutators, not only each other. UpdateNotify originally took a private
+// lock (acquireConfigLock); on Windows its LockFileEx range did not overlap
+// lockutil's, so `zero config notify --mode off` could race a theme (or
+// provider/credential/MCP) write and silently discard it — the later rename
+// wins and the other acknowledged change is gone. UpdateNotify now uses the
+// same lockConfigFileFn authority as every other mutator; this race holds it
+// against SetTheme and requires BOTH acknowledged edits to survive.
+func TestUpdateNotifyRacesExistingConfigMutatorWithoutLoss(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	if err := os.WriteFile(path, []byte(`{"notify":{"mode":"both","focusMode":"unfocused"}}`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	var wg sync.WaitGroup
+	errs := make(chan error, 2)
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		if _, err := UpdateNotify(path, func(NotifyConfig) NotifyConfig {
+			return NotifyConfig{Mode: "off", FocusMode: "always"}
+		}); err != nil {
+			errs <- fmt.Errorf("notify write: %w", err)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		if _, err := SetTheme(path, "dracula"); err != nil {
+			errs <- fmt.Errorf("theme write: %w", err)
+		}
+	}()
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		t.Fatal(err)
+	}
+
+	cfg := readConfigFixture(t, path)
+	if cfg.Notify.Mode != "off" || cfg.Notify.FocusMode != "always" {
+		t.Errorf("notify lost the race: %+v, want off/always — the two writers did not contend on one lock", cfg.Notify)
+	}
+	if cfg.Preferences.Theme != "dracula" {
+		t.Errorf("theme lost the race: %q, want dracula — the two writers did not contend on one lock", cfg.Preferences.Theme)
+	}
+}
+
+// Maintainer regression (PR #1001, jatmn review): Go's decoder MERGES the
+// fields of duplicate JSON members into one struct, so a full replacement that
+// omits a field could inherit it from an earlier duplicate —
+// {"notify":{"mode":"off"},"notify":{"focusMode":"focused"}} +
+// setNotify({FocusMode:"always"}) must yield blank/always, not off/always.
+// The editor removes every duplicate and inserts the replacement fresh.
+func TestSetNotifyReplacementInheritsNoFieldFromEarlierDuplicate(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	duplicated := `{"notify":{"mode":"off"},"notify":{"focusMode":"focused"},"activeProvider":"openai"}`
+	if err := os.WriteFile(path, []byte(duplicated), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := setNotify(path, NotifyConfig{FocusMode: "always"}); err != nil {
+		t.Fatalf("setNotify: %v", err)
+	}
+	stored, err := UserNotify(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stored.Mode != "" || stored.FocusMode != "always" {
+		t.Fatalf("replacement inherited a field from an earlier duplicate: %+v, want blank/always", stored)
+	}
+
+	// Unrelated bytes still survive the rewrite.
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(raw), `"activeProvider":"openai"`) {
+		t.Fatalf("unrelated member lost through the replace: %s", string(raw))
+	}
+}
+
+// Maintainer regression (PR #1001, Vasanthdev2004 review): the duplicate-key
+// fix must not reach the ORDINARY single-member file. Removing and re-inserting
+// the notify member there moved the key to the end of the object and collapsed
+// its formatting, so every /notify toggle reordered the user's config — JSON
+// member order carries no meaning, but a byte-preserving write should not
+// reformat anything it does not have to. A single notify member is replaced
+// in place: key position and surrounding formatting unchanged.
+func TestSetNotifySingleMemberReplacedInPlace(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "zero.json")
+	original := "{\n  \"activeProvider\": \"openai\",\n  \"notify\": {\"mode\": \"both\", \"focusMode\": \"unfocused\"},\n  \"preferences\": {\"theme\": \"dracula\"}\n}\n"
+	if err := os.WriteFile(path, []byte(original), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := setNotify(path, NotifyConfig{Mode: "off", FocusMode: "always"}); err != nil {
+		t.Fatalf("setNotify: %v", err)
+	}
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "{\n  \"activeProvider\": \"openai\",\n  \"notify\": {\"mode\":\"off\",\"focusMode\":\"always\"},\n  \"preferences\": {\"theme\": \"dracula\"}\n}\n"
+	if string(raw) != want {
+		t.Fatalf("single-member replace moved or reformatted unrelated bytes:\n got: %q\nwant: %q", string(raw), want)
+	}
+}
@@ -1,10 +1,61 @@
 package cron

 import (
+	"bytes"
+	"encoding/json"
+	"errors"
 	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
 	"testing"
+
+	"github.com/Gitlawb/zero/internal/fsutil"
 )

+func TestAppendRunRetainsNewestThousand(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Expr: "* * * * *", Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Seed an oversized legacy log, then cross the boundary again after compaction.
+	var history bytes.Buffer
+	for i := 0; i < 1207; i++ {
+		if err := json.NewEncoder(&history).Encode(RunRecord{ExitCode: i}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	if err := os.WriteFile(path, history.Bytes(), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	for _, next := range []int{1207, 1208} {
+		if err := store.AppendRun(job.ID, RunRecord{ExitCode: next}); err != nil {
+			t.Fatal(err)
+		}
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		lines := bytes.Split(bytes.TrimSpace(data), []byte("\n"))
+		if len(lines) != 1000 {
+			t.Fatalf("retained %d records, want 1000", len(lines))
+		}
+		for i, line := range lines {
+			var rec RunRecord
+			if err := json.Unmarshal(line, &rec); err != nil {
+				t.Fatal(err)
+			}
+			if rec.ExitCode != next-999+i {
+				t.Fatalf("record %d = %d, want %d", i, rec.ExitCode, next-999+i)
+			}
+		}
+	}
+}
+
 // AppendRun on a job removed mid-run must NOT resurrect its directory (which the
 // old unconditional MkdirAll did, leaving an orphaned runs.jsonl with no
 // metadata.json).
@@ -24,7 +75,7 @@ func TestAppendRunDoesNotResurrectRemovedJob(t *testing.T) {
 	if _, err := os.Stat(store.jobDir(job.ID)); !os.IsNotExist(err) {
 		t.Fatalf("AppendRun resurrected the removed job directory (stat err = %v)", err)
 	}
-	runs, err := store.Runs(job.ID)
+	runs, err := store.Runs(job.ID, 0)
 	if err != nil {
 		t.Fatalf("Runs: %v", err)
 	}
@@ -32,3 +83,256 @@ func TestAppendRunDoesNotResurrectRemovedJob(t *testing.T) {
 		t.Fatalf("expected no runs for a removed job, got %d", len(runs))
 	}
 }
+
+func TestRunsTail(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var history bytes.Buffer
+	// A forward scan would fail on this old oversized line. A recent-window
+	// reader must stop before reaching it, rather than merely cap its output.
+	history.WriteString(strings.Repeat("x", 1024*1024+1) + "\n")
+	for i := 0; i < 1103; i++ {
+		if err := json.NewEncoder(&history).Encode(RunRecord{ExitCode: i, SessionTitle: strings.Repeat("界", 1500)}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	history.WriteString("bad json\n\n{\"exitCode\":1103}") // no final newline
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	if err := os.WriteFile(path, history.Bytes(), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	for _, limit := range []int{1, 7, 999, 1000, 1001, 0, -1} {
+		runs, err := store.Runs(job.ID, limit)
+		want := limit
+		if want <= 0 || want > 1000 {
+			want = 1000
+		}
+		if err != nil || len(runs) != want {
+			t.Fatalf("limit %d: got %d records, err %v", limit, len(runs), err)
+		}
+		for i, run := range runs {
+			if run.ExitCode != 1104-want+i {
+				t.Fatalf("limit %d, record %d = %d", limit, i, run.ExitCode)
+			}
+			if run.ExitCode != 1103 && run.SessionTitle != strings.Repeat("界", 1500) {
+				t.Fatal("record spanning read blocks was corrupted")
+			}
+		}
+	}
+}
+
+func TestAppendRunFailurePreservesHistory(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	for _, data := range []string{"{\"exitCode\":7}\n", strings.Repeat("x", 1024*1024)} {
+		if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		rec := RunRecord{ExitCode: 8, Error: strings.Repeat("x", 1024*1024)}
+		if err := store.AppendRun(job.ID, rec); err == nil {
+			t.Fatal("expected oversized new record error")
+		}
+		got, err := os.ReadFile(path)
+		if err != nil || string(got) != data {
+			t.Fatalf("failed append changed history: %v", err)
+		}
+	}
+}
+
+func TestAppendRunWithOversizedHistory(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	// An oversized unterminated legacy record must not block future outcomes.
+	if err := os.WriteFile(path, []byte(strings.Repeat("x", maxRunBytes)), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.AppendRun(job.ID, RunRecord{ExitCode: 42}); err != nil {
+		t.Fatal(err)
+	}
+	runs, err := store.Runs(job.ID, 1)
+	if err != nil || len(runs) != 1 || runs[0].ExitCode != 42 {
+		t.Fatalf("new outcome lost: %+v, %v", runs, err)
+	}
+}
+
+func TestRunsSkipOversizedLines(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	for _, size := range []int{maxRunBytes - 1, maxRunBytes, maxRunBytes + 4096} {
+		// Valid JSON plus trailing whitespace catches accidental decoding of a
+		// prefix after dropping only the oversized suffix. The exact boundary
+		// also distinguishes an oversized line from the largest allowed line.
+		line := `{"exitCode":99}`
+		line += strings.Repeat(" ", size-len(line))
+		data := line + "\n{\"exitCode\":7}\n" + line + "\n{\"exitCode\":42}\n" + line
+		if err := os.WriteFile(path, []byte(data), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		runs, err := store.Runs(job.ID, 10)
+		want := []int{7, 42}
+		if size < maxRunBytes {
+			want = []int{99, 7, 99, 42, 99}
+		}
+		if err != nil || len(runs) != len(want) {
+			t.Fatalf("size %d: got %+v, err %v; want %v", size, runs, err, want)
+		}
+		for i, rec := range runs {
+			if rec.ExitCode != want[i] {
+				t.Fatalf("size %d: record %d = %d, want %d", size, i, rec.ExitCode, want[i])
+			}
+		}
+	}
+}
+
+// An outside reader holding runs.jsonl open makes the Windows replace fail;
+// the outcome must still be recorded rather than dropped.
+func TestAppendRunWhileHistoryHeldOpen(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	if err := os.WriteFile(path, []byte("{\"exitCode\":7}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	held, err := os.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer held.Close()
+	if err := store.AppendRun(job.ID, RunRecord{ExitCode: 42}); err != nil {
+		t.Fatalf("AppendRun with history held open: %v", err)
+	}
+	runs, err := store.Runs(job.ID, 10)
+	if err != nil || len(runs) != 2 || runs[0].ExitCode != 7 || runs[1].ExitCode != 42 {
+		t.Fatalf("outcome lost while history held open: %+v, %v", runs, err)
+	}
+}
+
+// Only a sharing or lock violation falls back to appending. Any other replace
+// failure, including a persistent access denial, and a committed replacement
+// whose backup cleanup failed must leave the log untouched, so history can
+// neither grow past retention nor record an outcome twice.
+func TestAppendRunFallbackOnlyForSharingViolation(t *testing.T) {
+	const seed = "{\"exitCode\":7}\n"
+	for _, tc := range []struct {
+		name   string
+		err    error
+		append bool
+	}{
+		{"sharing violation", syscall.Errno(32), runtime.GOOS == "windows"},
+		{"access denied", os.ErrPermission, false},
+		{"other", errors.New("boom"), false},
+		{"committed", &fsutil.CommittedReplacementCleanupError{Cause: syscall.Errno(32)}, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			store := newTestStore(t)
+			job, err := store.Add(Job{Prompt: "x"})
+			if err != nil {
+				t.Fatal(err)
+			}
+			path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+			if err := os.WriteFile(path, []byte(seed), 0o600); err != nil {
+				t.Fatal(err)
+			}
+			store.replace = func(string, string) error { return tc.err }
+			err = store.AppendRun(job.ID, RunRecord{ExitCode: 42})
+			data, readErr := os.ReadFile(path)
+			if readErr != nil {
+				t.Fatal(readErr)
+			}
+			if tc.append {
+				if err != nil || !strings.HasPrefix(string(data), seed) || !strings.Contains(string(data), "\"exitCode\":42") {
+					t.Fatalf("sharing violation dropped the outcome: err %v, log %q", err, data)
+				}
+				return
+			}
+			if !errors.Is(err, tc.err) {
+				t.Fatalf("AppendRun error = %v, want %v", err, tc.err)
+			}
+			if string(data) != seed {
+				t.Fatalf("non-transient replace failure changed the log: %q", data)
+			}
+		})
+	}
+}
+
+// The fallback append must start a fresh line even when the log ends in an
+// unterminated record, so neither record is corrupted.
+func TestAppendRunLineAfterUnterminatedTail(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	if err := os.WriteFile(path, []byte("{\"exitCode\":7}"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := appendRunLine(path, []byte("{\"exitCode\":42}")); err != nil {
+		t.Fatal(err)
+	}
+	runs, err := store.Runs(job.ID, 10)
+	if err != nil || len(runs) != 2 || runs[0].ExitCode != 7 || runs[1].ExitCode != 42 {
+		t.Fatalf("fallback append corrupted history: %+v, %v", runs, err)
+	}
+}
+
+func TestRunHistoryConcurrentStores(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var history bytes.Buffer
+	for i := 0; i < 1000; i++ {
+		if err := json.NewEncoder(&history).Encode(RunRecord{ExitCode: -1}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(filepath.Join(store.jobDir(job.ID), "runs.jsonl"), history.Bytes(), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	var wg sync.WaitGroup
+	for i := 0; i < 12; i++ {
+		wg.Go(func() {
+			other := NewStore(StoreOptions{RootDir: store.root})
+			if err := other.AppendRun(job.ID, RunRecord{ExitCode: i}); err != nil {
+				t.Error(err)
+				return
+			}
+			runs, err := other.Runs(job.ID, 1000)
+			if err != nil || len(runs) != 1000 {
+				t.Errorf("inconsistent history: %d records, err %v", len(runs), err)
+			}
+		})
+	}
+	wg.Wait()
+	runs, err := store.Runs(job.ID, 12)
+	if err != nil || len(runs) != 12 {
+		t.Fatalf("final tail: %d records, err %v", len(runs), err)
+	}
+	seen := make(map[int]bool)
+	for _, run := range runs {
+		if run.ExitCode < 0 || run.ExitCode >= 12 || seen[run.ExitCode] {
+			t.Fatalf("lost or duplicate concurrent append: %+v", runs)
+		}
+		seen[run.ExitCode] = true
+	}
+}
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"time"

@@ -16,6 +17,10 @@ import (
 const (
 	StatusActive = "active"
 	StatusPaused = "paused"
+
+	// MaxRunHistory is the number of recent outcomes retained per job.
+	MaxRunHistory = 1000
+	maxRunBytes   = 1024 * 1024
 )

 // ErrJobNotFound is returned (wrapped) by Get when a job's metadata file is
@@ -56,6 +61,9 @@ type StoreOptions struct {
 type Store struct {
 	root string
 	now  func() time.Time
+	// replace overrides the run-history replacement primitive in tests; nil
+	// uses the platform default.
+	replace func(src, dst string) error
 }

 func NewStore(opts StoreOptions) *Store {
@@ -228,8 +236,7 @@ func (s *Store) Update(job Job) error {
 // Remove). It re-reads the CURRENT on-disk job and passes it to mutate along with
 // any read error; mutate returns the job to persist. A removed job aborts with
 // ErrJobNotFound (no recreate). A transient read error (not removal) is surfaced
-// via readErr so the caller can still persist a best-effort state — the fire path
-// advances the schedule regardless, to avoid a re-fire.
+// via readErr; the callback can return it to abort without overwriting state.
 func (s *Store) Mutate(id string, mutate func(current Job, readErr error) (Job, error)) (Job, error) {
 	if !validID(id) {
 		return Job{}, fmt.Errorf("invalid cron job id %q", id)
@@ -309,10 +316,8 @@ func (s *Store) AppendRun(id string, rec RunRecord) error {
 		return err
 	}
 	defer unlock()
-	// Bail if the job was removed (e.g. mid-run) — otherwise the MkdirAll below
-	// would resurrect a deleted job's directory with an orphaned runs.jsonl and no
-	// metadata.json (which Runs would then still return). Under the per-job lock
-	// this stat-then-write is race-free against a concurrent Remove.
+	// Do not resurrect a job removed mid-run. The lock serializes this check
+	// and publication against Remove and other history writers/readers.
 	if _, err := os.Stat(filepath.Join(s.jobDir(id), "metadata.json")); err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			return nil
@@ -320,30 +325,98 @@ func (s *Store) AppendRun(id string, rec RunRecord) error {
 		return err
 	}
 	dir := s.jobDir(id)
-	if err := os.MkdirAll(dir, 0o700); err != nil {
-		return err
-	}
-	f, err := os.OpenFile(filepath.Join(dir, "runs.jsonl"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o600)
-	if err != nil {
-		return err
-	}
 	line, err := json.Marshal(rec)
 	if err != nil {
+		return err
+	}
+	if len(line) >= maxRunBytes {
+		return fmt.Errorf("cron run record exceeds %d bytes", maxRunBytes-1)
+	}
+	runs, err := s.readRuns(id, MaxRunHistory-1)
+	if err != nil {
+		return err
+	}
+	// Publish a complete snapshot even below the retention boundary so readers
+	// never see a partial append. Legacy oversized logs compact on their next run.
+	f, err := os.CreateTemp(dir, "runs-*.tmp")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	w := bufio.NewWriter(f)
+	for _, run := range runs {
+		if err := json.NewEncoder(w).Encode(run); err != nil {
+			_ = f.Close()
+			return err
+		}
+	}
+	if _, err := w.Write(append(line, '\n')); err != nil {
 		_ = f.Close()
 		return err
 	}
-	if _, err := f.Write(append(line, '\n')); err != nil {
+	if err := w.Flush(); err != nil {
 		_ = f.Close()
 		return err
 	}
 	// Surface a buffered-write failure that only materializes on Close.
+	if err := f.Close(); err != nil {
+		return err
+	}
+	path := filepath.Join(dir, "runs.jsonl")
+	// ReplaceWithRetry keeps a DACL applied to runs.jsonl itself; a rename would
+	// publish the temporary file's inherited directory DACL instead.
+	err = fsutil.ReplaceWithRetry(f.Name(), path, s.replace)
+	var committed *fsutil.CommittedReplacementCleanupError
+	if err == nil || errors.As(err, &committed) || !fsutil.IsSharingOrLockViolation(err) {
+		return err
+	}
+	// Windows refuses to replace a log another process holds open. Append the
+	// record instead so the outcome survives; compaction resumes on a later run.
+	// Other failures are returned so a log that can never be replaced cannot
+	// grow past the retention limit. The leading newline ends any unterminated
+	// tail, and readRuns skips the blank line it may leave. Zero's own readers
+	// hold the job lock.
+	if appendErr := appendRunLine(path, line); appendErr != nil {
+		return errors.Join(err, appendErr)
+	}
+	return nil
+}
+
+func appendRunLine(path string, line []byte) error {
+	f, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND, 0)
+	if err != nil {
+		return err
+	}
+	record := append(append([]byte{'\n'}, line...), '\n')
+	if _, err := f.Write(record); err != nil {
+		_ = f.Close()
+		return err
+	}
 	return f.Close()
 }

-func (s *Store) Runs(id string) ([]RunRecord, error) {
+// Runs returns the newest limit valid records in append order (oldest first).
+// Non-positive limits and limits above MaxRunHistory use MaxRunHistory. It reads
+// backwards from the tail, including for legacy logs not yet compacted.
+func (s *Store) Runs(id string, limit int) ([]RunRecord, error) {
 	if !validID(id) {
 		return nil, fmt.Errorf("invalid cron job id %q", id)
 	}
+	if limit <= 0 || limit > MaxRunHistory {
+		limit = MaxRunHistory
+	}
+	unlock, err := s.lockJob(id)
+	if err != nil {
+		return nil, err
+	}
+	defer unlock()
+	return s.readRuns(id, limit)
+}
+
+// readRuns requires the job lock. Memory is bounded by limit records plus one
+// line. Malformed and oversized legacy lines are skipped so they cannot prevent
+// recording new outcomes during compaction.
+func (s *Store) readRuns(id string, limit int) ([]RunRecord, error) {
 	f, err := os.Open(filepath.Join(s.jobDir(id), "runs.jsonl"))
 	if errors.Is(err, os.ErrNotExist) {
 		return nil, nil
@@ -352,14 +425,48 @@ func (s *Store) Runs(id string) ([]RunRecord, error) {
 		return nil, err
 	}
 	defer f.Close()
+	info, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
 	var runs []RunRecord
-	scanner := bufio.NewScanner(f)
-	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
-	for scanner.Scan() {
+	var line []byte
+	oversized := false
+	decode := func() {
+		slices.Reverse(line)
 		var rec RunRecord
-		if json.Unmarshal(scanner.Bytes(), &rec) == nil {
+		if json.Unmarshal(line, &rec) == nil {
 			runs = append(runs, rec)
 		}
+		line = line[:0]
 	}
-	return runs, scanner.Err()
+	var block [4096]byte
+	for end := info.Size(); end > 0 && len(runs) < limit; {
+		start := max(int64(0), end-int64(len(block)))
+		n, err := f.ReadAt(block[:end-start], start)
+		if err != nil {
+			return nil, err
+		}
+		for i := n - 1; i >= 0 && len(runs) < limit; i-- {
+			if block[i] == '\n' {
+				if !oversized {
+					decode()
+				}
+				oversized = false
+			} else if !oversized {
+				if len(line) >= maxRunBytes-1 {
+					line = line[:0]
+					oversized = true
+					continue
+				}
+				line = append(line, block[i])
+			}
+		}
+		end = start
+	}
+	if len(runs) < limit && len(line) > 0 {
+		decode()
+	}
+	slices.Reverse(runs)
+	return runs, nil
 }
@@ -238,7 +238,7 @@ func TestStoreAppendRun(t *testing.T) {
 			t.Fatalf("AppendRun: %v", err)
 		}
 	}
-	runs, err := s.Runs(job.ID)
+	runs, err := s.Runs(job.ID, 0)
 	if err != nil || len(runs) != 3 || runs[2].ExitCode != 2 {
 		t.Fatalf("Runs=%v err=%v", runs, err)
 	}
@@ -280,7 +280,7 @@ func TestStoreRejectsUnsafeID(t *testing.T) {
 		if _, err := s.Get(id); err == nil {
 			t.Fatalf("Get(%q) must be rejected", id)
 		}
-		if _, err := s.Runs(id); err == nil {
+		if _, err := s.Runs(id, 0); err == nil {
 			t.Fatalf("Runs(%q) must be rejected", id)
 		}
 	}
@@ -0,0 +1,73 @@
+//go:build windows
+
+package cron
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/sys/windows"
+)
+
+// Compacting runs.jsonl publishes a temporary file carrying the job directory's
+// inherited DACL. A rename would replace a restrictive DACL applied to the log
+// itself, so AppendRun must keep the log's own descriptor.
+func TestAppendRunPreservesHistoryDACL(t *testing.T) {
+	store := newTestStore(t)
+	job, err := store.Add(Job{Prompt: "x"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(store.jobDir(job.ID), "runs.jsonl")
+	if err := os.WriteFile(path, []byte("{\"exitCode\":7}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// A protected DACL granting only the owner: distinct from whatever the
+	// temporary file inherits from the directory.
+	restricted, err := windows.SecurityDescriptorFromString("D:P(A;;FA;;;OW)")
+	if err != nil {
+		t.Skipf("cannot build a test security descriptor: %v", err)
+	}
+	dacl, _, err := restricted.DACL()
+	if err != nil {
+		t.Skipf("cannot read the test DACL: %v", err)
+	}
+	if err := windows.SetNamedSecurityInfo(
+		path,
+		windows.SE_FILE_OBJECT,
+		windows.DACL_SECURITY_INFORMATION|windows.PROTECTED_DACL_SECURITY_INFORMATION,
+		nil, nil, dacl, nil,
+	); err != nil {
+		t.Skipf("cannot apply a restrictive DACL on this filesystem: %v", err)
+	}
+	want := describeDACL(t, path)
+	if inherited := describeDACL(t, store.jobDir(job.ID)); strings.Contains(inherited, want) {
+		t.Skip("the job directory already carries the same DACL; this filesystem cannot show the difference")
+	}
+
+	if err := store.AppendRun(job.ID, RunRecord{ExitCode: 42}); err != nil {
+		t.Fatal(err)
+	}
+	if got := describeDACL(t, path); got != want {
+		t.Fatalf("DACL after AppendRun = %q, want the log's own %q", got, want)
+	}
+	runs, err := store.Runs(job.ID, 10)
+	if err != nil || len(runs) != 2 || runs[1].ExitCode != 42 {
+		t.Fatalf("outcome not published by replacement: %+v, %v", runs, err)
+	}
+}
+
+func describeDACL(t *testing.T, path string) string {
+	t.Helper()
+	sd, err := windows.GetNamedSecurityInfo(path, windows.SE_FILE_OBJECT, windows.DACL_SECURITY_INFORMATION)
+	if err != nil {
+		t.Skipf("cannot read the security descriptor of %s: %v", path, err)
+	}
+	text := sd.String()
+	if index := strings.Index(text, "D:"); index >= 0 {
+		return text[index:]
+	}
+	return text
+}
@@ -72,9 +72,10 @@ func (w *execWorker) Kill() error {
 	if w.cmd.Process == nil {
 		return nil
 	}
-	// background.TerminateProcess is the cross-platform terminate (kills the
-	// process group on POSIX, taskkill /T on Windows).
-	return background.TerminateProcess(w.cmd.Process.Pid)
+	// The group the worker was launched into, not one rediscovered from its PID:
+	// the pool may call this after the worker has exited and been waited, and its
+	// children can still be running. See background.TerminateCommandGroup.
+	return background.TerminateCommandGroup(w.cmd)
 }

 // readerLines adapts a bufio.Reader to the Lines interface. Unlike a capped
@@ -154,13 +155,11 @@ func NewExecLauncher(cfg ExecLauncherConfig) (Launcher, error) {
 		background.ConfigureChildProcessGroup(cmd)
 		// CommandContext's default cancel sends os.Process.Kill to the LEADER only,
 		// orphaning the process group we just configured (a stuck worker's children
-		// would survive ctx cancellation). Terminate the whole group instead — the
-		// same cross-platform group terminate Kill() uses (D11).
+		// would survive ctx cancellation). Terminate the whole group instead, the
+		// same launch-time group terminate Kill() uses (D11). Cancel runs while Wait
+		// is in progress, so it must not reap.
 		cmd.Cancel = func() error {
-			if cmd.Process == nil {
-				return nil
-			}
-			return background.TerminateProcess(cmd.Process.Pid)
+			return background.TerminateCommandGroup(cmd)
 		}

 		stdout, err := cmd.StdoutPipe()
@@ -0,0 +1,90 @@
+//go:build !windows
+
+package daemon
+
+import (
+	"context"
+	"errors"
+	"os/exec"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// A WORKER'S CHILDREN ARE STOPPED THROUGH THE GROUP IT WAS LAUNCHED INTO.
+//
+// Kill and the Cancel hook used to hand the worker's PID to
+// background.TerminateProcess, which looks the group up again with Getpgid when it
+// signals. Once the worker has exited and been waited, that lookup fails, only the
+// dead PID is signalled, and whatever the worker left running survives; on Darwin
+// the lookup already fails while the exited worker is still a zombie. The worker
+// here is a shell that backgrounds a sleep, prints its PID and exits, so after the
+// wait the sleep is the only process left in the worker's group. Reported in #861.
+func TestExecWorkerStopsWhatItLeftRunningAfterItExits(t *testing.T) {
+	for _, stop := range []struct {
+		name string
+		run  func(*execWorker) error
+	}{
+		{"Kill", func(worker *execWorker) error { return worker.Kill() }},
+		{"Cancel hook", func(worker *execWorker) error { return worker.cmd.Cancel() }},
+	} {
+		t.Run(stop.name, func(t *testing.T) {
+			launcher, err := NewExecLauncher(ExecLauncherConfig{
+				Executable: "/bin/sh",
+				BaseArgs:   []string{"-c", "sleep 300 >/dev/null 2>&1 & echo $!"},
+			})
+			if err != nil {
+				t.Fatalf("NewExecLauncher: %v", err)
+			}
+			handle, err := launcher(context.Background(), WorkerSpec{})
+			if err != nil {
+				t.Fatalf("launch: %v", err)
+			}
+			worker, ok := handle.(*execWorker)
+			if !ok {
+				t.Fatalf("SETUP INVALID: the launcher returned %T, not the exec worker under test", handle)
+			}
+			line, ok, err := worker.Stdout().Next()
+			if err != nil || !ok {
+				t.Fatalf("read the child's pid: ok=%v err=%v", ok, err)
+			}
+			childPID, err := strconv.Atoi(strings.TrimSpace(line))
+			if err != nil {
+				t.Fatalf("parse the child's pid %q: %v", line, err)
+			}
+			t.Cleanup(func() { _ = syscall.Kill(childPID, syscall.SIGKILL) })
+
+			if _, err := worker.Wait(); err != nil {
+				t.Fatalf("wait for the worker: %v", err)
+			}
+			if childStopped(childPID) {
+				t.Fatalf("SETUP INVALID: the worker's child %d is not running, so there is nothing left to stop", childPID)
+			}
+
+			// The pool ignores what Kill returns; the outcome is what matters.
+			_ = stop.run(worker)
+
+			deadline := time.Now().Add(5 * time.Second)
+			for !childStopped(childPID) {
+				if time.Now().After(deadline) {
+					t.Fatalf("the worker's child %d survived %s after the worker was reaped", childPID, stop.name)
+				}
+				time.Sleep(20 * time.Millisecond)
+			}
+		})
+	}
+}
+
+// childStopped reports whether pid is gone or only waiting to be reaped.
+func childStopped(pid int) bool {
+	if errors.Is(syscall.Kill(pid, syscall.Signal(0)), syscall.ESRCH) {
+		return true
+	}
+	state, err := exec.Command("ps", "-o", "stat=", "-p", strconv.Itoa(pid)).Output()
+	if err != nil {
+		return errors.Is(syscall.Kill(pid, syscall.Signal(0)), syscall.ESRCH)
+	}
+	return strings.HasPrefix(strings.TrimSpace(string(state)), "Z")
+}
@@ -17,6 +17,28 @@ const (
 	ExitPermanent = 76
 )

+// Exit codes `zero exec` (internal/cli/exec.go) uses to report a run that
+// finished, or was stopped on purpose, rather than crashed. They are duplicated
+// here because the daemon cannot import the CLI package; keep them in sync.
+const (
+	exitUsage       = 2   // bad flags or arguments: a retry fails the same way
+	exitProvider    = 3   // provider failure the run already surfaced
+	exitIncomplete  = 4   // the agent ran (edits, commands) and stopped unfinished
+	exitInterrupted = 130 // SIGINT: someone stopped it on purpose
+)
+
+// isFinalExit reports whether a worker exit code means the run is over and must
+// not be retried. Retrying would repeat the agent's side effects and re-bill the
+// provider, and append a second run to the same session stream. Only crash-type
+// exits (1, signals) and launch/read errors are worth another attempt.
+func isFinalExit(code int) bool {
+	switch code {
+	case exitUsage, exitProvider, exitIncomplete, exitInterrupted:
+		return true
+	}
+	return false
+}
+
 // defaultPoolSize, defaultMaxAttempts and defaultKillTimeout are used when a
 // PoolOptions field is left zero.
 const (
@@ -176,7 +198,8 @@ type Sink interface {
 // Run leases a worker slot and dispatches spec to a worker, streaming its
 // stream-json lines to sink. It is at-least-once with bounded retries: a worker
 // that crashes (non-zero, non-permanent) is retried on a fresh worker after a
-// backoff; ExitPermanent or exhausting MaxAttempts returns ErrPermanent. Run
+// backoff; ExitPermanent, a final `zero exec` exit (usage, provider, incomplete,
+// interrupted) or exhausting MaxAttempts returns ErrPermanent. Run
 // queues when all slots are busy. The returned int is the final worker exit code.
 func (p *Pool) Run(ctx context.Context, spec WorkerSpec, sink Sink) (int, error) {
 	if err := p.acquire(ctx); err != nil {
@@ -209,6 +232,9 @@ func (p *Pool) Run(ctx context.Context, spec WorkerSpec, sink Sink) (int, error)
 		case code == ExitPermanent:
 			p.logf("worker %d exited permanently (code=%d) — not retrying", stat.id, code)
 			return code, ErrPermanent
+		case isFinalExit(code):
+			p.logf("worker %d finished with exit code %d — not retrying", stat.id, code)
+			return code, fmt.Errorf("%w: worker %d exited code=%d", ErrPermanent, stat.id, code)
 		case code == ExitTempfail:
 			lastErr = fmt.Errorf("worker %d tempfail (code=%d)", stat.id, code)
 			p.logf("worker %d tempfail — retry after %s", stat.id, p.opts.TempfailDelay)
				`@@ -1 +0,0 @@`
				`{"type":"bridge-session","sessionId":"b0000000-0000-4000-8000-000000000001","bridgeSessionId":"bridge_01","lastSequenceNum":0}`