throughline 0.16.17 → 0.16.19

package/CHANGELOG.md

@@ -10,6 +10,42 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.19] — 2026-10-11
+
+### 修正
+
+- Claude Codeの自動継続で、作業ツリー（`<repository>/.claude/worktrees/<名前>`）の後継をClaude Desktopが取り込んだ後にもう一度引き継ぐと、後継が元のrepositoryで立ち、前任の記憶が入らず、Desktopへも移らなかった（[ADR 0049](docs/adr/0049-claude-handoff-uses-registered-project.md)）。Windowsの実機（Claude Code 2.1.296）で2026-10-10 23:43に1回起きた。hookの`CLAUDE_PROJECT_DIR`が元のrepositoryを指し、会話を登録したproject（作業ツリー）と違っていた。
+  - 後継を立てるprojectを、会話が移った先（`relocated`）、会話を登録したproject（`sessions`。その場所が今もある時）、`CLAUDE_PROJECT_DIR`、hookのcwdの順で決める。
+  - 受領を確かめられなかった引き継ぎ（`unknown`・`handoff_delivery_unconfirmed`）でも、その後継がターンを終えたら、Claude Desktopへ移す。今までは裏の会話のまま残り、リモートコントロールからしか見えなかった。`state`と`error_code`は変えない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 直した。単体試験と、切り離した置き場での本物のhookの命令（作業ツリーで登録した会話へ、`CLAUDE_PROJECT_DIR`を元のrepositoryにして`pre-compact`を渡し、後継が作業ツリーで立って記憶が合流する事。直す前の版は`project_mismatch`になる事）。**本物のClaude Desktopが作業ツリーの後継を取り込む場面は、macOSでは未確認** | 直した。単体試験と、切り離した置き場での本物のhookの命令。Claude Desktopへ移す処理はLinuxでは対象外（Claude Codeの`--desktop`が無い）なので、`unknown`の後継を移す直しは働かない | 直した。単体試験と、切り離した置き場での本物のhookの命令（`CLAUDE_PROJECT_DIR`は`C:/…`の形）。実機で起きたのはこのOS。**直した版での本物の引き継ぎは、次に起きた時に記録で確かめる** |
+| Codex | 変更なし。projectはhookのcwdで決める。引き継ぎの部品も別 | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+## [0.16.18] — 2026-10-11
+
+### 変更
+
+- Codexの`PreCompact(auto)`のhookが`handoff_hook_identity_invalid`で失敗した時、失敗ログ（`~/.throughline/logs/hook-failures.log`）の行へ、渡された合図の形（`identity`）を残す。0.16.14で内部のID（`auto-compact-N`）を失敗から外したが、0.16.16のmacOSの実機で同じ失敗が2回出た（2026-10-10 16:55:08と16:55:15、引き継ぎ先のタスクを作った直後）。内部の圧縮の記録は0行で、0.16.14が想定した形ではなかった。失敗ログには文面と位置しか無く、どの値が不正だったかを決められなかった。
+  - 残すのは、会話のID・ターンのID・agentのID・agentの種類・モデル名・`trigger`と、`transcript_path`・`cwd`が絶対pathかどうか。pathの中身と、記号の混じる値は残さない（長さだけ）。会話の本文は入らない。
+  - 失敗の扱い（圧縮を止める・失敗として数える）は変えていない。原因が決まるまで、この失敗は今までどおり記録される。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex（Desktop） | 足した。単体試験と、切り離した置き場での本物のhookの命令（不正な合図を渡して、失敗ログの行に`identity`が出る事）。**本物のCodex Desktopがこの失敗を起こす場面は、狙って起こせないので未確認。次に起きた行で原因を決める** | 足した。単体試験と、切り離した置き場での本物のhookの命令。実機（同梱0.162.0-alpha.2）では、この失敗が起きていない | 足した。単体試験と、切り離した置き場での本物のhookの命令。実機では、この失敗の記録が無い |
+| Codex（CLI・席） | 自動継続の対象外（Desktop以外は、この検査の前後で何もしない）。対象外の呼び出しがこの検査で失敗した時は、同じ形が残る | 同じ。BellTeamのコンテナとmain-serverは自動継続が無効で、この処理へ入らない | 同じ |
+| Claude Code | 変更なし。この失敗はCodexの`PreCompact`だけが出す。失敗ログの部品は共通だが、`identity`を付けるのはCodexのこの失敗だけ | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+
 ## [0.16.17] — 2026-10-10
 
 ### 修正
