throughline 0.8.6 → 0.8.8

package/CHANGELOG.md

@@ -10,6 +10,34 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.8.8] — 2026-08-02
+
+### Fixed
+
+- Codex hook installation now writes the supported `timeout` field in seconds
+  for UserPromptSubmit, PostToolUse, and Stop. The previously emitted
+  `timeoutSec` field was ignored by Codex, leaving all three hooks at the
+  600-second default.
+- Reinstall canonicalizes existing Throughline-managed hooks by command
+  identity, replacing legacy `timeoutSec` entries while preserving unrelated
+  Codex hooks. Doctor reports the effective `timeout` field and explicitly
+  flags the legacy key for reinstall; factory diagnostics no longer classify
+  the ignored key as ready.
+
+## [0.8.7] — 2026-07-20
+
+### Fixed
+
+- Windows CI no longer calls the completed-turn receipt ACL PowerShell path
+  hundreds of times just to construct 256-record boundary fixtures. Boundary
+  behavior still crosses the limit through the public API, while dedicated
+  tests preserve native owner-only ACL verification and atomic failure safety.
+- Completed-turn receipt mutations now spend ACL subprocesses only on distinct
+  state transitions: three for a new Windows store and four for a replacement.
+- CI keeps the full 3-OS by 3-Node matrix, cancels only older runs for the same
+  event and ref, and gives the unit-test step an eight-minute regression guard
+  around a five-minute Windows SLO.
+
 ## [0.8.6] — 2026-07-20
 
 ### Fixed
