throughline 0.4.8 → 0.4.9

package/src/l3-summary.mjs

@@ -0,0 +1,72 @@
+/**
+ * L3 reference の表示集約ヘルパー (resume-context / codex-handoff 共通)
+ *
+ * 各 L1 / L2 行末尾に付ける `(詳細：…)` suffix の組み立てを担当する。
+ * - hook 出力 (system) は noise なので suffix から除外する
+ * - tool_input + tool_output は 1:1 なので tool 名 (例: Bash) で 1 つに集約する
+ *   (count は tool_input 側だけで数える)
+ * - mcp__ ツール名は末尾の関数名だけに短縮する (フルパスは namespace noise)
+ * - 件数は >1 のときだけ ` ×N` で表示
+ */
+
+/**
+ * MCP ツール名 (`mcp__plugin_..._playwright__browser_navigate`) を末尾の関数名
+ * (`browser_navigate`) だけに短縮する。最後の `__` 以降を返す。
+ */
+export function shortenMcpToolName(toolName) {
+  if (typeof toolName !== 'string') return toolName ?? 'tool';
+  if (!toolName.startsWith('mcp__')) return toolName;
+  const idx = toolName.lastIndexOf('__');
+  return idx >= 0 && idx + 2 < toolName.length ? toolName.slice(idx + 2) : toolName;
+}
+
+/**
+ * L3 kind + tool_name を AI が読みやすい日本語ラベルにする。
+ * null を返した kind は suffix からスキップする (noise / 二重カウント回避)。
+ */
+export function localizeL3Part(kind, toolName) {
+  if (kind === 'thinking') return '思考';
+  if (kind === 'tool_input') return shortenMcpToolName(toolName);
+  if (kind === 'tool_output') return null;
+  if (kind === 'system') return null;
+  if (kind === 'image') return '画像';
+  return kind;
+}
+
+/**
+ * L3 references を `(originSessionId, turnNumber)` でグルーピングし、
+ * 表示ラベル (Bash / 思考 / 画像 など) ごとの件数を保つ。
+ * Map の挿入順は created_at ASC のままなので、自然な発生順に並ぶ。
+ */
+export function groupL3ByTurn(l3Refs) {
+  const map = new Map();
+  for (const ref of l3Refs) {
+    if (ref.originSessionId == null || ref.turnNumber == null) continue;
+    const turnKey = `${ref.originSessionId}\x00${ref.turnNumber}`;
+    let entry = map.get(turnKey);
+    if (!entry) {
+      entry = { partCounts: new Map() };
+      map.set(turnKey, entry);
+    }
+    const label = localizeL3Part(ref.kind, ref.toolName);
+    if (label == null) continue;
+    entry.partCounts.set(label, (entry.partCounts.get(label) ?? 0) + 1);
+  }
+  return map;
+}
+
+/**
+ * 1 ターン分の `(詳細：…)` suffix 文字列を組み立てる。
+ * - L1 の場合は `本文` を先頭に置き「summary を超えた full body が引ける」ことを示す
+ * - L2 の場合は body 自体は行内にあるので L3 部品だけ列挙
+ * - 何も無いなら空文字 (suffix 自体を出さない)
+ */
+export function buildPartsSummary(partCounts, { includeBody = false } = {}) {
+  const parts = [];
+  if (includeBody) parts.push('本文');
+  for (const [label, count] of partCounts) {
+    parts.push(count > 1 ? `${label} ×${count}` : label);
+  }
+  if (parts.length === 0) return '';
+  return ` (詳細：${parts.join(', ')})`;
+}

package/src/resume-context.mjs

@@ -5,56 +5,42 @@
  *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
  * 設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
- *   - 注入順: ヘッダ + Reading Contract → L1 要約 → L2 本文 → L3 refs 一覧 → Continuation Instruction
- *   - 直近 N=20 ターンは bodies から L2 全文を注入
- *   - それ以前は skeletons から L1 要約のみ注入
- *   - L3 references は具体的な `throughline detail <時刻>` コマンドの一覧として注入
- *     (本文は埋め込まず、参照のみ)
- *   - memo / thinking は注入しない (= L2 全文があれば最後の assistant turn 自体に
- *     「次に何をしようとしていたか」が含まれる)
- *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（created_at ベース、DB 永続）
+ *   - 注入順: ヘッダ + 読み方 → L1 要約 → L2 本文（一番下）
+ *   - 直前の発話に Claude の attention が向くよう、L2 を末尾に置く
+ *   - L3 は別セクションを設けず、対応する L1 / L2 行にインラインで
+ *     `[→ throughline detail HH:MM:SS (kind …)]` ヒントを付ける
+ *   - L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が
+ *     含まれるため、memo / thinking / 末尾の再開指示は注入しない
+ *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（L2 は body の created_at、
+ *     L1 は元ターンの body 時刻が取れればそれ、なければ skeleton 時刻）
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
- *   - フレーミング: 「過去の記憶」ではなく「現在進行中の作業」として読ませる
- *     (Codex 側 renderCodexRolloutMemoryPreview の写像)
+ *   - フレーミング: 「報告してください」のメタ命令は出さない。直前の対話の
+ *     自然な続きとして応答させる
  */
 
