throughline 0.3.15 → 0.3.16

package/package.json

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

package/src/terminal-size.mjs

@@ -0,0 +1,115 @@
+/**
+ * terminal-size.mjs — OSC 18t (CSI 18t) で端末に window 幅を問い合わせるユーティリティ
+ *
+ * 背景: Windows ConPTY + VSCode task terminal では `process.stdout.columns` が
+ * 起動時のサイズで凍結し、panel の resize に追従しない。`process.stdout.on('resize')`
+ * も発火しない。Node 側からは polling しても同じ値しか取れない。
+ *
+ * 対策: ANSI CSI 18t (`\x1b[18t`) シーケンスで端末に「今の幅は？」と直接訊く。
+ * 対応端末 (xterm / VSCode 1.88+ / Windows Terminal 一部) は
+ * `\x1b[8;rows;cols t` で stdin に返してくる。これを raw mode で受けてパースすれば
+ * resize 後の真の columns が取れる。
+ *
+ * 非対応端末 (古い VSCode、ConEmu 等) は返事をしない。呼び出し側はタイムアウトで
+ * フォールバック (従来の process.stdout.columns) に落とす。
+ */
+
+const CSI_QUERY_WINDOW_SIZE = '\x1b[18t';
+
+// xterm.js / xterm は `\x1b[8;{rows};{cols}t` で返答する（CSI t ファミリ）。
+// 稀に `\x1b[8;{rows};{cols};W t` のようにオプショナルトークンが混ざる端末もあるため
+// 非貪欲マッチでターミネータ 't' までを拾う。
+const RESPONSE_RE = /\x1b\[8;(\d+);(\d+)t/;
+
+/**
+ * 受信バッファからサイズ応答を抽出する。純粋関数なのでテスト可能。
+ * @param {string} buf - 受信済みバイト列 (UTF-8 文字列化済み)
+ * @returns {{ cols: number, rows: number, consumedEnd: number } | null}
+ */
+export function parseSizeResponse(buf) {
+  const m = buf.match(RESPONSE_RE);
+  if (!m) return null;
+  const rows = Number(m[1]);
+  const cols = Number(m[2]);
+  if (!Number.isFinite(rows) || !Number.isFinite(cols)) return null;
+  return { rows, cols, consumedEnd: m.index + m[0].length };
+}
+
+/**
+ * OSC 18t クエリ機構を起動する。
+ *
+ * 契約:
+ *  - stdin が TTY でない、または setRawMode が使えない環境では `{ supported: false }` を即返す
+ *  - stdin を raw mode にし、data listener を登録する
+ *  - query() を呼ぶたびに `\x1b[18t` を stdout に書く
+ *  - 応答が返ってきたら onSize({cols, rows}) を呼ぶ
+ *  - Ctrl+C (0x03) を受け取ったら onInterrupt を呼ぶ (raw mode では自動 SIGINT が飛ばないため)
+ *  - stop() で raw mode を解除する (shutdown 時に必須)
+ *
+ * @param {{
+ *   stdin?: NodeJS.ReadableStream & { setRawMode?: (v: boolean) => unknown, isTTY?: boolean },
+ *   stdout?: NodeJS.WritableStream,
+ *   onSize: (size: { cols: number, rows: number }) => void,
+ *   onInterrupt?: () => void,
+ * }} deps
+ * @returns {{ supported: boolean, query: () => void, stop: () => void }}
+ */
+export function startSizeQuery(deps) {
+  const stdin = deps.stdin ?? process.stdin;
+  const stdout = deps.stdout ?? process.stdout;
+  const onSize = deps.onSize;
+  const onInterrupt = deps.onInterrupt;
+
+  const unsupported = { supported: false, query: () => {}, stop: () => {} };
+  if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+    return unsupported;
+  }
+
+  try {
+    stdin.setRawMode(true);
+  } catch {
+    return unsupported;
+  }
+  stdin.setEncoding?.('utf8');
+  stdin.resume?.();
+
+  let buf = '';
+  const onData = (chunk) => {
+    buf += chunk;
+    // Ctrl+C (ETX 0x03) 検出: raw mode だと自動 SIGINT 化しないので自前で拾う
+    if (onInterrupt && buf.indexOf('\x03') >= 0) {
+      try { onInterrupt(); } catch { /* shutdown path なので握り潰す */ }
+      return; // これ以上 parse しても無駄
+    }
+    // 複数応答が溜まっていたら最後の 1 件だけ採用し、バッファから消費分を落とす
+    let parsed = parseSizeResponse(buf);
+    let lastSize = null;
+    while (parsed) {
+      lastSize = { cols: parsed.cols, rows: parsed.rows };
+      buf = buf.slice(parsed.consumedEnd);
+      parsed = parseSizeResponse(buf);
+    }
+    if (lastSize) {
+      try { onSize(lastSize); } catch { /* 描画例外は呼び出し元で処理 */ }
+    }
+    // バッファが暴走しないよう頭を切る (応答は通常 12 バイト程度)
+    if (buf.length > 256) buf = buf.slice(-64);
+  };
+  stdin.on('data', onData);
+
+  let stopped = false;
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    try { stdin.off?.('data', onData); } catch { /* noop */ }
+    try { stdin.setRawMode(false); } catch { /* noop */ }
+    try { stdin.pause?.(); } catch { /* noop */ }
+  };
+
+  const query = () => {
+    if (stopped) return;
+    try { stdout.write(CSI_QUERY_WINDOW_SIZE); } catch { /* closed stdout の可能性 */ }
+  };
+
+  return { supported: true, query, stop };
+}

