throughline 0.3.24 → 0.4.0

package/src/resume-context.mjs

@@ -1,226 +1,113 @@
 /**
- * resume-context.mjs — 中断地点からの再開注入テキストを組み立てる共有モジュール
+ * resume-context.mjs — 引継ぎ注入テキストを組み立てる共有モジュール
  *
  * 呼び出し元:
- *   - session-start.mjs (isInheritance=true, 引き継ぎヘッダ)
+ *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
- * 設計（schema v7 対応）:
- *   - 注入順: ヘッダ → [in-flight メモ] → [中断直前の思考] → L1 要約 → L2 本文 → フッタ
- *   - in-flight メモ: /tl 発動時に現行 Claude が書いた「次の一手 / 方針 / 未解決 / TODO」
- *   - 中断直前の思考: 最終ターンの assistant extended thinking (details kind='thinking')
+ * 設計 (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 永続）
- *   - 末尾に /sc-detail <時刻> ガイドを追記
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
- *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更 (B 案)
+ *   - フレーミング: 「過去の記憶」ではなく「現在進行中の作業」として読ませる
+ *     (Codex 側 renderCodexRolloutMemoryPreview の写像)
  */
 
-const N_RECENT_L2 = 20;
+import { buildHandoffRecord, formatTime, N_RECENT_L2 } from './handoff-record.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
   `\n` +
   `**前セッションで進行中だった作業を、この新セッションで引き継いでいます。以下が中断時点の状態です:**\n` +
-  `- 中断直前の in-flight メモ（前セッション末尾で Claude 自身が書いた「次の一手・方針・未解決・TODO」）\n` +
-  `- 中断直前の思考 (最終ターンの extended thinking)\n` +
   `- 直近 ${N_RECENT_L2} ターンの会話本文 (L2)\n` +
   `- それ以前の要約 (L1)\n` +
+  `- L3 (ツール入出力・思考) の参照一覧 (本文は別途取り出す)\n` +
   `\n` +
   `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
   `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
 
