throughline 0.16.13 → 0.16.15

package/CHANGELOG.md

@@ -10,6 +10,50 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.15] — 2026-10-10
+
+### 追加
+
+- `throughline auto-handoff successor --thread <Codexの会話のID> --json`。あるCodexのタスクの「今の続き」を返す、読むだけの入口。ほかの製品が、旧タスクあての連絡を今の続きへ渡す時に使う。`auto-handoff status --json`は新しい20件だけを返すので、古い引き継ぎの続きを引けなかった。
+  - 返す物: `handed_off`（残っている後継があるか）、`current_thread_id`（引き継ぎを先までたどった、残っている一番先の後継。無ければ渡したID自身）、`chain`（そこまでの引き継ぎ）、`pending`（今の続きのタスクで、後継へ指示を送る前の引き継ぎ。`in_flight`がtrueならworkerが動いている最中、falseなら止まっていて`error_code`と`resume_state`が入る）。
+  - 消された後継とアーカイブ済みの後継は、無い物として扱う（旧タスクへ入力が来た時に開く後継と同じ決め方）。
+  - 記録が無い端末では、引き継ぎが1つも無い時と同じ答えを返す。記録は読み取り専用で開く。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex（Desktop） | 追加した。実機の記録で確認（引き継ぎ済みのタスク2つから今の続きが返り、引き継ぎの無いタスクは自分自身が返った） | 追加した。実機の記録で確認（後継がアーカイブ済みの系列は、旧タスク自身が返った） | 追加した。実機の記録で確認（16本続いた系列の最初と途中から、同じ今の続きが返った。止まったタスクは`pending`に理由が出た） |
+| Claude Code | 対象外。Claude Codeの自動継続の記録は別の形で、`auto-handoff status --host claude --json`が全件を返す | 同じ | 同じ |
+| Grok | 対象外。自動継続の機能が無い | 同じ | 同じ |
+| Cursor | 対象外。自動継続の機能が無い | 同じ | 同じ |
+
+### 変わらない事
+
+- 引き継ぎの動き。`auto-handoff status --json`の出力。
+
+## [0.16.14] — 2026-10-10
+
+### 修正
+
+- Codex Desktop（同梱のCodex 0.162.0-alpha.17.2）が、内部の文脈（ターンのIDが`auto-compact-N`）から`PreCompact(auto)`のhookを呼ぶ時、Throughlineが`handoff_hook_identity_invalid`の失敗として記録していた。macOSの実機で3回。圧縮は止まっていて、タスクにも影響は無かったが、起きていない失敗がhighで記録された。この形の呼び出しは、失敗にせず圧縮だけを止め、`~/.throughline/codex-auto-handoff/internal-compactions.jsonl`に1行残す（[ADR 0047](docs/adr/0047-codex-internal-compaction-is-stopped-without-error.md)）。
+  - 圧縮を止める動きは今までと同じ。引き継ぎは、文脈が上限に近づいた利用者のターンで今までどおり起きる。
+  - それ以外の不正なID（会話のIDがUUIDでない、記録の場所が無い、知らない形のターンのID）は、今までどおり失敗として記録する。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex（Desktop） | 直した。単体試験と、切り離した置き場での本物のhookの命令で確認（内部のIDは失敗0件・記録1行、不正なIDは失敗1件）。CIのmacOSも成功。**本物のCodex Desktopが内部の文脈からhookを呼ぶ場面は、狙って起こせないので未確認** | 直した。単体試験とCI。実機（同梱0.162.0-alpha.2）では、この呼び出しが起きていない | 直した。単体試験とCI。実機では、この失敗の記録が無い |
+| Claude Code | 対象外。Claude Codeの`PreCompact`は別の実装で、ターンのIDを検査しない | 同じ | 同じ |
+| Grok | 対象外。自動継続の機能が無く、`PreCompact`のhookを登録していない | 同じ | 同じ |
+| Cursor | 対象外。自動継続の機能が無く、`PreCompact`のhookを登録していない | 同じ | 同じ |
+
+### 確認していない範囲
+
+- 本物のCodex Desktopが内部の文脈からhookを呼ぶ場面での、新しい版の動き（次に起きた時に、失敗の記録が増えず、`internal-compactions.jsonl`に行が出る事で確かめる）。
+- 内部の文脈からの圧縮が、Codexのどの処理から始まるか（公開ソースでIDの形と渡り方だけを確かめた）。
+
 ## [0.16.13] — 2026-10-10
 
 ### 修正
