throughline 0.3.24 → 0.3.25

package/src/resume-context.mjs

@@ -13,10 +13,12 @@
  *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（created_at ベース、DB 永続）
  *   - 末尾に /sc-detail <時刻> ガイドを追記
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
- *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更 (B 案)
+ *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更する。
+ *     冒頭と末尾の両方に current-work instruction を置き、長文 context 内でも
+ *     L1/L2 を現在タスク用の作業文脈として読むよう誘導する。
  */
 
-const N_RECENT_L2 = 20;
+import { buildHandoffRecord, N_RECENT_L2 } from './handoff-record.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
@@ -30,6 +32,19 @@ const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
   `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
 
+const ACTIVE_WORK_READING_CONTRACT =
+  `\n` +
+  `**読み方の契約:**\n` +
+  `- これは単なる過去ログではなく、現在進行中の作業を再開するための active work context です。\n` +
+  `- L2 は古い順に並んだ作業履歴です。後の発言・判断・TODO は前の仮説や作業方針を上書きし得ます。\n` +
+  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2、in-flight メモ、最終ターン thinking を優先して現在状態を推定してください。\n` +
+  `- 不足している tool output / 詳細根拠が必要なときだけ、末尾の \`throughline detail <時刻>\` を使って L3 を取得してください。`;
+
+const CONTINUATION_REMINDER =
+  '**再開指示:** 上記の L1 / L2 / thinking / in-flight メモを、現在タスクに使う作業コンテキストとして扱ってください。' +
+  '最新の L2、in-flight メモ、最終ターン thinking から次の一手を決め、中断地点から続行してください。' +
+  '古い仮説や未完了 TODO は、後続の判断で上書きされ得ます。';
+
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
 const FOOTER_GUIDE =
@@ -43,67 +58,6 @@ const FOOTER_GUIDE =
   '返る内容: 指定ターンの 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);
-
-  // 最新 (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 注入テキストを組み立てる。
  *
