throughline 0.4.11 → 0.5.0

package/src/hook-entrypoints.test.mjs

@@ -3,7 +3,9 @@ import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
 import {
   existsSync,
+  mkdirSync,
   mkdtempSync,
+  readFileSync,
   rmSync,
   writeFileSync,
 } from 'node:fs';
@@ -367,3 +369,289 @@ test('process-turn subprocess stores L2 bodies and L3 details in an isolated DB'
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+// ---- Phase 0-5 spike (UserPromptSubmit) ----
+
+function seedMergedSession(home, sessionId, originId = 'orig-sess') {
+  // DB を直接作って bodies に origin != session_id を入れ、spikeInject が
+  // recentBodies を返せる状態にする。
+  const dbPath = join(home, '.throughline', 'throughline.db');
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      merged_into TEXT
+    );
+    CREATE TABLE IF NOT EXISTS skeletons (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS bodies (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      text TEXT NOT NULL,
+      token_count INTEGER,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS details (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER,
+      tool_name TEXT NOT NULL,
+      input_text TEXT,
+      output_text TEXT,
+      token_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      kind TEXT,
+      source_id TEXT
+    );
+    CREATE TABLE IF NOT EXISTS handoff_batons (
+      project_path TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+  `);
+  db.prepare(
+    `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+     VALUES (?, '/repo', 'active', 1, 2)`,
+  ).run(sessionId);
+  for (const r of [
+    { turn: 1, role: 'user', text: 'past user turn', createdAt: 1000 },
+    { turn: 2, role: 'assistant', text: 'past assistant turn', createdAt: 1100 },
+  ]) {
+    db.prepare(
+      `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES (?, ?, ?, ?, ?, 1, ?)`,
+    ).run(sessionId, originId, r.turn, r.role, r.text, r.createdAt);
+  }
+  db.close();
+}
+
+function touchSpikePromptFlag(home) {
+  const flagPath = join(home, '.throughline', 'spike-prompt.flag');
+  mkdirSync(dirname(flagPath), { recursive: true });
+  writeFileSync(flagPath, '', 'utf8');
+}
+
+function readPromptSpikeLog(home) {
+  const path = join(home, '.throughline', 'logs', 'prompt-spike.log');
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split('\n')
+    .filter((l) => l.trim())
+    .map((l) => JSON.parse(l));
+}
+
+test('Phase 0-5: spike SKIPS when marker file is absent', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    seedMergedSession(home, 'sess-no-marker');
+    const transcriptPath = join(project, 'transcript.jsonl');
+    writeFileSync(transcriptPath, '', 'utf8');
+
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'sess-no-marker',
+        cwd: project,
+        prompt: 'hello world',
+        transcript_path: transcriptPath,
+      }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(readFileSync(transcriptPath, 'utf8'), '', 'transcript untouched');
+    assert.equal(readPromptSpikeLog(home).length, 0, 'no spike log entry');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0-5: spike LOGS skip_reason when transcript_path is missing in payload', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    seedMergedSession(home, 'sess-no-tp');
+    touchSpikePromptFlag(home);
+
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'sess-no-tp',
+        cwd: project,
+        prompt: 'hello world',
+        // transcript_path omitted
+      }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const logs = readPromptSpikeLog(home);
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0].skip_reason, 'no_transcript_path_in_payload');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0-5: spike INJECTS into JSONL chain-reachable from last uuid on first prompt', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    seedMergedSession(home, 'sess-inject');
+    touchSpikePromptFlag(home);
+
+    // Pre-populate transcript with 1 attachment line (= simulates SessionStart hook output)
+    const transcriptPath = join(project, 'transcript.jsonl');
+    const attachmentLine = JSON.stringify({
+      type: 'attachment',
+      uuid: 'pre-attach-uuid',
+      parentUuid: null,
+    });
+    writeFileSync(transcriptPath, attachmentLine + '\n', 'utf8');
+
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'sess-inject',
+        cwd: project,
+        prompt: 'tell me the spike-tracer',
+        transcript_path: transcriptPath,
+        version: '2.1.145',
+        gitBranch: 'main',
+      }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+
+    const content = readFileSync(transcriptPath, 'utf8');
+    const lines = content.split('\n').filter((l) => l.trim());
+    assert.equal(lines.length, 3, '1 preexisting + 2 spike lines');
+    const firstSpike = JSON.parse(lines[1]);
+    assert.equal(firstSpike.parentUuid, 'pre-attach-uuid', 'chain (b) from last attachment uuid');
+    const lastSpike = JSON.parse(lines[2]);
+    assert.match(
+      lastSpike.message.content[0].text,
+      /\[spike-tracer: [0-9a-f]{8}\]$/,
+      'tracer in last assistant',
+    );
+
+    const logs = readPromptSpikeLog(home);
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0].parent_uuid_start, 'pre-attach-uuid');
+    assert.equal(logs[0].appended, 2);
+    assert.match(logs[0].tracer, /^[0-9a-f]{8}$/);
+
+    // per-session marker created
+    assert.ok(
+      existsSync(join(home, '.throughline', 'spike-prompt-state', 'sess-inject')),
+      'per-session marker created after successful spike',
+    );
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0-5: spike is IDEMPOTENT per session (second call is no-op)', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    seedMergedSession(home, 'sess-idem');
+    touchSpikePromptFlag(home);
+
+    const transcriptPath = join(project, 'transcript.jsonl');
+    writeFileSync(
+      transcriptPath,
+      JSON.stringify({ type: 'attachment', uuid: 'preU', parentUuid: null }) + '\n',
+      'utf8',
+    );
+
+    const firstPayload = JSON.stringify({
+      session_id: 'sess-idem',
+      cwd: project,
+      prompt: 'first',
+      transcript_path: transcriptPath,
+    });
+    const secondPayload = JSON.stringify({
+      session_id: 'sess-idem',
+      cwd: project,
+      prompt: 'second',
+      transcript_path: transcriptPath,
+    });
+
+    const r1 = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: firstPayload,
+    });
+    assert.equal(r1.status, 0, r1.stderr);
+    const after1 = readFileSync(transcriptPath, 'utf8').split('\n').filter((l) => l.trim()).length;
+
+    const r2 = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: secondPayload,
+    });
+    assert.equal(r2.status, 0, r2.stderr);
+    const after2 = readFileSync(transcriptPath, 'utf8').split('\n').filter((l) => l.trim()).length;
+
+    assert.equal(after2, after1, 'second prompt did not append additional lines');
+    assert.equal(readPromptSpikeLog(home).length, 1, 'only the first call logged');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0-5: /tl and /clear prompts do NOT trigger spike', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    seedMergedSession(home, 'sess-slash');
+    touchSpikePromptFlag(home);
+    const transcriptPath = join(project, 'transcript.jsonl');
+    writeFileSync(
+      transcriptPath,
+      JSON.stringify({ type: 'attachment', uuid: 'preU', parentUuid: null }) + '\n',
+      'utf8',
+    );
+
+    const r = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'sess-slash',
+        cwd: project,
+        prompt: '/tl',
+        transcript_path: transcriptPath,
+      }),
+    });
+    assert.equal(r.status, 0, r.stderr);
+
+    assert.equal(readPromptSpikeLog(home).length, 0, 'no spike log for /tl');
+    assert.ok(
+      !existsSync(join(home, '.throughline', 'spike-prompt-state', 'sess-slash')),
+      'per-session marker NOT created for /tl',
+    );
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/prompt-submit.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
- * UserPromptSubmit hook — /tl & /clear スラッシュコマンド検出 + バトン書き込み
+ * UserPromptSubmit hook — /tl & /clear スラッシュコマンド検出 + バトン書き込み + Phase 0-5 spike
  *
- * stdin: { session_id, cwd, prompt, hook_event_name, ... }
+ * stdin: { session_id, cwd, prompt, transcript_path, hook_event_name, ... }
  *
  * 動作:
  *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
@@ -13,7 +13,14 @@
  *      VSCode ウィンドウ等で「最新更新セッション = clear されたセッション」が
  *      成立しない multi-window シナリオで誤った前任を選ばないための確定的指名)
  *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
- *   - 本 hook は注入を一切行わない (SessionStart の引き継ぎ注入と二重にならないため)
+ *   - 本 hook は引き継ぎ注入を行わない (SessionStart の stdout 注入と二重にならないため)
+ *
+ *   - **Phase 0-5 spike (SPIKE ONLY)**: marker file `~/.throughline/spike-prompt.flag`
+ *     が存在し、当該セッションでまだ spike を打っていなければ、JSONL に user/assistant
+ *     行を chain-reachable (= 直前の attachment uuid を parent に取る) で append する。
+ *     SessionStart 経路の spike (chain (a) = orphan) ではモデルに届かなかったため、
+ *     UserPromptSubmit 経路で chain (b) を成立させて再検証する。
+ *     docs/THROUGHLINE_TRANSCRIPT_INJECTION_PLAN.md Phase 0-5 参照。
  *
  * 設計背景: docs/INHERITANCE_ON_CLEAR_ONLY.md バトン方式
  */
@@ -21,11 +28,15 @@
 import { getDb } from './db.mjs';
 import { writeBaton } from './baton.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
-import { appendFileSync, mkdirSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 
+// Phase 0-5 spike marker (SessionStart の spike-inject.flag とは別)
+const PROMPT_SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-prompt.flag');
+const PROMPT_SPIKE_STATE_DIR = join(homedir(), '.throughline', 'spike-prompt-state');
+
 function logBaton(entry) {
   const path = join(homedir(), '.throughline', 'logs', 'baton-write.log');
   try {
@@ -37,6 +48,56 @@ function logBaton(entry) {
   }
 }
 
+function logPromptSpike(entry) {
+  const path = join(homedir(), '.throughline', 'logs', 'prompt-spike.log');
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(entry) + '\n', 'utf8');
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[prompt-submit:spike-log] ${msg}\n`);
+  }
+}
+
+/**
+ * transcript_path の末尾 3 行を読み、各行の type / uuid / parentUuid を返す。
+ * 診断ログ用 (chain (b) が CC に効いたかを後で検証するための context)。
+ */
+function readTailLineSummary(targetJsonlPath, n = 3) {
+  if (!existsSync(targetJsonlPath)) return null;
+  try {
+    const text = readFileSync(targetJsonlPath, 'utf8');
+    const lines = text.split('\n').filter((l) => l.trim());
+    const tail = lines.slice(-n);
+    return tail.map((l) => {
+      try {
+        const o = JSON.parse(l);
+        const sub = o.type === 'attachment'
+          ? `attachment.${o.attachment?.type ?? '?'}`
+          : (o.type ?? 'n/a');
+        return { type: sub, uuid: o.uuid ?? null, parentUuid: o.parentUuid ?? null };
+      } catch {
+        return { type: 'parse-error', uuid: null, parentUuid: null };
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Phase 0-5 spike を当該セッションで既に打ったかを判定する。
+ * per-session marker file `~/.throughline/spike-prompt-state/<session_id>` の存在で判定。
+ */
+function alreadySpiked(sessionId) {
+  return existsSync(join(PROMPT_SPIKE_STATE_DIR, sessionId));
+}
+
+function markSpiked(sessionId) {
+  mkdirSync(PROMPT_SPIKE_STATE_DIR, { recursive: true });
+  writeFileSync(join(PROMPT_SPIKE_STATE_DIR, sessionId), '', 'utf8');
+}
+
 /**
  * プロンプトが /tl バトン発動コマンドか判定する。
  * 許容: "/tl", "/tl\n", "/tl 何か" (前後空白は trim 済み前提)
@@ -87,6 +148,13 @@ export async function run() {
   const tlMatch = isBatonCommand(prompt);
   const clearMatch = !tlMatch && isClearCommand(prompt);
 
+  // Phase 0-5 spike: real user prompt (not /tl, not /clear) で、marker file あり、
+  // session 未 spike なら chain (b) で JSONL に inject する。失敗しても prompt 自体は
+  // そのまま Claude に流す。
+  if (!tlMatch && !clearMatch && session_id && existsSync(PROMPT_SPIKE_MARKER_PATH)) {
+    await maybeRunPromptSpike({ payload, sessionId: session_id, projectPath: cwd ?? process.cwd() });
+  }
+
   if (!tlMatch && !clearMatch) {
     process.exit(0);
     return;
@@ -114,6 +182,65 @@ export async function run() {
   process.exit(0);
 }
 
+/**
+ * Phase 0-5 spike を本セッションでまだ打っていなければ inject する。
+ * idempotency: per-session marker `~/.throughline/spike-prompt-state/<session_id>`。
+ *
+ * 失敗は stderr に出して continue。本 hook の主目的 (baton / tasks.json) を阻害しない。
+ */
+async function maybeRunPromptSpike({ payload, sessionId, projectPath }) {
+  const transcriptPath = payload.transcript_path ?? null;
+  if (!transcriptPath) {
+    logPromptSpike({
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      skip_reason: 'no_transcript_path_in_payload',
+    });
+    return;
+  }
+  if (alreadySpiked(sessionId)) {
+    return; // 静かに skip (1 session 1 回限定)
+  }
+  try {
+    const { spikeInject, generateSpikeTracer } = await import('./spike-transcript-writer.mjs');
+    const { getDb } = await import('./db.mjs');
+    const db = getDb();
+    const tracer = generateSpikeTracer();
+    const tailBefore = readTailLineSummary(transcriptPath);
+    const result = spikeInject({
+      db,
+      targetJsonlPath: transcriptPath,
+      newSessionId: sessionId,
+      cwd: projectPath,
+      version: payload.version ?? '2.1.145',
+      gitBranch: payload.gitBranch ?? 'main',
+      tracer,
+    });
+    logPromptSpike({
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      transcript_path: transcriptPath,
+      tracer: result.tracer,
+      parent_uuid_start: result.parentUuidStart,
+      appended: result.appended,
+      tracer_appended_at: result.tracerAppendedAt,
+      skip_reason: result.skipReason ?? null,
+      tail_before: tailBefore,
+    });
+    if (result.appended > 0) {
+      markSpiked(sessionId);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[prompt-spike] ${msg}\n`);
+    logPromptSpike({
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      error: msg,
+    });
+  }
+}
+
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   run().catch((err) => {
     const msg = err instanceof Error ? err.message : 'unknown';

package/src/resume-context.mjs

@@ -5,8 +5,11 @@
  *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
  * 設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
- *   - 注入順: ヘッダ + 読み方 → L1 要約 → L2 本文（一番下）
- *   - 直前の発話に Claude の attention が向くよう、L2 を末尾に置く
+ *   - 注入順: ヘッダ + 読み方 → 現在地アンカー → L1 要約 → L2 本文（一番下）
+ *   - 「現在地」アンカーは直前の user / assistant turn をヘッダ直下に再掲して
+ *     最初の注意を最新ターンに固定する。L2 末尾アンカーは補強として残す。
+ *     （L2 が長くなると末尾アンカーだけでは前半の古いターンに注意が固着し、
+ *      話の流れを取り違える事例があった）
  *   - L3 は別セクションを設けず、対応する L1 / L2 行にインラインで
  *     `[→ throughline detail HH:MM:SS (kind …)]` ヒントを付ける
  *   - L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が
@@ -22,15 +25,63 @@ import { buildHandoffRecord } from './handoff-record.mjs';
 import { groupL3ByTurn, buildPartsSummary } from './l3-summary.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
-  `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
+  `## Throughline: 直前スレッドの継続応答用コンテキスト（${turnCount} ターン分の文脈を保持）\n` +
   `\n` +
-  `**読み方:**\n` +
-  `- 直前の対話の自然な続きとして応答してください。\n` +
-  '- **各ターンの詳細の取得方法**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
+  `**応答の冒頭で必ず以下を 1 行宣言してください** (会話の継続性をユーザーに見せるため):\n` +
+  `> 「Throughline で前のセッションから ${turnCount} ターン分の記憶を引き継いだ状態で続けます」\n` +
+  `\n` +
+  `**読み方 (重要):**\n` +
+  `- 下記「現在地」「L1」「L2」は **あなた自身が直前にユーザーと交わした会話** です ` +
+  `(画面が /clear されただけで、同じスレッドが継続しています)。\n` +
+  `- ユーザーの次のメッセージは新規依頼ではなく、上記スレッドの **続き** です。\n` +
+  `- 「続きよろしく」「OK」「次は？」のような短いメッセージは、**「現在地」の「直前のアシスタント」` +
+  `が示した次の一手をそのまま実行** してください。\n` +
+  `- **短文/相槌の判定**: 50 字以下、または「はい」「うん」「了解」「OK」「やって」「進めて」「続き」` +
+  `「次」のような相槌/同意/促し語だけで構成されているメッセージは、新しい依頼ではなく ` +
+  `**直前のアシスタントの提案に対する GO サイン** として扱ってください。\n` +
+  `- 短文を受けたら **やってはいけないこと**: 「何の話ですか?」と聞き返す / 改めて選択肢を提示しなおす / ` +
+  `直前のアシスタントが示した次の一手を無視して別の作業を始める。\n` +
+  `- **古い番号リストの再実行禁止**: 過去ターンで提示した番号付き選択肢 (例: 1/2/3) を最新ユーザーが ` +
+  `「2 をやれ」のように参照した場合、その項目が既に直前アシスタントターンで実装/実行済みなら、` +
+  `再実行ではなく **結果確認・次の一手** として応答してください ` +
+  `(最新アシスタント発話の指示が、過去ターンのリストへの参照より上位)。\n` +
+  `- 「何のことですか？」「初めまして」「何を確認したいですか?」と返すのは適切ではありません ` +
+  `(新規会話ではない)。\n` +
+  '- **各ターンの詳細**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
   `(該当ターンの本文＋詳細を stdout に返します)`;
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
+// 現在地アンカーは最新 user / assistant 本文を再掲する。長すぎると注入全体が膨らむので
+// この文字数で打ち切り、全文は L2 セクション側を参照させる。
+const ANCHOR_MAX_CHARS = 600;
+
+function truncateForAnchor(text) {
+  const normalized = text.replace(/\n+/g, ' ').trim();
+  if (normalized.length <= ANCHOR_MAX_CHARS) return normalized;
+  return normalized.slice(0, ANCHOR_MAX_CHARS) + ' …';
+}
+
+/**
+ * recentBodies (古い順) から「直前のやりとり」アンカー用に
+ * 最新の user / assistant 行をそれぞれ 1 件ずつ拾う。
+ */
+function pickLatestExchange(recentBodies) {
+  let latestUser = null;
+  let latestAssistant = null;
+  for (let i = recentBodies.length - 1; i >= 0; i -= 1) {
+    const r = recentBodies[i];
+    if (!r.text) continue;
+    if (r.role === 'assistant' && !latestAssistant) {
+      latestAssistant = r;
+    } else if (r.role === 'user' && !latestUser) {
+      latestUser = r;
+    }
+    if (latestUser && latestAssistant) break;
+  }
+  return { latestUser, latestAssistant };
+}
+
 /**
  * L1 + L2 注入テキストを組み立てる。L3 は本文ではなく
  * 各 L1 / L2 行末尾の inline hint として付与する。
@@ -61,6 +112,28 @@ export function buildResumeContext(
 
   const l3ByTurn = groupL3ByTurn(record.references.l3);
 
+  // 現在地アンカー: 引き継ぎ時のみ、最新 user / assistant turn をヘッダ直下に再掲する。
+  // L2 末尾アンカーだけだと、長い L2 で注意が前半に固着して話の流れを取り違える事例があった。
+  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)}`,
+      );
+    }
+    if (latestAssistant) {
+      anchorLines.push(
+        `**直前のアシスタント** [${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) {