@@ -2173,7 +2217,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.13...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.15...HEAD
+[0.16.15]: https://github.com/kitepon/Throughline/compare/v0.16.14...v0.16.15
+[0.16.14]: https://github.com/kitepon/Throughline/compare/v0.16.13...v0.16.14
 [0.16.13]: https://github.com/kitepon/Throughline/compare/v0.16.12...v0.16.13
 [0.16.12]: https://github.com/kitepon/Throughline/compare/v0.16.11...v0.16.12
 [0.16.11]: https://github.com/kitepon/Throughline/compare/v0.16.10...v0.16.11

package/README.ja.md

@@ -40,6 +40,14 @@ throughline auto-handoff status --operation <handoff-id> --json
 throughline auto-handoff resume --operation <handoff-id> --json
 ```
 
+あるタスクの今の続きは、次の命令で引けます（読むだけ。ほかの道具が、旧タスクあての連絡を今の続きへ渡す時に使います）。
+
+```bash
+throughline auto-handoff successor --thread <codex-thread-id> --json
+```
+
+`current_thread_id`が今の続きです（後継が無ければ渡したID自身）。`pending.in_flight`がtrueの間は、引き継ぎの途中です。
+
 原因を解消した後の`resume`は同じ引き継ぎと既知の後継を再利用します。配送後の結果不明は実際の入力・開始を観測した場合だけ回復し、作成結果が不明な後継は再作成しません。従来の手動`$throughline`とcurrent-thread実験の設定は独立しています。
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)、[Windowsの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-windows-codex-auto-handoff.md)、[Linuxの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-linux-codex-auto-handoff.md)を参照してください。

package/README.md

@@ -39,6 +39,14 @@ throughline auto-handoff status --operation <handoff-id> --json
 throughline auto-handoff resume --operation <handoff-id> --json
 ```
 
+あるタスクの今の続きは、次の命令で引けます（読むだけ。ほかの道具が、旧タスクあての連絡を今の続きへ渡す時に使います）。
+
+```bash
+throughline auto-handoff successor --thread <codex-thread-id> --json
+```
+
+`current_thread_id`が今の続きです（後継が無ければ渡したID自身）。`pending.in_flight`がtrueの間は、引き継ぎの途中です。
+
 原因を解消した後の`resume`は同じ引き継ぎと既知の後継を再利用します。配送後の結果不明は実際の入力・開始を観測した場合だけ回復し、作成結果が不明な後継は再作成しません。従来の手動`$throughline`とcurrent-thread実験の設定は独立しています。
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)、[Windowsの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-windows-codex-auto-handoff.md)、[Linuxの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-linux-codex-auto-handoff.md)を参照してください。

package/bin/throughline.mjs

@@ -412,6 +412,8 @@ Usage:
                               引き継ぎの状態と固定理由を確認
   throughline auto-handoff resume --operation <id> --json
                               同じ引き継ぎを再開（結果不明は再送しない）
+  throughline auto-handoff successor --thread <codex-thread-id> --json
+                              あるCodexのタスクの今の続きを返す（読むだけ）
   throughline auto-handoff mark-sources [--dry-run] [--json]
                               今までの引き継ぎの名前を付け直す（旧タスクへ印、
                               名前の無い後継へ名前）

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

