throughline 0.1.0 → 0.3.0

package/src/db.mjs

@@ -9,7 +9,7 @@ import { join } from 'path';
 
 const DB_DIR = join(homedir(), '.throughline');
 const DB_PATH = join(DB_DIR, 'throughline.db');
-const CURRENT_VERSION = 5;
+const CURRENT_VERSION = 7;
 
 let _db = null;
 
@@ -177,6 +177,31 @@ function initSchema(db) {
     `);
   }
 
+  // v5 → v6: handoff_batons テーブル追加（/tl スラッシュコマンドによる明示的引き継ぎ指名用）
+  // - project_path ごとに最新 1 件のみ (PRIMARY KEY)
+  // - SessionStart で読み出し、TTL 以内なら merge して DELETE
+  // - docs/INHERITANCE_ON_CLEAR_ONLY.md 参照: 案 D (時間差) 撤去、バトン方式へ移行
+  if (version < 6) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS handoff_batons (
+        project_path TEXT    PRIMARY KEY,
+        session_id   TEXT    NOT NULL,
+        created_at   INTEGER NOT NULL
+      );
+    `);
+  }
+
+  // v6 → v7: handoff_batons に memo_text 列追加（/tl 発動時に現行 Claude 自身が
+  // 書き込む in-flight メモ。「次の一手」「現在の方針」「未解決」「進行中 TODO」
+  // の短い Markdown テキスト。次セッションの SessionStart が resume-context の
+  // 先頭に注入して「中断地点からの再開」感を復元する）
+  if (version < 7) {
+    const batonCols = db.prepare('PRAGMA table_info(handoff_batons)').all();
+    if (!batonCols.some((c) => c.name === 'memo_text')) {
+      db.exec('ALTER TABLE handoff_batons ADD COLUMN memo_text TEXT');
+    }
+  }
+
   if (version < CURRENT_VERSION) {
     db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
   }

package/src/prompt-submit.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook — /tl スラッシュコマンド検出 + バトン書き込み
+ *
+ * stdin: { session_id, cwd, prompt, hook_event_name, ... }
+ *
+ * 動作:
+ *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
+ *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
+ *   - 本 hook は注入を一切行わない (SessionStart の引き継ぎ注入と二重にならないため)
+ *
+ * 設計背景: docs/INHERITANCE_ON_CLEAR_ONLY.md バトン方式
+ */
+
+import { getDb } from './db.mjs';
+import { writeBaton } from './baton.mjs';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+function logBaton(entry) {
+  const path = join(homedir(), '.throughline', 'logs', 'baton-write.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:log] ${msg}\n`);
+  }
+}
+
+/**
+ * プロンプトが /tl バトン発動コマンドか判定する。
+ * 許容: "/tl", "/tl\n", "/tl 何か" (前後空白は trim 済み前提)
+ */
+export function isBatonCommand(prompt) {
+  if (typeof prompt !== 'string') return false;
+  const trimmed = prompt.trim();
+  if (trimmed === '/tl') return true;
+  if (trimmed.startsWith('/tl ') || trimmed.startsWith('/tl\n')) return true;
+  return false;
+}
+
+async function main() {
+  let raw = '';
+  await new Promise((resolve) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', resolve);
+  });
+
+  const payload = JSON.parse(raw);
+  const { session_id, cwd, prompt } = payload;
+
+  if (!isBatonCommand(prompt)) {
+    process.exit(0);
+    return;
+  }
+
+  if (!session_id) {
+    process.stderr.write('[prompt-submit] missing session_id in payload\n');
+    process.exit(0);
+    return;
+  }
+
+  const projectPath = cwd ?? process.cwd();
+  const db = getDb();
+  const now = Date.now();
+
+  writeBaton(db, { projectPath, sessionId: session_id, now });
+
+  logBaton({
+    ts: new Date(now).toISOString(),
+    session_id,
+    project_path: projectPath,
+  });
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  const msg = err instanceof Error ? err.message : 'unknown';
+  process.stderr.write(`[prompt-submit] error: ${msg}\n`);
+  process.exit(1);
+});

package/src/resume-context.mjs

