- CLI/onboarding: localize the setup wizard and bundled channel setup flows for English, Simplified Chinese, and Traditional Chinese. (#80645) Thanks @GaosCode.

- Agents/skills: cache hydrated `resolvedSkills` across warm gateway turns while keying reuse by the redacted effective config, reducing redundant skill snapshot rebuilds without crossing config-gated skill boundaries. (#81451) Thanks @solodmd.

- Telegram/group chat: add opt-in `messages.groupChat.ambientTurns: "room_event"` handling so always-on ambient chatter can run as quiet room context and speak visibly only via the message tool. (#81317) Thanks @obviyus.

- Codex/context engines: bind thread-bootstrap projection epochs to Codex app-server threads, carry redacted tool-result context into fresh threads, and rotate backend threads when projection state changes. (#82351) Thanks @jalehman.

### Fixes

eed14a427f34d1531d63e5f1065ef2325b46f77e5a16ce809e5e845cd6700769 plugin-sdk-api-baseline.json

d8d090e4858f8d619b2151d69b8dc992132bc8930e04b990e4a69a433fb19d41 plugin-sdk-api-baseline.jsonl

ae6b95dffe88496aadee03e49b6b6db2db74d4bbd9b984be94a39d81df449f93 plugin-sdk-api-baseline.json

08da4f6d26afff58fc1accb2f1b12c2d0ef740a0abf60cbdef43a32f422a4382 plugin-sdk-api-baseline.jsonl

The factory `ctx` exposes optional `config`, `agentDir`, and `workspaceDir`

values for construction-time initialization.

`assemble()` may return `contextProjection` when the active harness has a

persistent backend thread. Omit it for legacy per-turn projection. Return

`{ mode: "thread_bootstrap", epoch }` when the assembled context should be

injected once into a backend thread and reused until the epoch changes. Change

the epoch after the engine's semantic context changes, such as after an

engine-owned compaction pass. Hosts may preserve tool-call metadata, input

shape, and redacted tool results in a thread-bootstrap projection so fresh

backend threads retain tool continuity without copying raw secret-bearing

payloads.

If your engine does **not** own the compaction algorithm, keep `compact()`

implemented and delegate it explicitly:

OpenClaw still owns channel routing, session files, visible message delivery,

OpenClaw dynamic tools, approvals, media delivery, and a transcript mirror.

Codex owns the canonical native thread, native model loop, native tool

continuation, and native compaction.

continuation, and native compaction unless the active OpenClaw context engine

declares that it owns compaction.

## Thread bindings and model changes

## Compaction and transcript mirror

When the selected model uses the Codex harness, native thread compaction is

delegated to Codex app-server. OpenClaw keeps a transcript mirror for channel

history, search, `/new`, `/reset`, and future model or harness switching.

delegated to Codex app-server unless an active context engine declares

`ownsCompaction: true`. Owning context engines compact first and cause OpenClaw

to abandon the old Codex backend thread so the next turn can rehydrate a fresh

thread from engine-managed context. OpenClaw keeps a transcript mirror for

channel history, search, `/new`, `/reset`, and future model or harness

switching.

When a context engine requests Codex thread-bootstrap projection, OpenClaw

projects tool-call names and ids, input shapes, and redacted tool-result content

into the fresh Codex thread. It does not copy raw tool-call argument values into

that projection.

The mirror includes the user prompt, final assistant text, and lightweight Codex

reasoning or plan records when the app-server emits them. Today, OpenClaw only

`openai-codex:*` auth profiles and `auth.order.openai-codex` remain valid, but

do not write new `openai-codex/gpt-*` model refs.

Do not set `compaction.model` or `compaction.provider` on Codex-backed agents.

Codex owns compaction through its native app-server thread state, so OpenClaw

Do not set `compaction.model` or `compaction.provider` on Codex-backed agents

unless a selected context engine owns compaction. Without an owning context

engine, Codex compacts through its native app-server thread state, so OpenClaw

ignores those local summarizer overrides at runtime and `openclaw doctor --fix`

removes them when the agent uses Codex.

`compaction.provider: "lossless-claw"` shape to the Lossless context-engine slot

when Codex is the active runtime.

When the active context engine reports `ownsCompaction: true`, `/compact` runs

that engine's compaction lifecycle and invalidates the bound Codex app-server

thread. The next Codex turn starts a fresh backend thread and rehydrates it from

the context engine instead of layering Codex native compaction on top of the

engine-owned semantic summary.

```json5

{

auth: {

- Codex-native shell, patch, MCP, and native app tools are owned by Codex.

OpenClaw can observe or block selected native events through the supported

relay, but it does not rewrite native tool arguments.

- Codex owns native compaction. OpenClaw keeps a transcript mirror for channel

history, search, `/new`, `/reset`, and future model or harness switching.

- Codex owns native compaction unless the active OpenClaw context engine

declares `ownsCompaction: true`. OpenClaw keeps a transcript mirror for

channel history, search, `/new`, `/reset`, and future model or harness

switching.

- Media generation, media understanding, TTS, approvals, and messaging-tool

output continue through the matching OpenClaw provider/model settings.

- `tool_result_persist` applies to OpenClaw-owned transcript tool results, not