throughline 0.14.3 → 0.15.1

package/src/resume-context.test.mjs

@@ -5,6 +5,7 @@ import {
   buildResumeContext,
   buildBudgetedResumeContext,
   buildAutoContinuationContext,
+  buildRecentSessionsContext,
   INJECTION_BUDGET_CHARS,
 } from './resume-context.mjs';
 
@@ -1034,3 +1035,280 @@ test('buildAutoContinuationContext: 改行のある直前の発言は全文を
   assert.match(result.text, /- 道具: Read \/work\/file-080-x+\.mjs\n\*\*止める直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 方針:\n1\. 型を直す\n2\. 試験を足す\n\*\*止める直前に呼ぼうとして、実行されなかった道具\*\*: Edit \/work\/types\.mjs\n/);
 });
 
+
+// ---- 同じ project の過去の会話 (ADR 0034) ----
+
+const RECENT_BASE = 1_700_000_000_000;
+const RECENT_MINUTE = 60_000;
+
+/** 1 ターン (user + assistant) を入れる。at は user 行の時刻で、assistant 行は 30 秒後。 */
+function insertTurn(db, { session, origin = session, turn, user, assistant, at }) {
+  insertBody(db, { session, origin, turn, role: 'user', text: user, createdAt: at });
+  insertBody(db, { session, origin, turn, role: 'assistant', text: assistant, createdAt: at + 30_000 });
+}
+
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function countOccurrences(text, needle) {
+  return text.split(needle).length - 1;
+}
+
+test('recent: 過去の会話が無い時は buildBudgetedResumeContext と同じ文になる', () => {
+  const db = makeDb();
+  insertTurn(db, { session: 'only', turn: 1, user: 'ひとつだけの依頼', assistant: 'ひとつだけの回答', at: RECENT_BASE });
+
+  const expected = buildBudgetedResumeContext(db, {
+    sessionId: 'only',
+    isInheritance: true,
+    handoffDisclosure: 'silent',
+  });
+  // 本文の無い新しい session は飛ばし、現在の会話に選ばない
+  const recent = buildRecentSessionsContext(db, {
+    sessionIds: ['newer-empty', 'only', 'older-empty'],
+    handoffDisclosure: 'silent',
+  });
+
+  assert.equal(recent.text, expected.text);
+  assert.equal(recent.sessionId, 'only');
+  assert.deepEqual(recent.sessions, [
+    {
+      sessionId: 'only',
+      role: 'current',
+      firstTurnAt: new Date(RECENT_BASE).toISOString(),
+      lastTurnAt: new Date(RECENT_BASE + 30_000).toISOString(),
+      turns: 1,
+      includedTurns: 1,
+    },
+  ]);
+  assert.equal(buildRecentSessionsContext(db, { sessionIds: ['newer-empty'] }), null);
+});
+
+test('recent: 短い最新の会話の後ろに、前の作業の会話が入る', () => {
+  const db = makeDb();
+  // 6 ターンの作業 → 1 ターンの連絡（最新）
+  for (let turn = 1; turn <= 6; turn += 1) {
+    insertTurn(db, {
+      session: 'work',
+      turn,
+      user: `作業の依頼${turn}`,
+      assistant: `作業の結果${turn}`,
+      at: RECENT_BASE + turn * RECENT_MINUTE,
+    });
+  }
+  insertDetail(db, {
+    session: 'work', origin: 'work', turn: 6, kind: 'tool_input', toolName: 'Bash', createdAt: RECENT_BASE + 6 * RECENT_MINUTE + 1000,
+  });
+  insertTurn(db, { session: 'note', turn: 1, user: '短い連絡', assistant: '連絡への返事', at: RECENT_BASE + 60 * RECENT_MINUTE });
+
+  const latestOnly = buildBudgetedResumeContext(db, {
+    sessionId: 'note',
+    isInheritance: true,
+    handoffDisclosure: 'silent',
+  });
+  const recent = buildRecentSessionsContext(db, { sessionIds: ['note', 'work'], handoffDisclosure: 'silent' });
+
+  // 現在の会話の部分は今と同じ文で、その後ろに過去の会話が続く
+  assert.ok(recent.text.startsWith(`${latestOnly.text}\n\n## Throughline: このprojectで記録された過去の会話（新しい順）\n`));
+  assert.ok(recent.text.length <= INJECTION_BUDGET_CHARS);
+  assert.equal(recent.sessionId, 'note');
+  // 「直前の会話」「短い返事は GO」の案内は現在の会話の1回だけ
+  assert.equal(countOccurrences(recent.text, '短文/相槌の判定'), 1);
+  assert.equal(countOccurrences(recent.text, '### 現在地 (直前のやりとり)'), 1);
+  assert.match(recent.text, /次のユーザー入力は、ここへの返事ではありません/);
+
+  const past = recent.text.slice(latestOnly.text.length);
+  assert.match(past, /### 過去の会話 \d{4}-\d{2}-\d{2} \d{2}:\d{2}〜\d{2}:\d{2}（6ターン \/ session work）/);
+  for (let turn = 1; turn <= 6; turn += 1) {
+    assert.match(past, new RegExp(`\\[\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\] \\[user\\]: 作業の依頼${turn}\\n`));
+  }
+  // ターンは古い順に並び、道具の案内は今と同じくターンの最後の行に付く
+  assert.ok(past.indexOf('作業の依頼1') < past.indexOf('作業の結果1'));
+  assert.ok(past.indexOf('作業の結果1') < past.indexOf('作業の依頼2'));
+  assert.match(past, /\[assistant\]: 作業の結果6 \(詳細：Bash\)/);
+  // 全部入ったので、recall の案内と一覧は付かない
+  assert.ok(!past.includes('throughline recall --l2 --session work'));
+  assert.ok(!past.includes('### 本文を載せていない過去の会話'));
+
+  assert.deepEqual(
+    recent.sessions.map((s) => [s.sessionId, s.role, s.turns, s.includedTurns]),
+    [['note', 'current', 1, 1], ['work', 'past', 6, 6]],
+  );
+  assert.equal(recent.sessions[1].firstTurnAt, new Date(RECENT_BASE + RECENT_MINUTE).toISOString());
+  assert.equal(recent.sessions[1].lastTurnAt, new Date(RECENT_BASE + 6 * RECENT_MINUTE + 30_000).toISOString());
+});
+
+test('recent: 入らないターンから先は載せず、recall の案内と一覧にする', () => {
+  const db = makeDb();
+  insertTurn(db, { session: 'oldest', turn: 1, user: 'OLDEST_REQUEST', assistant: 'OLDEST_ANSWER', at: RECENT_BASE });
+  insertTurn(db, { session: 'oldest', turn: 2, user: 'OLDEST_REQUEST_2', assistant: 'OLDEST_ANSWER_2', at: RECENT_BASE + RECENT_MINUTE });
+  for (let turn = 1; turn <= 14; turn += 1) {
+    insertTurn(db, {
+      session: 'work',
+      turn,
+      user: `work-q-${String(turn).padStart(2, '0')}`,
+      assistant: `work-a-${String(turn).padStart(2, '0')} ` + 'x'.repeat(600),
+      at: RECENT_BASE + (10 + turn) * RECENT_MINUTE,
+    });
+  }
+  insertTurn(db, { session: 'note', turn: 1, user: '短い連絡', assistant: '連絡への返事', at: RECENT_BASE + 60 * RECENT_MINUTE });
+
+  const recent = buildRecentSessionsContext(db, {
+    sessionIds: ['note', 'work', 'oldest'],
+    handoffDisclosure: 'silent',
+    maxChars: 6000,
+  });
+
+  assert.ok(recent.text.length <= 6000, `length ${recent.text.length} must fit budget`);
+  const work = recent.sessions.find((s) => s.sessionId === 'work');
+  assert.ok(work.includedTurns > 0 && work.includedTurns < 14, `includedTurns ${work.includedTurns}`);
+  assert.equal(work.turns, 14);
+  // 新しい側から続けて入り、ターンは user 行と assistant 行が揃う。それより古いターンは1行も入らない
+  for (let turn = 1; turn <= 14; turn += 1) {
+    const tag = String(turn).padStart(2, '0');
+    const included = turn > 14 - work.includedTurns;
+    assert.equal(recent.text.includes(`work-q-${tag}`), included, `user row of turn ${tag}`);
+    assert.equal(recent.text.includes(`work-a-${tag} `), included, `assistant row of turn ${tag}`);
+  }
+  // 残りは recall で引ける。境界は載せた最古ターンの時刻、件数は 10 まで
+  const rest = 14 - work.includedTurns;
+  const oldestIncluded = 14 - work.includedTurns + 1;
+  const boundary = new Date(RECENT_BASE + (10 + oldestIncluded) * RECENT_MINUTE).toISOString();
+  assert.ok(recent.text.includes(`（14ターンのうち新しい${work.includedTurns}ターン / session work）`));
+  assert.ok(
+    recent.text.includes(
+      `- これより前の${rest}ターン: ${rest > 10 ? '新しい10ターンの本文は ' : '本文は '}` +
+        `\`throughline recall --l2 --session work --before ${boundary} --last ${Math.min(rest, 10)}\``,
+    ),
+    recent.text,
+  );
+  // 途中で止まった会話より古い会話は、本文を載せず一覧にする
+  assert.ok(!recent.text.includes('OLDEST_REQUEST'));
+  const afterLast = new Date(RECENT_BASE + RECENT_MINUTE + 30_000 + 1).toISOString();
+  assert.match(
+    recent.text,
+    new RegExp(
+      '### 本文を載せていない過去の会話\\n' +
+        '- \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}〜\\d{2}:\\d{2}（2ターン）: 本文は ' +
+        escapeRegExp(`\`throughline recall --l2 --session oldest --before ${afterLast} --last 2\``) +
+        '$',
+    ),
+  );
+  assert.deepEqual(
+    recent.sessions.map((s) => [s.sessionId, s.role, s.includedTurns]),
+    [['note', 'current', 1], ['work', 'past', work.includedTurns], ['oldest', 'past', 0]],
+  );
+});
+
+test('recent: 現在の会話に載せ残しがある時は、その文を変えず、余りに一覧だけ付ける', () => {
+  const db = makeDb();
+  // 一覧の1行が長くなる session id（余りに入る場合と入らない場合の両方を作る）
+  const pastId = `past-${'p'.repeat(195)}`;
+  insertTurn(db, { session: pastId, turn: 1, user: 'PAST_SHORT_REQUEST', assistant: 'PAST_SHORT_ANSWER', at: RECENT_BASE });
+  for (let turn = 1; turn <= 10; turn += 1) {
+    insertTurn(db, {
+      session: 'long',
+      turn,
+      user: `long-q-${String(turn).padStart(2, '0')}`,
+      assistant: `long-a-${String(turn).padStart(2, '0')} ` + 'x'.repeat(800),
+      at: RECENT_BASE + (10 + turn) * RECENT_MINUTE,
+    });
+  }
+
+  // 現在の会話の文は、過去の会話の有無でも予算でも変わらない
+  const listed = new Set();
+  for (const maxChars of [4600, 4800, 4900, 5000, 5200, 5400, 5600, 5700]) {
+    const latestOnly = buildBudgetedResumeContext(db, {
+      sessionId: 'long',
+      isInheritance: true,
+      handoffDisclosure: 'silent',
+      maxChars,
+    });
+    const recent = buildRecentSessionsContext(db, {
+      sessionIds: ['long', pastId],
+      handoffDisclosure: 'silent',
+      maxChars,
+    });
+    listed.add(recent.sessions.length === 2);
+
+    assert.ok(latestOnly.remainingL2Turns > 0, 'the current session must have turns left for pull');
+    assert.ok(recent.text.length <= maxChars, `length ${recent.text.length} must fit budget ${maxChars}`);
+    assert.equal(recent.sessions[0].includedTurns, latestOnly.injectedL2Turns);
+    // 新しいターンを飛ばして古い会話の本文を載せない
+    assert.ok(!recent.text.includes('PAST_SHORT_REQUEST'));
+    assert.ok(!recent.text.includes('### 過去の会話 '));
+    if (recent.sessions.length === 1) {
+      // 余りに一覧の1行も入らない時は、今と同じ文
+      assert.equal(recent.text, latestOnly.text);
+      continue;
+    }
+    assert.ok(recent.text.startsWith(`${latestOnly.text}\n\n## Throughline: このprojectで記録された過去の会話（新しい順）\n`));
+    assert.ok(recent.text.includes('### 本文を載せていない過去の会話\n'));
+    assert.ok(recent.text.includes(`（1ターン）: 本文は \`throughline recall --l2 --session ${pastId} --before `));
+    assert.deepEqual(recent.sessions.map((s) => [s.sessionId, s.includedTurns]), [
+      ['long', latestOnly.injectedL2Turns],
+      [pastId, 0],
+    ]);
+  }
+  assert.deepEqual([...listed].sort(), [false, true], '一覧が入る予算と入らない予算の両方を確かめる');
+});
+
+test('recent: 同じ origin と turn は新しい会話の1回だけ載せる', () => {
+  const db = makeDb();
+  // 後継の会話 (current) が、前任 (shared) のターンを引き継いで持っている
+  insertTurn(db, { session: 'current', origin: 'shared', turn: 1, user: 'SHARED_REQUEST', assistant: 'SHARED_ANSWER', at: RECENT_BASE });
+  insertTurn(db, { session: 'current', turn: 1, user: '最新の依頼', assistant: '最新の回答', at: RECENT_BASE + 30 * RECENT_MINUTE });
+  // 同じターンの行が別の session にも残っている
+  insertTurn(db, { session: 'copy', origin: 'shared', turn: 1, user: 'SHARED_REQUEST', assistant: 'SHARED_ANSWER', at: RECENT_BASE });
+  insertTurn(db, { session: 'mixed', origin: 'shared', turn: 1, user: 'SHARED_REQUEST', assistant: 'SHARED_ANSWER', at: RECENT_BASE });
+  insertTurn(db, { session: 'mixed', turn: 1, user: 'MIXED_OWN_REQUEST', assistant: 'MIXED_OWN_ANSWER', at: RECENT_BASE - 10 * RECENT_MINUTE });
+
+  const recent = buildRecentSessionsContext(db, {
+    sessionIds: ['current', 'copy', 'mixed'],
+    handoffDisclosure: 'silent',
+  });
+
+  const past = recent.text.slice(recent.text.indexOf('## Throughline: このprojectで記録された過去の会話'));
+  assert.ok(!past.includes('SHARED_REQUEST'));
+  assert.ok(past.includes('MIXED_OWN_REQUEST'));
+  assert.match(past, /（1ターン \/ session mixed）/);
+  // 重なるターンしか持たない会話は、過去の会話に数えない
+  assert.deepEqual(
+    recent.sessions.map((s) => [s.sessionId, s.turns, s.includedTurns]),
+    [['current', 2, 2], ['mixed', 1, 1]],
+  );
+});
+
+test('recent: 一覧は5件までで、それより古い会話があることを書く', () => {
+  const db = makeDb();
+  insertTurn(db, { session: 'current', turn: 1, user: '最新の依頼', assistant: '最新の回答', at: RECENT_BASE + 100 * RECENT_MINUTE });
+  const sessionIds = ['current'];
+  for (let n = 1; n <= 7; n += 1) {
+    // どの会話も最新のターンが予算に入らない
+    insertTurn(db, {
+      session: `big-${n}`,
+      turn: 1,
+      user: `BIG_REQUEST_${n}`,
+      assistant: 'y'.repeat(INJECTION_BUDGET_CHARS),
+      at: RECENT_BASE + (50 - n) * RECENT_MINUTE,
+    });
+    sessionIds.push(`big-${n}`);
+  }
+
+  const recent = buildRecentSessionsContext(db, { sessionIds, handoffDisclosure: 'silent' });
+
+  assert.ok(recent.text.length <= INJECTION_BUDGET_CHARS);
+  assert.ok(!recent.text.includes('BIG_REQUEST_'));
+  const index = recent.text.slice(recent.text.indexOf('### 本文を載せていない過去の会話\n')).split('\n');
+  assert.equal(index.length, 7);
+  for (let n = 1; n <= 5; n += 1) {
+    assert.ok(index[n].includes(`--session big-${n} `), index[n]);
+    assert.ok(index[n].endsWith('--last 1`'), index[n]);
+  }
+  assert.equal(index[6], '- これより古い会話は、この一覧に載せていません。');
+  assert.deepEqual(
+    recent.sessions.map((s) => [s.sessionId, s.includedTurns]),
+    [['current', 1], ['big-1', 0], ['big-2', 0], ['big-3', 0], ['big-4', 0], ['big-5', 0]],
+  );
+});

package/src/sc-detail.mjs

@@ -5,8 +5,11 @@
  * 使い方:
  *   node src/sc-detail.mjs <時刻>
  *   node src/sc-detail.mjs <開始時刻>-<終了時刻>
+ *   node src/sc-detail.mjs <日付>T<時刻>
  *
- * 時刻フォーマット: HH:MM:SS または HH:MM（秒省略可）
+ * 時刻フォーマット: HH:MM:SS または HH:MM（秒省略可）。日付は YYYY-MM-DD。
+ * 日付を省いた時は、今日から1日ずつ遡り、その時刻のターンがある最も新しい日を対象にする
+ * （注入文の [HH:MM:SS] は過去の時刻で、前日以前のことがある）。
  * 複数ターンが同一時刻にヒットする場合は全部返す。
  *
  * 出力: 指定時刻のターン（または範囲内の全ターン）の L2 (bodies) + L3 (details)
@@ -22,10 +25,14 @@ import { getDb } from './db.mjs';
 import { DETAIL_KIND, DETAIL_KIND_VALUES } from './constants.mjs';
 
 function parseTimeArg(arg) {
-  const m = String(arg || '').trim().match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+  const m = String(arg || '')
+    .trim()
+    .match(/^(?:(\d{4})-(\d{2})-(\d{2})[T ])?(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
   if (!m) return null;
-  const [, hh, mm, ss] = m;
+  const [, year, month, day, hh, mm, ss] = m;
   return {
+    // null = 日付指定なし（今日から遡って探す）
+    date: year != null ? { year: Number(year), month: Number(month), day: Number(day) } : null,
     hours: Number(hh),
     minutes: Number(mm),
     seconds: ss != null ? Number(ss) : null, // null = 秒指定なし（その分内すべて）
@@ -33,35 +40,42 @@ function parseTimeArg(arg) {
 }
 
 /**
- * 指定時刻（HH:MM:SS）の当日タイムスタンプ（ms）を返す。
- * 秒が null の場合は start=00, end=59 の範囲を返す（呼び出し側で使い分け）。
+ * 時刻の指定を解釈する。範囲は `<開始>-<終了>`。終了の日付を省くと開始と同じ日になる。
+ * @returns {{ from: object, to: object } | null}
  */
-function timeToUnixRange(t, baseDate = new Date()) {
-  const y = baseDate.getFullYear();
-  const mo = baseDate.getMonth();
-  const d = baseDate.getDate();
-  const secStart = t.seconds != null ? t.seconds : 0;
-  const secEnd = t.seconds != null ? t.seconds : 59;
-  const start = new Date(y, mo, d, t.hours, t.minutes, secStart, 0).getTime();
-  const end = new Date(y, mo, d, t.hours, t.minutes, secEnd, 999).getTime();
-  return { start, end };
+export function parseDetailArg(arg) {
+  const s = String(arg || '').trim();
+  const single = parseTimeArg(s);
+  if (single) return { from: single, to: single };
+  // 日付にも `-` があるので、時刻の直後の `-` で開始と終了を分ける
+  const m = s.match(/^(.*?\d:\d{2}(?::\d{2})?)\s*-\s*(.+)$/);
+  if (!m) return null;
+  const from = parseTimeArg(m[1]);
+  const to = parseTimeArg(m[2]);
+  if (!from || !to) return null;
+  return { from, to: to.date ? to : { ...to, date: from.date } };
 }
 
-function parseRangeArg(arg) {
-  const s = String(arg || '').trim();
-  if (!s.includes('-')) {
-    const t = parseTimeArg(s);
-    if (!t) return null;
-    const r = timeToUnixRange(t);
-    return { start: r.start, end: r.end };
-  }
-  const [lo, hi] = s.split('-').map((x) => x.trim());
-  const tLo = parseTimeArg(lo);
-  const tHi = parseTimeArg(hi);
-  if (!tLo || !tHi) return null;
-  const rLo = timeToUnixRange(tLo);
-  const rHi = timeToUnixRange(tHi);
-  return { start: rLo.start, end: rHi.end };
+/**
+ * 時刻の指定を、日付 base（年月日だけを使う）の上のタイムスタンプ範囲（ms）にする。
+ * 秒が null の場合は、開始は 00 秒、終了は 59 秒までを含める。
+ */
+export function detailRangeOn(spec, base) {
+  const at = (t, endOfUnit) => {
+    const date = t.date ?? { year: base.getFullYear(), month: base.getMonth() + 1, day: base.getDate() };
+    const seconds = t.seconds != null ? t.seconds : endOfUnit ? 59 : 0;
+    return new Date(
+      date.year, date.month - 1, date.day, t.hours, t.minutes, seconds, endOfUnit ? 999 : 0,
+    ).getTime();
+  };
+  return { start: at(spec.from, false), end: at(spec.to, true) };
+}
+
+function formatDate(unixMs) {
+  const d = new Date(unixMs);
+  const mo = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${d.getFullYear()}-${mo}-${day}`;
 }
 
 function formatTime(unixMs) {
@@ -82,13 +96,15 @@ export function run(args) {
   if (!arg) {
     process.stderr.write(
       '使い方: throughline detail <HH:MM:SS>\n' +
-        '       throughline detail <HH:MM:SS>-<HH:MM:SS>\n',
+        '       throughline detail <HH:MM:SS>-<HH:MM:SS>\n' +
+        '       throughline detail <YYYY-MM-DD>T<HH:MM:SS>\n' +
+        '日付を省くと、今日から遡って、その時刻のターンがある最も新しい日を探します。\n',
     );
     process.exit(1);
   }
 
-  const range = parseRangeArg(arg);
-  if (!range) {
+  const spec = parseDetailArg(arg);
+  if (!spec) {
     process.stderr.write(`[sc-detail] 時刻フォーマットが無効: ${arg}\n`);
     process.exit(1);
   }
@@ -98,16 +114,39 @@ export function run(args) {
 
   // 指定時刻範囲内のターンを bodies から取得（project_path でフィルタ）
   // bodies と sessions を JOIN して同プロジェクトに絞る
-  const bodyRows = db
-    .prepare(
-      `SELECT b.session_id, b.origin_session_id, b.turn_number, b.role, b.text, b.created_at
-       FROM bodies b
-       JOIN sessions s ON s.session_id = b.session_id
-       WHERE lower(s.project_path) = lower(?)
-         AND b.created_at BETWEEN ? AND ?
-       ORDER BY b.created_at ASC, b.role ASC`,
-    )
-    .all(projectPath, range.start, range.end);
+  const bodyStmt = db.prepare(
+    `SELECT b.session_id, b.origin_session_id, b.turn_number, b.role, b.text, b.created_at
+     FROM bodies b
+     JOIN sessions s ON s.session_id = b.session_id
+     WHERE lower(s.project_path) = lower(?)
+       AND b.created_at BETWEEN ? AND ?
+     ORDER BY b.created_at ASC, b.role ASC`,
+  );
+
+  let bodyRows = [];
+  if (spec.from.date) {
+    const range = detailRangeOn(spec, new Date());
+    bodyRows = bodyStmt.all(projectPath, range.start, range.end);
+  } else {
+    // 日付の指定が無い時は、今日から1日ずつ遡り、最初にターンが見つかった日を対象にする。
+    // この project の最古の本文より前までは探さない。
+    const oldest = db
+      .prepare(
+        `SELECT MIN(b.created_at) AS oldest
+         FROM bodies b
+         JOIN sessions s ON s.session_id = b.session_id
+         WHERE lower(s.project_path) = lower(?)`,
+      )
+      .get(projectPath)?.oldest;
+    const today = new Date();
+    for (let back = 0; oldest != null; back += 1) {
+      const day = new Date(today.getFullYear(), today.getMonth(), today.getDate() - back);
+      const range = detailRangeOn(spec, day);
+      if (range.end < oldest) break;
+      bodyRows = bodyStmt.all(projectPath, range.start, range.end);
+      if (bodyRows.length > 0) break;
+    }
+  }
 
   if (bodyRows.length === 0) {
     process.stdout.write(
@@ -115,6 +154,9 @@ export function run(args) {
     );
     process.exit(0);
   }
+  // 今日以外の日のターンを返す時は、どの日のターンかを明示する
+  const foundDate = formatDate(bodyRows[0].created_at);
+  const dateNote = !spec.from.date && foundDate !== formatDate(Date.now()) ? `（${foundDate}）` : '';
 
   // ターン単位でグルーピング（同じ session_id + origin + turn_number）
   const turnKeys = new Set();
@@ -124,7 +166,7 @@ export function run(args) {
 
   const lines = [];
   lines.push('## Throughline /sc-detail');
-  lines.push(`指定時刻: ${arg}  対象ターン数: ${turnKeys.size}`);
+  lines.push(`指定時刻: ${arg}${dateNote}  対象ターン数: ${turnKeys.size}`);
   lines.push('');
 
   // L2 を時刻順に出力

package/src/sc-detail.test.mjs

@@ -0,0 +1,184 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+
+import { detailRangeOn, parseDetailArg } from './sc-detail.mjs';
+
+const REPO_ROOT = fileURLToPath(new URL('..', import.meta.url));
+const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
+
+function pad(n) {
+  return String(n).padStart(2, '0');
+}
+
+function clock(date) {
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+function ymd(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/** 今日から daysAgo 日前の、指定した時刻。 */
+function daysAgoAt(daysAgo, hours, minutes, seconds) {
+  const now = new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate() - daysAgo, hours, minutes, seconds);
+}
+
+function createBox() {
+  const home = mkdtempSync(join(tmpdir(), 'tl-sc-detail-'));
+  const project = join(home, 'project');
+  mkdirSync(project);
+  const env = {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: join(home, '.config'),
+    XDG_STATE_HOME: join(home, '.local', 'state'),
+  };
+  const run = (args) =>
+    spawnSync(process.execPath, [BIN_PATH, 'detail', ...args], { cwd: project, env, encoding: 'utf8' });
+  // detail は cwd の project だけを対象にする。子 process から見える cwd をそのまま記録する
+  const cwd = spawnSync(process.execPath, ['-e', 'process.stdout.write(process.cwd())'], {
+    cwd: project, env, encoding: 'utf8',
+  }).stdout;
+  // 最初の実行で製品の schema が作られる
+  assert.equal(run(['00:00']).status, 0);
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  db.prepare(
+    `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+     VALUES ('detail-session', ?, 'active', 1, 1)`,
+  ).run(cwd);
+  const insertBody = db.prepare(
+    `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES ('detail-session', 'detail-session', ?, ?, ?, 1, ?)`,
+  );
+  const insertDetail = 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 ('detail-session', 'detail-session', ?, 'Bash', ?, NULL, 1, ?, 'tool_input', ?)`,
+  );
+  let turn = 0;
+  const addTurn = (date, label) => {
+    turn += 1;
+    insertBody.run(turn, 'user', `${label}_REQUEST`, date.getTime());
+    insertBody.run(turn, 'assistant', `${label}_ANSWER`, date.getTime() + 400);
+    insertDetail.run(turn, `${label}_COMMAND`, date.getTime() + 200, `tool-${turn}`);
+  };
+  return { home, run, addTurn, close: () => db.close() };
+}
+
+test('parseDetailArg: 時刻だけ、日付つき、範囲を解釈する', () => {
+  assert.deepEqual(parseDetailArg('19:20:25'), {
+    from: { date: null, hours: 19, minutes: 20, seconds: 25 },
+    to: { date: null, hours: 19, minutes: 20, seconds: 25 },
+  });
+  assert.deepEqual(parseDetailArg('9:05').from, { date: null, hours: 9, minutes: 5, seconds: null });
+  const date = { year: 2026, month: 10, day: 4 };
+  assert.deepEqual(parseDetailArg('2026-10-04T19:20:25').from, { date, hours: 19, minutes: 20, seconds: 25 });
+  assert.deepEqual(parseDetailArg('2026-10-04 19:20').from, { date, hours: 19, minutes: 20, seconds: null });
+  // 範囲: 終了の日付を省くと開始と同じ日
+  assert.deepEqual(parseDetailArg('19:20:25-19:30:00'), {
+    from: { date: null, hours: 19, minutes: 20, seconds: 25 },
+    to: { date: null, hours: 19, minutes: 30, seconds: 0 },
+  });
+  assert.deepEqual(parseDetailArg('2026-10-04T23:50:00-23:59:59'), {
+    from: { date, hours: 23, minutes: 50, seconds: 0 },
+    to: { date, hours: 23, minutes: 59, seconds: 59 },
+  });
+  assert.deepEqual(parseDetailArg('2026-10-04T23:50:00-2026-10-05T00:10:00').to, {
+    date: { year: 2026, month: 10, day: 5 }, hours: 0, minutes: 10, seconds: 0,
+  });
+  for (const invalid of ['', 'abc', '19', '2026-10-04', '2026-10-04T', '19:20:25-', '19:20:25-abc', '10-04T19:20:25']) {
+    assert.equal(parseDetailArg(invalid), null, invalid);
+  }
+});
+
+test('detailRangeOn: 日付の無い時刻は渡した日に、日付つきはその日に置く', () => {
+  const base = new Date(2026, 9, 5, 3, 0, 0);
+  assert.deepEqual(detailRangeOn(parseDetailArg('19:20:25'), base), {
+    start: new Date(2026, 9, 5, 19, 20, 25, 0).getTime(),
+    end: new Date(2026, 9, 5, 19, 20, 25, 999).getTime(),
+  });
+  // 秒を省くと、その分の全部
+  assert.deepEqual(detailRangeOn(parseDetailArg('19:20'), base), {
+    start: new Date(2026, 9, 5, 19, 20, 0, 0).getTime(),
+    end: new Date(2026, 9, 5, 19, 20, 59, 999).getTime(),
+  });
+  assert.deepEqual(detailRangeOn(parseDetailArg('2026-10-04T19:20:25-19:30'), base), {
+    start: new Date(2026, 9, 4, 19, 20, 25, 0).getTime(),
+    end: new Date(2026, 9, 4, 19, 30, 59, 999).getTime(),
+  });
+});
+
+test('detail: 日付を省いた時刻は、今日に無ければ遡って最も新しい日のターンを返す', () => {
+  const box = createBox();
+  try {
+    const yesterday = daysAgoAt(1, 19, 20, 25);
+    const older = daysAgoAt(3, 19, 20, 25);
+    box.addTurn(older, 'OLDER');
+    box.addTurn(yesterday, 'YESTERDAY');
+    box.close();
+
+    const bare = box.run([clock(yesterday)]);
+    assert.equal(bare.status, 0, bare.stderr);
+    assert.match(bare.stdout, new RegExp(`指定時刻: 19:20:25（${ymd(yesterday)}）  対象ターン数: 1\\n`));
+    assert.match(bare.stdout, /\[19:20:25\] \[user\]: YESTERDAY_REQUEST/);
+    assert.match(bare.stdout, /YESTERDAY_ANSWER/);
+    assert.match(bare.stdout, /IN {2}Bash\n {2}IN: {2}YESTERDAY_COMMAND/);
+    // 同じ時刻のもっと古い日のターンは混ぜない
+    assert.doesNotMatch(bare.stdout, /OLDER_/);
+
+    // 日付を付ければ、その日のターンを引ける
+    const dated = box.run([`${ymd(older)}T19:20:25`]);
+    assert.equal(dated.status, 0, dated.stderr);
+    assert.match(dated.stdout, new RegExp(`指定時刻: ${ymd(older)}T19:20:25  対象ターン数: 1\\n`));
+    assert.match(dated.stdout, /OLDER_REQUEST/);
+    assert.match(dated.stdout, /OLDER_COMMAND/);
+    assert.doesNotMatch(dated.stdout, /YESTERDAY_/);
+
+    const range = box.run([`${ymd(older)}T19:20-19:21`]);
+    assert.equal(range.status, 0, range.stderr);
+    assert.match(range.stdout, /OLDER_REQUEST/);
+    assert.doesNotMatch(range.stdout, /YESTERDAY_/);
+  } finally {
+    rmSync(box.home, { recursive: true, force: true });
+  }
+});
+
+test('detail: 今日のターンはそのまま返し、無い時刻と無効な書き方は今までどおり知らせる', () => {
+  const box = createBox();
+  try {
+    const earlier = daysAgoAt(2, 8, 15, 0);
+    // 今日の 00:00:00 は、いつ実行しても過去の時刻
+    const today = daysAgoAt(0, 0, 0, 0);
+    box.addTurn(earlier, 'EARLIER');
+    box.addTurn(today, 'TODAY');
+    box.close();
+
+    const found = box.run(['00:00:00']);
+    assert.equal(found.status, 0, found.stderr);
+    assert.match(found.stdout, /指定時刻: 00:00:00 {2}対象ターン数: 1\n/);
+    assert.match(found.stdout, /TODAY_REQUEST/);
+
+    // この project の記録に無い時刻
+    const missing = box.run(['13:13:13']);
+    assert.equal(missing.status, 0, missing.stderr);
+    assert.match(missing.stdout, /指定時刻 13:13:13 に該当するターンが見つかりませんでした。/);
+    // 日付を付けた時は、その日だけを見る
+    const wrongDay = box.run([`${ymd(daysAgoAt(1, 0, 0, 0))}T08:15:00`]);
+    assert.equal(wrongDay.status, 0, wrongDay.stderr);
+    assert.match(wrongDay.stdout, /に該当するターンが見つかりませんでした。/);
+
+    const invalid = box.run(['yesterday']);
+    assert.equal(invalid.status, 1);
+    assert.match(invalid.stderr, /時刻フォーマットが無効: yesterday/);
+  } finally {
+    rmSync(box.home, { recursive: true, force: true });
+  }
+});