aiterm-mcp 0.49.0 → 0.51.0

package/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.51.0] - 2026-10-04
+
+### 追加
+
+- `aiterm-delivery-wake --parent <codex|claude|cursor>`。MCPの本体を使う時だけ起こす中継（`mcp-lazy`）の後ろで、眠っている本体を
+  親配送の引き取りのために起こすべきかを返す（ADR 0082）。終了した持ち主がその種類の親の配送を持ったままならexit 0、
+  無ければexit 1。何も出力せず、子processを起こさない。同じ判定を回す席のうち1席だけが起こす。
+  中継には先行起動の判定として渡す（`MCP_LAZY_WAKE_COMMAND`）。
+
+### 変更
+
+- `pty_observe`の`activity.post_startup_process_count`で、中継`mcp-lazy`の直接の子を数えない（ADR 0082）。
+  中継は道具を初めて呼ばれた時に本体を自分の下に起こすので、中継ごしの席は道具を一度使うと数が0へ戻らなかった。
+  見分けるのは、親の起動時のargvの先頭のbasenameが`mcp-lazy`で始まること。その下で動くprocessは今までどおり数える。
+
+### 修正
+
+- Cursor親の受け取りprocess（`cursor-parent-receive`）が、親のCursorが終わった後も残り、後から完了した子の回答を引き取っていた
+  （aiterm-steer-delivery 0.1.12）。Cursorの背景shellは親から切り離されて動くので、席を閉じても最長24時間残る。
+  引き取られた回答は`submitted`になるが、読む相手は居ない。受け取りprocessは、出力の読み手が居なくなったら引き取らずに終わる。
+  その配送は`sending`のまま残り、24時間で`CURSOR_PARENT_DELIVERY_UNCLAIMED`になる。本文は今までどおり記録に残る。
+
+## [0.50.0] - 2026-10-04
+
+### 変更
+
+- 新しい端末の環境を、その端末を開いたMCP processの環境にした（ADR 0081。POSIXのtmux。Windowsのpsmuxは元からこの動き）。
+  今までは、tmuxのserverを最初に起こした呼び出し元の環境が、後から開く全部の端末へ入っていた。別の呼び出し元の
+  `PATH`や`npm_config_prefix`、その呼び出し元だけが持つ変数が、名指ししていなくても端末に入る。
+  - harnessがMCP processへ渡す環境が少なければ、端末の環境もその分だけになる。Codexは既定で`HOME`・`PATH`・`SHELL`・`TERM`の
+    4つしか渡さない。要る変数は`~/.codex/config.toml`の`[mcp_servers.aiterm]`に`env_vars`で名前を並べる。
+  - `AITERM_SESSION_ID`・`AITERM_AGENT_*`・`TMUX`・`TMUX_PANE`は継がない（今までどおり、端末ごとに付く）。
+  - `env_vars`は今までどおり使える。`pty_list`の`env_keys`で読めるのは、`env_vars`で名指しした値と`AITERM_SESSION_ID`だけ。
+  - 同じtmuxのserverを、前の版のMCP processと並んで使える。前の版が開く端末は今までどおり動く。
+
+### 修正
+
+- 利用者の`~/.tmux.conf`を読んでいた。空のconfigを指す`-f`を`new-session`の引数として渡していて、tmux本体には届いていなかった。
+  READMEの「`-f /dev/null`で起動し、`~/.tmux.conf`を読まない」のとおりにした。
+- tmux 3.2未満で端末を1つも開けなかった（`new-session -f`を知らず「unknown option」で落ちる）。3.1cで開けることを確かめた。
+
 ## [0.49.0] - 2026-10-03
 
 ### 追加