@@ -0,0 +1,40 @@
+# ADR 0047: Codex の内部の文脈からの自動圧縮は、失敗にせず止める
+
+日付: 2026-10-10
+
+## Context
+
+Codex Desktop の自動継続は、`PreCompact(auto)` の hook が受け取った会話の ID とターンの ID が UUID の形でない時、
+`handoff_hook_identity_invalid` の例外にしていた。例外になった hook は、失敗の記録（`HOOK_CODEX_FAILED`、high）を残し、
+`continue: false` を返して圧縮を止める。
+
+2026-10-10、macOS の実機（Codex Desktop 26.1007、同梱の Codex 0.162.0-alpha.17.2）で、この失敗が3回記録された。
+
+- 13:04:46: 引き継ぎのためにターンを止めた 2.5 秒後。
+- 13:24:01: 別のタスクのターンが始まった 3.3 秒後。
+- 13:25:25: そのタスクを引き継ぎのために止めた 4.7 秒後。
+
+Codex は、利用者のターンとは別に、自分で作る内部の文脈を持つ。その文脈のターンの ID は `auto-compact-N` の形になる
+（`codex-rs/core/src/session/mod.rs` の `next_internal_sub_id`）。`PreCompact` の hook へ渡るターンの ID は、その時の文脈の ID
+（`codex-rs/core/src/hook_runtime.rs` の `run_pre_compact_hooks`）なので、内部の文脈から圧縮が始まると、UUID でない ID が届く。
+同梱の Codex が 0.162.0-alpha.2 の端末（Linux）では、この呼び出しは起きていない。
+
+3回とも、hook は圧縮を止めていた。2つのタスクの rollout に圧縮の行は無く、使用量も減っていない。13:24:01 に止めた後、
+ターンはそのまま進み、80 秒後の `PreCompact`（利用者のターンの ID）で引き継いで `continued` になった。
+起きていた害は、起きていない失敗が high で記録された事だった。
+
+## Decision
+
+1. 会話の ID と記録の場所が正しく、ターンの ID が `auto-compact-<数字>` の形の `PreCompact(auto)` は、失敗にしない。
+   `continue: false` を返して圧縮を止める（今までと同じ結果）。失敗の記録は残さない。
+2. その時に引き継ぎは作らない。内部の文脈は利用者のターンではなく、止める所と続ける作業が決まらない。文脈を残しておけば、
+   文脈が上限に近づいた利用者のターンの `PreCompact` で、今までどおり引き継ぐ。
+3. 止めた事を `~/.throughline/codex-auto-handoff/internal-compactions.jsonl` に1行残す（時刻・会話の ID・ターンの ID）。
+4. それ以外の形（会話の ID が UUID でない、記録の場所が無い、ターンの ID が知らない形）は、今までどおり
+   `handoff_hook_identity_invalid` の失敗にする。
+
+## Consequences
+
+- 内部の文脈からの圧縮で、失敗の記録が増えなくなる。圧縮を止める動きは変わらない。
+- 内部の文脈からの圧縮が何度も起きるタスクでも、圧縮は通らない。利用者のターンの `PreCompact` が来るまで、文脈はそのまま残る。
+- Codex が内部の ID の形を変えると、また失敗として記録される。その時は記録の message で気づける。

package/package.json

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

package/src/cli/auto-handoff.mjs

@@ -5,7 +5,7 @@ import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
-import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources } from '../codex-auto-handoff.mjs';
+import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor } from '../codex-auto-handoff.mjs';
 import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaudeAutoHandoffHooks,
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
@@ -17,17 +17,17 @@ import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWo
 const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open'];
 
 export function parseAutoHandoffArgs(args) {
-  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false, dryRun: false };
-  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources'].includes(out.action)) throw Error('auto_handoff_action_invalid');
+  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, thread: null, json: false, dryRun: false };
+  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor'].includes(out.action)) throw Error('auto_handoff_action_invalid');
   const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
