throughline 0.12.5 → 0.12.7

package/CHANGELOG.md

@@ -10,6 +10,32 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.12.7] — 2026-10-04
+
+### 修正
+
+- Claude Stop hookで、transcriptのファイルが無い会話を`HOOK_PROCESS_TURN_FAILED`（Claude Stop hook processing failed・high）として数えていた不具合を直す（[ADR 0029](docs/adr/0029-stop-flush-barrier-absent-transcript.md)）。Claude Codeを`--no-session-persistence`で起動すると、hookへ`transcript_path`は渡るが、ファイルは最後まで作られない。保存する元が無いので、Stopは期限（2秒）まで待った後、`~/.throughline/logs/backfill.log`に`skipped: "transcript_absent"`を1行残して終了code 0で終わる。ファイルがあるのに完了が見えない時と、`transcript_path`がpayloadに無い時は、今までどおり失敗として数える。
+- BellTeamコンテナ（0.12.6）で2026-10-04に2回起きた失敗は、transcriptがディスクに無い1会話のStopだった。Claude Code 2.1.289を`--no-session-persistence`で動かして、同じ文面の失敗を再現した。その2回の会話がこの引数で起動されたことを示す記録は無い。
+
+### 変更
+
+- `~/.throughline/logs/hook-failures.log`に、Stopが失敗した会話の`session_id`と`transcript_path`を足す。理由の文面だけでは、どの会話のStopかを端末の他の記録から探すことになるため。端末内にだけ残し、外へは送らない。
+
+## [0.12.6] — 2026-10-04
+
+### 修正
+
+- Codex Stop hookで、会話の取り込みが済んだ後のL1要約backend（Codex CLI）の失敗を、`HOOK_CODEX_FAILED`（Codex hook processing failed・high）ではなく`L1_SUMMARIZER_BACKEND_FAILED`（L1 summarizer backend failed・warn）として数える（[ADR 0028](docs/adr/0028-l1-summarizer-backend-failure-code.md)）。Codex CLIが利用上限や認証切れで非0終了すると、取り込みは成功しているのにhook処理の失敗として記録されていた。hookの終了codeとstderrは変えない。要約は次のStopが同じturnからやり直す。
+- 0.9.0と0.12.5の両方で、20 turnを超えるスレッドのStopがCodex CLIの失敗で`HOOK_CODEX_FAILED`を記録することを再現した。Macに残っていた1151回の最後の1回は、そのスレッドが利用上限に当たった時刻と一致する。1151回すべてがこの形だったことを示す記録は無い。
+
+### 変更
+
+- `~/.throughline/logs/hook-failures.log`に、errorが持つ`reason`と、外部CLIの`stderr`の末尾（1000字まで）を足す。`Codex CLI summarizer failed: exit 1`だけでは、利用上限か認証切れかが分からないため。端末内にだけ残し、外へは送らない。
+
+### 試験
+
+- Observerのcursorがprojectのpath・session id・本文を持たないことを確かめる試験が、偶然落ちることがあった。sha256の16進に目印の`a257`が現れると失敗し、Windowsではpathをそのまま正規表現にしていた。目印を16進に現れない文字列にし、値をそのまま探す形に直す。製品の動作は変えていない。
+
 ## [0.12.5] — 2026-10-04
 
 ### 修正
@@ -1588,7 +1614,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.12.5...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.12.7...HEAD
+[0.12.7]: https://github.com/kitepon/Throughline/compare/v0.12.6...v0.12.7
+[0.12.6]: https://github.com/kitepon/Throughline/compare/v0.12.5...v0.12.6
 [0.12.5]: https://github.com/kitepon/Throughline/compare/v0.12.4...v0.12.5
 [0.12.4]: https://github.com/kitepon/Throughline/compare/v0.12.3...v0.12.4
 [0.12.3]: https://github.com/kitepon/Throughline/compare/v0.12.2...v0.12.3

package/docs/adr/0012-claude-stop-transcript-flush-barrier.md

@@ -23,6 +23,7 @@ turn後に現行parserで読むとlatest logical groupは1件だった。Claude
 3. latest user groupを必須にし、過去の同文assistantや前turnを一致として採用しない。
    （2026-10-03 [ADR 0026](0026-stop-flush-barrier-next-user.md)で、Stop直後に次のuser行が届いた時の未捕捉の1つ前のgroupだけを例外にした。）
 4. deadlineまで一致しなければ明示errorと`HOOK_PROCESS_TURN_FAILED`を返し、completionなしへ丸めない。
+   （2026-10-04 [ADR 0029](0029-stop-flush-barrier-absent-transcript.md)で、deadlineまでtranscriptのファイル自体が無い時だけ、失敗に数えず`transcript_absent`として見送ることにした。）
 5. markerを持たない旧Claude hostは既存one-shot transcript parser契約を維持する。
 6. Claude Stop hookの`async: true`、DB schema、receipt wire、Observer cursorは変更しない。
 

package/docs/adr/0015-l1-summarizer-model-effort-ratio.md

