aiterm-mcp 0.48.0 → 0.50.0

package/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+### 追加
+
+- `pty_observe`に、agent sessionを閉じると失うものを数える2項目を足した（ADR 0080）。`activity.post_startup_process_count`は、起動準備が完了した時点に居なかったprocessの数（裏で動かしている作業。起動直後の1分に始めたものも数える）。`pending_child_deliveries`は、そのsessionが親として待っている、まだ届け終えていない子の結果の数。数えられない時はnullで、0と区別する。
+
+### 修正
+
+- 会話が長いClaude Codeのsessionが、入力待ちでも`pty_observe`で`unknown / unrecognized_screen`と出ていた。起動時の見出し「Claude Code」が画面の取得範囲から流れ出ると読めなかった。見出しが無い時は入力欄の形で読む。
+- `aiterm-setup`（`aiterm-update`の中でも走る）と`--remove-cursor-parent-hooks`が、gpt-connectorのCursor hookを`~/.cursor/hooks.json`から消していた。自分のhookを名前の部分一致で探し、`cursor-parent-hook.js`が`gpt-connector-cursor-parent-hook.js`にも当たっていた。file名の境目まで見る（aiterm-steer-delivery 0.1.10）。
+- `aiterm-setup`が、Claude Codeの`settings.json`を中身が同じでも書き換えることがあった。他の道具が後からhookを足していると、Aitermのentryを末尾へ移していた。同じ中身で登録済みなら並びを保つ（aiterm-steer-delivery 0.1.10）。
+- `pty_send`が「TUI が入力受付状態になりません」で断る時、その時の画面の読み（`state=… reason=…`）を文の末尾へ付ける。承認や確認のmodalの時は待たずに断るが、どの画面だったかが残らなかった。
+- BugHubへの報告で、`observed_at`を秒へ切り捨てていた。記録の時刻はミリ秒まで持つので、エラーを記録した直後（同じ秒の中）の自動送信は、受け口に「記録が観測より後」として断られる作りだった（記録は失われず、次の送信の機会まで届くのが遅れる）。切り捨てず、載せる記録のどの時刻よりも前にしない。
+- 実行中のCursor・Grokへ文を差し込む時、待ち行列の表示が5秒より遅い端末で`STEER_NOT_QUEUED`になっていた（Windowsの実機で、送ってから表示まで8〜9秒）。文は待ち行列に入っていて、今のturnの後に別のturnとして動いていた。子のturnが続いている間は、表示を30秒まで待つ。
+
 ## [0.48.0] - 2026-10-03
 
 ### 追加
