@excitedjs/dreamux 0.13.0-beta.62 → 0.13.0

package/CHANGELOG.json

@@ -1,6 +1,145 @@
 {
   "name": "@excitedjs/dreamux",
   "entries": [
+    {
+      "version": "0.13.0",
+      "tag": "@excitedjs/dreamux_v0.13.0",
+      "date": "Wed, 10 Jun 2026 07:24:34 GMT",
+      "comments": {
+        "minor": [
+          {
+            "comment": "Add runtime-scoped Claude Code Remote Control and make TeamMate capabilities report spawnable agent runtime ids."
+          },
+          {
+            "comment": "completion delivery now returns accepted at engine-take instead of after classifying the turn's model outcome (fixes over-delivery + removes turn-duration-coupled accept latency); subtype now authoritative in claude result classification"
+          },
+          {
+            "comment": "TeamMate MCP parity PR1 (issue #126): API/ledger foundation and event/wait contract, no worker execution yet and no tm wrapping. Bump the TeamMate task ledger to v2 with separated lifecycle_status/delivery_status, a monotonic per-task event stream, a steerable inputs[] session, and close/runtime/target/provider_ref/intent/operation_id plus reserved Team Mode fields; v1 task files still load via lossless in-memory migration and only an unknown future version fails loud (no rebuild required). Add dispatcher-facing MCP tools run_task, execute_task, send_input, await_completion, and get_capabilities (existing schedule/list_tasks/get_task/pull_result stay compatible); without a worker the execution tools report provider_unavailable and send_input queues input. Add a server-owned bounded event/wait broker so await_completion returns a structured still_running on timeout instead of failing."
+          },
+          {
+            "comment": "TeamMate MCP parity PR2 (issue #126): add the worker provider seam and an in-memory fake provider, with no real Codex/Claude Code worker yet and no tm wrapping. Introduce a runtime-agnostic TeamMateWorkerProvider (per-task steerable session, distinct from the dispatcher's long-lived AgentRuntimeProvider) plus a permissive worker catalog; a provider drives lifecycle through callbacks and never writes the ledger. Add a TeamMateWorkerExecutionService that maps onRunning/onCompleted/onFailed/onCancelled onto ledger transitions (markRunning, the PR1 record-before-deliver completion path, and a cancelled close) with wait-broker notifications, idempotent execution, and no re-execution of terminal tasks. Wire run_task/execute_task through the service, route send_input to a live worker session (promoting a queued input to submitted via the new ledger.markInputSubmitted), and make the worker catalog the source of truth for get_capabilities. Production behaviour is unchanged from PR1: with the default empty worker catalog every provider is worker-unavailable and execution tools still report provider_unavailable; only an injected fake catalog (tests) runs a session."
+          },
+          {
+            "comment": "TeamMate MCP parity PR8 (issue #126): make the push-delivery model real. (1) Codex worker turn completion is robust to a single-thread threadId field-shape drift (acceptAnyThread), and a redacted Codex WS event trace is captured to a new get_task_logs 'events' stream and summarized in the task failure text — a stalled turn now names the likely cause (e.g. no model output => worker auth/network/quota/proxy) instead of an opaque timeout. PR7's bounded turn timeout is preserved. (2) await_completion is removed as a dispatcher-facing MCP tool; normal orchestration is run_task -> the dispatcher turn ends -> the server delivers/wakes a new turn, with get_task/pull_result as the recovery/read path. The base prompt and bundled dispatcher skills are updated accordingly; an internal wait primitive remains for tests/admin diagnostics only. (3) The managed-service unit PATH now also includes the Claude Code install directory so server-hosted builtin:claude-code workers can resolve `claude` (DREAMUX_CLAUDE_BIN overrides; best-effort, codex-only installs are unaffected). BREAKING: the dispatcher-facing await_completion MCP tool is gone — a caller that invokes it now gets an unknown-tool error; re-read results with get_task/pull_result instead. Rebuild: run `dreamux daemon install` (or `dreamux onboard`) to regenerate the service unit PATH so `claude` resolves for builtin:claude-code workers, then `dreamux daemon restart` to pick up the updated base prompt and bundled skills."
+          },
+          {
+            "comment": "BREAKING: Feishu is now a built-in bidirectional channel rather than a provider-registry channel implementation. Channel plugin loading remains interface-only; the provider registry now only backs Agent Runtime providers. DispatcherService owns dispatcher agent lifecycle, live runtime slots, restart-notice injection, and Feishu channel MCP dispatch; server.ts is wiring only.\nRebuild: restart dreamux serve after upgrading so dispatcher agents and the built-in Feishu channel are recreated under DispatcherService ownership."
+          },
+          {
+            "comment": "Load installed npm Agent Runtime providers from dispatchers[].runtime.provider before config validation. External runtime providers now enter through the same provider registry, AgentRuntimeProvider catalog, DispatcherService creation path, and provider-owned capability declaration contract as builtin runtimes. Missing packages, missing exports, invalid provider contracts, incomplete capability declarations, and non-runnable descriptors fail loudly with the selected provider ref."
+          },
+          {
+            "comment": "A builtin:claude-code dispatcher now receives a dreamux-adapted dispatcher role prompt, injected via the resident `claude --append-system-prompt` flag (layered on top of claude's own system prompt). Previously claude dispatchers got no dispatcher prompt at all; they now carry the coordinator-not-worker boundaries, TeamMate MCP + push-delivery model, Feishu visible-reply contract, and public-artifact safety rules. No config or state change; the prompt is applied at dispatcher (re)start, so restart claude dispatchers to pick it up."
+          },
+          {
+            "comment": "Wire teammate -> dispatcher reverse completion delivery (issue #147): a finished teammate's result is now delivered back to the dispatcher as a new turn via the runtime's completionInput, using each engine's native mechanism (codex thread/inject_items + a trigger turn; claude-code native <task-notification> with isSynthetic). A teammate turn that errors at the model level (codex fatal 'error' notification) is delivered as 'failed' instead of hanging. NOTE: codex reverse-delivery requires codex 0.137+ (thread/inject_items); on older codex it fails loudly with a 0.137 hint rather than dropping the completion silently. Also fixes spawning a cross-provider teammate (e.g. a builtin:claude-code teammate under a builtin:codex dispatcher), which previously threw 'is not wired to Claude Code'."
+          },
+          {
+            "comment": "BREAKING: doctor now resolves each dispatcher's runtime through its agent-runtime provider's self-reported diagnostic (issue #146 fold) instead of branching on the codex/claude provider ref. The codex diagnostic adds a hard version floor: doctor fails loud when the resolved Codex binary is below 0.137.0, because teammate-completion delivery appends to the dispatcher thread via thread/inject_items, an RPC that exists only on codex >= 0.137 (issue #147). The claude per-dispatcher detail line changed from 'does not use Codex home state' to a neutral 'no host-managed home state'.\nRebuild: if `dreamux doctor` reports a Codex version below 0.137.0, upgrade Codex (the codex-cli binary referenced by the agent's config.bin / CODEX_HOST_CODEX_BIN) to >= 0.137.0; no config file change is required."
+          },
+          {
+            "comment": "BREAKING: ~/.dreamux/config.json runtime config is hoisted into named top-level agents[]. Each dispatcher now references a runtime by id via dispatchers[].agentRuntime instead of carrying an inline dispatchers[].runtime block; config lives only in agents[] ({ id, provider, config }). The old inline-runtime shape, a dispatcher missing agentRuntime, a dangling agentRuntime id, and a duplicate agents[].id all fail loud at load with rebuild guidance (no migration shim). Each agent's config is parsed through its provider's readConfig.\nRebuild: rewrite ~/.dreamux/config.json to the new schema (declare runtimes under agents[] and reference them with dispatchers[].agentRuntime), then restart dreamux serve. To regenerate from scratch instead, first MOVE ASIDE or DELETE the old config.json -- onboard loads the existing config and would otherwise fail loud on the old inline-runtime shape before it could rewrite -- then run dreamux onboard."
+          },
+          {
+            "comment": "BREAKING: a teammate now references a named agent (an agents[].id) instead of a provider. spawn takes agent_runtime (was provider_ref); the teammate resolves that id against the global agents[] map into its own { provider, config }, so a teammate on a different agent than its dispatcher (e.g. a claude teammate under a codex dispatcher) runs with its OWN config and the cross-provider 'is not wired to ...' mismatch is gone. Persisted teammate identity records change their field provider_ref -> agent_runtime; a pre-#148 identity fails loud on the next lifecycle verb with rebuild guidance (no migration shim). A teammate whose agent_runtime no longer matches any agents[].id also fails loud on resume rather than silently defaulting a runtime.\nRebuild: close and respawn affected teammates, or delete the stale identity files under ~/.dreamux/state/<dispatcher>/teammate/identities/<name>.json, then respawn. Ensure each teammate's agent_runtime names an existing agents[].id in ~/.dreamux/config.json."
+          },
+          {
+            "comment": "BREAKING: Remove the teammate `resume` verb for issue #155. The `resume` MCP tool (dispatcher-scoped `teammate` server) and the `mcp.teammate.resume` admin method are gone; callers must use `send`. `send` now subsumes resume semantics: when the named teammate is not live — including one previously `close`d — send reopens it from its persisted checkpoint (clearing the closed markers) and then submits, instead of failing with \"TeamMate ... is closed\". `close` is now a reversible soft-stop (it still records closedAt/note, but a later `send` revives the teammate). Read-only verbs (last/ctx/status) still fail-loud on a closed teammate and never silently reopen it. No on-disk migration is required: existing closed teammate identities and pre-#155 history files (which may contain `\"type\":\"resume\"` events) remain readable; the reopen path is purely runtime behavior."
+          },
+          {
+            "comment": "BREAKING: TeamMate MCP/admin spawn now requires `cwd`; the service no longer falls back to a dispatcher cwd or Dreamux runtime directory for native teammates. Call `spawn({ name, prompt, cwd, worktree?, agent_runtime? })` and pass either `worktree: { mode: \"reuse-cwd\" }` or `worktree: { mode: \"managed\", slug?, base_ref?, branch?, cleanup? }` for Dreamux-managed worktree isolation. TeamMate identities now persist dispatcher owner metadata plus source/runtime cwd and worktree cleanup metadata. Rebuild: respawn any caller-side TeamMate automation that omitted `cwd`; old identity files without owner/worktree metadata still read as dispatcher-owned reuse-cwd records and are rewritten only on later lifecycle mutation."
+          },
+          {
+            "comment": "BREAKING: TeamMate MCP/admin `history` now returns bounded session ledger rows (`items`, `next_cursor`) across TeamMate identities instead of the raw event list for one required name. Use `history_events({ name })` for the raw forward-only per-TeamMate timeline. Ledger rows expose agent runtime id, dispatcher owner metadata, source/runtime cwd, managed worktree metadata, close/cleanup state, intent, prompt previews, and a structured `send` resume hint. Rebuild: update dispatcher-side automation that parsed `history({ name }).events` to call `history_events({ name })`, or switch it to the ledger row shape."
+          },
+          {
+            "comment": "BREAKING: Team Mode adds persistent Feishu group channel binding. Dispatcher-scoped `team` MCP/admin now includes `bind_channel` and `transfer_channel_back`; bound group inbound is routed to the TeamLeader after the normal Feishu gate/format path, while unbound and P2P inbound continue to the dispatcher. TeamLeader Feishu reply/react calls are scoped to bound team channels. Rebuild: update Team Mode dispatcher automation to call `team.bind_channel({ team_id, chat_id, chat_type: \"group\" })` for group handoff and `team.transfer_channel_back({ chat_id, chat_type: \"group\" })` before returning a group to the dispatcher."
+          },
+          {
+            "comment": "BREAKING: Team Mode adds dispatcher-only `team.create_group` for P2P control requests. The command creates a Team, asks the shared dispatcher Feishu bot to create a group and invite requested peers, then binds that new group to the TeamLeader; the source P2P channel remains routed to the dispatcher. Rebuild: update Team Mode dispatcher automation to call `team.create_group({ name, repo_cwd, leader_agent_runtime, source_chat_id, source_chat_type: \"p2p\", requester_open_id, invite_open_ids? })` when a P2P requester asks for a team group. TeamLeaders still use the shared bot and do not receive independent Feishu credentials."
+          },
+          {
+            "comment": "BREAKING: Team Mode core adds dispatcher-scoped `team` MCP/admin lifecycle methods (`create`, `list`, `status`, `ledger`, `dissolve`) and extends TeamMate identities with role/owner/team metadata. TeamMate MCP calls are now scoped by a server-derived caller principal: dispatchers see dispatcher-owned ordinary TeamMates and TeamLeaders, while TeamLeaders see only their own team-owned members. Rebuild: update dispatcher automation to use `team.create({ name, repo_cwd, leader_agent_runtime, ... })` for TeamLeader creation and avoid passing owner/team fields through `teammate.*`; those fields are derived by Dreamux."
+          },
+          {
+            "comment": "TeamMate codex runtimes now inherit the parent dispatcher's codex config (approval_policy / sandbox_mode / extra_args) instead of always-defaults — consistent with the already-inherited bin/env/timeout. A codex teammate under a codex dispatcher now runs with that dispatcher's sandbox/approval/args."
+          },
+          {
+            "comment": "TeamMate codex workers no longer receive the dispatcher base system prompt. Previously the shared codex runtime hard-coded the dispatcher instructions on every thread start, so teammate workers were wrongly told they were the dispatcher; the dispatcher prompt is now supplied only to the dispatcher agent via the runtime's systemPrompt capability. A teammate's role/task continues to arrive through its first turn. Restart dispatchers to apply."
+          },
+          {
+            "comment": "Provider architecture PR A (issue #135): replace the old capability registry with a provider-ref registry that validates builtin refs and provider kind only. Runtime and channel provider factories now receive descriptors resolved from the server-owned registry, and config provider validation uses the injected registry before Phase 1 wired-provider checks. BREAKING: the exported CapabilityRegistry/capability descriptor API is removed; use ProviderRegistry for ref/kind lookup and read capabilities from provider instances."
+          },
+          {
+            "comment": "Realign the AgentRuntime contract around submitTurn and provider-owned capabilities, and make the agent runtime catalog read implementations from the provider registry instead of carrying its own provider map."
+          },
+          {
+            "comment": "Move TeamMate orchestration into Dispatcher Service and slim server wiring."
+          },
+          {
+            "comment": "BREAKING: Replace the TeamMate task/worker MCP model with named, resumable TeamMate agents. The dispatcher-scoped teammate MCP now exposes spawn/send/resume/close/history/list/status/last/ctx/get_capabilities; schedule/run_task/execute_task/send_input/cancel_task/get_task_logs/list_tasks/get_task/pull_result and task_id records are removed.\n\nRebuild: remove old ~/.dreamux/state/<dispatcher-id>/teammate/ledger.json and ~/.dreamux/state/<dispatcher-id>/teammate/tasks/ state, then recreate TeamMate sessions with the new spawn/resume flow. TeamMates now reuse AgentRuntime providers with async identity/history persistence."
+          }
+        ],
+        "patch": [
+          {
+            "comment": "Fix the built CLI cold-start crash (Cannot access 'BUILT_IN_DEFAULTS' before initialization) introduced by the #148 agents[] refactor. config/config.ts no longer registers the builtin runtime catalog itself; builtin runtimes are now composed by the caller through loadConfigWithBuiltins, which removes the static import cycle (config -> catalog -> builtin -> platform/paths -> config) at its root rather than deferring the temporal-dead-zone read. Adds a built dreamux --version smoke gate before CI and release publish steps."
+          },
+          {
+            "comment": "Fix Codex socket startup failure under deep state roots (long $HOME, long dispatcher/teammate names). When the descriptive socket path (state/<dispatcher>/.../codex.sock) exceeds the Unix sun_path budget, the socket now falls back to a short deterministic path under a private per-user runtime dir (XDG_RUNTIME_DIR, or a non-shared os tmpdir such as the macOS per-user $TMPDIR) instead of failing to start. The shared /tmp is never used; with no private root available the start still fails loudly. No action needed for existing installs whose paths fit the budget."
+          },
+          {
+            "comment": "TeamLeader completion routing is now per turn instead of per role: bound-channel leader turns stay pull-only (team ledger), while dispatcher-initiated leader send/control turns return to the dispatcher as completions; removes the redundant getLast-polling completion path that double-delivered leader ledger rows and team-member completions"
+          },
+          {
+            "comment": "Fix TeamMate reverse-completion delivery so duplicate/retried completions are idempotent and multi-send steering shares one current-turn completion."
+          },
+          {
+            "comment": "Add the server-hosted TeamMate scheduling MCP and versioned per-dispatcher task ledger for issue #110."
+          },
+          {
+            "comment": "Add TeamMate completion delivery (Codex inbox/turn + Claude Code task notification), bounded retry to an inspectable delivery_failed/pull-available state, and read-only result retrieval MCP tools for issue #110."
+          },
+          {
+            "comment": "Stabilize issue #110 closure with providerized README/help updates, doctor coverage for Claude Code runtime diagnostics, and a durable Epic closure checklist."
+          },
+          {
+            "comment": "Run builtin:claude-code as a resident stream-json process (one long-lived `claude --print --input-format stream-json` child per dispatcher) instead of a one-shot `claude --print` per turn, for issue #120. Adds an optional `dispatchers[].runtime.config.turn_timeout_ms` (default 600000) bounding a single resident turn, and the logs/claude-code/ stderr log directory; persisted state schemas are unchanged and the new config field is optional with a default."
+          },
+          {
+            "comment": "Align bundled dispatcher skills and the injected dispatcher base prompt with the server-hosted TeamMate MCP (schedule/list_tasks/get_task/pull_result) as the primary scheduled-task interface, keeping the tm CLI as a labeled fallback and stating the #110 Phase 1 boundary."
+          },
+          {
+            "comment": "Add the real builtin:claude-code TeamMate worker provider (issue #126 PR4): TeamMate MCP now executes Claude Code tasks too, selectable by pinning provider_ref=builtin:claude-code (default routing stays builtin:codex). get_capabilities reports both workers (claude-code is single-turn, steer:false). Adds server-owned per-task worker paths state/<id>/teammate/workers/<taskId>.mcp.json and logs/claude-code/teammate/<id>/<taskId>.stderr.log (auto-created, no operator action). No config schema or persisted-format change."
+          },
+          {
+            "comment": "Add TeamMate MCP control/query parity (issue #126 PR5): two additive tools so a dispatcher can stop and inspect a worker over MCP without shelling out to a tm CLI, killing a process, or tailing a log file. cancel_task stops a live worker (reaping its resources) or closes a not-yet-running/orphaned task in the ledger as cancelled, and is an idempotent no-op on an already-terminal task. get_task_logs returns a bounded tail of a worker's diagnostic logs (Codex app-server stdout protocol frames + stderr; Claude resident-child stderr) for the EFFECTIVE worker, resolving the catalog default for tasks that did not pin a provider. Read/wait parity (status/history/last/poll) was already served by list_tasks/get_task/pull_result/await_completion; resume and multi-turn stay deferred (one-turn workers). No config schema, persisted format, or runtime path change."
+          },
+          {
+            "comment": "Align bundled dispatcher skills and the injected dispatcher base prompt with the real TeamMate MCP surface (issue #126 PR6). After PR3-5 wired real workers, the docs still carried the stale #124 'Phase 1 boundary' caveat claiming the MCP could not run a scheduled task to completion and that the tm CLI was the only executed-result path. They now present the server-hosted TeamMate MCP as the default orchestration interface: run_task/execute_task execute the default builtin:codex worker for real (builtin:claude-code via provider_ref, single-turn), list_tasks/get_task/pull_result/await_completion read and wait without polling, and cancel_task/get_task_logs/get_capabilities control and inspect a worker. The tm CLI is the explicit fallback for resume, multi-turn continuation, dead-session recovery, and isolated managed worktrees, which the in-place MCP workers do not yet cover. Documentation/template realignment only: no config schema, persisted format, runtime path, or MCP tool behavior change, and the symlinked skills pick up the new text on the next serve with no rebuild required."
+          },
+          {
+            "comment": "Fix two TeamMate installed-state validation blockers (issue #126 PR7). (1) get_capabilities no longer claims a worker is available when its binary cannot be started in the dispatcher service environment: it now probes each built-in worker's binary on the service PATH and reports worker_available:false with a reason for a wired-but-unresolvable worker (the builtin:claude-code ENOENT case where `claude` is absent), with execution_available derived from the probed rows. The probe runs only on the advertisement path; the execute path already returned structured provider_unavailable on spawn. (2) A builtin:codex worker turn that reaches running but never completes (a stall in turn execution — auth, network, or model quota) is now bounded by a new turn_timeout_ms: on expiry the task fails with a self-contained message instead of sitting running forever with an empty diagnostic log. Config: turn_timeout_ms is added to the codex runtime config (dispatchers[].runtime.config.turn_timeout_ms), additive and defaulted to 600000ms, so existing configs load unchanged; `dreamux onboard` now writes it. No persisted-format or runtime-path change, and the tm fallback path is unchanged."
+          },
+          {
+            "comment": "Refactor builtin Agent Runtime module layout without behavior changes: move the Codex AgentRuntime implementation under agent-runtime, split the Claude Code resident transport into claude-code supervisor/rpc/stream/types/mcp-config modules, and share process-group helpers from runtime/process."
+          },
+          {
+            "comment": "Change the builtin:claude-code per-turn deadline from a fixed total-turn wall-clock to an idle/inactivity window for issue #156. `turn_timeout_ms` (default 600000) is now reset on every inbound stream line, so it bounds the max time the resident child may emit no stream activity rather than the total turn duration. A long but continuously-streaming turn (e.g. a deep audit running many tool calls for far longer than the window) is no longer reaped mid-work, while a genuinely wedged child that goes silent for the whole window is still failed and reaped (preserving the #120 anti-hang intent). No config change is required; the field name and default are unchanged, but its semantics changed (total-turn cap -> idle window). The timeout error text changed from 'timed out ... without a result' to 'stalled: no stream activity for {ms}ms'."
+          },
+          {
+            "comment": "Bound teammate completion push-back and move channel-input assembly into each runtime (#164). Completion results over an inline budget (default 32000 chars, TASK_MAX_OUTPUT_LENGTH override, clamped to 160000) are spilled to a 0600 /tmp file and only the path is inlined. The claude-code runtime drops the fake <task-notification> XML and delivers a plain status-varied user turn (isSynthetic:false; capability kind claudeCodeTaskNotification -> claudeCodePlainTurn); codex keeps its <teammate_session_completion> wrapper. CompletionEnvelope.status widens to completed|failed|stopped (no longer folded). Inbound Feishu messages are now assembled by each runtime into the native <channel source=\"feishu\" …> envelope (codex's <feishu_message> wrapper retired); the channel layer stops pre-rendering XML and hands runtimes neutral structured pieces. No persisted config/state format changes, so no rebuild is required."
+          },
+          {
+            "comment": "Remove the in-memory DispatcherRow field codex_cwd and the server-ctl `codex-cwd` status flag (the field was never persisted to status.json). The dispatcher runtime cwd is now a required launch parameter supplied by the Dispatcher Service; codex bin resolution and per-runtime artifact paths moved behind the Agent Runtime providers. No persisted format change; no rebuild required."
+          }
+        ],
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@excitedjs/feishu-transport\" to `0.3.0`"
+          }
+        ]
+      }
+    },
     {
       "version": "0.12.0",
       "tag": "@excitedjs/dreamux_v0.12.0",

package/CHANGELOG.md

@@ -1,6 +1,62 @@
 # Change Log - @excitedjs/dreamux
 
-This log was last generated on Sat, 06 Jun 2026 10:02:33 GMT and should not be manually modified.
+This log was last generated on Wed, 10 Jun 2026 07:24:34 GMT and should not be manually modified.
+
+## 0.13.0
+Wed, 10 Jun 2026 07:24:34 GMT
+
+### Minor changes
+
+- Add runtime-scoped Claude Code Remote Control and make TeamMate capabilities report spawnable agent runtime ids.
+- completion delivery now returns accepted at engine-take instead of after classifying the turn's model outcome (fixes over-delivery + removes turn-duration-coupled accept latency); subtype now authoritative in claude result classification
+- TeamMate MCP parity PR1 (issue #126): API/ledger foundation and event/wait contract, no worker execution yet and no tm wrapping. Bump the TeamMate task ledger to v2 with separated lifecycle_status/delivery_status, a monotonic per-task event stream, a steerable inputs[] session, and close/runtime/target/provider_ref/intent/operation_id plus reserved Team Mode fields; v1 task files still load via lossless in-memory migration and only an unknown future version fails loud (no rebuild required). Add dispatcher-facing MCP tools run_task, execute_task, send_input, await_completion, and get_capabilities (existing schedule/list_tasks/get_task/pull_result stay compatible); without a worker the execution tools report provider_unavailable and send_input queues input. Add a server-owned bounded event/wait broker so await_completion returns a structured still_running on timeout instead of failing.
+- TeamMate MCP parity PR2 (issue #126): add the worker provider seam and an in-memory fake provider, with no real Codex/Claude Code worker yet and no tm wrapping. Introduce a runtime-agnostic TeamMateWorkerProvider (per-task steerable session, distinct from the dispatcher's long-lived AgentRuntimeProvider) plus a permissive worker catalog; a provider drives lifecycle through callbacks and never writes the ledger. Add a TeamMateWorkerExecutionService that maps onRunning/onCompleted/onFailed/onCancelled onto ledger transitions (markRunning, the PR1 record-before-deliver completion path, and a cancelled close) with wait-broker notifications, idempotent execution, and no re-execution of terminal tasks. Wire run_task/execute_task through the service, route send_input to a live worker session (promoting a queued input to submitted via the new ledger.markInputSubmitted), and make the worker catalog the source of truth for get_capabilities. Production behaviour is unchanged from PR1: with the default empty worker catalog every provider is worker-unavailable and execution tools still report provider_unavailable; only an injected fake catalog (tests) runs a session.
+- TeamMate MCP parity PR8 (issue #126): make the push-delivery model real. (1) Codex worker turn completion is robust to a single-thread threadId field-shape drift (acceptAnyThread), and a redacted Codex WS event trace is captured to a new get_task_logs 'events' stream and summarized in the task failure text — a stalled turn now names the likely cause (e.g. no model output => worker auth/network/quota/proxy) instead of an opaque timeout. PR7's bounded turn timeout is preserved. (2) await_completion is removed as a dispatcher-facing MCP tool; normal orchestration is run_task -> the dispatcher turn ends -> the server delivers/wakes a new turn, with get_task/pull_result as the recovery/read path. The base prompt and bundled dispatcher skills are updated accordingly; an internal wait primitive remains for tests/admin diagnostics only. (3) The managed-service unit PATH now also includes the Claude Code install directory so server-hosted builtin:claude-code workers can resolve `claude` (DREAMUX_CLAUDE_BIN overrides; best-effort, codex-only installs are unaffected). BREAKING: the dispatcher-facing await_completion MCP tool is gone — a caller that invokes it now gets an unknown-tool error; re-read results with get_task/pull_result instead. Rebuild: run `dreamux daemon install` (or `dreamux onboard`) to regenerate the service unit PATH so `claude` resolves for builtin:claude-code workers, then `dreamux daemon restart` to pick up the updated base prompt and bundled skills.
+- BREAKING: Feishu is now a built-in bidirectional channel rather than a provider-registry channel implementation. Channel plugin loading remains interface-only; the provider registry now only backs Agent Runtime providers. DispatcherService owns dispatcher agent lifecycle, live runtime slots, restart-notice injection, and Feishu channel MCP dispatch; server.ts is wiring only.
+Rebuild: restart dreamux serve after upgrading so dispatcher agents and the built-in Feishu channel are recreated under DispatcherService ownership.
+- Load installed npm Agent Runtime providers from dispatchers[].runtime.provider before config validation. External runtime providers now enter through the same provider registry, AgentRuntimeProvider catalog, DispatcherService creation path, and provider-owned capability declaration contract as builtin runtimes. Missing packages, missing exports, invalid provider contracts, incomplete capability declarations, and non-runnable descriptors fail loudly with the selected provider ref.
+- A builtin:claude-code dispatcher now receives a dreamux-adapted dispatcher role prompt, injected via the resident `claude --append-system-prompt` flag (layered on top of claude's own system prompt). Previously claude dispatchers got no dispatcher prompt at all; they now carry the coordinator-not-worker boundaries, TeamMate MCP + push-delivery model, Feishu visible-reply contract, and public-artifact safety rules. No config or state change; the prompt is applied at dispatcher (re)start, so restart claude dispatchers to pick it up.
+- Wire teammate -> dispatcher reverse completion delivery (issue #147): a finished teammate's result is now delivered back to the dispatcher as a new turn via the runtime's completionInput, using each engine's native mechanism (codex thread/inject_items + a trigger turn; claude-code native <task-notification> with isSynthetic). A teammate turn that errors at the model level (codex fatal 'error' notification) is delivered as 'failed' instead of hanging. NOTE: codex reverse-delivery requires codex 0.137+ (thread/inject_items); on older codex it fails loudly with a 0.137 hint rather than dropping the completion silently. Also fixes spawning a cross-provider teammate (e.g. a builtin:claude-code teammate under a builtin:codex dispatcher), which previously threw 'is not wired to Claude Code'.
+- BREAKING: doctor now resolves each dispatcher's runtime through its agent-runtime provider's self-reported diagnostic (issue #146 fold) instead of branching on the codex/claude provider ref. The codex diagnostic adds a hard version floor: doctor fails loud when the resolved Codex binary is below 0.137.0, because teammate-completion delivery appends to the dispatcher thread via thread/inject_items, an RPC that exists only on codex >= 0.137 (issue #147). The claude per-dispatcher detail line changed from 'does not use Codex home state' to a neutral 'no host-managed home state'.
+Rebuild: if `dreamux doctor` reports a Codex version below 0.137.0, upgrade Codex (the codex-cli binary referenced by the agent's config.bin / CODEX_HOST_CODEX_BIN) to >= 0.137.0; no config file change is required.
+- BREAKING: ~/.dreamux/config.json runtime config is hoisted into named top-level agents[]. Each dispatcher now references a runtime by id via dispatchers[].agentRuntime instead of carrying an inline dispatchers[].runtime block; config lives only in agents[] ({ id, provider, config }). The old inline-runtime shape, a dispatcher missing agentRuntime, a dangling agentRuntime id, and a duplicate agents[].id all fail loud at load with rebuild guidance (no migration shim). Each agent's config is parsed through its provider's readConfig.
+Rebuild: rewrite ~/.dreamux/config.json to the new schema (declare runtimes under agents[] and reference them with dispatchers[].agentRuntime), then restart dreamux serve. To regenerate from scratch instead, first MOVE ASIDE or DELETE the old config.json -- onboard loads the existing config and would otherwise fail loud on the old inline-runtime shape before it could rewrite -- then run dreamux onboard.
+- BREAKING: a teammate now references a named agent (an agents[].id) instead of a provider. spawn takes agent_runtime (was provider_ref); the teammate resolves that id against the global agents[] map into its own { provider, config }, so a teammate on a different agent than its dispatcher (e.g. a claude teammate under a codex dispatcher) runs with its OWN config and the cross-provider 'is not wired to ...' mismatch is gone. Persisted teammate identity records change their field provider_ref -> agent_runtime; a pre-#148 identity fails loud on the next lifecycle verb with rebuild guidance (no migration shim). A teammate whose agent_runtime no longer matches any agents[].id also fails loud on resume rather than silently defaulting a runtime.
+Rebuild: close and respawn affected teammates, or delete the stale identity files under ~/.dreamux/state/<dispatcher>/teammate/identities/<name>.json, then respawn. Ensure each teammate's agent_runtime names an existing agents[].id in ~/.dreamux/config.json.
+- BREAKING: Remove the teammate `resume` verb for issue #155. The `resume` MCP tool (dispatcher-scoped `teammate` server) and the `mcp.teammate.resume` admin method are gone; callers must use `send`. `send` now subsumes resume semantics: when the named teammate is not live — including one previously `close`d — send reopens it from its persisted checkpoint (clearing the closed markers) and then submits, instead of failing with "TeamMate ... is closed". `close` is now a reversible soft-stop (it still records closedAt/note, but a later `send` revives the teammate). Read-only verbs (last/ctx/status) still fail-loud on a closed teammate and never silently reopen it. No on-disk migration is required: existing closed teammate identities and pre-#155 history files (which may contain `"type":"resume"` events) remain readable; the reopen path is purely runtime behavior.
+- BREAKING: TeamMate MCP/admin spawn now requires `cwd`; the service no longer falls back to a dispatcher cwd or Dreamux runtime directory for native teammates. Call `spawn({ name, prompt, cwd, worktree?, agent_runtime? })` and pass either `worktree: { mode: "reuse-cwd" }` or `worktree: { mode: "managed", slug?, base_ref?, branch?, cleanup? }` for Dreamux-managed worktree isolation. TeamMate identities now persist dispatcher owner metadata plus source/runtime cwd and worktree cleanup metadata. Rebuild: respawn any caller-side TeamMate automation that omitted `cwd`; old identity files without owner/worktree metadata still read as dispatcher-owned reuse-cwd records and are rewritten only on later lifecycle mutation.
+- BREAKING: TeamMate MCP/admin `history` now returns bounded session ledger rows (`items`, `next_cursor`) across TeamMate identities instead of the raw event list for one required name. Use `history_events({ name })` for the raw forward-only per-TeamMate timeline. Ledger rows expose agent runtime id, dispatcher owner metadata, source/runtime cwd, managed worktree metadata, close/cleanup state, intent, prompt previews, and a structured `send` resume hint. Rebuild: update dispatcher-side automation that parsed `history({ name }).events` to call `history_events({ name })`, or switch it to the ledger row shape.
+- BREAKING: Team Mode adds persistent Feishu group channel binding. Dispatcher-scoped `team` MCP/admin now includes `bind_channel` and `transfer_channel_back`; bound group inbound is routed to the TeamLeader after the normal Feishu gate/format path, while unbound and P2P inbound continue to the dispatcher. TeamLeader Feishu reply/react calls are scoped to bound team channels. Rebuild: update Team Mode dispatcher automation to call `team.bind_channel({ team_id, chat_id, chat_type: "group" })` for group handoff and `team.transfer_channel_back({ chat_id, chat_type: "group" })` before returning a group to the dispatcher.
+- BREAKING: Team Mode adds dispatcher-only `team.create_group` for P2P control requests. The command creates a Team, asks the shared dispatcher Feishu bot to create a group and invite requested peers, then binds that new group to the TeamLeader; the source P2P channel remains routed to the dispatcher. Rebuild: update Team Mode dispatcher automation to call `team.create_group({ name, repo_cwd, leader_agent_runtime, source_chat_id, source_chat_type: "p2p", requester_open_id, invite_open_ids? })` when a P2P requester asks for a team group. TeamLeaders still use the shared bot and do not receive independent Feishu credentials.
+- BREAKING: Team Mode core adds dispatcher-scoped `team` MCP/admin lifecycle methods (`create`, `list`, `status`, `ledger`, `dissolve`) and extends TeamMate identities with role/owner/team metadata. TeamMate MCP calls are now scoped by a server-derived caller principal: dispatchers see dispatcher-owned ordinary TeamMates and TeamLeaders, while TeamLeaders see only their own team-owned members. Rebuild: update dispatcher automation to use `team.create({ name, repo_cwd, leader_agent_runtime, ... })` for TeamLeader creation and avoid passing owner/team fields through `teammate.*`; those fields are derived by Dreamux.
+- TeamMate codex runtimes now inherit the parent dispatcher's codex config (approval_policy / sandbox_mode / extra_args) instead of always-defaults — consistent with the already-inherited bin/env/timeout. A codex teammate under a codex dispatcher now runs with that dispatcher's sandbox/approval/args.
+- TeamMate codex workers no longer receive the dispatcher base system prompt. Previously the shared codex runtime hard-coded the dispatcher instructions on every thread start, so teammate workers were wrongly told they were the dispatcher; the dispatcher prompt is now supplied only to the dispatcher agent via the runtime's systemPrompt capability. A teammate's role/task continues to arrive through its first turn. Restart dispatchers to apply.
+- Provider architecture PR A (issue #135): replace the old capability registry with a provider-ref registry that validates builtin refs and provider kind only. Runtime and channel provider factories now receive descriptors resolved from the server-owned registry, and config provider validation uses the injected registry before Phase 1 wired-provider checks. BREAKING: the exported CapabilityRegistry/capability descriptor API is removed; use ProviderRegistry for ref/kind lookup and read capabilities from provider instances.
+- Realign the AgentRuntime contract around submitTurn and provider-owned capabilities, and make the agent runtime catalog read implementations from the provider registry instead of carrying its own provider map.
+- Move TeamMate orchestration into Dispatcher Service and slim server wiring.
+- BREAKING: Replace the TeamMate task/worker MCP model with named, resumable TeamMate agents. The dispatcher-scoped teammate MCP now exposes spawn/send/resume/close/history/list/status/last/ctx/get_capabilities; schedule/run_task/execute_task/send_input/cancel_task/get_task_logs/list_tasks/get_task/pull_result and task_id records are removed.
+
+Rebuild: remove old ~/.dreamux/state/<dispatcher-id>/teammate/ledger.json and ~/.dreamux/state/<dispatcher-id>/teammate/tasks/ state, then recreate TeamMate sessions with the new spawn/resume flow. TeamMates now reuse AgentRuntime providers with async identity/history persistence.
+
+### Patches
+
+- Fix the built CLI cold-start crash (Cannot access 'BUILT_IN_DEFAULTS' before initialization) introduced by the #148 agents[] refactor. config/config.ts no longer registers the builtin runtime catalog itself; builtin runtimes are now composed by the caller through loadConfigWithBuiltins, which removes the static import cycle (config -> catalog -> builtin -> platform/paths -> config) at its root rather than deferring the temporal-dead-zone read. Adds a built dreamux --version smoke gate before CI and release publish steps.
+- Fix Codex socket startup failure under deep state roots (long $HOME, long dispatcher/teammate names). When the descriptive socket path (state/<dispatcher>/.../codex.sock) exceeds the Unix sun_path budget, the socket now falls back to a short deterministic path under a private per-user runtime dir (XDG_RUNTIME_DIR, or a non-shared os tmpdir such as the macOS per-user $TMPDIR) instead of failing to start. The shared /tmp is never used; with no private root available the start still fails loudly. No action needed for existing installs whose paths fit the budget.
+- TeamLeader completion routing is now per turn instead of per role: bound-channel leader turns stay pull-only (team ledger), while dispatcher-initiated leader send/control turns return to the dispatcher as completions; removes the redundant getLast-polling completion path that double-delivered leader ledger rows and team-member completions
+- Fix TeamMate reverse-completion delivery so duplicate/retried completions are idempotent and multi-send steering shares one current-turn completion.
+- Add the server-hosted TeamMate scheduling MCP and versioned per-dispatcher task ledger for issue #110.
+- Add TeamMate completion delivery (Codex inbox/turn + Claude Code task notification), bounded retry to an inspectable delivery_failed/pull-available state, and read-only result retrieval MCP tools for issue #110.
+- Stabilize issue #110 closure with providerized README/help updates, doctor coverage for Claude Code runtime diagnostics, and a durable Epic closure checklist.
+- Run builtin:claude-code as a resident stream-json process (one long-lived `claude --print --input-format stream-json` child per dispatcher) instead of a one-shot `claude --print` per turn, for issue #120. Adds an optional `dispatchers[].runtime.config.turn_timeout_ms` (default 600000) bounding a single resident turn, and the logs/claude-code/ stderr log directory; persisted state schemas are unchanged and the new config field is optional with a default.
+- Align bundled dispatcher skills and the injected dispatcher base prompt with the server-hosted TeamMate MCP (schedule/list_tasks/get_task/pull_result) as the primary scheduled-task interface, keeping the tm CLI as a labeled fallback and stating the #110 Phase 1 boundary.
+- Add the real builtin:claude-code TeamMate worker provider (issue #126 PR4): TeamMate MCP now executes Claude Code tasks too, selectable by pinning provider_ref=builtin:claude-code (default routing stays builtin:codex). get_capabilities reports both workers (claude-code is single-turn, steer:false). Adds server-owned per-task worker paths state/<id>/teammate/workers/<taskId>.mcp.json and logs/claude-code/teammate/<id>/<taskId>.stderr.log (auto-created, no operator action). No config schema or persisted-format change.
+- Add TeamMate MCP control/query parity (issue #126 PR5): two additive tools so a dispatcher can stop and inspect a worker over MCP without shelling out to a tm CLI, killing a process, or tailing a log file. cancel_task stops a live worker (reaping its resources) or closes a not-yet-running/orphaned task in the ledger as cancelled, and is an idempotent no-op on an already-terminal task. get_task_logs returns a bounded tail of a worker's diagnostic logs (Codex app-server stdout protocol frames + stderr; Claude resident-child stderr) for the EFFECTIVE worker, resolving the catalog default for tasks that did not pin a provider. Read/wait parity (status/history/last/poll) was already served by list_tasks/get_task/pull_result/await_completion; resume and multi-turn stay deferred (one-turn workers). No config schema, persisted format, or runtime path change.
+- Align bundled dispatcher skills and the injected dispatcher base prompt with the real TeamMate MCP surface (issue #126 PR6). After PR3-5 wired real workers, the docs still carried the stale #124 'Phase 1 boundary' caveat claiming the MCP could not run a scheduled task to completion and that the tm CLI was the only executed-result path. They now present the server-hosted TeamMate MCP as the default orchestration interface: run_task/execute_task execute the default builtin:codex worker for real (builtin:claude-code via provider_ref, single-turn), list_tasks/get_task/pull_result/await_completion read and wait without polling, and cancel_task/get_task_logs/get_capabilities control and inspect a worker. The tm CLI is the explicit fallback for resume, multi-turn continuation, dead-session recovery, and isolated managed worktrees, which the in-place MCP workers do not yet cover. Documentation/template realignment only: no config schema, persisted format, runtime path, or MCP tool behavior change, and the symlinked skills pick up the new text on the next serve with no rebuild required.
+- Fix two TeamMate installed-state validation blockers (issue #126 PR7). (1) get_capabilities no longer claims a worker is available when its binary cannot be started in the dispatcher service environment: it now probes each built-in worker's binary on the service PATH and reports worker_available:false with a reason for a wired-but-unresolvable worker (the builtin:claude-code ENOENT case where `claude` is absent), with execution_available derived from the probed rows. The probe runs only on the advertisement path; the execute path already returned structured provider_unavailable on spawn. (2) A builtin:codex worker turn that reaches running but never completes (a stall in turn execution — auth, network, or model quota) is now bounded by a new turn_timeout_ms: on expiry the task fails with a self-contained message instead of sitting running forever with an empty diagnostic log. Config: turn_timeout_ms is added to the codex runtime config (dispatchers[].runtime.config.turn_timeout_ms), additive and defaulted to 600000ms, so existing configs load unchanged; `dreamux onboard` now writes it. No persisted-format or runtime-path change, and the tm fallback path is unchanged.
+- Refactor builtin Agent Runtime module layout without behavior changes: move the Codex AgentRuntime implementation under agent-runtime, split the Claude Code resident transport into claude-code supervisor/rpc/stream/types/mcp-config modules, and share process-group helpers from runtime/process.
+- Change the builtin:claude-code per-turn deadline from a fixed total-turn wall-clock to an idle/inactivity window for issue #156. `turn_timeout_ms` (default 600000) is now reset on every inbound stream line, so it bounds the max time the resident child may emit no stream activity rather than the total turn duration. A long but continuously-streaming turn (e.g. a deep audit running many tool calls for far longer than the window) is no longer reaped mid-work, while a genuinely wedged child that goes silent for the whole window is still failed and reaped (preserving the #120 anti-hang intent). No config change is required; the field name and default are unchanged, but its semantics changed (total-turn cap -> idle window). The timeout error text changed from 'timed out ... without a result' to 'stalled: no stream activity for {ms}ms'.
+- Bound teammate completion push-back and move channel-input assembly into each runtime (#164). Completion results over an inline budget (default 32000 chars, TASK_MAX_OUTPUT_LENGTH override, clamped to 160000) are spilled to a 0600 /tmp file and only the path is inlined. The claude-code runtime drops the fake <task-notification> XML and delivers a plain status-varied user turn (isSynthetic:false; capability kind claudeCodeTaskNotification -> claudeCodePlainTurn); codex keeps its <teammate_session_completion> wrapper. CompletionEnvelope.status widens to completed|failed|stopped (no longer folded). Inbound Feishu messages are now assembled by each runtime into the native <channel source="feishu" …> envelope (codex's <feishu_message> wrapper retired); the channel layer stops pre-rendering XML and hands runtimes neutral structured pieces. No persisted config/state format changes, so no rebuild is required.
+- Remove the in-memory DispatcherRow field codex_cwd and the server-ctl `codex-cwd` status flag (the field was never persisted to status.json). The dispatcher runtime cwd is now a required launch parameter supplied by the Dispatcher Service; codex bin resolution and per-runtime artifact paths moved behind the Agent Runtime providers. No persisted format change; no rebuild required.
 
 ## 0.12.0
 Sat, 06 Jun 2026 10:02:33 GMT