throughline 0.6.2 → 0.7.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,232 @@ 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}`;
-
-      // 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);
-    }
+  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 })
+      : '';
+
+    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 });
+  }
+
+  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);
+}
+
+/**
+ * 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;
 
-    // ターン内の最終 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);
+// 予算超過時に注入へ入れる省略告知の予約分（この分を先に差し引いてから詰める）。
+// 告知には省略した L2 行の [時刻 role] 参照リストを含める — 窓内の L2 行にはまだ
+// L1 要約が無いことがあり、時刻が無いと `throughline detail` で取り出せなくなる
+// （= 「要約せず削る。ただし参照は必ず残す」コンセプトの担保）。
+const OMISSION_NOTE_RESERVE = 500;
+// l2Note 単体の上限 (RESERVE から l1Note ぶんの余裕を引いた値)
+const L2_NOTE_MAX_CHARS = 430;
+// 最新 L2 行が単体で予算を超える場合に、切り詰めてでも入れる最小の残余
+const MIN_TRUNCATED_L2_CHARS = 400;
+
+/**
+ * 予算付き注入テキスト。優先順位:
+ *   1. ヘッダ + 現在地アンカー（常に全文）
+ *   2. L1 要約（新しい順に予算まで。落とした分は告知行）
+ *   3. L2 本文（新しい順に予算まで詰めて古い順に出力。落とした分は告知行 +
+ *      L1 / `throughline detail` への誘導）
+ * 予算内に一切 L2 が入らない場合でも、最新 L2 行だけは切り詰めて入れる
+ * （現在地の文脈をアンカー 600 字より厚く確保するため）。
+ *
+ * @returns {{
+ *   text: string,
+ *   totalChars: number,
+ *   droppedL1Rows: number,
+ *   droppedL2Rows: 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') 分
+
+  // 固定部 (ヘッダ + アンカー) のコスト。セクション見出し・空行も概算に含める
+  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;
+
+  // 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;
     }
+  }
 
-    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}`);
+  // L2: 新しい順に採用して古い順で出力
+  const keptL2 = [];
+  let droppedL2Rows = 0;
+  let truncatedNewestL2 = false;
+  for (let i = sections.l2Lines.length - 1; i >= 0; i -= 1) {
+    const line = sections.l2Lines[i];
+    const cost = lineCost(line.text);
+    if (remaining - cost >= 0) {
+      keptL2.unshift(line);
+      remaining -= cost;
+      continue;
+    }
+    // 最新行が単体で入らない場合だけ、切り詰めて確保する
+    if (keptL2.length === 0 && remaining >= MIN_TRUNCATED_L2_CHARS) {
+      const marker = ` …(予算超過で切詰め; 全文: throughline detail ${line.time})`;
+      const keep = remaining - marker.length - 1;
+      keptL2.unshift({ ...line, text: line.text.slice(0, keep) + marker });
+      remaining = 0;
+      truncatedNewestL2 = true;
+      droppedL2Rows = i; // これより古い行は全部落ちる
+      break;
     }
+    droppedL2Rows = i + 1;
+    break;
   }
 
-  return lines.join('\n');
+  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 text = joinSections(
+    { header: sections.header, anchorLines: sections.anchorLines, l1Lines: keptL1, l2Lines: keptL2 },
+    { l1Note, l2Note },
+  );
+
+  return {
+    text,
+    totalChars: text.length,
+    droppedL1Rows,
+    droppedL2Rows,
+    truncatedNewestL2,
+  };
 }

package/src/resume-context.test.mjs

@@ -1,7 +1,11 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
-import { buildResumeContext } from './resume-context.mjs';
+import {
+  buildResumeContext,
+  buildBudgetedResumeContext,
+  INJECTION_BUDGET_CHARS,
+} from './resume-context.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -623,3 +627,132 @@ test('buildResumeContext: ignores inflightMemo (kept only for signature compatib
   assert.ok(text);
   assert.ok(!text.includes('**Next**: keep going'));
 });