@@ -66,6 +66,8 @@ none/low/medium/high/xhigh）のため none を下端とした。
 4. claude-primary の backend 順序を **codex-sidecar → Codex CLI (luna@low) → Haiku →
    raw L2** にする。各段の失敗理由は結果 (`sidecarReason` / `codexCliReason`) に記録
    する宣言済み fallback。codex-primary は従来どおり Codex CLI 一本で explicit error。
+   （2026-10-04 [ADR 0028](0028-l1-summarizer-backend-failure-code.md)で、この explicit error を runtime error store では
+   `L1_SUMMARIZER_BACKEND_FAILED` として数えることにした。hook の終了 code と stderr は変えていない。）
    （実測で Haiku は timeout 完全失敗があり、luna は同等品質・半分以下のレイテンシ・
    失敗ゼロのため、Haiku より先に置く。）
 5. sidecar `summarize-l1` preset のモデルは codex-sidecar（別repo）の所有。本 ADR では

package/docs/adr/0028-l1-summarizer-backend-failure-code.md

@@ -0,0 +1,59 @@
+# ADR 0028: Codex Stop の L1 要約 backend の失敗は、hook 処理の失敗と別の code で数える
+
+日付: 2026-10-04
+
+## Context
+
+Codex Stop hook は、rollout を DB へ取り込んで commit した後、bodies が L2 window（20 turn）を超えていれば、
+最古の未要約 turn を Codex CLI（`codex exec`）で L1 に要約する。codex-primary の要約は Codex CLI 一本で、
+CLI の失敗は explicit error にする（ADR 0015 Decision 4）。
+
+この error は hook の一番外の catch まで届き、`HOOK_CODEX_FAILED`（`Throughline Codex hook processing failed`、
+severity `high`）として runtime error store に数えられていた。
+
+Mac の runtime error store には `HOOK_CODEX_FAILED` が 1151 回あった（2026-07-13 〜 2026-08-07、最後の版は 0.9.0）。
+最後の1回は 2026-08-07T06:23:58.298Z で、その Codex スレッドは同じ秒に次の turn が
+`You've hit your usage limit` で終わっている。当時の stderr はどこにも残っていない。
+
+0.9.0 と 0.12.5 の両方で、次を再現した。20 turn を超えるスレッドに Stop を送り、Codex CLI が非0で終わると、
+取り込みは成功したまま hook が `Codex CLI summarizer failed: exit N`（reason `codex_cli_failed`）で失敗し、
+`HOOK_CODEX_FAILED` が1回増える。UserPromptSubmit と PostToolUse は要約をしないので失敗しない。
+
+`HOOK_CODEX_FAILED` という code からは、取り込みが壊れたのか、外部 CLI が使えなかっただけなのかを区別できない。
+後者は Codex 側の利用上限・認証切れ・model の失敗で起き、Throughline の修理では直らない。
+
+## Decision
+
+1. Codex hook の失敗のうち、L1 要約 backend の失敗だけを `L1_SUMMARIZER_BACKEND_FAILED` として数える。
+   component は `codex_l1_summarizer`、template は `Throughline L1 summarizer backend (Codex CLI) failed`、
+   severity は `warn`。
+2. 対象は `source` が `codex-cli` で、`reason` が `codex_cli_failed`（非0終了・timeout・起動失敗）か
+   `empty_output` の error だけ。`missing_project_path` と `recursion_guard` は製品側の誤りなので、
+   `HOOK_CODEX_FAILED` のままにする。要約以外の失敗も `HOOK_CODEX_FAILED` のまま。
+3. hook の終了 code（1）と stderr（`[codex-hook] Codex CLI summarizer failed: exit N`）は変えない。
+   ADR 0015 の explicit error 契約と、失敗を隠さない原則はそのまま。変えるのは数える code だけ。
+4. `hook-failures.log`（ADR 0027）に、error が持つ `reason` と、外部 CLI の `stderr` の末尾（1000字まで）を足す。
+   `Codex CLI summarizer failed: exit 1` だけでは、利用上限なのか認証切れなのかが分からないため。
+   このログは端末内にだけ残し、外へは送らない。runtime error store には今までどおり定型 code と回数だけを入れる。
+5. severity を `warn` にする理由: 会話の取り込みは commit 済みで、記憶は失われていない。要約は次の Stop が
+   同じ turn からやり直す。L1 が無い間、recall は L2 の本文を返す（ADR 0016）。
+   BugHub が受ける severity は `fatal`・`high`・`warn`・`info` の4つで、他の値は report 全体が 422 になる
+   （2026-10-04、BugHub の `PRODUCT_REPORTING.md` と `factory-report-v1.schema.json` をBugHubの担当が確認）。
+
+## Consequences
+
+- 外部 CLI が使えない端末は、BugHub で「L1 summarizer backend failed」（warn、日次のまとめ）として見える。
+  「Codex hook processing failed」（high、即時通知）は、取り込みや hook 処理そのものの失敗だけになる。
+- fingerprint は code ごとに決まるので、新しい code は BugHub で新しい issue になる。過去の `HOOK_CODEX_FAILED` の
+  回数は移らない。
+- runtime error store は、知らない code を持つ記録を schema invalid として拒否する。この版で
+  `L1_SUMMARIZER_BACKEND_FAILED` を記録した端末を 0.12.5 以前へ戻すと、store を読めなくなる。
+- Claude Stop は対象外。claude-primary の要約は Codex CLI → Haiku → raw L2 の宣言済み fallback で、
+  backend の失敗では throw しない。
+
+## 確認できていないこと
+
+- Mac の 1151 回がすべてこの形だったことを示す記録は無い。確認できたのは、同じ code を同じ版で再現できたことと、
+  最後の1回が利用上限に当たった時刻と一致することだけ。外した仮説は、製品の試験からの漏れ、rollout の大きさ、
+  入力の形、同時実行、スレッド全体の順次再生。
+- 要約が失敗し続ける端末では、Codex の Stop hook が毎回 exit 1 になる。Codex 側の表示への影響は調べていない。

