throughline 0.16.3 → 0.16.4

package/CHANGELOG.md

@@ -10,6 +10,25 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.4] — 2026-10-07
+
+### 変更
+
+- Codex StopのL1要約backend（Codex CLI）の失敗を、1回ごとにruntime errorとして数えるのをやめる（[ADR 0041](docs/adr/0041-l1-summarizer-backend-unrecovered.md)）。この失敗は、通信の断、利用上限、認証切れ、利用者の取り消しでも起きる。会話の取り込みは済んでいて、要約は次のStopがやり直し、recallはL2の本文を返すので、修理の対象として自動で登録しない。理由と外部CLIのstderrの末尾は、今までどおり端末の`hook-failures.log`に残る。hookの終了codeとstderrは変えない。
+- 最初の失敗から24時間を過ぎても成功を確認できない時だけ、`L1_SUMMARIZER_BACKEND_UNRECOVERED`（`warn`）で数える。要約が成功したら、その記録を`recovered`で解決にする。
+- Codexの自動継続のworkerは、要約のbackendの失敗を`handoff_summarizer_backend_failed`で止める（今までは汎用の`handoff_worker_failed`）。失敗の画面に、通信の断・利用上限・認証切れで起きる事、記録と入力が失われていない事、再開の仕方を書く。
+
+### 変わらない事
+
+- BugHubへ送る本文の形。項目は足していない。
+- hook処理の失敗（`HOOK_*_FAILED`）の数え方と重大度。これらの経路に通信は無い。
+- BugHubへの送信の失敗は、今までどおり送信の状態にだけ残し、runtime errorには数えない。
+
+### 確認していない範囲
+
+- 要約が失敗し続ける間のCodexの画面への影響。
+- 本物のCodex CLIが、通信の断・利用上限・認証切れのそれぞれで返す終了codeとstderr。
+
 ## [0.16.3] — 2026-10-07
 
 ### 修正
