throughline 0.3.0 → 0.3.1

package/bin/throughline.mjs

@@ -36,7 +36,7 @@ switch (cmd) {
     await import('../src/prompt-submit.mjs');
     break;
   case 'monitor':
-    await import('../src/token-monitor.mjs');
+    (await import('../src/token-monitor.mjs')).main();
     break;
   case 'detail':
     (await import('../src/sc-detail.mjs')).run(rest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [

package/src/state-file.mjs

@@ -68,25 +68,52 @@ export const STALE_DELETE_MS = 24 * 60 * 60 * 1000; // 24 時間: ファイル
 export function readAllSessionStates() {
   if (!existsSync(STATE_DIR)) return [];
   const now = Date.now();
-  const entries = readdirSync(STATE_DIR);
+  let entries;
+  try {
+    entries = readdirSync(STATE_DIR);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    process.stderr.write(`[state-file] readdir failed (${err.code ?? 'unknown'}): ${err.message}\n`);
+    return [];
+  }
   const results = [];
   for (const name of entries) {
     if (!name.endsWith('.json')) continue;
     const file = join(STATE_DIR, name);
-    const raw = readFileSync(file, 'utf8');
+
+    // 常駐 monitor を落とさないため IO 例外は吸収する。
+    // ENOENT: 削除 race、EACCES/EPERM: 一時的権限問題、いずれも skip して次フレームで再試行
+    let raw;
+    try {
+      raw = readFileSync(file, 'utf8');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        process.stderr.write(`[state-file] read failed ${name} (${err.code ?? 'unknown'}): ${err.message}\n`);
+      }
+      continue;
+    }
+
     let parsed;
     try {
       parsed = JSON.parse(raw);
     } catch (err) {
       // JSON 破損は状態ファイル固有の冪等な状況（次ターンで再生成される）
       process.stderr.write(`[state-file] corrupt state file ${name}, deleting: ${err.message}\n`);
-      unlinkSync(file);
+      try {
+        unlinkSync(file);
+      } catch {
+        // 削除失敗も握りつぶす（次回削除される）
+      }
       continue;
     }
     const age = now - (parsed.updatedAt ?? 0);
     if (age > STALE_DELETE_MS) {
       // 24h 超: ハード削除（無制限蓄積防止）
-      unlinkSync(file);
+      try {
+        unlinkSync(file);
+      } catch {
+        // 削除失敗は致命ではない、次回再試行
+      }
       continue;
     }
     parsed.stale = age > STALE_HIDE_MS;
@@ -102,15 +129,25 @@ export function readAllSessionStates() {
 export function snapshotStateMtimes() {
   const result = new Map();
   if (!existsSync(STATE_DIR)) return result;
-  for (const name of readdirSync(STATE_DIR)) {
+  let entries;
+  try {
+    entries = readdirSync(STATE_DIR);
+  } catch (err) {
+    if (err.code === 'ENOENT') return result;
+    process.stderr.write(`[state-file] snapshot readdir failed (${err.code ?? 'unknown'}): ${err.message}\n`);
+    return result;
+  }
+  for (const name of entries) {
     if (!name.endsWith('.json')) continue;
     // readdir と stat の間でファイルが削除される race がある。
-    // ENOENT のみ許容してそれ以外は throw（§0）
+    // monitor を落とさないため ENOENT 以外の IO 例外も吸収する（EACCES/EPERM 等は一時的で次フレームで回復）
     const file = join(STATE_DIR, name);
     try {
       result.set(name, statSync(file).mtimeMs);
     } catch (err) {
-      if (err.code !== 'ENOENT') throw err;
+      if (err.code !== 'ENOENT') {
+        process.stderr.write(`[state-file] stat failed ${name} (${err.code ?? 'unknown'}): ${err.message}\n`);
+      }
     }
   }
   return result;

package/src/state-file.test.mjs

@@ -0,0 +1,135 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, chmodSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir, homedir, platform } from 'node:os';
+
+import { normalizeProjectPath } from './state-file.mjs';
+
+// state-file.mjs は ~/.throughline/state を直接見るので、モジュール全体を一時ディレクトリ指定で
+// 差し替える薄いヘルパーを用意する。HOME 環境変数を偽装して import し直す方式で隔離する。
+async function withIsolatedStateDir(testFn) {
+  const work = mkdtempSync(join(tmpdir(), 'tl-state-'));
+  const origHome = process.env.HOME;
+  const origUserProfile = process.env.USERPROFILE;
+  process.env.HOME = work;
+  process.env.USERPROFILE = work;
+  // ESM キャッシュをバイパスするため query string 付きで import
+  const mod = await import(`./state-file.mjs?isolated=${Date.now()}-${Math.random()}`);
+  const stateDir = mod.getStateDir();
+  mkdirSync(stateDir, { recursive: true });
+  try {
+    await testFn({ stateDir, mod });
+  } finally {
+    process.env.HOME = origHome;
+    process.env.USERPROFILE = origUserProfile;
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+test('normalizeProjectPath: 空文字列は空文字列', () => {
+  assert.equal(normalizeProjectPath(''), '');
+  assert.equal(normalizeProjectPath(null), '');
+  assert.equal(normalizeProjectPath(undefined), '');
+});
+
+test('normalizeProjectPath: バックスラッシュがスラッシュになり末尾スラッシュ除去', () => {
+  const result = normalizeProjectPath('C:\\Users\\foo\\');
+  assert.ok(result.includes('/'));
+  assert.ok(!result.endsWith('/') || result === '/');
+});
+
+test('normalizeProjectPath: Windows では lowercase', () => {
+  if (platform() !== 'win32') return;
+  const result = normalizeProjectPath('C:\\Users\\Foo');
+  assert.equal(result, result.toLowerCase());
+});
+
+test('readAllSessionStates: 破損 JSON を削除して skip する', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    const broken = join(stateDir, 'broken-abc.json');
+    const good = join(stateDir, 'good-session.json');
+    writeFileSync(broken, '{ not valid json');
+    writeFileSync(good, JSON.stringify({
+      sessionId: 'good-session',
+      projectPath: '/tmp/foo',
+      transcriptPath: null,
+      updatedAt: Date.now(),
+    }));
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.equal(results[0].sessionId, 'good-session');
+    // 破損ファイルは削除されている
+    assert.ok(!existsSync(broken), 'corrupt file should be unlinked');
+  });
+});
+
+test('readAllSessionStates: 24h 超のファイルはハード削除される', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    const old = join(stateDir, 'old-session.json');
+    const past = Date.now() - (25 * 60 * 60 * 1000); // 25h 前
+    writeFileSync(old, JSON.stringify({
+      sessionId: 'old-session',
+      projectPath: '/tmp/foo',
+      transcriptPath: null,
+      updatedAt: past,
+    }));
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 0);
+    assert.ok(!existsSync(old), 'old file should be deleted');
+  });
+});
+
+test('readAllSessionStates: 15 分超は stale フラグ付きで返される', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    const stale = join(stateDir, 'stale-session.json');
+    const past = Date.now() - (20 * 60 * 1000); // 20 分前
+    writeFileSync(stale, JSON.stringify({
+      sessionId: 'stale-session',
+      projectPath: '/tmp/foo',
+      transcriptPath: null,
+      updatedAt: past,
+    }));
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.equal(results[0].stale, true);
+  });
+});
+
+test('readAllSessionStates: state ディレクトリ未作成なら空配列', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    rmSync(stateDir, { recursive: true, force: true });
+    const results = mod.readAllSessionStates();
+    assert.deepEqual(results, []);
+  });
+});
+
+test('snapshotStateMtimes: 存在する JSON の mtime を返す', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    const file = join(stateDir, 'abc.json');
+    writeFileSync(file, '{}');
+    const snap = mod.snapshotStateMtimes();
+    assert.equal(snap.size, 1);
+    assert.ok(snap.has('abc.json'));
+    assert.ok(typeof snap.get('abc.json') === 'number');
+  });
+});
+
+test('snapshotStateMtimes: .json 以外は無視', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    writeFileSync(join(stateDir, 'ignored.txt'), 'hello');
+    writeFileSync(join(stateDir, 'abc.json'), '{}');
+    const snap = mod.snapshotStateMtimes();
+    assert.equal(snap.size, 1);
+    assert.ok(snap.has('abc.json'));
+    assert.ok(!snap.has('ignored.txt'));
+  });
+});
+
+test('snapshotStateMtimes: ディレクトリ未作成なら空 Map', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    rmSync(stateDir, { recursive: true, force: true });
+    const snap = mod.snapshotStateMtimes();
+    assert.equal(snap.size, 0);
+  });
+});

