throughline 0.3.3 → 0.3.4

package/README.md

@@ -178,6 +178,19 @@ Example output (real values from a running 1M-context Opus session):
 - **Line-wrap safe.** Each line is truncated to `process.stdout.columns - 1`
   before drawing, preserving ANSI color codes. The redraw cursor math cannot
   desync on narrow terminals.
+- **Resize resilient.** Column width is polled every second, so pane drags that
+  don't fire a terminal `resize` event (common in VS Code's integrated
+  terminal) still trigger a full redraw.
+- **Per-row "last updated" stamp.** Each session row ends with `(24m ago)` so
+  you can tell a frozen display apart from an idle session at a glance. When
+  you need more detail, `throughline doctor --session <id-prefix>` compares the
+  state file against the actual transcript JSONL and flags drift, idle time,
+  and `/clear`-induced transcript path staleness.
+- **State-backed usage snapshot.** When the Stop hook finishes a turn it
+  persists the latest `tokens / model / contextWindowSize` back into the state
+  file. The monitor prefers this snapshot over re-reading the JSONL, which
+  removes a source of flicker when the transcript path in state drifts from
+  the one Claude Code is currently appending to.
 
 ### VS Code auto-start (automatic)
 
@@ -243,6 +256,7 @@ entry to the `tasks` array yourself:
 | `throughline detail <time>`                    | Retrieve L2 body text and L3 tool I/O for a turn (see below) |
 | `throughline save-inflight`                    | Called by `/tl` to attach an in-flight memo (stdin) to the current baton |
 | `throughline doctor`                           | Check Node version, hook registration, DB writability, PATH  |
+| `throughline doctor --session <id-prefix>`     | Diagnose a specific session — detect state/transcript drift, idle vs. stuck |
 | `throughline status`                           | Print DB statistics (sessions, skeletons, bodies, details)   |
 | `throughline --version`                        | Print the installed version                                  |
 

package/bin/throughline.mjs