@@ -1940,7 +1959,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.3...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.4...HEAD
+[0.16.4]: https://github.com/kitepon/Throughline/compare/v0.16.3...v0.16.4
 [0.16.3]: https://github.com/kitepon/Throughline/compare/v0.16.2...v0.16.3
 [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

package/docs/adr/0041-l1-summarizer-backend-unrecovered.md

@@ -0,0 +1,77 @@
+# ADR 0041: L1 要約 backend の失敗は、復帰を確認できない時だけ数える
+
+日付: 2026-10-07
+
+## Context
+
+オーナーは、通信失敗の報告・重大度・担当の決まりを定めた（2026-10-07、BugHub の `NETWORK_REPORTING.md`）。
+通信環境そのものの不調と、その状態への製品の対処不良を分ける。通常のオフライン、正常な取り消し、
+適切に処理された一時的な失敗を、自動で製品の欠陥として登録しない。必要な診断は保持する。重大度は
+エラーコードや回数だけで固定せず、機能停止・データの喪失・重複・復帰の可否を根拠に付ける。
+
+Throughline が runtime error として数える code は7つで、通信の失敗が入るのは `L1_SUMMARIZER_BACKEND_FAILED`
+（ADR 0028）だけだった。Codex Stop の要約は外部 CLI（`codex exec`）を呼ぶ。通信の断、利用上限、認証切れ、
+model の失敗、利用者の取り消しによる停止で、CLI は非0で終わるか空を返す。0.16.3 までは、この失敗を
+1回ごとに `warn` で数え、BugHub へ未解決の記録として送っていた。
+
+この失敗への Throughline の対処は、次のとおり（ADR 0015・0016・0028）。
+
+- 会話の取り込みは、要約の前に commit している。記憶は失われない。
+- 要約は、次の Stop が同じ turn からやり直す。重複は作らない。
+- L1 が無い間、recall は L2 の本文を返す。
+- hook は終了 code 1 と stderr で失敗を示す。理由と外部 CLI の stderr の末尾は、端末の `hook-failures.log` に残る。
+
+1回ごとの失敗は「適切に処理された一時的な失敗」に当たり、修理の対象として登録する物ではない。
+一方、backend が使えないまま続く端末では、古い turn の要約が作られず、Codex の自動継続は要約を作れずに
+止まる。この影響を隠さない。
+
+他の通信の扱いは、次のとおりで、変えない。
+
+- BugHub への送信の失敗（`unreachable` など）は、送信の状態（`runtime-errors report-status`）にだけ残し、
+  runtime error には数えない。次の時機に、その時点の累計を送り直す。hook の結果は変えない。
+- Claude Code の要約は、Codex CLI → Haiku → L2 の本文の、宣言済みの fallback。backend の失敗では throw せず、数えない。
+- `self-update` の npm の失敗は、呼び出し元へ結果として返す。runtime error には数えない。
+- hook 処理の失敗（`HOOK_*_FAILED`）の経路に、通信は無い。
+
+## Decision
+
+1. `L1_SUMMARIZER_BACKEND_FAILED` を、runtime error として数えるのをやめる。失敗の理由と stderr の末尾は、
+   今までどおり `hook-failures.log` に、この code の名前で残す（端末内だけ）。hook の終了 code と stderr は変えない。
+2. 端末ごとに、成功を確認できていない間の最初と最後の失敗の時刻を持つ
+   （`~/.throughline/l1-backend-recovery.json`。会話の内容も失敗の文面も書かない）。
+3. 最初の失敗から24時間を過ぎた後の失敗は、`L1_SUMMARIZER_BACKEND_UNRECOVERED` として数える。
+   component は `codex_l1_summarizer`、template は
+   `Throughline L1 summarizer backend (Codex CLI) has not recovered for over 24 hours`、severity は `warn`。
+4. severity を `warn` にする根拠は影響。記憶は失われていない（取り込みは済み、recall は L2 を返す）。重複は無い。
+   backend が戻れば、次の Stop で自動で復帰する。機能が止まるのは、Codex の自動継続が古い turn の要約を
+   作れない時で、その時は5の画面が出て、入力と記録は残り、再開できる。
+5. Codex の自動継続の worker は、要約の backend の失敗を、汎用の `handoff_worker_failed` ではなく
+   `handoff_summarizer_backend_failed` で止める。失敗の画面に、通信の断・利用上限・認証切れで起きる事、
+   記録と入力が失われていない事、backend が使える様になった後に旧タスクへ入力すると引き継ぎを始め直す事を書く。
+6. backend が要約を返したら、2の記録を消す。3を数えていた時は、その記録を `recovered` で解決にする
+   （製品の明示の解決。BugHub へは次の送信で届く）。復帰の後の失敗は、また最初から数える。
+7. 前の版が `L1_SUMMARIZER_BACKEND_FAILED` を記録した store を読める様に、その定義は残す。
+8. 送信の本文の形（BugHub の契約）は変えない。項目を足さない。
+
+ADR 0028 の1（1回ごとに数える）と5（severity の根拠のうち、数える条件）は、この ADR で置き換える。
+ADR 0028 の2（対象の error）・3（終了 code と stderr）・4（`hook-failures.log`）は変えない。
+
+## Consequences
+
+- 通信の一時的な断、利用上限、取り消しで要約が1回失敗しても、BugHub には何も出ない。端末の `hook-failures.log` で読める。
+- backend が使えないままの端末は、最初の失敗から24時間を過ぎた後の失敗で、BugHub に `warn` の未解決として出る。
+  これは「復帰を確認できていない」という事実で、原因が通信環境か、認証か、製品かは決めていない。
+  記録の担当は Throughline の保守だが、通信環境や認証の修理は、その環境を管理する担当へ渡す。
+- 「24時間」は、最初の失敗からの経過で見る。その間ずっと失敗し続けていた証明ではない（間に Stop が無ければ、
+  試していない）。記録は成功で自動で解決になる。
+- 要約が成功したかを見るのは、要約を実際に行った Stop だけ。20 turn 以内のスレッドの Stop は、復帰の証拠にしない。
+- runtime error store は、知らない code を持つ記録を schema invalid として拒否する。この版で
+  `L1_SUMMARIZER_BACKEND_UNRECOVERED` を記録した端末を 0.16.3 以前へ戻すと、store を読めなくなる。
+- 0.16.3 までに `L1_SUMMARIZER_BACKEND_FAILED` を記録した端末の記録は、そのまま残る。書き換えない。
+  保守の担当が、端末の正規の入口（`runtime-errors resolve`）で、根拠を付けて閉じる。
+
+## 確認していない範囲
+
+- 要約が失敗し続ける間、Codex の Stop hook は毎回 exit 1 になる。Codex の画面への影響は調べていない（ADR 0028 と同じ）。
+- 本物の Codex CLI が、通信の断・利用上限・認証切れのそれぞれで、どの終了 code と stderr を返すか。
+  試験は、非0で終わる代わりの CLI で行った。

package/package.json

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

package/src/cli/codex-hook.mjs

@@ -1,4 +1,4 @@
-import { recordRuntimeErrorBestEffort } from '../runtime-error-store.mjs';
+import { recordRuntimeErrorBestEffort, resolveRecoveredRuntimeErrorBestEffort } from '../runtime-error-store.mjs';
 import { logHookFailure } from '../hook-failure-log.mjs';
 
 function parseArgs(argv) {
@@ -422,6 +422,13 @@ export async function run(argv = []) {
         payload,
         env: process.env,
       });
+      // backend が要約を返した。失敗の後なら、復帰を確認できた（ADR 0041）。失敗の記録が無い時は、ファイルの有無を見るだけ。
+      if (result.summarized?.summarized?.some((turn) => turn.source === 'codex-cli')) {
+        const { noteL1BackendSuccess } = await import('../l1-backend-recovery.mjs');
+        if (noteL1BackendSuccess().reported) {
+          resolveRecoveredRuntimeErrorBestEffort('L1_SUMMARIZER_BACKEND_UNRECOVERED', { env: process.env });
+        }
+      }
     }
     if (parsed.event === 'pre-compact' && result.continue === false) {
       process.stdout.write(JSON.stringify({ continue: false, stopReason: result.stopReason }) + '\n');
@@ -434,7 +441,16 @@ export async function run(argv = []) {
     process.exit(result.continue === false || result.status === 'ok' || result.status === 'skipped' ? 0 : 1);
   } catch (err) {
     const code = codexHookFailureCode(err);
-    recordRuntimeErrorBestEffort(code, { env: process.env });
+    if (code === 'L1_SUMMARIZER_BACKEND_FAILED') {
+      // 取り込みは済み、要約は次の Stop がやり直す。1回ごとの失敗（通信の断・利用上限・取り消しを含む）は
+      // 端末の診断（hook-failures.log）にだけ残す。復帰を24時間確認できていない時だけ数える（ADR 0041）。
+      const { noteL1BackendFailure } = await import('../l1-backend-recovery.mjs');
+      if (noteL1BackendFailure().unrecovered) {
+        recordRuntimeErrorBestEffort('L1_SUMMARIZER_BACKEND_UNRECOVERED', { env: process.env });
+      }
+    } else {
+      recordRuntimeErrorBestEffort(code, { env: process.env });
+    }
     logHookFailure(code, err);
     const msg = err instanceof Error ? err.message : 'unknown';
     if (parsed.json) {

package/src/codex-auto-handoff.mjs

@@ -342,6 +342,7 @@ export function showAutoHandoffFailure(operation) {
 <h1>自動継続を完了できませんでした</h1><p>引き継ぎは下記の工程で止まっています。タスクと記録を確認してください。</p>
 <p><a href="codex://threads/${escape(operation.source_thread_id)}">旧タスクを開く</a>${operation.target_thread_id ? ` / <a href="codex://threads/${escape(operation.target_thread_id)}">後継タスクを開く</a>` : ''}</p>
 <p>理由: <code>${escape(operation.error_code)}</code></p><p>引き継ぎID: <code>${escape(operation.handoff_id)}</code></p>
+${operation.error_code === 'handoff_summarizer_backend_failed' ? '<p>記憶の要約に使うCodex CLIが失敗しました。通信の断、利用上限、認証切れなどで起きます。会話の記録と入力は失われていません。Codex CLIが使える様になった後、旧タスクへ入力すると、引き継ぎをもう一度始めます。</p>' : ''}
 <p>状態: ${escape(operation.state)} / 停止した工程: ${escape(operation.resume_state)}</p>
 <p>確認: <code>throughline auto-handoff status --operation ${escape(operation.handoff_id)}</code></p>
 <p>原因を解消した後の再開: <code>throughline auto-handoff resume --operation ${escape(operation.handoff_id)}</code></p>
@@ -408,7 +409,14 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
         const state = deps.readSource(operation);
         update({ snapshot_json: freezeCodexMemory(db, operation, operation.settings, state) });
       }
-      deps.summaries(db, operation);
+      try { deps.summaries(db, operation); }
+      catch (cause) {
+        // 古いturnの要約を作るbackend（Codex CLI）が使えない。通信の断・利用上限・認証切れでも起きる。
+        // 汎用の理由にせず、固定の理由で止める。失敗の画面に、失われた物が無い事と再開の仕方を書く（ADR 0041）。
+        if ((cause?.source === 'codex-cli' && ['codex_cli_failed', 'empty_output'].includes(cause.reason)) ||
+            cause?.message === 'handoff_l1_unavailable') throw error('handoff_summarizer_backend_failed');
+        throw cause;
+      }
       update({ state: 'memory_ready' });
     }
     if (operation.state === 'memory_ready') {

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

@@ -614,3 +614,20 @@ test('引き継ぎの最中に旧タスクへ来た入力は、凍結する記
   assert.equal(freezeCodexMemory(db, operation, {}, { stoppedAt: 305, laterTurns: later }).bodies.length, 3);
   assert.equal(freezeCodexMemory(db, operation, {}, { stoppedAt: 200, laterTurns: [later[0]] }).bodies.length, 3);
 }));
+
+test('要約のbackendが使えない時、workerは固定の理由で止まり、後継を作らない', async () => withDb(async db => {
+  const backend = reason => Object.assign(new Error('Codex CLI summarizer failed: exit 1'), { source: 'codex-cli', reason });
+  const cases = [[backend('codex_cli_failed'), 'handoff_summarizer_backend_failed'], [backend('empty_output'), 'handoff_summarizer_backend_failed'],
+    [new Error('handoff_l1_unavailable'), 'handoff_summarizer_backend_failed'],
+    // 製品側の誤り（要約の呼び方の間違い）と、他の失敗は、今までどおり汎用の理由。
+    [backend('recursion_guard'), 'handoff_worker_failed'], [new Error('別の失敗'), 'handoff_worker_failed']];
+  for (const [index, [cause, expected]] of cases.entries()) {
+    const operation = request(db, `summarizer-${index}`, { now: 1 }).operation;
+    const counters = { created: 0, submitted: 0, notified: 0 };
+    const deps = workerDependencies(db, {}, async () => { counters.submitted++; }, counters);
+    deps.summaries = () => { throw cause; };
+    const result = await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps });
+    assert.equal(result.state, 'failed'); assert.equal(result.error_code, expected); assert.equal(result.resume_state, 'source_stopped');
+    assert.equal(counters.created, 0); assert.equal(counters.submitted, 0); assert.equal(counters.notified, 1);
+  }
+}));

