- Agents/heartbeat: stop heartbeat turns after the first valid `heartbeat_respond` so repeated response loops do not burn tokens. (#86357) Thanks @udaymanish6.

- Tasks: keep retained lost tasks out of default status health counts, explain their cleanup window during maintenance, and prune lost task records after 24 hours instead of the general 7-day terminal retention.

- Memory-core: keep REM dreaming focused on live light-staged memories and mark staged entries as considered so old recall history no longer dominates fresh candidates. (#86302) Thanks @SebTardif.

- Memory: abort sync instead of downgrading an existing semantic vector index to FTS-only when the configured embedding provider is temporarily unavailable. (#85704) Thanks @yaaboo-gif.

- Telegram: propagate forum topic names through the account-scoped topic cache for native command context and topic create/edit actions. (#86299) Thanks @SebTardif.

- Slack: keep downloaded read-only files out of reply media so Slack file reads do not echo files back to the conversation. (#86318) Thanks @neeravmakwana.

- Cron: accept leading-plus relative durations such as `+5m` for one-shot `--at` schedules. (#86341) Thanks @mushuiyu886.

protected pruneEmbeddingCacheIfNeeded(): void {}

protected resetProviderInitializationForRetry(): void {}

protected async indexFile(

_entry: MemoryIndexEntry,

_options: { source: MemorySource; content?: string },

protected pruneEmbeddingCacheIfNeeded(): void {}

protected resetProviderInitializationForRetry(): void {}

protected async indexFile(

_entry: MemoryIndexEntry,

_options: { source: MemorySource; content?: string },

): Promise<T>;

protected abstract getIndexConcurrency(): number;

protected abstract pruneEmbeddingCacheIfNeeded(): void;

protected abstract resetProviderInitializationForRetry(): void;

protected abstract indexFile(

entry: MemoryIndexEntry,

options: { source: MemorySource; content?: string },

return state;

}

private assertFtsOnlySyncAllowed(): void {

if (this.provider) {

return;

}

const existingMeta = this.readMeta();

if (

!existingMeta ||

existingMeta.model === "fts-only" ||

!this.settings.provider ||

this.settings.provider === "none"

) {

return;

}

this.resetProviderInitializationForRetry();

throw new Error(

`Memory sync aborted: embedding provider "${this.settings.provider}" is configured but unavailable. ` +

`Refusing to run sync in fts-only fallback mode to protect existing vector index (current model: ${existingMeta.model}).`,

);

}

protected async runSync(params?: {

reason?: string;

force?: boolean;

sessionFiles?: string[];

progress?: (update: MemorySyncProgressUpdate) => void;

}) {

// Guard: if an embedding provider is configured but currently unavailable,

// abort sync to prevent silently degrading an existing semantic vector index

// to fts-only and wiping existing semantic vectors.

// This only protects existing semantic indexes; fresh or already-fts-only

// indexes can safely sync without an embedding provider.

this.assertFtsOnlySyncAllowed();

const progress = params?.progress ? this.createSyncProgress(params.progress) : undefined;

if (progress) {

progress.report({

force?: boolean;

progress?: MemorySyncProgressState;

}): Promise<void> {

this.assertFtsOnlySyncAllowed();

const dbPath = resolveUserPath(this.settings.store.path);

const tempDbPath = `${dbPath}.tmp-${randomUUID()}`;

const tempDb = openMemoryDatabaseAtPath(tempDbPath, this.settings.store.vector.enabled);

protected pruneEmbeddingCacheIfNeeded(): void {}

protected resetProviderInitializationForRetry(): void {}

protected async indexFile(

entry: MemoryIndexEntry,

_options: { source: MemorySource; content?: string },

import type { OpenClawConfig } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";

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

import { closeAllMemorySearchManagers, getMemorySearchManager } from "./index.js";

import type { MemoryIndexMeta } from "./manager-reindex-state.js";

import type { MemoryIndexManager } from "./manager.js";

import "./test-runtime-mocks.js";

}

}

function writeExistingMeta(memoryManager: MemoryIndexManager, model: string): void {

const metaWriter = memoryManager as unknown as {

writeMeta(meta: MemoryIndexMeta): void;

};

metaWriter.writeMeta({

model,

provider: "openai",

chunkTokens: 600,

chunkOverlap: 120,

sources: ["memory"],

});

}

it("preserves indexed chunks across forced reindex in FTS-only mode", async () => {

const memoryManager = await createManager();

expect(countChunksContaining("refresh marker")).toBeGreaterThan(0);

expect(countChunksContaining("Alpha topic")).toBe(0);

});

it("aborts instead of downgrading an existing semantic index to FTS-only", async () => {

const memoryManager = await createManager();

writeExistingMeta(memoryManager, "mock-embed");

await expect(memoryManager.sync({ force: true })).rejects.toThrow(

"Refusing to run sync in fts-only fallback mode to protect existing vector index (current model: mock-embed).",

);

expect(memoryManager.status().provider).toBe("auto");

});

});

}

try {

await this.providerInitPromise;

} catch (err) {

// Clear the cached rejected promise so subsequent calls can retry

// initialization instead of being permanently stuck with a stale failure.

this.providerInitPromise = null;

throw err;

} finally {

if (this.providerInitialized) {

this.providerInitPromise = null;

}

}

}

protected resetProviderInitializationForRetry(): void {

this.providerInitialized = false;

this.providerInitPromise = null;

this.providerUnavailableReason = undefined;

this.providerLifecycle = createPendingMemoryProviderLifecycle(this.requestedProvider);

}

protected markLocalEmbeddingProviderDegraded(err: unknown): void {

if (this.provider?.id !== "local") {

return;