@@ -120,107 +74,57 @@ export function buildResumeContext(
   db,
   { sessionId, isInheritance, excludeOriginId = null, inflightMemo = 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;
+  const record = buildHandoffRecord(db, {
+    sessionId,
+    isInheritance,
+    excludeOriginId,
+    inflightMemo,
+  });
+  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.inflightMemo) {
     lines.push('');
     lines.push('### 中断直前の in-flight メモ（前セッションの Claude 自身による要約）');
-    lines.push(inflightMemo.trim());
+    lines.push(record.memory.inflightMemo);
   }
 
-  if (thinkingRows.length > 0) {
+  if (record.memory.latestThinking.length > 0) {
     lines.push('');
     lines.push('### 中断直前の思考 (最終ターンの extended thinking)');
-    for (const r of thinkingRows) {
-      lines.push(`[${formatTime(r.created_at)}] ${r.output_text}`);
+    for (const r of record.memory.latestThinking) {
+      lines.push(`[${r.time}] ${r.text}`);
     }
   }
 
-  if (l1Rows.length > 0) {
+  if (record.memory.l1Summaries.length > 0) {
     lines.push('');
     lines.push('### それ以前の要約 (L1)');
-    for (const r of l1Rows) {
+    for (const r of record.memory.l1Summaries) {
       if (!r.summary || r.summary === '(no content)') continue;
-      lines.push(`[${formatTime(r.created_at)}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
+      lines.push(`[${r.time}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
     }
   }
 
-  if (bodyRows.length > 0) {
+  if (record.memory.recentBodies.length > 0) {
     lines.push('');
-    lines.push('### 直近のターン履歴 (L2)');
-    for (const r of bodyRows) {
+    lines.push('### 現在進行中の作業履歴 (L2 / active work thread)');
+    lines.push('以下は古い順です。後の行ほど現在状態に近く、前の仮説を上書きし得ます。');
+    for (const r of record.memory.recentBodies) {
       if (!r.text) continue;
-      lines.push(`[${formatTime(r.created_at)}] [${r.role}]: ${r.text}`);
+      lines.push(`[${r.time}] [${r.role}]: ${r.text}`);
     }
   }
 
   lines.push('');
   lines.push(FOOTER_GUIDE);
+  lines.push('');
+  lines.push(CONTINUATION_REMINDER);
 
   return lines.join('\n');
 }

package/src/resume-context.test.mjs

@@ -0,0 +1,172 @@
+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 memo -> thinking -> L1 -> L2 -> footer', () => {
+  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,
+  });
+  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: '**Next**: keep going',
+  });
+
+  assert.ok(text);
+  assert.match(text, /^## Throughline: 中断した作業の再開/);
+
+  const memoIdx = text.indexOf('### 中断直前の in-flight メモ');
+  const thinkingIdx = text.indexOf('### 中断直前の思考');
+  const l1Idx = text.indexOf('### それ以前の要約 (L1)');
+  const l2Idx = text.indexOf('### 現在進行中の作業履歴 (L2 / active work thread)');
+  const footerIdx = text.indexOf('**[Claude 向け — 記憶の使い方]**');
+
+  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(l2Idx > l1Idx, 'L2 should follow L1');
+  assert.ok(footerIdx > l2Idx, 'footer should follow L2');
+
+  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'));
+  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', () => {
+  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

@@ -25,6 +25,7 @@ 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';
 
 function logDecision(entry) {
   const path = join(homedir(), '.throughline', 'logs', 'inheritance-decision.log');
@@ -37,7 +38,7 @@ function logDecision(entry) {
   }
 }
 
-async function main() {
+export async function run() {
   let raw = '';
   await new Promise((resolve) => {
     process.stdin.setEncoding('utf8');
@@ -118,7 +119,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);
+  });
+}

package/src/state-file.mjs

@@ -2,12 +2,12 @@
  * state-file.mjs — セッション単位の状態ファイル管理（共有モジュール）
  *
  * パス: ~/.throughline/state/<session_id>.json
- * 書き手: turn-processor (Stop)
+ * 書き手: turn-processor (Claude Stop), codex-hook (Codex Stop)
  * 読み手: token-monitor
  *
  * 設計判断 (docs/PUBLIC_RELEASE_PLAN.md §4.5/4.6):
  *   - ファイル単位分割で last-writer-wins 問題を解消
- *   - PID 生存チェックで stale 削除（時間窓は使わない）
+ *   - updatedAt ベースで stale 判定（短命 hook process の PID には依存しない）
  *   - projectPath は path.resolve → / → 末尾 / 除去 → Windows lowercase で正規化
  */
 
@@ -37,21 +37,43 @@ export function normalizeProjectPath(p) {
 
 /**
  * セッション状態ファイルを書く
- * @param {{sessionId: string, projectPath: string, transcriptPath: string, pid: number, usage?: object|null}} data
+ * @param {{
+ *   sessionId: string,
+ *   projectPath: string,
+ *   transcriptPath?: string|null,
+ *   rolloutPath?: string|null,
+ *   pid?: number,
+ *   usage?: object|null,
+ *   host?: 'claude'|'codex',
+ * }} data
  *
  * usage: monitor が表示する tokens/model/contextWindowSize をここに固定保存する。
  * Stop hook が readLatestUsage の結果を載せることで、monitor 側が毎フレーム JSONL を
  * 再スキャンする必要がなくなる。旧バージョン互換のため optional (無ければ monitor が
  * transcriptPath を読んでフォールバック)。
  */
-export function writeSessionState({ sessionId, projectPath, transcriptPath, pid, usage }) {
+export function writeSessionState({
+  sessionId,
+  projectPath,
+  transcriptPath,
+  rolloutPath,
+  pid,
+  usage,
+  host,
+}) {
   if (!sessionId) throw new Error('writeSessionState: sessionId is required');
+  const normalizedHost = normalizeHost(host);
+  if (host && normalizedHost === 'unknown') {
+    throw new Error(`writeSessionState: unsupported host ${host}`);
+  }
   if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
-  const file = join(STATE_DIR, `${sessionId}.json`);
+  const file = join(STATE_DIR, stateFilename(sessionId));
   const payload = {
     sessionId,
+    host: normalizedHost === 'unknown' ? 'claude' : normalizedHost,
     projectPath: normalizeProjectPath(projectPath),
     transcriptPath: transcriptPath ?? null,
+    rolloutPath: rolloutPath ?? null,
     pid: pid ?? process.pid,
     updatedAt: Date.now(),
   };
@@ -69,7 +91,7 @@ export const STALE_DELETE_MS = 24 * 60 * 60 * 1000; // 24 時間: ファイル
 /**
  * 全セッション状態を読む。24 時間超のファイルは削除、壊れたファイルも削除する。
  * 15 分超のファイルは「stale」フラグを付けて返す（monitor 側で隠す判断をする）。
- * @returns {Array<{sessionId: string, projectPath: string, transcriptPath: string|null, updatedAt: number, stale: boolean}>}
+ * @returns {Array<{sessionId: string, host: string, projectPath: string, transcriptPath: string|null, rolloutPath: string|null, updatedAt: number, stale: boolean}>}
  */
 export function readAllSessionStates() {
   if (!existsSync(STATE_DIR)) return [];
@@ -112,6 +134,7 @@ export function readAllSessionStates() {
       }
       continue;
     }
+    parsed = normalizeState(parsed);
     const age = now - (parsed.updatedAt ?? 0);
     if (age > STALE_DELETE_MS) {
       // 24h 超: ハード削除（無制限蓄積防止）
@@ -128,6 +151,27 @@ export function readAllSessionStates() {
   return results;
 }
 
+function stateFilename(sessionId) {
+  return `${encodeURIComponent(sessionId)}.json`;
+}
+
+function normalizeHost(host) {
+  if (host === undefined || host === null || host === '') return 'claude';
+  if (host === 'claude' || host === 'codex') return host;
+  return 'unknown';
+}
+
+function normalizeState(parsed) {
+  const host = normalizeHost(parsed?.host);
+  return {
+    ...parsed,
+    host,
+    projectPath: normalizeProjectPath(parsed?.projectPath ?? ''),
+    transcriptPath: parsed?.transcriptPath ?? null,
+    rolloutPath: parsed?.rolloutPath ?? null,
+  };
+}
+
 /**
  * ファイル単位の mtime スナップショットを取る（差分検知用）
  * @returns {Map<string, number>}

package/src/state-file.test.mjs

@@ -146,11 +146,58 @@ test('writeSessionState: usage 付きで書くと JSON に含まれる', async (
     const results = mod.readAllSessionStates();
     assert.equal(results.length, 1);
     assert.ok(results[0].usage);
+    assert.equal(results[0].host, 'claude');
+    assert.equal(results[0].rolloutPath, null);
     assert.equal(results[0].usage.tokens, 123);
     assert.equal(results[0].usage.model, 'claude-opus-4-6');
   });
 });
 
+test('writeSessionState: Codex state は host と rolloutPath を保持しファイル名を encode する', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    mod.writeSessionState({
+      sessionId: 'codex:019dfaba-thread',
+      host: 'codex',
+      projectPath: '/tmp/x',
+      transcriptPath: null,
+      rolloutPath: '/tmp/codex/rollout.jsonl',
+      pid: 1,
+      usage: {
+        tokens: 123,
+        model: 'codex',
+        contextWindowSize: 258400,
+        contextWindowEstimated: false,
+        outputTokens: 10,
+        estimated: false,
+        source: 'codex-rollout-token-count',
+      },
+    });
+
+    assert.deepEqual(readdirSync(stateDir), ['codex%3A019dfaba-thread.json']);
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.equal(results[0].sessionId, 'codex:019dfaba-thread');
+    assert.equal(results[0].host, 'codex');
+    assert.equal(results[0].transcriptPath, null);
+    assert.equal(results[0].rolloutPath, '/tmp/codex/rollout.jsonl');
+    assert.equal(results[0].usage.source, 'codex-rollout-token-count');
+  });
+});
+
+test('writeSessionState: unsupported host は throw する', async () => {
+  await withIsolatedStateDir(async ({ mod }) => {
+    assert.throws(
+      () =>
+        mod.writeSessionState({
+          sessionId: 'sess-bad-host',
+          host: 'unknown-host',
+          projectPath: '/tmp/x',
+        }),
+      /unsupported host/,
+    );
+  });
+});
+
 test('writeSessionState: usage 無しで書いたらフィールド自体が無い (旧フォーマット互換)', async () => {
   await withIsolatedStateDir(async ({ stateDir, mod }) => {
     mod.writeSessionState({
@@ -162,6 +209,7 @@ test('writeSessionState: usage 無しで書いたらフィールド自体が無
     const results = mod.readAllSessionStates();
     assert.equal(results.length, 1);
     assert.equal(results[0].usage, undefined);
+    assert.equal(results[0].host, 'claude');
   });
 });
 
@@ -178,6 +226,8 @@ test('readAllSessionStates: 旧バージョンが書いた usage 無しの state
     }));
     const results = mod.readAllSessionStates();
     assert.equal(results.length, 1);
+    assert.equal(results[0].host, 'claude');
+    assert.equal(results[0].rolloutPath, null);
     assert.equal(results[0].usage, undefined);
     // usage 無しで読めること自体が互換性の証明
   });