throughline 0.14.3 → 0.15.1

package/src/cli/handoff-context.test.mjs

@@ -11,6 +11,7 @@ import { buildBudgetedResumeContext, INJECTION_BUDGET_CHARS } from '../resume-co
 import {
   parseArgs,
   readLatestProjectHandoffContext,
+  readRecentProjectHandoffContext,
   readSessionProjectPath,
 } from './handoff-context.mjs';
 
@@ -355,6 +356,7 @@ test('handoff-context accepts only the documented supplement argument shape', ()
     projectPath: null,
     supplementFile: null,
     handoffDisclosure: 'visible',
+    projectSessions: 'latest',
   });
   assert.deepEqual(parseArgs([
     '--session', 's', '--json', '--supplement-file', '/tmp/memory.json',
@@ -363,6 +365,7 @@ test('handoff-context accepts only the documented supplement argument shape', ()
     projectPath: null,
     supplementFile: '/tmp/memory.json',
     handoffDisclosure: 'visible',
+    projectSessions: 'latest',
   });
   assert.deepEqual(parseArgs([
     '--project', '.', '--json', '--disclosure', 'silent',
@@ -371,7 +374,23 @@ test('handoff-context accepts only the documented supplement argument shape', ()
     projectPath: process.cwd(),
     supplementFile: null,
     handoffDisclosure: 'silent',
+    projectSessions: 'latest',
   });
+  assert.deepEqual(parseArgs([
+    '--project', '.', '--json', '--disclosure', 'silent', '--sessions', 'recent',
+  ]), {
+    sessionId: null,
+    projectPath: process.cwd(),
+    supplementFile: null,
+    handoffDisclosure: 'silent',
+    projectSessions: 'recent',
+  });
+  assert.equal(parseArgs(['--project', '.', '--json', '--sessions', 'latest']).projectSessions, 'latest');
+  // 複数 session をまたぐのは --project だけ。--session の意味は変えない
+  assert.throws(() => parseArgs(['--session', 's', '--json', '--sessions', 'recent']));
+  assert.throws(() => parseArgs(['--session', 's', '--json', '--sessions', 'latest']));
+  assert.throws(() => parseArgs(['--project', '.', '--json', '--sessions', 'all']));
+  assert.throws(() => parseArgs(['--project', '.', '--json', '--sessions', 'recent', '--sessions', 'recent']));
   assert.throws(() => parseArgs(['--session', 's', '--supplement-file', '/tmp/memory.json', '--json']));
   assert.throws(() => parseArgs(['--project', '.', '--json', '--supplement-file', '/tmp/memory.json']));
   assert.throws(() => parseArgs(['--session', 's', '--json', '--disclosure', 'hidden']));
@@ -439,3 +458,177 @@ test('handoff-context fails without creating a missing database', () => {
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+function insertProjectSession(db, { sessionId, projectPath = '/work/project', updatedAt, turns }) {
+  db.prepare(
+    `INSERT INTO sessions
+       (session_id, project_path, status, created_at, updated_at, merged_into)
+     VALUES (?, ?, 'active', ?, ?, NULL)`,
+  ).run(sessionId, projectPath, updatedAt - 1000, updatedAt);
+  const insertBody = db.prepare(
+    `INSERT INTO bodies
+       (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES (?, ?, ?, ?, ?, 4, ?)`,
+  );
+  turns.forEach(([user, assistant, at], index) => {
+    insertBody.run(sessionId, sessionId, index + 1, 'user', user, at);
+    insertBody.run(sessionId, sessionId, index + 1, 'assistant', assistant, at + 500);
+  });
+}
+
+const PROJECT_ARGS = ['handoff-context', '--project', '/work/project', '--json', '--disclosure', 'silent'];
+
+test('handoff-context --sessions recent adds earlier sessions of the same project only', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-recent-'));
+  try {
+    const { db, dbPath } = createFixture(home);
+    // 5 ターンの作業の会話が、最新の 1 ターンの会話より前にある
+    insertProjectSession(db, {
+      sessionId: 'earlier-work',
+      updatedAt: 1_699_999_990_000,
+      turns: [1, 2, 3, 4, 5].map((n) => [
+        `EARLIER_REQUEST_${n}`, `EARLIER_RESULT_${n}`, 1_699_999_900_000 + n * 10_000,
+      ]),
+    });
+    insertProjectSession(db, {
+      sessionId: 'other-project-work',
+      projectPath: '/work/other',
+      updatedAt: 1_700_000_009_000,
+      turns: [['OTHER_PROJECT_PRIVATE', 'OTHER_PROJECT_ANSWER', 1_700_000_008_000]],
+    });
+    const before = ownershipSnapshot(db);
+    db.close();
+
+    // 引数を付けない時と --sessions latest は、今までと同じ出力
+    const latest = runCli(home, PROJECT_ARGS);
+    assert.equal(latest.status, 0, latest.stderr);
+    const latestPayload = JSON.parse(latest.stdout);
+    assert.deepEqual(Object.keys(latestPayload), ['schema', 'status', 'sessionId', 'context']);
+    assert.doesNotMatch(latestPayload.context, /EARLIER_REQUEST/);
+    assert.equal(runCli(home, [...PROJECT_ARGS, '--sessions', 'latest']).stdout, latest.stdout);
+
+    const recent = runCli(home, [...PROJECT_ARGS, '--sessions', 'recent']);
+    assert.equal(recent.status, 0, recent.stderr);
+    const payload = JSON.parse(recent.stdout);
+    assert.deepEqual(Object.keys(payload), ['schema', 'status', 'sessionId', 'context', 'sessions']);
+    assert.equal(payload.schema, 'throughline.handoff_context.v1');
+    assert.equal(payload.status, 'ready');
+    assert.equal(payload.sessionId, SESSION_ID);
+    assert.ok(payload.context.startsWith(`${latestPayload.context}\n\n## Throughline: このprojectで記録された過去の会話`));
+    assert.ok(payload.context.length <= INJECTION_BUDGET_CHARS);
+    for (let n = 1; n <= 5; n += 1) {
+      assert.ok(payload.context.includes(`EARLIER_REQUEST_${n}`));
+      assert.ok(payload.context.includes(`EARLIER_RESULT_${n}`));
+    }
+    assert.match(payload.context, /（5ターン \/ session earlier-work）/);
+    assert.doesNotMatch(payload.context, /OTHER_PROJECT_PRIVATE|OTHER_PROJECT_ANSWER|other-project-work/);
+    assert.deepEqual(payload.sessions, [
+      {
+        sessionId: SESSION_ID,
+        role: 'current',
+        firstTurnAt: new Date(1_700_000_002_000).toISOString(),
+        lastTurnAt: new Date(1_700_000_003_000).toISOString(),
+        turns: 1,
+        includedTurns: 1,
+      },
+      {
+        sessionId: 'earlier-work',
+        role: 'past',
+        firstTurnAt: new Date(1_699_999_910_000).toISOString(),
+        lastTurnAt: new Date(1_699_999_950_500).toISOString(),
+        turns: 5,
+        includedTurns: 5,
+      },
+    ]);
+
+    const selected = readRecentProjectHandoffContext('/work/project', {
+      dbPath,
+      handoffDisclosure: 'silent',
+    });
+    assert.equal(selected.context, payload.context);
+
+    const verify = new DatabaseSync(dbPath, { readOnly: true });
+    assert.deepEqual(ownershipSnapshot(verify), before);
+    verify.close();
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context --sessions recent matches the default when the project has one session', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-recent-single-'));
+  try {
+    const { db } = createFixture(home);
+    // 本文の無い session と別 project の session は、過去の会話に数えない
+    db.prepare(
+      `INSERT INTO sessions
+         (session_id, project_path, status, created_at, updated_at, merged_into)
+       VALUES ('newest-empty', '/work/project', 'active', ?, ?, NULL)`,
+    ).run(1_700_000_005_000, 1_700_000_006_000);
+    insertProjectSession(db, {
+      sessionId: 'other-project-work',
+      projectPath: '/work/other',
+      updatedAt: 1_699_999_990_000,
+      turns: [['OTHER_PROJECT_PRIVATE', 'OTHER_PROJECT_ANSWER', 1_699_999_900_000]],
+    });
+    db.close();
+
+    for (const disclosure of ['silent', 'visible']) {
+      const args = ['handoff-context', '--project', '/work/project', '--json', '--disclosure', disclosure];
+      const latest = runCli(home, args);
+      const recent = runCli(home, [...args, '--sessions', 'recent']);
+      assert.equal(latest.status, 0, latest.stderr);
+      assert.equal(recent.status, 0, recent.stderr);
+      const latestPayload = JSON.parse(latest.stdout);
+      const { sessions, ...rest } = JSON.parse(recent.stdout);
+      assert.deepEqual(rest, latestPayload);
+      assert.deepEqual(sessions.map((s) => [s.sessionId, s.role, s.turns, s.includedTurns]), [
+        [SESSION_ID, 'current', 1, 1],
+      ]);
+    }
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context --sessions recent returns empty with an empty session list', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-recent-empty-'));
+  try {
+    const { db } = createFixture(home);
+    db.exec('DELETE FROM details; DELETE FROM bodies; DELETE FROM skeletons;');
+    db.close();
+
+    const result = runCli(home, [...PROJECT_ARGS, '--sessions', 'recent']);
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(JSON.parse(result.stdout), {
+      schema: 'throughline.handoff_context.v1',
+      status: 'empty',
+      sessionId: null,
+      context: '',
+      sessions: [],
+    });
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context rejects --sessions together with --session', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-recent-usage-'));
+  try {
+    const { db } = createFixture(home);
+    db.close();
+
+    for (const args of [
+      ['handoff-context', '--session', SESSION_ID, '--json', '--sessions', 'recent'],
+      [...PROJECT_ARGS, '--sessions', 'everything'],
+    ]) {
+      const result = runCli(home, args);
+      assert.equal(result.status, 2);
+      assert.equal(result.stdout, '');
+      assert.match(result.stderr, /^Usage: throughline handoff-context /);
+      assert.match(result.stderr, /\[--sessions latest\|recent\]/);
+    }
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/observer-turn-feed.mjs

@@ -47,7 +47,7 @@ export function resolveObserverTurnFeed({ projectPath, cursor = null, codexHome,
     ? emptyCandidate()
     : candidates.find((item) => item.host === prior.host && item.threadHash === prior.thread_sha256);
   if (!priorCandidate || prior.host !== null &&
-    (prior.history_floor < priorCandidate.historyFloor || prior.length > priorCandidate.chain.length ||
+    (prior.length > priorCandidate.chain.length ||
       prefixDigest(priorCandidate.chain.slice(0, prior.length)) !== prior.prefix_sha256)) {
     return { schema: OBSERVER_CURSOR_SCHEMA, status: 'resync_required', afterCursor: cursor, throughCursor: null };
   }
@@ -254,7 +254,7 @@ function decodeCursorForRead(token, projectSha256) {
 function validateCursorCandidate(cursor, candidates) {
   if (cursor.host === null) return emptyCandidate();
   const current = candidates.find((item) => item.host === cursor.host && item.threadHash === cursor.thread_sha256);
-  if (!current || cursor.history_floor < current.historyFloor || cursor.length > current.chain.length ||
+  if (!current || cursor.length > current.chain.length ||
     prefixDigest(current.chain.slice(0, cursor.length)) !== cursor.prefix_sha256) return null;
   return current;
 }

package/src/observer-turn-feed.test.mjs

@@ -126,11 +126,16 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   try {
     const options = box.receiptOptions;
     seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: options, targetSessionId: 'claude-session' });
+    const full = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: 'o257', userBody: 'user-body-257', assistantBody: 'assistant-body-257', completedAt: 257 }, options);
+    // 同じ会話の先頭の控えが落ちた時は、先頭からの照合が合わなくなるので resync（ADR 0035）
+    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: full.throughCursor, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
     const latest = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     const decoded = decodeObserverCursor(latest.throughCursor);
-    const beforeFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });
-    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: beforeFloor, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
+    assert.equal(decoded.history_floor, 2);
+    // 下限の番号は位置に入れたままだが、検証には使わない。先頭からの照合が合えば有効
+    const olderFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });
+    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: olderFloor, receiptOptions: options, codexHome: box.home }).status, 'unchanged');
     assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: `${latest.throughCursor}x`, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
     const oldVersion = `tlc1.${Buffer.from(JSON.stringify({ ...decoded, schema: 'throughline.observer_cursor.v0' })).toString('base64url')}`;
     assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: oldVersion, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
@@ -157,6 +162,51 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   } finally { rmSync(box.root, { recursive: true, force: true }); }
 });
 
+test('observer feed: 控えが上限に達して別の古い会話の控えが落ちても、今の会話の位置は有効なまま', () => {
+  const box = fixture();
+  const dbPath = join(box.root, 'throughline.db');
+  let db;
+  try {
+    // 古い会話の控えで上限まで埋まっている席で、新しい会話が始まる
+    seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: box.receiptOptions, targetSessionId: 'old-session' });
+    db = createProjectionDb(dbPath, box.project, 'live-session');
+    const read = (afterCursor) => readObserverTurnPage({
+      projectPath: box.project, afterCursor, codexHome: box.home, receiptOptions: box.receiptOptions, dbPath,
+    });
+    const floorOf = (cursor) => decodeObserverCursor(cursor).history_floor;
+
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-1', turn: 1, user: 'user-1', assistant: 'assistant-1', at: 1001 });
+    let cursor = read(null).throughCursor;
+    assert.equal(floorOf(cursor), 2);
+    for (let turn = 2; turn <= 5; turn++) {
+      // 1 ターンごとに古い会話の控えが1件落ち、控え全体の下限が1上がる
+      addClaudeTurn(box, db, { sessionId: 'live-session', origin: `live-${turn}`, turn, user: `user-${turn}`, assistant: `assistant-${turn}`, at: 1000 + turn });
+      assert.equal(resolveObserverTurnFeed({
+        projectPath: box.project, cursor, codexHome: box.home, receiptOptions: box.receiptOptions,
+      }).status, 'append');
+      const page = read(cursor);
+      assert.equal(page.status, 'delta');
+      assert.deepEqual(page.turns.map((item) => item.user), [`user-${turn}`]);
+      assert.equal(page.page.complete, true);
+      assert.equal(floorOf(page.throughCursor), turn + 1);
+      cursor = page.throughCursor;
+    }
+    // 追いついた位置は、次のターンが来るまで unchanged
+    assert.equal(resolveObserverTurnFeed({
+      projectPath: box.project, cursor, codexHome: box.home, receiptOptions: box.receiptOptions,
+    }).status, 'unchanged');
+    // 読み遅れた位置（2 ターン前）からも、残りを続きとして読める
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-6', turn: 6, user: 'user-6', assistant: 'assistant-6', at: 1006 });
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-7', turn: 7, user: 'user-7', assistant: 'assistant-7', at: 1007 });
+    const late = read(cursor);
+    assert.equal(late.status, 'delta');
+    assert.deepEqual(late.turns.map((item) => item.user), ['user-6', 'user-7']);
+  } finally {
+    db?.close();
+    rmSync(box.root, { recursive: true, force: true });
+  }
+});
+
 test('observer feed: Codex pair hashes reuse DB capture role aggregation', () => {
   const box = fixture();
   try {

package/src/resume-context.mjs

@@ -211,8 +211,10 @@ function buildResumeSections(
     const isLastOfTurn = lastIdxPerTurn.get(key) === i;
     const partCounts = isLastOfTurn ? (l3ByTurn.get(key)?.partCounts ?? new Map()) : new Map();
     const suffix = buildPartsSummary(partCounts);
+    const rest = `[${r.role}]: ${r.text}${suffix}`;
     l2Lines.push({
-      text: `[${r.time}] [${r.role}]: ${r.text}${suffix}`,
+      text: `[${r.time}] ${rest}`,
+      rest,
       time: r.time,
       role: r.role,
       turnKey: key,
@@ -426,14 +428,13 @@ export function buildBudgetedResumeContext(
   return renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxChars });
 }
 
-/** 組み立て済みのセクションを、予算内の注入テキストにする（/clear の引き継ぎと自動圧縮後の継続が共有）。 */
-function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxChars }) {
-  const lineCost = (s) => s.length + 1; // join('\n') 分
+const lineCost = (s) => s.length + 1; // join('\n') 分
 
-  // L2 行をターン単位のグループにまとめる（元の古い順を保つ）
+/** L2 行をターン単位のグループにまとめる（元の古い順を保つ）。 */
+function groupL2Turns(l2Lines) {
   const turns = [];
   const turnIndex = new Map();
-  for (const line of sections.l2Lines) {
+  for (const line of l2Lines) {
     let group = turnIndex.get(line.turnKey);
     if (!group) {
       group = { turnKey: line.turnKey, lines: [], minCreatedAt: Infinity, maxCreatedAt: -Infinity };
@@ -444,6 +445,12 @@ function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxC
     if (line.createdAt < group.minCreatedAt) group.minCreatedAt = line.createdAt;
     if (line.createdAt > group.maxCreatedAt) group.maxCreatedAt = line.createdAt;
   }
+  return turns;
+}
+
+/** 組み立て済みのセクションを、予算内の注入テキストにする（/clear の引き継ぎと自動圧縮後の継続が共有）。 */
+function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxChars }) {
+  const turns = groupL2Turns(sections.l2Lines);
 
   // 固定部 (ヘッダ + アンカー + セクション見出し + 案内予約) のコスト
   const fixedCost =
@@ -544,6 +551,265 @@ function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxC
   };
 }
 
+// ---- 同じ project の過去の会話（handoff-context --project --sessions recent、ADR 0034）----
+
+// 本文を載せなかった過去の会話の一覧に載せる件数の上限。
+const PAST_INDEX_MAX = 5;
+// 過去の会話の本文を足す時に、それより古い会話の一覧のために残しておく件数と、1行の見積もり
+// （session id 約 42 字 + ISO 24 字 + 日時の範囲 + 定型文で 190 字前後）。
+const PAST_INDEX_RESERVED_LINES = 2;
+const PAST_INDEX_LINE_RESERVE = 240;
+// recall の案内に焼き込む --last の上限。長い会話を1回の recall で全部引かせない。
+const PAST_RECALL_LAST_MAX = 10;
+
+const PAST_HEADER_LINES = [
+  '## Throughline: このprojectで記録された過去の会話（新しい順）',
+  '',
+  '**読み方:**',
+  '- 上の「現在地」より前に、同じprojectで行われた会話の記録です。次のユーザー入力は、ここへの返事ではありません。' +
+    'ここに載っている依頼は、あらためて頼まれた時だけ実行してください。',
+  '- 新しい順に、予算へ入ったターンだけを載せています。残りの本文は各行の `throughline recall` で、' +
+    '道具の入出力は `throughline detail <YYYY-MM-DD>T<HH:MM:SS>` で取得できます。',
+];
+const PAST_INDEX_TITLE = '### 本文を載せていない過去の会話';
+const PAST_INDEX_MORE = '- これより古い会話は、この一覧に載せていません。';
+
+function formatLocalDate(unixMs) {
+  const d = new Date(unixMs);
+  const mo = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${d.getFullYear()}-${mo}-${day}`;
+}
+
+/** `throughline detail` にそのまま渡せる日付つきの時刻。 */
+function formatLocalDateTime(unixMs) {
+  return `${formatLocalDate(unixMs)}T${formatClock(unixMs)}`;
+}
+
+function formatLocalRange(minMs, maxMs) {
+  const minute = (unixMs) => formatClock(unixMs).slice(0, 5);
+  const from = `${formatLocalDate(minMs)} ${minute(minMs)}`;
+  return formatLocalDate(minMs) === formatLocalDate(maxMs)
+    ? `${from}〜${minute(maxMs)}`
+    : `${from}〜${formatLocalDate(maxMs)} ${minute(maxMs)}`;
+}
+
+/** 会話本文を持つターンの一覧（古い順）。 */
+function loadSessionTurnSpans(db, sessionId) {
+  return 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 text != ''
+       GROUP BY origin_session_id, turn_number
+       ORDER BY min_ca ASC`,
+    )
+    .all(sessionId)
+    .map((r) => ({
+      turnKey: `${r.origin_session_id}\x00${r.turn_number}`,
+      minCreatedAt: r.min_ca,
+      maxCreatedAt: r.max_ca,
+    }));
+}
+
+function describeSession(sessionId, role, spans, includedTurns) {
+  const first = spans.length > 0 ? spans[0].minCreatedAt : null;
+  const last = spans.reduce((max, t) => (max == null || t.maxCreatedAt > max ? t.maxCreatedAt : max), null);
+  return {
+    sessionId,
+    role,
+    firstTurnAt: first == null ? null : new Date(first).toISOString(),
+    lastTurnAt: last == null ? null : new Date(last).toISOString(),
+    turns: spans.length,
+    includedTurns,
+  };
+}
+
+function recallHint(sessionId, beforeMs, turns) {
+  const last = Math.min(turns, PAST_RECALL_LAST_MAX);
+  return (
+    (last < turns ? `新しい${last}ターンの本文は ` : '本文は ') +
+    `\`throughline recall --l2 --session ${sessionId} --before ${new Date(beforeMs).toISOString()} --last ${last}\``
+  );
+}
+
+/** 過去の会話1つ分の行。keptTurns はその会話の新しい側から続いたターン（古い順）。 */
+function renderPastBlock(candidate, keptTurns) {
+  const rest = candidate.turns - keptTurns.length;
+  const count = rest > 0
+    ? `${candidate.turns}ターンのうち新しい${keptTurns.length}ターン`
+    : `${candidate.turns}ターン`;
+  const lines = [
+    '',
+    `### 過去の会話 ${formatLocalRange(candidate.minCreatedAt, candidate.maxCreatedAt)}（${count} / session ${candidate.sessionId}）`,
+  ];
+  if (rest > 0) {
+    lines.push(
+      `- これより前の${rest}ターン: ${recallHint(candidate.sessionId, keptTurns[0].minCreatedAt, rest)}`,
+    );
+  }
+  for (const turn of keptTurns) {
+    for (const line of turn.lines) lines.push(`[${formatLocalDateTime(line.createdAt)}] ${line.rest}`);
+  }
+  return lines;
+}
+
+function renderPastIndexLine(candidate) {
+  return (
+    `- ${formatLocalRange(candidate.minCreatedAt, candidate.maxCreatedAt)}（${candidate.turns}ターン）: ` +
+    recallHint(candidate.sessionId, candidate.maxCreatedAt + 1, candidate.turns)
+  );
+}
+
+/**
+ * 同じ project の直近の会話から、予算付きの注入テキストを作る (ADR 0034)。
+ *
+ * 現在の会話（文脈を持つ最新の session）は、buildBudgetedResumeContext と同じ文を先頭に置く。
+ * 過去の会話は、その後ろの余った予算にだけ入れる。現在の会話の文は、過去の会話の有無で変わらない。
+ * 現在の会話のターンが全部入っている時だけ、過去の会話を新しい順にターン単位で足す。
+ * 入らないターンが出たらそこで止め、それより古い会話は一覧（日時・ターン数・recall）だけにする。
+ * 新しいターンを飛ばして古いターンを載せない。同じ (origin, turn) は新しい会話の1回だけ載せる。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{
+ *   sessionIds: string[],  同じ project の session を新しい順に並べたもの（選ぶのは呼び出し側）
+ *   handoffDisclosure?: 'visible' | 'silent',
+ *   maxChars?: number,
+ * }} params
+ * @returns {{
+ *   text: string,
+ *   sessionId: string,  現在の会話
+ *   sessions: Array<{
+ *     sessionId: string,
+ *     role: 'current' | 'past',
+ *     firstTurnAt: string | null,
+ *     lastTurnAt: string | null,
+ *     turns: number,
+ *     includedTurns: number,  0 は一覧にだけ載せた会話
+ *   }>,
+ * } | null}
+ */
+export function buildRecentSessionsContext(
+  db,
+  { sessionIds, handoffDisclosure = 'visible', maxChars = INJECTION_BUDGET_CHARS },
+) {
+  let currentIndex = -1;
+  let currentSections = null;
+  for (let i = 0; i < sessionIds.length; i += 1) {
+    currentSections = buildResumeSections(db, {
+      sessionId: sessionIds[i],
+      isInheritance: true,
+      handoffDisclosure,
+    });
+    if (currentSections) {
+      currentIndex = i;
+      break;
+    }
+  }
+  if (!currentSections) return null;
+
+  const currentId = sessionIds[currentIndex];
+  const currentSpans = loadSessionTurnSpans(db, currentId);
+  const current = renderBudgetedSections(db, currentSections, {
+    sessionId: currentId,
+    excludeOriginId: null,
+    maxChars,
+  });
+  const sessions = [describeSession(currentId, 'current', currentSpans, current.injectedL2Turns)];
+  const onlyCurrent = () => ({ text: current.text, sessionId: currentId, sessions: sessions.slice(0, 1) });
+
+  // 過去の会話の候補を、新しい順に必要な分だけ読む。先に読んだ（新しい）会話のターンは後の会話から外す。
+  const seenTurns = new Set(currentSpans.map((t) => t.turnKey));
+  const candidates = [];
+  let cursor = currentIndex + 1;
+  const candidateAt = (n) => {
+    while (candidates.length <= n && cursor < sessionIds.length) {
+      const sessionId = sessionIds[cursor];
+      cursor += 1;
+      const spans = loadSessionTurnSpans(db, sessionId).filter((t) => !seenTurns.has(t.turnKey));
+      if (spans.length === 0) continue;
+      for (const t of spans) seenTurns.add(t.turnKey);
+      candidates.push({
+        sessionId,
+        spans,
+        turns: spans.length,
+        minCreatedAt: spans[0].minCreatedAt,
+        maxCreatedAt: spans.reduce((max, t) => Math.max(max, t.maxCreatedAt), -Infinity),
+      });
+    }
+    return candidates[n] ?? null;
+  };
+  const countFrom = (n) => [candidateAt(n), candidateAt(n + 1)].filter(Boolean).length;
+  if (countFrom(0) === 0) return onlyCurrent();
+
+  const cost = (lines) => lines.reduce((sum, line) => sum + lineCost(line), 0);
+  const headerCost = cost(['', ...PAST_HEADER_LINES]);
+  const indexTitleCost = cost(['', PAST_INDEX_TITLE]);
+  const indexReserve = (count) =>
+    count > 0 ? indexTitleCost + PAST_INDEX_LINE_RESERVE * Math.min(PAST_INDEX_RESERVED_LINES, count) : 0;
+
+  // 過去の会話に使えるのは、現在の会話を今と同じ文で置いた後の余りだけ。
+  let remaining = maxChars - current.totalChars - headerCost;
+  const pastLines = [];
+  let next = 0;
+
+  // 本文: 現在の会話に載せ残しが無い時だけ、新しい会話から順にターンを足す。
+  let fillBodies =
+    current.remainingL2Turns === 0 && current.olderTurns === 0 && !current.truncatedNewestL2;
+  while (fillBodies) {
+    const candidate = candidateAt(next);
+    if (!candidate) break;
+    const available = remaining - indexReserve(countFrom(next + 1));
+    const keys = new Set(candidate.spans.map((t) => t.turnKey));
+    const stored = buildResumeSections(db, {
+      sessionId: candidate.sessionId,
+      isInheritance: true,
+      handoffDisclosure: 'silent',
+    });
+    const turns = groupL2Turns((stored?.l2Lines ?? []).filter((line) => keys.has(line.turnKey)));
+    let block = null;
+    for (let kept = 1; kept <= turns.length; kept += 1) {
+      const lines = renderPastBlock(candidate, turns.slice(turns.length - kept));
+      const blockCost = cost(lines);
+      if (blockCost <= available) block = { lines, blockCost, kept };
+    }
+    if (!block) break;
+    pastLines.push(...block.lines);
+    remaining -= block.blockCost;
+    sessions.push(describeSession(candidate.sessionId, 'past', candidate.spans, block.kept));
+    next += 1;
+    // 途中までしか入らなかった会話より古い会話は、一覧だけにする。
+    fillBodies = block.kept === candidate.turns;
+  }
+
+  // 一覧: 本文を載せなかった会話を、新しい順に載せる。
+  const indexLines = [];
+  while (indexLines.length < PAST_INDEX_MAX) {
+    const candidate = candidateAt(next);
+    if (!candidate) break;
+    const line = renderPastIndexLine(candidate);
+    const lineTotal = lineCost(line) + (indexLines.length === 0 ? indexTitleCost : 0);
+    if (lineTotal > remaining) break;
+    indexLines.push(line);
+    remaining -= lineTotal;
+    sessions.push(describeSession(candidate.sessionId, 'past', candidate.spans, 0));
+    next += 1;
+  }
+  if (indexLines.length > 0) {
+    pastLines.push('', PAST_INDEX_TITLE, ...indexLines);
+    if (candidateAt(next) && lineCost(PAST_INDEX_MORE) <= remaining) pastLines.push(PAST_INDEX_MORE);
+  }
+
+  // 余りに1行も入らなかった時は、節の見出しも付けない。
+  if (pastLines.length === 0) return onlyCurrent();
+
+  return {
+    text: [current.text, '', ...PAST_HEADER_LINES, ...pastLines].join('\n'),
+    sessionId: currentId,
+    sessions,
+  };
+}
+
 // 長い依頼は、指示が先頭にも末尾にも書かれる。先頭 3/4 と末尾 1/4 を残し、間を抜いたことを明示する。
 function truncateInFlight(text, maxChars) {
   const trimmed = text.trim();