aiterm-mcp 0.47.1 → 0.49.0

package/CHANGELOG.md

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

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.47.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.49.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -510,6 +510,12 @@ aiterm は同じ核心の洞察——端末を出会いの場にする——を
 `background_cpu_delta_complete`はpane開始から60秒以降に生成された子孫だけの同じ観測で、起動時MCPを除外する。
 `token_hint`は画面の直近token表示値またはnull。画面本文や生argvを解析する必要はない。
 
+agent sessionを閉じると失うものは、次の2項目で分かる。`activity.post_startup_process_count`は、`agent_launch`の起動準備が
+完了した時点（初手を送る前）に居なかったprocessの数。起動直後の1分に始めた裏の作業も数える。Codex自身の補助process
+（`codex-code-mode-host`）は数えない。`pending_child_deliveries`は、そのsessionが親として待っていて、まだ届け終えていない
+子の結果の数。呼び出した側が誰でも付く。どちらも、分からない時はnull（通常PTY、harnessのprocessを特定できない時。
+processの数は0.48.0以前が起動したagentも）。別端末が旧版の時は項目ごと無い。nullと項目なしは「分からない」で、0ではない。
+
 `agent_launch({ harness, cwd, trust_project: true })`はpromptなしでも既知のworkspace・project hooks・MCP初期同意を
 進め、入力受付とharness生存を確認して`startup.status="ready"`を返す。指定なしのpromptなし起動は`not_checked`。
 Claude Code初回起動の文字表示テーマ選択では、画面で選択済みの項目を確定して起動を続ける。
@@ -554,6 +560,17 @@ Claudeの相関済み承認は既存の`claude_approval`を使う。
 
 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 の純粋テストだけであり、新しい実機統合成功は主張しない。
 
