- Update: carry plugin-validation bypasses into config mutation pre-write reads, so package update doctor repairs can finish while externalized plugin schemas are converging.

- Agents/subagents: warn and continue completion announce cleanup when lifecycle cleanup fails, preventing ended subagent runs from becoming silent ghosts. Fixes #82306. Thanks @SebTardif.

- Telegram: let authorized text `/stop` commands use the fast-abort path before queued agent work, so active turns stop immediately instead of processing the abort after the turn finishes; foreign-bot `/stop@otherbot` mentions now stay on the regular topic lane instead of being routed into our control lane. Fixes #82162. Thanks @civiltox.

- Sessions: drop persisted entries with invalid session ids and strip malformed transcript file metadata before hydrating session runtime state.

- Cron: skip persisted job rows with malformed schedule or payload shapes in memory, leaving the store for `openclaw doctor --fix` instead of hydrating them into runtime state.

- Task persistence: drop malformed array/scalar requester-origin JSON from task and task-flow SQLite sidecars instead of restoring it as delivery metadata.

- Agents/timeouts: clarify model idle-timeout errors and docs so provider `timeoutSeconds` is shown as bounded by the whole agent/run timeout ceiling.

});

});

it("normalizes malformed persisted session entry fields on load", async () => {

const { storePath } = await makeTmpStore({

"agent:main:good": {

sessionId: " s-good ",

updatedAt: "definitely-not-a-time",

sessionFile: { path: "bad.jsonl" },

},

"agent:main:object-id": { sessionId: { nested: "bad" }, updatedAt: Date.now() },

"agent:main:unsafe-id": { sessionId: "../etc/passwd", updatedAt: Date.now() },

} as unknown as Record<string, SessionEntry>);

const store = loadSessionStore(storePath, { skipCache: true });

expect(store["agent:main:good"]?.sessionId).toBe("s-good");

expect(store["agent:main:good"]?.updatedAt).toBe(0);

expect(store["agent:main:good"]?.sessionFile).toBeUndefined();

expect(store["agent:main:object-id"]).toBeUndefined();

expect(store["agent:main:unsafe-id"]).toBeUndefined();

});