package/src/token-monitor.mjs

@@ -18,9 +18,10 @@
  */
 
 import { basename } from 'node:path';
+import { stripVTControlCharacters } from 'node:util';
+import { statSync, existsSync } from 'node:fs';
 import { getStateDir, readAllSessionStates, snapshotStateMtimes, normalizeProjectPath } from './state-file.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
-import { stripAnsi } from './transcript-reader.mjs';
 
 const REFRESH_MS = 1000;
 
@@ -45,60 +46,156 @@ function color(c, text) {
   return `${c}${text}${ANSI.reset}`;
 }
 
-/** ANSI エスケープシーケンスを除いた可視文字数を返す（サロゲートペア考慮はしない簡易版） */
-function visibleLength(s) {
-  return stripAnsi(s).length;
+// --- セル幅計算（ANSI / CJK / 絵文字対応、依存ゼロ） ---
+//
+// Node v22 には util.getStringWidth がないため、主要な East Asian Wide + 絵文字ブロックを
+// 自前の範囲判定で 2 セルとして扱う。East Asian Ambiguous は 1 セル（アラビア・タイ等は
+// 既存の char-count 実装と同じ扱いなので悪化しない）。
+// ZWJ / VS16 は幅 0 として扱う（絵文字シーケンスの微ズレは許容）。
+const ZERO_WIDTH_CODEPOINTS = new Set([0x200b, 0x200c, 0x200d, 0xfeff, 0xfe0e, 0xfe0f]);
+
+/**
+ * 単一コードポイントのセル幅を返す（0 / 1 / 2）
+ * @param {number} cp
+ */
+function codePointWidth(cp) {
+  if (cp < 0x20) return 0;                          // C0 制御
+  if (cp >= 0x7f && cp < 0xa0) return 0;            // DEL / C1 制御
+  if (ZERO_WIDTH_CODEPOINTS.has(cp)) return 0;
+  // Combining marks (簡易: Combining Diacritical Marks 主要ブロック)
+  if (cp >= 0x0300 && cp <= 0x036f) return 0;
+  // Wide ranges
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||               // Hangul Jamo
+    (cp >= 0x2e80 && cp <= 0x303e) ||               // CJK Radicals / Kangxi
+    (cp >= 0x3041 && cp <= 0x33ff) ||               // Hiragana/Katakana/Bopomofo/CJK Symbols
+    (cp >= 0x3400 && cp <= 0x4dbf) ||               // CJK Ext A
+    (cp >= 0x4e00 && cp <= 0x9fff) ||               // CJK Unified
+    (cp >= 0xa000 && cp <= 0xa4cf) ||               // Yi
+    (cp >= 0xac00 && cp <= 0xd7a3) ||               // Hangul Syllables
+    (cp >= 0xf900 && cp <= 0xfaff) ||               // CJK Compat Ideographs
+    (cp >= 0xfe30 && cp <= 0xfe4f) ||               // CJK Compat Forms
+    (cp >= 0xff00 && cp <= 0xff60) ||               // Fullwidth
+    (cp >= 0xffe0 && cp <= 0xffe6) ||               // Fullwidth signs
+    (cp >= 0x1f300 && cp <= 0x1faff) ||             // 絵文字主要ブロック
+    (cp >= 0x20000 && cp <= 0x3134f)                // CJK Ext B-G
+  ) {
+    return 2;
+  }
+  return 1;
 }
 
 /**
- * 行をターミナル幅に収まるよう切り詰める。ANSI コードを壊さないため、
- * 可視文字だけを数えながらコピーし、上限に達したら reset を付けて返す。
+ * 文字列のセル幅合計（ANSI 剥ぎ取り済み前提ではない — 内部で剥ぐ）
+ * @param {string} s
+ */
+function cellWidth(s) {
+  if (typeof s !== 'string') return 0;
+  const stripped = stripVTControlCharacters(s);
+  let total = 0;
+  for (const ch of stripped) {
+    total += codePointWidth(ch.codePointAt(0));
+  }
+  return total;
+}
+
+/**
+ * 行をセル幅で切り詰める。ANSI コードはそのまま通過させ（幅 0）、
+ * 可視セル幅が maxCells に達したら残りを捨てて reset を付けて返す。
+ * CJK 文字を跨ぐときは 1 セル余る場合があるので空白で埋める。
  * @param {string} line
- * @param {number} maxWidth
+ * @param {number} maxCells
  */
