throughline 0.12.9 → 0.13.0

package/CHANGELOG.md

@@ -10,6 +10,25 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.13.0] — 2026-10-04
+
+### 追加
+
+- Claude Codeの自動継続（[ADR 0032](docs/adr/0032-claude-compact-continuation.md)）。`throughline auto-handoff enable --host claude [--project <path>]`で有効にすると、自動圧縮の直後に、圧縮前の記録を同じ会話へ注入する。注入するのは、作業途中のユーザー依頼と圧縮直前の発言、直近の会話の原文（上限9,500字）。モデルは追加の入力なしで作業を続ける。既定は無効。手動`/compact`は対象外。
+- Claude Codeは、hookから作業を止めることも、新しい会話へ指示を送ることもできない。Codexのように新しいタスクへは切り替えず、hostが続ける同じ会話へ記憶を渡す。
+- `throughline install`は、Claudeの`PreCompact`フック（`throughline pre-compact`）を登録する。自動継続が無効の時は、判定を記録して抜ける。このフックは圧縮を止めない。
+- `auto-handoff`に`--host claude`を足す。使えるのは`enable`・`disable`・`status`。`--host`を省いた時は今までどおりCodex。
+
+### 修正
+
+- 圧縮をまたいだClaudeのターンが、複数のターンに割れて保存されていた不具合を直す。Claude Codeは圧縮の直後に、要約を本文に持つ`user`行（`isCompactSummary: true`）をtranscriptへ書く。0.12.9以前はこの行をユーザーの発言として数え、要約をユーザー発言としてL2へ保存していた。3回圧縮した実機のターンは4ターンとして保存された。圧縮より前のtool入出力はL3に入らなかった。
+- 修正後は、元の依頼と最終回答の1ターンとして保存し、圧縮より前のtool入出力も同じターンのL3へ入れる。Observer feedの`turn_start`は元の依頼のものになる（今までは要約行のターンとして`unknown`）。修正より前に保存した行は変えない。
+
+### 確認した範囲
+
+- LinuxのClaude Code 2.1.289（Haiku 4.5）。`claude -p`と対話画面のそれぞれで、自動圧縮2回をまたいで作業が完了し、圧縮のたびに注入が届いた。9,099字の注入はfile化されずに届いた。
+- macOS・Windows、VS Code拡張・Desktop、subagentの中の圧縮は確かめていない。
+
 ## [0.12.9] — 2026-10-04
 
 ### 修正
@@ -1634,7 +1653,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.12.9...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.13.0...HEAD
+[0.13.0]: https://github.com/kitepon/Throughline/compare/v0.12.9...v0.13.0
 [0.12.9]: https://github.com/kitepon/Throughline/compare/v0.12.8...v0.12.9
 [0.12.8]: https://github.com/kitepon/Throughline/compare/v0.12.7...v0.12.8
 [0.12.7]: https://github.com/kitepon/Throughline/compare/v0.12.6...v0.12.7

package/README.ja.md

@@ -44,6 +44,26 @@ throughline auto-handoff resume --operation <handoff-id> --json
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)を参照してください。
 
+## Claude Codeの自動継続
+
+```bash
+throughline auto-handoff enable --host claude --project /absolute/project/path
+throughline auto-handoff status --host claude --json
+throughline auto-handoff disable --host claude
+```
+
+既定では無効です。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
+
+Claude Codeは、自動圧縮の前にhookから作業を止めることも、新しい会話へ指示を送ることもできません。自動圧縮の後は、同じ会話で作業をそのまま続けます。Throughlineは会話を切り替えず、圧縮の直後に、圧縮前の記録を同じ会話へ注入します（[ADR 0032](docs/adr/0032-claude-compact-continuation.md)）。
+
+- `PreCompact`フックが、自動圧縮の時だけ印を残します。圧縮は止めません。
+- 圧縮直後の`SessionStart`（`source: "compact"`）フックが、作業途中のユーザー依頼と圧縮直前の発言、直近の会話の原文を注入します。上限は9,500字で、入り切らない古いターンは`throughline recall`の案内になります。
+- モデルは追加の入力なしで作業を続けます。圧縮の要約と記録が食い違う時は、記録を正とするよう指示します。
+
+手動`/compact`は対象に含めません。圧縮をまたいだターンは、元の依頼と最終回答の1ターンとして保存します（0.12.9以前は、圧縮の要約をユーザー発言として保存していました）。
+
+LinuxのClaude Code 2.1.289（`claude -p`と対話画面）で実機確認済みです。macOS・Windows、VS Code拡張・Desktop、subagentの中の圧縮は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-04-claude-compact-continuation.md)を参照してください。
+
 ## 所有境界
 
 本repositoryは導入、設定、状態、schemaとmigration、診断、復旧、更新、release判断を

package/README.md

