@praxisui/table 8.0.0-beta.7 → 8.0.0-beta.70

package/fesm2022/praxisui-table-table-agentic-authoring-turn-flow-CmfIj9ao.mjs

@@ -0,0 +1,2845 @@
+import { firstValueFrom, Observable } from 'rxjs';
+
+class TableAgenticAuthoringTurnFlow {
+    adapter;
+    aiApi;
+    mode = 'agentic-authoring';
+    filterFieldLabels = new Map();
+    filterFieldCatalogEntries = [];
+    selectionDerivedFilterCandidateFields = new Set();
+    selectedRecordFieldsForTurn = new Set();
+    selectedRecordsCountForTurn = 0;
+    filterExpressionSupportedForTurn = null;
+    contextHintsForTurn = null;
+    streamTerminalWatchdogMs = 75_000;
+    streamTerminalReconnectLimit = 2;
+    selectedRecordStreamTerminalWatchdogMs = 45_000;
+    selectedRecordSurfaceStreamTerminalWatchdogMs = 18_000;
+    constructor(adapter, aiApi) {
+        this.adapter = adapter;
+        this.aiApi = aiApi;
+    }
+    submit(request) {
+        const prompt = (request.prompt ?? '').trim();
+        if (!prompt) {
+            return Promise.resolve({
+                state: 'listening',
+                phase: 'capture',
+                statusText: '',
+            });
+        }
+        const componentId = this.adapter.componentId || request.componentId || 'praxis-table';
+        const componentType = this.adapter.componentType || request.componentType || 'table';
+        const currentState = this.toAiJsonObject(this.adapter.getCurrentConfig());
+        const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+        const pendingCompletion = this.completePendingComponentEditClarification(request);
+        if (pendingCompletion) {
+            return Promise.resolve(this.toTurnResult(this.compileAdapterResponse(pendingCompletion, request), request));
+        }
+        const run = async () => {
+            await this.prepareAuthoringContext();
+            const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
+            const schemaFields = this.adapter.getSchemaFields?.()
+                ?.map((field) => this.toAiJsonObject(field))
+                .filter((field) => Object.keys(field).length > 0);
+            const contextHints = this.mergeJsonObjects(this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.tableConversationMemoryHints(request)), this.optionalJsonObject(request.action?.contextHints)) ?? null;
+            this.filterFieldCatalogEntries = this.extractFilterFieldCatalogEntries(contextHints);
+            this.filterFieldLabels = this.extractFilterFieldLabels(this.filterFieldCatalogEntries);
+            this.selectionDerivedFilterCandidateFields = this.extractSelectionDerivedFilterCandidateFields(contextHints);
+            this.selectedRecordFieldsForTurn = this.extractSelectedRecordFields(contextHints);
+            this.selectedRecordsCountForTurn = this.extractSelectedRecordsCount(contextHints);
+            this.filterExpressionSupportedForTurn = this.resolveFilterExpressionSupported(contextHints);
+            this.contextHintsForTurn = contextHints;
+            const messages = this.withCapabilitySystemMessages(this.toChatMessages(request.messages, prompt), contextHints);
+            return {
+                contextHints,
+                patchRequest: {
+                    componentId,
+                    componentType,
+                    userPrompt: prompt,
+                    sessionId: request.sessionId,
+                    clientTurnId: request.clientTurnId,
+                    messages,
+                    currentState,
+                    currentStateDigest: this.buildCurrentStateDigest(currentState, dataProfile),
+                    uiContextRef: {
+                        componentId,
+                        componentType,
+                    },
+                    ...(dataProfile ? { dataProfile } : {}),
+                    ...(runtimeState ? { runtimeState } : {}),
+                    ...(schemaFields?.length ? { schemaFields } : {}),
+                    ...(contextHints ? { contextHints } : {}),
+                },
+            };
+        };
+        const progressPrompt = this.progressPromptFor(request, prompt);
+        if (this.canUsePatchStream()) {
+            return this.submitViaStream(request, progressPrompt, currentState, componentId, run);
+        }
+        return this.submitViaSnapshot(request, currentState, run);
+    }
+    async submitViaSnapshot(request, currentState, buildRequest) {
+        const { patchRequest } = await buildRequest();
+        const response = await firstValueFrom(this.aiApi.getPatch(patchRequest));
+        return this.toTurnResult(this.compileAdapterResponse(this.groundRelativeColumnOrder(response, request, currentState), request), request);
+    }
+    submitViaStream(request, prompt, currentState, componentId, buildRequest) {
+        return new Observable((subscriber) => {
+            let closed = false;
+            let connection = null;
+            let subscription = null;
+            let terminalWatchdog = null;
+            let streamId = null;
+            let streamAccessToken;
+            let lastEventId;
+            let reconnectAttempts = 0;
+            let streamContextHints = null;
+            const clearTerminalWatchdog = () => {
+                if (terminalWatchdog) {
+                    clearTimeout(terminalWatchdog);
+                    terminalWatchdog = null;
+                }
+            };
+            const closeConnection = () => {
+                clearTerminalWatchdog();
+                subscription?.unsubscribe();
+                subscription = null;
+                if (connection) {
+                    connection.close();
+                    connection = null;
+                }
+            };
+            const emitProgress = (statusText) => {
+                if (closed || !statusText.trim())
+                    return;
+                subscriber.next({
+                    state: 'processing',
+                    phase: 'contextualize',
+                    statusText,
+                    canApply: false,
+                });
+            };
+            const completeWithSnapshotFallback = async () => {
+                if (closed)
+                    return;
+                let shouldClose = true;
+                try {
+                    emitProgress(this.buildSnapshotFallbackMessage(prompt, componentId));
+                    const result = await this.submitViaSnapshot(request, currentState, buildRequest);
+                    if (this.isProcessingTurnResult(result)
+                        && streamId
+                        && reconnectAttempts < this.streamTerminalReconnectLimitFor(streamContextHints)) {
+                        subscriber.next(result);
+                        reconnectAttempts += 1;
+                        shouldClose = false;
+                        emitProgress(this.buildStreamReplayMessage(prompt, componentId));
+                        openConnection();
+                        return;
+                    }
+                    if (!closed) {
+                        subscriber.next(result);
+                        subscriber.complete();
+                    }
+                }
+                catch (error) {
+                    if (!closed)
+                        subscriber.error(error);
+                }
+                finally {
+                    if (shouldClose) {
+                        closed = true;
+                        closeConnection();
+                    }
+                }
+            };
+            const armTerminalWatchdog = () => {
+                clearTerminalWatchdog();
+                const watchdogMs = this.streamTerminalWatchdogDelay(streamContextHints);
+                if (watchdogMs <= 0)
+                    return;
+                terminalWatchdog = setTimeout(() => {
+                    if (closed || !streamId)
+                        return;
+                    if (reconnectAttempts < this.streamTerminalReconnectLimitFor(streamContextHints)) {
+                        reconnectAttempts += 1;
+                        emitProgress(this.buildStreamReplayMessage(prompt, componentId));
+                        openConnection();
+                        return;
+                    }
+                    void completeWithSnapshotFallback();
+                }, watchdogMs);
+            };
+            const openConnection = () => {
+                if (!streamId || closed)
+                    return;
+                closeConnection();
+                connection = this.aiApi.connectPatchStream(streamId, lastEventId, streamAccessToken);
+                subscription = connection.events$.subscribe({
+                    next: (event) => {
+                        if (closed)
+                            return;
+                        if (event?.eventId) {
+                            lastEventId = event.eventId;
+                        }
+                        const terminal = this.toTerminalStreamResult(event, request, currentState);
+                        if (terminal) {
+                            subscriber.next(terminal);
+                            subscriber.complete();
+                            closed = true;
+                            closeConnection();
+                            return;
+                        }
+                        if (event.type !== 'heartbeat') {
+                            armTerminalWatchdog();
+                        }
+                        const progress = this.buildStreamProgressMessage(event.type, this.toRecord(event.payload) ?? {}, prompt, componentId);
+                        emitProgress(progress);
+                    },
+                    error: async () => {
+                        if (closed)
+                            return;
+                        if (streamId && reconnectAttempts < this.streamTerminalReconnectLimitFor(streamContextHints)) {
+                            reconnectAttempts += 1;
+                            emitProgress(this.buildStreamReplayMessage(prompt, componentId));
+                            openConnection();
+                            return;
+                        }
+                        await completeWithSnapshotFallback();
+                    },
+                });
+                armTerminalWatchdog();
+            };
+            void (async () => {
+                try {
+                    emitProgress(this.buildInitialProgressMessage(prompt, componentId));
+                    const { patchRequest, contextHints } = await buildRequest();
+                    streamContextHints = contextHints ?? null;
+                    if (this.shouldUseSelectedRecordSurfaceSnapshotFallback(streamContextHints)) {
+                        const result = await this.submitViaSnapshot(request, currentState, buildRequest);
+                        if (!closed) {
+                            subscriber.next(result);
+                            subscriber.complete();
+                        }
+                        closed = true;
+                        closeConnection();
+                        return;
+                    }
+                    const start = await this.awaitPatchStreamStart(patchRequest, streamContextHints);
+                    streamId = start.streamId;
+                    streamAccessToken = start.streamAccessToken ?? undefined;
+                    if (start.observationId) {
+                        emitProgress(this.buildStreamProgressMessage('status', { message: 'Stream iniciado.', phase: 'request' }, prompt, componentId));
+                    }
+                    openConnection();
+                }
+                catch (error) {
+                    if (closed)
+                        return;
+                    await completeWithSnapshotFallback();
+                }
+            })();
+            return () => {
+                closed = true;
+                closeConnection();
+            };
+        });
+    }
+    streamTerminalWatchdogDelay(contextHints) {
+        if (this.shouldUseSelectedRecordSurfaceSnapshotFallback(contextHints)) {
+            return Math.min(this.streamTerminalWatchdogMs, this.selectedRecordSurfaceStreamTerminalWatchdogMs);
+        }
+        if (this.shouldUseSelectedRecordSnapshotFallback(contextHints)) {
+            return Math.min(this.streamTerminalWatchdogMs, this.selectedRecordStreamTerminalWatchdogMs);
+        }
+        return this.streamTerminalWatchdogMs;
+    }
+    streamTerminalReconnectLimitFor(contextHints) {
+        if (this.shouldUseSelectedRecordSurfaceSnapshotFallback(contextHints)) {
+            return 0;
+        }
+        return this.streamTerminalReconnectLimit;
+    }
+    shouldUseSelectedRecordSnapshotFallback(contextHints) {
+        return this.selectedRecordsCountForTurn > 0
+            && (this.selectedRecordFilterCandidates(contextHints).length > 0
+                || this.shouldUseSelectedRecordSurfaceSnapshotFallback(contextHints));
+    }
+    shouldUseSelectedRecordSurfaceSnapshotFallback(contextHints) {
+        return this.selectedRecordsCountForTurn > 0
+            && this.selectedRecordSurfaces(contextHints).length > 0;
+    }
+    selectedRecordSurfaces(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const recordSurfaces = this.toRecord(consultativeContext?.['recordSurfaces']);
+        const surfaces = Array.isArray(recordSurfaces?.['surfaces']) ? recordSurfaces['surfaces'] : [];
+        return surfaces
+            .map((surface) => this.toRecord(surface))
+            .filter((surface) => !!surface);
+    }
+    isProcessingTurnResult(result) {
+        return result?.state === 'processing';
+    }
+    awaitPatchStreamStart(patchRequest, contextHints) {
+        const start = firstValueFrom(this.aiApi.startPatchStream(patchRequest));
+        if (!this.shouldUseSelectedRecordSnapshotFallback(contextHints)) {
+            return start;
+        }
+        return this.withTimeout(start, this.streamTerminalWatchdogDelay(contextHints), 'selected-record-stream-start-timeout');
+    }
+    withTimeout(promise, timeoutMs, message) {
+        if (timeoutMs <= 0)
+            return promise;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+            promise.then((value) => {
+                clearTimeout(timeout);
+                resolve(value);
+            }, (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    canUsePatchStream() {
+        return typeof this.aiApi.startPatchStream === 'function'
+            && typeof this.aiApi.connectPatchStream === 'function';
+    }
+    toTerminalStreamResult(event, request, currentState) {
+        if (!event)
+            return null;
+        const payload = this.toRecord(event.payload) ?? {};
+        if (event.type === 'result') {
+            const response = (this.toRecord(payload['response']) ?? payload);
+            return this.toTurnResult(this.compileAdapterResponse(this.groundRelativeColumnOrder(response, request, currentState), request), request);
+        }
+        if (event.type === 'error' || event.type === 'cancelled') {
+            const message = this.stringValue(payload['assistantMessage'])
+                || this.stringValue(payload['message'])
+                || 'Nao foi possivel concluir o pedido da tabela.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: message,
+                errorText: message,
+                canApply: false,
+            };
+        }
+        return null;
+    }
+    buildInitialProgressMessage(prompt, componentId) {
+        return `Vou acompanhar este pedido na ${this.componentProgressLabel(componentId)}: "${this.promptPreview(prompt)}".`;
+    }
+    buildSnapshotFallbackMessage(prompt, componentId) {
+        return `Vou continuar pela resposta direta para este pedido na ${this.componentProgressLabel(componentId)}: "${this.promptPreview(prompt)}".`;
+    }
+    buildStreamReplayMessage(prompt, componentId) {
+        return `Ainda estou aguardando a conclusão na ${this.componentProgressLabel(componentId)}; vou sincronizar novamente este pedido: "${this.promptPreview(prompt)}".`;
+    }
+    buildStreamProgressMessage(eventType, payload, prompt, componentId) {
+        const phase = this.stringValue(payload['phase']);
+        const title = this.stringValue(payload['title']);
+        const detail = this.stringValue(payload['detail']);
+        const message = this.stringValue(payload['message']);
+        const summary = this.stringValue(payload['summary']);
+        const base = detail || summary || message || title || this.progressFallbackForPhase(phase, eventType);
+        const target = this.componentProgressLabel(componentId);
+        const preview = this.promptPreview(prompt);
+        if (phase === 'request' || eventType === 'status' && payload['state'] === 'started') {
+            return `Pedido recebido na ${target}: "${preview}".`;
+        }
+        if (phase === 'proposal') {
+            return `${base} Pedido em foco: "${preview}".`;
+        }
+        if (phase === 'analysis') {
+            return `Analisando contexto e capacidades da ${target} para: "${preview}".`;
+        }
+        return `${base} Pedido: "${preview}".`;
+    }
+    progressFallbackForPhase(phase, eventType) {
+        if (phase === 'analysis')
+            return 'Analisando contexto e capacidades disponiveis.';
+        if (phase === 'proposal')
+            return 'Preparando uma resposta aplicavel.';
+        if (eventType === 'heartbeat')
+            return 'Ainda processando o pedido.';
+        return 'Processando o pedido.';
+    }
+    componentProgressLabel(componentId) {
+        return componentId === 'praxis-table' ? 'tabela dinamica' : 'superficie selecionada';
+    }
+    promptPreview(prompt) {
+        const normalized = prompt.replace(/\s+/g, ' ').trim();
+        return normalized.length > 90 ? `${normalized.slice(0, 87)}...` : normalized;
+    }
+    progressPromptFor(request, fallback) {
+        const displayPrompt = typeof request.action?.displayPrompt === 'string'
+            ? request.action.displayPrompt.trim()
+            : '';
+        return displayPrompt || fallback;
+    }
+    normalizePrompt(prompt) {
+        return prompt
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .trim();
+    }
+    extractResourcePath(source) {
+        if (!source)
+            return null;
+        const direct = this.nonEmptyStringValue(source['resourcePath']);
+        if (direct)
+            return direct;
+        const consultativeContext = this.toRecord(source['consultativeContext']);
+        const fromConsultative = this.nonEmptyStringValue(consultativeContext?.['resourcePath']);
+        if (fromConsultative)
+            return fromConsultative;
+        const authoringContract = this.toRecord(source['authoringContract']);
+        if (authoringContract && authoringContract !== source) {
+            return this.extractResourcePath(authoringContract);
+        }
+        return null;
+    }
+    nonEmptyStringValue(value) {
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    async apply(request) {
+        const patch = this.toRecord(request.pendingPatch);
+        if (!patch) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: 'Não há alteração de tabela pronta para aplicar.',
+                errorText: 'Não há alteração de tabela pronta para aplicar.',
+                canApply: false,
+            };
+        }
+        const result = await this.adapter.applyPatch(patch, request.prompt);
+        if (!result.success) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: result.error || 'Não foi possível aplicar as alterações na tabela.',
+                errorText: result.error || 'Não foi possível aplicar as alterações na tabela.',
+                canApply: true,
+                pendingPatch: patch,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            assistantMessage: 'Alterações aplicadas na tabela.',
+            statusText: 'Alterações aplicadas na tabela.',
+            canApply: false,
+            pendingPatch: null,
+            diagnostics: result.warnings?.length ? { warnings: result.warnings } : undefined,
+        };
+    }
+    cancel() {
+        return Promise.resolve({
+            state: 'listening',
+            phase: 'capture',
+            assistantMessage: 'Solicitação cancelada.',
+            statusText: '',
+            canApply: false,
+            pendingPatch: null,
+            pendingClarification: null,
+        });
+    }
+    retry(request) {
+        const lastPrompt = [...(request.messages ?? [])].reverse()
+            .find((message) => message.role === 'user')?.text;
+        return this.submit({
+            ...request,
+            prompt: lastPrompt ?? request.prompt,
+            action: { kind: 'retry' },
+        });
+    }
+    toTurnResult(response, request) {
+        if (!response) {
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: 'Resposta vazia da IA.',
+                errorText: 'Resposta vazia da IA.',
+            };
+        }
+        if (response.sessionId && response.sessionId !== request.sessionId) {
+            request = { ...request, sessionId: response.sessionId };
+        }
+        if (response.type === 'clarification') {
+            const questions = this.toClarificationQuestions(response, request);
+            const diagnostics = this.buildClarificationDiagnostics(response);
+            return {
+                state: 'clarification',
+                phase: 'clarify',
+                sessionId: response.sessionId ?? request.sessionId,
+                observationId: response.observationId ?? request.observationId ?? null,
+                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                clarificationQuestions: questions,
+                quickReplies: this.toQuickReplies(response, request),
+                canApply: false,
+                diagnostics,
+            };
+        }
+        if (response.type === 'info') {
+            if (this.isTurnInProgressResponse(response)) {
+                const message = response.message || response.explanation || 'Ainda estou processando este pedido.';
+                return {
+                    state: 'processing',
+                    phase: 'contextualize',
+                    sessionId: response.sessionId ?? request.sessionId,
+                    observationId: response.observationId ?? request.observationId ?? null,
+                    statusText: message,
+                    canApply: false,
+                };
+            }
+            const message = response.message || response.explanation || 'Informação gerada.';
+            return {
+                state: 'success',
+                phase: 'summarize',
+                sessionId: response.sessionId ?? request.sessionId,
+                observationId: response.observationId ?? request.observationId ?? null,
+                assistantMessage: message,
+                statusText: message,
+                quickReplies: this.toQuickReplies(response, request),
+                canApply: false,
+            };
+        }
+        if (response.type === 'error') {
+            const message = response.message || 'Falha ao gerar alteração de tabela.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                sessionId: response.sessionId ?? request.sessionId,
+                observationId: response.observationId ?? request.observationId ?? null,
+                assistantMessage: message,
+                errorText: message,
+                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+            };
+        }
+        if (response.patch && Object.keys(response.patch).length > 0) {
+            const warnings = response.warnings?.filter(Boolean) ?? [];
+            const quickReplies = this.toQuickReplies(response, request);
+            const diagnostics = this.buildReviewDiagnostics(response, warnings);
+            return {
+                state: 'review',
+                phase: 'review',
+                sessionId: response.sessionId ?? request.sessionId,
+                observationId: response.observationId ?? request.observationId ?? null,
+                assistantMessage: this.toReviewMessage(response),
+                statusText: 'Revise a proposta antes de aplicar.',
+                quickReplies,
+                canApply: true,
+                pendingPatch: response.patch,
+                preview: {
+                    kind: 'table-config-patch',
+                    diff: response.diff ?? [],
+                },
+                diagnostics,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: response.sessionId ?? request.sessionId,
+            observationId: response.observationId ?? request.observationId ?? null,
+            assistantMessage: response.message || response.explanation || 'Nenhuma alteração necessária.',
+            statusText: response.message || response.explanation || 'Nenhuma alteração necessária.',
+            canApply: false,
+        };
+    }
+    isTurnInProgressResponse(response) {
+        return this.normalizeLabel(response.code ?? '') === 'turn in progress';
+    }
+    compileAdapterResponse(response, request) {
+        if (response.type === 'clarification' || response.type === 'info' || response.type === 'error') {
+            const compiledExecutable = !this.responseCarriesClarificationChoices(response)
+                && this.responseMayContainExecutableEnvelope(response)
+                ? this.adapter.compileAiResponse?.(response)
+                : null;
+            if (compiledExecutable?.patch && Object.keys(compiledExecutable.patch).length > 0) {
+                const warnings = [
+                    ...(response.warnings ?? []),
+                    ...(compiledExecutable.warnings ?? []),
+                ];
+                const executableResponse = {
+                    ...response,
+                    patch: compiledExecutable.patch,
+                    warnings: warnings.length ? warnings : undefined,
+                };
+                delete executableResponse.type;
+                return executableResponse;
+            }
+            if (compiledExecutable?.type === 'error') {
+                return {
+                    type: 'error',
+                    message: compiledExecutable.message || 'O componentEditPlan da tabela nao passou na validacao de capacidades.',
+                    warnings: compiledExecutable.warnings,
+                };
+            }
+            const continuedSurfaceRowAction = this.selectedRecordSurfaceRowActionPlanForClarification(response, request);
+            if (continuedSurfaceRowAction) {
+                return this.compileAdapterResponse(continuedSurfaceRowAction, request);
+            }
+            return response;
+        }
+        const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled && response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                type: 'error',
+                message: 'A tabela exige componentEditPlan validado pelo manifesto antes de gerar patch local.',
+                warnings: [
+                    'free-table-patch-rejected',
+                    'Use componentEditPlan validado contra PRAXIS_TABLE_AUTHORING_MANIFEST.',
+                ],
+            };
+        }
+        if (!compiled) {
+            return response;
+        }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan da tabela nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
+        const governedSelectedRecordFilter = this.isGovernedSelectedRecordFilterResponse(response);
+        if (!governedSelectedRecordFilter && this.shouldBlockUnsupportedFilterExpressionRuntimePatch(compiled.patch, request)) {
+            const questions = this.unsupportedFilterExpressionClarificationQuestions(compiled.patch);
+            return {
+                type: 'clarification',
+                message: [
+                    'Esse pedido combina alternativas entre campos diferentes, mas o contrato atual da tabela so materializa filtros simples.',
+                    'Posso aplicar uma unica escolha de filtro simples por vez, derivada dos campos suportados desta tabela, ou manter a tabela sem alteracao enquanto a intencao e refinada.',
+                ].join(' '),
+                questions,
+                warnings: [
+                    'unsupported-filter-expression-materialization-blocked',
+                    'Residual textual boolean-operator guard acted only after LLM proposed a runtime table.filter.apply operation while filterExpression is unsupported.',
+                ],
+            };
+        }
+        const implicitSelectedFilterClarification = governedSelectedRecordFilter ? null : this.implicitSelectedRecordFilterClarification(compiled.patch, request);
+        if (implicitSelectedFilterClarification) {
+            return implicitSelectedFilterClarification;
+        }
+        const warnings = [
+            ...(response.warnings ?? []),
+            ...(compiled.warnings ?? []),
+        ];
+        return {
+            ...response,
+            ...compiled,
+            patch: compiled.patch,
+            warnings: warnings.length ? warnings : undefined,
+        };
+    }
+    responseCarriesClarificationChoices(response) {
+        if (response.type !== 'clarification')
+            return false;
+        const record = response;
+        const questions = Array.isArray(response.questions) ? response.questions : [];
+        const optionPayloads = Array.isArray(record['optionPayloads']) ? record['optionPayloads'] : [];
+        return questions.length > 0 || optionPayloads.length > 0;
+    }
+    responseMayContainExecutableEnvelope(response) {
+        return this.responseMayContainRuntimeOperationEnvelope(response)
+            || this.responseMayContainComponentEditPlanEnvelope(response);
+    }
+    responseMayContainRuntimeOperationEnvelope(response) {
+        const record = response;
+        if (record['tableRuntimeOperations'])
+            return true;
+        const patch = this.toRecord(record['patch']);
+        if (patch?.['tableRuntimeOperations'])
+            return true;
+        return ['message', 'assistantMessage', 'content', 'explanation'].some((key) => {
+            const value = this.stringValue(record[key]);
+            return value.includes('tableRuntimeOperations') && value.includes('operationId');
+        });
+    }
+    responseMayContainComponentEditPlanEnvelope(response) {
+        const record = response;
+        if (record['componentEditPlan'] || record['tableEditPlan'] || record['editPlan'])
+            return true;
+        return ['message', 'assistantMessage', 'content', 'explanation'].some((key) => {
+            const value = this.stringValue(record[key]);
+            return value.includes('componentEditPlan') && value.includes('operationId');
+        });
+    }
+    isGovernedSelectedRecordFilterResponse(response) {
+        return (response.warnings ?? []).some((warning) => [
+            'selected-record-filter-request-materialized',
+            'selected-record-filter-clarification-materialized',
+        ].includes(warning));
+    }
+    shouldBlockUnsupportedFilterExpressionRuntimePatch(patch, request) {
+        if (this.filterExpressionSupportedForTurn === true)
+            return false;
+        if (!this.patchHasTableFilterApply(patch))
+            return false;
+        const prompt = this.normalizeLabel(request?.prompt ?? '');
+        // Safety guard only after an LLM-authored executable operation exists. It does
+        // not route primary intent; it blocks degraded materialization of explicit
+        // boolean alternatives when the canonical contract lacks filterExpression.
+        return /\b(ou|or|anyof|oneof|allof)\b/u.test(prompt);
+    }
+    unsupportedFilterExpressionClarificationQuestions(patch) {
+        const labels = this.attemptedRuntimeFilterFieldLabels(patch);
+        const fieldOptions = labels
+            .slice(0, 2)
+            .map((label) => `Aplicar apenas o filtro por ${label}`);
+        return [
+            ...fieldOptions,
+            'Nao aplicar filtro e revisar a intencao',
+        ].slice(0, 3);
+    }
+    attemptedRuntimeFilterFieldLabels(patch) {
+        const envelope = this.toRecord(this.toRecord(patch)?.['tableRuntimeOperations']);
+        const operations = Array.isArray(envelope?.['operations']) ? envelope['operations'] : [];
+        const labels = new Set();
+        for (const operation of operations) {
+            const record = this.toRecord(operation);
+            if (this.stringValue(record?.['operationId']) !== 'table.filter.apply')
+                continue;
+            const input = this.toRecord(record?.['input']) ?? {};
+            const criteria = this.toRecord(input['criteria']) ?? {};
+            for (const field of Object.keys(criteria)) {
+                labels.add(this.humanizeFilterField(field));
+            }
+        }
+        return [...labels];
+    }
+    patchHasTableFilterApply(patch) {
+        const envelope = this.toRecord(this.toRecord(patch)?.['tableRuntimeOperations']);
+        const operations = Array.isArray(envelope?.['operations']) ? envelope['operations'] : [];
+        return operations
+            .map((operation) => this.toRecord(operation))
+            .some((operation) => this.stringValue(operation?.['operationId']) === 'table.filter.apply');
+    }
+    selectedRecordFilterCandidate(contextHints, field) {
+        const normalizedField = field.trim();
+        if (!normalizedField)
+            return null;
+        return this.selectedRecordFilterCandidates(contextHints)
+            .find((candidate) => this.stringValue(candidate['field']) === normalizedField) ?? null;
+    }
+    selectedRecordFilterCandidates(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const selectedRecordsContext = this.toRecord(consultativeContext?.['selectedRecordsContext'])
+            ?? this.toRecord(contextHints?.['selectedRecordsContext']);
+        const candidates = Array.isArray(selectedRecordsContext?.['filterCandidates'])
+            ? selectedRecordsContext['filterCandidates']
+            : [];
+        return candidates
+            .map((candidate) => this.toRecord(candidate))
+            .filter((candidate) => !!candidate);
+    }
+    selectedRecordSampleRows(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const selectedRecordsContext = this.toRecord(consultativeContext?.['selectedRecordsContext'])
+            ?? this.toRecord(contextHints?.['selectedRecordsContext']);
+        const sampleRows = Array.isArray(selectedRecordsContext?.['sampleRows'])
+            ? selectedRecordsContext['sampleRows']
+            : [];
+        return sampleRows
+            .map((row) => this.toRecord(row))
+            .filter((row) => !!row);
+    }
+    selectedRecordFilterClarificationOptionPayload(entry, contextHints) {
+        const description = this.selectedRecordFilterCandidateDescription(entry.name, contextHints);
+        return {
+            value: entry.name,
+            label: `Filtrar por ${entry.label}`,
+            contextHints: {
+                selectedRecordsFilter: {
+                    field: entry.name,
+                    label: entry.label,
+                    source: 'selected-record-clarification',
+                },
+                ...(description
+                    ? {
+                        presentation: {
+                            kind: 'guided-option',
+                            icon: 'check',
+                            description,
+                            ctaLabel: 'Usar esta opção',
+                        },
+                    }
+                    : {}),
+            },
+        };
+    }
+    selectedRecordFilterCandidateDescription(field, contextHints) {
+        const candidate = this.selectedRecordFilterCandidate(contextHints, field);
+        const displayValues = Array.isArray(candidate?.['displayValues'])
+            ? candidate['displayValues']
+                .map((entry) => this.formatSelectedRecordFilterValue(entry))
+                .filter((entry) => !!entry)
+            : [];
+        if (displayValues.length) {
+            const preview = displayValues.slice(0, 3).join(', ');
+            return `Valores dos selecionados: ${preview}${displayValues.length > 3 ? ', ...' : ''}`;
+        }
+        const criteria = this.toRecord(candidate?.['criteria']);
+        const value = criteria?.[field];
+        if (value === undefined || value === null)
+            return null;
+        const record = this.toRecord(value);
+        if (record) {
+            const start = record['start'] ?? record['startDate'];
+            const end = record['end'] ?? record['endDate'];
+            if (start !== undefined && end !== undefined) {
+                return `Valores dos selecionados: ${this.formatSelectedRecordFilterValue(start)} até ${this.formatSelectedRecordFilterValue(end)}`;
+            }
+        }
+        if (Array.isArray(value) && value.length) {
+            const preview = value.slice(0, 3).map((entry) => this.formatSelectedRecordFilterValue(entry)).join(', ');
+            return `Valores dos selecionados: ${preview}${value.length > 3 ? ', ...' : ''}`;
+        }
+        return null;
+    }
+    formatSelectedRecordFilterValue(value) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return new Intl.NumberFormat('pt-BR', { maximumFractionDigits: 2 }).format(value);
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            const dateMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/u);
+            if (dateMatch)
+                return `${dateMatch[3]}/${dateMatch[2]}/${dateMatch[1]}`;
+            return trimmed;
+        }
+        if (typeof value === 'boolean')
+            return value ? 'sim' : 'não';
+        return String(value ?? '');
+    }
+    implicitSelectedRecordFilterClarification(patch, request) {
+        if (this.selectedRecordsCountForTurn <= 0)
+            return null;
+        if (this.filterFieldCatalogEntries.length < 2)
+            return null;
+        const operations = this.tableFilterApplyOperations(patch);
+        if (!operations.length)
+            return null;
+        const prompt = this.normalizeLabel(request?.prompt ?? '');
+        if (!prompt)
+            return null;
+        const groundedSurfaceOperation = this.selectedRecordSurfaceOperationForMisgroundedFilter(prompt, request);
+        if (groundedSurfaceOperation) {
+            return groundedSurfaceOperation;
+        }
+        const implicitFields = operations
+            .flatMap((operation) => Object.keys(this.toRecord(this.toRecord(operation['input'])?.['criteria']) ?? {}))
+            .filter((field) => field && !this.promptMentionsFilterField(prompt, field));
+        if (!implicitFields.length)
+            return null;
+        const contextHints = this.contextHintsFor(request);
+        // This guard runs only after the LLM authored an executable table.filter.apply
+        // operation. It does not route primary intent; it blocks ungrounded
+        // materialization when selected rows offer multiple plausible filter fields.
+        const options = this.selectedRecordFilterClarificationOptionEntries(implicitFields);
+        if (options.length < 2)
+            return null;
+        return {
+            type: 'clarification',
+            message: [
+                `Encontrei ${this.selectedRecordsCountForTurn} registro${this.selectedRecordsCountForTurn === 1 ? '' : 's'} selecionado${this.selectedRecordsCountForTurn === 1 ? '' : 's'}.`,
+                'Para buscar registros parecidos, escolha qual propriedade deve guiar o filtro.',
+            ].join(' '),
+            questions: ['Como você quer definir registros parecidos?'],
+            optionPayloads: options.map((entry) => this.selectedRecordFilterClarificationOptionPayload(entry, contextHints)),
+            warnings: [
+                'implicit-selected-record-filter-materialization-blocked',
+                'Residual grounding guard acted only after LLM proposed table.filter.apply from selected-record context with multiple plausible filter fields.',
+            ],
+        };
+    }
+    selectedRecordSurfaceOperationForMisgroundedFilter(normalizedPrompt, request) {
+        if (this.promptRequestsSimilarRecords(normalizedPrompt))
+            return null;
+        const contextHints = this.contextHintsFor(request);
+        const surfaces = this.selectedRecordSurfaces(contextHints);
+        if (!surfaces.length)
+            return null;
+        const ranked = surfaces
+            .map((surface) => ({
+            surface,
+            score: this.selectedRecordSurfacePromptScore(normalizedPrompt, surface),
+        }))
+            .filter((entry) => entry.score >= 2)
+            .sort((a, b) => b.score - a.score);
+        if (!ranked.length || (ranked.length > 1 && ranked[0].score === ranked[1].score)) {
+            return null;
+        }
+        const surface = ranked[0].surface;
+        const surfaceId = this.stringValue(surface['id']);
+        if (!surfaceId)
+            return null;
+        const surfaceLabel = this.stringValue(surface['label'])
+            || this.stringValue(this.toRecord(surface['resourceSurface'])?.['title'])
+            || this.humanizeField(surfaceId);
+        // Residual grounding guard: this runs only after the LLM authored a
+        // selected-record table.filter.apply operation. It ranks declared canonical
+        // recordSurfaces to correct an unsafe filter materialization, not to route
+        // primary user intent by command text.
+        return {
+            type: 'patch',
+            patch: {
+                tableRuntimeOperations: {
+                    source: 'selected-record-surface-grounding-guard',
+                    operations: [{
+                            operationId: 'dynamicPage.surface.open',
+                            input: {
+                                surfaceId,
+                                surfaceLabel,
+                                source: 'selected-records',
+                            },
+                        }],
+                },
+            },
+            warnings: [
+                'selected-record-filter-materialization-corrected-to-record-surface',
+                'Residual grounding guard acted only after LLM proposed table.filter.apply while declared recordSurfaces semantically matched the selected-record request.',
+            ],
+        };
+    }
+    selectedRecordSurfaceRowActionPlanForClarification(response, request) {
+        if (!request)
+            return null;
+        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
+        const normalizedConversation = this.normalizeLabel([
+            ...(request.messages ?? []).slice(-8).map((message) => message?.text ?? ''),
+            request.prompt ?? '',
+        ].join(' '));
+        if (!this.textMentionsRowActionRequest(normalizedPrompt || normalizedConversation)) {
+            return null;
+        }
+        const clarificationKind = this.selectedRecordSurfaceRowActionClarificationKind(response);
+        if (!clarificationKind)
+            return null;
+        const contextHints = this.contextHintsFor(request);
+        const surfaces = this.selectedRecordSurfaces(contextHints);
+        if (!surfaces.length)
+            return null;
+        const ranked = surfaces
+            .map((surface) => ({
+            surface,
+            score: this.selectedRecordSurfacePromptScore(normalizedConversation || normalizedPrompt, surface),
+        }))
+            .filter((entry) => entry.score >= 2)
+            .sort((left, right) => right.score - left.score);
+        if (!ranked.length || (ranked.length > 1 && ranked[0].score === ranked[1].score)) {
+            return null;
+        }
+        const surface = ranked[0].surface;
+        const resourceSurface = this.toRecord(surface['resourceSurface']);
+        if (!this.isResourceSurfaceCatalogDigest(resourceSurface)) {
+            return null;
+        }
+        const surfaceId = this.stringValue(surface['id']) || this.stringValue(resourceSurface['id']);
+        if (!surfaceId)
+            return null;
+        const surfaceLabel = this.stringValue(surface['label'])
+            || this.stringValue(resourceSurface['title'])
+            || this.humanizeField(surfaceId);
+        const actionId = `open-${this.slugifyActionId(surfaceId)}`;
+        const rowAction = {
+            id: actionId,
+            label: surfaceLabel,
+            action: 'surface.open',
+            icon: 'open_in_new',
+            recordSurface: this.toAiJsonObject(resourceSurface),
+        };
+        // Residual continuity guard: this runs only after the LLM returned a
+        // clarification/info response for a row-button request. The target surface
+        // is ranked from declared canonical recordSurfaces and recent conversation
+        // context, so the guard repairs materialization without becoming primary
+        // intent routing by local command text.
+        return {
+            type: 'patch',
+            componentEditPlan: {
+                kind: 'praxis.table.component-edit-plan',
+                version: '1.0',
+                componentId: 'praxis-table',
+                operationId: 'rowAction.add',
+                changeKind: 'add_row_action',
+                capabilityPath: 'actions.row.actions[]',
+                input: rowAction,
+                value: rowAction,
+            },
+            explanation: `Vou criar um botão em cada linha para abrir ${surfaceLabel}.`,
+            warnings: [
+                clarificationKind === 'technical'
+                    ? 'selected-record-surface-row-action-continued-from-technical-clarification'
+                    : 'selected-record-surface-row-action-continued-from-generic-clarification',
+                clarificationKind === 'technical'
+                    ? 'Residual continuity guard acted only after LLM asked for technical row-action details while declared recordSurfaces and conversation history already grounded the target surface.'
+                    : 'Residual continuity guard acted only after LLM asked a generic dataset/listing clarification while declared recordSurfaces and a row-action request already grounded the target surface.',
+            ],
+        };
+    }
+    selectedRecordSurfaceRowActionClarificationKind(response) {
+        const text = this.normalizeLabel([
+            response.message ?? '',
+            response.explanation ?? '',
+            ...(response.questions ?? []),
+        ].join(' '));
+        if ([
+            'surface to open',
+            'button label',
+            'placement in row',
+            'mais detalhes sobre surface',
+            'mais detalhes sobre button',
+            'mais detalhes sobre placement',
+        ].some((needle) => text.includes(needle))) {
+            return 'technical';
+        }
+        if ([
+            'qual conjunto de dados',
+            'conjunto de dados',
+            'dados voce quer listar',
+            'dados você quer listar',
+            'quer listar',
+            'listar',
+            'dataset',
+        ].some((needle) => text.includes(this.normalizeLabel(needle)))) {
+            return 'generic-dataset';
+        }
+        return null;
+    }
+    textMentionsRowActionRequest(normalizedText) {
+        return [
+            'botao',
+            'acao de linha',
+            'acoes de linha',
+            'nas linhas',
+            'por linha',
+            'em cada linha',
+        ].some((needle) => normalizedText.includes(needle));
+    }
+    isResourceSurfaceCatalogDigest(value) {
+        if (!value)
+            return false;
+        return !!this.stringValue(value['id'])
+            && !!this.stringValue(value['kind'])
+            && !!this.stringValue(value['scope'])
+            && !!this.stringValue(value['path'])
+            && !!this.stringValue(value['method']);
+    }
+    slugifyActionId(value) {
+        return this.normalizeLabel(value)
+            .replace(/[^a-z0-9]+/gu, '-')
+            .replace(/^-+|-+$/gu, '')
+            || 'surface';
+    }
+    promptRequestsSimilarRecords(normalizedPrompt) {
+        return [
+            'registro parecido',
+            'registros parecidos',
+            'outro registro',
+            'outros registros',
+            'buscar registros',
+            'procurar registros',
+            'filtrar registros',
+            'filtrar por',
+        ].some((needle) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, needle));
+    }
+    selectedRecordSurfacePromptScore(normalizedPrompt, surface) {
+        const resourceSurface = this.toRecord(surface['resourceSurface']);
+        const tags = Array.isArray(resourceSurface?.['tags']) ? resourceSurface['tags'] : [];
+        const haystack = this.normalizeLabel([
+            this.stringValue(surface['id']),
+            this.stringValue(surface['label']),
+            this.stringValue(surface['title']),
+            this.stringValue(surface['description']),
+            this.stringValue(surface['semanticDescription']),
+            this.stringValue(surface['semanticIntent']),
+            this.stringValue(surface['kind']),
+            this.stringValue(surface['scope']),
+            this.stringValue(surface['relation']),
+            this.stringValue(resourceSurface?.['id']),
+            this.stringValue(resourceSurface?.['title']),
+            this.stringValue(resourceSurface?.['description']),
+            this.stringValue(resourceSurface?.['semanticIntent']),
+            this.stringValue(resourceSurface?.['kind']),
+            this.stringValue(resourceSurface?.['scope']),
+            ...this.compactStringArray(surface['tags']),
+            ...tags.map((tag) => this.stringValue(tag)),
+        ].join(' '));
+        const promptTokens = normalizedPrompt
+            .split(/\s+/u)
+            .map((token) => token.trim())
+            .filter((token) => token.length >= 4 && !this.isSelectedRecordSurfaceStopToken(token));
+        return [...new Set(promptTokens)]
+            .reduce((score, token) => score + (haystack.includes(token) ? 1 : 0), 0);
+    }
+    isSelectedRecordSurfaceStopToken(token) {
+        return [
+            'quero',
+            'mostra',
+            'mostrar',
+            'mostre',
+            'abrir',
+            'abre',
+            'deste',
+            'desse',
+            'dele',
+            'dela',
+            'registro',
+            'selecionado',
+            'selecionada',
+        ].includes(token);
+    }
+    compactStringArray(value) {
+        return Array.isArray(value)
+            ? value
+                .map((entry) => this.stringValue(entry))
+                .filter((entry) => !!entry)
+            : [];
+    }
+    contextHintsFor(request) {
+        return this.toRecord(request?.contextHints) ?? this.contextHintsForTurn;
+    }
+    tableFilterApplyOperations(patch) {
+        const envelope = this.toRecord(this.toRecord(patch)?.['tableRuntimeOperations']);
+        const operations = Array.isArray(envelope?.['operations']) ? envelope['operations'] : [];
+        return operations
+            .map((operation) => this.toRecord(operation))
+            .filter((operation) => !!operation && this.stringValue(operation['operationId']) === 'table.filter.apply');
+    }
+    promptMentionsFilterField(prompt, fieldName) {
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        if (!normalizedPrompt)
+            return false;
+        const entry = this.filterFieldCatalogEntries.find((candidate) => candidate.name === fieldName);
+        const rawCandidates = [
+            fieldName,
+            this.humanizeFilterField(fieldName),
+            entry?.label,
+            ...(entry?.aliases ?? []),
+            ...(entry?.relatedColumnFields ?? []),
+            ...(entry?.relatedColumnLabels ?? []),
+        ];
+        return rawCandidates
+            .flatMap((candidate) => this.filterFieldMentionVariants(candidate ?? ''))
+            .some((candidate) => candidate && this.normalizedTextContainsApproxPhrase(normalizedPrompt, candidate));
+    }
+    selectedRecordFilterPromptGroundingScore(prompt, candidate) {
+        const fieldName = this.stringValue(candidate['field']);
+        if (!fieldName)
+            return 0;
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        if (!normalizedPrompt)
+            return 0;
+        const entry = this.filterFieldCatalogEntries.find((candidateEntry) => candidateEntry.name === fieldName);
+        const candidateLabel = this.stringValue(candidate['label']);
+        const candidateAliases = this.stringArrayValue(candidate['aliases']);
+        const candidateRelatedColumnFields = this.stringArrayValue(candidate['relatedColumnFields']);
+        const candidateRelatedColumnLabels = this.stringArrayValue(candidate['relatedColumnLabels']);
+        const criterionKind = this.normalizeLabel(this.stringValue(candidate['criterionKind']) || entry?.criterionKind || '');
+        let score = 0;
+        score += this.promptContainsAnyVariant(normalizedPrompt, candidateLabel || entry?.label || this.humanizeFilterField(fieldName)) ? 180 : 0;
+        score += candidateLabel && entry?.label && candidateLabel !== entry.label && this.promptContainsAnyVariant(normalizedPrompt, entry.label) ? 160 : 0;
+        score += this.promptContainsAnyVariant(normalizedPrompt, this.humanizeFilterField(fieldName)) ? 120 : 0;
+        for (const alias of candidateAliases) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, alias) ? 100 : 0;
+        }
+        for (const alias of entry?.aliases ?? []) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, alias) ? 90 : 0;
+        }
+        for (const label of candidateRelatedColumnLabels) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, label) ? 50 : 0;
+        }
+        for (const label of entry?.relatedColumnLabels ?? []) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, label) ? 40 : 0;
+        }
+        for (const field of candidateRelatedColumnFields) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, field) ? 35 : 0;
+        }
+        for (const field of entry?.relatedColumnFields ?? []) {
+            score += this.promptContainsAnyVariant(normalizedPrompt, field) ? 30 : 0;
+        }
+        const hasRangeIntent = ['faixa', 'banda', 'entre'].some((token) => this.normalizedTextContainsApproxToken(normalizedPrompt, token));
+        const hasDateIntent = ['data', 'periodo', 'admissao', 'entrou', 'entrada', 'epoca'].some((token) => this.normalizedTextContainsApproxToken(normalizedPrompt, token));
+        const hasPeriodIntent = ['periodo', 'intervalo', 'entre'].some((token) => this.normalizedTextContainsApproxToken(normalizedPrompt, token));
+        const hasRecentIntent = ['recente', 'recentes', 'ultimo', 'ultimos'].some((token) => this.normalizedTextContainsApproxToken(normalizedPrompt, token));
+        if (criterionKind.includes('date range')) {
+            score += hasDateIntent ? 70 : 0;
+            score += hasPeriodIntent ? 45 : 0;
+        }
+        else if (criterionKind.includes('range')) {
+            score += hasRangeIntent ? 70 : 0;
+            score += hasPeriodIntent ? 25 : 0;
+        }
+        if (fieldName.endsWith('LastDays')) {
+            score += hasRecentIntent ? 35 : 0;
+            score -= hasPeriodIntent ? 25 : 0;
+        }
+        return score;
+    }
+    promptContainsAnyVariant(normalizedPrompt, value) {
+        return this.filterFieldMentionVariants(value)
+            .some((variant) => !!variant && this.normalizedTextContainsApproxPhrase(normalizedPrompt, variant));
+    }
+    filterFieldMentionVariants(value) {
+        const normalized = this.normalizeLabel(value);
+        if (!normalized)
+            return [];
+        const variants = new Set([normalized]);
+        if (normalized.endsWith('s') && normalized.length > 3) {
+            variants.add(normalized.slice(0, -1));
+        }
+        else {
+            variants.add(`${normalized}s`);
+        }
+        for (const token of normalized.split(/\s+/u)) {
+            if (token.length >= 4) {
+                variants.add(token);
+                if (token.endsWith('s') && token.length > 4) {
+                    variants.add(token.slice(0, -1));
+                }
+                else {
+                    variants.add(`${token}s`);
+                }
+            }
+        }
+        return [...variants];
+    }
+    normalizedTextContainsApproxPhrase(normalizedText, normalizedPhrase) {
+        if (!normalizedText || !normalizedPhrase)
+            return false;
+        if (normalizedText.includes(normalizedPhrase))
+            return true;
+        const phraseTokens = normalizedPhrase
+            .split(/\s+/u)
+            .filter((token) => token.length > 2);
+        if (!phraseTokens.length)
+            return false;
+        return phraseTokens.every((token) => this.normalizedTextContainsApproxToken(normalizedText, token));
+    }
+    normalizedTextContainsApproxToken(normalizedText, rawToken) {
+        const token = this.normalizeLabel(rawToken);
+        if (!normalizedText || !token)
+            return false;
+        if (normalizedText.includes(token))
+            return true;
+        if (token.length < 5)
+            return false;
+        const maxDistance = token.length >= 9 ? 2 : 1;
+        return normalizedText
+            .split(/\s+/u)
+            .some((word) => word.length >= 4 && !this.isApproximateMatchingStopword(word) && ((word[0] === token[0] && this.boundedEditDistance(word, token, maxDistance) <= maxDistance)
+            || this.normalizedConsonantSignature(word) === this.normalizedConsonantSignature(token)));
+    }
+    isApproximateMatchingStopword(word) {
+        return new Set([
+            'estao',
+            'esta',
+            'sao',
+            'tem',
+            'têm',
+            'esses',
+            'essas',
+            'eles',
+            'elas',
+            'entrou',
+            'entrada',
+        ]).has(word);
+    }
+    normalizedConsonantSignature(value) {
+        return this.normalizeLabel(value).replace(/[aeiou]/gu, '');
+    }
+    stringArrayValue(value) {
+        return Array.isArray(value)
+            ? value.map((entry) => this.stringValue(entry)).filter((entry) => !!entry)
+            : [];
+    }
+    boundedEditDistance(left, right, maxDistance) {
+        if (Math.abs(left.length - right.length) > maxDistance)
+            return maxDistance + 1;
+        let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+        for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+            const current = [leftIndex];
+            let rowMin = current[0];
+            for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+                const cost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+                const value = Math.min(previous[rightIndex] + 1, current[rightIndex - 1] + 1, previous[rightIndex - 1] + cost);
+                current[rightIndex] = value;
+                rowMin = Math.min(rowMin, value);
+            }
+            if (rowMin > maxDistance)
+                return maxDistance + 1;
+            previous = current;
+        }
+        return previous[right.length];
+    }
+    selectedRecordFilterClarificationOptionEntries(preferredFields) {
+        const preferred = new Set(preferredFields);
+        const entries = [...this.filterFieldCatalogEntries]
+            .sort((left, right) => this.selectedRecordFilterOptionScore(right, preferred)
+            - this.selectedRecordFilterOptionScore(left, preferred));
+        const seen = new Set();
+        const options = [];
+        for (const entry of entries) {
+            const key = this.normalizeLabel(entry.label);
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            options.push(entry);
+            if (options.length >= 4)
+                break;
+        }
+        return options;
+    }
+    selectedRecordFilterOptionScore(entry, preferred) {
+        let score = preferred.has(entry.name) ? 40 : 0;
+        const name = this.normalizeLabel(entry.name);
+        const label = this.normalizeLabel(entry.label);
+        const controlType = this.normalizeLabel(entry.controlType ?? '');
+        const type = this.normalizeLabel(entry.type ?? '');
+        const criterionKind = this.normalizeLabel(entry.criterionKind ?? '');
+        if (this.selectionDerivedFilterCandidateFields.has(entry.name))
+            score += 120;
+        if (/IdsIn$/u.test(entry.name))
+            score += 40;
+        if (criterionKind.includes('range') || controlType.includes('range'))
+            score += 120;
+        if (this.filterEntryHasSelectedRecordSourceField(entry))
+            score += 45;
+        if (criterionKind === 'date range' || type.includes('date') || type.includes('time'))
+            score += 5;
+        if (controlType.includes('select') || controlType.includes('lookup'))
+            score += 25;
+        if (type === 'boolean' || controlType.includes('switch'))
+            score += 15;
+        if (type === 'string' || controlType.includes('text') || controlType.includes('input'))
+            score -= 10;
+        if (name.includes('nome') || label.includes('nome'))
+            score -= 15;
+        return score;
+    }
+    groundRelativeColumnOrder(response, request, currentState) {
+        const prompt = this.normalizeLabel(request.prompt ?? '');
+        const position = this.relativeOrderPosition(prompt);
+        if (!position)
+            return response;
+        const plan = this.toRecord(response.componentEditPlan);
+        if (!plan)
+            return response;
+        const columns = Array.isArray(currentState['columns'])
+            ? currentState['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+        if (columns.length < 2)
+            return response;
+        const operations = this.componentEditOperations(plan);
+        if (!operations.some((operation) => this.isColumnOrderOperation(operation))) {
+            return response;
+        }
+        const groundOperation = (operation) => {
+            if (!this.isColumnOrderOperation(operation))
+                return operation;
+            const targetField = this.resolveOperationTargetField(operation, columns);
+            if (!targetField)
+                return operation;
+            const reference = this.findRelativeOrderReferenceColumn(prompt, columns, targetField);
+            if (!reference)
+                return operation;
+            const reorderedBase = columns.filter((column) => this.stringValue(column['field']) !== targetField);
+            const referenceIndex = reorderedBase.findIndex((column) => this.stringValue(column['field']) === reference);
+            if (referenceIndex < 0)
+                return operation;
+            const order = position === 'after' ? referenceIndex + 1 : referenceIndex;
+            const input = {
+                ...(this.toRecord(operation['input']) ?? {}),
+                order,
+            };
+            return { ...operation, input };
+        };
+        if (Array.isArray(plan['operations'])) {
+            return {
+                ...response,
+                componentEditPlan: {
+                    ...plan,
+                    operations: operations.map((operation) => groundOperation(operation)),
+                },
+            };
+        }
+        return {
+            ...response,
+            componentEditPlan: groundOperation(plan),
+        };
+    }
+    relativeOrderPosition(prompt) {
+        if (prompt.includes('antes'))
+            return 'before';
+        if (prompt.includes('depois') || prompt.includes('apos'))
+            return 'after';
+        return null;
+    }
+    isColumnOrderOperation(operation) {
+        return this.stringValue(operation['operationId']) === 'column.order.set'
+            || this.stringValue(operation['changeKind']) === 'set_column_order';
+    }
+    resolveOperationTargetField(operation, columns) {
+        const target = this.toRecord(operation['target']);
+        const input = this.toRecord(operation['input']);
+        const rawTarget = this.stringValue(target?.['field'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input?.['field']);
+        if (!rawTarget)
+            return null;
+        const normalizedTarget = this.normalizeLabel(rawTarget);
+        const match = columns.find((column) => this.normalizeLabel(this.stringValue(column['field'])) === normalizedTarget
+            || this.normalizeLabel(this.stringValue(column['header'])) === normalizedTarget);
+        return this.stringValue(match?.['field']) || rawTarget;
+    }
+    findRelativeOrderReferenceColumn(prompt, columns, targetField) {
+        const candidates = columns
+            .filter((column) => this.stringValue(column['field']) !== targetField)
+            .map((column) => {
+            const field = this.stringValue(column['field']);
+            const header = this.stringValue(column['header']) || this.humanizeField(field);
+            const fieldKey = this.normalizeLabel(field);
+            const headerKey = this.normalizeLabel(header);
+            let score = 0;
+            if (headerKey && prompt.includes(headerKey))
+                score += 4;
+            if (fieldKey && prompt.includes(fieldKey))
+                score += 3;
+            return { field, score };
+        })
+            .filter((candidate) => candidate.field && candidate.score > 0)
+            .sort((left, right) => right.score - left.score);
+        return candidates[0]?.field ?? null;
+    }
+    toReviewMessage(response) {
+        const runtimeSummaries = this.describeTableRuntimeOperations(response.patch);
+        if (runtimeSummaries.length) {
+            return [
+                'Preparei esta operação para revisão:',
+                '',
+                ...runtimeSummaries.map((summary) => `- ${summary}`),
+            ].join('\n');
+        }
+        const planSummaries = this.describeComponentEditPlan(response.componentEditPlan);
+        if (planSummaries.length) {
+            return [
+                'Preparei este ajuste para revisão:',
+                '',
+                ...planSummaries.map((summary) => `- ${summary}`),
+            ].join('\n');
+        }
+        return response.explanation || 'Proposta de alteração pronta para revisar.';
+    }
+    describeTableRuntimeOperations(patch) {
+        const envelope = this.toRecord(this.toRecord(patch)?.['tableRuntimeOperations']);
+        const operations = Array.isArray(envelope?.['operations']) ? envelope['operations'] : [];
+        return operations
+            .map((operation) => this.toRecord(operation))
+            .filter((operation) => !!operation)
+            .map((operation) => this.describeTableRuntimeOperation(operation))
+            .filter((summary) => !!summary);
+    }
+    describeTableRuntimeOperation(operation) {
+        const operationId = this.stringValue(operation['operationId']);
+        const input = this.toRecord(operation['input']) ?? {};
+        if (operationId === 'table.filter.apply') {
+            const criteria = this.toRecord(input['criteria']) ?? {};
+            const fields = Object.keys(criteria);
+            if (!fields.length)
+                return 'Vou aplicar filtros na tabela.';
+            return `Vou aplicar filtros por ${fields.map((field) => `**${this.humanizeFilterField(field)}**`).join(', ')}.`;
+        }
+        if (operationId === 'table.export.run') {
+            const format = this.stringValue(input['format']).toUpperCase();
+            const scope = this.describeExportScope(this.stringValue(input['scope']));
+            return `Vou exportar ${scope}${format ? ` em **${format}**` : ''}.`;
+        }
+        if (operationId === 'dynamicPage.surface.open') {
+            const surfaceId = this.stringValue(input['surfaceId'] ?? input['id']);
+            const surfaceLabel = this.stringValue(input['surfaceLabel']);
+            return surfaceId
+                ? `Vou abrir a superfície relacionada **${surfaceLabel || this.humanizeField(surfaceId)}**.`
+                : 'Vou abrir a superfície relacionada solicitada.';
+        }
+        return null;
+    }
+    describeExportScope(scope) {
+        switch (scope) {
+            case 'selected':
+                return 'as linhas selecionadas';
+            case 'filtered':
+                return 'o resultado filtrado';
+            case 'currentPage':
+                return 'a pagina atual';
+            case 'all':
+                return 'todos os registros';
+            default:
+                return 'os dados da tabela';
+        }
+    }
+    describeComponentEditPlan(componentEditPlan) {
+        const operations = this.componentEditOperations(componentEditPlan);
+        const booleanStateSummary = this.describeBooleanStateRenderers(operations);
+        if (booleanStateSummary)
+            return [booleanStateSummary];
+        const categoricalRendererSummary = this.describeCategoricalRenderers(operations);
+        if (categoricalRendererSummary)
+            return [categoricalRendererSummary];
+        const seen = new Set();
+        return operations
+            .map((operation) => this.describeComponentEditOperation(operation))
+            .filter((summary) => {
+            if (!summary || seen.has(summary))
+                return false;
+            seen.add(summary);
+            return true;
+        });
+    }
+    componentEditOperations(componentEditPlan) {
+        const plan = this.toRecord(componentEditPlan);
+        if (!plan)
+            return [];
+        const operations = plan['operations'];
+        if (Array.isArray(operations)) {
+            return operations
+                .map((operation) => this.toRecord(operation))
+                .filter((operation) => !!operation);
+        }
+        return plan['operationId'] || plan['changeKind'] || plan['capabilityPath']
+            ? [plan]
+            : [];
+    }
+    buildClarificationDiagnostics(response) {
+        const continuation = this.extractPendingComponentEditContinuation(response);
+        return continuation ? { tableComponentEditContinuation: continuation } : undefined;
+    }
+    buildReviewDiagnostics(response, warnings) {
+        const memory = this.extractComponentEditDecisionMemory(response);
+        if (!memory && !warnings.length)
+            return undefined;
+        return {
+            ...(warnings.length ? { warnings: [...warnings] } : {}),
+            ...(memory ? { tableComponentEditDecision: memory } : {}),
+        };
+    }
+    tableConversationMemoryHints(request) {
+        const diagnostics = this.toRecord(request.diagnostics);
+        const decision = this.toRecord(diagnostics?.['tableComponentEditDecision']);
+        if (!decision)
+            return undefined;
+        return {
+            tableConversationMemory: {
+                lastComponentEditDecision: this.toAiJsonObject(decision),
+            },
+        };
+    }
+    extractComponentEditDecisionMemory(response) {
+        const operations = this.componentEditOperations(response.componentEditPlan);
+        if (!operations.length)
+            return null;
+        const mappedOperations = operations
+            .map((operation) => this.extractComponentEditOperationMemory(operation))
+            .filter((operation) => !!operation);
+        if (!mappedOperations.length)
+            return null;
+        return {
+            kind: 'praxis.table.component-edit-decision-memory',
+            operations: mappedOperations,
+            lastTarget: mappedOperations.at(-1)?.['target'] ?? null,
+            lastOperationId: this.stringValue(mappedOperations.at(-1)?.['operationId']),
+        };
+    }
+    extractComponentEditOperationMemory(operation) {
+        const operationId = this.stringValue(operation['operationId']) || this.stringValue(operation['changeKind']);
+        const target = this.toRecord(operation['target']) ?? {};
+        const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+        const field = this.stringValue(target['field'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input['field']);
+        if (!operationId && !field)
+            return null;
+        return {
+            ...(operationId ? { operationId } : {}),
+            ...(field ? { target: { ...target, kind: this.stringValue(target['kind']) || 'column', field } } : {}),
+            ...(Object.keys(input).length ? { input } : {}),
+        };
+    }
+    extractPendingComponentEditContinuation(response) {
+        const operation = this.componentEditOperations(response.componentEditPlan)[0];
+        if (!operation)
+            return null;
+        const operationId = this.stringValue(operation['operationId']) || this.stringValue(operation['changeKind']);
+        const target = this.toRecord(operation['target']) ?? {};
+        const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+        const field = this.stringValue(target['field'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input['field']);
+        if (!operationId || !field)
+            return null;
+        const missingInputKey = this.pendingComponentEditInputKey(operationId, input);
+        if (!missingInputKey)
+            return null;
+        return {
+            operationId,
+            target: { ...target, field },
+            input: { ...input },
+            missingInputKey,
+        };
+    }
+    pendingComponentEditInputKey(operationId, input) {
+        if (operationId === 'column.width.set' && !this.stringValue(input['width'] ?? input['value'])) {
+            return 'width';
+        }
+        return null;
+    }
+    completePendingComponentEditClarification(request) {
+        if (request.action?.kind !== 'clarify')
+            return null;
+        const diagnostics = this.toRecord(request.pendingClarification?.diagnostics);
+        const continuation = this.toRecord(diagnostics?.['tableComponentEditContinuation']);
+        if (!continuation)
+            return null;
+        const operationId = this.stringValue(continuation['operationId']);
+        const missingInputKey = this.stringValue(continuation['missingInputKey']);
+        const target = this.toRecord(continuation['target']);
+        const input = this.toRecord(continuation['input']) ?? {};
+        const value = (request.prompt ?? '').trim();
+        if (!operationId || !missingInputKey || !target || !value)
+            return null;
+        return {
+            type: 'patch',
+            sessionId: request.sessionId,
+            componentEditPlan: {
+                kind: 'praxis.table.component-edit-plan',
+                version: '1.0',
+                componentId: this.adapter.componentId || request.componentId || 'praxis-table',
+                operationId,
+                target,
+                input: {
+                    ...input,
+                    [missingInputKey]: value,
+                },
+            },
+            explanation: 'Clarificacao aplicada ao ajuste pendente.',
+        };
+    }
+    describeBooleanStateRenderers(operations) {
+        if (operations.length < 2)
+            return null;
+        const rendererOperations = operations
+            .filter((operation) => this.stringValue(operation['operationId']) === 'column.conditionalRenderer.add')
+            .map((operation) => {
+            const target = this.toRecord(operation['target']);
+            const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+            const renderer = this.toRecord(input['renderer']);
+            const rendererType = this.stringValue(renderer?.['type']) || 'badge';
+            const visual = this.toRecord(renderer?.[rendererType]) ?? {};
+            return {
+                field: this.stringValue(target?.['field']) || this.stringValue(operation['field']) || this.stringValue(input['field']),
+                trueLabel: this.booleanConditionValue(input['condition']) === true ? this.stringValue(visual['text']) : '',
+                falseLabel: this.booleanConditionValue(input['condition']) === false ? this.stringValue(visual['text']) : '',
+                rendererType,
+                details: this.booleanRendererBranchDetails(input, visual),
+            };
+        })
+            .filter((item) => item.field && (item.trueLabel || item.falseLabel));
+        if (rendererOperations.length < 2)
+            return null;
+        const field = rendererOperations[0].field;
+        if (!rendererOperations.every((item) => item.field === field))
+            return null;
+        const trueLabel = rendererOperations.find((item) => item.trueLabel)?.trueLabel;
+        const falseLabel = rendererOperations.find((item) => item.falseLabel)?.falseLabel;
+        if (!trueLabel || !falseLabel)
+            return null;
+        const rendererType = rendererOperations.find((item) => item.rendererType)?.rendererType || 'badge';
+        const trueDetails = rendererOperations.find((item) => item.trueLabel)?.details ?? [];
+        const falseDetails = rendererOperations.find((item) => item.falseLabel)?.details ?? [];
+        const trueSuffix = trueDetails.length ? ` (${trueDetails.join(', ')})` : '';
+        const falseSuffix = falseDetails.length ? ` (${falseDetails.join(', ')})` : '';
+        return `Vou mostrar a coluna **${this.humanizeField(field)}** como ${this.rendererLabel(rendererType)}: **${trueLabel}** para verdadeiro${trueSuffix} e **${falseLabel}** para falso${falseSuffix}.`;
+    }
+    booleanRendererBranchDetails(input, visual) {
+        const details = [];
+        const variant = this.stringValue(visual['variant']);
+        const color = this.stringValue(visual['color']);
+        const icon = this.stringValue(visual['icon']);
+        const tooltip = this.tooltipLabel(input['tooltip']);
+        if (variant)
+            details.push(`visual ${this.variantLabel(variant)}`);
+        if (color)
+            details.push(`cor ${this.colorLabel(color)}`);
+        if (icon)
+            details.push(`icone ${icon}`);
+        if (tooltip)
+            details.push(`dica "${tooltip}"`);
+        return details;
+    }
+    describeCategoricalRenderers(operations) {
+        const rendererOperations = operations
+            .filter((operation) => this.stringValue(operation['operationId']) === 'column.conditionalRenderer.add')
+            .map((operation) => {
+            const target = this.toRecord(operation['target']);
+            const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+            const field = this.stringValue(target?.['field'])
+                || this.stringValue(operation['field'])
+                || this.stringValue(input['field']);
+            const equality = this.literalEqualityCondition(input['condition']);
+            const renderer = this.toRecord(input['renderer']);
+            const rendererType = this.stringValue(renderer?.['type']) || 'badge';
+            const visual = this.toRecord(renderer?.[rendererType]) ?? {};
+            const label = this.stringValue(visual['text']) || equality?.valueLabel || '';
+            return {
+                field,
+                conditionField: equality?.field,
+                valueLabel: equality?.valueLabel,
+                label,
+                rendererType,
+                details: this.categoricalRendererDetails(input, visual),
+            };
+        })
+            .filter((item) => item.field && item.conditionField && item.valueLabel);
+        if (rendererOperations.length < 2)
+            return null;
+        const field = rendererOperations[0].field;
+        if (!rendererOperations.every((item) => item.field === field && item.conditionField === field))
+            return null;
+        const rendererType = rendererOperations.find((item) => item.rendererType)?.rendererType || 'badge';
+        const uniqueOperations = this.uniqueCategoricalRendererOperations(rendererOperations);
+        const options = uniqueOperations
+            .slice(0, 6)
+            .map((item) => {
+            const details = item.details.length ? ` (${item.details.join(', ')})` : '';
+            return `**${this.enumValueLabel(item.label || item.valueLabel || '')}**${details}`;
+        });
+        const suffix = uniqueOperations.length > options.length
+            ? ` e mais ${uniqueOperations.length - options.length} valores`
+            : '';
+        return `Vou mostrar a coluna **${this.humanizeField(field)}** como ${this.rendererPluralLabel(rendererType)} coloridos para ${options.join(', ')}${suffix}.`;
+    }
+    categoricalRendererDetails(input, visual) {
+        const details = this.rendererVisualDetails(visual);
+        const tooltip = this.tooltipLabel(input['tooltip']);
+        if (tooltip)
+            details.push(`dica "${tooltip}"`);
+        return details;
+    }
+    uniqueCategoricalRendererOperations(operations) {
+        const seen = new Set();
+        const unique = [];
+        for (const operation of operations) {
+            const key = this.normalizeComparableLabel(operation.valueLabel || '');
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            unique.push(operation);
+        }
+        return unique;
+    }
+    describeComponentEditOperation(operation) {
+        const operationId = this.stringValue(operation['operationId']) || this.stringValue(operation['changeKind']);
+        const target = this.toRecord(operation['target']);
+        const input = this.toRecord(operation['input']) ?? this.toRecord(operation['params']) ?? {};
+        const field = this.stringValue(target?.['field'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input['field']);
+        const label = field ? this.humanizeField(field) : 'a tabela';
+        switch (operationId) {
+            case 'column.add':
+            case 'add_column':
+                return `Vou adicionar a coluna **${label}** na tabela.`;
+            case 'column.format.set':
+            case 'set_column_format':
+                return `Vou formatar a coluna **${label}** como **${this.formatLabel(input['format'] ?? operation['value'])}**.`;
+            case 'column.valueMapping.set':
+            case 'set_column_value_mapping':
+                return this.describeValueMapping(label, input['valueMapping'] ?? operation['valueMapping'] ?? operation['value']);
+            case 'column.header.set':
+            case 'set_column_header':
+                return `Vou renomear a coluna **${label}** para **${this.stringValue(input['header'] ?? operation['value']) || label}**.`;
+            case 'column.visibility.set':
+            case 'set_column_visibility':
+                return `${this.booleanInput(input['visible'] ?? operation['value']) === false ? 'Vou ocultar' : 'Vou exibir'} a coluna **${label}**.`;
+            case 'column.sticky.set':
+                return this.describeStickyColumn(label, input['sticky'] ?? input['value'] ?? operation['value']);
+            case 'column.width.set':
+                return `Vou ajustar a largura da coluna **${label}**.`;
+            case 'column.order.set':
+                return `Vou reposicionar a coluna **${label}** na tabela.`;
+            case 'column.align.set':
+                return `Vou alinhar a coluna **${label}** ${this.alignmentLabel(input['align'] ?? input['value'] ?? operation['value'])}.`;
+            case 'column.style.set':
+                return this.describeColumnStyle(label, input['style'] ?? input['value'] ?? operation['value'], 'coluna');
+            case 'column.headerStyle.set':
+                return this.describeColumnStyle(label, input['headerStyle'] ?? input['value'] ?? operation['value'], 'cabecalho');
+            case 'column.remove':
+                return `Vou remover a coluna **${label}** da tabela.`;
+            case 'column.renderer.set':
+            case 'set_column_renderer':
+                return `Vou ajustar a apresentacao visual da coluna **${label}**.`;
+            case 'column.conditionalRenderer.add':
+            case 'set_column_conditional_badge_renderers':
+                return this.describeConditionalRenderer(label, input);
+            case 'column.conditionalStyle.add':
+            case 'set_column_conditional_style':
+                return this.describeConditionalStyle(label, this.toRecord(operation['value']) ?? input);
+            case 'column.computed.add':
+            case 'column.computed.set':
+            case 'add_computed_column':
+                return `Vou criar ou atualizar a coluna calculada **${label}**.`;
+            case 'behavior.filtering.configure':
+                return 'Vou atualizar os filtros da tabela.';
+            case 'filter.advanced.configure':
+            case 'configure_advanced_filters':
+                return this.describeAdvancedFiltersConfigure(input);
+            case 'filter.advanced.fields.add':
+                return this.describeAdvancedFilterFields(input, 'add');
+            case 'filter.advanced.fields.remove':
+                return this.describeAdvancedFilterFields(input, 'remove');
+            case 'behavior.pagination.configure':
+                return 'Vou atualizar a paginacao da tabela.';
+            case 'behavior.selection.configure':
+                return 'Vou atualizar a selecao de linhas.';
+            case 'toolbar.configure':
+                return 'Vou ajustar a barra de acoes da tabela.';
+            case 'toolbar.action.add':
+            case 'add_toolbar_action':
+                return `Vou adicionar a acao **${this.stringValue(input['label']) || this.stringValue(input['id']) || 'solicitada'}** na barra da tabela.`;
+            case 'rowAction.add':
+            case 'add_row_action':
+                return `Vou criar um botao em cada linha para abrir **${this.stringValue(input['label']) || this.stringValue(input['id']) || 'a opcao solicitada'}**.`;
+            case 'export.configure':
+                return this.describeExportConfigure(input);
+            case 'appearance.density.set':
+                return `Vou ajustar a densidade da tabela para **${this.stringValue(input['density'] ?? operation['value']) || 'o valor escolhido'}**.`;
+            default:
+                if (field && (input['format'] != null || operation['format'] != null)) {
+                    return `Vou formatar a coluna **${label}** como **${this.formatLabel(input['format'] ?? operation['format'])}**.`;
+                }
+                return field
+                    ? `Vou atualizar a coluna **${label}**.`
+                    : 'Vou atualizar a configuracao da tabela.';
+        }
+    }
+    describeExportConfigure(input) {
+        const scope = this.stringValue(input['scope'] ?? input['exportScope']);
+        const serialized = JSON.stringify(input).toLowerCase();
+        const selectedOnly = scope === 'selected'
+            || scope === 'selection'
+            || serialized.includes('selected')
+            || serialized.includes('selection');
+        if (selectedOnly) {
+            return 'Vou habilitar a exportacao das linhas selecionadas.';
+        }
+        return 'Vou habilitar a exportacao da tabela.';
+    }
+    describeValueMapping(label, mappingValue) {
+        const mapping = this.toRecord(mappingValue);
+        if (!mapping) {
+            return `Vou mapear os valores da coluna **${label}** para rotulos legiveis.`;
+        }
+        const trueLabel = this.stringValue(mapping['true'] ?? mapping['TRUE'] ?? mapping['1']);
+        const falseLabel = this.stringValue(mapping['false'] ?? mapping['FALSE'] ?? mapping['0']);
+        if (trueLabel && falseLabel) {
+            return `Vou mostrar a coluna **${label}** como **${trueLabel}/${falseLabel}**.`;
+        }
+        const entries = Object.entries(mapping)
+            .map(([key, value]) => {
+            const text = this.stringValue(value);
+            return key && text ? `**${key}** como **${text}**` : null;
+        })
+            .filter((item) => !!item)
+            .slice(0, 3);
+        if (entries.length > 0) {
+            return `Vou mapear ${entries.join(', ')} na coluna **${label}**.`;
+        }
+        return `Vou mapear os valores da coluna **${label}** para rotulos legiveis.`;
+    }
+    describeStickyColumn(label, value) {
+        const sticky = this.stringValue(value).toLowerCase();
+        if (sticky === 'false' || sticky === 'none') {
+            return `Vou desafixar a coluna **${label}**.`;
+        }
+        if (sticky === 'end' || sticky === 'right') {
+            return `Vou fixar a coluna **${label}** no fim da tabela.`;
+        }
+        return `Vou fixar a coluna **${label}** no inicio da tabela.`;
+    }
+    alignmentLabel(value) {
+        switch (this.stringValue(value).toLowerCase()) {
+            case 'left':
+                return 'a esquerda';
+            case 'right':
+                return 'a direita';
+            case 'center':
+                return 'ao centro';
+            default:
+                return 'como solicitado';
+        }
+    }
+    describeAdvancedFiltersConfigure(input) {
+        const enabled = this.booleanInput(input['enabled']);
+        if (enabled === false) {
+            return 'Vou desativar os filtros avancados da tabela.';
+        }
+        const settings = this.toRecord(input['settings']) ?? {};
+        const fields = this.arrayOfStrings(settings['alwaysVisibleFields']);
+        if (fields.length) {
+            return `Vou ativar os filtros avancados e deixar **${fields.map((field) => this.humanizeFilterField(field)).join(', ')}** sempre visiveis.`;
+        }
+        return 'Vou ativar os filtros avancados da tabela.';
+    }
+    describeAdvancedFilterFields(input, action) {
+        const fields = this.arrayOfStrings(input['fields']);
+        if (!fields.length) {
+            return action === 'add'
+                ? 'Vou incluir novos campos nos filtros avancados.'
+                : 'Vou remover campos dos filtros avancados.';
+        }
+        const labels = fields.map((field) => this.humanizeFilterField(field)).join(', ');
+        if (action === 'remove') {
+            return `Vou remover **${labels}** dos filtros avancados.`;
+        }
+        const alwaysVisible = this.booleanInput(input['alwaysVisible']);
+        if (alwaysVisible === true) {
+            return `Vou incluir **${labels}** nos filtros avancados e deixar disponivel na area principal.`;
+        }
+        return `Vou incluir **${labels}** nos filtros avancados.`;
+    }
+    describeConditionalRenderer(label, input) {
+        const renderer = this.toRecord(input['renderer']);
+        const rendererType = this.stringValue(renderer?.['type']) || 'badge';
+        const visual = this.toRecord(renderer?.[rendererType]) ?? {};
+        const text = this.stringValue(visual['text']);
+        const visualDetails = this.rendererVisualDetails(visual);
+        const visualSuffix = visualDetails.length ? `, ${visualDetails.join(', ')}` : '';
+        const description = this.stringValue(input['description']);
+        const condition = this.conditionPhrase(input['condition'], label);
+        const conditionSuffix = condition ? ` quando **${condition}**` : '';
+        const tooltip = this.tooltipLabel(input['tooltip']) ?? this.semanticDescriptionLabel(input['description']);
+        if (tooltip && !text) {
+            return `Vou adicionar uma dica na coluna **${label}**${conditionSuffix}: **${tooltip}**.`;
+        }
+        if (text) {
+            return `Vou destacar a coluna **${label}** com ${this.rendererLabel(rendererType)} **${text}**${visualSuffix}${conditionSuffix}.`;
+        }
+        if (description) {
+            return `Vou destacar a coluna **${label}**${visualSuffix} quando **${description}**.`;
+        }
+        return `Vou destacar a coluna **${label}**${visualSuffix}${conditionSuffix}.`;
+    }
+    rendererVisualDetails(visual) {
+        const details = [];
+        const color = this.stringValue(visual['color']);
+        const variant = this.stringValue(visual['variant']);
+        const icon = this.stringValue(visual['icon']);
+        if (color)
+            details.push(`cor ${this.colorLabel(color)}`);
+        if (variant)
+            details.push(`estilo ${this.variantLabel(variant)}`);
+        if (icon)
+            details.push(`icone ${icon}`);
+        return details;
+    }
+    describeConditionalStyle(label, input) {
+        const parts = [`Vou destacar a coluna **${label}**`];
+        const condition = this.conditionPhrase(input['condition'], label);
+        const style = this.styleLabel(this.toRecord(input['style']));
+        const tooltip = this.tooltipLabel(input['tooltip']) ?? this.semanticDescriptionLabel(input['description']);
+        if (!condition && !style && tooltip) {
+            return `Vou adicionar uma dica na coluna **${label}**: **${tooltip}**.`;
+        }
+        if (condition && !style && tooltip) {
+            return `Vou adicionar uma dica na coluna **${label}** quando **${condition}**: **${tooltip}**.`;
+        }
+        if (condition) {
+            parts.push(`quando **${condition}**`);
+        }
+        if (style) {
+            parts.push(`usando ${style}`);
+        }
+        if (tooltip) {
+            parts.push(`com dica **${tooltip}**`);
+        }
+        return `${parts.join(' ')}.`;
+    }
+    variantLabel(value) {
+        const normalized = value.toLowerCase();
+        switch (normalized) {
+            case 'filled':
+            case 'solid':
+                return 'preenchido';
+            case 'outlined':
+            case 'outline':
+                return 'com contorno';
+            case 'soft':
+                return 'suave';
+            default:
+                return value;
+        }
+    }
+    conditionPhrase(condition, currentLabel) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        if (this.isTautologyCondition(record))
+            return null;
+        for (const operator of ['===', '==']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands) || operands.length < 2)
+                continue;
+            const booleanLabel = this.booleanEqualityConditionLabel(operands[0], operands[1], currentLabel)
+                ?? this.booleanEqualityConditionLabel(operands[1], operands[0], currentLabel);
+            if (booleanLabel)
+                return booleanLabel;
+            const literalLabel = this.literalEqualityConditionLabel(operands[0], operands[1], currentLabel)
+                ?? this.literalEqualityConditionLabel(operands[1], operands[0], currentLabel);
+            if (literalLabel)
+                return literalLabel;
+        }
+        return this.conditionLabel(condition);
+    }
+    literalEqualityCondition(condition) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        for (const operator of ['===', '==']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands) || operands.length < 2)
+                continue;
+            const direct = this.literalEqualityOperands(operands[0], operands[1])
+                ?? this.literalEqualityOperands(operands[1], operands[0]);
+            if (direct)
+                return direct;
+        }
+        return null;
+    }
+    literalEqualityOperands(fieldOperand, valueOperand) {
+        const field = this.stringValue(this.toRecord(fieldOperand)?.['var']);
+        if (!field)
+            return null;
+        if (typeof valueOperand !== 'string' && typeof valueOperand !== 'number')
+            return null;
+        return { field, valueLabel: String(valueOperand) };
+    }
+    literalEqualityConditionLabel(fieldOperand, valueOperand, currentLabel) {
+        const equality = this.literalEqualityOperands(fieldOperand, valueOperand);
+        if (!equality)
+            return null;
+        const fieldLabel = this.humanizeField(equality.field);
+        const valueLabel = this.enumValueLabel(equality.valueLabel);
+        const normalizedCurrent = currentLabel ? this.normalizeComparableLabel(currentLabel) : '';
+        const normalizedField = this.normalizeComparableLabel(fieldLabel);
+        if (normalizedCurrent && normalizedCurrent === normalizedField) {
+            return `for ${valueLabel}`;
+        }
+        return `${fieldLabel} for ${valueLabel}`;
+    }
+    isTautologyCondition(condition) {
+        for (const operator of ['===', '==']) {
+            const operands = condition[operator];
+            if (!Array.isArray(operands) || operands.length < 2)
+                continue;
+            if (this.samePrimitiveOperand(operands[0], operands[1]))
+                return true;
+        }
+        return false;
+    }
+    samePrimitiveOperand(left, right) {
+        const leftType = typeof left;
+        return (leftType === 'string' || leftType === 'number' || leftType === 'boolean')
+            && leftType === typeof right
+            && left === right;
+    }
+    booleanEqualityConditionLabel(fieldOperand, valueOperand, currentLabel) {
+        if (typeof valueOperand !== 'boolean')
+            return null;
+        const field = this.stringValue(this.toRecord(fieldOperand)?.['var']);
+        if (!field)
+            return null;
+        const fieldLabel = this.humanizeField(field);
+        const normalizedCurrent = currentLabel ? this.normalizeComparableLabel(currentLabel) : '';
+        const normalizedField = this.normalizeComparableLabel(fieldLabel);
+        const state = valueOperand ? 'ativo' : 'inativo';
+        if (normalizedCurrent && normalizedCurrent === normalizedField) {
+            return `estiver ${state}`;
+        }
+        return `${fieldLabel} estiver ${state}`;
+    }
+    normalizeComparableLabel(value) {
+        return value
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '');
+    }
+    conditionLabel(condition) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        const startsWith = record['startsWith'];
+        if (Array.isArray(startsWith) && startsWith.length >= 2) {
+            const field = this.jsonLogicOperandLabel(startsWith[0]);
+            const value = this.jsonLogicOperandLabel(startsWith[1]);
+            if (field && value) {
+                return `${field} comeca com ${value}`;
+            }
+        }
+        for (const operator of ['>=', '<=', '>', '<', '===', '==']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands) || operands.length < 2)
+                continue;
+            const field = this.jsonLogicOperandLabel(operands[0]);
+            const value = this.jsonLogicOperandLabel(operands[1]);
+            if (field && value) {
+                return `${field} ${operator} ${value}`;
+            }
+        }
+        return null;
+    }
+    jsonLogicOperandLabel(operand) {
+        const record = this.toRecord(operand);
+        const field = this.stringValue(record?.['var']);
+        if (field)
+            return this.humanizeField(field);
+        if (typeof operand === 'string')
+            return operand;
+        if (typeof operand === 'number' || typeof operand === 'boolean')
+            return String(operand);
+        return null;
+    }
+    styleLabel(style) {
+        if (!style)
+            return null;
+        const labels = [];
+        const background = this.stringValue(style['backgroundColor'] ?? style['background-color']);
+        const color = this.stringValue(style['color']);
+        const fontWeight = this.stringValue(style['fontWeight'] ?? style['font-weight']);
+        const opacity = this.stringValue(style['opacity']);
+        const border = this.stringValue(style['border']
+            ?? style['borderLeft']
+            ?? style['border-left']
+            ?? style['borderRight']
+            ?? style['border-right']
+            ?? style['borderTop']
+            ?? style['border-top']
+            ?? style['borderBottom']
+            ?? style['border-bottom']);
+        if (background)
+            labels.push(`fundo ${this.colorLabel(background)}`);
+        if (color)
+            labels.push(`texto ${this.colorLabel(color)}`);
+        if (fontWeight)
+            labels.push('texto em destaque');
+        if (opacity)
+            labels.push(`opacidade ${opacity}`);
+        if (border)
+            labels.push('borda discreta');
+        return labels.length ? labels.join(', ') : null;
+    }
+    describeColumnStyle(label, value, target) {
+        const details = this.styleLabel(this.styleRecord(value));
+        const suffix = details ? ` com ${details}` : '';
+        if (target === 'cabecalho') {
+            return `Vou ajustar o estilo do cabecalho da coluna **${label}**${suffix}.`;
+        }
+        return `Vou ajustar o estilo visual da coluna **${label}**${suffix}.`;
+    }
+    styleRecord(value) {
+        const record = this.toRecord(value);
+        if (record)
+            return record;
+        const style = this.stringValue(value);
+        if (!style)
+            return null;
+        const parsed = {};
+        for (const declaration of style.split(';')) {
+            const separatorIndex = declaration.indexOf(':');
+            if (separatorIndex <= 0)
+                continue;
+            const property = declaration.slice(0, separatorIndex).trim();
+            const cssValue = declaration.slice(separatorIndex + 1).trim();
+            if (property && cssValue)
+                parsed[property] = cssValue;
+        }
+        return Object.keys(parsed).length ? parsed : null;
+    }
+    colorLabel(value) {
+        const normalized = value.toLowerCase();
+        if (normalized === 'warn' || normalized === 'warning') {
+            return 'de alerta';
+        }
+        if (normalized === 'accent') {
+            return 'de destaque';
+        }
+        if (normalized === 'info') {
+            return 'informativa';
+        }
+        if (normalized === 'basic' || normalized === 'neutral' || normalized === 'default') {
+            return 'neutra';
+        }
+        if (normalized === 'success' || normalized.includes('46, 125, 50') || normalized.includes('27, 94, 32') || normalized.includes('green')
+            || normalized.includes('#e8f5e9') || normalized.includes('#1b5e20') || normalized.includes('#a5d6a7')
+            || normalized.includes('#2e7d32')) {
+            return 'verde suave';
+        }
+        if (normalized.includes('255, 152, 0') || normalized.includes('255, 243, 224') || normalized.includes('138, 75, 0') || normalized.includes('orange')
+            || normalized.includes('#fff3e0') || normalized.includes('#ff9800') || normalized.includes('#ffa500') || normalized.includes('#8a4b00')) {
+            return 'laranja suave';
+        }
+        if (normalized.includes('244, 67, 54') || normalized.includes('183, 28, 28') || normalized.includes('red')
+            || normalized.includes('#ffebee') || normalized.includes('#b71c1c')) {
+            return 'vermelho suave';
+        }
+        if (normalized === 'primary' || normalized.includes('blue') || normalized.includes('#1976d2')
+            || normalized.includes('#2196f3')) {
+            return 'azul';
+        }
+        return value;
+    }
+    enumValueLabel(value) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return value;
+        return trimmed
+            .toLowerCase()
+            .split(/[_\s-]+/u)
+            .filter((part) => part.length > 0)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join(' ');
+    }
+    tooltipLabel(value) {
+        const tooltip = this.toRecord(value);
+        const text = this.stringValue(tooltip?.['text']) || this.stringValue(value);
+        return this.cleanReviewTooltipText(text);
+    }
+    semanticDescriptionLabel(value) {
+        const text = this.cleanReviewTooltipText(this.stringValue(value));
+        if (!text)
+            return null;
+        if (/^(adicionar|ajustar|alterar|destacar|aplicar|criar)\b/i.test(text))
+            return null;
+        return text;
+    }
+    cleanReviewTooltipText(value) {
+        const cleaned = value
+            .trim()
+            .replace(/\bcondicao\b/gi, 'condição')
+            .replace(/^adicionar\s+(?:tooltip|dica)\s*(?:dizendo|com\s+texto)?\s*/i, '')
+            .replace(/^adiciona\s+/i, '')
+            .replace(/^aplica(?:r)?\s+/i, '')
+            .replace(/^com\s+tooltip\s*/i, '')
+            .replace(/^tooltip\s*/i, '')
+            .trim();
+        return cleaned || null;
+    }
+    toChatMessages(messages, prompt) {
+        const supported = (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            role: message.role,
+            content: message.text,
+        }))
+            .filter((message) => message.content.trim().length > 0);
+        return supported.length ? supported : [{ role: 'user', content: prompt }];
+    }
+    withCapabilitySystemMessages(messages, contextHints) {
+        const policy = this.buildFilterExpressionSystemPolicy(contextHints);
+        return policy ? [policy, ...messages] : messages;
+    }
+    buildFilterExpressionSystemPolicy(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const runtimeOperations = this.toRecord(authoringContract?.['runtimeOperations']);
+        const filterExpression = this.toRecord(runtimeOperations?.['filterExpression']);
+        if (filterExpression?.['supported'] === true) {
+            return null;
+        }
+        const resourceCapabilities = this.toRecord(this.toRecord(authoringContract?.['consultativeContext'])?.['resourceCapabilities']);
+        const canonicalOperations = this.toRecord(resourceCapabilities?.['canonicalOperations']);
+        if (canonicalOperations?.['filter'] !== true && filterExpression?.['supported'] !== false) {
+            return null;
+        }
+        return {
+            role: 'system',
+            content: [
+                'Praxis table filter capability policy:',
+                '- The current table runtime can materialize table.filter.apply only as simple conjunction criteria over declared filter fields.',
+                '- Resource capability filter=true means the flat /filter DTO is available; it does not mean cross-field OR or nested boolean filter expressions are supported.',
+                '- runtimeOperations.filterExpression.supported is not true for this request.',
+                '- If the user asks for alternatives such as A OR B, cross-field OR, anyOf, oneOf, allOf, or nested boolean groups, do not say it can be applied and do not offer to apply it as a runtime filter.',
+                '- Instead, explain that this resource/runtime contract cannot materialize that compound filter yet and ask the user to choose one simple field/value filter or another supported action such as export of the current selection.',
+            ].join('\n'),
+        };
+    }
+    resolveFilterExpressionSupported(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const runtimeOperations = this.toRecord(authoringContract?.['runtimeOperations']);
+        const filterExpression = this.toRecord(runtimeOperations?.['filterExpression']);
+        if (filterExpression && typeof filterExpression['supported'] === 'boolean') {
+            return filterExpression['supported'];
+        }
+        const resourceCapabilities = this.toRecord(this.toRecord(authoringContract?.['consultativeContext'])?.['resourceCapabilities']);
+        if (resourceCapabilities && typeof resourceCapabilities['filterExpressionSupported'] === 'boolean') {
+            return resourceCapabilities['filterExpressionSupported'];
+        }
+        return null;
+    }
+    toClarificationQuestions(response, request) {
+        const labels = response.questions?.length
+            ? response.questions
+            : response.message
+                ? [response.message]
+                : ['Qual ajuste você quer aplicar na tabela?'];
+        const options = this.toQuickReplies(response, request).map((reply) => ({
+            id: reply.id,
+            label: reply.label,
+            value: typeof reply.value === 'string' && reply.value.trim() ? reply.value.trim() : reply.prompt,
+            displayPrompt: reply.label,
+            description: reply.description ?? undefined,
+            contextHints: reply.contextHints ? { ...reply.contextHints } : undefined,
+        }));
+        return labels.map((label, index) => ({
+            id: `table-clarification-${index + 1}`,
+            type: options.length ? 'single-choice' : 'text',
+            label,
+            allowCustom: true,
+            options,
+        }));
+    }
+    toQuickReplies(response, request) {
+        const payloads = response.optionPayloads ?? [];
+        if (payloads.length) {
+            return payloads
+                .map((option, index) => {
+                const rawLabel = option.label?.trim() || option.value?.trim() || `Opcao ${index + 1}`;
+                const label = this.humanizeClarificationOptionLabel(rawLabel);
+                const canonicalValue = option.value?.trim() || option.example?.trim() || label;
+                return {
+                    id: `option-${index + 1}`,
+                    label,
+                    prompt: label,
+                    value: canonicalValue,
+                    kind: 'clarification-option',
+                    description: this.optionDescription(option),
+                    icon: this.optionIcon(option),
+                    tone: this.optionTone(option),
+                    presentation: this.optionPresentation(option) ?? this.defaultGuidedOptionPresentation(option),
+                    contextHints: this.optionContextHints(option),
+                };
+            });
+        }
+        if (response.type && response.type !== 'clarification') {
+            return [];
+        }
+        return this.enhanceColumnClarificationOptions(response.options ?? [], response, request)
+            .filter((option) => !!option?.trim())
+            .map((option, index) => ({
+            id: `option-${index + 1}`,
+            label: this.humanizeClarificationOptionLabel(option.trim()),
+            prompt: option.trim(),
+            kind: 'clarification-option',
+            presentation: {
+                kind: 'guided-option',
+                icon: 'check',
+                ctaLabel: 'Usar esta opção',
+            },
+        }));
+    }
+    enhanceColumnClarificationOptions(options, response, request) {
+        const normalizedOptions = new Set(options
+            .map((option) => this.normalizeLabel(option))
+            .filter((option) => option.length > 0));
+        const enhanced = [...options];
+        if (normalizedOptions.size && this.optionsRepresentCurrentColumns(normalizedOptions)) {
+            this.appendMissingSchemaFields(enhanced, normalizedOptions);
+            return enhanced;
+        }
+        if (this.isFieldClarification(response)) {
+            this.appendRankedSchemaFieldCandidates(enhanced, normalizedOptions, request, response);
+        }
+        return enhanced;
+    }
+    appendMissingSchemaFields(enhanced, normalizedOptions) {
+        const schemaFields = this.adapter.getSchemaFields?.() ?? [];
+        for (const field of schemaFields) {
+            const record = this.toRecord(field);
+            const name = this.stringValue(record?.['name']);
+            if (!name)
+                continue;
+            const label = this.stringValue(record?.['label']) || this.humanizeField(name);
+            const canonical = this.normalizeLabel(label);
+            const technical = this.normalizeLabel(name);
+            if (normalizedOptions.has(canonical) || normalizedOptions.has(technical))
+                continue;
+            normalizedOptions.add(canonical);
+            normalizedOptions.add(technical);
+            enhanced.push(label);
+        }
+    }
+    appendRankedSchemaFieldCandidates(enhanced, normalizedOptions, request, response) {
+        const text = this.normalizeLabel([
+            request?.prompt,
+            response?.message,
+            ...(response?.questions ?? []),
+            ...(response?.options ?? []),
+        ].filter(Boolean).join(' '));
+        if (!text)
+            return;
+        const candidates = (this.adapter.getSchemaFields?.() ?? [])
+            .map((field) => this.toRecord(field))
+            .filter((field) => !!field)
+            .map((field) => {
+            const name = this.stringValue(field['name']);
+            const label = this.stringValue(field['label']) || this.humanizeField(name);
+            return { name, label, score: this.schemaFieldCandidateScore(name, label, text) };
+        })
+            .filter((field) => field.name && field.score > 0)
+            .sort((left, right) => right.score - left.score || left.label.localeCompare(right.label))
+            .slice(0, 4);
+        for (const candidate of candidates) {
+            const canonical = this.normalizeLabel(candidate.label);
+            const technical = this.normalizeLabel(candidate.name);
+            if (normalizedOptions.has(canonical) || normalizedOptions.has(technical))
+                continue;
+            normalizedOptions.add(canonical);
+            normalizedOptions.add(technical);
+            enhanced.push(candidate.label);
+        }
+    }
+    isFieldClarification(response) {
+        const text = this.normalizeLabel([
+            response?.message,
+            ...(response?.questions ?? []),
+            ...(response?.options ?? []),
+        ].filter(Boolean).join(' '));
+        return text.includes('campo') || text.includes('coluna') || text.includes('field');
+    }
+    schemaFieldCandidateScore(name, label, normalizedText) {
+        let score = 0;
+        const technical = this.normalizeLabel(name);
+        const canonical = this.normalizeLabel(label);
+        if (technical && normalizedText.includes(technical))
+            score += 3;
+        if (canonical && normalizedText.includes(canonical))
+            score += 4;
+        if (technical && canonical && technical !== canonical && canonical.includes(technical))
+            score += 1;
+        return score;
+    }
+    optionsRepresentCurrentColumns(normalizedOptions) {
+        const columns = this.toArray(this.adapter.getCurrentConfig()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column);
+        if (!columns.length)
+            return false;
+        const columnKeys = new Set();
+        for (const column of columns) {
+            const field = this.stringValue(column['field']);
+            const header = this.stringValue(column['header']);
+            if (field)
+                columnKeys.add(this.normalizeLabel(field));
+            if (header)
+                columnKeys.add(this.normalizeLabel(header));
+        }
+        let matched = 0;
+        for (const option of normalizedOptions) {
+            if (columnKeys.has(option))
+                matched += 1;
+        }
+        return matched > 0 && matched === normalizedOptions.size;
+    }
+    humanizeClarificationOptionLabel(label) {
+        return label
+            .replace(/\s*\((?:column|filter|behavior|toolbar|export|appearance)\.[^)]+\)\s*$/u, '')
+            .replace(/\s*—\s*ocultar\s*$/u, ' — ocultar coluna')
+            .replace(/\s*—\s*remover completamente\s*$/u, ' — remover coluna')
+            .replace(/\s*—\s*exibir\s*$/u, ' — exibir coluna')
+            .trim();
+    }
+    defaultGuidedOptionPresentation(option) {
+        const description = this.optionDescription(option);
+        const icon = this.optionIcon(option) || 'check';
+        const tone = this.optionTone(option);
+        return {
+            kind: 'guided-option',
+            icon,
+            tone,
+            description,
+            ctaLabel: 'Usar esta opção',
+        };
+    }
+    optionContextHints(option) {
+        return this.toRecord(option.contextHints);
+    }
+    optionPresentation(option) {
+        const hints = this.optionContextHints(option);
+        return this.toRecord(hints?.['presentation']);
+    }
+    optionDescription(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['description'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    optionIcon(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['icon'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    optionTone(option) {
+        const presentation = this.optionPresentation(option);
+        const value = presentation?.['tone'];
+        return typeof value === 'string' && value.trim() ? value.trim() : null;
+    }
+    booleanConditionValue(condition) {
+        const record = this.toRecord(condition);
+        if (!record)
+            return null;
+        for (const operator of ['==', '===']) {
+            const operands = record[operator];
+            if (!Array.isArray(operands))
+                continue;
+            const literal = operands.find((operand) => typeof operand === 'boolean');
+            if (typeof literal === 'boolean')
+                return literal;
+        }
+        return null;
+    }
+    booleanInput(value) {
+        return typeof value === 'boolean' ? value : null;
+    }
+    arrayOfStrings(value) {
+        return Array.isArray(value)
+            ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
+            : [];
+    }
+    toArray(value) {
+        return Array.isArray(value) ? value : [];
+    }
+    formatLabel(value) {
+        const format = this.stringValue(value);
+        if (!format)
+            return 'o formato solicitado';
+        if (format.startsWith('custom|')) {
+            const parts = format.split('|');
+            if (parts.length >= 3 && parts[1] && parts[2])
+                return `${parts[1]}/${parts[2]}`;
+            return 'formato personalizado';
+        }
+        if (format === '000.000.000-00')
+            return 'CPF brasileiro';
+        if (/^BRL\b/u.test(format))
+            return 'moeda brasileira';
+        switch (format) {
+            case 'active-inactive':
+                return 'Ativo/Inativo';
+            case 'yes-no':
+                return 'Sim/Não';
+            case 'true-false':
+                return 'Verdadeiro/Falso';
+            case 'on-off':
+            case 'onoff':
+                return 'Ligado/Desligado';
+            case 'shortDate':
+                return 'data curta';
+            case 'mediumDate':
+                return 'data com mes abreviado';
+            case 'longDate':
+                return 'data por extenso';
+            case 'fullDate':
+                return 'data completa com dia da semana';
+            case 'MMM/yyyy':
+                return 'mes e ano';
+            case 'dd/MM/yyyy':
+                return 'data no padrao brasileiro';
+            case 'yyyy-MM-dd':
+                return 'data ISO';
+            case 'yyyy-MM-dd HH:mm':
+                return 'data e hora';
+            case 'shortTime':
+                return 'hora curta';
+            case 'short':
+                return 'data e hora curtas';
+        }
+        return format;
+    }
+    rendererLabel(value) {
+        switch (value.trim().toLowerCase()) {
+            case 'chip':
+                return 'chip';
+            case 'avatar':
+                return 'avatar';
+            case 'badge':
+                return 'badge';
+            default:
+                return 'indicador visual';
+        }
+    }
+    rendererPluralLabel(value) {
+        switch (value.trim().toLowerCase()) {
+            case 'chip':
+                return 'chips';
+            case 'badge':
+                return 'badges';
+            case 'avatar':
+                return 'avatares';
+            default:
+                return `${this.rendererLabel(value)}s`;
+        }
+    }
+    humanizeField(field) {
+        if (field.trim().toLowerCase() === 'cpf')
+            return 'CPF';
+        return field
+            .replace(/[_-]+/gu, ' ')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .trim()
+            .replace(/^./u, (char) => char.toLocaleUpperCase('pt-BR'));
+    }
+    humanizeFilterField(field) {
+        const normalized = field.trim();
+        if (!normalized)
+            return 'Campo';
+        const catalogLabel = this.filterFieldLabels.get(normalized);
+        if (catalogLabel)
+            return catalogLabel;
+        if (normalized.toLowerCase() === 'cpf')
+            return 'CPF';
+        if (/between$/iu.test(normalized)) {
+            const base = normalized.replace(/Between$/iu, '');
+            return `Faixa de ${this.humanizeField(base).toLocaleLowerCase('pt-BR')}`;
+        }
+        if (/range$/iu.test(normalized)) {
+            const base = normalized.replace(/Range$/iu, '');
+            return `Periodo de ${this.humanizeFilterBase(base).toLocaleLowerCase('pt-BR')}`;
+        }
+        if (/lastDays$/iu.test(normalized)) {
+            const base = normalized.replace(/LastDays$/iu, '');
+            if (this.normalizeLabel(base) === 'data admissao') {
+                return 'Admissões recentes';
+            }
+            return `${this.humanizeFilterBase(base)} recentes`;
+        }
+        if (/IdsIn$/iu.test(normalized)) {
+            return this.pluralizeFilterLabel(this.humanizeField(normalized.replace(/IdsIn$/iu, '')));
+        }
+        return this.humanizeField(normalized);
+    }
+    pluralizeFilterLabel(label) {
+        const normalized = label.trim();
+        if (!normalized)
+            return label;
+        if (/s$/iu.test(normalized))
+            return normalized;
+        if (/ão$/iu.test(normalized))
+            return normalized.replace(/ão$/iu, 'ões');
+        if (/m$/iu.test(normalized))
+            return `${normalized.slice(0, -1)}ns`;
+        if (/l$/iu.test(normalized))
+            return `${normalized.slice(0, -1)}is`;
+        if (/[aeo]$/iu.test(normalized))
+            return `${normalized}s`;
+        return normalized;
+    }
+    extractFilterFieldLabels(entries) {
+        const labels = new Map();
+        for (const field of entries) {
+            labels.set(field.name, field.label);
+        }
+        return labels;
+    }
+    extractFilterFieldCatalogEntries(contextHints) {
+        return this.filterFieldCatalogFields(contextHints)
+            .map((field) => {
+            const record = this.toRecord(field);
+            const name = this.stringValue(record?.['name']);
+            if (!name)
+                return null;
+            const label = this.stringValue(record?.['label']) || this.humanizeFilterField(name);
+            const aliases = Array.isArray(record?.['aliases'])
+                ? record['aliases'].map((alias) => this.stringValue(alias)).filter((alias) => !!alias)
+                : [];
+            const relatedColumnFields = Array.isArray(record?.['relatedColumnFields'])
+                ? record['relatedColumnFields'].map((field) => this.stringValue(field)).filter((field) => !!field)
+                : [];
+            const relatedColumnLabels = Array.isArray(record?.['relatedColumnLabels'])
+                ? record['relatedColumnLabels'].map((label) => this.stringValue(label)).filter((label) => !!label)
+                : [];
+            const controlType = this.stringValue(record?.['controlType']) || undefined;
+            const type = this.stringValue(record?.['type']) || undefined;
+            const criterionKind = this.stringValue(record?.['criterionKind']) || undefined;
+            const criterionValueShape = this.stringValue(record?.['criterionValueShape']) || undefined;
+            return {
+                name,
+                label,
+                aliases,
+                relatedColumnFields,
+                relatedColumnLabels,
+                ...(controlType ? { controlType } : {}),
+                ...(type ? { type } : {}),
+                ...(criterionKind ? { criterionKind } : {}),
+                ...(criterionValueShape ? { criterionValueShape } : {}),
+            };
+        })
+            .filter((entry) => !!entry);
+    }
+    filterFieldCatalogFields(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const componentEditPlan = this.toRecord(authoringContract?.['componentEditPlan']);
+        const nestedCatalog = this.toRecord(componentEditPlan?.['filterFieldCatalog']);
+        const nestedFields = nestedCatalog?.['fields'];
+        if (Array.isArray(nestedFields))
+            return nestedFields;
+        const directCatalog = this.toRecord(authoringContract?.['filterFieldCatalog'])
+            ?? this.toRecord(contextHints?.['filterFieldCatalog']);
+        const directFields = directCatalog?.['fields'];
+        return Array.isArray(directFields) ? directFields : [];
+    }
+    extractSelectedRecordsCount(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const selectedRecordsContext = this.toRecord(consultativeContext?.['selectedRecordsContext'])
+            ?? this.toRecord(contextHints?.['selectedRecordsContext']);
+        const selectedCount = selectedRecordsContext?.['selectedCount'];
+        return typeof selectedCount === 'number' && Number.isFinite(selectedCount)
+            ? Math.max(0, selectedCount)
+            : 0;
+    }
+    extractSelectionDerivedFilterCandidateFields(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const selectedRecordsContext = this.toRecord(consultativeContext?.['selectedRecordsContext'])
+            ?? this.toRecord(contextHints?.['selectedRecordsContext']);
+        const candidates = Array.isArray(selectedRecordsContext?.['filterCandidates'])
+            ? selectedRecordsContext['filterCandidates']
+            : [];
+        return new Set(candidates
+            .map((candidate) => this.stringValue(this.toRecord(candidate)?.['field']))
+            .filter((field) => !!field));
+    }
+    extractSelectedRecordFields(contextHints) {
+        const authoringContract = this.toRecord(contextHints?.['authoringContract']);
+        const consultativeContext = this.toRecord(authoringContract?.['consultativeContext']);
+        const selectedRecordsContext = this.toRecord(consultativeContext?.['selectedRecordsContext'])
+            ?? this.toRecord(contextHints?.['selectedRecordsContext']);
+        const fields = Array.isArray(selectedRecordsContext?.['fields'])
+            ? selectedRecordsContext['fields'].map((field) => this.stringValue(field)).filter((field) => !!field)
+            : [];
+        const sampleRows = Array.isArray(selectedRecordsContext?.['sampleRows'])
+            ? selectedRecordsContext['sampleRows']
+            : [];
+        for (const row of sampleRows) {
+            const record = this.toRecord(row);
+            if (!record)
+                continue;
+            fields.push(...Object.keys(record));
+        }
+        return new Set(fields);
+    }
+    filterEntryHasSelectedRecordSourceField(entry) {
+        const sourceFields = [
+            ...entry.relatedColumnFields,
+            ...entry.aliases,
+        ];
+        return sourceFields.some((field) => this.selectedRecordFieldsForTurn.has(field));
+    }
+    humanizeFilterBase(field) {
+        const label = this.humanizeField(field).replace(/^Data\s+/iu, '');
+        if (this.normalizeLabel(label) === 'admissao')
+            return 'admissão';
+        return label;
+    }
+    normalizeLabel(value) {
+        return value
+            .normalize('NFD')
+            .replace(/\p{Diacritic}/gu, '')
+            .replace(/[_-]+/gu, ' ')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .trim()
+            .toLocaleLowerCase('pt-BR')
+            .replace(/\s+/gu, ' ');
+    }
+    stringValue(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    buildCurrentStateDigest(currentState, dataProfile) {
+        const currentColumns = Array.isArray(currentState['columns'])
+            ? currentState['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column)
+            : [];
+        const columns = currentColumns.length
+            ? currentColumns
+                .map((column) => column['field'])
+                .filter((field) => typeof field === 'string' && field.length > 0)
+            : undefined;
+        const columnOrder = currentColumns
+            .map((column, index) => {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                return null;
+            return {
+                field,
+                index,
+                ...(this.stringValue(column['header']) ? { header: this.stringValue(column['header']) } : {}),
+                ...(typeof column['order'] === 'number' ? { order: column['order'] } : {}),
+            };
+        })
+            .filter((column) => !!column);
+        const rowCount = typeof dataProfile?.['rowCount'] === 'number' ? dataProfile['rowCount'] : undefined;
+        return {
+            ...(columns?.length ? { columns } : {}),
+            ...(columnOrder.length ? { columnOrder } : {}),
+            ...(rowCount !== undefined ? { rowCount } : {}),
+        };
+    }
+    optionalJsonObject(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const object = this.toAiJsonObject(value);
+        return Object.keys(object).length ? object : undefined;
+    }
+    async prepareAuthoringContext() {
+        const adapter = this.adapter;
+        await adapter.prepareAuthoringContext?.();
+    }
+    mergeJsonObjects(base, overlay) {
+        if (!base)
+            return overlay;
+        if (!overlay)
+            return base;
+        return {
+            ...base,
+            ...overlay,
+        };
+    }
+    toAiJsonObject(value) {
+        const record = this.toRecord(value);
+        if (!record) {
+            return {};
+        }
+        try {
+            return JSON.parse(JSON.stringify(record));
+        }
+        catch {
+            return {};
+        }
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+}
+
+export { TableAgenticAuthoringTurnFlow };