- Agents/memory: explain that memory-triggered compaction exposes only `read` and append-only `write` when configured core tools are unavailable in `tools.allow` warnings. Fixes #82941. Thanks @galiniliev.

- Agents/OpenAI: preserve deterministic tool payload ordering for prompt-cache reuse across OpenAI Responses and chat completions calls. (#82940) Thanks @galiniliev.

- Agents/skills: apply the full effective tool policy pipeline to inline `command-dispatch: tool` skill dispatch before owner-only filtering, preserving configured allow, deny, sandbox, sender, group, and subagent restrictions. (#78525)

- Codex: avoid spawning native hook relay subprocesses for post-tool/finalize events with no registered hook handlers while preserving pre-tool safety and approval relays. Fixes #76552. (#78004) Thanks @evgyur.

- Channel accounts: keep top-level default channel accounts visible when named accounts are added alongside default credential material, so mixed legacy/new account configs keep resolving `default` instead of silently dropping it.

- Codex/Telegram: synthesize native Codex tool progress from final turn snapshots so Telegram `/verbose` stays visible when command events arrive only at completion.

- Mac app: make Channels settings open faster by deferring config-schema work, avoiding startup channel probes, caching decoded channel status rows, and showing only compact quick settings instead of the full generated channel schema.

});

});

it("clears requested hook events when the relay reports no local work", () => {

expect(

buildCodexNativeHookRelayConfig({

relay: createRelay({ inactiveEvents: ["post_tool_use", "before_agent_finalize"] }),

events: ["pre_tool_use", "post_tool_use", "before_agent_finalize"],

}),

).toEqual({

"features.hooks": true,

"hooks.PreToolUse": [

{

hooks: [

{

type: "command",

command:

"openclaw hooks relay --provider codex --relay-id relay-1 --event pre_tool_use",

timeout: 5,

async: false,

statusMessage: "OpenClaw native hook relay",

},

],

},

],

"hooks.PostToolUse": [],

"hooks.Stop": [],

"hooks.state": {

"/<session-flags>/config.toml:pre_tool_use:0:0": {

enabled: true,

trusted_hash: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),

},

"<session-flags>/config.toml:pre_tool_use:0:0": {

enabled: true,

trusted_hash: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),

},

},

});

});

it("omits matchers so Codex MCP tool names reach the relay with a stable trust hash", () => {

const config = buildCodexNativeHookRelayConfig({

relay: createRelay(),

});

});