@@ -43,6 +43,26 @@ throughline auto-handoff resume --operation <handoff-id> --json
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)を参照してください。
 
+## Claude Codeの自動継続
+
+```bash
+throughline auto-handoff enable --host claude --project /absolute/project/path
+throughline auto-handoff status --host claude --json
+throughline auto-handoff disable --host claude
+```
+
+既定では無効です。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
+
+Claude Codeは、自動圧縮の前にhookから作業を止めることも、新しい会話へ指示を送ることもできません。自動圧縮の後は、同じ会話で作業をそのまま続けます。Throughlineは会話を切り替えず、圧縮の直後に、圧縮前の記録を同じ会話へ注入します（[ADR 0032](docs/adr/0032-claude-compact-continuation.md)）。
+
+- `PreCompact`フックが、自動圧縮の時だけ印を残します。圧縮は止めません。
+- 圧縮直後の`SessionStart`（`source: "compact"`）フックが、作業途中のユーザー依頼と圧縮直前の発言、直近の会話の原文を注入します。上限は9,500字で、入り切らない古いターンは`throughline recall`の案内になります。
+- モデルは追加の入力なしで作業を続けます。圧縮の要約と記録が食い違う時は、記録を正とするよう指示します。
+
+手動`/compact`は対象に含めません。圧縮をまたいだターンは、元の依頼と最終回答の1ターンとして保存します（0.12.9以前は、圧縮の要約をユーザー発言として保存していました）。
+
+LinuxのClaude Code 2.1.289（`claude -p`と対話画面）で実機確認済みです。macOS・Windows、VS Code拡張・Desktop、subagentの中の圧縮は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-04-claude-compact-continuation.md)を参照してください。
+
 ## Ownership boundary
 
 This repository owns installation, configuration, state, schema and migrations,

package/bin/throughline.mjs

@@ -8,6 +8,7 @@
  *   throughline uninstall     # hook を削除
  *   throughline process-turn  # Stop hook (Claude Code から呼ばれる)
  *   throughline session-start # SessionStart hook (Claude Code から呼ばれる)
+ *   throughline pre-compact   # PreCompact hook (Claude Code から呼ばれる。自動継続の印)
  *   throughline detail <時刻> # L2+L3 詳細取得 (Claude が Bash 経由で呼ぶ想定)
  *   throughline recall --l2|--l1 # 注入案内から辿る pull 用 read-only 記憶取得
  *   throughline handoff-preview # Codex-facing throughline_handoff JSON preview
@@ -52,7 +53,7 @@ const [, , cmd, ...rest] = process.argv;
 
 // hook入口では、送信を明示して有効にした端末だけ、未受領のruntime errorを裏で送るprocessを起こす。
 // 既定（送信設定なし）では小さなファイル1つを見るだけで、通信もprocess起動もしない。
