throughline 0.4.12 → 0.6.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,391 @@ test('process-turn subprocess stores L2 bodies and L3 details in an isolated DB'
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test('process-turn subprocess backfills all completed logical turns from a multi-turn JSONL', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const transcriptPath = join(project, 'transcript.jsonl');
+  try {
+    writeFileSync(
+      transcriptPath,
+      [
+        { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'first request' }] } },
+        { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'first answer' }] } },
+        { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'second request' }] } },
+        { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'second answer' }] } },
+      ].map((entry) => JSON.stringify(entry)).join('\n'),
+      'utf8',
+    );
+    const result = runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: 'multi-turn-session', cwd: project, transcript_path: transcriptPath }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const db = openDb(home);
+    assert.deepEqual(
+      db.prepare('SELECT role, text FROM bodies ORDER BY turn_number, role').all().map((row) => ({ ...row })),
+      [
+        { role: 'assistant', text: 'first answer' },
+        { role: 'user', text: 'first request' },
+        { role: 'assistant', text: 'second answer' },
+        { role: 'user', text: 'second request' },
+      ],
+    );
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('session-start backfills a derived predecessor transcript without a state file', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const predecessorId = 'missing-stop-predecessor';
+  const derivedPath = join(
+    home,
+    '.claude',
+    'projects',
+    `-${project.replace(/[/.]/g, '-').replace(/^-+/, '')}`,
+    `${predecessorId}.jsonl`,
+  );
+  try {
+    mkdirSync(dirname(derivedPath), { recursive: true });
+    writeFileSync(
+      derivedPath,
+      [
+        { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'predecessor question' }] } },
+        { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'predecessor answer' }] } },
+      ].map((entry) => JSON.stringify(entry)).join('\n'),
+      'utf8',
+    );
+    const baton = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: predecessorId, cwd: project, prompt: '/clear' }),
+    });
+    assert.equal(baton.status, 0, baton.stderr);
+    const db = openDb(home);
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES (?, ?, 'active', 1, 1)`,
+    ).run(predecessorId, project);
+    db.close();
+
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: 'new-session', cwd: project, source: 'startup' }),
+    });
+    assert.equal(started.status, 0, started.stderr);
+    const after = openDb(home);
+    assert.deepEqual(
+      after
+        .prepare('SELECT session_id, origin_session_id, role, text FROM bodies ORDER BY turn_number, role')
+        .all()
+        .map((row) => ({ ...row })),
+      [
+        { session_id: 'new-session', origin_session_id: predecessorId, role: 'assistant', text: 'predecessor answer' },
+        { session_id: 'new-session', origin_session_id: predecessorId, role: 'user', text: 'predecessor question' },
+      ],
+    );
+    after.close();
+    const backfillLog = readFileSync(join(home, '.throughline', 'logs', 'backfill.log'), 'utf8')
+      .split('\n')
+      .filter((line) => line)
+      .map((line) => JSON.parse(line));
+    assert.ok(backfillLog.some((entry) => entry.hook === 'session-start'));
+    assert.equal(existsSync(join(home, '.throughline', 'state', `${predecessorId}.json`)), false);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    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/package-files.test.mjs

@@ -12,6 +12,7 @@ test('npm package files include Claude and Codex agent surfaces', () => {
     '.claude/commands/',
     '.codex-sidecar.yml',
     'docs/',
+    'rag/',
     'CHANGELOG.md',
     'README.md',
     'LICENSE',

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,19 +13,30 @@
  *      VSCode ウィンドウ等で「最新更新セッション = clear されたセッション」が
  *      成立しない multi-window シナリオで誤った前任を選ばないための確定的指名)
  *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
- *   - 本 hook は注入を一切行わない (SessionStart の引き継ぎ注入と二重にならないため)
+ *   - 本 hook は引き継ぎ注入を行わない (SessionStart の stdout 注入と二重にならないため)
  *
- * 設計背景: docs/INHERITANCE_ON_CLEAR_ONLY.md バトン方式
+ *   - **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/10_transcript_injection_plan.md Phase 0-5 参照。
+ *
+ * 設計背景: docs/03_inheritance_on_clear_only.md バトン方式
  */
 
 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

@@ -4,7 +4,7 @@
  * 呼び出し元:
  *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
- * 設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
+ * 設計 (docs/02_clear_auto_handoff_plan.md):
  *   - 注入順: ヘッダ + 読み方 → 現在地アンカー → L1 要約 → L2 本文（一番下）
  *   - 「現在地」アンカーは直前の user / assistant turn をヘッダ直下に再掲して
  *     最初の注意を最新ターンに固定する。L2 末尾アンカーは補強として残す。
@@ -25,12 +25,29 @@ 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` +
-  `- **下の「現在地」が直前のやりとりです。まずここで最新の状態と次の一手を把握してから L1/L2 を読んでください。**\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: セッション記憶';

package/src/resume-context.test.mjs

@@ -93,7 +93,9 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   });
 
   assert.ok(text);
-  assert.match(text, /^## Throughline: 中断した作業の再開/);
+  // A 経路: 「直前スレッドの継続応答用コンテキスト」 framing (元の「中断した作業の再開」よりも
+  // 強い directive。モデルが /clear 後の短い prompt を新規依頼として扱うのを抑止する目的)
+  assert.match(text, /^## Throughline: 直前スレッドの継続応答用コンテキスト/);
 
   // 旧版の冗長な行は全部削除
   assert.ok(!text.includes('と報告してください'), 'meta-report instruction must be gone');
@@ -101,13 +103,27 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   assert.ok(!text.includes('内訳の読み方'), 'glossary block must be gone');
   assert.ok(!text.includes('現在進行中の作業の active work context'), 'verbose framing must be gone');
 
-  // 残るのは 3 行: 現在地参照案内 + 自然な続き + Bash 呼び出し方法
-  assert.match(text, /下の「現在地」が直前のやりとりです/);
-  assert.match(text, /直前の対話の自然な続きとして応答してください/);
+  // A 経路の必須シグナル: 「あなた自身が直前にユーザーと交わした会話」 + 「新規依頼ではなく続き」
+  // + 短い指示の扱い + 「新規会話ではない」明示
+  assert.match(text, /あなた自身が直前にユーザーと交わした会話/);
+  assert.match(text, /新規依頼ではなく、上記スレッドの \*\*続き\*\*/);
+  assert.match(text, /続きよろしく.*OK.*次は？/s);
+  assert.match(text, /新規会話ではない/);
+  // β 経路 (early-style explicit report-back instruction): モデルが冒頭で
+  // 「引き継いだ状態で続けます」と明示的に表明することで、user が体感する継続感を強める
+  assert.match(text, /応答の冒頭で必ず以下を 1 行宣言/);
+  assert.match(text, /Throughline で前のセッションから .* ターン分の記憶を引き継いだ状態で続けます/);
   assert.match(
     text,
-    /\*\*各ターンの詳細の取得方法\*\*: \*\*`Bash` ツールで `throughline detail HH:MM:SS` を実行\*\* \(該当ターンの本文＋詳細を stdout に返します\)/,
+    /\*\*各ターンの詳細\*\*: \*\*`Bash` ツールで `throughline detail HH:MM:SS` を実行\*\* \(該当ターンの本文＋詳細を stdout に返します\)/,
   );
+
+  // v2.1: 古い番号リスト (1/2/3) を最新ユーザーが「2 をやれ」のように参照しても、
+  // 直前アシスタントで既に実行済みなら再実行ではなく結果確認に回るというガード。
+  // (このセッションで実際にハマった misread の再発防止)
+  assert.match(text, /古い番号リストの再実行禁止/);
+  assert.match(text, /既に直前アシスタントターンで実装\/実行済み/);
+  assert.match(text, /最新アシスタント発話の指示が、過去ターンのリストへの参照より上位/);
 });
 
 test('buildResumeContext: 現在地 anchor surfaces the latest user/assistant exchange above L1/L2', () => {