throughline 0.3.25 → 0.4.1

package/src/hook-entrypoints.test.mjs

@@ -98,33 +98,54 @@ test('prompt-submit subprocess writes a /tl baton into an isolated DB', () => {
   }
 });
 
-test('save-inflight subprocess stores memo on the current project baton', () => {
+test('prompt-submit subprocess writes a /clear baton (specific session marker)', () => {
   const home = makeTempHome();
   const project = makeTempProject();
   try {
-    const baton = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
       home,
       cwd: project,
       input: JSON.stringify({
-        session_id: 'old-session',
+        session_id: 'cleared-session',
         cwd: project,
-        prompt: '/tl',
+        prompt: '/clear',
       }),
     });
-    assert.equal(baton.status, 0, baton.stderr);
 
-    const memo = 'Next: keep the handoff precise';
-    const saved = runNode([join(REPO_ROOT, 'bin/throughline.mjs'), 'save-inflight'], {
+    assert.equal(result.status, 0, result.stderr);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT project_path, session_id FROM handoff_batons').get();
+    assert.equal(row.project_path, project);
+    assert.equal(row.session_id, 'cleared-session');
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('prompt-submit: /clear baton overwrites previous /tl baton in same project', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const tl = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
       home,
       cwd: project,
-      input: memo,
+      input: JSON.stringify({ session_id: 'session-A', cwd: project, prompt: '/tl' }),
     });
-    assert.equal(saved.status, 0, saved.stderr);
-    assert.match(saved.stdout, /in-flight memo saved/);
+    assert.equal(tl.status, 0, tl.stderr);
+
+    const clear = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: 'session-B', cwd: project, prompt: '/clear' }),
+    });
+    assert.equal(clear.status, 0, clear.stderr);
 
     const db = openDb(home);
-    const row = db.prepare('SELECT memo_text FROM handoff_batons').get();
-    assert.equal(row.memo_text, memo);
+    const row = db.prepare('SELECT session_id FROM handoff_batons').get();
+    assert.equal(row.session_id, 'session-B', 'most recent baton write wins');
     db.close();
   } finally {
     rmSync(project, { recursive: true, force: true });
@@ -132,6 +153,34 @@ test('save-inflight subprocess stores memo on the current project baton', () =>
   }
 });
 
