aiterm-mcp 0.44.1 → 0.45.0

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.45.0] - 2026-09-30
+
+### 変更
+
+- `pty_read({ rtk: true })`のreducerの手本をrtk 0.42.0から0.50.0へ上げた。
+  - grep：rtkの上限（全体200行・1ファイル25行）に収まる間は、grepの出力をそのまま返す。これまでは件数の見出しを付け、長い行を80字で切っていた。上限を超えた時だけファイルごとにまとめ、長い行は検索語の周りを残して切り、省いた分を`+N more in <file>`／`+N more files`で書く。まとめた形が元より長ければ元を返す。
+  - pytest：件数の見出しの下の罫線をやめた。pytestが報告の前に落ちた時（`INTERNALERROR>`、`ERROR: `）は、`Pytest: No tests collected`にせず汎用削減へ戻す。
+  - 縮めた結果が元より多くのトークンを使う時は、reducerを適用しない（rtkの`never_worse`）。
+  - pytestとgrepの回帰見本は、公開版rtk 0.50.0の実行結果から取り直した（recallの案内行は除く）。`FAILED`要約行の理由を全文残す違いは従来どおり。
+
+### 修正
+
+- `git log`のreducerが、何も書かずに10件で打ち切っていた。件数（`-n N`／`-N`／`--max-count`）か範囲（`A..B`）を指定したlogは打ち切らない。件数を指定した時は、rtkと同じく1行の幅を120字にする。指定が無い時は10件にして、`[+N more commits]`で終える。
+
 ## [0.44.1] - 2026-09-30
 
 ### 修正
