]);

await expect(fs.readFile(configPath, "utf-8")).resolves.toBe(cleanRaw);

const entries = await fs.readdir(path.dirname(configPath));

expect(entries.filter((entry) => entry.includes(".clobbered."))).toHaveLength(1);

expect(

entries.reduce((count, entry) => count + (entry.includes(".clobbered.") ? 1 : 0), 0),

).toBe(1);

expect(warn).toHaveBeenCalledWith(

expect.stringContaining("Config auto-stripped non-JSON prefix:"),

);

await expect(fs.readFile(configPath, "utf-8")).resolves.toBe(originalRaw);

const entries = await fs.readdir(path.dirname(configPath));

expect(entries.filter((entry) => entry.includes(".rejected."))).toHaveLength(1);

expect(

entries.reduce((count, entry) => count + (entry.includes(".rejected.") ? 1 : 0), 0),

).toBe(1);

expect(warn).toHaveBeenCalledWith(expect.stringContaining("Config write rejected:"));

});

});

};

}

function countMatching<T>(items: readonly T[], predicate: (item: T) => boolean): number {

let count = 0;

for (const item of items) {

if (predicate(item)) {

count += 1;

}

}

return count;

}

async function resolveTargetsForCustomRoot(home: string, agentIds: string[]) {

const customRoot = path.join(home, "custom-state");

const storePaths = await createAgentSessionStores(customRoot, agentIds);

const targets = await resolveAllAgentSessionStoreTargets(cfg, { env: process.env });

expectTargetsToContainStores(targets, storePaths);

expect(targets.filter((target) => target.storePath === storePaths.ops)).toHaveLength(1);

expect(countMatching(targets, (target) => target.storePath === storePaths.ops)).toBe(1);

});

});

const { storePaths, targets } = await resolveTargetsForCustomRoot(home, ["ops", "retired"]);

expectTargetsToContainStores(targets, storePaths);

expect(targets.filter((target) => target.storePath === storePaths.ops)).toHaveLength(1);

expect(countMatching(targets, (target) => target.storePath === storePaths.ops)).toBe(1);

});

});

const event = createInternalHookEvent("command", "new", "test-session");

await triggerInternalHook(event);

expect(event.messages.filter((message) => message === "reloadable-hook")).toHaveLength(1);

expect(

event.messages.reduce(

(count, message) => count + (message === "reloadable-hook" ? 1 : 0),

0,

),

).toBe(1);

});

it("should support named exports", async () => {

type GlobalHookRunner = NonNullable<ReturnType<typeof getGlobalHookRunner>>;

function countMatching<T>(items: readonly T[], predicate: (item: T) => boolean): number {

let count = 0;

for (const item of items) {

if (predicate(item)) {

count += 1;

}

}

return count;

}

function expectGlobalHookRunner(runner: ReturnType<typeof getGlobalHookRunner>): GlobalHookRunner {

expect(runner).toEqual(expect.objectContaining({ hasHooks: expect.any(Function) }));

if (runner === null) {

const event = createInternalHookEvent("gateway", "startup", "gateway:startup");

await triggerInternalHook(event);

expect(event.messages.filter((message) => message === "reload-hook-fired")).toHaveLength(1);

expect(countMatching(event.messages, (message) => message === "reload-hook-fired")).toBe(1);

clearInternalHooks();

});

});

} };`,

assert: (registry: ReturnType<typeof loadOpenClawPlugins>) => {

expect(registry.channels.filter((entry) => entry.plugin.id === "demo")).toHaveLength(1);

expect(countMatching(registry.channels, (entry) => entry.plugin.id === "demo")).toBe(1);

expect(

registry.channels.find((entry) => entry.plugin.id === "demo")?.plugin.meta?.label,

).toBe("Demo Duplicate");