package/src/terminal-size.test.mjs

@@ -0,0 +1,164 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { parseSizeResponse, startSizeQuery } from './terminal-size.mjs';
+
+// --- parseSizeResponse ---
+
+test('parseSizeResponse: 正常な CSI 8 応答をパースする', () => {
+  const r = parseSizeResponse('\x1b[8;24;80t');
+  assert.deepEqual(r && { rows: r.rows, cols: r.cols }, { rows: 24, cols: 80 });
+});
+
+test('parseSizeResponse: 先頭にノイズがあっても応答を見つける', () => {
+  const r = parseSizeResponse('garbage\x1b[8;40;120tmore');
+  assert.ok(r);
+  assert.equal(r.rows, 40);
+  assert.equal(r.cols, 120);
+  assert.equal(r.consumedEnd, 'garbage\x1b[8;40;120t'.length);
+});
+
+test('parseSizeResponse: 応答が無ければ null', () => {
+  assert.equal(parseSizeResponse(''), null);
+  assert.equal(parseSizeResponse('\x1b[8;24t'), null); // 不完全
+  assert.equal(parseSizeResponse('not ansi at all'), null);
+});
+
+test('parseSizeResponse: 数値でない応答は null', () => {
+  // 実際は RE が \d+ のみマッチするので to null になる
+  assert.equal(parseSizeResponse('\x1b[8;abc;defgt'), null);
+});
+
+// --- startSizeQuery ---
+
+function makeFakeStdin({ isTTY = true } = {}) {
+  const ee = new EventEmitter();
+  ee.isTTY = isTTY;
+  ee.setRawMode = (v) => { ee.rawMode = v; };
+  ee.setEncoding = () => {};
+  ee.resume = () => {};
+  ee.pause = () => {};
+  ee.off = (ev, fn) => ee.removeListener(ev, fn);
+  ee.rawMode = false;
+  return ee;
+}
+
+function makeFakeStdout() {
+  const writes = [];
+  return {
+    writes,
+    write(data) { writes.push(data); return true; },
+  };
+}
+
+test('startSizeQuery: stdin が TTY でなければ supported=false', () => {
+  const stdin = makeFakeStdin({ isTTY: false });
+  const stdout = makeFakeStdout();
+  const onSize = () => {};
+  const q = startSizeQuery({ stdin, stdout, onSize });
+  assert.equal(q.supported, false);
+});
+
+test('startSizeQuery: TTY なら supported=true で raw mode を立てる', () => {
+  const stdin = makeFakeStdin({ isTTY: true });
+  const stdout = makeFakeStdout();
+  const q = startSizeQuery({ stdin, stdout, onSize: () => {} });
+  assert.equal(q.supported, true);
+  assert.equal(stdin.rawMode, true);
+  q.stop();
+  assert.equal(stdin.rawMode, false);
+});
+
+test('startSizeQuery: query() で \\x1b[18t が stdout に書かれる', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const q = startSizeQuery({ stdin, stdout, onSize: () => {} });
+  q.query();
+  assert.deepEqual(stdout.writes, ['\x1b[18t']);
+  q.stop();
+});
+
+test('startSizeQuery: stdin に応答が流れると onSize が呼ばれる', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const sizes = [];
+  const q = startSizeQuery({ stdin, stdout, onSize: (s) => sizes.push(s) });
+  stdin.emit('data', '\x1b[8;24;80t');
+  assert.deepEqual(sizes, [{ rows: 24, cols: 80 }]);
+  q.stop();
+});
+
+test('startSizeQuery: 複数応答が一度に来たら最後のサイズだけ採用する', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const sizes = [];
+  const q = startSizeQuery({ stdin, stdout, onSize: (s) => sizes.push(s) });
+  // resize スパムで連続応答が来るケースを想定
+  stdin.emit('data', '\x1b[8;24;80t\x1b[8;30;100t\x1b[8;40;120t');
+  assert.deepEqual(sizes, [{ rows: 40, cols: 120 }]);
+  q.stop();
+});
+
+test('startSizeQuery: 応答が分割到着しても連結してパースする', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const sizes = [];
+  const q = startSizeQuery({ stdin, stdout, onSize: (s) => sizes.push(s) });
+  stdin.emit('data', '\x1b[8;24');
+  stdin.emit('data', ';80t');
+  assert.deepEqual(sizes, [{ rows: 24, cols: 80 }]);
+  q.stop();
+});
+
+test('startSizeQuery: Ctrl+C (0x03) が来たら onInterrupt を呼ぶ', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  let interrupted = false;
+  const q = startSizeQuery({
+    stdin,
+    stdout,
+    onSize: () => {},
+    onInterrupt: () => { interrupted = true; },
+  });
+  stdin.emit('data', '\x03');
+  assert.equal(interrupted, true);
+  q.stop();
+});
+
+test('startSizeQuery: stop() 後は query() しても書き込まない', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const q = startSizeQuery({ stdin, stdout, onSize: () => {} });
+  q.stop();
+  q.query();
+  assert.deepEqual(stdout.writes, []);
+});
+
+test('startSizeQuery: stop() を 2 度呼んでも安全 (冪等)', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const q = startSizeQuery({ stdin, stdout, onSize: () => {} });
+  q.stop();
+  q.stop();
+  assert.equal(stdin.rawMode, false);
+});
+
+test('startSizeQuery: バッファが 256 バイト超えたら前方を捨てる', () => {
+  const stdin = makeFakeStdin();
+  const stdout = makeFakeStdout();
+  const sizes = [];
+  const q = startSizeQuery({ stdin, stdout, onSize: (s) => sizes.push(s) });
+  // 応答が来ない状況でゴミが 300 バイト溜まる → 次の正常応答が認識される
+  stdin.emit('data', 'x'.repeat(300));
+  stdin.emit('data', '\x1b[8;10;20t');
+  assert.deepEqual(sizes, [{ rows: 10, cols: 20 }]);
+  q.stop();
+});
+
+test('startSizeQuery: setRawMode で throw する stdin は supported=false', () => {
+  const stdin = makeFakeStdin();
+  stdin.setRawMode = () => { throw new Error('no raw'); };
+  const stdout = makeFakeStdout();
+  const q = startSizeQuery({ stdin, stdout, onSize: () => {} });
+  assert.equal(q.supported, false);
+});

