aiterm-mcp 0.12.2 → 0.12.3

package/README.ja.md

@@ -71,7 +71,7 @@ pty_send("codex1", "also fix the imports it broke", { wait: "agent_done" })
 | `grok_agent` | Grok Build の `grok-build` モデル（xAI） | `prompt?`, `reasoning_effort?`（`low`/`medium`/`high`/`xhigh`/`max`）, `cwd?`, `session_name?`, `agent_done?` |
 | `composer_agent` | Grok Build の `grok-composer-2.5-fast` モデル（xAI） | `grok_agent` と同じ |
 
-各ベンダーの CLI が導入・認証済みであること（`codex_agent` は `codex`、Grok 系 2 つは `grok`）。バイナリは `CODEX_BIN` / `GROK_BIN` → `~/.local/bin/codex` / `~/.grok/bin/grok` → `PATH` の順で解決する。前提は **session を作る前に**検証する——`grok_agent` / `composer_agent` は範囲外の `reasoning_effort` を先に弾き（値集合は固定＝`low`/`medium`/`high`/`xhigh`/`max`）、CLI バイナリ不在・実在しない `cwd` は 3 つとも失敗する。前提（`reasoning_effort`・バイナリ・`cwd`）で弾かれた起動は **session の残骸をゼロ**にして返し、起動キーストロークを送れなければ session を畳む。（初回 prompt wait を使わない場合、その先でベンダー CLI が実際に立ち上がったか・認証できたかは aiterm は検証しない——起動できたかは session を読んで確認する。）（`codex_agent` は Codex の受理値が版で変わるため、`reasoning_effort` を検証せず config override〔`-c model_reasoning_effort=…`〕として Codex CLI へ渡す。）`cwd` は絶対パスで渡す——`~` は展開されない。`agent_done` は launch ごとの managed vendor home を使い、通常の hook file は書き換えない。Codex は managed `CODEX_HOME` に `auth.json` だけを symlink し、`config.toml` はコピーする。Grok/Composer はさらに `GROK_HOME` と `HOME` を隔離し、compat hook/plugin 混入を抑える。一方で Grok OAuth は通常 Grok home の `auth.json` と `auth.json.lock` をセットで共有し、複数セッション間で refresh lock が分裂しないようにする。初回の未 bind `pty_send({ wait: "agent_done" })` は、vendor TUI の入力欄が出るまで待ち、入力受付状態でなければ文字列を送らず送信前エラーにする。`codex_agent` launcher の `wait:"agent_done"` も同じく `prompt` と `agent_done:true` が必須。TUI が入力欄 ready にならない場合は prompt を送らず、`initial_prompt=not_sent` として session を調査可能なまま残す。起動時 prompt が `pending`/`sent` の間は、混入防止のため通常 `pty_send` も拒否する。手動介入は `pty_key`、または意図的な `pty_send(..., force:true)` で行う。`agent_done` は `getuid`・安全な一時ファイル・hard link 検査など POSIX ファイルシステム前提を使うため、対応は Linux / WSL2 / macOS。Windows ネイティブでは core PTY と agent launcher は使えるが、`agent_done` はまだ未対応。
+各ベンダーの CLI が導入・認証済みであること（`codex_agent` は `codex`、Grok 系 2 つは `grok`）。バイナリは `CODEX_BIN` / `GROK_BIN` → `~/.local/bin/codex` / `~/.grok/bin/grok` → `PATH` の順で解決する。前提は **session を作る前に**検証する——`grok_agent` / `composer_agent` は範囲外の `reasoning_effort` を先に弾き（値集合は固定＝`low`/`medium`/`high`/`xhigh`/`max`）、CLI バイナリ不在・実在しない `cwd` は 3 つとも失敗する。前提（`reasoning_effort`・バイナリ・`cwd`）で弾かれた起動は **session の残骸をゼロ**にして返し、起動キーストロークを送れなければ session を畳む。（初回 prompt wait を使わない場合、その先でベンダー CLI が実際に立ち上がったか・認証できたかは aiterm は検証しない——起動できたかは session を読んで確認する。）（`codex_agent` は Codex の受理値が版で変わるため、`reasoning_effort` を検証せず config override〔`-c model_reasoning_effort=…`〕として Codex CLI へ渡す。）`cwd` は絶対パスで渡す——`~` は展開されない。`agent_done` は launch ごとの managed vendor home を使い、通常の hook file は書き換えない。Codex は managed `CODEX_HOME` に `auth.json` だけを symlink し、`config.toml` はコピーする。Grok/Composer はさらに `GROK_HOME` と `HOME` を隔離し、compat hook/plugin 混入を抑える。Grok OAuth は検証済みの通常auth正本をvendor所有の `GROK_AUTH_PATH` で渡し、managed homeにauth/lockのsymlinkやcopyを作らない。refresh lockとatomic replacementはGrok自身が所有する。初回の未 bind `pty_send({ wait: "agent_done" })` は、vendor TUI の入力欄が出るまで待ち、入力受付状態でなければ文字列を送らず送信前エラーにする。`codex_agent` launcher の `wait:"agent_done"` も同じく `prompt` と `agent_done:true` が必須。TUI が入力欄 ready にならない場合は prompt を送らず、`initial_prompt=not_sent` として session を調査可能なまま残す。起動時 prompt が `pending`/`sent` の間は、混入防止のため通常 `pty_send` も拒否する。手動介入は `pty_key`、または意図的な `pty_send(..., force:true)` で行う。`agent_done` は `getuid`・安全な一時ファイル・hard link 検査など POSIX ファイルシステム前提を使うため、対応は Linux / WSL2 / macOS。Windows ネイティブでは core PTY と agent launcher は使えるが、`agent_done` はまだ未対応。
 
 **Claude launcher はあえて無い**し、エージェント間のプロトコルも無い: aiterm の役目は、あなたの Claude（や任意の MCP クライアント）が*他の*エージェントに手を伸ばして端末を操作できるようにすること。起動したエージェントは単なるもう 1 本の永続セッションなので、この README の他のすべて（トークン削減読取・完了検出・人の `attach` での監視/介入）がそのまま効く。
 
@@ -273,7 +273,7 @@ consumer は `aiterm-runtime-errors snapshot` を読み、durable ingestion 後
 | `grok_agent` | Grok Build の `grok-build` モデル（xAI） | `prompt?`, `reasoning_effort?`（`low`/`medium`/`high`/`xhigh`/`max`）, `cwd?`, `session_name?`, `agent_done?` |
 | `composer_agent` | Grok Build の `grok-composer-2.5-fast` モデル（xAI） | `grok_agent` と同じ |
 
