aiterm-mcp 0.50.0 → 0.51.1

package/CHANGELOG.md

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.51.1] - 2026-10-04
+
+### 修正
+
+- `pty_observe`の`activity.post_startup_process_count`で、harnessが立て直した起動時のprocessを数えない（ADR 0083）。
+  Cursorは起動時にstdioのMCPを立て、最初のつなぎが済むと止めて立て直す。つながるのが遅いMCPがあると、立て直しが
+  起動完了の後になり、何もしていない席で数が残っていた（実物で、直結3・中継ごし4）。起動時のprocessが終了していて、
+  同じ親の下に同じargvで立っているprocessは、その立て直しとして扱う。その下で動くprocessは今までどおり数える。
+  この版より前のAitermが起動したagentは、今までどおり数える。
+
+## [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
 
 ### 変更
@@ -2028,7 +2060,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.50.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.1...HEAD
+[0.51.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.51.0...v0.51.1
+[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

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.50.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.51.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -299,7 +299,7 @@ $ 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を
+新しい端末の環境は、その端末を開いた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`で渡す）。
@@ -517,11 +517,21 @@ sessionへ登録する名前の配列で、`pty_list({ env_keys: ["JOB_OWNER"] }
 `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は数える。harnessが立て直した起動時のprocess（終了した起動時のprocessと同じ親の下に、同じargvで立ったもの。
+つなぎ直したMCPなど）も数えない。`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.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).
+**Status:** actively maintained · current public release **v0.51.1** · 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,7 +321,7 @@ 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).
+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`,
@@ -550,11 +550,23 @@ 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. A startup process that the harness restarted (a process with the same parent and the same arguments as a startup
+process that has exited, such as a reconnected MCP server) is not counted either. `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.
@@ -791,7 +803,7 @@ trust, memory, or history stores. Cleanup removes only aiterm-owned launch metad
 correlation files.
 
 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
+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,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 } 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, 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";
@@ -1077,6 +1077,54 @@ export function selectHarnessProcesses(meta, rows, subtree) {
     });
     return roots;
 }
+const processKey = (row) => `${row.pid}:${row.started_identity}`;
+/** 起動完了の控えに入れたprocessの、親とargvのdigest。控えた後に終了したprocessは入らない。 */
+export function startupProcessShapes(identities, rows) {
+    const byPid = new Map(rows.map(row => [row.pid, row]));
+    const byKey = new Map(rows.map(row => [processKey(row), row]));
+    return identities.flatMap(identity => {
+        const row = byKey.get(identity);
+        if (!row)
+            return [];
+        const parent = parentProcess(row, byPid);
+        return [{ identity, parent: parent ? processKey(parent) : null, argv_digest: row.argv_digest }];
+    });
+}
+// 起動完了の控えに無いprocessの数。harnessと中継が自分のために立てるprocessは、利用者の作業ではないので数えない。
+// その下で動くprocessは数える。
+// harnessは起動の足場（MCP、language server）を自分で立て直す。控えた後に立て直されると、控えに無いprocessとして残る。
+// 控えの物が終了していて、同じ親の下に同じargvで立ったprocessは、その立て直しとして数えない。
+// 親も立て直されている時は、立て直された親の下を見る。終了した控え1つにつき、数えないのは1つまで。
+export function postStartupProcessCount(kind, activityRows, rows, startup, shapes = []) {
+    const byPid = new Map(rows.map(row => [row.pid, row]));
+    const relayChild = (row) => {
+        const parent = parentProcess(row, byPid);
+        return parent !== undefined && lazyRelayProcess(parent.command);
+    };
+    const present = new Set(activityRows.map(processKey));
+    const added = new Map(activityRows
+        .filter(row => !startup.has(processKey(row)) && !(kind === "codex" && codexHelperProcess(row.command)) && !relayChild(row))
+        .map(row => [processKey(row), row]));
+    const gone = shapes.filter(shape => startup.has(shape.identity) && !present.has(shape.identity));
+    const replacedBy = new Map();
+    for (let changed = gone.length > 0; changed;) {
+        changed = false;
+        for (const [key, row] of added) {
+            const parent = parentProcess(row, byPid);
+            if (!parent)
+                continue;
+            const parentKey = processKey(parent);
+            const original = gone.find(shape => !replacedBy.has(shape.identity) && shape.argv_digest === row.argv_digest
+                && shape.parent !== null && (shape.parent === parentKey || replacedBy.get(shape.parent) === parentKey));
+            if (!original)
+                continue;
+            replacedBy.set(original.identity, key);
+            added.delete(key);
+            changed = true;
+        }
+    }
+    return added.size;
+}
 export function observeSession(name, cursor) {
     assertSessionName(name);
     const previous = cursor === undefined ? null : decodeActivityCursor(cursor, name);
@@ -1178,9 +1226,8 @@ 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, meta.startup_process_shapes) : null,
     };
     return result;
 }
@@ -2003,8 +2050,10 @@ 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 startupShapes = Array.isArray(m.startup_process_shapes) && m.startup_process_shapes.every((shape) => shape && typeof shape.identity === "string" && (shape.parent === null || typeof shape.parent === "string") && typeof shape.argv_digest === "string")
+        ? { startup_process_shapes: m.startup_process_shapes } : {};
     const startupFields = Array.isArray(m.startup_processes) && m.startup_processes.every((identity) => typeof identity === "string")
-        ? { startup_processes: m.startup_processes } : {};
+        ? { startup_processes: m.startup_processes, ...startupShapes } : {};
     if (m.kind === "claude") {
         const expectedSettings = agentManagedClaudeSettingsPath(name, m.launch_id);
         const expectedResult = agentClaudeResultPath(name, m.launch_id);
@@ -3225,6 +3274,7 @@ async function prepareAgentInput(name, meta, options) {
     // ここまでに居るprocessは起動時の足場（harness・MCP・起動時hook）。初手を送る前に控える。
     if (live.activity.cursor !== null) {
         meta.startup_processes = Object.keys(decodeActivityCursor(live.activity.cursor, name).processes);
+        meta.startup_process_shapes = startupProcessShapes(meta.startup_processes, readRuntimeProcesses());
         writeAgentMetadata(meta);
     }
     return { status: "ready", reason: "composer_ready" };

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/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/docs/DESIGN.md

@@ -54,6 +54,9 @@ 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）。その下は数える。
+harnessが同じ親の下に同じargvで立て直した起動時のprocessも数えない（ADR 0083）。
+中継の後ろで眠っている本体を配送の引き取りのために起こすかは、`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.50.0",
+  "version": "0.51.1",
   "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"
   },