expect(testing.resolveCodexDynamicToolsLoading({}, privateQaCodexEnv)).toBe("direct");

});

it("limits Codex memory flush runs to managed read and write tools", async () => {

const factoryOptions: unknown[] = [];

testing.setOpenClawCodingToolsFactoryForTests((options) => {

factoryOptions.push(options);

return [

createRuntimeDynamicTool("read"),

createRuntimeDynamicTool("write"),

createRuntimeDynamicTool("exec"),

createRuntimeDynamicTool("process"),

createRuntimeDynamicTool("apply_patch"),

createRuntimeDynamicTool("message"),

];

});

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

const params = createParams(sessionFile, workspaceDir);

params.disableTools = false;

params.runtimePlan = createCodexRuntimePlanFixture();

params.trigger = "memory";

params.memoryFlushWritePath = "memory/2026-05-22.md";

const sandboxSessionKey = params.sessionKey;

if (!sandboxSessionKey) {

throw new Error("createParams must provide a sessionKey for Codex dynamic tool tests.");

}

const nativeToolSurfaceEnabled = testing.shouldEnableCodexAppServerNativeToolSurface(params, {

enabled: true,

backendId: "docker",

} as never);

const tools = await testing.buildDynamicTools({

params,

resolvedWorkspace: workspaceDir,

effectiveWorkspace: workspaceDir,

sandboxSessionKey,

sandbox: { enabled: true, backendId: "docker" } as never,

nativeToolSurfaceEnabled,

runAbortController: new AbortController(),

sessionAgentId: "main",

pluginConfig: {},

onYieldDetected: () => undefined,

});

expect(nativeToolSurfaceEnabled).toBe(false);

expect(factoryOptions).toHaveLength(1);

expect(factoryOptions[0]).toMatchObject({

trigger: "memory",

memoryFlushWritePath: "memory/2026-05-22.md",

});

expect(tools.map((tool) => tool.name)).toEqual(["read", "write"]);

});