package/docs/adr/0029-stop-flush-barrier-absent-transcript.md

@@ -0,0 +1,62 @@
+# ADR 0029: transcript のファイルが無い Claude Stop は、hook 処理の失敗に数えない
+
+日付: 2026-10-04
+
+## Context
+
+ADR 0012 の flush barrier は、Stop payload の `last_assistant_message` が transcript に見えるまで最大2秒待ち、
+見えなければ `HOOK_PROCESS_TURN_FAILED`（`Throughline Claude Stop hook processing failed`、severity `high`）で
+明示失敗する。
+
+2026-10-04、BellTeam コンテナ（0.12.6）で、前日に解決登録した `HOOK_PROCESS_TURN_FAILED` が再発した。
+00:36:19.037Z と 00:36:24.188Z の2回で、理由はどちらも
+`Claude Stop transcript completion was not visible before deadline`。
+
+失敗した会話は `/tmp` で 00:35:39Z から 00:36:24Z まで動いた Claude Code（2.1.289）の1会話。
+SessionStart と UserPromptSubmit の hook は `transcript_path` を受け取っているが、その path に
+ファイルは無い。`~/.claude/history.jsonl` にもこの会話の入力は残っていない。
+前日までに同じ内容の会話が5回 `/tmp` で動いていて、その時は transcript が残り、Stop は同じ実行で保存している。
+
+同じ端末で、Claude Code を `-p --input-format stream-json --no-session-persistence` で1 turn 動かして再現した。
+Stop payload には `transcript_path` と `last_assistant_message` が渡るが、ファイルは最後まで作られず、
+Stop は応答の 2.08 秒後に同じ文面で失敗した。payload に、保存しない起動であることを示す項目は無い。
+`--no-session-persistence` を外した同じ会話は、同じ Stop で 1 turn を保存した。
+
+Throughline が保存する本文の正本は transcript だけ（ADR 0012 Decision 2）。transcript が作られない会話には、
+保存する元が無い。これは host を起動した側の指定で、Throughline の修理では直らない。
+`HOOK_PROCESS_TURN_FAILED` の回数からは、保存できたはずの会話を落としたのか、保存する元が無かったのかを
+区別できない。
+
+## Decision
+
+1. flush barrier は、期限まで待っても完了が見えず、かつ `transcript_path` のファイルが存在しない時、
+   `transcript_absent` を返す。失敗にしない。
+2. 存在の確認は期限に達した時だけ行う。遅れて書かれる transcript は、今までどおり期限まで待つ。
+3. ファイルが存在するのに完了が見えない時は、今までどおり明示失敗して `HOOK_PROCESS_TURN_FAILED` を数える
+   （ADR 0012 Decision 4）。`transcript_path` が payload に無い時も、ファイルが無いことを確かめられないので
+   失敗のままにする。
+4. `transcript_absent` の Stop は、`~/.throughline/logs/backfill.log` に
+   `{"hook":"stop","session_id":…,"transcript_path":…,"skipped":"transcript_absent"}` を1行残し、
+   終了 code 0 で終わる。DB・state file・完了受領には何も書かない。runtime error store にも数えない。
+5. hook が失敗した時の `hook-failures.log`（ADR 0027）に、Stop の `session_id` と `transcript_path` を足す。
+   今回は理由の文面だけが残り、どの会話の Stop かを他の記録から探すことになった。
+   このログは端末内にだけ置き、外へは送らない。
+
+## Consequences
+
+- transcript を残さない起動（`--no-session-persistence`）の会話は、Throughline の記憶に入らない。
+  見送った Stop は `backfill.log` で数えられる。
+- その会話の Stop hook は、今までと同じく期限（2秒）まで待ってから終わる。
+- host が transcript の置き場を変え、hook に渡す path にファイルが無くなった場合も、失敗としては数えなくなる。
+  その時は `backfill.log` に `transcript_absent` が並び、`inserted_turns` が出なくなる。
+- 期限の後に初めてファイルが作られる会話は、その Stop では保存されない。同じ会話の次の Stop が、
+  未捕捉の turn をまとめて保存する（backfill）。最後の turn で起きた時は保存されない。
+- `HOOK_PROCESS_TURN_FAILED` の fingerprint は変わらない。過去の回数は移さない。
+
+## 確認できていないこと
+
+- 2026-10-04 の2回の会話を、誰がどの引数で起動したかは特定できていない。確かめたのは、その会話の
+  transcript がディスクに無いことと、`--no-session-persistence` で起動した会話が同じ文面で失敗すること。
+  transcript が後から消された可能性は、記録からは否定できない。
+- `--no-session-persistence` 以外に、path は渡るがファイルが作られない起動の仕方があるかは調べていない。
+- 実測は Linux の Claude Code 2.1.289 だけ。macOS と Windows では確かめていない。

