to: "dm:qa-operator",

text: "hi",

});

expect(inbound.id).toEqual(expect.stringMatching(/\S/));

expect(outbound.id).toEqual(expect.stringMatching(/\S/));

expect(inbound.id.trim()).not.toBe("");

expect(outbound.id.trim()).not.toBe("");

api.readTransportMessage({ accountId: "qa-channel", messageId: outbound.id });

await api.reset();

await api.resetBus();

expect(agentPayload?.channel).toBe("qa-channel");

expect(agentPayload?.replyChannel).toBe("reply-channel");

expect(agentPayload?.replyTo).toBe("reply-target");

expect(gatewayArgs?.[2]).toEqual(expect.any(Object));

expect(gatewayArgs?.[2]).toBeTypeOf("object");

});

it("finds managed dreaming cron jobs across legacy and current payload contracts", () => {

const [method, params, options] = gatewayCall.mock.calls[0] ?? [];

expect(method).toBe("sessions.create");

expect(params).toEqual({ label: "Test Session" });

expect(options?.timeoutMs).toEqual(expect.any(Number));

expect(options?.timeoutMs).toBe(60_000);

});

it("reads effective tool ids once and drops blanks", async () => {

const [method, params, options] = gatewayCall.mock.calls[0] ?? [];

expect(method).toBe("skills.status");

expect(params).toEqual({ agentId: "qa" });

expect(options?.timeoutMs).toEqual(expect.any(Number));

expect(options?.timeoutMs).toBe(45_000);

});

it("reads the raw qa session store from disk", async () => {

import fs from "node:fs/promises";

import { createRequire } from "node:module";

import path from "node:path";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const requireFromHere = createRequire(import.meta.url);

const connectMock = vi.hoisted(() => vi.fn(async () => undefined));

const listToolsMock = vi.hoisted(() => vi.fn(async () => ({ tools: [] })));

const callToolMock = vi.hoisted(() => vi.fn(async () => ({ content: [] })));

command: "/usr/bin/node",

args: [

"--import",

expect.stringContaining(path.join("node_modules", "tsx")),

requireFromHere.resolve("tsx"),

path.join(repoRoot, "src", "mcp", "plugin-tools-serve.ts"),

],

stderr: "pipe",

expect(endStdin).toHaveBeenCalledTimes(1);

expect(wait).toHaveBeenCalledTimes(1);

expect(kill).toHaveBeenCalledTimes(1);

expect(registerWithToken).toHaveBeenCalledWith({

deviceName: "OpenClaw Matrix QA CLI Self Verification Owner",

localpart: expect.stringMatching(/^qa-cli-self-verification-[a-f0-9]{8}$/),

password: expect.stringMatching(/^matrix-qa-/),

registrationToken: "registration-token",

});

const registrationRequest = registerWithToken.mock.calls[0]?.[0];

expect(registrationRequest?.deviceName).toBe(

"OpenClaw Matrix QA CLI Self Verification Owner",

);

expect(registrationRequest?.localpart?.startsWith("qa-cli-self-verification-")).toBe(true);

expect(registrationRequest?.localpart).toHaveLength("qa-cli-self-verification-".length + 8);

expect(registrationRequest?.password?.startsWith("matrix-qa-")).toBe(true);

expect(registrationRequest?.registrationToken).toBe("registration-token");

expect(loginWithPassword).toHaveBeenCalledWith({

deviceName: "OpenClaw Matrix QA CLI Self Verification Device",

password: "cli-owner-password",