@@ -2270,7 +2306,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.17...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.19...HEAD
+[0.16.19]: https://github.com/kitepon/Throughline/compare/v0.16.18...v0.16.19
+[0.16.18]: https://github.com/kitepon/Throughline/compare/v0.16.17...v0.16.18
 [0.16.17]: https://github.com/kitepon/Throughline/compare/v0.16.16...v0.16.17
 [0.16.16]: https://github.com/kitepon/Throughline/compare/v0.16.15...v0.16.16
 [0.16.15]: https://github.com/kitepon/Throughline/compare/v0.16.14...v0.16.15

package/docs/adr/0047-codex-internal-compaction-is-stopped-without-error.md

@@ -38,3 +38,18 @@ Codex は、利用者のターンとは別に、自分で作る内部の文脈
 - 内部の文脈からの圧縮で、失敗の記録が増えなくなる。圧縮を止める動きは変わらない。
 - 内部の文脈からの圧縮が何度も起きるタスクでも、圧縮は通らない。利用者のターンの `PreCompact` が来るまで、文脈はそのまま残る。
 - Codex が内部の ID の形を変えると、また失敗として記録される。その時は記録の message で気づける。
+
+## 追記（2026-10-11）
+
+0.16.16 の macOS の実機で、同じ `handoff_hook_identity_invalid` が2回出た（2026-10-10 16:55:08 と 16:55:15）。どちらも、
+引き継ぎ先のタスクを作った直後（作成の 1.4 秒後と、最初のターンの開始の 1.5 秒後）。`internal-compactions.jsonl` は
+0行だった。この ADR が想定した形（ターンの ID が `auto-compact-N`）の呼び出しではなかった事になる。
+
+- Context に書いた「内部の文脈から `PreCompact(auto)` を呼ぶ」は、Codex の source を読んだ推測で、実機では確かめていない。
+  `next_internal_sub_id` の ID は、`thread/inject_items` の文脈（`new_inject_items_context`）にも使われる。
+- hook へ渡る `transcript_path` は null になり得る（`codex-rs/hooks/src/schema.rs` の `NullableString`）。ターンの中の
+  圧縮は、ターンの ID（UUID）をそのまま渡す（`with_model` は `sub_id` を引き継ぐ）。どの値が不正だったかは、失敗ログに
+  文面と位置しか無く、決められなかった。
+- 0.16.18 で、この失敗の行へ合図の形（`identity`。ID・種類・絶対 path かどうか）を残す。次に起きた行を読んで、
+  扱いを決める。この ADR の Decision 1〜4 は、それまで変えない。
+

package/docs/adr/0049-claude-handoff-uses-registered-project.md

