� This is the 1st commit message:

:recycle: refactor: refactor async api request

� The commit message #2 will be skipped:

� ♻️ refactor: refactor async api request

Phase 5 (UI): WebGPT rebrand deployed, ru-RU locale
Phase 6 (Cleanup): old VPS #2 services removed, YooKassa keys set

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

8 commits across fork + home, 10 tasks, Foundation layer landed.
Nav visibility bug traced to DEFAULT_SIDEBAR_ITEMS allowlist in
systemStatus.ts. All verification green: typecheck 0 errors,
121/121 vitest passed, container healthy, bundle includes nav refs.

Next: spec sub-project #2 (PHI middleware extraction).

Sub-project #2 landed 2026-04-20. 9 commits on obsidian-pantheon
home repo. All verifications green. Clinical re-cert signed.

Retro captures: plan v1→v2 drift lessons (spec subagents must read
wrapped module signatures first), user-session systemd User/Group
pitfall, Redis fallback worked seamlessly, MCP session init pattern
for roundtrip testing.

Next: sub-project #2.5 (filesystem consolidation) + lobehub#3 (gateway).

Injection surface #2 of 2 for Sub-project lobehub#5 VRM avatars. Adds
<VRMAvatar size={128}> to features/AgentHome/AgentInfo (the welcome
card the user first sees when entering an agent session) behind the
same NEXT_PUBLIC_VRM_AVATARS flag as the chat-header chip.

Design spec §3 calls out two injection points: chat-header chip (Tags,
already landed) and agent-select. The functional equivalent of
agent-select in the current UI is AgentHome/AgentInfo — the avatar
card shown before the first message and re-shown when changing agents.
Inbox agents are excluded (no manifest binding).

Tests expanded 32 -> 47:

- Scene.test.tsx (new, 5): placeholder rendered, error status set in
  happy-dom (no WebGL), size propagation, stage background URL,
  gradient fallback for unknown stage.
- VRMAvatar.test.tsx (+4 = 8 total): resolver-API happy path shown
  in placeholder, prefers-reduced-motion skips scene, IntersectionObserver
  gating keeps off-screen avatars as placeholders, 3x concurrency cap.
- injection.test.tsx (new, 6): AgentHome/AgentInfo flag-off and flag-on
  renders, inbox-excluded case; feature-flag predicate isolation tests
  (NEXT_PUBLIC / VITE_PUBLIC parity), TitleTags module parses.

Type-only import of Three.Object3D so Scene.tsx has no new tsc errors.

Verify:
  pnpm vitest run src/features/VRMAvatar/  -> 47 passed
  tsc --noEmit                             -> 0 VRMAvatar errors

…chunks

When stdout emits multiple chunks back-to-back — or `'end'` lands while an
earlier `pipeline.push()` is still awaiting the Codex tracker's filesystem
reads — the per-chunk `.then` handlers ran concurrently. Two consequences:

1. Out-of-order events. Push #2's events could resolve before push #1's,
   so the JSONL stream came out shuffled.

2. Late-event loss. `'end'` would call `pipeline.flush()` and immediately
   set `streamEnded = true` while prior pushes were still pending. The
   async iterator could then return `{ done: true }` before those pushes
   queued their events.

Fix: thread every `push()` / `flush()` / error-surface call through a single
`pipelineQueue` `Promise` chain, the same shape the desktop controller uses
for its broadcast queue. `flush()` now reliably runs after every queued
push has drained, so `streamEnded` is the very last write.

Two regression tests cover the failure modes by spying on
`AgentStreamPipeline.push` to inject deterministic delays:

- "preserves event ordering across async pipeline.push() calls" — chunk A
  resolves slower than chunk B; without the chain B arrives first.
- "iterator drains slow in-flight pushes before flushing the stream" —
  `'end'` fires while a 40 ms push is still pending; without the chain
  the iterator returns done before the chunk's events queue.

