throughline 0.16.0 → 0.16.2

package/CHANGELOG.md

@@ -10,6 +10,43 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.2] — 2026-10-07
+
+### 修正
+
+- Codexの自動継続で、引き継ぎ済みの旧タスクへ新しい入力が届くたびに、同じ作業を引き継いだ後継がもう1つ立っていたのを直す（[ADR 0039](docs/adr/0039-codex-auto-handoff-one-successor-per-source.md)）。重複を見ていたのは元のタスクと元のターンの組で、旧タスクに新しいターンが出来ると別の引き継ぎとして受けていた。継続の指示が届いた後継が残っている間は、新しい引き継ぎを作らず、ターンを止めて、止めた理由に引き継ぎID・後継の名前・`codex://threads/<後継>`を書き、Desktopで後継を開く。後継がさらに引き継いでいれば、その先を示す。
+- workerは、継続の指示を送る直前に、同じ旧タスクの別の引き継ぎが先に指示を送っていないかを確かめる。送られていれば`handoff_source_already_continued`で止まり、後継へ指示を送らない。
+- 止めた事を`~/.throughline/codex-auto-handoff/redirects.jsonl`に1行残す（会話の本文は書かない）。
+
+### 変わらない事
+
+- 配送の前に失敗した引き継ぎしか無い旧タスクと、後継が残っていない（消した、アーカイブした）旧タスクからは、今までどおり新しい後継を立てる。
+- 旧タスクへ打った入力は後継へ渡さない。後継で打ち直す。
+
+### 確認した範囲
+
+- macOSのCodex Desktop（0.16.1）で2026-10-07に起きた記録（同じ旧タスクから3つの引き継ぎ）を読んだ。
+
+### 確認していない範囲
+
+- Codex Desktopの画面で、旧タスクに止めた理由がどう見えるか。
+
+## [0.16.1] — 2026-10-07
+
+### 修正
+
+- Claudeのターンの途中で会話記録（transcript）のフォルダが消され、Claude Codeが残りの行だけでファイルを作り直した時、Stopのhookが`Claude Stop transcript completion was not visible before deadline`で失敗し、`HOOK_PROCESS_TURN_FAILED`を数えていたのを直す（[ADR 0038](docs/adr/0038-stop-flush-barrier-head-lost-transcript.md)）。期限まで待って、transcriptに応答だけがあり利用者の発言が1つも無い時は、失敗に数えず、`backfill.log`に`skipped: "transcript_head_lost"`を残して終わる。ファイルが残らなかった時（`transcript_absent`、[ADR 0029](docs/adr/0029-stop-flush-barrier-absent-transcript.md)）と同じ扱いにする。
+- 利用者の発言が残っているのに完了が見えない時は、今までどおり失敗に数える。
+
+### 確認した範囲
+
+- Linuxのコンテナ（0.15.5、Claude Code 2.1.292）で2026-10-07に起きた失敗の、transcriptとStopのpayloadを切り離した置き場で再生した。0.15.5は同じ文面で失敗して1回数え、この版は失敗に数えず`transcript_head_lost`を記録した。
+
+### 確認していない範囲
+
+- 同じ朝に同じ試験の道具で数えられた残り11回の失敗は、transcriptが後で消されていて、同じ形だったかを直接は見ていない。11回とも、その会話の最後のStopで起きている。
+- macOSとWindowsでは、この形の失敗を再現していない（足した試験はCIの3環境で走る）。
+
 ## [0.16.0] — 2026-10-07
 
 ### 変更
@@ -1876,7 +1913,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.0...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.2...HEAD
+[0.16.2]: https://github.com/kitepon/Throughline/compare/v0.16.1...v0.16.2
+[0.16.1]: https://github.com/kitepon/Throughline/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/kitepon/Throughline/compare/v0.15.5...v0.16.0
 [0.15.5]: https://github.com/kitepon/Throughline/compare/v0.15.4...v0.15.5
 [0.15.4]: https://github.com/kitepon/Throughline/compare/v0.15.3...v0.15.4

package/docs/05_codex_first_roadmap.md

@@ -160,6 +160,8 @@ sequenceDiagram
 DBには引き継ぎID、元thread/turn、project/Codex環境、snapshot参照、
 前任引き継ぎID、新thread ID、配送ID、受付ID、状態、開始証拠、失敗理由を保存する。
 元thread/turnの要求は一意にし、フックの重複で後継を増やさない。
+継続の指示が届いた旧タスクへ新しいturnが来た時は、後継が残っている間は要求を作らず、
+ターンを止めて今の後継を示して開く（[ADR 0039](adr/0039-codex-auto-handoff-one-successor-per-source.md)）。
 schema変更は `src/db.mjs` と製品所有migrationへ置き、
 schemaの版とmigrationは同じ製品releaseで更新する。
 

package/docs/adr/0038-stop-flush-barrier-head-lost-transcript.md