@@ -1924,7 +1938,8 @@ prototype (preserved under `prototype/python/` as the porting source and referen
   `ubuntu-latest` for Node 18/20/22, publishing to npm on `v*` tags with
   provenance.
 
-[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.44.1...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.45.0...HEAD
+[0.45.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.44.1...v0.45.0
 [0.44.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.44.0...v0.44.1
 [0.44.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.43.7...v0.44.0
 [0.43.7]: https://github.com/kitepon/aiterm-mcp/compare/v0.43.6...v0.43.7

package/README.ja.md

@@ -203,7 +203,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.44.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.45.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -338,16 +338,19 @@ Throughline自体が不要である。
   [aiterm demo: 51 行 / ~56 tok (raw 152 行 / ~166 tok); 102 行 hidden] [is_complete=True via quiescent]
 ```
 
-`grep` を、コマンド別 reducer で「件数ヘッダ＋ヒット行だけ」に畳む:
+`grep` は、rtk の上限（全体 200 行・1 ファイル 25 行）に収まる間は grep の出力をそのまま返す。上限を超えた時だけ、コマンド別 reducer がファイルごとにまとめ、省いた分を書き添える:
 
 ```text
-→ pty_send("demo", "grep -rn capture-pane src/ test/")
+→ pty_send("demo", "grep -rn session src/")
 → pty_read("demo", { wait: true, rtk: true })
-← 2 matches in 1 files:
-
-  src/core.ts:159:// maxBuffer は既定 1MiB。capture-pane（大きなスクロールバック）… （行はここで truncate）
-  src/core.ts:335:const args = ["capture-pane", "-p", "-J", "-t", name];
-  [aiterm demo: rtk:grep 適用 / ~46 tok (raw ~53 tok)] [is_complete=True via quiescent]
+← 550 matches in 23 files:
+
+  src/agent-resolver.ts:211:// …（長い行は検索語の周りを ~80 字だけ残す）
+  …
+  src/remote.ts:268:session_id: session, agent_transcript: true, raw: true,
+    +4 more in src/remote.ts
+  +7 more files
+  [aiterm demo: rtk:grep 適用 / ~4286 tok (raw ~12546 tok)] [is_complete=True via quiescent]
 ```
 
 ネストは「中へ送るただのテキスト」——同じ PTY の*中で* Python REPL に入る（`ssh host`・`docker exec -it … bash`・起動したコーディングエージェントの TUI も、まったく同じ要領でネストする）:
@@ -449,7 +452,7 @@ aiterm          →  cwd=/tmp var=hello123  # 1 本の永続PTYが両方を保
 
 cd でディレクトリを移り、環境変数を立て、ビルドを走らせる。ssh で一度ログインして、その接続のまま 10 個コマンドを打つ。REPL や起動したエージェントの TUI を 1 ターンずつ操作する。こういう流れは、1 本の永続PTYが状態を握っていて初めて成り立つ。端末に何かを覚えておいてほしいときは、aiterm を使う。
 
-<sub>¹ いまのハーネスは ~192 KB の出力をいったんファイルに逃がして、先頭 ~2 KB だけを見せる。そのためトークン数はほぼ並ぶ。aiterm は行数を正確に返すうえ、あとから `line_range="A:B"` で好きな範囲（先頭でも末尾でも）を取り出せる。² `rtk` の grep 縮約は長い行（~80 字）を切り詰めて、あふれを `[+N more]` にまとめる。ざっと眺めるには向くが、全行をそのまま読みたいときは組み込みツールを使う。</sub>
+<sub>¹ いまのハーネスは ~192 KB の出力をいったんファイルに逃がして、先頭 ~2 KB だけを見せる。そのためトークン数はほぼ並ぶ。aiterm は行数を正確に返すうえ、あとから `line_range="A:B"` で好きな範囲（先頭でも末尾でも）を取り出せる。² `rtk` の grep 縮約は、rtk の上限（全体 200 行・1 ファイル 25 行）に収まる間は grep の出力をそのまま返す。上限を超えるとファイルごとにまとめ、長い行は検索語の周りを ~80 字だけ残し、あふれを `+N more in <file>`／`+N more files` にまとめる。大きな検索の全行をそのまま読みたいときは組み込みツールを使う。</sub>
 
 ## 既存手段との比較
 
@@ -649,7 +652,8 @@ agent_launch({ "harness": "codex-cli", "remote": { "host": "rabbit" }, "cwd": "/
 - **`is_complete=False` は失敗ではない。** 「timeout 内に完了を観測できなかった」という意味。長時間コマンドでは `timeout` を伸ばすか `until`/`mark` を使う。
 - **agent harnessは実物TUIを起動し、model APIを代理しない。** model・認証・挙動は選んだharnessのもの。隠れたagent間protocolはなく、MCPクライアントがClaude／Codex／Grok／Cursor TUIへ入力を送り出力を読む。
 - **`pty_send({ rtk: true })` は単行コマンドのみ＋外部 `rtk` バイナリが必要**（無ければ素通し）。一方 `pty_read({ rtk: true })` の reducer は自前実装で rtk 非依存。
-- **`pytest` reducer は件数・罫線・`FAILURES` ブロック整形が rtk 0.42.0 と byte 一致**（回帰テストで固定）。ただし `-ra`/`-rf` 時の `FAILED` 要約行の理由は**全文を保持する**（rtk 0.42.0 は最初の `" - "` 区切りで切るが、本実装は可読性優先で情報を残すため、この行は意図的に rtk と完全一致させない）。rtk が大出力時に付ける `[full output: …]`（tee ポインタ）行は read 側では再現しない。
+- **`pytest` reducer は件数・`FAILURES` ブロック整形が rtk 0.50.0 と byte 一致**（回帰テストで固定）。ただし `-ra`/`-rf` 時の `FAILED` 要約行の理由は**全文を保持する**（rtk 0.50.0 は最初の `" - "` 区切りで切るが、本実装は可読性優先で情報を残すため、この行は意図的に rtk と完全一致させない）。rtk が大出力時に付ける `[full output: …]`（recall ポインタ）行は read 側では再現しない。
+- **`grep` reducer は rtk 0.50.0 と一致**する。上限に収まる間は出力をそのまま返し、上限を超えた時のまとめ方は recall の案内を除いて `rtk grep` と byte 一致する。`git log` は件数（`-n`）か範囲（`A..B`）を指定すると全コミットを残し、指定が無ければ 10 件にして `[+N more commits]` で終える。rtk の `never_worse` と同じく、縮めた結果が元より多くのトークンを使う reducer は適用しない。
 - **tmux は `-f /dev/null` 起動**なので `~/.tmux.conf` を読まない（環境差を排除するため）。
 - **全セッションが単一multiplexer endpoint（POSIXは`claude.sock`、Windows nativeは1つのpsmux namespace）を共有する。** platformの`kill-server` commandは全セッションを消す。
 
@@ -668,7 +672,7 @@ Windows固有だけの変更はLinuxとWindowsを選ぶ。版番号だけの変
 `npm run release -- <version>`がversion同期・commit・tag・GitHub Releaseを一回で行い、tag起点のnpm公開は
 tagged commitが`origin/main`の祖先であることだけを確認して、他のCI結果を待ちません。
 
-共通進行は`src/core.ts`、harness固有は`src/harnesses/`、OS差は`src/tmux-runtime.ts`／`src/agent-resolver.ts`、reducerは`src/rtk.ts`、公開面は`src/index.ts`が所有する。現行設計は[`docs/DESIGN.md`](docs/DESIGN.md)、release手順は[`docs/RELEASE.md`](docs/RELEASE.md)を正とする。`prototype/python/`はreducerの歴史的移植元であり、pytest reducerは本家rtk 0.42.0と一致する（上記の`FAILED`行の差異だけは意図的・回帰テストで固定）。
+共通進行は`src/core.ts`、harness固有は`src/harnesses/`、OS差は`src/tmux-runtime.ts`／`src/agent-resolver.ts`、reducerは`src/rtk.ts`、公開面は`src/index.ts`が所有する。現行設計は[`docs/DESIGN.md`](docs/DESIGN.md)、release手順は[`docs/RELEASE.md`](docs/RELEASE.md)を正とする。`prototype/python/`はreducerの歴史的移植元であり、pytestとgrepのreducerは本家rtk 0.50.0と一致する（上記の`FAILED`行の差異だけは意図的・回帰テストで固定）。
 
 ## 試す
 

package/README.md

@@ -217,7 +217,7 @@ collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.44.1** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.45.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -367,16 +367,19 @@ A long output folded head+tail — the middle is elided by the reducer, not by m
   [aiterm demo: 51 lines / ~56 tok (raw 152 lines / ~166 tok); 102 lines hidden] [is_complete=True via quiescent]
 ```
 
-A `grep`, folded by the per-command reducer to a count header plus just the hits:
+A `grep` comes back exactly as grep printed it while it stays within rtk's caps (200 lines in all, 25 per file). Past a cap, the per-command reducer groups the hits by file and says what it left out:
 
 ```text
-→ pty_send("demo", "grep -rn capture-pane src/ test/")
+→ pty_send("demo", "grep -rn session src/")
 → pty_read("demo", { wait: true, rtk: true })
-← 2 matches in 1 files:
-
-  src/core.ts:159:// maxBuffer defaults to 1 MiB; capture-pane (large scrollback) … (line truncated here)
-  src/core.ts:335:const args = ["capture-pane", "-p", "-J", "-t", name];
-  [aiterm demo: rtk:grep applied / ~46 tok (raw ~53 tok)] [is_complete=True via quiescent]
+← 550 matches in 23 files:
+
+  src/agent-resolver.ts:211:// …(long lines keep ~80 chars around the pattern)
+  …
+  src/remote.ts:268:session_id: session, agent_transcript: true, raw: true,
+    +4 more in src/remote.ts
+  +7 more files
+  [aiterm demo: rtk:grep applied / ~4286 tok (raw ~12546 tok)] [is_complete=True via quiescent]
 ```
 
 Nesting is just text you send in — here a Python REPL *inside* the same PTY (an `ssh host`, a `docker exec -it … bash`, or a launched coding-agent TUI nests exactly the same way):
@@ -480,7 +483,7 @@ aiterm          →  cwd=/tmp var=hello123  # one persistent PTY holds both
 
 `cd` then set env then build, `ssh` once then run ten commands on the authenticated session, drive a live REPL or a launched agent's TUI turn by turn — one persistent PTY holds all of it. Reach for aiterm when the terminal has to remember something.
 
-<sub>¹ Today's harness auto-offloads the ~192 KB dump to a file and previews only a ~2 KB head, so the token counts nearly tie; aiterm reports the accurate line count and lets `line_range="A:B"` pull any slice later, head or tail. ² The `rtk` grep reducer truncates long lines (~80 chars) and folds the overflow into `[+N more]`, which suits scanning; use the built-in tool when you need every full line.</sub>
+<sub>¹ Today's harness auto-offloads the ~192 KB dump to a file and previews only a ~2 KB head, so the token counts nearly tie; aiterm reports the accurate line count and lets `line_range="A:B"` pull any slice later, head or tail. ² The `rtk` grep reducer returns grep's output unchanged while it fits rtk's caps (200 lines, 25 per file). Past a cap it groups by file, keeps ~80 chars of each long line around the pattern, and folds the rest into `+N more in <file>` / `+N more files`; use the built-in tool when you need every full line of a large search.</sub>
 
 ## vs. the alternatives
 
@@ -695,7 +698,8 @@ Sessions live on a shared tmux socket on POSIX or a shared psmux namespace on na
 - **`is_complete=False` is not a failure.** It means "completion was not observed within `timeout`." For long commands, raise `timeout` or use `until`/`mark`.
 - **Agent harnesses run their real TUI; aiterm doesn't proxy the model API.** The selected harness owns model choice, authentication, and behavior. There is no hidden inter-agent protocol; the MCP client drives the Claude/Codex/Grok/Cursor TUI with ordinary send/read operations.
 - **`pty_send({ rtk: true })` is single-line only and needs the external `rtk` binary** (passthrough without it). The `pty_read({ rtk: true })` reducer, by contrast, is self-contained and rtk-independent.
-- **The `pytest` reducer matches rtk 0.42.0** on test counts, the rule line, and `FAILURES`-block formatting (locked by regression tests). It **deliberately preserves the full failure reason** on the `FAILED` summary lines (emitted under `-ra`/`-rf`), whereas rtk 0.42.0 truncates the reason at the first `" - "` — a readability choice, so those lines are intentionally not byte-identical to rtk. The `[full output: …]` tee-pointer line rtk appends on large output is not reproduced on the read side.
+- **The `pytest` reducer matches rtk 0.50.0** on test counts and `FAILURES`-block formatting (locked by regression tests). It **deliberately preserves the full failure reason** on the `FAILED` summary lines (emitted under `-ra`/`-rf`), whereas rtk 0.50.0 truncates the reason at the first `" - "` — a readability choice, so those lines are intentionally not byte-identical to rtk. The `[full output: …]` recall-pointer line rtk appends on large output is not reproduced on the read side.
+- **The `grep` reducer matches rtk 0.50.0**: within the caps it returns the output unchanged, and past a cap its grouped form is byte-identical to `rtk grep` without the recall hints. `git log` keeps every commit when you set a count (`-n`) or a range (`A..B`); otherwise it shows 10 and ends with `[+N more commits]`. Like rtk's `never_worse`, a reducer whose result would cost more tokens than the output is skipped.
 - **tmux is started with `-f /dev/null`**, so it does not read `~/.tmux.conf` (to keep behavior reproducible across machines).
 - **All sessions share one multiplexer endpoint** (`claude.sock` on POSIX, one psmux namespace on native Windows). The platform's `kill-server` command removes them all.
 
@@ -718,7 +722,7 @@ Windows runner needs psmux ≥ 3.3.8 and Git for Windows on its PATH, and must r
 interactive Windows user; `NETWORK SERVICE` lacks the per-user environment the pane shell and
 harness CLIs rely on and is not a valid runner identity.
 
-Logic lives in `src/core.ts` (tmux control, reduction, completion detection, safety, agent launch) and `src/rtk.ts` (per-command reducers); `src/index.ts` is the MCP surface. The current architecture is in [`docs/DESIGN.md`](docs/DESIGN.md), the release procedure is in [`docs/RELEASE.md`](docs/RELEASE.md), and `prototype/python/` remains the reducer's historical porting source (the pytest reducer is ported to match upstream rtk 0.42.0, except the deliberate `FAILED`-line difference noted above, and is locked by regression tests).
+Logic lives in `src/core.ts` (tmux control, reduction, completion detection, safety, agent launch) and `src/rtk.ts` (per-command reducers); `src/index.ts` is the MCP surface. The current architecture is in [`docs/DESIGN.md`](docs/DESIGN.md), the release procedure is in [`docs/RELEASE.md`](docs/RELEASE.md), and `prototype/python/` remains the reducer's historical porting source (the pytest and grep reducers are ported to match upstream rtk 0.50.0, except the deliberate `FAILED`-line difference noted above, and is locked by regression tests).
 
 ## Try it
 

package/dist/rtk.js

@@ -3,15 +3,15 @@
  *
  * 要件C: rtk のファイルは複製せず、アルゴリズムを参照に自分のコードとして書き起こす。
  * rtk バイナリが無い場所でも縮約が効くよう、観測済み出力に対して動く。
- * pytest / grep は人間向け標準出力を解析でき rtk のアルゴリズムに忠実
- * （pytest は rtk 0.42.0 の出力と厳密一致するよう移植）。
+ * 手本は rtk 0.50.0。pytest は同版の出力と厳密一致させ、grep は上限に届かなければ出力をそのまま返す。
+ * rtk の never_worse と同じく、縮めた結果が元より多くのトークンを使うなら reducer を適用しない。
  *
  * 公開 API: reduce(command, output) -> [reducedText|null, reducerName|null] / classify / stripShellFrame
  */
-// rtk 由来のキャップ（truncate.rs / config.rs の値。数値のみ参照、コードは自作）
-const CAP_GREP_TOTAL = 200; // grep: 全体の最大マッチ行
-const CAP_GREP_PER_FILE = 25; // grep: ファイルあたり最大
-const GREP_MAX_LEN = 80; // grep: 1 行の最大幅
+// rtk 由来のキャップ（truncate.rs / config.rs / main.rs の値。数値のみ参照、コードは自作）
+const CAP_GREP_TOTAL = 200; // grep: まとめる時に表示する最大行（文脈行を含む）
+const CAP_GREP_PER_FILE = 25; // grep: まとめる時のファイルあたり最大
+const GREP_MAX_LEN = 80; // grep: まとめる時の 1 行の最大幅（UTF-8 バイトで判定）
 const COMPACT_PATH_THRESH = 50; // grep: パス短縮の閾値
 const MAX_PYTEST_FAILURES = 10; // pytest: 失敗ブロック最大
 const MAX_XFAIL = 10; // pytest: xfail/xpass 行 最大
@@ -19,6 +19,7 @@ const PYTEST_RELEVANT_PER_FAIL = 3;
 const LOG_LIMIT_DEFAULT = 10; // git log: 既定コミット数
 const LOG_BODY_LINES = 3;
 const LOG_WIDTH = 80;
+const LOG_WIDTH_USER_LIMIT = 120; // git log: 利用者が件数を決めた時の幅
 /** char(コードポイント)ベース切り詰め（rtk utils::truncate と同等）。 */
 function truncate(s, n) {
     const cp = Array.from(s);
@@ -134,8 +135,13 @@ export function reducePytest(output) {
         pytestEvidence = true;
     if (!pytestEvidence)
         return null;
-    if (p === 0 && f === 0 && s === 0 && xf === 0 && xp === 0 && e === 0)
+    if (p === 0 && f === 0 && s === 0 && xf === 0 && xp === 0 && e === 0) {
+        // rtk 0.50.0 は報告前に落ちた実行（exit≠0,5）を "No tests collected" にせず元の出力を返す。
+        // read 側は終了コードを持たないので、pytest 自身の異常終了の印で見分ける。
+        if (/^(INTERNALERROR>|ERROR: )/m.test(output))
+            return null;
         return "Pytest: No tests collected";
+    }
     // error(収集/内部エラー)は失敗の一種＝緑扱いにしない。extras に含め、"N passed" 早期 return を止める。
     const extras = s > 0 || xf > 0 || xp > 0 || e > 0 || xfailLines.length > 0;
     if (f === 0 && p > 0 && !extras)
@@ -149,7 +155,7 @@ export function reducePytest(output) {
         head += `, ${xf} xfailed`;
     if (xp > 0)
         head += `, ${xp} xpassed`;
-    const out = [head, "═".repeat(39)];
+    const out = [head];
     if (xfailLines.length) {
         out.push("", "Expected-failure outcomes:");
         for (const ln of xfailLines.slice(0, MAX_XFAIL))
@@ -171,8 +177,8 @@ export function reducePytest(output) {
                 const parts = first.split(" - ");
                 const name = parts[0].slice("FAILED".length).trim();
                 out.push(`${i + 1}. [FAIL] ${name}`);
-                // 失敗理由は全文保持（可読性優先。rtk 0.42.0 は最初の " - " segment で切るが、本実装は情報を残す）。
-                // 末尾セパレータは continue で入れない（rtk 0.42.0 と同じ）。
+                // 失敗理由は全文保持（可読性優先。rtk 0.50.0 は最初の " - " segment で切るが、本実装は情報を残す）。
+                // 末尾セパレータは continue で入れない（rtk 0.50.0 と同じ）。
                 if (parts.length > 1)
                     out.push("     " + truncate(parts.slice(1).join(" - "), 100));
                 continue;
@@ -195,7 +201,7 @@ export function reducePytest(output) {
                         break;
                 }
             }
-            // rtk 0.42.0 互換: セパレータ判定は表示数(shown)でなく全失敗数(failures)基準（cap 超過時の空行数まで一致）。
+            // rtk 0.50.0 互換: セパレータ判定は表示数(shown)でなく全失敗数(failures)基準（cap 超過時の空行数まで一致）。
             if (i < failures.length - 1)
                 out.push("");
         }
@@ -234,6 +240,7 @@ function parsePytestCounts(summary) {
 }
 // ---------------------------------------------------------------- grep
 const GREP_LINE = /^(.*?):(\d+):(.*)$/;
+const GREP_CONTEXT_TAIL = /^(\d+)-(.*)$/;
 function compactPath(p) {
     if (p.length <= COMPACT_PATH_THRESH)
         return p;
@@ -242,42 +249,118 @@ function compactPath(p) {
         return p;
     return `${parts[0]}/.../${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
 }
-export function reduceGrep(output) {
+/** rtk search.rs の clean_line と同じ: 長い行はパターンの周りを残し、無ければ先頭を残す。 */
+function cleanGrepLine(line, maxLen, pattern) {
+    const trimmed = line.trim();
+    if (Buffer.byteLength(trimmed, "utf8") <= maxLen)
+        return trimmed;
+    const chars = Array.from(trimmed);
+    const lower = trimmed.toLowerCase();
+    const pos = pattern ? lower.indexOf(pattern.toLowerCase()) : -1;
+    if (pos < 0)
+        return chars.slice(0, maxLen - 3).join("") + "...";
+    const charPos = Array.from(lower.slice(0, pos)).length;
+    const charLen = chars.length;
+    let start = Math.max(0, charPos - Math.floor(maxLen / 3));
+    const end = Math.min(start + maxLen, charLen);
+    if (end === charLen)
+        start = Math.max(0, end - maxLen);
+    const slice = chars.slice(start, end).join("");
+    if (start > 0 && end < charLen)
+        return `...${slice}...`;
+    if (start > 0)
+        return `...${slice}`;
+    return `${slice}...`;
+}
+/** `file:N:content`（一致）と、既知ファイルの `file-N-content`（文脈）を読む。 */
+function parseGrepLine(line, knownFiles) {
+    for (const f of knownFiles) {
+        if (!line.startsWith(f + "-"))
+            continue;
+        const m = GREP_CONTEXT_TAIL.exec(line.slice(f.length + 1));
+        if (m)
+            return [f, parseInt(m[1], 10), false, m[2]];
+    }
+    const m = GREP_LINE.exec(line);
+    if (!m || !m[1])
+        return null;
+    return [m[1], parseInt(m[2], 10), true, m[3]];
+}
+/**
+ * rtk 0.50.0 の grep: 上限（全体 200 行・ファイルあたり 25 行）に届かなければ出力をそのまま返す。
+ * 上限を超えた時だけファイルごとにまとめ、それが元より短い時に限りまとめた形を返す。
+ * 読めるのはファイル名と行番号の付いた出力だけで、それ以外は null（→ 汎用削減）。
+ */
+export function reduceGrep(output, pattern = "") {
+    const lines = output.split("\n");
+    const candidates = new Set();
+    for (const line of lines) {
+        const m = GREP_LINE.exec(line);
+        if (m && m[1])
+            candidates.add(m[1]);
+    }
+    if (!candidates.size)
+        return null;
+    // 長いファイル名から照合し、`a-1-x` を `a` の文脈行として先に拾う
+    const knownFiles = [...candidates].sort((a, b) => b.length - a.length);
     const byFile = new Map();
-    const order = [];
     let total = 0;
-    for (const line of output.split("\n")) {
-        const m = GREP_LINE.exec(line);
-        if (!m)
+    let hasContext = false;
+    for (const line of lines) {
+        if (line === "--") {
+            hasContext = true;
             continue;
-        const fname = m[1], lineno = m[2], content = m[3];
-        if (!fname || !/^\d+$/.test(lineno))
+        }
+        const parsed = parseGrepLine(line, knownFiles);
+        if (!parsed)
             continue;
-        total++;
-        if (!byFile.has(fname)) {
+        const [fname, lineno, isMatch, content] = parsed;
+        if (isMatch)
+            total++;
+        else
+            hasContext = true;
+        if (!byFile.has(fname))
             byFile.set(fname, []);
-            order.push(fname);
-        }
-        byFile.get(fname).push([lineno, truncate(content.trim(), GREP_MAX_LEN)]);
+        byFile.get(fname).push([lineno, isMatch, cleanGrepLine(content, GREP_MAX_LEN, pattern)]);
     }
     if (total === 0)
         return null;
-    const out = [`${total} matches in ${byFile.size} files:`, ""];
+    const plain = output.replace(/\n+$/, "");
+    const body = [];
     let shown = 0;
-    for (const fname of [...order].sort()) {
-        if (shown >= CAP_GREP_TOTAL)
-            break;
+    let skippedFiles = 0;
+    for (const fname of [...byFile.keys()].sort()) {
+        const entries = byFile.get(fname);
+        if (shown >= CAP_GREP_TOTAL) {
+            skippedFiles++;
+            continue;
+        }
         const disp = compactPath(fname);
-        for (const [lineno, content] of byFile.get(fname).slice(0, CAP_GREP_PER_FILE)) {
+        let fileShown = 0;
+        let prev = 0;
+        for (const [lineno, isMatch, content] of entries.slice(0, CAP_GREP_PER_FILE)) {
             if (shown >= CAP_GREP_TOTAL)
                 break;
-            out.push(`${disp}:${lineno}:${content}`);
+            if (hasContext && prev > 0 && lineno > prev + 1)
+                body.push("--");
+            prev = lineno;
+            const sep = isMatch ? ":" : "-";
+            body.push(`${disp}${sep}${lineno}${sep}${content}`);
             shown++;
+            fileShown++;
         }
+        const remaining = entries.length - fileShown;
+        if (remaining > 0)
+            body.push(`  +${remaining} more in ${disp}`);
     }
-    if (total > shown)
-        out.push(`[+${total - shown} more]`);
-    return out.join("\n");
+    if (skippedFiles > 0)
+        body.push(`+${skippedFiles} more files`);
+    // rtk と同じく、表示数（文脈行を含む）と一致数を比べて上限で削ったかを決める
+    const capped = shown < total || skippedFiles > 0;
+    if (!capped)
+        return plain;
+    const grouped = `${total} matches in ${byFile.size} files:\n\n${body.join("\n")}`;
+    return Buffer.byteLength(grouped, "utf8") < Buffer.byteLength(plain, "utf8") ? grouped : plain;
 }
 // ---------------------------------------------------------------- git status / log
 const GIT_HINT = /^\(use "git |^\(create\/copy files/;
@@ -313,14 +396,40 @@ export function reduceGitStatus(output) {
     }
     return kept.length ? kept.join("\n") : "ok";
 }
-export function reduceGitLog(output) {
+/**
+ * git log の引数から、利用者が件数（-n N / -N / --max-count）や範囲（A..B）を決めたかを読む。
+ * rtk は件数を決めたlogを打ち切らず幅を 120 にする。0.50.0 は範囲も利用者の決めた境界として打ち切らない。
+ */
+function gitLogBounds(args) {
+    let userLimit = false;
+    let range = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--")
+            break;
+        if (/^-\d+$/.test(a) || /^-n\d+$/.test(a) || /^--max-count=\d+$/.test(a))
+            userLimit = true;
+        else if ((a === "-n" || a === "--max-count") && /^\d+$/.test(args[i + 1] ?? "")) {
+            userLimit = true;
+            i++;
+        }
+        else if (!a.startsWith("-") && a.includes(".."))
+            range = true;
+    }
+    return { userLimit, range };
+}
+export function reduceGitLog(output, args = []) {
     if (!output.includes("commit "))
         return null;
     const blocks = output.split(/(?=^commit [0-9a-f]{7,40})/m).filter((b) => b.trim().startsWith("commit "));
     if (!blocks.length)
         return null;
+    const { userLimit, range } = gitLogBounds(args);
+    const width = userLimit ? LOG_WIDTH_USER_LIMIT : LOG_WIDTH;
+    // 件数も範囲も決めていない時だけ既定の 10 件に絞り、絞ったことを書く（黙って捨てない）
+    const limit = userLimit || range ? blocks.length : LOG_LIMIT_DEFAULT;
     const out = [];
-    for (const b of blocks.slice(0, LOG_LIMIT_DEFAULT)) {
+    for (const b of blocks.slice(0, limit)) {
         const bl = b.split("\n").map((x) => x.replace(/\s+$/, ""));
         let commit = "", author = "", subject = "";
         const body = [];
@@ -342,16 +451,18 @@ export function reduceGitLog(output) {
         }
         const am = /<([^>]+)>/.exec(author);
         const who = am ? am[1] : author;
-        let head = truncate(`${commit} ${subject}`.trim(), LOG_WIDTH);
+        let head = truncate(`${commit} ${subject}`.trim(), width);
         if (who)
             head += `  <${who}>`;
         const entry = [head];
         for (const bln of body.slice(0, LOG_BODY_LINES))
-            entry.push("  " + truncate(bln, LOG_WIDTH));
+            entry.push("  " + truncate(bln, width));
         if (body.length > LOG_BODY_LINES)
             entry.push(`  [+${body.length - LOG_BODY_LINES} lines omitted]`);
         out.push(entry.join("\n"));
     }
+    if (blocks.length > limit)
+        out.push(`[+${blocks.length - limit} more commits]`);
     return out.join("\n").trim();
 }
 const FILTERS = [
@@ -432,12 +543,116 @@ export function classify(command) {
             return rule.name;
     return null;
 }
+/** 引用符（'…' "…"）と \\ を解いた語の列。読み取り専用の解析なので、展開や置換はしない。 */
+function shellWords(command) {
+    const words = [];
+    let cur = "";
+    let has = false;
+    let quote = "";
+    for (let i = 0; i < command.length; i++) {
+        const c = command[i];
+        if (quote) {
+            if (c === quote)
+                quote = "";
+            else if (c === "\\" && quote === '"' && i + 1 < command.length)
+                cur += command[++i];
+            else
+                cur += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            has = true;
+        }
+        else if (c === "\\" && i + 1 < command.length) {
+            cur += command[++i];
+            has = true;
+        }
+        else if (/\s/.test(c)) {
+            if (has)
+                words.push(cur);
+            cur = "";
+            has = false;
+        }
+        else {
+            cur += c;
+            has = true;
+        }
+    }
+    if (has)
+        words.push(cur);
+    return words;
+}
+/** verb（git/grep 等）より後ろの語。前置ラッパーは basenameCmd と同じく読み飛ばす。 */
+function argsAfterVerb(command) {
+    const [verb, , stripped] = basenameCmd(command);
+    if (!verb)
+        return [];
+    const words = shellWords(stripped);
+    return words.slice(1);
+}
+// 値を取る grep / rg のフラグ（別の語で値を渡す形）。パターンを値と取り違えないために使う。
+const GREP_VALUE_SHORT = new Set(["e", "f", "m", "A", "B", "C", "d", "D"]);
+const RG_VALUE_SHORT = new Set(["e", "f", "m", "A", "B", "C", "d", "g", "t", "T", "M", "j", "E", "r"]);
+const GREP_VALUE_LONG = new Set([
+    "regexp", "file", "max-count", "after-context", "before-context", "context", "devices", "directories",
+    "include", "exclude", "exclude-dir", "exclude-from", "label", "glob", "iglob", "type", "type-not",
+    "max-columns", "threads", "max-depth", "color", "colors", "sort", "sortr", "encoding", "pre", "replace",
+]);
+/** grep / rg の検索パターン（-e が複数なら `|` で結ぶ。rtk の pattern_display と同じ）。 */
+export function grepPattern(command) {
+    const args = argsAfterVerb(command);
+    const valueShort = basenameCmd(command)[0] === "rg" ? RG_VALUE_SHORT : GREP_VALUE_SHORT;
+    const explicit = [];
+    const positional = [];
+    let endOfFlags = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (endOfFlags || !a.startsWith("-") || a === "-") {
+            positional.push(a);
+            continue;
+        }
+        if (a === "--") {
+            endOfFlags = true;
+            continue;
+        }
+        if (a.startsWith("--")) {
+            const [name, attached] = a.slice(2).split(/=(.*)/s);
+            const value = attached !== undefined ? attached : GREP_VALUE_LONG.has(name) ? args[++i] : undefined;
+            if (name === "regexp" && value !== undefined)
+                explicit.push(value);
+            continue;
+        }
+        const cluster = a.slice(1);
+        for (let j = 0; j < cluster.length; j++) {
+            if (!valueShort.has(cluster[j]))
+                continue;
+            const rest = cluster.slice(j + 1);
+            const value = rest || args[++i];
+            if (cluster[j] === "e" && value !== undefined)
+                explicit.push(value);
+            break;
+        }
+    }
+    if (explicit.length)
+        return explicit.join("|");
+    return positional[0] ?? "";
+}
+/** `git [opts] log <args>` の log より後ろの語。 */
+function gitLogArgs(command) {
+    const args = argsAfterVerb(command);
+    const i = args.indexOf("log");
+    return i >= 0 ? args.slice(i + 1) : [];
+}
 const REDUCERS = {
-    "git-status": reduceGitStatus,
-    "git-log": reduceGitLog,
-    grep: reduceGrep,
+    "git-status": (o) => reduceGitStatus(o),
+    "git-log": (o, c) => reduceGitLog(o, gitLogArgs(c)),
+    grep: (o, c) => reduceGrep(o, grepPattern(c)),
     pytest: (o) => reducePytest(o),
 };
+/** rtk の estimate_tokens と同じ（UTF-8 バイト数 / 4 の切り上げ）。 */
+function estimateTokens(s) {
+    return Math.ceil(Buffer.byteLength(s, "utf8") / 4);
+}
 /**
  * コマンドに応じた reducer を観測出力へ適用。返り値 [reducedText|null, reducerName|null]。
  * 前提(C13): `output` は制御文字除去済み（ANSI/CR 等）であること。色付き/生 PTY 出力を直接渡すと
@@ -447,12 +662,18 @@ export function reduce(command, output) {
     const name = classify(command);
     if (name === null)
         return [null, null];
-    if (name in REDUCERS) {
-        const red = REDUCERS[name](output);
-        return red !== null ? [red, name] : [null, null];
+    let red = null;
+    if (name in REDUCERS)
+        red = REDUCERS[name](output, command);
+    else {
+        const rule = FILTERS.find((r) => r.name === name);
+        if (rule)
+            red = applyFilter(rule, output);
     }
-    for (const rule of FILTERS)
-        if (rule.name === name)
-            return [applyFilter(rule, output), name];
-    return [null, null];
+    if (red === null)
+        return [null, null];
+    // rtk の never_worse: 縮めた結果の方がトークンを使うなら適用しない（→ 呼び手の汎用削減へ）
+    if (estimateTokens(red) > estimateTokens(output))
+        return [null, null];
+    return [red, name];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.44.1",
+  "version": "0.45.0",
   "mcpName": "io.github.kitepon/aiterm-mcp",
   "description": "Persistent terminal MCP with one harness-based launcher for Claude Code, Codex CLI, Grok CLI, and Cursor Agent CLI, plus durable PTYs for SSH, containers, and REPLs.",
   "keywords": [