aiterm-mcp 0.58.3 → 0.59.0

package/dist/harnesses/grok.js

@@ -117,16 +117,41 @@ export function grokCatalogFromInitialize(stdout, summary = "") {
             // 候補に無い既定値は黙って捨てず、checkedCatalogで形式異常にする。
             default_effort: efforts.length > 0 ? defaultEffort : null,
             hidden: false,
+            fast: false,
         };
     });
+    // Grokのfastは別のmodel（表示名が「<元の表示名> Fast」。1.0.50: Grok 4.7 と Grok 4.7 Fast＝grok-4.7-build-fast）。
+    // fast版は別のmodelとして並べず、元のmodelの fast: true にまとめる。元のmodelが一覧に無いfast版は、そのまま1つのmodelとして残す。
+    const fastIds = grokFastVariants(models);
+    const variants = new Set(Object.values(fastIds));
+    const current = typeof state.currentModelId === "string" ? state.currentModelId : null;
+    const baseOf = (id) => Object.keys(fastIds).find((base) => fastIds[base] === id) ?? id;
     return checkedCatalog("Grok", {
         source: "grok agent stdio initialize (_meta.modelState)",
         harness_version: typeof meta.agentVersion === "string" ? meta.agentVersion : null,
-        default_model: typeof state.currentModelId === "string" ? state.currentModelId : null,
+        default_model: baseOf(current),
         adapter_efforts: {},
-        models,
+        models: models.filter((model) => !variants.has(model.id))
+            .map((model) => ({ ...model, fast: model.id in fastIds })),
+        fast_ids: fastIds,
     });
 }