@@ -2009,7 +2050,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.49.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.0...HEAD
+[0.51.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.50.0...v0.51.0
+[0.50.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.49.0...v0.50.0
 [0.49.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.48.0...v0.49.0
 [0.48.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.47.1...v0.48.0
 [0.47.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.47.0...v0.47.1

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.49.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.51.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -299,10 +299,15 @@ $ aiterm-wait --session codex1 --cursor <event_cursor>   # exit 0=done / 3=timeo
 
 Cursorの`model`は`gpt-5.6-luna`のようなbase model、`reasoning_effort`は`high`のように別指定する。adapterは現行`model-effort` IDを`cursor-agent models`へ照合し、起動中変更はCursor標準model pickerのparameter editorを使う。不在時は別modelへfallbackしない。
 
+新しい端末の環境は、その端末を開いたMCP processの環境で決まる（0.50.0から。ADR 0081）。tmuxのserverを
+先に起こした別の呼び出し元の値は入らない。Aitermが端末ごとに付け直す`AITERM_SESSION_ID`・`AITERM_AGENT_*`は
+継がない。harnessがMCP processへ渡す環境が少なければ、端末の環境もその分だけになる（Codexは既定で
+`HOME`・`PATH`・`SHELL`・`TERM`。要る変数は`[mcp_servers.aiterm]`の`env_vars`で渡す）。
+
 `env_vars`は環境変数の**名前**だけを並べるallowlistであり、name/value mapではない。aitermは
 launcher起動時に現在のMCP processから各名前を読み、存在する値をshell quoteして、その1回のvendor
 起動コマンドへ入れる。未設定名は省略し、shell変数名として不正な名前はsession作成前に失敗する。
-全環境の暗黙copy、backend server再起動、retry、fallbackは行わない。値はMCP tool引数には入らないが、
+名指しした値だけが`pty_list`の`env_keys`で読める。値はMCP tool引数には入らないが、
 PTYの起動コマンドとして送られ、sessionの`.lastcmd`にも保持されるため、起動先vendorと同じOS userへ
 到達する。秘密転送路ではなく、席identityやworkflow用の非secret変数だけに使う。
 
@@ -492,8 +497,9 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 ### セッション観測と起動準備
 
 `pty_open`の既定shellはPOSIXでbash、WindowsでPowerShell 7。通常PTYとagentの内側では
-`AITERM_SESSION_ID`で自分のsessionを識別できる。`env_vars`はMCP processから継承する名前の配列で、
-`pty_list({ env_keys: ["JOB_OWNER"] })`は指定した非秘密キーだけを`environment`へ返す。未設定値はnull。
+`AITERM_SESSION_ID`で自分のsessionを識別できる。端末は開いたMCP processの環境を継ぐ。`env_vars`は、そのうち
+sessionへ登録する名前の配列で、`pty_list({ env_keys: ["JOB_OWNER"] })`は登録した非秘密キーだけを`environment`へ返す。
+登録していない値と未設定値はnull。
 一覧の`aiterm.pty-list-result.v1`は`observed_at`と`sessions`を持ち、各行に`session_id`、`current_command`、
 `attached`、`width`、`height`、`harness`、`environment`を返す。従来のtextも維持する。
 
@@ -511,11 +517,20 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 `token_hint`は画面の直近token表示値またはnull。画面本文や生argvを解析する必要はない。
 
 agent sessionを閉じると失うものは、次の2項目で分かる。`activity.post_startup_process_count`は、`agent_launch`の起動準備が
-完了した時点（初手を送る前）に居なかったprocessの数。起動直後の1分に始めた裏の作業も数える。Codex自身の補助process
-（`codex-code-mode-host`）は数えない。`pending_child_deliveries`は、そのsessionが親として待っていて、まだ届け終えていない
+完了した時点（初手を送る前）に居なかったprocessの数。起動直後の1分に始めた裏の作業も数える。数えないものは2つ。Codex自身の
+補助process（`codex-code-mode-host`）と、中継`mcp-lazy`の直接の子（初めて使う時に起こすMCPの本体と、先行起動の判定）。
+その下で動くprocessは数える。`pending_child_deliveries`は、そのsessionが親として待っていて、まだ届け終えていない
 子の結果の数。呼び出した側が誰でも付く。どちらも、分からない時はnull（通常PTY、harnessのprocessを特定できない時。
 processの数は0.48.0以前が起動したagentも）。別端末が旧版の時は項目ごと無い。nullと項目なしは「分からない」で、0ではない。
 
+MCPの本体を初めて使う時まで起こさない中継の後ろにAitermを登録すると、眠っている本体は、終了した持ち主の配送を引き取れない。
+`aiterm-delivery-wake --parent <codex|claude|cursor>`は、起こす必要があるかを返す。その種類の親の配送を、終了した持ち主が
+持ったままならexit 0、そうでなければexit 1、引数の誤りはexit 2。何も出力せず、子processを起こさない。同じ判定を回す席のうち
+1席だけが起こすよう、配送に印を付ける（引き取られないまま30秒過ぎたら、次の判定が印を取り直す）。`mcp-lazy`には、本体と同じ環境で
+先行起動の判定として渡す。
+`MCP_LAZY_WAKE_COMMAND='["/absolute/path/to/node","/absolute/path/to/aiterm-mcp/dist/delivery-wake-cli.js","--parent","claude"]'`
+持ち主の開始時刻はLinuxでは`/proc`で照合する。それ以外のOSでは、pidがあれば生きている持ち主として扱う。
+
 `agent_launch({ harness, cwd, trust_project: true })`はpromptなしでも既知のworkspace・project hooks・MCP初期同意を
 進め、入力受付とharness生存を確認して`startup.status="ready"`を返す。指定なしのpromptなし起動は`not_checked`。
 Claude Code初回起動の文字表示テーマ選択では、画面で選択済みの項目を確定して起動を続ける。

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.49.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.51.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -321,11 +321,17 @@ The canonical harness choices are:
 | `grok-cli` | Grok Build CLI | Grok model selected with `model`; live catalog check |
 | `cursor-cli` | Cursor Agent CLI | GPT, Claude, Grok, or another Cursor catalog model; normal transcript completion |
 
+A new terminal gets the environment of the MCP process that opened it (since 0.50.0, ADR 0081).
+Values from another caller that happened to start the tmux server first no longer appear in it.
+`AITERM_SESSION_ID` and `AITERM_AGENT_*` are not inherited; aiterm sets them per terminal. If a harness
+passes only a few variables to its MCP process, the terminal has only those (Codex passes `HOME`, `PATH`,
+`SHELL`, and `TERM` by default; forward more with `env_vars` under `[mcp_servers.aiterm]`).
+
 `env_vars` is an allowlist of environment-variable **names**, not a name/value map. At launch,
 aiterm reads each valid name from its current MCP process, shell-quotes present values, and places
 them on that one harness launch command. Missing names are omitted; invalid shell variable names
-fail before session creation. There is no implicit whole-environment copy, backend-server restart,
-retry, or fallback. Values do not enter the MCP tool arguments, but they are delivered through the
+fail before session creation. Only the named values can be read back with `env_keys` in `pty_list`.
+Values do not enter the MCP tool arguments, but they are delivered through the
 PTY launch command and retained in aiterm's per-session `.lastcmd`; the launched harness and other
 processes with access to the same OS user may read them. Use this for non-secret seat identity and
 workflow variables, not as a secret transport.
@@ -523,8 +529,8 @@ On top of that sits a productized layer a raw tmux bridge doesn't have: **token-
 ### Session observation and startup
 
 `pty_open` defaults to bash on POSIX and PowerShell 7 on Windows. Ordinary terminals and agents receive
-`AITERM_SESSION_ID`. Pass environment-variable names in `env_vars` to inherit ownership information from the MCP process.
-`pty_list({ env_keys: ["JOB_OWNER"] })` returns only the requested non-secret values in `environment`; missing values are null.
+`AITERM_SESSION_ID`. A terminal inherits the environment of the MCP process that opened it. Pass names in `env_vars` to register them on the session.
+`pty_list({ env_keys: ["JOB_OWNER"] })` returns only registered non-secret values in `environment`; unregistered and missing values are null.
 Its `aiterm.pty-list-result.v1` receipt contains `observed_at` and `sessions`, whose entries include `session_id`,
 `current_command`, `attached`, `width`, `height`, `harness`, and `environment`. Existing text remains available.
 
@@ -544,11 +550,22 @@ displayed token count or null. Callers do not need raw argv or pane-text parsing
 
 Two fields tell a caller what closing an agent session would lose. `activity.post_startup_process_count` is the number of
 processes in the session that did not exist when `agent_launch` finished startup (before the first prompt), so background work
-started in the first minute is counted too; Codex's own `codex-code-mode-host` helper is not counted. `pending_child_deliveries`
+started in the first minute is counted too. Two kinds of process are not counted: Codex's own `codex-code-mode-host` helper, and
+the direct children of an `mcp-lazy` relay (the MCP server it starts on first use and its wake predicate). What runs below them
+is counted. `pending_child_deliveries`
 is the number of sub-agent results this session is still waiting for as a parent, whoever the caller is. Both are null when
 Aiterm cannot tell (ordinary terminals, agents launched by 0.48.0 or earlier for the process count, or an unresolved harness
 process), and may be absent when a remote host runs an older Aiterm. Treat null or absent as unknown, not as zero.
 
+When Aiterm is registered behind a relay that starts the MCP server only on first use, a sleeping server cannot take over the
+deliveries of an owner that has exited. `aiterm-delivery-wake --parent <codex|claude|cursor>` answers whether one needs to start:
+exit 0 when an exited owner still holds a delivery for that parent kind, exit 1 otherwise, exit 2 for bad arguments. It prints
+nothing, starts no child process, and marks the delivery so that only one of the seats running the same check starts its server
+(the mark is retaken after 30 seconds if nobody took the delivery over). For `mcp-lazy`, pass it as the wake predicate with the
+same environment as the server:
+`MCP_LAZY_WAKE_COMMAND='["/absolute/path/to/node","/absolute/path/to/aiterm-mcp/dist/delivery-wake-cli.js","--parent","claude"]'`.
+Owner start times are checked through `/proc` on Linux; elsewhere an existing PID is treated as a live owner.
+
 `agent_launch({ harness, cwd, trust_project: true })` completes known workspace, project-hook, and project-MCP startup
 consent even without a prompt, then verifies input readiness and harness liveness before returning `startup.status="ready"`.
 For Claude Code's first-run text-style menu, it confirms the item already selected on screen before continuing startup.
@@ -784,10 +801,9 @@ symlink, filter, or replace harness configuration, authentication, MCP, plugin,
 trust, memory, or history stores. Cleanup removes only aiterm-owned launch metadata and completion
 correlation files.
 
-The ordinary environment still comes from the persistent shell session. When a caller needs a value that
-belongs to the current MCP process rather than the older persistent multiplexer server, every harness
-accepts `env_vars: ["NAME", ...]`. Only those names are refreshed at launch; this is a narrow
-per-launch overlay, not a replacement environment or configuration snapshot.
+The ordinary environment comes from the MCP process that opened the terminal, not from whichever caller
+started the persistent multiplexer server (since 0.50.0). Every harness still accepts
+`env_vars: ["NAME", ...]`; those names are placed on the launch command and registered on the session.
 
 ## License
 

package/dist/core.js

@@ -16,9 +16,9 @@ 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 } from "./process-runtime.js";
+import { readRuntimeProcesses, processSubtree, parentProcess, processIdentity, backgroundProcesses, lazyRelayProcess } from "./process-runtime.js";
 import { AitermError, telemetryOwnedFailure, ownTelemetryFailure } from "./errors.js";
-import { isWin, SOCKDIR, tmuxCommand, sendPsmuxPayload, loadPtyBufferChunk, pasteBufferBaseArgs, TMUX_EMPTY_CONFIG, attachCommand, normalizePaneCommand, atomicShellMultiline, appendMarkSentinel, markShellCommand, settlePaneLog, paneCwdArgument, sessionEnvironmentLaunch, } from "./tmux-runtime.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_EVENT_MAX_BYTES, assertSessionName, agentsDir, agentEventPath, agentMetadataPath, writeAgentMetadata, AGENT_EVENT_TAIL_BYTES, agentLabel, agentHarness, subagentInstruction, agentLineageFields, } from "./agent-shared.js";
 import { catalogUnavailable } from "./model-catalog.js";
 import { grokAuthPlan, grokAuthStatus, grokAuthPane, realGrokHome, resolveAndValidateGrokAuth, assertGrokModelAvailable, grokModelChoices, grokEventsTranscript, latestGrokCompletion, observeGrokDone, buildGrokAgentCmd, grokLaunchNote, grokEnvTokens, grokTuiReady, grokTuiBusy, grokPaneObservation, grokRateLimitDialog, grokStartupAction, grokLaunchBlockingDialog, assertGrokSandboxNotRejected, GROK_COMPOSER_MARKER_RE, grokFooterHasConfiguration, grokTranscriptText, createGrokAgentMetadata, } from "./harnesses/grok.js";
@@ -672,11 +672,10 @@ export function openSession(name, shell = "bash", envVars = []) {
                 throw new AitermError(`session '${nm}' は既に存在します（list で確認）`, 2);
         }
         else {
-            // -f は端末個人の設定ファイルを読まないための空 config。
             const environment = [...banner, ...envVars.filter(key => key !== "AITERM_SESSION_ID" && process.env[key] !== undefined)
                     .map(key => `${key}=${process.env[key]}`), `AITERM_SESSION_ID=${nm}`];
             const launch = sessionEnvironmentLaunch(shell, environment);
-            const r = tmux("new-session", "-d", "-s", nm, ...launch.args, "-f", TMUX_EMPTY_CONFIG, launch.shell);
+            const r = tmuxNewSession(true, nm, launch, environment.map(entry => entry.slice(0, entry.indexOf("="))));
             if (r.code === 0) {
                 if (launch.register_after_start)
                     for (const entry of environment) {
@@ -1078,6 +1077,18 @@ export function selectHarnessProcesses(meta, rows, subtree) {
     });
     return roots;
 }
+// 起動完了の控えに無いprocessの数。harnessと中継が自分のために立てるprocessは、利用者の作業ではないので数えない。
+// その下で動くprocessは数える。
+export function postStartupProcessCount(kind, activityRows, rows, startup) {
+    const byPid = new Map(rows.map(row => [row.pid, row]));
+    const relayChild = (row) => {
+        const parent = parentProcess(row, byPid);
+        return parent !== undefined && lazyRelayProcess(parent.command);
+    };
+    return new Set(activityRows
+        .filter(row => !(kind === "codex" && codexHelperProcess(row.command)) && !relayChild(row))
+        .map(row => `${row.pid}:${row.started_identity}`).filter(identity => !startup.has(identity))).size;
+}
 export function observeSession(name, cursor) {
     assertSessionName(name);
     const previous = cursor === undefined ? null : decodeActivityCursor(cursor, name);
@@ -1179,9 +1190,7 @@ export function observeSession(name, cursor) {
         background_cpu_seconds: Object.values(backgroundCpu).reduce((sum, cpu) => sum + cpu, 0),
         background_cpu_delta_seconds: comparable ? Object.entries(backgroundCpu).reduce((sum, [identity, cpu]) => sum + cpu - (previous.background_processes[identity] ?? 0), 0) : null,
         background_cpu_delta_complete: comparable ? Object.keys(previous.background_processes).every(identity => identity in backgroundCpu) : null,
-        post_startup_process_count: startup ? new Set(activityRows
-            .filter(row => !(meta?.kind === "codex" && codexHelperProcess(row.command)))
-            .map(row => `${row.pid}:${row.started_identity}`).filter(identity => !startup.has(identity))).size : null,
+        post_startup_process_count: startup ? postStartupProcessCount(meta.kind, activityRows, rows, startup) : null,
     };
     return result;
 }
@@ -1199,7 +1208,13 @@ export function listSessionsResult(envKeys = []) {
             const [name, command, attached, width, height] = line.split("\t");
             assertSessionName(name);
             const environment = {};
+            const registered = envKeys.length ? registeredSessionEnvironment(name) : null;
             for (const key of envKeys) {
+                // sessionの表には開いたprocessの環境も入っている。返すのは名指しで登録した値だけ。
+                if (registered && !registered.includes(key)) {
+                    environment[key] = null;
+                    continue;
+                }
                 const value = tmux("show-environment", "-t", name, key);
                 if (value.code !== 0 && !/unknown variable|not found|not set/i.test(value.stderr))
                     throw new AitermError("session環境変数を照会できません", 2);

package/dist/delivery-wake-cli.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+// aiterm-delivery-wake — 眠っているAitermのMCP本体を、親配送の引き取りのために起こすべきかを返す。
+// MCPを使う時だけ起こす中継（mcp-lazy）の先行起動の判定に渡す。本体が眠っている間は、終了した持ち主の配送を
+// 引き取る者が居ない（引き取りは起きている本体が5秒おきに行う）。
+// exit 0=起こす / 1=眠ったままでよい / 2=引数の誤り。stdoutへは何も出さない。
+// 中継の下で動くので、子processを起こさない（起こすと席のprocess数に入る）。node builtinとstate-rootだけに依存する。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { currentUid, runtimeStateBase } from "./state-root.js";
+const DIRECTORY = {
+    codex: "parent-deliveries", claude: "claude-parent-deliveries", cursor: "cursor-parent-deliveries",
+};
+// 起こす役を引き受けた印の寿命。起こした本体は起動してすぐ引き取る。引き取られないまま過ぎたら、次の判定が引き受け直す。
+const CLAIM_TTL_MS = 30_000;
+const USAGE = "usage: aiterm-delivery-wake --parent <codex|claude|cursor>";
+function processExists(pid) {
+    if (pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+// psのlstartと同じ値を/procから作る（起動時刻＋開始tick。LinuxのUSER_HZは100）。/procの無いOSはnull。
+function linuxStartedAt(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const ticks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
+        const boot = Number(/^btime (\d+)$/m.exec(fs.readFileSync("/proc/stat", "utf8"))?.[1]);
+        return Number.isFinite(ticks) && Number.isFinite(boot) ? (boot + Math.floor(ticks / 100)) * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+const DEFAULTS = { exists: processExists, started_at: linuxStartedAt, now: () => Date.now() };
+function ownerGone(owner, deps) {
+    const value = owner;
+    if (!value || !Number.isSafeInteger(value.pid) || typeof value.started_identity !== "string" || typeof value.closed !== "boolean")
+        return false;
+    if (value.closed)
+        return true;
+    const pid = value.pid;
+    if (!deps.exists(pid))
+        return true;
+    // 同じpidが別のprocessへ再利用されていないかを、開始時刻で見る。照合できない時は生きている扱い（本体が起きた時に照合する）。
+    const recorded = Date.parse(value.started_identity);
+    const actual = deps.started_at(pid);
+    return Number.isFinite(recorded) && actual !== null && Math.abs(actual - recorded) > 2_000;
+}
+/**
+ * 終了した持ち主の下に、引き取られていない配送の記録があれば、起こす役を引き受けてtrueを返す。
+ * 同じ種類の席は全部が同じ判定を回す。印を先に作れた1席だけが起こす。
+ */
+export function shouldWakeForDeliveries(stateRoot, parent, dependencies = {}) {
+    const deps = { ...DEFAULTS, ...dependencies };
+    let wake = false;
+    for (const prefix of ["", "remote-"]) {
+        const root = path.join(stateRoot, prefix + DIRECTORY[parent]);
+        const active = path.join(root, "active");
+        const claims = path.join(root, "wake-claims");
+        let owners;
+        try {
+            owners = fs.readdirSync(active, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const orphaned = new Set();
+        for (const directory of owners) {
+            if (!directory.isDirectory())
+                continue;
+            const ownerDir = path.join(active, directory.name);
+            let owner;
+            let records;
+            try {
+                owner = JSON.parse(fs.readFileSync(path.join(ownerDir, "owner.json"), "utf8"));
+                records = fs.readdirSync(ownerDir).filter(name => name !== "owner.json" && name.endsWith(".json"));
+            }
+            catch {
+                continue;
+            }
+            if (records.length > 0 && ownerGone(owner, deps))
+                orphaned.add(directory.name);
+        }
+        // 引き取りが済んだ持ち主の印を片付ける。
+        try {
+            for (const name of fs.readdirSync(claims))
+                if (!orphaned.has(name))
+                    fs.rmSync(path.join(claims, name), { recursive: true, force: true });
+        }
+        catch { /* 印の置き場がまだ無い */ }
+        for (const name of orphaned) {
+            const claim = path.join(claims, name);
+            try {
+                fs.mkdirSync(claims, { recursive: true, mode: 0o700 });
+                fs.mkdirSync(claim, { mode: 0o700 });
+                wake = true;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const now = deps.now();
+                if (now - fs.statSync(claim).mtimeMs < CLAIM_TTL_MS)
+                    continue;
+                fs.utimesSync(claim, now / 1000, now / 1000);
+                wake = true;
+            }
+        }
+    }
+    return wake;
+}
+function main(argv) {
+    if (argv.length !== 2 || argv[0] !== "--parent" || !(argv[1] in DIRECTORY)) {
+        process.stderr.write(`${USAGE}\n`);
+        return 2;
+    }
+    return shouldWakeForDeliveries(path.join(runtimeStateBase(), `aiterm-mcp-${currentUid()}`), argv[1]) ? 0 : 1;
+}
+function invokedDirectly() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    try {
+        process.exitCode = main(process.argv.slice(2));
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-delivery-wake: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 3;
+    }
+}

package/dist/index.js

@@ -253,7 +253,7 @@ registerRemoteAwareTool("pty_open", {
     inputSchema: {
         name: z.string().nullish().describe("セッション名（省略時は t1, t2... を自動採番）"),
         shell: z.string().default(DEFAULT_PTY_SHELL).describe(`起動シェル（既定 ${DEFAULT_PTY_SHELL}）`),
-        env_vars: z.array(z.string()).optional().describe("現在のMCP processからsessionへ継承する環境変数名"),
+        env_vars: z.array(z.string()).optional().describe("sessionへ登録する環境変数名（値は現在のMCP processから読む。pty_listのenv_keysで読める）。端末の環境は、名指ししなくても現在のMCP processの環境を継ぐ"),
     },
 }, async ({ name, shell, env_vars }) => {
     try {

package/dist/process-runtime.js

@@ -1,6 +1,7 @@
 // OSのprocess表とnative PIDの所有者。argvは相関にだけ使い、公開identityにはdigestだけを載せる。
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
+import path from "node:path";
 import { AitermError } from "./errors.js";
 import { isWin } from "./tmux-runtime.js";
 import { resolveWindowsPowerShell7 } from "./windows-powershell.js";
@@ -153,6 +154,12 @@ export function processSubtree(rows, rootPid) {
     }
     return rows.filter(row => selected.has(row.pid));
 }
+// 中継（mcp-lazy）は、登録されたMCPの本体と先行起動の判定を、自分の直接の子として起こす。
+// 見分けるのは起動した実行ファイルの名前（argvの先頭のbasenameが`mcp-lazy`で始まる）。取り決めはmcp-lazyのREADMEにある。
+export function lazyRelayProcess(command) {
+    const first = /^(?:"([^"]+)"|(\S+))/.exec(command);
+    return path.posix.basename((first?.[1] ?? first?.[2] ?? "").replace(/\\/g, "/")).toLowerCase().startsWith("mcp-lazy");
+}
 export function backgroundProcesses(rows, root) {
     // 起動時の足場processを除く既存契約。pane開始から60秒以上後に生成された子孫だけを集計する。
     const rootStart = Date.parse(root.started_identity);

package/dist/tmux-runtime.js

@@ -118,11 +118,16 @@ export function tmuxSpawnEnv() {
     return env;
 }
 export function tmuxCommandWithInput(observe, input, ...args) {
+    return runTmux(observe, input, args);
+}
+// session は、新しい session を作る呼び出しの時だけ渡す client の環境（POSIX のみ）。server を起こし得るのは
+// この呼び出しだけなので、空 config の指定と macOS の gui domain での起動もここに限る。
+function runTmux(observe, input, args, session) {
     // maxBuffer は既定 1MiB。capture-pane（大きなスクロールバック）や多セッションの list-sessions で
     // 頭打ちになり stdout が切れる/空になる。Python の subprocess.run は無制限だったので 64MiB へ広げる。
     // Windows は tmux CLI 互換の native psmux を -L namespace 隔離で叩く（WSL 非依存）。
     let r;
-    const spawnOpts = { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, input, env: tmuxSpawnEnv() };
+    const spawnOpts = { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, input, env: session ?? tmuxSpawnEnv() };
     if (isWin) {
         ensureWinPsmux(observe);
         r = spawnSync(psmuxBin(), ["-L", WIN_NS, ...args], spawnOpts);
@@ -130,8 +135,10 @@ export function tmuxCommandWithInput(observe, input, ...args) {
     else {
         // resolveTmux() は tmux を解決できなければ明確な AitermError を投げる（POSIX 版の事前確認）。
         const bin = resolveTmux(observe);
-        r = (args[0] === "new-session" && macGuiServerWanted(bin) && startTmuxInMacGui(bin, args, spawnOpts.env ?? process.env))
-            || spawnSync(bin, ["-S", SOCK, ...args], spawnOpts);
+        // -f は tmux 本体の引数で、server を起こす時にだけ読まれる（new-session の -f は別物で、config を指さない）。
+        const argv = session ? ["-f", TMUX_EMPTY_CONFIG, "-S", SOCK, ...args] : ["-S", SOCK, ...args];
+        r = (session && macGuiServerWanted(bin) && startTmuxInMacGui(bin, argv, session))
+            || spawnSync(bin, argv, spawnOpts);
     }
     // ENOBUFS（出力が 64MiB 超）を「code=1 の失敗」へ握り潰すと部分/空 stdout を正常扱いしてしまう。区別して投げる。
     // EXPECTED-FAILURE: 外部システム境界（tmux 出力過大）
@@ -191,8 +198,8 @@ export function macGuiTmuxPlist(label, dir, argv, env, cwd) {
         "",
     ].join("\n");
 }
-function startTmuxInMacGui(bin, args, env) {
-    return runInMacGui([bin, "-S", SOCK, ...args], env, process.cwd(), 30_000, "launchd経由のtmux起動が30秒以内に終わりませんでした");
+function startTmuxInMacGui(bin, argv, env) {
+    return runInMacGui([bin, ...argv], env, process.cwd(), 30_000, "launchd経由のtmux起動が30秒以内に終わりませんでした");
 }
 // 起動前の認証確認（`claude auth status`・`agent status` 等）も keychain を読むので、tmux server と同じく
 // Aqua の外では gui domain で実行する。gui domain が無ければ null を返し、呼び出し側が直接実行する。
@@ -306,21 +313,99 @@ export function pasteBufferBaseArgs() {
 }
 // new-session -f 用の空 config（端末個人の設定ファイルを読まない）。Windows は NUL デバイス。
 export const TMUX_EMPTY_CONFIG = isWin ? "NUL" : "/dev/null";
+// tmux 3.2 で new-session -e と、update-environment のワイルドカードが入った。
+function tmuxHasSessionEnvironmentFlags(version) {
+    const observed = version ?? spawnSync(resolveTmux(), ["-V"], { encoding: "utf8", timeout: 5000 }).stdout;
+    const match = /^tmux (\d+)\.(\d+)/.exec(observed ?? "");
+    if (!match)
+        throw new AitermError("tmuxの環境変数機能を判定できません", 2);
+    return Number(match[1]) > 3 || (Number(match[1]) === 3 && Number(match[2]) >= 2);
+}
 export function sessionEnvironmentLaunch(shell, environment, version) {
-    let modern = isWin;
-    if (!isWin) {
-        const observed = version ?? spawnSync(resolveTmux(), ["-V"], { encoding: "utf8", timeout: 5000 }).stdout;
-        const match = /^tmux (\d+)\.(\d+)/.exec(observed ?? "");
-        if (!match)
-            throw new AitermError("tmuxの環境変数機能を判定できません", 2);
-        modern = Number(match[1]) > 3 || (Number(match[1]) === 3 && Number(match[2]) >= 2);
-    }
+    const modern = isWin || tmuxHasSessionEnvironmentFlags(version);
     if (modern)
         return { shell, args: environment.flatMap(entry => ["-e", entry]), register_after_start: false };
     // tmux <3.2はnew-session -eを持たない。子への継承とsession台帳への登録を製品内で完結する。
     const quote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
     return { shell: `exec /usr/bin/env ${environment.map(quote).join(" ")} ${quote(shell)}`, args: [], register_after_start: true };
 }
+// Aiterm が端末ごとに付け直す名札と、呼んだ側の pane を指す値。新しい端末へは継がせない。
+const SESSION_OWN_ENV = /^(?:AITERM_SESSION_ID|AITERM_AGENT_[A-Z0-9_]+|TMUX|TMUX_PANE)$/;
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function sessionCallerEnvironment(base = tmuxSpawnEnv() ?? process.env) {
+    const env = {};
+    for (const [key, value] of Object.entries(base)) {
+        if (value !== undefined && !SESSION_OWN_ENV.test(key))
+            env[key] = value;
+    }
+    return env;
+}
+// update-environment へ渡す並び。3.2 以上は "*" で client の環境を丸ごと写す。それより前は名前を並べる。
+// client に無い名前は、その session で「消す」印になる。
+export function updateEnvironmentPatterns(caller, others, wildcard) {
+    const names = caller.filter(key => ENV_NAME.test(key));
+    const known = new Set(names);
+    const rest = [...new Set(others)].filter(key => ENV_NAME.test(key) && !known.has(key));
+    return wildcard ? ["*", ...rest] : [...names, ...rest];
+}
+// `NAME=value` と、消す印の `-NAME` から名前を取り出す。server が無ければ null。
+function tmuxEnvironmentNames(...scope) {
+    const r = runTmux(false, undefined, ["show-environment", ...scope]);
+    if (r.code !== 0)
+        return null;
+    return r.stdout.split("\n").map(line => line.replace(/^-/, "").split("=", 1)[0]).filter(key => ENV_NAME.test(key));
+}
+// session の表には開いた process の環境が丸ごと入る。名指しで登録した名前は、session の option に控える。
+const REGISTERED_ENV_OPTION = "@aiterm_env_keys";
+// 控えが無ければ null（Windows と、この仕組みより前の版が開いた session）。
+export function registeredSessionEnvironment(name) {
+    if (isWin)
+        return null;
+    const r = runTmux(false, undefined, ["show-options", "-t", `=${name}:`, "-v", REGISTERED_ENV_OPTION]);
+    return r.code === 0 && r.stdout.trim() ? r.stdout.trim().split(" ") : null;
+}
+// tmux は、server を起こした client の環境を共通環境として全 session へ配る。何もしないと、最初に端末を
+// 開いた呼び出し元の値が、後から別の呼び出し元が開く端末へ入る。新しい端末の環境を「開いた process の環境」に
+// するため、new-session の間だけ update-environment を差し替えて client の環境を session へ写し、共通環境に
+// しか無い変数は session で消す（psmux は元から端末ごとに呼び出し元の環境を継ぐ）。共通環境そのものは
+// 変えない。同じ server を使う旧版の process が、開く端末の環境をそこから受け取っている。
+export function tmuxNewSession(observe, name, launch, registered = []) {
+    if (isWin) {
+        return runTmux(observe, undefined, ["new-session", "-d", "-s", name, ...launch.args, "-f", TMUX_EMPTY_CONFIG, launch.shell]);
+    }
+    const env = sessionCallerEnvironment();
+    const wildcard = tmuxHasSessionEnvironmentFlags();
+    // tmux は起動時に PWD を共通環境へ足す。
+    const others = new Set(["PWD"]);
+    for (let attempt = 0;; attempt++) {
+        for (const key of tmuxEnvironmentNames("-g") ?? [])
+            others.add(key);
+        const r = runTmux(observe, undefined, [
+            "set-option", "-g", "update-environment", updateEnvironmentPatterns(Object.keys(env), [...others], wildcard).join(" "), ";",
+            "new-session", "-d", "-s", name, ...launch.args, launch.shell, ";",
+            "set-option", "-t", `=${name}:`, REGISTERED_ENV_OPTION, registered.join(" "), ";",
+            "set-option", "-gu", "update-environment",
+        ], env);
+        if (r.code !== 0) {
+            // 途中の命令が失敗すると、後続の命令は実行されない。差し替えた設定を戻す。
+            runTmux(false, undefined, ["set-option", "-gu", "update-environment"]);
+            return r;
+        }
+        // 共通環境の名前が、どれも session 側で上書きか消去になっていることを確かめる。別の呼び出し元が同時に
+        // server を起こした時は、消す対象を取り違えている。
+        const shared = tmuxEnvironmentNames("-g");
+        const own = new Set(tmuxEnvironmentNames("-t", `=${name}`) ?? []);
+        const uncovered = shared?.filter(key => !own.has(key));
+        if (uncovered?.length === 0)
+            return r;
+        runTmux(false, undefined, ["kill-session", "-t", `=${name}`]);
+        if (!uncovered || attempt >= 2) {
+            return { code: 1, stdout: "", stderr: "共通環境の変数をsessionから外せなかったため、sessionを破棄しました" };
+        }
+        for (const key of uncovered)
+            others.add(key);
+    }
+}
 // 人が同じ session を覗く/介入するための attach コマンド。
 // Windows は native psmux（tmux CLI 互換）を -L namespace で叩く。
 export function attachCommand(name) {

package/docs/DESIGN.md

@@ -41,6 +41,12 @@ sentinelの方言は端末runtimeが実効shellから決める。SSH先の現在
 psmuxが出力した余分な環境値を返さない。通常PTYとagentへ`AITERM_SESSION_ID`を注入し、
 `env_vars`の継承とsessionへの登録もAitermが所有する。古いtmuxは子へのenv注入とsession登録を使う。
 
+新しい端末の環境は、その端末を開いたprocessの環境にする（ADR 0081）。tmuxはserverを起こしたclientの環境を
+全sessionへ配るので、`new-session`の間だけ`update-environment`を差し替えてclientの環境をsessionへ写し、
+共通環境にしか無い変数はsessionで消す。`AITERM_SESSION_ID`・`AITERM_AGENT_*`・`TMUX`・`TMUX_PANE`は継がない。
+sessionの表には環境が丸ごと入るので、名指しで登録した名前をsessionのoption `@aiterm_env_keys`に控え、
+`env_keys`はその名前だけを返す。psmuxは元から端末ごとに呼び出し元の環境を継ぐ。
+
 `pty_observe`は存在、pane／harnessの生存、画面状態と理由、native process identityを分ける。
 PIDは開始識別子・argv digestと組にし、paneとharnessを同一視しない。特定できないidentityはnull。
 同じlaunchに属するnpm shimとnative本体は、中間の非候補processも含めた祖先関係から一つの起動として扱う。
@@ -48,6 +54,8 @@ PIDは開始識別子・argv digestと組にし、paneとharnessを同一視し
 POSIXの停止状態はOSのprocess表から取得し、SIGSTOP中は残画面より優先して`blocked/harness_stopped`を返す。
 sessionを閉じると失うものは数で返す（ADR 0080）。`activity.post_startup_process_count`は起動完了の時点に居なかったprocessの数、
 `pending_child_deliveries`はそのsessionが親として待つ未配送の数。数えられない時はnullで、0と区別する。
+harnessと中継が自分のために立てるprocessは数えない（Codexの`codex-code-mode-host`、中継`mcp-lazy`の直接の子。ADR 0082）。その下は数える。
+中継の後ろで眠っている本体を配送の引き取りのために起こすかは、`aiterm-delivery-wake`が返す（ADR 0082）。
 Claude Codeの入力待ちは、起動時の見出しが取得範囲から流れ出た後も、入力欄の形（`❯`行の上下の罫線）で読む。
 画面本文とargv本文は返さず、活動cursorには画面digestとprocess別CPUだけを持たせる。
 初回とpane再作成後の差分はnull。区間中にprocessが消えた時は観測できたCPU増分だけを返し、

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "mcpName": "io.github.kitepon/aiterm-mcp",
   "description": "Persistent terminal MCP with one harness-based launcher for Claude Code, Codex CLI, Grok CLI, and Cursor Agent CLI, plus durable PTYs for SSH, containers, and REPLs.",
   "keywords": [
@@ -43,6 +43,7 @@
     "aiterm-setup": "dist/setup-cli.js",
     "aiterm-runtime-errors": "dist/runtime-errors-cli.js",
     "aiterm-wait": "dist/aiterm-wait-cli.js",
+    "aiterm-delivery-wake": "dist/delivery-wake-cli.js",
     "aiterm-update": "dist/update-cli.js"
   },
   "files": [
@@ -70,7 +71,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "aiterm-steer-delivery": "^0.1.10",
+    "aiterm-steer-delivery": "^0.1.12",
     "ws": "8.21.3",
     "zod": "^4.4.3"
   },