- Codex app-server: stream commentary preambles into editable channel progress drafts without promoting them to final answers.

- Codex migration: remove the bundled `codex-cli` backend and repair legacy `codex-cli/*` model refs to the Codex app-server route on `openai/*`.

- Gateway/startup: add owner-level startup trace attribution for auth, plugin loading, lookup counts, and plugin sidecar services. (#81738) Thanks @samzong.

- Plugins/hooks: expose the resolved effective `contextTokenBudget` plus source/reference metadata on `llm_output` and sanitized `model_call_*` hook events/contexts so plugin cost and context-health alerts can use agent-level context caps. Fixes #64327. Thanks @BunsDev.

- Channels/status reactions: wire `StatusReactionController` into WhatsApp message turns (queued → thinking → tool → done/error lifecycle, on par with Telegram and Discord), add `deploy`/`build`/`concierge` emoji categories with tool-token routing, and replace the status reaction defaults with self-explanatory emoji (🧠 thinking, 🛠️ tool, 💻 coding, 🌐 web, ⏳ stallSoft, ⚠️ stallHard, ✅ done, ❌ error, 🗜️ compacting) so stall and lifecycle reactions read as status indicators instead of emotional commentary. Fixes #59077. (#80612) Thanks @gado-ships-it.

- Control UI: add a browser-local Text size setting in Appearance and Quick Settings, scaling chat and dense UI text while keeping inputs above the mobile Safari focus-zoom threshold. Fixes #8547. Thanks @BunsDev.

- Docs: add a dedicated ds4 provider page with local DeepSeek V4 Flash config, on-demand startup, context sizing, and live verification steps.

- `model_call_started` / `model_call_ended` - observe sanitized provider/model call metadata, timing, outcome, and bounded request-id hashes without prompt or response content

- `llm_input` - observe provider input (system prompt, prompt, history)

- `llm_output` - observe provider output

- `llm_output` - observe provider output, usage, and the resolved `contextTokenBudget` when available

**Tools**

bodies, or provider request IDs. These hooks include stable metadata such as

`runId`, `callId`, `provider`, `model`, optional `api`/`transport`, terminal

`durationMs`/`outcome`, and `upstreamRequestIdHash` when OpenClaw can derive a

bounded provider request-id hash.

bounded provider request-id hash. When the runtime has resolved context-window

metadata, the hook event and context also include `contextTokenBudget`, the

effective token budget after model/config/agent caps, plus

`contextWindowSource` and `contextWindowReferenceTokens` when a lower cap was

applied.

`before_agent_finalize` runs only when a harness is about to accept a natural

final assistant answer. It is not the `/stop` cancellation path and does not

provider: "codex",

modelId: "gpt-5.4-codex",

model: createCodexTestModel("codex"),

contextTokenBudget: 150_000,

contextWindowInfo: {

tokens: 150_000,

referenceTokens: 200_000,

source: "agentContextTokens",

},

thinkLevel: "medium",

disableTools: true,

timeoutMs: 5_000,

resolvedRef?: string;

runId?: string;

sessionId?: string;

contextTokenBudget?: number;

contextWindowSource?: string;

contextWindowReferenceTokens?: number;

},

{

runId?: string;

sessionId?: string;

contextTokenBudget?: number;

contextWindowSource?: string;

contextWindowReferenceTokens?: number;

},

{ runId?: string; sessionId?: string },

];

expect(llmOutputPayload.runId).toBe("run-1");

expect(llmOutputPayload.sessionId).toBe("session-1");

expect(llmOutputPayload.provider).toBe("codex");

expect(llmOutputPayload.model).toBe("gpt-5.4-codex");

expect(llmOutputPayload.contextTokenBudget).toBe(150_000);

expect(llmOutputPayload.contextWindowSource).toBe("agentContextTokens");

expect(llmOutputPayload.contextWindowReferenceTokens).toBe(200_000);

expect(llmOutputPayload.resolvedRef).toBe("codex/gpt-5.4-codex");

expect(llmOutputPayload.harnessId).toBe("codex");

expect(llmOutputPayload.assistantTexts).toEqual(["hello back"]);

expect(llmOutputPayload.lastAssistant?.role).toBe("assistant");

