it exists and is non-empty. `MEMORY.md` content is not pasted into native Codex

turn input when memory tools are available; when it exists, the harness adds a

small workspace-memory pointer and Codex should use `memory_search` or

`memory_get` when durable memory is relevant. If tools are disabled or memory

search is unavailable, `MEMORY.md` uses the normal bounded turn-context path.

`BOOTSTRAP.md` when present is forwarded as OpenClaw turn input reference

context.

- Workspace + bootstrap files (`AGENTS.md`, `SOUL.md`, `TOOLS.md`, `IDENTITY.md`, `USER.md`, `HEARTBEAT.md`, `BOOTSTRAP.md` when new, plus `MEMORY.md` when present). Native Codex turns do not paste raw `MEMORY.md` when memory tools are available; they include a small memory pointer and use memory tools on demand. If tools are disabled or memory search is unavailable, `MEMORY.md` uses the normal bounded turn-context path. Lowercase root `memory.md` is not injected; it is legacy repair input for `openclaw doctor --fix` when paired with `MEMORY.md`. Large injected files are truncated by `agents.defaults.bootstrapMaxChars` (default: 12000), and total bootstrap injection is capped by `agents.defaults.bootstrapTotalMaxChars` (default: 60000). `memory/*.md` daily files are not part of the normal bootstrap prompt; they remain on-demand via memory tools on ordinary turns, but reset/startup model runs can prepend a one-shot startup-context block with recent daily memory for that first turn. Bare chat `/new` and `/reset` commands are acknowledged without invoking the model. The startup prelude is controlled by `agents.defaults.startupContext`. Post-compaction AGENTS.md excerpts are separate and require explicit `agents.defaults.compaction.postCompactionSections` opt-in.

buildBootstrapContextForFiles,

resolveBootstrapFilesForRun,

const CODEX_MEMORY_CONTEXT_BASENAME = "memory.md";

const CODEX_MEMORY_TOOL_NAMES = new Set(["memory_search", "memory_get"]);

type CodexBootstrapFile = Awaited<ReturnType<typeof resolveBootstrapFilesForRun>>[number];

type CodexBootstrapContext = {

bootstrapFiles: CodexBootstrapFile[];

contextFiles: EmbeddedContextFile[];

memoryReferenceFiles?: EmbeddedContextFile[];

memoryToolRouted?: boolean;

memoryToolsAvailable: boolean;

const bootstrapFiles = await resolveBootstrapFilesForRun({

const memoryReferenceFiles = params.memoryToolsAvailable

? selectCodexWorkspaceMemoryReferenceFiles(bootstrapFiles).map((file) =>

remapCodexContextFilePath({

file: toCodexEmbeddedContextFile(file),

sourceWorkspaceDir: params.resolvedWorkspace,

targetWorkspaceDir: params.effectiveWorkspace,

}),

)

: [];

const contextFiles = buildBootstrapContextForFiles(

params.memoryToolsAvailable

? bootstrapFiles.filter((file) => !isCodexMemoryBootstrapFile(file))

: bootstrapFiles,

{

config: params.params.config,

agentId: params.params.agentId ?? params.sessionAgentId,

warn: (message) => embeddedAgentLog.warn(message),

},

).map((file) =>

const promptContextFiles = selectCodexWorkspacePromptContextFiles(contextFiles, {

excludeMemory: params.memoryToolsAvailable,

});

bootstrapFiles,

memoryReferenceFiles,

memoryToolRouted: params.memoryToolsAvailable,

memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true,

memoryToolRouted?: boolean;

} else if (

baseName === CODEX_MEMORY_CONTEXT_BASENAME &&

params.memoryToolRouted === true

) {

injectedChars = 0;

truncated = false;

workspaceMemoryReference?: string;

params.workspaceMemoryReference?.trim() ? params.workspaceMemoryReference.trim() : undefined,

const files = contextFiles;

options: { excludeMemory?: boolean } = {},

const excludeMemory = options.excludeMemory ?? true;

(!excludeMemory || baseName !== CODEX_MEMORY_CONTEXT_BASENAME) &&

function selectCodexWorkspaceMemoryReferenceFiles(

bootstrapFiles: CodexBootstrapFile[],

): CodexBootstrapFile[] {

return bootstrapFiles

.filter((file) => {

const baseName = getCodexBootstrapFileBasename(file);

return (

baseName === CODEX_MEMORY_CONTEXT_BASENAME &&

!file.missing &&

(file.content ?? "").trim().length > 0

);

})

.toSorted(compareCodexBootstrapFiles);

export function renderCodexWorkspaceMemoryReference(params: {

files: EmbeddedContextFile[];

}): string | undefined {

if (params.files.length === 0) {

return undefined;

}

const lines = [

"## OpenClaw Workspace Memory",

"",

`MEMORY.md exists in the active agent workspace. OpenClaw does not paste its contents into native Codex turns; use ${Array.from(CODEX_MEMORY_TOOL_NAMES).join(" or ")} when durable memory is relevant and the tools are available.`,

"",

];

for (const file of params.files) {

lines.push(`- ${file.path}`);

}

return lines.join("\n").trim();

export function hasCodexWorkspaceMemoryTools(tools: readonly { name: string }[]): boolean {

return tools.some((tool) => normalizeCodexDynamicToolName(tool.name) === "memory_search");

function isCodexMemoryBootstrapFile(file: CodexBootstrapFile): boolean {

return getCodexBootstrapFileBasename(file) === CODEX_MEMORY_CONTEXT_BASENAME;

function toCodexEmbeddedContextFile(file: CodexBootstrapFile): EmbeddedContextFile {

return {

path: readNonEmptyString(file.path) ?? readNonEmptyString(file.name) ?? "",

content: file.content ?? "",

};

function compareCodexBootstrapFiles(left: CodexBootstrapFile, right: CodexBootstrapFile): number {

return compareCodexContextFiles(

toCodexEmbeddedContextFile(left),

toCodexEmbeddedContextFile(right),

);

function getCodexBootstrapFileBasename(file: CodexBootstrapFile): string {

return getCodexContextFileBasename(

readNonEmptyString(file.path) ?? readNonEmptyString(file.name) ?? "",

);

function normalizeCodexDynamicToolName(name: string): string {

return name.trim().toLowerCase();