@@ -0,0 +1,53 @@
+# ADR 0038: 始まりを失った transcript の Claude Stop は、hook 処理の失敗に数えない
+
+日付: 2026-10-07
+
+## Context
+
+2026-10-07 08:24:17 JST、BellTeam コンテナ（0.15.5）で、解決登録していた `HOOK_PROCESS_TURN_FAILED` が再発した
+（7回目）。理由は `Claude Stop transcript completion was not visible before deadline`。
+
+失敗した会話は、`/tmp/ag-fvIcWA/proj` で動いた Claude Code（2.1.292）の試験用の会話。1つ目のターンの Stop は
+同じ会話の transcript を読んで 1 turn を保存している（08:23:59）。2つ目のターンの Stop が失敗した。
+
+残っていた transcript は 10 行で、最初の行は 08:24:08.262 の assistant（thinking だけ）、次が 08:24:15.621 の
+最後の応答だった。user の行は1つも無い。同じファイルの `turn_duration` は `messageCount: 29` と書いている。
+transcript を置くフォルダ（`~/.claude/projects/-tmp-ag-fvIcWA-proj`）の作成時刻は 08:24:15.744 で、
+会話の作業フォルダ（`/tmp/ag-fvIcWA/proj`）は 08:24:15.861 に消されている。
+
+会話を起動した試験の道具は、回答が端末に出た直後に端末を閉じ、transcript のフォルダと作業フォルダを消す。
+Claude Code は最後の応答の行（thinking と本文）をその後で書くので、フォルダごとファイルを作り直す。
+Stop hook は応答の後に非同期で走り、応答だけのファイルを読んだ、と読める。
+
+同じ道具は同じ朝に続けて動き、08:24〜08:33 の間に同じ文面の失敗が 12 回数えられた（7回目〜18回目）。
+transcript が残っていたのは最初の1回だけで、残りの11回は後でファイルが消されている。11回とも、
+その会話の最後の Stop で、1つ前の Stop は保存できている。
+
+ファイルが残らなかった時は ADR 0029 の `transcript_absent` になり、失敗に数えない。今回はファイルが
+作り直されていたので、ADR 0029 Decision 3（ファイルがあるのに完了が見えない時は失敗）に当たった。
+どちらも「保存する元が、会話を起動した側に消された」で、違いは Claude Code が残りを書いた時刻だけ。
+
+Throughline はターンを user の発言から数える（`readLatestLogicalTurnCompletions`）。user の発言が1つも無い
+transcript からは、どのターンも作れない。Claude Code は会話の最初に必ず user の行を書くので、
+assistant の発言があって user の発言が無い transcript は、始まりを失った物に限られる。
+
+控えた transcript と同じ Stop の payload を、切り離した置き場で再生した。0.15.5 は同じ文面で失敗し、
+`HOOK_PROCESS_TURN_FAILED` を1回数えた。
+
+## Decision
+
+1. flush barrier は、期限まで待っても完了が見えず、transcript に assistant の発言があって user の発言が
+   1つも無い時、`transcript_head_lost` を返す。失敗にしない。
+2. 確認は期限に達した時だけ行う。遅れて書かれる user の行は、今までどおり期限まで待つ。
+3. user の発言が1つでも残っている時と、発言が1つも無いファイル（書き始め）は、今までどおり明示失敗して
+   `HOOK_PROCESS_TURN_FAILED` を数える（ADR 0012 Decision 4、ADR 0029 Decision 3）。
+4. `transcript_head_lost` の Stop は、ADR 0029 Decision 4 と同じ扱いにする。`backfill.log` に
+   `{"hook":"stop",…,"skipped":"transcript_head_lost"}` を1行残し、終了 code 0 で終わる。
+   DB・state file・完了受領・runtime error store には何も書かない。
+
+## Consequences
+
+- 始まりを消された会話の最後のターンは保存されない。保存する依頼がどこにも無いので、今までも保存できていない。
+  変わるのは、失敗に数えるかどうかだけ。
+- 見送った Stop は `backfill.log` の `skipped` で数えられる。
+- transcript の途中だけが失われ、user の発言が残っている時は、今までどおり失敗に数える。

package/docs/adr/0039-codex-auto-handoff-one-successor-per-source.md

