throughline 0.8.2 → 0.8.4

package/CHANGELOG.md

@@ -10,6 +10,31 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.8.4] — 2026-07-20
+
+### Fixed
+
+- The installed Codex skill now selects Desktop, VS Code, or CLI from the
+  current Codex surface and passes an explicit `--open-host` value. A command
+  launched through an older persistent PTY can no longer silently redirect a
+  Desktop handoff to the PTY's inherited VS Code or Terminal host.
+- `codex-handoff-start` now reports both requested and resolved open hosts in
+  JSON and text output while retaining the existing `openHost` field.
+
+## [0.8.3] — 2026-07-20
+
+### Fixed
+
+- Codex fresh-thread handoffs now detect when they were launched from Codex
+  Desktop and open the new local task with the app's
+  `codex://threads/<thread-id>` deep link instead of spawning a Terminal
+  `codex resume` session. `--open-host desktop` is available explicitly;
+  VS Code and CLI opening behavior is unchanged.
+- Concurrent CLI and Codex hook processes now configure a bounded SQLite busy
+  timeout and avoid reapplying WAL mode when it is already active. A transient
+  writer or WAL recovery lock no longer makes DB initialization fail
+  immediately, and a failed initialization is never retained as the singleton.
+
 ## [0.8.2] — 2026-07-20
 
 ### Fixed
@@ -1119,7 +1144,11 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.4...HEAD
+[0.8.4]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.3...v0.8.4
+[0.8.3]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.2...v0.8.3
+[0.8.2]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.1...v0.8.2
+[0.8.1]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/kitepon-rgb/Throughline/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.3...v0.7.0
 [0.6.3]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.2...v0.6.3

package/README.md

@@ -304,7 +304,7 @@ throughline codex-summarize --session codex:<thread-id> --json
 throughline codex-resume --session codex:<thread-id>
 throughline codex-resume --session codex:<thread-id> --format handoff
 throughline codex-handoff-start --session codex:<thread-id>
-throughline codex-handoff-start --session codex:<thread-id> --execute --open-host vscode
+throughline codex-handoff-start --session codex:<thread-id> --execute --open-host desktop
 throughline codex-handoff-smoke --session codex:<thread-id>
 throughline codex-handoff-model-smoke --session codex:<thread-id> --dry-run --json
 THROUGHLINE_EXPERIMENTAL_CODEX_HANDOFF_MODEL_SMOKE=1 \
@@ -567,7 +567,12 @@ live model smoke, and can include the prompt with `--print-prompt`. With
 `--memo-stdin`, it also propagates `--memo-stdin` into the replay commands and
 reminds you to pipe the same memo when using them separately. Add `--execute`
 to create a new Codex app-server thread, inject the handoff memory as a
-developer item, and open it with `--open-host auto|vscode|cli|none`. The
+developer item, and open it with `--open-host auto|desktop|vscode|cli|none`. `auto`
+opens the new task in Codex Desktop when invoked there, while preserving the
+existing VS Code and CLI routes. The result reports both the requested and
+resolved host. The installed `$throughline` skill passes the current Codex
+surface explicitly so a persistent shell or PTY cannot redirect the handoff.
+The
 individual commands remain available: validate the fresh-thread handoff with
 `throughline codex-handoff-smoke --session codex:<thread-id>`, optionally audit
 the model-smoke boundary with
@@ -785,7 +790,7 @@ aggregate は collection が既定OFFで、canonical dotagents config の
 | `throughline codex-summarize --session codex:<id>` | Summarize captured Codex L2 into L1 with the Codex CLI backend |
 | `throughline codex-resume --session codex:<id>` | Render Codex active-work context from a captured Codex session |
 | `throughline codex-resume --session codex:<id> --format handoff` | Render a concise fresh-thread handoff prompt without mutating the current thread |
-| `throughline codex-handoff-start --session codex:<id>` | Guided start plan for moving handoff memory into a new Codex thread; add `--execute` to create the thread through app-server, inject developer memory, and open it with `--open-host auto\|vscode\|cli\|none`; use `--print-prompt` to include the prompt and `--memo-stdin` to carry a current-work memo |
+| `throughline codex-handoff-start --session codex:<id>` | Guided start plan for moving handoff memory into a new Codex thread; add `--execute` to create the thread through app-server, inject developer memory, and open it with `--open-host auto\|desktop\|vscode\|cli\|none`; output includes requested and resolved host, and the installed `$throughline` skill passes the current Codex surface explicitly; use `--print-prompt` to include the prompt and `--memo-stdin` to carry a current-work memo |
 | `throughline codex-handoff-smoke --session codex:<id>` | Read-only validation that the fresh-thread handoff prompt is pasteable before starting a new thread |
 | `throughline codex-handoff-model-smoke --session codex:<id>` | Experimental marker smoke for the handoff prompt. `--dry-run` checks readiness / command boundary without starting Codex exec; `--memo-stdin` carries a current-work memo; live `codex exec --ephemeral --sandbox read-only` requires explicit env opt-in |
 | `throughline codex-visibility-smoke --session codex:<id>` | Experimental Codex app-server marker smoke; injects memory and starts a model turn |