-function truncateToWidth(line, maxWidth) {
-  if (maxWidth <= 0) return '';
-  if (visibleLength(line) <= maxWidth) return line;
+function truncateToCells(line, maxCells) {
+  if (maxCells <= 0) return '';
+  if (cellWidth(line) <= maxCells) return line;
   let out = '';
-  let visible = 0;
+  let cells = 0;
   let i = 0;
-  while (i < line.length && visible < maxWidth) {
-    const ch = line[i];
-    if (ch === '\x1b' && line[i + 1] === '[') {
-      // ANSI sequence: copy until final byte (a-zA-Z)
-      const end = line.slice(i).search(/[a-zA-Z]/);
-      if (end === -1) break;
-      out += line.slice(i, i + end + 1);
-      i += end + 1;
+  while (i < line.length) {
+    const code = line.charCodeAt(i);
+    // ANSI CSI: \x1b[ ... 終端 (0x40-0x7e)
+    if (code === 0x1b && line.charCodeAt(i + 1) === 0x5b) {
+      let j = i + 2;
+      while (j < line.length) {
+        const c = line.charCodeAt(j);
+        if (c >= 0x40 && c <= 0x7e) { j++; break; }
+        j++;
+      }
+      out += line.slice(i, j);
+      i = j;
       continue;
     }
+    // コードポイント単位で取得（サロゲートペア考慮）
+    const cp = line.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const w = codePointWidth(cp);
+    if (cells + w > maxCells) {
+      // CJK 1 セル余り
+      if (cells < maxCells) out += ' ';
+      break;
+    }
     out += ch;
-    visible++;
-    i++;
+    cells += w;
+    i += ch.length;
   }
   return out + ANSI.reset;
 }
 
+/**
+ * 文字列の末尾を半角スペースでパディングして targetCells に揃える。
+ * 既にはみ出している場合は truncateToCells で切り詰める。
+ * @param {string} s
+ * @param {number} targetCells
+ */
+function padCellsEnd(s, targetCells) {
+  const width = cellWidth(s);
+  if (width === targetCells) return s;
+  if (width > targetCells) return truncateToCells(s, targetCells);
+  return s + ' '.repeat(targetCells - width);
+}
+
 // --- CLI 引数 ---
+/**
+ * @param {string[]} argv
+ * @returns {{all: boolean, session: string|null}}
+ * @throws {Error} --session に値が欠落している場合
+ */
 function parseArgs(argv) {
   const args = { all: false, session: null };
   for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === '--all') args.all = true;
-    else if (argv[i] === '--session') args.session = argv[++i];
+    if (argv[i] === '--all') {
+      args.all = true;
+    } else if (argv[i] === '--session') {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('--')) {
+        throw new Error('--session requires a session id (or prefix) as next argument');
+      }
+      args.session = value;
+      i++;
+    }
   }
   return args;
 }
 
 // --- 表示 ---
 function renderBar(ratio, width = 20) {
-  const filled = Math.max(0, Math.min(width, Math.round(ratio * width)));
+  // NaN は 0、+Infinity は 1（オーバーフロー = 満タン表示）、負値 / -Infinity は 0 にクランプ
+  let safe;
+  if (Number.isNaN(ratio)) safe = 0;
+  else if (ratio === Infinity) safe = 1;
+  else if (ratio === -Infinity) safe = 0;
+  else safe = Math.max(0, Math.min(1, ratio));
+  const filled = Math.round(safe * width);
   return '█'.repeat(filled) + '░'.repeat(width - filled);
 }
 
 function formatNumber(n) {
-  if (n >= 1_000_000) return (n / 1_000_000).toFixed(2) + 'M';
+  if (!Number.isFinite(n) || n < 0) return '0';
+  // 999_950 以上は toFixed(1) で "1000.0k" になってしまうので M 表記に切り上げる
+  if (n >= 999_500) return (n / 1_000_000).toFixed(2) + 'M';
   if (n >= 1_000) return (n / 1_000).toFixed(1) + 'k';
-  return String(n);
+  return String(Math.floor(n));
 }
 
 function formatLine({ state, usage, isActive }) {
@@ -116,13 +213,16 @@ function formatLine({ state, usage, isActive }) {
     ratio >= 0.7 ? ANSI.yellow :
     ANSI.green;
 
+  // 色覚配慮: 色だけでなく記号 / テキスト接頭辞でも重要度を示す
+  //   90%超: !! + 強い文言 (赤)
+  //   70%超: !  + 弱い文言 (黄)
   const warn =
-    ratio >= 0.9 ? color(ANSI.red, '  ⚠ /clear 強く推奨') :
-    ratio >= 0.7 ? color(ANSI.yellow, '  ⚠ そろそろ /clear') :
+    ratio >= 0.9 ? color(ANSI.red + ANSI.bold, '  !! /clear 強く推奨') :
+    ratio >= 0.7 ? color(ANSI.yellow, '  !  そろそろ /clear') :
     '';
 
   const marker = isActive ? color(ANSI.bold + ANSI.cyan, '▶') : ' ';
-  const projectCol = project.padEnd(18).slice(0, 18);
+  const projectCol = padCellsEnd(project, 18);
   const idCol = color(ANSI.dim, shortId);
   const barCol = color(barColor, bar);
   const tokCol = `${formatNumber(tokens).padStart(6)} / ${pct.toString().padStart(3)}%`;
@@ -133,11 +233,18 @@ function formatLine({ state, usage, isActive }) {
 }
 
 // --- フィルタ ---
+/**
+ * セッション一覧に表示フィルタを適用する。
+ * ルール:
+ *   - stale (15 分無活動) は基本非表示。--all のときのみ stale も含める
+ *   - --session が指定されればプレフィックス一致、ただし base (stale フィルタ通過済み) 上で絞る
+ *   - --session 無し & --all 無しのときは cwd 一致のみ残す
+ */
 function filterStates(states, args, cwd) {
-  // stale (15 分無活動) は基本非表示。--all のときだけ stale も含める
-  let base = args.all ? states : states.filter((s) => !s.stale);
+  const base = args.all ? states : states.filter((s) => !s.stale);
   if (args.session) {
-    return states.filter((s) => s.sessionId === args.session || s.sessionId.startsWith(args.session));
+    // startsWith が完全一致も含むので === は冗長
+    return base.filter((s) => s.sessionId.startsWith(args.session));
   }
   if (args.all) return base;
   const normalizedCwd = normalizeProjectPath(cwd);
@@ -146,24 +253,55 @@ function filterStates(states, args, cwd) {
 
 // --- メインループ ---
 let lastRenderedLines = 0;
-let lastMtimes = new Map();
+let lastRenderKey = '';
+
+/**
+ * 再描画要否の判定キー。state ファイル群の mtime と transcript JSONL の size を
+ * 1 本の文字列にまとめてハッシュキーとする。キーが前回と同じなら描画スキップ。
+ *
+ * 注: transcript は JSONL append-only なので size 変化 = 新しい usage エントリ到来と
+ * 同義。mtime だけでは transcript 更新を検出できない（state-file の mtime は
+ * Stop hook のタイミングで更新され、transcript は Claude の stream 中に太る）。
+ */
+function computeRenderKey() {
+  const parts = [];
+  // state mtimes
+  const mtimes = snapshotStateMtimes();
+  const names = Array.from(mtimes.keys()).sort();
+  for (const name of names) parts.push(`s:${name}:${mtimes.get(name)}`);
+  // transcript sizes（state ファイルを読まずに直接 stat、IO 最小化）
+  try {
+    const states = readAllSessionStates();
+    for (const st of states) {
+      if (!st.transcriptPath || !existsSync(st.transcriptPath)) continue;
+      try {
+        const size = statSync(st.transcriptPath).size;
+        parts.push(`t:${st.sessionId}:${size}`);
+      } catch {
+        // stat 失敗は無視（次フレームで回復）
+      }
+    }
+  } catch {
+    // readAllSessionStates 自体の失敗も 1 フレームで回復
+  }
+  return parts.join('|');
+}
 
+/**
+ * 前回と比べてキーが変化していれば true。副作用として lastRenderKey を更新する。
+ */
 function needsRerender() {
-  const current = snapshotStateMtimes();
-  if (current.size !== lastMtimes.size) {
-    lastMtimes = current;
+  const key = computeRenderKey();
+  if (key !== lastRenderKey) {
+    lastRenderKey = key;
     return true;
   }
-  for (const [name, mtime] of current) {
-    if (lastMtimes.get(name) !== mtime) {
-      lastMtimes = current;
-      return true;
-    }
-  }
-  // mtime は同じでも transcript JSONL のサイズが変われば再描画したい
-  // → transcript-usage のキャッシュ判定に任せるため毎秒呼ぶ設計。
-  //    state ファイル変化なしでも再計算は走らせる（キャッシュヒット時は軽量）
-  return true;
+  return false;
+}
+
+/** テスト用リセット */
+function resetRenderKeyCache() {
+  lastRenderKey = '';
 }
 
 function renderFrame(args) {
@@ -174,9 +312,15 @@ function renderFrame(args) {
 
   const lines = [];
   if (filtered.length === 0) {
-    lines.push(color(ANSI.dim, '[Throughline] 待機中 — アクティブなセッションがありません'));
-    if (!args.all) {
-      lines.push(color(ANSI.dim, `  (${normalizeProjectPath(process.cwd())} に state 無し。--all で全プロジェクト表示)`));
+    if (args.session) {
+      // --session 指定で未ヒットは「存在しない」と明示（一般の "待機中" と区別）
+      lines.push(color(ANSI.yellow, `[Throughline] セッション "${args.session}" に一致する active セッションが見つかりません`));
+      lines.push(color(ANSI.dim, '  (プレフィックス指定も可。--all で stale を含めて再検索)'));
+    } else {
+      lines.push(color(ANSI.dim, '[Throughline] 待機中 — アクティブなセッションがありません'));
+      if (!args.all) {
+        lines.push(color(ANSI.dim, `  (${normalizeProjectPath(process.cwd())} に state 無し。--all で全プロジェクト表示)`));
+      }
     }
   } else {
     const header = color(
@@ -191,13 +335,14 @@ function renderFrame(args) {
     }
   }
 
-  // ★ 折り返し対策: 各行を (columns - 1) 幅に切り詰めて物理 1 行に収める。
+  // ★ 折り返し対策: 各行を (columns - 1) セル幅に切り詰めて物理 1 行に収める。
   //   こうすれば ANSI.up(lines.length) と論理行数が物理行数と一致する。
   //   columns - 1 にしてるのはターミナル末尾列に書くと自動改行する端末があるため。
+  //   truncateToCells は CJK / 絵文字を 2 セルとして正しく数える。
   const columns = process.stdout.columns && process.stdout.columns > 10
     ? process.stdout.columns - 1
     : 120;
-  const clipped = lines.map((l) => truncateToWidth(l, columns));
+  const clipped = lines.map((l) => truncateToCells(l, columns));
 
   // 前フレームを消去してから再描画:
   //   1. カーソルを前フレームの先頭行へ戻す (CUU = 行移動のみ)
@@ -213,25 +358,98 @@ function renderFrame(args) {
 }
 
 // --- 起動 ---
-function main() {
-  const args = parseArgs(process.argv.slice(2));
+let cursorRestored = false;
+function restoreCursor() {
+  if (cursorRestored) return;
+  cursorRestored = true;
+  try {
+    process.stdout.write(ANSI.showCursor);
+  } catch {
+    // stdout がすでに閉じていても無視
+  }
+}
+
+function safeRenderFrame(args) {
+  try {
+    renderFrame(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown error';
+    process.stderr.write(`[Throughline] render error: ${msg}\n`);
+    // 1 フレームの失敗で常駐を落とさない。次フレームで回復を試す
+  }
+}
+
+export function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'invalid args';
+    process.stderr.write(`[Throughline] ${msg}\n`);
+    process.exit(2);
+  }
 
   process.stdout.write(ANSI.hideCursor);
   process.stdout.write(color(ANSI.dim, `[Throughline] モニター起動 (state: ${getStateDir()}, Ctrl+C で終了)\n`));
 
-  renderFrame(args);
+  safeRenderFrame(args);
   const timer = setInterval(() => {
-    if (needsRerender()) renderFrame(args);
+    if (needsRerender()) safeRenderFrame(args);
   }, REFRESH_MS);
 
-  const shutdown = () => {
+  // ターミナル幅が変わったら即座に全画面リフレッシュ（前フレームの ANSI 座標が無効化されるため）
+  // debounce 200ms でドラッグ中のジッタを吸収
+  let resizeTimer = null;
+  const onResize = () => {
+    if (resizeTimer) clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(() => {
+      resizeTimer = null;
+      // 既存描画が新しい幅では崩れている可能性があるため座標情報を破棄して再描画
+      lastRenderedLines = 0;
+      resetRenderKeyCache();
+      safeRenderFrame(args);
+    }, 200);
+  };
+  if (typeof process.stdout.on === 'function') {
+    process.stdout.on('resize', onResize);
+  }
+
+  const shutdown = (code = 0) => {
     clearInterval(timer);
-    process.stdout.write('\n' + ANSI.showCursor);
-    process.stdout.write(color(ANSI.dim, '[Throughline] モニター終了\n'));
-    process.exit(0);
+    if (resizeTimer) clearTimeout(resizeTimer);
+    restoreCursor();
+    process.stdout.write('\n' + color(ANSI.dim, '[Throughline] モニター終了\n'));
+    process.exit(code);
   };
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+
+  // クラッシュ時もカーソルを必ず戻す
+  process.on('exit', restoreCursor);
+  process.on('uncaughtException', (err) => {
+    restoreCursor();
+    const msg = err instanceof Error ? (err.stack ?? err.message) : String(err);
+    process.stderr.write(`[Throughline] uncaught exception:\n${msg}\n`);
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason) => {
+    restoreCursor();
+    process.stderr.write(`[Throughline] unhandled rejection: ${String(reason)}\n`);
+    process.exit(1);
+  });
 }
 
-main();
+// --- テスト用エクスポート（本番コードからは参照しない） ---
+export const _internal = {
+  parseArgs,
+  filterStates,
+  cellWidth,
+  truncateToCells,
+  padCellsEnd,
+  formatNumber,
+  renderBar,
+  formatLine,
+  computeRenderKey,
+  needsRerender,
+  resetRenderKeyCache,
+};

package/src/token-monitor.test.mjs

@@ -0,0 +1,331 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { _internal } from './token-monitor.mjs';
+import { normalizeProjectPath } from './state-file.mjs';
+
+const {
+  parseArgs,
+  filterStates,
+  cellWidth,
+  truncateToCells,
+  padCellsEnd,
+  formatNumber,
+  renderBar,
+  formatLine,
+} = _internal;
+
+// state-file は projectPath を resolve + lowercase 正規化する。
+// filterStates は cwd 引数を内部で正規化するので、テストでも同じ関数を使って揃える。
+const CWD_FOO = normalizeProjectPath('/tmp/foo');
+const CWD_BAR = normalizeProjectPath('/tmp/bar');
+
+// ─── parseArgs ─────────────────────────────────────────────────────
+
+test('parseArgs: 引数なしは defaults', () => {
+  assert.deepEqual(parseArgs([]), { all: false, session: null });
+});
+
+test('parseArgs: --all フラグ', () => {
+  assert.deepEqual(parseArgs(['--all']), { all: true, session: null });
+});
+
+test('parseArgs: --session <id>', () => {
+  assert.deepEqual(parseArgs(['--session', 'abc123']), { all: false, session: 'abc123' });
+});
+
+test('parseArgs: --all と --session の組み合わせ', () => {
+  assert.deepEqual(parseArgs(['--all', '--session', 'abc']), { all: true, session: 'abc' });
+});
+
+test('parseArgs: --session 値欠落は throw する', () => {
+  assert.throws(() => parseArgs(['--session']), /requires a session id/);
+});
+
+test('parseArgs: --session の次が別フラグなら throw する', () => {
+  assert.throws(() => parseArgs(['--session', '--all']), /requires a session id/);
+});
+
+test('parseArgs: 未知の引数は黙殺', () => {
+  // 将来 --help などを足す余地を残すため、現状は黙殺で OK
+  assert.deepEqual(parseArgs(['--unknown', 'value']), { all: false, session: null });
+});
+
+// ─── filterStates ─────────────────────────────────────────────────
+
+function makeState({ sessionId, projectPath, stale = false }) {
+  return {
+    sessionId,
+    projectPath,
+    transcriptPath: null,
+    updatedAt: Date.now(),
+    stale,
+  };
+}
+
+test('filterStates: --all なしでは stale を隠す', () => {
+  const states = [
+    makeState({ sessionId: 'a', projectPath: CWD_FOO, stale: false }),
+    makeState({ sessionId: 'b', projectPath: CWD_FOO, stale: true }),
+  ];
+  const result = filterStates(states, { all: false, session: null }, CWD_FOO);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].sessionId, 'a');
+});
+
+test('filterStates: --all は stale も含む', () => {
+  const states = [
+    makeState({ sessionId: 'a', projectPath: CWD_FOO, stale: false }),
+    makeState({ sessionId: 'b', projectPath: CWD_BAR, stale: true }),
+  ];
+  const result = filterStates(states, { all: true, session: null }, CWD_FOO);
+  assert.equal(result.length, 2);
+});
+
+test('filterStates: --session は base (stale フィルタ済み) 上でプレフィックス一致', () => {
+  const states = [
+    makeState({ sessionId: 'abc123', projectPath: CWD_FOO, stale: false }),
+    makeState({ sessionId: 'abc999', projectPath: CWD_FOO, stale: true }), // stale は除外される
+    makeState({ sessionId: 'def456', projectPath: CWD_FOO, stale: false }),
+  ];
+  const result = filterStates(states, { all: false, session: 'abc' }, CWD_FOO);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].sessionId, 'abc123');
+});
+
+test('filterStates: --session + --all なら stale 含めたうえでプレフィックス一致', () => {
+  const states = [
+    makeState({ sessionId: 'abc123', projectPath: CWD_FOO, stale: false }),
+    makeState({ sessionId: 'abc999', projectPath: CWD_FOO, stale: true }),
+  ];
+  const result = filterStates(states, { all: true, session: 'abc' }, CWD_FOO);
+  assert.equal(result.length, 2);
+});
+
+test('filterStates: --session 完全一致もプレフィックス一致の一部として拾う', () => {
+  const states = [
+    makeState({ sessionId: 'exact-match-id', projectPath: CWD_FOO, stale: false }),
+  ];
+  const result = filterStates(states, { all: false, session: 'exact-match-id' }, CWD_FOO);
+  assert.equal(result.length, 1);
+});
+
+test('filterStates: cwd 不一致は除外（--session も --all もなし）', () => {
+  const states = [
+    makeState({ sessionId: 'a', projectPath: CWD_FOO, stale: false }),
+    makeState({ sessionId: 'b', projectPath: CWD_BAR, stale: false }),
+  ];
+  const result = filterStates(states, { all: false, session: null }, CWD_FOO);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].sessionId, 'a');
+});
+
+// ─── cellWidth ─────────────────────────────────────────────────────
+
+test('cellWidth: ASCII は 1 セル', () => {
+  assert.equal(cellWidth('abc'), 3);
+  assert.equal(cellWidth(''), 0);
+  assert.equal(cellWidth('Hello World'), 11);
+});
+
+test('cellWidth: CJK は 2 セル', () => {
+  assert.equal(cellWidth('あ'), 2);
+  assert.equal(cellWidth('漢字'), 4);
+  assert.equal(cellWidth('한글'), 4);
+});
+
+test('cellWidth: 絵文字は 2 セル', () => {
+  assert.equal(cellWidth('😀'), 2);
+  assert.equal(cellWidth('🚀🎉'), 4);
+});
+
+test('cellWidth: ANSI エスケープは 0 セル', () => {
+  assert.equal(cellWidth('\x1b[32mhello\x1b[0m'), 5);
+  assert.equal(cellWidth('\x1b[1;36m★\x1b[0m'), 1);
+});
+
+test('cellWidth: 混在 (ASCII + CJK + 絵文字 + ANSI)', () => {
+  const line = '\x1b[32m▶\x1b[0m Throughline プロジェクト';
+  // ▶ (U+25B6) は "Geometric Shapes" で現状 1 セル扱い、ASCII 12 + ひらがな 4 * 2
+  // "Throughline " = 12, "プロジェクト" = 12 (6 文字 * 2), ▶ = 1, 空白 = 1
+  assert.equal(cellWidth(line), 1 + 1 + 12 + 12);
+});
+
+test('cellWidth: 制御文字は 0', () => {
+  assert.equal(cellWidth('\x00\x01\x02'), 0);
+});
+
+test('cellWidth: ZWJ は 0', () => {
+  assert.equal(cellWidth('a\u200db'), 2); // a + ZWJ (0) + b
+});
+
+// ─── truncateToCells ──────────────────────────────────────────────
+
+test('truncateToCells: ASCII で単純切り詰め', () => {
+  const result = truncateToCells('abcdefghij', 5);
+  // 切り詰め後に reset が付く
+  assert.ok(result.startsWith('abcde'));
+});
+
+test('truncateToCells: CJK 境界で 1 セル余る場合は空白で埋める', () => {
+  // maxCells=5 で "あいう" (6 セル) を切ると "あい" (4 セル) + 1 セル分空白
+  const result = truncateToCells('あいうえお', 5);
+  const stripped = result.replace(/\x1b\[[0-9;]*m/g, '');
+  // CJK 2 セル × 2 = 4 セル + 空白 1 = 5 セル
+  assert.ok(stripped.startsWith('あい '));
+});
+
+test('truncateToCells: 既に収まっていればそのまま', () => {
+  assert.equal(truncateToCells('abc', 10), 'abc');
+});
+
+test('truncateToCells: ANSI コードを破壊しない', () => {
+  const input = '\x1b[32mhello\x1b[0m world';
+  const result = truncateToCells(input, 7);
+  // ANSI がそのまま残り、可視部分は "hello w" で切れる
+  assert.ok(result.includes('\x1b[32m'));
+});
+
+test('truncateToCells: maxCells=0 は空文字列', () => {
+  assert.equal(truncateToCells('hello', 0), '');
+});
+
+// ─── padCellsEnd ──────────────────────────────────────────────────
+
+test('padCellsEnd: ASCII を右端パディング', () => {
+  assert.equal(padCellsEnd('abc', 6), 'abc   ');
+});
+
+test('padCellsEnd: CJK でも正しく幅を計算してパディング', () => {
+  // "あい" = 4 セル、target 6 → 空白 2 個付加
+  assert.equal(padCellsEnd('あい', 6), 'あい  ');
+});
+
+test('padCellsEnd: ちょうど target なら変化なし', () => {
+  assert.equal(padCellsEnd('abc', 3), 'abc');
+  assert.equal(padCellsEnd('漢字', 4), '漢字');
+});
+
+test('padCellsEnd: target 超過なら切り詰め', () => {
+  const result = padCellsEnd('abcdefgh', 4);
+  const stripped = result.replace(/\x1b\[[0-9;]*m/g, '');
+  assert.equal(stripped.slice(0, 4), 'abcd');
+});
+
+// ─── formatNumber ─────────────────────────────────────────────────
+
+test('formatNumber: 1000 未満はそのまま（小数なし）', () => {
+  assert.equal(formatNumber(0), '0');
+  assert.equal(formatNumber(42), '42');
+  assert.equal(formatNumber(999), '999');
+});
+
+test('formatNumber: 1_000 以上は k 表記', () => {
+  assert.equal(formatNumber(1_000), '1.0k');
+  assert.equal(formatNumber(1_234), '1.2k');
+  assert.equal(formatNumber(999_499), '999.5k');
+});
+
+test('formatNumber: 999_500 以上は M 表記にジャンプ（"1000.0k" 回避）', () => {
+  assert.equal(formatNumber(999_500), '1.00M');
+  assert.equal(formatNumber(999_950), '1.00M');
+  assert.equal(formatNumber(999_999), '1.00M');
+  assert.equal(formatNumber(1_000_000), '1.00M');
+  assert.equal(formatNumber(1_234_567), '1.23M');
+});
+
+test('formatNumber: 無効値は "0"', () => {
+  assert.equal(formatNumber(NaN), '0');
+  assert.equal(formatNumber(-1), '0');
+  assert.equal(formatNumber(Infinity), '0');
+});
+
+// ─── renderBar ────────────────────────────────────────────────────
+
+test('renderBar: ratio=0 は全部 ░', () => {
+  assert.equal(renderBar(0, 5), '░░░░░');
+});
+
+test('renderBar: ratio=1 は全部 █', () => {
+  assert.equal(renderBar(1, 5), '█████');
+});
+
+test('renderBar: ratio=0.5 は半々', () => {
+  // width=10, 0.5 * 10 = 5 filled
+  assert.equal(renderBar(0.5, 10), '█████░░░░░');
+});
+
+test('renderBar: NaN でもバーが消えない', () => {
+  const result = renderBar(NaN, 5);
+  assert.equal(result.length, 5);
+  assert.ok(result.includes('░'));
+});
+
+test('renderBar: Infinity / 負値は安全にクランプ', () => {
+  assert.equal(renderBar(Infinity, 5), '█████');
+  assert.equal(renderBar(-1, 5), '░░░░░');
+  assert.equal(renderBar(1.5, 5), '█████');
+});
+
+// ─── formatLine 警告表示（色覚配慮） ────────────────────────────
+
+function stripColors(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function makeLineArgs(ratio) {
+  const max = 200_000;
+  const tokens = Math.round(ratio * max);
+  return {
+    state: {
+      sessionId: 'abc12345-xxxx',
+      projectPath: '/tmp/foo',
+      transcriptPath: null,
+      updatedAt: Date.now(),
+    },
+    usage: {
+      tokens,
+      model: 'test-model',
+      contextWindowSize: max,
+      outputTokens: 0,
+    },
+    isActive: true,
+  };
+}
+
+test('formatLine: 70% 未満は警告テキストなし', () => {
+  const out = stripColors(formatLine(makeLineArgs(0.5)));
+  assert.ok(!out.includes('!!'));
+  assert.ok(!out.includes('!  '));
+  assert.ok(!out.includes('/clear'));
+});
+
+test('formatLine: 70% 以上で "!" マーカーと弱めの文言', () => {
+  const out = stripColors(formatLine(makeLineArgs(0.75)));
+  assert.ok(out.includes('!'), 'should include ! marker');
+  assert.ok(out.includes('そろそろ /clear'), 'should show soft warning');
+  assert.ok(!out.includes('!!'), 'should not include critical marker yet');
+});
+
+test('formatLine: 90% 以上で "!!" マーカーと強い文言', () => {
+  const out = stripColors(formatLine(makeLineArgs(0.95)));
+  assert.ok(out.includes('!!'), 'should include !! critical marker');
+  assert.ok(out.includes('強く推奨'), 'should show strong warning');
+});
+
+test('formatLine: 色付きで警告が赤 / 黄になる（色覚配慮の裏付け）', () => {
+  const critical = formatLine(makeLineArgs(0.95));
+  assert.ok(critical.includes('\x1b[31m'), 'critical should use red');
+  const warning = formatLine(makeLineArgs(0.75));
+  assert.ok(warning.includes('\x1b[33m'), 'warning should use yellow');
+});
+
+test('formatLine: プロジェクト名に CJK が含まれてもセル幅で整形される', () => {
+  const args = makeLineArgs(0.5);
+  args.state.projectPath = '/tmp/プロジェクト名';
+  const out = formatLine(args);
+  // basename で "プロジェクト名" (7 文字, 14 セル) が project 欄に入る。
+  // padCellsEnd(..., 18) で 14 セル + 4 セル空白になる。セル幅を数える
+  // のは難しいがクラッシュしないことと想定文字列が含まれることを最低限確認
+  assert.ok(stripColors(out).includes('プロジェクト名'));
+});

package/src/transcript-usage.mjs

@@ -72,20 +72,26 @@ function hasContextWindowHint(raw) {
   return /\[1m\]|1M context/i.test(raw);
 }
 
-/** @type {Map<string, {size: number, sample: UsageSample|null}>} */
+/** @type {Map<string, {size: number, mtimeMs: number, sample: UsageSample|null, stickyWindow: number}>} */
 const cache = new Map();
 
 /**
- * transcript JSONL から最新の assistant usage を抽出する
+ * transcript JSONL から最新の assistant usage を抽出する。
+ *
+ * キャッシュ無効化は size + mtimeMs の両方を比較する（同サイズで内容差し替えも検出）。
+ * sticky 1M: 一度でも 1M 文脈窓と判定した path は以後 1M のまま（200k→1M 境界での
+ * バー急変を防ぐ）。プロセス再起動でリセット、monitor 再起動時でも初回サンプルで
+ * 即復帰するので実害なし。
+ *
  * @param {string} transcriptPath
  * @returns {UsageSample | null}
  */
 export function readLatestUsage(transcriptPath) {
   if (!transcriptPath || !existsSync(transcriptPath)) return null;
 
-  const { size } = statSync(transcriptPath);
+  const stat = statSync(transcriptPath);
   const cached = cache.get(transcriptPath);
-  if (cached && cached.size === size) {
+  if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
     return cached.sample;
   }
 
@@ -110,15 +116,30 @@ export function readLatestUsage(transcriptPath) {
       (usage.cache_creation_input_tokens ?? 0) +
       (usage.cache_read_input_tokens ?? 0);
     const model = entry.message?.model ?? '';
+    const detected = inferContextWindowSize(model, tokens, rawHint);
     latest = {
       tokens,
       model,
-      contextWindowSize: inferContextWindowSize(model, tokens, rawHint),
+      contextWindowSize: detected,
       outputTokens: usage.output_tokens ?? 0,
     };
   }
 
-  cache.set(transcriptPath, { size, sample: latest });
+  // sticky 1M: 既に 1M を観測していたらその値を維持
+  const priorSticky = cached?.stickyWindow ?? 0;
+  const stickyWindow = latest
+    ? Math.max(latest.contextWindowSize, priorSticky)
+    : priorSticky;
+  if (latest && stickyWindow > latest.contextWindowSize) {
+    latest.contextWindowSize = stickyWindow;
+  }
+
+  cache.set(transcriptPath, {
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+    sample: latest,
+    stickyWindow,
+  });
   return latest;
 }
 

package/src/transcript-usage.test.mjs

@@ -0,0 +1,159 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync, utimesSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { readLatestUsage, clearUsageCache, inferContextWindowSize } from './transcript-usage.mjs';
+
+function writeTranscript(path, entries) {
+  writeFileSync(path, entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
+}
+
+function assistantEntry({ model, inputTokens, cacheCreate = 0, cacheRead = 0, outputTokens = 0 }) {
+  return {
+    type: 'assistant',
+    message: {
+      model,
+      usage: {
+        input_tokens: inputTokens,
+        cache_creation_input_tokens: cacheCreate,
+        cache_read_input_tokens: cacheRead,
+        output_tokens: outputTokens,
+      },
+    },
+  };
+}
+
+function withFixture(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-usage-'));
+  const path = join(dir, 'transcript.jsonl');
+  clearUsageCache();
+  try {
+    fn({ dir, path });
+  } finally {
+    clearUsageCache();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// ─── inferContextWindowSize ────────────────────────────────────────
+
+test('inferContextWindowSize: [1m] サフィックスは 1M', () => {
+  assert.equal(inferContextWindowSize('claude-opus-4-6[1m]', 0, false), 1_000_000);
+  assert.equal(inferContextWindowSize('claude-sonnet-4-7[1M]', 0, false), 1_000_000);
+});
+
+test('inferContextWindowSize: rawHint=true なら 1M', () => {
+  assert.equal(inferContextWindowSize('claude-opus-4-6', 0, true), 1_000_000);
+});
+
+test('inferContextWindowSize: 200k 超観測でも 1M', () => {
+  assert.equal(inferContextWindowSize('claude-opus-4-6', 250_000, false), 1_000_000);
+});
+
+test('inferContextWindowSize: デフォルトは 200k', () => {
+  assert.equal(inferContextWindowSize('claude-opus-4-6', 100_000, false), 200_000);
+  assert.equal(inferContextWindowSize('', 0, false), 200_000);
+});
+
+// ─── readLatestUsage ──────────────────────────────────────────────
+
+test('readLatestUsage: 存在しないファイルは null', () => {
+  assert.equal(readLatestUsage('/nonexistent/path'), null);
+  assert.equal(readLatestUsage(''), null);
+  assert.equal(readLatestUsage(null), null);
+});
+
+test('readLatestUsage: 最新の assistant エントリを返す', () => {
+  withFixture(({ path }) => {
+    writeTranscript(path, [
+      assistantEntry({ model: 'claude-opus-4-6', inputTokens: 1000 }),
+      { type: 'user', message: { content: 'hi' } },
+      assistantEntry({ model: 'claude-opus-4-6', inputTokens: 5000, cacheRead: 1000, outputTokens: 100 }),
+    ]);
+    const result = readLatestUsage(path);
+    assert.ok(result);
+    assert.equal(result.tokens, 6000);
+    assert.equal(result.model, 'claude-opus-4-6');
+    assert.equal(result.outputTokens, 100);
+    assert.equal(result.contextWindowSize, 200_000);
+  });
+});
+
+test('readLatestUsage: usage なしエントリは skip', () => {
+  withFixture(({ path }) => {
+    writeTranscript(path, [
+      { type: 'assistant', message: { model: 'x', content: [] } },
+      assistantEntry({ model: 'claude-opus-4-6', inputTokens: 500 }),
+    ]);
+    const result = readLatestUsage(path);
+    assert.equal(result.tokens, 500);
+  });
+});
+
+test('readLatestUsage: キャッシュが mtime 変化で無効化される', () => {
+  withFixture(({ path }) => {
+    writeTranscript(path, [assistantEntry({ model: 'x', inputTokens: 100 })]);
+    const first = readLatestUsage(path);
+    assert.equal(first.tokens, 100);
+
+    // 同じサイズで中身を差し替え、mtime も進める
+    writeTranscript(path, [assistantEntry({ model: 'x', inputTokens: 999 })]);
+    // 強制的に mtime を 2 秒後にする（OS によっては書き込み直後でも mtime が同じことがある）
+    const future = new Date(Date.now() + 2000);
+    utimesSync(path, future, future);
+
+    const second = readLatestUsage(path);
+    assert.equal(second.tokens, 999, 'cache should be invalidated by mtime change');
+  });
+});
+
+// ─── sticky 1M ──────────────────────────────────────────────────
+
+test('readLatestUsage: 一度 1M を観測したら以後は下がらない', () => {
+  withFixture(({ path }) => {
+    // 初回: 250k 観測 → 1M 判定
+    writeTranscript(path, [assistantEntry({ model: 'claude-opus-4-6', inputTokens: 250_000 })]);
+    const first = readLatestUsage(path);
+    assert.equal(first.contextWindowSize, 1_000_000);
+
+    // 次: 100k に下がっても window は 1M のまま維持（sticky）
+    writeTranscript(path, [assistantEntry({ model: 'claude-opus-4-6', inputTokens: 100_000 })]);
+    const future = new Date(Date.now() + 2000);
+    utimesSync(path, future, future);
+
+    const second = readLatestUsage(path);
+    assert.equal(second.tokens, 100_000);
+    assert.equal(second.contextWindowSize, 1_000_000, 'sticky 1M must remain after observation');
+  });
+});
+
+test('readLatestUsage: clearUsageCache で sticky もリセット', () => {
+  withFixture(({ path }) => {
+    writeTranscript(path, [assistantEntry({ model: 'claude-opus-4-6', inputTokens: 250_000 })]);
+    readLatestUsage(path);
+    clearUsageCache();
+
+    writeTranscript(path, [assistantEntry({ model: 'claude-opus-4-6', inputTokens: 100_000 })]);
+    const future = new Date(Date.now() + 2000);
+    utimesSync(path, future, future);
+
+    const result = readLatestUsage(path);
+    assert.equal(result.contextWindowSize, 200_000, 'sticky should reset after clearUsageCache');
+  });
+});
+
+test('readLatestUsage: partial-write JSONL 行は skip', () => {
+  withFixture(({ path }) => {
+    // 最後の行が壊れている
+    writeFileSync(
+      path,
+      JSON.stringify(assistantEntry({ model: 'x', inputTokens: 42 })) +
+        '\n' +
+        '{"type":"assistant","message":{"model":"x","us',
+    );
+    const result = readLatestUsage(path);
+    assert.equal(result.tokens, 42);
+  });
+});