@@ -0,0 +1,58 @@
+# ADR 0039: 引き継ぎ済みの Codex タスクへ新しい入力が来ても、後継を増やさない
+
+日付: 2026-10-07
+
+## Context
+
+2026-10-07、macOS の Codex Desktop（Throughline 0.16.1、自動継続は全 project で有効）で、同じ作業を引き継いだ
+後継タスクが3つ出来た。時刻は JST。
+
+- 09:49:01 旧タスク `01a1136a` の自動圧縮を止め、後継 `01a113d5` を立てた（`continued`）。後継は 09:54:40 に
+  ターンを終え、利用者の操作を待っていた。
+- 09:56:48 旧タスク `01a1136a` へ、利用者の新しい入力（1行）が届いた。旧タスクは閾値を超えたままなので、
+  `PreCompact(auto)` がもう一度発火した。Throughline はそのターンを止め、2つ目の後継 `01a113dc` を立てた。
+- 09:56:58 同じ旧タスクへもう1行届き、3つ目の後継 `01a113dd` を立てた。
+
+3つの引き継ぎは、どれも元が同じ旧タスクで、前任の引き継ぎも同じだった。2つ目と3つ目の後継は、1つ目の
+後継が 09:49〜09:54 に進めた作業を知らないまま、同じ作業（本番の認証の確認）を始めた。3つ目が自分で
+降りたので、操作は重複しなかった。
+
+設計の受入条件は「同じ旧タスクから後継を重複作成せず、旧・新タスクが同じ操作を重複実行しない」
+（[05_codex_first_roadmap.md](../05_codex_first_roadmap.md)）。実装が一意にしていたのは元 thread と元 turn の
+組で、同じ旧タスクの別の turn は別の要求として受けていた。hook が同じ turn で2回走った時は増えないが、
+旧タスクに新しい turn が出来るたびに後継が増える。
+
+Claude Code の自動継続（ADR 0033）は、記録を旧い会話ごとに1つ持つ。引き継ぎ済みの会話で道具が呼ばれた時は、
+後継を増やさずに止め、止めた理由に後継を書く。Codex の側をこの形にそろえる。
+
+## Decision
+
+1. Codex の `PreCompact(auto)` は、その旧タスクから継続の指示が届いた（届いたかもしれない）引き継ぎがあり、
+   その後継のタスクが残っている時、新しい引き継ぎを作らない。`continue: false` でターンを止め、止めた理由に
+   引き継ぎ ID、後継の名前、`codex://threads/<後継>` を書く。Desktop で後継を開く。
+2. 「指示が届いた（かもしれない）」は、受付 ID が保存されている、状態が `submitted`・`continued`、
+   または配送の途中（`mutation_stage` が `submit`。結果不明で止まった物を含む）のどれか。
+   配送の前に失敗した引き継ぎは数えない。その旧タスクからは、今までどおり新しい引き継ぎを作る。
+3. 示す後継は、今その作業を持っているタスクにする。後継がさらに引き継いでいれば、その先をたどる。
+   後継の rollout が `sessions` に無い時（消した、アーカイブした）は、その後継は無い物として扱う。
+   残っている後継が1つも無ければ、今までどおり旧タスクから新しい引き継ぎを作る。
+4. 0.16.1 までに同じ旧タスクから複数の後継が立っている記録では、rollout が最後に書かれた後継を示す。
+5. worker は、継続の指示を送る直前に、同じ旧タスクの別の引き継ぎが先に指示を送っていないかを確かめる。
+   確認と「配送の途中」の記録は1つの transaction で行う。先に送られていれば、送らずに
+   `handoff_source_already_continued` で失敗にする。2つの入力がほぼ同時に来て、hook の判定をどちらも
+   通った時のための確認。
+6. 止めた事は `~/.throughline/codex-auto-handoff/redirects.jsonl` に1行残す（時刻、旧タスクと turn、
+   引き継ぎ ID、後継、開けたか）。会話の本文は書かない。引き継ぎの行は増えないので、起きた事はここで数える。
+7. 同じ turn の hook がもう一度来た時は、今までどおり同じ引き継ぎを返す。手動の `/compact` は、
+   今までどおり止めない。
+
+## Consequences
+
+- 旧タスクへ打った入力は、後継へは渡らない。旧タスクでターンが止まり、後継が開く。利用者は後継で
+  打ち直す。入力を後継へ自動で送る事はしない（継続の指示は1回だけ送る、という配送の契約を変えないため）。
+- 引き継ぎ済みの旧タスクは、後継が残っている間、そのタスクで作業を続けられない。旧タスクで続けたい時は、
+  旧タスクで手動の `/compact` を使う。
+- 2つの入力がほぼ同時に来て5に当たった時は、後に来た方の後継（記憶だけが入った、指示の無いタスク）が
+  残り、失敗の表示が出る。
+- 外から旧タスクへ届く文（旧タスクが開いた通話への返信など）も、同じように止まる。0.16.1 までは、
+  1通ごとに後継が1つ増えていた。

package/package.json

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

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

@@ -22,6 +22,21 @@ export function findAutoHandoffForTarget(db, threadId) {
   return decode(db.prepare('SELECT * FROM codex_handoffs WHERE target_thread_id = ?').get(threadId));
 }
 
