healthOk: false,

});

expect(readGatewayRestartHandoffSync).toHaveBeenCalledWith(

expect.objectContaining({

OPENCLAW_STATE_DIR: "/tmp/openclaw-service",

OPENCLAW_CONFIG_PATH: "/tmp/openclaw-service/openclaw.json",

}),

);

expect(readGatewayRestartHandoffSync).toHaveBeenCalledOnce();

const [handoffEnv] = readGatewayRestartHandoffSync.mock.calls[0] as unknown as [

{ OPENCLAW_STATE_DIR?: string; OPENCLAW_CONFIG_PATH?: string },

];

expect(handoffEnv?.OPENCLAW_STATE_DIR).toBe("/tmp/openclaw-service");

expect(handoffEnv?.OPENCLAW_CONFIG_PATH).toBe("/tmp/openclaw-service/openclaw.json");

expect(note).toHaveBeenCalledWith(

expect.stringContaining("Recent restart handoff: full-process via systemd"),

"Gateway",

import { noteSessionLockHealth } from "./doctor-session-locks.js";

async function expectPathMissing(targetPath: string): Promise<void> {

await expect(fs.access(targetPath)).rejects.toMatchObject({ code: "ENOENT" });

try {

await fs.access(targetPath);

throw new Error(`expected missing path: ${targetPath}`);

} catch (error) {

expect((error as NodeJS.ErrnoException).code).toBe("ENOENT");

}

}

describe("noteSessionLockHealth", () => {

const result = await repairBrokenSessionTranscriptFile({ filePath, shouldRepair: true });

expect(result).toMatchObject({

broken: true,

repaired: true,

originalEntries: 6,

activeEntries: 3,

});

expect(result.broken).toBe(true);

expect(result.repaired).toBe(true);

expect(result.originalEntries).toBe(6);

expect(result.activeEntries).toBe(3);

if (result.backupPath === undefined) {

throw new Error("expected transcript backup path");

}

expect(warnings).toEqual(["extra:channels.signal"]);

expect(extraWarningsForAccount).toHaveBeenCalledTimes(1);

expect(extraWarningsForAccount).toHaveBeenCalledWith(

expect.objectContaining({ prefix: "channels.signal" }),

);

const [warningOptions] = extraWarningsForAccount.mock.calls[0] ?? [];

expect(warningOptions?.prefix).toBe("channels.signal");

});

});

warning.includes("Telegram allowFrom contains 1") && warning.includes("(e.g. @alice)"),

),

).toBe(true);

expect(warnings).toEqual(

expect.arrayContaining([expect.stringContaining('channels.signal.allowFrom: set to ["*"]')]),

);

expect(

warnings.some((warning) => warning.includes('channels.signal.allowFrom: set to ["*"]')),

).toBe(true);

});

it("sanitizes empty-allowlist warning paths before returning preview output", async () => {