throughline 0.7.0 → 0.8.1

package/src/cli/factory-diagnostics.test.mjs

@@ -5,6 +5,7 @@ import { existsSync, mkdtempSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
+import { CURRENT_VERSION } from '../db.mjs';
 import {
   collectFactoryDiagnostics,
   inspectFactoryDatabase,
@@ -19,7 +20,12 @@ test('factory-diagnostics CLI: JSON-only contract and schema fixture', () => {
     stdout: { write(value) { output.push(value); } },
     version: '0.6.1',
     inspectThread: () => ({ status: 'ready', rolloutAvailable: true }),
-    inspectDatabase: () => ({ status: 'ready', schemaVersion: 8, handoffMemory: true }),
+    inspectDatabase: () => ({
+      status: 'ready',
+      schemaVersion: CURRENT_VERSION,
+      supportedSchemaVersion: CURRENT_VERSION,
+      handoffMemory: true,
+    }),
     inspectHooks: () => ({
       status: 'ready',
       claudeStatus: 'ready',
@@ -32,6 +38,9 @@ test('factory-diagnostics CLI: JSON-only contract and schema fixture', () => {
   const parsed = JSON.parse(output[0]);
   assert.equal(parsed.schema, 'throughline.native_factory_diagnostics.v1');
   assert.equal(parsed.version, '0.6.1');
+  assert.equal(parsed.databaseSchema.schema, `throughline.database.v${CURRENT_VERSION}`);
+  assert.equal(parsed.databaseSchema.databaseSchemaVersion, CURRENT_VERSION);
+  assert.equal(parsed.databaseSchema.supportedDatabaseSchemaVersion, CURRENT_VERSION);
   assert.equal(parsed.readiness.restore.status, 'ready');
   assert.equal(parsed.evidence.restoreSmoke.status, 'unverified');
 });

package/src/cli/recall.mjs

@@ -0,0 +1,279 @@
+/**
+ * `throughline recall` — 注入案内から辿る pull 用の DB 直参照 CLI (read-only)
+ *
+ * 注入（push）は「現在地 + 入るだけの L2」だけを運び、残りの記憶は本コマンドで
+ * 必要な時だけ取得する（オーナー裁定 2026-07-18、ADR 0016）:
+ *   - `recall --l2 --session <id> --before <ISO日時> --last <N>`
+ *       境界（strict less-than, ms 比較）より古いターンを新しい側から N 件、
+ *       L2 全文（注入と同じ行文法 + L3 参照 suffix）で出す。
+ *   - `recall --l1 --session <id> --before <ISO日時> --skip <N>`
+ *       境界から N 件（--l2 の担当分）を飛ばした先の全ターン一覧。
+ *       L1 要約があれば要約、無ければ「未要約」と明示して detail 誘導を出す。
+ *
+ * 契約:
+ *   - 範囲・境界・session は注入時に案内コマンドへ焼き込まれた値だけで決まる。
+ *     recall 側で「現在の 20 ターン窓」を再計算しない（新セッションのターン追記で
+ *     窓がスライドし、古い側が黙って欠落するため）。
+ *   - DB は read-only で開く（create / migrate / write なし）。DB が無ければ
+ *     explicit error で終了する。
+ *   - 既定 session 解決は持たない。案内コマンドが常に `--session` を運ぶ。
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { formatTime } from '../handoff-record.mjs';
+import { groupL3ByTurn, buildPartsSummary } from '../l3-summary.mjs';
+
+export function defaultRecallDbPath() {
+  return join(homedir(), '.throughline', 'throughline.db');
+}
+
+const USAGE =
+  'usage: throughline recall (--l2 --last <N> | --l1 [--skip <N>] [--last <N>]) ' +
+  '--session <id> --before <ISO8601> [--db <path>]';
+
+export function parseRecallArgs(argv) {
+  const opts = {
+    mode: null,
+    sessionId: null,
+    beforeMs: null,
+    last: null,
+    skip: 0,
+    dbPath: null,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--l2' || a === '--l1') {
+      if (opts.mode) throw new Error('recall: --l2 と --l1 は同時に指定できません');
+      opts.mode = a.slice(2);
+    } else if (a === '--session') {
+      opts.sessionId = argv[++i];
+    } else if (a === '--before') {
+      const raw = argv[++i];
+      const ms = Date.parse(raw ?? '');
+      if (!Number.isFinite(ms)) {
+        throw new Error(`recall: --before の日時を解釈できません: ${raw}（ISO 8601 を指定）`);
+      }
+      opts.beforeMs = ms;
+    } else if (a === '--last') {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 0) throw new Error('recall: --last は 0 以上の整数');
+      opts.last = n;
+    } else if (a === '--skip') {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 0) throw new Error('recall: --skip は 0 以上の整数');
+      opts.skip = n;
+    } else if (a === '--db') {
+      opts.dbPath = argv[++i];
+    } else {
+      throw new Error(`recall: 未知の引数: ${a}\n${USAGE}`);
+    }
+  }
+  if (!opts.mode) throw new Error(`recall: --l2 または --l1 を指定してください\n${USAGE}`);
+  if (!opts.sessionId) throw new Error(`recall: --session は必須です\n${USAGE}`);
+  if (opts.beforeMs == null) throw new Error(`recall: --before は必須です\n${USAGE}`);
+  if (opts.mode === 'l2' && opts.last == null) {
+    throw new Error(`recall: --l2 には --last <N> が必須です\n${USAGE}`);
+  }
+  return opts;
+}
+
+/**
+ * 境界より古い側の distinct ターンを新しい順に列挙する。
+ * 各要素: { originSessionId, turnNumber, turnKey, minCreatedAt }
+ */
+function listTurnsBefore(db, { sessionId, beforeMs }) {
+  const rows = db
+    .prepare(
+      `SELECT origin_session_id, turn_number, MIN(created_at) AS min_ca, MAX(created_at) AS max_ca
+       FROM bodies
+       WHERE session_id = ? AND created_at < ?
+       GROUP BY origin_session_id, turn_number
+       ORDER BY min_ca DESC`,
+    )
+    .all(sessionId, beforeMs);
+  return rows.map((r) => ({
+    originSessionId: r.origin_session_id,
+    turnNumber: r.turn_number,
+    turnKey: `${r.origin_session_id}\x00${r.turn_number}`,
+    minCreatedAt: r.min_ca,
+    maxCreatedAt: r.max_ca,
+  }));
+}
+
+function loadL3ForTurns(db, sessionId, turns) {
+  if (turns.length === 0) return [];
+  const placeholders = turns.map(() => '(?, ?, ?)').join(', ');
+  const params = turns.flatMap((t) => [sessionId, t.originSessionId, Number(t.turnNumber)]);
+  return db
+    .prepare(
+      `SELECT kind, tool_name, origin_session_id, turn_number, created_at
+       FROM details
+       WHERE (session_id, origin_session_id, turn_number) IN (VALUES ${placeholders})
+       ORDER BY created_at ASC, id ASC`,
+    )
+    .all(...params)
+    .map((r) => ({
+      kind: r.kind,
+      toolName: r.tool_name,
+      originSessionId: r.origin_session_id,
+      turnNumber: r.turn_number,
+      createdAt: r.created_at,
+    }));
+}
+
+/**
+ * --l2: 境界より古いターンを新しい側から last 件、古い順の L2 全文で描画する。
+ */
+export function renderRecallL2(db, { sessionId, beforeMs, last }) {
+  const turnsDesc = listTurnsBefore(db, { sessionId, beforeMs });
+  const selected = turnsDesc.slice(0, last).reverse(); // 古い順に戻す
+  const lines = [];
+
+  if (selected.length === 0) {
+    lines.push(`## Throughline recall (L2): 該当ターンなし（--before ${new Date(beforeMs).toISOString()} より古い L2 が DB にありません）`);
+    return { text: lines.join('\n'), turnCount: 0 };
+  }
+
+  const range = `${formatTime(selected[0].minCreatedAt)}〜${formatTime(selected[selected.length - 1].maxCreatedAt)}`;
+  lines.push(`## Throughline recall (L2): ${selected.length}ターン (${range}, 古い順)`);
+  if (selected.length < last) {
+    lines.push(`（--last ${last} のうち DB に存在するのは ${selected.length} ターンのみ）`);
+  }
+  lines.push('');
+
+  const l3ByTurn = groupL3ByTurn(loadL3ForTurns(db, sessionId, selected));
+
+  const bodyStmt = db.prepare(
+    `SELECT role, text, created_at
+     FROM bodies
+     WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND created_at < ?
+     ORDER BY created_at ASC`,
+  );
+  for (const turn of selected) {
+    const rows = bodyStmt
+      .all(sessionId, turn.originSessionId, Number(turn.turnNumber), beforeMs)
+      .filter((r) => r.text);
+    for (let i = 0; i < rows.length; i += 1) {
+      const r = rows[i];
+      const isLast = i === rows.length - 1;
+      const partCounts = isLast ? (l3ByTurn.get(turn.turnKey)?.partCounts ?? new Map()) : new Map();
+      const suffix = buildPartsSummary(partCounts);
+      lines.push(`[${formatTime(r.created_at)}] [${r.role}]: ${r.text}${suffix}`);
+    }
+  }
+  return { text: lines.join('\n'), turnCount: selected.length };
+}
+
+/**
+ * --l1: 境界から skip 件を飛ばした先の全ターン一覧（古い順）。
+ * L1 要約があれば要約行、無ければ「未要約」と明示して detail 誘導を出す。
+ */
+export function renderRecallL1(db, { sessionId, beforeMs, skip, last = null }) {
+  const turnsDesc = listTurnsBefore(db, { sessionId, beforeMs });
+  let olderDesc = turnsDesc.slice(skip);
+  if (last != null) olderDesc = olderDesc.slice(0, last);
+  const selected = [...olderDesc].reverse(); // 古い順
+  const lines = [];
+
+  if (selected.length === 0) {
+    lines.push('## Throughline recall (L1): 該当ターンなし');
+    return { text: lines.join('\n'), turnCount: 0, summarizedCount: 0 };
+  }
+
+  const skelRows = db
+    .prepare(
+      `SELECT origin_session_id, turn_number, summary, created_at
+       FROM skeletons
+       WHERE session_id = ?
+       ORDER BY created_at ASC`,
+    )
+    .all(sessionId);
+  const skelByTurn = new Map();
+  for (const r of skelRows) {
+    const key = `${r.origin_session_id}\x00${r.turn_number}`;
+    if (!skelByTurn.has(key)) skelByTurn.set(key, []);
+    skelByTurn.get(key).push(r);
+  }
+
+  let summarizedCount = 0;
+  const bodyLines = [];
+  for (const turn of selected) {
+    const time = formatTime(turn.minCreatedAt);
+    const skels = skelByTurn.get(turn.turnKey);
+    if (skels && skels.length > 0) {
+      summarizedCount += 1;
+      for (const s of skels) {
+        if (!s.summary || s.summary === '(no content)') continue;
+        const summary = s.summary.replace(/\n+/g, ' ').trim();
+        bodyLines.push(`[${time}] ${summary}`);
+      }
+    } else {
+      bodyLines.push(`[${time}] (未要約) 全文: throughline detail ${time}`);
+    }
+  }
+
+  const range = `${formatTime(selected[0].minCreatedAt)}〜${formatTime(selected[selected.length - 1].minCreatedAt)}`;
+  lines.push(
+    `## Throughline recall (L1): 全${selected.length}ターン / 要約済み ${summarizedCount} (${range}, 古い順)`,
+  );
+  lines.push('各ターンの全文・ツール入出力: `throughline detail <時刻>` で取得可');
+  lines.push('');
+  lines.push(...bodyLines);
+  return { text: lines.join('\n'), turnCount: selected.length, summarizedCount };
+}
+
+export function runRecall(db, opts) {
+  if (opts.mode === 'l2') {
+    return renderRecallL2(db, {
+      sessionId: opts.sessionId,
+      beforeMs: opts.beforeMs,
+      last: opts.last,
+    });
+  }
+  return renderRecallL1(db, {
+    sessionId: opts.sessionId,
+    beforeMs: opts.beforeMs,
+    skip: opts.skip,
+    last: opts.last,
+  });
+}
+
+export function run(argv) {
+  let opts;
+  try {
+    opts = parseRecallArgs(argv);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  }
+
+  const dbPath = opts.dbPath ?? defaultRecallDbPath();
+  if (!existsSync(dbPath)) {
+    process.stderr.write(`recall: DB がありません: ${dbPath}（recall は DB を作成しません）\n`);
+    return 1;
+  }
+
+  let db;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+  } catch (err) {
+    process.stderr.write(
+      `recall: DB を read-only で開けませんでした: ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    return 1;
+  }
+
+  try {
+    const result = runRecall(db, opts);
+    process.stdout.write(`${result.text}\n`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`recall: ${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  } finally {
+    db.close();
+  }
+}

package/src/cli/recall.test.mjs

@@ -0,0 +1,269 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { parseRecallArgs, renderRecallL2, renderRecallL1 } from './recall.mjs';
+
+const BIN = fileURLToPath(new URL('../../bin/throughline.mjs', import.meta.url));
+
+function makeDb(path = ':memory:') {
+  const db = new DatabaseSync(path);
+  db.exec(`
+    CREATE TABLE skeletons (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE bodies (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      text TEXT NOT NULL,
+      token_count INTEGER,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE details (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER,
+      tool_name TEXT NOT NULL,
+      input_text TEXT,
+      output_text TEXT,
+      token_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      kind TEXT,
+      source_id TEXT
+    );
+  `);
+  return db;
+}
+
+function insertBody(db, { session, origin, turn, role, text, createdAt }) {
+  db.prepare(
+    `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES (?, ?, ?, ?, ?, 1, ?)`,
+  ).run(session, origin, turn, role, text, createdAt);
+}
+
+function insertSkeleton(db, { session, origin, turn, role, summary, createdAt }) {
+  db.prepare(
+    `INSERT INTO skeletons (session_id, origin_session_id, turn_number, role, summary, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(session, origin, turn, role, summary, createdAt);
+}
+
+// day: 2026-07-17T23:50:00Z 起点の ms を返す (深夜跨ぎテスト用)
+const BASE = Date.parse('2026-07-17T23:50:00.000Z');
+
+function seedTurns(db, { session = 's1', origin = 'o1', turns = 10, stepMs = 60_000 } = {}) {
+  for (let t = 1; t <= turns; t += 1) {
+    insertBody(db, {
+      session, origin, turn: t, role: 'user',
+      text: `q-${String(t).padStart(2, '0')}`, createdAt: BASE + t * stepMs,
+    });
+    insertBody(db, {
+      session, origin, turn: t, role: 'assistant',
+      text: `a-${String(t).padStart(2, '0')}`, createdAt: BASE + t * stepMs + 1_000,
+    });
+  }
+}
+
+test('parseRecallArgs: mode/session/before are required, --l2 requires --last', () => {
+  assert.throws(() => parseRecallArgs([]), /--l2 または --l1/);
+  assert.throws(() => parseRecallArgs(['--l2', '--session', 's', '--last', '3']), /--before は必須/);
+  assert.throws(() => parseRecallArgs(['--l2', '--before', '2026-07-18T00:00:00Z', '--last', '3']), /--session は必須/);
+  assert.throws(
+    () => parseRecallArgs(['--l2', '--session', 's', '--before', '2026-07-18T00:00:00Z']),
+    /--last <N> が必須/,
+  );
+  assert.throws(() => parseRecallArgs(['--l2', '--l1']), /同時に指定できません/);
+  assert.throws(
+    () => parseRecallArgs(['--l2', '--session', 's', '--before', '14:02:11', '--last', '3']),
+    /解釈できません/,
+    'HH:MM:SS 単独は日付が無く受け付けない (深夜跨ぎで壊れるため ISO 必須)',
+  );
+  const ok = parseRecallArgs([
+    '--l1', '--session', 's', '--before', '2026-07-18T00:00:00.482Z', '--skip', '7',
+  ]);
+  assert.equal(ok.mode, 'l1');
+  assert.equal(ok.beforeMs, Date.parse('2026-07-18T00:00:00.482Z'));
+  assert.equal(ok.skip, 7);
+});
+
+test('recall --l2: strict less-than ms boundary, newest-first selection, oldest-first output', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 10 });
+  // 境界 = turn 8 の min(created_at) → turn 7 以前だけが対象 (turn 8 自身は含まない)
+  const boundary = BASE + 8 * 60_000;
+
+  const { text, turnCount } = renderRecallL2(db, { sessionId: 's1', beforeMs: boundary, last: 3 });
+
+  assert.equal(turnCount, 3);
+  assert.ok(!text.includes('a-08'), 'boundary turn itself must be excluded (strict less-than)');
+  assert.ok(text.includes('q-05') && text.includes('a-07'), 'turns 5..7 must be returned');
+  assert.ok(!text.includes('q-04 '), 'turns older than --last window are not returned');
+  // 古い順: q-05 が a-07 より先
+  assert.ok(text.indexOf('q-05') < text.indexOf('a-07'));
+});
+
+test('recall --l2: same-second sibling rows are split exactly by ms boundary (no gap, no overlap)', () => {
+  const db = makeDb();
+  const sec = Date.parse('2026-07-18T01:02:03.000Z');
+  // 同一秒内に 2 ターン (ms 差のみ)
+  insertBody(db, { session: 's1', origin: 'o1', turn: 1, role: 'assistant', text: 'ms-100', createdAt: sec + 100 });
+  insertBody(db, { session: 's1', origin: 'o1', turn: 2, role: 'assistant', text: 'ms-482', createdAt: sec + 482 });
+
+  const { text } = renderRecallL2(db, { sessionId: 's1', beforeMs: sec + 482, last: 10 });
+  assert.ok(text.includes('ms-100'), 'older same-second row must be included');
+  assert.ok(!text.includes('ms-482'), 'boundary row itself must be excluded');
+});
+
+test('recall --l2: ISO boundary works across midnight (no today-anchored resolution)', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 10 }); // BASE=23:50Z 起点、turn 10 は翌日 00:30Z 台
+  const boundary = BASE + 10 * 60_000; // 日付跨ぎ後の turn 10 の min
+
+  const { text, turnCount } = renderRecallL2(db, { sessionId: 's1', beforeMs: boundary, last: 20 });
+  assert.equal(turnCount, 9, 'all 9 turns before the post-midnight boundary must be found');
+  assert.ok(text.includes('q-01'));
+});
+
+test('recall --l2: results do not shift when the new session appends turns (no window recomputation)', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 10 });
+  const boundary = BASE + 8 * 60_000;
+  const before = renderRecallL2(db, { sessionId: 's1', beforeMs: boundary, last: 3 });
+
+  // 新セッションのターンが同じ session_id へ大量に追記されても (merge 後の走行)、
+  // recall の結果は焼き込まれた境界だけで決まり不変
+  for (let t = 100; t < 130; t += 1) {
+    insertBody(db, {
+      session: 's1', origin: 'newborn', turn: t, role: 'assistant',
+      text: `new-${t}`, createdAt: BASE + t * 60_000,
+    });
+  }
+  const after = renderRecallL2(db, { sessionId: 's1', beforeMs: boundary, last: 3 });
+  assert.equal(after.text, before.text);
+});
+
+test('recall --l2: fewer rows than --last is announced, not silent', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 3 });
+  const { text, turnCount } = renderRecallL2(db, {
+    sessionId: 's1', beforeMs: BASE + 3 * 60_000, last: 13,
+  });
+  assert.equal(turnCount, 2);
+  assert.match(text, /--last 13 のうち DB に存在するのは 2 ターンのみ/);
+});
+
+test('recall --l2: other sessions are not mixed in', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 3 });
+  insertBody(db, {
+    session: 'codex:zzz', origin: 'codex:zzz', turn: 1, role: 'assistant',
+    text: 'codex-row', createdAt: BASE + 60_000,
+  });
+  const { text } = renderRecallL2(db, { sessionId: 's1', beforeMs: BASE + 10 * 60_000, last: 20 });
+  assert.ok(!text.includes('codex-row'));
+});
+
+test('recall --l2: L3 suffix appears on the last row of each turn', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 3 });
+  db.prepare(
+    `INSERT INTO details (session_id, origin_session_id, turn_number, tool_name, input_text, output_text, token_count, created_at, kind, source_id)
+     VALUES ('s1', 'o1', 1, 'Bash', 'ls', 'ok', 1, ?, 'tool_input', 'tu-1')`,
+  ).run(BASE + 60_000 + 500);
+  const { text } = renderRecallL2(db, { sessionId: 's1', beforeMs: BASE + 10 * 60_000, last: 20 });
+  assert.match(text, /a-01 \(詳細：Bash\)/);
+});
+
+test('recall --l1: skip jumps over the --l2 range; summarized and unsummarized turns are both listed', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 10 });
+  // turn 1, 2 だけ要約済み
+  insertSkeleton(db, { session: 's1', origin: 'o1', turn: 1, role: 'assistant', summary: 'sum-1', createdAt: BASE });
+  insertSkeleton(db, { session: 's1', origin: 'o1', turn: 2, role: 'assistant', summary: 'sum-2', createdAt: BASE });
+
+  // 境界 = turn 8 の min。--skip 3 で turn 7..5 を飛ばし、turn 4 以前が対象
+  const boundary = BASE + 8 * 60_000;
+  const { text, turnCount, summarizedCount } = renderRecallL1(db, {
+    sessionId: 's1', beforeMs: boundary, skip: 3,
+  });
+
+  assert.equal(turnCount, 4, 'turns 1..4 must be listed');
+  assert.equal(summarizedCount, 2);
+  assert.match(text, /全4ターン \/ 要約済み 2/);
+  assert.ok(text.includes('sum-1') && text.includes('sum-2'));
+  assert.match(text, /\(未要約\) 全文: throughline detail \d{2}:\d{2}:\d{2}/);
+  assert.ok(!text.includes('q-05'), 'skipped turns (--l2 range) must not appear');
+  // 古い順: sum-1 が未要約 turn 4 より先
+  assert.ok(text.indexOf('sum-1') < text.indexOf('(未要約)'));
+});
+
+test('recall --l1: empty result is explicit', () => {
+  const db = makeDb();
+  seedTurns(db, { turns: 2 });
+  const { text, turnCount } = renderRecallL1(db, {
+    sessionId: 's1', beforeMs: BASE + 2 * 60_000, skip: 5,
+  });
+  assert.equal(turnCount, 0);
+  assert.match(text, /該当ターンなし/);
+});
+
+test('recall CLI: read-only contract — missing DB is an explicit error and is not created', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-recall-'));
+  const dbPath = join(dir, 'nope', 'throughline.db');
+  try {
+    let failed = false;
+    try {
+      execFileSync(
+        process.execPath,
+        [BIN, 'recall', '--l2', '--session', 's1',
+          '--before', '2026-07-18T00:00:00Z', '--last', '3', '--db', dbPath],
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+      );
+    } catch (err) {
+      failed = true;
+      assert.match(String(err.stderr), /DB がありません/);
+    }
+    assert.ok(failed, 'missing DB must exit non-zero');
+    assert.ok(!existsSync(dbPath), 'recall must not create the DB');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('recall CLI: end-to-end via bin dispatcher against a real DB file', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-recall-'));
+  const dbPath = join(dir, 'throughline.db');
+  try {
+    const db = makeDb(dbPath);
+    seedTurns(db, { turns: 5 });
+    db.close();
+
+    const boundaryIso = new Date(BASE + 4 * 60_000).toISOString();
+    const out = execFileSync(
+      process.execPath,
+      [BIN, 'recall', '--l2', '--session', 's1',
+        '--before', boundaryIso, '--last', '2', '--db', dbPath],
+      { encoding: 'utf8' },
+    );
+    assert.match(out, /## Throughline recall \(L2\): 2ターン/);
+    assert.ok(out.includes('a-03') && out.includes('q-02'));
+    assert.ok(!out.includes('a-04'), 'boundary turn must be excluded');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/completed-turn-receipts.mjs

@@ -20,7 +20,8 @@ export const COMPLETED_TURN_RECEIPT_SCHEMA_VERSION = '1.0';
 export const COMPLETED_TURN_RECEIPT_LIMIT = 256;
 
 const PRIVATE_DIRECTORY_CAPABILITY = Symbol('throughline.completed-turn-receipt-directory');
-const WINDOWS_ACL_TIMEOUT_MS = 3_000;
+// CI実測でPowerShellコールドスタートが3.0〜3.2秒に達しflakeしたため15秒 (run 29586852389 / 29628634501)
+const WINDOWS_ACL_TIMEOUT_MS = 15_000;
 
 export function defaultCompletedTurnReceiptStorePath(projectSha256, env = process.env) {
   if (!isSha256(projectSha256)) throw new TypeError('projectSha256 must be a SHA-256 digest');

package/src/factory-diagnostics.mjs

@@ -1,5 +1,7 @@
+import { CURRENT_VERSION } from './db.mjs';
+
 export const FACTORY_DIAGNOSTICS_SCHEMA = 'throughline.native_factory_diagnostics.v1';
-export const DATABASE_SCHEMA = 'throughline.database.v8';
+export const DATABASE_SCHEMA = `throughline.database.v${CURRENT_VERSION}`;
 
 const STATUSES = new Set(['ready', 'not_ready', 'not_applicable', 'unverified']);
 

package/src/factory-diagnostics.test.mjs

@@ -2,9 +2,26 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 import {
+  DATABASE_SCHEMA,
   FACTORY_DIAGNOSTICS_SCHEMA,
   buildFactoryDiagnostics,
 } from './factory-diagnostics.mjs';
+import { CURRENT_VERSION } from './db.mjs';
+
+test('factory diagnostics: database label は DB 実体・対応 version と一致する', () => {
+  const result = buildFactoryDiagnostics({
+    database: {
+      status: 'ready',
+      schemaVersion: CURRENT_VERSION,
+      supportedSchemaVersion: CURRENT_VERSION,
+      handoffMemory: true,
+    },
+  });
+
+  assert.equal(DATABASE_SCHEMA, `throughline.database.v${CURRENT_VERSION}`);
+  assert.equal(result.databaseSchema.schema, `throughline.database.v${result.databaseSchema.databaseSchemaVersion}`);
+  assert.equal(result.databaseSchema.databaseSchemaVersion, result.databaseSchema.supportedDatabaseSchemaVersion);
+});
 
 test('factory diagnostics: 未設定の native factory は not_applicable を成功へ丸めない', () => {
   const result = buildFactoryDiagnostics({

package/src/handoff-executor.mjs

@@ -140,8 +140,10 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
       injectionText = budgeted.text;
       injectionStats = {
         total_chars: budgeted.totalChars,
-        dropped_l1_rows: budgeted.droppedL1Rows,
-        dropped_l2_rows: budgeted.droppedL2Rows,
+        injected_l2_turns: budgeted.injectedL2Turns,
+        remaining_l2_turns: budgeted.remainingL2Turns,
+        older_turns: budgeted.olderTurns,
+        older_summarized: budgeted.olderSummarized,
         truncated_newest_l2: budgeted.truncatedNewestL2,
       };
     }