const entries = Object.values(store.entries ?? {});

expect(entries).toHaveLength(1);

const entry = entries[0];

expect(entry).toBeDefined();

if (!entry) {

throw new Error("Expected short-term recall entry");

}

const sequentializer = sequentializeSpy.mock.results[0]?.value as

| TelegramMiddleware

| undefined;

expect(sequentializer).toBeDefined();

if (!sequentializer) {

return;

throw new Error("Expected sequentialize middleware");

}

const topicCtx = (threadId: number, updateId: number) => {

await waitForRealtimeTest(() => {

const events = processEvent.mock.calls.map(([event]) => event as NormalizedEvent);

const ended = events.find((event) => event.type === "call.ended");

expect(ended).toBeDefined();

if (ended?.type !== "call.ended") {

throw new Error("expected realtime stop to emit call.ended");

}

const workingCall = submitToolResult.mock.calls.find(

([callId]) => callId === "consult-call",

);

expect(workingCall).toBeDefined();

const payload = workingCall?.[1] as Record<string, unknown> | undefined;

if (!workingCall) {

throw new Error("expected consult-call tool result");

}

const payload = workingCall[1] as Record<string, unknown> | undefined;

expect(payload?.status).toBe("working");

expect(payload?.tool).toBe("openclaw_agent_consult");

expect(typeof payload?.message).toBe("string");

expect(workingCall?.[2]).toEqual({ willContinue: true });

expect(workingCall[2]).toEqual({ willContinue: true });

});

expect(submitToolResult).toHaveBeenCalledTimes(1);

expected: { text: string; mediaUrls?: string[] },

): void {

const payload = findBlockReplyPayload(onBlockReply, expected.text);

expect(payload).toBeDefined();

if (!payload) {

throw new Error(`Expected block reply text: ${expected.text}`);

}

item.livenessState === expected.livenessState &&

item.replayInvalid === expected.replayInvalid,

);

expect(payload).toBeDefined();

if (!payload) {

throw new Error(`Expected lifecycle payload for phase ${expected.phase}`);

}

}

it("captures usage from completions timings on done events", () => {

// Look for lifecycle:error event

const lifecycleError = findLifecycleErrorAgentEvent(onAgentEvent.mock.calls);

expect(lifecycleError).toBeDefined();

const error = (lifecycleError?.data as { error?: unknown } | undefined)?.error;

if (!lifecycleError) {

throw new Error("Expected lifecycle error event");

}

const error = (lifecycleError.data as { error?: unknown } | undefined)?.error;

expect(typeof error).toBe("string");

expect(error).toContain("API rate limit reached");

});

const stateAsset = result.assets.find((asset) => asset.kind === "state");

const workspaceAsset = result.assets.find((asset) => asset.kind === "workspace");

expect(stateAsset).toBeDefined();

expect(workspaceAsset).toBeDefined();

if (!stateAsset || !workspaceAsset) {

throw new Error("Expected backup assets to include state and workspace entries.");

}

) => {

const manifestPath = entryPaths[0];

const stateRoot = entryPaths[1];

expect(manifestPath).toBeDefined();

expect(stateRoot).toBeDefined();

if (!manifestPath || !stateRoot) {

throw new Error("backup test expected manifest and state entries");

}

function requireItem(items: MigrationItem[], id: string): MigrationItem {

const item = items.find((candidate) => candidate.id === id);

expect(item).toBeDefined();

if (!item) {

throw new Error(`missing migration item ${id}`);

}

const entry = requireArray(providers, "auth providers").find(

(candidate) => requireRecord(candidate, "auth provider").provider === provider,

);

expect(entry).toBeDefined();

if (!entry) {

throw new Error(`missing provider ${provider}`);

}

const entry = requireArray(profiles, "auth profiles").find(

(candidate) => requireRecord(candidate, "auth profile").profileId === profileId,

);

expect(entry).toBeDefined();

if (!entry) {

throw new Error(`missing profile ${profileId}`);

}