+### BugHubへの報告（既定では無効）
+
+Aitermは、既定では実行時エラーをどこへも送らない。送るのは、次の2つがそろった端末だけ。
+
+1. `aiterm-runtime-errors reporting enable` で明示して有効にした。
+2. BugHubの持ち主が置いた合鍵のファイルがある（POSIXは `~/.config/bughub/product-credentials/aiterm-mcp.json`、Windowsは `%LOCALAPPDATA%\bughub\product-credentials\aiterm-mcp.json`）。本人だけが読める通常のファイルでなければ読まない。
+
+宛先は合鍵のファイルから読む。送る中身は、エラーのコード・回数・最初と最後の時刻・版・重さ・解決の印だけで、prompt・path・stackは保存も送信もしない。送るのは別processで、MCP processは通信しない。きっかけは、エラーを記録した時・解決や開き直しをした時・MCPの起動時（未報告がある時だけ、多くても1時間に1回）と、`aiterm-runtime-errors report`（その場で1回、1分に1回まで）。応答の署名まで確かめた時だけ受け取り済みにし、確かめられない時は次の機会に送り直す。
+
+`aiterm-runtime-errors reporting status` は、有効・無効、合鍵の状態（`ready`／`missing`／`rejected`）、未報告の件数、最後の送信の結果を返す。止める時は `aiterm-runtime-errors reporting disable`。報告を有効にした端末は、工場の収集設定が無くても記録が有効になる。
+
 ### 対話エージェントharness
 
 `agent_launch`は選んだharnessの対話TUIを新しい永続PTYに起動し、`session_id`を返す。harnessはagent loop・認証・hook・session・transcriptを所有し、modelは独立。以後は他sessionと同じ`pty_read`／`pty_send`で操作する。

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.47.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).
+**Status:** actively maintained · current public release **v0.49.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -542,6 +542,13 @@ between observations, the delta covers only observed increments and `cpu_delta_c
 only to descendants created at least 60 seconds after the pane, excluding startup MCP processes. `token_hint` is the latest
 displayed token count or null. Callers do not need raw argv or pane-text parsing.
 
+Two fields tell a caller what closing an agent session would lose. `activity.post_startup_process_count` is the number of
+processes in the session that did not exist when `agent_launch` finished startup (before the first prompt), so background work
+started in the first minute is counted too; Codex's own `codex-code-mode-host` helper is not counted. `pending_child_deliveries`
+is the number of sub-agent results this session is still waiting for as a parent, whoever the caller is. Both are null when
+Aiterm cannot tell (ordinary terminals, agents launched by 0.48.0 or earlier for the process count, or an unresolved harness
+process), and may be absent when a remote host runs an older Aiterm. Treat null or absent as unknown, not as zero.
+
 `agent_launch({ harness, cwd, trust_project: true })` completes known workspace, project-hook, and project-MCP startup
 consent even without a prompt, then verifies input readiness and harness liveness before returning `startup.status="ready"`.
 For Claude Code's first-run text-style menu, it confirms the item already selected on screen before continuing startup.
@@ -589,6 +596,18 @@ snapshotの`product_version`は各recordの最終実発生時の版を表す。s
 
 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.
 
+**Reporting to BugHub is off by default.** Aiterm sends runtime errors nowhere unless both hold: the user ran
+`aiterm-runtime-errors reporting enable`, and a credential file placed by the BugHub owner exists
+(`~/.config/bughub/product-credentials/aiterm-mcp.json`, or `%LOCALAPPDATA%\bughub\product-credentials\aiterm-mcp.json` on Windows;
+it is read only when it is a regular file readable by its owner alone). The destination comes from that file. The payload is the
+cumulative error codes, counts, first/last timestamps, versions, severity, and resolution marks; prompts, paths, and stacks are neither
+stored nor sent. A separate process does the sending, never the MCP process, and there is no polling: a report is attempted when an error
+is recorded, when a record is resolved or reopened, and when the MCP server starts (only while something is unreported, at most once per
+hour), or on `aiterm-runtime-errors report` (once, at most once per minute). A record becomes acknowledged only after the response
+signature is verified; otherwise the next attempt resends the then-current totals. `aiterm-runtime-errors reporting status` shows the
+switch, the credential state, the unreported count, and the last attempt; `reporting disable` turns it off. Enabling reporting also
+enables collection on that host.
+
 ### Interactive agent harnesses
 
 `agent_launch` starts a selected harness's interactive coding-agent TUI inside a fresh persistent PTY and returns its `session_id`. The harness owns the agent loop, authentication, hooks, session, and transcript; `model` is independent. The TUI is a full-screen app, so read it with `pty_read({ screen: true })` for the rendered view.

package/dist/core.js

@@ -15,13 +15,14 @@ import { fileURLToPath } from "node:url";
 import * as rtk from "./rtk.js";
 import { isCursorMcpClient } from "aiterm-steer-delivery";
 import { paneTokenHint } from "./harnesses/pane-tokens.js";
+import { unfinishedDeliveriesOwnedBy } from "./parent-delivery-owners.js";
 import { readRuntimeProcesses, processSubtree, parentProcess, processIdentity, backgroundProcesses } from "./process-runtime.js";
 import { AitermError, telemetryOwnedFailure, ownTelemetryFailure } from "./errors.js";
 import { isWin, SOCKDIR, tmuxCommand, sendPsmuxPayload, loadPtyBufferChunk, pasteBufferBaseArgs, TMUX_EMPTY_CONFIG, attachCommand, normalizePaneCommand, atomicShellMultiline, appendMarkSentinel, markShellCommand, settlePaneLog, paneCwdArgument, sessionEnvironmentLaunch, } from "./tmux-runtime.js";
 import { sleep, currentUid, runtimeStateBase, safeStatSize, readFileRange, writeJson0600, createEmpty0600, shq, LAUNCH_ID_RE, AGENT_DONE_POLL_MS, AGENT_EVENT_MAX_BYTES, assertSessionName, agentsDir, agentEventPath, agentMetadataPath, writeAgentMetadata, AGENT_EVENT_TAIL_BYTES, agentLabel, agentHarness, subagentInstruction, agentLineageFields, } from "./agent-shared.js";
 import { catalogUnavailable } from "./model-catalog.js";
 import { grokAuthPlan, grokAuthStatus, grokAuthPane, realGrokHome, resolveAndValidateGrokAuth, assertGrokModelAvailable, grokModelChoices, grokEventsTranscript, latestGrokCompletion, observeGrokDone, buildGrokAgentCmd, grokLaunchNote, grokEnvTokens, grokTuiReady, grokTuiBusy, grokPaneObservation, grokRateLimitDialog, grokStartupAction, grokLaunchBlockingDialog, assertGrokSandboxNotRejected, GROK_COMPOSER_MARKER_RE, grokFooterHasConfiguration, grokTranscriptText, createGrokAgentMetadata, } from "./harnesses/grok.js";
-import { codexAuthPlan, codexAuthStatus, codexAuthPane, bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexRateLimitModelSwitchDialog, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, codexModelChoices, } from "./harnesses/codex.js";
+import { codexAuthPlan, codexAuthStatus, codexAuthPane, bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexHelperProcess, codexRateLimitModelSwitchDialog, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, codexModelChoices, } from "./harnesses/codex.js";
 import { claudeAuthPlan, claudeAuthStatus, claudeAuthPane, OPERATION_ID_RE, CLAUDE_RESULT_MAX_BYTES, CLAUDE_EFFORTS, agentManagedClaudeSettingsPath, agentClaudeResultPath, agentClaudeOperationPath, agentClaudeApprovalReceiptPath, agentClaudeDispatchReceiptPath, validateOperationId, readClaudeResultText, assertClaudeAuthenticationReady, claudeModelChoices, buildClaudeAgentCmd, claudeLaunchNote, claudeTuiReady, claudePaneObservation, claudeUsageLimit, claudeStartupAction, claudeLoginMethodMenu, CLAUDE_COMPOSER_MARKER_RE, createClaudeAgentMetadata, claudeSessionTranscriptPath, claudeApiErrorFromLine, claudeApiErrorAfter, } from "./harnesses/claude.js";
 import { cursorAuthPlan, cursorAuthStatus, cursorAuthPane, bindCursorTranscriptSession, cursorTurnBoundary, latestCursorCompletion, observeCursorDone, cursorTranscriptText, assertCursorAuthenticationReady, assertCursorModelAvailable, cursorModelChoices, buildCursorAgentCmd, cursorAgentArgv, cursorPwshLaunchLine, cursorPromptWithLineage, createCursorAgentMetadata, cursorLaunchNote, cursorEffortNavigation, cursorTuiReady, cursorPaneObservation, cursorPromptHooksRunning, cursorUsageLimit, CURSOR_SUBMIT_SEQUENCE, CURSOR_COMPOSER_CONTENT_MARKER_RE, validateCursorModelEffort, } from "./harnesses/cursor.js";
 import { readInterimWords, recordInterimBoundary } from "./interim-words.js";
@@ -1085,9 +1086,10 @@ export function observeSession(name, cursor) {
         schema: "aiterm.pty-observe-result.v1", session_id: name, observed_at: new Date().toISOString(),
         exists: !!listed, harness: null, launch_id: null, state: "missing", reason: "session_missing",
         pane_alive: false, harness_alive: null, pane_process: null, harness_process: null, process_identity: null,
-        token_hint: null,
+        token_hint: null, pending_child_deliveries: null,
         activity: { cursor: null, output_changed: null, cpu_seconds: null, cpu_delta_seconds: null, cpu_delta_complete: null,
-            background_cpu_seconds: null, background_cpu_delta_seconds: null, background_cpu_delta_complete: null },
+            background_cpu_seconds: null, background_cpu_delta_seconds: null, background_cpu_delta_complete: null,
+            post_startup_process_count: null },
     };
     if (!listed)
         return result;
@@ -1164,6 +1166,10 @@ export function observeSession(name, cursor) {
         screen_digest: createHash("sha256").update(screen).digest("hex"), processes, background_processes: backgroundCpu,
     };
     const comparable = previous?.pane_identity === sample.pane_identity;
+    // 起動完了の控えが無いsession（通常PTY、控える前の版で起動したagent）とharnessを特定できない時は数えない。
+    const startup = agent && Array.isArray(meta?.startup_processes) ? new Set(meta.startup_processes) : null;
+    // このsessionが親として待っている子の結果。持ち主はharnessの下で動くAitermのMCP process。
+    result.pending_child_deliveries = agent ? unfinishedDeliveriesOwnedBy(activityRows) : null;
     result.activity = {
         cursor: Buffer.from(JSON.stringify(sample)).toString("base64url"),
         output_changed: comparable ? previous.screen_digest !== sample.screen_digest : null,
@@ -1173,6 +1179,9 @@ export function observeSession(name, cursor) {
         background_cpu_seconds: Object.values(backgroundCpu).reduce((sum, cpu) => sum + cpu, 0),
         background_cpu_delta_seconds: comparable ? Object.entries(backgroundCpu).reduce((sum, [identity, cpu]) => sum + cpu - (previous.background_processes[identity] ?? 0), 0) : null,
         background_cpu_delta_complete: comparable ? Object.keys(previous.background_processes).every(identity => identity in backgroundCpu) : null,
+        post_startup_process_count: startup ? new Set(activityRows
+            .filter(row => !(meta?.kind === "codex" && codexHelperProcess(row.command)))
+            .map(row => `${row.pid}:${row.started_identity}`).filter(identity => !startup.has(identity))).size : null,
     };
     return result;
 }
@@ -1989,6 +1998,8 @@ function loadAgentMetadata(name) {
         initial_prompt_delivery: m.initial_prompt_delivery, initial_prompt_cursor: m.initial_prompt_cursor,
     };
     const executableFields = m.agent_executable === undefined ? {} : { agent_executable: m.agent_executable };
+    const startupFields = Array.isArray(m.startup_processes) && m.startup_processes.every((identity) => typeof identity === "string")
+        ? { startup_processes: m.startup_processes } : {};
     if (m.kind === "claude") {
         const expectedSettings = agentManagedClaudeSettingsPath(name, m.launch_id);
         const expectedResult = agentClaudeResultPath(name, m.launch_id);
@@ -2016,6 +2027,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             launch_operation_id: launchOperationId,
             launch_request_digest: launchRequestDigest,
             hook_route: "shared_claude_settings",
@@ -2047,6 +2059,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             hook_route: "shared_codex_home",
             completion_route: "codex_transcript",
             ...loadAgentLineageFields(m, true),
@@ -2074,6 +2087,7 @@ function loadAgentMetadata(name) {
             initial_prompt: normalizeInitialPromptState(m.initial_prompt),
             ...deliveryFields,
             ...executableFields,
+            ...startupFields,
             hook_route: "shared_cursor_home",
             completion_route: "cursor_transcript",
             ...loadAgentLineageFields(m, true),
@@ -2109,6 +2123,7 @@ function loadAgentMetadata(name) {
         initial_prompt: normalizeInitialPromptState(m.initial_prompt),
         ...deliveryFields,
         ...executableFields,
+        ...startupFields,
         hook_route: "shared_grok_home",
         completion_route: "grok_transcript",
         ...loadAgentLineageFields(m, true),
@@ -3202,6 +3217,11 @@ async function prepareAgentInput(name, meta, options) {
     const live = observeSession(name);
     if (live.harness_alive !== true || live.harness_process === null || live.state !== "idle")
         return { status: "blocked", reason: live.reason };
+    // ここまでに居るprocessは起動時の足場（harness・MCP・起動時hook）。初手を送る前に控える。
+    if (live.activity.cursor !== null) {
+        meta.startup_processes = Object.keys(decodeActivityCursor(live.activity.cursor, name).processes);
+        writeAgentMetadata(meta);
+    }
     return { status: "ready", reason: "composer_ready" };
 }
 export async function sendInitialAgentPrompt(name, text, o = {}) {
@@ -3849,8 +3869,13 @@ export async function dispatchAgentTurn(name, text, o = {}) {
                 const reason = grokPaneObservation(ready.lastScreen).reason;
                 throw new AitermError(`GROK_RATE_LIMIT_RECOVERY_FAILED: ${reason}。上限パネル解除後の入力受付を確認できません。今回の文字列は送信していません。`, 2);
             }
+            // 待たずに断るのは、応答が要る既知の画面（承認・確認のmodal）の時。どの画面で断ったかを残す。
+            const state = meta.kind === "grok" ? grokPaneObservation(ready.lastScreen)
+                : meta.kind === "codex" ? codexPaneObservation(ready.lastScreen)
+                    : meta.kind === "claude" ? claudePaneObservation(ready.lastScreen) : cursorPaneObservation(ready.lastScreen);
             throw new AitermError(`agent session '${name}' の ${agentLabel(meta.kind)} TUI が入力受付状態になりません。文字列は送信していません。` +
-                "少し後で pty_read(screen:true) を確認し、TUI が起動済みなら再度 pty_send してください。", 2);
+                "少し後で pty_read(screen:true) を確認し、TUI が起動済みなら再度 pty_send してください。" +
+                `\nstate=${state.state} reason=${state.reason}`, 2);
         }
     }
     if (codexRateLimitModelSwitch)
@@ -3928,10 +3953,17 @@ const CURSOR_FOLLOW_UP_STEER_RE = /enter steer · /;
 const cursorSteerQueued = (screen) => CURSOR_FOLLOW_UP_STEER_RE.test(screen.split("\n").filter(line => line.trim()).slice(-30).join("\n"));
 const STEER_SCREEN_POLL_MS = 100;
 const STEER_SCREEN_MAX_SAMPLES = 50;
-async function waitSteerScreen(name, predicate) {
-    for (let i = 0; i < STEER_SCREEN_MAX_SAMPLES; i++) {
+// 待ち行列の表示が遅い端末がある（fox 2026-10-03: Cursorへ送ってから表示まで8〜9秒。5秒で打ち切って3回とも失敗した）。
+// 子のturnが続いている間は、文は待ち行列へ入るしかないので、ここまで待つ。
+const STEER_SCREEN_RUNNING_MAX_SAMPLES = 300;
+const STEER_RUNNING_CHECK_SAMPLES = 10;
+async function waitSteerScreen(name, predicate, stillRunning) {
+    for (let i = 0; i < STEER_SCREEN_RUNNING_MAX_SAMPLES; i++) {
         if (predicate(captureScreen(name, AGENT_TUI_READY_LINES)))
             return true;
+        // 短い待ちを過ぎたら、子のturnが続いている間だけ待ちを延ばす。終わっていれば、これ以上待っても表示は変わらない。
+        if (i >= STEER_SCREEN_MAX_SAMPLES && i % STEER_RUNNING_CHECK_SAMPLES === 0 && !stillRunning())
+            return false;
         await sleep(STEER_SCREEN_POLL_MS);
     }
     return false;
@@ -4012,13 +4044,17 @@ async function steerRunningTurn(name, meta, text, o) {
         : meta.kind === "cursor" ? cursorSteerQueued : null;
     if (queued) {
         const label = meta.kind === "cursor" ? "Cursor" : "Grok";
-        if (!await waitSteerScreen(name, queued)) {
+        // Cursorはturn_endedを記録へ書いた後も画面にbusy表示を残すので、記録で見る。Grokは画面で見る。
+        const stillRunning = () => meta.kind === "cursor"
+            ? latestCursorCompletion(meta, readTranscriptLines) === null
+            : isAgentTuiBusy(meta.kind, captureScreen(name, AGENT_TUI_READY_LINES));
+        if (!await waitSteerScreen(name, queued, stillRunning)) {
             throw new AitermError(`STEER_NOT_QUEUED vendor=${meta.kind} session=${name}\n` +
                 `差し込む文が${label}の待ち行列へ入ったことを確認できません。子のturnが送る直前に終わっていた時は、` +
                 `文は新しいturnとして始まっており、その完了は通知されません。再送する前にpty_read(screen:true)で確かめてください。`, 2);
         }
         sendKey(name, "Enter");
-        if (!await waitSteerScreen(name, screen => !queued(screen))) {
+        if (!await waitSteerScreen(name, screen => !queued(screen), stillRunning)) {
             throw new AitermError(`STEER_STILL_QUEUED vendor=${meta.kind} session=${name}\n` +
                 `差し込む文が${label}の待ち行列に残っています。現在のturnが終わると別turnとして実行されます。`, 2);
         }

package/dist/harnesses/claude.js

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

package/dist/harnesses/codex.js

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

package/dist/index.js

@@ -15,6 +15,7 @@ import { z } from "zod";
 import { agentModelsResult } from "./model-catalog.js";
 import * as core from "./core.js";
 import { runtimeErrorStoreDiagnostic } from "./runtime-error-store.js";
+import { triggerRuntimeErrorReport } from "./runtime-error-report.js";
 import { createRequire } from "node:module";
 import { ParentDeliveryManager, deliveryKey } from "./parent-delivery.js";
 import { acceptRemote, callRemoteTool, observeRemoteAgentDone, remoteInputDescription, remoteInputSchema, remoteLabel, remoteWaitProcess } from "./remote.js";
@@ -596,10 +597,12 @@ registerRemoteAwareTool("pty_observe", {
         pane_process: nativeProcessIdentitySchema.nullable(), harness_process: nativeProcessIdentitySchema.nullable(),
         process_identity: nativeProcessIdentitySchema.nullable(),
         token_hint: z.number().nullable(),
+        pending_child_deliveries: z.number().nullable().optional(),
         parent_deliveries: z.array(parentDeliveryOutputSchema).optional(),
         activity: z.object({ cursor: z.string().nullable(), output_changed: z.boolean().nullable(),
             cpu_seconds: z.number().nullable(), cpu_delta_seconds: z.number().nullable(), cpu_delta_complete: z.boolean().nullable(),
-            background_cpu_seconds: z.number().nullable(), background_cpu_delta_seconds: z.number().nullable(), background_cpu_delta_complete: z.boolean().nullable() }),
+            background_cpu_seconds: z.number().nullable(), background_cpu_delta_seconds: z.number().nullable(), background_cpu_delta_complete: z.boolean().nullable(),
+            post_startup_process_count: z.number().nullable().optional() }),
     },
 }, async ({ session_id, cursor }, extra) => {
     try {
@@ -1120,6 +1123,8 @@ async function main() {
     };
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // 受け口がまだ受け取っていない実行時エラーがあれば、別processで送る（明示して有効にした端末だけ。既定では何も起動しない）。
+    triggerRuntimeErrorReport();
 }
 main().catch((e) => {
     console.error("aiterm-mcp fatal:", e);

package/dist/parent-delivery-owners.js

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

package/dist/parent-delivery.js

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

package/dist/runtime-error-os.js

@@ -23,6 +23,50 @@ export function defaultRuntimeErrorPaths(options = {}) {
         storePath: path.join(stateHome, "aiterm-mcp", "runtime-errors.json"),
     };
 }
+// BugHubへの報告で使う場所。有効スイッチはAiterm自身の設定、合鍵はBugHubの持ち主が端末へ置くファイル。
+export function defaultRuntimeErrorReportPaths(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const home = options.home ?? os.homedir();
+    if (platform === "win32") {
+        const base = options.localAppData ?? process.env.LOCALAPPDATA ?? path.win32.join(home, "AppData", "Local");
+        return {
+            reportingConfigPath: path.win32.join(base, "aiterm-mcp", "runtime-error-reporting.json"),
+            credentialPath: path.win32.join(base, "bughub", "product-credentials", "aiterm-mcp.json"),
+            reportStatePath: path.win32.join(base, "aiterm-mcp", "runtime-errors-report.json"),
+        };
+    }
+    const configHome = options.xdgConfigHome ?? process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+    const stateHome = options.xdgStateHome ?? process.env.XDG_STATE_HOME ?? path.join(home, ".local", "state");
+    return {
+        reportingConfigPath: path.join(configHome, "aiterm-mcp", "runtime-error-reporting.json"),
+        credentialPath: path.join(configHome, "bughub", "product-credentials", "aiterm-mcp.json"),
+        reportStatePath: path.join(stateHome, "aiterm-mcp", "runtime-errors-report.json"),
+    };
+}
+const MAX_REPORTING_CONFIG_BYTES = 4 * 1024;
+/** 報告の有効スイッチの状態。ファイルが無ければ無効（既定）。形が違うファイルは有効とみなさない。 */
+export function runtimeErrorReportingStatus(file, platform = process.platform) {
+    let text;
+    try {
+        text = readBoundedFile(file, MAX_REPORTING_CONFIG_BYTES, platform, false);
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? "disabled" : "malformed";
+    }
+    try {
+        const config = JSON.parse(text);
+        if (typeof config !== "object" || config === null || Array.isArray(config))
+            return "malformed";
+        const keys = Object.keys(config);
+        const value = config;
+        if (keys.length !== 2 || value.schema_version !== "1.0" || typeof value.enabled !== "boolean")
+            return "malformed";
+        return value.enabled ? "enabled" : "disabled";
+    }
+    catch {
+        return "malformed";
+    }
+}
 const WINDOWS_DACL_VERIFY_SCRIPT = String.raw `
 $ErrorActionPreference='Stop'
 $target=$env:AITERMMCP_ACL_PATH; $kind=$env:AITERMMCP_ACL_KIND

