- Docker: keep the bundled Codex plugin in official release image keep lists so the default OpenAI agent harness remains available after Docker pruning. Fixes #83613. (#83626) Thanks @YuanHanzhong.

- CLI/channels: preserve the first line of `openclaw channels logs` output when the rolling tail window starts exactly on a line boundary, mirroring the already-fixed `readLogSlice` behavior in `src/logging/log-tail.ts`.

- Control UI: treat terminal session status as authoritative over stale active-run flags so completed terminal runs stop showing abort/live UI. (#84057)

- Codex/message: tell message-tool-only Codex turns to send visible channel output with `message(action="send")` before ending, so direct replies do not stay private. Fixes #84129. (#84397) Thanks @joshavant.

- CLI: preserve embedded equals signs in inline root option values instead of truncating after the second separator. (#83995) Thanks @ThiagoCAltoe.

- Matrix/config: accept `messages.queue.byChannel.matrix` queue overrides and keep queue provider schema/type keys aligned for Matrix, Google Chat, and Mattermost. Thanks @bdjben.

- CLI: format `openclaw acp client` failures through the shared error formatter so object-shaped errors stay readable instead of printing `[object Object]`. Fixes #83904. (#84080)

testing.buildDeveloperInstructions(params, {

dynamicTools: [createMessageDynamicTool("Message test tool")],

}),

).toContain("To send a visible message, use the `message` tool.");

).toContain('call `message` with `action="send"` before ending the turn');

expect(

testing.buildDeveloperInstructions(params, {

dynamicTools: [createMessageDynamicTool("Message test tool")],

}),

).toContain("Do not rely on normal final assistant text for visible delivery");

const withoutMessageToolInstructions = testing.buildDeveloperInstructions(params, {

dynamicTools: [],

params.sourceReplyDeliveryMode = "automatic";

const automaticInstructions = testing.buildDeveloperInstructions(params);

expect(automaticInstructions).toContain("active Codex delivery path");

expect(automaticInstructions).not.toContain("use the `message` tool");

expect(automaticInstructions).not.toContain('call `message` with `action="send"`');

});

it("includes Codex app-server scoped plugin command guidance in developer instructions", () => {

? dynamicTools.some((tool) => tool.name.trim() === "message")

: params.disableMessageTool !== true;

if (params.sourceReplyDeliveryMode === "message_tool_only" && messageToolAvailable) {

return "To send a visible message, use the `message` tool.";

return [

"Preserve channel/session context.",

'If this turn needs visible output in the current channel, call `message` with `action="send"` before ending the turn.',

"Do not rely on normal final assistant text for visible delivery; final text is private to OpenClaw/Codex in this mode.",

'If no visible channel response is needed, do not call `message(action="send")`.',

].join(" ");

}

return "To send a visible reply, use the active Codex delivery path.";

}

const defaultTool = createMessageTool();

expect(scopedTool.description).toContain(

'use action="send" with message for visible replies to the current source conversation',

'if visible output is needed in the current source conversation, call action="send" with message before ending',

);

expect(scopedTool.description).toContain("target defaults to the current source conversation");

expect(scopedTool.description).toContain("Normal final answers stay private");

expect(scopedTool.description).toContain(

"Normal final answers stay private and are not visible in this mode",

);

expect(explicitTargetTool.description).toContain("Include target when sending");

expect(explicitTargetTool.description).not.toContain(

"target defaults to the current source conversation",

);

expect(defaultTool.description).not.toContain(

"visible replies to the current source conversation",

"if visible output is needed in the current source conversation",

);

});

}).find((candidate) => candidate.name === "message");

expect(tool?.description).toContain(

'use action="send" with message for visible replies to the current source conversation',

'if visible output is needed in the current source conversation, call action="send" with message before ending',

);

});

const targetGuidance = requireExplicitTarget

? "Include target when sending."

: "target defaults to the current source conversation; omit unless sending elsewhere.";

return `${description} This turn: use action="send" with message for visible replies to the current source conversation. ${targetGuidance} Normal final answers stay private.`;

return `${description} This turn: if visible output is needed in the current source conversation, call action="send" with message before ending. ${targetGuidance} Normal final answers stay private and are not visible in this mode.`;

}

