import { registerMemoryCli } from "./src/cli.js";

import { registerDreamingCommand } from "./src/dreaming-command.js";

import { registerShortTermPromotionDreaming } from "./src/dreaming.js";

import {

buildMemoryFlushPlan,

DEFAULT_MEMORY_FLUSH_FORCE_TRANSCRIPT_BYTES,

DEFAULT_MEMORY_FLUSH_PROMPT,

DEFAULT_MEMORY_FLUSH_SOFT_TOKENS,

} from "./src/flush-plan.js";

import { buildMemoryFlushPlan } from "./src/flush-plan.js";

import { registerBuiltInMemoryEmbeddingProviders } from "./src/memory/provider-adapters.js";

import { buildPromptSection } from "./src/prompt-section.js";

import { listMemoryCorePublicArtifacts } from "./src/public-artifacts.js";

import { memoryRuntime } from "./src/runtime-provider.js";

import { createMemoryGetTool, createMemorySearchTool } from "./src/tools.js";

export {

buildMemoryFlushPlan,

DEFAULT_MEMORY_FLUSH_FORCE_TRANSCRIPT_BYTES,

DEFAULT_MEMORY_FLUSH_PROMPT,

DEFAULT_MEMORY_FLUSH_SOFT_TOKENS,

} from "./src/flush-plan.js";

export { buildPromptSection } from "./src/prompt-section.js";

export default definePluginEntry({

id: "memory-core",

name: "Memory (Core)",

export const MAX_CONCEPT_TAGS = 8;

export type ConceptTagScriptFamily = "latin" | "cjk" | "mixed" | "other";

type ConceptTagScriptFamily = "latin" | "cjk" | "mixed" | "other";

export type ConceptTagScriptCoverage = {

latinEntryCount: number;

/**

* Build the deterministic subagent session key used for dream narratives.

*/

export function buildNarrativeSessionKey(params: {

function buildNarrativeSessionKey(params: {

workspaceDir: string;

phase: NarrativePhaseData["phase"];

nowMs: number;

import fs from "node:fs/promises";

import path from "node:path";

export type DreamingArtifactsAuditIssue = {

type DreamingArtifactsAuditIssue = {

severity: "warn" | "error";

code:

| "dreaming-session-corpus-unreadable"

remove: (id: string) => Promise<{ removed?: boolean }>;

};

export type ShortTermPromotionDreamingConfig = {

type ShortTermPromotionDreamingConfig = {

enabled: boolean;

cron: string;

timezone?: string;

`If nothing to store, reply with ${SILENT_REPLY_TOKEN}.`,

].join(" ");

export const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = [

const DEFAULT_MEMORY_FLUSH_SYSTEM_PROMPT = [

"Pre-compaction memory flush turn.",

"The session is near auto-compaction; capture durable memories to disk.",

MEMORY_FLUSH_TARGET_HINT,

import type { MemorySearchRuntimeDebug } from "openclaw/plugin-sdk/memory-core-host-runtime-files";

import { vi } from "vitest";

export type SearchImpl = (opts?: {

type SearchImpl = (opts?: {

maxResults?: number;

minScore?: number;

sessionKey?: string;

qmdSearchModeOverride?: "query" | "search" | "vsearch";

onDebug?: (debug: MemorySearchRuntimeDebug) => void;

}) => Promise<unknown[]>;

export type MemoryReadParams = { relPath: string; from?: number; lines?: number };

export type MemoryReadResult = {

type MemoryReadResult = {

text: string;

path: string;

truncated?: boolean;

import {

DEFAULT_LOCAL_MODEL,

getMemoryEmbeddingProvider,

listMemoryEmbeddingProviders,

type MemoryEmbeddingProvider,

import { formatErrorMessage } from "../dreaming-shared.js";

import { canAutoSelectLocal } from "./provider-adapters.js";

export { DEFAULT_LOCAL_MODEL } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";

export type EmbeddingProvider = MemoryEmbeddingProvider;

export type EmbeddingProviderId = string;

export type EmbeddingProviderRequest = string;

export type EmbeddingProviderFallback = string;

type EmbeddingProviderFallback = string;

export type EmbeddingProviderRuntime = MemoryEmbeddingProviderRuntime;

export type EmbeddingProviderResult = {

DEFAULT_TEMPORAL_DECAY_CONFIG,

} from "./temporal-decay.js";

export type HybridSource = string;

type HybridSource = string;

export { type MMRConfig, DEFAULT_MMR_CONFIG };

export { type TemporalDecayConfig, DEFAULT_TEMPORAL_DECAY_CONFIG };

export type HybridVectorResult = {

type HybridVectorResult = {

id: string;

path: string;

startLine: number;

vectorScore: number;

};

export type HybridKeywordResult = {

type HybridKeywordResult = {

id: string;

path: string;

startLine: number;

import { randomUUID } from "node:crypto";

import fs from "node:fs/promises";

export async function moveMemoryIndexFiles(sourceBase: string, targetBase: string): Promise<void> {

async function moveMemoryIndexFiles(sourceBase: string, targetBase: string): Promise<void> {

const suffixes = ["", "-wal", "-shm"];

for (const suffix of suffixes) {

const source = `${sourceBase}${suffix}`;

}

}

export async function removeMemoryIndexFiles(basePath: string): Promise<void> {

async function removeMemoryIndexFiles(basePath: string): Promise<void> {

const suffixes = ["", "-wal", "-shm"];

await Promise.all(suffixes.map((suffix) => fs.rm(`${basePath}${suffix}`, { force: true })));

}

export async function swapMemoryIndexFiles(targetPath: string, tempPath: string): Promise<void> {

async function swapMemoryIndexFiles(targetPath: string, tempPath: string): Promise<void> {

const backupPath = `${targetPath}.backup-${randomUUID()}`;

await moveMemoryIndexFiles(targetPath, backupPath);

try {