throughline 0.1.0

package/src/transcript-reader.test.mjs

@@ -0,0 +1,292 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  stripAnsi,
+  normalizeToolResultContent,
+  sliceCurrentTurnEntries,
+  extractDetailBlocks,
+} from './transcript-reader.mjs';
+import { DETAIL_KIND } from './constants.mjs';
+
+test('stripAnsi: ANSI 色コードを除去する', () => {
+  assert.equal(stripAnsi('\x1b[32mgreen\x1b[0m text'), 'green text');
+  assert.equal(stripAnsi('plain'), 'plain');
+  assert.equal(stripAnsi(''), '');
+});
+
+test('normalizeToolResultContent: string / array / image mix', () => {
+  assert.equal(normalizeToolResultContent('raw string'), 'raw string');
+  assert.equal(
+    normalizeToolResultContent([
+      { type: 'text', text: 'hello' },
+      { type: 'text', text: ' world' },
+    ]),
+    'hello world',
+  );
+  assert.equal(
+    normalizeToolResultContent([
+      { type: 'text', text: 'before' },
+      { type: 'image', source: {} },
+      { type: 'text', text: 'after' },
+    ]),
+    'before[image]after',
+  );
+  assert.equal(normalizeToolResultContent(null), '');
+});
+
+/** 単一 text ブロック user / assistant エントリを作る */
+function userEntry(text) {
+  return { type: 'user', message: { role: 'user', content: [{ type: 'text', text }] } };
+}
+function asstTextEntry(text) {
+  return {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'text', text }] },
+  };
+}
+function asstToolUseEntry(id, name, input) {
+  return {
+    type: 'assistant',
+    message: { role: 'assistant', content: [{ type: 'tool_use', id, name, input }] },
+  };
+}
+function userToolResultEntry(toolUseId, content) {
+  return {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [{ type: 'tool_result', tool_use_id: toolUseId, content }],
+    },
+  };
+}
+function attachmentEntry(uuid, hookEvent, command, content) {
+  return {
+    type: 'attachment',
+    uuid,
+    attachment: { type: 'hook_success', hookEvent, command, content },
+  };
+}
+
+test('sliceCurrentTurnEntries: 最後の user text → 最後の assistant text を切り出す', () => {
+  const entries = [
+    userEntry('old prompt'),
+    asstTextEntry('old response'),
+    userEntry('current prompt'),
+    asstToolUseEntry('toolu_1', 'Bash', { command: 'ls' }),
+    userToolResultEntry('toolu_1', 'file1\nfile2'),
+    asstTextEntry('current response'),
+  ];
+  const slice = sliceCurrentTurnEntries(entries);
+  assert.equal(slice.length, 4);
+  assert.equal(slice[0].message.content[0].text, 'current prompt');
+  assert.equal(slice[3].message.content[0].text, 'current response');
+});
+
+test('sliceCurrentTurnEntries: 空配列なら空を返す', () => {
+  assert.deepEqual(sliceCurrentTurnEntries([]), []);
+});
+
+test('sliceCurrentTurnEntries: assistant text が無ければ空', () => {
+  const entries = [userEntry('hello'), asstToolUseEntry('t1', 'Read', { path: '/x' })];
+  assert.deepEqual(sliceCurrentTurnEntries(entries), []);
+});
+
+test('extractDetailBlocks: tool_use と tool_result をペアで抽出', () => {
+  const entries = [
+    userEntry('do it'),
+    asstToolUseEntry('toolu_42', 'Bash', { command: 'echo hi' }),
+    userToolResultEntry('toolu_42', 'hi\n'),
+    asstTextEntry('done'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 2);
+
+  const [input, output] = details;
+  assert.equal(input.kind, DETAIL_KIND.TOOL_INPUT);
+  assert.equal(input.tool_name, 'Bash');
+  assert.equal(input.source_id, 'toolu_42');
+  assert.ok(input.input_text.includes('echo hi'));
+  assert.equal(input.output_text, null);
+
+  assert.equal(output.kind, DETAIL_KIND.TOOL_OUTPUT);
+  assert.equal(output.tool_name, 'Bash'); // tool_use からマップされる
+  assert.equal(output.source_id, 'toolu_42:result');
+  assert.equal(output.output_text, 'hi\n');
+});
+
+test('extractDetailBlocks: thinking / text ブロックは L3 に入れない', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'internal thoughts' },
+          { type: 'text', text: 'response' },
+        ],
+      },
+    },
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 0);
+});
+
+test('extractDetailBlocks: attachment (hook_success) を system として抽出', () => {
+  const entries = [
+    userEntry('prompt'),
+    attachmentEntry('att-uuid-1', 'UserPromptSubmit', 'node hook.mjs', 'injected context'),
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].kind, DETAIL_KIND.SYSTEM);
+  assert.equal(details[0].tool_name, 'hook_success:UserPromptSubmit');
+  assert.equal(details[0].source_id, 'att-uuid-1');
+  assert.equal(details[0].input_text, 'node hook.mjs');
+  assert.equal(details[0].output_text, 'injected context');
+});
+
+test('extractDetailBlocks: attachment (async_hook_response) を system として抽出', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'attachment',
+      uuid: 'async-1',
+      attachment: {
+        type: 'async_hook_response',
+        hookName: 'Stop',
+        hookEvent: 'Stop',
+        stdout: 'hook output text',
+        stderr: '',
+        exitCode: 0,
+      },
+    },
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].kind, DETAIL_KIND.SYSTEM);
+  assert.equal(details[0].tool_name, 'async_hook_response:Stop');
+  assert.equal(details[0].source_id, 'async-1');
+  assert.equal(details[0].output_text, 'hook output text');
+});
+
+test('extractDetailBlocks: attachment (nested_memory) も system として拾う', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'attachment',
+      uuid: 'mem-1',
+      attachment: {
+        type: 'nested_memory',
+        path: 'C:\\Users\\x\\.claude\\rules\\x.md',
+        content: 'memory file body',
+      },
+    },
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].tool_name, 'nested_memory');
+  assert.equal(details[0].input_text, 'C:\\Users\\x\\.claude\\rules\\x.md');
+  assert.equal(details[0].output_text, 'memory file body');
+});
+
+test('extractDetailBlocks: attachment (mcp_instructions_delta) の addedBlocks も拾う', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'attachment',
+      uuid: 'mcp-1',
+      attachment: {
+        type: 'mcp_instructions_delta',
+        addedNames: ['plugin:foo'],
+        addedBlocks: ['## plugin:foo\nDo things'],
+        removedNames: [],
+      },
+    },
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].tool_name, 'mcp_instructions_delta');
+  assert.ok(details[0].output_text.includes('plugin:foo'));
+});
+
+test('extractDetailBlocks: 未知の attachment 種別は JSON dump で残す (情報ロスゼロ)', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'attachment',
+      uuid: 'unknown-1',
+      attachment: {
+        type: 'some_future_type',
+        foo: 'bar',
+        count: 42,
+      },
+    },
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].tool_name, 'some_future_type');
+  assert.ok(details[0].output_text.includes('bar'));
+  assert.ok(details[0].output_text.includes('42'));
+});
+
+test('extractDetailBlocks: tool_output の ANSI コードは剥離される', () => {
+  const entries = [
+    userEntry('run it'),
+    asstToolUseEntry('t1', 'Bash', { command: 'ls' }),
+    userToolResultEntry('t1', '\x1b[32mgreen\x1b[0m file'),
+    asstTextEntry('ok'),
+  ];
+  const details = extractDetailBlocks(entries);
+  const output = details.find((d) => d.kind === DETAIL_KIND.TOOL_OUTPUT);
+  assert.equal(output.output_text, 'green file');
+});
+
+test('extractDetailBlocks: system (stop_hook_summary) と queue-operation はスキップ', () => {
+  const entries = [
+    userEntry('prompt'),
+    { type: 'system', subtype: 'stop_hook_summary', hookCount: 3 },
+    { type: 'queue-operation', op: 'enqueue' },
+    { type: 'file-history-snapshot', uuid: 'abc' },
+    asstTextEntry('reply'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 0);
+});
+
+test('extractDetailBlocks: tool_result の content が配列でも処理できる', () => {
+  const entries = [
+    userEntry('fetch'),
+    asstToolUseEntry('t1', 'Read', { file_path: '/x' }),
+    userToolResultEntry('t1', [
+      { type: 'text', text: 'line1\n' },
+      { type: 'text', text: 'line2' },
+    ]),
+    asstTextEntry('done'),
+  ];
+  const details = extractDetailBlocks(entries);
+  const output = details.find((d) => d.kind === DETAIL_KIND.TOOL_OUTPUT);
+  assert.equal(output.output_text, 'line1\nline2');
+});
+
+test('extractDetailBlocks: 複数ツール連続呼び出しを全て拾う', () => {
+  const entries = [
+    userEntry('investigate'),
+    asstToolUseEntry('t1', 'Read', { path: '/a' }),
+    userToolResultEntry('t1', 'a contents'),
+    asstToolUseEntry('t2', 'Grep', { pattern: 'foo' }),
+    userToolResultEntry('t2', 'foo found'),
+    asstTextEntry('summary'),
+  ];
+  const details = extractDetailBlocks(entries);
+  assert.equal(details.length, 4);
+  assert.deepEqual(
+    details.map((d) => d.kind),
+    [DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT, DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT],
+  );
+});

package/src/transcript-usage.mjs

@@ -0,0 +1,128 @@
+/**
+ * transcript-usage.mjs — Transcript JSONL の最新 assistant エントリから
+ * Anthropic API の実測 usage を抽出する（length/4 ヒューリスティックを置き換え）
+ *
+ * 各 assistant エントリの構造:
+ *   {
+ *     type: "assistant",
+ *     message: {
+ *       model: "claude-opus-4-6[1m]",
+ *       usage: {
+ *         input_tokens: 1234,
+ *         cache_creation_input_tokens: 567,
+ *         cache_read_input_tokens: 890,
+ *         output_tokens: 42
+ *       }
+ *     }
+ *   }
+ *
+ * 現在の context 使用量 = input_tokens + cache_creation_input_tokens + cache_read_input_tokens
+ * これは API が「このリクエストに投入された文脈サイズ」として返す実測値。
+ *
+ * 差分読みキャッシュ:
+ *   path → { size, lastUsage, lastModel, lastReadAt }
+ *   次回呼び出し時、size が不変ならキャッシュ値を返す。
+ *   変化していれば全読みして末尾の assistant usage を更新。
+ *   (差分 byte offset 読みは将来最適化。まずは全読みで正確性優先)
+ */
+
+import { readFileSync, statSync, existsSync } from 'node:fs';
+
+/**
+ * @typedef {Object} UsageSample
+ * @property {number} tokens - 文脈使用量 (input + cache_creation + cache_read)
+ * @property {string} model - モデル名 (e.g. "claude-opus-4-6[1m]")
+ * @property {number} contextWindowSize - 推定コンテキスト上限 (200_000 or 1_000_000)
+ * @property {number} outputTokens - output_tokens (参考)
+ */
+
+/**
+ * モデル名 + 実測トークン数 + transcript 本文のヒントから context_window_size を推論する。
+ *
+ * 注意: Claude Code の transcript JSONL の `message.model` は base name のみで
+ * `[1m]` サフィックスが含まれない（実測確認済み 2026-04-15）。slug/entrypoint/version にも
+ * 1M コンテキスト識別子は無い。そのため純粋なモデル名推論では 1M セッションを検出できない。
+ *
+ * 検出優先順位:
+ *   1. モデル名に `[1m]` サフィックス
+ *   2. transcript 本文に `[1m]` / `1M context` 文字列（Claude の system prompt 由来）
+ *   3. 実測トークン数 > 200k（事後検出、フォールバック）
+ *
+ * @param {string} model
+ * @param {number} [observedTokens=0]
+ * @param {boolean} [rawHint=false] - transcript 本文に 1M 識別子が含まれるか
+ * @returns {number}
+ */
+export function inferContextWindowSize(model, observedTokens = 0, rawHint = false) {
+  if (model && /\[1m\]/i.test(model)) return 1_000_000;
+  if (rawHint) return 1_000_000;
+  if (observedTokens > 200_000) return 1_000_000;
+  return 200_000;
+}
+
+/**
+ * transcript 本文に 1M コンテキスト識別子が含まれるかを判定する。
+ * Claude の system prompt に "claude-opus-4-6[1m]" や "(with 1M context)" が
+ * 含まれる場合、transcript JSONL の本文にも当該文字列が現れる。
+ *
+ * @param {string} raw
+ * @returns {boolean}
+ */
+function hasContextWindowHint(raw) {
+  return /\[1m\]|1M context/i.test(raw);
+}
+
+/** @type {Map<string, {size: number, sample: UsageSample|null}>} */
+const cache = new Map();
+
+/**
+ * transcript JSONL から最新の assistant usage を抽出する
+ * @param {string} transcriptPath
+ * @returns {UsageSample | null}
+ */
+export function readLatestUsage(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return null;
+
+  const { size } = statSync(transcriptPath);
+  const cached = cache.get(transcriptPath);
+  if (cached && cached.size === size) {
+    return cached.sample;
+  }
+
+  const raw = readFileSync(transcriptPath, 'utf8');
+  const rawHint = hasContextWindowHint(raw);
+  let latest = null;
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      // JSONL 末尾の partial-write 行は skip する（JSONL 仕様上の許容）
+      continue;
+    }
+    if (entry.type !== 'assistant') continue;
+    const usage = entry.message?.usage;
+    if (!usage) continue;
+    const tokens =
+      (usage.input_tokens ?? 0) +
+      (usage.cache_creation_input_tokens ?? 0) +
+      (usage.cache_read_input_tokens ?? 0);
+    const model = entry.message?.model ?? '';
+    latest = {
+      tokens,
+      model,
+      contextWindowSize: inferContextWindowSize(model, tokens, rawHint),
+      outputTokens: usage.output_tokens ?? 0,
+    };
+  }
+
+  cache.set(transcriptPath, { size, sample: latest });
+  return latest;
+}
+
+/** キャッシュを全削除（テスト用） */
+export function clearUsageCache() {
+  cache.clear();
+}