@@ -45,7 +45,7 @@ switch (cmd) {
     await (await import('../src/cli/save-inflight.mjs')).run();
     break;
   case 'doctor':
-    await (await import('../src/cli/doctor.mjs')).run();
+    await (await import('../src/cli/doctor.mjs')).run(rest);
     break;
   case 'status':
     await (await import('../src/cli/status.mjs')).run();

package/package.json

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

package/src/cli/doctor.mjs

@@ -1,21 +1,31 @@
 /**
- * throughline doctor — 環境チェック
+ * throughline doctor — 環境チェック + セッション診断
  *
- * チェック項目:
+ * 通常: throughline doctor
  *   - Node.js バージョン >= 22.5
  *   - node:sqlite が使えるか
  *   - ~/.throughline/throughline.db が書き込み可能か
  *   - ~/.claude/settings.json に Throughline hook が登録されているか
+ *
+ * セッション診断: throughline doctor --session <id-prefix>
+ *   - 特定セッションの state ファイルと transcript JSONL の整合性をチェック
+ *   - 「モニターが止まって見える」ときの真因切り分け用
+ *     (本当にアイドルか、state の transcriptPath が古い JSONL を指しているか)
  */
 
-import { existsSync, accessSync, readFileSync, constants } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, accessSync, readFileSync, constants, readdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
+import { getStateDir } from '../state-file.mjs';
+import { readLatestUsage } from '../transcript-usage.mjs';
 
 const GREEN = '\x1b[32m✓\x1b[0m';
 const RED = '\x1b[31m✗\x1b[0m';
 const YELLOW = '\x1b[33m!\x1b[0m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
 
 async function check(label, fn) {
   try {
@@ -32,7 +42,244 @@ async function check(label, fn) {
   }
 }
 
-export async function run() {
+function parseArgs(argv) {
+  const args = { session: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--session') {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('--')) {
+        throw new Error('--session requires a session id prefix');
+      }
+      args.session = value;
+      i++;
+    }
+  }
+  return args;
+}
+
+function formatAgo(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '?';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  const day = Math.floor(hr / 24);
+  return `${day}d ago`;
+}
+
+function formatTs(ms) {
+  if (!Number.isFinite(ms)) return '?';
+  const d = new Date(ms);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+function formatBytes(n) {
+  if (!Number.isFinite(n) || n < 0) return '?';
+  if (n >= 1_000_000_000) return (n / 1_000_000_000).toFixed(2) + ' GB';
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(2) + ' MB';
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + ' kB';
+  return `${n} B`;
+}
+
+/**
+ * transcript JSONL を末尾から走査して最後の assistant エントリの timestamp を返す。
+ * JSONL は append-only だが巨大化しうるので、末尾 256 KB だけ読んで逆順走査する。
+ * @param {string} transcriptPath
+ * @returns {{ ts: number | null, usage: object | null }}
+ */
+function tailLatestAssistantTs(transcriptPath) {
+  try {
+    const stat = statSync(transcriptPath);
+    // シンプル化: 現状の全ファイル read で十分（モニターも全 read している）。
+    // 巨大 JSONL 対策は readLatestUsage 側の将来最適化に任せる。
+    const raw = readFileSync(transcriptPath, 'utf8');
+    const lines = raw.split('\n');
+    let latestTs = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const trimmed = lines[i].trim();
+      if (!trimmed) continue;
+      let entry;
+      try {
+        entry = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (entry.type !== 'assistant') continue;
+      const ts = entry.timestamp ?? entry.ts ?? null;
+      if (ts) {
+        latestTs = typeof ts === 'string' ? Date.parse(ts) : ts;
+        break;
+      }
+    }
+    return { ts: latestTs, fileMtime: stat.mtimeMs, size: stat.size };
+  } catch (err) {
+    throw new Error(`transcript read failed: ${err.message}`);
+  }
+}
+
+/**
+ * 同じプロジェクトディレクトリ内の最新 JSONL を返す（transcript 差し替え検出用）。
+ * state の transcriptPath と比較して、指し先が「最新」でなければズレている可能性。
+ */
+function findLatestJsonlInSameDir(transcriptPath) {
+  try {
+    const dir = dirname(transcriptPath);
+    if (!existsSync(dir)) return null;
+    const files = readdirSync(dir).filter((n) => n.endsWith('.jsonl'));
+    if (files.length === 0) return null;
+    let best = null;
+    for (const name of files) {
+      const full = join(dir, name);
+      try {
+        const mt = statSync(full).mtimeMs;
+        if (!best || mt > best.mtimeMs) best = { path: full, mtimeMs: mt };
+      } catch {
+        /* skip */
+      }
+    }
+    return best;
+  } catch {
+    return null;
+  }
+}
+
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM'; // 他ユーザー所有プロセスは生きている扱い
+  }
+}
+
+function runSessionDiagnosis(prefix) {
+  const stateDir = getStateDir();
+  if (!existsSync(stateDir)) {
+    console.log(`${RED} state ディレクトリが存在しません: ${stateDir}`);
+    console.log(`${DIM}  → Throughline が一度も動作していない可能性。throughline install してから Claude Code を起動してください。${RESET}`);
+    return;
+  }
+  const entries = readdirSync(stateDir)
+    .filter((n) => n.endsWith('.json'))
+    .filter((n) => n.startsWith(prefix) || n.replace(/\.json$/, '').startsWith(prefix));
+  if (entries.length === 0) {
+    console.log(`${RED} prefix "${prefix}" に一致する state ファイルが見つかりません`);
+    console.log(`${DIM}  → ~/.throughline/state/ を ls して session_id を確認してください。${RESET}`);
+    return;
+  }
+  if (entries.length > 1) {
+    console.log(`${YELLOW} 複数のセッションが prefix に一致しました:`);
+    for (const name of entries) console.log(`  - ${name}`);
+    console.log(`${DIM}  → もう少し長い prefix を指定してください。${RESET}`);
+    return;
+  }
+
+  const name = entries[0];
+  const stateFile = join(stateDir, name);
+  const sessionId = name.replace(/\.json$/, '');
+  console.log(`${BOLD}[Session ${sessionId}]${RESET}\n`);
+
+  let state;
+  try {
+    state = JSON.parse(readFileSync(stateFile, 'utf8'));
+  } catch (err) {
+    console.log(`${RED} state ファイル読み込み失敗: ${err.message}`);
+    return;
+  }
+
+  const now = Date.now();
+  console.log(`  state file:       ${stateFile}`);
+  console.log(`    updatedAt:      ${formatTs(state.updatedAt)} (${formatAgo(now - (state.updatedAt ?? 0))})`);
+  console.log(`    projectPath:    ${state.projectPath ?? '(未設定)'}`);
+  console.log(`    transcriptPath: ${state.transcriptPath ?? '(未設定)'}`);
+  if (state.pid) {
+    const alive = isPidAlive(state.pid);
+    console.log(`    pid:            ${state.pid} (${alive ? 'alive' : 'dead'})`);
+  }
+  if (state.usage) {
+    const u = state.usage;
+    const pct = u.contextWindowSize ? Math.round((u.tokens / u.contextWindowSize) * 100) : 0;
+    console.log(`    usage (snapshot): ${u.tokens?.toLocaleString()} tokens (${pct}% of ${u.contextWindowSize?.toLocaleString()})`);
+    console.log(`                      model: ${u.model ?? '?'}`);
+  } else {
+    console.log(`    usage (snapshot): ${DIM}(未記録 — 旧バージョンで書かれた state、または Stop が 1 度も走っていない)${RESET}`);
+  }
+  console.log('');
+
+  if (!state.transcriptPath) {
+    console.log(`${YELLOW} transcriptPath が state に含まれていません — 診断不能`);
+    return;
+  }
+
+  if (!existsSync(state.transcriptPath)) {
+    console.log(`  transcript:       ${RED}存在しない${RESET}`);
+    console.log(`${DIM}  → state の transcriptPath が古い or /clear で消えた可能性。新しい発話で state が再生成されます。${RESET}`);
+    return;
+  }
+
+  let tail;
+  try {
+    tail = tailLatestAssistantTs(state.transcriptPath);
+  } catch (err) {
+    console.log(`  transcript:       ${RED}${err.message}${RESET}`);
+    return;
+  }
+  console.log(`  transcript:`);
+  console.log(`    size:           ${formatBytes(tail.size)}`);
+  console.log(`    mtime:          ${formatTs(tail.fileMtime)} (${formatAgo(now - tail.fileMtime)})`);
+  if (tail.ts) {
+    console.log(`    latest assistant entry: ${formatTs(tail.ts)} (${formatAgo(now - tail.ts)})`);
+  } else {
+    console.log(`    latest assistant entry: ${DIM}(未検出 — usage 付きの assistant エントリがまだ無い)${RESET}`);
+  }
+
+  const live = readLatestUsage(state.transcriptPath);
+  if (live) {
+    const pct = live.contextWindowSize ? Math.round((live.tokens / live.contextWindowSize) * 100) : 0;
+    console.log(`    usage (live):   ${live.tokens?.toLocaleString()} tokens (${pct}% of ${live.contextWindowSize?.toLocaleString()})`);
+  }
+  console.log('');
+
+  // diagnosis
+  console.log(`  diagnosis:`);
+  const latestInDir = findLatestJsonlInSameDir(state.transcriptPath);
+  if (latestInDir && latestInDir.path !== state.transcriptPath && latestInDir.mtimeMs > tail.fileMtime) {
+    console.log(`    ${RED}state points to old JSONL${RESET}`);
+    console.log(`      state:  ${state.transcriptPath} (${formatAgo(now - tail.fileMtime)})`);
+    console.log(`      newer:  ${latestInDir.path} (${formatAgo(now - latestInDir.mtimeMs)})`);
+    console.log(`${DIM}    → 次の発話で state が自動修復されます。それでも直らない場合は state ファイルを削除してください。${RESET}`);
+  } else {
+    console.log(`    ${GREEN}state and transcript are consistent${RESET}`);
+  }
+  const idleMs = now - tail.fileMtime;
+  if (idleMs > 10 * 60 * 1000) {
+    console.log(`    ${YELLOW}no transcript activity in ${formatAgo(idleMs)} — session likely idle${RESET}`);
+    console.log(`${DIM}    → Claude Code でこのセッションが動いていれば transcript は必ず太ります。太っていないなら本当にアイドル。${RESET}`);
+  }
+  if (state.usage && live && state.usage.tokens !== live.tokens) {
+    console.log(`    ${YELLOW}state.usage snapshot (${state.usage.tokens}) != live transcript (${live.tokens})${RESET}`);
+    console.log(`${DIM}    → Stop が一度走った後に更に assistant エントリが追記された状態。次の Stop で揃います。${RESET}`);
+  }
+}
+
+export async function run(argv = []) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (err) {
+    process.stderr.write(`[throughline doctor] ${err.message}\n`);
+    process.exit(2);
+  }
+
+  if (args.session) {
+    runSessionDiagnosis(args.session);
+    return;
+  }
+
   console.log('throughline doctor\n');
 
   // Node.js バージョン