package/bin/throughline.mjs

@@ -248,7 +248,7 @@ Usage:
                               render command, optional --print-prompt, and
                               --memo-stdin replay guidance. Use --execute to
                               create a new app-server thread, inject handoff
-                              memory, and open it with --open-host auto|vscode|cli|none
+                              memory, and open it with --open-host auto|desktop|vscode|cli|none
   throughline codex-visibility-smoke
                               Experimental: inject Codex active-work memory and
                               start a marker-check model turn. Requires

package/codex/skills/throughline/SKILL.md

@@ -25,6 +25,17 @@ not ask for confirmation. Execute the handoff-start command directly. If it
 fails, report the error plainly instead of silently falling back to another
 memory source or current-thread rollback.
 
+Choose the open host from the current Codex application surface, not from
+environment variables inherited by the shell or a persistent PTY. Pass it
+explicitly whenever the surface is known:
+
+- Codex Desktop: `--open-host desktop`
+- Codex in VS Code: `--open-host vscode`
+- Codex CLI: `--open-host cli`
+
+Use `--open-host auto` only when the Codex surface is genuinely unknown. In
+that case, report both the requested and resolved hosts from the CLI result.
+
 ## Common Requests
 
 ### Bare "$throughline" / "use Throughline"
@@ -32,9 +43,13 @@ memory source or current-thread rollback.
 Run:
 
 ```bash
-throughline codex-handoff-start --execute
+throughline codex-handoff-start --execute --open-host desktop
 ```
 
+The example above is for Codex Desktop. Replace `desktop` with `vscode` or
+`cli` when that is the current Codex surface. Do not copy the host identity
+from the shell or PTY that happens to execute the command.
+
 This is the Codex new-thread continuation flow. It does not mutate the current
 Codex thread. Report the new thread id, open status, and any manual resume
 command if the host could not be opened automatically.
@@ -80,7 +95,7 @@ If the user wants to continue in a fresh Codex thread instead of mutating the
 current thread, use:
 
 ```bash
-throughline codex-handoff-start --session codex:<current-thread-id> --execute
+throughline codex-handoff-start --session codex:<current-thread-id> --execute --open-host <current-codex-surface>
 ```
 
 If the user gave a current-work memo, pipe it with `--memo-stdin`. This starts a
@@ -106,7 +121,7 @@ memory, unless they explicitly ask to mutate the current Codex thread.
 Execute:
 
 ```bash
-throughline codex-handoff-start --execute
+throughline codex-handoff-start --execute --open-host <current-codex-surface>
 ```
 
 Report only the essential outcome, especially the new thread id and open status.
@@ -120,7 +135,7 @@ throughline trim --dry-run --host codex
 Safe new-thread continuation:
 
 ```bash
-throughline codex-handoff-start --session codex:<current-thread-id> --execute --json
+throughline codex-handoff-start --session codex:<current-thread-id> --execute --open-host <current-codex-surface> --json
 ```
 
 Report the context reduction estimate from the dry-run when present:

package/docs/04_public_release_plan.md

@@ -140,6 +140,7 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.6.1): Spotter auditor context projection** | `throughline auditor-context`を追加。exact session/projectと最新完了L2 pairのorigin/turn/hash freshnessを検査し、fresh時だけbounded user/assistant本文をversioned JSONで返す。DBはread-onlyで開き、作成・migration・WAL書き込みをしない。Spotter側はproject opt-inでのみ利用する。580 tests、CI 6/6、pack scan、registry global install / doctorを通過し、npm / tag / GitHub Releaseを2026-07-13に公開した |
 | **npm 公開 (v0.6.2): factory diagnostics + local runtime error store** | `throughline factory-diagnostics --json` と `throughline runtime-errors ... --json` を追加。collection は canonical dotagents config の `collection.enabled: true` が明示された時だけ有効で既定OFF、store は network I/O を行わない。公開commit `e6ce6e3`、CI `29238704750`、npm `latest`、tag / GitHub Release、registry由来隔離installと診断snapshotを2026-07-13に確認した |
 | **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に確認した |