@@ -1994,7 +2028,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.48.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.50.0...HEAD
+[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
 [0.47.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.46.1...v0.47.0

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.48.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.50.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の環境で決まる（v0.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も維持する。
 
@@ -510,6 +516,12 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 `background_cpu_delta_complete`はpane開始から60秒以降に生成された子孫だけの同じ観測で、起動時MCPを除外する。
 `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が親として待っていて、まだ届け終えていない
+子の結果の数。呼び出した側が誰でも付く。どちらも、分からない時はnull（通常PTY、harnessのprocessを特定できない時。
+processの数は0.48.0以前が起動したagentも）。別端末が旧版の時は項目ごと無い。nullと項目なしは「分からない」で、0ではない。
+
 `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.48.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.50.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 v0.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.
 
@@ -542,6 +548,13 @@ between observations, the delta covers only observed increments and `cpu_delta_c
 only to descendants created at least 60 seconds after the pane, excluding startup MCP processes. `token_hint` is the latest
 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`
+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.
+
 `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.
@@ -777,10 +790,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 v0.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

@@ -15,13 +15,14 @@ import { fileURLToPath } from "node:url";
 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 { 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";
-import { codexAuthPlan, codexAuthStatus, codexAuthPane, bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexRateLimitModelSwitchDialog, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, codexModelChoices, } from "./harnesses/codex.js";
+import { codexAuthPlan, codexAuthStatus, codexAuthPane, bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexHelperProcess, codexRateLimitModelSwitchDialog, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, codexModelChoices, } from "./harnesses/codex.js";
 import { claudeAuthPlan, claudeAuthStatus, claudeAuthPane, OPERATION_ID_RE, CLAUDE_RESULT_MAX_BYTES, CLAUDE_EFFORTS, agentManagedClaudeSettingsPath, agentClaudeResultPath, agentClaudeOperationPath, agentClaudeApprovalReceiptPath, agentClaudeDispatchReceiptPath, validateOperationId, readClaudeResultText, assertClaudeAuthenticationReady, claudeModelChoices, buildClaudeAgentCmd, claudeLaunchNote, claudeTuiReady, claudePaneObservation, claudeUsageLimit, claudeStartupAction, claudeLoginMethodMenu, CLAUDE_COMPOSER_MARKER_RE, createClaudeAgentMetadata, claudeSessionTranscriptPath, claudeApiErrorFromLine, claudeApiErrorAfter, } from "./harnesses/claude.js";
 import { cursorAuthPlan, cursorAuthStatus, cursorAuthPane, bindCursorTranscriptSession, cursorTurnBoundary, latestCursorCompletion, observeCursorDone, cursorTranscriptText, assertCursorAuthenticationReady, assertCursorModelAvailable, cursorModelChoices, buildCursorAgentCmd, cursorAgentArgv, cursorPwshLaunchLine, cursorPromptWithLineage, createCursorAgentMetadata, cursorLaunchNote, cursorEffortNavigation, cursorTuiReady, cursorPaneObservation, cursorPromptHooksRunning, cursorUsageLimit, CURSOR_SUBMIT_SEQUENCE, CURSOR_COMPOSER_CONTENT_MARKER_RE, validateCursorModelEffort, } from "./harnesses/cursor.js";
 import { readInterimWords, recordInterimBoundary } from "./interim-words.js";
@@ -671,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) {
@@ -1085,9 +1085,10 @@ export function observeSession(name, cursor) {
         schema: "aiterm.pty-observe-result.v1", session_id: name, observed_at: new Date().toISOString(),
         exists: !!listed, harness: null, launch_id: null, state: "missing", reason: "session_missing",
         pane_alive: false, harness_alive: null, pane_process: null, harness_process: null, process_identity: null,
-        token_hint: null,
+        token_hint: null, pending_child_deliveries: null,
         activity: { cursor: null, output_changed: null, cpu_seconds: null, cpu_delta_seconds: null, cpu_delta_complete: null,
-            background_cpu_seconds: null, background_cpu_delta_seconds: null, background_cpu_delta_complete: null },
+            background_cpu_seconds: null, background_cpu_delta_seconds: null, background_cpu_delta_complete: null,
+            post_startup_process_count: null },
     };
     if (!listed)
         return result;
@@ -1164,6 +1165,10 @@ export function observeSession(name, cursor) {
         screen_digest: createHash("sha256").update(screen).digest("hex"), processes, background_processes: backgroundCpu,
     };
     const comparable = previous?.pane_identity === sample.pane_identity;
+    // 起動完了の控えが無いsession（通常PTY、控える前の版で起動したagent）とharnessを特定できない時は数えない。
+    const startup = agent && Array.isArray(meta?.startup_processes) ? new Set(meta.startup_processes) : null;
+    // このsessionが親として待っている子の結果。持ち主はharnessの下で動くAitermのMCP process。
+    result.pending_child_deliveries = agent ? unfinishedDeliveriesOwnedBy(activityRows) : null;
     result.activity = {
         cursor: Buffer.from(JSON.stringify(sample)).toString("base64url"),
         output_changed: comparable ? previous.screen_digest !== sample.screen_digest : null,
@@ -1173,6 +1178,9 @@ 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,
     };
     return result;
 }
@@ -1190,7 +1198,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);
@@ -1989,6 +2003,8 @@ function loadAgentMetadata(name) {
         initial_prompt_delivery: m.initial_prompt_delivery, initial_prompt_cursor: m.initial_prompt_cursor,
     };
     const executableFields = m.agent_executable === undefined ? {} : { agent_executable: m.agent_executable };
+    const startupFields = Array.isArray(m.startup_processes) && m.startup_processes.every((identity) => typeof identity === "string")
+        ? { startup_processes: m.startup_processes } : {};
     if (m.kind === "claude") {
         const expectedSettings = agentManagedClaudeSettingsPath(name, m.launch_id);
         const expectedResult = agentClaudeResultPath(name, m.launch_id);
@@ -2016,6 +2032,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             launch_operation_id: launchOperationId,
             launch_request_digest: launchRequestDigest,
             hook_route: "shared_claude_settings",
@@ -2047,6 +2064,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             hook_route: "shared_codex_home",
             completion_route: "codex_transcript",
             ...loadAgentLineageFields(m, true),
@@ -2074,6 +2092,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             hook_route: "shared_cursor_home",
             completion_route: "cursor_transcript",
             ...loadAgentLineageFields(m, true),
@@ -2109,6 +2128,7 @@ function loadAgentMetadata(name) {
         initial_prompt: normalizeInitialPromptState(m.initial_prompt),
         ...deliveryFields,
         ...executableFields,
+        ...startupFields,
         hook_route: "shared_grok_home",
         completion_route: "grok_transcript",
         ...loadAgentLineageFields(m, true),
@@ -3202,6 +3222,11 @@ async function prepareAgentInput(name, meta, options) {
     const live = observeSession(name);
     if (live.harness_alive !== true || live.harness_process === null || live.state !== "idle")
         return { status: "blocked", reason: live.reason };
+    // ここまでに居るprocessは起動時の足場（harness・MCP・起動時hook）。初手を送る前に控える。
+    if (live.activity.cursor !== null) {
+        meta.startup_processes = Object.keys(decodeActivityCursor(live.activity.cursor, name).processes);
+        writeAgentMetadata(meta);
+    }
     return { status: "ready", reason: "composer_ready" };
 }
 export async function sendInitialAgentPrompt(name, text, o = {}) {
@@ -3849,8 +3874,13 @@ export async function dispatchAgentTurn(name, text, o = {}) {
                 const reason = grokPaneObservation(ready.lastScreen).reason;
                 throw new AitermError(`GROK_RATE_LIMIT_RECOVERY_FAILED: ${reason}。上限パネル解除後の入力受付を確認できません。今回の文字列は送信していません。`, 2);
             }
+            // 待たずに断るのは、応答が要る既知の画面（承認・確認のmodal）の時。どの画面で断ったかを残す。
+            const state = meta.kind === "grok" ? grokPaneObservation(ready.lastScreen)
+                : meta.kind === "codex" ? codexPaneObservation(ready.lastScreen)
+                    : meta.kind === "claude" ? claudePaneObservation(ready.lastScreen) : cursorPaneObservation(ready.lastScreen);
             throw new AitermError(`agent session '${name}' の ${agentLabel(meta.kind)} TUI が入力受付状態になりません。文字列は送信していません。` +
-                "少し後で pty_read(screen:true) を確認し、TUI が起動済みなら再度 pty_send してください。", 2);
+                "少し後で pty_read(screen:true) を確認し、TUI が起動済みなら再度 pty_send してください。" +
+                `\nstate=${state.state} reason=${state.reason}`, 2);
         }
     }
     if (codexRateLimitModelSwitch)
@@ -3928,10 +3958,17 @@ const CURSOR_FOLLOW_UP_STEER_RE = /enter steer · /;
 const cursorSteerQueued = (screen) => CURSOR_FOLLOW_UP_STEER_RE.test(screen.split("\n").filter(line => line.trim()).slice(-30).join("\n"));
 const STEER_SCREEN_POLL_MS = 100;
 const STEER_SCREEN_MAX_SAMPLES = 50;
-async function waitSteerScreen(name, predicate) {
-    for (let i = 0; i < STEER_SCREEN_MAX_SAMPLES; i++) {
+// 待ち行列の表示が遅い端末がある（fox 2026-10-03: Cursorへ送ってから表示まで8〜9秒。5秒で打ち切って3回とも失敗した）。
+// 子のturnが続いている間は、文は待ち行列へ入るしかないので、ここまで待つ。
+const STEER_SCREEN_RUNNING_MAX_SAMPLES = 300;
+const STEER_RUNNING_CHECK_SAMPLES = 10;
+async function waitSteerScreen(name, predicate, stillRunning) {
+    for (let i = 0; i < STEER_SCREEN_RUNNING_MAX_SAMPLES; i++) {
         if (predicate(captureScreen(name, AGENT_TUI_READY_LINES)))
             return true;
+        // 短い待ちを過ぎたら、子のturnが続いている間だけ待ちを延ばす。終わっていれば、これ以上待っても表示は変わらない。
+        if (i >= STEER_SCREEN_MAX_SAMPLES && i % STEER_RUNNING_CHECK_SAMPLES === 0 && !stillRunning())
+            return false;
         await sleep(STEER_SCREEN_POLL_MS);
     }
     return false;
@@ -4012,13 +4049,17 @@ async function steerRunningTurn(name, meta, text, o) {
         : meta.kind === "cursor" ? cursorSteerQueued : null;
     if (queued) {
         const label = meta.kind === "cursor" ? "Cursor" : "Grok";
-        if (!await waitSteerScreen(name, queued)) {
+        // Cursorはturn_endedを記録へ書いた後も画面にbusy表示を残すので、記録で見る。Grokは画面で見る。
+        const stillRunning = () => meta.kind === "cursor"
+            ? latestCursorCompletion(meta, readTranscriptLines) === null
+            : isAgentTuiBusy(meta.kind, captureScreen(name, AGENT_TUI_READY_LINES));
+        if (!await waitSteerScreen(name, queued, stillRunning)) {
             throw new AitermError(`STEER_NOT_QUEUED vendor=${meta.kind} session=${name}\n` +
                 `差し込む文が${label}の待ち行列へ入ったことを確認できません。子のturnが送る直前に終わっていた時は、` +
                 `文は新しいturnとして始まっており、その完了は通知されません。再送する前にpty_read(screen:true)で確かめてください。`, 2);
         }
         sendKey(name, "Enter");
-        if (!await waitSteerScreen(name, screen => !queued(screen))) {
+        if (!await waitSteerScreen(name, screen => !queued(screen), stillRunning)) {
             throw new AitermError(`STEER_STILL_QUEUED vendor=${meta.kind} session=${name}\n` +
                 `差し込む文が${label}の待ち行列に残っています。現在のturnが終わると別turnとして実行されます。`, 2);
         }

package/dist/harnesses/claude.js

@@ -258,8 +258,18 @@ export function claudeLaunchNote(model, effort, meta) {
     const writeScopeNote = writeScopeLaunchNote("claude", meta?.write_scope);
     return `起動設定: model=${model ?? "CLI既定"} effort=${effort ?? "CLI既定"}。${writeScopeNote}`;
 }
+// 会話が長くなると、起動時の見出し「Claude Code」は取得範囲から流れ出る。入力欄は❯行のすぐ上と下を罫線で挟む形で、
+// 起動時の確認画面や通常shellの❯とは見分けられる。見出しが無い時はこの形でClaude CodeのTUIと判断する。
+function claudeComposerBox(screen) {
+    const lines = screen.split(/\r?\n/u);
+    const rule = /^\s*─{8,}\s*$/u;
+    let marker = lines.length - 1;
+    while (marker >= 0 && !/^\s*❯/u.test(lines[marker]))
+        marker--;
+    return marker > 0 && rule.test(lines[marker - 1]) && lines.slice(marker + 1).some(line => rule.test(line));
+}
 export function claudeTuiReady(screen) {
-    if (!screen.includes("Claude Code"))
+    if (!screen.includes("Claude Code") && !claudeComposerBox(screen))
         return false;
     if (claudeLoginMethodMenu(screen))
         return false;

package/dist/harnesses/codex.js

@@ -427,6 +427,12 @@ function currentCodexDialog(screen) {
     const heading = [...current.matchAll(CODEX_DIALOG_HEADING)].at(-1);
     return heading ? current.slice(heading.index) : current;
 }
+// Codexは道具を初めて使う時に補助process（code-mode-host）を立て、sessionの終わりまで残す。
+// harnessの一部であって利用者の作業ではない。この下で動くprocessは作業として数える。
+export function codexHelperProcess(command) {
+    const first = /^(?:"([^"]+)"|(\S+))/.exec(command);
+    return path.posix.basename((first?.[1] ?? first?.[2] ?? "").replace(/\\/g, "/")).replace(/\.exe$/i, "") === "codex-code-mode-host";
+}
 export function codexPaneObservation(screen) {
     const failure = codexStartupFailure(screen);
     if (failure)

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 {
@@ -597,10 +597,12 @@ registerRemoteAwareTool("pty_observe", {
         pane_process: nativeProcessIdentitySchema.nullable(), harness_process: nativeProcessIdentitySchema.nullable(),
         process_identity: nativeProcessIdentitySchema.nullable(),
         token_hint: z.number().nullable(),
+        pending_child_deliveries: z.number().nullable().optional(),
         parent_deliveries: z.array(parentDeliveryOutputSchema).optional(),
         activity: z.object({ cursor: z.string().nullable(), output_changed: z.boolean().nullable(),
             cpu_seconds: z.number().nullable(), cpu_delta_seconds: z.number().nullable(), cpu_delta_complete: z.boolean().nullable(),
-            background_cpu_seconds: z.number().nullable(), background_cpu_delta_seconds: z.number().nullable(), background_cpu_delta_complete: z.boolean().nullable() }),
+            background_cpu_seconds: z.number().nullable(), background_cpu_delta_seconds: z.number().nullable(), background_cpu_delta_complete: z.boolean().nullable(),
+            post_startup_process_count: z.number().nullable().optional() }),
     },
 }, async ({ session_id, cursor }, extra) => {
     try {

package/dist/parent-delivery-owners.js

@@ -0,0 +1,42 @@
+// 親配送の記録を、持ち主（登録したMCP process）から数える。
+// parent-delivery.tsはcoreに依存するので、coreのpty_observeが使う分だけをここへ分ける。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { ensureStateRoot } from "./agent-shared.js";
+const DELIVERY_DIRECTORIES = ["parent-deliveries", "claude-parent-deliveries", "cursor-parent-deliveries"];
+/** 持ち主の保存場所の名前の先頭。pidの使い回しと取り違えないよう、開始時刻も入れる。 */
+export function deliveryOwnerPrefix(owner) {
+    return `${owner.pid}-${createHash("sha256").update(owner.started_identity).digest("hex").slice(0, 16)}-`;
+}
+/** 渡したprocessのどれかが持ち主で、まだ親へ届け終えていない配送の数。届け終えた記録はactiveから出ている。 */
+export function unfinishedDeliveriesOwnedBy(processes, stateRoot = ensureStateRoot()) {
+    const prefixes = processes.map(deliveryOwnerPrefix);
+    let count = 0;
+    for (const prefix of ["", "remote-"]) {
+        for (const directory of DELIVERY_DIRECTORIES) {
+            const active = path.join(stateRoot, prefix + directory, "active");
+            let owners;
+            try {
+                owners = fs.readdirSync(active, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            for (const owner of owners) {
+                if (!owner.isDirectory() || !prefixes.some(candidate => owner.name.startsWith(candidate)))
+                    continue;
+                try {
+                    count += fs.readdirSync(path.join(active, owner.name)).filter(name => name !== "owner.json" && name.endsWith(".json")).length;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+        }
+    }
+    return count;
+}

package/dist/parent-delivery.js

@@ -1,10 +1,11 @@
 // Aitermが所有する、子の完了観測・回答本文の保存・親への配送。
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID, createHash } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { ensureStateRoot, writeJson0600 } from "./agent-shared.js";
 import { readProcessIdentities } from "./process-runtime.js";
+import { deliveryOwnerPrefix } from "./parent-delivery-owners.js";
 import { CodexDeliveryError, submitCodexParentAnswer, verifyCodexParent } from "./codex-parent-receiver.js";
 import { claudeParentSchema, ClaudeDeliveryError, bindClaudeParentDelivery, submitClaudeParentAnswer, verifyClaudeParent } from "./claude-parent-receiver.js";
 import { cursorParentSchema, CursorDeliveryError, prepareCursorDelivery, submitCursorParentAnswer, verifyCursorParent } from "./cursor-parent-receiver.js";
@@ -141,8 +142,7 @@ export class ParentDeliveryManager {
         if (!ownProcess)
             throw new AitermError("PARENT_DELIVERY_OWNER_UNKNOWN: 配送processを識別できません", 2);
         this.owner = { pid: process.pid, started_identity: ownProcess.started_identity, closed: false };
-        const identity = createHash("sha256").update(ownProcess.started_identity).digest("hex").slice(0, 16);
-        this.ownerDir = path.join(this.active, `${process.pid}-${identity}-${randomUUID()}`);
+        this.ownerDir = path.join(this.active, `${deliveryOwnerPrefix(this.owner)}${randomUUID()}`);
         fs.mkdirSync(this.ownerDir, { recursive: true, mode: 0o700 });
         fs.mkdirSync(this.results, { recursive: true, mode: 0o700 });
         fs.mkdirSync(this.claims, { recursive: true, mode: 0o700 });

package/dist/runtime-error-report.js

@@ -178,11 +178,14 @@ export async function reportRuntimeErrors(options) {
             return result("halted");
         }
         // tsとobserved_atは同じ時刻から作る（受け口は両者が10分より離れたreportを断る）。
+        // observed_atは秒へ切り捨てず、載せる記録のどの時刻よりも前にしない。受け口は、記録や解決が観測より後のreportを
+        // 422で断る。記録の時刻はミリ秒まで持つので、切り捨てると、記録の直後（同じ秒の中）の自動送信が断られていた。
         const ts = String(Math.floor(started.getTime() / 1000));
+        const observed = Math.max(started.getTime(), ...snapshot.records.flatMap((record) => [Date.parse(record.last_seen), record.resolved_at === null ? 0 : Date.parse(record.resolved_at)]));
         const reportId = randomUUID();
         const report = buildRuntimeErrorReport(snapshot.records, {
             installedVersion: options.installedVersion ?? pkg.version, reportId,
-            observedAt: new Date(Number(ts) * 1000).toISOString(),
+            observedAt: new Date(observed).toISOString(),
         });
         const body = Buffer.from(JSON.stringify(report), "utf8");
         if (body.byteLength > MAX_REPORT_BYTES)

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,11 +41,20 @@ 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も含めた祖先関係から一つの起動として扱う。
 祖先を共有しない候補は別々に残し、複数候補を一つと推測しない。
 POSIXの停止状態はOSのprocess表から取得し、SIGSTOP中は残画面より優先して`blocked/harness_stopped`を返す。
+sessionを閉じると失うものは数で返す（ADR 0080）。`activity.post_startup_process_count`は起動完了の時点に居なかったprocessの数、
+`pending_child_deliveries`はそのsessionが親として待つ未配送の数。数えられない時はnullで、0と区別する。
+Claude Codeの入力待ちは、起動時の見出しが取得範囲から流れ出た後も、入力欄の形（`❯`行の上下の罫線）で読む。
 画面本文とargv本文は返さず、活動cursorには画面digestとprocess別CPUだけを持たせる。
 初回とpane再作成後の差分はnull。区間中にprocessが消えた時は観測できたCPU増分だけを返し、
 `cpu_delta_complete=false`を付ける。background活動はpane開始から60秒以降に生成された子孫だけを数える。
@@ -73,6 +82,7 @@ agent sessionへの送信口は`pty_send`だけとする。子の状態は呼び
 Claude Codeはtool処理中に画面の実行中表示が消え、Stop hookの実行中には表示が残る。turnの印を実行中判定の正本とする。Stopが発火しないAPIエラー終了では、次の送信時に印の作成後の会話記録にある`isApiErrorMessage`を確認し、終了したturnの印だけを解除する。過去のエラーで新しい印を解除しない。waiterは印を変更せず、読取専用のままエラーを返す。
 それ以外は新しいturnとしてdispatchする。
 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`）で閉じ、
 新turnが作業を継ぐので、完了判定はこの継ぎ目を完了と数えない。Grokが待ち行列へ入れない時とCursorの入力欄に本文が残る時は`steered`を返さない。
 Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼び出し側は通常のdispatchだけを使う。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.48.0",
+  "version": "0.50.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": [
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "aiterm-steer-delivery": "^0.1.8",
+    "aiterm-steer-delivery": "^0.1.10",
     "ws": "8.21.3",
     "zod": "^4.4.3"
   },