@@ -1,23 +1,34 @@
 /**
- * resume-context.mjs — L1+L2 の再注入テキストを組み立てる共有モジュール
+ * resume-context.mjs — 中断地点からの再開注入テキストを組み立てる共有モジュール
  *
  * 呼び出し元:
  *   - session-start.mjs (isInheritance=true, 引き継ぎヘッダ)
  *
- * 新設計（schema v4）:
+ * 設計（schema v7 対応）:
+ *   - 注入順: ヘッダ → [in-flight メモ] → [中断直前の思考] → L1 要約 → L2 本文 → フッタ
+ *   - in-flight メモ: /tl 発動時に現行 Claude が書いた「次の一手 / 方針 / 未解決 / TODO」
+ *   - 中断直前の思考: 最終ターンの assistant extended thinking (details kind='thinking')
  *   - 直近 N=20 ターンは bodies から L2 全文を注入
  *   - それ以前は skeletons から L1 要約のみ注入
- *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（bodies.created_at ベース、DB 永続）
+ *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（created_at ベース、DB 永続）
  *   - 末尾に /sc-detail <時刻> ガイドを追記
- *   - judgments セクションは廃止
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
+ *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更 (B 案)
  */
 
 const N_RECENT_L2 = 20;
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
-  `## Throughline: セッション記憶（${turnCount} ターン引き継ぎ）\n` +
-  `**[Throughline] 前セッションの記憶を引き継ぎました。応答の冒頭で「前の記憶を ${turnCount} ターン引き継ぎました」とユーザーに報告してください。**`;
+  `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
+  `\n` +
+  `**前セッションで進行中だった作業を、この新セッションで引き継いでいます。以下が中断時点の状態です:**\n` +
+  `- 中断直前の in-flight メモ（前セッション末尾で Claude 自身が書いた「次の一手・方針・未解決・TODO」）\n` +
+  `- 中断直前の思考 (最終ターンの extended thinking)\n` +
+  `- 直近 ${N_RECENT_L2} ターンの会話本文 (L2)\n` +
+  `- それ以前の要約 (L1)\n` +
+  `\n` +
+  `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
+  `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
@@ -25,11 +36,11 @@ const FOOTER_GUIDE =
   '---\n' +
   '**[Claude 向け — 記憶の使い方]**\n' +
   '上の L1 要約や L2 本文を読んで「具体的なコマンドやツール出力、ファイル内容を確認したい」と感じたら、' +
-  '推測せずに **Bash ツールで `throughline detail <時刻>` を実行** して L3（ツール入出力・hook 出力）を取得してください。\n' +
+  '推測せずに **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 別にグループ化）。\n' +
+  '返る内容: 指定ターンの L2 会話本文 + L3（tool_input / tool_output / system / thinking 別にグループ化）。\n' +
   'ユーザーに「詳細を見せて」と言われた時だけでなく、**ユーザー発言の文脈が過去ターンに依存しているのに L1/L2 だけでは情報不足だと判断した時**に、Claude 自身の判断で呼び出して構いません。';
 
 /**
@@ -44,29 +55,75 @@ function formatTime(unixMs) {
 }
 
 /**
- * 本文を 1 行にまとめる（改行は空白に畳む）。
+ * 最新ターン番号 (= 中断直前) の 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 flattenText(text) {
-  if (!text) return '';
-  return text.replace(/\n+/g, ' ').trim();
+function loadLatestThinking(db, sessionId, excludeOriginId) {
+  const hasExclude = Boolean(excludeOriginId);
+
+  // 最新 (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`;
+
+  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 [];
+  }
 }
 
 /**
  * L1+L2 注入テキストを組み立てる。
  *
  * @param {import('node:sqlite').DatabaseSync} db
- * @param {{ sessionId: string, isInheritance: boolean, excludeOriginId?: string | null }} params
- *        sessionId: 合流先 session_id (merge target)
- *        excludeOriginId: 注入対象から除外する origin_session_id（= 現セッションの origin）
- *                         指定すると「前任チェーンのターンのみ」を注入する
+ * @param {{
+ *   sessionId: string,
+ *   isInheritance: boolean,
+ *   excludeOriginId?: string | null,
+ *   inflightMemo?: string | null,
+ * }} params
  * @returns {string | null}
  */