+test('prompt-submit: non-baton prompt does not write any baton', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'session-X',
+        cwd: project,
+        prompt: 'hello world',
+      }),
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+
+    if (existsSync(join(home, '.throughline', 'throughline.db'))) {
+      const db = openDb(home);
+      const row = db.prepare('SELECT COUNT(*) AS n FROM handoff_batons').get();
+      assert.equal(row.n, 0, 'a normal prompt must not create any baton');
+      db.close();
+    }
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('session-start subprocess consumes baton and injects inherited resume context', () => {
   const home = makeTempHome();
   const project = makeTempProject();
@@ -157,11 +206,6 @@ test('session-start subprocess consumes baton and injects inherited resume conte
          (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
        VALUES ('old-session', 'old-session', 1, 'assistant', 'old assistant body', 4, 2)`,
     ).run();
-    db.prepare(
-      `UPDATE handoff_batons
-       SET memo_text = 'handoff memo'
-       WHERE project_path = ?`,
-    ).run(project);
     db.close();
 
     const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
@@ -175,7 +219,6 @@ test('session-start subprocess consumes baton and injects inherited resume conte
     });
 
     assert.equal(started.status, 0, started.stderr);
-    assert.match(started.stdout, /handoff memo/);
     assert.match(started.stdout, /old assistant body/);
 
     const after = openDb(home);

package/src/prompt-submit.mjs

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
 /**
- * UserPromptSubmit hook — /tl スラッシュコマンド検出 + バトン書き込み
+ * UserPromptSubmit hook — /tl & /clear スラッシュコマンド検出 + バトン書き込み
  *
  * stdin: { session_id, cwd, prompt, hook_event_name, ... }
  *
  * 動作:
  *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
+ *   - prompt が /clear (単独 or /clear ... 形式) で始まっていれば、現セッションの
+ *     session_id をバトンに書き込んで終了。
+ *     (これにより SessionStart 側の findLatestClaudePredecessor heuristic に頼らず、
+ *      確定的に「/clear が打たれたセッション」を新セッションに引き継げる。複数
+ *      VSCode ウィンドウ等で「最新更新セッション = clear されたセッション」が
+ *      成立しない multi-window シナリオで誤った前任を選ばないための確定的指名)
  *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
  *   - 本 hook は注入を一切行わない (SessionStart の引き継ぎ注入と二重にならないため)
  *
@@ -43,6 +49,18 @@ export function isBatonCommand(prompt) {
   return false;
 }
 
+/**
+ * プロンプトが /clear バトン発動コマンドか判定する。
+ * 許容: "/clear", "/clear\n", "/clear 何か" (前後空白は trim 済み前提)
+ */
+export function isClearCommand(prompt) {
+  if (typeof prompt !== 'string') return false;
+  const trimmed = prompt.trim();
+  if (trimmed === '/clear') return true;
+  if (trimmed.startsWith('/clear ') || trimmed.startsWith('/clear\n')) return true;
+  return false;
+}
+
 export async function run() {
   let raw = '';
   await new Promise((resolve) => {
@@ -66,7 +84,10 @@ export async function run() {
     process.stderr.write(`[vscode-task] ${msg}\n`);
   }
 
-  if (!isBatonCommand(prompt)) {
+  const tlMatch = isBatonCommand(prompt);
+  const clearMatch = !tlMatch && isClearCommand(prompt);
+
+  if (!tlMatch && !clearMatch) {
     process.exit(0);
     return;
   }
@@ -87,6 +108,7 @@ export async function run() {
     ts: new Date(now).toISOString(),
     session_id,
     project_path: projectPath,
+    trigger: tlMatch ? 'tl' : 'clear',
   });
 
   process.exit(0);

package/src/prompt-submit.test.mjs

@@ -0,0 +1,66 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { isBatonCommand, isClearCommand } from './prompt-submit.mjs';
+
+test('isBatonCommand: bare /tl', () => {
+  assert.equal(isBatonCommand('/tl'), true);
+});
+
+test('isBatonCommand: /tl with trailing newline', () => {
+  assert.equal(isBatonCommand('/tl\n'), true);
+});
+
+test('isBatonCommand: /tl with leading/trailing whitespace', () => {
+  assert.equal(isBatonCommand('  /tl  '), true);
+});
+
+test('isBatonCommand: /tl with arguments', () => {
+  assert.equal(isBatonCommand('/tl some memo'), true);
+});
+
+test('isBatonCommand: rejects /tl-prefixed identifier', () => {
+  assert.equal(isBatonCommand('/tldr summary'), false);
+});
+
+test('isBatonCommand: rejects /clear', () => {
+  assert.equal(isBatonCommand('/clear'), false);
+});
+
+test('isBatonCommand: rejects empty / non-string', () => {
+  assert.equal(isBatonCommand(''), false);
+  assert.equal(isBatonCommand(null), false);
+  assert.equal(isBatonCommand(undefined), false);
+  assert.equal(isBatonCommand(42), false);
+});
+
+test('isClearCommand: bare /clear', () => {
+  assert.equal(isClearCommand('/clear'), true);
+});
+
+test('isClearCommand: /clear with trailing newline', () => {
+  assert.equal(isClearCommand('/clear\n'), true);
+});
+
+test('isClearCommand: /clear with leading/trailing whitespace', () => {
+  assert.equal(isClearCommand('  /clear  '), true);
+});
+
+test('isClearCommand: /clear with arguments', () => {
+  assert.equal(isClearCommand('/clear something'), true);
+});
+
+test('isClearCommand: rejects /clear-prefixed identifier', () => {
+  assert.equal(isClearCommand('/cleared'), false);
+  assert.equal(isClearCommand('/clearcache'), false);
+});
+
+test('isClearCommand: rejects /tl', () => {
+  assert.equal(isClearCommand('/tl'), false);
+});
+
+test('isClearCommand: rejects empty / non-string', () => {
+  assert.equal(isClearCommand(''), false);
+  assert.equal(isClearCommand(null), false);
+  assert.equal(isClearCommand(undefined), false);
+  assert.equal(isClearCommand(42), false);
+});

package/src/resume-context.mjs

@@ -1,33 +1,32 @@
 /**
- * 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 本体のコンテキストに既にあるため）
- *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更する。
- *     冒頭と末尾の両方に current-work instruction を置き、長文 context 内でも
- *     L1/L2 を現在タスク用の作業文脈として読むよう誘導する。
+ *   - フレーミング: 「過去の記憶」ではなく「現在進行中の作業」として読ませる
+ *     (Codex 側 renderCodexRolloutMemoryPreview の写像)
  */
 
-import { buildHandoffRecord, N_RECENT_L2 } from './handoff-record.mjs';
+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} ターン分引き継ぎました」と報告してください。` +
   `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
@@ -37,48 +36,38 @@ const ACTIVE_WORK_READING_CONTRACT =
   `**読み方の契約:**\n` +
   `- これは単なる過去ログではなく、現在進行中の作業を再開するための active work context です。\n` +
   `- L2 は古い順に並んだ作業履歴です。後の発言・判断・TODO は前の仮説や作業方針を上書きし得ます。\n` +
-  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2、in-flight メモ、最終ターン thinking を優先して現在状態を推定してください。\n` +
-  `- 不足している tool output / 詳細根拠が必要なときだけ、末尾の \`throughline detail <時刻>\` を使って L3 を取得してください。`;
+  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2 を優先して現在状態を推定してください。\n` +
+  `- 不足している tool output / 詳細根拠が必要なときだけ、L3 references の \`throughline detail <時刻>\` を使って取得してください。`;
 
 const CONTINUATION_REMINDER =
-  '**再開指示:** 上記の L1 / L2 / thinking / in-flight メモを、現在タスクに使う作業コンテキストとして扱ってください。' +
-  '最新の L2、in-flight メモ、最終ターン thinking から次の一手を決め、中断地点から続行してください。' +
+  '**再開指示:** 上記の L1 / L2 を、現在タスクに使う作業コンテキストとして扱ってください。' +
+  '最新の L2 から次の一手を決め、中断地点から続行してください。' +
   '古い仮説や未完了 TODO は、後続の判断で上書きされ得ます。';
 
 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 自身の判断で呼び出して構いません。';
-
 /**
- * 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 },
 ) {
+  // handoff-record は Codex 側でも使うので signature 維持。inflightMemo / latestThinking は
+  // 新仕様の注入テキストには使わない (L2 全文で十分という判断)。
   const record = buildHandoffRecord(db, {
     sessionId,
     isInheritance,
     excludeOriginId,
-    inflightMemo,
   });
   if (!record) return null;
 
@@ -88,20 +77,6 @@ export function buildResumeContext(
     : NORMAL_HEADER;
   const lines = [header];
 
-  if (record.memory.inflightMemo) {
-    lines.push('');
-    lines.push('### 中断直前の in-flight メモ（前セッションの Claude 自身による要約）');
-    lines.push(record.memory.inflightMemo);
-  }
-
-  if (record.memory.latestThinking.length > 0) {
-    lines.push('');
-    lines.push('### 中断直前の思考 (最終ターンの extended thinking)');
-    for (const r of record.memory.latestThinking) {
-      lines.push(`[${r.time}] ${r.text}`);
-    }
-  }
-
   if (record.memory.l1Summaries.length > 0) {
     lines.push('');
     lines.push('### それ以前の要約 (L1)');
@@ -121,8 +96,16 @@ export function buildResumeContext(
     }
   }
 
-  lines.push('');
-  lines.push(FOOTER_GUIDE);
+  if (record.references.l3.length > 0) {
+    lines.push('');
+    lines.push('### L3 詳細参照 (本文は注入されていません)');
+    lines.push('必要なときだけ以下のコマンドで取得してください:');
+    for (const ref of record.references.l3) {
+      const time = formatTime(ref.createdAt);
+      lines.push(`- [${time}] ${ref.kind}: \`throughline detail ${time}\``);
+    }
+  }
+
   lines.push('');
   lines.push(CONTINUATION_REMINDER);
 

package/src/resume-context.test.mjs

@@ -65,7 +65,7 @@ function insertThinking(db, row) {
   ).run(row.session, row.origin, row.turn, row.text, row.createdAt, row.sourceId);
 }
 
-test('buildResumeContext: inheritance output order is memo -> thinking -> L1 -> L2 -> footer', () => {
+test('buildResumeContext: inheritance output order is L1 -> L2 -> L3 refs -> reminder (no memo / no thinking)', () => {
   const db = makeDb();
 
   insertSkeleton(db, {
@@ -92,6 +92,7 @@ test('buildResumeContext: inheritance output order is memo -> thinking -> L1 ->
     text: 'recent assistant body',
     createdAt: 2100,
   });
+  // thinking は DB に書かれても、新仕様では注入テキストに出ない
   insertThinking(db, {
     session: 'new',
     origin: 'old',
@@ -104,32 +105,36 @@ test('buildResumeContext: inheritance output order is memo -> thinking -> L1 ->
   const text = buildResumeContext(db, {
     sessionId: 'new',
     isInheritance: true,
-    inflightMemo: '**Next**: keep going',
+    // inflightMemo は互換のため受け取れるが、新仕様では注入テキストに使わない
+    inflightMemo: '**Next**: keep going (should NOT appear)',
   });
 
   assert.ok(text);
   assert.match(text, /^## Throughline: 中断した作業の再開/);
 
-  const memoIdx = text.indexOf('### 中断直前の in-flight メモ');
-  const thinkingIdx = text.indexOf('### 中断直前の思考');
+  // 新仕様: 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 footerIdx = text.indexOf('**[Claude 向け — 記憶の使い方]**');
+  const l3Idx = text.indexOf('### L3 詳細参照');
+  const reminderIdx = text.indexOf('**再開指示:**');
 
-  assert.ok(memoIdx > 0, 'in-flight memo section should be present');
-  assert.ok(thinkingIdx > memoIdx, 'thinking should follow in-flight memo');
-  assert.ok(l1Idx > thinkingIdx, 'L1 should follow thinking');
+  assert.ok(l1Idx > 0, 'L1 section should be present');
   assert.ok(l2Idx > l1Idx, 'L2 should follow L1');
-  assert.ok(footerIdx > l2Idx, 'footer should follow L2');
+  assert.ok(l3Idx > l2Idx, 'L3 references should follow L2');
+  assert.ok(reminderIdx > l3Idx, 'continuation reminder should follow L3 refs');
 
-  assert.ok(text.includes('**Next**: keep going'));
-  assert.ok(text.includes('latest thinking block'));
   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, /単なる過去ログではなく、現在進行中の作業/);
-  assert.match(text, /後の行ほど現在状態に近く/);
-  assert.match(text, /上記の L1 \/ L2 \/ thinking \/ in-flight メモを、現在タスクに使う作業コンテキスト/);
 });
 
 test('buildResumeContext: returns null when no memory rows or inflight memo exist', () => {

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';
@@ -27,6 +35,37 @@ 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');
   try {
@@ -57,11 +96,7 @@ export async function run() {
   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) {
@@ -75,18 +110,40 @@ export async function run() {
      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({
@@ -94,22 +151,21 @@ export async function run() {
     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');

package/.claude/commands/tl-trim.md

@@ -1,42 +0,0 @@
----
-description: 現セッションの context trim 計画を dry-run する (Throughline)
----
-
-Throughline の context trim は、現時点では dry-run のみ有効です。自動 `/rewind` や自動 rollback / inject は、host primitive の検証が完了するまで実行してはいけません。
-
-まず、今この時点の「現在作業」を自分の文脈から思い出し、以下 4 項目を Markdown で整理してください。
-
-- **次の一手**: 今まさに何をやろうとしていたか（1-3 文、具体的に）
-- **現在の方針 / 仮説**: 追っているバグの原因、設計の方向性、調査中の観点など
-- **未解決の疑問**: 判断保留中の論点
-- **進行中 TODO**: 完了済みを除いた現行 TODO
-
-その Markdown を stdin として、次のコマンドを Bash ツールで実行し、結果をユーザーにそのまま要約してください。
-
-```bash
-throughline trim --dry-run --host claude --memo-stdin $ARGUMENTS <<'EOF'
-**次の一手**: ...
-**現在の方針 / 仮説**: ...
-**未解決の疑問**: ...
-**進行中 TODO**:
-- ...
-EOF
-```
-
-出力には以下が含まれます。
-
-- 現セッションで Throughline が捕捉している turn 数
-- keep-recent 設定
-- rollback 候補 turn 数
-- host が自動 rollback / inject 対応かどうか
-- rollback 後に戻す curated memory preview
-- rollback 後に「今やっている作業」として戻す current-work memo
-
-`$ARGUMENTS` には `--keep-recent 20`、`--all`、`--session <id>` を渡せます。
-
-重要:
-
-- dry-run の結果だけで自動 rollback しないでください。
-- Claude の既存 `/tl` baton handoff は変更しません。
-- L1/L2 だけでは「今やっている作業」として認識されにくいので、current-work memo を省略しないでください。
-- `Throughline Trim Dry-run` の `Automatic execution allowed` が `no` の場合は、実行手順ではなく「現状は dry-run / 手動案内まで」と説明してください。