expect(llmOutputContext.runId).toBe("run-1");

expect(llmOutputContext.sessionId).toBe("session-1");

expect(llmOutputContext.contextTokenBudget).toBe(150_000);

expect(llmOutputContext.contextWindowSource).toBe("agentContextTokens");

expect(llmOutputContext.contextWindowReferenceTokens).toBe(200_000);

const [agentEndPayload, agentEndContext] = mockCall(agentEnd, "agent_end") as [

{ messages?: Array<{ role?: string }>; success?: boolean },

{ runId?: string; sessionId?: string },

});

const hadSessionFile = await pathExists(params.sessionFile);

let historyMessages = (await readMirroredSessionHistoryMessages(params.sessionFile)) ?? [];

const hookContextWindowFields = {

...(params.contextWindowInfo?.tokens

? { contextTokenBudget: params.contextWindowInfo.tokens }

: params.contextTokenBudget

? { contextTokenBudget: params.contextTokenBudget }

: {}),

...(params.contextWindowInfo?.source

? { contextWindowSource: params.contextWindowInfo.source }

: {}),

...(params.contextWindowInfo?.referenceTokens

? { contextWindowReferenceTokens: params.contextWindowInfo.referenceTokens }

: {}),

};

const hookContext = {

runId: params.runId,

agentId: sessionAgentId,

messageProvider: params.messageProvider ?? undefined,

trigger: params.trigger,

channelId: params.messageChannel ?? params.messageProvider ?? undefined,

...hookContextWindowFields,

};

