aiterm-mcp 0.61.13 → 0.61.15

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.61.15] - 2026-10-24
+
+### Fixed
+
+- Completion checks observe the original request boundary outside the shared metadata mutex, then revalidate the unchanged original record and all uncertainty/slot gates before committing. Slow transcript/native completion observation no longer blocks unrelated admission; unknown sends are never reconciled or replayed.
+
+## [0.61.14] - 2026-10-24
+
+### Fixed
+
+- Native execution participants retain their verified current-process identity instead of spawning another OS identity probe at every scope check. Foreign process, multiplexer, source/target generation and participant checks remain fresh. This reduces admission overhead; it does not reconcile unknown sends or establish recovery from a production mutex timeout.
+
 ## [0.61.13] - 2026-10-24
 
 ### Validation scope
@@ -2836,7 +2848,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.61.13...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.15...HEAD
+[0.61.15]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.14...v0.61.15
+[0.61.14]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.13...v0.61.14
 [0.61.13]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.12...v0.61.13
 [0.61.12]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.11...v0.61.12
 [0.61.11]: https://github.com/kitepon/aiterm-mcp/compare/v0.61.10...v0.61.11

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.61.13** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.61.15** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 

package/README.md

@@ -227,7 +227,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.61.13** · 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.61.15** · 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
 

package/dist/execution-parent-worker.js

@@ -15,9 +15,24 @@ import { createSteerExecutionAdmission } from "./execution-steer.js";
 import { ExecutionError } from "./execution-wire.js";
 import { parentHookReference } from "./execution-parent-alias.js";
 import { requireExecutionEffectScope } from "./execution-effect.js";
+let localActor;
+function currentLocalActor() {
+    // This code is executing in the observed process. Its PID/start identity
+    // cannot change during its lifetime; another process has its own module.
+    // Keep only a verified self identity, never a server/parent/target sample.
+    // Missing/failed first reads remain failures and may be observed again.
+    if (!localActor || localActor.pid !== process.pid) {
+        const observed = readProcessIdentities([process.pid])[0];
+        if (!observed || observed.pid !== process.pid || !observed.started_identity
+            || !Number.isFinite(Date.parse(observed.started_identity)))
+            return null;
+        localActor = Object.freeze({ pid: observed.pid, started_identity: observed.started_identity });
+    }
+    return { ...localActor };
+}
 export const localParentWorkerRuntime = {
     scope: () => ({ state_root: stateRoot(), multiplexer: isWin ? { kind: "namespace", key: WIN_NS } : { kind: "socket", key: SOCK } }),
-    actor: () => readProcessIdentities([process.pid])[0] ?? null,
+    actor: currentLocalActor,
     observeActors: readProcessIdentities,
     observeParentProcess: observeExecutionParentProcess, observeSessionGeneration: observeExecutionSessionGeneration,
 };

package/dist/execution-service.js