package/dist/runtime-error-report.js

@@ -0,0 +1,263 @@
+// BugHubへの実行時エラーの報告。明示して有効にした端末だけが、合鍵のファイルにある宛先へ累計を送る。
+// 既定では通信しない。送るのは常に別processで、MCP processは通信しない。判断はADR 0079。
+import { spawn } from "node:child_process";
+import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import * as fs from "node:fs";
+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 { 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));
+const REPORT_SCHEMA = "1.0";
+const REPORT_STATE_SCHEMA = "1.0";
+const MAX_REPORT_RECORDS = 500;
+const MAX_REPORT_BYTES = 512 * 1024;
+const MAX_CREDENTIAL_BYTES = 8 * 1024;
+const MAX_RESPONSE_BYTES = 64 * 1024;
+const REQUEST_TIMEOUT_MS = 10_000;
+// 受け口の上限は端末×製品ごとに1分に1回。自動の送信は、未受領がある時だけ、多くても1時間に1回。
+const MANUAL_MIN_INTERVAL_MS = 60_000;
+const AUTO_MIN_INTERVAL_MS = 60 * 60_000;
+const LOCK_STALE_MS = 2 * 60_000;
+/** 契約にある項目だけを載せる。端末名・OS・arch・保存用の連番は送らない（端末は合鍵から決まる）。 */
+export function buildRuntimeErrorReport(records, options) {
+    if (records.length > MAX_REPORT_RECORDS)
+        throw new Error(`1回のreportは${MAX_REPORT_RECORDS}件までです`);
+    return {
+        schema_version: REPORT_SCHEMA,
+        report_id: options.reportId,
+        product_id: "aiterm-mcp",
+        installed_version: options.installedVersion,
+        observed_at: options.observedAt,
+        runtime_errors: records.map((record) => ({
+            fingerprint: record.fingerprint, error_code: record.error_code, component: record.component,
+            message_template: record.message_template, severity: record.severity, status: record.status,
+            occurrence_count: record.occurrence_count, first_seen: record.first_seen, last_seen: record.last_seen,
+            product_version: record.product_version, state_schema_version: record.state_schema_version,
+        })),
+        resolutions: records.filter((record) => record.status === "resolved" && record.resolved_at !== null && record.reason_code !== null)
+            .map((record) => ({ fingerprint: record.fingerprint, resolved_at: record.resolved_at, reason_code: record.reason_code })),
+    };
+}
+export function reportBodyDigest(body) {
+    return createHash("sha256").update(body).digest("hex");
+}
+/** sig = HMAC-SHA256(secret, ts + "\n" + 送ったバイト列のSHA-256の16進)。secretは文字列をそのままUTF-8で鍵にする。 */
+export function signReport(secret, ts, body) {
+    return createHmac("sha256", Buffer.from(secret, "utf8")).update(`${ts}\n${reportBodyDigest(body)}`).digest("hex");
+}
+export function reportAuthorization(keyId, ts, sig) {
+    return `BugHub-HMAC-SHA256 key_id=${keyId}, ts=${ts}, sig=${sig}`;
+}
+/** 受領とみなすのは、accepted・report_idの一致・応答の署名がそろった時だけ。別の機器が返した200を受領にしない。 */
+export function verifyReportResponse(secret, reportId, response) {
+    if (typeof response !== "object" || response === null || Array.isArray(response))
+        return false;
+    const value = response;
+    if (value.accepted !== true || value.report_id !== reportId)
+        return false;
+    if (typeof value.received_at !== "string" || typeof value.sig !== "string" || !/^[0-9a-f]{64}$/.test(value.sig))
+        return false;
+    const expected = createHmac("sha256", Buffer.from(secret, "utf8")).update(`${reportId}\n${value.received_at}`).digest();
+    return timingSafeEqual(expected, Buffer.from(value.sig, "hex"));
+}
+/** 合鍵のファイルは、本人だけが読める通常のファイルだけを読む。無い端末は「無い」と返し、失敗にしない。 */
+export function readProductCredential(file, platform = process.platform) {
+    let text;
+    try {
+        text = readBoundedFile(file, MAX_CREDENTIAL_BYTES, platform, true);
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? { status: "missing" } : { status: "rejected", reason: "unsafe_file" };
+    }
+    try {
+        const value = JSON.parse(text);
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return { status: "rejected", reason: "malformed" };
+        const credential = value;
+        if (Object.keys(credential).sort().join(",") !== "key_id,secret,url")
+            return { status: "rejected", reason: "malformed" };
+        if (typeof credential.url !== "string" || typeof credential.key_id !== "string" || typeof credential.secret !== "string"
+            || !/^[A-Za-z0-9._-]{1,128}$/.test(credential.key_id) || credential.secret.length < 1 || credential.secret.length > 1024) {
+            return { status: "rejected", reason: "malformed" };
+        }
+        const url = new URL(credential.url);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return { status: "rejected", reason: "malformed" };
+        return { status: "ready", credential: { url: credential.url, key_id: credential.key_id, secret: credential.secret } };
+    }
+    catch {
+        return { status: "rejected", reason: "malformed" };
+    }
+}
+export function setRuntimeErrorReporting(file, enabled) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify({ schema_version: "1.0", enabled })}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+const EMPTY_REPORT_STATE = () => ({
+    schema_version: REPORT_STATE_SCHEMA, last_attempt_at: null, last_status: null, last_http_status: null,
+    last_accepted_at: null, halted_credential_mtime_ms: null,
+});
+export function readReportState(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (value?.schema_version !== REPORT_STATE_SCHEMA)
+            return EMPTY_REPORT_STATE();
+        return { ...EMPTY_REPORT_STATE(), ...value };
+    }
+    catch {
+        return EMPTY_REPORT_STATE();
+    }
+}
+function writeReportState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+/**
+ * 未受領の記録がある時に、その時点の累計を1回送る。受領を確かめられた時だけ受け取り済みにする。
+ * 届いたか分からない時は何も進めない。次の機会に、その時点の累計を新しいreport_idで送り直す。
+ */
+export async function reportRuntimeErrors(options) {
+    const platform = options.platform ?? process.platform;
+    const paths = options.paths ?? defaultRuntimeErrorReportPaths({ platform });
+    const now = options.now ?? (() => new Date());
+    const result = (status, extra = {}) => ({ status, http_status: null, reported_records: 0, acknowledged_cursor: null, ...extra });
+    if (runtimeErrorReportingStatus(paths.reportingConfigPath, platform) !== "enabled")
+        return result("disabled");
+    const credential = readProductCredential(paths.credentialPath, platform);
+    if (credential.status === "missing")
+        return result("no_credential");
+    if (credential.status === "rejected")
+        return result("credential_rejected");
+    const store = options.store ?? new RuntimeErrorStore();
+    const snapshot = store.snapshot();
+    if (snapshot.collection !== "enabled" || snapshot.cursor <= snapshot.acknowledged_cursor)
+        return result("nothing_to_report");
+    const lock = `${paths.reportStatePath}.lock`;
+    fs.mkdirSync(path.dirname(lock), { recursive: true, mode: 0o700 });
+    try {
+        fs.mkdirSync(lock);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        // 別のprocessが送っている。途中で落ちたprocessの残りだけ、時間を置いて引き取る。
+        let stale = false;
+        try {
+            stale = now().getTime() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS;
+        }
+        catch { /* 相手が外した */ }
+        if (!stale)
+            return result("deferred");
+        try {
+            fs.rmdirSync(lock);
+            fs.mkdirSync(lock);
+        }
+        catch {
+            return result("deferred");
+        }
+    }
+    try {
+        const state = readReportState(paths.reportStatePath);
+        const started = now();
+        const sinceLast = state.last_attempt_at === null ? Infinity : started.getTime() - Date.parse(state.last_attempt_at);
+        if (sinceLast < (options.trigger === "auto" ? AUTO_MIN_INTERVAL_MS : MANUAL_MIN_INTERVAL_MS))
+            return result("deferred");
+        let credentialMtime = null;
+        try {
+            credentialMtime = fs.statSync(paths.credentialPath).mtimeMs;
+        }
+        catch { /* 読めた直後に消えた時は下の送信結果に任せる */ }
+        if (options.trigger === "auto" && state.halted_credential_mtime_ms !== null && state.halted_credential_mtime_ms === credentialMtime) {
+            return result("halted");
+        }
+        // tsとobserved_atは同じ時刻から作る（受け口は両者が10分より離れたreportを断る）。
+        // observed_atは秒へ切り捨てず、載せる記録のどの時刻よりも前にしない。受け口は、記録や解決が観測より後のreportを
+        // 422で断る。記録の時刻はミリ秒まで持つので、切り捨てると、記録の直後（同じ秒の中）の自動送信が断られていた。
+        const ts = String(Math.floor(started.getTime() / 1000));
+        const observed = Math.max(started.getTime(), ...snapshot.records.flatMap((record) => [Date.parse(record.last_seen), record.resolved_at === null ? 0 : Date.parse(record.resolved_at)]));
+        const reportId = randomUUID();
+        const report = buildRuntimeErrorReport(snapshot.records, {
+            installedVersion: options.installedVersion ?? pkg.version, reportId,
+            observedAt: new Date(observed).toISOString(),
+        });
+        const body = Buffer.from(JSON.stringify(report), "utf8");
+        if (body.byteLength > MAX_REPORT_BYTES)
+            throw new Error("reportが大きすぎます");
+        const finish = (status, httpStatus, acknowledged = null) => {
+            writeReportState(paths.reportStatePath, {
+                ...state, last_attempt_at: started.toISOString(), last_status: status, last_http_status: httpStatus,
+                last_accepted_at: status === "accepted" ? started.toISOString() : state.last_accepted_at,
+                halted_credential_mtime_ms: status === "halted" ? credentialMtime : null,
+            });
+            return result(status, { http_status: httpStatus, reported_records: report.runtime_errors.length, acknowledged_cursor: acknowledged });
+        };
+        let response;
+        let text;
+        try {
+            response = await (options.fetch ?? fetch)(credential.credential.url, {
+                method: "POST", redirect: "error", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                headers: {
+                    "content-type": "application/json",
+                    authorization: reportAuthorization(credential.credential.key_id, ts, signReport(credential.credential.secret, ts, body)),
+                },
+                body,
+            });
+            text = (await response.text()).slice(0, MAX_RESPONSE_BYTES);
+        }
+        catch {
+            return finish("delivery_unknown", null);
+        }
+        if (response.status === 200) {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch { /* 署名を確かめられない200は受領にしない */ }
+            if (!verifyReportResponse(credential.credential.secret, reportId, parsed))
+                return finish("delivery_unknown", 200);
+            store.acknowledge(snapshot.cursor);
+            return finish("accepted", 200, snapshot.cursor);
+        }
+        // 合鍵が無効な間は、同じファイルのまま自動で送り続けない。時刻のずれ（401 timestamp_skew）は合鍵の問題ではない。
+        if ((response.status === 401 && !/skew/i.test(text)) || response.status === 403)
+            return finish("halted", response.status);
+        if (response.status === 429)
+            return finish("rate_limited", 429);
+        if (response.status >= 500)
+            return finish("delivery_unknown", response.status);
+        return finish("rejected", response.status);
+    }
+    finally {
+        try {
+            fs.rmdirSync(lock);
+        }
+        catch { /* 古いlockとして引き取られた */ }
+    }
+}
+/**
+ * 自動の送信を別processへ頼む。呼ぶ側（MCP process・記録のworker・CLI）は通信しない。
+ * 有効でない端末では何も起動しない。node:testの子で動く時も起動しない（試験が、その端末の本物の記録を
+ * 開発中の版の名前で送らないように）。
+ */
+export function triggerRuntimeErrorReport(env = process.env) {
+    if (env.NODE_TEST_CONTEXT)
+        return false;
+    try {
+        if (runtimeErrorReportingStatus(defaultRuntimeErrorReportPaths().reportingConfigPath) !== "enabled")
+            return false;
+        const child = spawn(process.execPath, [WORKER, "report"], { stdio: "ignore", detached: true, windowsHide: true, env });
+        child.once("error", () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime-error-store.js

@@ -3,6 +3,7 @@ import { spawn, spawnSync } from "node:child_process";
 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 { 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";
@@ -183,6 +184,7 @@ function validateState(value, maxRecords = 256) {
 export class RuntimeErrorStore {
     configPath;
     storePath;
+    reportingConfigPath;
     platform;
     arch;
     productVersion;
@@ -194,6 +196,9 @@ export class RuntimeErrorStore {
         const defaults = defaultRuntimeErrorPaths(options);
         this.configPath = options.configPath ?? defaults.configPath;
         this.storePath = options.storePath ?? defaults.storePath;
+        this.reportingConfigPath = options.reportingConfigPath !== undefined ? options.reportingConfigPath
+            : options.configPath !== undefined || options.storePath !== undefined ? null
+                : defaultRuntimeErrorReportPaths(options).reportingConfigPath;
         this.platform = options.platform ?? process.platform;
         if (!ARCHES.has(options.arch ?? process.arch))
             throw new Error("arch が不正です");
@@ -206,7 +211,12 @@ export class RuntimeErrorStore {
         if (!Number.isInteger(this.maxRecords) || this.maxRecords < 1 || this.maxRecords > 256)
             throw new Error("maxRecords は 1..256 必須です");
     }
-    collectionStatus() { return collectionStatus(this.configPath, this.platform); }
+    // 報告を有効にした端末は、記録も有効。工場の収集設定が無くても、製品が自分の記録を持てる。
+    collectionStatus() {
+        if (this.reportingConfigPath !== null && runtimeErrorReportingStatus(this.reportingConfigPath, this.platform) === "enabled")
+            return "enabled";
+        return collectionStatus(this.configPath, this.platform);
+    }
     assertPrivateDirectory(dir) {
         const info = fs.lstatSync(dir);
         if (!info.isDirectory() || info.isSymbolicLink())

package/dist/runtime-error-worker.js

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { RuntimeErrorStore, validateRuntimeObservation } from "./runtime-error-store.js";
-function main() {
+import { reportRuntimeErrors, triggerRuntimeErrorReport } from "./runtime-error-report.js";
+async function main() {
     const [action, code, ...rest] = process.argv.slice(2);
     if (rest.length > 0)
         throw new Error("invalid args");
+    if (action === "report" && code === undefined) {
+        await reportRuntimeErrors({ trigger: "auto" });
+        return;
+    }
     const store = new RuntimeErrorStore();
     if (action === "record" && code) {
-        store.record(validateRuntimeObservation({ code }));
+        // 記録できた時だけ、受け口への報告を別processへ頼む（有効にした端末だけ）。このworkerは通信しない。
+        if (store.record(validateRuntimeObservation({ code })))
+            triggerRuntimeErrorReport();
         return;
     }
     if (action === "diagnostic" && code === undefined) {
@@ -16,9 +23,4 @@ function main() {
     }
     throw new Error("invalid action");
 }
-try {
-    main();
-}
-catch {
-    process.exitCode = 1;
-}
+main().catch(() => { process.exitCode = 1; });

package/dist/runtime-errors-cli.js

@@ -3,6 +3,8 @@ import process from "node:process";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { RuntimeErrorStore } from "./runtime-error-store.js";
+import { defaultRuntimeErrorReportPaths, runtimeErrorReportingStatus } from "./runtime-error-os.js";
+import { readProductCredential, readReportState, reportRuntimeErrors, setRuntimeErrorReporting, triggerRuntimeErrorReport, } from "./runtime-error-report.js";
 function parseArgs(argv) {
     const [name, flag, value, ...rest] = argv;
     if (rest.length > 0)
@@ -18,13 +20,46 @@ function parseArgs(argv) {
         if (/^[0-9a-f]{64}$/.test(value))
             return { name, fingerprint: value };
     }
-    throw new Error("使い方: aiterm-runtime-errors snapshot | ack --cursor N | resolve|reopen --fingerprint SHA256");
+    if (name === "report" && flag === undefined)
+        return { name };
+    if (name === "reporting" && (flag === "enable" || flag === "disable" || flag === "status") && value === undefined) {
+        return { name, action: flag };
+    }
+    throw new Error("使い方: aiterm-runtime-errors snapshot | ack --cursor N | resolve|reopen --fingerprint SHA256 | report | reporting enable|disable|status");
 }
 function emit(value) {
     process.stdout.write(`${JSON.stringify(value)}\n`);
 }
-export function main(argv = process.argv.slice(2)) {
+// 報告の状態。宛先・合鍵・pathは出さない。
+function reportingStatus() {
+    const paths = defaultRuntimeErrorReportPaths();
+    const snapshot = new RuntimeErrorStore().snapshot();
+    const state = readReportState(paths.reportStatePath);
+    return {
+        reporting: runtimeErrorReportingStatus(paths.reportingConfigPath),
+        credential: readProductCredential(paths.credentialPath).status,
+        collection: snapshot.collection,
+        unreported: Math.max(0, snapshot.cursor - snapshot.acknowledged_cursor),
+        last_attempt_at: state.last_attempt_at, last_status: state.last_status,
+        last_http_status: state.last_http_status, last_accepted_at: state.last_accepted_at,
+    };
+}
+export async function main(argv = process.argv.slice(2)) {
     const command = parseArgs(argv);
+    if (command.name === "report") {
+        const result = await reportRuntimeErrors({ trigger: "manual" });
+        emit({ ok: result.status === "accepted" || result.status === "nothing_to_report", command: command.name, result });
+        if (result.status !== "accepted" && result.status !== "nothing_to_report")
+            process.exitCode = 1;
+        return;
+    }
+    if (command.name === "reporting") {
+        if (command.action !== "status") {
+            setRuntimeErrorReporting(defaultRuntimeErrorReportPaths().reportingConfigPath, command.action === "enable");
+        }
+        emit({ ok: true, command: command.name, action: command.action, status: reportingStatus() });
+        return;
+    }
     const store = new RuntimeErrorStore();
     if (command.name === "snapshot") {
         emit({ ok: true, command: command.name, snapshot: store.snapshot() });
@@ -38,6 +73,9 @@ export function main(argv = process.argv.slice(2)) {
         ? store.resolve(command.fingerprint)
         : store.reopen(command.fingerprint);
     emit({ ok: true, command: command.name, changed, snapshot: store.snapshot() });
+    // 解決・開き直しも受け口へ知らせる（有効にした端末だけ。送るのは別process）。
+    if (changed)
+        triggerRuntimeErrorReport();
 }
 function isDirectExecution() {
     if (!process.argv[1])
@@ -54,13 +92,10 @@ function isDirectExecution() {
     }
 }
 if (isDirectExecution()) {
-    try {
-        main();
-    }
-    catch {
+    main().catch(() => {
         // CLI も privacy allowlist を守り、store/config の生例外や path を stdout/stderr に反射しない。
         process.stderr.write("aiterm-runtime-errors: operation failed\n");
         emit({ ok: false, code: "AITERM_RUNTIME_ERROR_STORE_OPERATION_FAILED" });
         process.exitCode = 1;
-    }
+    });
 }

package/docs/DESIGN.md

@@ -46,6 +46,9 @@ PIDは開始識別子・argv digestと組にし、paneとharnessを同一視し
 同じlaunchに属するnpm shimとnative本体は、中間の非候補processも含めた祖先関係から一つの起動として扱う。
 祖先を共有しない候補は別々に残し、複数候補を一つと推測しない。
 POSIXの停止状態はOSのprocess表から取得し、SIGSTOP中は残画面より優先して`blocked/harness_stopped`を返す。
+sessionを閉じると失うものは数で返す（ADR 0080）。`activity.post_startup_process_count`は起動完了の時点に居なかったprocessの数、
+`pending_child_deliveries`はそのsessionが親として待つ未配送の数。数えられない時はnullで、0と区別する。
+Claude Codeの入力待ちは、起動時の見出しが取得範囲から流れ出た後も、入力欄の形（`❯`行の上下の罫線）で読む。
 画面本文とargv本文は返さず、活動cursorには画面digestとprocess別CPUだけを持たせる。
 初回とpane再作成後の差分はnull。区間中にprocessが消えた時は観測できたCPU増分だけを返し、
 `cpu_delta_complete=false`を付ける。background活動はpane開始から60秒以降に生成された子孫だけを数える。
@@ -73,6 +76,7 @@ agent sessionへの送信口は`pty_send`だけとする。子の状態は呼び
 Claude Codeはtool処理中に画面の実行中表示が消え、Stop hookの実行中には表示が残る。turnの印を実行中判定の正本とする。Stopが発火しないAPIエラー終了では、次の送信時に印の作成後の会話記録にある`isApiErrorMessage`を確認し、終了したturnの印だけを解除する。過去のエラーで新しい印を解除しない。waiterは印を変更せず、読取専用のままエラーを返す。
 それ以外は新しいturnとしてdispatchする。
 CodexとClaude Codeは次のtool境界で同じturnへ取り込む。Cursorは「follow-ups」枠へ入った文を「enter steer」で現在turnへ移し、`turn_ended`は最後に1回書く。
+待ち行列の表示は5秒待ち、子のturnが続いている間だけ30秒まで延ばす（表示が遅い端末がある。turnが終わっていれば、文は新しいturnとして始まっている）。
 Grokは待ち行列へ入れた後に「send now」を押す。旧turnは`cancelled`（`cancellation_context.trigger=send_now`）で閉じ、
 新turnが作業を継ぐので、完了判定はこの継ぎ目を完了と数えない。Grokが待ち行列へ入れない時とCursorの入力欄に本文が残る時は`steered`を返さない。
 Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼び出し側は通常のdispatchだけを使う。
@@ -320,7 +324,9 @@ privacy案内は現在の枠付きcomposerとmodel footerが見える場合だ
 ## Diagnostics and local error state
 
 `diagnostics`はread-onlyで、PTY backendとagent dependencyを検査する。runtime error aggregateは
-製品所有のlocal stateに固定codeと集約metadataだけを保存し、network I/Oを持たない。工場reporterとの
+製品所有のlocal stateに固定codeと集約metadataだけを保存し、既定ではnetwork I/Oを持たない。
+BugHubへの報告は、利用者が明示して有効にし、合鍵のファイルがある端末だけが、別processで行う。
+きっかけは記録・解決・起動・手動の4つで、定期的な見張りは置かない。受け取り済みにするのは応答の署名まで確かめた時だけ（ADR 0079）。工場reporterとの
 連携は明示opt-inの任意adapterであり、未設定時もAiterm本体は単独動作する。raw error、prompt、出力、
 transcript、path、credentialを保存・公開しない。
 親配送hook（Claude Code・Cursor）の登録状態は`src/parent-hook-diagnostic.ts`が利用者設定の読取りだけで要約し、

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.47.1",
+  "version": "0.49.0",
   "mcpName": "io.github.kitepon/aiterm-mcp",
   "description": "Persistent terminal MCP with one harness-based launcher for Claude Code, Codex CLI, Grok CLI, and Cursor Agent CLI, plus durable PTYs for SSH, containers, and REPLs.",
   "keywords": [
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "aiterm-steer-delivery": "^0.1.8",
+    "aiterm-steer-delivery": "^0.1.10",
     "ws": "8.21.3",
     "zod": "^4.4.3"
   },