aiterm-mcp 0.23.1 → 0.24.2

package/README.ja.md

@@ -94,7 +94,14 @@ host統合は、kitepon.devの製品開発を支える内部基盤
 
 **言葉でなく実測で:** 記録済み203テストのベンチマークでは、`pty_read` はコンテキストに載るトークンを生ログの **約 7.1 分の 1** に減らす。しかも pass/fail の判定は畳んでも残る。→ [組み込みシェルツールとの使い分け](#組み込みシェルツールとの使い分け)
 
-13 ツール: 6 つの **PTY ツール**（`pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list`）で 1 本の永続端末を開き・操作し・読む。加えて 4 つの **エージェント起動ツール**（`claude_agent` / `codex_agent` / `grok_agent` / `composer_agent`）が別のコーディングエージェントの TUI を新しい端末の中に起動し、`claude_turn`がdurable caller向けの構造化issue／recoveryを、`claude_approval`が相関済みClaude承認UI中継を、`diagnostics`が安全なfactory readinessを返す。バックエンドは **tmux** なので、MCP サーバや AI クライアントが再起動してもセッションは生き残る。
+14 ツール: 6 つの **PTY ツール**（`pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list`）で 1 本の永続端末を開き・操作し・読む。加えて 4 つの **エージェント起動ツール**（`claude_agent` / `codex_agent` / `grok_agent` / `composer_agent`）が別のコーディングエージェントの TUI を新しい端末の中に起動し、`agent_configure`が起動中のCodex／Claudeのmodel・effortを再起動なしで変更し、`claude_turn`がdurable caller向けの構造化issue／recoveryを、`claude_approval`が相関済みClaude承認UI中継を、`diagnostics`が安全なfactory readinessを返す。バックエンドは **tmux** なので、MCP サーバや AI クライアントが再起動してもセッションは生き残る。
+
+**v0.24.2では長寿命Codexでも設定変更を維持。** 起動時headerがcapture範囲外へ流れた後は、
+常駐するmodel／effort footerと入力欄でCodexを識別する。idle sessionをそのまま変更でき、
+caller側の画面再描画、再試行、agent再起動は不要。
+
+**v0.24.0では起動中agentの設定変更を追加。** `agent_configure`はvendor標準操作を使って、
+起動中のCodex／Claudeのmodelとreasoning effortを変更する。PTY、vendor session、会話contextは維持する。
 
 **v0.23.0では、ローカル完結の別vendor向けportable forkを追加した。** どのlauncherでも
 `throughline_source_session`と新しいミッションを`prompt`へ渡すと、PTY作成前にローカルの
@@ -241,7 +248,7 @@ Throughline自体が不要である。
 Claude Code を再起動して、接続を確認:
 
 ```bash
-/mcp        # aiterm が connected・13 ツール公開、と出る
+/mcp        # aiterm が connected・14 ツール公開、と出る
 ```
 
 最初のセッション——4 回の呼び出しで、1 個の永続端末:
@@ -282,7 +289,7 @@ MCP クライアントが aiterm を stdio 越しにプログラムから駆動
 
 ```mermaid
 flowchart LR
-    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · claude_agent · claude_turn · claude_approval · codex_agent<br/>grok_agent · composer_agent · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 13 tools"]
+    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · agent_configure · claude_agent · claude_turn · claude_approval · codex_agent<br/>grok_agent · composer_agent · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 14 tools"]
     S -->|"pty_read<br/>token-reduced"| AI
     S -->|"tmux send-keys<br/>capture-pane"| P["persistent PTYs<br/>tmux · survive restarts"]
     P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
@@ -363,6 +370,7 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 | `pty_key` | 制御キーを送る | `session_id`, `key`（`C-c`/`Enter`/`Up`…） |
 | `pty_close` | 冪等に閉じ、`closed` / `already_closed`を返す | `session_id` |
 | `pty_list` | セッション一覧 | （なし） |
+| `agent_configure` | 起動中のCodex／Claudeを再起動せずmodel／effort変更 | `session_id`, `model?`, `reasoning_effort?` |
 | `claude_turn` | 相関済みClaude operationをdispatch（issue）または回収（recover） | `action`, `session_id`, `operation_id`, `text?` |
 | `claude_approval` | 現在表示中の相関済みClaude承認UIを検査または応答 | `action`, `session_id`, `operation_id?`, `approval_choice?`, `observed_prompt_digest?` |
 | `diagnostics` | 機械可読 JSON による read-only factory readiness | （なし） |
@@ -373,12 +381,14 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 
 `aiterm-runtime-errors snapshot` は dotagents factory adapter 向けに、製品所有のローカル snapshot を機械可読 JSON で返す。canonical dotagents factory-reporter config が schema-exact、host profile が実行 OS と一致し、`collection.enabled` が JSON boolean `true` の時だけ収集する。reporting field は schema 検証するが endpoint/credential file へ接続・読取せず network I/O も行わない。観測 API は core owner layer の固定3 code（PTY dependency・persistence・任意 vendor launcher）だけを受け、保存するのも固定 template と aggregate metadata（SHA-256 fingerprint、count、first/last、status、monotonic sequence）だけ。exception、stderr/stdout、stack、prompt、PTY/transcript/event body、path、任意 context は受け付けない。保存済み JSON も top/record exact・固定定義一致・fingerprint 再計算を通し、明示 DTO だけを返す。
 
-consumer は `aiterm-runtime-errors snapshot` を読み、durable ingestion 後に `aiterm-runtime-errors ack --cursor N` を呼ぶ。運用上の明示操作は `resolve|reopen --fingerprint SHA256`。MCP からの収集・diagnostic read は timeout 付き child process に隔離し、FIFOや停止 filesystem が端末本体を止めない。store mutation は期限付き bakery ticket queue で直列化する。各waiterは PID＋process start identity＋owner token を持つ再利用されない固有ticketを所有するため、死んだownerだけを固有名で除去でき、固定path回収のABAを作らない。POSIX state は `$XDG_STATE_HOME/aiterm-mcp/`（既定 `~/.local/state/aiterm-mcp/`）へ atomic replacement で置き、every read で owner/mode を再検証する。Windows native は `%LOCALAPPDATA%\aiterm-mcp\` で current SID の非継承 FullControl ACE 1件だけへ DACL を再構築し readback する。今回 Windows は path/DACL/timeout の純粋テストだけであり、新しい実機統合成功は主張しない。
+consumer は `aiterm-runtime-errors snapshot` を読み、durable ingestion 後に `aiterm-runtime-errors ack --cursor N` を呼ぶ。運用上の明示操作は `resolve|reopen --fingerprint SHA256`。MCP からの収集・diagnostic read は timeout 付き child process に隔離し、FIFOや停止 filesystem が端末本体を止めない。store mutation は期限付き bakery ticket queue で直列化する。各waiterは PID＋process start identity＋owner token を持つ再利用されない固有ticketを所有するため、死んだownerだけを固有名で除去でき、固定path回収のABAを作らない。queueの期限は正常な前任者を含む総待ち時間ではなく、同じ先頭ownerが進まない時間を測る。通常pollはprocessの生存確認だけを行い、process start identityはblockerがstallした時に照合する。POSIX state は `$XDG_STATE_HOME/aiterm-mcp/`（既定 `~/.local/state/aiterm-mcp/`）へ atomic replacement で置き、every read で owner/mode を再検証する。Windows native は `%LOCALAPPDATA%\aiterm-mcp\` で current SID の非継承 FullControl ACE 1件だけへ DACL を再構築し readback する。今回 Windows は path/DACL/timeout の純粋テストだけであり、新しい実機統合成功は主張しない。
 
 ### 対話エージェント起動ツール
 
 各ツールは特定ベンダーの対話型コーディングエージェント TUI を新しい永続 PTY の中に起動し、`session_id` を返す。以後は他のセッションと同様に `pty_read` / `pty_send` で操作する。モデルごとに 1 ツール＝ツール名を見ればどのモデルか分かる。TUI は全画面アプリなので、`pty_read({ screen: true })` で描画済みの画面を読む。
 
+`agent_configure({ session_id, model?, reasoning_effort? })`はvendor標準操作で起動中のCodex／Claudeを変更し、PTYと会話contextを維持する。Claude Code標準の`/model`・`/effort`は、新しいClaude sessionの既定値も同時に保存する。
+
 | ツール | 起動するもの | 主な引数 |
 | --- | --- | --- |
 | `claude_agent` | Claude Code CLI（Anthropic） | `prompt?`, `throughline_source_session?`, `model?`, `reasoning_effort?`（`low`/`medium`/`high`/`xhigh`/`max`）, `cwd?`, `session_name?` |

package/README.md

@@ -94,7 +94,16 @@ toolchain behind kitepon.dev's products.
 
 **Measured, not claimed:** in the recorded 203-test benchmark, a `pty_read` puts **~7.1× fewer tokens** in your context than the raw log — and the pass/fail verdict survives the fold. → [When to reach for it vs. the built-in shell](#when-to-reach-for-it-vs-the-built-in-shell)
 
-Thirteen tools: six **PTY tools** — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` — to open, drive, and read one persistent terminal, four **agent launchers** — `claude_agent` / `codex_agent` / `grok_agent` / `composer_agent` — that each start another coding agent's TUI inside a fresh one, `claude_turn` for durable structured issue/recovery, `claude_approval` for correlated Claude approval prompts, and `diagnostics` for safe factory readiness. The backend is **tmux**, so sessions survive even if the MCP server or the AI client restarts.
+Fourteen tools: six **PTY tools** — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` — to open, drive, and read one persistent terminal, four **agent launchers** — `claude_agent` / `codex_agent` / `grok_agent` / `composer_agent` — that each start another coding agent's TUI inside a fresh one, `agent_configure` to change a running Codex/Claude session's model and effort without restarting it, `claude_turn` for durable structured issue/recovery, `claude_approval` for correlated Claude approval prompts, and `diagnostics` for safe factory readiness. The backend is **tmux**, so sessions survive even if the MCP server or the AI client restarts.
+
+**v0.24.2 keeps in-place configuration working in long-lived Codex sessions.** Once the
+startup header has scrolled out of the captured pane, aiterm recognizes Codex by its persistent
+model/effort footer together with the input prompt. An idle session is therefore configured
+directly; callers do not need to redraw the TUI, retry, or restart the agent.
+
+**v0.24.0 adds in-place agent configuration.** `agent_configure` uses each vendor's
+native controls to change the model and/or reasoning effort of a running Codex or Claude
+session while preserving its PTY, vendor session, and conversation context.
 
 **v0.23.0 adds a local, cross-vendor portable fork.** Pass `throughline_source_session`
 with a mission in `prompt` to any launcher, and aiterm asks the locally installed Throughline
@@ -263,7 +272,7 @@ The only edits to the captures above are the two `⋮` lines (a long head/tail r
 Restart Claude Code, then verify the connection:
 
 ```bash
-/mcp        # aiterm should show as connected, exposing 13 tools
+/mcp        # aiterm should show as connected, exposing 14 tools
 ```
 
 Your first session — four calls, one persistent terminal:
@@ -304,7 +313,7 @@ The terminal is real and shared, so a human *can* jump in ([A human can watch](#
 
 ```mermaid
 flowchart LR
-    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · claude_agent · claude_turn · claude_approval · codex_agent<br/>grok_agent · composer_agent · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 13 tools"]
+    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · agent_configure · claude_agent · claude_turn · claude_approval · codex_agent<br/>grok_agent · composer_agent · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 14 tools"]
     S -->|"pty_read<br/>token-reduced"| AI
     S -->|"tmux send-keys<br/>capture-pane"| P["persistent PTYs<br/>tmux · survive restarts"]
     P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
@@ -387,6 +396,7 @@ On top of that sits a productized layer a raw tmux bridge doesn't have: **token-
 | `pty_key` | Send a control key | `session_id`, `key` (`C-c`/`Enter`/`Up`…) |
 | `pty_close` | Close idempotently; return `closed` / `already_closed` | `session_id` |
 | `pty_list` | List sessions (agent rows carry `agent=<kind>` metadata) | (none) |
+| `agent_configure` | Change model/effort in a running Codex or Claude session without restarting it | `session_id`, `model?`, `reasoning_effort?` |
 | `claude_turn` | Issue (dispatch-only) or recover one correlated Claude operation | `action`, `session_id`, `operation_id`, `text?` |
 | `claude_approval` | Inspect or answer the current correlated Claude approval prompt | `action`, `session_id`, `operation_id?`, `approval_choice?`, `observed_prompt_digest?` |
 | `diagnostics` | Read-only factory readiness as machine-readable JSON | (none) |
@@ -397,12 +407,14 @@ On top of that sits a productized layer a raw tmux bridge doesn't have: **token-
 
 `aiterm-runtime-errors snapshot` exposes a machine-readable, product-owned local snapshot for the dotagents factory adapter. Collection is fail-closed unless the canonical dotagents factory-reporter config is schema-exact, its host profile matches the executing OS, and it contains the JSON boolean `collection.enabled: true`; reporting fields are schema-validated but endpoints and credential files are never contacted, and the store performs no network I/O. The only accepted observations are three fixed codes owned by the core boundary (PTY dependency, persistence, and optional vendor launcher). Stored data is limited to fixed templates and aggregate metadata (SHA-256 fingerprint, count, first/last seen, status, and monotonic sequence); exceptions, stderr/stdout, stacks, prompts, terminal/transcript/event bodies, paths, and arbitrary context cannot enter the API. Persisted JSON is revalidated with exact top/record fields and a recomputed fingerprint before explicit DTO projection.
 
-Consumer flow is `aiterm-runtime-errors snapshot`, then `aiterm-runtime-errors ack --cursor N` after durable ingestion. Operators can use `resolve|reopen --fingerprint SHA256`. MCP collection and diagnostic reads run in timeout-bounded child processes, so a FIFO or stalled filesystem cannot block terminal work; child failure emits only the fixed store diagnostic. Store mutation uses a bounded bakery ticket queue: every waiter owns a never-reused ticket containing PID, process-start identity, and an owner token, so dead owners are removed by unique filename without fixed-path reclaim ABA. Worker deadlines use forced termination so a SIGTERM-ignoring child cannot mutate state after timeout. POSIX state is atomically replaced under `$XDG_STATE_HOME/aiterm-mcp/` (default `~/.local/state/aiterm-mcp/`) with owner/mode rechecked on every read. Windows native uses `%LOCALAPPDATA%\aiterm-mcp\`; each DACL is rebuilt and read back as one non-inherited FullControl ACE for the current SID. Windows path/DACL/timeout behavior is covered by pure tests in this change; no new Windows integration success is claimed.
+Consumer flow is `aiterm-runtime-errors snapshot`, then `aiterm-runtime-errors ack --cursor N` after durable ingestion. Operators can use `resolve|reopen --fingerprint SHA256`. MCP collection and diagnostic reads run in timeout-bounded child processes, so a FIFO or stalled filesystem cannot block terminal work; child failure emits only the fixed store diagnostic. Store mutation uses a bounded bakery ticket queue: every waiter owns a never-reused ticket containing PID, process-start identity, and an owner token, so dead owners are removed by unique filename without fixed-path reclaim ABA. The queue deadline measures lack of progress by the same head owner, not total wait behind healthy predecessors; normal polling uses the native process-liveness check and validates process-start identity only when a blocker stalls. Worker deadlines use forced termination so a SIGTERM-ignoring child cannot mutate state after timeout. POSIX state is atomically replaced under `$XDG_STATE_HOME/aiterm-mcp/` (default `~/.local/state/aiterm-mcp/`) with owner/mode rechecked on every read. Windows native uses `%LOCALAPPDATA%\aiterm-mcp\`; each DACL is rebuilt and read back as one non-inherited FullControl ACE for the current SID. Windows path/DACL/timeout behavior is covered by pure tests in this change; no new Windows integration success is claimed.
 
 ### Interactive agent launchers
 
 Each launcher starts a specific vendor's interactive coding-agent TUI inside a fresh persistent PTY and returns its `session_id` — from there you drive it with plain `pty_read` / `pty_send`, exactly like any other session. One tool per model, so the tool name itself tells you which model you get. The TUI is a full-screen app, so read it with `pty_read({ screen: true })` for the rendered view.
 
+`agent_configure({ session_id, model?, reasoning_effort? })` changes a running Codex or Claude TUI through the vendor's standard controls, preserving the PTY and conversation context. Claude Code's native `/model` and `/effort` commands also save those choices as defaults for new Claude sessions.
+
 | Tool | Launches | Key args |
 | --- | --- | --- |
 | `claude_agent` | Claude Code CLI (Anthropic) | `prompt?`, `throughline_source_session?`, `model?`, `reasoning_effort?` (`low`/`medium`/`high`/`xhigh`/`max`), `cwd?`, `session_name?`, `launch_operation_id?` |

package/dist/core.js

@@ -3323,7 +3323,11 @@ function isAgentTuiReady(kind, screen) {
         return screen.includes("Claude Code") && /(^|\n)\s*❯/.test(screen);
     }
     if (kind === "codex") {
-        return screen.includes("OpenAI Codex") && /(^|\n)\s*[›>]/.test(screen);
+        // 起動直後は製品header、長寿命sessionでは常駐footerがCodex TUIの識別子になる。
+        // capture-paneは直近45行だけなので、会話が進むとheaderは正常に画面外へ流れる。
+        const codexFrontend = screen.includes("OpenAI Codex")
+            || /(^|\n)\s*\S+\s+(?:low|medium|high|xhigh|max|ultra)\s+·\s+\S.*$/m.test(screen);
+        return codexFrontend && /(^|\n)\s*[›>]/.test(screen);
     }
     // Grok Build 0.2.117 は起動完了後に製品名を消し、model footerだけを残す。
     // Composerも同じfrontendでmodel名だけが異なるため、両方をvendor UIの根拠にする。
@@ -3563,6 +3567,138 @@ export function isAgentSession(name) {
     assertSessionName(name);
     return tryLoadAgentMetadata(name) !== null;
 }
+async function waitForScreenText(name, text, timeoutMs = 3_000) {
+    const deadline = performance.now() + timeoutMs;
+    do {
+        const screen = captureScreen(name, AGENT_TUI_READY_LINES);
+        if (screen.includes(text))
+            return screen;
+        await sleep(100);
+    } while (performance.now() < deadline);
+    throw new AitermError(`${agentLabel(loadAgentMetadata(name).kind)} の ${text} 画面を確認できません`, 2);
+}
+function sendMenuChoice(name, choice) {
+    const sent = tmux("send-keys", "-t", name, choice);
+    if (sent.code !== 0) {
+        throw new AitermError(`agent設定の選択を送れませんでした: ${sent.stderr.trim() || `code=${sent.code}`}`, 2);
+    }
+}
+function codexModelChoice(screen, model) {
+    for (const line of screen.slice(screen.lastIndexOf("Select Model and Effort")).split("\n")) {
+        const match = line.match(/^\s*(?:›\s*)?(\d+)\.\s+(\S+)/);
+        if (match?.[2] === model)
+            return match[1];
+    }
+    return null;
+}
+function codexEffortChoice(screen, effort) {
+    const labels = {
+        low: /^Low\b/i,
+        medium: /^Medium\b/i,
+        high: /^High\b/i,
+        xhigh: /^Extra high\b/i,
+        max: /^Max\b/i,
+        ultra: /^Ultra\b/i,
+    };
+    const wanted = labels[effort.toLowerCase()];
+    if (!wanted)
+        return null;
+    for (const line of screen.split("\n")) {
+        const match = line.match(/^\s*(?:›\s*)?(\d+)\.\s+(.+?)\s{2,}/);
+        if (match && wanted.test(match[2]))
+            return match[1];
+    }
+    return null;
+}
+function codexMoreReasoningChoice(screen) {
+    for (const line of screen.split("\n")) {
+        const match = line.match(/^\s*(?:›\s*)?(\d+)\.\s+More reasoning/);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/** 同じ対話sessionを保ったまま、vendor標準の操作でmodel／effortを変更する。 */
+export async function configureAgent(name, opts) {
+    assertSessionName(name);
+    const model = opts.model?.trim() || null;
+    const effort = opts.reasoning_effort?.trim() || null;
+    if (!model && !effort)
+        throw new AitermError("model または reasoning_effort を指定してください", 2);
+    const meta = loadAgentMetadata(name);
+    if (meta.kind !== "claude" && meta.kind !== "codex") {
+        throw new AitermError("agent_configure はClaudeとCodexのsessionだけに対応します", 2);
+    }
+    bindCompletedInitialPrompt(meta);
+    const ready = await waitAgentTuiReady(name, meta, AGENT_TUI_READY_TIMEOUT_MS);
+    if (!ready.ready)
+        throw new AitermError(`agent session '${name}' は入力待ちではありません`, 2);
+    if (meta.kind === "claude") {
+        if (model) {
+            await sendAgentPromptText(name, `/model ${model}`);
+            const modelReady = await waitAgentTuiReady(name, meta, AGENT_TUI_READY_TIMEOUT_MS);
+            if (!modelReady.ready)
+                throw new AitermError(`Claudeのmodel変更完了を確認できません`, 2);
+        }
+        if (effort) {
+            await sendAgentPromptText(name, `/effort ${effort}`);
+            const effortReady = await waitAgentTuiReady(name, meta, AGENT_TUI_READY_TIMEOUT_MS);
+            if (!effortReady.ready)
+                throw new AitermError(`Claudeのeffort変更完了を確認できません`, 2);
+        }
+        return {
+            schema: "aiterm.agent-configure-result.v1",
+            session_id: name,
+            provider: "claude",
+            model,
+            reasoning_effort: effort,
+        };
+    }
+    await sendAgentPromptText(name, "/model");
+    const modelScreen = await waitForScreenText(name, "Select Model and Effort");
+    if (model) {
+        const choice = codexModelChoice(modelScreen, model);
+        if (!choice)
+            throw new AitermError(`Codexの/modelに ${model} がありません`, 2);
+        sendMenuChoice(name, choice);
+    }
+    else {
+        sendMenuChoice(name, "Enter");
+    }
+    let effortScreen = await waitForScreenText(name, "Select Reasoning Level");
+    if (effort) {
+        let choice = codexEffortChoice(effortScreen, effort);
+        if (!choice && (effort === "max" || effort === "ultra")) {
+            const more = codexMoreReasoningChoice(effortScreen);
+            if (more) {
+                sendMenuChoice(name, more);
+                effortScreen = await waitForScreenText(name, "Advanced Reasoning");
+                choice = codexEffortChoice(effortScreen, effort);
+            }
+        }
+        if (!choice)
+            throw new AitermError(`Codexの/modelに reasoning_effort=${effort} がありません`, 2);
+        sendMenuChoice(name, choice);
+    }
+    else {
+        sendMenuChoice(name, "Enter");
+    }
+    await waitForScreenText(name, "Model changed to");
+    return {
+        schema: "aiterm.agent-configure-result.v1",
+        session_id: name,
+        provider: "codex",
+        model,
+        reasoning_effort: effort,
+    };
+}
+export function __testCodexConfigureChoices(screen, model, effort) {
+    return {
+        model: codexModelChoice(screen, model),
+        effort: codexEffortChoice(screen, effort),
+        more: codexMoreReasoningChoice(screen),
+    };
+}
 // v0.16.0: 親をブロックする wait 経路は廃止した。send は ready gate と submit 分離を内蔵した
 // dispatch として即返り、event_cursor（送信直前のvendor完了正本境界）を receipt で返す。
 // 完了通知は aiterm-wait（--cursor で境界を渡す）、回収は pty_read / claude_turn recover が担う。

package/dist/index.js

@@ -396,6 +396,33 @@ server.registerTool("claude_approval", {
         return fail(e);
     }
 });
+server.registerTool("agent_configure", {
+    description: "起動済みのCodex／Claude agent sessionを再起動せず、会話contextを保ったままmodel／reasoning effortを変更する。" +
+        "ClaudeはCLI標準の/model・/effort、CodexはCLI標準の/model選択画面を使う。",
+    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を変更しない"),
+    },
+    outputSchema: {
+        schema: z.literal("aiterm.agent-configure-result.v1"),
+        session_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
+        provider: z.enum(["claude", "codex"]),
+        model: z.string().nullable(),
+        reasoning_effort: z.string().nullable(),
+    },
+}, async ({ session_id, model, reasoning_effort }) => {
+    try {
+        const result = await core.configureAgent(session_id, { model, reasoning_effort });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            structuredContent: { ...result },
+        };
+    }
+    catch (e) {
+        return fail(e);
+    }
+});
 // 対話型エージェント起動ツール（モデルごとに1つ＝ツール名/説明でどのモデルか一目で分かる）。
 // いずれも永続端末に TUI を起動し session_id を返す。以後 pty_read/pty_send で対話操作する。
 const agentModelDesc = (kind) => kind === "claude"

package/dist/runtime-error-store.js

@@ -532,10 +532,15 @@ export class RuntimeErrorStore {
             ticket = path.join(queue, ticketName);
             this.publishOwnerFile(ticket, owner);
             fs.unlinkSync(choosing);
-            const deadline = Date.now() + 1_500;
+            // 期限はqueue全体の総待ち時間ではなく、同じ先頭ownerが進まない時間を測る。
+            // 正常な前任者がticketを順に解放するたびに予算を更新し、長いqueueをbusyと誤認しない。
+            let deadline = Date.now() + 1_500;
+            let blockingTicket = null;
+            let choosingBlockers = new Set();
             for (;;) {
                 const names = fs.readdirSync(queue).sort();
                 let hasLiveChoosing = false;
+                const liveChoosing = new Set();
                 for (const name of names.filter((candidate) => choosingPattern.test(candidate))) {
                     const currentPath = path.join(queue, name);
                     let current;
@@ -549,10 +554,17 @@ export class RuntimeErrorStore {
                     }
                     if (name !== `choosing-${current.token}.json`)
                         throw new Error("runtime error choosing entry が不正です");
-                    const identity = processStartIdentity(current.pid, this.platform, identityTimeoutMs);
-                    const live = identity === current.start_id || (!identity && processExists(current.pid));
-                    if (live)
+                    // 通常待機ではkill(0)だけを使う。macOSのprocess start identityは外部psを起動するため、
+                    // 全waiterが全pollで呼ぶとqueue自身が進めなくなる。PID再利用の照合はstall時だけ行う。
+                    let live = processExists(current.pid);
+                    if (live && Date.now() >= deadline) {
+                        const identity = processStartIdentity(current.pid, this.platform, identityTimeoutMs);
+                        live = identity === current.start_id || (!identity && processExists(current.pid));
+                    }
+                    if (live) {
                         hasLiveChoosing = true;
+                        liveChoosing.add(name);
+                    }
                     else {
                         try {
                             fs.unlinkSync(currentPath);
@@ -564,11 +576,17 @@ export class RuntimeErrorStore {
                     }
                 }
                 if (hasLiveChoosing) {
+                    if (choosingBlockers.size === 0
+                        || [...choosingBlockers].some((name) => !liveChoosing.has(name))) {
+                        deadline = Date.now() + 1_500;
+                    }
+                    choosingBlockers = liveChoosing;
                     if (Date.now() >= deadline)
                         throw new Error("runtime error store is busy");
                     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
                     continue;
                 }
+                choosingBlockers = new Set();
                 let firstLive = null;
                 const ticketNames = fs.readdirSync(queue).sort();
                 for (const name of ticketNames.filter((candidate) => ticketPattern.test(candidate))) {
@@ -584,8 +602,11 @@ export class RuntimeErrorStore {
                     }
                     if (!name.endsWith(`-${current.token}.ticket`))
                         throw new Error("runtime error lock ticket が不正です");
-                    const identity = processStartIdentity(current.pid, this.platform, identityTimeoutMs);
-                    const live = identity === current.start_id || (!identity && processExists(current.pid));
+                    let live = processExists(current.pid);
+                    if (live && name === blockingTicket && Date.now() >= deadline) {
+                        const identity = processStartIdentity(current.pid, this.platform, identityTimeoutMs);
+                        live = identity === current.start_id || (!identity && processExists(current.pid));
+                    }
                     if (!live) {
                         try {
                             fs.unlinkSync(currentPath);
@@ -601,6 +622,10 @@ export class RuntimeErrorStore {
                 }
                 if (firstLive === ticketName)
                     break;
+                if (firstLive !== blockingTicket) {
+                    blockingTicket = firstLive;
+                    deadline = Date.now() + 1_500;
+                }
                 if (Date.now() >= deadline)
                     throw new Error("runtime error store is busy");
                 Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.23.1",
+  "version": "0.24.2",
   "mcpName": "io.github.kitepon-rgb/aiterm-mcp",
   "description": "Persistent tmux terminal MCP that lets Claude Code drive Codex CLI's interactive TUI, including slash commands and $imagegen. Also runs durable PTY sessions for SSH, containers, REPLs, and coding agents.",
   "keywords": [