+| **release candidate (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契約は変更しない。公開実績はpush後CI、npm、tag / GitHub Release、registry由来global installの確認後に追記する |
 | **未リリース: 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

@@ -28,7 +28,7 @@
 - Claude-primary の現行 L2 -> L1 要約は `codex-sidecar` が configured の場合に sidecar を優先し、使えない場合は Claude Haiku 経路に戻る。Codex-primary は Codex CLI backend 失敗を明示 error にし、Claude Haiku / raw L2 へ fallback しない。
 - Codex guarded trim は、Codex app-server の `thread/read` / `thread/resume` / `thread/rollback` / `thread/inject_items` を使う。明示 thread identity と injectable memory がない場合は mutation 前に拒否する。rollout/app-server turn count mismatch は診断に残し、`thread/read` / `thread/resume` が同じ count を返す場合は app-server 側の差分で rollback `numTurns` を補正する。
 - Claude `/rewind` 自動化はまだ有効化しない。
-- 2026-05-10 update: Codex automatic current-thread refresh mutation は無効化する。live rollback / inject で token_count が一時的に落ちても同一 thread で戻る実測があるため、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行い、`codex_auto_refresh_disabled` で quiet にする。bare `$throughline` は `codex-handoff-start --execute` による app-server 新スレッド handoff とし、明示 `trim --execute --host codex` だけを診断用 current-thread rollback / inject path として残す。
+- 2026-05-10 update: Codex automatic current-thread refresh mutation は無効化する。live rollback / inject で token_count が一時的に落ちても同一 thread で戻る実測があるため、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行い、`codex_auto_refresh_disabled` で quiet にする。bare `$throughline` は `codex-handoff-start --execute --open-host <current-codex-surface>` による app-server 新スレッド handoff とし、明示 `trim --execute --host codex` だけを診断用 current-thread rollback / inject path として残す。current surfaceはCodex UI contextから決め、shell／永続PTYの継承環境へ委ねない。
 
 ## 新セッション引き継ぎ
 
@@ -271,7 +271,7 @@ Phase 3 implementation result (2026-05-06):
 - [x] `throughline codex-resume --format handoff` は current thread を mutate せず、新規 Codex thread に貼る短い handoff prompt を返す。handoff view は L2 件数 / 本文長 / detail refs を cap し、full active-work context は通常 text renderer に残す。
 - [x] `throughline codex-handoff-smoke --session codex:<thread_id>` は新規 thread handoff prompt を read-only に検査し、prompt size / required sections / mutation boundary / detail command dedupe を固定する。
 - [x] `throughline codex-handoff-model-smoke --session codex:<thread_id>` は明示 opt-in 時だけ `codex exec --ephemeral --ignore-user-config --ignore-rules --sandbox read-only` で handoff prompt の marker model smoke を行う。`--dry-run` は env なしで readiness / command boundary を監査し、`--print-prompt` で結合 prompt を出せる。`--memo-stdin` で Codex-primary current-work memo も同じ prompt に含める。structural handoff smoke が ready でなければ拒否し、current thread は mutate しない。
-- [x] `throughline codex-handoff-start --session codex:<thread_id>` は safe continuation の guided entrypoint として、structural smoke / model smoke dry-run / handoff render / optional live smoke / `--print-prompt` をまとめて表示する。`--execute` では app-server `thread/start` + `thread/inject_items` で新 thread に developer memory を注入し、`--open-host auto|vscode|cli|none` で表示を開く。`--memo-stdin` 時は replay 用コマンドにも `--memo-stdin` を伝播し、same memo を pipe する注意を出す。
+- [x] `throughline codex-handoff-start --session codex:<thread_id>` は safe continuation の guided entrypoint として、structural smoke / model smoke dry-run / handoff render / optional live smoke / `--print-prompt` をまとめて表示する。`--execute` では app-server `thread/start` + `thread/inject_items` で新 thread に developer memory を注入し、`--open-host auto|desktop|vscode|cli|none` で表示を開く。CLIはrequested / resolved hostを両方報告する。`auto` は Codex Desktop 起点（`CODEX_INTERNAL_ORIGINATOR_OVERRIDE="Codex Desktop"` または `__CFBundleIdentifier=com.openai.codex`）を CLI より先に識別するが、bare `$throughline` skillは現在のCodex UI surfaceを明示指定し、永続PTYの継承環境へhost選択を委ねない。Desktop の `codex://threads/<thread-id>` deep linkとVS Code / CLI の既存経路は維持する。`--memo-stdin` 時は replay 用コマンドにも `--memo-stdin` を伝播し、same memo を pipe する注意を出す。
 - [x] `throughline codex-resume --format item-json` は Codex developer message item JSON を返す。
 - [x] `codex-resume` は explicit session を受け取れる。省略時は cwd の最新 `codex:%` session だけを対象にし、Claude session を混ぜない。
 - [x] `src/codex-handoff.test.mjs` / `src/codex-resume.test.mjs` で renderer と CLI shape を固定した。
@@ -440,7 +440,7 @@ Phase 5 implementation status (2026-05-06):
 - [x] `doctor --codex` は Claude settings を変更しない。Codex primary entrypoint の診断に限定する。
 - [x] 実セッションで `doctor --codex` -> `codex-capture` -> `codex-resume --format item-json` -> `doctor --codex` の local smoke を実施した。`codex-resume` は developer message item JSON を描画し、再診断で captured DB session が 1 件として表示された。
 - [x] 実セッションで `codex-visibility-smoke` を実施した。`THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE=1` を必須にし、長い model turn に備えて `--request-timeout-ms 150000` / `--timeout-ms 180000` を使えるようにした。
-- [x] Codex primary の setup / install 手順は README に記録した。global install は Codex hooks と `$throughline` skill を自動登録する。2026-05-10 以降、bare `$throughline` は `throughline codex-handoff-start --execute` による app-server 新スレッド handoff とする。hooks は capture / monitor state write だけを行い、current-thread rollback / inject は明示 `trim --execute --host codex` を要求された時だけ使う。
+- [x] Codex primary の setup / install 手順は README に記録した。global install は Codex hooks と `$throughline` skill を自動登録する。2026-05-10 以降、bare `$throughline` は `throughline codex-handoff-start --execute --open-host <current-codex-surface>` による app-server 新スレッド handoffとし、current surfaceはCodex UI contextから明示する。hooks は capture / monitor state write だけを行い、current-thread rollback / inject は明示 `trim --execute --host codex` を要求された時だけ使う。
 - [x] `codex-summarize` を明示診断・運用 flow に追加した。Codex CLI backend を使い、Claude Haiku へ fallback しない。
 - [x] Codex primary の summarize / guarded execute まで含む end-to-end smoke を実施した。2026-05-07 correction では guarded execute を live app-server smoke としてのみ扱った。2026-05-08 unblock 後は、controlled rollback model-visible smoke の `not-reproduced` と current-thread live run の `execute-durable-verified` を合わせて、Codex current-thread trim 完了条件に含める。
   - `codex-capture`: `capturedTurns = 41`, `capturedRows = 75`, `capturedDetails = 2424`
@@ -460,7 +460,7 @@ Phase 5 implementation status (2026-05-06):
   - 追加確認: 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 も解決済みとして扱う。
   - 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` による app-server 新スレッド handoff とする。current-thread rollback / inject は明示要求時だけ使う。
+  - 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 前に拒否する。
   - doctor visibility 修正: `doctor --codex` は旧 context refresh readiness として rollback source、inject memory source、memory contract、L1 summaries / recent L2 bodies / L3 references-only count、heuristic reduction estimate を表示していた。実 thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` では live readiness として `context refresh: ready`、`rollback source: codex-rollout`、`inject memory source: throughline-db`、`memory contract: older L1 + latest 20 L2 full bodies + L3 references only` を確認した。ただし incident 後は restart-safe readiness ではない。
   - 削減量の記録: `trim --dry-run --host codex` は rollout text がある場合に `contextReductionEstimate` を返す。2026-05-06 の現在 thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` では通常 keep-recent preview だと `capturedTurns = 14` / `keepRecent = 20` のため `rollbackTurns = 0`、推定削減量も 0 だった。旧 bare `$throughline` context refresh は `--all` を使っていたため、この keep-recent preview の 0 は「Codex で削減できない」という意味ではない。

package/docs/06_codex_trim_rollback_fix_plan.md

@@ -25,8 +25,9 @@ count を返す場合は、その差分で rollback `numTurns` を補正しま
 一時的に下がっても同一 thread で戻る挙動を確認したため、Codex automatic
 current-thread refresh は無効化します。`UserPromptSubmit` / `PostToolUse` / `Stop`
 hooks は capture / monitor state write のみ行い、`codex_auto_refresh_disabled` で
-quiet にします。bare `$throughline` は `codex-handoff-start --execute` による
-app-server 新スレッド handoff とします。
+quiet にします。bare `$throughline` は
+`codex-handoff-start --execute --open-host <current-codex-surface>` による
+app-server 新スレッド handoff とし、surfaceはCodex UI contextから明示します。
 
 最初のインシデント仮説に対する重要な訂正:
 

package/docs/09_rollback_context_trim_insight.md

@@ -25,7 +25,7 @@
 
 2026-05-09 skill UX: bare `$throughline` は diagnostics / dry-run / preflight を AI に順番実行させる surface ではなく、`throughline trim --execute --host codex --all` を直接走らせる scripted current-thread refresh としていた。目的は rollback と、Throughline DB の L2 最新 20 full bodies + older L1 summaries + L3 references-only memory injection のみだった。2026-05-10 以降は `--json` の full plan / memory preview が tool output として context を再膨張させるため、通常 path では付けないようにした。
 
-2026-05-10 rollback UX correction: 追加 live 実験で、current-thread rollback / inject 後に token_count が一時的に下がっても同一 thread で戻る挙動を確認した。これを受け、Codex automatic current-thread refresh は無効化し、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行う。bare `$throughline` は `throughline codex-handoff-start --execute` による app-server 新スレッド handoff とし、明示 `trim --execute --host codex` は診断用 current-thread path として残す。
+2026-05-10 rollback UX correction: 追加 live 実験で、current-thread rollback / inject 後に token_count が一時的に下がっても同一 thread で戻る挙動を確認した。これを受け、Codex automatic current-thread refresh は無効化し、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行う。bare `$throughline` は `throughline codex-handoff-start --execute --open-host <current-codex-surface>` による app-server 新スレッド handoffとし、surfaceはCodex UI contextから明示する。明示 `trim --execute --host codex` は診断用 current-thread path として残す。
 
 2026-05-07 host primitive audit: `throughline codex-host-primitive-audit` で installed Codex app-server schema を機械監査した。`thread/rollback` / `thread/inject_items` / `thread/compact/start` / `thread/start` / `thread/fork` / `thread/resume` は存在するが、rollback 済み user text を current-thread の model-visible input へ復活させない deletion / isolation / projection primitive は見つからなかった。`thread/resume(history)` は schema 上 `[UNSTABLE] FOR CODEX CLOUD - DO NOT USE` で、`thread_id` も ignored になるため、Throughline の current-thread repair primitive には採用しない。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [

package/src/cli/codex-handoff-start.mjs

@@ -79,8 +79,8 @@ function parseArgs(args) {
       out.execute = true;
     } else if (arg === '--open-host') {
       const value = args[++i];
-      if (!['auto', 'vscode', 'cli', 'none'].includes(value)) {
-        throw new Error('--open-host must be auto, vscode, cli, or none');
+      if (!['auto', 'desktop', 'vscode', 'cli', 'none'].includes(value)) {
+        throw new Error('--open-host must be auto, desktop, vscode, cli, or none');
       }
       out.openHost = value;
     } else if (arg === '--codex-app-server-bin') {
@@ -190,6 +190,8 @@ function buildGuidance({ sessionId, parsed, handoffSmoke, handoffPrompt }) {
     ]),
   };
   const ready = handoffSmoke.status === 'ready';
+  const requestedOpenHost = parsed.openHost;
+  const resolvedOpenHost = resolveOpenHost(requestedOpenHost);
   return {
     status: ready ? 'ready' : 'not-ready',
     reason: ready ? 'fresh_thread_handoff_start_ready' : 'handoff_smoke_not_ready',
@@ -198,6 +200,8 @@ function buildGuidance({ sessionId, parsed, handoffSmoke, handoffPrompt }) {
     startThreadManually: !parsed.execute,
     execute: parsed.execute,
     openHost: parsed.openHost,
+    requestedOpenHost,
+    resolvedOpenHost,
     handoffSmoke,
     modelPromptChars: modelPrompt.length,
     estimatedModelPromptTokens: estimateTokens(modelPrompt),
@@ -234,7 +238,8 @@ function renderTextResult(result) {
   lines.push(`  session:           ${result.sessionId}`);
   lines.push(`  mutates thread:    ${result.mutatesCurrentThread ? 'yes' : 'no'}`);
   lines.push(`  execute:           ${result.execute ? 'yes' : 'no'}`);
-  lines.push(`  open host:         ${result.openHost}`);
+  lines.push(`  open requested:    ${result.requestedOpenHost ?? result.openHost}`);
+  lines.push(`  open resolved:     ${result.resolvedOpenHost ?? result.open?.host ?? result.openHost}`);
   lines.push(`  handoff smoke:     ${result.handoffSmoke.status}`);
   lines.push(`  prompt chars:      ${result.handoffSmoke.promptChars}/${result.handoffSmoke.maxPromptChars}`);
   lines.push(`  model prompt:      ${result.modelPromptChars}`);
@@ -247,6 +252,7 @@ function renderTextResult(result) {
   }
   if (result.open) {
     lines.push(`  open status:       ${result.open.status}`);
+    lines.push(`  desktop url:       ${result.open.desktopUrl}`);
     lines.push(`  vscode url:        ${result.open.vscodeUrl}`);
     lines.push(`  resume command:    ${result.open.resumeCommand}`);
   }
@@ -268,21 +274,34 @@ function renderTextResult(result) {
   return lines.join('\n');
 }
 
-function resolveOpenHost(host) {
+function isCodexDesktopEnvironment(env) {
+  const originator = env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE?.trim()
+    .toLowerCase()
+    .replace(/[_-]+/g, ' ');
+  return originator === 'codex desktop' || env.__CFBundleIdentifier === 'com.openai.codex';
+}
+
+function resolveOpenHost(host, env = process.env) {
   if (host !== 'auto') return host;
+  if (isCodexDesktopEnvironment(env)) return 'desktop';
   if (
-    process.env.VSCODE_IPC_HOOK_CLI ||
-    process.env.VSCODE_IPC_HOOK ||
-    process.env.TERM_PROGRAM === 'vscode' ||
-    process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === 'codex_vscode'
+    env.VSCODE_IPC_HOOK_CLI ||
+    env.VSCODE_IPC_HOOK ||
+    env.TERM_PROGRAM === 'vscode' ||
+    env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === 'codex_vscode'
   ) {
     return 'vscode';
   }
   return 'cli';
 }
 
+function buildCodexDesktopUrl(threadId) {
+  return `codex://threads/${encodeURIComponent(threadId)}`;
+}
+
 function openStartedCodexThread({ threadId, host, cwd }) {
   const resolvedHost = resolveOpenHost(host);
+  const desktopUrl = buildCodexDesktopUrl(threadId);
   const vscodeUrl = `vscode://openai.chatgpt/local/${encodeURIComponent(threadId)}`;
   const resumeCommand = `codex resume ${threadId} --no-alt-screen`;
   if (resolvedHost === 'none') {
@@ -290,23 +309,30 @@ function openStartedCodexThread({ threadId, host, cwd }) {
       status: 'skipped',
       reason: 'open_host_none',
       host: resolvedHost,
+      requestedHost: host,
+      resolvedHost,
+      desktopUrl,
       vscodeUrl,
       resumeCommand,
     };
   }
 
-  if (resolvedHost === 'vscode') {
+  if (resolvedHost === 'desktop' || resolvedHost === 'vscode') {
+    const url = resolvedHost === 'desktop' ? desktopUrl : vscodeUrl;
     const result =
       process.platform === 'darwin'
-        ? spawnSync('open', [vscodeUrl], { encoding: 'utf8' })
+        ? spawnSync('open', [url], { encoding: 'utf8' })
         : process.platform === 'win32'
-          ? spawnSync('cmd.exe', ['/c', 'start', '', vscodeUrl], { encoding: 'utf8' })
-          : spawnSync('xdg-open', [vscodeUrl], { encoding: 'utf8' });
+          ? spawnSync('cmd.exe', ['/c', 'start', '', url], { encoding: 'utf8' })
+          : spawnSync('xdg-open', [url], { encoding: 'utf8' });
     if (result.status !== 0) {
       return {
         status: 'failed',
-        reason: 'vscode_deep_link_open_failed',
+        reason: `${resolvedHost}_deep_link_open_failed`,
         host: resolvedHost,
+        requestedHost: host,
+        resolvedHost,
+        desktopUrl,
         vscodeUrl,
         resumeCommand,
         error: (result.stderr || result.stdout || '').trim(),
@@ -314,8 +340,11 @@ function openStartedCodexThread({ threadId, host, cwd }) {
     }
     return {
       status: 'opened',
-      reason: 'vscode_deep_link_opened',
+      reason: `${resolvedHost}_deep_link_opened`,
       host: resolvedHost,
+      requestedHost: host,
+      resolvedHost,
+      desktopUrl,
       vscodeUrl,
       resumeCommand,
     };
@@ -337,6 +366,9 @@ end tell
           status: 'failed',
           reason: 'terminal_open_failed',
           host: resolvedHost,
+          requestedHost: host,
+          resolvedHost,
+          desktopUrl,
           vscodeUrl,
           resumeCommand,
           error: (result.stderr || result.stdout || '').trim(),
@@ -346,6 +378,9 @@ end tell
         status: 'opened',
         reason: 'terminal_resume_opened',
         host: resolvedHost,
+        requestedHost: host,
+        resolvedHost,
+        desktopUrl,
         vscodeUrl,
         resumeCommand,
       };
@@ -354,6 +389,9 @@ end tell
       status: 'manual',
       reason: 'cli_auto_open_unsupported_on_platform',
       host: resolvedHost,
+      requestedHost: host,
+      resolvedHost,
+      desktopUrl,
       vscodeUrl,
       resumeCommand,
     };
@@ -363,6 +401,9 @@ end tell
     status: 'failed',
     reason: 'unsupported_open_host',
     host: resolvedHost,
+    requestedHost: host,
+    resolvedHost,
+    desktopUrl,
     vscodeUrl,
     resumeCommand,
   };
@@ -460,6 +501,9 @@ export async function run(args) {
 }
 
 export const _internal = {
+  buildCodexDesktopUrl,
+  isCodexDesktopEnvironment,
   parseArgs,
   renderTextResult,
+  resolveOpenHost,
 };

package/src/cli/codex-handoff-start.test.mjs

@@ -5,9 +5,58 @@ import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { _internal } from './codex-handoff-start.mjs';
 
 const REPO_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
 
+test('codex-handoff-start recognizes desktop as an explicit open host', () => {
+  assert.equal(_internal.parseArgs(['--open-host', 'desktop']).openHost, 'desktop');
+});
+
+test('codex-handoff-start auto-selects Codex Desktop before inherited VS Code signals', () => {
+  assert.equal(
+    _internal.resolveOpenHost('auto', {
+      CODEX_INTERNAL_ORIGINATOR_OVERRIDE: 'Codex Desktop',
+      VSCODE_IPC_HOOK_CLI: '/tmp/stale-vscode.sock',
+    }),
+    'desktop',
+  );
+  assert.equal(
+    _internal.resolveOpenHost('auto', { __CFBundleIdentifier: 'com.openai.codex' }),
+    'desktop',
+  );
+});
+
+test('codex-handoff-start does not mistake a stale VS Code PTY for Desktop without a Desktop signal', () => {
+  assert.equal(
+    _internal.resolveOpenHost('auto', {
+      VSCODE_IPC_HOOK_CLI: '/tmp/stale-vscode.sock',
+    }),
+    'vscode',
+  );
+  assert.equal(
+    _internal.resolveOpenHost('desktop', {
+      VSCODE_IPC_HOOK_CLI: '/tmp/stale-vscode.sock',
+    }),
+    'desktop',
+  );
+});
+
+test('codex-handoff-start keeps VS Code and CLI auto-open behavior', () => {
+  assert.equal(
+    _internal.resolveOpenHost('auto', { CODEX_INTERNAL_ORIGINATOR_OVERRIDE: 'codex_vscode' }),
+    'vscode',
+  );
+  assert.equal(_internal.resolveOpenHost('auto', {}), 'cli');
+});
+
+test('codex-handoff-start builds the Codex Desktop local thread deep link', () => {
+  assert.equal(
+    _internal.buildCodexDesktopUrl('019f78e8-77ec-7d73-aee4-fb8e3869200a'),
+    'codex://threads/019f78e8-77ec-7d73-aee4-fb8e3869200a',
+  );
+});
+
 function makeTempHome() {
   return mkdtempSync(join(tmpdir(), 'tl-codex-handoff-start-home-'));
 }
@@ -115,6 +164,9 @@ test('codex-handoff-start prints guided ready JSON for latest Codex session', as
     assert.equal(payload.sessionId, 'codex:thread-handoff-start');
     assert.equal(payload.mutatesCurrentThread, false);
     assert.equal(payload.startThreadManually, true);
+    assert.equal(payload.openHost, 'auto');
+    assert.equal(payload.requestedOpenHost, 'auto');
+    assert.ok(['desktop', 'vscode', 'cli'].includes(payload.resolvedOpenHost));
     assert.equal(payload.memoStdin, false);
     assert.equal(payload.memoReplayNote, null);
     assert.equal(payload.handoffSmoke.status, 'ready');
@@ -144,6 +196,8 @@ test('codex-handoff-start can print the exact fresh-thread prompt', async () =>
     assert.equal(result.status, 0, result.stderr);
     assert.match(result.stdout, /throughline codex handoff start/);
     assert.match(result.stdout, /status:\s+ready/);
+    assert.match(result.stdout, /open requested:\s+auto/);
+    assert.match(result.stdout, /open resolved:\s+(desktop|vscode|cli)/);
     assert.match(result.stdout, /commands:/);
     assert.match(result.stdout, /## Throughline: New Codex Thread Handoff/);
     assert.match(result.stdout, /latest handoff start body/);
@@ -250,12 +304,22 @@ test('codex-handoff-start execute creates a new app-server thread and can skip o
     assert.equal(payload.status, 'started');
     assert.equal(payload.reason, 'new_thread_handoff_started');
     assert.equal(payload.execute, true);
+    assert.equal(payload.openHost, 'none');
+    assert.equal(payload.requestedOpenHost, 'none');
+    assert.equal(payload.resolvedOpenHost, 'none');
     assert.equal(payload.startThreadManually, false);
     assert.equal(payload.newThread.threadId, '019e2000-0000-7000-8000-000000000001');
     assert.equal(payload.newThread.delivery, 'developer-item');
     assert.equal(payload.newThread.injectSent, true);
     assert.equal(payload.newThread.turnStatus, 'not-started');
     assert.equal(payload.open.status, 'skipped');
+    assert.equal(payload.open.host, 'none');
+    assert.equal(payload.open.requestedHost, 'none');
+    assert.equal(payload.open.resolvedHost, 'none');
+    assert.equal(
+      payload.open.desktopUrl,
+      'codex://threads/019e2000-0000-7000-8000-000000000001',
+    );
     assert.equal(payload.open.vscodeUrl, 'vscode://openai.chatgpt/local/019e2000-0000-7000-8000-000000000001');
     assert.match(payload.open.resumeCommand, /codex resume 019e2000-0000-7000-8000-000000000001/);
 

package/src/cli/help.test.mjs

@@ -49,7 +49,7 @@ test('CLI help exposes guided Codex handoff and guarded execute semantics', () =
   }
   assert.match(result.stdout, /Fresh-thread Codex handoff start plan/);
   assert.match(result.stdout, /Use --execute to/);
-  assert.match(result.stdout, /--open-host auto\|vscode\|cli\|none/);
+  assert.match(result.stdout, /--open-host auto\|desktop\|vscode\|cli\|none/);
   assert.match(result.stdout, /throughline trim --execute/);
   assert.match(result.stdout, /injectable DB memory/);
   assert.match(result.stdout, /matching/);

package/src/cli/install.test.mjs

@@ -181,6 +181,10 @@ test('global install copies Throughline Codex skill to ~/.codex/skills/', async
     assert.match(skillBody, /name: throughline/);
     assert.match(skillBody, /Bare "\$throughline"/);
     assert.match(skillBody, /throughline codex-handoff-start --execute/);
+    assert.match(skillBody, /--open-host desktop/);
+    assert.match(skillBody, /--open-host vscode/);
+    assert.match(skillBody, /--open-host cli/);
+    assert.match(skillBody, /not from[\s\S]*persistent PTY/);
     assert.match(skillBody, /do not run doctor \/ dry-run \/ preflight first/);
     assert.match(metadataBody, /start a new Codex thread with Throughline handoff memory/);
     assert.doesNotMatch(metadataBody, /scripted current-thread rollback/);

package/src/db-contention.test.mjs

@@ -0,0 +1,95 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const DB_MODULE_URL = pathToFileURL(fileURLToPath(new URL('./db.mjs', import.meta.url))).href;
+
+function waitForLine(stream, expected) {
+  return new Promise((resolve, reject) => {
+    let output = '';
+    const onData = (chunk) => {
+      output += chunk;
+      if (output.includes(expected)) {
+        stream.off('data', onData);
+        resolve();
+      }
+    };
+    stream.on('data', onData);
+    stream.once('error', reject);
+  });
+}
+
+function waitForExit(child) {
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('close', (code) => resolve({ code, stderr }));
+  });
+}
+
+test('getDb configures a bounded SQLite busy timeout for concurrent hook processes', () => {
+  const home = mkdtempSync(join(tmpdir(), 'throughline-db-timeout-'));
+  try {
+    const result = spawnSync(process.execPath, ['--input-type=module', '-e', `
+      import { getDb } from ${JSON.stringify(DB_MODULE_URL)};
+      const db = getDb();
+      process.stdout.write(String(db.prepare('PRAGMA busy_timeout').get().timeout));
+      db.close();
+    `], {
+      env: { ...process.env, HOME: home, USERPROFILE: home },
+      encoding: 'utf8',
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.stdout, '5000');
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('getDb reuses an existing WAL database while another process owns the writer lock', async () => {
+  const home = mkdtempSync(join(tmpdir(), 'throughline-db-contention-'));
+  const env = { ...process.env, HOME: home, USERPROFILE: home };
+  const initialize = spawn(process.execPath, ['--input-type=module', '-e', `
+    import { getDb } from ${JSON.stringify(DB_MODULE_URL)};
+    getDb().close();
+  `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+  assert.deepEqual(await waitForExit(initialize), { code: 0, stderr: '' });
+
+  const holder = spawn(process.execPath, ['--input-type=module', '-e', `
+    import { DatabaseSync } from 'node:sqlite';
+    import { join } from 'node:path';
+    const db = new DatabaseSync(join(process.env.HOME, '.throughline', 'throughline.db'));
+    db.exec('CREATE TABLE IF NOT EXISTS contention_probe (value TEXT)');
+    db.exec("BEGIN IMMEDIATE; INSERT INTO contention_probe VALUES ('held')");
+    process.stdout.write('locked\\n');
+    setTimeout(() => {
+      db.exec('COMMIT');
+      db.close();
+    }, 500);
+  `], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+  await waitForLine(holder.stdout, 'locked\n');
+
+  const contender = spawn(process.execPath, ['--input-type=module', '-e', `
+    import { getDb } from ${JSON.stringify(DB_MODULE_URL)};
+    const db = getDb();
+    const mode = db.prepare('PRAGMA journal_mode').get().journal_mode;
+    db.close();
+    if (String(mode).toLowerCase() !== 'wal') process.exit(2);
+  `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+
+  const [holderResult, contenderResult] = await Promise.all([
+    waitForExit(holder),
+    waitForExit(contender),
+  ]);
+  try {
+    assert.deepEqual(holderResult, { code: 0, stderr: '' });
+    assert.deepEqual(contenderResult, { code: 0, stderr: '' });
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/db.mjs

@@ -9,6 +9,7 @@ import { join } from 'path';
 
 const DB_DIR = join(homedir(), '.throughline');
 const DB_PATH = join(DB_DIR, 'throughline.db');
+const DB_BUSY_TIMEOUT_MS = 5_000;
 export const CURRENT_VERSION = 9;
 
 let _db = null;
@@ -248,11 +249,19 @@ export function getDb() {
 
   mkdirSync(DB_DIR, { recursive: true });
 
-  _db = new DatabaseSync(DB_PATH);
-  _db.exec('PRAGMA journal_mode = WAL');
-  _db.exec('PRAGMA foreign_keys = ON');
-
-  initSchema(_db);
-
-  return _db;
+  const db = new DatabaseSync(DB_PATH);
+  try {
+    db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+    const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
+    if (String(journalMode).toLowerCase() !== 'wal') {
+      db.exec('PRAGMA journal_mode = WAL');
+    }
+    db.exec('PRAGMA foreign_keys = ON');
+    initSchema(db);
+    _db = db;
+    return _db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
 }