it("skips session store disk writes when payload is unchanged", async () => {

const key = "agent:main:no-op-save";

const { storePath } = await makeTmpStore({

import { validateSessionId } from "./paths.js";

import type { SessionEntry } from "./types.js";

function isRecord(value: unknown): value is Record<string, unknown> {

return !!value && typeof value === "object" && !Array.isArray(value);

}

function isSafeSessionId(value: unknown): value is string {

if (typeof value !== "string") {

return false;

}

try {

validateSessionId(value);

return true;

} catch {

return false;

}

}

function normalizeOptionalTimestamp(value: unknown): number | undefined {

if (value === undefined) {

return undefined;

}

return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;

}

export function normalizePersistedSessionEntryShape(value: unknown): SessionEntry | undefined {

if (!isRecord(value) || !isSafeSessionId(value.sessionId)) {

return undefined;

}

let next = value as unknown as SessionEntry;

const sessionId = value.sessionId.trim();

if (sessionId !== value.sessionId) {

next = { ...next, sessionId };

}

if (value.sessionFile !== undefined && typeof value.sessionFile !== "string") {

if (next === value) {

next = { ...next };

}

delete next.sessionFile;

}

const updatedAt = normalizeOptionalTimestamp(value.updatedAt);

if (updatedAt !== value.updatedAt) {

if (next === value) {

next = { ...next };

}

next.updatedAt = updatedAt ?? 0;

}

return next;

}

setSerializedSessionStore,

writeSessionStoreCache,

} from "./store-cache.js";

import { normalizePersistedSessionEntryShape } from "./store-entry-shape.js";

import { collectSessionMaintenancePreserveKeys } from "./store-maintenance-preserve.js";

import { resolveMaintenanceConfig } from "./store-maintenance-runtime.js";

import {

return !!value && typeof value === "object" && !Array.isArray(value);

}

function isSessionEntryRecord(value: unknown): value is SessionEntry {

return !!value && typeof value === "object" && !Array.isArray(value);

}

function isRecord(value: unknown): value is Record<string, unknown> {

return !!value && typeof value === "object" && !Array.isArray(value);

}

export function normalizeSessionStore(store: Record<string, SessionEntry>): boolean {

let changed = false;

for (const [key, entry] of Object.entries(store)) {

if (!isSessionEntryRecord(entry)) {

const shaped = normalizePersistedSessionEntryShape(entry);

if (!shaped) {

delete store[key];

changed = true;

continue;

normalizePluginExtensionSlotKeys(

normalizePluginExtensions(

normalizePendingFinalDeliveryFields(

normalizeSessionEntryDelivery(normalizeSessionRuntimeModelFields(entry)),

normalizeSessionEntryDelivery(normalizeSessionRuntimeModelFields(shaped)),

),

),

),

expect(store.array).toBeUndefined();

});

});

it("filters invalid session ids and drops malformed sessionFile fields", async () => {

await withTempDir({ prefix: "openclaw-session-store-readonly-shape-" }, async (dir) => {

const storePath = path.join(dir, "sessions.json");

await fs.writeFile(

storePath,

JSON.stringify({

good: { sessionId: " good-session ", updatedAt: "bad", sessionFile: ["bad"] },

badId: { sessionId: { id: "bad" }, updatedAt: 1 },

traversal: { sessionId: "../etc/passwd", updatedAt: 1 },

}),

"utf8",

);

const store = readSessionStoreReadOnly(storePath);

expect(store.good?.sessionId).toBe("good-session");

expect(store.good?.updatedAt).toBe(0);

expect(store.good?.sessionFile).toBeUndefined();

expect(store.badId).toBeUndefined();

expect(store.traversal).toBeUndefined();

});

});

});

import fs from "node:fs";

import { z } from "zod";

import { safeParseJsonWithSchema } from "../../utils/zod-parse.js";

import { normalizePersistedSessionEntryShape } from "./store-entry-shape.js";

import type { SessionEntry } from "./types.js";

const SessionStoreSchema = z.record(z.string(), z.unknown()) as z.ZodType<

Record<string, SessionEntry | undefined>

>;

function isSessionEntryRecord(value: unknown): value is SessionEntry {

return !!value && typeof value === "object" && !Array.isArray(value);

}

export function readSessionStoreReadOnly(

storePath: string,

): Record<string, SessionEntry | undefined> {

}

const parsed = safeParseJsonWithSchema(SessionStoreSchema, raw) ?? {};

return Object.fromEntries(

Object.entries(parsed).filter(([, entry]) => isSessionEntryRecord(entry)),

Object.entries(parsed).flatMap(([key, entry]) => {

const normalized = normalizePersistedSessionEntryShape(entry);

return normalized ? [[key, normalized]] : [];

}),

);

} catch {

return {};

}

});

it("falls back to the canonical transcript path for malformed persisted sessionFile metadata", async () => {

fs.writeFileSync(

fixture.storePath(),

JSON.stringify({

[sessionKey]: {

sessionId,

sessionFile: { path: "../../escaped.jsonl" },

updatedAt: Date.now(),

},

}),

"utf-8",

);

const result = await appendAssistantMessageToSessionTranscript({

sessionKey,

text: "Hello from a repaired metadata boundary",

storePath: fixture.storePath(),

});

expect(result.ok).toBe(true);

if (result.ok) {

expect(result.sessionFile).toBe(

resolveSessionTranscriptPathInDir(sessionId, fixture.sessionsDir()),

);

expect(fs.existsSync(result.sessionFile)).toBe(true);

}

});

it("emits transcript update events for delivery mirrors", async () => {

const store = {

[sessionKey]: {