aiterm-mcp 0.12.1 → 0.12.3

package/dist/core.js

@@ -14,6 +14,7 @@ import * as os from "node:os";
 import { createHash, randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import * as rtk from "./rtk.js";
+import { recordRuntimeError } from "./runtime-error-store.js";
 // Windows ネイティブには tmux が無い。その場合だけ全 tmux 呼び出しを WSL 経由へ橋渡しする
 // （POSIX = Linux/WSL2/macOS は従来どおり tmux を直接叩く）。
 const isWin = process.platform === "win32";
@@ -53,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;
@@ -62,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 で越えられる）。先頭の任意クオート ['"]? で
@@ -98,6 +106,33 @@ export class AitermError extends Error {
         this.code = code;
     }
 }
+class TelemetryOwnedError extends AitermError {
+    telemetryCode;
+    constructor(message, code, telemetryCode, cause) {
+        super(message, code);
+        this.name = "TelemetryOwnedError";
+        this.telemetryCode = telemetryCode;
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+function telemetryOwnedFailure(telemetryCode, error, fallbackCode = 1) {
+    if (error instanceof TelemetryOwnedError)
+        return error;
+    recordRuntimeError(telemetryCode);
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof AitermError ? error.code : fallbackCode;
+    return new TelemetryOwnedError(message, code, telemetryCode, error);
+}
+function ownTelemetryFailure(telemetryCode, error, fallbackCode = 1) {
+    throw telemetryOwnedFailure(telemetryCode, error, fallbackCode);
+}
+function ptyDependencyError(message, observe = true) {
+    const error = new AitermError(message, 2);
+    if (observe)
+        ownTelemetryFailure("AITERM.PTY_DEPENDENCY_UNAVAILABLE", error, 2);
+    throw error;
+}
 // Windows のドライブパス (C:\a\b) を WSL から見える /mnt/c/a/b へ変換する。
 // 一時領域は常にドライブ直下なので UNC は想定外＝弾く（黙って壊れた //server パスを作らない）。
 export function toWslPath(p) {
@@ -109,22 +144,22 @@ export function toWslPath(p) {
 // Windows で最初の tmux 呼び出し前に一度だけ WSL+tmux の可用性を確かめ、失敗は原因別に投げる。
 // -e（ログインシェル非経由）＋短い timeout で、初回セットアップ未完了の wsl によるハングも防ぐ。
 let winBridgeOk = false;
-function ensureWinBridge() {
+function ensureWinBridge(observe = true) {
     if (winBridgeOk)
         return;
     const r = spawnSync("wsl.exe", ["-e", "tmux", "-V"], { encoding: "utf8", timeout: 10000 });
     if (r.error) {
         const code = r.error.code;
         if (code === "ETIMEDOUT")
-            throw new AitermError("WSL が応答しません（初回セットアップ未完了の可能性）。一度 `wsl` を起動してから再実行してください。", 2);
+            ptyDependencyError("WSL が応答しません（初回セットアップ未完了の可能性）。一度 `wsl` を起動してから再実行してください。", observe);
         if (code === "ENOENT")
-            throw new AitermError("wsl.exe が見つかりません。Windows では WSL 上の tmux 経由で動作します。WSL と tmux を導入してください。", 2);
-        throw new AitermError(`wsl.exe を起動できませんでした（${code ?? "unknown"}）。`, 2);
+            ptyDependencyError("wsl.exe が見つかりません。Windows では WSL 上の tmux 経由で動作します。WSL と tmux を導入してください。", observe);
+        ptyDependencyError(`wsl.exe を起動できませんでした（${code ?? "unknown"}）。`, observe);
     }
     // wsl.exe は System32 にあるので「起動」は成功するが、ディストリ未導入や distro 内に tmux が無いと
     // 非ゼロで終わる。両方を区別せず（wsl の出力は UTF-16 で文字化けし得るため）正直に表す。
     if (r.status !== 0)
-        throw new AitermError("WSL 経由で tmux を起動できませんでした。WSL のディストリ未導入、または distro 内に tmux が無い可能性があります。`wsl tmux -V` が通るか確認してください（tmux 導入例: sudo apt install tmux）。", 2);
+        ptyDependencyError("WSL 経由で tmux を起動できませんでした。WSL のディストリ未導入、または distro 内に tmux が無い可能性があります。`wsl tmux -V` が通るか確認してください（tmux 導入例: sudo apt install tmux）。", observe);
     winBridgeOk = true;
 }
 // tmux が見つからないときの説明。macOS は tmux を同梱せず、Homebrew の bin は GUI 起動時の PATH に
@@ -143,7 +178,7 @@ function tmuxMissingMessage() {
 // 解決順: AITERM_TMUX（明示指定）→ PATH 上の tmux → Homebrew 既定パス。一度だけ実行しキャッシュする。
 // 見つからなければ tmuxMissingMessage で投げる（黙ってフォールバックせず、原因が見えるようにする）。
 let tmuxBin = null;
-function resolveTmux() {
+function resolveTmux(observe = true) {
     if (tmuxBin)
         return tmuxBin;
     const override = process.env.AITERM_TMUX;
@@ -151,7 +186,7 @@ function resolveTmux() {
         const r = spawnSync(override, ["-V"], { encoding: "utf8", timeout: 5000 });
         if (!r.error && r.status === 0)
             return (tmuxBin = override);
-        throw new AitermError(`AITERM_TMUX に指定された tmux を起動できません: ${override}（\`${override} -V\` が通りません）`, 2);
+        ptyDependencyError(`AITERM_TMUX に指定された tmux を起動できません: ${override}（\`${override} -V\` が通りません）`, observe);
     }
     // CLI/開発時は PATH 上の tmux をそのまま使う（最優先）。
     const onPath = spawnSync("tmux", ["-V"], { encoding: "utf8", timeout: 5000 });
@@ -169,20 +204,21 @@ function resolveTmux() {
             /* 次の候補へ */
         }
     }
-    throw new AitermError(tmuxMissingMessage(), 2);
+    ptyDependencyError(tmuxMissingMessage(), observe);
 }
-function tmux(...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();
-        r = spawnSync("wsl.exe", ["-e", "tmux", "-S", SOCK, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+        ensureWinBridge(observe);
+        r = spawnSync("wsl.exe", ["-e", "tmux", "-S", SOCK, ...args], spawnOpts);
     }
     else {
         // resolveTmux() は tmux を解決できなければ明確な AitermError を投げる（POSIX 版の事前確認）。
-        r = spawnSync(resolveTmux(), ["-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 出力過大）
@@ -193,10 +229,22 @@ function tmux(...args) {
     // 通常は resolveTmux() が事前に弾くため発火しないが、mid-run 消滅に対する正直な防御。
     if (!isWin && r.error && r.error.code === "ENOENT") {
         tmuxBin = null; // 次回 resolveTmux で再解決を許す
-        throw new AitermError(tmuxMissingMessage(), 2);
+        ptyDependencyError(tmuxMissingMessage(), observe);
     }
     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);
+}
 function sessionExists(name) {
     return tmux("has-session", "-t", name).code === 0;
 }
@@ -204,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) {
@@ -359,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);
@@ -685,7 +773,12 @@ function assertNotDestructive(text, code, context = "") {
 }
 // ---------------------------------------------------------------- 操作（return で返す / 失敗は AitermError）
 export function openSession(name, shell = "bash") {
-    fs.mkdirSync(SOCKDIR, { recursive: true });
+    try {
+        fs.mkdirSync(SOCKDIR, { recursive: true });
+    }
+    catch (error) {
+        ownTelemetryFailure("AITERM.PERSISTENCE_WRITE_FAILED", error);
+    }
     // macOS の /bin/bash は 3.2 で、起動時に zsh 移行バナーを出して最初の read を汚す。darwin かつ bash の
     // ときだけ -e で環境変数を渡して抑止する。-e は tmux>=3.2 が必要だが macOS の Homebrew tmux は常に該当。
     // （古い tmux<3.2 が残る Linux/WSL で -e を渡すと new-session が落ちるため、darwin 限定にする。）
@@ -720,7 +813,12 @@ export function openSession(name, shell = "bash") {
     // 新規セッションの .log は必ず truncate する。"a"（追記）だと外部 kill / killAll / クラッシュで
     // 同名 session だけ消えて .log が残った場合、offset=0 と相まって旧出力を新規として返す（B5）。
     // break は new-session 成功後にのみ到達＝作りたての空 session ゆえ切り詰めは安全。lastcmd/mark 残骸も掃除。
-    fs.writeFileSync(logpath(nm), "");
+    try {
+        fs.writeFileSync(logpath(nm), "");
+    }
+    catch (error) {
+        ownTelemetryFailure("AITERM.PERSISTENCE_WRITE_FAILED", error);
+    }
     for (const p of [lastcmdpath(nm), markpath(nm)]) {
         try {
             fs.unlinkSync(p);
@@ -738,16 +836,24 @@ export function openSession(name, shell = "bash") {
     const pr = tmux("pipe-pane", "-t", nm, "-o", `cat >> ${quoted}`);
     if (pr.code !== 0) {
         // 配管に失敗した session は pty_read が永遠に空を返す＝成功を装わない。作った session を片付けて明示エラー。
-        tmux("kill-session", "-t", nm);
+        try {
+            tmuxCleanup("kill-session", "-t", nm);
+        }
+        catch { /* cleanup failure is not a second observation */ }
         try {
             fs.unlinkSync(logpath(nm)); // B14: 直前に作った空 .log も残さない
         }
         catch {
             /* noop */
         }
-        throw new AitermError("tmux pipe-pane 失敗（出力ログを配管できないため session を破棄）: " + pr.stderr.trim(), 2);
+        ownTelemetryFailure("AITERM.PERSISTENCE_WRITE_FAILED", new AitermError("tmux pipe-pane 失敗（出力ログを配管できないため session を破棄）: " + pr.stderr.trim(), 2), 2);
+    }
+    try {
+        writeOffset(nm, 0);
+    }
+    catch (error) {
+        ownTelemetryFailure("AITERM.PERSISTENCE_WRITE_FAILED", error);
     }
-    writeOffset(nm, 0);
     return [nm, attachHint(nm)];
 }
 export function send(name, text, o = {}) {
@@ -770,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);
@@ -979,7 +1128,29 @@ export function listSessions() {
     }
     return "(セッション無し)";
 }
-export function closeSession(name) {
+/**
+ * `pty_list` 相当を read-only に照会し、内容を返さず session 件数だけを返す。
+ * session 名・前面コマンド・PTY 出力を診断応答へ持ち出さないため、factory が安全に readiness を
+ * 見られる。socket 不在は「セッション未設定」であって障害ではない。
+ */
+export function readOnlyPtyListDiagnostic() {
+    try {
+        const r = tmux("list-sessions", "-F", "#{session_name}");
+        if (r.code === 0) {
+            return { status: "ready", session_count: r.stdout.split(/\r?\n/).filter(Boolean).length };
+        }
+        // tmux は専用 socket に server がいない通常状態を exit 1 で返す。その他の失敗を「空」と
+        // 偽装しないため、メッセージを公開せず unverified に留める。
+        if (/no server running|failed to connect/i.test(r.stderr)) {
+            return { status: "not_applicable", session_count: 0 };
+        }
+    }
+    catch {
+        // tmux 未導入・WSL bridge 不全等。絶対 path や生 stderr を診断 JSON に出さない。
+    }
+    return { status: "unverified", session_count: null };
+}
+function closeSessionInternal(name, observeDependency = true) {
     assertSessionName(name);
     if (agentWaitLocks.has(name)) {
         throw new AitermError(`agent session '${name}' は agent_done 待機中のため close できません`, 2);
@@ -992,8 +1163,15 @@ export function closeSession(name) {
             throw new AitermError(`agent session '${name}' は別プロセス${d.pid != null ? `（pid ${d.pid}）` : ""}の agent_done 待機中のため close できません`, 2);
         }
     }
-    tmux("kill-session", "-t", name);
-    for (const p of [logpath(name), offsetpath(name), lastcmdpath(name), markpath(name)]) {
+    {
+        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), sendLockPath(name)]) {
         try {
             fs.unlinkSync(p);
         }
@@ -1004,6 +1182,9 @@ export function closeSession(name) {
     cleanupAgentState(name);
     return `closed ${name}`;
 }
+export function closeSession(name) {
+    return closeSessionInternal(name, true);
+}
 export function killAll() {
     if (agentWaitLocks.size > 0) {
         throw new AitermError(`agent_done 待機中の session があるため killAll できません: ${Array.from(agentWaitLocks).join(",")}`, 2);
@@ -1016,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));
                 }
@@ -1303,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 });
@@ -1394,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 });
@@ -1412,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);
@@ -1437,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);
@@ -1504,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();
@@ -1606,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,
@@ -1624,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;
@@ -1682,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,
@@ -1695,6 +1954,7 @@ function loadAgentMetadata(name) {
         node_platform: process.platform,
         grok_home: expectedGrokHome,
         home: expectedHome,
+        grok_auth_path: expectedAuthPath,
     };
 }
 function parseAgentDoneEvent(line, meta) {
@@ -2288,21 +2548,46 @@ function resolveAgentBin(kind) {
         // 明示指定 env は実在を検証する。存在しないパスを黙って返すと、session を作って
         // `'/typo' ...` を送信し bash が command not found を出すだけで openAgent は「起動した」と
         // 偽成功を返す（既定パス/PATH 経路は検証するのに env だけ無検証だった非対称の解消・A3）。
-        if (fs.existsSync(fromEnv))
+        if (isUsableExecutableFile(fromEnv))
             return fromEnv;
         throw new AitermError(`${envVar} に指定された ${name} が存在しません: ${fromEnv}`, 2);
     }
     const cand = path.join(home, ...rel);
-    if (fs.existsSync(cand))
+    if (isUsableExecutableFile(cand))
         return cand;
     const w = spawnSync(isWin ? "where" : "which", [name], {
         encoding: "utf8",
         timeout: 5000,
     });
-    if (w.status === 0 && (w.stdout ?? "").trim())
-        return w.stdout.trim().split(/\r?\n/)[0];
+    if (w.status === 0 && (w.stdout ?? "").trim()) {
+        const resolved = w.stdout.trim().split(/\r?\n/)[0];
+        if (isUsableExecutableFile(resolved))
+            return resolved;
+    }
     return null;
 }
+function isUsableExecutableFile(candidate) {
+    try {
+        if (!fs.statSync(candidate).isFile())
+            return false;
+        if (isWin)
+            return /\.(?:exe|cmd|bat|com)$/i.test(candidate);
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** vendor CLI の存在だけを安全に要約する。認証状態・実行出力・解決先 path は返さない。 */
+export function vendorLauncherDiagnostic(kind) {
+    try {
+        return resolveAgentBin(kind) ? "ready" : "not_applicable";
+    }
+    catch {
+        return "unverified";
+    }
+}
 // 単一引用符で安全に包む（' は '\'' で脱出）。send は raw:true で送るため自前で quote する。
 function shq(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
@@ -2354,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",
@@ -2427,10 +2713,16 @@ export function openAgent(kind, opts = {}) {
             "（モデルカタログ supports_reasoning_effort=false）", 2);
     }
     const agentDone = !!opts.agent_done;
-    const bin = resolveAgentBin(kind);
+    let bin;
+    try {
+        bin = resolveAgentBin(kind);
+    }
+    catch (error) {
+        ownTelemetryFailure("AITERM.VENDOR_LAUNCHER_FAILED", error, 2);
+    }
     if (!bin) {
         const where = kind === "codex" ? "~/.local/bin/codex" : "~/.grok/bin/grok";
-        throw new AitermError(`${label} の CLI が見つかりません（${where} か PATH が必要）`, 2);
+        ownTelemetryFailure("AITERM.VENDOR_LAUNCHER_FAILED", new AitermError(`${label} の CLI が見つかりません（${where} か PATH が必要）`, 2), 2);
     }
     // cwd 検証（session を作る前に。cd 失敗はシェル内で静かに死に「起動した」と偽成功を返すため）。
     let cwd = null;
@@ -2461,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);
@@ -2481,14 +2774,15 @@ export function openAgent(kind, opts = {}) {
         send(sid, full, { enter: true, mark: false, force: true, rtk: false, raw: true });
     }
     catch (e) {
+        const failure = telemetryOwnedFailure("AITERM.VENDOR_LAUNCHER_FAILED", e);
         // 起動コマンドを投入できなかった session は空のまま残る＝残骸を作らない。片付けてから元エラーを伝える。
         try {
-            closeSession(sid);
+            closeSessionInternal(sid, false);
         }
         catch {
             /* 片付け失敗より元エラーの伝達を優先 */
         }
-        throw e;
+        throw failure;
     }
     return [
         sid,