expect(logLines).toHaveLength(2);

});

it("imports bridge artifacts from legacy providers without agent ids", async () => {

const workspaceDir = await createBridgeWorkspace("legacy-agentids-workspace");

const { rootDir: vaultDir, config } = await createVault({

rootDir: nextCaseRoot("legacy-agentids-vault"),

config: {

vaultMode: "bridge",

bridge: {

enabled: true,

readMemoryArtifacts: true,

indexMemoryRoot: true,

},

},

});

const memoryPath = path.join(workspaceDir, "MEMORY.md");

await fs.writeFile(memoryPath, "# Durable Memory\n", "utf8");

registerBridgeArtifacts([

{

kind: "memory-root",

workspaceDir,

relativePath: "MEMORY.md",

absolutePath: memoryPath,

contentType: "markdown",

} as Omit<MemoryPluginPublicArtifact, "agentIds"> as MemoryPluginPublicArtifact,

]);

const appConfig: OpenClawConfig = {

agents: {

list: [{ id: "main", default: true, workspace: workspaceDir }],

},

};

const result = await syncMemoryWikiBridgeSources({ config, appConfig });

expect(result.importedCount).toBe(1);

expect(result.artifactCount).toBe(1);

const page = await fs.readFile(path.join(vaultDir, result.pagePaths[0] ?? ""), "utf8");

expect(page).toContain("# Memory Bridge: MEMORY");

expect(page).toContain("- Agents: unknown");

});

it("returns a no-op result outside bridge mode", async () => {

const { config } = await createVault({ rootDir: nextCaseRoot("isolated") });

registerMemoryRuntime,

resolveMemoryFlushPlan,

restoreMemoryPluginState,

type MemoryPluginPublicArtifact,

} from "./memory-state.js";

function createMemoryRuntime() {

]);

});

it("normalizes public memory artifacts without agent ids", async () => {

const legacyArtifact = {

kind: "memory-root",

workspaceDir: "/tmp/workspace",

relativePath: "MEMORY.md",

absolutePath: "/tmp/workspace/MEMORY.md",

contentType: "markdown" as const,

} as Omit<MemoryPluginPublicArtifact, "agentIds"> as MemoryPluginPublicArtifact;

registerMemoryCapability("memory-core", {

publicArtifacts: {

async listArtifacts() {

return [legacyArtifact];

},

},

});

await expect(listActiveMemoryPublicArtifacts({ cfg: {} as never })).resolves.toEqual([

{

kind: "memory-root",

workspaceDir: "/tmp/workspace",

relativePath: "MEMORY.md",

absolutePath: "/tmp/workspace/MEMORY.md",

agentIds: [],

contentType: "markdown",

},

]);

});

it("preserves sidecar runtime fields when a memory plugin adds public artifacts only", async () => {

const runtime = createMemoryRuntime();

const flushPlanResolver = () => createMemoryFlushPlan("memory/sidecar.md");

function cloneMemoryPublicArtifact(

artifact: MemoryPluginPublicArtifact,

): MemoryPluginPublicArtifact {

const agentIds = Array.isArray(artifact.agentIds) ? artifact.agentIds : [];

return {

...artifact,

agentIds: [...artifact.agentIds],

agentIds: [...agentIds],

};

}