if (activeContextEngine) {

await bootstrapHarnessContextEngine({

sessionId: params.sessionId,

provider: params.provider,

model: params.modelId,

...hookContextWindowFields,

resolvedRef:

params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,

...(params.runtimePlan?.observability.harnessId

sessionId: params.sessionId,

provider: params.provider,

model: params.modelId,

...hookContextWindowFields,

resolvedRef:

params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,

...(params.runtimePlan?.observability.harnessId

reusableCliSession: params?.cliSessionId ? { sessionId: params.cliSessionId } : {},

modelId: "gpt-5.4",

normalizedModel: "gpt-5.4",

contextWindowInfo: {

tokens: 150_000,

referenceTokens: 200_000,

source: "agentContextTokens",

},

systemPrompt: "You are a helpful assistant.",

systemPromptReport: {} as PreparedCliRunContext["systemPromptReport"],

bootstrapPromptWarningLines: [],

expect(llmOutputEvent.sessionId).toBe("s1");

expect(llmOutputEvent.provider).toBe("codex-cli");

expect(llmOutputEvent.model).toBe("gpt-5.4");

expect(llmOutputEvent.contextTokenBudget).toBe(150_000);

expect(llmOutputEvent.contextWindowSource).toBe("agentContextTokens");

expect(llmOutputEvent.contextWindowReferenceTokens).toBe(200_000);

expect(llmOutputEvent.assistantTexts).toEqual(["hello from cli"]);

const lastAssistant = requireRecord(llmOutputEvent.lastAssistant, "last assistant");

expect(lastAssistant.role).toBe("assistant");

expect(lastAssistant.content).toEqual([{ type: "text", text: "hello from cli" }]);

expect(lastAssistant.provider).toBe("codex-cli");

expect(lastAssistant.model).toBe("gpt-5.4");

expect(callArg(hookRunner.runLlmOutput, 0, 1, "llm_output context")).toBeTypeOf("object");

const llmOutputContext = requireRecord(

callArg(hookRunner.runLlmOutput, 0, 1, "llm_output context"),

"llm_output context",

);

expect(llmOutputContext.contextTokenBudget).toBe(150_000);

expect(llmOutputContext.contextWindowSource).toBe("agentContextTokens");

expect(llmOutputContext.contextWindowReferenceTokens).toBe(200_000);

const agentEndEvent = requireRecord(

callArg(hookRunner.runAgentEnd, 0, 0, "agent_end event"),

sessionId: params.sessionId,

workspaceDir: params.workspaceDir,

trigger: params.trigger,

...(context.contextWindowInfo?.tokens

? { contextTokenBudget: context.contextWindowInfo.tokens }

: {}),

...(context.contextWindowInfo?.source

? { contextWindowSource: context.contextWindowInfo.source }

: {}),

...(context.contextWindowInfo?.referenceTokens

? { contextWindowReferenceTokens: context.contextWindowInfo.referenceTokens }

: {}),

...buildAgentHookContextChannelFields(params),

} as const;

sessionId: params.sessionId,

provider: params.provider,

model: context.modelId,

...(context.contextWindowInfo?.tokens

? { contextTokenBudget: context.contextWindowInfo.tokens }

: {}),

...(context.contextWindowInfo?.source

? { contextWindowSource: context.contextWindowInfo.source }

: {}),

...(context.contextWindowInfo?.referenceTokens

? { contextWindowReferenceTokens: context.contextWindowInfo.referenceTokens }

: {}),

resolvedRef: `${params.provider}/${context.modelId}`,

assistantTexts,

...(lastAssistant ? { lastAssistant } : {}),

import { resolveCliBackendConfig } from "../cli-backends.js";

import { hashCliSessionText, resolveCliSessionReuse } from "../cli-session.js";

import { claudeCliSessionTranscriptHasContent } from "../command/attempt-execution.helpers.js";

import { resolveContextWindowInfo } from "../context-window-guard.js";

import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";

import { resolveHeartbeatPromptForSystemPrompt } from "../heartbeat-system-prompt.js";

import {

resolveBootstrapMaxChars,

const modelId = (params.model ?? "default").trim() || "default";

const normalizedModel = normalizeCliModel(modelId, backendResolved.config);

const modelDisplay = `${params.provider}/${modelId}`;

const contextWindowInfo = resolveContextWindowInfo({

cfg: params.config,

provider: params.provider,

modelId,

defaultTokens: DEFAULT_CONTEXT_TOKENS,

});

const sessionLabel = params.sessionKey ?? params.sessionId;

const { bootstrapFiles, contextFiles } = await prepareDeps.resolveBootstrapContextForRun({

reusableCliSession,

modelId,

normalizedModel,

contextWindowInfo,

systemPrompt,

systemPromptReport,

bootstrapPromptWarningLines: bootstrapPromptWarning.lines,

import type { InputProvenance } from "../../sessions/input-provenance.js";

import type { BootstrapContextMode } from "../bootstrap-files.js";

import type { ResolvedCliBackend } from "../cli-backends.js";

import type { ContextWindowInfo } from "../context-window-guard.js";

import type {

CurrentTurnPromptContext,

EmbeddedRunTrigger,

reusableCliSession: CliReusableSession;

modelId: string;

normalizedModel: string;

contextWindowInfo?: ContextWindowInfo;

systemPrompt: string;

systemPromptReport: SessionSystemPromptReport;

bootstrapPromptWarningLines: string[];

import type { PluginHookAgentContext } from "../../plugins/hook-types.js";

import type {

PluginHookAgentContext,

PluginHookContextWindowSource,

} from "../../plugins/hook-types.js";

export type AgentHarnessHookContext = {

runId: string;

messageProvider?: string;

trigger?: string;

channelId?: string;

contextTokenBudget?: number;

contextWindowSource?: PluginHookContextWindowSource;

contextWindowReferenceTokens?: number;

};

export function buildAgentHookContext(params: AgentHarnessHookContext): PluginHookAgentContext {

...(params.messageProvider ? { messageProvider: params.messageProvider } : {}),

...(params.trigger ? { trigger: params.trigger } : {}),

...(params.channelId ? { channelId: params.channelId } : {}),

...(params.contextTokenBudget ? { contextTokenBudget: params.contextTokenBudget } : {}),

...(params.contextWindowSource ? { contextWindowSource: params.contextWindowSource } : {}),

...(params.contextWindowReferenceTokens

? { contextWindowReferenceTokens: params.contextWindowReferenceTokens }

: {}),

};

}

allowGatewaySubagentBinding: params.allowGatewaySubagentBinding,

contextEngine,

contextTokenBudget: ctxInfo.tokens,

contextWindowInfo: ctxInfo,

skillsSnapshot: params.skillsSnapshot,

prompt,

transcriptPrompt: params.transcriptPrompt,