it("exposes OpenClaw sandbox shell tools under distinct names for non-Docker sandbox backends", async () => {

testing.setOpenClawCodingToolsFactoryForTests(() => [

createRuntimeDynamicTool("read"),

"edit",

"apply_patch",

] as const;

const CODEX_MEMORY_FLUSH_DYNAMIC_TOOL_ALLOW = new Set(["read", "write"]);

const CODEX_NATIVE_PROJECT_DOC_BASENAMES = new Set(["agents.md"]);

const CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = new Set([

"identity.md",

},

});

const codexFilteredTools = addSandboxShellDynamicToolsIfAvailable(

filterCodexDynamicTools(allTools, input.pluginConfig),

isCodexMemoryFlushRun(params)

? filterCodexMemoryFlushDynamicTools(allTools)

: filterCodexDynamicTools(allTools, input.pluginConfig),

allTools,

input,

);

sandbox?: OpenClawSandboxContext,

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

): boolean {

if (isCodexMemoryFlushRun(params)) {

return false;

}

const toolsAllow = includeForcedMessageToolAllow(params.toolsAllow, params);

if (toolsAllow === undefined) {

return canCodexAppServerNativeToolSurfaceHonorSandbox(sandbox, options);

);

}

function isCodexMemoryFlushRun(

params?: Pick<EmbeddedRunAttemptParams, "trigger" | "memoryFlushWritePath">,

): boolean {

return params?.trigger === "memory" && Boolean(params.memoryFlushWritePath?.trim());

}

function filterCodexMemoryFlushDynamicTools<T extends { name: string }>(tools: T[]): T[] {

return tools.filter((tool) =>

CODEX_MEMORY_FLUSH_DYNAMIC_TOOL_ALLOW.has(normalizeCodexDynamicToolName(tool.name)),

);

}

function shouldRequireCodexSandboxExecServerEnvironment(params: {

sandbox?: OpenClawSandboxContext;

nativeToolSurfaceEnabled: boolean;

}

function shouldExposeSandboxExecDynamicTool(input: DynamicToolBuildParams): boolean {

if (isCodexMemoryFlushRun(input.params)) {

return false;

}

const backendId = input.sandbox?.enabled ? input.sandbox.backendId.trim().toLowerCase() : "";

return Boolean(backendId && input.nativeToolSurfaceEnabled === false);

}

const refreshQueuedFollowupSessionMock = vi.fn();

const incrementCompactionCountMock = vi.fn();

const ensureSelectedAgentHarnessPluginMock = vi.fn();

const ensureMemoryFlushTargetFileMock = vi.fn();

function registerMemoryFlushPlanResolverForTest(resolver: MemoryFlushPlanResolver): void {

registerMemoryCapability("memory-core", { flushPlanResolver: resolver });

});

runEmbeddedPiAgentMock.mockReset().mockResolvedValue({ payloads: [], meta: {} });

refreshQueuedFollowupSessionMock.mockReset();

ensureMemoryFlushTargetFileMock.mockReset().mockResolvedValue(undefined);

ensureSelectedAgentHarnessPluginMock.mockReset().mockResolvedValue(undefined);

incrementCompactionCountMock.mockReset().mockImplementation(async (params) => {

const sessionKey = String(params.sessionKey ?? "");

compactEmbeddedPiSession: compactEmbeddedPiSessionMock as never,

runWithModelFallback: runWithModelFallbackMock as never,

runEmbeddedPiAgent: runEmbeddedPiAgentMock as never,

ensureMemoryFlushTargetFile: ensureMemoryFlushTargetFileMock as never,

refreshQueuedFollowupSession: refreshQueuedFollowupSessionMock as never,

incrementCompactionCount: incrementCompactionCountMock as never,

ensureSelectedAgentHarnessPlugin: ensureSelectedAgentHarnessPluginMock as never,

expect(flushCall.prompt).not.toBe(flushCall.transcriptPrompt);

expect(flushCall.memoryFlushWritePath).toMatch(/^memory\/\d{4}-\d{2}-\d{2}\.md$/);

expect(flushCall.silentExpected).toBe(true);

expect(ensureMemoryFlushTargetFileMock).toHaveBeenCalledWith({

workspaceDir: followupRun.run.workspaceDir,

relativePath: flushCall.memoryFlushWritePath,

});

expect(ensureMemoryFlushTargetFileMock.mock.invocationCallOrder[0]).toBeLessThan(

runEmbeddedPiAgentMock.mock.invocationCallOrder[0] ?? 0,

);

expect(refreshQueuedFollowupSessionMock).toHaveBeenCalledTimes(1);

const refreshCall = requireRefreshQueuedFollowupSessionCall();

expect(refreshCall.key).toBe(sessionKey);

import crypto from "node:crypto";

import fs from "node:fs";

import path from "node:path";

import type { AgentMessage } from "@earendil-works/pi-agent-core";

import { resolveBootstrapWarningSignaturesSeen } from "../../agents/bootstrap-budget.js";

import { estimateMessagesTokens } from "../../agents/compaction.js";

return await runEmbeddedPiAgent(...args);

}

async function ensureMemoryFlushTargetFile(params: {

workspaceDir: string;

relativePath: string;

}): Promise<void> {

const workspaceDir = normalizeOptionalString(params.workspaceDir);

const relativePath = normalizeOptionalString(params.relativePath);

if (!workspaceDir || !relativePath || path.isAbsolute(relativePath)) {

throw new Error("Invalid memory flush target path");

}

const workspaceRoot = path.resolve(workspaceDir);

const targetPath = path.resolve(workspaceRoot, relativePath);

const targetRelativePath = path.relative(workspaceRoot, targetPath);

if (

!targetRelativePath ||

targetRelativePath.startsWith("..") ||

path.isAbsolute(targetRelativePath)

) {

throw new Error("Memory flush target path must stay inside the workspace");

}

await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });

const handle = await fs.promises.open(targetPath, "a");

await handle.close();

}

const memoryDeps = {

compactEmbeddedPiSession: compactEmbeddedPiSessionDefault,

runWithModelFallback,

ensureSelectedAgentHarnessPlugin,

runEmbeddedPiAgent: runEmbeddedPiAgentDefault,

ensureMemoryFlushTargetFile,

registerAgentRunContext,

refreshQueuedFollowupSession,

incrementCompactionCount,

ensureSelectedAgentHarnessPlugin,

compactEmbeddedPiSession: compactEmbeddedPiSessionDefault,

runEmbeddedPiAgent: runEmbeddedPiAgentDefault,

ensureMemoryFlushTargetFile,

registerAgentRunContext,

refreshQueuedFollowupSession,

incrementCompactionCount,

nowMs: memoryFlushNowMs,

}) ?? memoryFlushPlan;

const memoryFlushWritePath = activeMemoryFlushPlan.relativePath;

await memoryDeps.ensureMemoryFlushTargetFile({

workspaceDir: params.followupRun.run.workspaceDir,

relativePath: memoryFlushWritePath,

});

const flushSystemPrompt = [

params.followupRun.run.extraSystemPrompt,

activeMemoryFlushPlan.systemPrompt,