@@ -1163,7 +1191,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.6...HEAD
+[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.8...HEAD
+[0.8.8]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.7...v0.8.8
+[0.8.7]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.6...v0.8.7
 [0.8.6]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.5...v0.8.6
 [0.8.5]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.4...v0.8.5
 [0.8.4]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.3...v0.8.4

package/README.ja.md

@@ -14,6 +14,16 @@
 > **Claude Code のコンテキスト消費を約 90% 削減しつつ、記憶はほぼそのまま残す。**
 > 「時間の新旧」ではなく **「コンテンツの種類」** で会話を分離する。人間が読みたいテキストは残し、機械が出力したツール I/O は SQLite に退避する。同じ判断、同じ文脈、9 割軽量。
 
+[kitepon.dev](https://kitepon.dev/)を運営する[クオ（@QLyun35332）](https://x.com/QLyun35332)が
+開発・メンテナンスしています。
+
+## 所有境界
+
+本repositoryはdatabase、migration、capture契約、release、diagnosticsを所有します。
+製品横断の導入とhost統合は、kitepon.devの製品開発を支える内部基盤
+[dotagents](https://github.com/kitepon-rgb/dotagents)が担当します。
+MarkItDownは別区分の第三者CLIです。
+
 ## 30 秒で始める
 
 ```bash
@@ -363,6 +373,7 @@ Throughline state をまだ書いていない現在セッションも表示で
 - [`docs/09_rollback_context_trim_insight.md`](docs/09_rollback_context_trim_insight.md) — rollback / trim 設計 insight。復元 memory を current work として読ませる制約も記録
 - [`docs/07_codex_trim_implementation_plan.md`](docs/07_codex_trim_implementation_plan.md) — Claude/Codex 両対応と rollback trim の統合 TODO 計画
 - [`docs/04_public_release_plan.md`](docs/04_public_release_plan.md) — 公開配布化プラン、§ 0 フォールバック禁止ルール、バージョン別実装ステータス
+- [`docs/15_windows_ci_release_latency_plan.md`](docs/15_windows_ci_release_latency_plan.md) — Windows CI性能gateとACL契約を維持するrelease工程
 - [`CHANGELOG.md`](CHANGELOG.md) — リリース履歴
 - [`docs/archive/`](docs/archive/) — 破棄済み旧設計 (CONCEPT 初期案、session-linking 実験記録など)
 

package/README.md

@@ -14,6 +14,16 @@
 > **Cut ~90% of Claude Code's context usage while keeping nearly all the memory.**
 > Throughline separates conversation by **type, not time** — humans-readable text stays, machine-generated tool output retires to SQLite. Same decisions, same context, 90% lighter.
 
+Built and maintained by [Quo](https://x.com/QLyun35332) at [kitepon.dev](https://kitepon.dev/en).
+
+## Ownership boundary
+
+This repository owns the database, migrations, capture contracts, release, and
+diagnostics. Cross-product installation and host integration are handled by
+[dotagents](https://github.com/kitepon-rgb/dotagents), the internal development
+toolchain behind kitepon.dev's products.
+MarkItDown is a separately managed third-party CLI.
+
 ## In 30 seconds
 
 ```bash
@@ -1148,6 +1158,8 @@ the first generation to pick up the auto-start task.
 - [`docs/04_public_release_plan.md`](docs/04_public_release_plan.md) — public
   release plan, implementation status by version, § 0 fallback rule, and
   remaining tasks.
+- [`docs/15_windows_ci_release_latency_plan.md`](docs/15_windows_ci_release_latency_plan.md) —
+  Windows CI performance gate and the ACL-preserving release workflow.
 - [`docs/archive/`](docs/archive/) — superseded design documents kept for
   historical reference (original CONCEPT, session-linking experiments,
   pre-publish action list).

package/docs/00_overview.md

@@ -19,6 +19,7 @@
 | [11_codex_monitor_implementation_plan.md](11_codex_monitor_implementation_plan.md) | Codex monitor 対応の実装記録 |
 | [13_native_factory_diagnostics_plan.md](13_native_factory_diagnostics_plan.md) | native factory read-only readiness 診断の実装記録 |
 | [14_observer_completed_turn_feed_plan.md](14_observer_completed_turn_feed_plan.md) | Observer向けcompleted-only read / wait CLIのactive計画。CLI・opaque cursor・pagination・最大3600秒waitは実装済み、公開／full regression gateは継続中 |
+| [15_windows_ci_release_latency_plan.md](15_windows_ci_release_latency_plan.md) | Windows CI 18分の原因、ACL安全網を維持した短縮、release gateの受入条件 |
 | [BUGHUB_RUNTIME_ERROR_STORE_PLAN.md](BUGHUB_RUNTIME_ERROR_STORE_PLAN.md) | local runtime error aggregate store の契約と実装 TODO |
 
 ## Supporting Records
@@ -35,6 +36,7 @@
 - [ADR 0001](adr/0001-claude-primary-codex-adapter.md): Claude primaryを維持し、Codexをadapterとして追加する。
 - [ADR 0002](adr/0002-observer-claude-completion-receipt.md): Claude completed turnはThroughline所有のStop receiptで固定する。
 - [ADR 0003](adr/0003-observer-completed-chain-cursor.md): Observer cursorをhost固有のcompleted pair chainとprefix検証へ束縛する。
+- [ADR 0020](adr/0020-windows-ci-release-latency.md): Windows ACL契約を維持し、境界fixtureと実ACL検証を分離する。
 
 Observerの公開境界は`throughline observer-read`／`throughline observer-wait`のJSON-only CLIである。
 ThroughlineはClaude Stop receiptとCodex rolloutの`task_complete`だけからcompleted cursorを構築し、

package/docs/04_public_release_plan.md

@@ -142,6 +142,8 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.6.3): Codex diagnostics ready 集約 + Windows bounded observer** | 3 managed Codex hooks が canonical `ready` のとき hook summary / Codex connector を `ready` とし、未検査 Claude connector は明示 `unverified` のまま Codex-only overall から除外する。Windows runtime-error observer は、既存 state の使用前検証と新規 file の ACL 付与・read-back を維持しつつ、同一 mutation 内の重複 PowerShell ACL 検証を除いた。公開commit `fc83ddf`、CI `29284655280`（9/9 green）、npm `throughline@0.6.3`、tag / GitHub Release、npm shasum `4f3fcd2598a75f026358dae7f3eb3165242b580b` を2026-07-14に確認した |
 | **npm 公開 (v0.8.4): Codex handoff host境界の明示化** | `$throughline` skillは現在のCodex UI surfaceからDesktop／VS Code／CLIを選び、`--open-host`を明示する。shell／永続PTYの継承環境はsurface判定に使わない。`codex-handoff-start`は互換の`openHost`を残し、requested / resolved hostをJSONとtextで報告する。古いVS Code由来PTY事故形と配布skillをfocused testで固定し、Claude-facing hook／`/tl`／baton／resume契約は変更しない。公開commit `5b840b6`、CI run `29721583754` 9/9 green、npm `latest` 0.8.4、shasum `1f2c39a22e45f3e02e8739ee5fd6ceefc6a71034`、tag / GitHub Release、registry由来global install、配置skill一致、`doctor --codex` exit 0を2026-07-20に確認した。判断証拠は [ADR 0017](adr/0017-codex-handoff-host-boundary.md) |
 | **npm公開 (v0.8.6): 製品所有DB migration入口** | `throughline migrate --json` は既存DBだけをproduction migrationで現行schemaへ移行し、versioned bounded JSONを返す。DB不在は作らず`not_applicable`、現行は`already_current`、future schemaと失敗は非0。`factory-diagnostics`のread-only契約は維持する。0.8.5はdry-run後に別作業の未コミット文書が混入したためdeprecateし、同一runtimeをclean worktreeから0.8.6として再公開した。設計判断は [ADR 0018](adr/0018-product-owned-database-migration.md) |
+| **公開済み (v0.8.7): Windows CI release latency** | completed-turn receiptの256件境界fixtureと実ACL検証を分離し、production mutationのPowerShellはdistinct state transitionだけに限定する。temporary ACL失敗時の旧store保持とdirectory／lock／final storeのnative ACL testを維持する。CIは9 matrixのままevent／ref単位concurrency、unit test 5分SLO／8分timeoutとする。設計判断は [ADR 0020](adr/0020-windows-ci-release-latency.md) |
+| **release準備 (v0.8.8): Codex hook timeout key修理** | Codex `hooks.json` の3 managed hookは秒単位の正規key `timeout`を30／30／300で書く。無視される旧`timeoutSec` entryは次回global installでcommand identityにより置換し、doctorは旧形式を要再install、factory diagnosticsはnot readyとする。Claude hooksとObserver wait deadline APIは変更しない |
 | **未リリース: Codex current-session 75% trigger** | Codex 自動発火を token-monitor に依存させず、global install が Codex `UserPromptSubmit` / `PostToolUse` hooks も登録する。hook は当該 Codex session の rollout `token_count` を直接読み、verified 75% 以上なら同じ user turn または tool loop 継続前に `$throughline` workflow 実行指示を `additionalContext` で注入する。Stop hook の guarded auto-refresh は残す。`~/.codex/config.toml` は旧 `codex_hooks = true` に加えて現行 `hooks = true` も有効化する |
 | **グローバル E2E 検証** | 2026-04-17 別ディレクトリから `throughline doctor` 全緑を確認 |
 

package/docs/05_codex_first_roadmap.md

@@ -456,9 +456,9 @@ Phase 5 implementation status (2026-05-06):
   - 修正: Caveat の Codex Stop hook は `async: false` で登録され、nested `codex exec` smoke で Stop -> 次 turn 注入まで確認済みだった。Throughline は Claude Stop と同じ発想で Codex Stop も `async: true` にしていたため、Codex 側だけ Caveat と同じ同期 hook に寄せた。既に `async: true` で登録済みの Throughline Codex Stop hook も次回 `throughline install` で `async: false` に更新される。
   - 再実測: `npm install -g .` -> `throughline install` 後、`~/.codex/hooks.json` の Throughline Codex Stop は `async: false` になり、Caveat / Spotter hooks は保持された。`codex exec --json -C /home/kite/projects/Throughline "Reply exactly: TL_CODEX_SYNC_STOP_SMOKE_20260506"` で child thread `019dfd4f-93ff-7522-8f89-bd1e1996c8d7` が作られ、直後の `throughline doctor --codex` で latest DB session が `codex:019dfd4f-93ff-7522-8f89-bd1e1996c8d7` に進んだ。Codex Stop hook の自然 capture は同期登録で確認済み。
   - 追加修正: Caveat の Codex hook は bare `caveat` ではなく絶対 node + installed CLI script path で登録されていた。Throughline も Codex App Server / VSCode host の PATH 差分を避けるため、旧 bare `throughline codex-hook stop` を次回 install で絶対 node + `bin/throughline.mjs codex-hook stop` に置換する。`doctor --codex` は Codex hook feature / Throughline Stop hook command / legacy bare command を診断表示する。
-  - 絶対パス型の再実測: `npm install -g .` -> `throughline install` 後、`~/.codex/hooks.json` の Stop 先頭は `/usr/bin/node /home/kite/projects/Throughline/bin/throughline.mjs codex-hook stop`、`async: false`、`timeoutSec: 300` になり、Caveat / Spotter hooks は 2 番目以降に保持された。`doctor --codex` は `Codex hooks feature: enabled` / `Codex Stop hook: registered` を表示した。`codex exec --json -C /home/kite/projects/Throughline "Reply exactly: TL_CODEX_ABSOLUTE_STOP_SMOKE_20260506"` で child thread `019dfd5e-1248-7c11-8ddc-97e1b0701e10` が作られ、直後の `throughline doctor --codex` で latest DB session が `codex:019dfd5e-1248-7c11-8ddc-97e1b0701e10` に進んだ。
+  - 絶対パス型の再実測: `npm install -g .` -> `throughline install` 後、`~/.codex/hooks.json` の Stop 先頭は `/usr/bin/node /home/kite/projects/Throughline/bin/throughline.mjs codex-hook stop`、`async: false`になり、Caveat / Spotter hooks は 2 番目以降に保持された。2026-08-02 correction: 当時記録した`timeoutSec: 300`はCodexに無視される誤keyで、v0.8.8から正規の`timeout: 300`へ修正した。`doctor --codex` は `Codex hooks feature: enabled` / `Codex Stop hook: registered` を表示した。`codex exec --json -C /home/kite/projects/Throughline "Reply exactly: TL_CODEX_ABSOLUTE_STOP_SMOKE_20260506"` で child thread `019dfd5e-1248-7c11-8ddc-97e1b0701e10` が作られ、直後の `throughline doctor --codex` で latest DB session が `codex:019dfd5e-1248-7c11-8ddc-97e1b0701e10` に進んだ。
   - 追加確認: current VSCode-origin parent thread `019dfd38-c530-71c3-b7b8-180bdd3054bc` は hook shape 変更前に開始していたため、変更後の自然 Stop smoke としては不適格。assistant final 後に rollout は `task_complete` まで進んだが latest DB session は exec child のままだった。次に VSCode-origin を見る場合は、hook shape 変更後に新しく開始した Codex session で確認する。
-  - 最終確認: hook shape 変更後に新しく開始した VSCode-origin Codex session で 1 turn 完了後、`throughline doctor --codex` を実行した。`current Codex thread` は `019dfd62-9a9d-7211-bf91-89d8e3fc908e`、`latest DB session` は `codex:019dfd62-9a9d-7211-bf91-89d8e3fc908e` で一致し、`Codex hooks feature: enabled`、`Codex Stop hook: registered`、command は `/usr/bin/node /home/kite/projects/Throughline/bin/throughline.mjs codex-hook stop`、`async: false`、`timeoutSec: 300` だった。VSCode-origin の自然 Stop hook による DB capture も解決済みとして扱う。
+  - 最終確認: hook shape 変更後に新しく開始した VSCode-origin Codex session で 1 turn 完了後、`throughline doctor --codex` を実行した。`current Codex thread` は `019dfd62-9a9d-7211-bf91-89d8e3fc908e`、`latest DB session` は `codex:019dfd62-9a9d-7211-bf91-89d8e3fc908e` で一致し、`Codex hooks feature: enabled`、`Codex Stop hook: registered`、command は `/usr/bin/node /home/kite/projects/Throughline/bin/throughline.mjs codex-hook stop`、`async: false`だった。2026-08-02 correction: 当時の`timeoutSec: 300`は無効で、v0.8.8の再install後は`timeout: 300`を正とする。VSCode-origin の自然 Stop hookによるDB captureの証拠自体は維持する。
   - historical 2026-05-07 correction: 以下の Codex trim smoke は live app-server primitive の履歴として残す。ただし 2026-05-06 incident 後、restart / reconnect 越しの durable context trim 成功とは一時的に扱わず、`$throughline` / Codex Stop hook の automatic mutation を止めていた。
   - 2026-05-10 UX 修正: bare `$throughline` は `doctor --codex` / `trim --dry-run --all` / `trim --preflight --all` を AI に順番実行させる説明 surface でも、`trim --execute --host codex --all` を直接実行する current-thread refresh でもなく、`throughline codex-handoff-start --execute --open-host <current-codex-surface>` による app-server 新スレッド handoff とする。current surfaceはCodex UI contextから明示し、current-thread rollback / inject は明示要求時だけ使う。
   - memory contract 修正: Codex guarded trim でも注入 memory は元の `/tl` 思想を正とする。古い turn は L1 summaries、直近 20 turn は L2 full bodies、L3 は reference only で、L3 bodies / tool payloads は注入しない。rollout source は rollback candidate と app-server turn-count 補正の根拠であり、Throughline DB memory がある場合に rollout active work preview を注入 memory として使わない。DB memory が無い execute は rollout preview を注入せず、mutation 前に拒否する。

package/docs/15_windows_ci_release_latency_plan.md

@@ -0,0 +1,89 @@
+# Windows CI・リリース待ち時間改修計画
+
+## 目的
+
+ThroughlineのWindows CIがLinux／macOSの約1分に対して16〜18分かかり、定型releaseを
+実用不能な長さへ押し上げている。Windows互換性matrixとowner-only ACL契約を維持したまま、
+unit testを5分以内（目標3分以内）へ短縮し、release前の同一candidateに対するCIを1回へ
+集約する。
+
+## 現状の実測
+
+GitHub Actions run `29722650046`（Windows Node 22.13.0）のTAP計測では、次の3テストが
+突出していた。TAP durationはwall timeとして加算せず、job全体の実測約18分をbaselineとする。
+
+| テスト | `duration_ms` |
+|---|---:|
+| observer feed: Claude history floor, host/thread switch, cross-host tie, and opaque cursor | 568,093 ms |
+| completed turn receipt: bounded store drops only oldest receipts | 559,807 ms |
+| completed turn receipt: noisy project cannot evict another project anchor | 436,267 ms |
+
+3テストはいずれも256件境界を作るため公開APIを257回呼び、その各mutationでWindows
+PowerShellを複数回起動してdirectory／lock／temporary／final storeのACLを検証している。
+境界計算の反復とACL実機検証が結合されていることが主因で、runner一般の遅さではない。
+
+また現行workflowはmainへのpushごとに9 matrixを新規起動し、同じbranchの旧runをcancelしない。
+短時間の段階commitでWindows 18分runが重複する。
+
+## 決定
+
+1. completed-turn receiptの大量境界テストは、正規schemaの境界直前storeをfixtureとして用意し、
+   最後の1 mutationだけ公開APIで実行する。limit超過、history floor、project分離、cursor判定の
+   受入条件は変更しない。
+2. Windows owner-only ACLは専用integration testでdirectory、SQLite lock、final storeを
+   `windows-acl-test-helper`から外部検証する。大量境界テストからPowerShell反復を除いても、
+   production ACL契約の実機coverageを失わない。
+3. CIのunit test stepへ`timeout-minutes: 8`を設定する。SLOは5分、目標3分としrunner遅延と分離する。
+4. workflowへevent／ref単位の`concurrency`を設定し、新しいcommitが来た時は同一event／refの
+   古いrunだけをcancelする。手動runとpush／PRは相互cancelしない。
+5. OS 3種 × Node `22.13.0`／`22.x`／`24.x`の9 matrixは維持する。互換範囲を速度対策のために
+   縮小しない。
+6. `0.8.7`の最終candidateへ実装・version・CHANGELOG・README・正本文書をまとめ、push後CIを
+   1回だけrelease gateとして使う。公開後のSHA／CI番号はGitHub Releaseを正本とし、証拠追記だけの
+   追加commit／追加CIを作らない。
+
+## 非目標
+
+- Windows ACLの適用・read-back検証、atomic rename、失敗時の旧store保持を弱めない。
+- Windows testをskipしない。matrixのOS／Node versionを減らさない。
+- completed-turn receiptの256件limit、history floor、cursor、project分離契約を変えない。
+- Claude hooks、Codex adapter、DB migration、handoff契約を変更しない。
+- release自動publishやcredential保管をworkflowへ追加しない。
+
+## 既知の罠
+
+- fixtureを直接書くだけでは公開APIの境界mutationを検証できない。必ずlimit直前から最後の1件を
+  `writeCompletedTurnReceipt`で追加する。
+- Windowsでfixtureを書き換える時も既存owner-only ACLを保持し、専用ACL testはproduction APIが
+  作った実pathを外部helperで検査する。
+- `concurrency.cancel-in-progress`は別branch／別PRをcancelしないref単位にする。
+- test timeoutはunit test stepへ8分で置き、5分SLOにrunner一時遅延の余白を持たせる。
+- 進行中の旧CIを新しいcandidateの成功証拠として流用しない。
+
+## 受入条件
+
+- [ ] 3つの大量境界テストが公開契約を維持したままPowerShell反復を行わない。
+- [ ] Windows専用ACL testがdirectory／lock／storeのowner-only ACLを外部検証する。
+- [ ] focused testとfull `npm test`がgreen。
+- [ ] CI定義にunit test 8分上限とevent／ref単位concurrencyがある。
+- [ ] 最終GitHub Actionsで9/9 green、Windows各jobのunit testが5分以内（目標3分以内）。
+- [ ] `npm pack --dry-run --json`で公開物を確認する。
+- [ ] npm `throughline@0.8.7`、tag／GitHub Release、registry由来global install、
+  `throughline --version = 0.8.7`、配置skill／hooks／doctorを確認する。
+
+## 敵対的検証の反映
+
+read-only refuterはP0なし、P1を4件報告した。TAP durationをwall timeとして加算しないこと、
+temporary ACL失敗時の旧store保持testを加えること、concurrencyへ`event_name`を含めること、
+5分SLOとtimeoutを分離することを採用した。fixture seedと本体の重複ACL検証削減は、最後の公開API
+mutation、native final-path ACL test、atomic failure testを同時に置く条件で妥当と裁定した。
+
+## 工程
+
+工程状態と完了証拠の正本はLattice storeとし、この文書は目的、判断、非目標、受入条件を所有する。
+
+1. ベースライン計測と原因同定
+2. 敵対的検証と設計裁定
+3. 安全網とfixture分離
+4. workflow・文書統合
+5. push後CI、npm公開、global install

package/docs/adr/0019-product-owned-database-migration-acceptance.md

@@ -0,0 +1,54 @@
+# ADR 0019: 製品所有DB migrationの公開受入
+
+## 状態
+
+Accepted — 2026-07-20
+
+## 親裁定
+
+`throughline migrate --json` の実装と公開版 `0.8.6` を、Throughlineの製品所有DB migration入口として
+受け入れる。`factory-diagnostics`のread-only契約、DB不在時に作成しない契約、future schema拒否を維持する。
+
+## 実装・回帰証拠
+
+- 設計: [ADR 0018](0018-product-owned-database-migration.md)
+- 実装commit: `6fd9554`
+- clean republish commit: `4f9908d`
+- focused test: DB schema、factory diagnostics、migrate CLIの16件すべてgreen
+- full test: 実装受入時の `npm test` green
+- GitHub CI: run `29724249940`、Node 22.13.0／22.x／24.x × macOS／Ubuntu／Windowsの9/9 green
+- clean pack: 208 files、`src/cli/migrate.mjs`を収録し、並行作業の
+  `docs/15_windows_ci_release_latency_plan.md`を含まないことを機械確認
+
+## 公開証拠
+
+- npm `latest`: `throughline@0.8.6`
+- registry shasum: `b4a9ccda9b69715d51c37408d696a210103ee47a`
+- tag / GitHub Release: `v0.8.6`
+- `0.8.5`はrelease dry-run後に別セッションの未コミット文書1件がworktreeへ書かれ、tarballへ混入した。
+  runtime codeは同一だったがpackage scopeを不合格とし、tag / GitHub Releaseを作らずnpm deprecateした。
+  `0.8.6`は受理済みcommitから作った隔離clean worktreeで再pack・再公開した。
+
+## 4 host受入
+
+| host | version | migration | DB schema | Throughline factory check |
+|---|---:|---|---|---|
+| mac-kite | 0.8.6 | `already_current` | 9 / 9 | ready |
+| main-server | 0.8.6 | `already_current` | 9 / 9 | ready |
+| FOX WSL2 | 0.8.6 | `already_current` | 9 / 9 | ready |
+| FOX Windows native | 0.8.6 | `already_current` | 9 / 9 | ready |
+
+FOX Windows nativeは旧command形のCodex hook 3本を検出したため、`throughline install`でThroughline管理分だけを
+現行形へ正規化し、再投影後に`database_schema=pass`、`codex_hooks=pass`を確認した。UI trustは人手領域として
+変更していない。
+
+dotagentsのfactory reporter全体は、Caveat native diagnostics、Codex routing、toolchain ledger、
+main-server stale ingestという既存の別checkによりredのままである。Throughline migration／schema／hooksとは
+分離し、他製品の修理を本受入へ混入させない。Lattice checkは全hostでpassし、Lattice本体は変更していない。
+
+## H操作の記録とrollback
+
+目的は更新直後のDB migrationを製品所有入口で確定し、全hostへ配布すること。影響はnpm `latest`、Git tag / Release、
+4hostのglobal Throughline、FOX WindowsのThroughline管理hook/skillである。rollbackはnpm `latest`とglobal installを
+0.8.4へ戻し、hookは`throughline uninstall`または保存済み設定backupから復元する。DB schemaの自動downgradeはせず、
+必要時は更新前DB backupから復元する。オーナーの本戦役H承認に基づき実行した。

package/docs/adr/0020-windows-ci-release-latency.md

@@ -0,0 +1,56 @@
+# ADR 0020: Windows CI release latency
+
+- Status: Accepted
+- Date: 2026-07-20
+- Scope: Throughline v0.8.7 release gate
+
+## Context
+
+GitHub Actions run `29722650046` のWindows jobは約18分を要した。TAP上で突出した3テストは、
+completed-turn receiptの256件境界を作るためproduction APIを257回呼び、mutationごとに
+PowerShellでdirectory、SQLite lock、temporary、final storeのowner-only ACLを適用・検証していた。
+境界計算の反復とWindows実ACLのintegration検証が結合され、短時間のmain pushでは9 job matrixが
+重複起動していた。
+
+read-only refuterによる敵対的検証ではP0はなく、次のP1を設計へ反映した。
+
+- temporary ACL失敗時に旧storeを保持する回帰testが不足していた。
+- refだけのconcurrency groupはmain pushと`workflow_dispatch`を相互cancelし得る。
+- 5分SLOと同値のstep timeoutは共有runnerの一時遅延でflakeし得る。
+- TAP durationの合計をjob wall timeとして扱ってはならない。
+
+## Decision
+
+1. 大量境界testは、production APIによる最初のprivate store作成後に正規schemaの256件fixtureをseedし、
+   257件目だけをproduction APIで追加する。limit、history floor、project isolation、observer cursorの
+   公開契約は変えない。
+2. Windows ACLは三層で固定する。mock testで初回3回・継続4回のdistinct transitionを検査し、
+   temporary ACL失敗時の旧store保持を失敗注入で検査し、Windows native testでdirectory、lock、
+   final storeのowner-only ACLを外部helperから検査する。
+3. completed-turn receipt本体は、apply scriptが同じPowerShell process内でread-back済みの新規
+   directory／lock／temporaryを直後に再検証しない。ACL済みtemporaryのrename後はshapeだけを
+   in-process検査し、final pathの実ACLはnative integration testで証明する。
+4. CIはOS 3種 × Node `22.13.0`／`22.x`／`24.x`の9 matrixを維持する。unit test SLOは5分、
+   目標3分、step timeoutは8分とする。
+5. concurrency groupはworkflow、event、refで分離する。同じpush refまたは同じPR refの旧runだけを
+   cancelし、`workflow_dispatch`とpush／PRは相互cancelしない。
+6. 公開commitのCI番号・npm shasum・global install証拠はGitHub Releaseへ置く。証拠追記だけの
+   Git commitと追加CIは作らない。
+
+## Compatibility
+
+- completed-turn receiptのschema、256件limit、pair identity、atomic rename、fail-closed ACLを維持する。
+- Windows、macOS、LinuxおよびNode matrixを減らさない。
+- Claude hooks、Codex adapter、Observer JSON-only CLI、DB migrationの挙動を変更しない。
+
+## Rollback
+
+公開前はfixture、本体最適化、workflow変更を同時にrevertする。公開後に戻す場合もACL安全網testを
+先に外さず、旧実装へ戻したcandidateの9 matrixを通してから公開する。store migrationは不要である。
+
+## Non-goals
+
+- Windows testやACL検査のskip
+- matrix縮小
+- npm自動publish、credential保管
+- release番号だけを根拠にした性能成功扱い

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [
@@ -9,12 +9,19 @@
     "context-compression",
     "llm"
   ],
-  "author": "kitepon",
+  "author": {
+    "name": "Quo / クオ at kitepon.dev",
+    "url": "https://kitepon.dev/"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kitepon-rgb/Throughline.git"
   },
+  "bugs": {
+    "url": "https://github.com/kitepon-rgb/Throughline/issues"
+  },
+  "homepage": "https://github.com/kitepon-rgb/Throughline#readme",
   "bin": {
     "throughline": "bin/throughline.mjs"
   },

package/src/cli/doctor.mjs

@@ -480,6 +480,31 @@ function summarizeHookTrust(hooks, { hooksFeatureEnabled, codexHooksFeatureEnabl
   };
 }
 
+function hasLegacyCodexHookTimeout(hook) {
+  return Object.hasOwn(hook, 'timeoutSec');
+}
+
+function describeCodexHookRegistration(hooks, legacyCommandHooks, expectedTimeout) {
+  if (hooks.length === 0) return 'not registered';
+  if (legacyCommandHooks.length > 0) return 'legacy command needs reinstall';
+  if (hooks.some(hasLegacyCodexHookTimeout)) return 'legacy timeout key needs reinstall';
+  if (hooks.length !== 1) return 'configuration needs reinstall';
+  const hook = hooks[0];
+  return hook.type === 'command' && hook.timeout === expectedTimeout && hook.async === false
+    ? 'registered'
+    : 'configuration needs reinstall';
+}
+
+function printCodexHookDetails(hook) {
+  console.log(`    command:             ${hook.command}`);
+  console.log(`    async:               ${hook.async === false ? 'false' : String(hook.async)}`);
+  console.log(`    timeout:             ${hook.timeout ?? '(default: 600)'}`);
+  if (hasLegacyCodexHookTimeout(hook)) {
+    console.log(`    legacy timeoutSec:   ${hook.timeoutSec} (ignored by Codex; reinstall required)`);
+  }
+  console.log(`    trusted:             ${hook.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+}
+
 function readCodexHookDiagnosis(codexHome) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
@@ -599,47 +624,29 @@ function runCodexDiagnosis({
   console.log(`  CODEX_HOME:            ${codexHome}`);
   console.log(`  Codex hooks feature:   ${hookDiagnosis.featureEnabled ? 'enabled' : 'not enabled'}`);
   console.log(`  Codex hook trust:      ${hookDiagnosis.managedHookTrust.status}`);
-  console.log(`  Codex UserPrompt hook: ${
-    hookDiagnosis.managedPromptHooks.length === 0
-      ? 'not registered'
-      : hookDiagnosis.legacyManagedPromptHooks.length > 0
-        ? 'legacy command needs reinstall'
-        : 'registered'
-  }`);
+  console.log(`  Codex UserPrompt hook: ${describeCodexHookRegistration(
+    hookDiagnosis.managedPromptHooks,
+    hookDiagnosis.legacyManagedPromptHooks,
+    30,
+  )}`);
   if (hookDiagnosis.managedPromptHooks.length > 0) {
-    const h = hookDiagnosis.managedPromptHooks[0];
-    console.log(`    command:             ${h.command}`);
-    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
-    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
-    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+    printCodexHookDetails(hookDiagnosis.managedPromptHooks[0]);
   }
-  console.log(`  Codex PostTool hook:   ${
-    hookDiagnosis.managedPostToolUseHooks.length === 0
-      ? 'not registered'
-      : hookDiagnosis.legacyManagedPostToolUseHooks.length > 0
-        ? 'legacy command needs reinstall'
-        : 'registered'
-  }`);
+  console.log(`  Codex PostTool hook:   ${describeCodexHookRegistration(
+    hookDiagnosis.managedPostToolUseHooks,
+    hookDiagnosis.legacyManagedPostToolUseHooks,
+    30,
+  )}`);
   if (hookDiagnosis.managedPostToolUseHooks.length > 0) {
-    const h = hookDiagnosis.managedPostToolUseHooks[0];
-    console.log(`    command:             ${h.command}`);
-    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
-    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
-    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+    printCodexHookDetails(hookDiagnosis.managedPostToolUseHooks[0]);
   }
-  console.log(`  Codex Stop hook:       ${
-    hookDiagnosis.managedStopHooks.length === 0
-      ? 'not registered'
-      : hookDiagnosis.legacyManagedStopHooks.length > 0
-        ? 'legacy command needs reinstall'
-        : 'registered'
-  }`);
+  console.log(`  Codex Stop hook:       ${describeCodexHookRegistration(
+    hookDiagnosis.managedStopHooks,
+    hookDiagnosis.legacyManagedStopHooks,
+    300,
+  )}`);
   if (hookDiagnosis.managedStopHooks.length > 0) {
-    const h = hookDiagnosis.managedStopHooks[0];
-    console.log(`    command:             ${h.command}`);
-    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
-    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
-    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+    printCodexHookDetails(hookDiagnosis.managedStopHooks[0]);
   }
   console.log(`  VSCode monitor task:   ${monitorTaskDiagnosis.status}`);
   if (monitorTaskDiagnosis.path) {
@@ -1024,6 +1031,8 @@ export const _internal = {
   buildCodexContextRefreshDiagnosis,
   readCodexHostPrimitiveDiagnosis,
   readCodexHookDiagnosis,
+  describeCodexHookRegistration,
+  printCodexHookDetails,
   readVsCodeMonitorTaskDiagnosis,
   isPidAlive,
   findLatestJsonlInSameDir,

package/src/cli/doctor.test.mjs

@@ -19,8 +19,42 @@ const {
   runTrimDiagnosis,
   buildCodexContextRefreshDiagnosis,
   readCodexHostPrimitiveDiagnosis,
+  describeCodexHookRegistration,
+  printCodexHookDetails,
 } = _internal;
 
+test('Codex hook diagnosis requires reinstall for legacy timeoutSec key', () => {
+  const legacy = { type: 'command', command: 'canonical', timeoutSec: 300, async: false };
+  assert.equal(
+    describeCodexHookRegistration([legacy], [], 300),
+    'legacy timeout key needs reinstall',
+  );
+  assert.equal(
+    describeCodexHookRegistration([{ type: 'command', command: 'canonical', timeout: 300, async: false }], [], 300),
+    'registered',
+  );
+});
+
+test('Codex hook diagnosis prints timeout and exposes ignored legacy key', () => {
+  const lines = [];
+  const originalLog = console.log;
+  console.log = (line) => lines.push(line);
+  try {
+    printCodexHookDetails({
+      command: 'canonical',
+      timeout: 300,
+      timeoutSec: 30,
+      async: false,
+      throughlineDoctorTrusted: true,
+    });
+  } finally {
+    console.log = originalLog;
+  }
+  const output = lines.join('\n');
+  assert.match(output, /timeout:\s+300/);
+  assert.match(output, /legacy timeoutSec:\s+30 \(ignored by Codex; reinstall required\)/);
+});
+
 // ─── parseArgs ──────────────────────────────────────────────────────
 
 test('parseArgs: 引数なしは session null', () => {
@@ -345,7 +379,7 @@ test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
                   {
                     type: 'command',
                     command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook user-prompt-submit',
-                    timeoutSec: 30,
+                    timeout: 30,
                     async: false,
                   },
                 ],
@@ -357,7 +391,7 @@ test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
                   {
                     type: 'command',
                     command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook post-tool-use',
-                    timeoutSec: 30,
+                    timeout: 30,
                     async: false,
                   },
                 ],
@@ -369,7 +403,7 @@ test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
                   {
                     type: 'command',
                     command: 'throughline codex-hook stop',
-                    timeoutSec: 300,
+                    timeout: 300,
                     async: true,
                   },
                 ],

package/src/cli/factory-diagnostics.mjs

@@ -122,11 +122,11 @@ function hasFactoryDatabaseShape(db) {
   return bodiesUnique;
 }
 
-function eventStatus({ hooks, legacyHooks, featureEnabled, expectedCommand, timeoutSec }) {
+function eventStatus({ hooks, legacyHooks, featureEnabled, expectedCommand, timeout }) {
   if (hooks.length === 0) return featureEnabled ? 'not_ready' : 'not_applicable';
   if (!featureEnabled || legacyHooks.length > 0 || hooks.length !== 1) return 'not_ready';
   const hook = hooks[0];
-  return hook.type === 'command' && hook.command === expectedCommand && hook.timeoutSec === timeoutSec &&
+  return hook.type === 'command' && hook.command === expectedCommand && hook.timeout === timeout &&
     hook.async === false ? 'ready' : 'not_ready';
 }
 
@@ -143,21 +143,21 @@ export function inspectFactoryHooks({ codexHome = defaultCodexHome(), readHooks
         legacyHooks: diagnosis.legacyManagedPromptHooks,
         featureEnabled: diagnosis.featureEnabled,
         expectedCommand: diagnosis.expectedPromptCommand,
-        timeoutSec: 30,
+        timeout: 30,
       }),
       postToolUse: eventStatus({
         hooks: diagnosis.managedPostToolUseHooks,
         legacyHooks: diagnosis.legacyManagedPostToolUseHooks,
         featureEnabled: diagnosis.featureEnabled,
         expectedCommand: diagnosis.expectedPostToolUseCommand,
-        timeoutSec: 30,
+        timeout: 30,
       }),
       stop: eventStatus({
         hooks: diagnosis.managedStopHooks,
         legacyHooks: diagnosis.legacyManagedStopHooks,
         featureEnabled: diagnosis.featureEnabled,
         expectedCommand: diagnosis.expectedStopCommand,
-        timeoutSec: 300,
+        timeout: 300,
       }),
     };
     const values = Object.values(events);

package/src/cli/factory-diagnostics.test.mjs

@@ -166,11 +166,11 @@ test('factory-diagnostics hook inspection rejects corrupt and false-ready shapes
       expectedPromptCommand: 'prompt',
       expectedPostToolUseCommand: 'post',
       expectedStopCommand: 'stop',
-      managedPromptHooks: [{ type: 'command', command: 'prompt', timeoutSec: 30, async: true }],
+      managedPromptHooks: [{ type: 'command', command: 'prompt', timeout: 30, async: true }],
       legacyManagedPromptHooks: [],
-      managedPostToolUseHooks: [{ type: 'command', command: 'post', timeoutSec: 30, async: false }],
+      managedPostToolUseHooks: [{ type: 'command', command: 'post', timeout: 30, async: false }],
       legacyManagedPostToolUseHooks: [],
-      managedStopHooks: [{ type: 'command', command: 'stop', timeoutSec: 300, async: false }],
+      managedStopHooks: [{ type: 'command', command: 'stop', timeout: 300, async: false }],
       legacyManagedStopHooks: [],
     }),
   });
@@ -188,11 +188,11 @@ test('factory-diagnostics hook inspection summarizes every canonical ready event
       expectedPromptCommand: 'prompt',
       expectedPostToolUseCommand: 'post',
       expectedStopCommand: 'stop',
-      managedPromptHooks: [{ type: 'command', command: 'prompt', timeoutSec: 30, async: false }],
+      managedPromptHooks: [{ type: 'command', command: 'prompt', timeout: 30, async: false }],
       legacyManagedPromptHooks: [],
-      managedPostToolUseHooks: [{ type: 'command', command: 'post', timeoutSec: 30, async: false }],
+      managedPostToolUseHooks: [{ type: 'command', command: 'post', timeout: 30, async: false }],
       legacyManagedPostToolUseHooks: [],
-      managedStopHooks: [{ type: 'command', command: 'stop', timeoutSec: 300, async: false }],
+      managedStopHooks: [{ type: 'command', command: 'stop', timeout: 300, async: false }],
       legacyManagedStopHooks: [],
     }),
   });
@@ -202,6 +202,30 @@ test('factory-diagnostics hook inspection summarizes every canonical ready event
   assert.equal(result.reason, 'hooks_inspected');
 });
 
+test('factory-diagnostics hook inspection rejects legacy timeoutSec keys', () => {
+  const result = inspectFactoryHooks({
+    readHooks: () => ({
+      configExists: true,
+      configReadable: true,
+      hooksExists: true,
+      hooksReadable: true,
+      featureEnabled: true,
+      expectedPromptCommand: 'prompt',
+      expectedPostToolUseCommand: 'post',
+      expectedStopCommand: 'stop',
+      managedPromptHooks: [{ type: 'command', command: 'prompt', timeoutSec: 30, async: false }],
+      legacyManagedPromptHooks: [],
+      managedPostToolUseHooks: [{ type: 'command', command: 'post', timeoutSec: 30, async: false }],
+      legacyManagedPostToolUseHooks: [],
+      managedStopHooks: [{ type: 'command', command: 'stop', timeoutSec: 300, async: false }],
+      legacyManagedStopHooks: [],
+    }),
+  });
+
+  assert.deepEqual(result.events, { userPromptSubmit: 'not_ready', postToolUse: 'not_ready', stop: 'not_ready' });
+  assert.equal(result.status, 'not_ready');
+});
+
 function createFactorySchema(db) {
   db.exec(`
     PRAGMA user_version = 9;

package/src/cli/install.mjs

@@ -170,7 +170,7 @@ function createCodexHooks() {
         {
           type: 'command',
           command: buildCodexUserPromptSubmitHookCommand(),
-          timeoutSec: 30,
+          timeout: 30,
           async: false,
           statusMessage: null,
         },
@@ -181,7 +181,7 @@ function createCodexHooks() {
         {
           type: 'command',
           command: buildCodexPostToolUseHookCommand(),
-          timeoutSec: 30,
+          timeout: 30,
           async: false,
           statusMessage: null,
         },
@@ -192,7 +192,7 @@ function createCodexHooks() {
         {
           type: 'command',
           command: buildCodexStopHookCommand(),
-          timeoutSec: 300,
+          timeout: 300,
           async: false,
           statusMessage: null,
         },

package/src/cli/install.test.mjs

@@ -120,19 +120,21 @@ test('global install registers Codex session hooks and enables hooks features',
       .find(h => h.command === expectedStopCommand);
     assert.ok(codexHook, 'Codex Stop should have absolute throughline.mjs codex-hook stop');
     assert.equal(codexHook.async, false, 'Codex Stop hook should be synchronous for Codex');
-    assert.equal(codexHook.timeoutSec, 300, 'Codex Stop hook should allow summarizer time');
+    assert.equal(codexHook.timeout, 300, 'Codex Stop hook should allow summarizer time');
     const promptHook = hooks.hooks.UserPromptSubmit
       .flatMap(g => g.hooks ?? [])
       .find(h => h.command === expectedPromptCommand);
     assert.ok(promptHook, 'Codex UserPromptSubmit should have absolute throughline.mjs codex-hook user-prompt-submit');
     assert.equal(promptHook.async, false, 'Codex UserPromptSubmit hook should be synchronous for capture/monitor state');
-    assert.equal(promptHook.timeoutSec, 30, 'Codex UserPromptSubmit hook should be short');
+    assert.equal(promptHook.timeout, 30, 'Codex UserPromptSubmit hook should be short');
     const postToolUseHook = hooks.hooks.PostToolUse
       .flatMap(g => g.hooks ?? [])
       .find(h => h.command === expectedPostToolUseCommand);
     assert.ok(postToolUseHook, 'Codex PostToolUse should have absolute throughline.mjs codex-hook post-tool-use');
     assert.equal(postToolUseHook.async, false, 'Codex PostToolUse hook should be synchronous for capture/monitor state');
-    assert.equal(postToolUseHook.timeoutSec, 30, 'Codex PostToolUse hook should be short');
+    assert.equal(postToolUseHook.timeout, 30, 'Codex PostToolUse hook should be short');
+    const managedHooks = [codexHook, promptHook, postToolUseHook];
+    assert.doesNotMatch(JSON.stringify(managedHooks), /timeoutSec/);
     const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
     assert.match(config, /^\[features\]\ncodex_hooks = true/m);
     assert.match(config, /^hooks = true/m);
@@ -245,7 +247,7 @@ test('global install preserves existing Codex hooks and is idempotent', async ()
                 {
                   type: 'command',
                   command: '/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop',
-                  timeoutSec: 5,
+                  timeout: 5,
                   async: false,
                   statusMessage: null,
                 },
@@ -287,7 +289,7 @@ test('global install preserves existing Codex hooks and is idempotent', async ()
   }
 });
 
-test('global install updates existing Throughline Codex hook shapes', async () => {
+test('global install replaces legacy timeoutSec Throughline Codex hook shapes', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -356,19 +358,22 @@ test('global install updates existing Throughline Codex hook shapes', async () =
       .filter(h => h.command === expectedStopCommand);
     assert.equal(codexHooks.length, 1);
     assert.equal(codexHooks[0].async, false);
-    assert.equal(codexHooks[0].timeoutSec, 300);
+    assert.equal(codexHooks[0].timeout, 300);
+    assert.equal(Object.hasOwn(codexHooks[0], 'timeoutSec'), false);
     const promptHooks = hooks.hooks.UserPromptSubmit
       .flatMap(g => g.hooks ?? [])
       .filter(h => h.command === expectedPromptCommand);
     assert.equal(promptHooks.length, 1);
     assert.equal(promptHooks[0].async, false);
-    assert.equal(promptHooks[0].timeoutSec, 30);
+    assert.equal(promptHooks[0].timeout, 30);
+    assert.equal(Object.hasOwn(promptHooks[0], 'timeoutSec'), false);
     const postToolUseHooks = hooks.hooks.PostToolUse
       .flatMap(g => g.hooks ?? [])
       .filter(h => h.command === expectedPostToolUseCommand);
     assert.equal(postToolUseHooks.length, 1);
     assert.equal(postToolUseHooks[0].async, false);
-    assert.equal(postToolUseHooks[0].timeoutSec, 30);
+    assert.equal(postToolUseHooks[0].timeout, 30);
+    assert.equal(Object.hasOwn(postToolUseHooks[0], 'timeoutSec'), false);
     assert.equal(
       hooks.hooks.Stop.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook stop').length,
       0,
@@ -426,7 +431,7 @@ test('global uninstall removes only Throughline-managed Codex hook', async () =>
         {
           type: 'command',
           command: '/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop',
-          timeoutSec: 5,
+          timeout: 5,
           async: false,
           statusMessage: null,
         },

package/src/completed-turn-receipts-test-fixture.mjs

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import {
+  COMPLETED_TURN_RECEIPT_LIMIT,
+  defaultCompletedTurnReceiptStorePath,
+  writeCompletedTurnReceipt,
+} from './completed-turn-receipts.mjs';
+
+function sha256(value) {
+  return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+
+/**
+ * Seeds a schema-valid receipt store without repeating the Windows ACL subprocess path.
+ * One public mutation creates the private directory, lock, and store; direct replacement
+ * preserves that file ACL, and the caller still performs the boundary mutation publicly.
+ */
+export function seedCompletedTurnReceiptStore({
+  projectPath,
+  receiptOptions = {},
+  size = COMPLETED_TURN_RECEIPT_LIMIT,
+  targetSessionId = 'fixture-target',
+}) {
+  if (!Number.isSafeInteger(size) || size < 1 || size > COMPLETED_TURN_RECEIPT_LIMIT) {
+    throw new TypeError('fixture receipt size is invalid');
+  }
+  const first = writeCompletedTurnReceipt({
+    projectPath,
+    targetSessionId,
+    originSessionId: 'fixture-origin-1',
+    userBody: 'fixture-user-1',
+    assistantBody: 'fixture-assistant-1',
+    completedAt: 1,
+  }, receiptOptions);
+  const storePath = receiptOptions.storePath ||
+    defaultCompletedTurnReceiptStorePath(first.project_sha256, receiptOptions.env);
+  const store = JSON.parse(readFileSync(storePath, 'utf8'));
+  store.next_sequence = size + 1;
+  store.history_floor = 1;
+  store.receipts = Array.from({ length: size }, (_, offset) => {
+    const sequence = offset + 1;
+    return {
+      ...first,
+      target_session_id: targetSessionId,
+      origin_session_id: `fixture-origin-${sequence}`,
+      user_sha256: sha256(`fixture-user-${sequence}`),
+      assistant_sha256: sha256(`fixture-assistant-${sequence}`),
+      completed_at: sequence,
+      sequence,
+    };
+  });
+  writeFileSync(storePath, `${JSON.stringify(store)}\n`, 'utf8');
+  return { storePath, projectSha256: first.project_sha256 };
+}

package/src/completed-turn-receipts.mjs

@@ -142,7 +142,11 @@ function writeStore(store, normalized, options, privateDirectory) {
       chmodSync(temporary, 0o600);
     }
     renameSync(temporary, path);
-    assertPrivateFile(lstatSync(path), options.env, path);
+    // The temporary file ACL is applied and read back before rename. Rename
+    // preserves that ACL, so only the new final path shape needs an immediate
+    // in-process check; native integration tests verify the external ACL.
+    if (isWindows(options.env)) assertPrivateFileShape(lstatSync(path));
+    else assertPrivateFile(lstatSync(path), options.env, path);
   } finally {
     rmSync(temporary, { force: true });
   }
@@ -164,7 +168,8 @@ function withStoreLock(normalized, options, operation) {
     if (isWindows(options.env)) applyAndVerifyWindowsAcl(lockPath, false);
     else chmodSync(lockPath, 0o600);
   }
-  assertPrivateFile(lstatSync(lockPath), options.env, lockPath);
+  if (created && isWindows(options.env)) assertPrivateFileShape(lstatSync(lockPath));
+  else assertPrivateFile(lstatSync(lockPath), options.env, lockPath);
   const database = new DatabaseSync(lockPath);
   let active = false;
   try {
@@ -186,7 +191,8 @@ function ensurePrivateDirectory(directory, env) {
   assertPrivateDirectoryShape(info);
   if (isWindows(env)) applyAndVerifyWindowsAcl(directory, true);
   else chmodSync(directory, 0o700);
-  assertPrivateDirectory(directory, env);
+  if (isWindows(env)) assertPrivateDirectoryShape(lstatSync(directory));
+  else assertPrivateDirectory(directory, env);
 }
 
 function privateDirectoryCapability(directory, env) {

package/src/completed-turn-receipts.test.mjs

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import childProcess from 'node:child_process';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import {
@@ -10,6 +11,8 @@ import {
   readCompletedTurnReceiptSnapshot,
   writeCompletedTurnReceipt,
 } from './completed-turn-receipts.mjs';
+import { seedCompletedTurnReceiptStore } from './completed-turn-receipts-test-fixture.mjs';
+import { verifyWindowsPrivateAcl } from './windows-acl-test-helper.mjs';
 
 function sandbox() {
   const root = mkdtempSync(join(tmpdir(), 'throughline-completed-receipts-'));
@@ -101,9 +104,8 @@ test('completed turn receipt: rejects symlinked store paths', { skip: process.pl
 test('completed turn receipt: bounded store drops only oldest receipts', () => {
   const box = sandbox();
   try {
-    for (let index = 1; index <= COMPLETED_TURN_RECEIPT_LIMIT + 1; index++) {
-      writeCompletedTurnReceipt({ ...input(index), targetSessionId: `target-${index}` }, { storePath: box.storePath });
-    }
+    seedCompletedTurnReceiptStore({ projectPath: '/repo', receiptOptions: { storePath: box.storePath } });
+    writeCompletedTurnReceipt({ ...input(COMPLETED_TURN_RECEIPT_LIMIT + 1), targetSessionId: 'target-final' }, { storePath: box.storePath });
     const stored = JSON.parse(readFileSync(box.storePath, 'utf8'));
     assert.equal(stored.receipts.length, COMPLETED_TURN_RECEIPT_LIMIT);
     assert.equal(stored.history_floor, 2);
@@ -119,9 +121,11 @@ test('completed turn receipt: noisy project cannot evict another project anchor'
   const env = { HOME: box.root, USERPROFILE: box.root, XDG_STATE_HOME: join(box.root, 'state-home') };
   try {
     const quiet = writeCompletedTurnReceipt({ ...input(), projectPath: '/quiet-project' }, { env });
-    for (let index = 1; index <= COMPLETED_TURN_RECEIPT_LIMIT + 1; index++) {
-      writeCompletedTurnReceipt({ ...input(index), projectPath: '/noisy-project', targetSessionId: `target-${index}` }, { env });
-    }
+    seedCompletedTurnReceiptStore({ projectPath: '/noisy-project', receiptOptions: { env } });
+    writeCompletedTurnReceipt({
+      ...input(COMPLETED_TURN_RECEIPT_LIMIT + 1),
+      projectPath: '/noisy-project', targetSessionId: 'target-final',
+    }, { env });
     const quietStorePath = defaultCompletedTurnReceiptStorePath(quiet.project_sha256, env);
     const quietStore = JSON.parse(readFileSync(quietStorePath, 'utf8'));
     assert.equal(quietStore.receipts.length, 1);
@@ -131,6 +135,70 @@ test('completed turn receipt: noisy project cannot evict another project anchor'
   }
 });
 
+test('completed turn receipt: one Windows mutation spends ACL processes only on distinct state transitions', (t) => {
+  const box = sandbox();
+  const env = { OS: 'Windows_NT', HOME: box.root, USERPROFILE: box.root };
+  const calls = [];
+  t.mock.method(childProcess, 'spawnSync', (command, args, options) => {
+    calls.push({ command, args, options });
+    return { status: 0, signal: null, error: undefined };
+  });
+  const options = { env, storePath: box.storePath };
+
+  try {
+    writeCompletedTurnReceipt(input(1), options);
+    assert.equal(calls.length, 3, 'new directory, lock, and store each require one apply+verify process');
+    assert.ok(calls.every((call) => call.command === 'powershell.exe'));
+    calls.length = 0;
+
+    writeCompletedTurnReceipt(input(2), options);
+    assert.equal(calls.length, 4, 'directory apply, existing lock/store verify, and replacement store apply are distinct');
+    assert.ok(calls.every((call) => call.options.timeout === 15_000));
+  } finally {
+    rmSync(box.root, { recursive: true, force: true });
+  }
+});
+
+test('completed turn receipt: Windows temporary ACL failure leaves the previous atomic store intact', (t) => {
+  const box = sandbox();
+  const env = { OS: 'Windows_NT', HOME: box.root, USERPROFILE: box.root };
+  let calls = 0;
+  let failAt = Number.POSITIVE_INFINITY;
+  t.mock.method(childProcess, 'spawnSync', () => {
+    calls += 1;
+    return { status: calls === failAt ? 1 : 0, signal: null, error: undefined };
+  });
+  const options = { env, storePath: box.storePath };
+
+  try {
+    writeCompletedTurnReceipt(input(1), options);
+    const before = readFileSync(box.storePath, 'utf8');
+    failAt = calls + 4;
+    assert.throws(() => writeCompletedTurnReceipt(input(2), options), /ACL verification failed/);
+    assert.equal(readFileSync(box.storePath, 'utf8'), before);
+  } finally {
+    rmSync(box.root, { recursive: true, force: true });
+  }
+});
+
+test('completed turn receipt: atomic private store has owner-only modes', () => {
+  const box = sandbox();
+  try {
+    writeCompletedTurnReceipt(input(), { storePath: box.storePath });
+    if (process.platform === 'win32') {
+      verifyWindowsPrivateAcl(dirname(box.storePath), true);
+      verifyWindowsPrivateAcl(`${box.storePath}.lock.sqlite`);
+      verifyWindowsPrivateAcl(box.storePath);
+    } else {
+      assert.equal(statSync(dirname(box.storePath)).mode & 0o777, 0o700);
+      assert.equal(statSync(`${box.storePath}.lock.sqlite`).mode & 0o777, 0o600);
+      assert.equal(statSync(box.storePath).mode & 0o777, 0o600);
+    }
+  } finally {
+    rmSync(box.root, { recursive: true, force: true });
+  }
+});
+
 test('completed turn receipt: explicit store path rejects a second project', () => {
   const box = sandbox();
   try {

package/src/observer-turn-feed.test.mjs

@@ -6,6 +6,7 @@ import test from 'node:test';
 import { DatabaseSync } from 'node:sqlite';
 import { decodeObserverCursor, encodeObserverCursor, readObserverTurnPage, resolveObserverTurnFeed } from './observer-turn-feed.mjs';
 import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
+import { seedCompletedTurnReceiptStore } from './completed-turn-receipts-test-fixture.mjs';
 import { hashAuditorBody } from './body-digest.mjs';
 
 function fixture() {
@@ -123,7 +124,8 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   const box = fixture();
   try {
     const options = box.receiptOptions;
-    for (let i = 1; i <= 257; i++) writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: `o${i}`, userBody: `u${i}`, assistantBody: `a${i}`, completedAt: i }, options);
+    seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: options, targetSessionId: 'claude-session' });
+    writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: 'o257', userBody: 'u257', assistantBody: 'a257', completedAt: 257 }, options);
     const latest = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     const decoded = decodeObserverCursor(latest.throughCursor);
     const beforeFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });