throughline 0.6.3 → 0.8.0

package/src/pending-handoff.test.mjs

@@ -0,0 +1,107 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { registerPendingHandoff, consumePendingHandoff } from './pending-handoff.mjs';
+
+function makeDb() {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE pending_handoffs (
+      session_id          TEXT    PRIMARY KEY,
+      project_path        TEXT    NOT NULL,
+      source              TEXT,
+      auto_predecessor_id TEXT,
+      created_at          INTEGER NOT NULL
+    );
+  `);
+  return db;
+}
+
+test('registerPendingHandoff: inserts an intent row', () => {
+  const db = makeDb();
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'startup',
+    now: 1000,
+  });
+  const row = db.prepare('SELECT * FROM pending_handoffs').get();
+  assert.equal(row.session_id, 'S1');
+  assert.equal(row.project_path, '/proj');
+  assert.equal(row.source, 'startup');
+  assert.equal(row.auto_predecessor_id, null);
+  assert.equal(row.created_at, 1000);
+});
+
+test('registerPendingHandoff: re-registration (resume) updates source and created_at', () => {
+  const db = makeDb();
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'startup',
+    now: 1000,
+  });
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'resume',
+    now: 5000,
+  });
+  const rows = db.prepare('SELECT * FROM pending_handoffs').all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].source, 'resume');
+  assert.equal(rows[0].created_at, 5000);
+});
+
+test('registerPendingHandoff: stores frozen auto predecessor for source=clear', () => {
+  const db = makeDb();
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'clear',
+    autoPredecessorId: 'PRED',
+    now: 1000,
+  });
+  const row = db.prepare('SELECT * FROM pending_handoffs').get();
+  assert.equal(row.auto_predecessor_id, 'PRED');
+});
+
+test('consumePendingHandoff: returns the row once and deletes it', () => {
+  const db = makeDb();
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'clear',
+    autoPredecessorId: 'PRED',
+    now: 1234,
+  });
+
+  const first = consumePendingHandoff(db, { sessionId: 'S1' });
+  assert.deepEqual(first, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'clear',
+    autoPredecessorId: 'PRED',
+    createdAt: 1234,
+  });
+
+  const second = consumePendingHandoff(db, { sessionId: 'S1' });
+  assert.equal(second, null, 'second consumption must return null (row deleted)');
+});
+
+test('consumePendingHandoff: returns null for an unknown session (not newborn)', () => {
+  const db = makeDb();
+  registerPendingHandoff(db, {
+    sessionId: 'S1',
+    projectPath: '/proj',
+    source: 'startup',
+    now: 1000,
+  });
+  const result = consumePendingHandoff(db, { sessionId: 'OTHER' });
+  assert.equal(result, null);
+  assert.equal(
+    db.prepare('SELECT COUNT(*) AS c FROM pending_handoffs').get().c,
+    1,
+    'other sessions must not consume S1 pending row',
+  );
+});

package/src/prompt-submit.mjs

@@ -1,10 +1,17 @@
 #!/usr/bin/env node
 /**
- * UserPromptSubmit hook — /tl & /clear スラッシュコマンド検出 + バトン書き込み + Phase 0-5 spike
+ * UserPromptSubmit hook — 二相ハンドオフ第二相 + /tl & /clear バトン書き込み + Phase 0-5 spike
  *
  * stdin: { session_id, cwd, prompt, transcript_path, hook_event_name, ... }
  *
  * 動作:
+ *   - **二相ハンドオフ第二相 (ADR 0014)**: このセッションの pending intent
+ *     (SessionStart が登録) が残っていれば、それを消費して baton path 優先 →
+ *     auto path の順で前任を merge し、予算内 resume context を stdout 注入する。
+ *     プロンプト到達 = セッション実在の証明であり、transcript を生成しない幽霊
+ *     SessionStart はここに到達できない (= バトン・記憶を奪えない)。
+ *     注入がこの hook に移ったため、SessionStart 側の注入は廃止済み
+ *     (旧「二重注入回避」制約はこの構成では発生しない)。
  *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
  *   - prompt が /clear (単独 or /clear ... 形式) で始まっていれば、現セッションの
  *     session_id をバトンに書き込んで終了。
@@ -27,6 +34,8 @@
 
 import { getDb } from './db.mjs';
 import { writeBaton } from './baton.mjs';
+import { executeFirstPromptHandoff } from './handoff-executor.mjs';
+import { logDecision } from './decision-log.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -146,6 +155,42 @@ export async function run() {
     process.stderr.write(`[vscode-task] ${msg}\n`);
   }
 
+  // 二相ハンドオフの第二相 (ADR 0014): このプロンプトが newborn セッションの
+  // 初回プロンプトなら、pending intent を消費して merge + 注入をここで行う。
+  // プロンプト到達 = セッション実在の証明。幽霊 SessionStart はここに来られない。
+  // /tl・/clear のバトン書き込みより先に実行する (初回プロンプトが /tl でも、
+  // 引き継ぎを受けてから自分のバトンを書く順序になり、自己バトン食いが起きない)。
+  if (session_id) {
+    const db = getDb();
+    const projectPath = cwd ?? process.cwd();
+    const now = Date.now();
+    const handoff = executeFirstPromptHandoff(db, {
+      sessionId: session_id,
+      projectPath,
+      now,
+    });
+    if (handoff.attempted) {
+      if (handoff.injectionText) {
+        process.stdout.write(handoff.injectionText + '\n');
+      }
+      logDecision({
+        ts: new Date(now).toISOString(),
+        phase: 'prompt-submit',
+        session_id,
+        project_path: projectPath,
+        pending_created_at: handoff.pendingCreatedAt,
+        triggered_path: handoff.triggeredPath,
+        baton_session_id: handoff.baton?.sessionId ?? null,
+        baton_age_ms: handoff.baton?.ageMs ?? null,
+        baton_skip_reason: handoff.baton?.skipReason ?? null,
+        merged: handoff.mergeResult.merged,
+        merge_skip_reason: handoff.mergeResult.skipReason ?? null,
+        predecessor_id: handoff.mergeResult.predecessorId ?? null,
+        injection: handoff.injectionStats,
+      });
+    }
+  }
+
   const tlMatch = isBatonCommand(prompt);
   const clearMatch = !tlMatch && isClearCommand(prompt);
 

package/src/resume-context.mjs

@@ -83,22 +83,17 @@ function pickLatestExchange(recentBodies) {
 }
 
 /**
- * L1 + L2 注入テキストを組み立てる。L3 は本文ではなく
- * 各 L1 / L2 行末尾の inline hint として付与する。
+ * 注入セクションを構造化して組み立てる（内部共通）。
+ * buildResumeContext (無制限) と buildBudgetedResumeContext (予算付き) が共有する。
  *
- * @param {import('node:sqlite').DatabaseSync} db
- * @param {{
- *   sessionId: string,
- *   isInheritance: boolean,
- *   excludeOriginId?: string | null,
- *   inflightMemo?: string | null,
- * }} params
- * @returns {string | null}
+ * @returns {{
+ *   header: string,
+ *   anchorLines: string[],
+ *   l1Lines: string[],
+ *   l2Lines: { text: string, time: string }[],
+ * } | null}
  */
-export function buildResumeContext(
-  db,
-  { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
-) {
+function buildResumeSections(db, { sessionId, isInheritance, excludeOriginId = null }) {
   const record = buildHandoffRecord(db, {
     sessionId,
     isInheritance,
@@ -108,15 +103,14 @@ export function buildResumeContext(
 
   const turnCount = record.stats.preservedContextRows;
   const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
-  const lines = [header];
 
   const l3ByTurn = groupL3ByTurn(record.references.l3);
 
   // 現在地アンカー: 引き継ぎ時のみ、最新 user / assistant turn をヘッダ直下に再掲する。
   // L2 末尾アンカーだけだと、長い L2 で注意が前半に固着して話の流れを取り違える事例があった。
+  const anchorLines = [];
   if (isInheritance && record.memory.recentBodies.length > 0) {
     const { latestUser, latestAssistant } = pickLatestExchange(record.memory.recentBodies);
-    const anchorLines = [];
     if (latestUser) {
       anchorLines.push(
         `**最新ユーザー指示** [${latestUser.time}]: ${truncateForAnchor(latestUser.text)}`,
@@ -127,62 +121,345 @@ export function buildResumeContext(
         `**直前のアシスタント** [${latestAssistant.time}]: ${truncateForAnchor(latestAssistant.text)}`,
       );
     }
-    if (anchorLines.length > 0) {
-      lines.push('');
-      lines.push('### 現在地 (直前のやりとり)');
-      lines.push(...anchorLines);
-    }
   }
 
-  if (record.memory.l1Summaries.length > 0) {
-    const l1Lines = [];
-    for (const r of record.memory.l1Summaries) {
-      if (!r.summary || r.summary === '(no content)') continue;
-      const summary = r.summary.replace(/\n+/g, ' ').trim();
-      const key = `${r.originSessionId}\x00${r.turnNumber}`;
+  const l1Lines = [];
+  for (const r of record.memory.l1Summaries) {
+    if (!r.summary || r.summary === '(no content)') continue;
+    const summary = r.summary.replace(/\n+/g, ' ').trim();
+    const key = `${r.originSessionId}\x00${r.turnNumber}`;
 
-      // body 時刻が引けた行だけ詳細呼び出しを案内する。引けない場合は
-      // `[skeleton 時刻]` のままだと throughline detail が解決しないので suffix を出さない。
-      const displayTime = r.bodyTime ?? r.time;
-      const partCounts = l3ByTurn.get(key)?.partCounts ?? new Map();
-      const suffix = r.bodyTime != null
-        ? buildPartsSummary(partCounts, { includeBody: true })
-        : '';
+    // body 時刻が引けた行だけ詳細呼び出しを案内する。引けない場合は
+    // `[skeleton 時刻]` のままだと throughline detail が解決しないので suffix を出さない。
+    const displayTime = r.bodyTime ?? r.time;
+    const partCounts = l3ByTurn.get(key)?.partCounts ?? new Map();
+    const suffix = r.bodyTime != null
+      ? buildPartsSummary(partCounts, { includeBody: true })
+      : '';
 
-      l1Lines.push(`[${displayTime}] ${summary}${suffix}`);
-    }
-    if (l1Lines.length > 0) {
-      lines.push('');
-      lines.push('### それ以前の要約 (L1)');
-      lines.push(...l1Lines);
-    }
+    l1Lines.push(`[${displayTime}] ${summary}${suffix}`);
   }
 
-  if (record.memory.recentBodies.length > 0) {
+  // ターン内の最終 role 行 (通常 user→assistant 順なら assistant) にだけ suffix を出す。
+  // L3 (思考 / ツール / hook 出力 / 画像) は turn_number 単位でしか紐付いていないので
+  // 同じターンの user 行と assistant 行の両方に貼ると同じ内容が二度出て紛らわしい。
+  const l2Lines = [];
+  const lastIdxPerTurn = new Map();
+  for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
+    const r = record.memory.recentBodies[i];
+    if (!r.text) continue;
+    const key = `${r.originSessionId}\x00${r.turnNumber}`;
+    lastIdxPerTurn.set(key, i);
+  }
+  for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
+    const r = record.memory.recentBodies[i];
+    if (!r.text) continue;
+    const key = `${r.originSessionId}\x00${r.turnNumber}`;
+    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,
+      turnKey: key,
+      createdAt: r.createdAt,
+    });
+  }
+
+  return { header, anchorLines, l1Lines, l2Lines };
+}
+
+function joinSections({ header, anchorLines, l1Lines, l2Lines }, { l1Note = null, l2Note = null } = {}) {
+  const lines = [header];
+  if (anchorLines.length > 0) {
+    lines.push('');
+    lines.push('### 現在地 (直前のやりとり)');
+    lines.push(...anchorLines);
+  }
+  if (l1Lines.length > 0 || l1Note) {
+    lines.push('');
+    lines.push('### それ以前の要約 (L1)');
+    if (l1Note) lines.push(l1Note);
+    lines.push(...l1Lines);
+  }
+  if (l2Lines.length > 0 || l2Note) {
     lines.push('');
     lines.push('### 直前の対話 (L2 / active work thread, 古い順)');
+    if (l2Note) lines.push(l2Note);
+    lines.push(...l2Lines.map((l) => l.text));
+  }
+  return lines.join('\n');
+}
+
+/**
+ * L1 + L2 注入テキストを組み立てる（サイズ無制限）。L3 は本文ではなく
+ * 各 L1 / L2 行末尾の inline hint として付与する。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{
+ *   sessionId: string,
+ *   isInheritance: boolean,
+ *   excludeOriginId?: string | null,
+ *   inflightMemo?: string | null,
+ * }} params
+ * @returns {string | null}
+ */
+export function buildResumeContext(
+  db,
+  { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
+) {
+  const sections = buildResumeSections(db, { sessionId, isInheritance, excludeOriginId });
+  if (!sections) return null;
+  return joinSections(sections);
+}
 
-    // ターン内の最終 role 行 (通常 user→assistant 順なら assistant) にだけ suffix を出す。
-    // L3 (思考 / ツール / hook 出力 / 画像) は turn_number 単位でしか紐付いていないので
-    // 同じターンの user 行と assistant 行の両方に貼ると同じ内容が二度出て紛らわしい。
-    const lastIdxPerTurn = new Map();
-    for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
-      const r = record.memory.recentBodies[i];
-      if (!r.text) continue;
-      const key = `${r.originSessionId}\x00${r.turnNumber}`;
-      lastIdxPerTurn.set(key, i);
+/**
+ * hook stdout 注入の予算上限（文字数）。
+ *
+ * 実測 (2026-07-17, Claude Code 2.1.211 / ADR 0014):
+ *   SessionStart / UserPromptSubmit の hook stdout は約 10,000 字を超えると
+ *   file 化され、モデル可視は `<persisted-output>`（ファイルパス + 先頭 2KB preview）
+ *   だけに劣化する。9,501 字は inline 通過、15,286 字は file 化を確認。
+ *   全 transcript 実測では >10k の注入 12 件が 12 件とも劣化していた
+ *   (v2.1.195 / 2026-06-28 以降)。安全側マージンとして 9,500 に設定。
+ */
+export const INJECTION_BUDGET_CHARS = 9_500;
+
+// 案内セクション（### さらに前の記憶）の予約分。ヘッダ・アンカーと同格の固定部として
+// 予算計算の最初に差し引き、どれだけ逼迫しても落とさない（無条件表示）。
+// 実文言はテンプレート固定 + 動的値（件数・時刻範囲・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. 案内セクション（無条件表示。予約 GUIDANCE_RESERVE を先に差し引く）
+ *   3. L2 本文: 新しい順に**丸ごと入るターンだけ**詰めて古い順に出力
+ *      （ターン単位の原子。固定 N で予算を遊ばせず、断片も詰めない。
+ *       ターン境界の自然な端数は許容）
+ *   L1 は注入しない（窓の残りは recall --l2、それより古い側は recall --l1 が担う）。
+ *   最新ターンが単体で予算を超える場合だけ、切り詰めてでも入れる
+ *   （現在地の文脈をアンカー 600 字より厚く確保するため）。
+ *
+ * @returns {{
+ *   text: string,
+ *   totalChars: number,
+ *   injectedL2Turns: number,
+ *   remainingL2Turns: number,
+ *   olderTurns: number,
+ *   olderSummarized: number,
+ *   truncatedNewestL2: boolean,
+ * } | null}
+ */
+export function buildBudgetedResumeContext(
+  db,
+  { sessionId, isInheritance, excludeOriginId = null, maxChars = INJECTION_BUDGET_CHARS },
+) {
+  const sections = buildResumeSections(db, { sessionId, isInheritance, excludeOriginId });
+  if (!sections) return null;
+
+  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('### 直前の対話 (L2 / active work thread, 古い順)');
 
-    for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
-      const r = record.memory.recentBodies[i];
-      if (!r.text) continue;
-      const key = `${r.originSessionId}\x00${r.turnNumber}`;
-      const isLastOfTurn = lastIdxPerTurn.get(key) === i;
-      const partCounts = isLastOfTurn ? (l3ByTurn.get(key)?.partCounts ?? new Map()) : new Map();
-      const suffix = buildPartsSummary(partCounts);
-      lines.push(`[${r.time}] [${r.role}]: ${r.text}${suffix}`);
+  let remaining = maxChars - fixedCost - GUIDANCE_RESERVE;
+
+  // L2: 新しい順にターンを丸ごと採用して古い順で出力
+  const keptTurns = [];
+  let truncatedNewestL2 = false;
+  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) {
+      keptTurns.unshift(turn);
+      remaining -= cost;
+      continue;
+    }
+    // 最新ターンが単体で入らない場合だけ、最新行を切り詰めて確保する
+    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;
+      keptTurns.unshift({
+        ...turn,
+        lines: [{ ...newestLine, text: newestLine.text.slice(0, keep) + marker }],
+      });
+      remaining = 0;
+      truncatedNewestL2 = true;
     }
+    break; // ターン原子: 入らないターンが出たらそこで打ち切り (歯抜けを作らない)
   }
 
-  return lines.join('\n');
+  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;
+  }
+
+  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,
+    injectedL2Turns,
+    remainingL2Turns,
+    olderTurns: older.total,
+    olderSummarized: older.summarized,
+    truncatedNewestL2,
+  };
 }