- Config/gateway: recover configs accidentally prefixed with non-JSON output during gateway startup or `openclaw doctor --fix`, preserving the clobbered file as a backup while leaving normal config reads read-only.

- Pi embedded runs: pass real built-in tools into Pi session creation and then narrow active tool names after custom tool registration, so the runner and compaction paths compile cleanly and keep OpenClaw-managed custom tool allowlists without feeding string arrays into `createAgentSession`. Thanks @vincentkoc.

- Agents/OpenAI websocket: route native OpenAI websocket metadata and session-header decisions through the shared endpoint classifier so local mocks and custom `models.providers.openai.baseUrl` endpoints stay out of the native OpenAI path consistently across embedded-runner and websocket transport code. Thanks @vincentkoc.

- Cron/MCP: retire bundled MCP runtimes through one shared cleanup path for isolated cron run ends, persistent cron session rollover, and direct cron `deleteAfterRun` fallback cleanup. Fixes #69145, #68623, and #68827.

- MCP/gateway: tear down stdio MCP process trees on transport close and dispose bundled MCP runtimes during session delete/reset, preventing orphaned wrapper/server processes from accumulating. Fixes #68809 and #69465.

- Config: render validation warnings with real line breaks instead of a literal `\n` sequence in CLI/audit output. Fixes #70140.

- Cron/doctor: repair malformed persisted cron job IDs through `openclaw doctor`, including legacy `jobId`, non-string `id`, and missing `id` rows, so `cron list` no longer needs display-layer coercion for corrupt store data. Fixes #70128.

import { afterEach, describe, expect, it, vi } from "vitest";

import { cleanupBundleMcpHarness } from "./pi-bundle-mcp-test-harness.js";

import { __testing, materializeBundleMcpToolsForRun } from "./pi-bundle-mcp-tools.js";

import {

__testing,

getOrCreateSessionMcpRuntime,

materializeBundleMcpToolsForRun,

retireSessionMcpRuntime,

} from "./pi-bundle-mcp-tools.js";

import type { SessionMcpRuntime } from "./pi-bundle-mcp-types.js";

vi.mock("./embedded-pi-mcp.js", () => ({

expect((result.error as Error).message).toMatch(/disposed/);

expect(manager.listSessionIds()).not.toContain("session-d");

});

it("retires global session runtimes and ignores missing ids", async () => {

await getOrCreateSessionMcpRuntime({

sessionId: "session-retire",

sessionKey: "agent:test:session-retire",

workspaceDir: "/workspace",

});

expect(__testing.getCachedSessionIds()).toContain("session-retire");

await expect(

retireSessionMcpRuntime({ sessionId: " session-retire ", reason: "test" }),

).resolves.toBe(true);

expect(__testing.getCachedSessionIds()).not.toContain("session-retire");

await expect(retireSessionMcpRuntime({ sessionId: " ", reason: "test" })).resolves.toBe(false);

});

});

await getSessionMcpRuntimeManager().disposeSession(sessionId);

}

export async function retireSessionMcpRuntime(params: {

sessionId?: string | null;

reason: string;

onError?: (error: unknown, sessionId: string, reason: string) => void;

}): Promise<boolean> {

const sessionId = normalizeOptionalString(params.sessionId);

if (!sessionId) {

return false;

}

try {

await disposeSessionMcpRuntime(sessionId);

return true;

} catch (error) {

params.onError?.(error, sessionId, params.reason);

return false;

}

}

export async function disposeAllSessionMcpRuntimes(): Promise<void> {

await getSessionMcpRuntimeManager().disposeAll();

}

disposeSessionMcpRuntime,

getOrCreateSessionMcpRuntime,

getSessionMcpRuntimeManager,

retireSessionMcpRuntime,

} from "./pi-bundle-mcp-runtime.js";

export {

createBundleMcpToolRuntime,

let observedContexts: Array<Array<{ role?: string; content?: unknown }>> = [];

vi.mock("./pi-bundle-mcp-tools.js", () => ({

retireSessionMcpRuntime: vi.fn(async () => true),

getOrCreateSessionMcpRuntime: async () => ({

sessionId: "bundle-mcp-runtime",

sessionKey: "agent:test:bundle-mcp-e2e",

}));

vi.doMock("./pi-bundle-mcp-tools.js", () => ({

disposeSessionMcpRuntime: (sessionId: string) => disposeSessionMcpRuntimeMock(sessionId),

retireSessionMcpRuntime: ({ sessionId }: { sessionId?: string | null }) =>

sessionId ? disposeSessionMcpRuntimeMock(sessionId) : Promise.resolve(false),

}));

vi.doMock("./pi-embedded-runner/model.js", async () => {

const actual = await vi.importActual<typeof import("./pi-embedded-runner/model.js")>(

}));

vi.doMock("../pi-bundle-mcp-tools.js", () => ({

retireSessionMcpRuntime: vi.fn(async () => true),

createBundleMcpToolRuntime: vi.fn(async () => ({

tools: [],

dispose: vi.fn(async () => {}),

} from "../model-auth.js";

import { normalizeProviderId } from "../model-selection.js";

import { ensureOpenClawModelsJson } from "../models-config.js";

import { disposeSessionMcpRuntime } from "../pi-bundle-mcp-tools.js";

import { retireSessionMcpRuntime } from "../pi-bundle-mcp-tools.js";

import {

classifyFailoverReason,

extractObservedOverflowTokenCount,

await contextEngine.dispose?.();

stopRuntimeAuthRefreshTimer();

if (params.cleanupBundleMcpOnRunEnd === true) {

await disposeSessionMcpRuntime(params.sessionId).catch((error) => {

log.warn(

`bundle-mcp cleanup failed after run for ${params.sessionId}: ${formatErrorMessage(error)}`,

);

await retireSessionMcpRuntime({

sessionId: params.sessionId,

reason: "embedded-run-end",

onError: (error, sessionId) => {

log.warn(

`bundle-mcp cleanup failed after run for ${sessionId}: ${formatErrorMessage(error)}`,

);

},

});

}

}

createBundleMcpToolRuntime: async () => undefined,

getOrCreateSessionMcpRuntime: async () => undefined,

materializeBundleMcpToolsForRun: async () => undefined,

retireSessionMcpRuntime: async () => true,

}));

vi.mock("../../pi-bundle-lsp-runtime.js", () => ({

import { clearBootstrapSnapshotOnSessionRollover } from "../../agents/bootstrap-cache.js";

import { getCliSessionBinding } from "../../agents/cli-session.js";

import { resetRegisteredAgentHarnessSessions } from "../../agents/harness/registry.js";

import { disposeSessionMcpRuntime } from "../../agents/pi-bundle-mcp-tools.js";

import { retireSessionMcpRuntime } from "../../agents/pi-bundle-mcp-tools.js";

import { normalizeChatType } from "../../channels/chat-type.js";

import { resolveGroupSessionKey } from "../../config/sessions/group.js";

import { canonicalizeMainSessionAlias } from "../../config/sessions/main-session.js";

agentId,

archivedTranscripts,

});

await disposeSessionMcpRuntime(previousSessionEntry.sessionId).catch((error) => {

log.warn(

`failed to dispose bundle MCP runtime for session ${previousSessionEntry.sessionId}`,

{

await retireSessionMcpRuntime({

sessionId: previousSessionEntry.sessionId,

reason: "reply-session-rollover",

onError: (error, sessionId) => {

log.warn(`failed to dispose bundle MCP runtime for session ${sessionId}`, {

error: String(error),

},

);

});

},

});

await resetRegisteredAgentHarnessSessions({

sessionId: previousSessionEntry.sessionId,