+export function findAutoHandoffForTurn(db, threadId, turnId) {
+  return decode(db.prepare('SELECT * FROM codex_handoffs WHERE source_thread_id = ? AND source_turn_id = ?')
+    .get(threadId, turnId));
+}
+
+/**
+ * 継続の指示が後継へ届いた、または届いたかもしれない引き継ぎ（新しい順）。後継が作業を持っているので、
+ * 同じ旧タスクから別の後継を立てない。配送の前に失敗した引き継ぎは入れない。
+ */
+export function listDeliveredAutoHandoffsForSource(db, threadId) {
+  return db.prepare(`SELECT * FROM codex_handoffs WHERE source_thread_id = ? AND target_thread_id IS NOT NULL
+    AND (queued_submission_id IS NOT NULL OR state IN ('submitted', 'continued') OR mutation_stage = 'submit')
+    ORDER BY created_at DESC`).all(threadId).map(decode);
+}
+
 export function listAutoHandoffs(db, { projectPath = null, limit = 20 } = {}) {
   const rows = projectPath == null
     ? db.prepare('SELECT * FROM codex_handoffs ORDER BY created_at DESC LIMIT ?').all(limit)

package/src/codex-auto-handoff.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync, openSync, closeSync, writeFileSync, realpathSync } from 'node:fs';
+import { mkdirSync, openSync, closeSync, writeFileSync, appendFileSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve, relative, isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -13,7 +13,8 @@ import { findCodexThreadCandidate } from './codex-thread-index.mjs';
 import { captureCodexRolloutToDb } from './codex-capture.mjs';
 import { readAutoHandoffConfig, autoHandoffEnabledFor } from './codex-auto-handoff-config.mjs';
 import { getAutoHandoff, requestAutoHandoff, updateAutoHandoff, failAutoHandoff,
-  claimAutoHandoff, releaseAutoHandoff, freezeCodexMemory, continuationInput } from './codex-auto-handoff-store.mjs';
+  claimAutoHandoff, releaseAutoHandoff, freezeCodexMemory, continuationInput,
+  findAutoHandoffForTurn, listDeliveredAutoHandoffsForSource } from './codex-auto-handoff-store.mjs';
 import { ensureAutoHandoffSummaries, renderAutoHandoffMemory } from './codex-auto-handoff-memory.mjs';
 import { CODEX_NATIVE_ID_PATTERN, CodexHandoffError, readCodexHandoffState,
   settingsMatch, threadStartSettings } from './hosts/codex-handoff-state.mjs';
@@ -66,8 +67,45 @@ export async function launchAutoHandoffWorker(id) {
   } finally { closeSync(log); }
 }
 