@@ -95,4 +342,15 @@ export async function run() {
   });
 
   console.log('');
+  console.log(`${DIM}ヒント: 特定セッションが止まって見えるときは ${RESET}throughline doctor --session <id-prefix>${DIM} で診断できます。${RESET}`);
 }
+
+// テスト用エクスポート
+export const _internal = {
+  parseArgs,
+  formatAgo,
+  formatBytes,
+  runSessionDiagnosis,
+  isPidAlive,
+  findLatestJsonlInSameDir,
+};

package/src/cli/doctor.test.mjs

@@ -0,0 +1,109 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, utimesSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _internal } from './doctor.mjs';
+
+const { parseArgs, formatAgo, formatBytes, findLatestJsonlInSameDir, isPidAlive } = _internal;
+
+// ─── parseArgs ──────────────────────────────────────────────────────
+
+test('parseArgs: 引数なしは session null', () => {
+  assert.deepEqual(parseArgs([]), { session: null });
+});
+
+test('parseArgs: --session <prefix>', () => {
+  assert.deepEqual(parseArgs(['--session', 'abc']), { session: 'abc' });
+});
+
+test('parseArgs: --session の値欠落は throw', () => {
+  assert.throws(() => parseArgs(['--session']), /session id prefix/);
+});
+
+test('parseArgs: --session の次が別フラグなら throw', () => {
+  assert.throws(() => parseArgs(['--session', '--other']), /session id prefix/);
+});
+
+// ─── formatAgo ──────────────────────────────────────────────────────
+
+test('formatAgo: 60 秒未満は秒表示', () => {
+  assert.equal(formatAgo(30_000), '30s ago');
+});
+
+test('formatAgo: 60 分未満は分表示', () => {
+  assert.equal(formatAgo(5 * 60_000), '5m ago');
+});
+
+test('formatAgo: 24 時間未満は時表示', () => {
+  assert.equal(formatAgo(3 * 60 * 60_000), '3h ago');
+});
+
+test('formatAgo: 24 時間以上は日表示', () => {
+  assert.equal(formatAgo(2 * 24 * 60 * 60_000), '2d ago');
+});
+
+test('formatAgo: 無効値', () => {
+  assert.equal(formatAgo(NaN), '?');
+  assert.equal(formatAgo(-1), '?');
+});
+
+// ─── formatBytes ────────────────────────────────────────────────────
+
+test('formatBytes: KB/MB/GB の切り替え', () => {
+  assert.equal(formatBytes(999), '999 B');
+  assert.equal(formatBytes(1_500), '1.5 kB');
+  assert.equal(formatBytes(1_500_000), '1.50 MB');
+  assert.equal(formatBytes(2_000_000_000), '2.00 GB');
+});
+
+test('formatBytes: 無効値', () => {
+  assert.equal(formatBytes(NaN), '?');
+  assert.equal(formatBytes(-1), '?');
+});
+
+// ─── findLatestJsonlInSameDir ──────────────────────────────────────
+
+test('findLatestJsonlInSameDir: 同じディレクトリ内の最新 JSONL を返す', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-doctor-'));
+  try {
+    const older = join(dir, 'a.jsonl');
+    const newer = join(dir, 'b.jsonl');
+    writeFileSync(older, 'x');
+    // mtime を強制的に差をつけるため書き込み間隔を開けたいが、連続 write だと同 ms 。
+    // ここでは newer の内容を後に書いて、後書きが newer の mtime を十分大きくする。
+    const now = Date.now();
+    writeFileSync(newer, 'y');
+    // older の mtime を古く設定
+    utimesSync(older, new Date(now - 10000), new Date(now - 10000));
+    utimesSync(newer, new Date(now), new Date(now));
+    const result = findLatestJsonlInSameDir(older);
+    assert.ok(result);
+    assert.equal(result.path, newer);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('findLatestJsonlInSameDir: 存在しないパスは null', () => {
+  assert.equal(findLatestJsonlInSameDir('/does/not/exist/x.jsonl'), null);
+});
+
+// ─── isPidAlive ─────────────────────────────────────────────────────
+
+test('isPidAlive: 自身の PID は alive', () => {
+  assert.equal(isPidAlive(process.pid), true);
+});
+
+test('isPidAlive: 不正な値は false', () => {
+  assert.equal(isPidAlive(0), false);
+  assert.equal(isPidAlive(-1), false);
+  assert.equal(isPidAlive(null), false);
+  assert.equal(isPidAlive(undefined), false);
+});
+
+test('isPidAlive: 存在しない PID は false', () => {
+  // 巨大な PID はほぼ確実に未使用
+  assert.equal(isPidAlive(2_147_483_646), false);
+});

package/src/state-file.mjs

@@ -37,9 +37,14 @@ export function normalizeProjectPath(p) {
 
 /**
  * セッション状態ファイルを書く
- * @param {{sessionId: string, projectPath: string, transcriptPath: string, pid: number}} data
+ * @param {{sessionId: string, projectPath: string, transcriptPath: string, pid: number, usage?: object|null}} data
+ *
+ * usage: monitor が表示する tokens/model/contextWindowSize をここに固定保存する。
+ * Stop hook が readLatestUsage の結果を載せることで、monitor 側が毎フレーム JSONL を
+ * 再スキャンする必要がなくなる。旧バージョン互換のため optional (無ければ monitor が
+ * transcriptPath を読んでフォールバック)。
  */
-export function writeSessionState({ sessionId, projectPath, transcriptPath, pid }) {
+export function writeSessionState({ sessionId, projectPath, transcriptPath, pid, usage }) {
   if (!sessionId) throw new Error('writeSessionState: sessionId is required');
   if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
   const file = join(STATE_DIR, `${sessionId}.json`);
@@ -50,6 +55,7 @@ export function writeSessionState({ sessionId, projectPath, transcriptPath, pid
     pid: pid ?? process.pid,
     updatedAt: Date.now(),
   };
+  if (usage) payload.usage = usage;
   writeFileSync(file, JSON.stringify(payload));
 }
 

package/src/state-file.test.mjs

@@ -133,3 +133,52 @@ test('snapshotStateMtimes: ディレクトリ未作成なら空 Map', async () =
     assert.equal(snap.size, 0);
   });
 });
+
+test('writeSessionState: usage 付きで書くと JSON に含まれる', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    mod.writeSessionState({
+      sessionId: 'sess-a',
+      projectPath: '/tmp/x',
+      transcriptPath: null,
+      pid: 1,
+      usage: { tokens: 123, model: 'claude-opus-4-6', contextWindowSize: 200000, outputTokens: 10 },
+    });
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.ok(results[0].usage);
+    assert.equal(results[0].usage.tokens, 123);
+    assert.equal(results[0].usage.model, 'claude-opus-4-6');
+  });
+});
+
+test('writeSessionState: usage 無しで書いたらフィールド自体が無い (旧フォーマット互換)', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    mod.writeSessionState({
+      sessionId: 'sess-b',
+      projectPath: '/tmp/x',
+      transcriptPath: null,
+      pid: 1,
+    });
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.equal(results[0].usage, undefined);
+  });
+});
+
+test('readAllSessionStates: 旧バージョンが書いた usage 無しの state を読める', async () => {
+  await withIsolatedStateDir(async ({ stateDir, mod }) => {
+    // 旧フォーマット (usage フィールド無し) を直接書く
+    const file = join(stateDir, 'old-fmt.json');
+    writeFileSync(file, JSON.stringify({
+      sessionId: 'old-fmt',
+      projectPath: '/tmp/foo',
+      transcriptPath: null,
+      pid: 1,
+      updatedAt: Date.now(),
+    }));
+    const results = mod.readAllSessionStates();
+    assert.equal(results.length, 1);
+    assert.equal(results[0].usage, undefined);
+    // usage 無しで読めること自体が互換性の証明
+  });
+});

