@praxisui/table 8.0.0-beta.84 → 8.0.0-beta.86

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

@@ -1,3536 +0,0 @@
-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.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 normalizedExecutable = this.normalizeBulkRouteSelectionPayload(compiledExecutable, request);
-                const warnings = [
-                    ...(response.warnings ?? []),
-                    ...(normalizedExecutable.warnings ?? []),
-                ];
-                const executableResponse = {
-                    ...response,
-                    patch: normalizedExecutable.patch,
-                    warnings: warnings.length ? warnings : undefined,
-                };
-                delete executableResponse.type;
-                return executableResponse;
-            }
-            if (compiledExecutable?.type === 'error') {
-                const continuedInvalidExecutable = this.selectedRecordSurfaceRuntimeOperationForInvalidExecutable(response, request, compiledExecutable.warnings);
-                if (continuedInvalidExecutable) {
-                    return continuedInvalidExecutable;
-                }
-                const continuedBulkRouteAction = this.bulkRouteActionPlanForInvalidExecutable(response, request, compiledExecutable.warnings);
-                if (continuedBulkRouteAction) {
-                    return this.compileAdapterResponse(continuedBulkRouteAction, request);
-                }
-                return {
-                    type: 'error',
-                    message: compiledExecutable.message || 'O componentEditPlan da tabela nao passou na validacao de capacidades.',
-                    warnings: compiledExecutable.warnings,
-                };
-            }
-            const continuedSurfaceRowActionFromInfo = this.selectedRecordSurfaceRowActionPlanForInfo(response, request);
-            if (continuedSurfaceRowActionFromInfo) {
-                return this.compileAdapterResponse(continuedSurfaceRowActionFromInfo, request);
-            }
-            const continuedSurfaceRuntimeOperation = this.selectedRecordSurfaceRuntimeOperationForInfo(response, request);
-            if (continuedSurfaceRuntimeOperation) {
-                return continuedSurfaceRuntimeOperation;
-            }
-            const continuedBulkRouteNarrative = this.bulkRouteActionPlanForNonExecutableNarrative(response, request);
-            if (continuedBulkRouteNarrative) {
-                return this.compileAdapterResponse(continuedBulkRouteNarrative, request);
-            }
-            const continuedBulkRouteAction = this.bulkRouteActionPlanForClarification(response, request);
-            if (continuedBulkRouteAction) {
-                return this.compileAdapterResponse(continuedBulkRouteAction, request);
-            }
-            const continuedSurfaceRowAction = this.selectedRecordSurfaceRowActionPlanForClarification(response, request);
-            if (continuedSurfaceRowAction) {
-                return this.compileAdapterResponse(continuedSurfaceRowAction, request);
-            }
-            return response;
-        }
-        const rowActionGuidance = this.recordSurfaceRowActionGuidanceForConsult(response, request);
-        if (rowActionGuidance) {
-            return rowActionGuidance;
-        }
-        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) {
-            const continuedBulkRouteNarrative = this.bulkRouteActionPlanForNonExecutableNarrative(response, request);
-            if (continuedBulkRouteNarrative) {
-                return this.compileAdapterResponse(continuedBulkRouteNarrative, request);
-            }
-            return response;
-        }
-        if (compiled.type === 'error') {
-            const continuedBulkRouteAction = this.bulkRouteActionPlanForInvalidExecutable(response, request, compiled.warnings);
-            if (continuedBulkRouteAction) {
-                return this.compileAdapterResponse(continuedBulkRouteAction, request);
-            }
-            const continuedInvalidExecutable = this.selectedRecordSurfaceRuntimeOperationForInvalidExecutable(response, request, compiled.warnings);
-            if (continuedInvalidExecutable) {
-                return continuedInvalidExecutable.componentEditPlan
-                    ? this.compileAdapterResponse(continuedInvalidExecutable, request)
-                    : continuedInvalidExecutable;
-            }
-            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 normalizedCompiled = this.normalizeBulkRouteSelectionPayload(compiled, request);
-        const warnings = [
-            ...(response.warnings ?? []),
-            ...(normalizedCompiled.warnings ?? []),
-        ];
-        return {
-            ...response,
-            ...normalizedCompiled,
-            patch: normalizedCompiled.patch,
-            warnings: warnings.length ? warnings : undefined,
-        };
-    }
-    normalizeBulkRouteSelectionPayload(compiled, request) {
-        if (!compiled?.patch || !request)
-            return compiled;
-        const text = this.normalizeLabel([
-            ...(request.messages ?? [])
-                .filter((message) => message?.role === 'user')
-                .slice(-2)
-                .map((message) => message?.text ?? ''),
-            request.prompt ?? '',
-        ].join(' '));
-        if (!this.textMentionsBulkActionRequest(text))
-            return compiled;
-        const routePath = this.extractRoutePath(text);
-        const patch = this.cloneJson(compiled.patch);
-        const componentEditPlan = compiled.componentEditPlan
-            ? this.cloneJson(compiled.componentEditPlan)
-            : undefined;
-        const bulkActions = patch?.actions?.bulk?.actions;
-        let changed = false;
-        if (Array.isArray(bulkActions)) {
-            for (const action of bulkActions) {
-                if (!action || typeof action !== 'object')
-                    continue;
-                if (this.ensureBulkRouteActionSelectionQuery(action, routePath)) {
-                    changed = true;
-                }
-            }
-        }
-        if (componentEditPlan && this.ensureBulkRouteActionSelectionQueryOnPlan(componentEditPlan, routePath)) {
-            changed = true;
-        }
-        if (!Array.isArray(bulkActions) && !componentEditPlan)
-            return compiled;
-        if (!changed)
-            return compiled;
-        return {
-            ...compiled,
-            ...(componentEditPlan ? { componentEditPlan } : {}),
-            patch,
-            warnings: [
-                ...(compiled.warnings ?? []),
-                'bulk-route-action-selection-query-normalized',
-            ],
-        };
-    }
-    ensureBulkRouteActionSelectionQueryOnPlan(plan, routePath) {
-        if (!plan || typeof plan !== 'object')
-            return false;
-        let changed = false;
-        for (const key of ['input', 'value']) {
-            if (this.ensureBulkRouteActionSelectionQuery(plan[key], routePath)) {
-                changed = true;
-            }
-        }
-        if (Array.isArray(plan.operations)) {
-            for (const operation of plan.operations) {
-                if (!operation || typeof operation !== 'object')
-                    continue;
-                for (const key of ['input', 'value']) {
-                    if (this.ensureBulkRouteActionSelectionQuery(operation[key], routePath)) {
-                        changed = true;
-                    }
-                }
-            }
-        }
-        return changed;
-    }
-    ensureBulkRouteActionSelectionQuery(action, routePath) {
-        if (!action || typeof action !== 'object')
-            return false;
-        let changed = false;
-        if (this.ensureBulkRouteActionGlobalRouteRef(action, routePath)) {
-            changed = true;
-        }
-        if (this.ensureGlobalRouteActionSelectionQuery(action.globalAction)) {
-            changed = true;
-        }
-        if (Array.isArray(action.effects)) {
-            for (const effect of action.effects) {
-                if (effect?.kind === 'global-action' && this.ensureGlobalRouteActionSelectionQuery(effect.globalAction)) {
-                    changed = true;
-                }
-            }
-        }
-        return changed;
-    }
-    ensureBulkRouteActionGlobalRouteRef(action, routePath) {
-        if (!routePath)
-            return false;
-        if (this.hasGlobalRouteActionRef(action))
-            return false;
-        const configuredAction = this.stringValue(action.action);
-        const looksLikeRouteAction = configuredAction === 'navigation.openRoute'
-            || configuredAction === 'navigation.open route'
-            || this.stringValue(action.globalAction?.actionId) === 'navigation.openRoute';
-        const hasRoutePayload = this.stringValue(action.payload?.path)
-            || this.stringValue(action.globalAction?.payload?.path)
-            || routePath;
-        if (!looksLikeRouteAction && !hasRoutePayload)
-            return false;
-        const globalAction = {
-            actionId: 'navigation.openRoute',
-            payload: {
-                path: this.stringValue(action.payload?.path)
-                    || this.stringValue(action.globalAction?.payload?.path)
-                    || routePath,
-                query: { ids: '${runtime.selectedIds}' },
-            },
-        };
-        action.globalAction = globalAction;
-        action.effects = [{ kind: 'global-action', globalAction }];
-        if (!this.stringValue(action.action)) {
-            action.action = 'navigation.openRoute';
-        }
-        return true;
-    }
-    hasGlobalRouteActionRef(action) {
-        if (this.stringValue(action?.globalAction?.actionId) === 'navigation.openRoute') {
-            return true;
-        }
-        if (!Array.isArray(action?.effects))
-            return false;
-        return action.effects.some((effect) => effect?.kind === 'global-action'
-            && this.stringValue(effect.globalAction?.actionId) === 'navigation.openRoute');
-    }
-    ensureGlobalRouteActionSelectionQuery(globalAction) {
-        if (!globalAction || typeof globalAction !== 'object')
-            return false;
-        if (globalAction.actionId !== 'navigation.openRoute')
-            return false;
-        const payload = globalAction.payload;
-        if (!payload || typeof payload !== 'object')
-            return false;
-        if (!this.stringValue(payload.path))
-            return false;
-        if (!payload.query || typeof payload.query !== 'object' || Array.isArray(payload.query)) {
-            payload.query = {};
-        }
-        if (payload.query.ids !== undefined && payload.query.ids !== null && payload.query.ids !== '') {
-            return false;
-        }
-        payload.query.ids = '${runtime.selectedIds}';
-        return true;
-    }
-    recordSurfaceRowActionGuidanceForConsult(response, request) {
-        if (!request || !this.promptAsksRowActionCapabilities(request))
-            return null;
-        if (!this.responseCarriesRowActionAddPlan(response))
-            return null;
-        const surfaces = this.selectedRecordSurfaces(this.contextHintsFor(request));
-        if (!surfaces.length)
-            return null;
-        const labels = [...new Set(surfaces
-                .map((surface) => {
-                const resourceSurface = this.toRecord(surface['resourceSurface']);
-                return this.stringValue(surface['label'])
-                    || this.stringValue(resourceSurface?.['title'])
-                    || this.stringValue(surface['id']);
-            })
-                .filter((label) => !!label))];
-        if (!labels.length)
-            return null;
-        return {
-            type: 'info',
-            message: [
-                'Você pode adicionar botões de linha para superfícies relacionadas declaradas para este recurso.',
-                `Opções disponíveis agora: ${labels.map((label) => `**${label}**`).join(', ')}.`,
-                'Quando quiser materializar uma delas, peça algo como "adicione um botão na linha para abrir Histórico de folha".',
-            ].join(' '),
-            warnings: [
-                'row-action-capability-question-preserved-as-consult',
-                'Residual consult guard acted only after the LLM proposed rowAction.add for a row-action capability-discovery question while declared recordSurfaces were available.',
-            ],
-        };
-    }
-    promptAsksRowActionCapabilities(request) {
-        const currentPrompt = this.normalizeLabel(request.prompt ?? '');
-        const recentUserContext = this.normalizeLabel((request.messages ?? [])
-            .filter((message) => message?.role === 'user')
-            .slice(-2)
-            .map((message) => message?.text ?? '')
-            .join(' '));
-        const text = [recentUserContext, currentPrompt].filter(Boolean).join(' ');
-        if (!this.textMentionsRowActionRequest(text))
-            return false;
-        const asksAvailability = [
-            'quais',
-            'qual',
-            'o que',
-            'que botoes',
-            'que botões',
-            'botoes posso',
-            'botões posso',
-            'acoes disponiveis',
-            'ações disponíveis',
-            'acoes estao disponiveis',
-            'ações estão disponíveis',
-            'posso adicionar',
-            'can i add',
-            'available',
-            'what actions',
-            'which actions',
-            'which buttons',
-        ].some((needle) => text.includes(this.normalizeLabel(needle)));
-        if (!asksAvailability)
-            return false;
-        const explicitMaterialization = [
-            'adicione',
-            'adicionar agora',
-            'crie',
-            'criar agora',
-            'coloque',
-            'aplique',
-            'materialize',
-            'create a',
-            'add a',
-        ].some((needle) => currentPrompt.includes(this.normalizeLabel(needle)));
-        return !explicitMaterialization;
-    }
-    responseCarriesRowActionAddPlan(response) {
-        const record = response;
-        return [
-            this.toRecord(record['componentEditPlan']),
-            this.toRecord(this.toRecord(record['patch'])?.['componentEditPlan']),
-            this.toRecord(record['tableEditPlan']),
-            this.toRecord(record['editPlan']),
-        ].some((plan) => {
-            if (!plan)
-                return false;
-            if (this.stringValue(plan['operationId']) === 'rowAction.add')
-                return true;
-            const operations = Array.isArray(plan['operations']) ? plan['operations'] : [];
-            return operations.some((operation) => this.stringValue(this.toRecord(operation)?.['operationId']) === 'rowAction.add');
-        });
-    }
-    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 hasSelectedRecords = this.selectedRecordsCountForTurn > 0;
-        const source = hasSelectedRecords
-            ? 'selected-record-surface-row-action-continued-from-clarification'
-            : 'record-surface-row-action-continued-from-clarification';
-        const warning = hasSelectedRecords
-            ? (clarificationKind === 'technical'
-                ? 'selected-record-surface-row-action-continued-from-technical-clarification'
-                : 'selected-record-surface-row-action-continued-from-generic-clarification')
-            : 'record-surface-row-action-continued-from-clarification';
-        const warningDetail = clarificationKind === 'technical'
-            ? `Residual continuity guard acted only after LLM asked for technical row-action details while declared recordSurfaces${hasSelectedRecords ? ' 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.';
-        const rowActionResponse = this.buildSelectedRecordSurfaceRowActionResponse(ranked[0].surface, source, warning, warningDetail);
-        if (!rowActionResponse)
-            return null;
-        // 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 rowActionResponse;
-    }
-    selectedRecordSurfaceRowActionPlanForInfo(response, request) {
-        if (response.type !== 'info' || !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 responseText = this.normalizeLabel([
-            response.message ?? '',
-            response.explanation ?? '',
-        ].join(' '));
-        if (!this.textMentionsSurfaceOpenCommitment(responseText) && !this.textMentionsRowActionRequest(responseText)) {
-            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} ${responseText}`, 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;
-        }
-        // Residual continuity guard: this runs only after the LLM has already
-        // answered an info turn for a row-button request but failed to emit the
-        // manifest-backed rowAction.add envelope. The target is ranked from the
-        // governed recordSurfaces catalog plus LLM-authored evidence.
-        return this.buildSelectedRecordSurfaceRowActionResponse(ranked[0].surface, 'selected-record-surface-row-action-info-continuity-guard', 'selected-record-surface-row-action-continued-from-info', 'Residual continuity guard acted only after LLM resolved a declared recordSurface in an info answer for a row-action request without emitting rowAction.add.');
-    }
-    selectedRecordSurfaceRuntimeOperationForInfo(response, request) {
-        if (response.type !== 'info' || !request)
-            return null;
-        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
-        if (!this.textMentionsRecordSurfaceOpenRequest(normalizedPrompt))
-            return null;
-        const responseText = this.normalizeLabel([
-            response.message ?? '',
-            response.explanation ?? '',
-        ].join(' '));
-        if (!this.textMentionsSurfaceOpenCommitment(responseText))
-            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} ${responseText}`, 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 surfaceId = this.stringValue(surface['id']);
-        if (!surfaceId)
-            return null;
-        const resourceSurface = this.toRecord(surface['resourceSurface']);
-        const surfaceLabel = this.stringValue(surface['label'])
-            || this.stringValue(resourceSurface?.['title'])
-            || this.humanizeField(surfaceId);
-        // Residual continuity guard: this runs only after the LLM already resolved
-        // a declared recordSurface in an info answer but failed to emit the runtime
-        // operation required by the user request. Ranking uses the governed
-        // recordSurfaces catalog plus the LLM-authored answer, not primary local
-        // command routing.
-        return {
-            type: 'patch',
-            patch: {
-                tableRuntimeOperations: {
-                    source: 'selected-record-surface-info-continuity-guard',
-                    operations: [{
-                            operationId: 'dynamicPage.surface.open',
-                            input: {
-                                surfaceId,
-                                surfaceLabel,
-                                source: 'selected-records',
-                            },
-                        }],
-                },
-            },
-            explanation: `Vou abrir a superfície relacionada ${surfaceLabel}.`,
-            warnings: [
-                'selected-record-surface-info-continued-to-runtime-operation',
-                'Residual continuity guard acted only after LLM resolved a declared recordSurface in an info answer without emitting the required runtime operation.',
-            ],
-        };
-    }
-    selectedRecordSurfaceRuntimeOperationForInvalidExecutable(response, request, warnings = []) {
-        if (!request || !this.responseMayContainExecutableEnvelope(response))
-            return null;
-        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
-        const normalizedConversation = this.normalizeLabel([
-            ...(request.messages ?? []).slice(-8).map((message) => message?.text ?? ''),
-            request.prompt ?? '',
-        ].join(' '));
-        const requestText = `${normalizedPrompt} ${normalizedConversation}`;
-        if (!this.textMentionsRecordSurfaceOpenRequest(requestText))
-            return null;
-        if (this.promptRequestsSimilarRecords(requestText))
-            return null;
-        const contextHints = this.contextHintsFor(request);
-        const surfaces = this.selectedRecordSurfaces(contextHints);
-        if (!surfaces.length)
-            return null;
-        const responseEvidence = this.normalizeLabel([
-            response.message ?? '',
-            response.explanation ?? '',
-            ...(response.questions ?? []),
-            ...warnings,
-            this.stringifySurfaceEvidence(response),
-        ].join(' '));
-        const ranked = surfaces
-            .map((surface) => ({
-            surface,
-            score: this.selectedRecordSurfacePromptScore(`${requestText} ${responseEvidence}`, 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;
-        }
-        if (this.textMentionsRowActionRequest(requestText)) {
-            const rowActionResponse = this.buildSelectedRecordSurfaceRowActionResponse(ranked[0].surface, 'selected-record-surface-row-action-invalid-executable-continuity-guard', 'selected-record-surface-row-action-continued-from-invalid-executable', 'Residual continuity guard acted only after LLM emitted an executable envelope that failed table component capability validation for a row-action request while a declared recordSurface uniquely matched the selected-record request.');
-            if (rowActionResponse)
-                return rowActionResponse;
-        }
-        const surface = ranked[0].surface;
-        const surfaceId = this.stringValue(surface['id']);
-        if (!surfaceId)
-            return null;
-        const resourceSurface = this.toRecord(surface['resourceSurface']);
-        const surfaceLabel = this.stringValue(surface['label'])
-            || this.stringValue(resourceSurface?.['title'])
-            || this.humanizeField(surfaceId);
-        // Residual executable guard: this runs only after the LLM already authored
-        // an executable envelope that failed component capability validation. The
-        // surface target is ranked from declared recordSurfaces plus LLM-authored
-        // evidence, so this does not become primary command routing by text.
-        return {
-            type: 'patch',
-            patch: {
-                tableRuntimeOperations: {
-                    source: 'selected-record-surface-invalid-executable-continuity-guard',
-                    operations: [{
-                            operationId: 'dynamicPage.surface.open',
-                            input: {
-                                surfaceId,
-                                surfaceLabel,
-                                source: 'selected-records',
-                            },
-                        }],
-                },
-            },
-            explanation: `Vou abrir a superfície relacionada ${surfaceLabel}.`,
-            warnings: [
-                'selected-record-surface-invalid-executable-continued-to-runtime-operation',
-                'Residual continuity guard acted only after LLM emitted an executable envelope that failed table component capability validation while a declared recordSurface uniquely matched the selected-record request.',
-            ],
-        };
-    }
-    buildSelectedRecordSurfaceRowActionResponse(surface, source, warning, warningDetail) {
-        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),
-        };
-        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,
-                source,
-            },
-            explanation: `Vou criar um botão em cada linha para abrir ${surfaceLabel}.`,
-            warnings: [warning, warningDetail],
-        };
-    }
-    bulkRouteActionPlanForClarification(response, request) {
-        if (response.type !== 'clarification' || !request)
-            return null;
-        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
-        if (!this.textMentionsBulkActionRequest(normalizedPrompt))
-            return null;
-        if (!this.textMentionsRecordSurfaceOpenRequest(normalizedPrompt))
-            return null;
-        const routePath = this.extractRoutePath(request.prompt ?? '');
-        if (!routePath)
-            return null;
-        const clarificationKind = this.globalActionClarificationKind(response);
-        if (!clarificationKind)
-            return null;
-        return this.buildBulkRouteActionPlan(routePath, 'bulk-route-action-continued-from-clarification', [
-            'bulk-route-action-continued-from-technical-clarification',
-            'Residual continuity guard acted only after LLM asked for technical bulk route details while a route path and selected-record bulk action intent were already grounded.',
-        ]);
-    }
-    bulkRouteActionPlanForInvalidExecutable(response, request, validationWarnings = []) {
-        if (!request)
-            return null;
-        if (!response.componentEditPlan && !response.patch)
-            return null;
-        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
-        if (!this.textMentionsBulkActionRequest(normalizedPrompt))
-            return null;
-        if (!this.textMentionsRecordSurfaceOpenRequest(normalizedPrompt))
-            return null;
-        const routePath = this.extractRoutePath(request.prompt ?? '');
-        if (!routePath)
-            return null;
-        return this.buildBulkRouteActionPlan(routePath, 'bulk-route-action-continued-from-invalid-executable', [
-            ...validationWarnings,
-            'bulk-route-action-continued-from-invalid-executable',
-            'Residual continuity guard acted only after LLM proposed an invalid executable table plan while route path and selected-record bulk action intent were already grounded.',
-        ]);
-    }
-    bulkRouteActionPlanForNonExecutableNarrative(response, request) {
-        if (!request)
-            return null;
-        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
-        if (!this.textMentionsBulkActionRequest(normalizedPrompt))
-            return null;
-        if (!this.textMentionsRecordSurfaceOpenRequest(normalizedPrompt))
-            return null;
-        const routePath = this.extractRoutePath(request.prompt ?? '');
-        if (!routePath)
-            return null;
-        const narrative = this.normalizeLabel([
-            response.message ?? '',
-            response.explanation ?? '',
-            ...(response.warnings ?? []),
-        ].join(' '));
-        const hasCanonicalDecision = this.normalizedTextIncludesAny(narrative, ['componentEditPlan', 'component edit plan'])
-            && this.normalizedTextIncludesAny(narrative, ['bulkAction.add', 'bulk action.add'])
-            && this.normalizedTextIncludesAny(narrative, ['navigation.openRoute', 'navigation.open route'])
-            && this.normalizedTextIncludesAny(narrative, ['selectedIds', 'selected ids', 'runtime.selectedIds']);
-        if (!hasCanonicalDecision)
-            return null;
-        return this.buildBulkRouteActionPlan(routePath, 'bulk-route-action-continued-from-non-executable-narrative', [
-            'bulk-route-action-continued-from-non-executable-narrative',
-            'Residual continuity guard acted only after LLM described the canonical bulkAction.add/navigation.openRoute decision without returning an executable componentEditPlan envelope.',
-        ]);
-    }
-    buildBulkRouteActionPlan(routePath, source, warnings) {
-        const actionId = `open-${this.slugifyActionId(routePath)}-selected`;
-        const label = this.humanizeBulkRouteActionLabel(routePath);
-        const globalAction = {
-            actionId: 'navigation.openRoute',
-            payload: {
-                path: routePath,
-                query: { ids: '${runtime.selectedIds}' },
-            },
-        };
-        const bulkAction = {
-            id: actionId,
-            label,
-            action: 'navigation.openRoute',
-            icon: 'route',
-            globalAction,
-            effects: [
-                {
-                    kind: 'global-action',
-                    globalAction,
-                },
-            ],
-        };
-        // Residual continuity guard: this executes only after the LLM already
-        // resolved the turn as a clarification, while the user-provided route path
-        // and the declared bulkAction.add/globalAction contract are sufficient to
-        // materialize the operation. It grounds payload details in canonical runtime
-        // selection templates instead of using local text as primary intent routing.
-        return {
-            type: 'patch',
-            componentEditPlan: {
-                kind: 'praxis.table.component-edit-plan',
-                version: '1.0',
-                componentId: 'praxis-table',
-                operationId: 'bulkAction.add',
-                changeKind: 'add_bulk_action',
-                capabilityPath: 'actions.bulk.actions[]',
-                input: bulkAction,
-                value: bulkAction,
-                source,
-            },
-            explanation: `Vou adicionar a ação ${label} para os registros selecionados.`,
-            warnings,
-        };
-    }
-    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',
-            'mais detalhes sobre openmode',
-            'mais detalhes sobre open mode',
-            'mais detalhes sobre iconorstyle',
-            'mais detalhes sobre appliesto',
-            'mais detalhes sobre actionlabel',
-            'mais detalhes sobre openbehavior',
-            'mais detalhes sobre actionbehavior',
-            'mais detalhes sobre destinationsurface',
-            'mais detalhes sobre iconlabel',
-            'qual condicao deve ser usada',
-            'qual condição deve ser usada',
-            'mais detalhes sobre action behavior',
-            'o alvo do ajuste',
-            'nome que voce prefere',
-            'nome que você prefere',
-            'openmode',
-            'open mode',
-            'iconorstyle',
-            'appliesto',
-            'actionlabel',
-            'openbehavior',
-            'actionbehavior',
-            'destinationsurface',
-            'iconlabel',
-        ].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;
-    }
-    globalActionClarificationKind(response) {
-        const text = this.normalizeLabel([
-            response.message ?? '',
-            response.explanation ?? '',
-            ...(response.questions ?? []),
-        ].join(' '));
-        if ([
-            'recordidparamname',
-            'record id param name',
-            'o alvo do ajuste',
-            'qual formato aplicar',
-            'mais detalhes sobre target',
-            'mais detalhes sobre payload',
-            'mais detalhes sobre route',
-            'mais detalhes sobre openmode',
-            'mais detalhes sobre open mode',
-        ].some((needle) => text.includes(this.normalizeLabel(needle)))) {
-            return 'technical';
-        }
-        return null;
-    }
-    textMentionsRowActionRequest(normalizedText) {
-        return [
-            'botao',
-            'acao de linha',
-            'acoes de linha',
-            'acao por registro',
-            'acoes por registro',
-            'nas linhas',
-            'por linha',
-            'em cada linha',
-        ].some((needle) => normalizedText.includes(needle));
-    }
-    textMentionsBulkActionRequest(normalizedText) {
-        return [
-            'acao em lote',
-            'acoes em lote',
-            'registros selecionados',
-            'linhas selecionadas',
-            'selecionados',
-            'bulk action',
-        ].some((needle) => normalizedText.includes(this.normalizeLabel(needle)));
-    }
-    normalizedTextIncludesAny(normalizedText, needles) {
-        return needles.some((needle) => normalizedText.includes(this.normalizeLabel(needle)));
-    }
-    extractRoutePath(text) {
-        const match = String(text || '').match(/(?:^|\s)(\/[A-Za-z0-9._~:/?#[\]@!$&'()*+,;=%-]+)(?=$|\s|[,.])/u);
-        return match?.[1]?.replace(/[,.]$/u, '') ?? '';
-    }
-    humanizeBulkRouteActionLabel(path) {
-        const segments = path
-            .split(/[?#]/u)[0]
-            .split('/')
-            .map((segment) => segment.trim())
-            .filter(Boolean);
-        const lastSegments = segments.slice(-2);
-        const label = lastSegments
-            .map((segment) => this.humanizeField(segment))
-            .join(' - ');
-        return label ? `Abrir ${label}` : 'Abrir rota dos selecionados';
-    }
-    textMentionsRecordSurfaceOpenRequest(normalizedText) {
-        return [
-            'abrir',
-            'abre',
-            'abra',
-            'mostra',
-            'mostrar',
-            'mostre',
-            'exibir',
-            'exiba',
-            'ver',
-            'consulta',
-            'consultar',
-        ].some((needle) => normalizedText.includes(needle));
-    }
-    textMentionsSurfaceOpenCommitment(normalizedText) {
-        return [
-            'vou abrir',
-            'abrindo',
-            'abrir a superficie',
-            'abrir a superfície',
-            'superficie a abrir',
-            'superfície a abrir',
-        ].some((needle) => normalizedText.includes(this.normalizeLabel(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 'bulkAction.add':
-            case 'add_bulk_action':
-                return `Vou adicionar a acao **${this.stringValue(input['label']) || this.stringValue(input['id']) || 'solicitada'}** para os registros selecionados.`;
-            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() : '';
-    }
-    stringifySurfaceEvidence(value) {
-        try {
-            return JSON.stringify(value)?.slice(0, 4000) ?? '';
-        }
-        catch {
-            return '';
-        }
-    }
-    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 {};
-        }
-    }
-    cloneJson(value) {
-        try {
-            return JSON.parse(JSON.stringify(value));
-        }
-        catch {
-            return value;
-        }
-    }
-    toRecord(value) {
-        return value && typeof value === 'object' && !Array.isArray(value)
-            ? value
-            : null;
-    }
-}
-
-export { TableAgenticAuthoringTurnFlow };