// Subagent initial-user-message tests ensure the delegated task appears once in

// the first user turn instead of being duplicated into the system prompt.

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

import { buildSubagentInitialUserMessage } from "./subagent-initial-user-message.js";

import { buildSubagentSystemPrompt } from "./subagent-system-prompt.js";

// Subagent list tests cover active/recent formatting, usage summaries, and

// stale-run filtering for the user-visible subagent status command.

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

});

it("keeps ended orchestrators active while descendants remain pending", () => {

// Parent orchestrators can finish their own turn before child workers do;

// list output should keep them active until descendants settle.

const now = Date.now();

const orchestratorRun = {

runId: "run-orchestrator-ended",

channels: { whatsapp: { allowFrom: ["*"] } },

session: { store: storePath },

} as OpenClawConfig;

// Prompt/cache usage is separate from visible IO so operators can spot

// cache-heavy sessions without misreading it as assistant output.

const list = buildSubagentList({

cfg,

runs: [run],

// Subagent orphan-recovery tests cover restart recovery for child sessions whose

// embedded run was interrupted while the registry still considers them active.

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

import * as sessions from "../config/sessions.js";

import * as gateway from "../gateway/call.js";

import * as subagentRegistrySteerRuntime from "./subagent-registry-steer-runtime.js";

import type { SubagentRunRecord } from "./subagent-registry.types.js";

// Mock dependencies before importing the module under test

// Mocks are installed before importing the recovery module so registry/runtime

// helpers resolve to deterministic restart fixtures.

vi.mock("../config/config.js", () => ({

getRuntimeConfig: vi.fn(() => ({

session: { store: undefined },

expect(result.failed).toBe(0);

expect(result.skipped).toBe(0);

// Should have called callGateway to resume the session

// Recovery resumes through the gateway and records the new run id so the

// registry follows the resumed transcript instead of the idempotency key.

expect(gateway.callGateway).toHaveBeenCalledOnce();

const opts = requireRecord(

firstCallParam(vi.mocked(gateway.callGateway).mock.calls, "gateway resume"),

// Subagent registry cleanup tests cover deferred cleanup decisions while

// completion delivery, descendants, and retry windows are still unresolved.

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

import { resolveDeferredCleanupDecision } from "./subagent-registry-cleanup.js";

import type { SubagentRunRecord } from "./subagent-registry.types.js";

Pick<Parameters<typeof resolveDeferredCleanupDecision>[0], "resolveAnnounceRetryDelayMs">

>,

) {

// Fixed timing keeps expiry and backoff decisions independent from wall

// clock drift while still exercising production thresholds.

return resolveDeferredCleanupDecision({

now,

announceExpiryMs: 5 * 60_000,

// Subagent registry helper tests cover orphan reconciliation and compact logging

// for announce delivery give-up paths.

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

import { defaultRuntime } from "../runtime.js";

import { logAnnounceGiveUp, reconcileOrphanedRun } from "./subagent-registry-helpers.js";

});

it("normalizes multiline delivery errors onto one gateway log line", () => {

// Gateway logs are line-oriented; multiline provider errors must be

// collapsed before they enter warning text.

const logSpy = vi.spyOn(defaultRuntime, "log").mockImplementation(() => {});

const entry = createRunEntry({

delivery: {