+/** 元のmodel ID → fast版のmodel ID。表示名が「<元の表示名> Fast」のmodelを、その元のmodelのfast版と読む。 */
+export function grokFastVariants(models) {
+    const byName = new Map(models.flatMap((model) => model.display_name ? [[model.display_name, model.id]] : []));
+    const pairs = {};
+    for (const model of models) {
+        const match = model.display_name?.match(/^(.+) Fast$/);
+        const base = match ? byName.get(match[1]) : undefined;
+        if (base && base !== model.id)
+            pairs[base] = model.id;
+    }
+    return pairs;
+}
+/** model IDが、一覧の上でほかのmodelのfast版なら、その元のmodel ID。 */
+export function grokFastBase(catalog, model) {
+    return Object.keys(catalog.fast_ids ?? {}).find((base) => catalog.fast_ids?.[base] === model) ?? null;
+}
 export function assertGrokModelAvailable(bin, cwd, model) {
     const models = grokModelCatalog(bin, cwd);
     if (!models.includes(model)) {
@@ -630,3 +655,135 @@ export function grokAuthPane(screen) {
     }
     return { url, user_code: embedded, input_required: false, message: null };
 }
+// ---- ファスト。Grokのfastは別のmodel。Grokは、起動の --model と、動いている席の `/model <ID> [effort]`・`/effort` で、
+// 利用者のconfig.tomlの [models] の default と default_reasoning_effort を書き換える（1.0.50で確かめた。「✓ Default model: …」）。
+// 席だけの切り替えにするため、切り替えの直前の値へ戻す。
+const GROK_DEFAULT_KEYS = ["default", "default_reasoning_effort"];
+/** [models] の節の中の `<key> = …` の行の番号。節や行が無ければnull。 */
+function grokModelsLine(rows, key) {
+    const start = rows.findIndex((row) => /^\s*\[models\]\s*(?:#.*)?$/.test(row));
+    if (start < 0)
+        return null;
+    for (let index = start + 1; index < rows.length && !/^\s*\[/.test(rows[index]); index++) {
+        if (new RegExp(`^\\s*${key}\\s*=`).test(rows[index]))
+            return index;
+    }
+    return null;
+}
+export function readGrokModelDefaults(configPath) {
+    let body;
+    try {
+        body = fs.readFileSync(configPath, "utf8");
+    }
+    catch {
+        body = null;
+    }
+    return grokModelDefaultsFromBody(body);
+}
+/** config.tomlの中身（読めなかった時はnull）から、[models] の既定を読む。 */
+export function grokModelDefaultsFromBody(body) {
+    if (body === null)
+        return { body: null, default: { present: false, value: null }, default_reasoning_effort: { present: false, value: null } };
+    const rows = body.split(/\r?\n/);
+    const pick = (key) => {
+        const line = grokModelsLine(rows, key);
+        if (line === null)
+            return { present: false, value: null };
+        const value = rows[line].match(/=\s*"([^"\\]*)"\s*(?:#.*)?$/);
+        return { present: true, value: value ? value[1] : null };
+    };
+    return { body, default: pick("default"), default_reasoning_effort: pick("default_reasoning_effort") };
+}
+function withoutGrokDefaults(body) {
+    const rows = body.split(/\r?\n/);
+    for (const key of GROK_DEFAULT_KEYS) {
+        const line = grokModelsLine(rows, key);
+        if (line !== null)
+            rows.splice(line, 1);
+    }
+    return rows.join("\n");
+}
+/**
+ * Grokがconfig.tomlへ書いた [models] の既定（default・default_reasoning_effort）を、切り替えの直前の値へ戻す。
+ * 切り替えの前後で、ほかの行が同じなら前の中身をそのまま書き戻す。ほかの行も変わっていたら、既定の行だけを直す。
+ * 前の中身を読めなかった時、元の値が読めない書き方だった時、今のfileに [models] の節が無い時は、その項目に触らない。
+ */
+export function restoreGrokModelDefaults(configPath, before) {
+    if (before.body === null)
+        return;
+    let now;
+    try {
+        now = fs.readFileSync(configPath, "utf8");
+    }
+    catch {
+        return;
+    }
+    if (now === before.body)
+        return;
+    const eol = now.includes("\r\n") ? "\r\n" : "\n";
+    const rows = now.split(/\r?\n/);
+    for (const key of GROK_DEFAULT_KEYS) {
+        const pin = before[key];
+        if (pin.present && pin.value === null)
+            continue;
+        const line = grokModelsLine(rows, key);
+        if (pin.present) {
+            const wanted = `${key} = ${JSON.stringify(pin.value)}`;
+            if (line !== null)
+                rows[line] = wanted;
+            else {
+                const header = rows.findIndex((row) => /^\s*\[models\]\s*(?:#.*)?$/.test(row));
+                if (header >= 0)
+                    rows.splice(header + 1, 0, wanted);
+            }
+        }
+        else if (line !== null) {
+            rows.splice(line, 1);
+        }
+    }
+    const edited = rows.join(eol);
+    if (edited === now)
+        return;
+    // ほかの行が前と同じなら、前の中身（空白や並びもそのまま）を書き戻す。
+    const next = withoutGrokDefaults(edited) === withoutGrokDefaults(before.body) ? before.body : edited;
+    const temp = `${configPath}.aiterm-restore-${process.pid}`;
+    fs.writeFileSync(temp, next, { mode: fs.statSync(configPath).mode & 0o777 });
+    try {
+        fs.renameSync(temp, configPath);
+    }
+    catch (error) {
+        // Windowsでは、ほかのprocessがfileを開いている間、置き換えに失敗する事がある。途中のfileを残さず、呼び手に次の回で試させる。
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch { /* 残っても中身は前の値 */ }
+        throw error;
+    }
+}
+/**
+ * 足元の枠の行の「<modelの表示> (<effort>)」から、modelの表示（「Grok 4.7 Fast」）を読む。権限の表示（· always-approve）は、付く時と付かない時がある。
+ * 切り替えの知らせ（Switched to Grok 4.7 Fast (high effort)）は、かっこの中に空白があるので拾わない。
+ */
+export function grokFooterModelName(screen) {
+    let name = null;
+    for (const line of screen.split("\n")) {
+        const match = line.match(/(Grok [^()·│╯╰─]+?) \([a-z-]+\)/);
+        if (match)
+            name = match[1].trim();
+    }
+    return name;
+}
+/** 足元の「Grok 4.7 Fast (high)」から、今のmodelを一覧のIDで返す。base は元のmodel、fast はfast版かどうか。 */
+export function grokModelFromFooter(screen, catalog) {
+    const name = grokFooterModelName(screen);
+    if (!name)
+        return null;
+    const fastIds = catalog.fast_ids ?? {};
+    for (const model of catalog.models) {
+        if (model.display_name === name)
+            return { id: model.id, base: model.id, fast: false };
+        if (fastIds[model.id] && `${model.display_name} Fast` === name)
+            return { id: fastIds[model.id], base: model.id, fast: true };
+    }
+    return null;
+}

package/dist/index.js

@@ -834,15 +834,27 @@ registerRemoteAwareTool("agent_auth", {
         return fail(error);
     }
 });
+// ファスト（高速の応答。ADR 0114）。断りの符号は4つのharnessで共通で、文の先頭に付く。
+const fastModeErrorCodes = ["FAST_MODE_NOT_SUPPORTED", "FAST_MODE_UNAVAILABLE", "FAST_MODE_MODEL_CONFLICT", "FAST_MODE_UNCONFIRMED"];
+const fastModeFailureSchema = z.object({
+    code: z.enum(fastModeErrorCodes),
+    message: z.string(),
+});
+const fastModeDesc = "ファスト（harnessの高速の応答。費用や利用量が増える）。席は必ず通常の速度で起きる。trueはその席をfastへ切り替え、falseは通常の速度にする" +
+    "（fastに対応していないmodelでもfalseは受ける）。切り替えは席だけに留め、harnessが利用者の既定へ書いた分は切り替えの直前の値へ戻す。" +
+    "断りは文の先頭の符号で分かる: FAST_MODE_NOT_SUPPORTED（そのmodelは対応していない）、FAST_MODE_UNAVAILABLE（アカウントや契約で使えない）、" +
+    "FAST_MODE_MODEL_CONFLICT（modelへfast版のIDを書いてfalseを渡した）、FAST_MODE_UNCONFIRMED（切り替えた後の状態を確かめられない）。";
 registerRemoteAwareTool("agent_configure", {
-    description: "起動済みのClaude／Codex／Grok／Cursor agent sessionを再起動せず、会話contextを保ったままmodel／reasoning effortを変更する。" +
+    description: "起動済みのClaude／Codex／Grok／Cursor agent sessionを再起動せず、会話contextを保ったままmodel／reasoning effort／fastを変更する。" +
         "各harnessのCLI標準model操作を使う。Cursorのreasoning_effort変更はmodelと同時指定する。" +
         "Claude Codeの席では /model の選ぶ画面の「この会話だけ」（s）で替え、端末の ~/.claude/settings.json の既定は書き換えない。" +
-        "その選び方が無い版、選ぶ画面に無いmodel、そのmodelで選べないeffortは、何も変えずに断る。",
+        "その選び方が無い版、選ぶ画面に無いmodel、そのmodelで選べないeffortは、何も変えずに断る。" +
+        "fastだけの指定も受ける。" + fastModeDesc,
     inputSchema: {
         session_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
         model: z.string().min(1).nullish().describe("変更後のmodel。省略時はmodelを変更しない"),
         reasoning_effort: z.string().min(1).nullish().describe("変更後のreasoning effort。省略時はeffortを変更しない"),
+        fast: z.boolean().nullish().describe("変更後のfast。省略時は、その席の今の状態を変えない"),
     },
     outputSchema: {
         schema: z.literal("aiterm.agent-configure-result.v1"),
@@ -851,10 +863,11 @@ registerRemoteAwareTool("agent_configure", {
         harness: z.enum(["claude-code", "codex-cli", "grok-cli", "cursor-cli"]),
         model: z.string().nullable(),
         reasoning_effort: z.string().nullable(),
+        fast: z.boolean().nullable().optional().describe("切り替えた後の、席のfastの状態。Aitermが確かめた事の無い席（前の版が起こした席）はnull"),
     },
-}, async ({ session_id, model, reasoning_effort }) => {
+}, async ({ session_id, model, reasoning_effort, fast }) => {
     try {
-        const result = await core.configureAgent(session_id, { model, reasoning_effort });
+        const result = await core.configureAgent(session_id, { model, reasoning_effort, fast });
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
             structuredContent: { ...result },
@@ -870,11 +883,14 @@ const agentModelChoiceSchema = z.object({
     efforts: z.array(z.string()).describe("このmodelで選べるreasoning_effort。空ならeffort非対応"),
     default_effort: z.string().nullable(),
     hidden: z.boolean().describe("harnessが一覧で隠すmodel（Codexのinclude_hidden時だけtrueがある）"),
+    fast: z.boolean().describe("このharness・このmodelでfastへ切り替えられるか（agent_launch／agent_configureのfast: true）。" +
+        "fastが別のmodel IDのharness（Cursor・Grok）は、fast版を別のmodelとして並べず、元のmodelのここがtrueになる"),
 });
 registerRemoteAwareTool("agent_models", {
     description: "harnessが今返すmodelとreasoning effortの候補を、そのharnessの公式の一覧から取得する。promptもturnも送らず推論を消費しない。" +
         "Codexはapp-server model/list、Claude Codeはstream-json initializeのmodels、Grokはagent stdio initializeのmodelState、" +
         "Cursorはcursor-agent modelsを素のmodel IDとeffortへ分けたもの。返るidとeffortsはagent_launch／agent_configureへそのまま渡せる。" +
+        "modelごとのfastは、そのmodelでfastへ切り替えられるか（harnessが返す値）。fast_unavailableは、アカウントの都合でどのmodelでも使えない時の訳。" +
         "取得不能はMODEL_CATALOG_UNAVAILABLE、形式異常はMODEL_CATALOG_INVALIDのエラーで返し、別の一覧へfallbackしない。" +
         "remoteを付けると別端末のharnessの候補を返す。",
     inputSchema: {
@@ -890,6 +906,7 @@ registerRemoteAwareTool("agent_models", {
         default_model: z.string().nullable().describe("model省略時にharnessが使うmodel。一覧のIDで表せなければnull"),
         efforts: z.array(z.string()).describe("全modelのeffortの和"),
         adapter_efforts: z.record(z.string(), z.string()).describe("harnessの一覧には無く、Aitermのadapterが足したeffortと理由"),
+        fast_unavailable: fastModeFailureSchema.nullable().optional().describe("このアカウント・この端末では、どのmodelでもfastを使えない時の訳（harnessが先に答えられる時だけ。今はClaude Code）。使える・分からない時はnull"),
         models: z.array(agentModelChoiceSchema),
     },
 }, async ({ harness, cwd, include_hidden }) => {
@@ -907,6 +924,11 @@ registerRemoteAwareTool("agent_models", {
 });
 // 新規APIの選択軸はharness。旧4 launcher名は移行期間中の薄いaliasとして同じ実装へ流す。
 const kindForHarness = (harness) => harness === "claude-code" ? "claude" : harness === "codex-cli" ? "codex" : harness === "cursor-cli" ? "cursor" : "grok";
+const fastModeLaunchDesc = "ファスト（harnessの高速の応答。費用や利用量が増える）。省略とfalseは通常の速度で起こす（利用者の設定にfastが残っていても通常）。" +
+    "trueは通常で起こしてから、その席をfastへ切り替える。modelがfastに対応していない時（FAST_MODE_NOT_SUPPORTED）と、" +
+    "modelへfast版のIDを書いてfalseを渡した時（FAST_MODE_MODEL_CONFLICT）は起動を断る。アカウントの都合で使えない時・確かめられない時は、" +
+    "起動を断らずに通常の速度で起こし、返りの fast を false、fast_error に訳を入れる。" +
+    "modelへfast版のIDを直に書いて省略した時だけ、そのIDのまま起こす（返りの fast は true）。";
 const agentModelDesc = (kind) => kind === "claude"
     ? "起動モデル（例: claude-sonnet-4-6）。省略時はClaude CLI既定"
     : kind === "codex"
@@ -966,7 +988,7 @@ async function launchRemoteAgent(target, harness, args, extra) {
 }
 async function launchAgent(kind, args, extra) {
     const supportsWriteScope = kind !== "claude";
-    const { prompt, image, throughline_source_session, throughline_supplement_file, model, reasoning_effort, env_vars, cwd, session_name, launch_operation_id, write_scope, trust_project } = args;
+    const { prompt, image, throughline_source_session, throughline_supplement_file, model, reasoning_effort, fast, env_vars, cwd, session_name, launch_operation_id, write_scope, trust_project } = args;
     let delivery = null;
     try {
         if (!supportsWriteScope && write_scope !== undefined) {
@@ -975,12 +997,13 @@ async function launchAgent(kind, args, extra) {
         const initialPrompt = image && image.length > 0 ? core.attachImages(prompt ?? "", image) : prompt ?? undefined;
         if (initialPrompt || throughline_source_session)
             delivery = await deliveryForRequest(extra);
-        const [sid, hint, eventCursor, submitResidue, initialDelivery, startup] = await core.openAgentWithInitialPrompt(kind, {
+        const [sid, hint, eventCursor, submitResidue, initialDelivery, startup, fastState] = await core.openAgentWithInitialPrompt(kind, {
             prompt: initialPrompt,
             throughline_source_session,
             throughline_supplement_file,
             model: model ?? undefined,
             reasoning_effort: reasoning_effort ?? undefined,
+            fast: fast ?? undefined,
             env_vars,
             trust_project,
             before_send: delivery?.before_send,
@@ -1001,6 +1024,8 @@ async function launchAgent(kind, args, extra) {
             submit_residue: submitResidue,
             initial_prompt: initialDelivery,
             startup,
+            fast: fastState.fast,
+            fast_error: fastState.fast_error,
             ...(supportsWriteScope && write_scope !== undefined
                 ? {
                     write_scope,
@@ -1012,8 +1037,11 @@ async function launchAgent(kind, args, extra) {
         };
         // 開始未確認（submitted_unconfirmed）は誤りにしない。sessionは立ち、promptは入力欄を離れ、配送も登録済み。
         // 誤りで返すとClaude Code親は受け口のhookを走らせず、子の回答が届かない（ADR 0093）。状態はinitial_promptと本文で伝える。
+        const fastLine = fastState.fast_error
+            ? `\nfast: false（通常の速度で起こした）。${fastState.fast_error.message}`
+            : fast === true ? `\nfast: ${fastState.fast}` : "";
         return {
-            content: [{ type: "text", text: `session_id: ${sid}\n${hint}${deliveryIdLine(delivery)}` }],
+            content: [{ type: "text", text: `session_id: ${sid}\n${hint}${fastLine}${deliveryIdLine(delivery)}` }],
             structuredContent: structured,
         };
     }
@@ -1073,6 +1101,7 @@ function registerAgentTool(toolName, kind, desc) {
             model: z.string().nullish().describe(agentModelDesc(kind)),
             // CLI／model側の値集合が版で変わるため公開enumでは縛らない（core側も同方針）。
             reasoning_effort: z.string().nullish().describe(agentEffortDesc(kind)),
+            fast: z.boolean().nullish().describe(fastModeLaunchDesc),
             env_vars: z.array(z.string()).optional().describe("起動したagentへ現在のMCP processから継承する環境変数名。値はtool引数へ渡さない"),
             trust_project: z.boolean().optional().describe("対象projectを信頼し、既知のworkspace・project hooks・MCP初期同意を起動中に進める"),
             cwd: z.string().nullish().describe("作業ディレクトリ（対象リポのルート等・任意）"),
@@ -1097,6 +1126,8 @@ function registerAgentTool(toolName, kind, desc) {
             // 初回prompt dispatch後のsubmit座礁観測（additive）。true=composerに残存を確認（submit未成立の疑い）/
             // false=残存を観測せず（submit成立の保証ではない）/ null=promptなし・判定不能。
             submit_residue: z.boolean().nullable(),
+            fast: z.boolean().optional().describe("起こした後の、席のfastの状態"),
+            fast_error: fastModeFailureSchema.nullable().optional().describe("fastを頼まれたが、通常の速度で起こした時の訳"),
             ...writeScopeOutputSchema,
         },
     }, async (args, extra) => launchAgent(kind, args, extra));
@@ -1115,6 +1146,7 @@ server.registerTool("agent_launch", {
         throughline_supplement_file: z.string().min(1).optional().describe("Throughline 0.10.8以降へそのまま渡すproject束縛済み長期記憶・知識の補足JSON path"),
         model: z.string().nullish().describe("harnessが選ぶモデル。provider名ではなくlive catalog上のmodel ID"),
         reasoning_effort: z.string().nullish().describe("harness adapterが標準CLI表現へ変換する思考レベル。Cursorではmodel同時指定が必要"),
+        fast: z.boolean().nullish().describe(fastModeLaunchDesc),
         env_vars: z.array(z.string()).optional().describe("現在のMCP processから継承する環境変数名"),
         trust_project: z.boolean().optional().describe("対象projectを信頼し、既知のworkspace・project hooks・MCP初期同意を起動中に進める"),
         cwd: z.string().nullish().describe("作業ディレクトリ（絶対パス・任意）"),
@@ -1138,6 +1170,8 @@ server.registerTool("agent_launch", {
         wait_command: z.string().nullable(),
         parent_delivery: parentDeliveryOutputSchema.optional(),
         submit_residue: z.boolean().nullable(),
+        fast: z.boolean().optional().describe("起こした後の、席のfastの状態（この項目を返さない版の別端末では無い）"),
+        fast_error: fastModeFailureSchema.nullable().optional().describe("fastを頼まれたが、通常の速度で起こした時の訳"),
         write_scope: z.string().optional(),
         write_scope_enforcement: z.enum(["enforced_read_only", "declaration_only_unsupported"]).optional(),
     },

package/dist/live-node.js

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+/**
+ * このprocessのNodeを、後からでも起こせる場所で返す。自分でNodeを起こす時と、呼び手へ「起こす先」として渡す時に使う。
+ * `process.execPath`は起きた時の実体で、長く動くprocessでは後から消える事がある（Homebrewは版ごとの場所へ入れ、更新で前の版を消す。
+ * 2026-10-12、MacでNodeが26.10.0_1から26.11.1へ上がり、前の版から起きていたMCP process 19個が、無いNodeを起こそうとして黙って失敗していた）。
+ * Homebrewの時は同じformulaのopt（更新でも残る）を返す。実体が消えていて代わりも無い時は、PATHから探させる（`node`）。
+ * aiterm-steer-deliveryの同じ名前の関数と同じ決まり（0.4.6〜）。
+ */
+export function liveNodeExecutable(executable = process.execPath, exists = existsSync) {
+    const brew = /^(.*)\/Cellar\/(node(?:@\d+)?)\/[^/]+\/bin\/node$/.exec(executable);
+    if (brew) {
+        const opt = `${brew[1]}/opt/${brew[2]}/bin/node`;
+        if (exists(opt))
+            return opt;
+    }
+    return exists(executable) ? executable : "node";
+}

package/dist/model-catalog.js

@@ -50,6 +50,7 @@ export function agentModelsResult(harness, catalog) {
         default_model: catalog.default_model,
         efforts: sortEfforts(catalog.models.flatMap(model => model.efforts)),
         adapter_efforts: catalog.adapter_efforts,
+        fast_unavailable: catalog.fast_unavailable ?? null,
         models: catalog.models,
     };
 }

package/dist/parent-delivery-cli.js

@@ -22,6 +22,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { realCodexHome, readCodexWakeResult } from "aiterm-steer-delivery";
 import { AITERM_PROFILE } from "./steer-profile.js";
+import { liveNodeExecutable } from "./live-node.js";
 import { checkCodexParent, submitCodexParentAnswer, withCodexReceiver } from "./codex-parent-receiver.js";
 import { codexHookDeliveryState, codexHookDirectory, codexInputDirectory } from "./codex-hook-state.js";
 export const PARENT_DELIVERY_SCHEMA = "aiterm.parent-delivery.v1";
@@ -134,7 +135,7 @@ async function deliveryState(target, delivery) {
  * アプリ配下のprocessは、PATHが細い事がある（2026-10-07、素のsshの環境からの呼び出しで起きた）。
  * nodeの場所がPATHに無い時だけ頭へ足す。既にあれば、並びも中身も変えない。
  */
-export function pathWithNode(env, node = process.execPath, platform = process.platform) {
+export function pathWithNode(env, node = liveNodeExecutable(), platform = process.platform) {
     const windows = platform === "win32";
     // Windowsの環境変数名は大文字小文字を区別しない（`Path`で入っている事が多い）。
     const key = Object.keys(env).find(name => windows ? name.toLowerCase() === "path" : name === "PATH") ?? "PATH";
@@ -146,7 +147,7 @@ export function pathWithNode(env, node = process.execPath, platform = process.pl
 }
 /** この命令の場所と版。製品側の入口（aiterm-steer-delivery）が、呼べる相手かどうかを確かめるのに使う。 */
 export function providerDescription() {
-    return { version: pkg.version, node: process.execPath, cli: fileURLToPath(import.meta.url) };
+    return { version: pkg.version, node: liveNodeExecutable(), cli: fileURLToPath(import.meta.url) };
 }
 export async function runParentDelivery(argv) {
     const [kind, command, ...args] = argv;

package/dist/parent-delivery.js

@@ -64,6 +64,22 @@ async function submitParentAnswer(parent, deliveryId, text) {
 const OWNER_IDENTITY_RECHECK_MS = 60_000;
 // owner.jsonの無い保存場所を、作っている途中の持ち主として扱う時間。
 const OWNER_SETUP_GRACE_MS = 60_000;
+// 持ち主が自分の保存場所へ付ける「生きている印」（ADR 0112）。中身は無く、最後に書いた時刻（mtime）だけを使う。
+// 印が新しい持ち主は、OSへ聞かずに生きていると読む。pidを使い回した別のprocessは、この印を書かない。
+// 印の無い持ち主（0.58.3までの版）と、印が古い持ち主だけ、今までどおり開始時刻で照合する。
+// 名前は.jsonで終わらせない（回収は、保存場所の.jsonを配送の記録として引き取る）。
+const OWNER_HEARTBEAT_FILE = "alive";
+const OWNER_HEARTBEAT_MS = 15_000;
+// 持ち主のprocessが同期の処理で塞がる間（最長で十数秒）も印を新しいと読めるよう、書く間隔の4倍にする。
+const OWNER_HEARTBEAT_FRESH_MS = 60_000;
+function ownerHeartbeatAt(directory) {
+    try {
+        return fs.statSync(path.join(directory, OWNER_HEARTBEAT_FILE)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
 function processExists(pid) {
     // 0以下はprocess groupを指す。持ち主のpidにはならない。
     if (pid <= 0)
@@ -129,10 +145,11 @@ export class ParentDeliveryManager {
     verifiedOwners = new Map();
     serviceError = null;
     closing = false;
+    lastHeartbeat = Number.NEGATIVE_INFINITY;
     constructor(options = {}) {
         this.deps = { observe: observeAnywhere, answer: answerAnywhere, submit: submitParentAnswer,
             verify: verifyParent, processes: readProcessIdentities, exists: processExists,
-            now: () => performance.now(), ...options.dependencies };
+            now: () => performance.now(), wall: () => Date.now(), ...options.dependencies };
         const stateRoot = ensureStateRoot();
         // 別端末の子の記録はremote-で始まる保存場所へ分け、boundary.remoteを知らない旧版のreaderへ渡さない。
         const prefix = options.remote ? "remote-" : "";
@@ -414,14 +431,40 @@ export class ParentDeliveryManager {
         this.recovering = this.recoverOrphans().finally(() => { this.recovering = null; });
         return this.recovering;
     }
+    /** 自分の保存場所の「生きている印」を新しくする。書けない回は次の回へ回す（印が古くなれば、相手は開始時刻で照合する）。 */
+    heartbeat() {
+        const wall = this.deps.wall();
+        if (this.closing || Math.abs(wall - this.lastHeartbeat) < OWNER_HEARTBEAT_MS)
+            return;
+        const file = path.join(this.ownerDir, OWNER_HEARTBEAT_FILE);
+        try {
+            const at = new Date(wall);
+            try {
+                fs.utimesSync(file, at, at);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                fs.writeFileSync(file, "", { mode: 0o600 });
+                fs.utimesSync(file, at, at);
+            }
+            this.lastHeartbeat = wall;
+        }
+        catch { /* 次の回 */ }
+    }
     async recoverOrphans() {
+        this.heartbeat();
         // 生存を確かめる相手は、closeしていない他の持ち主だけ。居なければOSへ問い合わせない。
-        // この処理は5秒おきに全MCP processで回る。全processの一覧を取ると、processの多い端末で負荷になる。
+        // この処理は5秒おきに全MCP processで回る。processを起こして確かめると、MCP processの数の掛け算で端末を重くする
+        // （Windowsで、23個のMCP processがPowerShellを毎秒4回起こしていた。2026-10-12）。
         const directories = fs.readdirSync(this.active, { withFileTypes: true })
             .filter((directory) => directory.isDirectory() && path.join(this.active, directory.name) !== this.ownerDir);
         const now = this.deps.now();
+        const wall = this.deps.wall();
         const fate = new Map();
         const unverified = [];
+        // 前の照合を覚えている持ち主。誰かを照合する回に、まとめて照合し直す。
+        const remembered = [];
         for (const directory of directories) {
             let owner;
             try {
@@ -437,14 +480,23 @@ export class ParentDeliveryManager {
                 fate.set(directory.name, "gone");
                 continue;
             }
+            const beat = ownerHeartbeatAt(path.join(this.active, directory.name));
+            if (beat !== null && Math.abs(wall - beat) < OWNER_HEARTBEAT_FRESH_MS) {
+                fate.set(directory.name, "alive");
+                continue;
+            }
             const verified = this.verifiedOwners.get(directory.name);
             if (verified && verified.pid === pid && verified.started_identity === owner.started_identity
-                && now - verified.at < OWNER_IDENTITY_RECHECK_MS)
+                && now - verified.at < OWNER_IDENTITY_RECHECK_MS) {
                 fate.set(directory.name, verified.alive ? "alive" : "unverified");
+                remembered.push({ name: directory.name, pid, started_identity: owner.started_identity });
+            }
             else
                 unverified.push({ name: directory.name, pid, started_identity: owner.started_identity });
         }
         if (unverified.length > 0) {
+            // 覚えた時刻が持ち主ごとにずれると、1分の間に何度もprocessを起こす。照合する回は、全員を1回で照合し直して時刻を揃える。
+            unverified.push(...remembered);
             const processes = this.deps.processes([...new Set(unverified.map((entry) => entry.pid))]);
             for (const entry of unverified) {
                 const row = processes.find((candidate) => candidate.pid === entry.pid);

package/dist/process-runtime.js

@@ -101,17 +101,31 @@ export function readRuntimeProcesses() {
         };
     });
 }
+/** そのpidのprocessが今あるか。OSへ直接聞き、processを起こさない。権限が無くて触れないprocessも「ある」と読む。 */
+function pidExists(pid) {
+    if (pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
 /**
  * 指定したpidの開始時刻だけを引く。readRuntimeProcessesと同じ開始時刻を返し、存在しないpidは結果に含めない。
  * process表にpidはあるが開始時刻を読めない時は、started_identityをnullで返す（pidが無いのとは区別する）。
  * 全processのargvを読む一覧取得は、processの多い端末で重い（定期実行から呼ばない）。
  */
 export function readProcessIdentities(pids) {
-    const wanted = [...new Set(pids)];
+    if (pids.some(pid => !Number.isSafeInteger(pid) || pid < 0))
+        throw new AitermError("process照会のpidが不正です", 2);
+    // 居ないpidは、OSへ直接聞いて先に除く。全部居なければ、processを起こさない。
+    // macOSのpsは、範囲の外のpidが1つ混ざると、居るprocessの分も出さずに誤りで終わる。
+    const wanted = [...new Set(pids)].filter(pidExists);
     if (wanted.length === 0)
         return [];
-    if (wanted.some(pid => !Number.isSafeInteger(pid) || pid < 0))
-        throw new AitermError("process照会のpidが不正です", 2);
     if (!isWin) {
         const result = spawnSync(POSIX_PS, [...POSIX_IDENTITY_ARGS, wanted.join(",")], {
             encoding: "utf8", env: { ...process.env, LC_ALL: "C" }, timeout: 10000,
@@ -129,11 +143,25 @@ export function readProcessIdentities(pids) {
     }
     // CommandLineの読めないprocess（別の権限のserviceなど）も返す。pidが使い回された先を「別のprocess」と確かめるのに要る。
     // 開始時刻を読めない行も、pidがprocess表にある印として返す。
+    // WMI（Win32_Process）は使わない。絞っても1回に0.1〜0.3秒かかり、WMIの側のprocess（wmiprvse）のCPUを使う
+    // （process 1300個のWindowsで測った 2026-10-12。ADR 0112）。.NETのprocessの読み（OpenProcessとGetProcessTimes）は1個1.5ミリ秒。
+    // 開始時刻は同じ値になる（WMIはマイクロ秒で切り捨てた値を返し、どちらも1ミリ秒で切り捨てて使う。888個のprocessで食い違いは0）。
+    // 権限が無くて読めないprocessだけ、WMIへ聞き直す。
     const script = [
         ...WINDOWS_PROBE_HEADER,
-        `$rows=@(Get-CimInstance Win32_Process -Filter "${wanted.map(pid => `ProcessId=${pid}`).join(" OR ")}" | ForEach-Object {`,
-        "[ordered]@{ pid=[int]$_.ProcessId; started_identity=$(if ($null -ne $_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('o') } else { $null }) }",
-        "})",
+        "$rows=@()",
+        `foreach ($id in @(${wanted.join(",")})) {`,
+        "  try { $p=[Diagnostics.Process]::GetProcessById($id) } catch [ArgumentException] { continue }",
+        "  $started=$null",
+        "  try { $started=$p.StartTime.ToUniversalTime().ToString('o') }",
+        "  catch [InvalidOperationException] { continue }",
+        "  catch {",
+        "    $w=Get-CimInstance Win32_Process -Filter \"ProcessId=$id\" -Property CreationDate",
+        "    if ($null -eq $w) { continue }",
+        "    if ($null -ne $w.CreationDate) { $started=$w.CreationDate.ToUniversalTime().ToString('o') }",
+        "  }",
+        "  $rows += [ordered]@{ pid=[int]$id; started_identity=$started }",
+        "}",
         "ConvertTo-Json -Compress -InputObject $rows",
     ].join("\n");
     const result = spawnSync(resolveWindowsPowerShell7(), [...WINDOWS_PROBE_ARGS, Buffer.from(script, "utf16le").toString("base64")], {

package/dist/runtime-error-report.js

@@ -7,6 +7,7 @@ import { createRequire } from "node:module";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { defaultRuntimeErrorReportPaths, readBoundedFile, runtimeErrorReportingStatus } from "./runtime-error-os.js";
+import { liveNodeExecutable } from "./live-node.js";
 import { RuntimeErrorStore } from "./runtime-error-store.js";
 const pkg = createRequire(import.meta.url)("../package.json");
 const WORKER = fileURLToPath(new URL("./runtime-error-worker.js", import.meta.url));
@@ -252,7 +253,7 @@ export function triggerRuntimeErrorReport(env = process.env) {
     try {
         if (runtimeErrorReportingStatus(defaultRuntimeErrorReportPaths().reportingConfigPath) !== "enabled")
             return false;
-        const child = spawn(process.execPath, [WORKER, "report"], { stdio: "ignore", detached: true, windowsHide: true, env });
+        const child = spawn(liveNodeExecutable(), [WORKER, "report"], { stdio: "ignore", detached: true, windowsHide: true, env });
         child.once("error", () => { });
         child.unref();
         return true;

package/dist/runtime-error-store.js

@@ -4,6 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { createRequire } from "node:module";
 import { defaultRuntimeErrorReportPaths, runtimeErrorReportingStatus } from "./runtime-error-os.js";
+import { liveNodeExecutable } from "./live-node.js";
 import { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, expectedHostProfiles, readBoundedFile, processStartIdentity, forceKill } from "./runtime-error-os.js";
 export { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, windowsPrivateDaclVerifyCommand } from "./runtime-error-os.js";
 import { fileURLToPath } from "node:url";
@@ -673,7 +674,7 @@ export function recordRuntimeError(code, options = {}) {
         fixedStoreFailure(stderr);
     } };
     try {
-        const child = spawn(process.execPath, [options.workerPath ?? WORKER, "record", code], {
+        const child = spawn(liveNodeExecutable(), [options.workerPath ?? WORKER, "record", code], {
             stdio: "ignore", windowsHide: true, env: process.env,
         });
         const timer = setTimeout(() => { report(); forceKill(child); }, options.timeoutMs ?? defaultWorkerTimeoutMs("record"));
@@ -707,7 +708,7 @@ export async function runtimeErrorStoreDiagnostic(options = {}) {
         } };
         let child;
         try {
-            child = spawn(process.execPath, [options.workerPath ?? WORKER, "diagnostic"], {
+            child = spawn(liveNodeExecutable(), [options.workerPath ?? WORKER, "diagnostic"], {
                 stdio: ["ignore", "pipe", "ignore"], windowsHide: true, env: process.env,
             });
         }