-import { buildHandoffRecord, formatTime, N_RECENT_L2 } from './handoff-record.mjs';
+import { buildHandoffRecord } from './handoff-record.mjs';
+import { groupL3ByTurn, buildPartsSummary } from './l3-summary.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
   `\n` +
-  `**前セッションで進行中だった作業を、この新セッションで引き継いでいます。以下が中断時点の状態です:**\n` +
-  `- 直近 ${N_RECENT_L2} ターンの会話本文 (L2)\n` +
-  `- それ以前の要約 (L1)\n` +
-  `- L3 (ツール入出力・思考) の参照一覧 (本文は別途取り出す)\n` +
-  `\n` +
-  `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
-  `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
-
-const ACTIVE_WORK_READING_CONTRACT =
-  `\n` +
-  `**読み方の契約:**\n` +
-  `- これは単なる過去ログではなく、現在進行中の作業を再開するための active work context です。\n` +
-  `- L2 は古い順に並んだ作業履歴です。後の発言・判断・TODO は前の仮説や作業方針を上書きし得ます。\n` +
-  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2 を優先して現在状態を推定してください。\n` +
-  `- 不足している tool output / 詳細根拠が必要なときだけ、L3 references の \`throughline detail <時刻>\` を使って取得してください。`;
-
-const CONTINUATION_REMINDER =
-  '**再開指示:** 上記の L1 / L2 を、現在タスクに使う作業コンテキストとして扱ってください。' +
-  '最新の L2 から次の一手を決め、中断地点から続行してください。' +
-  '古い仮説や未完了 TODO は、後続の判断で上書きされ得ます。';
+  `**読み方:**\n` +
+  `- 直前の対話の自然な続きとして応答してください。\n` +
+  '- **各ターンの詳細の取得方法**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
+  `(該当ターンの本文＋詳細を stdout に返します)`;
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
 /**
- * L1 + L2 + L3 references 注入テキストを組み立てる。
+ * L1 + L2 注入テキストを組み立てる。L3 は本文ではなく
+ * 各 L1 / L2 行末尾の inline hint として付与する。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{
  *   sessionId: string,
  *   isInheritance: boolean,
  *   excludeOriginId?: string | null,
- *   inflightMemo?: string | null,  // 互換のため受け取るが新仕様では使用しない
+ *   inflightMemo?: string | null,
  * }} params
  * @returns {string | null}
  */