function createRelay(): NativeHookRelayRegistrationHandle {

function createRelay(options?: {

inactiveEvents?: readonly NativeHookRelayRegistrationHandle["allowedEvents"][number][];

}): NativeHookRelayRegistrationHandle {

const inactiveEvents = new Set(options?.inactiveEvents ?? []);

return {

relayId: "relay-1",

provider: "codex",

runId: "run-1",

allowedEvents: ["pre_tool_use", "post_tool_use", "permission_request", "before_agent_finalize"],

expiresAtMs: Date.now() + 1000,

shouldRelayEvent: (event) => !inactiveEvents.has(event),

commandForEvent: (event) =>

`openclaw hooks relay --provider codex --relay-id relay-1 --event ${event}`,

renew: () => undefined,

const hookState: JsonObject = {};

for (const event of events) {

const codexEvent = CODEX_HOOK_EVENT_BY_NATIVE_EVENT[event];

if (!params.relay.shouldRelayEvent(event)) {

config[`hooks.${codexEvent}`] = [] satisfies JsonValue;

continue;

}

const command = params.relay.commandForEvent(event);

const timeout = normalizeHookTimeoutSec(params.hookTimeoutSec);

config[`hooks.${codexEvent}`] = [

?.config;

expect(startConfig?.["features.hooks"]).toBe(true);

expect(Array.isArray(startConfig?.["hooks.PreToolUse"])).toBe(true);

expect(Array.isArray(startConfig?.["hooks.PostToolUse"])).toBe(true);

expect(Array.isArray(startConfig?.["hooks.Stop"])).toBe(true);

expect(startConfig?.["hooks.PostToolUse"]).toEqual([]);

expect(startConfig?.["hooks.Stop"]).toEqual([]);

expect(startConfig).not.toHaveProperty("hooks.PermissionRequest");

const relayId = extractRelayIdFromThreadRequest(startRequest?.params);

expect(

});

projector = new CodexAppServerEventProjector(params, thread.threadId, activeTurnId, {

nativePostToolUseRelayEnabled:

nativeHookRelay?.allowedEvents.includes("post_tool_use") === true,

nativeHookRelay?.allowedEvents.includes("post_tool_use") === true &&

nativeHookRelay.shouldRelayEvent("post_tool_use"),

trajectoryRecorder,

});

if (

);

});

it("preserves safety relays while marking hook-only events without handlers inactive", () => {

const relay = registerNativeHookRelay({

provider: "codex",

sessionId: "session-1",

runId: "run-1",

command: {

executable: "/opt/Open Claw/openclaw.mjs",

nodeExecutable: "/usr/local/bin/node",

timeoutMs: 1234,

},

});

expect(relay.shouldRelayEvent("pre_tool_use")).toBe(true);

expect(relay.shouldRelayEvent("post_tool_use")).toBe(false);

expect(relay.shouldRelayEvent("before_agent_finalize")).toBe(false);

expect(relay.shouldRelayEvent("permission_request")).toBe(true);

});

it("builds relay commands only for native events with matching local hooks", () => {

initializeGlobalHookRunner(

createMockPluginRegistry([{ hookName: "after_tool_call", handler: vi.fn() }]),

);

const relay = registerNativeHookRelay({

provider: "codex",

sessionId: "session-1",

runId: "run-1",

command: {

executable: "/opt/Open Claw/openclaw.mjs",

nodeExecutable: "/usr/local/bin/node",

timeoutMs: 1234,

},

});

expect(relay.shouldRelayEvent("pre_tool_use")).toBe(true);

expect(relay.shouldRelayEvent("post_tool_use")).toBe(true);

expect(relay.shouldRelayEvent("before_agent_finalize")).toBe(false);

expect(relay.commandForEvent("post_tool_use")).toBe(

"/usr/local/bin/node '/opt/Open Claw/openclaw.mjs' hooks relay --provider codex --relay-id " +

`${relay.relayId} --event post_tool_use --timeout 1234`,

);

});

it("builds relay commands for before-agent-finalize hooks", () => {

initializeGlobalHookRunner(

createMockPluginRegistry([{ hookName: "before_agent_finalize", handler: vi.fn() }]),

);

const relay = registerNativeHookRelay({

provider: "codex",

sessionId: "session-1",

runId: "run-1",

command: {

executable: "/opt/Open Claw/openclaw.mjs",

nodeExecutable: "/usr/local/bin/node",

timeoutMs: 1234,

},

});

expect(relay.shouldRelayEvent("before_agent_finalize")).toBe(true);

expect(relay.commandForEvent("before_agent_finalize")).toBe(

"/usr/local/bin/node '/opt/Open Claw/openclaw.mjs' hooks relay --provider codex --relay-id " +

`${relay.relayId} --event before_agent_finalize --timeout 1234`,

);

});

it("allows callers to replace a relay at a stable id", () => {

const first = registerNativeHookRelay({

provider: "codex",

import { resolveOpenClawPackageRootSync } from "../../infra/openclaw-root.js";

import { privateFileStoreSync } from "../../infra/private-file-store.js";

import { createSubsystemLogger } from "../../logging/subsystem.js";

import { hasGlobalHooks } from "../../plugins/hook-runner-global.js";

import { PluginApprovalResolutions } from "../../plugins/types.js";

import { runBeforeToolCallHook } from "../pi-tools.before-tool-call.js";

import { normalizeToolName } from "../tool-policy.js";

};

export type NativeHookRelayRegistrationHandle = NativeHookRelayRegistration & {

shouldRelayEvent: (event: NativeHookRelayEvent) => boolean;

commandForEvent: (event: NativeHookRelayEvent) => string;

renew: (ttlMs?: number) => void;

unregister: () => void;

registerNativeHookRelayBridge(registration);

const handle: NativeHookRelayRegistrationHandle = {

...registration,

shouldRelayEvent: nativeHookRelayEventHasLocalWork,

commandForEvent: (event) =>

buildNativeHookRelayCommand({

provider: params.provider,

]);

}

function nativeHookRelayEventHasLocalWork(event: NativeHookRelayEvent): boolean {

if (event === "pre_tool_use") {

return true;

}

if (event === "post_tool_use") {

return hasGlobalHooks("after_tool_call");

}

if (event === "before_agent_finalize") {

return hasGlobalHooks("before_agent_finalize");

}

return true;

}

export async function invokeNativeHookRelay(

params: InvokeNativeHookRelayParams,

): Promise<NativeHookRelayProcessResponse> {