function appendMessageToolReadHint(

expect(managerMocks.runTurn).toHaveBeenCalledTimes(1);

const text = runTurnCall().text;

expect(text).toContain("Source channel delivery is private by default");

expect(text).toContain("message(action=send)");

expect(text).toContain('call `message` with `action="send"` before ending');

expect(text).toContain("The target defaults to the current source channel");

expect(text).toContain("reply privately unless you send explicitly");

});

[

"Source channel delivery is private by default for this turn.",

"Normal ACP final output will not be automatically posted to the source channel.",

"To send visible output, use message(action=send). The target defaults to the current source channel.",

'If visible output is needed in the current source channel, call `message` with `action="send"` before ending. The target defaults to the current source channel.',

].join(" "),

);

return params.promptText ? `${guidance}\n\n${params.promptText}` : guidance;

silentToken: "NO_REPLY",

});

expect(toolOnlyContext).toContain("Normal final replies are private");

expect(toolOnlyContext).toContain("message tool with action=send");

expect(toolOnlyContext).toContain('message tool with action="send" before ending');

expect(toolOnlyContext).toContain("Be a good group participant");

expect(toolOnlyContext).toContain("wrap bare URLs");

expect(toolOnlyContext).toContain("<https://example.com>");

expect(toolOnlyContext).toContain("do not call message(action=send)");

expect(toolOnlyContext).toContain('do not call message(action="send")');

expect(toolOnlyContext).not.toContain('reply with exactly "NO_REPLY"');

expect(

isolatedGroups.buildGroupIntro({

sourceReplyDeliveryMode: "message_tool_only",

});

expect(toolOnlyContext).toContain("Normal final replies are private");

expect(toolOnlyContext).toContain("message tool with action=send");

expect(toolOnlyContext).toContain("do not call message(action=send)");

expect(toolOnlyContext).toContain('message tool with action="send" before ending');

expect(toolOnlyContext).toContain('do not call message(action="send")');

expect(toolOnlyContext).not.toContain("NO_REPLY");

expect(toolOnlyContext).not.toContain("Your replies are automatically sent");

});

lines.push(`You are in a ${providerLabel} group chat.`);

if (messageToolOnly) {

lines.push(

"Normal final replies are private and are not automatically sent to this group chat. To post visible output here, use the message tool with action=send; the target defaults to this group chat.",

'Normal final replies are private and are not automatically sent to this group chat. If this turn needs visible output here, call the message tool with action="send" before ending; the target defaults to this group chat.',

);

} else {

lines.push(

!messageToolOnly && params.silentToken && params.silentReplyPolicy !== "disallow";

if (messageToolOnly) {

lines.push(

"If no visible group response is needed, do not call message(action=send). Your normal final answer stays private and will not be posted to the group.",

'If no visible group response is needed, do not call message(action="send"). Your normal final answer stays private and will not be posted to the group.',

);

}

if (canUseSilentReply) {

lines.push(`You are in a ${providerLabel} direct conversation.`);

if (messageToolOnly) {

lines.push(

"Normal final replies are private and are not automatically sent to this conversation. To post visible output here, use the message tool with action=send; the target defaults to this conversation.",

'Normal final replies are private and are not automatically sent to this conversation. If this turn needs visible output here, call the message tool with action="send" before ending; the target defaults to this conversation.',

);

lines.push(

"If no visible direct response is needed, do not call message(action=send). Your normal final answer stays private and will not be posted to the conversation.",

'If no visible direct response is needed, do not call message(action="send"). Your normal final answer stays private and will not be posted to the conversation.',

);

return lines.join(" ");

}

{ sourceReplyDeliveryMode: "message_tool_only" },

);

expect(text).toContain("Delivery: to send a message, use the `message` tool.");

expect(text).toContain(

'Delivery: if this turn needs visible output in the current source conversation, call `message` with `action="send"` before ending.',

);

expect(text.indexOf("Delivery:")).toBeLessThan(text.indexOf("Conversation info"));

expect(text).toContain("Conversation info (untrusted metadata):");

});

{ sourceReplyDeliveryMode: "automatic" },

);

expect(text).not.toContain("Delivery: to send a message");

expect(text).not.toContain("Delivery: if this turn needs visible output");

expect(text).toContain("Conversation info (untrusted metadata):");

});