throughline 0.12.7 → 0.12.9

package/CHANGELOG.md

@@ -10,6 +10,26 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.12.9] — 2026-10-04
+
+### 修正
+
+- 新しいDBを複数のhookが同時に開くと、どれかが`no such table: judgments`か`database is locked`で落ちる不具合を直す（[ADR 0031](docs/adr/0031-serialized-schema-migration.md)）。WindowsのCursorの会話では同じhookが2本ほぼ同時に走るので、新しい端末の最初の会話で起きる。schemaの移行は、書き込みlockを取ってから版を読み直し、1つのtransactionで終える。WALへの切り替えは、断られたら読み直して5秒まで待つ。既に現行schemaのDBを開く時の動作は変わらない。
+- 切り離した置き場で再現した。新しいDBを6 processが同時に開くと、Linuxで6回中3回、どれか1本が落ちた。Windowsでも、最初の1回で2本が落ちた。修理後は48回（6 process）で失敗0。
+
+### 変更
+
+- `~/.throughline/logs/hook-failures.log`に、失敗した位置（`stack`、先頭6行まで）を足す。`database is locked`のような文面だけでは、どの処理で落ちたかが分からないため。端末内にだけ残し、外へは送らない。
+- hookのstdinがJSONとして読めない時の文面を`hook stdin is not valid JSON (N chars): …`にする。hostがstdinを渡さずに閉じた時（0字）と、途中で切れた時を見分けられる。失敗として数えることと、終了codeは変えない。
+- 2026-10-04にWindows（0.12.4）で起きたSessionStartとUserPromptSubmitの失敗各1回は、原因が分かっていない。どちらもCursorの会話で2本ほぼ同時に走ったhookの片方で、もう片方は成功している。現行schemaのDBで起きたので、上の修正の形ではない。この2つの変更は、次に起きた時に理由を端末へ残すためのもの。
+
+## [0.12.8] — 2026-10-04
+
+### 変更
+
+- runtime errorの送信を有効にした端末は、未受領の記録が無くても、受け口へ最後に届いた版と今の版が違う時に、`runtime_errors`と`resolutions`が空のreportを1回送る（[ADR 0030](docs/adr/0030-report-installed-version-once.md)）。reportは`installed_version`を持つので、受け口は記録が出ていない端末の版も分かる。届いた後は、版が変わるまで送らない。reportの形、署名、送る時機と間隔は変えない。送信を有効にしていない端末（既定）と、収集が無効な端末は、今までどおり何も送らない。
+- 0.12.7以前は、未受領の記録が無ければ通信しなかった。更新した端末で何も起きなければ、受け口は古い版を持ち続けていた。
+
 ## [0.12.7] — 2026-10-04
 
 ### 修正
