@antelopejs/dms-ai 0.7.0 → 0.9.0

package/frontend-vue/app/chat/components/ChatView.vue

@@ -8,8 +8,11 @@ import {
 	watch,
 } from "vue";
 import type { ChatTransport } from "../../runtime/chat-transport";
-import type { ConversationStartMode } from "../../runtime/assistant-session";
-import type { PanelIntent, PanelIntents } from "../../runtime/panel-intents";
+import type {
+	PanelIntent,
+	PanelIntents,
+	StartConversationIntent,
+} from "../../runtime/panel-intents";
 import {
 	useChangeSetActions,
 	type ChatApi,
@@ -41,9 +44,10 @@ import type { ConversationSummary, CurrentPage } from "../types/conversation";
 import type { ExpiredRequest } from "../types/permission";
 import type { QuestionReply } from "../types/question";
 import type { PendingAttachment } from "../utils/attachments";
-import { formatClock, formatTokens } from "../utils/format";
+import { formatTokens } from "../utils/format";
 import { newUuid } from "../utils/ids";
 import { isRunStalled, runElapsedMs } from "../utils/run-status";
+import { describeStatus } from "../utils/status-label";
 import { bareToolName } from "../utils/tool-lexicon";
 import { latestTodos } from "../utils/todos";
 import ApprovalDock from "./ApprovalDock.vue";
@@ -176,27 +180,18 @@ const status = computed<PanelStatusKind>(() => {
 	return isRunning.value ? "working" : "ready";
 });
 
-const statusLabel = computed<string>(() => {
-	const labels: Record<PanelStatusKind, () => string> = {
-		ready: () => t("dms_ai.panel.status.ready"),
-		working: () =>
-			t("dms_ai.panel.status.working", {
-				time: formatClock(
-					runElapsedMs(conversation.progress.value, nowMs.value),
-				),
-			}),
-		waiting: () =>
-			t(
-				"dms_ai.panel.status.waiting",
-				{ count: pendingCount.value },
-				pendingCount.value,
-			),
-		connecting: () => t("dms_ai.panel.status.connecting"),
-		offline: () => t("dms_ai.panel.status.offline"),
-	};
-	const label = labels[status.value]();
-	return status.value === "offline" ? label : `${label} · ${agentName.value}`;
-});
+const statusLabel = computed<string>(() =>
+	describeStatus(
+		{
+			kind: status.value,
+			elapsedMs: runElapsedMs(conversation.progress.value, nowMs.value),
+			pendingCount: pendingCount.value,
+			agentName: agentName.value,
+			model: conversation.model.value,
+		},
+		t,
+	),
+);
 
 const usageLabel = computed<string>(() => {
 	if (!isConnected.value) return t("dms_ai.panel.composer.usage_offline");
@@ -325,16 +320,13 @@ function setDraft(text: string): void {
 	composerRef.value?.setDraft(text);
 }
 
-/** Sets the new conversation's mode as soon as the stream can carry it, unless the chat moved on. */
-function setModeWhenConnected(next: ConversationStartMode): void {
+/** Runs `run` once the stream is up, if still here. */
+function whenConnected(run: () => void): void {
 	const conversationId = activeId.value;
 	const apply = (): void => {
-		if (activeId.value === conversationId) mode.setMode(next);
+		if (activeId.value === conversationId) run();
 	};
-	if (isConnected.value) {
-		apply();
-		return;
-	}
+	if (isConnected.value) return apply();
 	const stop = watch(isConnected, (connected) => {
 		if (!connected) return;
 		stop();
@@ -342,6 +334,20 @@ function setModeWhenConnected(next: ConversationStartMode): void {
 	});
 }
 
+function startConversation(intent: StartConversationIntent): void {
+	newConversation();
+	const { prompt = "", mode: next } = intent;
+	const sends = intent.send === true && prompt !== "";
+	if (next !== undefined || sends)
+		whenConnected(() => {
+			if (next !== undefined) mode.setMode(next);
+			if (sends) conversation.sendUserMessage(prompt);
+		});
+	if (sends) return;
+	if (prompt) void nextTick(() => setDraft(prompt));
+	else void nextTick(() => composerRef.value?.focus());
+}
+
 const INTENT_HANDLERS: Record<
 	PanelIntent["kind"],
 	(intent: PanelIntent) => void
@@ -350,12 +356,7 @@ const INTENT_HANDLERS: Record<
 		if (intent.kind === "open") switchConversation(intent.conversationId);
 	},
 	start: (intent) => {
-		newConversation();
-		if (intent.kind === "start" && intent.mode)
-			setModeWhenConnected(intent.mode);
-		if (intent.kind === "start" && intent.prompt)
-			void nextTick(() => setDraft(intent.prompt ?? ""));
-		else void nextTick(() => composerRef.value?.focus());
+		if (intent.kind === "start") startConversation(intent);
 	},
 	focus: () => void nextTick(() => composerRef.value?.focus()),
 	approvals: () => {

package/frontend-vue/app/chat/components/NoticeCard.vue

@@ -30,6 +30,7 @@ const LOOKS: Record<Notice["kind"], NoticeLook> = {
 	permission_expired: { tone: "neutral", icon: "i-ph-timer" },
 	question_skipped: { tone: "neutral", icon: "i-ph-arrow-bend-down-right" },
 	full_auto_ended: { tone: "neutral", icon: "i-ph-lightning-slash" },
+	model_fallback: { tone: "warning", icon: "i-ph-swap" },
 };
 
 const showErrors = ref(false);
@@ -116,6 +117,21 @@ const expiredTool = computed<string>(() => {
 					t("dms_ai.panel.notice.question_skipped", { header: notice.header })
 				}}
 			</template>
+			<template v-else-if="notice.kind === 'model_fallback'">
+				<b>
+					{{
+						t("dms_ai.panel.notice.model_fallback_title", {
+							model: notice.usedModel,
+						})
+					}}
+				</b>
+				{{
+					t("dms_ai.panel.notice.model_fallback_text", {
+						requested: notice.requestedModel,
+						model: notice.usedModel,
+					})
+				}}
+			</template>
 			<template v-else>
 				{{ t("dms_ai.panel.notice.full_auto_ended", { time }) }}
 			</template>

package/frontend-vue/app/chat/components/PanelHeader.vue

@@ -4,13 +4,9 @@ import { useChatI18n } from "../composables/useChatI18n";
 import type { ActiveRule } from "../types/protocol";
 import { ruleIcon } from "../utils/permission-view";
 import { shortcutLabel } from "../utils/platform";
+import type { StatusKind } from "../utils/status-label";
 
-export type PanelStatusKind =
-	| "ready"
-	| "working"
-	| "waiting"
-	| "connecting"
-	| "offline";
+export type PanelStatusKind = StatusKind;
 
 interface Props {
 	title: string;

package/frontend-vue/app/chat/composables/conversation-events.ts

@@ -73,6 +73,7 @@ interface SnapshotEvent {
 	changeSets?: ChangeSetSummary[];
 	mode?: SnapshotModeWire;
 	totalTokens?: number;
+	model?: string;
 }
 
 interface QueueStateEvent {
@@ -99,6 +100,7 @@ interface BlockPreviewEvent {
 
 interface UsageEvent {
 	totalTokens?: number;
+	model?: string;
 }
 
 type EventHandler = (state: ConversationState, event: never) => void;
@@ -290,6 +292,7 @@ function applySnapshot(state: ConversationState, event: SnapshotEvent): void {
 	state.changeSets.value = byId(event.changeSets ?? []);
 	state.mode.value = toModeState(event.mode) ?? state.mode.value;
 	state.totalTokens.value = event.totalTokens ?? state.totalTokens.value;
+	state.model.value = event.model ?? null;
 	state.isRunning.value = false;
 	state.progress.value = null;
 	state.isTurnInFlight.value = false;
@@ -379,6 +382,7 @@ function appendBlockPreview(
 }
 
 function applyUsage(state: ConversationState, event: UsageEvent): void {
+	if (event.model !== undefined) state.model.value = event.model;
 	if (typeof event.totalTokens !== "number") return;
 	state.totalTokens.value = event.totalTokens;
 }

package/frontend-vue/app/chat/composables/useConversation.ts

@@ -49,6 +49,8 @@ export interface UseConversationResult {
 	mode: Ref<ConversationModeState | null>;
 	/** Tokens this chat has used so far; null until the sidecar says. */
 	totalTokens: Ref<number | null>;
+	/** The model that answered last; null until a reply names it. */
+	model: Ref<string | null>;
 	sendUserMessage: (
 		content: string,
 		attachments?: PendingAttachment[],
@@ -76,6 +78,7 @@ export interface ConversationState {
 	changeSets: Ref<Record<string, ChangeSetSummary>>;
 	mode: Ref<ConversationModeState | null>;
 	totalTokens: Ref<number | null>;
+	model: Ref<string | null>;
 	/**
 	 * When the calls of the stored transcript started and ended. A re-attach
 	 * replays the running turn's events, and the replayed calls take their
@@ -285,6 +288,7 @@ function reset(state: ConversationState): void {
 	state.changeSets.value = {};
 	state.mode.value = null;
 	state.totalTokens.value = null;
+	state.model.value = null;
 	state.callTimes.clear();
 }
 
@@ -302,6 +306,7 @@ function createConversationState(
 		changeSets: ref<Record<string, ChangeSetSummary>>({}),
 		mode: ref<ConversationModeState | null>(null),
 		totalTokens: ref<number | null>(null),
+		model: ref<string | null>(null),
 		callTimes: new Map(),
 	};
 }
@@ -326,6 +331,7 @@ export function useConversation(
 		changeSets: state.changeSets,
 		mode: state.mode,
 		totalTokens: state.totalTokens,
+		model: state.model,
 		sendUserMessage: (content, attachments = [], extra = {}) =>
 			sendUserMessage(state, content, attachments, extra),
 		retry: () => retry(state),

package/frontend-vue/app/chat/types/protocol.ts

@@ -165,11 +165,19 @@ export interface FullAutoEndedNotice {
 	timestampMs: number;
 }
 
+export interface ModelFallbackNotice {
+	kind: "model_fallback";
+	requestedModel: string;
+	usedModel: string;
+	timestampMs: number;
+}
+
 export type Notice =
 	| AutoFixNotice
 	| PermissionExpiredNotice
 	| QuestionSkippedNotice
-	| FullAutoEndedNotice;
+	| FullAutoEndedNotice
+	| ModelFallbackNotice;
 
 export interface FullAutoState {
 	duration: FullAutoDuration;

package/frontend-vue/app/chat/utils/status-label.ts

@@ -0,0 +1,50 @@
+import type { Translate } from "../composables/useChatI18n";
+import { formatClock } from "./format";
+
+export type StatusKind =
+	| "ready"
+	| "working"
+	| "waiting"
+	| "connecting"
+	| "offline";
+
+export interface StatusFacts {
+	kind: StatusKind;
+	elapsedMs: number;
+	pendingCount: number;
+	agentName: string;
+	/** The model that answered last; null until a reply names it. */
+	model: string | null;
+}
+
+const PART_SEPARATOR = " · ";
+
+function stateLabel(facts: StatusFacts, t: Translate): string {
+	const labels: Record<StatusKind, () => string> = {
+		ready: () => t("dms_ai.panel.status.ready"),
+		working: () =>
+			t("dms_ai.panel.status.working", { time: formatClock(facts.elapsedMs) }),
+		waiting: () =>
+			t(
+				"dms_ai.panel.status.waiting",
+				{ count: facts.pendingCount },
+				facts.pendingCount,
+			),
+		connecting: () => t("dms_ai.panel.status.connecting"),
+		offline: () => t("dms_ai.panel.status.offline"),
+	};
+	return labels[facts.kind]();
+}
+
+/**
+ * The panel's status line: the state, then the agent, then the model that
+ * answered last ("Ready · Claude Code · claude-opus-5-5"). Offline has no
+ * agent to name.
+ */
+export function describeStatus(facts: StatusFacts, t: Translate): string {
+	const label = stateLabel(facts, t);
+	if (facts.kind === "offline") return label;
+	const parts = [label, facts.agentName];
+	if (facts.model !== null) parts.push(facts.model);
+	return parts.join(PART_SEPARATOR);
+}

package/frontend-vue/app/chat/utils/tool-lexicon.ts

@@ -374,6 +374,16 @@ const BUILDER_TOOLS: Record<string, ToolLexiconEntry> = {
 		icon: ICONS.BLOCK,
 		target: firstOf("path"),
 	},
+	BuilderComposePage: {
+		verb: "compose_page",
+		icon: ICONS.BLOCK,
+		target: firstOf("pageRef"),
+	},
+	BuilderConfigureTableView: {
+		verb: "configure_table_view",
+		icon: ICONS.BLOCK,
+		target: firstOf("pageRef"),
+	},
 	BuilderMoveBlock: {
 		verb: "move_block",
 		icon: ICONS.BLOCK,
@@ -475,6 +485,12 @@ const BUILDER_TOOLS: Record<string, ToolLexiconEntry> = {
 		icon: ICONS.DATA,
 		target: firstOf("name"),
 	},
+	BuilderPreviewQuery: {
+		verb: "preview_query",
+		icon: ICONS.DATA,
+		target: firstOf("name"),
+		isReadOnly: true,
+	},
 	BuilderConfigureQuery: {
 		verb: "configure_query",
 		icon: ICONS.DATA,

package/frontend-vue/app/components/SkillDetail.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import type { Tone } from "#dms-ui/app/types/tone";
+import type { Tone } from "#dms-core/app/types/tone";
 import { computed } from "vue";
 import { renderDocument } from "../chat/utils/markdown";
 import { useAssistant } from "../views/composables/useAssistant";

package/frontend-vue/app/plugins/ai.client.ts

@@ -268,8 +268,8 @@ function createSession(parts: SessionParts): AssistantSession {
 			intents.push({ kind: "open", conversationId });
 			panel.open();
 		},
-		startConversation: (prompt, mode) => {
-			intents.push({ kind: "start", prompt, mode });
+		startConversation: (prompt, mode, send) => {
+			intents.push({ kind: "start", prompt, mode, send });
 			panel.open();
 		},
 		holdStream: parts.holds.hold,

package/frontend-vue/app/runtime/assistant-actions.ts

@@ -14,10 +14,12 @@ export interface PublicAssistantActions {
 	/**
 	 * Opens the assistant panel on a new conversation with `prompt` in the composer, unsent. With
 	 * `mode`, the conversation is set to it first: `plan` makes the agent end with a plan to approve.
+	 * With `send`, the prompt is sent as the first message once the stream is up, and the composer
+	 * stays empty.
 	 */
 	startConversation: (
 		prompt: string,
-		options?: { mode?: ConversationStartMode },
+		options?: { mode?: ConversationStartMode; send?: boolean },
 	) => void;
 }
 
@@ -36,6 +38,6 @@ export function publicAssistantActions(
 			return session.value !== null;
 		},
 		startConversation: (prompt, options) =>
-			session.value?.startConversation(prompt, options?.mode),
+			session.value?.startConversation(prompt, options?.mode, options?.send),
 	};
 }

package/frontend-vue/app/runtime/assistant-session.ts

@@ -38,7 +38,11 @@ export interface AssistantSession {
 	 * Opens the panel on a new conversation, the composer optionally prefilled, and the
 	 * conversation set to `mode` first when one is given.
 	 */
-	startConversation: (prompt?: string, mode?: ConversationStartMode) => void;
+	startConversation: (
+		prompt?: string,
+		mode?: ConversationStartMode,
+		send?: boolean,
+	) => void;
 	/**
 	 * Keeps the tab's stream open while the panel is closed, until the returned
 	 * function releases it: the command palette's answer streams through it.

package/frontend-vue/app/runtime/block-health.ts

@@ -0,0 +1,135 @@
+/**
+ * What the DMS data blocks (charts, KPIs, lists, tables) say about themselves.
+ * Each states its kind, its layout path and what its reader sees on its root
+ * element; a test harness reads the same attributes. A host that predates
+ * them states nothing, and the page reads as having no data block.
+ */
+const BLOCK_SELECTOR = "[data-dms-block-state]";
+const STATE_ATTRIBUTE = "data-dms-block-state";
+const TYPE_ATTRIBUTE = "data-dms-block-type";
+const PATH_ATTRIBUTE = "data-dms-block";
+const UNKNOWN_TYPE = "Block";
+
+/** How long the host waits for a page's blocks to stop loading. */
+export const BLOCK_SETTLE_BUDGET_MS = 15_000;
+/** How long the blocks of a page must stay unchanged before it counts as settled. */
+export const BLOCK_QUIET_MS = 700;
+
+const BLOCK_STATES = ["loading", "ok", "empty", "error"] as const;
+type BlockState = (typeof BLOCK_STATES)[number];
+type ReportedState = Exclude<BlockState, "ok">;
+
+export interface BlockFact {
+	path?: string;
+	type: string;
+	state: BlockState;
+}
+
+export interface ReportedBlock extends BlockFact {
+	state: ReportedState;
+}
+
+export interface PageBlocks {
+	status: "settled" | "timeout" | "superseded";
+	checked: number;
+	/** The blocks showing no data: empty, failed, or still loading. */
+	blocks: ReportedBlock[];
+}
+
+function isBlockState(value: string | null): value is BlockState {
+	return BLOCK_STATES.some((state) => state === value);
+}
+
+function isReported(block: BlockFact): block is ReportedBlock {
+	return block.state !== "ok";
+}
+
+function readBlock(element: Element): BlockFact | null {
+	const state = element.getAttribute(STATE_ATTRIBUTE);
+	if (!isBlockState(state)) return null;
+	const path = element.getAttribute(PATH_ATTRIBUTE);
+	return {
+		...(path === null ? {} : { path }),
+		type: element.getAttribute(TYPE_ATTRIBUTE) ?? UNKNOWN_TYPE,
+		state,
+	};
+}
+
+/** The data blocks under `root`, in document order. */
+export function readBlocks(root: ParentNode): BlockFact[] {
+	return [...root.querySelectorAll(BLOCK_SELECTOR)].flatMap((element) => {
+		const block = readBlock(element);
+		return block === null ? [] : [block];
+	});
+}
+
+function holdsBlock(node: Node): boolean {
+	return (
+		node instanceof Element &&
+		(node.matches(BLOCK_SELECTOR) ||
+			node.querySelector(BLOCK_SELECTOR) !== null)
+	);
+}
+
+function changesBlocks(record: MutationRecord): boolean {
+	if (record.type === "attributes") return true;
+	return [...record.addedNodes, ...record.removedNodes].some(holdsBlock);
+}
+
+export interface AwaitSettledBlocksOptions {
+	root: Document;
+	/** Aborted when another navigation starts: the wait ends as `superseded`. */
+	signal: AbortSignal;
+	budgetMs?: number;
+	quietMs?: number;
+}
+
+/**
+ * Resolves when the blocks of the page have stopped changing for `quietMs`
+ * and none is loading, or at `budgetMs` with the blocks still loading named,
+ * or at once when `signal` aborts.
+ */
+export function awaitSettledBlocks(
+	options: AwaitSettledBlocksOptions,
+): Promise<PageBlocks> {
+	const { root, signal } = options;
+	const budgetMs = options.budgetMs ?? BLOCK_SETTLE_BUDGET_MS;
+	const quietMs = options.quietMs ?? BLOCK_QUIET_MS;
+	return new Promise((resolve) => {
+		let quietTimer: ReturnType<typeof setTimeout> | undefined;
+		const finish = (status: PageBlocks["status"]): void => {
+			clearTimeout(quietTimer);
+			clearTimeout(budgetTimer);
+			observer.disconnect();
+			signal.removeEventListener("abort", onAbort);
+			const facts = readBlocks(root);
+			resolve({
+				status,
+				checked: facts.length,
+				blocks: facts.filter(isReported),
+			});
+		};
+		const onQuiet = (): void => {
+			if (readBlocks(root).every((block) => block.state !== "loading"))
+				finish("settled");
+		};
+		const restartQuiet = (): void => {
+			clearTimeout(quietTimer);
+			quietTimer = setTimeout(onQuiet, quietMs);
+		};
+		const onAbort = (): void => finish("superseded");
+		const observer = new MutationObserver((records) => {
+			if (records.some(changesBlocks)) restartQuiet();
+		});
+		const budgetTimer = setTimeout(() => finish("timeout"), budgetMs);
+		if (signal.aborted) return finish("superseded");
+		signal.addEventListener("abort", onAbort);
+		observer.observe(root, {
+			subtree: true,
+			childList: true,
+			attributes: true,
+			attributeFilter: [STATE_ATTRIBUTE],
+		});
+		restartQuiet();
+	});
+}

package/frontend-vue/app/runtime/constants.ts

@@ -40,6 +40,7 @@ export const HELLO_MESSAGE_TYPE = "hello";
 export const LOG_PREFIX = "[dms-ai]";
 export const HOST_STATE_UPDATE_TYPE = "host_state_update";
 export const HOST_NAVIGATION_COMPLETE_TYPE = "host_navigation_complete";
+export const HOST_PAGE_BLOCKS_TYPE = "host_page_blocks";
 export const HOST_COMMAND_NAVIGATE_TYPE = "host_command_navigate";
 /** Frames of the tab's stream meant for the dashboard; every other one is the chat's. */
 export const HOST_COMMAND_TYPES: ReadonlySet<string> = new Set([

package/frontend-vue/app/runtime/navigation-complete.ts

@@ -1,22 +1,63 @@
 import { router } from "@inertiajs/vue3";
-import { HOST_NAVIGATION_COMPLETE_TYPE } from "./constants";
+import {
+	awaitSettledBlocks,
+	BLOCK_SETTLE_BUDGET_MS,
+	type PageBlocks,
+} from "./block-health";
+import {
+	HOST_NAVIGATION_COMPLETE_TYPE,
+	HOST_PAGE_BLOCKS_TYPE,
+} from "./constants";
 
 interface HostNavigationCompleteMessage {
 	type: typeof HOST_NAVIGATION_COMPLETE_TYPE;
 	path: string;
+	/** A `host_page_blocks` message for this path follows within this long. */
+	blocksWithinMs: number;
 }
 
+interface HostPageBlocksMessage extends PageBlocks {
+	type: typeof HOST_PAGE_BLOCKS_TYPE;
+	path: string;
+}
+
+type NavigationMessage = HostNavigationCompleteMessage | HostPageBlocksMessage;
+
 interface InstallNavigationCompleteEmitterOptions {
-	send: (msg: HostNavigationCompleteMessage) => void;
+	send: (msg: NavigationMessage) => void;
 }
 
+/**
+ * Reports each completed visit at once, then what the page's data blocks
+ * showed once they settled, so the assistant learns of empty charts without
+ * a screenshot.
+ */
 export function installNavigationCompleteEmitter(
 	options: InstallNavigationCompleteEmitterOptions,
 ): () => void {
-	return router.on("navigate", (event) =>
+	let settling = new AbortController();
+	let stopped = false;
+	const stopNavigation = router.on("navigate", (event) => {
+		const path = new URL(event.detail.page.url, window.location.origin)
+			.pathname;
+		settling.abort();
+		settling = new AbortController();
 		options.send({
 			type: HOST_NAVIGATION_COMPLETE_TYPE,
-			path: new URL(event.detail.page.url, window.location.origin).pathname,
-		}),
-	);
+			path,
+			blocksWithinMs: BLOCK_SETTLE_BUDGET_MS,
+		});
+		void awaitSettledBlocks({
+			root: document,
+			signal: settling.signal,
+		}).then((blocks) => {
+			if (!stopped)
+				options.send({ type: HOST_PAGE_BLOCKS_TYPE, path, ...blocks });
+		});
+	});
+	return () => {
+		stopped = true;
+		settling.abort();
+		stopNavigation();
+	};
 }

package/frontend-vue/app/runtime/panel-intents.ts

@@ -7,11 +7,15 @@ interface OpenConversationIntent {
 	conversationId: string;
 }
 
-/** Opens the panel on a new conversation, the composer optionally prefilled, in `mode` when given. */
-interface StartConversationIntent {
+/**
+ * Opens the panel on a new conversation, in `mode` when given. The prompt is put in the composer,
+ * or sent as the first message when `send` is set.
+ */
+export interface StartConversationIntent {
 	kind: "start";
 	prompt?: string;
 	mode?: ConversationStartMode;
+	send?: boolean;
 }
 
 /** Puts the caret in the composer of the current conversation. */

package/frontend-vue/app/views/ChangeSetPanel.vue

@@ -7,7 +7,7 @@ import { useAssistant } from "./composables/useAssistant";
 import { useChangeSetActions } from "./composables/useChangeSetActions";
 import { useViewFormat } from "./composables/useViewFormat";
 import { AI_ROUTES } from "./constants";
-import type { Tone } from "#dms-ui/app/types/tone";
+import type { Tone } from "#dms-core/app/types/tone";
 import type {
 	ChangeSetDetail,
 	ChangeSetSummary,