package/src/turn-processor.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — L1 要約生成 + L2 本文保存 + turn_number 確定
+ *
+ * stdin: { session_id, transcript_path }
+ * 処理:
+ *   0. 【再帰ガード】環境変数 THROUGHLINE_IN_HAIKU_SUBPROCESS=1 が立っていたら即 exit
+ *      （Haiku 要約用の claude -p subprocess 内で自分自身の Stop hook として起動された場合）
+ *   1. resolveMergeTarget で「実書き込み先 (target) / origin」を解決
+ *      （input session が別セッションに合流済みなら合流先に書く）
+ *   2. 最後の assistant ターン + 直前の user ターンのペアを取得
+ *   3. L2 本文 (bodies) に user / assistant の 2 行を INSERT
+ *   4. 【遅延要約】target 配下の bodies ターン数 (distinct origin×turn) が
+ *      WINDOW (=20) を超えていたら、最古の未要約ターンを 1 件だけ
+ *      Haiku 4.5 で要約 → skeletons (L1) に INSERT。
+ *      20 ターン以内で作業が終わるケースでは Haiku コスト 0。
+ *      /clear 跨ぎでも同様に、合流後のターン総数が 20 超えた時点から逐次発火。
+ *      失敗時は L2 全文をそのまま L1 に入れる（情報欠損ゼロ）
+ *   5. turn_number=NULL の details レコードを確定 (L3)
+ *
+ * schema v4 以降で動作。judgments テーブルは廃止済み。
+ */
+
+// ★★★ 再帰暴走ガード ★★★
+// haiku-summarizer が spawn する claude -p は独立した Claude Code セッションで、
+// 同じ .claude/settings.json を読んで自分の Stop hook を起動する。放置すると
+// turn-processor → claude -p → turn-processor → claude -p → ... の無限再帰で
+// 大量の node プロセスが生まれ API 500 を引き起こす。
+// haiku-summarizer が spawn 時に env.THROUGHLINE_IN_HAIKU_SUBPROCESS=1 を設定するので
+// ここで即検出して exit する。env は child_process.spawn で継承される。
+if (process.env.THROUGHLINE_IN_HAIKU_SUBPROCESS === '1') {
+  process.exit(0);
+}
+
+import { getDb } from './db.mjs';
+import {
+  getLastTurnPair,
+  readRawEntries,
+  sliceCurrentTurnEntries,
+  extractDetailBlocks,
+} from './transcript-reader.mjs';
+import { resolveMergeTarget } from './session-merger.mjs';
+import { writeSessionState } from './state-file.mjs';
+import { summarizeToL1 } from './haiku-summarizer.mjs';
+
+/** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
+export const L2_WINDOW = 20;
+
+/**
+ * target 配下の distinct (origin_session_id, turn_number) ターン数を返す。
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} target
+ */
+export function countDistinctBodyTurns(db, target) {
+  const row = db
+    .prepare(
+      `SELECT COUNT(*) AS c FROM (
+         SELECT DISTINCT origin_session_id, turn_number
+         FROM bodies
+         WHERE session_id = ?
+       )`,
+    )
+    .get(target);
+  return row?.c ?? 0;
+}
+
+/**
+ * bodies に存在し skeletons に未登録の最古ターンを 1 件返す。
+ * 遅延要約のターゲット選択に使う。
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} target
+ * @returns {{ origin_session_id: string, turn_number: number, created_at: number } | null}
+ */
+export function pickOldestUnsummarizedTurn(db, target) {
+  const row = db
+    .prepare(
+      `SELECT b.origin_session_id, b.turn_number, MIN(b.created_at) AS created_at
+       FROM bodies b
+       WHERE b.session_id = ?
+         AND NOT EXISTS (
+           SELECT 1 FROM skeletons s
+           WHERE s.session_id = b.session_id
+             AND s.origin_session_id = b.origin_session_id
+             AND s.turn_number = b.turn_number
+         )
+       GROUP BY b.origin_session_id, b.turn_number
+       ORDER BY created_at ASC
+       LIMIT 1`,
+    )
+    .get(target);
+  return row ?? null;
+}
+
+/**
+ * user と assistant のペアを結合して L2 要約用テキストを作る。
+ * @param {{content: string} | null} userTurn
+ * @param {{content: string} | null} assistantTurn
+ * @returns {string}
+ */
+function buildL2ForSummary(userTurn, assistantTurn) {
+  const parts = [];
+  if (userTurn?.content) parts.push(`[user]: ${userTurn.content}`);
+  if (assistantTurn?.content) parts.push(`[assistant]: ${assistantTurn.content}`);
+  return parts.join('\n\n');
+}
+
+async function main() {
+  let raw = '';
+  await new Promise((resolve) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', resolve);
+  });
+
+  const payload = JSON.parse(raw || '{}');
+  const { session_id, transcript_path, cwd } = payload;
+  if (!session_id) throw new Error('Missing session_id in Stop payload');
+
+  // Stop hook 時点で state ファイルを更新 → token-monitor の「アクティブ行」判定が
+  // アシスタント応答終了時刻まで追従する
+  writeSessionState({
+    sessionId: session_id,
+    projectPath: cwd ?? process.cwd(),
+    transcriptPath: transcript_path ?? null,
+    pid: process.ppid,
+  });
+
+  const db = getDb();
+  const now = Date.now();
+
+  // merge target 解決: 入力 session が既に合流済みなら target = 合流先
+  const { target, origin } = resolveMergeTarget(db, session_id);
+
+  // target の sessions 行を upsert
+  const existing = db
+    .prepare('SELECT session_id FROM sessions WHERE session_id = ?')
+    .get(target);
+  if (!existing) {
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES (?, ?, 'active', ?, ?)`,
+    ).run(target, cwd ?? process.cwd(), now, now);
+  } else {
+    db.prepare('UPDATE sessions SET updated_at = ? WHERE session_id = ?').run(now, target);
+  }
+
+  // 最後の assistant ターン + 直前の user ターンを取得
+  const { user: userTurn, assistant: assistantTurn } = getLastTurnPair(transcript_path);
+  if (!assistantTurn) {
+    // /clear 直後などでトランスクリプトが空の場合は何もしない
+    process.exit(0);
+  }
+
+  const turnNumber = assistantTurn.turn_number;
+
+  // L2 = bodies に user / assistant を個別行で保存
+  const insertBody = db.prepare(
+    `INSERT OR IGNORE INTO bodies
+       (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  );
+  // user / assistant を「1 往復 = 1 ターン」として扱うため、同じ turn_number
+  // （= assistant 側の turn_number）でペアリングして保存する。
+  // これにより bodies と skeletons が同じ turn_number で突合できる。
+  if (userTurn?.content) {
+    insertBody.run(
+      target,
+      origin,
+      turnNumber,
+      'user',
+      userTurn.content,
+      Math.round(userTurn.content.length / 4),
+      now,
+    );
+  }
+  if (assistantTurn?.content) {
+    insertBody.run(
+      target,
+      origin,
+      turnNumber,
+      'assistant',
+      assistantTurn.content,
+      Math.round(assistantTurn.content.length / 4),
+      now,
+    );
+  }
+
+  // L1 = 遅延要約。target 配下の bodies ターン数 (distinct origin×turn) が
+  // WINDOW を超えていたら、最古の未要約ターンを 1 件だけ要約する。
+  // 20 ターン以内で終わる作業では Haiku コストゼロ。
+  if (countDistinctBodyTurns(db, target) > L2_WINDOW) {
+    const oldest = pickOldestUnsummarizedTurn(db, target);
+    if (oldest) {
+      const rows = db
+        .prepare(
+          `SELECT role, text FROM bodies
+           WHERE session_id = ? AND origin_session_id = ? AND turn_number = ?`,
+        )
+        .all(target, oldest.origin_session_id, oldest.turn_number);
+      const userRow = rows.find((r) => r.role === 'user');
+      const asstRow = rows.find((r) => r.role === 'assistant');
+      const l2ForSummary = buildL2ForSummary(
+        userRow ? { content: userRow.text } : null,
+        asstRow ? { content: asstRow.text } : null,
+      );
+      const { summary } = summarizeToL1(l2ForSummary);
+
+      db.prepare(
+        `INSERT OR IGNORE INTO skeletons
+           (session_id, origin_session_id, turn_number, role, summary, created_at)
+         VALUES (?, ?, ?, 'assistant', ?, ?)`,
+      ).run(
+        target,
+        oldest.origin_session_id,
+        oldest.turn_number,
+        summary,
+        oldest.created_at,
+      );
+    }
+  }
+
+  // L3 = transcript から tool_use / tool_result / attachment (hook) を抽出して details に INSERT
+  // extractDetailBlocks はこの論理ターンの範囲のみをスキャンする。再実行時は
+  // source_id ベースの UNIQUE 制約で冪等性を確保（INSERT OR IGNORE）。
+  const allEntries = transcript_path ? readRawEntries(transcript_path) : [];
+  const turnEntries = sliceCurrentTurnEntries(allEntries);
+  const detailBlocks = extractDetailBlocks(turnEntries);
+
+  if (detailBlocks.length > 0) {
+    const insertDetail = db.prepare(
+      `INSERT OR IGNORE INTO details
+         (session_id, origin_session_id, turn_number, tool_name, input_text, output_text,
+          token_count, created_at, kind, source_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    // 数百行の INSERT を 1 トランザクションにまとめて fsync コストを 1 回に抑える
+    db.exec('BEGIN');
+    try {
+      for (const d of detailBlocks) {
+        const tokenCount = Math.round(
+          ((d.input_text?.length ?? 0) + (d.output_text?.length ?? 0)) / 4,
+        );
+        insertDetail.run(
+          target,
+          origin,
+          turnNumber,
+          d.tool_name,
+          d.input_text,
+          d.output_text,
+          tokenCount,
+          now,
+          d.kind,
+          d.source_id,
+        );
+      }
+      db.exec('COMMIT');
+    } catch (err) {
+      db.exec('ROLLBACK');
+      throw err;
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`[turn-processor] error: ${msg}\n`);
+  process.exit(1);
+});