Bisected: both tests fail without the chain, pass with it. E2E re-smoke
(`bun src/index.ts hetero exec --type claude-code` simple text + tool-using
prompt + stdin) still produces clean ordered JSONL.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…runs (#14431)

* 🌐 i18n: add taskDetail.runAll keys for subtask dependency runner

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ✨ feat(cli): add `lh hetero exec` for standalone heterogeneous agent runs (LOBE-8523 phase 1a)

Phase 1a of LOBE-8516: a Node-side `spawnAgent()` plus the CLI command that
drives it. Standalone-only — no `--topic` / `--operation-id` / no server
ingest. Output is `AgentStreamEvent` JSONL on stdout, one event per line.

Why phase 1a is its own milestone: it lets us validate the producer pipeline
end-to-end (`spawn → JsonlStreamProcessor → adapter → toStreamEvent`) under a
plain Node process, get Device-mode + manual debugging unblocked, and ship
without waiting on phase 2's server `heteroIngest` procedures.

## Shared `spawnAgent({ agentType, prompt, resumeSessionId, cwd, command })`

- Lives in `@lobechat/heterogeneous-agents/spawn`. Pure Node — no Electron, no
  image cache, no on-disk tracing, no proxy env composition. Desktop main keeps
  its own bespoke spawn path for those host concerns; this minimal version is
  what the CLI sandbox + terminal use case needs.
- CC: stream-json stdin format + the established preset flags. Codex: `exec` /
  `exec resume` form with `--json --skip-git-repo-check --full-auto`.
- Returns `SpawnAgentHandle` with: async-iterable `events`, `exit` promise,
  `kill(signal)` (Unix process-group kill, Windows direct), `pid`, raw `stderr`.
- Internally a single-queue async iterator coordinates between the stdout
  listeners and the consumer — keeps backpressure simple, no extra deps.

## `lh hetero exec` command

```
lh hetero exec --type claude-code|codex
  [--prompt - | --prompt <text>]   # default stdin
  [--resume <sessionId>]
  [--cwd <path>]                    # default process.cwd()
  [--command <bin>]                 # default `claude` / `codex`
  [--operation-id <id>]             # uuid v4 generated if omitted
```

- Reads prompt from stdin when omitted or `-`.
- Forwards child stderr to ours so users see auth prompts / missing-binary
  errors.
- Ctrl-C → SIGINT to the child's process group (Unix); a second Ctrl-C
  escalates to SIGKILL.
- Exit code passthrough: child code 0/non-0 stays as-is; SIGINT / SIGTERM /
  SIGKILL map to POSIX 130 / 143 / 137.

## Out of scope (phase 1b — next PR)

- `--topic` / `--operation-id` flags as REQUIRED + the BatchIngester
- `--render none|jsonl` flag (phase 1a is implicit JSONL)
- trpc `aiAgent.heteroIngest` / `heteroFinish` calls
- Gateway WS interrupt subscription

## Validation

- `bunx vitest run packages/heterogeneous-agents` — 113 passing (8 new
  spawnAgent tests + the 105 pre-existing on canary)
- `bunx vitest run apps/cli/src/commands/hetero.test.ts` — 7 passing
  (all `--type` / `--prompt` / `--operation-id` / exit-code-passthrough /
  SIGINT-mapping branches)
- Real end-to-end: `bun src/index.ts hetero exec --type claude-code --prompt
  'Reply with exactly the word HELLO and nothing else.'` produced clean
  AgentStreamEvent JSONL (stream_start → 2 stream_chunks → step_complete
  turn_metadata → step_complete result_usage → stream_end → agent_runtime_end),
  every line stamped with the same auto-generated operationId.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* 🐛 fix(spawn): serialize pipeline pushes so flush waits for in-flight chunks

When stdout emits multiple chunks back-to-back — or `'end'` lands while an
earlier `pipeline.push()` is still awaiting the Codex tracker's filesystem
reads — the per-chunk `.then` handlers ran concurrently. Two consequences:

1. Out-of-order events. Push #2's events could resolve before push #1's,
   so the JSONL stream came out shuffled.

2. Late-event loss. `'end'` would call `pipeline.flush()` and immediately
   set `streamEnded = true` while prior pushes were still pending. The
   async iterator could then return `{ done: true }` before those pushes
   queued their events.

Fix: thread every `push()` / `flush()` / error-surface call through a single
`pipelineQueue` `Promise` chain, the same shape the desktop controller uses
for its broadcast queue. `flush()` now reliably runs after every queued
push has drained, so `streamEnded` is the very last write.

Two regression tests cover the failure modes by spying on
`AgentStreamPipeline.push` to inject deterministic delays:

- "preserves event ordering across async pipeline.push() calls" — chunk A
  resolves slower than chunk B; without the chain B arrives first.
- "iterator drains slow in-flight pushes before flushing the stream" —
  `'end'` fires while a 40 ms push is still pending; without the chain
  the iterator returns done before the chunk's events queue.

Bisected: both tests fail without the chain, pass with it. E2E re-smoke
(`bun src/index.ts hetero exec --type claude-code` simple text + tool-using
prompt + stdin) still produces clean ordered JSONL.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…antic-release-21.0.2

build(deps-dev): bump semantic-release from 20.1.3 to 21.0.2

- Add `suppressSignal` and `sourceMessageId` to `ExecAgentAppContext`
  so background agent runs can flag themselves and skip
  `agent.user.message` re-emission in execAgent (#2).
- Fix character truncation in `ToolResultWithKind.data: unknown`
  (was bare ` nknown;`).
- Replace the invalid `chatConfig.enableAutoCreateTopic` field on the
  three self-iteration builtin agents (nightly-review / self-reflection /
  self-feedback-intent) with the required `plugins:
  ['agent-signal-self-iteration']` so execAgent actually injects the
  self-iteration tool manifest at runtime.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

- Add `suppressSignal` and `sourceMessageId` to `ExecAgentAppContext`
  so background agent runs can flag themselves and skip
  `agent.user.message` re-emission in execAgent (#2).
- Fix character truncation in `ToolResultWithKind.data: unknown`
  (was bare ` nknown;`).
- Replace the invalid `chatConfig.enableAutoCreateTopic` field on the
  three self-iteration builtin agents (nightly-review / self-reflection /
  self-feedback-intent) with the required `plugins:
  ['agent-signal-self-iteration']` so execAgent actually injects the
  self-iteration tool manifest at runtime.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>