package/src/l1-backend-recovery.mjs

@@ -0,0 +1,74 @@
+/**
+ * l1-backend-recovery.mjs — L1 要約の backend（Codex CLI）が失敗してから、復帰を確認できたかの記録 (ADR 0041)
+ *
+ * Codex Stop の要約は外部 CLI を呼ぶ。通信の断、利用上限、認証切れ、利用者の取り消しでも失敗する。
+ * 会話の取り込みは済んでいて、要約は次の Stop がやり直すので、1回ごとの失敗は修理の対象として数えない。
+ * 最初の失敗から期限（24時間）を過ぎても成功を確認できていない時だけ、runtime error として数える。
+ *
+ * 端末ごとに1つのファイル（~/.throughline/l1-backend-recovery.json）に、成功を確認できていない間の
+ * 最初と最後の失敗の時刻だけを持つ。会話の内容も失敗の文面も書かない（文面は hook-failures.log に残る）。
+ * 読み書きの失敗は stderr に出し、hook の結果を変えない。
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const L1_BACKEND_RECOVERY_SCHEMA = 'throughline.l1_backend_recovery.v1';
+export const L1_BACKEND_UNRECOVERED_MS = 24 * 60 * 60 * 1000;
+
+export function l1BackendRecoveryPath({ home = homedir() } = {}) {
+  return join(home, '.throughline', 'l1-backend-recovery.json');
+}
+
+function read(path) {
+  try {
+    const state = JSON.parse(readFileSync(path, 'utf8'));
+    if (state?.schema !== L1_BACKEND_RECOVERY_SCHEMA || !Number.isFinite(state.first_failure_at)) return null;
+    return state;
+  } catch (error) {
+    if (error.code !== 'ENOENT') process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return null;
+  }
+}
+
+/**
+ * backend の失敗を1回記す。最初の失敗から期限を過ぎていれば unrecovered を返す。
+ * @returns {{ unrecovered: boolean, firstFailureAt: number|null }}
+ */
+export function noteL1BackendFailure({ home, now = Date.now() } = {}) {
+  const path = l1BackendRecoveryPath({ home });
+  try {
+    const previous = read(path);
+    const firstFailureAt = previous?.first_failure_at ?? now;
+    const unrecovered = now - firstFailureAt >= L1_BACKEND_UNRECOVERED_MS;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify({ schema: L1_BACKEND_RECOVERY_SCHEMA, first_failure_at: firstFailureAt,
+      last_failure_at: now, reported: Boolean(previous?.reported) || unrecovered })}\n`, { mode: 0o600 });
+    renameSync(temporary, path);
+    return { unrecovered, firstFailureAt };
+  } catch (error) {
+    process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return { unrecovered: false, firstFailureAt: null };
+  }
+}
+
+/**
+ * backend が要約を返した。失敗の記録があれば消す。期限を過ぎて runtime error に数えていた時は reported を返す。
+ * 記録が無い時（ふだん）は、ファイルの有無を1回見るだけで終わる。
+ * @returns {{ recovered: boolean, reported: boolean }}
+ */
+export function noteL1BackendSuccess({ home } = {}) {
+  const path = l1BackendRecoveryPath({ home });
+  if (!existsSync(path)) return { recovered: false, reported: false };
+  try {
+    const previous = read(path);
+    rmSync(path, { force: true });
+    return { recovered: true, reported: Boolean(previous?.reported) };
+  } catch (error) {
+    process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return { recovered: false, reported: false };
+  }
+}

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

@@ -144,7 +144,7 @@ function makeBin(dir, name, body) {
   return command;
 }
 
-test('Codex StopでL1要約backendが失敗した時、取り込みは残り、別のcodeで1回数える', () => {
+test('Codex StopのL1要約backendの失敗は1回ごとには数えず、24時間復帰を確認できない時だけ数え、成功で解決にする', () => {
   const { root, env } = createEnabledEnvironment('throughline-runtime-hook-summarizer-');
   const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
   const project = join(root, 'project');
@@ -168,20 +168,29 @@ test('Codex StopでL1要約backendが失敗した時、取り込みは残り、
   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 },
+  const stop = (bin) => spawnSync(process.execPath, [BIN, 'codex-hook', 'stop'], {
+    env: { ...env, CODEX_HOME: codexHome, THROUGHLINE_CODEX_CLI_BIN: bin },
     input: JSON.stringify({ session_id: threadId, transcript_path: rolloutPath, cwd: project }),
     encoding: 'utf8',
   });
+  const records = () => {
+    const storePath = defaultRuntimeErrorStorePath(env);
+    if (!existsSync(storePath)) return [];
+    return JSON.parse(readFileSync(storePath, 'utf8')).records
+      .map((record) => [record.error_code, record.component, record.severity, record.count, record.status, record.reason_code]);
+  };
+  const recoveryPath = join(root, '.throughline', 'l1-backend-recovery.json');
+  const result = stop(codex);
 
   // 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],
-  ]);
+  // 1回の失敗は、修理の対象として数えない。通信の断・利用上限・取り消しでも起き、次の Stop がやり直す。
+  assert.deepEqual(records(), []);
+  const first = JSON.parse(readFileSync(recoveryPath, 'utf8'));
+  assert.equal(first.schema, 'throughline.l1_backend_recovery.v1'); assert.equal(first.reported, false);
+  assert.deepEqual(Object.keys(first).sort(), ['first_failure_at', 'last_failure_at', 'reported', 'schema']);
 
   // 取り込みは要約の前に commit 済み。
   const db = new DatabaseSync(join(root, '.throughline', 'throughline.db'));
@@ -198,6 +207,31 @@ test('Codex StopでL1要約backendが失敗した時、取り込みは残り、
   assert.equal(entry.code, 'L1_SUMMARIZER_BACKEND_FAILED');
   assert.equal(entry.reason, 'codex_cli_failed');
   assert.match(entry.stderr, /usage limit reached/);
+
+  // 続けて失敗しても、最初の失敗から24時間に届くまでは数えない。
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), []);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).first_failure_at, first.first_failure_at);
+
+  // 最初の失敗から24時間を過ぎても成功を確認できていない。warn で数える。
+  writeFileSync(recoveryPath, JSON.stringify({ ...first, first_failure_at: Date.now() - 25 * 3_600_000 }));
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 1, 'open', null]]);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).reported, true);
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'open', null]]);
+
+  // backend が要約を返した。失敗の記録を消し、数えていた記録を recovered で解決にする。
+  const working = makeBin(binDir, 'codex-ok', "process.stdout.write('要約\\n');\n");
+  const recovered = stop(working);
+  assert.equal(recovered.status, 0, recovered.stderr);
+  assert.equal(existsSync(recoveryPath), false);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'resolved', 'recovered']]);
+
+  // 復帰した後の失敗は、また最初から数える（すぐには数えない）。
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'resolved', 'recovered']]);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).reported, false);
 });
 
 test('store failure preserves product failure and emits only fixed storage diagnostic', () => {

package/src/runtime-error-observer.mjs

@@ -1,7 +1,10 @@
-import { observeRuntimeError } from './runtime-error-store.mjs';
+import { observeRuntimeError, resolveRuntimeError, runtimeErrorFingerprint } from './runtime-error-store.mjs';
 
 try {
-  const result = observeRuntimeError({ code: process.argv[2] });
+  // 第2引数が recovered の時は、その code の記録を「復帰を確認した」として解決にする（ADR 0041）。
+  const result = process.argv[3] === 'recovered'
+    ? resolveRuntimeError(runtimeErrorFingerprint(process.argv[2]), { reasonCode: 'recovered' })
+    : observeRuntimeError({ code: process.argv[2] });
   process.exitCode = result.status === 'disabled' ? 3 : 0;
 } catch {
   process.exitCode = 1;

package/src/runtime-error-store.mjs

@@ -64,14 +64,30 @@ const DEFINITIONS = Object.freeze({
     template: 'Throughline Codex hook processing failed',
   }),
   // Codex Stop の取り込みは済み、L1 要約の backend（Codex CLI）だけが失敗した（ADR 0028）。
+  // 0.16.4 からは数えない（ADR 0041）。1回ごとの失敗は、通信の断・利用上限・取り消しでも起き、次の Stop がやり直す。
+  // 前の版が記録した store を読める様に、定義は残す。
   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',
   }),
+  // L1 要約の backend が失敗し、最初の失敗から24時間を過ぎても成功を確認できていない（ADR 0041）。
+  // 記憶は失われていない（取り込みは済み、recall は L2 を返す）。要約が成功した時に、recovered で解決にする。
+  L1_SUMMARIZER_BACKEND_UNRECOVERED: Object.freeze({
+    component: 'codex_l1_summarizer',
+    severity: 'warn',
+    template: 'Throughline L1 summarizer backend (Codex CLI) has not recovered for over 24 hours',
+  }),
 });
 
+/** 定型 code の fingerprint。記録は code ごとに1つ。 */
+export function runtimeErrorFingerprint(code) {
+  const definition = DEFINITIONS[code];
+  if (!definition) throw new TypeError('未登録の runtime error code です');
+  return createHash('sha256').update(['throughline', definition.component, code, definition.template].join('\0')).digest('hex');
+}
+
 export function defaultRuntimeErrorConfigPath(env = process.env) {
   if (isWindows(env)) {
     return join(windowsLocalAppData(env), 'throughline', 'runtime-errors.config.json');
@@ -143,9 +159,7 @@ export function observeRuntimeError(input, options = {}) {
   return withStoreLock(options, (privateDirectory) => {
     const now = normalizeTimestamp(input.now);
     const version = normalizeVersion(options.version ?? PACKAGE_VERSION);
-    const fingerprint = createHash('sha256')
-      .update(['throughline', definition.component, input.code, definition.template].join('\0'))
-      .digest('hex');
+    const fingerprint = runtimeErrorFingerprint(input.code);
     const store = readStore(options, { privateDirectory });
     const existing = store.records.find((record) => record.fingerprint === fingerprint);
     const sequence = nextSequence(store);
@@ -307,10 +321,15 @@ export function getRuntimeErrorDiagnostics(options = {}) {
   }
 }
 
+/** 復帰を確認できた記録を、recovered で解決にする。記録が無い時と、解決済みの時は何もしない。 */
+export function resolveRecoveredRuntimeErrorBestEffort(code, options = {}) {
+  return recordRuntimeErrorBestEffort(code, { ...options, action: 'recovered' });
+}
+
 export function recordRuntimeErrorBestEffort(code, options = {}) {
-  const { stderr = process.stderr, ...storeOptions } = options;
+  const { stderr = process.stderr, action = null, ...storeOptions } = options;
   try {
-    const child = childProcess.spawnSync(process.execPath, [fileURLToPath(new URL('./runtime-error-observer.mjs', import.meta.url)), code], {
+    const child = childProcess.spawnSync(process.execPath, [fileURLToPath(new URL('./runtime-error-observer.mjs', import.meta.url)), code, ...(action ? [action] : [])], {
       env: storeOptions.env ?? process.env,
       encoding: 'utf8',
       stdio: 'ignore',