-    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
+    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], successor: ['thread'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
   const seen = new Set();
   for (let i = 1; i < args.length; i++) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
     seen.add(args[i]);
     if (args[i] === '--json') { out.json = true; continue; }
     if (args[i] === '--dry-run' && out.action === 'mark-sources') { out.dryRun = true; continue; }
-    const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database' }[args[i]];
+    const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database', '--thread': 'thread' }[args[i]];
     if (!key || !allowed.includes(key) || !args[i + 1] || args[i + 1].startsWith('--')) throw Error('auto_handoff_argument_invalid');
     out[key] = args[++i];
   }
@@ -36,6 +36,7 @@ export function parseAutoHandoffArgs(args) {
   if (out.project && !isAbsolute(out.project)) out.project = resolve(out.project);
   if (out.project && out.operation) throw Error('auto_handoff_argument_invalid');
   if (['worker', 'resume', 'detail', 'desktop-open'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
+  if (out.action === 'successor' && !out.thread) throw Error('auto_handoff_thread_required');
   if (out.action === 'detail') {
     out.turn = Number(out.turn);
     if (!out.origin || !Number.isSafeInteger(out.turn) || out.turn < 1) throw Error('auto_handoff_detail_identity_required');
@@ -128,6 +129,14 @@ export async function run(args = []) {
       finally { db.close(); }
       process.stdout.write(parsed.json ? JSON.stringify({ status: 'ok', text }) + '\n' : text + '\n');
       return 0;
+    } else if (parsed.action === 'successor') {
+      // あるタスクの今の続きを返す。読むだけ。DB がまだ無い端末では、引き継ぎが1つも無いのと同じ答えにする。
+      const db = existsSync(DB_PATH) ? openReadOnlyDb() : null;
+      try {
+        if (db && db.prepare('PRAGMA user_version').get().user_version !== CURRENT_VERSION) throw Error('auto_handoff_schema_mismatch');
+        result = { schema: 'throughline.codex_auto_handoff_successor.v1', ...(db ? resolveAutoHandoffSuccessor(db, parsed.thread)
+          : { thread_id: parsed.thread, handed_off: false, current_thread_id: parsed.thread, chain: [], pending: null }) };
+      } finally { db?.close(); }
     } else if (parsed.action === 'mark-sources') {
       // 0.16.9 までの版が引き継いだ分の名前を付け直す（名前の無い後継へ名前、旧タスクへ引き継ぎ済みの印）。何度流しても同じ結果になる。
       const db = getDb();

package/src/codex-auto-handoff.mjs

@@ -103,6 +103,15 @@ function openSuccessor(operation) {
   return !result.error && result.status === 0;
 }
 
+// Codex が内部の文脈へ付けるターンの ID（`codex-rs/core/src/session/mod.rs` の `next_internal_sub_id`）。
+const INTERNAL_COMPACTION_TURN_ID_PATTERN = /^auto-compact-\d+$/;
+
+/** ターンの外の自動圧縮を止めた記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
+function recordInternalCompactionStop(entry) {
+  mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+  appendFileSync(join(stateRoot(), 'internal-compactions.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
 /** 引き継ぎ済みの旧タスクを止めた記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
 function recordAutoHandoffRedirect(entry) {
   mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
@@ -157,13 +166,20 @@ function settleUndeliveredAutoHandoff(db, threadId, { rolloutPath, processes, re
 export async function requestCodexAutoHandoff({ payload, db = null,
   config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
   findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect,
+  recordInternalCompaction = recordInternalCompactionStop,
   processes = readRuntimeProcesses, readTarget = targetState, now = Date.now() } = {}) {
   if (payload.trigger !== 'auto' || !autoHandoffEnabledFor(config, payload.cwd)) return { status: 'skipped' };
   const threadId = payload.session_id, turnId = payload.turn_id;
-  if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '') || !CODEX_NATIVE_ID_PATTERN.test(turnId ?? '') ||
-      typeof payload.transcript_path !== 'string' || !isAbsolute(payload.transcript_path) || !isAbsolute(payload.cwd ?? '')) {
-    throw error('handoff_hook_identity_invalid');
+  const located = CODEX_NATIVE_ID_PATTERN.test(threadId ?? '') &&
+    typeof payload.transcript_path === 'string' && isAbsolute(payload.transcript_path) && isAbsolute(payload.cwd ?? '');
+  // Codex が自分で作った内部の文脈（ターンの ID が `auto-compact-N`）からの圧縮。利用者のターンではないので、
+  // 引き継ぎの起点にできない。例外にせず圧縮だけを止める（文脈を残せば、次の利用者のターンの圧縮の合図で引き継げる）。
+  if (located && INTERNAL_COMPACTION_TURN_ID_PATTERN.test(turnId ?? '')) {
+    recordInternalCompaction({ at: new Date(now).toISOString(), thread_id: threadId, turn_id: turnId });
+    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');
   // JS実装のrealpathは、WindowsのCodex Desktopが起動したhookの中で `EISDIR: lstat 'C:'` で落ちる。OSのrealpathを使う。
   const rolloutPath = realpathSync.native(payload.transcript_path);
   const state = readCodexHandoffState(rolloutPath, { threadId, turnId });
@@ -285,6 +301,39 @@ export async function nameAutoHandoffTarget(request, targetId, name) {
   }
 }
 
+/**
+ * あるタスクの「今の続き」を引く（ほかの製品が、旧タスクあての連絡を今の続きへ渡すための入口）。読むだけ。
+ * 引き継ぎを先までたどり、残っている一番先の後継を返す。消された後継は無い物として扱う。
+ * @returns {{
+ *   thread_id: string, handed_off: boolean, current_thread_id: string,
+ *   chain: Array<{handoff_id: string, source_thread_id: string, target_thread_id: string, state: string, created_at: number, updated_at: number}>,
+ *   pending: null | {handoff_id: string, source_thread_id: string, state: string, error_code: string|null, resume_state: string|null,
+ *     in_flight: boolean, created_at: number, updated_at: number}
+ * }} current_thread_id は、後継が無ければ thread_id 自身。pending は、今の続きのタスクで、後継へ指示を送る前の引き継ぎ
+ *   （一番新しい1つ）。in_flight が true なら worker が動いている最中、false なら止まっている（error_code と resume_state を見る）。
+ */
+export function resolveAutoHandoffSuccessor(db, threadId, { findThread = findCodexThreadCandidate,
+  processes = readRuntimeProcesses, now = Date.now() } = {}) {
+  if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '')) throw error('handoff_thread_id_invalid');
+  // 残っている一番先の後継（旧タスクへ入力が来た時に開く物と同じ）。そこから threadId まで、作った引き継ぎをさかのぼる。
+  const leaf = findLiveAutoHandoffSuccessor(db, threadId, { findThread });
+  const path = [];
+  for (let operation = leaf, depth = 0; operation && depth < 200; depth++) {
+    path.unshift(operation);
+    if (operation.source_thread_id === threadId) break;
+    operation = findAutoHandoffForTarget(db, operation.source_thread_id);
+  }
+  const chain = path.map(operation => ({ handoff_id: operation.handoff_id, source_thread_id: operation.source_thread_id,
+    target_thread_id: operation.target_thread_id, state: operation.state, created_at: operation.created_at, updated_at: operation.updated_at }));
+  const current = leaf ? leaf.target_thread_id : threadId;
+  const undelivered = listUndeliveredAutoHandoffsForSource(db, current)[0] ?? null;
+  const pending = undelivered ? { handoff_id: undelivered.handoff_id, source_thread_id: undelivered.source_thread_id,
+    state: undelivered.state, error_code: undelivered.error_code ?? null, resume_state: undelivered.resume_state ?? null,
+    in_flight: !HANDOFF_TERMINAL_STATES.has(undelivered.state) && workerActive(undelivered, processes, now),
+    created_at: undelivered.created_at, updated_at: undelivered.updated_at } : null;
+  return { thread_id: threadId, handed_off: chain.length > 0, current_thread_id: current, chain, pending };
+}
+
 /**
  * 引き継ぎが済んだ旧タスクの名前の頭へ、引き継ぎ済みの印を付ける。同じ名前の後継が一覧に並んでも、
  * 印の無い1本が今の続きだと分かるようにする。今の名前を読んでから付けるので、利用者が付け直した名前も残る。

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 } from './codex-auto-handoff.mjs';
+  untrackedInheritedMemory, resolveAutoHandoffSuccessor } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -287,6 +287,85 @@ test('PreCompactの重複ではworkerを増やさず、manualと別projectでは
   assert.equal((await requestCodexAutoHandoff({ ...args, config: { ...config, projects: ['/other'] } })).status, 'skipped');
 }));
 
+test('タスクの今の続きを引く。先までたどり、消えた後継は無い物として扱い、途中の引き継ぎと止まった引き継ぎを見分ける', async () => withDb(async db => {
+  const id = n => `${String(n).repeat(8)}-${String(n).repeat(4)}-${String(n).repeat(4)}-${String(n).repeat(4)}-${String(n).repeat(12)}`;
+  const [A, B, C, D, X, Y, Z] = [1, 2, 3, 4, 5, 6, 7].map(id);
+  const done = (source, target) => updateAutoHandoff(db, request(db, source).operation.handoff_id,
+    { state: 'continued', target_thread_id: target, queued_submission_id: `receipt-${target}` }).operation;
+  const gone = new Set();
+  const options = { findThread: ({ threadId }) => gone.has(threadId) ? null : { rolloutPath: `/r/${threadId}`, mtimeMs: 1 }, processes: () => [], now: 1_000_000 };
+  // 引き継ぎの無いタスクは、自分が今の続き
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, X, options), { thread_id: X, handed_off: false, current_thread_id: X, chain: [], pending: null });
+
+  const ab = done(A, B); const bc = done(B, C);
+  const fromA = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(fromA.handed_off, true); assert.equal(fromA.current_thread_id, C); assert.equal(fromA.pending, null);
+  assert.deepEqual(fromA.chain.map(item => [item.handoff_id, item.source_thread_id, item.target_thread_id, item.state]),
+    [[ab.handoff_id, A, B, 'continued'], [bc.handoff_id, B, C, 'continued']]);
+  assert.equal(resolveAutoHandoffSuccessor(db, B, options).current_thread_id, C);
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, B, options).chain.map(item => item.handoff_id), [bc.handoff_id]);
+  assert.equal(resolveAutoHandoffSuccessor(db, C, options).handed_off, false);
+
+  // 今の続き C が、さらに引き継いでいる最中（worker が動いている）
+  const cd = updateAutoHandoff(db, request(db, C).operation.handoff_id, { state: 'memory_ready' }).operation;
+  db.prepare('UPDATE codex_handoffs SET worker_identity_json = ?, updated_at = ? WHERE handoff_id = ?').run(JSON.stringify({ pid: 4242, started_identity: 'w' }), 999_000, cd.handoff_id);
+  const running = resolveAutoHandoffSuccessor(db, A, { ...options, processes: () => [{ pid: 4242, started_identity: 'w' }] });
+  assert.equal(running.current_thread_id, C); assert.equal(running.pending.handoff_id, cd.handoff_id);
+  assert.equal(running.pending.in_flight, true); assert.equal(running.pending.state, 'memory_ready');
+  // worker が居なくなっていれば、途中で止まった物として返す
+  assert.equal(resolveAutoHandoffSuccessor(db, A, options).pending.in_flight, false);
+
+  // C の引き継ぎが失敗して止まった
+  updateAutoHandoff(db, cd.handoff_id, { state: 'failed', error_code: 'handoff_summarizer_backend_failed', resume_state: 'source_stopped' });
+  const stopped = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(stopped.current_thread_id, C);
+  assert.deepEqual([stopped.pending.state, stopped.pending.error_code, stopped.pending.resume_state, stopped.pending.in_flight],
+    ['failed', 'handoff_summarizer_backend_failed', 'source_stopped', false]);
+
+  // やり直して D へ続いた。C が消されても、D が残っていれば D が今の続き
+  updateAutoHandoff(db, cd.handoff_id, { state: 'continued', error_code: null, resume_state: null, target_thread_id: D, queued_submission_id: 'receipt-D' });
+  gone.add(C);
+  const toD = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(toD.current_thread_id, D); assert.equal(toD.chain.length, 3); assert.equal(toD.pending, null);
+  // 後継が全部消されたら、旧タスクが今の続きに戻る
+  gone.add(D); gone.add(B);
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, A, options), { thread_id: A, handed_off: false, current_thread_id: A, chain: [], pending: null });
+
+  // 後継が出来る前に失敗したタスク（後継なし）
+  updateAutoHandoff(db, request(db, Y).operation.handoff_id, { state: 'failed', error_code: 'handoff_target_not_loaded', resume_state: 'memory_ready' });
+  const failed = resolveAutoHandoffSuccessor(db, Y, options);
+  assert.equal(failed.handed_off, false); assert.equal(failed.current_thread_id, Y); assert.equal(failed.pending.error_code, 'handoff_target_not_loaded');
+  assert.throws(() => resolveAutoHandoffSuccessor(db, 'not-a-thread', options), /handoff_thread_id_invalid/);
+  void Z;
+}));
+
+test('Codexの内部の文脈（auto-compact-N）からの圧縮は、例外にせず止めて記録する。引き継ぎは作らない', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const file = join(home, 'rollout.jsonl'); writeFileSync(file, '');
+  const payload = { trigger: 'auto', cwd: home, session_id: thread, turn_id: 'auto-compact-3', transcript_path: file };
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  let launched = 0; const recorded = [];
+  const args = { db, config, payload, launchWorker: async () => { launched++; }, recordInternalCompaction: entry => recorded.push(entry), now: Date.parse('2026-10-10T04:24:01.175Z') };
+  const result = await requestCodexAutoHandoff(args);
+  assert.equal(result.status, 'ok'); assert.equal(result.continue, false); assert.equal(result.internalCompaction, true);
+  assert.match(result.stopReason, /ターンの外の自動圧縮を止めました/);
+  assert.equal(launched, 0);
+  assert.equal(db.prepare('SELECT COUNT(*) n FROM codex_handoffs').get().n, 0, '引き継ぎの行は作らない');
+  assert.deepEqual(recorded, [{ at: '2026-10-10T04:24:01.175Z', thread_id: thread, turn_id: 'auto-compact-3' }]);
+
+  // 無効な project と手動の圧縮は、今までどおり何もしない
+  assert.equal((await requestCodexAutoHandoff({ ...args, config: { ...config, projects: ['/other'] } })).status, 'skipped');
+  assert.equal((await requestCodexAutoHandoff({ ...args, payload: { ...payload, trigger: 'manual' } })).status, 'skipped');
+  assert.equal(recorded.length, 1);
+
+  // 形の決まっていない ID と、場所の分からない呼び出しは、今までどおり失敗として扱う
+  for (const broken of [{ turn_id: 'something-else' }, { turn_id: undefined }, { turn_id: 'auto-compact-' }, { session_id: 'not-a-uuid' },
+    { transcript_path: null }, { transcript_path: 'relative/rollout.jsonl' }]) {
+    await assert.rejects(requestCodexAutoHandoff({ ...args, payload: { ...payload, ...broken } }), /handoff_hook_identity_invalid/);
+  }
+  assert.equal(recorded.length, 1);
+}));
+
 test('PreCompactの入口は、JS実装のrealpathが使えない環境（WindowsのCodex Desktopのhook）でも引き継ぎを作る', async () => withDb(async (db, home) => {
   const thread = '11111111-1111-1111-1111-111111111111', turn = '22222222-2222-2222-2222-222222222222';
   const dir = join(home, 'codex', 'sessions'); mkdirSync(dir, { recursive: true });