aiterm-mcp 0.52.0 → 0.52.2

package/CHANGELOG.md

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.52.2] - 2026-10-05
+
+### 修正
+
+- 0.52.1で、socketの置き場（`claude-tmux-sockets`）ごと無くなったagent sessionへの送信が、
+  `ENOENT: … .agent-send.lock`という生のエラーを返していた。0.52.0までは
+  「入力受付状態になりません。文字列は送信していません。」の断りだった。連携元が「文字列は送信していません」で
+  未送信を見分けている時、0.52.1ではこの場合だけ見分けられなかった。送信の順番を守るlock（ADR 0088）を
+  置き場に作れない時は、lockを取らずに進め、今まで通りの断りを返す。置き場が無ければsessionにも届かず、
+  守る相手が無い。sessionだけが無くなった時（置き場は残る）の断りは、0.52.1でも変わっていない。
+- 0.52.1で、送信の途中で終了したprocessのpidを別の生きたprocessが使い回すと、そのagent sessionへの送信が
+  `AGENT_SEND_BUSY`で断られ続けた。lockの持ち主をpidだけで見ていたため。`pty_close`してもlockが残り、
+  閉じて同じIDで起動し直しても同じ断りだった。生きて見える持ち主は、processが始まってからの経過と
+  lockを作ってからの時間を比べて本人かを確かめ、lockより後に始まった別のprocessなら片付ける。
+  片付けの途中で残った印は、5秒より古ければ、pidが生きて見えても残った物と読む（その時の断りは今までと同じ文面）。
+  `pty_close`は、使い回されたpidのlockと古い印も片付ける。OSへの照会は、送信が実際に重なった時と、
+  閉じる時にlockが残っていた時だけ行う。
+
+## [0.52.1] - 2026-10-05
+
+### 修正
+
+- 同じagent sessionへの`pty_send`が重なると、後の1通が断られる事があった（ADR 0088）。Aitermは送る時点の子の状態を見て
+  差し込みか新しいturnかを決めるが、見てから送り終えるまでの間に起動直後の入力受付待ち（最長30秒）が挟まり、
+  その区間を守るものが無かった。Claude Codeでは2通ともturnの印が無いと読み、後の1通が
+  「operation_idなしのClaude turn が未解決です」で断られた（文は打たれない）。Codex・Grok・Cursorでは断りにならず、
+  同じ入力欄へ2通が続けて貼られ、1行につながって届いた。同じsessionへの送信（`pty_send`、`claude_turn issue`、起動時prompt）を
+  1本ずつ通し、後の1通は前の1通が終わってから振り分け直す。順に送った時と同じ結果になり、Claude Codeへ重なった後の1通は
+  `mode=agent_steer`で返る。前の1通を待つ分だけ返りが遅れる。待つ上限（POSIX 60秒、Windows 180秒）を越えたら、
+  打鍵前に`AGENT_SEND_BUSY`と「文字列は送信していません」を返す。送信の途中で終了したprocessのlockは、次の送信が片付ける。
+  公開toolの返却形式とstate schemaは変えていない。旧版へ戻す時の手当ては要らない。
+
 ## [0.52.0] - 2026-10-04
 
 ### 修正