@@ -62,8 +48,6 @@ export function buildResumeContext(
   db,
   { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
 ) {
-  // handoff-record は Codex 側でも使うので signature 維持。inflightMemo / latestThinking は
-  // 新仕様の注入テキストには使わない (L2 全文で十分という判断)。
   const record = buildHandoffRecord(db, {
     sessionId,
     isInheritance,
@@ -72,42 +56,60 @@ export function buildResumeContext(
   if (!record) return null;
 
   const turnCount = record.stats.preservedContextRows;
-  const header = isInheritance
-    ? RESUME_HEADER_TEMPLATE(turnCount) + ACTIVE_WORK_READING_CONTRACT
-    : NORMAL_HEADER;
+  const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
   const lines = [header];
 
+  const l3ByTurn = groupL3ByTurn(record.references.l3);
+
   if (record.memory.l1Summaries.length > 0) {
-    lines.push('');
-    lines.push('### それ以前の要約 (L1)');
+    const l1Lines = [];
     for (const r of record.memory.l1Summaries) {
       if (!r.summary || r.summary === '(no content)') continue;
-      lines.push(`[${r.time}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
+      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);
     }
   }
 
   if (record.memory.recentBodies.length > 0) {
     lines.push('');
-    lines.push('### 現在進行中の作業履歴 (L2 / active work thread)');
-    lines.push('以下は古い順です。後の行ほど現在状態に近く、前の仮説を上書きし得ます。');
-    for (const r of record.memory.recentBodies) {
+    lines.push('### 直前の対話 (L2 / active work thread, 古い順)');
+
+    // ターン内の最終 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;
-      lines.push(`[${r.time}] [${r.role}]: ${r.text}`);
+      const key = `${r.originSessionId}\x00${r.turnNumber}`;
+      lastIdxPerTurn.set(key, i);
     }
-  }
 
-  if (record.references.l3.length > 0) {
-    lines.push('');
-    lines.push('### L3 詳細参照 (本文は注入されていません)');
-    lines.push('必要なときだけ以下のコマンドで取得してください:');
-    for (const ref of record.references.l3) {
-      const time = formatTime(ref.createdAt);
-      lines.push(`- [${time}] ${ref.kind}: \`throughline detail ${time}\``);
+    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}`);
     }
   }
 
-  lines.push('');
-  lines.push(CONTINUATION_REMINDER);
-
   return lines.join('\n');
 }

package/src/resume-context.test.mjs

@@ -56,25 +56,68 @@ function insertBody(db, row) {
   ).run(row.session, row.origin, row.turn, row.role, row.text, 1, row.createdAt);
 }
 
-function insertThinking(db, row) {
+function insertDetail(db, row) {
   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 (?, ?, ?, 'thinking', NULL, ?, 1, ?, 'thinking', ?)`,
-  ).run(row.session, row.origin, row.turn, row.text, row.createdAt, row.sourceId);
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    row.session,
+    row.origin,
+    row.turn,
+    row.toolName ?? row.kind,
+    row.input ?? null,
+    row.output ?? null,
+    row.tokenCount ?? 1,
+    row.createdAt,
+    row.kind,
+    row.sourceId ?? null,
+  );
 }
 
-test('buildResumeContext: inheritance output order is L1 -> L2 -> L3 refs -> reminder (no memo / no thinking)', () => {
+test('buildResumeContext: header is terse and announces the Bash invocation contract', () => {
   const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'user',
+    text: 'hi',
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+  assert.match(text, /^## Throughline: 中断した作業の再開/);
+
+  // 旧版の冗長な行は全部削除
+  assert.ok(!text.includes('と報告してください'), 'meta-report instruction must be gone');
+  assert.ok(!text.includes('一番下の'), 'redundant ordering hint must be gone');
+  assert.ok(!text.includes('内訳の読み方'), 'glossary block must be gone');
+  assert.ok(!text.includes('現在進行中の作業の active work context'), 'verbose framing must be gone');
+
+  // 残るのは 2 行: 自然な続き + Bash 呼び出し方法
+  assert.match(text, /直前の対話の自然な続きとして応答してください/);
+  assert.match(
+    text,
+    /\*\*各ターンの詳細の取得方法\*\*: \*\*`Bash` ツールで `throughline detail HH:MM:SS` を実行\*\* \(該当ターンの本文＋詳細を stdout に返します\)/,
+  );
+});
 
+test('buildResumeContext: L2 is the very last section (anchored at bottom for attention)', () => {
+  const db = makeDb();
   insertSkeleton(db, {
     session: 'new',
     origin: 'old',
     turn: 1,
     role: 'assistant',
     summary: 'older L1 summary',
-    createdAt: 1000,
+    createdAt: 800,
   });
   insertBody(db, {
     session: 'new',
@@ -89,52 +132,284 @@ test('buildResumeContext: inheritance output order is L1 -> L2 -> L3 refs -> rem
     origin: 'old',
     turn: 2,
     role: 'assistant',
-    text: 'recent assistant body',
+    text: 'recent assistant body — this should be the last line',
     createdAt: 2100,
   });
-  // thinking は DB に書かれても、新仕様では注入テキストに出ない
-  insertThinking(db, {
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+
+  assert.ok(!text.includes('**再開指示:**'), 'continuation reminder should be removed');
+  assert.ok(!text.includes('### L3 詳細参照'), 'standalone L3 section should be removed');
+
+  const lines = text.split('\n').filter((l) => l.length > 0);
+  assert.match(
+    lines[lines.length - 1],
+    /\[assistant\]: recent assistant body — this should be the last line/,
+  );
+
+  const l1Idx = text.indexOf('### それ以前の要約 (L1)');
+  const l2Idx = text.indexOf('### 直前の対話 (L2 / active work thread, 古い順)');
+  assert.ok(l1Idx > 0, 'L1 section should be present');
+  assert.ok(l2Idx > l1Idx, 'L2 section should follow L1');
+});
+
+test('buildResumeContext: L2 entries get inline (詳細：…) suffixes with tool-name-aware labels', () => {
+  const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    role: 'assistant',
+    text: 'turn with tools',
+    createdAt: 5000,
+  });
+  insertDetail(db, {
     session: 'new',
     origin: 'old',
-    turn: 2,
-    text: 'latest thinking block',
-    createdAt: 2200,
-    sourceId: 'asst:thinking:0',
+    turn: 5,
+    kind: 'thinking',
+    toolName: 'thinking',
+    output: 'thinking text',
+    createdAt: 5010,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'tool_input',
+    toolName: 'Bash',
+    input: 'ls',
+    createdAt: 5020,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'tool_input',
+    toolName: 'Bash',
+    input: 'pwd',
+    createdAt: 5030,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'tool_output',
+    toolName: 'Bash',
+    output: 'home',
+    createdAt: 5040,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'system',
+    toolName: 'UserPromptSubmit',
+    output: 'hook ran',
+    createdAt: 5050,
+  });
+  // MCP tool: 末尾の関数名だけにすべき
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'tool_input',
+    toolName: 'mcp__plugin_everything-claude-code_playwright__browser_navigate',
+    input: '{"url":"http://example.com"}',
+    createdAt: 5060,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 6,
+    role: 'user',
+    text: 'plain user message',
+    createdAt: 6000,
   });
 
   const text = buildResumeContext(db, {
     sessionId: 'new',
     isInheritance: true,
-    // inflightMemo は互換のため受け取れるが、新仕様では注入テキストに使わない
-    inflightMemo: '**Next**: keep going (should NOT appear)',
   });
 
   assert.ok(text);
-  assert.match(text, /^## Throughline: 中断した作業の再開/);
 
-  // 新仕様: memo / thinking セクションは注入されない
-  assert.ok(text.indexOf('### 中断直前の in-flight メモ') < 0, 'memo section should not be injected');
-  assert.ok(text.indexOf('### 中断直前の思考') < 0, 'thinking section should not be injected');
-  assert.ok(!text.includes('**Next**: keep going'), 'inflightMemo content should be ignored');
-  assert.ok(!text.includes('latest thinking block'), 'thinking text should not appear');
+  const turnWithToolsLine = text
+    .split('\n')
+    .find((l) => l.includes('turn with tools'));
+  assert.ok(turnWithToolsLine, 'L2 line for turn 5 should exist');
+  // - tool_input + tool_output は tool 名で集約 (Bash ×2)
+  // - hook 出力 (system) は suffix から除外
+  // - MCP ツール名は末尾の関数名 (browser_navigate) だけ
+  assert.match(
+    turnWithToolsLine,
+    /\(詳細：思考, Bash ×2, browser_navigate\)$/,
+  );
+  assert.ok(
+    !turnWithToolsLine.includes('hook 出力'),
+    'hook 出力 (system) must be excluded from the suffix',
+  );
+  assert.ok(
+    !turnWithToolsLine.includes('mcp__'),
+    'MCP full path must be shortened to function name only',
+  );
 
-  // 注入される順序: L1 → L2 → L3 refs → 再開指示
-  const l1Idx = text.indexOf('### それ以前の要約 (L1)');
-  const l2Idx = text.indexOf('### 現在進行中の作業履歴 (L2 / active work thread)');
-  const l3Idx = text.indexOf('### L3 詳細参照');
-  const reminderIdx = text.indexOf('**再開指示:**');
+  // 旧版にあった `[→ throughline detail HH:MM:SS]` のリンク表記は per-line には出さない
+  assert.ok(
+    !turnWithToolsLine.includes('throughline detail'),
+    'per-line should not repeat the throughline detail command (the header announces it)',
+  );
 
-  assert.ok(l1Idx > 0, 'L1 section should be present');
-  assert.ok(l2Idx > l1Idx, 'L2 should follow L1');
-  assert.ok(l3Idx > l2Idx, 'L3 references should follow L2');
-  assert.ok(reminderIdx > l3Idx, 'continuation reminder should follow L3 refs');
-
-  assert.ok(text.includes('older L1 summary'));
-  assert.ok(text.includes('[user]: recent user body'));
-  assert.ok(text.includes('[assistant]: recent assistant body'));
-  // L3 refs は detail コマンドのみ (本文は注入しない)
-  assert.match(text, /throughline detail \d{2}:\d{2}:\d{2}/);
-  assert.match(text, /単なる過去ログではなく、現在進行中の作業/);
+  const plainLine = text.split('\n').find((l) => l.includes('plain user message'));
+  assert.ok(plainLine, 'L2 line for turn 6 should exist');
+  assert.ok(
+    !plainLine.includes('詳細：'),
+    'L2 turns without L3 should not carry a (詳細：…) suffix',
+  );
+
+  // 旧版にあった独立 `### Detail References` セクションも出ない
+  assert.ok(!text.includes('### L3 詳細参照'));
+});
+
+test('buildResumeContext: (詳細：…) suffix appears only on the last role row of each turn (no duplication)', () => {
+  const db = makeDb();
+  // Turn 5: both user and assistant rows. L3 attached at turn level.
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    role: 'user',
+    text: 'user side of turn 5',
+    createdAt: 5000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    role: 'assistant',
+    text: 'assistant side of turn 5',
+    createdAt: 5100,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'thinking',
+    toolName: 'thinking',
+    output: 'thinking',
+    createdAt: 5050,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 5,
+    kind: 'tool_input',
+    toolName: 'Bash',
+    input: 'ls',
+    createdAt: 5060,
+  });
+
+  // Turn 6: only user row (e.g. compact session ending on user). suffix should
+  // attach to the user row since it's the last role of the turn.
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 6,
+    role: 'user',
+    text: 'lone user turn',
+    createdAt: 6000,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 6,
+    kind: 'image',
+    toolName: 'image',
+    output: '[img]',
+    createdAt: 6010,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+
+  const userTurn5 = text.split('\n').find((l) => l.includes('user side of turn 5'));
+  const assistantTurn5 = text.split('\n').find((l) => l.includes('assistant side of turn 5'));
+  const userTurn6 = text.split('\n').find((l) => l.includes('lone user turn'));
+
+  assert.ok(userTurn5 && assistantTurn5 && userTurn6);
+  // Turn 5: only assistant (last role of the turn) gets the suffix
+  assert.ok(!userTurn5.includes('詳細：'), 'user row should not duplicate the turn suffix');
+  assert.match(assistantTurn5, /\(詳細：思考, Bash\)$/);
+  // Turn 6: user is the only role, so it gets the suffix
+  assert.match(userTurn6, /\(詳細：画像\)$/);
+});
+
+test('buildResumeContext: L1 entries display the body time at the start and prepend "本文" to the suffix', () => {
+  const db = makeDb();
+  // L1 summary was created at turn-processor run time (8000), but the original
+  // body was written at 1500. The line prefix [HH:MM:SS] must be the body time
+  // so `Bash で throughline detail HH:MM:SS` resolves correctly.
+  insertSkeleton(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    summary: 'old turn summary',
+    createdAt: 8000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: 'original body text from turn 1',
+    createdAt: 1500,
+  });
+  // Push turn 1 out of L2 window
+  for (let t = 2; t <= 25; t += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn: t,
+      role: 'user',
+      text: `filler turn ${t}`,
+      createdAt: 9000 + t,
+    });
+  }
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+
+  const l1Line = text.split('\n').find((l) => l.includes('old turn summary'));
+  assert.ok(l1Line, 'L1 line should be present');
+
+  // 行頭 [HH:MM:SS] が body 時刻を指している (skeleton 時刻ではない)
+  const bodyTime = new Date(1500).toTimeString().slice(0, 8);
+  const skeletonTime = new Date(8000).toTimeString().slice(0, 8);
+  assert.ok(
+    l1Line.startsWith(`[${bodyTime}] `),
+    `L1 line should start with body time [${bodyTime}], got: ${l1Line}`,
+  );
+  assert.ok(
+    !l1Line.startsWith(`[${skeletonTime}] `),
+    'L1 line must not start with skeleton (summarization) time',
+  );
+
+  // (詳細：本文) suffix が付く (body が引けるという案内)
+  assert.match(l1Line, /\(詳細：本文\)$/);
 });
 
 test('buildResumeContext: returns null when no memory rows or inflight memo exist', () => {
@@ -175,3 +450,24 @@ test('buildResumeContext: excludeOriginId omits rows from the current origin', (
   assert.ok(text.includes('old origin body'));
   assert.ok(!text.includes('current origin body'));
 });
+
+test('buildResumeContext: ignores inflightMemo (kept only for signature compatibility)', () => {
+  const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'user',
+    text: 'hi',
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    inflightMemo: '**Next**: keep going (should NOT appear)',
+  });
+
+  assert.ok(text);
+  assert.ok(!text.includes('**Next**: keep going'));
+});