-if (['process-turn', 'session-start', 'prompt-submit', 'codex-hook'].includes(cmd)) {
+if (['process-turn', 'session-start', 'prompt-submit', 'pre-compact', 'codex-hook'].includes(cmd)) {
   try {
     (await import('../src/runtime-error-report-trigger.mjs')).triggerRuntimeErrorReportBestEffort();
   } catch {
@@ -80,6 +81,9 @@ switch (cmd) {
   case 'prompt-submit':
     await (await import('../src/prompt-submit.mjs')).run();
     break;
+  case 'pre-compact':
+    await (await import('../src/claude-pre-compact.mjs')).run();
+    break;
   case 'monitor':
     (await import('../src/token-monitor.mjs')).main();
     break;
@@ -233,6 +237,7 @@ switch (cmd) {
     'session-start': 'HOOK_SESSION_START_FAILED',
     'prompt-submit': 'HOOK_PROMPT_SUBMIT_FAILED',
     'process-turn': 'HOOK_PROCESS_TURN_FAILED',
+    'pre-compact': 'HOOK_PRE_COMPACT_FAILED',
   }[cmd];
   if (code) {
     const { recordRuntimeErrorBestEffort } = await import('../src/runtime-error-store.mjs');
@@ -401,6 +406,9 @@ Usage:
                               同じ引き継ぎを再開（結果不明は再送しない）
   throughline auto-handoff detail --operation <id> --origin <session> --turn <n>
                               凍結したL2/L3を取得
+  throughline auto-handoff enable|disable|status --host claude [--project <path>] [--json]
+                              Claude Codeの自動継続（自動圧縮の直後に、同じ会話へ
+                              圧縮前の記録を注入）を有効化・無効化・確認
   throughline doctor            Check environment
   throughline doctor --trim     Show trim host boundary diagnostics
   throughline doctor --codex    Show Codex primary diagnostics
@@ -411,6 +419,7 @@ Hook subcommands (called by Claude Code / Codex):
   throughline session-start   SessionStart hook
   throughline process-turn    Stop hook
   throughline prompt-submit   UserPromptSubmit hook (/tl & /clear baton writer)
+  throughline pre-compact     PreCompact hook (Claude自動圧縮の印。圧縮後に記憶を注入)
   throughline codex-hook user-prompt-submit Codex current-session refresh prompt hook
   throughline codex-hook post-tool-use Codex current-session refresh tool-loop hook
   throughline codex-hook stop Codex Stop hook

package/docs/02_clear_auto_handoff_plan.md

@@ -11,6 +11,7 @@
 | `/tl` | `UserPromptSubmit` が現在の session id を baton として保存する。次の実セッションがその前任を確定的に引き継ぐ |
 | VS Code の `/clear` | 組み込みコマンドは `UserPromptSubmit` に届かない。`SessionStart source='clear'` を使う auto path が、同じ project の直近前任を凍結して引き継ぐ |
 | Claude Desktop の `/clear` | `UserPromptSubmit` に届かず、`SessionStart source='clear'` も来ないため自動継承しない。続ける場合は `/clear` の前に `/tl` を実行する |
+| Claude Code の自動圧縮 | 会話は切り替わらない。`auto-handoff enable --host claude` で有効にした時だけ、`PreCompact`（`trigger: auto`）が印を残し、圧縮直後の `SessionStart source='compact'` が作業途中のターンと直近の会話を同じ会話へ注入する。既定は無効。手動 `/compact` は対象外。正本は [ADR 0032](adr/0032-claude-compact-continuation.md) |
 
 `/clear` が `UserPromptSubmit` に届かないことは、VS Code と Desktop の対照実測で
 確定している。`prompt-submit` に残る `/clear` 分岐は host が将来その文字列を渡した場合の
@@ -43,7 +44,7 @@ baton path と auto path は同じ `buildBudgetedResumeContext` を使う。注
 
 ## host 別境界
 
-- Claude Code: VS Code `/clear` は auto path、Desktop `/clear` は `/tl` 併用。
+- Claude Code: VS Code `/clear` は auto path、Desktop `/clear` は `/tl` 併用。自動圧縮は、有効にした時だけ同じ会話へ注入する（ADR 0032）。
 - Grok: `/tl` の baton 成功後に `throughline grok-continue --session <id>` で後継席を
   起動する。`/clear` では起動しない。正本は [ADR 0021](adr/0021-grok-host-capture.md)。
 - Cursor: `/tl` は baton を残すが後継会話を自動起動しない。次の会話が baton を消費する。

package/docs/05_codex_first_roadmap.md

@@ -28,6 +28,8 @@
 最初の成立検証はCodex Desktopで行う。OSごとの仕組みと受入条件は共通にし、
 差分は既存の `src/os/` と配送ライブラリの環境適合へ閉じ込める。
 VS Code・CLIとClaude/Grok/Cursorの対応はhostごとに同じ条件で検証する。
+Claude Codeは圧縮前の停止と新しい会話への配送がhookからできないため、自動圧縮の直後に同じ会話へ記憶を注入する
+（[ADR 0032](adr/0032-claude-compact-continuation.md)）。この節の処理順と進行状態はCodexだけに適用する。
 一つのhostの成功で他のhostも対応済みとはしない。
 
 ### 根拠と検証範囲

package/docs/adr/0032-claude-compact-continuation.md

@@ -0,0 +1,88 @@
+# ADR 0032: Claude Code の自動継続は、自動圧縮の直後に同じ会話へ記憶を注入する
+
+日付: 2026-10-04
+
+## Context
+
+Codex Desktop の自動継続（0.11.0）は、自動圧縮の前に旧タスクを止め、記憶を注入した新しいタスクで
+作業を続ける。オーナーの指示（2026-10-04）で、同じことを Claude Code でも行う。
+
+Claude Code 2.1.289 で、Codex と同じ方式が取れるかを公式の hook 仕様と実機で確かめた。
+
+| 必要な操作 | Codex Desktop | Claude Code 2.1.289 |
+|---|---|---|
+| 圧縮の前に作業を止める | `PreCompact` が `continue: false` を返す | `PreCompact` の `continue` は捨てられる。できるのは圧縮を止めること（exit code 2、`decision: "block"`）だけで、止めると会話は圧縮されないまま続き、文脈上限に達した後は元の error で失敗する |
+| 新しい会話を作って記憶を入れる | app-server の `thread/start` と `thread/inject_items` | 公開された入口が無い |
+| 新しい会話へ指示を送って始めさせる | 公式 queue への配送 | `claude-cli://` は入力欄へ下書きを入れるだけで送信しない。`claude --bg` は別の background session を作り、編集の前に git worktree へ移る。元の画面の会話は入れ替わらない |
+
+一方、Claude Code は自動圧縮の後、同じ会話で作業をそのまま続ける。圧縮の直後に
+`SessionStart`（`source: "compact"`）の hook を走らせ、その出力を圧縮後の文脈へ足すと公式文書に書かれている。
+
+実機の結果（Linux、`claude -p`、Haiku 4.5、`CLAUDE_CODE_AUTO_COMPACT_WINDOW=100000`）:
+
+- `PreCompact` は `trigger: "auto"` で届く。payload は `session_id`・`transcript_path`・`cwd`・`trigger`・`custom_instructions`。
+- 圧縮の後、同じ `session_id` の `SessionStart(source=compact)` が届く。stdout は `<system-reminder>` として
+  モデルへ届き、モデルは追加の入力なしで作業を続けた。9,099 字の出力は file 化されずにそのまま届いた。
+- transcript は圧縮より前の行を残したまま、`system`（`subtype: "compact_boundary"`、`compactMetadata.trigger`）と、
+  要約を本文に持つ `user` 行（`isCompactSummary: true`）を足す。圧縮境界の行は `SessionStart` hook が
+  走った時刻より後の時刻を持つ。
+- 1回目の圧縮の前に `PreCompact` が5秒の間隔で2回届いたことがある。
+- 依頼を送った直後（最初の応答の前）に自動圧縮が起きることがある。その回では、`SessionStart(source=compact)` の
+  時点で、送った依頼の行は transcript に書かれていた。行の `promptId` は hook payload の `prompt_id` と同じ値。
+
+あわせて、既存の不具合が見つかった。`readTranscript` は要約の `user` 行を人の発言として数えていた。
+圧縮をまたいだ1ターンは「元の依頼 + 途中の発言」と「要約 + 圧縮後の発言」に割れ、要約が user 発言として
+bodies に入り、圧縮より前の tool 入出力は L3 に入らなかった。3回圧縮した実機のターンは4ターンとして保存された。
+
+## Decision
+
+Claude では会話を切り替えず、host が続ける同じ会話へ記憶を渡す。
+
+1. **印**: `PreCompact` hook（`throughline pre-compact`、matcher 無し）が、`trigger: "auto"` で自動継続が有効な
+   project の時だけ、`~/.throughline/claude-auto-handoff/<session_id>.json` に印を残す。手動の `/compact` と
+   無効の時は、同じ会話の古い印を消す。subagent の中の圧縮（payload に `agent_id`）は印に触らない。
+   hook は圧縮を止めない。stdout へ何も書かず、失敗しても exit code 2 を返さない。
+2. **注入**: `SessionStart(source=compact)` が印を取り出して消し、次を stdout へ書く（上限 9,500 字、ADR 0014）。
+   - ヘッダ: 自動圧縮が起きたこと、下記が圧縮前の原文であること、作業の途中なので入力を待たずに続けること、
+     完了済みの操作を繰り返さないこと。宣言文は求めない。
+   - 現在地: 作業途中のターンの user 依頼（4,000 字まで）と、圧縮直前の assistant 発言（1,500 字まで）。
+     transcript から読む。上限を超える時は先頭 3/4 と末尾 1/4 を残し、間を抜いた字数を書く。
+   - 案内と L2: `/clear` の引き継ぎ（ADR 0016）と同じ。完了済みのターンを新しい順に、丸ごと入る分だけ。
+3. **作業途中のターンは保存しない**: 注入の前に完了済みのターンを bodies へ回収するが、最後の user 発言の群は除く。
+   途中の発言を代表として保存すると、群レベルの重複除去で最終回答が入らなくなる。保存は今までどおり Stop で行う。
+   transcript は hook より遅れて書かれることがある。hook payload の `prompt_id` と、最後の user 行の `promptId` が
+   両方あって食い違う時は、今の依頼がまだ書かれていない。その時は最後の群を現在地に載せず、回収もせず、
+   現在地には「記録からまだ読めない」とだけ書く。
+4. **trigger は `PreCompact` の payload だけから決める**: `SessionStart` の時点の transcript から推測しない
+   （圧縮境界の行は hook より後に書かれる）。手動の `/compact` は対象にしない（Codex と同じ）。
+5. **要約行**: `isCompactSummary: true` の行は、ターンの始まりにも本文にもしない。`turn_number`（transcript 内の
+   本文行の通し番号）は詰めず、要約行の分も進める。詰めると、要約行を数えていた頃に保存した行と番号が食い違う。
+   L3 の範囲も要約行で切らず、元の依頼から取る。
+6. **有効化**: 既定は無効。`throughline auto-handoff enable --host claude [--project <path>]` が
+   `~/.throughline/claude-auto-handoff.json` を書く。`--host` を省いた時は今までどおり Codex。
+   Codex の設定とは別のファイルで、互いに影響しない。有効判定は会話を起動した project（`CLAUDE_PROJECT_DIR`）で行う。
+   `resume`・`detail`・`worker` と `--operation` は Claude では使えない（引き継ぎ操作の記録を持たない）。
+7. **hook の登録**: `throughline install` が Claude の `PreCompact` hook を登録する。`enable` は登録が無ければ足す。
+   無効の時、hook は判定を記録して抜ける。
+8. **失敗**: `PreCompact` の失敗は `HOOK_PRE_COMPACT_FAILED`（severity `warn`。圧縮と作業は続く）、
+   注入の失敗は既存の `HOOK_SESSION_START_FAILED`。どちらも理由を `hook-failures.log` に残す。
+   判定は `inheritance-decision.log` に `phase: "pre-compact"` と `phase: "compact-continuation"` で残す。
+
+## Consequences
+
+- Claude Code の圧縮は走る。Codex のように圧縮の本文生成を省けない。圧縮後の文脈は、host の要約と
+  Throughline の記録の両方を持つ。食い違う時は記録を正とするよう、ヘッダで指示する。
+- schema は変えない（v12 のまま）。新しい会話も、配送も、常駐 process も作らない。`aiterm-steer-delivery` は使わない。
+- Claude の `/clear` と `/tl` の引き継ぎ（ADR 0014・0016）は変えない。`SessionStart(source=compact)` の
+  pending intent の登録も今までどおり行う。
+- 作業途中のターンの tool 入出力は、Stop まで `throughline detail` で取れない。
+- 圧縮をまたいだターンは、元の依頼と最終回答の1ターンとして保存される。Observer feed にも1ターンで出て、
+  `turn_start` は元の依頼のものになる。今までは要約行のターンとして `unknown` で出ていた。
+- 修正より前に保存した行はそのまま残る。同じ断片を持つ群は入れ直さない。
+- `throughline install`（`self-update` を含む）は `~/.claude/settings.json` に `PreCompact` を1件足す。
+
+## 確認した範囲
+
+- Linux の Claude Code 2.1.289（`claude -p` と対話画面）、Haiku 4.5。自動圧縮2回をまたいで作業が完了し、
+  圧縮のたびに注入が届き、圧縮されたターンが1ターンとして保存された。
+- macOS・Windows、VS Code 拡張・Desktop、subagent の中の圧縮は確かめていない。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.12.9",
+  "version": "0.13.0",
   "type": "module",
   "description": "Persistent memory hooks for Claude Code, Codex, Grok, and Cursor (/clear-safe context compression)",
   "keywords": [

package/rag/01-hooks/raw/claude-compact-hooks-extract.md

@@ -0,0 +1,56 @@
+# Claude Code: 圧縮まわりの hook（一次ソース抜粋）
+
+取得: 2026-10-04、`https://code.claude.com/docs/en/hooks.md`・`context-window.md`・`deep-links.md`・`agent-view.md`・`env-vars.md`。
+実機は Claude Code 2.1.289。設計は [ADR 0032](../../../docs/adr/0032-claude-compact-continuation.md)。
+
+## PreCompact
+
+> Exit with code 2 to block compaction. For a manual `/compact`, the stderr message is shown to the user. You can also block by returning JSON with `"decision": "block"`.
+>
+> Blocking automatic compaction has different effects depending on when it fires. If compaction was triggered proactively before the context limit, Claude Code skips it and the conversation continues uncompacted. If compaction was triggered to recover from a context-limit error already returned by the API, the underlying error surfaces and the current request fails.
+>
+> Claude Code discards a PreCompact hook's `systemMessage` and `continue` fields.
+
+- matcher は `manual` / `auto`。入力は共通項目に加えて `trigger` と `custom_instructions`（auto では `null`）。
+- → 圧縮の前に作業を止める口は無い。止められるのは圧縮だけ。
+
+## SessionStart（source=compact）
+
+> | `compact` | Auto or manual compaction |
+
+> | [SessionStart hooks](/docs/en/hooks-guide#re-inject-context-after-compaction) that match the `compact` source | Claude Code runs them and adds their output to the compacted context |
+
+- 入力の `source` は `compact`。auto と manual の区別は入力に無い。
+- → 区別は `PreCompact` の `trigger` で取る。
+
+## PostCompact
+
+> PostCompact hooks have no decision control. They can't affect the compaction result but can perform follow-up tasks.
+
+- 入力に `compact_summary`（生成された要約）。Throughline は使わない。
+
+## subagent
+
+> | `agent_id` | Unique identifier for the subagent. Present only when the hook fires inside a subagent call. Use this to distinguish subagent hook calls from main-thread calls. |
+
+## 新しい会話を始める口
+
+> A deep link never executes anything on its own. The link only chooses a directory and fills the prompt box.
+
+> When you dispatch a background session from agent view or start one with `claude --bg`, the session starts in your working directory. Before editing files, Claude moves the session into an isolated git worktree under `.claude/worktrees/`
+
+- `claude-cli://open?q=…` は入力欄へ下書きを入れるだけ。`claude --bg "<prompt>"` は別の background session。
+- → 対話中の会話を、記憶を入れた新しい会話へ入れ替えて続けさせる公開の口は無い。
+
+## 自動圧縮の窓
+
+> | `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Set the auto-compact window in tokens, from `100000` to `1000000`. … |
+
+- 実機試験だけで使う。製品は依存しない。
+
+## 実機で見た transcript（2.1.289）
+
+- 圧縮の後に `{"type":"system","subtype":"compact_boundary","compactMetadata":{"trigger":"auto","preTokens":…,"postTokens":…}}`。
+- 続けて `{"type":"user","isCompactSummary":true,"isVisibleInTranscriptOnly":true,"message":{"role":"user","content":"This session is being continued from a previous conversation that ran out of context. …"}}`。
+- `SessionStart:compact` の hook 出力は `attachment`（`type: "hook_success"`）として残り、モデルには `<system-reminder>` で届く。
+- 圧縮より前の行は消えない。

package/rag/INDEX.md

@@ -27,6 +27,10 @@ rag/
 - [fork rolloutのmetadata実測](01-hooks/codex-fork-rollout-metadata.md) — 子の先頭metadataの後に親のmetadataと履歴がコピーされる並びを実機で確認。自動継続の誤ったthread不一致判定を最小fixtureと実rolloutで再現・修正した。
 - [PreCompact・記憶注入・配送の一次ソース抜粋](01-hooks/raw/codex-auto-handoff-extract.md) — 公式仕様と配送ライブラリの固定source。[Desktop実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)でauto停止・新規idle taskの自動開始・配送process終了後の継続が成立した。cold readの途中状態と表示後の権限更新を観測し、[設計](../docs/05_codex_first_roadmap.md#自動新規タスク継続の設計案)へ反映した。
 
+## Claude自動継続の根拠
+
+- [圧縮まわりのhookの一次ソース抜粋](01-hooks/raw/claude-compact-hooks-extract.md) — `PreCompact`は圧縮を止められるが作業は止められない。`SessionStart(source=compact)`の出力は圧縮後の文脈へ足される。新しい会話へ指示を送る公開の口は無い。[実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-04-claude-compact-continuation.md)で、自動圧縮の直後に注入が届き、入力なしで作業が続いた。Finding 6・第三仮説（PreCompactでの再投影）に対する現行の答えは[ADR 0032](../docs/adr/0032-claude-compact-continuation.md)。
+
 ## Question this RAG was built to answer
 
 > Throughline は「コンテキスト削減しつつ過去の記憶を一切失わない」と定義されている。記憶を引き継いでいてもモデルがそれを自分の作業履歴として体感していないなら、その記憶は無意味なコンテキストである。

package/src/claude-auto-handoff-config.mjs

@@ -0,0 +1,38 @@
+import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { normalizeProjectPathForCompare, sameProjectPath } from './project-path.mjs';
+
+// Claude の自動継続の設定。Codex の設定（codex-auto-handoff.json）とは別のファイルで、互いに影響しない。
+export const CLAUDE_AUTO_HANDOFF_CONFIG_SCHEMA = 'throughline.claude-auto-handoff.v1';
+export const claudeAutoHandoffConfigPath = () => join(homedir(), '.throughline', 'claude-auto-handoff.json');
+
+export function readClaudeAutoHandoffConfig(path = claudeAutoHandoffConfigPath()) {
+  let text;
+  try { text = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if (error.code === 'ENOENT') return { schema: CLAUDE_AUTO_HANDOFF_CONFIG_SCHEMA, enabled: false, projects: [] };
+    throw error;
+  }
+  const config = JSON.parse(text);
+  if (config.schema !== CLAUDE_AUTO_HANDOFF_CONFIG_SCHEMA || typeof config.enabled !== 'boolean' ||
+      !Array.isArray(config.projects) ||
+      config.projects.some(p => typeof p !== 'string' || !isAbsolute(p))) throw new Error('auto_handoff_config_invalid');
+  return config;
+}
+
+export function writeClaudeAutoHandoffConfig({ enabled, projects = [] }, path = claudeAutoHandoffConfigPath()) {
+  if (typeof enabled !== 'boolean') throw new TypeError('auto_handoff_config_invalid');
+  const config = { schema: CLAUDE_AUTO_HANDOFF_CONFIG_SCHEMA, enabled,
+    projects: projects.map(normalizeProjectPathForCompare) };
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(config)}\n`, { mode: 0o600, flag: 'wx' });
+  renameSync(temporary, path);
+  return config;
+}
+
+export function claudeAutoHandoffEnabledFor(config, projectPath) {
+  return config.enabled && (config.projects.length === 0 || config.projects.some(p => sameProjectPath(p, projectPath)));
+}

package/src/claude-auto-handoff.mjs

@@ -0,0 +1,207 @@
+/**
+ * claude-auto-handoff.mjs — Claude Code の自動継続 (ADR 0032)
+ *
+ * Codex の自動継続は、自動圧縮の前に旧タスクを止めて新しいタスクへ記憶を渡す。Claude Code は
+ * hook から作業を止められず、新しい会話へ指示を送る公開 API も無い。自動圧縮の後は host が
+ * 同じ会話で作業を続け、SessionStart(source=compact) の hook 出力を圧縮後の文脈へ足す。
+ * そこで Claude では、会話を切り替えずに次の 2 段で記憶を渡す。
+ *
+ *   1. PreCompact      : trigger=auto の時だけ、その会話に「自動圧縮が始まった」印を残す。
+ *                        圧縮は止めない（止めると文脈上限の error になる）。
+ *   2. SessionStart    : source=compact で印があれば、完了済みのターンを回収し、
+ *      (source=compact)  作業途中のターンと直近の会話の原文を stdout へ書く。
+ *
+ * 手動の /compact は対象にしない（Codex と同じ）。印は PreCompact の payload だけから作り、
+ * SessionStart の時点の transcript から trigger を推測しない（圧縮境界の行は hook より後に書かれる）。
+ */
+
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { readClaudeAutoHandoffConfig, claudeAutoHandoffEnabledFor } from './claude-auto-handoff-config.mjs';
+import { CLAUDE_HOST, hostOfSessionId } from './hosts/identity.mjs';
+import { claudeHostAdapter } from './hosts/claude.mjs';
+import { readLatestUserGroup } from './transcript-reader.mjs';
+import { backfillBodies, logBackfill } from './turn-backfill.mjs';
+import { resolveMergeTarget } from './session-merger.mjs';
+import { buildCompactContinuationContext } from './resume-context.mjs';
+
+export const CLAUDE_COMPACT_REQUEST_SCHEMA = 'throughline.claude-auto-handoff.request.v1';
+// 印は圧縮の完了で消える。圧縮が失敗して残った印は、次の PreCompact の時にこの期限で掃除する。
+const STALE_REQUEST_MS = 24 * 60 * 60 * 1000;
+// session id を印のファイル名に使う。Claude の id は UUID で、path の区切りを含む値は受け付けない。
+const CLAUDE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+
+export const claudeCompactRequestDir = () => join(homedir(), '.throughline', 'claude-auto-handoff');
+
+function requestPath(sessionId, dir) {
+  if (hostOfSessionId(sessionId) !== CLAUDE_HOST || !CLAUDE_SESSION_ID_PATTERN.test(sessionId)) {
+    throw new Error('auto_handoff_session_id_invalid');
+  }
+  return join(dir, `${sessionId}.json`);
+}
+
+function removeStaleRequests(dir, now) {
+  let names;
+  try { names = readdirSync(dir); }
+  catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const path = join(dir, name);
+    let modifiedAt;
+    try { modifiedAt = statSync(path).mtimeMs; }
+    catch (error) {
+      if (error.code === 'ENOENT') continue; // 別の hook が同時に消した
+      throw error;
+    }
+    if (now - modifiedAt > STALE_REQUEST_MS) rmSync(path, { force: true });
+  }
+}
+
+/**
+ * PreCompact hook の本体。自動圧縮で、その project が有効な時だけ印を残す。
+ * 手動と無効の時は、同じ会話の古い印を消して何もしない。subagent の中の圧縮は、
+ * 親の会話の印に触らない（payload の session_id は親の会話を指す）。
+ *
+ * @param {{
+ *   payload: {session_id?: string, trigger?: string, cwd?: string, transcript_path?: string},
+ *   env?: NodeJS.ProcessEnv,
+ *   config?: {enabled: boolean, projects: string[]},
+ *   now?: number,
+ *   dir?: string,
+ * }} params
+ * @returns {{status: 'requested'|'skipped', reason?: string, sessionId: string, projectPath?: string}}
+ */
+export function recordClaudeCompactRequest({
+  payload,
+  env = process.env,
+  config = readClaudeAutoHandoffConfig(),
+  now = Date.now(),
+  dir = claudeCompactRequestDir(),
+}) {
+  const sessionId = payload?.session_id;
+  if (typeof sessionId !== 'string' || !sessionId) throw new Error('Missing session_id in PreCompact payload');
+  if (payload.agent_id) return { status: 'skipped', reason: 'subagent_compact', sessionId };
+  const path = requestPath(sessionId, dir);
+  // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
+  const projectPath = claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env });
+
+  const reason = payload.trigger !== 'auto'
+    ? 'manual_compact'
+    : claudeAutoHandoffEnabledFor(config, projectPath) ? null : 'auto_handoff_disabled';
+  if (reason) {
+    rmSync(path, { force: true });
+    return { status: 'skipped', reason, sessionId, projectPath };
+  }
+
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  removeStaleRequests(dir, now);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify({
+    schema: CLAUDE_COMPACT_REQUEST_SCHEMA,
+    session_id: sessionId,
+    trigger: 'auto',
+    project_path: projectPath,
+    transcript_path: payload.transcript_path ?? null,
+    requested_at: now,
+  })}\n`, { mode: 0o600, flag: 'wx' });
+  renameSync(temporary, path);
+  return { status: 'requested', sessionId, projectPath };
+}
+
+/**
+ * SessionStart(source=compact) から呼ぶ。その会話の印を取り出して消す。無ければ null。
+ * @returns {{session_id: string, trigger: 'auto', project_path: string, transcript_path: string|null, requested_at: number}|null}
+ */
+export function consumeClaudeCompactRequest({ sessionId, dir = claudeCompactRequestDir() }) {
+  if (hostOfSessionId(sessionId) !== CLAUDE_HOST || !CLAUDE_SESSION_ID_PATTERN.test(sessionId)) return null;
+  const path = requestPath(sessionId, dir);
+  let text;
+  try { text = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+  rmSync(path, { force: true });
+  const request = JSON.parse(text);
+  if (request.schema !== CLAUDE_COMPACT_REQUEST_SCHEMA || request.session_id !== sessionId ||
+      request.trigger !== 'auto') throw new Error('auto_handoff_request_invalid');
+  return request;
+}
+
+export function listClaudeCompactRequests({ dir = claudeCompactRequestDir() } = {}) {
+  let names;
+  try { names = readdirSync(dir); }
+  catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+  return names.filter(name => name.endsWith('.json')).map(name => {
+    const { session_id, project_path, requested_at } = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+    return { session_id, project_path, requested_at };
+  }).sort((a, b) => a.requested_at - b.requested_at);
+}
+
+/**
+ * 自動圧縮の直後に注入するテキストを作る。
+ *
+ * 作業途中のターン（最後の user 発言の群）は Stop の前なので、回収の対象から外して transcript から読む。
+ * それより前の完了済みターンは、Stop が空振りした分もここで bodies へ回収してから並べる。
+ *
+ * transcript は hook より遅れて書かれることがある。hook payload の `prompt_id` と、最後の user 行の
+ * `promptId` が両方あって食い違う時は、今の依頼がまだ書かれていない。その時は最後の群を
+ * 作業途中として見せず、回収もしない（どちらのターンか確定できない群を、完了として保存しない）。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{ sessionId: string, transcriptPath: string|null|undefined, promptId?: string|null, now?: number }} params
+ * @returns {{
+ *   text: string,
+ *   stats: {total_chars: number, injected_l2_turns: number, remaining_l2_turns: number, older_turns: number,
+ *     in_flight_user: boolean, in_flight_unreadable: boolean, in_flight_fragments: number, backfilled_turns: number},
+ * } | null}
+ */
+export function buildClaudeCompactContinuation(db, { sessionId, transcriptPath, promptId = null, now = Date.now() }) {
+  const { target, origin } = resolveMergeTarget(db, sessionId);
+  const latest = readLatestUserGroup(transcriptPath);
+  const inFlightUnreadable = Boolean(promptId && latest?.user.prompt_id && latest.user.prompt_id !== promptId);
+  const inFlight = inFlightUnreadable ? null : latest;
+
+  const backfill = backfillBodies(db, {
+    targetSessionId: target,
+    originSessionId: origin,
+    transcriptPath,
+    now,
+    beforeUserTurnNumber: latest ? latest.user.turn_number : null,
+  });
+  logBackfill({
+    ts: new Date(now).toISOString(),
+    hook: 'session-start-compact',
+    session_id: sessionId,
+    target,
+    origin,
+    transcript_path: transcriptPath ?? null,
+    groups: backfill.groups,
+    inserted_turns: backfill.insertedTurns,
+    skipped_existing: backfill.skippedExisting,
+  });
+
+  const context = buildCompactContinuationContext(db, { sessionId: target, inFlight, inFlightUnreadable });
+  if (!context) return null;
+  return {
+    text: context.text,
+    stats: {
+      total_chars: context.totalChars,
+      injected_l2_turns: context.injectedL2Turns,
+      remaining_l2_turns: context.remainingL2Turns,
+      older_turns: context.olderTurns,
+      in_flight_user: Boolean(inFlight),
+      in_flight_unreadable: inFlightUnreadable,
+      in_flight_fragments: inFlight?.fragments.length ?? 0,
+      backfilled_turns: backfill.insertedTurns,
+    },
+  };
+}