throughline 0.6.3 → 0.8.0

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,226 @@ 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 keeps all L2 turns, no L1 section, guidance always present', () => {
+  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 budgeted = buildBudgetedResumeContext(db, { sessionId: 'new', isInheritance: true });
+
+  assert.ok(budgeted);
+  assert.equal(budgeted.injectedL2Turns, 1);
+  assert.equal(budgeted.remainingL2Turns, 0);
+  assert.equal(budgeted.olderTurns, 0);
+  assert.equal(budgeted.truncatedNewestL2, false);
+  assert.ok(budgeted.totalChars <= INJECTION_BUDGET_CHARS);
+  // 案内セクションは無条件表示 (データ無し側も「なし」と明示)
+  assert.ok(budgeted.text.includes('### さらに前の記憶（必要な時だけ取得）'));
+  assert.match(budgeted.text, /これより前の続き: なし/);
+  assert.match(budgeted.text, /それ以前のターン: なし/);
+  // L1 セクションは注入しない
+  assert.ok(!budgeted.text.includes('### それ以前の要約 (L1)'));
+});
+
+test('budgeted: packs whole turns newest-first, bakes --before/--last/--session into guidance', () => {
+  const db = makeDb();
+  // 各 ~800 字 × 10 ターン = 本文だけで ~8,000 字 → maxChars 5000 で古いターンが落ちる
+  for (let turn = 1; turn <= 10; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'user',
+      text: `q-${String(turn).padStart(2, '0')} question`,
+      createdAt: 1000 + turn * 100,
+    });
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: `turn-${String(turn).padStart(2, '0')} ` + 'x'.repeat(800),
+      createdAt: 1050 + turn * 100,
+    });
+  }
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 5000,
+  });
+
+  assert.ok(budgeted);
+  assert.ok(budgeted.totalChars <= 5000, `totalChars ${budgeted.totalChars} must fit budget`);
+  assert.ok(budgeted.injectedL2Turns > 0, 'newest turns must be injected');
+  assert.ok(budgeted.remainingL2Turns > 0, 'some old turns must be left for pull');
+  assert.equal(budgeted.injectedL2Turns + budgeted.remainingL2Turns, 10);
+  assert.ok(budgeted.text.includes('turn-10'), 'newest L2 turn must survive');
+  assert.ok(!budgeted.text.includes('turn-01 '), 'oldest L2 turn must be left for pull');
+
+  // ターン原子性: 注入されたターンは user 行と assistant 行が揃っている
+  const oldestInjectedTurn = 10 - budgeted.injectedL2Turns + 1;
+  const tag = String(oldestInjectedTurn).padStart(2, '0');
+  assert.ok(budgeted.text.includes(`q-${tag} question`), 'user row of injected turn must be present');
+  assert.ok(budgeted.text.includes(`turn-${tag} `), 'assistant row of injected turn must be present');
+
+  // 案内: --before は実注入最古ターンの min(created_at) の ISO ms、--last は残り件数
+  const boundaryMs = 1000 + oldestInjectedTurn * 100; // 最古注入ターンの user 行時刻
+  const iso = new Date(boundaryMs).toISOString().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  assert.match(
+    budgeted.text,
+    new RegExp(
+      `これより前の続き${budgeted.remainingL2Turns}ターン .*` +
+        '`throughline recall --l2 --session new ' +
+        `--before ${iso} --last ${budgeted.remainingL2Turns}\``,
+    ),
+    'guidance must bake session, ISO ms boundary, and remaining count',
+  );
+  // 全 10 ターンとも窓内なので、窓より古い側は正直に「なし」と明示される
+  assert.match(budgeted.text, /それ以前のターン: なし/);
+});
+
+test('budgeted: --l1 guidance bakes the same boundary and the --l2 skip count', () => {
+  const db = makeDb();
+  // 窓 (20) + 窓外 5 ターン。予算を絞って窓内にも pull 残りを作る
+  for (let turn = 1; turn <= 25; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: `turn-${String(turn).padStart(2, '0')} ` + 'x'.repeat(700),
+      createdAt: 1000 + turn * 100,
+    });
+  }
+
+  const budgeted = buildBudgetedResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    maxChars: 4000,
+  });
+
+  assert.ok(budgeted);
+  assert.ok(budgeted.remainingL2Turns > 0);
+  assert.equal(budgeted.olderTurns, 5);
+  const oldestInjectedTurn = 25 - budgeted.injectedL2Turns + 1;
+  const boundaryMs = 1000 + oldestInjectedTurn * 100;
+  const iso = new Date(boundaryMs).toISOString().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  assert.match(
+    budgeted.text,
+    new RegExp(`--l2 --session new --before ${iso} --last ${budgeted.remainingL2Turns}`),
+  );
+  assert.match(
+    budgeted.text,
+    new RegExp(`--l1 --session new --before ${iso} --skip ${budgeted.remainingL2Turns}`),
+    '--l1 guidance must bake the same boundary and skip count',
+  );
+});
+
+test('budgeted: window turns beyond budget never fall into a blank band (guidance covers them)', () => {
+  const db = makeDb();
+  // 40 ターン: 窓は最新 20 ターン、そこからさらに予算落ちが出る構成
+  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);
+  // 窓 20 ターンのうち注入できなかった分は全部 recall --l2 の担当として案内される
+  assert.equal(budgeted.injectedL2Turns + budgeted.remainingL2Turns, 20);
+  // 窓より古い 20 ターンは --l1 側 (未要約でも件数として見える)
+  assert.equal(budgeted.olderTurns, 20);
+  assert.match(budgeted.text, /それ以前の全20ターン（要約済み 0 \/ 未要約 20）/);
+});
+
+test('budgeted: older summarized/unsummarized counts are honest in the guidance', () => {
+  const db = makeDb();
+  for (let turn = 1; turn <= 25; turn += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn,
+      role: 'assistant',
+      text: `turn-${turn}`,
+      createdAt: 1000 + turn * 1000,
+    });
+  }
+  // 窓 (最新 20 ターン = turn 6..25) より古い turn 1..5 のうち 2 件だけ要約済み
+  insertSkeleton(db, { session: 'new', origin: 'old', turn: 1, role: 'assistant', summary: 's1', createdAt: 90_000 });
+  insertSkeleton(db, { session: 'new', origin: 'old', turn: 2, role: 'assistant', summary: 's2', createdAt: 90_001 });
+
+  const budgeted = buildBudgetedResumeContext(db, { sessionId: 'new', isInheritance: true });
+
+  assert.ok(budgeted);
+  assert.equal(budgeted.olderTurns, 5);
+  assert.equal(budgeted.olderSummarized, 2);
+  assert.match(budgeted.text, /それ以前の全5ターン（要約済み 2 \/ 未要約 3）/);
+});
+
+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('### 現在地 (直前のやりとり)'));
+});

