throughline 0.2.0 → 0.3.1

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-reader.mjs

@@ -197,7 +197,7 @@ export function sliceCurrentTurnEntries(entries) {
  * 分類ルール:
  *   - assistant の tool_use ブロック → tool_input (name, input を JSON 化して input_text に)
  *   - user の tool_result ブロック → tool_output (content を output_text に、ANSI 剥離)
- *   - assistant/user の thinking ブロック → 破棄
+ *   - assistant の thinking ブロック → thinking (b.thinking を output_text に)
  *   - assistant/user の text ブロック → 扱わない（L2 bodies 側の責務）
  *   - attachment entry (hook_success) → system (hookName + content を出力に)
  *   - system entry (stop_hook_summary) → skip（hook タイミング情報で意味なし）
@@ -215,7 +215,8 @@ export function extractDetailBlocks(turnEntries) {
     if (e.type === 'assistant') {
       const blocks = e.message?.content;
       if (!Array.isArray(blocks)) continue;
-      for (const b of blocks) {
+      for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
         if (!b || !b.type) continue;
         if (b.type === 'tool_use' && typeof b.id === 'string') {
           toolNameById.set(b.id, b.name ?? 'unknown');
@@ -226,6 +227,16 @@ export function extractDetailBlocks(turnEntries) {
             input_text: JSON.stringify(b.input ?? null),
             output_text: null,
           });
+        } else if (b.type === 'thinking' && typeof b.thinking === 'string') {
+          // 固有 id が無いため entry uuid + block index で冪等キーを合成
+          const sourceId = e.uuid ? `${e.uuid}:thinking:${i}` : null;
+          out.push({
+            kind: DETAIL_KIND.THINKING,
+            tool_name: 'thinking',
+            source_id: sourceId,
+            input_text: null,
+            output_text: b.thinking,
+          });
         } else if (b.type === 'image') {
           out.push({
             kind: DETAIL_KIND.IMAGE,
@@ -235,7 +246,7 @@ export function extractDetailBlocks(turnEntries) {
             output_text: '[image]',
           });
         }
-        // text / thinking は扱わない
+        // text は扱わない
       }
     } else if (e.type === 'user') {
       const blocks = e.message?.content;

package/src/transcript-reader.test.mjs

@@ -114,22 +114,80 @@ test('extractDetailBlocks: tool_use と tool_result をペアで抽出', () => {
   assert.equal(output.output_text, 'hi\n');
 });
 
-test('extractDetailBlocks: thinking / text ブロックは L3 に入れない', () => {
+test('extractDetailBlocks: assistant の thinking ブロックを kind=thinking で抽出、text は無視', () => {
   const entries = [
     userEntry('prompt'),
     {
       type: 'assistant',
+      uuid: 'asst-1',
       message: {
         role: 'assistant',
         content: [
-          { type: 'thinking', thinking: 'internal thoughts' },
+          { type: 'thinking', thinking: 'internal thoughts', signature: 'sig' },
           { type: 'text', text: 'response' },
         ],
       },
     },
   ];
   const details = extractDetailBlocks(entries);
-  assert.equal(details.length, 0);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].kind, DETAIL_KIND.THINKING);
+  assert.equal(details[0].tool_name, 'thinking');
+  assert.equal(details[0].source_id, 'asst-1:thinking:0');
+  assert.equal(details[0].input_text, null);
+  assert.equal(details[0].output_text, 'internal thoughts');
+});
+
+test('extractDetailBlocks: 同 entry 内で thinking + tool_use + image が混在しても全て抽出', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'assistant',
+      uuid: 'asst-2',
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'first thought' },
+          { type: 'tool_use', id: 'toolu_1', name: 'Read', input: { path: '/x' } },
+          { type: 'thinking', thinking: 'second thought' },
+          { type: 'image', source: {} },
+          { type: 'text', text: 'done' },
+        ],
+      },
+    },
+    asstTextEntry('wrap'),
+  ];
+  const details = extractDetailBlocks(entries);
+  // thinking x2, tool_input x1, image x1 = 4
+  assert.equal(details.length, 4);
+  const thinkings = details.filter((d) => d.kind === DETAIL_KIND.THINKING);
+  assert.equal(thinkings.length, 2);
+  assert.equal(thinkings[0].source_id, 'asst-2:thinking:0');
+  assert.equal(thinkings[1].source_id, 'asst-2:thinking:2');
+  assert.equal(thinkings[0].output_text, 'first thought');
+  assert.equal(thinkings[1].output_text, 'second thought');
+});
+
+test('extractDetailBlocks: thinking エントリに uuid が無くても source_id=null で通過する', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'assistant',
+      // uuid 欠損
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'thought without uuid' },
+          { type: 'text', text: 'reply' },
+        ],
+      },
+    },
+  ];
+  const details = extractDetailBlocks(entries);
+  const thinking = details.find((d) => d.kind === DETAIL_KIND.THINKING);
+  assert.ok(thinking);
+  assert.equal(thinking.source_id, null);
+  assert.equal(thinking.output_text, 'thought without uuid');
 });
 
 test('extractDetailBlocks: attachment (hook_success) を system として抽出', () => {

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);
+  });
+});