-const NORMAL_HEADER = '## Throughline: セッション記憶';
-
-const FOOTER_GUIDE =
-  '---\n' +
-  '**[Claude 向け — 記憶の使い方]**\n' +
-  '上の L1 要約や L2 本文を読んで「具体的なコマンドやツール出力、ファイル内容を確認したい」と感じたら、' +
-  '推測せずに **Bash ツールで `throughline detail <時刻>` を実行** して L3（ツール入出力・hook 出力・thinking）を取得してください。\n' +
-  '- 単一時刻: `throughline detail 14:23:05`\n' +
-  '- 時刻範囲: `throughline detail 14:23-14:30`\n' +
-  '\n' +
-  '返る内容: 指定ターンの L2 会話本文 + L3（tool_input / tool_output / system / thinking 別にグループ化）。\n' +
-  'ユーザーに「詳細を見せて」と言われた時だけでなく、**ユーザー発言の文脈が過去ターンに依存しているのに L1/L2 だけでは情報不足だと判断した時**に、Claude 自身の判断で呼び出して構いません。';
-
-/**
- * Unix ms を HH:MM:SS 形式に変換する。
- */
-function formatTime(unixMs) {
-  const d = new Date(unixMs);
-  const hh = String(d.getHours()).padStart(2, '0');
-  const mm = String(d.getMinutes()).padStart(2, '0');
-  const ss = String(d.getSeconds()).padStart(2, '0');
-  return `${hh}:${mm}:${ss}`;
-}
-
-/**
- * 最新ターン番号 (= 中断直前) の thinking ブロックを details から取り出す。
- * origin 除外がある場合はそれも考慮する。
- *
- * @param {import('node:sqlite').DatabaseSync} db
- * @param {string} sessionId
- * @param {string | null} excludeOriginId
- * @returns {Array<{ output_text: string, created_at: number }>}
- */
-function loadLatestThinking(db, sessionId, excludeOriginId) {
-  const hasExclude = Boolean(excludeOriginId);
+const ACTIVE_WORK_READING_CONTRACT =
+  `\n` +
+  `**読み方の契約:**\n` +
+  `- これは単なる過去ログではなく、現在進行中の作業を再開するための active work context です。\n` +
+  `- L2 は古い順に並んだ作業履歴です。後の発言・判断・TODO は前の仮説や作業方針を上書きし得ます。\n` +
+  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2 を優先して現在状態を推定してください。\n` +
+  `- 不足している tool output / 詳細根拠が必要なときだけ、L3 references の \`throughline detail <時刻>\` を使って取得してください。`;
 
-  // 最新 (origin_session_id, turn_number) を bodies から特定
-  const latestQuery = hasExclude
-    ? `SELECT origin_session_id, turn_number, created_at
-       FROM bodies
-       WHERE session_id = ? AND origin_session_id != ? AND role = 'assistant'
-       ORDER BY created_at DESC
-       LIMIT 1`
-    : `SELECT origin_session_id, turn_number, created_at
-       FROM bodies
-       WHERE session_id = ? AND role = 'assistant'
-       ORDER BY created_at DESC
-       LIMIT 1`;
+const CONTINUATION_REMINDER =
+  '**再開指示:** 上記の L1 / L2 を、現在タスクに使う作業コンテキストとして扱ってください。' +
+  '最新の L2 から次の一手を決め、中断地点から続行してください。' +
+  '古い仮説や未完了 TODO は、後続の判断で上書きされ得ます。';
 
-  let latest;
-  try {
-    latest = hasExclude
-      ? db.prepare(latestQuery).get(sessionId, excludeOriginId)
-      : db.prepare(latestQuery).get(sessionId);
-  } catch {
-    return [];
-  }
-  if (!latest) return [];
-
-  // その (origin_session_id, turn_number) に紐づく kind='thinking' を取り出す
-  try {
-    const rows = db
-      .prepare(
-        `SELECT output_text, created_at FROM details
-         WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND kind = 'thinking'
-         ORDER BY created_at ASC`,
-      )
-      .all(sessionId, latest.origin_session_id, latest.turn_number);
-    return rows.filter((r) => typeof r.output_text === 'string' && r.output_text.length > 0);
-  } catch {
-    return [];
-  }
-}
+const NORMAL_HEADER = '## Throughline: セッション記憶';
 
 /**
- * L1+L2 注入テキストを組み立てる。
+ * L1 + L2 + L3 references 注入テキストを組み立てる。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{
  *   sessionId: string,
  *   isInheritance: boolean,
  *   excludeOriginId?: string | null,
- *   inflightMemo?: string | null,
+ *   inflightMemo?: string | null,  // 互換のため受け取るが新仕様では使用しない
  * }} params
  * @returns {string | null}
  */
 export function buildResumeContext(
   db,
-  { sessionId, isInheritance, excludeOriginId = null, inflightMemo = null },
+  { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
 ) {
-  if (!sessionId) return null;
-
-  const hasExclude = Boolean(excludeOriginId);
-
-  const bodiesQuery = hasExclude
-    ? `SELECT origin_session_id, turn_number, role, text, created_at
-       FROM bodies
-       WHERE session_id = ? AND origin_session_id != ?
-       ORDER BY created_at DESC
-       LIMIT ?`
-    : `SELECT origin_session_id, turn_number, role, text, created_at
-       FROM bodies
-       WHERE session_id = ?
-       ORDER BY created_at DESC
-       LIMIT ?`;
-
-  const limitRows = N_RECENT_L2 * 2; // user/assistant の 2 ロール分
-
-  let bodyRowsDesc = [];
-  try {
-    bodyRowsDesc = hasExclude
-      ? db.prepare(bodiesQuery).all(sessionId, excludeOriginId, limitRows)
-      : db.prepare(bodiesQuery).all(sessionId, limitRows);
-  } catch {
-    // bodies テーブル未作成（v3 DB）の場合は空
-    bodyRowsDesc = [];
-  }
-  const bodyRows = bodyRowsDesc.reverse(); // ASC に戻す
-
-  // 古い側の L1（bodies に既に含まれるターンを除いたもの）
-  const bodySet = new Set(
-    bodyRows.map((r) => `${r.origin_session_id}\x00${r.turn_number}`),
-  );
-
-  const skelQuery = hasExclude
-    ? `SELECT origin_session_id, turn_number, role, summary, created_at
-       FROM skeletons
-       WHERE session_id = ? AND origin_session_id != ?
-       ORDER BY created_at ASC`
-    : `SELECT origin_session_id, turn_number, role, summary, created_at
-       FROM skeletons
-       WHERE session_id = ?
-       ORDER BY created_at ASC`;
-
-  const allSkel = hasExclude
-    ? db.prepare(skelQuery).all(sessionId, excludeOriginId)
-    : db.prepare(skelQuery).all(sessionId);
-
-  const l1Rows = allSkel.filter(
-    (s) => !bodySet.has(`${s.origin_session_id}\x00${s.turn_number}`),
-  );
-
-  const thinkingRows = loadLatestThinking(db, sessionId, excludeOriginId);
-
-  if (
-    bodyRows.length === 0 &&
-    l1Rows.length === 0 &&
-    thinkingRows.length === 0 &&
-    !inflightMemo
-  ) {
-    return null;
-  }
-
-  const turnCount = bodyRows.length + l1Rows.length;
-  const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
+  // handoff-record は Codex 側でも使うので signature 維持。inflightMemo / latestThinking は
+  // 新仕様の注入テキストには使わない (L2 全文で十分という判断)。
+  const record = buildHandoffRecord(db, {
+    sessionId,
+    isInheritance,
+    excludeOriginId,
+  });
+  if (!record) return null;
+
+  const turnCount = record.stats.preservedContextRows;
+  const header = isInheritance
+    ? RESUME_HEADER_TEMPLATE(turnCount) + ACTIVE_WORK_READING_CONTRACT
+    : NORMAL_HEADER;
   const lines = [header];
 
-  if (inflightMemo && inflightMemo.trim().length > 0) {
+  if (record.memory.l1Summaries.length > 0) {
     lines.push('');
-    lines.push('### 中断直前の in-flight メモ（前セッションの Claude 自身による要約）');
-    lines.push(inflightMemo.trim());
-  }
-
-  if (thinkingRows.length > 0) {
-    lines.push('');
-    lines.push('### 中断直前の思考 (最終ターンの extended thinking)');
-    for (const r of thinkingRows) {
-      lines.push(`[${formatTime(r.created_at)}] ${r.output_text}`);
+    lines.push('### それ以前の要約 (L1)');
+    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()}`);
     }
   }
 
-  if (l1Rows.length > 0) {
+  if (record.memory.recentBodies.length > 0) {
     lines.push('');
-    lines.push('### それ以前の要約 (L1)');
-    for (const r of l1Rows) {
-      if (!r.summary || r.summary === '(no content)') continue;
-      lines.push(`[${formatTime(r.created_at)}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
+    lines.push('### 現在進行中の作業履歴 (L2 / active work thread)');
+    lines.push('以下は古い順です。後の行ほど現在状態に近く、前の仮説を上書きし得ます。');
+    for (const r of record.memory.recentBodies) {
+      if (!r.text) continue;
+      lines.push(`[${r.time}] [${r.role}]: ${r.text}`);
     }
   }
 
-  if (bodyRows.length > 0) {
+  if (record.references.l3.length > 0) {
     lines.push('');
-    lines.push('### 直近のターン履歴 (L2)');
-    for (const r of bodyRows) {
-      if (!r.text) continue;
-      lines.push(`[${formatTime(r.created_at)}] [${r.role}]: ${r.text}`);
+    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}\``);
     }
   }
 
   lines.push('');
-  lines.push(FOOTER_GUIDE);
+  lines.push(CONTINUATION_REMINDER);
 
   return lines.join('\n');
 }

package/src/resume-context.test.mjs

@@ -0,0 +1,177 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { buildResumeContext } from './resume-context.mjs';
+
+function makeDb() {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE 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 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 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
+    );
+  `);
+  return db;
+}
+
+function insertSkeleton(db, row) {
+  db.prepare(
+    `INSERT INTO skeletons (session_id, origin_session_id, turn_number, role, summary, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(row.session, row.origin, row.turn, row.role, row.summary, row.createdAt);
+}
+
+function insertBody(db, row) {
+  db.prepare(
+    `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(row.session, row.origin, row.turn, row.role, row.text, 1, row.createdAt);
+}
+
+function insertThinking(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);
+}
+
+test('buildResumeContext: inheritance output order is L1 -> L2 -> L3 refs -> reminder (no memo / no thinking)', () => {
+  const db = makeDb();
+
+  insertSkeleton(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    summary: 'older L1 summary',
+    createdAt: 1000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    role: 'user',
+    text: 'recent user body',
+    createdAt: 2000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    role: 'assistant',
+    text: 'recent assistant body',
+    createdAt: 2100,
+  });
+  // thinking は DB に書かれても、新仕様では注入テキストに出ない
+  insertThinking(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    text: 'latest thinking block',
+    createdAt: 2200,
+    sourceId: 'asst:thinking:0',
+  });
+
+  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');
+
+  // 注入される順序: 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('**再開指示:**');
+
+  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, /単なる過去ログではなく、現在進行中の作業/);
+});
+
+test('buildResumeContext: returns null when no memory rows or inflight memo exist', () => {
+  const db = makeDb();
+  assert.equal(
+    buildResumeContext(db, { sessionId: 'empty', isInheritance: true }),
+    null,
+  );
+});
+
+test('buildResumeContext: excludeOriginId omits rows from the current origin', () => {
+  const db = makeDb();
+
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: 'old origin body',
+    createdAt: 1000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'new',
+    turn: 1,
+    role: 'assistant',
+    text: 'current origin body',
+    createdAt: 2000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: false,
+    excludeOriginId: 'new',
+  });
+
+  assert.ok(text);
+  assert.ok(text.includes('old origin body'));
+  assert.ok(!text.includes('current origin body'));
+});

package/src/session-start.mjs

@@ -1,20 +1,28 @@
 #!/usr/bin/env node
 /**
- * SessionStart hook — セッション登録 + バトン消費 + 引き継ぎ注入
+ * SessionStart hook — セッション登録 + 引き継ぎ判定 + 注入
  *
  * stdin: { session_id, source, cwd, transcript_path, hook_event_name }
  *
- * 【引き継ぎ条件 (バトン方式)】
- *   ユーザーが旧セッションで /tl スラッシュコマンドを打つと UserPromptSubmit hook が
- *   baton テーブルに session_id を書き込む。本 SessionStart hook はそれを TTL 1 時間以内
- *   なら消費して merge + 引き継ぎヘッダ付き L1+L2 を stdout 注入する。
- *   バトンが無ければ / 期限切れなら何も引き継がない（docs/INHERITANCE_ON_CLEAR_ONLY.md 参照）。
+ * 【引き継ぎ条件 (2 経路)】 docs/THROUGHLINE_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 して注入。
+ *
+ *   両方同時成立はしない (consumeBaton が先発、baton ありなら baton path、
+ *   なければ source 判定)。env で OFF にしたユーザーは `/tl` を打ってから
+ *   新セッションスタートで baton path を使う。
  *
  * 役割:
  *   1. sessions テーブルに新セッションを INSERT OR IGNORE
- *   2. バトン消費 + 指名された前任を merge (session-merger.mjs)
- *   3. 合流成立なら L1+L2 を「引き継ぎヘッダ」付きで stdout 注入
- *   4. 判定結果を ~/.throughline/logs/inheritance-decision.log に記録
+ *   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 に記録
  */
 
 import { getDb } from './db.mjs';
@@ -25,6 +33,38 @@ import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+
+const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
+
+function isAutoHandoffDisabled(env) {
+  return env[ENV_DISABLE_AUTO_HANDOFF] === '1';
+}
+
+/**
+ * 同 project_path の最新 Claude unmerged session を返す (auto path 用 predecessor)。
+ * Codex session (`codex:*`) と現セッション自身は除外。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} projectPath
+ * @param {string} currentSessionId
+ * @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');
@@ -37,7 +77,7 @@ function logDecision(entry) {
   }
 }
 
-async function main() {
+export async function run() {
   let raw = '';
   await new Promise((resolve) => {
     process.stdin.setEncoding('utf8');
@@ -56,11 +96,7 @@ async function main() {
   const db = getDb();
   const now = Date.now();
 
-  // 0. VSCode で開かれた新規プロジェクトに .vscode/tasks.json を自動プロビジョニング。
-  //    Stop hook 側にも同じ呼び出しがあるが、Stop が発火しない環境（応答中断・IDE 挙動差）
-  //    でも SessionStart は必ず走るので、新規プロジェクトでの自動起動を確実化する保険。
-  //    冪等性は ensureMonitorTaskFile 側で保証されており、Stop/UserPromptSubmit と重複呼び
-  //    出しされても安全。
+  // 0. VSCode 用 tasks.json 自動プロビジョニング (冪等)
   try {
     ensureMonitorTaskFile({ cwd: projectPath, env: process.env });
   } catch (err) {
@@ -74,18 +110,40 @@ async function main() {
      VALUES (?, ?, 'active', ?, ?)`,
   ).run(session_id, projectPath, now, now);
 
-  // 2. バトン消費
+  // 2. baton 消費
   const baton = consumeBaton(db, { projectPath, now });
 
-  let mergeResult = { merged: false, skipReason: 'no_baton' };
+  // 3. 引継ぎ判定
+  let mergeResult = { merged: false, skipReason: 'no_trigger' };
+  let triggeredPath = null;
+  const autoDisabled = isAutoHandoffDisabled(process.env);
+
   if (baton.sessionId) {
-    // バトンが指す session が既に他と merge 済みなら、その合流先末端を前任とする
+    // 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';
+    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' };
   }
 
   logDecision({
@@ -93,22 +151,21 @@ async function main() {
     source: source ?? null,
     session_id,
     project_path: projectPath,
+    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,
-    baton_has_memo: Boolean(baton.memoText),
     merged: mergeResult.merged,
     merge_skip_reason: mergeResult.skipReason ?? null,
     predecessor_id: mergeResult.predecessorId ?? null,
   });
 
-  // 3. 合流成立なら引き継ぎヘッダ付きで注入
-  //    バトンに付いていた in-flight メモも併せて先頭セクションに注入する
+  // 4. 合流成立なら curated memory を stdout 注入 (L1 + L2 + L3 refs)
   if (mergeResult.merged) {
     const text = buildResumeContext(db, {
       sessionId: session_id,
       isInheritance: true,
-      inflightMemo: baton.memoText ?? null,
     });
     if (text) {
       process.stdout.write(text + '\n');
@@ -118,7 +175,9 @@ async function main() {
   process.exit(0);
 }
 
-main().catch((err) => {
-  process.stderr.write(`[session-start] error: ${err.message}\n`);
-  process.exit(1);
-});
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch((err) => {
+    process.stderr.write(`[session-start] error: ${err.message}\n`);
+    process.exit(1);
+  });
+}