package/src/runtime-error-store.mjs

@@ -25,7 +25,8 @@ export const RUNTIME_ERROR_DIAGNOSTIC = '[throughline:runtime-errors] store_unav
 const DEFAULT_SNAPSHOT_LIMIT = 256;
 const BEST_EFFORT_TIMEOUT_MS = 750;
 const WINDOWS_BEST_EFFORT_TIMEOUT_MS = 5_000;
-const WINDOWS_ACL_TIMEOUT_MS = 3_000;
+// CI実測でPowerShellコールドスタートが3.0〜3.2秒に達しflakeしたため15秒 (run 29586852389 / 29628634501)
+const WINDOWS_ACL_TIMEOUT_MS = 15_000;
 const RESOLUTION_REASONS = new Set(['manual', 'recovered']);
 const PRIVATE_DIRECTORY_CAPABILITY = Symbol('throughline.private-directory');
 

package/src/runtime-error-store.test.mjs

@@ -101,7 +101,7 @@ test('runtime error store: one Windows mutation spends ACL processes only on dis
 
   assert.equal(observeRuntimeError({ code: 'HOOK_CODEX_FAILED' }, options).status, 'recorded');
   assert.equal(calls.length, 4, 'directory apply, existing lock/store verify, and replacement store apply are distinct');
-  assert.ok(calls.every((call) => call.options.timeout === 3_000));
+  assert.ok(calls.every((call) => call.options.timeout === 15_000));
 });
 
 test('runtime error store: Windows temporary ACL failure leaves the previous atomic store intact', (t) => {

package/src/session-start.mjs

@@ -1,65 +1,38 @@
 #!/usr/bin/env node
 /**
- * SessionStart hook — セッション登録 + 引き継ぎ判定 + 注入
+ * SessionStart hook — セッション登録 + 引き継ぎ intent 登録（二相ハンドオフの第一相）
  *
  * stdin: { session_id, source, cwd, transcript_path, hook_event_name }
  *
- * 【引き継ぎ条件 (2 経路)】 docs/02_clear_auto_handoff_plan.md
+ * 【二相ハンドオフ】 ADR 0014 / docs/02_clear_auto_handoff_plan.md
  *
- *   1. baton path: ユーザーが旧セッションで `/tl` を打つと UserPromptSubmit hook が
- *      handoff_batons に session_id を書く。本 hook が TTL 1 時間以内に消費して
- *      前任を merge + 引継ぎ stdout 注入。`source` 値関係なく発火。
- *   2. auto path: `source='clear'` かつ env `THROUGHLINE_DISABLE_AUTO_HANDOFF` が
- *      `'1'` でない場合、同 project_path の最新 Claude unmerged session を
- *      自動 merge して注入。
+ *   Claude Code は同一 project_path に対し短時間 (実測 315–488ms) に複数の
+ *   SessionStart を発火させることがあり、一部は transcript を一度も生成しない
+ *   幽霊セッションになる。SessionStart 時点では実体と幽霊を判別できない
+ *   （transcript は本物でも hook より数百 ms 遅れて作られる）ため、
+ *   この hook では merge も注入も行わない:
  *
- *   両方同時成立はしない (consumeBaton が先発、baton ありなら baton path、
- *   なければ source 判定)。env で OFF にしたユーザーは `/tl` を打ってから
- *   新セッションスタートで baton path を使う。
- *
- * 役割:
  *   1. sessions テーブルに新セッションを INSERT OR IGNORE
- *   2. baton path 判定 (consumeBaton + mergeSpecificPredecessor)
- *   3. baton 無し かつ source='clear' かつ env disable 無し → auto path 判定
- *   4. 合流成立なら curated memory (L1+L2+L3 refs) を「引き継ぎヘッダ」付きで stdout 注入
- *   5. 判定結果を ~/.throughline/logs/inheritance-decision.log に記録
+ *   2. auto path (source='clear' かつ env THROUGHLINE_DISABLE_AUTO_HANDOFF != '1')
+ *      なら前任candidateをこの時点で解決して凍結（transcript 実在フィルタ付き —
+ *      幽霊 twin を前任に選ばない）
+ *   3. registerPendingHandoff で intent を登録
+ *   4. 判定を ~/.throughline/logs/inheritance-decision.log に記録 (phase='session-start')
+ *
+ *   バトンの消費・merge・注入は最初の UserPromptSubmit (= 実体の証明) で行う。
+ *   幽霊はプロンプトを発火しないため記憶を奪えない。
  */
 
 import { getDb } from './db.mjs';
-import { consumeBaton } from './baton.mjs';
-import { mergeSpecificPredecessor, resolveMergeTarget } from './session-merger.mjs';
-import { backfillBodies, deriveTranscriptPath, logBackfill } from './turn-backfill.mjs';
-import { buildResumeContext } from './resume-context.mjs';
+import { registerPendingHandoff } from './pending-handoff.mjs';
+import { deriveTranscriptPath } from './turn-backfill.mjs';
 import { readAllSessionStates } from './state-file.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
-import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
-import { randomBytes } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
+import { logDecision } from './decision-log.mjs';
+import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 
-// SPIKE ONLY — Phase 0-2 / 0-4 検証用。marker file 削除で無効化される。
-// docs/10_transcript_injection_plan.md §3 Phase 0-2 参照。
-const SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-inject.flag');
-
-// Phase 0-6: initialUserMessage が interactive モードで効くか実機検証する experimental switch。
-// flag 存在時、SessionStart hook は plain stdout の代わりに JSON 出力に切り替わり、
-// hookSpecificOutput.initialUserMessage に tracer 入りメッセージを乗せる。
-// openclaude の OSS 実装では「headless 専用」と記載されているが、real CC の挙動は未確認。
-const INITIAL_USER_MESSAGE_TEST_FLAG = join(homedir(), '.throughline', 'initial-user-message-test.flag');
-
-function logInitialUserMessageTest(entry) {
-  const path = join(homedir(), '.throughline', 'logs', 'initial-user-message-test.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(`[session-start:initialUserMessage-test-log] ${msg}\n`);
-  }
-}
-
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
 function isAutoHandoffDisabled(env) {
@@ -67,8 +40,13 @@ function isAutoHandoffDisabled(env) {
 }
 
 /**
- * 同 project_path の最新 Claude unmerged session を返す (auto path 用 predecessor)。
- * Codex session (`codex:*`) と現セッション自身は除外。
+ * 同 project_path の最新 Claude unmerged session から、transcript が実在する
+ * 最初の candidate を返す (auto path 用 predecessor)。
+ *
+ * transcript 実在フィルタの理由 (ADR 0014): /clear の二重 SessionStart では
+ * 幽霊 twin も sessions 行を持ち、updated_at が最新になるため、フィルタ無しだと
+ * 幽霊を前任に選んで実前任を取りこぼす (2026-05 の auto path incident 群)。
+ * 実前任は /clear 前に活動していた実体なので transcript を必ず持つ。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {string} projectPath
@@ -76,30 +54,30 @@ function isAutoHandoffDisabled(env) {
  * @returns {{ session_id: string } | null}
  */
 function findLatestClaudePredecessor(db, projectPath, currentSessionId) {
-  return (
-    db
-      .prepare(
-        `SELECT session_id FROM sessions
-         WHERE lower(project_path) = lower(?)
-           AND merged_into IS NULL
-           AND session_id != ?
-           AND session_id NOT LIKE 'codex:%'
-         ORDER BY updated_at DESC
-         LIMIT 1`,
-      )
-      .get(projectPath, currentSessionId) ?? null
-  );
-}
-
-function logDecision(entry) {
-  const path = join(homedir(), '.throughline', 'logs', 'inheritance-decision.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(`[session-start:decision-log] ${msg}\n`);
+  const candidates = db
+    .prepare(
+      `SELECT session_id FROM sessions
+       WHERE lower(project_path) = lower(?)
+         AND merged_into IS NULL
+         AND session_id != ?
+         AND session_id NOT LIKE 'codex:%'
+       ORDER BY updated_at DESC
+       LIMIT 5`,
+    )
+    .all(projectPath, currentSessionId);
+
+  if (candidates.length === 0) return null;
+
+  const states = readAllSessionStates();
+  for (const row of candidates) {
+    const derived = deriveTranscriptPath(projectPath, row.session_id);
+    if (existsSync(derived)) return row;
+    const stateTranscriptPath = states.find(
+      (state) => state.sessionId === row.session_id,
+    )?.transcriptPath;
+    if (stateTranscriptPath && existsSync(stateTranscriptPath)) return row;
   }
+  return null;
 }
 
 export async function run() {
@@ -135,183 +113,42 @@ export async function run() {
      VALUES (?, ?, 'active', ?, ?)`,
   ).run(session_id, projectPath, now, now);
 
-  // 2. baton 消費
-  const baton = consumeBaton(db, { projectPath, now });
-
-  // 3. 引継ぎ判定
-  let mergeResult = { merged: false, skipReason: 'no_trigger' };
-  let triggeredPath = null;
+  // 2. auto path intent: source='clear' なら前任をこの時点で解決して凍結する。
+  //    初回プロンプトまでの間に他ウィンドウが動いても「/clear が意味した前任」がずれない。
   const autoDisabled = isAutoHandoffDisabled(process.env);
-
-  if (baton.sessionId) {
-    // baton path
-    triggeredPath = 'baton';
-    const { target: predecessorId } = resolveMergeTarget(db, baton.sessionId);
-    mergeResult = mergeSpecificPredecessor(db, {
-      newSessionId: session_id,
-      predecessorId,
-      now,
-    });
-  } else if (source === 'clear' && !autoDisabled) {
-    // auto path: 同 project の最新 Claude unmerged session を自動 predecessor にする
-    triggeredPath = 'auto';
+  let autoPredecessorId = null;
+  let intentNote = null;
+  if (source === 'clear' && autoDisabled) {
+    intentNote = 'auto_handoff_disabled';
+  } else if (source === 'clear') {
     const predRow = findLatestClaudePredecessor(db, projectPath, session_id);
     if (predRow?.session_id) {
-      const { target: predecessorId } = resolveMergeTarget(db, predRow.session_id);
-      mergeResult = mergeSpecificPredecessor(db, {
-        newSessionId: session_id,
-        predecessorId,
-        now,
-      });
-    } else {
-      mergeResult = { merged: false, skipReason: 'no_predecessor' };
-    }
-  } else if (source === 'clear' && autoDisabled) {
-    triggeredPath = 'auto-disabled';
-    mergeResult = { merged: false, skipReason: 'auto_handoff_disabled' };
-  }
-
-  // 4. 合流成立なら curated memory を stdout 注入 (L1 + L2 + L3 refs)
-  //    順序厳守: stdout flush を先に完了させてから spike 分岐へ進む。
-  //    spike が throw しても stdout は既に attachment に保存されている。
-  //
-  //    Phase 0-6: initialUserMessage test flag 存在時は JSON 出力に切り替え、
-  //    initialUserMessage が interactive モードで messages[] に乗るか実機検証する。
-  if (mergeResult.merged) {
-    const predecessorId = mergeResult.predecessorId;
-    // /clear 直前ターンの取りこぼしを注入前に回収する。前任の transcript path は project path
-    // から決定的に導出する — state ファイルは Stop 不発の前任（まさに回収したい事例）では存在しないため補助。
-    const derivedTranscriptPath = deriveTranscriptPath(projectPath, predecessorId);
-    const stateTranscriptPath = readAllSessionStates().find(
-      (state) => state.sessionId === predecessorId,
-    )?.transcriptPath;
-    const predecessorTranscriptPath = existsSync(derivedTranscriptPath)
-      ? derivedTranscriptPath
-      : stateTranscriptPath && existsSync(stateTranscriptPath)
-        ? stateTranscriptPath
-        : null;
-
-    if (predecessorTranscriptPath) {
-      try {
-        const backfill = backfillBodies(db, {
-          targetSessionId: session_id,
-          originSessionId: predecessorId,
-          transcriptPath: predecessorTranscriptPath,
-          now,
-        });
-        logBackfill({
-          ts: new Date(now).toISOString(),
-          hook: 'session-start',
-          session_id,
-          target: session_id,
-          origin: predecessorId,
-          transcript_path: predecessorTranscriptPath,
-          groups: backfill.groups,
-          inserted_turns: backfill.insertedTurns,
-          skipped_existing: backfill.skippedExisting,
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[session-start:backfill] ${message}\n`);
-        logBackfill({
-          ts: new Date(now).toISOString(),
-          hook: 'session-start',
-          session_id,
-          target: session_id,
-          origin: predecessorId,
-          transcript_path: predecessorTranscriptPath,
-          error: message,
-        });
-      }
+      autoPredecessorId = predRow.session_id;
     } else {
-      logBackfill({
-        ts: new Date(now).toISOString(),
-        hook: 'session-start',
-        session_id,
-        target: session_id,
-        origin: predecessorId,
-        transcript_path: null,
-        skip_reason: 'no_transcript_path',
-      });
-    }
-
-    const text = buildResumeContext(db, {
-      sessionId: session_id,
-      isInheritance: true,
-    });
-    if (existsSync(INITIAL_USER_MESSAGE_TEST_FLAG)) {
-      // TEST MODE: emit JSON with initialUserMessage tracer. Plain stdout は出さない
-      // (= 通常 Throughline 案内文無し)。テスト 1 回限定。flag を削除すれば即復帰。
-      const tracer = randomBytes(4).toString('hex');
-      const initialMessage =
-        `[initial-user-tracer: ${tracer}]\n\n` +
-        `This text is being delivered via the SessionStart hook's ` +
-        `hookSpecificOutput.initialUserMessage field. If you can quote the 8-hex ` +
-        `tracer above when asked, it means initialUserMessage IS consumed in ` +
-        `interactive mode (not headless-only as openclaude documents).`;
-      const jsonOutput = JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: 'SessionStart',
-          initialUserMessage: initialMessage,
-        },
-      });
-      process.stdout.write(jsonOutput + '\n');
-      logInitialUserMessageTest({
-        ts: new Date(now).toISOString(),
-        session_id,
-        tracer,
-        mode: 'json-initial-user-message-only',
-        had_resume_context: Boolean(text),
-      });
-    } else if (text) {
-      process.stdout.write(text + '\n');
+      intentNote = 'no_predecessor';
     }
   }
 