-各ベンダーの CLI が導入・認証済みであること（`codex_agent` は `codex`、Grok 系 2 つは `grok`）。バイナリは `CODEX_BIN` / `GROK_BIN` → `~/.local/bin/codex` / `~/.grok/bin/grok` → `PATH` の順で解決する。前提はセッション作成前に検証し（grok/composer は範囲外の `reasoning_effort` を弾く。CLI 不在・実在しない `cwd` は 3 つとも失敗）、起動に失敗してもセッションの残骸は残さない。詳細は [その端末の中に他のコーディングエージェントを起動する](#2-その端末の中に他のコーディングエージェントを起動する--オーケストレーションの旗艦)。`cwd` は絶対パスで渡す——`~` は展開されない。`agent_done` は hook-backed で、Codex/Grok/Composer は Linux/WSL2/macOS の後続 `pty_send(wait:"agent_done")` で実 smoke 済み。Codex は launcher の `prompt + wait:"agent_done"` も実 smoke 済み。Windows ネイティブでは agent launcher は使えるが `agent_done` はまだ未対応。Codex の managed `CODEX_HOME` は `auth.json` だけを symlink し、`config.toml` をコピーし、`hooks.json` は aiterm が所有する。初回の未 bind agent send では `pty_send({ wait:"agent_done" })` が vendor TUI の入力欄を待ち、未 ready なら送信前エラーにする。`codex_agent` launcher の `wait:"agent_done"` は `prompt` と `agent_done:true` が必須で、TUI ready 後にだけ初回 prompt を送る。入力欄 ready にならない場合は prompt を送らず、`initial_prompt=not_sent` を返して session を残す。Grok OAuth mode では hook/config 隔離は launch ごとに維持しつつ、通常 Grok home の `auth.json` と `auth.json.lock` をセットで共有する。OAuth auth 不在ならセッション残骸なしで失敗する。
+各ベンダーの CLI が導入・認証済みであること（`codex_agent` は `codex`、Grok 系 2 つは `grok`）。バイナリは `CODEX_BIN` / `GROK_BIN` → `~/.local/bin/codex` / `~/.grok/bin/grok` → `PATH` の順で解決する。前提はセッション作成前に検証し（grok/composer は範囲外の `reasoning_effort` を弾く。CLI 不在・実在しない `cwd` は 3 つとも失敗）、起動に失敗してもセッションの残骸は残さない。詳細は [その端末の中に他のコーディングエージェントを起動する](#2-その端末の中に他のコーディングエージェントを起動する--オーケストレーションの旗艦)。`cwd` は絶対パスで渡す——`~` は展開されない。`agent_done` は hook-backed で、Codex/Grok/Composer は Linux/WSL2/macOS の後続 `pty_send(wait:"agent_done")` で実 smoke 済み。Codex は launcher の `prompt + wait:"agent_done"` も実 smoke 済み。Windows ネイティブでは agent launcher は使えるが `agent_done` はまだ未対応。Codex の managed `CODEX_HOME` は `auth.json` だけを symlink し、`config.toml` をコピーし、`hooks.json` は aiterm が所有する。初回の未 bind agent send では `pty_send({ wait:"agent_done" })` が vendor TUI の入力欄を待ち、未 ready なら送信前エラーにする。`codex_agent` launcher の `wait:"agent_done"` は `prompt` と `agent_done:true` が必須で、TUI ready 後にだけ初回 prompt を送る。入力欄 ready にならない場合は prompt を送らず、`initial_prompt=not_sent` を返して session を残す。Grok OAuth mode ではhook/config隔離をlaunchごとに維持し、検証済みの通常auth正本を`GROK_AUTH_PATH`でvendorへ渡す。managed homeにauth/lockは作らない。OAuth auth 不在ならセッション残骸なしで失敗する。
 
 エージェントの回答が `wait:"agent_done"` の画面 tail（ペイン高 ≒ 24 行）より長くて切れたら、`pty_read({ agent_transcript: true })` で全文回収する。managed home 配下の vendor 構造化 transcript から、直近完了ターンの最終 assistant メッセージを平文で返す（再プロンプト不要）。Codex は Stop hook の `turn_id` で join、Grok/Composer は最後の実ユーザー行より後ろの assistant 行を採る。読み取り専用で、`screen`/`full`/`rtk`/`line_range`/`wait` とは併用不可（`lines` のみ可）。transcript 不在・非 agent session・抽出不能はいずれも明示エラー（黙って空を返さない）。
 
@@ -291,6 +291,8 @@ consumer は `aiterm-runtime-errors snapshot` を読み、durable ingestion 後
 
 `pty_send` は送信前に破壊的コマンド（`rm -rf /`, `mkfs`, `dd of=/dev/…`, `DROP TABLE` 等）を遮断し（`force: true` で越える）、ESC・ブラケットペースト終端などをサニタイズする。`pty_read` は既定で制御文字を無害化して返す（`raw: true` はバイトをそのまま返す）。これは**サンドボックスではなく tripwire**（[既知の制約](#既知の制約バグではなく仕様)参照）。
 
+1回の `pty_send` が受理する本文はUTF-8で最大64KiB。同一sessionへの送信はaiterm processをまたいで直列化し、chunk同士の混線を防ぐ。macOSでは長いPTY入力の欠落を避けるためUTF-8境界を壊さない256-byte単位でtmux pasteし、Linux/WSLでは上限内を1回でpasteする。途中chunkが失敗した場合は部分送信済みであることを明示し、自動でEnterを押さない。送信processの異常終了でlockが残った場合は送信前にfail-closedする。そのsessionを `pty_close` して作り直すか、全sessionを破棄できる場合だけ `pty_kill_all` で安全に掃除する。
+
 ## 人が覗く
 
 セッションは共有 tmux ソケット上にある。`pty_open`（および各エージェント起動ツール）の戻り値に表示される `tmux -S … attach -t <id>` で人間が同じ端末に入って介入できる（抜けるのは `Ctrl-b d`）——起動した Codex/Grok/Composer のセッションが走るのを覗いたり、作業の途中で AI からキーボードを奪ったりも。Windows ネイティブではセッションが WSL 内にあるため、表示は WSL 形（`wsl tmux -S … attach -t <id>`）になる。

package/README.md

@@ -24,11 +24,11 @@
 
 Ten tools: six **PTY tools** — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` — to open, drive, and read one persistent terminal, three **agent launchers** — `codex_agent` / `grok_agent` / `composer_agent` — that each start another coding agent's TUI inside a fresh one, and `diagnostics` for safe factory readiness. The backend is **tmux**, so sessions survive even if the MCP server or the AI client restarts.
 
-**v0.12.2 is a release candidate (pending).** Factory diagnostics and the local
+**v0.12.2 was published on 2026-07-13.** Factory diagnostics and the local
 runtime-error store collect only when canonical dotagents config explicitly sets
 `collection.enabled: true`; collection is off by default and performs no network
-I/O. Publication, tag, CI, registry registration, and registry-install verification
-are pending.
+I/O. npm `latest`, provenance CI, tag / GitHub Release, Official MCP Registry
+registration, and a registry-derived isolated install were verified.
 
 **Status:** actively maintained · the newcomer here, betting on a different shape (see [vs. the alternatives](#vs-the-alternatives)) · runs on Linux · WSL2 · macOS · native Windows for the core PTY tools (`agent_done` is POSIX/WSL/macOS only for now) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
@@ -72,7 +72,7 @@ One call per model, so the tool name itself tells you which model you get:
 | `grok_agent` | Grok Build, model `grok-4.5` by default (`model?` overrides) (xAI) | `prompt?`, `model?`, `reasoning_effort?` unsupported (an explicit value is an error; Grok CLI `--effort` is headless-only), `cwd?`, `session_name?`, `agent_done?` |
 | `composer_agent` | Grok Build, model `grok-composer-2.5-fast` by default (`model?` overrides) (xAI) | `prompt?`, `model?`, `reasoning_effort?` unsupported (an explicit value is an error), `cwd?`, `session_name?`, `agent_done?` |
 
-The vendor CLI must be installed and authenticated (`codex` for `codex_agent`; `grok` for both Grok tools). aiterm resolves the binary via `CODEX_BIN` / `GROK_BIN`, then `~/.local/bin/codex` / `~/.grok/bin/grok`, then `PATH`. Prerequisites are checked **before** a session exists: empty `model` values and any `reasoning_effort` for `grok_agent` / `composer_agent` are rejected up front; a missing CLI binary or a nonexistent `cwd` fails for all three. A rejected launch leaves **zero leftover session** behind, and if the launch keystroke itself can't be delivered aiterm tears the session down. (Without an initial prompt wait, aiterm does *not* then verify the vendor CLI actually started or authenticated — read the session to confirm the agent came up.) `codex_agent` forwards `model` as `-m` and `reasoning_effort` as `-c model_reasoning_effort=…` without validating the effort value, since Codex's accepted values vary by version. Grok/Composer reject `reasoning_effort`: Grok CLI `--effort` is only for headless `grok -p`, and the interactive TUI ignores it with a warning. Pass an absolute path for `cwd` — `~` is not expanded. Codex launch responses always report the effective model/effort and where each came from (argument, terminal-config inheritance, or CLI default), with an explicit warning when the effective effort is `ultra` (max reasoning plus proactive automatic delegation). `agent_done` uses launch-local managed vendor homes and does not edit your normal hook files; Codex links only `auth.json` and copies `config.toml` into its managed `CODEX_HOME` — explicitly passed `model` / `reasoning_effort` values also rewrite the matching top-level pins in that copy, so terminal pins don't silently leak into the child — while Grok/Composer additionally isolate `GROK_HOME` and `HOME` to suppress compat hook/plugin contamination. Grok OAuth uses the normal Grok home's `auth.json` and `auth.json.lock` as a pair so refresh locking does not split across sessions. Before the first unbound `pty_send({ wait: "agent_done" })`, aiterm waits for the vendor TUI's input prompt and fails before sending if the prompt is not ready, avoiding dropped startup input. `codex_agent` launcher `wait:"agent_done"` has the same requirement and is only valid with both `prompt` and `agent_done:true`; if the TUI is not ready, the prompt is not sent and the session is left inspectable with `initial_prompt=not_sent`. While an initial prompt is still `pending`/`sent`, ordinary `pty_send` is rejected to prevent mixed input; manual takeover can still use `pty_key`, or `pty_send(..., force:true)` if you intentionally want to type into that live TUI. `agent_done` currently requires POSIX filesystem semantics (`getuid`, secure temp files, hard-link checks), so it is supported on Linux, WSL2, and macOS; native Windows can still use the core PTY tools and agent launchers without `agent_done`.
+The vendor CLI must be installed and authenticated (`codex` for `codex_agent`; `grok` for both Grok tools). aiterm resolves the binary via `CODEX_BIN` / `GROK_BIN`, then `~/.local/bin/codex` / `~/.grok/bin/grok`, then `PATH`. Prerequisites are checked **before** a session exists: empty `model` values and any `reasoning_effort` for `grok_agent` / `composer_agent` are rejected up front; a missing CLI binary or a nonexistent `cwd` fails for all three. A rejected launch leaves **zero leftover session** behind, and if the launch keystroke itself can't be delivered aiterm tears the session down. (Without an initial prompt wait, aiterm does *not* then verify the vendor CLI actually started or authenticated — read the session to confirm the agent came up.) `codex_agent` forwards `model` as `-m` and `reasoning_effort` as `-c model_reasoning_effort=…` without validating the effort value, since Codex's accepted values vary by version. Grok/Composer reject `reasoning_effort`: Grok CLI `--effort` is only for headless `grok -p`, and the interactive TUI ignores it with a warning. Pass an absolute path for `cwd` — `~` is not expanded. Codex launch responses always report the effective model/effort and where each came from (argument, terminal-config inheritance, or CLI default), with an explicit warning when the effective effort is `ultra` (max reasoning plus proactive automatic delegation). `agent_done` uses launch-local managed vendor homes and does not edit your normal hook files; Codex links only `auth.json` and copies `config.toml` into its managed `CODEX_HOME` — explicitly passed `model` / `reasoning_effort` values also rewrite the matching top-level pins in that copy, so terminal pins don't silently leak into the child — while Grok/Composer additionally isolate `GROK_HOME` and `HOME` to suppress compat hook/plugin contamination. Grok OAuth passes the validated normal auth canonical file through vendor-owned `GROK_AUTH_PATH`; managed homes contain no auth/lock symlink or copy, so refresh locking and atomic replacement stay in Grok itself. Before the first unbound `pty_send({ wait: "agent_done" })`, aiterm waits for the vendor TUI's input prompt and fails before sending if the prompt is not ready, avoiding dropped startup input. `codex_agent` launcher `wait:"agent_done"` has the same requirement and is only valid with both `prompt` and `agent_done:true`; if the TUI is not ready, the prompt is not sent and the session is left inspectable with `initial_prompt=not_sent`. While an initial prompt is still `pending`/`sent`, ordinary `pty_send` is rejected to prevent mixed input; manual takeover can still use `pty_key`, or `pty_send(..., force:true)` if you intentionally want to type into that live TUI. `agent_done` currently requires POSIX filesystem semantics (`getuid`, secure temp files, hard-link checks), so it is supported on Linux, WSL2, and macOS; native Windows can still use the core PTY tools and agent launchers without `agent_done`.
 
 There is deliberately **no Claude launcher**, and no protocol between the agents: aiterm's job is to let your Claude (or any MCP client) reach for *other* agents and drive their terminals. Because a launched agent is just another persistent session, everything else in this README applies to it: token-reduced reads, completion detection, and a human `attach` to watch or take over.
 
@@ -276,7 +276,7 @@ Each launcher starts a specific vendor's interactive coding-agent TUI inside a f
 | `grok_agent` | Grok Build, model `grok-4.5` by default (`model?` overrides) (xAI) | `prompt?`, `model?`, `reasoning_effort?` unsupported (an explicit value is an error; Grok CLI `--effort` is headless-only), `cwd?`, `session_name?`, `agent_done?` |
 | `composer_agent` | Grok Build, model `grok-composer-2.5-fast` by default (`model?` overrides) (xAI) | `prompt?`, `model?`, `reasoning_effort?` unsupported (an explicit value is an error), `cwd?`, `session_name?`, `agent_done?` |
 
-The vendor CLI must be installed and authenticated (`codex` for `codex_agent`; `grok` for both Grok tools). aiterm resolves the binary via `CODEX_BIN` / `GROK_BIN`, then `~/.local/bin/codex` / `~/.grok/bin/grok`, then `PATH`. Prerequisites are validated before a session is created: empty `model` and any Grok/Composer `reasoning_effort` are errors, while a missing CLI or nonexistent `cwd` fails for all three; a failed launch leaves no session behind. Codex forwards `model` as `-m` and `reasoning_effort` as `-c model_reasoning_effort=…`; Grok/Composer reject effort because interactive TUI does not support it (Grok CLI `--effort` is headless-only). Full details under [Launch other coding agents into that terminal](#2-launch-other-coding-agents-into-that-terminal--the-orchestration-flagship). Pass an absolute path for `cwd` — `~` is not expanded. `agent_done` is hook-backed for agent launchers; Codex/Grok/Composer have passing live smokes on Linux/WSL2/macOS for follow-up `pty_send(wait:"agent_done")`, and Codex has a live smoke for launcher `prompt + wait:"agent_done"`. Native Windows can launch agents but `agent_done` is not supported yet. Codex managed `CODEX_HOME` links only `auth.json`, copies `config.toml`, and owns its own `hooks.json`. Before the first unbound agent send, `pty_send({ wait:"agent_done" })` waits for the vendor TUI input prompt and fails before sending if it is not ready. `codex_agent` launcher `wait:"agent_done"` requires `prompt` plus `agent_done:true`; it sends the initial prompt only after the TUI is ready, and returns `initial_prompt=not_sent` without sending if the TUI is blocked before input. In Grok OAuth mode, aiterm keeps hook/config isolation per launch but shares both `auth.json` and `auth.json.lock` with the normal Grok home; missing OAuth auth fails without leaving a session behind.
+The vendor CLI must be installed and authenticated (`codex` for `codex_agent`; `grok` for both Grok tools). aiterm resolves the binary via `CODEX_BIN` / `GROK_BIN`, then `~/.local/bin/codex` / `~/.grok/bin/grok`, then `PATH`. Prerequisites are validated before a session is created: empty `model` and any Grok/Composer `reasoning_effort` are errors, while a missing CLI or nonexistent `cwd` fails for all three; a failed launch leaves no session behind. Codex forwards `model` as `-m` and `reasoning_effort` as `-c model_reasoning_effort=…`; Grok/Composer reject effort because interactive TUI does not support it (Grok CLI `--effort` is headless-only). Full details under [Launch other coding agents into that terminal](#2-launch-other-coding-agents-into-that-terminal--the-orchestration-flagship). Pass an absolute path for `cwd` — `~` is not expanded. `agent_done` is hook-backed for agent launchers; Codex/Grok/Composer have passing live smokes on Linux/WSL2/macOS for follow-up `pty_send(wait:"agent_done")`, and Codex has a live smoke for launcher `prompt + wait:"agent_done"`. Native Windows can launch agents but `agent_done` is not supported yet. Codex managed `CODEX_HOME` links only `auth.json`, copies `config.toml`, and owns its own `hooks.json`. Before the first unbound agent send, `pty_send({ wait:"agent_done" })` waits for the vendor TUI input prompt and fails before sending if it is not ready. `codex_agent` launcher `wait:"agent_done"` requires `prompt` plus `agent_done:true`; it sends the initial prompt only after the TUI is ready, and returns `initial_prompt=not_sent` without sending if the TUI is blocked before input. In Grok OAuth mode, aiterm keeps hook/config isolation per launch and passes the validated normal auth canonical file through `GROK_AUTH_PATH`; managed homes contain no auth/lock file, and missing OAuth auth fails before a session exists.
 
 When an agent's answer is longer than the `wait:"agent_done"` screen tail (pane height ≈ 24 lines), recover it in full with `pty_read({ agent_transcript: true })`. It returns the most recently completed turn's final assistant message in plain text, read from the vendor's structured session transcript under the managed home — no re-prompting. Codex joins on the Stop hook `turn_id`; Grok/Composer take the assistant rows after the last real user row. Read-only, and mutually exclusive with `screen`/`full`/`rtk`/`line_range`/`wait` (`lines` is allowed). A missing transcript, a non-agent session, or an unextractable message is an explicit error, never a silent empty.
 
@@ -294,6 +294,8 @@ When an agent's answer is longer than the `wait:"agent_done"` screen tail (pane
 
 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 by default (`raw: true` returns the bytes verbatim). This is a **tripwire, not a sandbox** (see [Known constraints](#known-constraints-by-design-not-bugs)).
 
+Each `pty_send` accepts at most 64 KiB of UTF-8 text. Sends to the same session are serialized across aiterm processes so chunks cannot interleave. On macOS, text is pasted through tmux in UTF-8-safe 256-byte chunks to avoid the platform PTY truncation observed with long input; Linux and WSL use one bounded paste. If a later chunk fails, aiterm reports the partial-send state and does not press Enter automatically. A lock left by a terminated sender fails closed before sending; close and recreate that session (or use `pty_kill_all` when every session is disposable) to clean it up safely.
+
 ## A human can watch
 
 Sessions live on a shared tmux socket. The `tmux -S … attach -t <id>` line printed by `pty_open` (and by each agent launcher) lets a human attach to the same terminal and intervene (`Ctrl-b d` to detach) — including watching a launched Codex/Grok/Composer session run and taking the keyboard from your AI mid-task. On native Windows the printed line is the WSL form — `wsl tmux -S … attach -t <id>` — since the session lives inside WSL.
@@ -344,4 +346,15 @@ If aiterm let your AI hand a task to another agent — or saved you a round-trip
 
 ## License
 
+> Grok OAuthのauth/lock共有は0.9.1当時の契約で、2026-07-14に廃止した。現行はmanaged隔離を維持し、検証済み通常auth正本を`GROK_AUTH_PATH`でvendorへ渡す。aitermはlock・atomic replace・copy-backを所有しない。
+
 MIT
+
+## Grok OAuth isolation
+
+For `agent_done`, Grok/Composer keep launch-local `GROK_HOME` and fake `HOME`.
+The child receives `GROK_AUTH_PATH` pointing at the validated normal auth
+canonical file; managed homes never contain auth or lock symlinks/copies.
+aiterm does not create locks or copy credentials back. An inherited
+`GROK_AUTH_PATH` must be absolute and safe; only an absent default auth file is
+allowed when `XAI_API_KEY` is set.

package/dist/core.js

@@ -54,6 +54,7 @@ const AGENT_METADATA_NEGATIVE_CACHE_TTL_MS = 2_000;
 const AGENT_TUI_READY_TIMEOUT_MS = 30_000;
 const AGENT_TUI_READY_POLL_MS = 500;
 const AGENT_TUI_READY_LINES = 45;
+const GROK_AUTH_MAX_BYTES = 64 * 1024;
 // 出力削減（RTK の CAP 思想を移植）
 const MAX_LINES_BEFORE_ELIDE = 60;
 const HEAD_LINES = 30;
@@ -63,6 +64,12 @@ const LINE_HEAD_CHARS = 1200;
 const LINE_TAIL_CHARS = 600;
 const DEDUP_MIN_RUN = 3; // 同一行がこれ以上連続したら 1 行＋件数に畳む
 const MAX_FULL_BYTES = 8 * 1024 * 1024; // full/range 読取で一度にメモリへ載せる上限（B7）
+const MAX_SEND_BYTES = 64 * 1024;
+// macOSのPTY入力queueは、tmuxが長文を1回で流すと後半を落とすことがある。
+// UTF-8境界を守って小さいtmux client roundtripに分け、各回にserver event loopがPTYへdrainできる境界を作る。
+const PTY_PASTE_CHUNK_BYTES = process.platform === "darwin" ? 256 : MAX_SEND_BYTES;
+const SESSION_SEND_LOCK_WAIT_MS = 10_000;
+const SESSION_SEND_LOCK_POLL_MS = 25;
 // 安全: send 前に弾く破壊的コマンド（外部システム境界の防御）
 const DESTRUCTIVE = [
     // rm -rf の危険な対象形（best-effort・force で越えられる）。先頭の任意クオート ['"]? で
@@ -199,18 +206,19 @@ function resolveTmux(observe = true) {
     }
     ptyDependencyError(tmuxMissingMessage(), observe);
 }
-function tmuxCommand(observe, ...args) {
+function tmuxCommandWithInput(observe, input, ...args) {
     // maxBuffer は既定 1MiB。capture-pane（大きなスクロールバック）や多セッションの list-sessions で
     // 頭打ちになり stdout が切れる/空になる。Python の subprocess.run は無制限だったので 64MiB へ広げる。
     // Windows は同じ tmux を WSL 経由（-e でログインシェル非経由＝$ 展開やクオート崩れを防ぐ）で叩く。
     let r;
+    const spawnOpts = { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, input };
     if (isWin) {
         ensureWinBridge(observe);
-        r = spawnSync("wsl.exe", ["-e", "tmux", "-S", SOCK, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+        r = spawnSync("wsl.exe", ["-e", "tmux", "-S", SOCK, ...args], spawnOpts);
     }
     else {
         // resolveTmux() は tmux を解決できなければ明確な AitermError を投げる（POSIX 版の事前確認）。
-        r = spawnSync(resolveTmux(observe), ["-S", SOCK, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+        r = spawnSync(resolveTmux(observe), ["-S", SOCK, ...args], spawnOpts);
     }
     // ENOBUFS（出力が 64MiB 超）を「code=1 の失敗」へ握り潰すと部分/空 stdout を正常扱いしてしまう。区別して投げる。
     // EXPECTED-FAILURE: 外部システム境界（tmux 出力過大）
@@ -225,9 +233,15 @@ function tmuxCommand(observe, ...args) {
     }
     return { code: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
 }
+function tmuxCommand(observe, ...args) {
+    return tmuxCommandWithInput(observe, undefined, ...args);
+}
 function tmux(...args) {
     return tmuxCommand(true, ...args);
 }
+function tmuxWithInput(input, ...args) {
+    return tmuxCommandWithInput(true, input, ...args);
+}
 function tmuxCleanup(...args) {
     return tmuxCommand(false, ...args);
 }
@@ -238,6 +252,42 @@ function paneCurrentCommand(name) {
     const r = tmux("display-message", "-p", "-t", name, "#{pane_current_command}");
     return r.code === 0 ? r.stdout.trim() : "";
 }
+function pasteBufferSupportsNoSanitizeFlag() {
+    const listed = tmux("list-commands");
+    if (listed.code !== 0) {
+        throw new AitermError(`tmux paste-buffer 能力の確認に失敗しました: ${listed.stderr.trim() || `code=${listed.code}`}`, 2);
+    }
+    const usage = listed.stdout.split("\n").find((line) => line.startsWith("paste-buffer "));
+    if (!usage)
+        throw new AitermError("tmux list-commands にpaste-bufferがありません", 2);
+    // tmux 3.4は制御文字を無変換でpasteし、-S自体が無い。3.7は既定でvis(3)変換し、
+    // -Sが無変換を選ぶ。version文字比較で推測せず、実際のcommand usageにflagがあるかを見る。
+    return /\[-[^\]]*S[^\]]*\]/.test(usage);
+}
+function splitPtyText(text) {
+    const chunks = [];
+    let chunk = "";
+    let chunkBytes = 0;
+    for (const codePoint of text) {
+        const bytes = Buffer.byteLength(codePoint, "utf8");
+        if (chunk && chunkBytes + bytes > PTY_PASTE_CHUNK_BYTES) {
+            chunks.push(chunk);
+            chunk = "";
+            chunkBytes = 0;
+        }
+        chunk += codePoint;
+        chunkBytes += bytes;
+    }
+    if (chunk)
+        chunks.push(chunk);
+    return chunks;
+}
+function assertSendTextSize(text, context = "送信文字列") {
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > MAX_SEND_BYTES) {
+        throw new AitermError(`${context}が${MAX_SEND_BYTES} bytesを超えています（${bytes} bytes）`, 2);
+    }
+}
 // session 名はファイルパス（logpath 等）と pipe-pane の /bin/sh 文字列へ流れる。英数 _ - のみ・64字に
 // 限定し、パストラバーサル（../）とシェルインジェクション（' でのクオート破り・$・; 等）を全入口で断つ。
 function assertSessionName(name) {
@@ -393,6 +443,10 @@ function lastcmdpath(name) {
 function markpath(name) {
     return path.join(SOCKDIR, name + ".mark");
 }
+function sendLockPath(name) {
+    assertSessionName(name);
+    return path.join(SOCKDIR, name + ".send.lock");
+}
 function readOffset(name) {
     try {
         const n = parseInt(fs.readFileSync(offsetpath(name), "utf8").trim(), 10);
@@ -822,35 +876,78 @@ export function send(name, text, o = {}) {
                 `正しく展開されません。until で完了パターンを指定してください。`, 2);
         }
     }
-    writeLastcmd(name, text); // read rtk の reducer 分類用（書換/mark 前の素のコマンド）
-    if (o.rtk)
-        text = rtkRewrite(text);
-    if (o.rtk && !o.force)
-        assertNotDestructive(text, 3, "rtk 変換後: ");
-    if (o.mark) {
-        // 実出力は rc=<数字>、この行のエコーは rc=%d(リテラル)。MARK_DONE_RE は数字アンカーで後者に免疫。
-        text = text + `; printf '\\n<<<AITERM_DONE rc=%d>>>\\n' "$?"`;
-        try {
-            fs.writeFileSync(markpath(name), "1"); // waitCompletion に sentinel 完了検出を有効化させる
+    assertSendTextSize(text);
+    const releaseSendLock = acquireSessionSendFileLock(name);
+    try {
+        writeLastcmd(name, text); // read rtk の reducer 分類用（書換/mark 前の素のコマンド）
+        if (o.rtk)
+            text = rtkRewrite(text);
+        if (o.rtk && !o.force)
+            assertNotDestructive(text, 3, "rtk 変換後: ");
+        if (o.mark)
+            text = text + `; printf '\\n<<<AITERM_DONE rc=%d>>>\\n' "$?"`;
+        assertSendTextSize(text, o.rtk || o.mark ? "変換後の送信文字列" : "送信文字列");
+        if (o.mark) {
+            try {
+                fs.writeFileSync(markpath(name), "1"); // waitCompletion に sentinel 完了検出を有効化させる
+            }
+            catch {
+                /* noop（フラグ書けなくても until/quiescence 経路は生きる） */
+            }
         }
-        catch {
-            /* noop（フラグ書けなくても until/quiescence 経路は生きる） */
+        else {
+            // 非 mark 送信は、未消化の古い mark 完了待ちを無効化する（前コマンドの sentinel を待ち続けない）。
+            try {
+                fs.unlinkSync(markpath(name));
+            }
+            catch {
+                /* noop */
+            }
         }
-    }
-    else {
-        // 非 mark 送信は、未消化の古い mark 完了待ちを無効化する（前コマンドの sentinel を待ち続けない）。
-        try {
-            fs.unlinkSync(markpath(name));
+        // `send-keys -l`と単発`paste-buffer`は、長文をPTY入力queueへ一度に流し、macOS CIで
+        // 途中以降が欠落しても tmux 自体は code=0 を返した。macOSだけUTF-8を壊さない256byte以下に分け、
+        // Linux/WSLは一括のままとする。全chunk＋Enterはsession単位のcross-process lock内で直列化する。
+        const pasteSupportsNoSanitize = pasteBufferSupportsNoSanitizeFlag();
+        const chunks = splitPtyText(text);
+        const bufferBase = `aiterm-${process.pid}-${randomBytes(8).toString("hex")}`;
+        for (let i = 0; i < chunks.length; i += 1) {
+            const bufferName = `${bufferBase}-${i}`;
+            const partial = i > 0
+                ? " 先行chunkはPTYに入力済みでEnterは未送信です。再送前に入力を確認・消去してください。"
+                : "";
+            const loaded = tmuxWithInput(chunks[i], "load-buffer", "-b", bufferName, "-");
+            if (loaded.code !== 0) {
+                tmuxCleanup("delete-buffer", "-b", bufferName);
+                throw new AitermError(`tmux bufferへの送信準備に失敗しました` +
+                    `（chunk ${i + 1}/${chunks.length}）: ${loaded.stderr.trim() || `code=${loaded.code}`}.${partial}`, 2);
+            }
+            // -r: LF→CR 置換を無効化。-Sは対応新版だけでvis(3)制御文字変換を無効化する。
+            // send 自身の raw/sanitize 契約だけを真実とし、tmux 側で黙って再変換させない。
+            const pasteArgs = ["paste-buffer", "-d", "-r"];
+            if (pasteSupportsNoSanitize)
+                pasteArgs.push("-S");
+            pasteArgs.push("-b", bufferName, "-t", name);
+            const pasted = tmux(...pasteArgs);
+            if (pasted.code !== 0) {
+                // paste 失敗時は -d で消えないbufferを明示的に掃除する。元エラーを優先する。
+                tmuxCleanup("delete-buffer", "-b", bufferName);
+                throw new AitermError(`tmux bufferのPTY送信に失敗しました` +
+                    `（chunk ${i + 1}/${chunks.length}）: ${pasted.stderr.trim() || `code=${pasted.code}`}.${partial}`, 2);
+            }
         }
-        catch {
-            /* noop */
+        if (enter) {
+            const entered = tmux("send-keys", "-t", name, "Enter");
+            if (entered.code !== 0) {
+                throw new AitermError(`文字列はPTYに入力済みですがtmuxへEnterを送れませんでした: ` +
+                    `${entered.stderr.trim() || `code=${entered.code}`}。再送前に入力を確認・消去してください`, 2);
+            }
         }
+        // コードポイント数で数える（JS の .length は UTF-16 単位で絵文字等がズレる。Python は len()=コードポイント）。
+        return `sent ${[...text].length} chars to ${name}` + (enter ? " (+Enter)" : "");
+    }
+    finally {
+        releaseSendLock();
     }
-    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) {
     assertSessionName(name);
@@ -1066,8 +1163,15 @@ function closeSessionInternal(name, observeDependency = true) {
             throw new AitermError(`agent session '${name}' は別プロセス${d.pid != null ? `（pid ${d.pid}）` : ""}の agent_done 待機中のため close できません`, 2);
         }
     }
+    {
+        const sending = liveSendLocks(name);
+        if (sending.length > 0) {
+            const d = sending[0];
+            throw new AitermError(`session '${name}' は別プロセス${d.pid != null ? `（pid ${d.pid}）` : ""}の送信中のため close できません`, 2);
+        }
+    }
     (observeDependency ? tmux : tmuxCleanup)("kill-session", "-t", name);
-    for (const p of [logpath(name), offsetpath(name), lastcmdpath(name), markpath(name)]) {
+    for (const p of [logpath(name), offsetpath(name), lastcmdpath(name), markpath(name), sendLockPath(name)]) {
         try {
             fs.unlinkSync(p);
         }
@@ -1093,11 +1197,18 @@ export function killAll() {
             throw new AitermError(`agent_done 待機中の session があるため killAll できません: ${list}`, 2);
         }
     }
+    {
+        const sending = liveSendLocks(null);
+        if (sending.length > 0) {
+            const list = sending.map((d) => `${d.session}${d.pid != null ? `(pid ${d.pid})` : ""}`).join(",");
+            throw new AitermError(`送信中の session があるため killAll できません: ${list}`, 2);
+        }
+    }
     tmux("kill-server");
-    // B9: SOCKDIR 内の .log/.offset/.lastcmd/.mark 残骸も掃除する（残すと B5 の stale-log 復活の温床）。
+    // B9: SOCKDIR 内の .log/.offset/.lastcmd/.mark/.send.lock 残骸も掃除する。
     try {
         for (const f of fs.readdirSync(SOCKDIR)) {
-            if (/\.(log|offset|lastcmd|mark)$/.test(f)) {
+            if (/\.(log|offset|lastcmd|mark)$/.test(f) || f.endsWith(".send.lock")) {
                 try {
                     fs.unlinkSync(path.join(SOCKDIR, f));
                 }
@@ -1380,70 +1491,61 @@ function createManagedCodexHome(name, launchId, overrides = {}) {
     return managedHome;
 }
 function realGrokHome() {
-    return process.env.GROK_HOME || path.join(process.env.HOME ?? os.homedir(), ".grok");
-}
-function validateGrokAuthLock(lockPath) {
-    let st;
-    try {
-        st = fs.lstatSync(lockPath);
-    }
-    catch (e) {
-        throw e;
-    }
-    if (st.isSymbolicLink())
-        throw new AitermError(`Grok auth lock が symlink です: ${lockPath}`, 2);
-    if (!st.isFile())
-        throw new AitermError(`Grok auth lock が通常ファイルではありません: ${lockPath}`, 2);
-    if (st.nlink !== 1)
-        throw new AitermError(`Grok auth lock が hard link です: ${lockPath}`, 2);
-    try {
-        fs.chmodSync(lockPath, 0o600);
-    }
-    catch {
-        /* lock file permission tightening is best-effort */
-    }
-}
-function ensureGrokAuthLock(srcHome) {
-    const lockPath = path.join(srcHome, "auth.json.lock");
-    try {
-        validateGrokAuthLock(lockPath);
-        return lockPath;
-    }
-    catch (e) {
-        if (e.code !== "ENOENT")
-            throw e;
-    }
-    try {
-        createEmpty0600NoFollow(lockPath);
-    }
-    catch (e) {
-        if (e.code !== "EEXIST")
-            throw e;
-    }
-    validateGrokAuthLock(lockPath);
-    return lockPath;
-}
-function linkGrokOauthFiles(srcHome, grokHome) {
-    const srcAuth = path.join(srcHome, "auth.json");
-    let authExists = false;
+    return path.resolve(process.env.GROK_HOME || path.join(process.env.HOME ?? os.homedir(), ".grok"));
+}
+function resolveAndValidateGrokAuth(srcHome) {
+    const inheritedSet = Object.prototype.hasOwnProperty.call(process.env, "GROK_AUTH_PATH");
+    const inherited = process.env.GROK_AUTH_PATH;
+    if (inheritedSet && (!inherited || !path.isAbsolute(inherited)))
+        throw new AitermError("GROK_AUTH_PATH は空でない絶対パスで指定してください", 2);
+    const authPath = inherited ?? path.join(srcHome, "auth.json");
+    let fd;
     try {
-        const authSt = fs.statSync(srcAuth);
-        if (!authSt.isFile())
-            throw new AitermError(`Grok auth.json が通常ファイルではありません: ${srcAuth}`, 2);
-        authExists = true;
+        fd = fs.openSync(authPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.uid !== currentUid() || (st.mode & 0o077) !== 0 || st.size > GROK_AUTH_MAX_BYTES) {
+            throw new AitermError("Grok 認証正本の安全検証に失敗しました", 2);
+        }
+        const value = JSON.parse(fs.readFileSync(fd, "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new AitermError("Grok 認証正本のJSONが不正です", 2);
+        // auth file 自体は O_NOFOLLOW で開いているが、中間 directory の symlink は辿り得る。
+        // vendor に渡す正本を path swap の入口にしないため、字句正規化した絶対 path と realpath を
+        // 一致させ、canonical な祖先も root まで検証する。same-UID race の排他は vendor lock の責務。
+        const lexicalPath = path.resolve(authPath);
+        const canonicalPath = fs.realpathSync(authPath);
+        if (lexicalPath !== canonicalPath)
+            throw new AitermError("Grok 認証正本の path に symlink を含められません", 2);
+        for (let dir = path.dirname(canonicalPath);; dir = path.dirname(dir)) {
+            const dirSt = fs.lstatSync(dir);
+            // /tmp のような root 所有 + sticky の共有 directory は、本人所有の private な
+            // 直下 directory を他 UID が rename/unlink できないため許可する。sticky 無しの
+            // group/other writable 祖先は path swap が可能なので従来どおり拒否する。
+            const writableByOthers = (dirSt.mode & 0o022) !== 0;
+            const protectedSharedRoot = dirSt.uid === 0 && (dirSt.mode & 0o1000) !== 0;
+            if (!dirSt.isDirectory()
+                || dirSt.isSymbolicLink()
+                || (dirSt.uid !== currentUid() && dirSt.uid !== 0)
+                || (writableByOthers && !protectedSharedRoot)) {
+                throw new AitermError("Grok 認証正本の祖先 directory が安全ではありません", 2);
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+        }
+        return canonicalPath;
     }
     catch (e) {
-        if (e.code !== "ENOENT")
+        if (e.code === "ENOENT" && !inheritedSet && process.env.XAI_API_KEY)
+            return null;
+        if (e instanceof AitermError)
             throw e;
+        throw new AitermError(e.code === "ENOENT" ? "Grok 認証正本が見つかりません。先に grok login が必要です" : "Grok 認証正本を安全に開けません", 2);
     }
-    if (!authExists) {
-        if (process.env.XAI_API_KEY)
-            return;
-        throw new AitermError(`Grok auth.json が見つかりません。先に grok login が必要です: ${srcHome}`, 2);
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
     }
-    const srcLock = ensureGrokAuthLock(srcHome);
-    fs.symlinkSync(srcAuth, path.join(grokHome, "auth.json"));
-    fs.symlinkSync(srcLock, path.join(grokHome, "auth.json.lock"));
 }
 function writeManagedGrokConfig(grokHome) {
     fs.mkdirSync(path.join(grokHome, "hooks"), { recursive: false, mode: 0o700 });
@@ -1471,17 +1573,7 @@ function writeManagedGrokConfig(grokHome) {
         "",
     ].join("\n"));
 }
-function createManagedGrokHome(name, launchId) {
-    const srcHome = realGrokHome();
-    let srcSt;
-    try {
-        srcSt = fs.statSync(srcHome);
-    }
-    catch {
-        throw new AitermError(`Grok home が見つかりません: ${srcHome}`, 2);
-    }
-    if (!srcSt.isDirectory())
-        throw new AitermError(`Grok home が directory ではありません: ${srcHome}`, 2);
+function createManagedGrokHome(name, launchId, authPath) {
     const grokHome = agentManagedGrokHomePath(name, launchId);
     const fakeHome = agentManagedGrokUserHomePath(name, launchId);
     fs.mkdirSync(grokHome, { recursive: false, mode: 0o700 });
@@ -1489,9 +1581,6 @@ function createManagedGrokHome(name, launchId) {
     fs.chmodSync(grokHome, 0o700);
     fs.chmodSync(fakeHome, 0o700);
     fs.symlinkSync(grokHome, path.join(fakeHome, ".grok"));
-    // OAuth refresh token rotation は auth.json だけでなく vendor lock と同じ実体を共有させる。
-    // per-launch GROK_HOME 隔離は維持し、通常 Grok home の hook/config/session は読ませない。
-    linkGrokOauthFiles(srcHome, grokHome);
     const hookScript = grokHookScriptPath();
     if (!fs.existsSync(hookScript)) {
         throw new AitermError(`Grok Stop hook wrapper が見つかりません。npm run build を実行してください: ${hookScript}`, 2);
@@ -1514,7 +1603,7 @@ function createManagedGrokHome(name, launchId) {
     });
     // Grok 0.2.87 は compat false でも ~/.claude/plugins の hook file を拾う。HOME を一時化して
     // plugin/hook source を完全に 0 にする。実 HOME は必要なら hook/agent 側で参照できるよう env で渡す。
-    return { grokHome, home: fakeHome };
+    return { grokHome, home: fakeHome, authPath };
 }
 function writeAgentMetadata(meta) {
     writeJson0600(agentMetadataPath(meta.aiterm_session, meta.launch_id), meta);
@@ -1581,13 +1670,101 @@ function probeWaitLock(p) {
 function unlinkStaleWaitLock(p) {
     try {
         const st = fs.lstatSync(p);
-        if (st.isFile() && !st.isSymbolicLink() && st.uid === currentUid())
+        const uid = typeof process.getuid === "function" ? process.getuid() : null;
+        if (st.isFile() && !st.isSymbolicLink() && (uid == null || st.uid === uid))
             fs.unlinkSync(p);
     }
     catch {
         /* noop */
     }
 }
+function liveSendLocks(name) {
+    let files;
+    try {
+        files = fs.readdirSync(SOCKDIR);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        if (!f.endsWith(".send.lock"))
+            continue;
+        const session = f.slice(0, -".send.lock".length);
+        if (name != null && session !== name)
+            continue;
+        const p = path.join(SOCKDIR, f);
+        const probe = probeWaitLock(p);
+        if (probe.live)
+            out.push({ session, pid: probe.pid, at: probe.at });
+        // dead send lockはここでunlinkしない。probe後に別processが同pathへ新しいlive lockを作る
+        // ABAが起きると、そのlive lockを消して二重owner化できる。close/killAllがsessionを止めた後に掃除する。
+    }
+    return out;
+}
+function acquireSessionSendFileLock(name) {
+    const p = sendLockPath(name);
+    const token = randomBytes(16).toString("hex");
+    const nofollow = fs.constants.O_NOFOLLOW ?? 0;
+    const deadline = Date.now() + SESSION_SEND_LOCK_WAIT_MS;
+    let fd = null;
+    let lastProbe = { pid: null, at: null, live: true };
+    while (fd == null) {
+        try {
+            fd = fs.openSync(p, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | nofollow, 0o600);
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            lastProbe = probeWaitLock(p);
+            if (!lastProbe.live) {
+                const detail = lastProbe.pid != null ? `pid ${lastProbe.pid}` : "owner不明";
+                throw new AitermError(`session '${name}' に前回送信のlock残骸があります（${detail}）。` +
+                    `自動回収は並行送信の混線を招くため行いません。pty_closeでsessionを閉じてから再作成するか、` +
+                    `不要な全sessionをpty_kill_allで停止して残骸を掃除してください`, 2);
+            }
+            if (Date.now() >= deadline) {
+                const detail = lastProbe.pid != null ? `pid ${lastProbe.pid}` : "owner不明";
+                throw new AitermError(`session '${name}' は別プロセスの送信中です（${detail}）。${SESSION_SEND_LOCK_WAIT_MS}ms待ってもlockを取得できませんでした`, 2);
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, SESSION_SEND_LOCK_POLL_MS);
+        }
+    }
+    try {
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: new Date().toISOString(), token }) + "\n", "utf8");
+    }
+    catch (error) {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+            /* noop */
+        }
+        // pathを再確認せずunlinkすると、外部置換後のlockを消し得る。書込失敗は残骸としてfail closedし、
+        // close/killAllのsession停止後cleanupへ委ねる。
+        throw error;
+    }
+    fs.closeSync(fd);
+    try {
+        fs.chmodSync(p, 0o600);
+    }
+    catch {
+        /* Windows等でmode強制できなくてもOS user temp境界とO_EXCLは維持される */
+    }
+    return () => {
+        try {
+            const st = fs.lstatSync(p);
+            if (!st.isFile() || st.isSymbolicLink())
+                return;
+            const current = JSON.parse(fs.readFileSync(p, "utf8").split("\n", 1)[0]);
+            if (current.token === token)
+                fs.unlinkSync(p);
+        }
+        catch {
+            /* 別ownerのlockや置換済みpathは消さない */
+        }
+    };
+}
 // close/killAll 用: 生きた別プロセス待機の wait lock を列挙する（stale 残骸は数えない）。
 function liveWaitLocks(name) {
     const dir = existingAgentsDir();
@@ -1683,11 +1860,11 @@ function createCodexAgentMetadata(name, cwd, initialPrompt, overrides = {}) {
     writeAgentMetadata(meta);
     return meta;
 }
-function createGrokAgentMetadata(kind, name, cwd, initialPrompt) {
+function createGrokAgentMetadata(kind, name, cwd, initialPrompt, authPath) {
     const launchId = randomBytes(16).toString("hex");
     const eventFile = agentEventPath(name, launchId);
     createEmpty0600NoFollow(eventFile);
-    const managed = createManagedGrokHome(name, launchId);
+    const managed = createManagedGrokHome(name, launchId, authPath);
     const meta = {
         kind,
         aiterm_session: name,
@@ -1701,6 +1878,7 @@ function createGrokAgentMetadata(kind, name, cwd, initialPrompt) {
         node_platform: process.platform,
         grok_home: managed.grokHome,
         home: managed.home,
+        grok_auth_path: managed.authPath,
     };
     writeAgentMetadata(meta);
     return meta;
@@ -1759,6 +1937,10 @@ function loadAgentMetadata(name) {
     if (m.hook_route !== "managed_grok_home" || m.grok_home !== expectedGrokHome || m.home !== expectedHome) {
         throw new AitermError("agent metadata の path が現在の secure state root と一致しません", 2);
     }
+    const expectedAuthPath = resolveAndValidateGrokAuth(realGrokHome());
+    if ((typeof m.grok_auth_path === "string" ? m.grok_auth_path : null) !== expectedAuthPath) {
+        throw new AitermError("agent metadata の認証正本が現在の設定と一致しません", 2);
+    }
     return {
         kind: m.kind,
         aiterm_session: name,
@@ -1772,6 +1954,7 @@ function loadAgentMetadata(name) {
         node_platform: process.platform,
         grok_home: expectedGrokHome,
         home: expectedHome,
+        grok_auth_path: expectedAuthPath,
     };
 }
 function parseAgentDoneEvent(line, meta) {
@@ -2456,6 +2639,7 @@ function agentEnvPrefix(meta, sid) {
     return [
         `HOME=${shq(meta.home ?? "")}`,
         `GROK_HOME=${shq(meta.grok_home ?? "")}`,
+        ...(meta.grok_auth_path ? [`GROK_AUTH_PATH=${shq(meta.grok_auth_path)}`] : []),
         "GROK_DISABLE_AUTOUPDATER=1",
         "GROK_CLAUDE_HOOKS_ENABLED=false",
         "GROK_CURSOR_HOOKS_ENABLED=false",
@@ -2569,13 +2753,14 @@ export function openAgent(kind, opts = {}) {
     // でしか確認できない（CI 非対象。docs/03_audit-sweep-2026-07.md 参照）。
     const binForCmd = isWin ? toWslPath(bin) : bin;
     const cwdForCmd = cwd && isWin ? toWslPath(cwd) : cwd;
+    const grokAuthPath = agentDone && kind !== "codex" ? resolveAndValidateGrokAuth(realGrokHome()) : null;
     const [sid, hint] = openSession(opts.session_name ?? null, "bash");
     let launchNote = "";
     try {
         const meta = agentDone
             ? kind === "codex"
                 ? createCodexAgentMetadata(sid, cwd, opts.prompt ? "pending" : "none", { model, effort })
-                : createGrokAgentMetadata(kind, sid, cwd, opts.prompt ? "pending" : "none")
+                : createGrokAgentMetadata(kind, sid, cwd, opts.prompt ? "pending" : "none", grokAuthPath)
             : null;
         if (meta)
             agentMetadataNegativeCache.delete(sid);

package/dist/index.js

@@ -84,7 +84,9 @@ server.registerTool("pty_send", {
         "agent_done:true で起動した Codex/Grok/Composer セッションは wait:'agent_done' で Stop hook まで待てる。",
     inputSchema: {
         session_id: z.string(),
-        text: z.string().describe("送る文字列（コマンド）"),
+        text: z
+            .string()
+            .describe("送る文字列（コマンド）。UTF-8で最大64KiB"),
         enter: z.boolean().default(true).describe("末尾で Enter を送る"),
         wait: z
             .enum(["none", "agent_done"])

package/dist/runtime-error-store.js

@@ -31,6 +31,11 @@ const RECORD_KEYS = [
 const DIAGNOSTIC_KEYS = ["status", "collection", "record_count", "unacknowledged_count"];
 const ARCHES = new Set(["x64", "arm64", "arm", "ia32"]);
 const EMPTY_STATE = () => ({ schema_version: STORE_SCHEMA, cursor: 0, acknowledged_cursor: 0, records: [] });
+// readLock と queue scan の内部だけで使う。entry 本文など外部入力の Error message で
+// disappearance を判定しないため、公開せず型そのものを識別子にする。
+class LockDisappearedOrReplacedError extends Error {
+    constructor() { super("runtime error store lock が消滅または置換されました"); }
+}
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -426,6 +431,10 @@ export class RuntimeErrorStore {
         }
         else {
             const before = fs.lstatSync(lock);
+            // APFS の高競合では readdir snapshot 後、正当に unlink 済みの entry が pre-open
+            // lstat で nlink=0 と観測される。これは置換／消滅として caller の既存 skip 経路へ渡す。
+            if (before.nlink === 0)
+                throw new LockDisappearedOrReplacedError();
             if (!before.isFile() || before.isSymbolicLink() || before.nlink < 1 || before.nlink > 2
                 || before.uid !== process.getuid() || (before.mode & 0o777) !== 0o600 || before.size > 4096) {
                 throw new Error("runtime error store lock が不正です");
@@ -433,9 +442,10 @@ export class RuntimeErrorStore {
             const fd = fs.openSync(lock, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK | (fs.constants.O_NOFOLLOW ?? 0));
             try {
                 const after = fs.fstatSync(fd);
-                if (before.dev !== after.dev || before.ino !== after.ino || after.nlink < 1 || after.nlink > 2) {
-                    throw new Error("runtime error store lock が置換されました");
-                }
+                if (before.dev !== after.dev || before.ino !== after.ino || after.nlink === 0)
+                    throw new LockDisappearedOrReplacedError();
+                if (after.nlink < 1 || after.nlink > 2)
+                    throw new Error("runtime error store lock が不正です");
                 text = fs.readFileSync(fd, "utf8");
             }
             finally {
@@ -532,8 +542,7 @@ export class RuntimeErrorStore {
                         current = this.readLock(currentPath);
                     }
                     catch (error) {
-                        if (error.code === "ENOENT"
-                            || (error instanceof Error && error.message.includes("置換されました")))
+                        if (error.code === "ENOENT" || error instanceof LockDisappearedOrReplacedError)
                             continue;
                         throw error;
                     }
@@ -568,8 +577,7 @@ export class RuntimeErrorStore {
                         current = this.readLock(currentPath);
                     }
                     catch (error) {
-                        if (error.code === "ENOENT"
-                            || (error instanceof Error && error.message.includes("置換されました")))
+                        if (error.code === "ENOENT" || error instanceof LockDisappearedOrReplacedError)
                             continue;
                         throw error;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "mcpName": "io.github.kitepon-rgb/aiterm-mcp",
   "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. Also launches interactive Codex/Grok/Composer agent TUIs in a persistent terminal. Token-reducing reads.",
   "keywords": [