@@ -1113,6 +1113,8 @@ export class ExecutionService {
         });
     }
     async finish(args) {
+        if (args.evidence.kind === "completion")
+            return this.finishCompletion(args.request, args.evidence.target);
         return this.store.transaction(async (state) => {
             const record = find(state, args.request);
             if (record.operations.launch === "issued" || record.operations.send === "issued"
@@ -1134,34 +1136,63 @@ export class ExecutionService {
                 const target = record.relation.target;
                 if (!target)
                     throw new ExecutionError("EXECUTION_CONFLICT");
-                if (args.evidence.kind === "completion") {
-                    if (!target.boundary || !same(target, args.evidence.target))
-                        throw new ExecutionError("EXECUTION_CONFLICT", "possible");
-                    if (record.relation.completion === "completed" && record.relation.target_fence === "closed")
-                        return view(state, record);
-                    const observed = await this.runtime.completion(target);
-                    if (observed.state === "unknown")
-                        throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
-                    record.relation.completion = observed.state;
-                    record.relation.target_fence = pendingParentReturn(state, args.request) ? "unknown"
-                        : observed.state === "completed" ? "closed" : observed.fence;
-                }
-                else {
-                    if (!same(target.launch, args.evidence.target))
-                        throw new ExecutionError("EXECUTION_CONFLICT", "possible");
-                    if (record.relation.completion === "interrupted" && record.relation.target_fence === "closed")
-                        return view(state, record);
-                    const observed = await this.runtime.observe(target.launch.session_id);
-                    if (observed.state !== "absent" || state.slots.some(slot => slot.session_id === target.launch.session_id))
-                        throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
-                    record.relation.completion = "interrupted";
-                    record.relation.target_fence = "closed";
-                }
+                if (!same(target.launch, args.evidence.target))
+                    throw new ExecutionError("EXECUTION_CONFLICT", "possible");
+                if (record.relation.completion === "interrupted" && record.relation.target_fence === "closed")
+                    return view(state, record);
+                const observed = await this.runtime.observe(target.launch.session_id);
+                if (observed.state !== "absent" || state.slots.some(slot => slot.session_id === target.launch.session_id))
+                    throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
+                record.relation.completion = "interrupted";
+                record.relation.target_fence = "closed";
             }
             retireSettledBranches(state);
             return view(state, record);
         });
     }
+    /** Completion evidence is for one fixed historical request/Point. Native
+     * transcript/generation observation must not hold the global writer mutex.
+     * Commit only if the original record and all uncertainty gates still match;
+     * an unrelated writer is allowed to progress while evidence is observed.
+     */
+    async finishCompletion(request, target) {
+        const eligible = (state) => {
+            const record = find(state, request);
+            if ([record.operations.launch, record.operations.send].some(stage => stage === "issued" || stage === "unknown")
+                || state.slots.some(slot => slot.request && same(slot.request, request))
+                || openParentEffect(state, request))
+                throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
+            if (!record.relation.target)
+                throw new ExecutionError("EXECUTION_CONFLICT");
+            if (!record.relation.target.boundary || !same(record.relation.target, target))
+                throw new ExecutionError("EXECUTION_CONFLICT", "possible");
+            return record;
+        };
+        const settled = (record) => record.relation.completion === "completed" && record.relation.target_fence === "closed";
+        const initial = await this.store.transaction(state => {
+            const record = eligible(state);
+            return { record, result: view(state, record) };
+        }, { readOnly: true });
+        if (settled(initial.record))
+            return initial.result;
+        const observed = { ...await this.runtime.completion(executionPointSchema.parse(target)) };
+        if (observed.state === "unknown")
+            throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
+        return this.store.transaction(state => {
+            const record = eligible(state);
+            if (settled(record))
+                return view(state, record);
+            // Do not overwrite a concurrent cancellation, target rebinding, phase
+            // change or interruption with an earlier read's completion evidence.
+            if (!same(record, initial.record))
+                throw new ExecutionError("EXECUTION_UNCONFIRMED", "possible");
+            record.relation.completion = observed.state;
+            record.relation.target_fence = pendingParentReturn(state, request) ? "unknown"
+                : observed.state === "completed" ? "closed" : observed.fence;
+            retireSettledBranches(state);
+            return view(state, record);
+        });
+    }
     /** Adapter for existing restart/configuration/close paths. It shares the
      * same per-seat issuance slots as dispatch and stop, without creating a job ID.
      * Callers must not wrap a multi-step restart in one unobserved callback:

package/docs/DESIGN.md

@@ -53,11 +53,18 @@ private participant factoryはproducer/service/dispatcher/同process用worker pr
 source環境の既存8名は一度だけ読み、必要な値だけを固定してproducerとdispatcherへ渡す。
 呼出側のprovider/profile/runtime methodの差替えは構築済みparticipantへ混入させず、現在のscope/actorの変化は作用前に拒否する。
 親managerの保存先とownerも同じscope/actorへ照合する。別processのhookはactorを流用せず、自分のworker factoryで接続する。
+native runtimeの自己actorは、現在実行中のprocessのPIDと開始identityを一度だけOSで確定して保持する。
+同processの生存中に開始identityは変わらないため、scope確認ごとの自己PID照会を行わない。
+初回の欠測・失敗は確定値として保持せず、返すobjectも複製する。注入runtimeのactor、他process・server・
+source/target世代の観測は保持せず、従来どおり各受付で再照合する。
 注入runtimeへ欠けたparent依存を既定OS処理で補わず、完全なfake依存を要求する。このfactoryも通常mainには未注入。
 同producer serviceの停止closeは、既存のissued close slotを持つ間だけ同期の期待世代primitiveへ渡す。
 実killの直前にもruntimeの同期世代読取を通し、scope/actor/期待launchの交代を拒否する。
 注入runtimeのclose欠測をcore既定処理で補わず、作用後の応答欠測は消失観測があってもunknown slotを保持する。
 完了の照会点は固定し、終了fenceの非同期応答後にも現在世代を確認する。実受取番/終了fenceの証拠adapterは未了。
+通常のcompletion終了確認は元request/Pointを共有lock内で固定し、native/transcript観測をlock外で行う。
+反映時に同じrecord全体・issued/unknown・元slot・親作用を再照合し、途中変更があれば反映しない。
+親返却のpending判定は反映時のstateで行い、元unknownの解除や送信の再実行には使わない。
 private producer/worker factoryを構築したprocessではnative effect scopeを必須にする。
 coreの公開変更入口も、打鍵や設定・認証・lock/metadata準備に入る前に対象のrequest contextを要求する。
 この入口確認はissuedへの昇格ではない。実作用時には既存の同期受付を別に通す。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.61.13",
+  "version": "0.61.15",
   "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": [