@@ -1614,7 +1634,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.12.7...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.12.9...HEAD
+[0.12.9]: https://github.com/kitepon/Throughline/compare/v0.12.8...v0.12.9
+[0.12.8]: https://github.com/kitepon/Throughline/compare/v0.12.7...v0.12.8
 [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

package/README.md

@@ -890,7 +890,7 @@ once with `npm install --global throughline@latest`, then run
 | `throughline runtime-errors compact --json`    | Remove only acknowledged, resolved aggregates after retention; open or unacknowledged records remain |
 | `throughline runtime-errors report-enable --credential-file <path> --json` | Opt in to sending aggregates to the receiver named in that credential file; sending is disabled by default |
 | `throughline runtime-errors report-disable --json` | Stop sending aggregates |
-| `throughline runtime-errors report --json`     | Send unacknowledged aggregates once now; exits 0 only for `sent` or `nothing_pending` |
+| `throughline runtime-errors report --json`     | Send unacknowledged aggregates once now (or an empty report when the receiver has not seen this version yet); exits 0 only for `sent` or `nothing_pending` |
 | `throughline runtime-errors report-status --json` | Read the last attempt time and fixed result code without exposing the receiver, credential, or paths |
 | `throughline handoff-preview --session <id>`   | Print a Codex-facing `throughline_handoff` JSON projection    |
 | `throughline handoff-context (--session <id> \| --project <path>) --json` | Print the SessionStart inheritance context without moving memory rows. Project mode selects the newest captured session with dialogue, supports `--disclosure silent`, and returns `empty` when no dialogue exists. Session mode may add a project-bound supplement inside the same 9,500-character budget |
@@ -948,8 +948,10 @@ throughline runtime-errors report-status --json
 ```
 
 Once enabled, the Claude and Codex hook entry points start a detached sender at
-most once per hour, and only contact the receiver when unacknowledged records
-exist; the hooks do not wait for it. The body carries the public snapshot fields
+most once per hour; the hooks do not wait for it. It contacts the receiver when
+unacknowledged records exist, or once after the installed version changed (a
+report with empty `runtime_errors` and `resolutions`, so the receiver learns the
+version; see [ADR 0030](docs/adr/0030-report-installed-version-once.md)). The body carries the public snapshot fields
 only (fixed error code, template, count, timestamps, version, resolutions). The
 secret is never transmitted: the body is signed with
 `HMAC-SHA256(secret, ts + "\n" + SHA-256(body))`, redirects are not followed,

package/docs/adr/0025-runtime-error-reporting.md

@@ -38,7 +38,7 @@ BugHub は、端末に入る CLI 製品が自分の分だけを送る受け口
 7. 送る時機は hook 入口。`process-turn`・`session-start`・`prompt-submit`・`codex-hook` の開始時に、
    送信が有効で、次に試してよい時刻を過ぎていれば、切り離した子 process を1つ起こす。
    hook の終了は待たせない。子 process が store lock の下で時刻を先に書くので、同時に起きても送るのは1つ。
-   未受領の記録が無ければ通信しない。間隔は1時間。credential や report の形で断られた時は24時間空ける。
+   未受領の記録が無ければ通信しない（2026-10-04 [ADR 0030](0030-report-installed-version-once.md)で、受け口へ届いた版と今の版が違う時だけ、空の report を1回送ることにした）。間隔は1時間。credential や report の形で断られた時は24時間空ける。
    `throughline runtime-errors report --json` は間隔を待たずに1回送る。
 8. 送信の状態（最後に試した時刻・結果の固定 code・次の時刻）は `runtime-errors.report.state.json` に持ち、
    `runtime-errors report-status --json` で読む。宛先・credential・path は出さない。

package/docs/adr/0030-report-installed-version-once.md

@@ -0,0 +1,48 @@
+# ADR 0030: 未受領の記録が無くても、受け口へ届いた版と今の版が違う時は、空の report を1回送る
+
+日付: 2026-10-04
+
+## Context
+
+ADR 0025 Decision 7 は、未受領の記録（runtime error と解決記録）が無ければ通信しないと決めている。
+report は毎回 `installed_version` を持つが、記録が無い端末からは report が出ない。
+
+BugHub は 2026-10-04 から、工場の report を送らない端末について、製品の report の `installed_version` と
+`observed_at` を端末の導入版として表示する。受け口は `runtime_errors` と `resolutions` が空の report も受ける
+（BugHub の担当が確認。同じ端末×製品は1分に1回まで）。
+
+BellTeam コンテナは工場の report を送らない。0.12.7 へ更新して未解決が0件になった後は、
+次に runtime error か解決記録が出るまで report が出ず、BugHub の導入版は「未確認」のままになる。
+更新した端末で何も起きなければ、受け口は古い版を持ち続ける。
+
+オーナーは 2026-10-04 に、エラーが無い時にも版を知らせる report を送ってよいか、送るなら
+版が変わった時に1回だけか・1時間ごとかを選び、「版が変わった時に1回だけ送る」と決めた。
+
+## Decision
+
+1. 送信の状態（`runtime-errors.report.state.json`）に、受け口が受領した最後の report の版
+   `last_reported_version` を持つ。書くのは、report が `sent`（ADR 0025 Decision 6 の受領がそろった時）に
+   なった時だけ。記録を載せた report でも、空の report でも同じ。
+2. 未受領の記録が無い時、`last_reported_version` が今の版と同じなら、今までどおり通信しない（`nothing_pending`）。
+   違う時（版を上げた・下げた後、この項目を持たない旧版の state）は、`runtime_errors` と `resolutions` が
+   空の report を1回送る。
+3. 空の report の形は ADR 0025 と同じ。項目は `schema_version`・`report_id`・`product_id`・
+   `installed_version`・`observed_at`・空の `runtime_errors`・空の `resolutions`。wire の版は変えない。
+   署名、redirect を追わないこと、受領の確認も同じ。
+4. 送るのは、今までどおり `report-enable` で明示して有効にし、収集も有効な端末だけ。
+   送信が無効な端末と収集が無効な端末は、版も送らない。
+5. 送る時機と間隔は変えない（hook 入口、1時間、断られた時は ADR 0025 の間隔）。
+   断られた時と届いたか分からない時は `last_reported_version` を書かず、次の送信でもう一度送る。
+6. `runtime-errors report --json` の結果は `sent`（`runtime_errors: 0`・`resolutions: 0`）。
+   `report-status` の項目は変えない。
+
+## Consequences
+
+- 送信を有効にした端末は、0.12.8 へ上げた後に1回、その後は版が変わるたびに1回、空の report を送る。
+  受け口には、端末がその版で動いた時刻が1つ届く。
+- 版が同じ間は、記録が無ければ通信しない。端末が動いているかどうかは、この report からは分からない。
+- 版を上げた後、次の送信の時刻（最長1時間）と、その後の最初の hook までは届かない。
+  急ぐ時は `runtime-errors report --json` を回す。
+- 0.12.7 以前へ戻すと、旧版は state を書き直す時に `last_reported_version` を落とす。
+  再び上げた時に、もう1回送る。
+- 既定の利用者（送信を有効にしていない端末）の動作は変わらない。

package/docs/adr/0031-serialized-schema-migration.md

@@ -0,0 +1,43 @@
+# ADR 0031: schema の移行は書き込み lock の中で版を読み直して行い、WAL への切り替えは読み直して待つ
+
+日付: 2026-10-04
+
+## Context
+
+`getDb()` は DB を開くたびに `PRAGMA user_version` を読み、現行版より古ければ移行を走らせていた。
+版を読むのも、移行の各 statement も、transaction の外だった。
+
+Windows の Cursor の会話では、同じ hook が2本ほぼ同時に走る（2026-10-04 の記録では、1会話の SessionStart が
+数ms〜320ms の間隔で2行残る。`~/.cursor/hooks.json` と `~/.claude/settings.json` の両方に Throughline の登録がある。
+2本目がどちらの登録から来るかは確かめていない）。新しい端末の最初の会話では、2本とも版 0 を読む。片方が先に移行を終えると、もう片方は版 0 のつもりで
+v2 の移行（`DELETE FROM judgments ...`）を走らせ、v4 で消えた表へ触って `no such table: judgments` で落ちる。
+
+もう1つ、新しい DB の journal mode を WAL へ切り替える `PRAGMA journal_mode = WAL` は排他 lock を要る。
+他の process が同じ DB を開いている間は、`busy_timeout` を待たずに `database is locked` で断られる。
+
+2026-10-04 に、切り離した置き場で再現した。新しい DB を 6 process が同時に開くと、Linux（Node 26）で
+6回中3回、どれか1本が上のどちらかで落ちた。Windows（Node 24）でも、SessionStart と UserPromptSubmit を
+2本ずつ同時に動かした最初の1回で2本が `no such table: judgments` で落ちた。
+既に現行 schema の DB では、どちらも起きない（版が現行なら移行は何も書かず、WAL なら切り替えない）。
+
+## Decision
+
+1. 移行は `BEGIN IMMEDIATE` で書き込み lock を取り、その中で `PRAGMA user_version` を読み直してから走らせ、
+   `user_version` の更新まで1つの transaction で commit する。失敗した時は rollback し、途中の schema を残さない。
+2. lock の外で読んだ版が現行版以上なら、lock を取らない。現行 schema の DB を開く hook は、今までどおり何も書かない。
+3. 他の process が移行している間に開いた process は、`busy_timeout`（5秒）まで lock を待ち、
+   取れた後に読み直した版が現行なら何もしない。
+4. WAL への切り替えは、`database is locked` で断られたら 25ms 待って journal mode を読み直し、
+   `busy_timeout` と同じ時間まで繰り返す。他の process が先に切り替えれば、読み直しで WAL が見えて終わる。
+5. `migrate --json`（ADR 0018 の正規入口）も同じ関数を通る。結果の形は変えない。
+
+## Consequences
+
+- 新しい端末で複数の hook が同時に最初の DB を開いても、全員が現行 schema で開ける。
+- 古い schema からの移行中、他の hook は最長5秒待つ。移行が5秒を超えると、待った hook は
+  `database is locked` で失敗する。今までは、移行の途中の schema で走るか、同じ移行をもう一度走らせていた。
+- 移行が途中で失敗した DB は、移行前の schema のまま残る。次に開いた時に最初からやり直す。
+- 2026-10-04 に Windows（0.12.4）で起きた SessionStart と UserPromptSubmit の失敗各1回は、
+  現行 schema の DB で起きている。この ADR の2つの形ではなく、原因は分かっていない。
+  理由の文面は 0.12.4 では端末に残らない。0.12.9 は `hook-failures.log` に失敗した位置（stack の先頭）を足し、
+  hook の stdin が JSON として読めない時の文面に字数を入れる。

package/package.json

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

package/src/db-contention.test.mjs

@@ -93,3 +93,30 @@ test('getDb reuses an existing WAL database while another process owns the write
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test('getDbは、新しいDBを複数のprocessが同時に開いても、全員が現行schemaで開ける', async () => {
+  // WindowsのCursorの会話では同じhookが2本ほぼ同時に走る。初回はどのprocessも版0を読むので、lockの外で読んだ版から
+  // 移行をやり直すと、先に進んだprocessが消した表へ触って落ちた（修理前は6本で半分ほどの確率）。
+  const rounds = 6;
+  const processes = 6;
+  for (let round = 0; round < rounds; round += 1) {
+    const home = mkdtempSync(join(tmpdir(), 'throughline-db-first-open-'));
+    const env = { ...process.env, HOME: home, USERPROFILE: home };
+    try {
+      const results = await Promise.all(Array.from({ length: processes }, () => {
+        const child = spawn(process.execPath, ['--input-type=module', '-e', `
+          import { getDb, CURRENT_VERSION } from ${JSON.stringify(DB_MODULE_URL)};
+          const db = getDb();
+          const version = db.prepare('PRAGMA user_version').get().user_version;
+          db.prepare('SELECT count(*) AS n FROM sessions').get();
+          db.close();
+          if (version !== CURRENT_VERSION) process.exit(2);
+        `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+        return waitForExit(child);
+      }));
+      assert.deepEqual(results, Array.from({ length: processes }, () => ({ code: 0, stderr: '' })));
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  }
+});

package/src/db.mjs

@@ -25,10 +25,68 @@ export function openReadOnlyDb(path = DB_PATH) {
   }
 }
 
+const WAL_SWITCH_RETRY_MS = 25;
+
+function isSqliteBusy(error) {
+  if (typeof error?.errcode === 'number') return (error.errcode & 0xff) === 5;
+  return /database is locked/u.test(String(error?.message ?? ''));
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/**
+ * journal mode を WAL にする。既に WAL なら何も書かない。
+ *
+ * WAL への切り替えは排他 lock を要り、他の process が同じ DB を開いている間は busy_timeout を待たずに
+ * `database is locked` で断られる。新しい DB を複数の hook が同時に開く時に起きるので、
+ * busy_timeout と同じ時間まで読み直す (ADR 0031)。他の process が先に切り替えれば、読み直しで WAL が見える。
+ */
+function ensureWalJournalMode(db) {
+  const deadline = Date.now() + DB_BUSY_TIMEOUT_MS;
+  for (;;) {
+    try {
+      const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
+      if (String(journalMode).toLowerCase() === 'wal') return;
+      db.exec('PRAGMA journal_mode = WAL');
+      return;
+    } catch (error) {
+      if (!isSqliteBusy(error) || Date.now() >= deadline) throw error;
+      sleepSync(WAL_SWITCH_RETRY_MS);
+    }
+  }
+}
+
+function readSchemaVersion(db) {
+  return db.prepare('PRAGMA user_version').get().user_version ?? 0;
+}
+
+/**
+ * schema を現行版へ上げる。現行版なら何も書かない。
+ *
+ * 移行は書き込み lock を取ってから版を読み直し、1つの transaction で終える (ADR 0031)。
+ * lock の外で読んだ版は、他の process が移行を進めた後では古い。古い版から移行をやり直すと、
+ * 途中の版で消した表（v4 の judgments）へ触って `no such table` で落ちる。
+ */
 function initSchema(db) {
-  const row = db.prepare('PRAGMA user_version').get();
-  const version = row.user_version ?? 0;
+  if (readSchemaVersion(db) >= CURRENT_VERSION) return;
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    const version = readSchemaVersion(db);
+    if (version < CURRENT_VERSION) applySchemaMigrations(db, version);
+    db.exec('COMMIT');
+  } catch (error) {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      // ignore
+    }
+    throw error;
+  }
+}
 
+function applySchemaMigrations(db, version) {
   // v0 → v1: 全テーブル作成
   if (version < 1) {
     db.exec(`
@@ -353,10 +411,7 @@ export function migrateDefaultDb() {
       };
     }
 