+function liveSuccessors(db, threadId, options, seen) {
+  const found = [];
+  for (const operation of listDeliveredAutoHandoffsForSource(db, threadId)) {
+    if (operation.handoff_id === options.exceptHandoffId || seen.has(operation.handoff_id)) continue;
+    seen.add(operation.handoff_id);
+    const deeper = liveSuccessors(db, operation.target_thread_id, options, seen);
+    if (deeper.length) { found.push(...deeper); continue; }
+    const thread = options.findThread({ threadId: operation.target_thread_id, codexHome: operation.codex_home,
+      projectPath: operation.project_path, requireProjectMatch: true });
+    if (thread) found.push({ operation, mtimeMs: thread.mtimeMs ?? 0 });
+  }
+  return found;
+}
+
+/**
+ * 旧タスクの作業を今持っている後継の引き継ぎ。継続の指示が届いた引き継ぎをたどり、後継がさらに引き継いで
+ * いればその先へ進む。後継のrolloutが無い枝（消した、アーカイブした）は数えない。無ければ null。
+ * 0.16.1 までに同じ旧タスクから複数の後継が立っていた時は、最後に動いた後継を返す。
+ */
+export function findLiveAutoHandoffSuccessor(db, threadId,
+  { exceptHandoffId = null, findThread = findCodexThreadCandidate } = {}) {
+  return liveSuccessors(db, threadId, { exceptHandoffId, findThread }, new Set())
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.operation ?? null;
+}
+
+function openSuccessor(operation) {
+  const result = openUrlWithOsHandler(`codex://threads/${encodeURIComponent(operation.target_thread_id)}`);
+  return !result.error && result.status === 0;
+}
+
+/** 引き継ぎ済みの旧タスクを止めた記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
+function recordAutoHandoffRedirect(entry) {
+  mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+  appendFileSync(join(stateRoot(), 'redirects.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
 export async function requestCodexAutoHandoff({ payload, db = null,
-  config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker } = {}) {
+  config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
+  findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect } = {}) {
   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 ?? '') ||
@@ -82,6 +120,19 @@ export async function requestCodexAutoHandoff({ payload, db = null,
   if (!sessionPart) throw error('handoff_codex_home_unavailable');
   const codexHome = rolloutPath.slice(0, sessionPart.index);
   const actualDb = db ?? getDb();
+  // 引き継ぎ済みの旧タスクへ、新しい入力が来た。作業は後継が持っているので、後継を増やさずに止めて後継を示す。
+  const successor = findAutoHandoffForTurn(actualDb, threadId, turnId) ? null
+    : findLiveAutoHandoffSuccessor(actualDb, threadId, { findThread });
+  if (successor) {
+    const opened = openThread(successor);
+    recordRedirect({ at: new Date().toISOString(), source_thread_id: threadId, source_turn_id: turnId,
+      handoff_id: successor.handoff_id, target_thread_id: successor.target_thread_id, opened });
+    return { status: 'ok', operationId: successor.handoff_id, inserted: false, redirected: true,
+      targetThreadId: successor.target_thread_id, opened, continue: false,
+      stopReason: `このタスクはThroughlineが新しいタスクへ引き継ぎ済みです（引き継ぎID: ${successor.handoff_id}）。` +
+        `続きは後継のタスク「${autoHandoffTargetName(actualDb, successor)}」で行ってください: ` +
+        `codex://threads/${successor.target_thread_id}` };
+  }
   const { operation, inserted } = requestAutoHandoff(actualDb, { threadId, turnId, projectPath: state.meta.cwd,
     rolloutPath, codexHome, openHost: config.openHost });
   if (inserted) {
@@ -218,7 +269,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
     nativeState: sourceNativeState, capture: captureCodexRolloutToDb, summaries: ensureAutoHandoffSummaries,
     createTarget, readTarget: targetState, openTarget, verify: verifyCodexParent,
     submit: submitCodexParentAnswer, notify: showAutoHandoffFailure, wait: waitForHandoff,
-    executable: () => platformDesktopFinder()(), ...dependencies };
+    executable: () => platformDesktopFinder()(), liveSuccessor: findLiveAutoHandoffSuccessor, ...dependencies };
   let operation = getAutoHandoff(db, id);
   if (!operation) throw error('handoff_not_found');
   if (operation.state === 'continued') return operation;
@@ -299,7 +350,16 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       if (target?.latestTurnId || !target?.settings || !settingsMatch(operation.runtime.preparedSettings, target.settings)) throw error('handoff_target_advanced');
       const parent = { thread_id: operation.target_thread_id, codex_home: operation.codex_home };
       await deps.verify(autoHandoffDeliveryProfile, parent, runtime);
-      update({ mutation_stage: 'submit' });
+      // 同じ旧タスクの別の引き継ぎが先に指示を送っていたら、後継を増やさない。確認と記録を1つのtransactionで行う。
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        if (deps.liveSuccessor(db, operation.source_thread_id, { exceptHandoffId: id })) throw error('handoff_source_already_continued');
+        update({ mutation_stage: 'submit' });
+        db.exec('COMMIT');
+      } catch (cause) {
+        db.exec('ROLLBACK');
+        throw cause;
+      }
       const receipt = await deps.submit(autoHandoffDeliveryProfile, parent, operation.delivery_id, continuationInput(operation), runtime);
       update({ state: 'submitted', queued_submission_id: receipt.queued_submission_id, mutation_stage: null });
     }

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

@@ -11,7 +11,7 @@ import { collectAutoHandoffMemory, ensureAutoHandoffSummaries, renderAutoHandoff
   renderFrozenDetail } from './codex-auto-handoff-memory.mjs';
 import { readCodexHandoffState, settingsMatch, threadStartSettings } from './hosts/codex-handoff-state.mjs';
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
-  autoHandoffTargetName, nameAutoHandoffTarget } from './codex-auto-handoff.mjs';
+  autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -216,6 +216,116 @@ test('PreCompactの重複ではworkerを増やさず、manualと別projectでは
   assert.equal((await requestCodexAutoHandoff({ ...args, config: { ...config, projects: ['/other'] } })).status, 'skipped');
 }));
 
+function desktopSource(home, thread, turn) {
+  const dir = join(home, 'codex', 'sessions'); mkdirSync(dir, { recursive: true });
+  const file = join(dir, `rollout-${thread}.jsonl`);
+  writeFileSync(file, [{ type: 'session_meta', payload: { id: thread, originator: 'Codex Desktop', source: 'vscode', cwd: home } },
+    { type: 'event_msg', payload: { type: 'task_started', turn_id: turn } }].map(JSON.stringify).join('\n') + '\n');
+  return { trigger: 'auto', cwd: home, session_id: thread, turn_id: turn, transcript_path: file };
+}
+
+function delivered(db, home, source, turnId, target, now, fields = {}) {
+  const operation = requestAutoHandoff(db, { threadId: source, turnId, projectPath: home,
+    rolloutPath: '/codex/rollout.jsonl', codexHome: join(home, 'codex'), openHost: 'desktop', now }).operation;
+  return updateAutoHandoff(db, operation.handoff_id, { target_thread_id: target, state: 'continued',
+    queued_submission_id: `receipt-${target}`, runtime_json: { title: 'ベルチーム' }, ...fields }).operation;
+}
+
+test('引き継ぎ済みの旧タスクへ新しい入力が来ても後継を増やさず、止めて今の後継を示して開く', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const first = delivered(db, home, thread, '22222222-2222-2222-2222-222222222222', 'successor-1', 1);
+  const payload = desktopSource(home, thread, '33333333-3333-3333-3333-333333333333');
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  const seen = { launched: 0, opened: [], recorded: [], asked: [] };
+  const args = { db, config, payload, launchWorker: async () => { seen.launched++; },
+    findThread: query => { seen.asked.push(query); return { mtimeMs: 1 }; },
+    openThread: operation => { seen.opened.push(operation.target_thread_id); return true; },
+    recordRedirect: entry => { seen.recorded.push(entry); } };
+  const result = await requestCodexAutoHandoff(args);
+  assert.equal(result.continue, false); assert.equal(result.redirected, true); assert.equal(result.inserted, false);
+  assert.equal(result.operationId, first.handoff_id); assert.equal(result.targetThreadId, 'successor-1');
+  assert.match(result.stopReason, /引き継ぎ済み/);
+  assert.match(result.stopReason, /codex:\/\/threads\/successor-1/);
+  assert.ok(result.stopReason.includes('｜ベルチーム（自動引き継ぎ）」'));
+  assert.equal(seen.launched, 0); assert.deepEqual(seen.opened, ['successor-1']);
+  assert.equal(db.prepare('SELECT COUNT(*) AS n FROM codex_handoffs').get().n, 1);
+  assert.equal(seen.asked[0].threadId, 'successor-1'); assert.equal(seen.asked[0].codexHome, join(home, 'codex'));
+  assert.equal(seen.recorded.length, 1);
+  assert.deepEqual({ ...seen.recorded[0], at: null }, { at: null, source_thread_id: thread,
+    source_turn_id: payload.turn_id, handoff_id: first.handoff_id, target_thread_id: 'successor-1', opened: true });
+
+  // 後継がさらに引き継いでいれば、その先を示す。開けなくても止めて、止めた理由に後継を書く。
+  delivered(db, home, 'successor-1', 'turn-b', 'successor-2', 2);
+  const chained = await requestCodexAutoHandoff({ ...args, openThread: () => false });
+  assert.equal(chained.targetThreadId, 'successor-2'); assert.equal(chained.opened, false);
+  assert.match(chained.stopReason, /codex:\/\/threads\/successor-2/);
+  assert.equal(seen.launched, 0);
+}));
+
+test('後継が残っていない旧タスクと、配送の前に失敗した旧タスクからは、新しい後継を立てる', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  let launched = 0;
+  const base = { db, config, launchWorker: async () => { launched++; },
+    openThread: () => { throw new Error('開かない'); }, recordRedirect: () => { throw new Error('記録しない'); } };
+  // 作成の途中で失敗した引き継ぎ（後継はあるが、継続の指示は送っていない）。
+  const failed = requestAutoHandoff(db, { threadId: thread, turnId: 'turn-a', projectPath: home,
+    rolloutPath: '/codex/rollout.jsonl', codexHome: join(home, 'codex'), openHost: 'desktop', now: 1 }).operation;
+  updateAutoHandoff(db, failed.handoff_id, { target_thread_id: 'never-started', state: 'failed', error_code: 'handoff_target_not_loaded' });
+  const afterFailure = await requestCodexAutoHandoff({ ...base, findThread: () => ({ mtimeMs: 1 }),
+    payload: desktopSource(home, thread, '33333333-3333-3333-3333-333333333333') });
+  assert.equal(afterFailure.inserted, true); assert.equal(afterFailure.redirected, undefined); assert.equal(launched, 1);
+  // 継続の指示は届いたが、後継のrolloutが無い（消した、アーカイブした）。
+  updateAutoHandoff(db, afterFailure.operationId, { target_thread_id: 'removed', state: 'continued', queued_submission_id: 'receipt' });
+  const afterRemoval = await requestCodexAutoHandoff({ ...base, findThread: () => null,
+    payload: desktopSource(home, thread, '44444444-4444-4444-4444-444444444444') });
+  assert.equal(afterRemoval.inserted, true); assert.equal(launched, 2);
+  // 同じturnのhookがもう一度来た時は、今までどおり同じ引き継ぎを返す。
+  const again = await requestCodexAutoHandoff({ ...base, findThread: () => ({ mtimeMs: 1 }),
+    payload: desktopSource(home, thread, '44444444-4444-4444-4444-444444444444') });
+  assert.equal(again.operationId, afterRemoval.operationId); assert.equal(again.inserted, false); assert.equal(launched, 2);
+}));
+
+test('同じ旧タスクから複数の後継が立っていた記録では、最後に動いた後継を選ぶ', async () => withDb(async (db, home) => {
+  delivered(db, home, 'old', 'turn-1', 'first', 1);
+  const active = delivered(db, home, 'old', 'turn-2', 'second', 2);
+  delivered(db, home, 'old', 'turn-3', 'third', 3);
+  // 配送結果が不明のまま止まった引き継ぎも、指示が届いたかもしれないので数える。
+  const unknown = requestAutoHandoff(db, { threadId: 'other', turnId: 'turn', projectPath: home,
+    rolloutPath: '/codex/rollout.jsonl', codexHome: join(home, 'codex'), openHost: 'desktop', now: 4 }).operation;
+  updateAutoHandoff(db, unknown.handoff_id, { target_thread_id: 'maybe', state: 'unknown', mutation_stage: 'submit' });
+  const mtimes = { first: 10, second: 30, third: 20, maybe: 1 };
+  const findThread = ({ threadId }) => ({ mtimeMs: mtimes[threadId] });
+  assert.equal(findLiveAutoHandoffSuccessor(db, 'old', { findThread }).handoff_id, active.handoff_id);
+  assert.equal(findLiveAutoHandoffSuccessor(db, 'old', { findThread, exceptHandoffId: active.handoff_id }).target_thread_id, 'third');
+  assert.equal(findLiveAutoHandoffSuccessor(db, 'other', { findThread }).target_thread_id, 'maybe');
+  assert.equal(findLiveAutoHandoffSuccessor(db, 'second', { findThread }), null);
+}));
+
+test('workerは、同じ旧タスクの別の引き継ぎが先に指示を送っていたら配送しない', async () => withDb(async db => {
+  const counters = { created: 0, notified: 0, submitted: 0 };
+  const submit = async () => { counters.submitted++; return { queued_submission_id: `receipt-${counters.submitted}` }; };
+  const liveSuccessor = (database, threadId, options) =>
+    findLiveAutoHandoffSuccessor(database, threadId, { ...options, findThread: () => ({ mtimeMs: 1 }) });
+  const first = request(db, 'shared-source', { now: 1 }).operation;
+  const firstResult = await runAutoHandoffWorker(first.handoff_id,
+    { db, dependencies: { ...workerDependencies(db, {}, submit, counters), liveSuccessor } });
+  assert.equal(firstResult.state, 'continued');
+  const second = request(db, 'shared-source', { turnId: 'turn-2', now: 2 }).operation;
+  const deps = workerDependencies(db, {}, submit, counters);
+  const result = await runAutoHandoffWorker(second.handoff_id, { db, dependencies: { ...deps, liveSuccessor,
+    readSource: () => ({ ...deps.readSource(), latestTurnId: 'turn-2' }),
+    capture: () => ({ status: 'captured' }),
+    createTarget: async (database, operation) => {
+      updateAutoHandoff(database, operation.handoff_id, { target_thread_id: 'second-target', mutation_stage: null,
+        runtime_json: { ...operation.runtime, targetPrepared: true, targetMemoryInjected: true,
+          preparedSettings: deps.readTarget(operation).settings } });
+    } } });
+  assert.equal(result.state, 'failed'); assert.equal(result.error_code, 'handoff_source_already_continued');
+  assert.equal(result.mutation_stage, null); assert.equal(result.queued_submission_id, null);
+  assert.equal(counters.submitted, 1); assert.equal(counters.notified, 1);
+}));
+
 test('公開CLIはactionに適合する引数だけを受け取る', () => {
   assert.equal(parseAutoHandoffArgs(['status', '--json']).action, 'status');
   for (const args of [['enable', '--operation', 'id'], ['disable', '--project', '/p'], ['status', '--json', '--json'],

package/src/runtime-error-hook.test.mjs

@@ -98,6 +98,20 @@ test('Claude Stopで、transcriptのファイルが無い会話は失敗に数
     skipped: 'transcript_absent',
   }]);
 
+  // ターンの途中でtranscriptが消され、応答の行だけでファイルが作り直された。依頼が残っていないので、失敗に数えない（ADR 0038）。
+  const headLostPath = join(root, 'head-lost.jsonl');
+  writeFileSync(headLostPath, JSON.stringify({ type: 'assistant',
+    message: { role: 'assistant', stop_reason: 'end_turn', content: [{ type: 'text', text: 'PROBE_OK' }] } }) + '\n');
+  const headLost = stop({
+    session_id: 'a1b2c3d4-0000-4000-8000-000000000003', transcript_path: headLostPath, cwd: root,
+    hook_event_name: 'Stop', stop_hook_active: false, last_assistant_message: 'PROBE_OK',
+  });
+  assert.equal(headLost.status, 0, headLost.stderr);
+  assert.equal(existsSync(storePath), false, 'a transcript that lost its head must not be counted as a hook failure');
+  assert.equal(existsSync(join(root, '.throughline', 'logs', 'hook-failures.log')), false);
+  assert.deepEqual([readLog('backfill.log').at(-1).session_id, readLog('backfill.log').at(-1).skipped],
+    ['a1b2c3d4-0000-4000-8000-000000000003', 'transcript_head_lost']);
+
   // ファイルはあるのに、Stopが渡した応答がそこに無い。保存できなかった会話なので、失敗のまま数える。
   const presentPath = join(root, 'present.jsonl');
   writeFileSync(presentPath, JSON.stringify({ type: 'user', message: { role: 'user', content: 'request' } }) + '\n');

package/src/turn-processor.mjs

@@ -33,6 +33,7 @@
 import { getDb } from './db.mjs';
 import {
   readRawEntries,
+  readTranscript,
   readLatestLogicalTurnCompletions,
   sliceCurrentTurnEntries,
   extractDetailBlocks,
@@ -60,6 +61,12 @@ export const CLAUDE_STOP_TRANSCRIPT_FLUSH_INTERVAL_MS = 25;
 
 const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 
+/** transcript に assistant の発言だけがあり、user の発言が1つも無い（会話の始まりを失っている）。 */
+function isTranscriptHeadLost(transcriptPath) {
+  const turns = readTranscript(transcriptPath);
+  return turns.length > 0 && !turns.some(turn => turn.role === 'user');
+}
+
 /**
  * Claude Stop payloadのassistant identityがtranscriptへ永続化されるまで待つ。
  * markerは本文ソースにせず、transcript可視化のbarrierにだけ使う。
@@ -77,6 +84,10 @@ const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, mil
  * 期限まで待ってもtranscriptのファイル自体が無い時は、失敗にせず `transcript_absent` を返す
  * （ADR 0029）。Claude Codeを `--no-session-persistence` で起動すると、hookへ `transcript_path` は
  * 渡るが、ファイルは最後まで作られない。ファイルがあるのに完了が見えない時は、今までどおり失敗にする。
+ *
+ * 期限まで待って、transcriptにassistantの発言だけがありuserの発言が1つも無い時は、失敗にせず
+ * `transcript_head_lost` を返す（ADR 0038）。ターンの途中でtranscriptが消されると、Claude Codeは
+ * 残りの行だけでファイルを作り直す。そのターンの依頼はどこにも残っていない。
  */
 export async function waitForClaudeStopTranscriptFlush({
   transcriptPath,
@@ -87,6 +98,7 @@ export async function waitForClaudeStopTranscriptFlush({
   readCompletions = readLatestLogicalTurnCompletions,
   isTurnCaptured = () => true,
   transcriptExists = existsSync,
+  transcriptHeadLost = isTranscriptHeadLost,
   now = Date.now,
   wait = delay,
 }) {
@@ -115,8 +127,9 @@ export async function waitForClaudeStopTranscriptFlush({
     }
     const remaining = deadline - now();
     if (remaining <= 0) {
-      if (typeof transcriptPath === 'string' && transcriptPath && !transcriptExists(transcriptPath)) {
-        return { status: 'transcript_absent' };
+      if (typeof transcriptPath === 'string' && transcriptPath) {
+        if (!transcriptExists(transcriptPath)) return { status: 'transcript_absent' };
+        if (transcriptHeadLost(transcriptPath)) return { status: 'transcript_head_lost' };
       }
       throw new Error('Claude Stop transcript completion was not visible before deadline');
     }
@@ -279,8 +292,8 @@ async function processStop() {
       lastAssistantMessage: last_assistant_message,
       isTurnCaptured: (fragmentTurnNumbers) => isLogicalTurnCaptured(db, origin, fragmentTurnNumbers),
     });
-    if (flush.status === 'transcript_absent') {
-      // 保存する元が無い。失敗には数えず、どの会話のStopを見送ったかを端末内に残す（ADR 0029）。
+    if (flush.status === 'transcript_absent' || flush.status === 'transcript_head_lost') {
+      // 保存する元が無い。失敗には数えず、どの会話のStopを見送ったかを端末内に残す（ADR 0029・0038）。
       logBackfill({
         ts: new Date().toISOString(),
         hook: 'stop',
@@ -288,7 +301,7 @@ async function processStop() {
         target,
         origin,
         transcript_path,
-        skipped: 'transcript_absent',
+        skipped: flush.status,
       });
       process.exit(0);
     }

package/src/turn-processor.test.mjs

@@ -274,6 +274,46 @@ test('Claude Stop flush barrierは、期限までtranscriptのファイルが無
   }
 });
 
+test('Claude Stop flush barrierは、期限までtranscriptにuserの発言が1つも無い時だけtranscript_head_lostを返す', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'throughline-stop-head-lost-'));
+  const transcriptPath = join(root, 'head-lost.jsonl');
+  let elapsed = 0;
+  const clock = { now: () => elapsed, wait: async (milliseconds) => { elapsed += milliseconds; } };
+  const line = (entry) => JSON.stringify(entry);
+  const assistant = (content) => ({ type: 'assistant', message: { role: 'assistant', stop_reason: 'end_turn', content } });
+  try {
+    // ターンの途中でtranscriptのフォルダが消され、Claude Codeが残りの行だけでファイルを作り直した形（Linux 2.1.292で実測）。
+    const tail = [
+      line(assistant([{ type: 'thinking', thinking: '' }])),
+      line(assistant([{ type: 'text', text: '最後の応答' }])),
+      line({ type: 'system', subtype: 'stop_hook_summary', hookCount: 3 }),
+      line({ type: 'ai-title', aiTitle: '題' }),
+    ];
+    writeFileSync(transcriptPath, tail.join('\n') + '\n', 'utf8');
+    assert.deepEqual(await waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: '最後の応答', timeoutMs: 30, intervalMs: 10, ...clock,
+    }), { status: 'transcript_head_lost' });
+    assert.equal(elapsed, 30, 'a user line that is written late must still get the whole deadline');
+
+    // userの発言が残っているのに完了が見えない時は、失敗のまま（保存できたはずの会話）。
+    writeFileSync(transcriptPath,
+      [line({ type: 'user', message: { role: 'user', content: '依頼' } }), ...tail].join('\n') + '\n', 'utf8');
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: '別の応答', timeoutMs: 30, intervalMs: 10, ...clock,
+    }), /not visible before deadline/);
+
+    // 発言が1つも無いファイル（書き始め）は、先頭を失ったとは言えない。失敗のまま。
+    writeFileSync(transcriptPath, line({ type: 'mode', mode: 'normal' }) + '\n', 'utf8');
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: '最後の応答', timeoutMs: 30, intervalMs: 10, ...clock,
+    }), /not visible before deadline/);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('Claude Stop flush barrierはmarkerなし旧payloadをone-shot互換へ残す', async () => {
   let reads = 0;
   const result = await waitForClaudeStopTranscriptFlush({