@@ -2103,7 +2135,9 @@ prototype (preserved under `prototype/python/` as the porting source and referen
   `ubuntu-latest` for Node 18/20/22, publishing to npm on `v*` tags with
   provenance.
 
-[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.52.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.52.2...HEAD
+[0.52.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.52.1...v0.52.2
+[0.52.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.52.0...v0.52.1
 [0.52.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.3...v0.52.0
 [0.51.3]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.2...v0.51.3
 [0.51.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.1...v0.51.2

package/README.ja.md

@@ -209,7 +209,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.52.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.52.2** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -261,6 +261,8 @@ ClaudeがAPIエラーや安全判定の拒否で終了した時は、Stop hook
 
 agent配送だけを期待する連携では、`pty_send`に`require_agent:true`を指定する。agent登録が無ければ、打鍵前に`AGENT_SESSION_REQUIRED`と「文字列は送信していません」を返す。省略時は通常PTY送信を維持する。`force:true`との併用は未送信で拒否する。
 
+同じagent sessionへの`pty_send`が重なった時は、1本ずつ通す。後の1通は、前の1通を送り終えてから振り分け直すので、順に送った時と同じ結果になる（起動直後のClaude Codeへ重なった後の1通は`mode=agent_steer`で返る）。前の1通が起動直後の入力受付待ちなら、その分だけ返りが遅れる。待つ上限（POSIX 60秒、Windows 180秒）を越えた時は、打鍵前に`AGENT_SEND_BUSY`と「文字列は送信していません」を返す。送信の途中で終了したprocessのlockは、次の送信が片付けて進む。
+
 `agent_launch`・`pty_send`（agent session宛て）は任意の`image`（画像ファイルの絶対パスの配列。png/jpg/jpeg/gif/webp）を受ける。aitermが本文末尾へ添付行を付け、どのharnessも自分のfile読取toolでそのpathを画像として開く。呼出し側はharness別の添付手順を覚えない。不正なpathは送信前に拒否する。
 
 `agent_launch`は任意の`write_scope`も受ける。Codex／Grokのread-onlyは`--sandbox read-only`、Cursorは公式`--mode ask`で実効化する。path説明は同等CLI引数がないためdeclaration-only。

package/README.md

@@ -223,7 +223,7 @@ collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.52.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.52.2** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -282,6 +282,8 @@ The same primitive hosts another agent's TUI. `agent_launch` starts a selected e
 
 Set `require_agent:true` on `pty_send` when the integration requires agent delivery. If the agent registration is missing, Aiterm refuses before sending any text and returns `AGENT_SESSION_REQUIRED` with an explicit unsent message. The default preserves ordinary PTY sends; combining it with `force:true` is rejected before sending.
 
+Overlapping `pty_send` calls to the same agent session are handled one at a time. A later call picks its route only after the earlier one has been sent, so the result matches calls made in sequence (a call that overlaps the first send to a freshly started Claude Code session returns `mode=agent_steer`). It returns later by however long the earlier call waits for the session to accept input. If its turn does not come within the limit (60 seconds on POSIX, 180 seconds on Windows), Aiterm refuses before sending any text and returns `AGENT_SEND_BUSY` with an explicit unsent message. A lock left by a process that exited mid-send is cleared by the next send.
+
 `agent_launch` and `pty_send` (to an agent session) accept an optional `image`: an array of absolute paths to image files (png/jpg/jpeg/gif/webp). Aiterm appends an attachment block to the prompt, and every harness opens the path with its own file-reading tool and sees the image; the caller never learns harness-specific attachment tricks. Invalid paths are rejected before anything is sent.
 
 `agent_launch` accepts an optional `write_scope`: either `"read-only"` or a human-readable description of writable paths. Codex/Grok use `--sandbox read-only`; Cursor uses its official read-only `--mode ask`. A path description remains declaration-only because these CLI launch surfaces provide no equivalent path allowlist flag.

package/dist/core.js

@@ -16,7 +16,7 @@ import * as rtk from "./rtk.js";
 import { isCursorMcpClient } from "aiterm-steer-delivery";
 import { paneTokenHint } from "./harnesses/pane-tokens.js";
 import { unfinishedDeliveriesOwnedBy } from "./parent-delivery-owners.js";
-import { readRuntimeProcesses, processSubtree, parentProcess, processIdentity, backgroundProcesses, lazyRelayProcess, aitermProcessProbe, windowsConsoleHost } from "./process-runtime.js";
+import { readRuntimeProcesses, processSubtree, parentProcess, processIdentity, backgroundProcesses, lazyRelayProcess, aitermProcessProbe, windowsConsoleHost, processElapsedSeconds } from "./process-runtime.js";
 import { AitermError, telemetryOwnedFailure, ownTelemetryFailure } from "./errors.js";
 import { isWin, SOCKDIR, tmuxCommand, sendPsmuxPayload, loadPtyBufferChunk, pasteBufferBaseArgs, tmuxNewSession, registeredSessionEnvironment, attachCommand, normalizePaneCommand, atomicShellMultiline, appendMarkSentinel, markShellCommand, settlePaneLog, paneCwdArgument, sessionEnvironmentLaunch, } from "./tmux-runtime.js";
 import { sleep, currentUid, runtimeStateBase, safeStatSize, readFileRange, writeJson0600, createEmpty0600, shq, LAUNCH_ID_RE, AGENT_DONE_POLL_MS, AGENT_RATE_LIMIT_POLL_MS, pollGate, AGENT_EVENT_MAX_BYTES, assertSessionName, agentsDir, agentEventPath, agentMetadataPath, writeAgentMetadata, AGENT_EVENT_TAIL_BYTES, agentLabel, agentHarness, subagentInstruction, agentLineageFields, } from "./agent-shared.js";
@@ -86,6 +86,10 @@ const PTY_PASTE_CHUNK_PAUSE_MS = 10;
 const PTY_PASTE_PAUSE_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 const SESSION_SEND_LOCK_WAIT_MS = isWin ? 130_000 : 10_000;
 const SESSION_SEND_LOCK_POLL_MS = 25;
+// 同じagent sessionへの送信が重なった時に、前の1通を待つ上限（ADR 0088）。
+// 起動から最初の描画を待つ上限と、貼り付けの上限の和。前の1通が正常に進んでいる間は待ち切れる長さにする。
+const AGENT_SEND_LOCK_WAIT_MS = AGENT_TUI_FIRST_DRAW_TIMEOUT_MS + SESSION_SEND_LOCK_WAIT_MS;
+const AGENT_SEND_LOCK_POLL_MS = 50;
 // CSI/OSC/ESC エスケープ・制御文字
 // CSI / OSC(BEL or ST 終端) / DCS・PM・APC・SOS(ESC P/^/_/X … BEL or ST 終端。ペイロード本文ごと除去=B10) / 残る2文字エスケープ
 const ANSI_RE = /\x1b\[[0-9;?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[P^_X][\s\S]*?(?:\x07|\x1b\\)|\x1b[@-_]/g;
@@ -349,6 +353,15 @@ function sendLockPath(name) {
     assertSessionName(name);
     return path.join(SOCKDIR, name + ".send.lock");
 }
+// agent sessionへの送信1本（振り分け〜Enterの確認）を守るlock。貼り付け1回ぶんの`.send.lock`とは別に持つ。
+function agentSendLockPath(name) {
+    assertSessionName(name);
+    return path.join(SOCKDIR, name + ".agent-send.lock");
+}
+// 持ち主が終了した`.agent-send.lock`を片付ける役の印。
+function agentSendReapPath(name) {
+    return agentSendLockPath(name) + ".reap";
+}
 function readOffset(name) {
     try {
         const n = parseInt(fs.readFileSync(offsetpath(name), "utf8").trim(), 10);
@@ -1345,6 +1358,7 @@ function closeSessionInternal(name, observeDependency = true) {
             /* noop */
         }
     }
+    cleanupAgentSendLock(name);
     cleanupAgentState(name);
     agentLaunchLines.delete(name);
     return `closed ${name}`;
@@ -1390,7 +1404,7 @@ export function killAll() {
         /* socketの置き場が無い */
     }
     for (const file of socketFiles) {
-        const name = file.replace(/\.(?:log|offset|lastcmd|mark|send\.lock)$/, "");
+        const name = file.replace(/\.(?:log|offset|lastcmd|mark|send\.lock|agent-send\.lock(?:\.reap)?)$/, "");
         if (name !== file && /^[A-Za-z0-9_-]{1,64}$/.test(name))
             sessions.add(name);
     }
@@ -1413,10 +1427,10 @@ export function killAll() {
     if (killed.code !== 0 && !/no server running|No such file or directory|failed to connect/i.test(killed.stderr)) {
         throw new AitermError("このsocketのserverを終了できません: " + killed.stderr.trim(), 2);
     }
-    // B9: SOCKDIR 内の .log/.offset/.lastcmd/.mark/.send.lock 残骸も掃除する。
+    // B9: SOCKDIR 内の .log/.offset/.lastcmd/.mark/.send.lock/.agent-send.lock 残骸も掃除する。
     try {
         for (const f of fs.readdirSync(SOCKDIR)) {
-            if (/\.(log|offset|lastcmd|mark)$/.test(f) || f.endsWith(".send.lock")) {
+            if (/\.(log|offset|lastcmd|mark)$/.test(f) || f.endsWith(".send.lock") || /\.agent-send\.lock(?:\.reap)?$/.test(f)) {
                 try {
                     fs.unlinkSync(path.join(SOCKDIR, f));
                 }
@@ -1846,6 +1860,7 @@ function isPidAlive(pid) {
 function probeWaitLock(p) {
     let pid = null;
     let at = null;
+    let token = null;
     let ageMs = 0;
     try {
         const st = fs.lstatSync(p);
@@ -1857,15 +1872,17 @@ function probeWaitLock(p) {
             pid = v.pid;
         if (typeof v.at === "string")
             at = v.at;
+        if (typeof v.token === "string")
+            token = v.token;
     }
     catch {
         /* pid 不明のまま鮮度判定に落ちる */
     }
     if (pid == null)
-        return { pid: null, at, live: ageMs < WAIT_LOCK_FRESH_MS };
+        return { pid: null, at, token, ageMs, live: ageMs < WAIT_LOCK_FRESH_MS };
     if (pid === process.pid)
-        return { pid, at, live: false };
-    return { pid, at, live: isPidAlive(pid) };
+        return { pid, at, token, ageMs, live: false };
+    return { pid, at, token, ageMs, live: isPidAlive(pid) };
 }
 function unlinkStaleWaitLock(p) {
     try {
@@ -1965,6 +1982,218 @@ function acquireSessionSendFileLock(name) {
         }
     };
 }
+// ── 同じagent sessionへの送信を1本ずつ通す（ADR 0088） ────
+// 振り分け（差し込みか新しいturnか）から送り終えるまでの間に、入力受付待ちなどの待ちが挟まる。
+// その間に次の1通が同じ状態を読むと、Claudeはturnの印の取り合いで後の1通が断られ、他のharnessは同じ入力欄へ2回貼る。
+// 同じprocessの中は着いた順の待ち行列、別のprocessの間はfileで排他し、後の1通は前の1通が終わってから振り分け直す。
+const agentSendQueues = new Map();
+const agentSendHeld = new Set();
+let agentSendLockWaitMs = AGENT_SEND_LOCK_WAIT_MS;
+export function __testSetAgentSendLockWaitMs(value) {
+    if (value !== null && (!Number.isSafeInteger(value) || value < 0))
+        throw new Error("wait must be a non-negative integer");
+    agentSendLockWaitMs = value ?? AGENT_SEND_LOCK_WAIT_MS;
+}
+// `O_EXCL`で作れた時だけ持ち主になる。既に在れば null。
+function tryCreateOwnedLock(p) {
+    const nofollow = fs.constants.O_NOFOLLOW ?? 0;
+    let fd;
+    try {
+        fd = fs.openSync(p, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | nofollow, 0o600);
+    }
+    catch (e) {
+        const code = e.code;
+        // Windowsは、消している途中のfile（他のprocessがまだ開いている）と同じ名前を作るとEPERM／EACCESになる。
+        if (code === "EEXIST" || (isWin && (code === "EPERM" || code === "EACCES")))
+            return null;
+        throw e;
+    }
+    const token = randomBytes(16).toString("hex");
+    try {
+        // 書けなかったlockは中身が読めないまま残り、鮮度猶予の後に持ち主なしとして片付く。
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, at: new Date().toISOString(), token }) + "\n", "utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return token;
+}
+function releaseOwnedLock(p, token) {
+    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 {
+        /* 別の持ち主のlockや置換済みpathは消さない */
+    }
+}
+// 同じprocessの送信は待ち行列で1本になっているので、自分のpidのlockは外し損ねた残骸と読める（probeWaitLock）。
+// このprocessが持っている最中のlockだけは、その読みから外す。
+function probeAgentSendLock(name) {
+    const probe = probeWaitLock(agentSendLockPath(name));
+    return probe.pid === process.pid && agentSendHeld.has(name) ? { ...probe, live: true } : probe;
+}
+// 持ち主のpidが生きて見えても、lockより後に始まったprocessなら、終了した持ち主のpidを使い回した別のprocessである。
+// 読みの粗さ（psの経過は1秒刻み）と小さな時計合わせで本人を別人と読まないよう、この秒数を越えて若い時だけ別人とする。
+const AGENT_SEND_LOCK_OWNER_SLACK_S = 5;
+function agentSendLockOwnerReplaced(probe) {
+    if (!probe.live || probe.pid == null || probe.pid === process.pid)
+        return false;
+    const created = probe.at === null ? Number.NaN : Date.parse(probe.at);
+    const lockAgeS = (Number.isFinite(created) ? Date.now() - created : probe.ageMs ?? 0) / 1000;
+    let elapsed;
+    try {
+        elapsed = processElapsedSeconds(probe.pid);
+    }
+    catch {
+        // 確かめられない時は、今まで通り生きていると読む（誤って片付けるより断る方に倒す）。
+        return false;
+    }
+    return elapsed === null || elapsed + AGENT_SEND_LOCK_OWNER_SLACK_S < lockAgeS;
+}
+// 片付け役が印を持つのは一瞬。持ち主が終了しているか、鮮度猶予より古い印は、片付けの途中で残った物と読む。
+// 古さでも読むのは、終了した片付け役のpidを別のprocessが使い回すと、pidだけでは生きて見えるため。
+function agentSendReapMarkStuck(guard) {
+    const probe = probeWaitLock(guard);
+    return !probe.live || (probe.ageMs ?? 0) >= WAIT_LOCK_FRESH_MS;
+}
+// 持ち主が終了したlockを片付ける。確かめてから消すまでの間に別のprocessが新しいlockを作ると生きたlockを消すので、
+// 消す役を`.reap`の`O_EXCL`で1つに絞り、その中でもう一度確かめてから消す。lockが在る間は誰も新しいlockを作れない。
+// replacedTokenは、持ち主が別人と確かめたlockの印。pidが生きて見えるので、確かめた時と同じlockの時だけ消す。
+// done=片付けた（または片付ける物が無かった）／busy=別のprocessが片付け中／stuck=片付けの印が残っている
+function reapDeadAgentSendLock(name, replacedToken = null) {
+    const guard = agentSendReapPath(name);
+    const token = tryCreateOwnedLock(guard);
+    if (token === null)
+        return agentSendReapMarkStuck(guard) ? "stuck" : "busy";
+    try {
+        const probe = probeAgentSendLock(name);
+        if (!probe.live || (replacedToken !== null && probe.token === replacedToken)) {
+            try {
+                fs.unlinkSync(agentSendLockPath(name));
+            }
+            catch {
+                /* 既に無い */
+            }
+        }
+    }
+    finally {
+        releaseOwnedLock(guard, token);
+    }
+    return "done";
+}
+// BellTeamのため: 先頭の「AGENT_SEND_BUSY: agent session '<名前>' は」と、文中の「文字列は送信していません。」で
+// 未送信の断りを見分けている（2026-10-05）。この2か所を変える時は、変える前に知らせる。
+function agentSendBusyError(name, pid, waitMs) {
+    return new AitermError(`AGENT_SEND_BUSY: agent session '${name}' は${pid != null ? `別プロセス（pid ${pid}）` : "先に受け付けた送信"}の処理中です。` +
+        `${waitMs}ms待っても順番が来ませんでした。文字列は送信していません。少し後で再度 pty_send してください。`, 2);
+}
+async function acquireAgentSendFileLock(name, deadline, waitMs) {
+    const p = agentSendLockPath(name);
+    let checkedOwner = null;
+    let checkedOwnerReplaced = false;
+    for (;;) {
+        let token;
+        try {
+            token = tryCreateOwnedLock(p);
+        }
+        catch (e) {
+            // socketの置き場が無ければ、守る相手のsessionにも届かない。lockを取らずに進め、送信側の今まで通りの断りを返す。
+            if (e.code === "ENOENT")
+                return () => { };
+            throw e;
+        }
+        if (token !== null)
+            return () => releaseOwnedLock(p, token);
+        const probe = probeAgentSendLock(name);
+        let dead = !probe.live;
+        let replacedToken = null;
+        // 生きて見える持ち主は、初めて見た時に1回、本人かを確かめる。結果は覚え、待つ間にOSへ照会し直さない。
+        if (!dead && probe.pid != null) {
+            const owner = `${probe.pid}@${probe.at}`;
+            if (owner !== checkedOwner) {
+                checkedOwner = owner;
+                checkedOwnerReplaced = agentSendLockOwnerReplaced(probe);
+            }
+            if (checkedOwnerReplaced) {
+                dead = true;
+                replacedToken = probe.token ?? null;
+            }
+        }
+        if (dead && reapDeadAgentSendLock(name, replacedToken) === "stuck") {
+            // BellTeamのため: 先頭の「agent session '<名前>' に、終了した送信のlockを片付ける途中で残った印があります。」と、
+            // 文中の「文字列は送信していません。」で見分け、pty_close→起動し直しへ回している（2026-10-05）。
+            // この文面と、pty_closeがこの印を片付ける事を変える時は、変える前に知らせる。
+            throw new AitermError(`agent session '${name}' に、終了した送信のlockを片付ける途中で残った印があります。` +
+                `自動回収は並行送信の混線を招くため行いません。文字列は送信していません。` +
+                `pty_listで対象を確認し、pty_closeでsessionを閉じてから同じIDで再作成してください`, 2);
+        }
+        if (performance.now() >= deadline)
+            throw agentSendBusyError(name, dead ? null : probe.pid, waitMs);
+        await sleep(AGENT_SEND_LOCK_POLL_MS);
+    }
+}
+async function withAgentSendLock(name, run) {
+    const waitMs = agentSendLockWaitMs;
+    const deadline = performance.now() + waitMs;
+    const previous = agentSendQueues.get(name) ?? Promise.resolve();
+    let leave;
+    const mine = new Promise((resolve) => {
+        leave = resolve;
+    });
+    // 待ち切れずに抜けた送信の後ろも、前の送信が終わるまで待つ。行列の控えは、ここまでの送信が全部終わってから消す。
+    const tail = previous.then(() => mine);
+    agentSendQueues.set(name, tail);
+    void tail.then(() => {
+        if (agentSendQueues.get(name) === tail)
+            agentSendQueues.delete(name);
+    });
+    let timer;
+    try {
+        const myTurn = await Promise.race([
+            previous.then(() => true),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), waitMs);
+            }),
+        ]);
+        clearTimeout(timer);
+        if (!myTurn)
+            throw agentSendBusyError(name, null, waitMs);
+        const release = await acquireAgentSendFileLock(name, deadline, waitMs);
+        agentSendHeld.add(name);
+        try {
+            return await run();
+        }
+        finally {
+            agentSendHeld.delete(name);
+            release();
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        leave();
+    }
+}
+// pty_closeの掃除。生きた持ち主のlockは残す（その送信はsessionが無くなった所で失敗し、自分のlockを外す）。
+// 持ち主が終了したlock、pidを使い回されて生きて見えるlock、残った片付けの印は片付ける。
+function cleanupAgentSendLock(name) {
+    const guard = agentSendReapPath(name);
+    try {
+        if (fs.existsSync(guard) && agentSendReapMarkStuck(guard))
+            fs.unlinkSync(guard);
+        if (!fs.existsSync(agentSendLockPath(name)))
+            return;
+        const probe = probeAgentSendLock(name);
+        reapDeadAgentSendLock(name, agentSendLockOwnerReplaced(probe) ? probe.token ?? null : null);
+    }
+    catch {
+        /* 掃除の失敗で閉じる処理を止めない */
+    }
+}
 // close/killAll 用: 生きた別プロセス待機の wait lock を列挙する（stale 残骸は数えない）。
 function liveWaitLocks(name) {
     const dir = existingAgentsDir();
@@ -3291,6 +3520,11 @@ async function prepareAgentInput(name, meta, options) {
 }
 export async function sendInitialAgentPrompt(name, text, o = {}) {
     assertSessionName(name);
+    loadAgentMetadata(name);
+    // 起動時promptの準備中に届いたpty_sendは、起動時promptを送り終えてから振り分ける（ADR 0088）。
+    return withAgentSendLock(name, () => sendInitialAgentPromptInLock(name, text, o));
+}
+async function sendInitialAgentPromptInLock(name, text, o) {
     const meta = loadAgentMetadata(name);
     if (meta.initial_prompt === "done") {
         throw new AitermError(`agent session '${name}' の起動時 prompt は既に完了しています`, 2);
@@ -3893,6 +4127,10 @@ async function assertCursorPromptNotHookBlocked(name) {
 }
 export async function dispatchAgentTurn(name, text, o = {}) {
     assertSessionName(name);
+    loadAgentMetadata(name);
+    return withAgentSendLock(name, () => dispatchAgentTurnInLock(name, text, o));
+}
+async function dispatchAgentTurnInLock(name, text, o) {
     const meta = loadAgentMetadata(name);
     const operationId = o.operation_id == null ? null : validateOperationId(o.operation_id);
     if (operationId && meta.kind !== "claude") {
@@ -4040,9 +4278,14 @@ export function __testSteerQueued(kind, screen) {
  * agent sessionへの唯一の送信口。呼び出し側は子の状態を知らないまま呼び、Aitermがこの時点の画面で振り分ける。
  * 実行中なら現在のturnへ差し込み（steer）、そうでなければ新しいturnとしてdispatchする。
  * 振り分けを呼び出し側へ任せると、状態を見てから呼ぶまでの間に子のturnが変わり、選んだ入口が外れる。
+ * 同じsessionへの送信は1本ずつ通し、重なった後の1通は前の1通が終わってから振り分け直す（ADR 0088）。
  */
 export async function sendAgentMessage(name, text, o = {}) {
     assertSessionName(name);
+    loadAgentMetadata(name);
+    return withAgentSendLock(name, () => sendAgentMessageInLock(name, text, o));
+}
+async function sendAgentMessageInLock(name, text, o) {
     const meta = loadAgentMetadata(name);
     // 前面回復は busy 判定より先（bash 前面のままだと画面の実行中マーカーを読んでも打鍵が届かない）。
     const paneInputRecovery = await ensureAgentOwnsPaneInput(name, meta.kind);
@@ -4062,7 +4305,7 @@ export async function sendAgentMessage(name, text, o = {}) {
     if (running) {
         return steerRunningTurn(name, meta, text, { raw: o.raw, pane_input_recovery: paneInputRecovery });
     }
-    return dispatchAgentTurn(name, text, { raw: o.raw, before_send: o.before_send, pane_input_recovery: paneInputRecovery });
+    return dispatchAgentTurnInLock(name, text, { raw: o.raw, before_send: o.before_send, pane_input_recovery: paneInputRecovery });
 }
 /**
  * 実行中turnへ追加の指示を渡す。各harnessの標準操作だけを使い、完了境界は1つに保つ。

package/dist/process-runtime.js

@@ -36,6 +36,7 @@ export function parsePosixProcessTable(text) {
 const POSIX_PS = "/bin/ps";
 const POSIX_TABLE_ARGS = ["-axww", "-o", "pid=,ppid=,pgid=,stat=,lstart=,time=,command="];
 const POSIX_IDENTITY_ARGS = ["-o", "pid=,lstart=", "-p"];
+const POSIX_ELAPSED_ARGS = ["-o", "etime=", "-p"];
 const WINDOWS_PROBE_HEADER = ["$ErrorActionPreference='Stop'", "[Console]::OutputEncoding=[Text.UTF8Encoding]::new($false)"];
 const WINDOWS_PROBE_ARGS = ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand"];
 // 先頭2行だけのbase64。3 byteの区切りで切り、後ろの行に左右されない前方一致にする。
@@ -47,7 +48,8 @@ const WINDOWS_PROBE_PREFIX = (() => {
 export function aitermProcessProbe(command) {
     if (command.includes(` ${WINDOWS_PROBE_ARGS.join(" ")} ${WINDOWS_PROBE_PREFIX}`))
         return true;
-    return command === `${POSIX_PS} ${POSIX_TABLE_ARGS.join(" ")}` || command.startsWith(`${POSIX_PS} ${POSIX_IDENTITY_ARGS.join(" ")} `);
+    return command === `${POSIX_PS} ${POSIX_TABLE_ARGS.join(" ")}` || command.startsWith(`${POSIX_PS} ${POSIX_IDENTITY_ARGS.join(" ")} `)
+        || command.startsWith(`${POSIX_PS} ${POSIX_ELAPSED_ARGS.join(" ")} `);
 }
 /** Windowsのconsole host。console processの起動に付いて立ち、最後のconsole processが終わると消える。 */
 export function windowsConsoleHost(row) {
@@ -157,6 +159,42 @@ export function readProcessIdentities(pids) {
         return { pid: row.pid, started_identity: new Date(row.started_identity).toISOString() };
     });
 }
+/** `ps -o etime=`の「[[日-]時:]分:秒」を秒にする。 */
+export function parsePosixElapsed(value) {
+    const match = /^(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)$/.exec(value.trim());
+    if (!match)
+        return null;
+    return Number(match[1] ?? 0) * 86400 + Number(match[2] ?? 0) * 3600 + Number(match[3]) * 60 + Number(match[4]);
+}
+/**
+ * processが始まってからの秒数。process表に無ければnull。OSへ照会できなかった時は例外にする。
+ * 開始時刻でなく経過で返す。POSIXのpsが出す開始時刻は、time zoneの設定と時計合わせで読みが変わる。
+ */
+export function processElapsedSeconds(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        throw new AitermError("process照会のpidが不正です", 2);
+    if (isWin) {
+        const row = readProcessIdentities([pid])[0];
+        if (!row)
+            return null;
+        if (row.started_identity === null)
+            throw new AitermError("processの開始時刻を取得できません", 2);
+        return Math.max(0, (Date.now() - Date.parse(row.started_identity)) / 1000);
+    }
+    const result = spawnSync(POSIX_PS, [...POSIX_ELAPSED_ARGS, String(pid)], {
+        encoding: "utf8", env: { ...process.env, LC_ALL: "C" }, timeout: 10000,
+    });
+    const text = (result.stdout ?? "").trim();
+    // 該当するprocessが無い時、psは何も出さずstatus 1で終わる。
+    if (result.error || (result.status !== 0 && !(result.status === 1 && !text)))
+        throw new AitermError("OSのprocess一覧を取得できません", 2);
+    if (!text)
+        return null;
+    const elapsed = parsePosixElapsed(text);
+    if (elapsed === null)
+        throw new AitermError("processの経過時間の形式を認識できません", 2);
+    return elapsed;
+}
 // Windowsの親PIDは親の終了後も残り、別processへ再利用される。子より後に始まったprocessは
 // 本当の親ではないので、親子関係として辿らない（辿ると循環や無関係なprocessの混入が起きる）。
 export function parentProcess(row, byPid) {

package/docs/DESIGN.md

@@ -95,6 +95,9 @@ agent sessionへの送信口は`pty_send`だけとする。子の状態は呼び
 実行中なら現在のturnへ追加textを差し込み、新しい完了境界と配送は作らない。完了境界は差し込み後も1つに保つ。
 Claude Codeはtool処理中に画面の実行中表示が消え、Stop hookの実行中には表示が残る。turnの印を実行中判定の正本とする。Stopが発火しないAPIエラー終了では、次の送信時に印の作成後の会話記録にある`isApiErrorMessage`を確認し、終了したturnの印だけを解除する。過去のエラーで新しい印を解除しない。waiterは印を変更せず、読取専用のままエラーを返す。
 それ以外は新しいturnとしてdispatchする。
+振り分けから送り終えるまでの間には、起動直後の入力受付待ちなどの待ちが挟まる。同じsessionへの送信（`pty_send`、`claude_turn issue`、起動時prompt）は1本ずつ通し、
+重なった後の1通は前の1通が終わってから振り分け直す。同じprocessの中は着いた順の待ち行列、別のprocessの間はsocketの置き場の`<name>.agent-send.lock`で排他する。
+待つ上限は、起動から最初の描画を待つ上限と貼り付けの上限の和で、越えたら`AGENT_SEND_BUSY`で未送信を返す。判断の記録はADR 0088（`docs/adr/0088-one-agent-send-per-session.md`）。
 CodexとClaude Codeは次のtool境界で同じturnへ取り込む。Cursorは「follow-ups」枠へ入った文を「enter steer」で現在turnへ移し、`turn_ended`は最後に1回書く。
 待ち行列の表示は5秒待ち、子のturnが続いている間だけ30秒まで延ばす（表示が遅い端末がある。turnが終わっていれば、文は新しいturnとして始まっている）。
 Grokは待ち行列へ入れた後に「send now」を押す。旧turnは`cancelled`（`cancellation_context.trigger=send_now`）で閉じ、
@@ -309,6 +312,10 @@ ADR 0074（repositoryの`docs/adr/0074-agent-model-catalog.md`）。
 境界失敗は明示errorにする。retry、別model、別harness、別backendへ自動fallbackしない。
 stale send lockは並行processとのABAを避けるため自動削除せず、公開APIでは対象sessionを`pty_close`して
 同じIDで再作成する。全session一括停止は公開しない。
+agent sessionへの送信1本を守る`<name>.agent-send.lock`は持つ時間が長いので、持ち主が終了した残骸を次の送信が片付ける。消す役を`<name>.agent-send.lock.reap`の排他作成で1つに絞り、
+その中でもう一度確かめてから消すので、確かめた後で別のlockに入れ替わらない。消す役の印そのものが残った時だけは自動で消さず、`pty_close`を案内する。
+終了した持ち主のpidを別のprocessが使い回すと、pidだけでは生きて見える。生きて見える持ち主は、processが始まってからの経過とlockを作ってからの時間を比べ、
+lockより後に始まったprocessなら別人と読んで片付ける。消す役の印は、5秒より古ければ残った物と読む。`pty_close`は、どちらも片付ける。
 
 Grokのread-only sandbox起動拒否は、`src/harnesses/grok.ts`の
 `assertGrokSandboxNotRejected`がCLIのエラー表示から検出する。`src/core.ts`の共通入力受付待機は

package/package.json

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