- Codex app-server: preserve network access for sandboxed Codex code-mode turns when the OpenClaw sandbox allows outbound egress. Fixes #83347. Thanks @YusukeIt0.

- QA-Lab: keep the OTLP smoke decoder independent of removed OpenTelemetry generated-root internals.

- Messages: default group/channel visible replies to automatic final delivery again, keeping `message_tool` opt-in for ambient/shared rooms and tool-reliable models.

- CLI/TUI: force standalone `/exit` runs to terminate after `runTui` returns so onboarding-launched TUI children do not stay alive invisibly. (#83501) Thanks @fuller-stack-dev.

- Agents/code mode: preserve agent, session, run, and channel context in `before_tool_call` hooks for top-level `exec`/`wait` dispatches. Fixes #83387.

- Replies: keep final payload delivery after live preview updates so channels can finalize or send the completed answer instead of losing preview-only drafts. (#83468)

- Discord: deliver final replies in progress-mode preview streams instead of deduplicating the final visible message. (#83443) Thanks @compoodment.

it("runs tui with explicit timeout override", async () => {

await runProgram(["tui", "--timeout-ms", "45000"]);

const options = firstMockArg(runTui) as { timeoutMs?: number };

const options = firstMockArg(runTui) as {

timeoutMs?: number;

forceProcessExitOnReturn?: boolean;

};

expect(options?.timeoutMs).toBe(45000);

expect(options?.forceProcessExitOnReturn).toBe(true);

});

it("runs crestodian one-shot requests", async () => {

message: opts.message as string | undefined,

timeoutMs,

historyLimit: Number.isNaN(historyLimit) ? undefined : historyLimit,

forceProcessExitOnReturn: true,

});

} catch (err) {

defaultRuntime.error(String(err));

});

});

it("handles /exit without sending through the gateway", async () => {

const { handleCommand, requestExit, sendChat, addUser, addSystem } = createHarness();

await handleCommand("/exit");

expect(requestExit).toHaveBeenCalledTimes(1);

expect(sendChat).not.toHaveBeenCalled();

expect(addUser).not.toHaveBeenCalled();

expect(addSystem).not.toHaveBeenCalled();

});

it("leaves a Crestodian breadcrumb after switching agents", async () => {

const { handleCommand, addSystem, setSession, state } = createHarness();

timeoutMs?: number;

historyLimit?: number;

message?: string;

/**

* Internal CLI guard: after the standalone TUI returns, force the child

* process out if imported runtime handles keep the event loop alive.

*/

forceProcessExitOnReturn?: boolean;

};

export type TuiExitReason = "exit" | "return-to-crestodian";

resolveLocalAuthSpawnOptions,

resolveTuiCtrlCAction,

resolveTuiSessionKey,

scheduleProcessExitAfterTuiReturn,

stopTuiSafely,

} from "./tui.js";

deferredFinish.setFinish(finish);

expect(finish).toHaveBeenCalledTimes(1);

});

it("schedules a process-exit guard after standalone TUI return", () => {

let callback: (() => void) | undefined;

const unref = vi.fn();

const setTimeoutFn = vi.fn((fn: () => void, ms: number) => {

callback = fn;

expect(ms).toBe(2000);

return { unref };

});

const exit = vi.fn();

const writeStderr = vi.fn();

scheduleProcessExitAfterTuiReturn({ setTimeoutFn, exit, writeStderr });

expect(setTimeoutFn).toHaveBeenCalledOnce();

expect(unref).toHaveBeenCalledOnce();

callback?.();

expect(writeStderr).toHaveBeenCalledWith("openclaw tui forcing process exit after return\n");

expect(exit).toHaveBeenCalledWith(0);

});

});

describe("resolveCodexCliBin", () => {

const TUI_SHUTDOWN_DRAIN_MAX_MS = 500;

const TUI_SHUTDOWN_DRAIN_IDLE_MS = 100;

const TUI_SHUTDOWN_HARD_EXIT_MS = 2000;

const TUI_PROCESS_EXIT_AFTER_RETURN_MS = 2000;

type TuiProcessExitTimer = {

unref?: () => void;

};

type TuiProcessExitTimeout = (callback: () => void, delayMs: number) => TuiProcessExitTimer;

export async function drainAndStopTuiSafely(tui: DrainableTui): Promise<void> {

if (typeof tui.terminal?.drainInput === "function") {

stopTuiSafely(() => tui.stop());

}

export function scheduleProcessExitAfterTuiReturn(

params: {

delayMs?: number;

setTimeoutFn?: TuiProcessExitTimeout;

exit?: (code?: number) => never | void;

writeStderr?: (text: string) => void;

} = {},

): TuiProcessExitTimer {

const delayMs = Math.max(0, Math.floor(params.delayMs ?? TUI_PROCESS_EXIT_AFTER_RETURN_MS));

const setTimeoutFn =

params.setTimeoutFn ??

((callback, timeoutMs) => setTimeout(callback, timeoutMs) as unknown as TuiProcessExitTimer);

const exit = params.exit ?? ((code?: number) => process.exit(code));

const writeStderr =

params.writeStderr ??

((text: string) => {

process.stderr.write(text);

});

const timer = setTimeoutFn(() => {

try {

writeStderr("openclaw tui forcing process exit after return\n");

} catch {

// Best effort only; forced exit must not depend on stderr.

}

exit(0);

}, delayMs);

timer.unref?.();

return timer;

}

type CtrlCAction = "clear" | "warn" | "exit";

type TuiCtrlCAction = CtrlCAction | "force-exit";

process.once("exit", finish);

deferredFinish.setFinish(finish);

});

if (opts.forceProcessExitOnReturn === true) {

scheduleProcessExitAfterTuiReturn();

}

return exitResult;

}