// Compatibility coverage for embedded runner barrel exports and runtime ids.

import { describe, expect, it } from "vitest";

import { normalizeEmbeddedAgentRuntime } from "../agent-runtime-id.js";

import * as embeddedAgentRunner from "../embedded-agent-runner.js";

import * as embeddedAgent from "../embedded-agent.js";

describe("embedded runner compatibility aliases", () => {

it("keeps the embedded-agent barrel bound to the runner implementation", () => {

// Shipped imports still reach the runner through the embedded-agent barrel;

// keep these aliases exact so consumers do not fork stateful implementations.

expect(embeddedAgent.runEmbeddedAgent).toBe(embeddedAgentRunner.runEmbeddedAgent);

expect(embeddedAgent.compactEmbeddedAgentSession).toBe(

embeddedAgentRunner.compactEmbeddedAgentSession,

});

it("normalizes shipped runtime aliases", () => {

// These aliases appear in persisted/runtime-facing config and must resolve

// before model/provider dispatch observes the runtime id.

expect(normalizeEmbeddedAgentRuntime("pi")).toBe("openclaw");

expect(normalizeEmbeddedAgentRuntime("codex-app-server")).toBe("codex");

});

// Cache-TTL eligibility coverage for native and provider-routed model families.

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

vi.mock("../../plugins/provider-runtime.js", async () => {

resolveProviderCacheTtlEligibility: (params: {

context: { provider: string; modelId: string; modelApi?: string };

}) => {

// Provider runtime owns model-family-specific eligibility; tests mirror

// plugin decisions without loading actual provider plugins.

if (params.context.provider === "anthropic") {

return true;

}

describe("readLastCacheTtlTimestamp", () => {

it("returns the latest matching timestamp for the active provider/model", () => {

// Replay only reuses cache TTL entries scoped to the current model target;

// stale entries for other providers must not reset pruning clocks.

const sessionManager = {

getEntries: () => [

{

// Classification coverage for compaction failure and skip reason telemetry.

import { describe, expect, it } from "vitest";

import {

classifyCompactionReason,

describe("resolveCompactionFailureReason", () => {

it("replaces generic compaction cancellation with the safeguard reason", () => {

// Safeguard cancellation is the actionable root cause; preserving only the

// generic cancellation text would hide the provider/auth failure.

expect(

resolveCompactionFailureReason({

reason: "Compaction cancelled",

});

it("strips terminal escapes and log separators from unknown reasons", () => {

// Unknown reason detail is embedded in metric tags, so strip control

// characters and separators before exporting it.

expect(

formatUnknownCompactionReasonDetail("\u001b[31mNo API\u001b[0m provider = ollama\nnext"),

).toBe("No_API_provider_ollama_next");

// Hook integration coverage for direct and queued embedded compaction.

import type { AgentMessage } from "openclaw/plugin-sdk/agent-core";

import { beforeAll, beforeEach, describe, expect, it, vi, type Mock } from "vitest";

import {

};

function createDeferred<T>(): Deferred<T> {

// Tests use manual deferreds to prove queued compaction waits at the exact

// lifecycle boundary instead of racing transcript updates.

let resolve: ((value: T) => void) | undefined;

const promise = new Promise<T>((promiseResolve) => {

resolve = promiseResolve;

})?.[0] as SessionHookEvent | undefined;

async function runCompactionHooks(params: { sessionKey?: string; messageProvider?: string }) {

// Build metrics through the production helper so hook payload assertions stay

// aligned with compaction token accounting.

const originalMessages = sessionMessages.slice(1) as AgentMessage[];

const currentMessages = sessionMessages.slice(1) as AgentMessage[];

const beforeMetrics = compactTesting.buildBeforeCompactionHookMetrics({

// Regression coverage for pruning duplicate user turns before compaction.

import { describe, expect, it } from "vitest";

import {

collectDuplicateUserMessageEntryIdsForCompaction,

describe("compaction duplicate user message pruning", () => {

it("drops identical long user messages inside the duplicate window", () => {

// Whitespace-normalized duplicates inside the short window are transport

// artifacts; keeping both wastes compaction budget and distorts summaries.

const first = {

role: "user",

content: "please run the deployment status check for production",

});

it("keeps short repeated acknowledgements and distant repeats", () => {

// Short repeats and distant repeats are plausible user intent, so only

// high-confidence duplicated long prompts are removed.

const short = { role: "user", content: "next", timestamp: 1_000 } as const;

const shortAgain = { role: "user", content: "next", timestamp: 2_000 } as const;

const long = {

// Coverage for building compaction runtime context from active runner state.

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

import type { OpenClawConfig } from "../../config/config.js";

import { addSession, resetProcessRegistryForTests } from "../bash-process-registry.js";

});

expect(result.provider).toBe("anthropic");

expect(result.model).toBe("claude-opus-4-6");

// Auth profile dropped because provider changed

// Auth profile must be dropped when provider changes; otherwise compaction

// could send a stale credential to the override provider.

expect(result.authProfileId).toBeUndefined();

});

});

it("preserves scoped active process session references for compaction", () => {

// Only sessions tied to the same scope are summarized; cross-session process

// state would leak unrelated task context into the compaction prompt.

vi.useFakeTimers();

vi.setSystemTime(new Date("2026-01-02T03:04:05.000Z"));

const active = createProcessSessionFixture({

// Persistence coverage for transcript rotation after successful compaction.

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

firstKeptId: string;

oldUserId: string;

} {

// Fixture includes pre-compaction history, preserved branch metadata, and

// post-compaction turns so rotation can prove exactly which entries survive.

const manager = SessionManager.create(sessionDir, sessionDir);

manager.appendModelChange("openai", "gpt-5.2");

manager.appendThinkingLevelChange("medium");

const dir = await createTmpDir();

const { sessionFile } = createCompactedSession(dir);

// File-only rotation is used after the active manager has moved on; opening

// a new manager here would hide bugs in the direct persistence path.

const openSpy = vi.spyOn(SessionManager, "open").mockImplementation(() => {

throw new Error("SessionManager.open should not be used for file rotation");

});

// Coverage for deferred context-engine maintenance and transcript rewrite hooks.

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

import type { ContextEngineRuntimeContext } from "../../context-engine/types.js";

import { peekSystemEvents, resetSystemEventsForTest } from "../../infra/system-events.js";

let resetDeferredTurnMaintenanceStateForTest: typeof import("./context-engine-maintenance.js").resetDeferredTurnMaintenanceStateForTest;

function createQueuedTaskRun(params: Parameters<typeof createQueuedTaskRunOrNull>[0]): TaskRecord {

// Task creation can legally return null for invalid inputs; tests here always

// need a concrete queued task record.

const task = createQueuedTaskRunOrNull(params);

if (!task) {

throw new Error("expected queued task creation to succeed");

timeoutMs = 2_000,

stepMs = 5,

): Promise<void> {

// Timed polling lets fake-timer tasks advance through queue and delivery

// microtasks without binding assertions to a specific internal await count.

const startedAt = Date.now();

for (;;) {

try {

}));

async function loadFreshContextEngineMaintenanceModuleForTest() {

// The module owns singleton deferred-maintenance state, so reload between

// cases before asserting abort or queue behavior.

({

buildContextEngineMaintenanceRuntimeContext,

createDeferredTurnMaintenanceAbortSignal,

// Coverage for final bundled-tool policy filtering in embedded runs.

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { applyFinalEffectiveToolPolicy } from "./effective-tool-policy.js";

function makeTool(name: string): AnyAgentTool {

// Minimal tool shape keeps policy tests independent from executor/runtime

// implementations while still exercising plugin metadata.

return {

name,

label: name,

});

it("filters bundled tools through inherited subagent allowlists", () => {

// Inherited allowlists are persisted by session key; use a real temp store

// so parsing and lookup match production policy application.

const agentId = `bundled-inherited-allow-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const sessionKey = `agent:${agentId}:subagent:limited`;

const storePath = path.join(os.tmpdir(), `openclaw-bundled-inherited-allow-${agentId}.json`);

});

it("applies channel-normalized per-sender policy to bundled tools", () => {

// Teams normalizes to msteams in policy keys, which must happen before

// sender-specific deny rules are applied.

const filtered = applyFinalEffectiveToolPolicy({

bundledTools: [makeTool("mcp__bundle__exec"), makeTool("mcp__bundle__read")],

config: {

// Coverage for embedded extension factory selection and runtime wiring.

import type { SessionManager } from "openclaw/plugin-sdk/agent-sessions";

import type { Model } from "openclaw/plugin-sdk/llm";

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

import { buildEmbeddedExtensionFactories } from "./extensions.js";

vi.mock("../../plugins/provider-runtime.js", () => ({

// Plugin-owned cache-TTL decisions are mocked out here; extension selection

// tests assert the core default wiring only.

resolveProviderCacheTtlEligibility: () => undefined,

resolveProviderRuntimePlugin: () => undefined,

}));

}));

function buildSafeguardFactories(cfg: OpenClawConfig, workspaceDir?: string) {

// The safeguard runtime attaches to the session manager, so tests keep the

// same manager instance around for both factory construction and inspection.

const sessionManager = {} as SessionManager;

const model = {

id: "claude-sonnet-4-20250514",