provider: "fixture-provider",

});

expect(order).toEqual([]);

expect(order).toStrictEqual([]);

});

it("keeps explicit empty stored auth order as a provider disable", async () => {

provider: "fixture-provider",

});

expect(order).toEqual([]);

expect(order).toStrictEqual([]);

});

it("marks aliased provider profiles good under the canonical auth provider", async () => {

const running = getSession(sessionId);

const finished = getFinishedSession(sessionId);

try {

expect(supervisorMockState.cancelReasons).toEqual([]);

expect(supervisorMockState.cancelReasons).toStrictEqual([]);

expect(finished).toBeUndefined();

expect(running?.exited).toBe(false);

} finally {

expect(resolved.hostWorkdir).toBe(workspaceDir);

expect(resolved.containerWorkdir).toBe("/workspace");

expect(warnings).toEqual([]);

expect(warnings).toStrictEqual([]);

});

});

expect(resolved.hostWorkdir).toBe(nested);

expect(resolved.containerWorkdir).toBe("/workspace/scripts/runner");

expect(warnings).toEqual([]);

expect(warnings).toStrictEqual([]);

});

});

expect(resolved.hostWorkdir).toBe(nested);

expect(resolved.containerWorkdir).toBe("/sandbox-root/project");

expect(warnings).toEqual([]);

expect(warnings).toStrictEqual([]);

});

});

});

expect(files.length).toBeGreaterThan(0);

const nonHeartbeatFiles = files.filter((file) => file.name !== "HEARTBEAT.md");

expect(nonHeartbeatFiles).toEqual([]);

expect(nonHeartbeatFiles).toStrictEqual([]);

});

it("keeps bootstrap context empty in lightweight cron mode", async () => {

runKind: "cron",

});

expect(files).toEqual([]);

expect(files).toStrictEqual([]);

});

it("drops HEARTBEAT.md for non-heartbeat runs when the heartbeat prompt section is disabled", async () => {

expect(pruned.droppedChunks).toBe(0);

expect(pruned.messages.length).toBe(messages.length);

expect(pruned.keptTokens).toBe(estimateMessagesTokens(messages));

expect(pruned.droppedMessagesList).toEqual([]);

expect(pruned.droppedMessagesList).toStrictEqual([]);

});

it("returns droppedMessagesList containing dropped messages", () => {

});

expect(pruned.droppedChunks).toBe(0);

expect(pruned.droppedMessagesList).toEqual([]);

expect(pruned.droppedMessagesList).toStrictEqual([]);

expect(pruned.messages.length).toBe(1);

});

"Agent-to-agent reply step",

),

);

expect(replyPromptAgentCalls).toEqual([]);

expect(replyPromptAgentCalls).toStrictEqual([]);

expect(calls.some((call) => call.method === "send")).toBe(false);

});

await expect(manager.sweepIdleRuntimes()).resolves.toBe(1);

expect(disposed).toEqual(["session-idle"]);

expect(manager.listSessionIds()).toEqual([]);

expect(manager.listSessionIds()).toStrictEqual([]);

expect(manager.resolveSessionId("agent:test:session-idle")).toBeUndefined();

});

now += 60_000_000;

await expect(manager.sweepIdleRuntimes()).resolves.toBe(0);

expect(manager.listSessionIds()).toEqual(["session-no-ttl"]);

expect(disposed).toEqual([]);

expect(disposed).toStrictEqual([]);

});

});

});

it("skips empty or whitespace-only content", () => {

const files = [makeFile({ content: " \n " })];

expect(buildBootstrapContextFiles(files)).toEqual([]);

expect(buildBootstrapContextFiles(files)).toStrictEqual([]);

});

it("truncates large bootstrap content", () => {

const head = `HEAD-${"a".repeat(600)}`;

maxChars: 200,

totalMaxChars: 40,

});

expect(result).toEqual([]);

expect(result).toStrictEqual([]);

});

it("keeps missing markers under small total budgets", () => {

expect(warnings).toHaveLength(3);

expect(

warnings.filter((warning) => !warning.includes('missing or invalid "path" field')),

).toEqual([]);

).toStrictEqual([]);

});

});

]);

});

it("handles empty array", () => {

expect(stripThoughtSignatures([])).toEqual([]);

expect(stripThoughtSignatures([])).toStrictEqual([]);

});

it("handles null/undefined blocks in array", () => {

const input = [null, undefined, { type: "text", text: "hello" }];

},

];

expect(downgradeOpenAIReasoningBlocks(input as any)).toEqual([]);

expect(downgradeOpenAIReasoningBlocks(input as any)).toStrictEqual([]);

});

it("keeps non-reasoning thinking signatures", () => {

allowedToolNames: ["read"],

});

expect(result).toEqual([]);

expect(result).toStrictEqual([]);

});

it("downgrades orphaned openai reasoning even when the model has not changed", async () => {

sessionManager,

});

expect(result).toEqual([]);

expect(result).toStrictEqual([]);

});

it("downgrades orphaned openai reasoning when the model changes too", async () => {