@@ -0,0 +1,49 @@
+# ADR 0049: Claude の引き継ぎは、会話を登録した project で後継を立てる。受領を確かめられなかった後継も Desktop へ移す
+
+日付: 2026-10-11
+
+## Context
+
+Claude Code の自動継続は、PreCompact の hook で、後継を立てる project を決める（ADR 0033）。決め方は、会話が別の project へ
+移っていれば移った先、そうでなければ hook の環境変数 `CLAUDE_PROJECT_DIR`、無ければ hook の cwd だった。後継の最初の指示は、
+前任と後継の project（`sessions.project_path`）が同じ時だけ、前任の記憶を合流させる。`sessions` の行は SessionStart の cwd で作る。
+
+2026-10-11、オーナーから「WindowsのClaudeの自動スルーラインで起動する新セッションってRemoteがONで立ち上がってるの？
+なんか意図した挙動と違う気がする」と指摘があった。Windows の実機（Claude Code 2.1.296）の記録を読んだ。
+
+- 0.16.16 より後の Claude の引き継ぎは5回。5回とも、後継はリモートコントロール付きで立っていた（ADR 0048）。
+  4回は、後継がターンを終えた後に Claude Desktop へ移っていた（ADR 0043）。
+- 1回（10/10 23:43）は、受領を確かめられないまま（`unknown`・`handoff_delivery_unconfirmed`）だった。後継は立って作業を
+  続けていたが、Desktop へ移らず、裏の会話のまま残った。見えるのはリモートコントロールからだけだった。
+- この回の前任は、作業ツリー（`<repository>/.claude/worktrees/<名前>`）で動く後継を、Claude Desktop が取り込んだ会話だった。
+  SessionStart の cwd は作業ツリーで、`sessions` の project も作業ツリーだった。PreCompact の時、`CLAUDE_PROJECT_DIR` は
+  元の repository を指していた。transcript に `relocated` の行は無い。
+- その結果、後継は元の repository（branch は `main`）で立った。前任と project が違うので、記憶は合流しなかった
+  （`merge_skip_reason: project_mismatch`）。合流しないと受領も残らないので、引き継ぎは `unknown` で終わった。
+- Desktop へ移す処理は、受領が残った引き継ぎ（`sent`）の後継だけを対象にしていた。`unknown` の記録には後継の session id が
+  無く、後継の Stop では何も起きなかった。
+
+## Decision
+
+1. PreCompact で後継を立てる project は、次の順で決める。会話が移った先（`relocated`）、会話を登録した project
+   （`sessions.project_path`。その場所が今もある時）、`CLAUDE_PROJECT_DIR`、hook の cwd。
+   印（baton）・有効かどうかの判定・後継を立てる場所は、同じ値を使う。
+2. `sessions` を読むのは、自動圧縮で、自動継続が有効で、まだ引き継ぎの記録が無い時だけ。読めない時と、登録した場所が
+   もう無い時（作業ツリーを消した後）は、今までと同じ値で進める。
+3. 受領を確かめられなかった引き継ぎ（`unknown`、後継の短い ID だけが記録にある）でも、その後継がターンを終えたら、
+   Desktop へ移す。継続の指示は起動時の引数で渡してあるので、ターンを終えた後継は指示を受けている。
+   後継の session id を記録へ入れる。`state` と `error_code` は変えない（記憶が合流しなかった事は、記録に残す）。
+4. 後継が立たなかった引き継ぎ（`failed`）は、今までどおり何もしない。
+
+## Consequences
+
+- 作業ツリーの会話は、Desktop が取り込んだ後に引き継いでも、同じ作業ツリーで続く。記憶も合流する。
+- 何かの理由で受領を確かめられなかった時も、後継は裏の会話のまま残らない。ただし、その後継に前任の記憶が入ったかは
+  別の話で、`unknown` の記録を見て確かめる必要がある。
+- 会話を起動した後で `CLAUDE_PROJECT_DIR` だけが変わる場面では、登録した project が優先される。会話を別の project へ
+  移す場面は、今までどおり `relocated` の行で分かる。
+- Stop の完了受領の project（`turn-processor`）は変えていない。Desktop が取り込んだ作業ツリーの会話の完了受領は、
+  今までどおり `CLAUDE_PROJECT_DIR`（元の repository）へ出る。
+- リモートコントロール付きで立てた後継は、Desktop へ移す時に止める（`claude stop`）。起動時のリモートの接続はそこで切れ、
+  移った後は Claude Desktop 自身のリモートの設定に従う。ここは変えていない。
+- Codex・Grok・Cursor は、hook の cwd で project を決める。この ADR の対象は Claude Code だけ。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -249,6 +249,23 @@ function nativeProjectPath(projectPath, platform) {
   return (platform === 'win32' ? win32 : posix).resolve(projectPath);
 }
 