package/src/token-monitor.mjs

@@ -24,6 +24,10 @@ import { getStateDir, readAllSessionStates, snapshotStateMtimes, normalizeProjec
 import { readLatestUsage } from './transcript-usage.mjs';
 
 const REFRESH_MS = 1000;
+// データ変化が無くても N ms ごとに再描画して「(24m ago)」表示を進める。
+// 変化検知のほうが優先で、こちらはフォールバック的なタイマー。
+const TIME_AGO_REFRESH_MS = 10_000;
+let lastTimeAgoRefresh = Date.now();
 
 // --- ANSI ---
 const ANSI = {
@@ -198,7 +202,36 @@ function formatNumber(n) {
   return String(Math.floor(n));
 }
 
-function formatLine({ state, usage, isActive }) {
+/**
+ * ある時刻からの経過時間を短い人間可読形式で返す。
+ * 「止まって見える」瞬間に、それがどれだけ前の値なのかを一目で示すために使う。
+ * @param {number} ms - 経過ミリ秒
+ */
+export function formatTimeAgo(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return 'just now';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 10) return 'just now';
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  const day = Math.floor(hr / 24);
+  return `${day}d ago`;
+}
+
+/**
+ * columns の変化を検知して全画面再描画すべきかを返す。
+ * process.stdout.on('resize') イベントが VSCode 統合ターミナルで発火しないケースが
+ * あるため、1 秒 tick から呼び出して polling で検知する。
+ * @param {number} prevCols
+ * @param {number} currCols
+ */
+export function shouldForceFullRedraw(prevCols, currCols) {
+  return prevCols !== currCols && currCols > 0;
+}
+
+function formatLine({ state, usage, isActive, now = Date.now() }) {
   const project = basename(state.projectPath || '?');
   const shortId = state.sessionId.slice(0, 8);
   const tokens = usage?.tokens ?? 0;
@@ -228,8 +261,13 @@ function formatLine({ state, usage, isActive }) {
   const tokCol = `${formatNumber(tokens).padStart(6)} / ${pct.toString().padStart(3)}%`;
   const remCol = color(ANSI.dim, `残 ${formatNumber(remaining)}`);
   const modelCol = usage?.model ? color(ANSI.dim, usage.model) : color(ANSI.dim, '(未取得)');
+  // 最終更新からの経過: 表示が「止まって見える」とき、それが idle なのか障害なのかを
+  // 即座に判別できるようにする。updatedAt は state.writeSessionState 時の Date.now()。
+  const ago = typeof state.updatedAt === 'number'
+    ? color(ANSI.dim, `(${formatTimeAgo(now - state.updatedAt)})`)
+    : '';
 
-  return `${marker} ${projectCol} ${idCol} ${barCol} ${tokCol}  ${remCol}  ${modelCol}${warn}`;
+  return `${marker} ${projectCol} ${idCol} ${barCol} ${tokCol}  ${remCol}  ${modelCol} ${ago}${warn}`;
 }
 
 // --- フィルタ ---
@@ -328,10 +366,16 @@ function renderFrame(args) {
       `[Throughline] ${filtered.length} セッション${args.all ? ' (--all)' : ''}`,
     );
     lines.push(header);
+    const now = Date.now();
     for (let i = 0; i < filtered.length; i++) {
       const state = filtered[i];
-      const usage = state.transcriptPath ? readLatestUsage(state.transcriptPath) : null;
-      lines.push(formatLine({ state, usage, isActive: i === 0 }));
+      // Stop hook が state.usage に固定値を入れていればそれを使う（JSONL 再スキャン不要）。
+      // 旧バージョンが書いた state や usage スナップショットが取れなかったターンでは
+      // transcriptPath を直読してフォールバック。state 側の情報が 1 本化されると
+      // 「state が古い JSONL を指している」時の表示ブレが減る。
+      const usage = state.usage
+        ?? (state.transcriptPath ? readLatestUsage(state.transcriptPath) : null);
+      lines.push(formatLine({ state, usage, isActive: i === 0, now }));
     }
   }
 
@@ -393,18 +437,40 @@ export function main() {
   process.stdout.write(color(ANSI.dim, `[Throughline] モニター起動 (state: ${getStateDir()}, Ctrl+C で終了)\n`));
 
   safeRenderFrame(args);
+  // columns の最後に使った値。polling で resize 検知するために使う。
+  // VSCode 統合ターミナルは process.stdout.on('resize') が発火しないことがあり、
+  // 起動時に狭い幅だった場合に描画が崩れたまま固定される（実害ベースで確認済み）。
+  // 1 秒 tick のたびに currCols と比較してイベント不達を埋める。
+  let lastColumns = process.stdout.columns ?? 0;
   const timer = setInterval(() => {
+    const currCols = process.stdout.columns ?? 0;
+    if (shouldForceFullRedraw(lastColumns, currCols)) {
+      lastColumns = currCols;
+      lastRenderedLines = 0;
+      resetRenderKeyCache();
+      safeRenderFrame(args);
+      return;
+    }
+    // 状態が更新されていれば再描画。state mtime か transcript size のどちらかが
+    // 変わっていれば発火するので、Stop 完了・新 assistant エントリ追記の両方を捕捉する。
     if (needsRerender()) safeRenderFrame(args);
+    // 1 秒刻みの「経過時間」(24m ago など) を反映するため、データに変化が無くても
+    // 10 秒に 1 回は強制再描画する。コストは state 数本の JSONL パースのみで軽い。
+    if (Date.now() - lastTimeAgoRefresh > TIME_AGO_REFRESH_MS) {
+      lastTimeAgoRefresh = Date.now();
+      safeRenderFrame(args);
+    }
   }, REFRESH_MS);
 
-  // ターミナル幅が変わったら即座に全画面リフレッシュ（前フレームの ANSI 座標が無効化されるため）
-  // debounce 200ms でドラッグ中のジッタを吸収
+  // resize イベント経路は残す: polling 前に通知が来ればより速く反応できる。
+  // debounce 200ms でドラッグ中のジッタを吸収し、polling 側との二重再描画も防ぐ。
   let resizeTimer = null;
   const onResize = () => {
     if (resizeTimer) clearTimeout(resizeTimer);
     resizeTimer = setTimeout(() => {
       resizeTimer = null;
       // 既存描画が新しい幅では崩れている可能性があるため座標情報を破棄して再描画
+      lastColumns = process.stdout.columns ?? 0;
       lastRenderedLines = 0;
       resetRenderKeyCache();
       safeRenderFrame(args);
@@ -452,6 +518,8 @@ export const _internal = {
   computeRenderKey,
   needsRerender,
   resetRenderKeyCache,
+  formatTimeAgo,
+  shouldForceFullRedraw,
 };
 
 // --- エントリポイント自動起動 ---

package/src/token-monitor.test.mjs

@@ -13,6 +13,8 @@ const {
   formatNumber,
   renderBar,
   formatLine,
+  formatTimeAgo,
+  shouldForceFullRedraw,
 } = _internal;
 
 // state-file は projectPath を resolve + lowercase 正規化する。
@@ -329,3 +331,76 @@ test('formatLine: プロジェクト名に CJK が含まれてもセル幅で整
   // のは難しいがクラッシュしないことと想定文字列が含まれることを最低限確認
   assert.ok(stripColors(out).includes('プロジェクト名'));
 });
+
+// ─── formatTimeAgo ─────────────────────────────────────────────────
+
+test('formatTimeAgo: 10 秒未満は "just now"', () => {
+  assert.equal(formatTimeAgo(0), 'just now');
+  assert.equal(formatTimeAgo(500), 'just now');
+  assert.equal(formatTimeAgo(9_500), 'just now');
+});
+
+test('formatTimeAgo: 60 秒未満は秒表示', () => {
+  assert.equal(formatTimeAgo(15_000), '15s ago');
+  assert.equal(formatTimeAgo(59_000), '59s ago');
+});
+
+test('formatTimeAgo: 60 分未満は分表示', () => {
+  assert.equal(formatTimeAgo(60_000), '1m ago');
+  assert.equal(formatTimeAgo(24 * 60 * 1000), '24m ago');
+});
+
+test('formatTimeAgo: 24 時間未満は時表示', () => {
+  assert.equal(formatTimeAgo(60 * 60 * 1000), '1h ago');
+  assert.equal(formatTimeAgo(23 * 60 * 60 * 1000), '23h ago');
+});
+
+test('formatTimeAgo: 24 時間以上は日表示', () => {
+  assert.equal(formatTimeAgo(24 * 60 * 60 * 1000), '1d ago');
+  assert.equal(formatTimeAgo(3 * 24 * 60 * 60 * 1000), '3d ago');
+});
+
+test('formatTimeAgo: 無効値は "just now"', () => {
+  assert.equal(formatTimeAgo(NaN), 'just now');
+  assert.equal(formatTimeAgo(-1), 'just now');
+  assert.equal(formatTimeAgo(Infinity), 'just now');
+});
+
+// ─── shouldForceFullRedraw ────────────────────────────────────────
+
+test('shouldForceFullRedraw: columns 変化なしは false', () => {
+  assert.equal(shouldForceFullRedraw(80, 80), false);
+});
+
+test('shouldForceFullRedraw: columns が増えたら true', () => {
+  assert.equal(shouldForceFullRedraw(40, 120), true);
+});
+
+test('shouldForceFullRedraw: columns が減ったら true', () => {
+  assert.equal(shouldForceFullRedraw(120, 40), true);
+});
+
+test('shouldForceFullRedraw: 片方 0 以下は false (未初期化 or 無効)', () => {
+  assert.equal(shouldForceFullRedraw(80, 0), false);
+  assert.equal(shouldForceFullRedraw(0, 80), true);
+});
+
+// ─── formatLine: time-ago 表示 ────────────────────────────────────
+
+test('formatLine: updatedAt から経過時間が表示される', () => {
+  const now = Date.now();
+  const args = {
+    ...makeLineArgs(0.5),
+    now,
+  };
+  args.state.updatedAt = now - 3 * 60 * 1000; // 3 分前
+  const out = stripColors(formatLine(args));
+  assert.ok(out.includes('(3m ago)'), `expected "(3m ago)" in output: ${out}`);
+});
+
+test('formatLine: updatedAt が無ければ ago 表示は出ない', () => {
+  const args = makeLineArgs(0.5);
+  delete args.state.updatedAt;
+  const out = stripColors(formatLine(args));
+  assert.ok(!out.includes('ago'));
+});

package/src/turn-processor.mjs

@@ -43,6 +43,7 @@ import { resolveMergeTarget } from './session-merger.mjs';
 import { writeSessionState } from './state-file.mjs';
 import { summarizeToL1 } from './haiku-summarizer.mjs';
 import { ensureMonitorTaskFile } from './vscode-task.mjs';
+import { readLatestUsage } from './transcript-usage.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
@@ -273,6 +274,26 @@ async function main() {
     }
   }
 
+  // monitor が JSONL を毎フレーム再スキャンせずに済むよう、現在確定している usage を
+  // state ファイルに固定する。Stop 完了時点で assistant エントリは transcript に
+  // 書き出し済みなので readLatestUsage が最新値を返す。
+  // 取得失敗は致命ではないので try/catch で握る（stderr には出す）。
+  try {
+    const usage = transcript_path ? readLatestUsage(transcript_path) : null;
+    if (usage) {
+      writeSessionState({
+        sessionId: session_id,
+        projectPath: cwd ?? process.cwd(),
+        transcriptPath: transcript_path ?? null,
+        pid: process.ppid,
+        usage,
+      });
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[turn-processor] usage snapshot failed: ${msg}\n`);
+  }
+
   process.exit(0);
 }