// Subagent announce format e2e tests exercise the full announce flow with

// channel fixtures, session stores, hooks, and gateway calls wired together.

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

import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";

import {

params: Record<string, unknown> | undefined,

sourceSessionKey: string,

) {

// Announce handoffs are inter-session messages; provenance lets the receiver

// distinguish child-output delivery from ordinary user input.

const inputProvenance = params?.inputProvenance;

if (!inputProvenance || typeof inputProvenance !== "object") {

throw new Error("Expected input provenance");

};

const announceFormatChannelPlugins = [

// Channel fixtures intentionally mix plain channels with Slack-style thread

// target resolution so formatting covers direct and threaded destinations.

{

pluginId: "discord",

plugin: createChannelTestPluginBase({ id: "discord", label: "Discord" }),

// Subagent announce flow tests cover the seam-level orchestration between wait

// outcomes, requester lookup, delivery, and cleanup.

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

import type { EmbeddedAgentQueueMessageOutcome } from "./embedded-agent-runner/runs.js";

import { createSubagentAnnounceDeliveryRuntimeMock } from "./subagent-announce.test-support.js";

requesterSessionOrigin?: { provider?: string; channel?: string };

bestEffortDeliver?: boolean;

}) => {

// The delivery mock preserves the key branch: active Discord requester

// sessions are steered in-process, while inactive/direct paths call agent.

const store = loadSessionStoreMock("/tmp/sessions.json") as Record<string, unknown>;

const requesterEntry = (store?.[params.targetRequesterSessionKey] ?? {}) as

| { sessionId?: string; origin?: { provider?: string; channel?: string } }

// Subagent announce timeout tests cover retry timing and fallback requester

// resolution when completion delivery cannot finish immediately.

import { clampTimerTimeoutMs } from "@openclaw/normalization-core/number-coercion";

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

import { createSubagentAnnounceDeliveryRuntimeMock } from "./subagent-announce.test-support.js";

directIdempotencyKey?: string;

internalEvents?: unknown;

}) => {

// Retry behavior is modeled here because the outer announce flow only sees

// whether direct delivery eventually succeeded or failed.

const buildRequest = () => ({

method: "agent",

expectFinal: true,

// Subagent control tests cover sending, steering, killing, and admin cleanup of

// child runs recorded in the subagent registry and session store.

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

limit?: number;

callGateway?: (request: CallGatewayOptions) => Promise<{ messages?: unknown[] }>;

}) => {

// The real helper snapshots assistant fingerprints so a steer command only

// reports new replies, not the baseline text that existed before steering.

const history = await params.callGateway?.({

method: "chat.history",

params: { sessionKey: params.sessionKey, limit: params.limit ?? 50 },

function setSubagentControlDepsForTest(

overrides: Parameters<typeof testing.setDepsForTest>[0] = {},

) {

// Tests use real JSON store mutation to catch persisted cleanup/kill state,

// while swapping process-owned queues and embedded-run aborts for fakes.

testing.setDepsForTest({

abortEmbeddedAgentRun: () => false,

clearSessionQueues: () => ({ followupCleared: 0, laneCleared: 0, keys: [] }),

// Subagent delivery-state tests cover migration of legacy run fields into the

// nested completion/delivery shape used by current registry records.

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

import { normalizeSubagentRunState } from "./subagent-delivery-state.js";

import type { LegacySubagentRunRecord } from "./subagent-delivery-state.js";

describe("normalizeSubagentRunState", () => {

it("migrates legacy pending delivery fields into nested completion and delivery state", () => {

// Restored runs may still carry flat pendingFinalDelivery fields from older

// builds; normalization must preserve retry payloads before stripping them.

const entry = normalizeSubagentRunState(

baseRun({

frozenResultText: "child output",

// Subagent depth tests cover depth recovery from persisted session metadata and

// timer-safe timeout normalization for spawned agent runs.

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

});

it("derives depth from spawnedBy ancestry when spawnDepth is missing", () => {

// Ancestry fallback keeps restored sessions useful when old stores predate

// the explicit spawnDepth field.

const key1 = "agent:main:subagent:one";

const key2 = "agent:main:subagent:two";

const key3 = "agent:main:subagent:three";