},

});

expect(result.profiles).toEqual([]);

expect(result.profiles).toStrictEqual([]);

expect(result.defaultModel).toBe("anthropic/claude-opus-4-7");

expect(result.configPatch).toEqual({

agents: {

if (!profile) {

throw new Error("Expected Anthropic policy profile");

}

expect(collectLegacyExtendedLevelIds(profile.levels)).toEqual([]);

expect(collectLegacyExtendedLevelIds(profile.levels)).toStrictEqual([]);

});

it("does not expose Anthropic thinking profiles for unrelated providers", () => {

});

expect(dryRun.dryRun).toBe(true);

expect(dryRun.createdCount).toBe(1);

await expect(fs.readdir(path.join(rootDir, "sources"))).resolves.toEqual([]);

await expect(fs.readdir(path.join(rootDir, "sources"))).resolves.toStrictEqual([]);

const applied = await runWikiChatGptImport({

config,

fs

.readdir(path.join(rootDir, "sources"))

.then((entries) => entries.filter((entry) => entry !== "index.md")),

).resolves.toEqual([]);

).resolves.toStrictEqual([]);

});

});

await compileMemoryWikiVault(config);

const second = await compileMemoryWikiVault(config);

expect(second.updatedFiles).toEqual([]);

expect(second.updatedFiles).toStrictEqual([]);

await expect(fs.readFile(path.join(rootDir, "entities", "beta.md"), "utf8")).resolves.toContain(

"[Gamma](concepts/gamma.md)",

);

});

it("stays empty when no wiki or memory-adjacent tools are registered", () => {

expect(buildWikiPromptSection({ availableTools: new Set(["web_search"]) })).toEqual([]);

expect(buildWikiPromptSection({ availableTools: new Set(["web_search"]) })).toStrictEqual([]);

});

it("can append a compact compiled digest snapshot when enabled", async () => {

}),

);

expect(builder({ availableTools: new Set(["web_search"]) })).toEqual([]);

expect(builder({ availableTools: new Set(["web_search"]) })).toStrictEqual([]);

});

it("stabilizes digest prompt ordering for prompt-cache-friendly output", async () => {

const regressionFailures = comparison.failures.filter((failure) =>

failure.includes("completion rate"),

);

expect(regressionFailures).toEqual([]);

expect(regressionFailures).toStrictEqual([]);

});

it("fails the parity gate when required parity scenarios are missing on both sides", () => {

expect(inventory.primaryCoverageIdCount).toBeGreaterThan(0);

expect(inventory.secondaryCoverageIdCount).toBeGreaterThan(0);

expect(inventory.overlappingCoverage.length).toBeGreaterThan(0);

expect(inventory.missingCoverage).toEqual([]);

expect(inventory.missingCoverage).toStrictEqual([]);

expect(inventory.byTheme.memory.map((feature) => feature.id)).toContain("memory.recall");

expect(inventory.bySurface.memory.map((feature) => feature.id)).toContain("memory.recall");

});

}),

).rejects.toThrow("node missing");

await expect(readdir(tempParent)).resolves.toEqual([]);

await expect(readdir(tempParent)).resolves.toStrictEqual([]);

});

it("keeps the slow-reply QA opt-out enabled under fast mode", () => {

});

expect(plan.outputDir).toBe(outputDir);

expect(plan.scenarioIds).toEqual([]);

expect(plan.scenarioIds).toStrictEqual([]);

expect(plan.qaCommand).not.toContain("--scenario");

expect(plan.guestOutputDir).toBe("/workspace/openclaw-host/.artifacts/qa-e2e/multipass-test");

expect(plan.reportPath).toBe(path.join(outputDir, "qa-suite-report.md"));

const tempEntries = fs

.readdirSync(resolvePreferredOpenClawTmpDir())

.filter((entry) => entry.startsWith(path.basename(expectedTransferDir)));

expect(tempEntries).toEqual([]);

expect(tempEntries).toStrictEqual([]);

fs.rmSync(outputDir, { recursive: true, force: true });

});

pack.scenarios

.filter((scenario) => scenario.execution?.kind !== "flow")

.map((scenario) => scenario.id),

).toEqual([]);

).toStrictEqual([]);

expect(

pack.scenarios.filter((scenario) => (scenario.execution.flow?.steps.length ?? 0) > 0),

).not.toEqual([]);

).not.toStrictEqual([]);

expect(

pack.scenarios

.filter((scenario) => !(scenario.coverage?.primary.length ?? 0))

.map((scenario) => scenario.id),

).toEqual([]);

).toStrictEqual([]);

expect(readQaScenarioById("memory-recall").coverage?.primary).toContain("memory.recall");

});

expect(scenarioIds).toContain("subagent-fanout-synthesis");

expect(

QA_AGENTIC_PARITY_SCENARIO_IDS.filter((scenarioId) => !scenarioIds.includes(scenarioId)),

).toEqual([]);

).toStrictEqual([]);

});

it("loads scenario-specific execution config from per-scenario markdown", () => {