package/src/token-monitor.mjs

@@ -23,6 +23,7 @@ import { statSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { getStateDir, readAllSessionStates, snapshotStateMtimes, normalizeProjectPath } from './state-file.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
+import { startSizeQuery } from './terminal-size.mjs';
 
 const REFRESH_MS = 1000;
 // データ変化が無くても N ms ごとに再描画して「(24m ago)」表示を進める。
@@ -238,26 +239,43 @@ export function shouldForceFullRedraw(prevCols, currCols) {
   return prevCols !== currCols && currCols > 0;
 }
 
+// OSC 18t (startSizeQuery) で取得した最新の「端末実測幅」。
+// Windows ConPTY + VSCode task terminal では process.stdout.columns が起動時の値で
+// 凍結するため、resize に追従するにはこの ANSI クエリ経路が必要。
+// undefined = 未取得 / OSC 18t 非対応環境。その場合は process.stdout.columns にフォールバック。
+let measuredCols = undefined;
+
+/** テスト用: OSC 18t の測定値を手動でセット/リセット */
+export function setMeasuredColumns(v) {
+  measuredCols = v;
+}
+
 /**
  * 描画に使う列幅を解決する。
  *
  * 優先順:
- *   1. **stdout が TTY** かつ `process.stdout.columns` が 1 以上
- *       → その値から 1 引いたもの（末尾列での自動改行回避）
- *   2. `process.env.COLUMNS` が 1 以上 → その値 - 1
- *   3. それ以外 → 80 にフォールバック
+ *   1. OSC 18t で測った実測値 (measuredCols) が 1 以上 → それ - 1
+ *   2. stdout が TTY かつ `process.stdout.columns` が 1 以上 → それ - 1
+ *   3. `process.env.COLUMNS` が 1 以上 → それ - 1
+ *   4. それ以外 → 80 にフォールバック
  *
- * 歴史: 0.3.6〜0.3.12 までは `>= 40` の閾値を設けて「狂った小さい値は捨てる」挙動
- * だった。しかし実際の VSCode task panel は 30 cells 程度で起動することがあり (実測)、
- * 真の columns=30 なのに閾値に引っかかって 200 フォールバックに倒れ、30 cell 端末に
- * 200 cell の行を書いて 7 行に折り返し、`\x1b[NA` が 7 倍 under-count して
- * 描画が永遠に積み上がるバグの真因だった。
+ * OSC 18t を最優先にする理由:
+ *   Windows ConPTY + VSCode task terminal は panel resize が process.stdout.columns
+ *   に届かず凍結する。毎フレーム `\x1b[18t` を端末に投げて `\x1b[8;rows;cols t` を
+ *   stdin で受けると、真の現在幅が取れる (0.3.16 で導入、terminal-size.mjs 参照)。
  *
- * 正の columns はすべて信頼する。真の幅に合わせて truncate すれば物理行 = 論理行
- * が保証され、CUU 戻り先が正確になる。狭い terminal ではコンテンツが切り詰められるが、
- * 積み上がりに比べれば遥かにマシ (ユーザーが panel を広げれば full UI が見える)。
+ *   非対応端末 (古い VSCode、パイプ出力) では measuredCols が undefined のままで
+ *   自動的にフォールバック経路に倒れる。
+ *
+ * 歴史 (保管):
+ *   0.3.6〜0.3.12 は `>= 40` 閾値で狭い columns を「狂った値」として 200 に倒す
+ *   挙動だったが、30 cells の panel が実在するため 200 セルの行 →  物理 7 行 wrap →
+ *   CUU under-count → 積み上がり、という連鎖バグの起点だった。0.3.13 で閾値を撤廃。
  */
 export function resolveColumns() {
+  if (typeof measuredCols === 'number' && measuredCols > 0) {
+    return Math.max(1, measuredCols - 1);
+  }
   if (process.stdout.isTTY) {
     const reported = typeof process.stdout.columns === 'number' ? process.stdout.columns : 0;
     if (reported > 0) return Math.max(1, reported - 1);
@@ -401,11 +419,9 @@ function renderFrame(args) {
       }
     }
   } else {
-    // runtime cols を毎フレーム出してリサイズ追従状況を可視化する (診断目的、将来削除可)
-    const runtimeCols = process.stdout.columns ?? '?';
     const header = color(
       ANSI.bold,
-      `[Throughline] ${filtered.length} セッション cols=${runtimeCols}${args.all ? ' (--all)' : ''}`,
+      `[Throughline] ${filtered.length} セッション${args.all ? ' (--all)' : ''}`,
     );
     lines.push(header);
     const now = Date.now();
@@ -559,21 +575,40 @@ export function main() {
   }
 
   process.stdout.write(ANSI.hideCursor);
-  // 起動時に実 runtime での TTY/columns/resolveColumns を出す。
-  // diag と runtime で値がズレる (PTY allocation タイミング違い等) を直視できるようにするため。
-  const startupCols = resolveColumns();
-  const ttyFlag = process.stdout.isTTY ? 'T' : '-';
-  process.stdout.write(color(ANSI.dim,
-    `[Throughline] モニター起動 [${ttyFlag} cols=${process.stdout.columns ?? '?'} clip=${startupCols}] Ctrl+C で終了\n`,
-  ));
+  process.stdout.write(color(ANSI.dim, `[Throughline] モニター起動 (state: ${getStateDir()}, Ctrl+C で終了)\n`));
+
+  // OSC 18t で端末に直接「今の幅は？」を問い合わせる経路を立ち上げる。
+  // Windows ConPTY + VSCode task terminal では process.stdout.columns が凍結するため、
+  // これが無いと panel を広げても content が復活しない。
+  // 応答が来るたびに measuredCols を更新 → 次フレームで resolveColumns がそれを使う。
+  const sizeQuery = startSizeQuery({
+    onSize: ({ cols }) => {
+      const prev = resolveColumns();
+      setMeasuredColumns(cols);
+      const curr = resolveColumns();
+      if (prev !== curr) {
+        // 幅が実際に変わった時だけ全再描画。同値なら needsRerender の通常経路に任せる
+        lastRenderedLines = 0;
+        resetRenderKeyCache();
+        safeRenderFrame(args);
+      }
+    },
+    onInterrupt: () => process.kill(process.pid, 'SIGINT'),
+  });
 
   safeRenderFrame(args);
-  // columns の最後に使った値。polling で resize 検知するために使う。
-  // VSCode 統合ターミナルは process.stdout.on('resize') が発火しないことがあり、
-  // 起動時に狭い幅だった場合に描画が崩れたまま固定される（実害ベースで確認済み）。
-  // 1 秒 tick のたびに currCols と比較してイベント不達を埋める。
+  // 起動直後に 1 回クエリを飛ばして正しい初期幅を取る
+  if (sizeQuery.supported) sizeQuery.query();
+
+  // 1 秒 tick:
+  //   - OSC 18t に対応している端末なら毎回クエリを投げて resize 追従
+  //   - 対応していない端末では process.stdout.columns の変化を従来通り polling
+  //   - 更新が無くてもデータ変化 (needsRerender) があれば再描画
+  //   - 10 秒に 1 回は (Nm ago) 表示更新のために強制再描画
   let lastColumns = process.stdout.columns ?? 0;
   const timer = setInterval(() => {
+    if (sizeQuery.supported) sizeQuery.query();
+
     const currCols = process.stdout.columns ?? 0;
     if (shouldForceFullRedraw(lastColumns, currCols)) {
       lastColumns = currCols;
@@ -582,11 +617,7 @@ export function main() {
       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);
@@ -614,6 +645,7 @@ export function main() {
   const shutdown = (code = 0) => {
     clearInterval(timer);
     if (resizeTimer) clearTimeout(resizeTimer);
+    sizeQuery.stop(); // stdin raw mode を確実に解除 (残ると端末が壊れる)
     restoreCursor();
     process.stdout.write('\n' + color(ANSI.dim, '[Throughline] モニター終了\n'));
     process.exit(code);
@@ -621,16 +653,20 @@ export function main() {
   process.on('SIGINT', () => shutdown(0));
   process.on('SIGTERM', () => shutdown(0));
 
-  // クラッシュ時もカーソルを必ず戻す
-  process.on('exit', restoreCursor);
-  process.on('uncaughtException', (err) => {
+  // クラッシュ時もカーソルと raw mode を必ず戻す
+  const cleanupOnCrash = () => {
+    sizeQuery.stop();
     restoreCursor();
+  };
+  process.on('exit', cleanupOnCrash);
+  process.on('uncaughtException', (err) => {
+    cleanupOnCrash();
     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();
+    cleanupOnCrash();
     process.stderr.write(`[Throughline] unhandled rejection: ${String(reason)}\n`);
     process.exit(1);
   });
@@ -652,6 +688,7 @@ export const _internal = {
   formatTimeAgo,
   shouldForceFullRedraw,
   resolveColumns,
+  setMeasuredColumns,
 };
 
 // --- エントリポイント自動起動 ---

package/src/token-monitor.test.mjs

@@ -16,6 +16,7 @@ const {
   formatTimeAgo,
   shouldForceFullRedraw,
   resolveColumns,
+  setMeasuredColumns,
 } = _internal;
 
 // state-file は projectPath を resolve + lowercase 正規化する。
@@ -453,6 +454,39 @@ test('resolveColumns: 全てのソースが無効ならフォールバック 80'
   });
 });
 
+test('resolveColumns: OSC 18t 実測値が最優先で採用される', () => {
+  // process.stdout.columns=30 (凍結値) でも measuredCols=90 が返ってくれば 89 を返す
+  // (Windows ConPTY + VSCode task panel で panel resize に追従する経路)
+  withStdoutState({ isTTY: true, columns: 30, envColumns: undefined }, () => {
+    try {
+      setMeasuredColumns(90);
+      assert.equal(resolveColumns(), 89);
+    } finally {
+      setMeasuredColumns(undefined);
+    }
+  });
+});
+
+test('resolveColumns: measuredCols=0 は無効値として無視する', () => {
+  withStdoutState({ isTTY: true, columns: 30, envColumns: undefined }, () => {
+    try {
+      setMeasuredColumns(0);
+      assert.equal(resolveColumns(), 29); // stdout.columns へ落ちる
+    } finally {
+      setMeasuredColumns(undefined);
+    }
+  });
+});
+
+test('resolveColumns: measuredCols をリセットすれば従来経路に戻る', () => {
+  withStdoutState({ isTTY: true, columns: 30, envColumns: undefined }, () => {
+    setMeasuredColumns(90);
+    assert.equal(resolveColumns(), 89);
+    setMeasuredColumns(undefined);
+    assert.equal(resolveColumns(), 29);
+  });
+});
+
 // ─── formatLine: time-ago 表示 ────────────────────────────────────
 
 test('formatLine: updatedAt から経過時間が表示される', () => {