-  // 5. SPIKE: marker file あり + merge 成立 + transcript_path あり の 3 条件で
-  //    L2 を user/assistant role 付きで transcript_path にも append する。
-  //    本実装ではない (docs/10_transcript_injection_plan.md Phase 0-2)。
-  //
-  //    tracer: 末尾 assistant 行に stdout 注入には含まれない一意トークンを付与する。
-  //    次の /clear 後に Claude が tracer を再現できれば JSONL 経路はモデル可視。
-  let spikeResult = null;
-  const spikeMarkerExists = existsSync(SPIKE_MARKER_PATH);
-  if (spikeMarkerExists && mergeResult.merged && transcript_path) {
-    try {
-      const { spikeInject, generateSpikeTracer } = await import('./spike-transcript-writer.mjs');
-      const tracer = generateSpikeTracer();
-      spikeResult = spikeInject({
-        db,
-        targetJsonlPath: transcript_path,
-        newSessionId: session_id,
-        cwd: projectPath,
-        version: payload.version ?? '2.1.145',
-        gitBranch: payload.gitBranch ?? 'main',
-        tracer,
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : 'unknown';
-      process.stderr.write(`[spike-inject] ${msg}\n`);
-      spikeResult = { error: msg };
-    }
-  }
+  // 3. pending intent 登録。merge / 注入はしない (最初の UserPromptSubmit で実行)。
+  registerPendingHandoff(db, {
+    sessionId: session_id,
+    projectPath,
+    source: source ?? null,
+    autoPredecessorId,
+    now,
+  });
 
   logDecision({
     ts: new Date(now).toISOString(),
+    phase: 'session-start',
     source: source ?? null,
     session_id,
     project_path: projectPath,
     transcript_path: transcript_path ?? null,
-    triggered_path: triggeredPath,
     auto_handoff_disabled: autoDisabled,
-    baton_session_id: baton.sessionId ?? null,
-    baton_age_ms: baton.ageMs ?? null,
-    baton_skip_reason: baton.skipReason ?? null,
-    merged: mergeResult.merged,
-    merge_skip_reason: mergeResult.skipReason ?? null,
-    predecessor_id: mergeResult.predecessorId ?? null,
-    spike_marker_exists: spikeMarkerExists,
-    spike_result: spikeResult,
+    auto_predecessor_id: autoPredecessorId,
+    intent_note: intentNote,
+    pending_registered: true,
   });
 
   process.exit(0);

package/src/transcript-reader.mjs

@@ -141,6 +141,38 @@ export function getLogicalTurnGroups(transcriptPath) {
   return groups;
 }
 
+/**
+ * transcript上のlatest user groupが、現在どのassistant本文まで永続化されたかを返す。
+ * 過去のcompleted groupではなく最後のuser以後だけを見るため、同文answerの誤帰属を避ける。
+ *
+ * @param {string} transcriptPath
+ * @returns {{userTurnNumber: number, assistantTurnNumber: number|null, assistantContent: string|null}|null}
+ */
+export function readLatestLogicalTurnCompletion(transcriptPath) {
+  const turns = readTranscript(transcriptPath);
+  let latestUserIndex = -1;
+  for (let index = turns.length - 1; index >= 0; index--) {
+    if (turns[index].role === 'user') {
+      latestUserIndex = index;
+      break;
+    }
+  }
+  if (latestUserIndex < 0) return null;
+
+  const user = turns[latestUserIndex];
+  let representative = null;
+  for (let index = latestUserIndex + 1; index < turns.length; index++) {
+    const turn = turns[index];
+    if (turn.role === 'user') break;
+    if (turn.role === 'assistant' && !isJunkAssistantText(turn.content)) representative = turn;
+  }
+  return {
+    userTurnNumber: user.turn_number,
+    assistantTurnNumber: representative?.turn_number ?? null,
+    assistantContent: representative?.content ?? null,
+  };
+}
+
 /**
  * ANSI エスケープシーケンスを除去する。
  * ツール出力（特に Bash）にしばしば含まれる色コードを剥がす。