package/package.json

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

package/src/cli/codex-hook.mjs

@@ -360,6 +360,22 @@ async function runCodexContextRefreshInstructionHook({
   };
 }
 
+const L1_SUMMARIZER_BACKEND_REASONS = new Set(['codex_cli_failed', 'empty_output']);
+
+/**
+ * Codex hook が失敗した時に記録する runtime error の code を決める（ADR 0028）。
+ * L1 要約の backend（Codex CLI）が非0で終わった、または空を返した失敗は、取り込みの後に起きる
+ * 外部 CLI の失敗なので、hook 処理の失敗とは別の code で数える。hook の終了 code と stderr は変えない。
+ * @param {unknown} error
+ * @returns {'HOOK_CODEX_FAILED' | 'L1_SUMMARIZER_BACKEND_FAILED'}
+ */
+export function codexHookFailureCode(error) {
+  if (error?.source === 'codex-cli' && L1_SUMMARIZER_BACKEND_REASONS.has(error?.reason)) {
+    return 'L1_SUMMARIZER_BACKEND_FAILED';
+  }
+  return 'HOOK_CODEX_FAILED';
+}
+
 export async function run(argv = []) {
   suppressExperimentalWarnings();
   let parsed;
@@ -417,8 +433,9 @@ export async function run(argv = []) {
     // continue=falseは、明示した失敗理由を含めてhostへ停止を届けた返答。背景処理の成否は引き継ぎ状態へ記録する。
     process.exit(result.continue === false || result.status === 'ok' || result.status === 'skipped' ? 0 : 1);
   } catch (err) {
-    recordRuntimeErrorBestEffort('HOOK_CODEX_FAILED', { env: process.env });
-    logHookFailure('HOOK_CODEX_FAILED', err);
+    const code = codexHookFailureCode(err);
+    recordRuntimeErrorBestEffort(code, { env: process.env });
+    logHookFailure(code, err);
     const msg = err instanceof Error ? err.message : 'unknown';
     if (parsed.json) {
       process.stdout.write(

package/src/cli/codex-hook.test.mjs

@@ -6,6 +6,7 @@ import { test } from 'node:test';
 import { DatabaseSync } from 'node:sqlite';
 
 import {
+  codexHookFailureCode,
   runCodexPostToolUseHook,
   runCodexStopHook,
   runCodexUserPromptSubmitHook,
@@ -497,6 +498,19 @@ test('codex-hook stop skips cleanly when Codex thread id is unavailable', async
   }
 });
 
+test('codexHookFailureCodeは、L1要約backendの失敗だけを別のcodeにする', () => {
+  const backend = (reason) => Object.assign(new Error('x'), { source: 'codex-cli', reason });
+  assert.equal(codexHookFailureCode(backend('codex_cli_failed')), 'L1_SUMMARIZER_BACKEND_FAILED');
+  assert.equal(codexHookFailureCode(backend('empty_output')), 'L1_SUMMARIZER_BACKEND_FAILED');
+  // 製品側の誤り（projectPath 欠落・再帰）と、要約以外の失敗は hook 処理の失敗のまま。
+  assert.equal(codexHookFailureCode(backend('missing_project_path')), 'HOOK_CODEX_FAILED');
+  assert.equal(codexHookFailureCode(backend('recursion_guard')), 'HOOK_CODEX_FAILED');
+  assert.equal(codexHookFailureCode(Object.assign(new Error('x'), { reason: 'codex_cli_failed' })), 'HOOK_CODEX_FAILED');
+  assert.equal(codexHookFailureCode(new Error('database is locked')), 'HOOK_CODEX_FAILED');
+  assert.equal(codexHookFailureCode('thrown string'), 'HOOK_CODEX_FAILED');
+  assert.equal(codexHookFailureCode(null), 'HOOK_CODEX_FAILED');
+});
+
 test('codexHomeFromTranscriptPath infers CODEX_HOME from rollout path', () => {
   const path = '/tmp/codex-home/sessions/2026/05/06/rollout-2026-05-06T09-40-50-id.jsonl';
   assert.equal(_internal.codexHomeFromTranscriptPath(path), '/tmp/codex-home');

package/src/hook-failure-log.mjs

@@ -36,6 +36,19 @@ export function logHookFailure(code, error, { home, now = Date.now(), stderr = p
     name: error instanceof Error ? error.name : typeof error,
     message: message.slice(0, HOOK_FAILURE_MESSAGE_LIMIT),
   };
+  // どの会話の失敗かを残す（errorが `hookContext` を持つ時）。回数と文面だけでは、失敗した会話を
+  // 端末の他の記録から探すことになる。
+  const context = error?.hookContext;
+  if (typeof context?.session_id === 'string' && context.session_id) entry.session_id = context.session_id;
+  if (typeof context?.transcript_path === 'string' && context.transcript_path) {
+    entry.transcript_path = context.transcript_path;
+  }
+  // 外部 CLI の失敗は、message が終了 code だけになる。理由（reason）と CLI の stderr の末尾も残す
+  // （CLI は先頭に起動情報を出し、失敗の理由は末尾に出す）。
+  if (typeof error?.reason === 'string' && error.reason) entry.reason = error.reason;
+  if (typeof error?.stderr === 'string' && error.stderr) {
+    entry.stderr = error.stderr.slice(-HOOK_FAILURE_MESSAGE_LIMIT);
+  }
   const path = hookFailureLogPath(home === undefined ? {} : { home });
   try {
     mkdirSync(dirname(path), { recursive: true });

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

@@ -23,6 +23,44 @@ test('logHookFailureは、失敗の理由を1行のJSONで追記する', () => {
   }
 });
 
+test('logHookFailureは、外部CLIの失敗の理由とstderrの末尾を残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    const err = new Error('Codex CLI summarizer failed: exit 1');
+    err.reason = 'codex_cli_failed';
+    err.stderr = `${'banner '.repeat(300)}ERROR: usage limit`;
+    logHookFailure('L1_SUMMARIZER_BACKEND_FAILED', err, { home });
+    const [entry] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.equal(entry.code, 'L1_SUMMARIZER_BACKEND_FAILED');
+    assert.equal(entry.message, 'Codex CLI summarizer failed: exit 1');
+    assert.equal(entry.reason, 'codex_cli_failed');
+    assert.equal(entry.stderr.length, HOOK_FAILURE_MESSAGE_LIMIT);
+    assert.match(entry.stderr, /ERROR: usage limit$/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('logHookFailureは、どの会話の失敗かを残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    const withContext = new Error('with context');
+    withContext.hookContext = { session_id: 'session-a', transcript_path: '/claude/projects/-tmp/session-a.jsonl' };
+    logHookFailure('HOOK_PROCESS_TURN_FAILED', withContext, { home });
+    // 文字列でない値と空文字は残さない（payloadを読む前の失敗では、手がかりがまだ無い）。
+    const withoutContext = new Error('without context');
+    withoutContext.hookContext = { session_id: '', transcript_path: undefined };
+    logHookFailure('HOOK_PROCESS_TURN_FAILED', withoutContext, { home });
+    const [first, second] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.equal(first.session_id, 'session-a');
+    assert.equal(first.transcript_path, '/claude/projects/-tmp/session-a.jsonl');
+    assert.equal('session_id' in second, false);
+    assert.equal('transcript_path' in second, false);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('logHookFailureは、長い文面を上限で切る', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
   try {

package/src/observer-turn-feed.test.mjs

@@ -126,7 +126,7 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   try {
     const options = box.receiptOptions;
     seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: options, targetSessionId: 'claude-session' });
-    writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: 'o257', userBody: 'u257', assistantBody: 'a257', completedAt: 257 }, options);
+    writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: 'o257', userBody: 'user-body-257', assistantBody: 'assistant-body-257', completedAt: 257 }, options);
     const latest = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     const decoded = decodeObserverCursor(latest.throughCursor);
     const beforeFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });
@@ -137,7 +137,12 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
     const changedPrefix = encodeObserverCursor({ ...decoded, prefix_sha256: 'f'.repeat(64) });
     assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: changedPrefix, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
     assert.throws(() => encodeObserverCursor({ ...decoded, length: 0 }), /cursor invalid/);
-    assert.doesNotMatch(JSON.stringify(decoded), new RegExp(`${box.project}|claude-session|u257|a257`));
+    // cursor は project の path・session id・本文を持たない。目印は16進に現れない文字列にし、正規表現を使わず
+    // 値をそのまま探す（sha256 の16進に `a257` が偶然現れる、Windows の path が正規表現として壊れる、の2つを避ける）。
+    const cursorValues = Object.values(decoded).map(String).join('\n');
+    for (const secret of [box.project, 'claude-session', 'user-body-257', 'assistant-body-257']) {
+      assert.equal(cursorValues.includes(secret), false, secret);
+    }
     const id = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
     writeRollout(box.home, box.project, id, completeEvents('2026-07-15T00:03:00.000Z'));
     const switched = resolveObserverTurnFeed({ projectPath: box.project, cursor: latest.throughCursor, receiptOptions: options, codexHome: box.home });

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

@@ -1,7 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { execFileSync, spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -69,6 +70,122 @@ test('top-level hook owners record one fixed aggregate per failure without repla
   assert.equal(store.records.find((record) => record.error_code === 'HOOK_PROCESS_TURN_FAILED').count, 2);
 });
 
+test('Claude Stopで、transcriptのファイルが無い会話は失敗に数えず、ファイルがあって完了が見えない時だけ数える', () => {
+  const { root, env } = createEnabledEnvironment('throughline-runtime-stop-absent-');
+  const storePath = defaultRuntimeErrorStorePath(env);
+  const stop = (payload) => spawnSync(process.execPath, [BIN, 'process-turn'], {
+    env, cwd: root, input: JSON.stringify(payload), encoding: 'utf8',
+  });
+  const readLog = (name) => readFileSync(join(root, '.throughline', 'logs', name), 'utf8')
+    .trim().split('\n').map((line) => JSON.parse(line));
+
+  // `--no-session-persistence` のClaude Code（2.1.289で実測）: pathは渡るが、ファイルは作られない。
+  const absentPath = join(root, 'never-written.jsonl');
+  const absent = stop({
+    session_id: 'a1b2c3d4-0000-4000-8000-000000000001', transcript_path: absentPath, cwd: root,
+    hook_event_name: 'Stop', stop_hook_active: false, last_assistant_message: 'PROBE_OK',
+  });
+  assert.equal(absent.status, 0, absent.stderr);
+  assert.equal(absent.stderr, '');
+  assert.equal(existsSync(storePath), false, 'an absent transcript must not be counted as a hook failure');
+  assert.equal(existsSync(join(root, '.throughline', 'logs', 'hook-failures.log')), false);
+  assert.deepEqual(readLog('backfill.log').map(({ ts, ...entry }) => entry), [{
+    hook: 'stop',
+    session_id: 'a1b2c3d4-0000-4000-8000-000000000001',
+    target: 'a1b2c3d4-0000-4000-8000-000000000001',
+    origin: 'a1b2c3d4-0000-4000-8000-000000000001',
+    transcript_path: absentPath,
+    skipped: 'transcript_absent',
+  }]);
+
+  // ファイルはあるのに、Stopが渡した応答がそこに無い。保存できなかった会話なので、失敗のまま数える。
+  const presentPath = join(root, 'present.jsonl');
+  writeFileSync(presentPath, JSON.stringify({ type: 'user', message: { role: 'user', content: 'request' } }) + '\n');
+  const present = stop({
+    session_id: 'a1b2c3d4-0000-4000-8000-000000000002', transcript_path: presentPath, cwd: root,
+    hook_event_name: 'Stop', stop_hook_active: false, last_assistant_message: 'PROBE_OK',
+  });
+  assert.equal(present.status, 1);
+  assert.match(present.stderr, /not visible before deadline/);
+  const store = JSON.parse(readFileSync(storePath, 'utf8'));
+  assert.deepEqual(store.records.map((record) => [record.error_code, record.count]), [['HOOK_PROCESS_TURN_FAILED', 1]]);
+  const [failure] = readLog('hook-failures.log');
+  assert.equal(failure.code, 'HOOK_PROCESS_TURN_FAILED');
+  assert.equal(failure.session_id, 'a1b2c3d4-0000-4000-8000-000000000002');
+  assert.equal(failure.transcript_path, presentPath);
+});
+
+function makeBin(dir, name, body) {
+  const script = join(dir, `${name}.mjs`);
+  writeFileSync(script, body);
+  if (process.platform === 'win32') {
+    const command = join(dir, `${name}.cmd`);
+    writeFileSync(command, `@echo off\r\n${JSON.stringify(process.execPath)} ${JSON.stringify(script)} %*\r\n`);
+    writeFileSync(join(dir, `${name}.ps1`), `& ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} @args\nexit $LASTEXITCODE\n`);
+    return command;
+  }
+  const command = join(dir, name);
+  writeFileSync(command, `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} "$@"\n`);
+  chmodSync(command, 0o755);
+  return command;
+}
+
+test('Codex StopでL1要約backendが失敗した時、取り込みは残り、別のcodeで1回数える', () => {
+  const { root, env } = createEnabledEnvironment('throughline-runtime-hook-summarizer-');
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const project = join(root, 'project');
+  const codexHome = join(root, 'codex');
+  const rolloutDir = join(codexHome, 'sessions', '2026', '05', '06');
+  mkdirSync(project, { recursive: true });
+  mkdirSync(rolloutDir, { recursive: true });
+  const at = '2026-05-06T00:41:00.000Z';
+  const event = (type, payload = {}) => ({ timestamp: at, type: 'event_msg', payload: { type, ...payload } });
+  const rows = [{ timestamp: at, type: 'session_meta',
+    payload: { id: threadId, timestamp: at, cwd: project, source: 'vscode', cli_version: '0.128.0-alpha.1' } }];
+  // L2 window（20 turn）を超えると、Stop は最古の turn を Codex CLI で要約する。
+  for (let turn = 0; turn < 22; turn += 1) {
+    rows.push(event('user_message', { message: `request ${turn}` }), event('task_started'),
+      { timestamp: at, type: 'turn_context', payload: { model: 'gpt-5.5', cwd: project } },
+      event('agent_message', { message: `answer ${turn}` }), event('task_complete'));
+  }
+  const rolloutPath = join(rolloutDir, `rollout-2026-05-06T09-40-50-${threadId}.jsonl`);
+  writeFileSync(rolloutPath, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+  const binDir = join(root, 'bin');
+  mkdirSync(binDir, { recursive: true });
+  const codex = makeBin(binDir, 'codex', "process.stderr.write('ERROR: usage limit reached\\n');\nprocess.exit(42);\n");
+
+  const result = spawnSync(process.execPath, [BIN, 'codex-hook', 'stop'], {
+    env: { ...env, CODEX_HOME: codexHome, THROUGHLINE_CODEX_CLI_BIN: codex },
+    input: JSON.stringify({ session_id: threadId, transcript_path: rolloutPath, cwd: project }),
+    encoding: 'utf8',
+  });
+
+  // hook は明示して失敗する（終了 code と stderr は変えない）。
+  assert.equal(result.status, 1, result.stderr);
+  assert.match(result.stderr, /\[codex-hook\] Codex CLI summarizer failed: exit 42/);
+
+  const store = JSON.parse(readFileSync(defaultRuntimeErrorStorePath(env), 'utf8'));
+  assert.deepEqual(store.records.map((record) => [record.error_code, record.component, record.severity, record.count]), [
+    ['L1_SUMMARIZER_BACKEND_FAILED', 'codex_l1_summarizer', 'warn', 1],
+  ]);
+
+  // 取り込みは要約の前に commit 済み。
+  const db = new DatabaseSync(join(root, '.throughline', 'throughline.db'));
+  try {
+    const { n } = db.prepare("SELECT COUNT(*) AS n FROM bodies WHERE session_id = ? AND role = 'assistant'")
+      .get(`codex:${threadId}`);
+    assert.equal(n, 22);
+  } finally {
+    db.close();
+  }
+
+  const [entry] = readFileSync(join(root, '.throughline', 'logs', 'hook-failures.log'), 'utf8')
+    .trim().split('\n').map((line) => JSON.parse(line));
+  assert.equal(entry.code, 'L1_SUMMARIZER_BACKEND_FAILED');
+  assert.equal(entry.reason, 'codex_cli_failed');
+  assert.match(entry.stderr, /usage limit reached/);
+});
+
 test('store failure preserves product failure and emits only fixed storage diagnostic', () => {
   const { env } = createEnabledEnvironment('throughline-runtime-hook-store-fail-');
   const storePath = defaultRuntimeErrorStorePath(env);

package/src/runtime-error-store.mjs

@@ -52,6 +52,13 @@ const DEFINITIONS = Object.freeze({
     severity: 'high',
     template: 'Throughline Codex hook processing failed',
   }),
+  // Codex Stop の取り込みは済み、L1 要約の backend（Codex CLI）だけが失敗した（ADR 0028）。
+  L1_SUMMARIZER_BACKEND_FAILED: Object.freeze({
+    component: 'codex_l1_summarizer',
+    // BugHub が受ける severity は fatal・high・warn・info だけ。他の値は report 全体が 422 になる。
+    severity: 'warn',
+    template: 'Throughline L1 summarizer backend (Codex CLI) failed',
+  }),
 });
 
 export function defaultRuntimeErrorConfigPath(env = process.env) {

package/src/turn-processor.mjs

@@ -44,6 +44,7 @@ import { summarizeToL1 } from './haiku-summarizer.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
 import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
@@ -69,6 +70,10 @@ const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, mil
  *
  * markerとtranscriptの本文は、前後の空白を除いて比べる（ADR 0027）。Claude Codeはmarkerを
  * `.trim()` して渡すので、本文が空白や改行で始まる（終わる）turnは、そのままでは一致しない。
+ *
+ * 期限まで待ってもtranscriptのファイル自体が無い時は、失敗にせず `transcript_absent` を返す
+ * （ADR 0029）。Claude Codeを `--no-session-persistence` で起動すると、hookへ `transcript_path` は
+ * 渡るが、ファイルは最後まで作られない。ファイルがあるのに完了が見えない時は、今までどおり失敗にする。
  */
 export async function waitForClaudeStopTranscriptFlush({
   transcriptPath,
@@ -78,6 +83,7 @@ export async function waitForClaudeStopTranscriptFlush({
   readCompletion,
   readCompletions = readLatestLogicalTurnCompletions,
   isTurnCaptured = () => true,
+  transcriptExists = existsSync,
   now = Date.now,
   wait = delay,
 }) {
@@ -106,6 +112,9 @@ export async function waitForClaudeStopTranscriptFlush({
     }
     const remaining = deadline - now();
     if (remaining <= 0) {
+      if (typeof transcriptPath === 'string' && transcriptPath && !transcriptExists(transcriptPath)) {
+        return { status: 'transcript_absent' };
+      }
       throw new Error('Claude Stop transcript completion was not visible before deadline');
     }
     await wait(Math.min(intervalMs, remaining));
@@ -212,7 +221,20 @@ function buildL2ForSummary(userTurn, assistantTurn) {
   return parts.join('\n\n');
 }
 
+/** 失敗した時に hook-failures.log へ残す、どの会話のStopだったかの手がかり。 */
+let failureContext = {};
+
 export async function run() {
+  try {
+    await processStop();
+  } catch (err) {
+    // 失敗を記録するのは呼び出し側（bin/throughline.mjs と下の直接実行）。errorに手がかりを持たせて渡す。
+    if (err instanceof Error) err.hookContext = failureContext;
+    throw err;
+  }
+}
+
+async function processStop() {
   if (process.env.THROUGHLINE_IN_HAIKU_SUBPROCESS === '1') {
     process.exit(0);
   }
@@ -229,6 +251,7 @@ export async function run() {
   const payload = parseHookPayload(raw || '{}', { env: process.env });
   const { session_id, transcript_path, cwd, last_assistant_message } = payload;
   if (!session_id) throw new Error('Missing session_id in Stop payload');
+  failureContext = { session_id, transcript_path };
 
   // VSCode で開かれたプロジェクトに .vscode/tasks.json を自動プロビジョニングする。
   // 2 回目以降は冪等性チェックで即 return するので毎ターン走っても安全。
@@ -245,11 +268,24 @@ export async function run() {
   const { target, origin } = resolveMergeTarget(db, session_id);
 
   if (hostAdapterForSessionId(session_id).waitsForStopTranscriptFlush) {
-    await waitForClaudeStopTranscriptFlush({
+    const flush = await waitForClaudeStopTranscriptFlush({
       transcriptPath: transcript_path,
       lastAssistantMessage: last_assistant_message,
       isTurnCaptured: (fragmentTurnNumbers) => isLogicalTurnCaptured(db, origin, fragmentTurnNumbers),
     });
+    if (flush.status === 'transcript_absent') {
+      // 保存する元が無い。失敗には数えず、どの会話のStopを見送ったかを端末内に残す（ADR 0029）。
+      logBackfill({
+        ts: new Date().toISOString(),
+        hook: 'stop',
+        session_id,
+        target,
+        origin,
+        transcript_path,
+        skipped: 'transcript_absent',
+      });
+      process.exit(0);
+    }
   }
 
   // Stop hook 時点で state ファイルを更新 → token-monitor の「アクティブ行」判定が

package/src/turn-processor.test.mjs

@@ -222,6 +222,7 @@ test('Claude Stop flush barrierはmarker不一致をdeadlineで明示失敗す
       timeoutMs: 30,
       intervalMs: 10,
       readCompletion: () => ({ userTurnNumber: 4, assistantTurnNumber: null, assistantContent: null }),
+      transcriptExists: () => true,
       now: () => elapsed,
       wait: async (milliseconds) => { elapsed += milliseconds; },
     }),
@@ -230,6 +231,49 @@ test('Claude Stop flush barrierはmarker不一致をdeadlineで明示失敗す
   assert.equal(elapsed, 30);
 });
 
+test('Claude Stop flush barrierは、期限までtranscriptのファイルが無い時だけtranscript_absentを返す', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'throughline-stop-absent-'));
+  const transcriptPath = join(root, 'never-written.jsonl');
+  let elapsed = 0;
+  const clock = { now: () => elapsed, wait: async (milliseconds) => { elapsed += milliseconds; } };
+  try {
+    // `--no-session-persistence` のClaude Code: pathは渡るが、ファイルは最後まで作られない。期限までは待つ。
+    assert.deepEqual(await waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'PROBE_OK', timeoutMs: 30, intervalMs: 10, ...clock,
+    }), { status: 'transcript_absent' });
+    assert.equal(elapsed, 30, 'a transcript that is written late must still get the whole deadline');
+
+    // 待っている間にファイルが作られ、完了が見えた時は、今までどおり採用する。
+    elapsed = 0;
+    let reads = 0;
+    assert.deepEqual(await waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'late answer', timeoutMs: 100, intervalMs: 10, ...clock,
+      readCompletions: () => {
+        reads++;
+        if (reads < 3) return { latest: null, previous: null };
+        return { latest: { userTurnNumber: 0, assistantTurnNumber: 1, assistantContent: 'late answer', fragmentTurnNumbers: [1] }, previous: null };
+      },
+    }), { status: 'ready', userTurnNumber: 0, assistantTurnNumber: 1 });
+
+    // ファイルはあるのに完了が見えない時は、失敗のまま。
+    writeFileSync(transcriptPath, JSON.stringify({ type: 'user', message: { role: 'user', content: 'request' } }), 'utf8');
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'PROBE_OK', timeoutMs: 30, intervalMs: 10, ...clock,
+    }), /not visible before deadline/);
+
+    // pathが渡らないpayloadは、ファイルが無いことを確かめられない。失敗のまま。
+    for (const missingPath of [undefined, null, '']) {
+      elapsed = 0;
+      await assert.rejects(waitForClaudeStopTranscriptFlush({
+        transcriptPath: missingPath, lastAssistantMessage: 'PROBE_OK', 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({