aiterm-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kitepon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ja.md

@@ -0,0 +1,124 @@
+<p align="center">
+  <img src=".github/og.svg" alt="aiterm-mcp — AI が握るローカル永続端末を stdio MCP サーバとして公開する" width="100%">
+</p>
+
+# aiterm-mcp
+
+[![CI](https://github.com/kitepon-rgb/aiterm-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/kitepon-rgb/aiterm-mcp/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/aiterm-mcp.svg)](https://www.npmjs.com/package/aiterm-mcp)
+
+> *(English: [README.md](README.md))*
+
+> AI が握る**ローカル永続端末**を stdio MCP サーバとして公開する。1 個のローカル端末を握り、SSH もコンテナも「その端末に打つ 1 コマンド」に格下げする。読み取りはトークン削減つき。
+
+`pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` の 6 ツールだけ。バックエンドは tmux なので、MCP サーバや AI クライアントが再起動してもセッションは生き残る。
+
+## なぜ
+
+AI にコマンドを 1 個ずつ投げて結果を受け取る往復は、SSH では毎回「接続→認証→切断」を繰り返し遅く、トークンも食う。aiterm は **1 個の PTY を永続的に握り**、その中で `ssh host` や `docker exec -it x bash` と打って入る（ネスト）。セッション種別をツールで区別しない。
+
+```
+pty_open()                         → ローカル端末を 1 個握る
+pty_send(id, "ssh 192.168.1.2")    → その端末の中で SSH に入る
+pty_send(id, "uname -a")           → リモートで実行
+pty_read(id, { wait: true })       → 削減済みの出力を読む
+```
+
+## 仕組み
+
+```mermaid
+flowchart LR
+    AI["AI / MCP client"] -->|"pty_send"| S["aiterm-mcp<br/>stdio MCP · 6 tools"]
+    S -->|"pty_read<br/>token-reduced"| AI
+    S -->|"tmux send-keys<br/>capture-pane"| P["one local PTY<br/>tmux · persistent"]
+    P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
+```
+
+プリミティブは「PTY を 1 個握る」ことだけ。SSH・コンテナ・REPL は、その中へ `pty_send` で打ち込む“ただのテキスト”に過ぎない。PTY は tmux 上にあるので、MCP サーバや AI クライアントが再起動してもセッションは生き残る。
+
+## 既存手段との比較
+
+| | **aiterm-mcp** | 1 コマンド毎の往復 | 一般的な terminal / tmux MCP |
+| --- | --- | --- | --- |
+| 永続セッション | ✅ tmux・再起動を跨ぐ | ❌ 毎回新シェル | ⚠️ まちまち |
+| SSH / コンテナ | `pty_send` 1 回でネスト | 毎コマンド接続し直し | ⚠️ ツールが分かれがち |
+| トークン削減読取 | ✅ コマンド別 reducer | ❌ 生出力 | ⚠️ ほぼ無し |
+| 完了検出 | 4 層: 終了 / `until` / 静止 / timeout | 無し（毎回ブロック） | ⚠️ プロンプト一致・脆い |
+| 人が同時操作 | ✅ 共有 tmux ソケット | ❌ | ⚠️ まちまち |
+
+## 要件
+
+- **Node.js >= 18**
+- **tmux**（実行時の前提。`tmux -V` で確認。未導入なら `apt install tmux` / `brew install tmux`）
+- 任意: [`rtk`](https://github.com/rtk-ai/rtk) バイナリ（`pty_send` の `rtk: true` 委譲で使う。無くても動く）
+
+## インストール / 登録
+
+Claude Code（CLI）にユーザースコープ（全プロジェクトで利用可）で登録する例:
+
+```bash
+# 公開後（npm）
+claude mcp add --scope user --transport stdio aiterm -- npx -y aiterm-mcp
+
+# またはグローバルインストールしてコマンド名で
+npm i -g aiterm-mcp
+claude mcp add --scope user --transport stdio aiterm -- aiterm-mcp
+```
+
+`~/.claude.json` に登録される。Claude Code を再起動すると、初回に承認プロンプトが出る。`/mcp` で接続状態を確認できる。
+
+他の MCP クライアントでも、stdio で `npx -y aiterm-mcp`（または `aiterm-mcp`）を起動するだけ。
+
+## ツール
+
+| ツール | 役割 | 主な引数 |
+| --- | --- | --- |
+| `pty_open` | 端末を 1 個握り `session_id` を返す | `name?`, `shell="bash"` |
+| `pty_send` | テキスト(コマンド)を送る | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
+| `pty_read` | 出力を削減して読む（既定は増分） | `session_id`, `wait`, `until`, `timeout`, `screen`, `full`, `lines`, `line_range`, `raw`, `rtk` |
+| `pty_key` | 制御キーを送る | `session_id`, `key`（`C-c`/`Enter`/`Up`…） |
+| `pty_close` | セッションを閉じる | `session_id` |
+| `pty_list` | セッション一覧 | （なし） |
+
+### 完了検出（4 層）
+
+`pty_read({ wait: true })` は、プロセス終了 / `until` 正規表現一致 / 出力静止 ∧ シェル復帰（quiescence）/ timeout の 4 層で「コマンドが終わったか」を判定する。ネスト中（SSH 先）はシェル復帰判定が効かないので `until` でプロンプトを指定すると綺麗に判定できる。
+
+### トークン削減
+
+- `pty_read` は既定で制御文字除去・連続重複圧縮・head+tail 折りたたみ（＋復元ヒント・メタ併記）をかける。
+- `pty_read({ rtk: true })` は直前に送ったコマンド別の reducer（`git status`/`git log`/`grep`/`pytest` ほか）で観測出力をさらに縮約する（rtk バイナリ非依存・自前実装）。
+- `pty_send({ rtk: true })` は既知コマンドを `rtk` 形に書き換えて送り、実行先に `rtk` があればソースで削減を効かせる（無ければ素通し）。
+
+### 安全
+
+`pty_send` は送信前に破壊的コマンド（`rm -rf /`, `mkfs`, `dd of=/dev/…`, `DROP TABLE` 等）を遮断し（`force: true` で越える）、ESC・ブラケットペースト終端などをサニタイズする。`pty_read` は制御文字を無害化して返す。
+
+## 既知の制約（バグではなく仕様）
+
+- **ネスト中（ssh / docker / REPL）は quiescence が原理的に効かない。** 前面コマンドがシェル集合（bash/sh/zsh/fish/dash）の外になるため。完了検出は `until`（プロンプト等の正規表現）か `mark: true`（終了コード付き sentinel）を使う。
+- **`is_complete=False` は失敗ではない。** 「timeout 内に完了を観測できなかった」という意味。長時間コマンドでは `timeout` を伸ばすか `until`/`mark` を使う。
+- **破壊ゲートはサンドボックスではなく tripwire。** よくある破壊形だけを弾く。相対パスの `rm`、`$VAR` 展開後に危険化するもの、ssh 先で実行されるコマンドは捕捉しない。
+- **`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 側では再現しない。
+- **tmux は `-f /dev/null` 起動**なので `~/.tmux.conf` を読まない（環境差を排除するため）。
+- **全セッションが単一 socket（`claude.sock`）上にある。** `tmux … kill-server` は全セッションを消す。
+
+## 人が覗く
+
+セッションは共有 tmux ソケット上にある。`pty_open` の戻り値に表示される `tmux -S … attach -t <id>` で人間が同じ端末に入って介入できる（抜けるのは `Ctrl-b d`）。
+
+## 開発
+
+```bash
+npm install
+npm run build      # tsc → dist/
+npm test           # build してから node:test 回帰スイート（tmux 必須）
+npm link           # ローカルで `aiterm-mcp` を PATH に
+```
+
+ロジックは `src/core.ts`（tmux 制御・削減・完了検出・安全）と `src/rtk.ts`（コマンド別 reducer）、公開は `src/index.ts`。設計の出発点と reducer の移植元（pytest reducer は本家 rtk 0.42.0 と出力が byte 一致するよう移植・回帰テストで固定）は `prototype/python/` を参照。
+
+## ライセンス
+
+MIT

package/README.md

@@ -0,0 +1,124 @@
+<p align="center">
+  <img src=".github/og.svg" alt="aiterm-mcp — AI holds one persistent terminal as a stdio MCP server (tmux-backed)" width="100%">
+</p>
+
+# aiterm-mcp
+
+[![CI](https://github.com/kitepon-rgb/aiterm-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/kitepon-rgb/aiterm-mcp/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/aiterm-mcp.svg)](https://www.npmjs.com/package/aiterm-mcp)
+
+> *(日本語: [README.ja.md](README.ja.md))*
+
+> Give an AI a **persistent local terminal** as a stdio MCP server. It holds **one** local PTY; SSH and containers are demoted to "a command you send into that terminal." Reads are token-reduced.
+
+Just six tools — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list`. The backend is **tmux**, so sessions survive even if the MCP server or the AI client restarts.
+
+## Why
+
+Sending an AI one command at a time and reading back the result means, over SSH, repeating connect → authenticate → disconnect every round — slow, and it burns tokens. aiterm **holds one PTY persistently** and you type `ssh host` or `docker exec -it x bash` *inside it* (nesting). Session kind is never a tool-level distinction.
+
+```
+pty_open()                         → grab one local terminal
+pty_send(id, "ssh 192.168.1.2")    → enter SSH inside that terminal
+pty_send(id, "uname -a")           → run it on the remote
+pty_read(id, { wait: true })       → read the reduced output
+```
+
+## How it works
+
+```mermaid
+flowchart LR
+    AI["AI / MCP client"] -->|"pty_send"| S["aiterm-mcp<br/>stdio MCP · 6 tools"]
+    S -->|"pty_read<br/>token-reduced"| AI
+    S -->|"tmux send-keys<br/>capture-pane"| P["one local PTY<br/>tmux · persistent"]
+    P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
+```
+
+One PTY is the only primitive. Everything else — SSH, containers, REPLs — is just text you `pty_send` into it. Because the PTY lives in tmux, sessions outlive the MCP server and the AI client.
+
+## vs. the alternatives
+
+| | **aiterm-mcp** | one-shot shell tool (per command) | generic terminal / tmux MCPs |
+| --- | --- | --- | --- |
+| Persistent session | ✅ tmux, survives restarts | ❌ new shell every call | ⚠️ varies |
+| SSH / containers | nest with one `pty_send` | reconnect every command | ⚠️ often separate tools |
+| Token-reduced reads | ✅ per-command reducers | ❌ raw output | ⚠️ rarely |
+| Completion detection | 4-layer: exit / `until` / quiescence / timeout | n/a (blocks per call) | ⚠️ prompt-match, fragile |
+| Human can co-drive | ✅ shared tmux socket (`attach`) | ❌ | ⚠️ varies |
+
+## Requirements
+
+- **Node.js >= 18**
+- **tmux** (runtime prerequisite; check with `tmux -V`. Install with `apt install tmux` / `brew install tmux`)
+- Optional: the [`rtk`](https://github.com/rtk-ai/rtk) binary (used by `pty_send`'s `rtk: true` delegation; works fine without it)
+
+## Install / register
+
+Register with Claude Code (CLI) at user scope (available in every project):
+
+```bash
+# After publishing (npm)
+claude mcp add --scope user --transport stdio aiterm -- npx -y aiterm-mcp
+
+# Or install globally and use the command name
+npm i -g aiterm-mcp
+claude mcp add --scope user --transport stdio aiterm -- aiterm-mcp
+```
+
+This registers it in `~/.claude.json`. Restart Claude Code; you'll get an approval prompt the first time. Check the connection with `/mcp`.
+
+Any other MCP client works too — just launch `npx -y aiterm-mcp` (or `aiterm-mcp`) over stdio.
+
+## Tools
+
+| Tool | Role | Key args |
+| --- | --- | --- |
+| `pty_open` | Grab one terminal, return a `session_id` | `name?`, `shell="bash"` |
+| `pty_send` | Send text (a command) | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
+| `pty_read` | Read output, token-reduced (incremental by default) | `session_id`, `wait`, `until`, `timeout`, `screen`, `full`, `lines`, `line_range`, `raw`, `rtk` |
+| `pty_key` | Send a control key | `session_id`, `key` (`C-c`/`Enter`/`Up`…) |
+| `pty_close` | Close a session | `session_id` |
+| `pty_list` | List sessions | (none) |
+
+### Completion detection (4 layers)
+
+`pty_read({ wait: true })` decides "is the command done?" via four layers: process exit / `until` regex match / output is quiescent ∧ the shell is back (quiescence) / timeout. While nested (inside SSH), the "shell is back" check cannot fire, so pass `until` with the remote prompt for a clean decision.
+
+### Token reduction
+
+- `pty_read` by default strips control characters, collapses repeated lines, and folds long output into head+tail (with a restore hint and a meta line).
+- `pty_read({ rtk: true })` further shrinks the observed output with a per-command reducer (`git status`/`git log`/`grep`/`pytest` and more) — a self-contained reimplementation that needs no `rtk` binary.
+- `pty_send({ rtk: true })` rewrites a known command into `rtk` form before sending, so reduction happens at the source if `rtk` exists there (passthrough otherwise).
+
+### Safety
+
+Before sending, `pty_send` blocks destructive commands (`rm -rf /`, `mkfs`, `dd of=/dev/…`, `DROP TABLE`, …) — pass `force: true` to override — and sanitizes ESC / bracketed-paste terminators. `pty_read` neutralizes control characters in what it returns.
+
+## Known constraints (by design, not bugs)
+
+- **While nested (ssh / docker / REPL), quiescence cannot fire by design**, because the foreground command is no longer in the shell set (bash/sh/zsh/fish/dash). Use `until` (a regex for the prompt etc.) or `mark: true` (an exit-code sentinel) for completion.
+- **`is_complete=False` is not a failure.** It means "completion was not observed within `timeout`." For long commands, raise `timeout` or use `until`/`mark`.
+- **The destructive gate is a tripwire, not a sandbox.** It blocks common destructive forms only. It does **not** catch relative-path `rm`, things that become dangerous after `$VAR` expansion, or commands run on the far side of an SSH session.
+- **`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.
+- **tmux is started with `-f /dev/null`**, so it does not read `~/.tmux.conf` (to keep behavior reproducible across machines).
+- **All sessions live on a single socket (`claude.sock`).** `tmux … kill-server` removes them all.
+
+## A human can watch
+
+Sessions live on a shared tmux socket. The `tmux -S … attach -t <id>` line printed by `pty_open` lets a human attach to the same terminal and intervene (`Ctrl-b d` to detach).
+
+## Development
+
+```bash
+npm install
+npm run build      # tsc → dist/
+npm test           # build, then the node:test regression suite (requires tmux)
+npm link           # put `aiterm-mcp` on PATH locally
+```
+
+Logic lives in `src/core.ts` (tmux control, reduction, completion detection, safety) and `src/rtk.ts` (per-command reducers); `src/index.ts` is the MCP surface. The design origin and the reducer's porting source (the pytest reducer is ported to be byte-exact with upstream rtk 0.42.0, locked by regression tests) are in `prototype/python/`.
+
+## License
+
+MIT

package/dist/core.js

@@ -0,0 +1,390 @@
+/**
+ * core — CLI/MCP が共有する純粋ロジック層（Node/TS 版）。
+ *
+ * 1個のローカル専用 tmux セッションを握り、send でキーストロークを流し、read で画面/出力を
+ * トークン削減して受け取る。SSH/docker は専用機能にせず send(id, "ssh host") で中に入る（ネスト）。
+ * セッションは tmux サーバ常駐ゆえ、本プロセスが毎回終了しても次回 read で再接続できる。
+ *
+ * 設計: docs/ai-terminal-design-plan.md / docs/mcp-server-plan.md。出力削減は rag/ の RTK を移植。
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as rtk from "./rtk.js";
+const SOCKDIR = path.join(process.env.TMPDIR ?? "/tmp", "claude-tmux-sockets");
+const SOCK = path.join(SOCKDIR, "claude.sock");
+// 完了検出
+export const DEFAULT_TIMEOUT = 10.0;
+const POLL = 0.25;
+const STABLE_POLLS = 2; // 連続でログサイズ不変ならば静止とみなす回数
+const SHELLS = new Set(["bash", "sh", "zsh", "fish", "dash"]);
+// 出力削減（RTK の CAP 思想を移植）
+const MAX_LINES_BEFORE_ELIDE = 60;
+const HEAD_LINES = 30;
+const TAIL_LINES = 20;
+const DEDUP_MIN_RUN = 3; // 同一行がこれ以上連続したら 1 行＋件数に畳む
+// 安全: send 前に弾く破壊的コマンド（外部システム境界の防御）
+const DESTRUCTIVE = [
+    /\brm\s+-[rfRF]*[rf][rfRF]*\s+(\/|~|\$HOME|\/\*|\.\s*$|\*\s*$)/i,
+    /\bmkfs(\.\w+)?\b/i,
+    /\bdd\b[^\n]*\bof=\/dev\//i,
+    />\s*\/dev\/(sd|nvme|hd|mmcblk)/i,
+    /\bDROP\s+(TABLE|DATABASE|SCHEMA)\b/i,
+    /\bTRUNCATE\s+TABLE\b/i,
+    /(curl|wget)\b[^\n]*\|\s*(sudo\s+)?(ba)?sh\b/i,
+    /:\(\)\s*\{\s*:\|:&\s*\};:/i, // fork bomb
+    /\bchmod\s+-R\s+0*0\s+\//i,
+    /\bgit\s+reset\s+--hard\b/i,
+];
+// CSI/OSC/ESC エスケープ・制御文字
+const ANSI_RE = /\x1b\[[0-9;?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-_]/g;
+const CTRL_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g; // \t(09) \n(0a) は残す
+const PASTE_MARKERS_RE = /\x1b\[20[01]~/g;
+// よく使う制御キーの別名（tmux のキー名へ）
+const KEYMAP = {
+    "ctrl-c": "C-c", "c-c": "C-c", "ctrl-d": "C-d", "c-d": "C-d",
+    "ctrl-z": "C-z", "c-z": "C-z", "ctrl-l": "C-l", "ctrl-r": "C-r",
+    enter: "Enter", tab: "Tab", esc: "Escape", escape: "Escape",
+    up: "Up", down: "Down", left: "Left", right: "Right",
+    space: "Space", bspace: "BSpace", backspace: "BSpace",
+};
+export class AitermError extends Error {
+    code;
+    constructor(message, code = 1) {
+        super(message);
+        this.code = code;
+    }
+}
+function tmux(...args) {
+    // maxBuffer は既定 1MiB。capture-pane（大きなスクロールバック）や多セッションの list-sessions で
+    // 頭打ちになり stdout が切れる/空になる。Python の subprocess.run は無制限だったので 64MiB へ広げる。
+    const r = spawnSync("tmux", ["-S", SOCK, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    // ENOBUFS（出力が 64MiB 超）を「code=1 の失敗」へ握り潰すと部分/空 stdout を正常扱いしてしまう。区別して投げる。
+    // EXPECTED-FAILURE: 外部システム境界（tmux 出力過大）
+    if (r.error && r.error.code === "ENOBUFS") {
+        throw new AitermError(`tmux 出力が 64MiB を超えました（${args[0]}）。範囲を絞って読んでください。`, 2);
+    }
+    return { code: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+function sessionExists(name) {
+    return tmux("has-session", "-t", name).code === 0;
+}
+function paneCurrentCommand(name) {
+    const r = tmux("display-message", "-p", "-t", name, "#{pane_current_command}");
+    return r.code === 0 ? r.stdout.trim() : "";
+}
+function logpath(name) {
+    return path.join(SOCKDIR, name + ".log");
+}
+function offsetpath(name) {
+    return path.join(SOCKDIR, name + ".offset");
+}
+function lastcmdpath(name) {
+    return path.join(SOCKDIR, name + ".lastcmd");
+}
+function readOffset(name) {
+    try {
+        const n = parseInt(fs.readFileSync(offsetpath(name), "utf8").trim(), 10);
+        return Number.isNaN(n) ? 0 : n;
+    }
+    catch {
+        return 0;
+    }
+}
+function writeOffset(name, off) {
+    fs.writeFileSync(offsetpath(name), String(off));
+}
+function writeLastcmd(name, cmd) {
+    try {
+        fs.writeFileSync(lastcmdpath(name), cmd);
+    }
+    catch {
+        /* noop */
+    }
+}
+function readLastcmd(name) {
+    try {
+        return fs.readFileSync(lastcmdpath(name), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export function attachHint(name) {
+    return (`このセッションを自分の目で見る/介入する:\n` +
+        `  tmux -S ${SOCK} attach -t ${name}\n` +
+        `  （抜けるには Ctrl-b d）`);
+}
+// ---------------------------------------------------------------- 出力削減
+function estimateTokens(s) {
+    return Math.ceil(s.length / 4.0);
+}
+export function stripControl(text) {
+    text = text.replace(/\r\n/g, "\n"); // CRLF 正規化
+    const out = [];
+    for (let line of text.split("\n")) {
+        if (line.includes("\r")) {
+            const parts = line.split("\r");
+            line = parts[parts.length - 1]; // 行中の\rは進捗上書き＝最終状態だけ残す
+        }
+        line = line.replace(ANSI_RE, "").replace(CTRL_RE, "");
+        out.push(line.replace(/\s+$/, "")); // rstrip
+    }
+    return out.join("\n");
+}
+function collapseBlanks(lines) {
+    const out = [];
+    let blanks = 0;
+    for (const ln of lines) {
+        if (ln === "") {
+            blanks++;
+            if (blanks <= 1)
+                out.push(ln);
+        }
+        else {
+            blanks = 0;
+            out.push(ln);
+        }
+    }
+    while (out.length && out[0] === "")
+        out.shift();
+    while (out.length && out[out.length - 1] === "")
+        out.pop();
+    return out;
+}
+function dedupRuns(lines) {
+    const out = [];
+    let i = 0;
+    const n = lines.length;
+    while (i < n) {
+        let j = i;
+        while (j < n && lines[j] === lines[i])
+            j++;
+        const run = j - i;
+        if (run >= DEDUP_MIN_RUN && lines[i] !== "")
+            out.push(`${lines[i]}  〈×${run}〉`);
+        else
+            out.push(...lines.slice(i, j));
+        i = j;
+    }
+    return out;
+}
+/** RTK 4戦略を移植: 制御除去 / 空白正規化 / 連続重複圧縮 / head+tail 折りたたみ。返り値 [body, meta]。 */
+export function reduceOutput(raw, name, elide = true) {
+    const rawLinesN = (raw.match(/\n/g)?.length ?? 0) + (raw && !raw.endsWith("\n") ? 1 : 0);
+    const cleaned = stripControl(raw);
+    let lines = collapseBlanks(cleaned.split("\n"));
+    lines = dedupRuns(lines);
+    let elided = 0;
+    if (elide && lines.length > MAX_LINES_BEFORE_ELIDE) {
+        elided = lines.length - HEAD_LINES - TAIL_LINES;
+        const hint = `… 〈${elided} 行省略。全文は full=true、範囲は line_range="A:B"〉 …`;
+        lines = [...lines.slice(0, HEAD_LINES), hint, ...lines.slice(lines.length - TAIL_LINES)];
+    }
+    const body = lines.join("\n");
+    const meta = `[aiterm ${name}: ${lines.length} 行 / ~${estimateTokens(body)} tok ` +
+        `(raw ${rawLinesN} 行 / ~${estimateTokens(raw)} tok)` +
+        (elided ? `; ${elided} 行 hidden]` : "]");
+    return [body, meta];
+}
+// ---------------------------------------------------------------- tmux 補助
+function autoName() {
+    const r = tmux("list-sessions", "-F", "#{session_name}");
+    const existing = new Set(r.code === 0 ? r.stdout.split(/\s+/).filter(Boolean) : []);
+    let i = 1;
+    while (existing.has(`t${i}`))
+        i++;
+    return `t${i}`;
+}
+function captureScreen(name, lines) {
+    const args = ["capture-pane", "-p", "-J", "-t", name];
+    if (lines)
+        args.push("-S", `-${lines}`);
+    const r = tmux(...args);
+    return r.code === 0 ? r.stdout : "";
+}
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
+/** 完了境界の4層: dead / until 一致 / (出力静止 ∧ シェルに戻った) / timeout。 */
+async function waitCompletion(name, untilRe, timeout) {
+    // 締切は単調時計で測る。Date.now() は NTP 補正やサスペンドで巻き戻り、長時間待ちで誤判定する（Python は time.monotonic）。
+    const deadline = performance.now() + timeout * 1000;
+    const start = readOffset(name);
+    let lastSize = null;
+    let stable = 0;
+    const until = untilRe ? new RegExp(untilRe) : null;
+    for (;;) {
+        const alive = sessionExists(name);
+        let size = 0;
+        try {
+            size = fs.statSync(logpath(name)).size;
+        }
+        catch {
+            size = 0;
+        }
+        if (until && size > start) {
+            const buf = fs.readFileSync(logpath(name));
+            const neu = buf.subarray(start).toString("utf8");
+            if (until.test(stripControl(neu)))
+                return [true, "until"];
+        }
+        if (!alive)
+            return [true, "dead"];
+        if (size === lastSize) {
+            stable++;
+            if (stable >= STABLE_POLLS && SHELLS.has(paneCurrentCommand(name)))
+                return [true, "quiescent"];
+        }
+        else {
+            stable = 0;
+        }
+        lastSize = size;
+        if (performance.now() >= deadline)
+            return [false, "timeout"];
+        await sleep(POLL * 1000);
+    }
+}
+function rtkRewrite(text) {
+    if (text.trim().includes("\n"))
+        return text;
+    // timeout 無しだと rtk がハングしたとき send() ごと凍結する。Python は timeout=5。
+    const r = spawnSync("rtk", ["rewrite", text], { encoding: "utf8", timeout: 5000, maxBuffer: 1024 * 1024 });
+    if (r.error)
+        return text; // rtk 不在（ENOENT）・タイムアウト（ETIMEDOUT）等は元テキストへ素通し
+    if ((r.status === 0 || r.status === 3) && (r.stdout ?? "").trim())
+        return (r.stdout ?? "").replace(/\n+$/, "");
+    return text;
+}
+// ---------------------------------------------------------------- 操作（return で返す / 失敗は AitermError）
+export function openSession(name, shell = "bash") {
+    fs.mkdirSync(SOCKDIR, { recursive: true });
+    const nm = name || autoName();
+    if (sessionExists(nm))
+        throw new AitermError(`session '${nm}' は既に存在します（list で確認）`, 2);
+    const r = tmux("new-session", "-d", "-s", nm, "-f", "/dev/null", shell);
+    if (r.code !== 0)
+        throw new AitermError("tmux new-session 失敗: " + r.stderr.trim(), 2);
+    fs.closeSync(fs.openSync(logpath(nm), "a")); // touch
+    tmux("pipe-pane", "-t", nm, "-o", `cat >> ${logpath(nm)}`);
+    writeOffset(nm, 0);
+    return [nm, attachHint(nm)];
+}
+export function send(name, text, o = {}) {
+    const enter = o.enter ?? true;
+    if (!sessionExists(name))
+        throw new AitermError(`session '${name}' が無い（open してください）`, 2);
+    if (!o.raw) {
+        text = text.replace(PASTE_MARKERS_RE, "").replace(ANSI_RE, "").replace(CTRL_RE, "");
+    }
+    if (!o.force) {
+        for (const pat of DESTRUCTIVE) {
+            if (pat.test(text)) {
+                throw new AitermError(`破壊的の可能性があるコマンドを遮断しました: /${pat.source}/\n` +
+                    `  本当に実行するなら force を有効にして再実行してください。`, 3);
+            }
+        }
+    }
+    writeLastcmd(name, text); // read rtk の reducer 分類用（書換/mark 前の素のコマンド）
+    if (o.rtk)
+        text = rtkRewrite(text);
+    if (o.mark)
+        text = text + `; printf '\\n<<<AITERM_DONE rc=%d>>>\\n' "$?"`;
+    tmux("send-keys", "-t", name, "-l", "--", text);
+    if (enter)
+        tmux("send-keys", "-t", name, "Enter");
+    // コードポイント数で数える（JS の .length は UTF-16 単位で絵文字等がズレる。Python は len()=コードポイント）。
+    return `sent ${[...text].length} chars to ${name}` + (enter ? " (+Enter)" : "");
+}
+export function sendKey(name, key) {
+    if (!sessionExists(name))
+        throw new AitermError(`session '${name}' が無い`, 2);
+    const k = KEYMAP[key.toLowerCase()] ?? key;
+    tmux("send-keys", "-t", name, k);
+    return `sent key ${k} to ${name}`;
+}
+export async function readOutput(name, o = {}) {
+    const timeout = o.timeout ?? DEFAULT_TIMEOUT;
+    if (!sessionExists(name) && !fs.existsSync(logpath(name)))
+        throw new AitermError(`session '${name}' が無い`, 2);
+    if (o.screen) {
+        const rawTxt = captureScreen(name, o.lines || 0);
+        if (o.raw)
+            return rawTxt;
+        const [body, meta] = reduceOutput(rawTxt, name, true);
+        return body + "\n" + meta;
+    }
+    let status = null;
+    if (o.wait) {
+        const [, st] = await waitCompletion(name, o.until ?? null, timeout);
+        status = st;
+    }
+    let data;
+    try {
+        data = fs.readFileSync(logpath(name));
+    }
+    catch {
+        data = Buffer.alloc(0);
+    }
+    let text;
+    if (o.full || o.range) {
+        text = data.toString("utf8");
+        if (o.range) {
+            const [lo, hi] = o.range;
+            text = text.split("\n").slice(lo, hi ?? undefined).join("\n");
+        }
+    }
+    else {
+        const off = readOffset(name);
+        text = data.subarray(off).toString("utf8");
+        if (o.lines)
+            text = text.split("\n").slice(-o.lines).join("\n");
+    }
+    if (!o.range)
+        writeOffset(name, data.length); // 既定/full は offset を末尾へ
+    if (o.raw)
+        return text.endsWith("\n") ? text : text + "\n";
+    if (o.rtk) {
+        // コマンド別 reducer（自前移植）を観測出力へ適用
+        const cmd = readLastcmd(name);
+        if (cmd.trim()) {
+            const framed = rtk.stripShellFrame(stripControl(text), cmd);
+            const [reduced, rname] = rtk.reduce(cmd, framed);
+            if (reduced !== null) {
+                const meta = `[aiterm ${name}: rtk:${rname} 適用 / ~${estimateTokens(reduced)} tok (raw ~${estimateTokens(text)} tok)]`;
+                if (status) {
+                    const complete = status !== "timeout";
+                    return reduced + "\n" + meta + ` [is_complete=${complete ? "True" : "False"} via ${status}]`;
+                }
+                return reduced + "\n" + meta;
+            }
+        }
+        // reducer 非該当 → 汎用削減へフォールバック
+    }
+    const [body, meta] = reduceOutput(text, name, !o.range);
+    if (status) {
+        const complete = status !== "timeout";
+        return body + "\n" + meta + ` [is_complete=${complete ? "True" : "False"} via ${status}]`;
+    }
+    return body + "\n" + meta;
+}
+export function listSessions() {
+    const r = tmux("list-sessions", "-F", "#{session_name}\t#{pane_current_command}\t#{?session_attached,attached,detached}\t#{window_width}x#{window_height}");
+    if (r.code === 0 && r.stdout.trim())
+        return r.stdout.replace(/\s+$/, "");
+    return "(セッション無し)";
+}
+export function closeSession(name) {
+    tmux("kill-session", "-t", name);
+    for (const p of [logpath(name), offsetpath(name), lastcmdpath(name)]) {
+        try {
+            fs.unlinkSync(p);
+        }
+        catch {
+            /* noop */
+        }
+    }
+    return `closed ${name}`;
+}
+export function killAll() {
+    tmux("kill-server");
+    return "killed all sessions on this socket";
+}

package/dist/index.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * aiterm-mcp — AI が握るローカル永続端末を stdio MCP サーバとして公開する（Node/TS 版）。
+ *
+ * WSL2/Linux/mac のローカルで動かし、握るのはローカル端末1個。リモートは pty_send "ssh ..." で
+ * 中に入る（ネスト）。バックエンドは tmux（実行時の前提）。ロジックは core.ts に集約。
+ *
+ * 重要: stdio MCP は stdout が JSON-RPC 専用。診断は stderr/console.error のみ（console.log 禁止）。
+ * 起動: npx -y aiterm-mcp（または mcp 登録のコマンドに同じ）。
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as core from "./core.js";
+const server = new McpServer({ name: "aiterm", version: "0.1.0" });
+function ok(s) {
+    return { content: [{ type: "text", text: s }] };
+}
+function fail(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { content: [{ type: "text", text: "aiterm: " + msg }], isError: true };
+}
+server.registerTool("pty_open", {
+    description: "ローカル永続端末(tmux セッション)を1個開き、session_id を返す。tmux サーバ常駐ゆえ本サーバや " +
+        "クライアントが再起動してもセッションは生存する。リモート操作は専用ツールにせず、開いた端末の中で " +
+        'pty_send(session_id, "ssh host") と打って入る。',
+    inputSchema: {
+        name: z.string().nullish().describe("セッション名（省略時は t1, t2... を自動採番）"),
+        shell: z.string().default("bash").describe("起動シェル（既定 bash）"),
+    },
+}, async ({ name, shell }) => {
+    try {
+        const [sid, hint] = core.openSession(name ?? null, shell);
+        return ok(`session_id: ${sid}\n${hint}`);
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+server.registerTool("pty_send", {
+    description: "セッションへテキスト(コマンド)を送る。送信後の出力は pty_read で取得する。",
+    inputSchema: {
+        session_id: z.string(),
+        text: z.string().describe("送る文字列（コマンド）"),
+        enter: z.boolean().default(true).describe("末尾で Enter を送る"),
+        mark: z.boolean().default(false).describe("完了 sentinel(終了コード付き)で包む"),
+        force: z.boolean().default(false).describe("破壊的コマンドゲートを越える"),
+        rtk: z.boolean().default(false).describe("既知コマンドを rtk 形へ委譲して送る（rtk 不在なら素通し）"),
+        raw: z.boolean().default(false).describe("送信前サニタイズを無効化"),
+    },
+}, async ({ session_id, text, enter, mark, force, rtk, raw }) => {
+    try {
+        return ok(core.send(session_id, text, { enter, mark, force, rtk, raw }));
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+server.registerTool("pty_read", {
+    description: "セッションの出力をトークン削減して読む（既定は前回読取位置からの増分）。" +
+        "削減: 制御文字除去 / 反復圧縮 / head+tail 折りたたみ＋復元ヒント＋メタ併記。",
+    inputSchema: {
+        session_id: z.string(),
+        wait: z.boolean().default(false).describe("完了まで待つ（4層: dead/until/出力静止∧シェル復帰/timeout）"),
+        until: z.string().nullish().describe("この正規表現が出たら完了とみなす"),
+        timeout: z.number().default(10).describe("wait の最大待ち秒数"),
+        screen: z.boolean().default(false).describe("描画済みスクリーン(TUI 向け)"),
+        full: z.boolean().default(false).describe("増分でなく全文"),
+        lines: z.number().int().nullish().describe("末尾 N 行のみ"),
+        line_range: z.string().nullish().describe('全文からの行範囲 "A:B"'),
+        raw: z.boolean().default(false).describe("削減せず生テキスト"),
+        rtk: z.boolean().default(false).describe("直前コマンド別の自前 reducer(git/grep/pytest 等)で縮約"),
+    },
+}, async ({ session_id, wait, until, timeout, screen, full, lines, line_range, raw, rtk }) => {
+    try {
+        let range = null;
+        if (line_range) {
+            const idx = line_range.indexOf(":");
+            const lo = idx < 0 ? line_range : line_range.slice(0, idx);
+            const hi = idx < 0 ? "" : line_range.slice(idx + 1);
+            // 不正/空の上端は「末尾まで」(null) に倒す。"5:abc" を空に潰さず "5:" と同じく 5 行目以降にする。
+            const hiN = hi ? parseInt(hi, 10) : NaN;
+            range = [parseInt(lo, 10) || 0, Number.isNaN(hiN) ? null : hiN];
+        }
+        const out = await core.readOutput(session_id, {
+            wait,
+            until: until ?? null,
+            timeout,
+            screen,
+            full,
+            lines: lines ?? null,
+            range,
+            raw,
+            rtk,
+        });
+        return ok(out);
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+server.registerTool("pty_key", {
+    description: "制御キーを送る（C-c, C-d, Enter, Tab, Up, Down... の別名に対応）。",
+    inputSchema: {
+        session_id: z.string(),
+        key: z.string().describe('キー名（例 "C-c", "Enter", "Up"）'),
+    },
+}, async ({ session_id, key }) => {
+    try {
+        return ok(core.sendKey(session_id, key));
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+server.registerTool("pty_close", {
+    description: "セッションを閉じ、ログ／読取位置を破棄する。",
+    inputSchema: { session_id: z.string() },
+}, async ({ session_id }) => {
+    try {
+        return ok(core.closeSession(session_id));
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+server.registerTool("pty_list", {
+    description: "握っているセッション一覧（名前 / 現在の前面コマンド / attach 状態 / サイズ）。",
+    inputSchema: {},
+}, async () => {
+    try {
+        return ok(core.listSessions());
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((e) => {
+    console.error("aiterm-mcp fatal:", e);
+    process.exit(1);
+});

package/dist/rtk.js

@@ -0,0 +1,414 @@
+/**
+ * rtk — RTK の出力削減を「自前実装」で移植した read 側リデューサ群（Node/TS 版）。
+ *
+ * 要件C: rtk のファイルは複製せず、アルゴリズムを参照に自分のコードとして書き起こす。
+ * rtk バイナリが無い場所でも縮約が効くよう、観測済み出力に対して動く。
+ * pytest / grep は人間向け標準出力を解析でき rtk のアルゴリズムに忠実
+ * （pytest は rtk 0.42.0 の出力と厳密一致するよう移植）。
+ *
+ * 公開 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 行の最大幅
+const COMPACT_PATH_THRESH = 50; // grep: パス短縮の閾値
+const MAX_PYTEST_FAILURES = 10; // pytest: 失敗ブロック最大
+const MAX_XFAIL = 10; // pytest: xfail/xpass 行 最大
+const PYTEST_RELEVANT_PER_FAIL = 3;
+const LOG_LIMIT_DEFAULT = 10; // git log: 既定コミット数
+const LOG_BODY_LINES = 3;
+const LOG_WIDTH = 80;
+/** char(コードポイント)ベース切り詰め（rtk utils::truncate と同等）。 */
+function truncate(s, n) {
+    const cp = Array.from(s);
+    if (cp.length <= n)
+        return s;
+    if (n < 3)
+        return "...";
+    return cp.slice(0, n - 3).join("") + "...";
+}
+const PROMPT_TAIL = /[$#%>]\s*$/;
+/** 観測ログ片からエコー行と前後のプロンプト行を落とし、コマンド出力本体だけ残す（発見的）。 */
+export function stripShellFrame(text, command) {
+    const lines = text.split("\n");
+    const cmd = command.trim();
+    let start = 0;
+    if (cmd) {
+        for (let i = 0; i < lines.length; i++)
+            if (lines[i].includes(cmd))
+                start = i + 1;
+    }
+    let end = lines.length;
+    while (end > start) {
+        const last = lines[end - 1];
+        if (!last.trim() || (PROMPT_TAIL.test(last) && (!cmd || !last.includes(cmd))))
+            end--;
+        else
+            break;
+    }
+    return lines.slice(start, end).join("\n");
+}
+// ---------------------------------------------------------------- pytest
+export function reducePytest(output) {
+    let summaryLine = "";
+    const failures = [];
+    const xfailLines = [];
+    let state = "header";
+    let current = [];
+    const flush = () => {
+        if (current.length) {
+            failures.push(current.join("\n"));
+            current = [];
+        }
+    };
+    for (const line of output.split("\n")) {
+        const t = line.trim();
+        if (t.startsWith("===") && t.includes("test session starts")) {
+            state = "header";
+            continue;
+        }
+        if (t.startsWith("===") && t.includes("FAILURES")) {
+            state = "failures";
+            continue;
+        }
+        if (t.startsWith("===") && t.includes("short test summary")) {
+            state = "summary";
+            flush();
+            continue;
+        }
+        if (t.startsWith("===") && (t.includes("passed") || t.includes("failed") || t.includes("skipped"))) {
+            summaryLine = t;
+            continue;
+        }
+        if (!summaryLine &&
+            !t.startsWith("===") &&
+            !t.startsWith("FAILED") &&
+            !t.startsWith("ERROR") &&
+            (t.includes(" passed") || t.includes(" failed") || t.includes(" skipped")) &&
+            t.includes(" in ")) {
+            summaryLine = t;
+            continue;
+        }
+        if (state === "header") {
+            if (t.startsWith("collected"))
+                state = "progress";
+        }
+        else if (state === "progress") {
+            // 進捗ドット行は捨てる
+        }
+        else if (state === "failures") {
+            if (t.startsWith("___")) {
+                flush();
+                current.push(t);
+            }
+            else if (t && !t.startsWith("===")) {
+                current.push(t);
+            }
+        }
+        else if (state === "summary") {
+            if (t.startsWith("FAILED") || t.startsWith("ERROR"))
+                failures.push(t);
+            else if (t.startsWith("XFAIL") || t.startsWith("XPASS"))
+                xfailLines.push(t);
+        }
+    }
+    flush();
+    const [p, f, s, xf, xp] = parsePytestCounts(summaryLine);
+    if (p === 0 && f === 0 && s === 0 && xf === 0 && xp === 0)
+        return "Pytest: No tests collected";
+    const extras = s > 0 || xf > 0 || xp > 0 || xfailLines.length > 0;
+    if (f === 0 && p > 0 && !extras)
+        return `Pytest: ${p} passed`;
+    let head = `Pytest: ${p} passed, ${f} failed`;
+    if (s > 0)
+        head += `, ${s} skipped`;
+    if (xf > 0)
+        head += `, ${xf} xfailed`;
+    if (xp > 0)
+        head += `, ${xp} xpassed`;
+    const out = [head, "═".repeat(39)];
+    if (xfailLines.length) {
+        out.push("", "Expected-failure outcomes:");
+        for (const ln of xfailLines.slice(0, MAX_XFAIL))
+            out.push("  " + truncate(ln, 120));
+        if (xfailLines.length > MAX_XFAIL)
+            out.push(`  … +${xfailLines.length - MAX_XFAIL} more`);
+    }
+    if (failures.length) {
+        out.push("", "Failures:");
+        const shown = failures.slice(0, MAX_PYTEST_FAILURES);
+        for (let i = 0; i < shown.length; i++) {
+            const lines = shown[i].split("\n");
+            const first = lines[0];
+            if (first.startsWith("___")) {
+                const name = first.replace(/^_+|_+$/g, "").trim();
+                out.push(`${i + 1}. [FAIL] ${name}`);
+            }
+            else if (first.startsWith("FAILED")) {
+                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 と同じ）。
+                if (parts.length > 1)
+                    out.push("     " + truncate(parts.slice(1).join(" - "), 100));
+                continue;
+            }
+            else {
+                out.push(`${i + 1}. [FAIL] ${first}`);
+            }
+            let rel = 0;
+            for (const body of lines.slice(1)) {
+                const bt = body.trim();
+                const isRel = bt.startsWith(">") ||
+                    bt.startsWith("E") ||
+                    bt.toLowerCase().includes("assert") ||
+                    bt.toLowerCase().includes("error") ||
+                    body.includes(".py:");
+                if (isRel) {
+                    out.push("     " + truncate(body, 100));
+                    rel++;
+                    if (rel >= PYTEST_RELEVANT_PER_FAIL)
+                        break;
+                }
+            }
+            // rtk 0.42.0 互換: セパレータ判定は表示数(shown)でなく全失敗数(failures)基準（cap 超過時の空行数まで一致）。
+            if (i < failures.length - 1)
+                out.push("");
+        }
+        if (failures.length > MAX_PYTEST_FAILURES)
+            out.push("", `… +${failures.length - MAX_PYTEST_FAILURES} more failures`);
+    }
+    return out.join("\n").trim();
+}
+function parsePytestCounts(summary) {
+    let p = 0, f = 0, s = 0, xf = 0, xp = 0;
+    for (const part of summary.split(",")) {
+        const words = part.split(/\s+/).filter(Boolean);
+        for (let i = 0; i < words.length; i++) {
+            if (i === 0)
+                continue;
+            const n = parseInt(words[i - 1], 10);
+            if (Number.isNaN(n))
+                continue;
+            const w = words[i];
+            if (w.includes("xpassed"))
+                xp = n;
+            else if (w.includes("xfailed"))
+                xf = n;
+            else if (w.includes("passed"))
+                p = n;
+            else if (w.includes("failed"))
+                f = n;
+            else if (w.includes("skipped"))
+                s = n;
+        }
+    }
+    return [p, f, s, xf, xp];
+}
+// ---------------------------------------------------------------- grep
+const GREP_LINE = /^(.*?):(\d+):(.*)$/;
+function compactPath(p) {
+    if (p.length <= COMPACT_PATH_THRESH)
+        return p;
+    const parts = p.split("/");
+    if (parts.length <= 3)
+        return p;
+    return `${parts[0]}/.../${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+}
+export function reduceGrep(output) {
+    const byFile = new Map();
+    const order = [];
+    let total = 0;
+    for (const line of output.split("\n")) {
+        const m = GREP_LINE.exec(line);
+        if (!m)
+            continue;
+        const fname = m[1], lineno = m[2], content = m[3];
+        if (!fname || !/^\d+$/.test(lineno))
+            continue;
+        total++;
+        if (!byFile.has(fname)) {
+            byFile.set(fname, []);
+            order.push(fname);
+        }
+        byFile.get(fname).push([lineno, truncate(content.trim(), GREP_MAX_LEN)]);
+    }
+    if (total === 0)
+        return null;
+    const out = [`${total} matches in ${byFile.size} files:`, ""];
+    let shown = 0;
+    for (const fname of [...order].sort()) {
+        if (shown >= CAP_GREP_TOTAL)
+            break;
+        const disp = compactPath(fname);
+        for (const [lineno, content] of byFile.get(fname).slice(0, CAP_GREP_PER_FILE)) {
+            if (shown >= CAP_GREP_TOTAL)
+                break;
+            out.push(`${disp}:${lineno}:${content}`);
+            shown++;
+        }
+    }
+    if (total > shown)
+        out.push(`[+${total - shown} more]`);
+    return out.join("\n");
+}
+// ---------------------------------------------------------------- git status / log
+const GIT_HINT = /^\(use "git |^\(create\/copy files/;
+export function reduceGitStatus(output) {
+    const lines = output.split("\n");
+    const nonempty = lines.filter((ln) => ln.trim());
+    if (!nonempty.length)
+        return null;
+    const porc = nonempty.filter((ln) => /^(##|[ MADRCU?!]{2}) /.test(ln));
+    if (porc.length && porc.length >= nonempty.length - 1) {
+        const out = [];
+        for (let i = 0; i < nonempty.length; i++) {
+            const ln = nonempty[i];
+            if (i === 0 && ln.startsWith("## "))
+                out.push("* " + ln.slice(3));
+            else
+                out.push(ln);
+        }
+        return out.join("\n");
+    }
+    const kept = [];
+    for (const ln of lines) {
+        const t = ln.trim();
+        if (!t)
+            continue;
+        if (GIT_HINT.test(t) || t.includes('(use "git add') || t.includes('(use "git restore'))
+            continue;
+        if (t.includes("nothing to commit") && t.includes("working tree clean")) {
+            kept.push(t);
+            break;
+        }
+        kept.push(ln);
+    }
+    return kept.length ? kept.join("\n") : "ok";
+}
+export function reduceGitLog(output) {
+    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 out = [];
+    for (const b of blocks.slice(0, LOG_LIMIT_DEFAULT)) {
+        const bl = b.split("\n").map((x) => x.replace(/\s+$/, ""));
+        let commit = "", author = "", subject = "";
+        const body = [];
+        for (const ln of bl) {
+            const t = ln.trim();
+            if (t.startsWith("commit "))
+                commit = t.split(/\s+/)[1].slice(0, 9);
+            else if (t.startsWith("Author:"))
+                author = t.slice("Author:".length).trim();
+            else if (t.startsWith("Date:") || t.startsWith("Merge:"))
+                continue;
+            else if (t && !subject && (ln.startsWith("    ") || ln.startsWith("\t")))
+                subject = t;
+            else if (t && (ln.startsWith("    ") || ln.startsWith("\t"))) {
+                if (!t.startsWith("Signed-off-by:") && !t.startsWith("Co-authored-by:"))
+                    body.push(t);
+            }
+        }
+        const am = /<([^>]+)>/.exec(author);
+        const who = am ? am[1] : author;
+        let head = truncate(`${commit} ${subject}`.trim(), LOG_WIDTH);
+        if (who)
+            head += `  <${who}>`;
+        const entry = [head];
+        for (const bln of body.slice(0, LOG_BODY_LINES))
+            entry.push("  " + truncate(bln, LOG_WIDTH));
+        if (body.length > LOG_BODY_LINES)
+            entry.push(`  [+${body.length - LOG_BODY_LINES} lines omitted]`);
+        out.push(entry.join("\n"));
+    }
+    return out.join("\n").trim();
+}
+const FILTERS = [
+    { name: "df", match: /^df\b/, strip: [/^$/], maxLines: 40, onEmpty: "df: ok" },
+    { name: "free", match: /^free\b/, strip: [/^$/], maxLines: 20, onEmpty: "free: ok" },
+    { name: "make", match: /^make\b/, strip: [/^make\[\d+\]:/, /^$/, /^Nothing to be done/], maxLines: 50, onEmpty: "make: ok" },
+    { name: "systemctl", match: /^systemctl\s+status\b/, strip: [/^\s*$/], maxLines: 30, onEmpty: "systemctl: ok" },
+];
+function applyFilter(rule, output) {
+    const lines = output.split("\n");
+    const kept = [];
+    for (const ln of lines) {
+        if (rule.strip && rule.strip.some((r) => r.test(ln)))
+            continue;
+        if (rule.keep && rule.keep.length && !rule.keep.some((r) => r.test(ln)))
+            continue;
+        kept.push(ln);
+    }
+    let result = kept;
+    if (rule.maxLines && kept.length > rule.maxLines) {
+        const omitted = kept.length - rule.maxLines;
+        result = [...kept.slice(0, rule.maxLines), `... (${omitted} lines truncated)`];
+    }
+    const body = result.join("\n").trim();
+    if (!body && rule.onEmpty)
+        return rule.onEmpty;
+    return body;
+}
+// ---------------------------------------------------------------- ルーティング
+function basenameCmd(command) {
+    const toks = command.trim().split(/\s+/).filter(Boolean);
+    let i = 0;
+    while (i < toks.length && (toks[i].includes("=") || ["sudo", "env", "command", "exec"].includes(toks[i])))
+        i++;
+    if (i >= toks.length)
+        return ["", ""];
+    const verb = toks[i].split("/").pop();
+    let sub = "";
+    for (const t of toks.slice(i + 1)) {
+        if (!t.startsWith("-")) {
+            sub = t;
+            break;
+        }
+    }
+    return [verb, sub];
+}
+export function classify(command) {
+    const [verb, sub] = basenameCmd(command);
+    if (verb === "git") {
+        if (sub === "status")
+            return "git-status";
+        if (sub === "log")
+            return "git-log";
+        return null;
+    }
+    if (verb === "grep" || verb === "rg")
+        return "grep";
+    if (verb === "pytest" || verb === "py.test")
+        return "pytest";
+    if (verb === "python" && command.includes("pytest"))
+        return "pytest";
+    for (const rule of FILTERS)
+        if (rule.match.test(command.trim()))
+            return rule.name;
+    return null;
+}
+const REDUCERS = {
+    "git-status": reduceGitStatus,
+    "git-log": reduceGitLog,
+    grep: reduceGrep,
+    pytest: (o) => reducePytest(o),
+};
+/** コマンドに応じた reducer を観測出力へ適用。返り値 [reducedText|null, reducerName|null]。 */
+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];
+    }
+    for (const rule of FILTERS)
+        if (rule.name === name)
+            return [applyFilter(rule, output), name];
+    return [null, null];
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "aiterm-mcp",
+  "version": "0.1.0",
+  "description": "AI-driven persistent terminal as a local stdio MCP server (tmux-backed). Holds one local PTY; SSH and containers are just commands you send into it. Token-reducing reads.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "terminal",
+    "tmux",
+    "pty",
+    "claude",
+    "ai-agent",
+    "ssh"
+  ],
+  "license": "MIT",
+  "author": "kitepon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kitepon-rgb/aiterm-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kitepon-rgb/aiterm-mcp/issues"
+  },
+  "homepage": "https://github.com/kitepon-rgb/aiterm-mcp#readme",
+  "type": "module",
+  "bin": {
+    "aiterm-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3"
+  }
+}