-export function buildResumeContext(db, { sessionId, isInheritance, excludeOriginId = null }) {
+export function buildResumeContext(
+  db,
+  { sessionId, isInheritance, excludeOriginId = null, inflightMemo = null },
+) {
   if (!sessionId) return null;
 
   const hasExclude = Boolean(excludeOriginId);
 
-  // 直近 N 件の bodies を取得
   const bodiesQuery = hasExclude
     ? `SELECT origin_session_id, turn_number, role, text, created_at
        FROM bodies
@@ -92,7 +149,7 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
   }
   const bodyRows = bodyRowsDesc.reverse(); // ASC に戻す
 
-  // 古い側の L1（bodies に既に含まれるターンを除いたもの）を skeletons から取得
+  // 古い側の L1（bodies に既に含まれるターンを除いたもの）
   const bodySet = new Set(
     bodyRows.map((r) => `${r.origin_session_id}\x00${r.turn_number}`),
   );
@@ -115,7 +172,14 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
     (s) => !bodySet.has(`${s.origin_session_id}\x00${s.turn_number}`),
   );
 
-  if (bodyRows.length === 0 && l1Rows.length === 0) {
+  const thinkingRows = loadLatestThinking(db, sessionId, excludeOriginId);
+
+  if (
+    bodyRows.length === 0 &&
+    l1Rows.length === 0 &&
+    thinkingRows.length === 0 &&
+    !inflightMemo
+  ) {
     return null;
   }
 
@@ -123,12 +187,26 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
   const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
   const lines = [header];
 
+  if (inflightMemo && inflightMemo.trim().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}`);
+    }
+  }
+
   if (l1Rows.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)}] ${flattenText(r.summary)}`);
+      lines.push(`[${formatTime(r.created_at)}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
     }
   }
 

package/src/session-merger.mjs

@@ -2,10 +2,13 @@
  * session-merger.mjs — 記憶張り替え + merged_into チェーン解決
  *
  * 用途:
- *   - SessionStart hook: mergePredecessorInto で前任セッションの L1/L2/L3 を新セッションに張り替える
- *   - Stop / PostToolUse hook: resolveMergeTarget で「入力 session_id → 実書き込み先」を解決
+ *   - SessionStart hook: バトンで指名された旧セッションを mergeSpecificPredecessor で新セッションに張り替え
+ *   - Stop hook: resolveMergeTarget で「入力 session_id → 実書き込み先」を解決
  *
- * 設計背景: docs/SESSION_LINKING_DESIGN.md
+ * 設計背景: docs/SESSION_LINKING_DESIGN.md, docs/INHERITANCE_ON_CLEAR_ONLY.md (バトン方式採用)
+ *
+ * 旧実装 (案 D: 時間差ヒューリスティック / 自動前任選択) は撤去済み。
+ * 引き継ぎはユーザーが /tl を打って書いたバトンによる明示的指名のみで発火する。
  */
 
 const MAX_CHAIN_DEPTH = 10;
@@ -16,8 +19,6 @@ const MAX_CHAIN_DEPTH = 10;
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {string} sessionId
  * @returns {{ target: string, origin: string }}
