repairBrokenSessionTranscriptFile,

} from "./doctor-session-transcripts.js";

function countNonEmptyLines(value: string): number {

let count = 0;

for (const line of value.split(/\r?\n/)) {

if (line) {

count += 1;

}

}

return count;

}

describe("doctor session transcript repair", () => {

let root: string;

expect(title).toBe("Session transcripts");

expect(message).toContain("duplicated prompt-rewrite branches");

expect(message).toContain('Run "openclaw doctor --fix"');

expect((await fs.readFile(filePath, "utf-8")).split(/\r?\n/).filter(Boolean)).toHaveLength(3);

expect(countNonEmptyLines(await fs.readFile(filePath, "utf-8"))).toBe(3);

});

it("ignores ordinary branch history without internal runtime context", async () => {

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

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

expect((await fs.readFile(filePath, "utf-8")).split(/\r?\n/).filter(Boolean)).toHaveLength(3);

expect(countNonEmptyLines(await fs.readFile(filePath, "utf-8"))).toBe(3);

});

});

getStatusSummary: vi.fn().mockResolvedValue({ ok: true }),

}));

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;

}

describe("waitForAgentJob", () => {

async function runLifecycleScenario(params: {

runIdPrefix: string;

expect(firstResolveRespond).toHaveBeenCalledWith(true, { ok: true }, undefined);

expect(repeatResolveRespond).toHaveBeenCalledWith(true, { ok: true }, undefined);

expect(broadcasts.filter((entry) => entry.event === "exec.approval.resolved")).toHaveLength(

expect(countMatching(broadcasts, (entry) => entry.event === "exec.approval.resolved")).toBe(

resolvedBroadcastCount,

);

expect(conflictingResolveRespond).toHaveBeenCalledWith(

},

});

expect(registry.services.filter((entry) => entry.service.id === "shared-service")).toHaveLength(

expect(countMatching(registry.services, (entry) => entry.service.id === "shared-service")).toBe(

1,

);

expectNoDiagnosticContaining({

const OPENAI_API_KEY_MARKER = "OPENAI_API_KEY"; // pragma: allowlist secret

const MAX_AUDIT_MODELS_JSON_BYTES = 5 * 1024 * 1024;

function countNonEmptyLines(value: string): number {

let count = 0;

for (const line of value.split("\n")) {

if (line.trim().length > 0) {

count += 1;

}

}

return count;

}

async function writeJsonFile(filePath: string, value: unknown): Promise<void> {

await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");

}

expect(report.summary.unresolvedRefCount).toBe(0);

const callLog = await fs.readFile(execLogPath, "utf8");

const callCount = callLog.split("\n").filter((line) => line.trim().length > 0).length;

const callCount = countNonEmptyLines(callLog);

expect(callCount).toBe(1);

});

expect(report.summary.unresolvedRefCount).toBeGreaterThanOrEqual(2);

const callLog = await fs.readFile(execLogPath, "utf8");

const callCount = callLog.split("\n").filter((line) => line.trim().length > 0).length;

const callCount = countNonEmptyLines(callLog);

expect(callCount).toBe(1);

});

const OS_TS_PATHS = [TS_PATHS.linux, TS_PATHS.macos, TS_PATHS.windows];

function countNonEmptyLines(value: string): number {

let count = 0;

for (const line of value.split("\n")) {

if (line) {

count += 1;

}

}

return count;

}

function runTsEval(source: string, env: Record<string, string> = {}) {

return execFileSync("node", ["--import", "tsx", "--input-type=module", "--eval", source], {

encoding: "utf8",

} else {

expect(wrapper, wrapperPath).toContain(TS_PATHS[platform as "linux" | "macos" | "windows"]);

}

expect(wrapper.split("\n").filter(Boolean).length).toBeLessThanOrEqual(5);

expect(countNonEmptyLines(wrapper)).toBeLessThanOrEqual(5);

}

});

return config.test as NonNullable<T["test"]>;

}

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;

}

describe("unit-fast vitest lane", () => {

it("runs cache-friendly tests without the reset-heavy runner or runtime setup", () => {

const config = createUnitFastVitestConfig({});

expect(currentCandidates.length).toBeGreaterThanOrEqual(unitFastTestFiles.length);

expect(broadCandidates.length).toBeGreaterThan(currentCandidates.length);

expect(broadAnalysis.filter((entry) => entry.unitFast).length).toBeGreaterThan(

expect(countMatching(broadAnalysis, (entry) => entry.unitFast)).toBeGreaterThan(

unitFastTestFiles.length,

);

});