-    const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
-    if (String(journalMode).toLowerCase() !== 'wal') {
-      db.exec('PRAGMA journal_mode = WAL');
-    }
+    ensureWalJournalMode(db);
     initSchema(db);
     const afterSchemaVersion = Number(db.prepare('PRAGMA user_version').get().user_version ?? 0);
     if (afterSchemaVersion !== CURRENT_VERSION) {
@@ -397,10 +452,7 @@ export function getDb() {
   const db = new DatabaseSync(DB_PATH);
   try {
     db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
-    const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
-    if (String(journalMode).toLowerCase() !== 'wal') {
-      db.exec('PRAGMA journal_mode = WAL');
-    }
+    ensureWalJournalMode(db);
     db.exec('PRAGMA foreign_keys = ON');
     initSchema(db);
     _db = db;

package/src/hook-entrypoints.test.mjs

@@ -976,7 +976,9 @@ test('a failed hook leaves its reason in the local hook failure log', () => {
       ['HOOK_SESSION_START_FAILED', 'Error', 'Missing session_id in SessionStart payload'],
     ]);
     for (const entry of entries) {
-      assert.deepEqual(Object.keys(entry), ['ts', 'code', 'version', 'name', 'message']);
+      assert.deepEqual(Object.keys(entry), ['ts', 'code', 'version', 'name', 'message', 'stack']);
+      // 失敗した位置は、payloadを検査して投げたhookの入口を指す。
+      assert.match(entry.stack[0], /^at .*(turn-processor|session-start)\.mjs:\d+:\d+\)?$/);
       assert.match(entry.ts, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
       assert.match(entry.version, /^\d+\.\d+\.\d+$/);
     }

package/src/hook-failure-log.mjs

@@ -3,7 +3,7 @@
  *
  * runtime error store は外へ送れる形（定型 code と回数）だけを持つ (ADR 0025)。失敗した時の
  * 例外の文面はどこにも残らず、後から原因を追えなかった（2026-10-04、Mac と main-server の
- * 7〜8月の失敗）。このログは理由を端末内にだけ残す。runtime error の収集・送信の設定とは
+ * 7〜8月の失敗）。このログは理由と失敗した位置（stack の先頭）を端末内にだけ残す。runtime error の収集・送信の設定とは
  * 独立で、外へは送らない。
  * 書き込み失敗は stderr に出す（黙って握りつぶさない）。
  */
@@ -17,11 +17,23 @@ const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = require('../package.json').version;
 
 export const HOOK_FAILURE_MESSAGE_LIMIT = 1000;
+export const HOOK_FAILURE_STACK_FRAMES = 6;
+export const HOOK_FAILURE_STACK_FRAME_LIMIT = 300;
 
 export function hookFailureLogPath({ home = homedir() } = {}) {
   return join(home, '.throughline', 'logs', 'hook-failures.log');
 }
 
+function stackFrames(error) {
+  if (!(error instanceof Error) || typeof error.stack !== 'string') return [];
+  return error.stack
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('at '))
+    .slice(0, HOOK_FAILURE_STACK_FRAMES)
+    .map((line) => line.slice(0, HOOK_FAILURE_STACK_FRAME_LIMIT));
+}
+
 /**
  * @param {string} code runtime error の定型 code（例: HOOK_PROCESS_TURN_FAILED）
  * @param {unknown} error 失敗の原因
@@ -36,6 +48,10 @@ 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),
   };
+  // 失敗した位置を残す。`database is locked` のような文面だけでは、DB を開く時か書く時か、
+  // どの処理で落ちたかが分からない（2026-10-04、Windows の SessionStart と UserPromptSubmit の失敗）。
+  const frames = stackFrames(error);
+  if (frames.length > 0) entry.stack = frames;
   // どの会話の失敗かを残す（errorが `hookContext` を持つ時）。回数と文面だけでは、失敗した会話を
   // 端末の他の記録から探すことになる。
   const context = error?.hookContext;

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

@@ -3,7 +3,13 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { HOOK_FAILURE_MESSAGE_LIMIT, hookFailureLogPath, logHookFailure } from './hook-failure-log.mjs';
+import {
+  HOOK_FAILURE_MESSAGE_LIMIT,
+  HOOK_FAILURE_STACK_FRAMES,
+  HOOK_FAILURE_STACK_FRAME_LIMIT,
+  hookFailureLogPath,
+  logHookFailure,
+} from './hook-failure-log.mjs';
 
 test('logHookFailureは、失敗の理由を1行のJSONで追記する', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
@@ -12,9 +18,12 @@ test('logHookFailureは、失敗の理由を1行のJSONで追記する', () => {
     logHookFailure('HOOK_CODEX_FAILED', 'thrown string', { home, now: Date.UTC(2026, 9, 4, 0, 0, 1) });
     const lines = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
     assert.equal(lines.length, 2);
-    assert.deepEqual({ ...lines[0], version: 'x' }, {
+    const { stack, ...first } = lines[0];
+    assert.deepEqual({ ...first, version: 'x' }, {
       ts: '2026-10-04T00:00:00.005Z', code: 'HOOK_PROCESS_TURN_FAILED', version: 'x', name: 'TypeError', message: 'first reason',
     });
+    // Errorは失敗した位置を持つ。文字列を投げた時はstackが無いので、項目ごと残さない。
+    assert.equal(Array.isArray(stack) && stack.length > 0, true);
     assert.deepEqual({ ...lines[1], version: 'x' }, {
       ts: '2026-10-04T00:00:01.000Z', code: 'HOOK_CODEX_FAILED', version: 'x', name: 'string', message: 'thrown string',
     });
@@ -61,6 +70,31 @@ test('logHookFailureは、どの会話の失敗かを残す', () => {
   }
 });
 
+test('logHookFailureは、失敗した位置をstackの先頭から残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    const err = new Error('database is locked');
+    err.stack = [
+      'Error: database is locked',
+      '    at getDb (file:///throughline/src/db.mjs:455:5)',
+      `    at ${'x'.repeat(HOOK_FAILURE_STACK_FRAME_LIMIT + 40)}`,
+      ...Array.from({ length: HOOK_FAILURE_STACK_FRAMES + 3 }, (_, index) => `    at frame${index} (file:///throughline/src/a.mjs:${index}:1)`),
+    ].join('\n');
+    logHookFailure('HOOK_SESSION_START_FAILED', err, { home });
+    const noFrames = new Error('no frames');
+    noFrames.stack = 'Error: no frames';
+    logHookFailure('HOOK_SESSION_START_FAILED', noFrames, { home });
+    const [entry, second] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.equal(entry.stack.length, HOOK_FAILURE_STACK_FRAMES);
+    assert.equal(entry.stack[0], 'at getDb (file:///throughline/src/db.mjs:455:5)');
+    assert.equal(entry.stack[1].length, HOOK_FAILURE_STACK_FRAME_LIMIT);
+    assert.equal(entry.stack[2], 'at frame0 (file:///throughline/src/a.mjs:0:1)');
+    assert.equal('stack' in second, false);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('logHookFailureは、長い文面を上限で切る', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
   try {

package/src/hosts/cursor.test.mjs

@@ -25,6 +25,16 @@ test('parseHookPayload accepts one leading BOM and preserves BOM inside prompt t
   assert.throws(() => parseHookPayload('\uFEFF{"conversation_id":'), SyntaxError);
 });
 
+test('parseHookPayloadは、stdinが空の時と途中で切れた時を、文面の字数で見分けられるようにする', () => {
+  assert.throws(() => parseHookPayload(''), (error) => {
+    assert.equal(error instanceof SyntaxError, true);
+    assert.match(error.message, /^hook stdin is not valid JSON \(0 chars\): /u);
+    assert.equal(error.cause instanceof SyntaxError, true);
+    return true;
+  });
+  assert.throws(() => parseHookPayload('\uFEFF{"conversation_id":'), /^SyntaxError: hook stdin is not valid JSON \(20 chars\): /u);
+});
+
 test('isCursorEnvelope detects Cursor events and cursor_version', () => {
   assert.equal(
     isCursorEnvelope({

package/src/hosts/index.mjs

@@ -29,7 +29,15 @@ const ADAPTERS = Object.freeze({
 
 /** Parse hook stdin, including the leading UTF-8 BOM emitted by Windows Cursor. */
 export function parseHookPayload(raw, options = {}) {
-  return normalizeHookPayload(JSON.parse(raw.replace(/^\uFEFF/, '')), options);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+  } catch (error) {
+    // host が stdin を渡さずに閉じた時（0 字）と、途中で切れた時を、理由の文面で見分けられるようにする。
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new SyntaxError(`hook stdin is not valid JSON (${raw.length} chars): ${detail}`, { cause: error });
+  }
+  return normalizeHookPayload(parsed, options);
 }
 
 /**

package/src/runtime-error-report.mjs

@@ -131,22 +131,30 @@ export async function reportRuntimeErrors(options = {}) {
 
   // 記録が無効な端末でも次の時刻は書く。書かないと、hookのたびに送信processが起きる。
   const outcome = isRuntimeErrorCollectionEnabled({ env })
-    ? await sendPendingRecords({ env, nowMs, fetchImpl, storeOptions, credentialFile: config.reporting.credential_file })
+    ? await sendPendingRecords({
+      env, nowMs, fetchImpl, storeOptions,
+      credentialFile: config.reporting.credential_file,
+      lastReportedVersion: claimed.last_reported_version,
+    })
     : result('collection_disabled');
   updateState(lockOptions, (state) => ({
     ...state,
     last_result: outcome.status,
     last_success_at: outcome.status === 'sent' ? new Date(nowMs).toISOString() : state.last_success_at,
+    last_reported_version: outcome.status === 'sent' ? PACKAGE_VERSION : state.last_reported_version,
     next_attempt_at: new Date(nowMs + (LONG_BACKOFF_STATUSES.has(outcome.status)
       ? REPORT_REJECTED_BACKOFF_MS : REPORT_INTERVAL_MS)).toISOString(),
   }));
   return outcome;
 }
 
-async function sendPendingRecords({ env, nowMs, fetchImpl, storeOptions, credentialFile }) {
+async function sendPendingRecords({ env, nowMs, fetchImpl, storeOptions, credentialFile, lastReportedVersion }) {
   const acknowledged = readRuntimeErrorSnapshot({ ...storeOptions, limit: 1 }).cursor.acknowledged_through;
   const snapshot = readRuntimeErrorSnapshot({ ...storeOptions, afterCursor: acknowledged });
-  if (snapshot.runtime_errors.length === 0 && snapshot.resolutions.length === 0) {
+  // 未受領の記録が無くても、受け口へ最後に届いた版と今の版が違う時は、記録が空のreportを1回送る
+  // （ADR 0030）。受け口は installed_version を端末の導入版として持つ。届いた後は、版が変わるまで送らない。
+  if (snapshot.runtime_errors.length === 0 && snapshot.resolutions.length === 0 &&
+    lastReportedVersion === PACKAGE_VERSION) {
     return result('nothing_pending', { acknowledged_through: acknowledged });
   }
 
@@ -321,6 +329,7 @@ function emptyState() {
     last_result: null,
     last_success_at: null,
     next_attempt_at: null,
+    last_reported_version: null,
   };
 }
 
@@ -332,6 +341,9 @@ function normalizeState(value) {
     if (isCanonicalTimestamp(value[key])) state[key] = value[key];
   }
   if (RESULT_STATUSES.has(value.last_result)) state.last_result = value.last_result;
+  if (typeof value.last_reported_version === 'string' && /^[0-9A-Za-z.+-]{1,64}$/.test(value.last_reported_version)) {
+    state.last_reported_version = value.last_reported_version;
+  }
   return state;
 }
 

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

@@ -393,6 +393,76 @@ test('runtime error report: background runs respect the interval, explicit runs
   }
 });
 
+test('runtime error report: with nothing pending, the installed version is reported once and again only after it changes', async () => {
+  const { root, env } = createEnvironment();
+  const installed = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+  let reply = (entry) => accept(entry);
+  const receiver = await startReceiver((entry) => reply(entry));
+  const statePath = defaultRuntimeErrorReportStatePath(env);
+  const readState = () => JSON.parse(readFileSync(statePath, 'utf8'));
+  try {
+    setRuntimeErrorCollectionEnabled(true, { env });
+    setRuntimeErrorReportingEnabled(true, { env, credentialFile: writeCredential(root, receiver.url) });
+
+    // 断られた時は届いた版として覚えない。次の送信でもう一度送る。
+    reply = () => ({ status: 429, body: { error: 'rate_limited' } });
+    assert.equal((await reportRuntimeErrors({ env, now: NOW })).status, 'rate_limited');
+    assert.equal(readState().last_reported_version, null);
+
+    // 記録が1件も無い端末（0.12.7以前から上げた直後のstateも同じ）: 版と時刻だけのreportを1回送る。
+    reply = (entry) => accept(entry);
+    const first = await reportRuntimeErrors({ env, now: NOW + 1000 });
+    assert.equal(first.status, 'sent');
+    assert.equal(first.runtime_errors, 0);
+    assert.equal(first.resolutions, 0);
+    assert.equal(receiver.requests.length, 2);
+    const sent = receiver.requests[1];
+    assert.equal(sent.signatureValid, true);
+    assert.deepEqual(sent.report, {
+      schema_version: '1.0',
+      report_id: first.report_id,
+      product_id: 'throughline',
+      installed_version: installed,
+      observed_at: new Date(NOW + 1000).toISOString(),
+      runtime_errors: [],
+      resolutions: [],
+    });
+    assert.equal(readState().last_reported_version, installed);
+    assert.equal(readRuntimeErrorSnapshot({ env }).cursor.acknowledged_through, 0);
+
+    // 同じ版のままなら、記録が無い間は通信しない。
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 2000 })).status, 'nothing_pending');
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 2 * REPORT_INTERVAL_MS, background: true })).status, 'nothing_pending');
+    assert.equal(receiver.requests.length, 2);
+
+    // 記録を送ったreportも、その版を届けたことになる。
+    observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, { env });
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 3 * REPORT_INTERVAL_MS })).status, 'sent');
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 3 * REPORT_INTERVAL_MS + 1000 })).status, 'nothing_pending');
+    assert.equal(receiver.requests.length, 3);
+
+    // 版が変わった（最後に届いた版が今の版と違う）時は、もう1回だけ送る。
+    writeFileSync(statePath, JSON.stringify({ ...readState(), last_reported_version: '0.0.1' }));
+    const afterUpdate = await reportRuntimeErrors({ env, now: NOW + 4 * REPORT_INTERVAL_MS });
+    assert.equal(afterUpdate.status, 'sent');
+    assert.deepEqual(receiver.requests[3].report.runtime_errors, []);
+    assert.equal(receiver.requests[3].report.installed_version, installed);
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 4 * REPORT_INTERVAL_MS + 1000 })).status, 'nothing_pending');
+    assert.equal(receiver.requests.length, 4);
+
+    // 記録を無効にした端末と、送信を無効にした端末は、版も送らない。
+    writeFileSync(statePath, JSON.stringify({ ...readState(), last_reported_version: '0.0.1' }));
+    setRuntimeErrorCollectionEnabled(false, { env });
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 5 * REPORT_INTERVAL_MS })).status, 'collection_disabled');
+    setRuntimeErrorCollectionEnabled(true, { env });
+    setRuntimeErrorReportingEnabled(false, { env });
+    assert.equal((await reportRuntimeErrors({ env, now: NOW + 6 * REPORT_INTERVAL_MS })).status, 'reporting_disabled');
+    assert.equal(receiver.requests.length, 4);
+  } finally {
+    await receiver.close();
+  }
+});
+
 test('runtime error report: an unsafe or malformed credential file is never used', { skip: process.platform === 'win32' }, async () => {
   const { root, env } = createEnvironment();
   let calls = 0;