- *   target: 実書き込み先 session_id（合流先）
- *   origin: 入力 session_id そのもの（INSERT 時の origin_session_id に使う）
  */
 export function resolveMergeTarget(db, sessionId) {
   const origin = sessionId;
@@ -46,43 +47,53 @@ export function resolveMergeTarget(db, sessionId) {
 }
 
 /**
- * 同一プロジェクト内の最新非合流セッションを新セッションに張り替える。
+ * バトンで指名された特定の旧セッションを新セッションに張り替える。
  *
  * 実行順序（BEGIN IMMEDIATE トランザクション内）:
- *   1. 前任候補 SELECT（同 project_path, session_id != new, merged_into IS NULL, 最新 updated_at）
+ *   1. 前任の妥当性チェック（存在する / 自分自身ではない / 既に合流済みでない / created_at が古い）
  *   2. skeletons / details / bodies の session_id を new に UPDATE
- *      （bodies は schema v4 で追加された L2 テーブル。v3 DB でも UPDATE は no-op で害なし）
  *   3. 前任 sessions.merged_into = new
  *   4. 新セッション sessions.updated_at = now
  *
  * @param {import('node:sqlite').DatabaseSync} db
- * @param {{ newSessionId: string, projectPath: string }} params
- * @returns {{ merged: boolean, predecessorId?: string, rowCounts?: { sk: number, dt: number, bd: number } }}
+ * @param {{ newSessionId: string, predecessorId: string, now?: number }} params
+ * @returns {{
+ *   merged: boolean,
+ *   predecessorId?: string,
+ *   rowCounts?: { sk: number, dt: number, bd: number },
+ *   skipReason?: 'self_handoff' | 'predecessor_not_found' | 'already_merged' | 'predecessor_not_older',
+ * }}
  */
-export function mergePredecessorInto(db, { newSessionId, projectPath }) {
+export function mergeSpecificPredecessor(db, { newSessionId, predecessorId, now = Date.now() }) {
+  if (newSessionId === predecessorId) {
+    return { merged: false, skipReason: 'self_handoff' };
+  }
+
   db.exec('BEGIN IMMEDIATE');
   try {
-    // 時系列単調制約: 前任は新セッションより created_at が古いものに限る。
-    // これにより merge chain は厳密に時系列順となり、循環参照が構造的に発生不可能になる。
-    // (同時刻に複数 SessionStart が発火しても、自分自身より新しいセッションは選ばない)
     const pred = db
-      .prepare(
-        `SELECT session_id FROM sessions
-         WHERE lower(project_path) = lower(?)
-           AND session_id != ?
-           AND merged_into IS NULL
-           AND created_at < (SELECT created_at FROM sessions WHERE session_id = ?)
-         ORDER BY updated_at DESC
-         LIMIT 1`,
-      )
-      .get(projectPath, newSessionId, newSessionId);
+      .prepare('SELECT session_id, created_at, merged_into FROM sessions WHERE session_id = ?')
+      .get(predecessorId);
 
     if (!pred) {
       db.exec('COMMIT');
-      return { merged: false };
+      return { merged: false, skipReason: 'predecessor_not_found' };
+    }
+    if (pred.merged_into) {
+      db.exec('COMMIT');
+      return { merged: false, skipReason: 'already_merged' };
     }
 
-    const predecessorId = pred.session_id;
+    const self = db
+      .prepare('SELECT created_at FROM sessions WHERE session_id = ?')
+      .get(newSessionId);
+
+    // 時系列単調制約: 前任は新セッションより created_at が古いこと。
+    // バトンが自分より新しい session を指していたら（異常データ）merge しない。
+    if (self && pred.created_at >= self.created_at) {
+      db.exec('COMMIT');
+      return { merged: false, skipReason: 'predecessor_not_older' };
+    }
 
     const sk = db
       .prepare('UPDATE skeletons SET session_id = ? WHERE session_id = ?')
@@ -90,14 +101,12 @@ export function mergePredecessorInto(db, { newSessionId, projectPath }) {
     const dt = db
       .prepare('UPDATE details SET session_id = ? WHERE session_id = ?')
       .run(newSessionId, predecessorId);
-    // bodies は schema v4 以降のみ存在。v3 DB では 0 changes で害なし
     let bd = { changes: 0 };
     try {
       bd = db
         .prepare('UPDATE bodies SET session_id = ? WHERE session_id = ?')
         .run(newSessionId, predecessorId);
     } catch (err) {
-      // bodies テーブルが未作成の場合は無視（schema v3 DB 互換）
       if (!/no such table/i.test(err.message || '')) throw err;
     }
 
@@ -106,7 +115,7 @@ export function mergePredecessorInto(db, { newSessionId, projectPath }) {
       predecessorId,
     );
     db.prepare('UPDATE sessions SET updated_at = ? WHERE session_id = ?').run(
-      Date.now(),
+      now,
       newSessionId,
     );
 

package/src/session-merger.test.mjs

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
-import { resolveMergeTarget, mergePredecessorInto } from './session-merger.mjs';
+import { resolveMergeTarget, mergeSpecificPredecessor } from './session-merger.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -81,7 +81,7 @@ test('resolveMergeTarget: detects cycle and throws', () => {
   assert.throws(() => resolveMergeTarget(db, 'A'), /cycle detected/);
 });
 
-test('mergePredecessorInto: picks older predecessor and moves rows', () => {
+test('mergeSpecificPredecessor: moves rows from named predecessor to new session', () => {
   const db = makeDb();
   insertSession(db, 'old', 100);
   db.prepare(
@@ -90,7 +90,12 @@ test('mergePredecessorInto: picks older predecessor and moves rows', () => {
   ).run();
   insertSession(db, 'new', 200);
 
-  const result = mergePredecessorInto(db, { newSessionId: 'new', projectPath: '/proj' });
+  const result = mergeSpecificPredecessor(db, {
+    newSessionId: 'new',
+    predecessorId: 'old',
+    now: 200,
+  });
+
   assert.equal(result.merged, true);
   assert.equal(result.predecessorId, 'old');
   assert.equal(result.rowCounts.sk, 1);
@@ -102,50 +107,76 @@ test('mergePredecessorInto: picks older predecessor and moves rows', () => {
   assert.equal(oldRow.merged_into, 'new');
 });
 
-test('mergePredecessorInto: does NOT pick a session newer than self (cycle prevention)', () => {
+test('mergeSpecificPredecessor: self-handoff is refused', () => {
+  const db = makeDb();
+  insertSession(db, 'A', 100);
+
+  const result = mergeSpecificPredecessor(db, {
+    newSessionId: 'A',
+    predecessorId: 'A',
+    now: 100,
+  });
+
+  assert.equal(result.merged, false);
+  assert.equal(result.skipReason, 'self_handoff');
+});
+
+test('mergeSpecificPredecessor: predecessor not in sessions table', () => {
+  const db = makeDb();
+  insertSession(db, 'new', 200);
+
+  const result = mergeSpecificPredecessor(db, {
+    newSessionId: 'new',
+    predecessorId: 'nonexistent',
+    now: 200,
+  });
+
+  assert.equal(result.merged, false);
+  assert.equal(result.skipReason, 'predecessor_not_found');
+});
+
+test('mergeSpecificPredecessor: predecessor already merged into third session', () => {
+  const db = makeDb();
+  insertSession(db, 'old', 100, 'middle');
+  insertSession(db, 'middle', 150);
+  insertSession(db, 'new', 200);
+
+  const result = mergeSpecificPredecessor(db, {
+    newSessionId: 'new',
+    predecessorId: 'old',
+    now: 200,
+  });
+
+  assert.equal(result.merged, false);
+  assert.equal(result.skipReason, 'already_merged');
+});
+
+test('mergeSpecificPredecessor: refuses predecessor with created_at >= self', () => {
   const db = makeDb();
-  // new session created at t=100
   insertSession(db, 'new', 100);
-  // another session was created LATER at t=200 (e.g. a parallel window that started after)
   insertSession(db, 'newer', 200);
 
-  const result = mergePredecessorInto(db, { newSessionId: 'new', projectPath: '/proj' });
-  assert.equal(result.merged, false, 'should not merge a newer session into an older one');
+  const result = mergeSpecificPredecessor(db, {
+    newSessionId: 'new',
+    predecessorId: 'newer',
+    now: 100,
+  });
 
-  const newerRow = db
-    .prepare('SELECT merged_into FROM sessions WHERE session_id = ?')
-    .get('newer');
-  assert.equal(newerRow.merged_into, null);
+  assert.equal(result.merged, false);
+  assert.equal(result.skipReason, 'predecessor_not_older');
 });
 
-test('mergePredecessorInto: chronological monotonicity prevents cycles across 3 sessions', () => {
+test('mergeSpecificPredecessor: updates new session updated_at to provided now', () => {
   const db = makeDb();
-  // Sessions created in order: A (t=100), B (t=200), C (t=300)
-  insertSession(db, 'A', 100);
-  insertSession(db, 'B', 200);
-  insertSession(db, 'C', 300);
-
-  // Simulate SessionStart firing for B first, then C, then (accidentally) A again
-  mergePredecessorInto(db, { newSessionId: 'B', projectPath: '/proj' });
-  // B should have absorbed A
-  assert.equal(
-    db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get('A').merged_into,
-    'B',
-  );
-
-  mergePredecessorInto(db, { newSessionId: 'C', projectPath: '/proj' });
-  // C should have absorbed B (A is already merged, so not a candidate)
-  assert.equal(
-    db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get('B').merged_into,
-    'C',
-  );
-
-  // Re-firing SessionStart for A must not create a cycle (A cannot absorb newer B or C)
-  const redundant = mergePredecessorInto(db, { newSessionId: 'A', projectPath: '/proj' });
-  assert.equal(redundant.merged, false);
-
-  // Verify no cycle: resolveMergeTarget from any node terminates at C
-  assert.equal(resolveMergeTarget(db, 'A').target, 'C');
-  assert.equal(resolveMergeTarget(db, 'B').target, 'C');
-  assert.equal(resolveMergeTarget(db, 'C').target, 'C');
+  insertSession(db, 'old', 100);
+  insertSession(db, 'new', 200);
+
+  mergeSpecificPredecessor(db, {
+    newSessionId: 'new',
+    predecessorId: 'old',
+    now: 500,
+  });
+
+  const newRow = db.prepare('SELECT updated_at FROM sessions WHERE session_id = ?').get('new');
+  assert.equal(newRow.updated_at, 500);
 });