throughline 0.7.0 → 0.8.0

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/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,
       };
     }

package/src/resume-context.mjs

@@ -158,7 +158,13 @@ function buildResumeSections(db, { sessionId, isInheritance, excludeOriginId = n
     const isLastOfTurn = lastIdxPerTurn.get(key) === i;
     const partCounts = isLastOfTurn ? (l3ByTurn.get(key)?.partCounts ?? new Map()) : new Map();
     const suffix = buildPartsSummary(partCounts);
-    l2Lines.push({ text: `[${r.time}] [${r.role}]: ${r.text}${suffix}`, time: r.time, role: r.role });
+    l2Lines.push({
+      text: `[${r.time}] [${r.role}]: ${r.text}${suffix}`,
+      time: r.time,
+      role: r.role,
+      turnKey: key,
+      createdAt: r.createdAt,
+    });
   }
 
   return { header, anchorLines, l1Lines, l2Lines };
@@ -220,30 +226,119 @@ export function buildResumeContext(
  */
 export const INJECTION_BUDGET_CHARS = 9_500;
 
-// 予算超過時に注入へ入れる省略告知の予約分（この分を先に差し引いてから詰める）。
-// 告知には省略した L2 行の [時刻 role] 参照リストを含める — 窓内の L2 行にはまだ
-// L1 要約が無いことがあり、時刻が無いと `throughline detail` で取り出せなくなる
-// （= 「要約せず削る。ただし参照は必ず残す」コンセプトの担保）。
-const OMISSION_NOTE_RESERVE = 500;
-// l2Note 単体の上限 (RESERVE から l1Note ぶんの余裕を引いた値)
-const L2_NOTE_MAX_CHARS = 430;
-// 最新 L2 行が単体で予算を超える場合に、切り詰めてでも入れる最小の残余
+// 案内セクション（### さらに前の記憶）の予約分。ヘッダ・アンカーと同格の固定部として
+// 予算計算の最初に差し引き、どれだけ逼迫しても落とさない（無条件表示）。
+// 実文言はテンプレート固定 + 動的値（件数・時刻範囲・session id・ISO 境界）なので
+// この上限内に収まる（session id ~42 字 + ISO 24 字 + 本文 2 行で最大 ~520 字を実測見積もり）。
+const GUIDANCE_RESERVE = 600;
+// 最新 L2 ターンが単体で予算を超える場合に、切り詰めてでも入れる最小の残余
 const MIN_TRUNCATED_L2_CHARS = 400;
 
 /**
- * 予算付き注入テキスト。優先順位:
+ * 20 ターン窓の外側（それより古い側）のターン統計。
+ * 案内セクションの `recall --l1` 行（全 M ターン / 要約済み K / 時刻範囲）に使う。
+ */
+function loadOlderTurnStats(db, { sessionId, excludeOriginId, windowKeys }) {
+  const hasExclude = Boolean(excludeOriginId);
+  const turnQuery = hasExclude
+    ? `SELECT origin_session_id, turn_number, MIN(created_at) AS min_ca
+       FROM bodies
+       WHERE session_id = ? AND origin_session_id != ?
+       GROUP BY origin_session_id, turn_number`
+    : `SELECT origin_session_id, turn_number, MIN(created_at) AS min_ca
+       FROM bodies
+       WHERE session_id = ?
+       GROUP BY origin_session_id, turn_number`;
+  const allTurns = hasExclude
+    ? db.prepare(turnQuery).all(sessionId, excludeOriginId)
+    : db.prepare(turnQuery).all(sessionId);
+
+  const older = allTurns.filter(
+    (r) => !windowKeys.has(`${r.origin_session_id}\x00${r.turn_number}`),
+  );
+  if (older.length === 0) {
+    return { total: 0, summarized: 0, minMs: null, maxMs: null };
+  }
+
+  const skelQuery = hasExclude
+    ? `SELECT DISTINCT origin_session_id, turn_number FROM skeletons
+       WHERE session_id = ? AND origin_session_id != ?`
+    : `SELECT DISTINCT origin_session_id, turn_number FROM skeletons
+       WHERE session_id = ?`;
+  const skelKeys = new Set(
+    (hasExclude
+      ? db.prepare(skelQuery).all(sessionId, excludeOriginId)
+      : db.prepare(skelQuery).all(sessionId)
+    ).map((r) => `${r.origin_session_id}\x00${r.turn_number}`),
+  );
+
+  let minMs = Infinity;
+  let maxMs = -Infinity;
+  let summarized = 0;
+  for (const r of older) {
+    if (r.min_ca < minMs) minMs = r.min_ca;
+    if (r.min_ca > maxMs) maxMs = r.min_ca;
+    if (skelKeys.has(`${r.origin_session_id}\x00${r.turn_number}`)) summarized += 1;
+  }
+  return { total: older.length, summarized, minMs, maxMs };
+}
+
+function formatClock(unixMs) {
+  const d = new Date(unixMs);
+  const hh = String(d.getHours()).padStart(2, '0');
+  const mm = String(d.getMinutes()).padStart(2, '0');
+  const ss = String(d.getSeconds()).padStart(2, '0');
+  return `${hh}:${mm}:${ss}`;
+}
+
+/**
+ * 案内セクション（無条件表示）。表示用の HH:MM:SS と機械用の境界（ISO 8601 ms / 件数 /
+ * session id）を分離し、機械用は全部コマンド引数へ焼き込む。recall 側は再計算しない。
+ */
+function buildGuidanceLines({ sessionId, boundaryMs, remainingTurns, remainingRange, older }) {
+  const lines = ['### さらに前の記憶（必要な時だけ取得）'];
+  const boundaryIso = boundaryMs != null ? new Date(boundaryMs).toISOString() : null;
+
+  if (remainingTurns > 0) {
+    lines.push(
+      `- これより前の続き${remainingTurns}ターン (${remainingRange}) の会話全文: ` +
+        `\`throughline recall --l2 --session ${sessionId} --before ${boundaryIso} --last ${remainingTurns}\` を実行`,
+    );
+  } else {
+    lines.push('- これより前の続き: なし（直近の会話は全て上の L2 セクションに注入済み）');
+  }
+
+  if (older.total > 0) {
+    const range = `${formatClock(older.minMs)}〜${formatClock(older.maxMs)}`;
+    lines.push(
+      `- それ以前の全${older.total}ターン（要約済み ${older.summarized} / 未要約 ${older.total - older.summarized}）の一覧 (${range}): ` +
+        `\`throughline recall --l1 --session ${sessionId} --before ${boundaryIso} --skip ${remainingTurns}\` を実行` +
+        '（気になるターンは `throughline detail <時刻>` で全文・ツール入出力まで掘れる）',
+    );
+  } else {
+    lines.push('- それ以前のターン: なし');
+  }
+  return lines;
+}
+
+/**
+ * 予算付き注入テキスト。構成 (オーナー裁定 2026-07-18):
  *   1. ヘッダ + 現在地アンカー（常に全文）
- *   2. L1 要約（新しい順に予算まで。落とした分は告知行）
- *   3. L2 本文（新しい順に予算まで詰めて古い順に出力。落とした分は告知行 +
- *      L1 / `throughline detail` への誘導）
- * 予算内に一切 L2 が入らない場合でも、最新 L2 行だけは切り詰めて入れる
- * （現在地の文脈をアンカー 600 字より厚く確保するため）。
+ *   2. 案内セクション（無条件表示。予約 GUIDANCE_RESERVE を先に差し引く）
+ *   3. L2 本文: 新しい順に**丸ごと入るターンだけ**詰めて古い順に出力
+ *      （ターン単位の原子。固定 N で予算を遊ばせず、断片も詰めない。
+ *       ターン境界の自然な端数は許容）
+ *   L1 は注入しない（窓の残りは recall --l2、それより古い側は recall --l1 が担う）。
+ *   最新ターンが単体で予算を超える場合だけ、切り詰めてでも入れる
+ *   （現在地の文脈をアンカー 600 字より厚く確保するため）。
  *
  * @returns {{
  *   text: string,
  *   totalChars: number,
- *   droppedL1Rows: number,
- *   droppedL2Rows: number,
+ *   injectedL2Turns: number,
+ *   remainingL2Turns: number,
+ *   olderTurns: number,
+ *   olderSummarized: number,
  *   truncatedNewestL2: boolean,
  * } | null}
  */
@@ -256,97 +351,115 @@ export function buildBudgetedResumeContext(
 
   const lineCost = (s) => s.length + 1; // join('\n') 分
 
-  // 固定部 (ヘッダ + アンカー) のコスト。セクション見出し・空行も概算に含める
+  // L2 行をターン単位のグループにまとめる（元の古い順を保つ）
+  const turns = [];
+  const turnIndex = new Map();
+  for (const line of sections.l2Lines) {
+    let group = turnIndex.get(line.turnKey);
+    if (!group) {
+      group = { turnKey: line.turnKey, lines: [], minCreatedAt: Infinity, maxCreatedAt: -Infinity };
+      turnIndex.set(line.turnKey, group);
+      turns.push(group);
+    }
+    group.lines.push(line);
+    if (line.createdAt < group.minCreatedAt) group.minCreatedAt = line.createdAt;
+    if (line.createdAt > group.maxCreatedAt) group.maxCreatedAt = line.createdAt;
+  }
+
+  // 固定部 (ヘッダ + アンカー + セクション見出し + 案内予約) のコスト
   const fixedCost =
     lineCost(sections.header) +
     (sections.anchorLines.length > 0
       ? lineCost('') + lineCost('### 現在地 (直前のやりとり)') +
         sections.anchorLines.reduce((a, l) => a + lineCost(l), 0)
       : 0) +
-    lineCost('') + lineCost('### それ以前の要約 (L1)') +
     lineCost('') + lineCost('### 直前の対話 (L2 / active work thread, 古い順)');
 
-  let remaining = maxChars - fixedCost - OMISSION_NOTE_RESERVE;
+  let remaining = maxChars - fixedCost - GUIDANCE_RESERVE;
 
-  // L1: 新しい順 (配列末尾) に採用して古い順で出力
-  const keptL1 = [];
-  let droppedL1Rows = 0;
-  for (let i = sections.l1Lines.length - 1; i >= 0; i -= 1) {
-    const cost = lineCost(sections.l1Lines[i]);
-    if (remaining - cost >= 0) {
-      keptL1.unshift(sections.l1Lines[i]);
-      remaining -= cost;
-    } else {
-      droppedL1Rows = i + 1;
-      break;
-    }
-  }
-
-  // L2: 新しい順に採用して古い順で出力
-  const keptL2 = [];
-  let droppedL2Rows = 0;
+  // L2: 新しい順にターンを丸ごと採用して古い順で出力
+  const keptTurns = [];
   let truncatedNewestL2 = false;
-  for (let i = sections.l2Lines.length - 1; i >= 0; i -= 1) {
-    const line = sections.l2Lines[i];
-    const cost = lineCost(line.text);
+  for (let i = turns.length - 1; i >= 0; i -= 1) {
+    const turn = turns[i];
+    const cost = turn.lines.reduce((a, l) => a + lineCost(l.text), 0);
     if (remaining - cost >= 0) {
-      keptL2.unshift(line);
+      keptTurns.unshift(turn);
       remaining -= cost;
       continue;
     }
-    // 最新行が単体で入らない場合だけ、切り詰めて確保する
-    if (keptL2.length === 0 && remaining >= MIN_TRUNCATED_L2_CHARS) {
-      const marker = ` …(予算超過で切詰め; 全文: throughline detail ${line.time})`;
+    // 最新ターンが単体で入らない場合だけ、最新行を切り詰めて確保する
+    if (keptTurns.length === 0 && remaining >= MIN_TRUNCATED_L2_CHARS) {
+      const newestLine = turn.lines[turn.lines.length - 1];
+      const marker = ` …(予算超過で切詰め; 全文: throughline detail ${newestLine.time})`;
       const keep = remaining - marker.length - 1;
-      keptL2.unshift({ ...line, text: line.text.slice(0, keep) + marker });
+      keptTurns.unshift({
+        ...turn,
+        lines: [{ ...newestLine, text: newestLine.text.slice(0, keep) + marker }],
+      });
       remaining = 0;
       truncatedNewestL2 = true;
-      droppedL2Rows = i; // これより古い行は全部落ちる
-      break;
     }
-    droppedL2Rows = i + 1;
-    break;
+    break; // ターン原子: 入らないターンが出たらそこで打ち切り (歯抜けを作らない)
   }
 
-  const l1Note =
-    droppedL1Rows > 0
-      ? `（注入予算 ${maxChars} 字超過のため古い L1 を ${droppedL1Rows} 行省略）`
-      : null;
-
-  // 省略 L2 行の取り出し手がかり: [時刻 role] を新しい側 (文脈に近い側) から
-  // L2_NOTE_MAX_CHARS に収まるだけ列挙し、残りは「ほか N 行」に畳む。
-  let l2Note = null;
-  if (droppedL2Rows > 0) {
-    const base =
-      `（注入予算 ${maxChars} 字超過のため古い L2 を ${droppedL2Rows} 行省略。` +
-      '各行の全文は `throughline detail 時刻` で取得可。省略分 (新しい順): ';
-    const closing = '）';
-    const dropped = sections.l2Lines.slice(0, droppedL2Rows);
-    const refs = [];
-    let used = base.length + closing.length;
-    for (let i = dropped.length - 1; i >= 0; i -= 1) {
-      const ref = `[${dropped[i].time} ${dropped[i].role}]`;
-      const foldTail = i > 0 ? ` ほか${i}行`.length : 0;
-      if (used + ref.length + 1 + foldTail > L2_NOTE_MAX_CHARS) {
-        refs.push(`ほか${i + 1}行`);
-        break;
-      }
-      refs.push(ref);
-      used += ref.length + 1;
-    }
-    l2Note = base + refs.join(' ') + closing;
+  const injectedL2Turns = keptTurns.length;
+  const remainingL2Turns = turns.length - injectedL2Turns;
+
+  // pull 境界: 実際に注入できた最古ターンの min(created_at)。strict less-than で
+  // 「それより古い側」が recall --l2 の担当になる。1 ターンも入らなかった場合は
+  // 最新ターンの max(created_at)+1 を境界にして窓全体を pull 側に渡す。
+  let boundaryMs = null;
+  if (injectedL2Turns > 0) {
+    boundaryMs = keptTurns[0].minCreatedAt;
+  } else if (turns.length > 0) {
+    boundaryMs = turns[turns.length - 1].maxCreatedAt + 1;
   }
 
-  const text = joinSections(
-    { header: sections.header, anchorLines: sections.anchorLines, l1Lines: keptL1, l2Lines: keptL2 },
-    { l1Note, l2Note },
-  );
+  let remainingRange = null;
+  if (remainingL2Turns > 0) {
+    const remainingTurnsList = turns.slice(0, remainingL2Turns);
+    remainingRange = `${formatClock(remainingTurnsList[0].minCreatedAt)}〜${formatClock(remainingTurnsList[remainingTurnsList.length - 1].maxCreatedAt)}`;
+  }
+
+  const older = loadOlderTurnStats(db, {
+    sessionId,
+    excludeOriginId,
+    windowKeys: new Set(turns.map((t) => t.turnKey)),
+  });
+
+  const guidanceLines = buildGuidanceLines({
+    sessionId,
+    boundaryMs,
+    remainingTurns: remainingL2Turns,
+    remainingRange,
+    older,
+  });
+
+  const lines = [sections.header];
+  if (sections.anchorLines.length > 0) {
+    lines.push('');
+    lines.push('### 現在地 (直前のやりとり)');
+    lines.push(...sections.anchorLines);
+  }
+  lines.push('');
+  lines.push(...guidanceLines);
+  if (keptTurns.length > 0) {
+    lines.push('');
+    lines.push('### 直前の対話 (L2 / active work thread, 古い順)');
+    for (const turn of keptTurns) {
+      lines.push(...turn.lines.map((l) => l.text));
+    }
+  }
+  const text = lines.join('\n');
 
   return {
     text,
     totalChars: text.length,
-    droppedL1Rows,
-    droppedL2Rows,
+    injectedL2Turns,
+    remainingL2Turns,
+    olderTurns: older.total,
+    olderSummarized: older.summarized,
     truncatedNewestL2,
   };
 }