+
+// ---- buildBudgetedResumeContext (ADR 0014: hook stdout の 10k file 化対策) ----
+
+test('INJECTION_BUDGET_CHARS stays under the measured 10k persisted-output limit', () => {
+  assert.ok(INJECTION_BUDGET_CHARS <= 9_501, '実測 inline 通過上限 9,501 字以下であること');
+});
+
+test('budgeted: under budget output matches the unbudgeted renderer, nothing dropped', () => {
+  const db = makeDb();
+  insertBody(db, { session: 'new', origin: 'old', turn: 1, role: 'user', text: 'short question', createdAt: 1000 });
+  insertBody(db, { session: 'new', origin: 'old', turn: 1, role: 'assistant', text: 'short answer', createdAt: 1100 });
+
+  const full = buildResumeContext(db, { sessionId: 'new', isInheritance: true });
+  const budgeted = buildBudgetedResumeContext(db, { sessionId: 'new', isInheritance: true });
+
+  assert.ok(budgeted);
+  assert.equal(budgeted.text, full);
+  assert.equal(budgeted.droppedL1Rows, 0);
+  assert.equal(budgeted.droppedL2Rows, 0);
+  assert.equal(budgeted.truncatedNewestL2, false);
+  assert.ok(budgeted.totalChars <= INJECTION_BUDGET_CHARS);
+});
+
+test('budgeted: drops oldest L2 rows first, keeps newest, and stays within maxChars', () => {
+  const db = makeDb();
+  // 各 ~800 字 × 10 行 = 本文だけで ~8,000 字 → maxChars 4000 で古い行が落ちる
+  for (let turn = 1; turn <= 10; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: `turn-${String(turn).padStart(2, '0')} ` + 'x'.repeat(800),
+      createdAt: 1000 + turn * 100,
+    });
+  }
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 4000,
+  });
+
+  assert.ok(budgeted);
+  assert.ok(budgeted.totalChars <= 4000, `totalChars ${budgeted.totalChars} must fit budget`);
+  assert.ok(budgeted.droppedL2Rows > 0, 'some old L2 rows must be dropped');
+  assert.ok(budgeted.text.includes('turn-10'), 'newest L2 row must survive');
+  assert.ok(!budgeted.text.includes('turn-01 '), 'oldest L2 row must be dropped');
+  assert.match(budgeted.text, /古い L2 を \d+ 行省略/, 'omission must be announced, not silent');
+  // 「削るときは取り出すための参照を必ず残す」: 落とした行の [時刻 role] リストが
+  // 告知に載っていること (窓内の行にはまだ L1 が無く、時刻が無いと detail で引けない)
+  assert.match(
+    budgeted.text,
+    /省略分 \(新しい順\): (\[\d{2}:\d{2}:\d{2} assistant\][ ]?)+/,
+    'dropped rows must be listed with [time role] refs for throughline detail',
+  );
+});
+
+test('budgeted: very many dropped rows fold into ほかN行 keeping the note bounded', () => {
+  const db = makeDb();
+  for (let turn = 1; turn <= 40; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: `turn-${String(turn).padStart(2, '0')} ` + 'x'.repeat(700),
+      createdAt: 1000 + turn * 1000,
+    });
+  }
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 4000,
+  });
+
+  assert.ok(budgeted);
+  assert.ok(budgeted.totalChars <= 4000);
+  assert.match(budgeted.text, /ほか\d+行/, 'overflow refs must fold into a count');
+});
+
+test('budgeted: a single oversized newest L2 row is truncated with a detail pointer', () => {
+  const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: 'HEAD-MARKER ' + 'y'.repeat(20_000),
+    createdAt: 1000,
+  });
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 4000,
+  });
+
+  assert.ok(budgeted);
+  assert.ok(budgeted.totalChars <= 4000);
+  assert.equal(budgeted.truncatedNewestL2, true);
+  assert.ok(budgeted.text.includes('HEAD-MARKER'), 'the head of the newest row must survive');
+  assert.match(budgeted.text, /全文: throughline detail /, 'truncation must point to detail command');
+});
+
+test('budgeted: header and anchor always survive even under pressure', () => {
+  const db = makeDb();
+  for (let turn = 1; turn <= 5; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: 'z'.repeat(3000),
+      createdAt: 1000 + turn,
+    });
+  }
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 4000,
+  });
+
+  assert.ok(budgeted);
+  assert.match(budgeted.text, /^## Throughline: 直前スレッドの継続応答用コンテキスト/);
+  assert.ok(budgeted.text.includes('### 現在地 (直前のやりとり)'));
+});