+/**
+ * その会話を sessions へ登録した project（SessionStart の cwd）。行が無い時、その場所がもう無い時は null。
+ *
+ * 作業ツリーで動く後継を Claude Desktop が取り込むと、hook の CLAUDE_PROJECT_DIR は元の repository を指す
+ * （Windows、Claude Code 2.1.296 で実測）。そこで後継を立てると、後継は別の作業ツリーで始まり、前任と project が
+ * 違うので記憶も合流しない（ADR 0049）。登録した project で立てれば、前任と後継の project がそろう。
+ */
+function registeredProjectPath(db, sessionId, platform) {
+  let registered;
+  // sessions を読めない時は、hook の環境から読んだ project で進める（今までと同じ動き）。
+  try { registered = db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId)?.project_path; }
+  catch { return null; }
+  if (typeof registered !== 'string' || !(posix.isAbsolute(registered) || win32.isAbsolute(registered))) return null;
+  const native = nativeProjectPath(registered, platform);
+  return existsSync(native) ? native : null;
+}
+
 /**
  * PreCompact hook の本体。自動圧縮で、その project が有効な時だけ、印と記録を残して圧縮を止める。
  *
@@ -277,9 +294,15 @@ export function requestClaudeAutoHandoff({
   const existing = readClaudeAutoHandoff(sessionId, dir);
   // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
   // 会話が別の project へ移っている時（Claude Desktop）は、移った先で行う。
-  const projectPath = nativeProjectPath(
-    claudeHostAdapter.completionProjectPath({
-      cwd: payload.cwd ?? process.cwd(), env, transcriptPath: payload.transcript_path }), platform);
+  const relocated = readClaudeRelocatedCwd(payload.transcript_path);
+  const hookProjectPath = nativeProjectPath(
+    relocated ?? claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env }), platform);
+  let db = null;
+  const open = () => (db ??= openDb());
+  // 自動圧縮で、機能が有効な時だけ、会話を登録した project を読む（ADR 0049）。
+  const projectPath = payload.trigger === 'auto' && !existing && config.enabled && !relocated
+    ? registeredProjectPath(open(), sessionId, platform) ?? hookProjectPath
+    : hookProjectPath;
 
   if (payload.trigger !== 'auto') {
     // 人が /compact を選んだ。まだ止めていない記録は取り下げる。
@@ -298,15 +321,14 @@ export function requestClaudeAutoHandoff({
   }
 
   // /tl と同じ印。後継の最初の指示が、この会話を前任として合流させる。
-  const db = openDb();
   // 会話が別の project へ移っている時（Claude Desktop）は、sessions の project も移った先にそろえる。
   // 合流は前任と後継の project が同じ時だけ行う。付け替えは Stop でも行うが、移った後に1回も Stop を
   // 通らないまま引き継ぐ会話があり、その時は後継へ記憶が入らなかった（0.15.2・0.15.3、macOS で実測）。
-  if (readClaudeRelocatedCwd(payload.transcript_path)) {
-    db.prepare('UPDATE sessions SET project_path = ? WHERE session_id = ? AND project_path <> ?')
+  if (relocated) {
+    open().prepare('UPDATE sessions SET project_path = ? WHERE session_id = ? AND project_path <> ?')
       .run(projectPath, sessionId, projectPath);
   }
-  writeBaton(db, { projectPath, sessionId, now });
+  writeBaton(open(), { projectPath, sessionId, now });
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   removeStale(dir, now);
   const handoffId = randomUUID();
@@ -753,10 +775,15 @@ export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHand
   if (!validSessionId(sessionId)) return null;
   // この会話自身が引き継ぎの途中なら、作業は次の後継が続ける。移すのは、最後に作業を終えた後継だけ。
   if (readJson(recordPath(sessionId, dir))) return null;
-  const record = listClaudeAutoHandoffs({ dir }).find(item => item.successor?.session_id === sessionId &&
-    item.state === 'sent' && item.desktop?.wanted && !item.desktop.state);
+  const waiting = listClaudeAutoHandoffs({ dir }).filter(item => item.desktop?.wanted && !item.desktop.state);
+  // 受領を確かめられなかった引き継ぎ（unknown）は、後継の session id が記録に無い。その後継がターンを終えたなら、
+  // 後継は動いている。裏の会話のまま残さず、同じように Desktop へ移す（ADR 0049）。
+  const record = waiting.find(item => item.state === 'sent' && item.successor?.session_id === sessionId) ??
+    waiting.find(item => item.state === 'unknown' && !item.successor?.session_id &&
+      typeof item.successor?.short_id === 'string' && sessionId.startsWith(item.successor.short_id));
   if (!record) return null;
-  updateRecord(record.source_session_id, { desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
+  updateRecord(record.source_session_id, { successor: { ...record.successor, session_id: sessionId },
+    desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
   try { await launch(record.source_session_id, { dir }); }
   catch {
     updateRecord(record.source_session_id, { desktop: { ...record.desktop, state: 'failed', error_code: 'desktop_open_start_failed' } }, { dir });

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

@@ -97,6 +97,37 @@ test('PreCompact: 移っていない会話は、これまでどおり起動し
   assert.equal(result.projectPath, '/work/app');
 }));
 
+test('PreCompact: CLAUDE_PROJECT_DIR が元の repository を指していても、会話を登録した作業ツリーで引き継ぐ（Claude Desktop が取り込んだ後継）', () => withDir(dir => {
+  // 作業ツリーで動く後継を Desktop が取り込むと、hook の cwd は作業ツリー、CLAUDE_PROJECT_DIR は元の repository になる
+  const repo = join(dir, 'repo');
+  const worktree = join(repo, '.claude', 'worktrees', 'core-ui');
+  mkdirSync(worktree, { recursive: true });
+  const registered = () => {
+    const db = makeBatonDb();
+    db.exec('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, project_path TEXT NOT NULL)');
+    db.prepare('INSERT INTO sessions VALUES (?, ?)').run(SESSION, worktree);
+    return db;
+  };
+  const adopted = { env: { CLAUDE_PROJECT_DIR: repo }, payload: { cwd: worktree }, platform: process.platform };
+
+  const { result, db } = request(dir, { db: registered(), ...adopted });
+  assert.equal(result.status, 'requested');
+  assert.equal(result.projectPath, worktree, '後継は、前任が動いていた作業ツリーで立てる');
+  assert.equal(readClaudeAutoHandoff(SESSION, dir).project_path, worktree);
+  assert.equal(db.prepare('SELECT session_id FROM handoff_batons WHERE project_path = ?').get(worktree).session_id, SESSION,
+    '印も作業ツリーに書く。後継は同じ project の前任だけを合流させる');
+
+  // 有効かどうかも、登録した project で決める
+  rmSync(join(dir, `${SESSION}.json`));
+  assert.equal(request(dir, { db: registered(), ...adopted, config: { enabled: true, projects: [repo] } }).result.reason, 'auto_handoff_disabled');
+  assert.equal(request(dir, { db: registered(), ...adopted, config: { enabled: true, projects: [worktree] } }).result.status, 'requested');
+
+  // 登録した場所がもう無い時（作業ツリーを消した後）は、hook の環境から読んだ project で進める
+  rmSync(join(dir, `${SESSION}.json`));
+  rmSync(worktree, { recursive: true });
+  assert.equal(request(dir, { db: registered(), ...adopted }).result.projectPath, repo);
+}));
+
 test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して圧縮を止める', () => withDir(dir => {
   const { result, db } = request(dir);
   assert.equal(result.status, 'requested');
@@ -725,8 +756,8 @@ test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null);
   writeRecord(dir, SESSION, { desktop: { wanted: false, state: null } });
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '端末から始めた会話の後継は移さない');
-  writeRecord(dir, SESSION, { state: 'unknown' });
-  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '受領を確かめられていない後継は移さない');
+  writeRecord(dir, SESSION, { state: 'failed', error_code: 'handoff_successor_launch_failed', successor: null });
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '後継が立たなかった引き継ぎでは動かない');
   // 対象の後継
   writeRecord(dir, SESSION, {});
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SESSION, dir, launch }), null, '旧い会話自身の Stop では動かない');
@@ -748,6 +779,32 @@ test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、
   assert.deepEqual([readClaudeAutoHandoff(SESSION, dir).desktop.state, readClaudeAutoHandoff(SESSION, dir).desktop.error_code], ['failed', 'desktop_open_start_failed']);
 }));
 
+test('Stop: 受領を確かめられなかった引き継ぎ（unknown）でも、その後継がターンを終えたら Desktop へ移す', () => withDir(async dir => {
+  const launched = [];
+  const launch = async (id) => { launched.push(id); };
+  // worker は、後継の最初の指示の受領を待ち切れなかった。記録にあるのは後継の短い ID だけ
+  const unconfirmed = { state: 'unknown', error_code: 'handoff_delivery_unconfirmed', accepted_at: null,
+    successor: { short_id: SUCCESSOR.slice(0, 8), session_id: null } };
+  writeRecord(dir, SESSION, unconfirmed);
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: 'bbbbbbbb-0000-4000-8000-000000000002', dir, launch }), null, '別の会話の Stop では動かない');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), `h-${SESSION}`);
+  assert.deepEqual(launched, [SESSION]);
+  const record = readClaudeAutoHandoff(SESSION, dir);
+  assert.deepEqual(record.successor, { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR }, '移す process が使う後継の ID を記録へ入れる');
+  assert.deepEqual([record.state, record.error_code, record.desktop.state], ['unknown', 'handoff_delivery_unconfirmed', 'requested'],
+    '受領を確かめられなかった事は、記録に残したままにする');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '2回目の Stop では起動しない');
+
+  // 移す process は、その記録で後継を止めて Desktop で開く
+  const calls = [];
+  const opened = await runClaudeDesktopOpen(SESSION, { dir, env: {}, pollMs: 10, idleTimeoutMs: 500,
+    spawn: (command, args) => { calls.push(args.slice(0, 2).join(' '));
+      return args[0] === 'agents' ? { status: 0, stdout: JSON.stringify([{ id: SUCCESSOR.slice(0, 8), kind: 'background', status: 'idle' }]) } : { status: 0, stdout: '' }; },
+    pty: (command, args) => { calls.push(args.join(' ')); return { status: 0, stdout: `Opening session ${SUCCESSOR} in Claude Desktop` }; } });
+  assert.deepEqual(calls, ['agents --json', `stop ${SUCCESSOR.slice(0, 8)}`, `--desktop --resume ${SUCCESSOR}`]);
+  assert.deepEqual([opened.state, opened.desktop.state], ['unknown', 'opened']);
+}));
+
 test('Desktop で開く: 後継が手すきになるのを待って止め、擬似端末の中で claude --desktop --resume を呼ぶ', () => withDir(async dir => {
   const shortId = SUCCESSOR.slice(0, 8);
   const run = async ({ statuses, stopStatus = 0, opened, beforePoll = () => {} }) => {
@@ -1008,6 +1065,55 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.deepEqual([merged.triggered_path, merged.injection.auto_handoff_id], ['baton', record.handoff_id]);
 }));
 
+test('hook: 作業ツリーの後継を Claude Desktop が取り込んだ後（CLAUDE_PROJECT_DIR は元の repository）に引き継いでも、後継は作業ツリーで立ち、記憶が入る', () => withDir(async home => {
+  // fox（Windows、Claude Code 2.1.296）で 2026-10-10 に起きた形。SessionStart の cwd は作業ツリー、
+  // PreCompact の時の CLAUDE_PROJECT_DIR は元の repository だった。
+  const repo = join(home, 'repo');
+  const worktree = join(repo, '.claude', 'worktrees', 'core-ui');
+  mkdirSync(worktree, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  const adopted = { ...fakeClaudePath(home), CLAUDE_PROJECT_DIR: repo, CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' };
+  const hook = (command, payload) =>
+    cli(home, [command], JSON.stringify({ session_id: SESSION, cwd: worktree, transcript_path: transcriptPath, ...payload }), adopted);
+
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'resume' }).status, 0);
+  writeFileSync(transcriptPath, jsonl([
+    { ...user('画面の余白を直して', '2026-10-10T14:40:00Z'), entrypoint: 'claude-desktop', cwd: worktree },
+    assistant('余白を直します。', '2026-10-10T14:40:02Z'),
+    toolUse('toolu_9', 'Read', { file_path: join(worktree, 'ui.css') }),
+  ]));
+
+  const pre = hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' });
+  assert.equal(pre.status, 2, pre.stderr);
+  const stopped = hook('pre-tool-use', { hook_event_name: 'PreToolUse', tool_name: 'Read', tool_use_id: 'toolu_9', permission_mode: 'auto' });
+  assert.equal(JSON.parse(stopped.stdout).continue, false);
+  const status = () => JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).handoffs;
+  let handoff;
+  for (let i = 0; i < 100 && (handoff = status()[0]).state !== 'failed'; i++) await new Promise(r => setTimeout(r, 100));
+  assert.equal(handoff.error_code, 'handoff_successor_launch_failed', '偽の claude で止まる。本物は起動しない');
+  assert.equal(handoff.project_path, worktree, '後継を立てる場所は、前任が動いていた作業ツリー');
+
+  // 後継は作業ツリーで立ち、最初の指示（起動時に渡された継続の指示）を受ける
+  const recordFile = join(home, '.throughline', 'claude-auto-handoff', `${SESSION}.json`);
+  const record = JSON.parse(readFileSync(recordFile, 'utf8'));
+  writeFileSync(recordFile, JSON.stringify({ ...record, state: 'launching', error_code: null }));
+  const successorPayload = { session_id: SUCCESSOR, cwd: record.project_path, hook_event_name: 'SessionStart', source: 'startup' };
+  assert.equal(cli(home, ['session-start'], JSON.stringify(successorPayload), fakeClaudePath(home)).status, 0);
+  const first = cli(home, ['prompt-submit'], JSON.stringify({ ...successorPayload, hook_event_name: 'UserPromptSubmit',
+    prompt: claudeContinuationInput(record) }), fakeClaudePath(home));
+  assert.equal(first.status, 0, first.stderr);
+  assert.match(first.stdout, /^## Throughline: 自動継続の文脈\n/);
+  assert.match(first.stdout, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 画面の余白を直して\n/);
+  assert.equal(existsSync(join(home, '.throughline', 'claude-auto-handoff', `${SESSION}.accepted`)), true, '最初の指示が受領を残す');
+
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  assert.equal(db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get(SESSION).merged_into, SUCCESSOR);
+  db.close();
+  const decisions = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(JSON.parse);
+  assert.deepEqual(decisions.filter(entry => entry.phase === 'prompt-submit').map(entry => [entry.merged, entry.merge_skip_reason ?? null]), [[true, null]]);
+}));
+
 test('hook: 別の project へ移した会話（Claude Desktop）を、移った後に1回も Stop を通らないまま引き継いでも、後継へ記憶が入る', () => withDir(async home => {
   // Desktop は「フォルダなし」で始めた会話を project へ移す。SessionStart は移る前の場所で呼ばれ、
   // CLAUDE_PROJECT_DIR は移った後も移る前の場所のまま届く。

package/src/codex-auto-handoff.mjs

@@ -106,6 +106,26 @@ function openSuccessor(operation) {
 // Codex が内部の文脈へ付けるターンの ID（`codex-rs/core/src/session/mod.rs` の `next_internal_sub_id`）。
 const INTERNAL_COMPACTION_TURN_ID_PATTERN = /^auto-compact-\d+$/;
 
+const SAFE_IDENTITY_TEXT_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
+const identityText = value => typeof value !== 'string' ? (value === null ? 'null' : typeof value)
+  : SAFE_IDENTITY_TEXT_PATTERN.test(value) ? value : `text(${value.length})`;
+const identityPath = value => typeof value !== 'string' ? (value === null ? 'null' : typeof value)
+  : isAbsolute(value) ? 'absolute' : `relative(${value.length})`;
+
+/**
+ * 引き継ぎの起点にできなかった合図の形。失敗ログへ残して、どの値が不正だったかを後から読めるようにする
+ * （2026-10-10、macOS で `handoff_hook_identity_invalid` が5回出たが、ログに形が無く原因を決められなかった）。
+ * ID・モデル名・種類だけを残す。path は絶対かどうかだけ。記号の混じる値は長さだけ。会話の本文は入らない。
+ */
+export function hookIdentityShape(payload = {}) {
+  return {
+    session_id: identityText(payload.session_id), turn_id: identityText(payload.turn_id),
+    transcript_path: identityPath(payload.transcript_path), cwd: identityPath(payload.cwd),
+    agent_id: identityText(payload.agent_id), agent_type: identityText(payload.agent_type),
+    model: identityText(payload.model), trigger: identityText(payload.trigger),
+  };
+}
+
 /** ターンの外の自動圧縮を止めた記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
 function recordInternalCompactionStop(entry) {
   mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
@@ -179,7 +199,9 @@ export async function requestCodexAutoHandoff({ payload, db = null,
     return { status: 'ok', inserted: false, internalCompaction: true, continue: false,
       stopReason: 'Throughlineが、ターンの外の自動圧縮を止めました。文脈が上限に近づいたターンで、新しいタスクへ引き継ぎます。' };
   }
-  if (!located || !CODEX_NATIVE_ID_PATTERN.test(turnId ?? '')) throw error('handoff_hook_identity_invalid');
+  if (!located || !CODEX_NATIVE_ID_PATTERN.test(turnId ?? '')) {
+    throw Object.assign(error('handoff_hook_identity_invalid'), { hookIdentity: hookIdentityShape(payload) });
+  }
   // JS実装のrealpathは、WindowsのCodex Desktopが起動したhookの中で `EISDIR: lstat 'C:'` で落ちる。OSのrealpathを使う。
   const rolloutPath = realpathSync.native(payload.transcript_path);
   const state = readCodexHandoffState(rolloutPath, { threadId, turnId });

package/src/codex-auto-handoff.test.mjs

@@ -15,7 +15,7 @@ import { readCodexHandoffState, settingsMatch, threadStartSettings, resolvePrepa
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
   autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor,
   markAutoHandoffSource, markAutoHandoffSources, autoHandoffSourceFallbackTitle, carryAutoHandoffQueue,
-  untrackedInheritedMemory, resolveAutoHandoffSuccessor } from './codex-auto-handoff.mjs';
+  untrackedInheritedMemory, resolveAutoHandoffSuccessor, hookIdentityShape } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -364,6 +364,16 @@ test('Codexの内部の文脈（auto-compact-N）からの圧縮は、例外に
     await assert.rejects(requestCodexAutoHandoff({ ...args, payload: { ...payload, ...broken } }), /handoff_hook_identity_invalid/);
   }
   assert.equal(recorded.length, 1);
+
+  // 失敗には、どの値が不正だったかの形を付ける。path と記号の混じる値は、中身を残さない
+  const shaped = await requestCodexAutoHandoff({ ...args, payload: { ...payload, turn_id: 'something else', transcript_path: null,
+    agent_type: 'reviewer', model: 'gpt-5.5' } }).catch(error => error);
+  assert.equal(shaped.code, 'handoff_hook_identity_invalid');
+  assert.deepEqual(shaped.hookIdentity, { session_id: thread, turn_id: 'text(14)', transcript_path: 'null', cwd: 'absolute',
+    agent_id: 'undefined', agent_type: 'reviewer', model: 'gpt-5.5', trigger: 'auto' });
+  assert.deepEqual(hookIdentityShape({ session_id: thread, turn_id: 'auto-compact-', transcript_path: 'relative/rollout.jsonl', cwd: 7 }),
+    { session_id: thread, turn_id: 'auto-compact-', transcript_path: 'relative(22)', cwd: 'number',
+      agent_id: 'undefined', agent_type: 'undefined', model: 'undefined', trigger: 'undefined' });
 }));
 
 test('PreCompactの入口は、JS実装のrealpathが使えない環境（WindowsのCodex Desktopのhook）でも引き継ぎを作る', async () => withDb(async (db, home) => {

package/src/hook-failure-log.mjs

@@ -62,6 +62,13 @@ export function logHookFailure(code, error, { home, now = Date.now(), stderr = p
   if (typeof context?.transcript_path === 'string' && context.transcript_path) {
     entry.transcript_path = context.transcript_path;
   }
+  // 不正な合図の形（errorが `hookIdentity` を持つ時）。文面が同じ失敗でも、どの値が不正だったかを残す。
+  // 値は呼び出し側が ID・種類・「絶対 path かどうか」へ直してある。ここでは短い文字列だけを通す。
+  const identity = error?.hookIdentity;
+  if (identity && typeof identity === 'object') {
+    const kept = Object.entries(identity).filter(([, value]) => typeof value === 'string' && value.length <= 80);
+    if (kept.length > 0) entry.identity = Object.fromEntries(kept);
+  }
   // 外部 CLI の失敗は、message が終了 code だけになる。理由（reason）と CLI の stderr の末尾も残す
   // （CLI は先頭に起動情報を出し、失敗の理由は末尾に出す）。
   if (typeof error?.reason === 'string' && error.reason) entry.reason = error.reason;

package/src/hook-failure-log.test.mjs

@@ -50,6 +50,22 @@ test('logHookFailureは、外部CLIの失敗の理由とstderrの末尾を残す
   }
 });
 
+test('logHookFailureは、不正な合図の形を残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    const shaped = new Error('handoff_hook_identity_invalid');
+    shaped.hookIdentity = { turn_id: 'auto-compact-', transcript_path: 'null', cwd: 'absolute', long: 'x'.repeat(81), count: 3 };
+    logHookFailure('HOOK_CODEX_FAILED', shaped, { home });
+    logHookFailure('HOOK_CODEX_FAILED', new Error('plain'), { home });
+    const [first, second] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    // 短い文字列だけを通す（長い値と文字列でない値は落とす）。
+    assert.deepEqual(first.identity, { turn_id: 'auto-compact-', transcript_path: 'null', cwd: 'absolute' });
+    assert.equal('identity' in second, false);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('logHookFailureは、どの会話の失敗かを残す', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
   try {