@praxisui/table 8.0.0-beta.98 → 9.0.0-beta.0

package/fesm2022/{praxisui-table-table-agentic-authoring-turn-flow-DZyPFYjL.mjs → praxisui-table-table-agentic-authoring-turn-flow-DL9l0XF7.mjs}

@@ -1,8 +1,9 @@
-import { firstValueFrom, Observable } from 'rxjs';
+import { Observable, firstValueFrom } from 'rxjs';
 
 class TableAgenticAuthoringTurnFlow {
     adapter;
     aiApi;
+    turnClient;
     mode = 'agentic-authoring';
     filterFieldLabels = new Map();
     filterFieldCatalogEntries = [];
@@ -19,9 +20,10 @@ class TableAgenticAuthoringTurnFlow {
     streamTerminalReconnectLimit = 2;
     selectedRecordStreamTerminalWatchdogMs = 45_000;
     selectedRecordSurfaceStreamTerminalWatchdogMs = 18_000;
-    constructor(adapter, aiApi) {
+    constructor(adapter, aiApi, turnClient) {
         this.adapter = adapter;
         this.aiApi = aiApi;
+        this.turnClient = turnClient;
     }
     submit(request) {
         const prompt = (request.prompt ?? '').trim();
@@ -50,7 +52,8 @@ class TableAgenticAuthoringTurnFlow {
             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;
+            const baseContextHints = this.mergeJsonObjects(this.mergeJsonObjects(this.optionalJsonObject(this.adapter.getAuthoringContext?.()), this.tableConversationMemoryHints(request)), this.optionalJsonObject(request.action?.contextHints)) ?? null;
+            const contextHints = this.mergeJsonObjects(baseContextHints ?? undefined, this.componentPresentationTargetGroundingHints(prompt) ?? undefined) ?? baseContextHints;
             this.filterFieldCatalogEntries = this.extractFilterFieldCatalogEntries(contextHints);
             this.filterFieldLabels = this.extractFilterFieldLabels(this.filterFieldCatalogEntries);
             this.selectionDerivedFilterCandidateFields = this.extractSelectionDerivedFilterCandidateFields(contextHints);
@@ -82,11 +85,100 @@ class TableAgenticAuthoringTurnFlow {
             };
         };
         const progressPrompt = this.progressPromptFor(request, prompt);
+        if (this.canUseAgenticTurnStream()) {
+            return this.submitViaAgenticStream(request, progressPrompt, currentState, componentId, run);
+        }
         if (this.canUsePatchStream()) {
             return this.submitViaStream(request, progressPrompt, currentState, componentId, run);
         }
         return this.submitViaSnapshot(request, currentState, run);
     }
+    submitViaAgenticStream(request, prompt, currentState, componentId, buildRequest) {
+        return new Observable((subscriber) => {
+            let closed = false;
+            let subscription = null;
+            const close = () => {
+                closed = true;
+                subscription?.unsubscribe();
+                subscription = null;
+            };
+            const emitProgress = (statusText) => {
+                if (closed || !statusText.trim())
+                    return;
+                subscriber.next({
+                    state: 'processing',
+                    phase: 'contextualize',
+                    statusText,
+                    canApply: false,
+                });
+            };
+            const fallbackToSnapshot = async () => {
+                if (closed)
+                    return;
+                try {
+                    emitProgress(this.buildSnapshotFallbackMessage(prompt, componentId));
+                    const result = await this.submitViaSnapshot(request, currentState, buildRequest);
+                    if (!closed) {
+                        subscriber.next(result);
+                        subscriber.complete();
+                    }
+                }
+                catch (error) {
+                    if (!closed) {
+                        subscriber.next(this.toAssistantErrorResult(error));
+                        subscriber.complete();
+                    }
+                }
+                finally {
+                    close();
+                }
+            };
+            void (async () => {
+                try {
+                    emitProgress(this.buildInitialProgressMessage(prompt, componentId));
+                    const { patchRequest, contextHints } = await buildRequest();
+                    const localResponse = this.localRecommendedIntentResponse(request, contextHints ?? null);
+                    if (localResponse) {
+                        subscriber.next(this.toTurnResult(localResponse, request));
+                        subscriber.complete();
+                        close();
+                        return;
+                    }
+                    if (this.shouldUseSelectedRecordSurfaceSnapshotFallback(contextHints ?? null)) {
+                        await fallbackToSnapshot();
+                        return;
+                    }
+                    subscription = this.turnClient?.streamEvents(this.toAgenticAuthoringTurnRequest(patchRequest), {
+                        resultTimeoutMs: this.streamTerminalWatchdogDelay(contextHints ?? null),
+                        streamTimeoutMs: this.streamTerminalWatchdogDelay(contextHints ?? null),
+                    }).subscribe({
+                        next: (event) => {
+                            if (closed)
+                                return;
+                            const terminal = this.toAgenticStreamTurnResult(event, request, currentState);
+                            if (terminal) {
+                                subscriber.next(terminal);
+                                subscriber.complete();
+                                close();
+                                return;
+                            }
+                            const progress = this.toAgenticStreamProgress(event, prompt, componentId);
+                            if (progress) {
+                                emitProgress(progress);
+                            }
+                        },
+                        error: () => {
+                            void fallbackToSnapshot();
+                        },
+                    }) ?? null;
+                }
+                catch {
+                    await fallbackToSnapshot();
+                }
+            })();
+            return () => close();
+        });
+    }
     async submitViaSnapshot(request, currentState, buildRequest) {
         const { patchRequest, contextHints } = await buildRequest();
         const localResponse = this.localRecommendedIntentResponse(request, contextHints ?? null);
@@ -317,6 +409,14 @@ class TableAgenticAuthoringTurnFlow {
         const guidedSelectedRecordsFilter = this.localGuidedSelectedRecordsFilterResponse(request, contextHints);
         if (guidedSelectedRecordsFilter)
             return guidedSelectedRecordsFilter;
+        if (this.selectedRecordLocalReadonlyAnalysisRequested(request)
+            && this.selectedRecordSampleRows(contextHints).length > 0) {
+            return this.selectedRecordsReadonlyInfoResponse(request, contextHints);
+        }
+        if (this.selectedRecordGenericCommonalityAnalysisRequested(request)
+            && this.selectedRecordSampleRows(contextHints).length > 0) {
+            return this.selectedRecordsGuidedAnalysisResponse(request, contextHints);
+        }
         const selectedRecordDerivedFilter = this.localSelectedRecordDerivedFilterResponse(request, contextHints);
         if (selectedRecordDerivedFilter)
             return selectedRecordDerivedFilter;
@@ -394,15 +494,7 @@ class TableAgenticAuthoringTurnFlow {
             };
         }
         if (this.selectedRecordReadOnlyAnalysisRequested(request)) {
-            return {
-                type: 'info',
-                sessionId: request.sessionId,
-                message: this.selectedRecordsAnalyticalSummary(contextHints),
-                warnings: [
-                    'recommended-intent-local-selected-records-analysis',
-                    'Resposta informativa gerada a partir do recommendedIntent canonico table.selection.analyze e selectedRecordsContext.sampleRows; nao houve roteamento textual primario.',
-                ],
-            };
+            return this.selectedRecordsReadonlyInfoResponse(request, contextHints);
         }
         const candidates = this.selectedRecordFilterCandidates(contextHints);
         const fields = candidates
@@ -429,6 +521,17 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    selectedRecordsReadonlyInfoResponse(request, contextHints) {
+        return {
+            type: 'info',
+            sessionId: request.sessionId,
+            message: this.selectedRecordsAnalyticalSummary(contextHints),
+            warnings: [
+                'recommended-intent-local-selected-records-analysis',
+                'Resposta informativa gerada a partir do selectedRecordsContext.sampleRows e de uma intencao consultiva ja contextualizada; nao houve roteamento textual primario.',
+            ],
+        };
+    }
     localGuidedRuntimeOperationResponse(request, contextHints) {
         const runtimeOperation = this.toRecord(contextHints?.['tableRuntimeOperation']);
         const operationId = this.stringValue(runtimeOperation?.['operationId']);
@@ -2022,6 +2125,40 @@ class TableAgenticAuthoringTurnFlow {
         return typeof this.aiApi.startPatchStream === 'function'
             && typeof this.aiApi.connectPatchStream === 'function';
     }
+    canUseAgenticTurnStream() {
+        return typeof this.turnClient?.streamEvents === 'function';
+    }
+    toAgenticAuthoringTurnRequest(patchRequest) {
+        return {
+            ...patchRequest,
+            targetApp: 'praxis-ui-angular',
+            targetComponentId: patchRequest.componentId,
+            currentPage: patchRequest.currentState,
+            contextHints: patchRequest.contextHints ?? null,
+        };
+    }
+    toAgenticStreamTurnResult(event, request, currentState) {
+        if (event.kind !== 'stream-event') {
+            return null;
+        }
+        return this.toTerminalStreamResult(event.event, request, currentState);
+    }
+    toAgenticStreamProgress(event, prompt, componentId) {
+        if (event.kind === 'stream-started') {
+            return this.buildStreamProgressMessage('status', { message: 'Stream iniciado.', phase: 'request' }, prompt, componentId);
+        }
+        if (event.kind === 'stream-lifecycle') {
+            return this.buildStreamProgressMessage('status', {
+                message: event.statusText,
+                phase: event.phase,
+                ...(event.diagnostics ?? {}),
+            }, prompt, componentId);
+        }
+        if (event.event.type === 'heartbeat') {
+            return null;
+        }
+        return this.buildStreamProgressMessage(event.event.type, this.toRecord(event.event.payload) ?? {}, prompt, componentId);
+    }
     toTerminalStreamResult(event, request, currentState) {
         if (!event)
             return null;
@@ -2185,14 +2322,27 @@ class TableAgenticAuthoringTurnFlow {
         });
     }
     retry(request) {
+        const retryAction = this.retryActionFromDiagnostics(request.diagnostics);
         const lastPrompt = [...(request.messages ?? [])].reverse()
             .find((message) => message.role === 'user')?.text;
         return this.submit({
             ...request,
-            prompt: lastPrompt ?? request.prompt,
-            action: { kind: 'retry' },
+            prompt: this.stringValue(retryAction?.['value']) || lastPrompt || request.prompt,
+            action: retryAction
+                ? { ...retryAction, kind: this.stringValue(retryAction['kind']) || 'clarify' }
+                : { kind: 'retry' },
         });
     }
+    retryActionFromDiagnostics(diagnostics) {
+        const retryAction = this.toRecord(diagnostics?.['retryAction']);
+        if (!retryAction)
+            return null;
+        const contextHints = this.toRecord(retryAction['contextHints']);
+        return {
+            ...retryAction,
+            ...(contextHints ? { contextHints } : {}),
+        };
+    }
     toTurnResult(response, request) {
         if (!response) {
             return {
@@ -2257,6 +2407,7 @@ class TableAgenticAuthoringTurnFlow {
         }
         if (response.type === 'error') {
             const message = response.message || 'Falha ao gerar alteração de tabela.';
+            const retryDiagnostics = this.errorRetryDiagnostics(request, response);
             return {
                 state: 'error',
                 phase: 'capture',
@@ -2264,7 +2415,7 @@ class TableAgenticAuthoringTurnFlow {
                 observationId: response.observationId ?? request.observationId ?? null,
                 assistantMessage: message,
                 errorText: message,
-                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+                diagnostics: retryDiagnostics,
             };
         }
         if (response.patch && Object.keys(response.patch).length > 0) {
@@ -2316,10 +2467,26 @@ class TableAgenticAuthoringTurnFlow {
     }
     compileAdapterResponse(response, request) {
         response = this.normalizeCategoricalRendererPalette(response, request);
+        const incompatibleBooleanStatusPresentation = this.incompatibleBooleanStatusPresentationBoundary(response, request);
+        if (incompatibleBooleanStatusPresentation) {
+            return incompatibleBooleanStatusPresentation;
+        }
+        const visualPresentationTargetMismatch = this.visualPresentationTargetMismatchBoundary(response, request);
+        if (visualPresentationTargetMismatch) {
+            return visualPresentationTargetMismatch;
+        }
         response = this.normalizeStatusPresentationPlan(response, request);
         response = this.normalizeNumericBandConditionalStylePlan(response, request);
         response = this.normalizeCompoundColumnPresentationPlan(response, request);
         response = this.normalizeComputedColumnAuxiliaryMaterializations(response);
+        const selectedRecordReadonlyPresentationBoundary = this.selectedRecordReadonlyPresentationBoundaryResponse(response, request);
+        if (selectedRecordReadonlyPresentationBoundary) {
+            return selectedRecordReadonlyPresentationBoundary;
+        }
+        const visualPresentationChoice = this.visualPresentationChoiceClarificationBoundary(response, request);
+        if (visualPresentationChoice) {
+            return visualPresentationChoice;
+        }
         if (response.type === 'clarification' || response.type === 'info' || response.type === 'error') {
             const selectedRecordReadonlyClarificationBoundary = this.selectedRecordReadonlyClarificationBoundaryResponse(response, request);
             if (selectedRecordReadonlyClarificationBoundary) {
@@ -2329,6 +2496,22 @@ class TableAgenticAuthoringTurnFlow {
             if (continuedEarlyColumnPlan) {
                 return this.compileAdapterResponse(continuedEarlyColumnPlan, request);
             }
+            const governedCategoricalSemanticsChoice = this.governedCategoricalSemanticsClarificationBoundary(response);
+            if (governedCategoricalSemanticsChoice) {
+                return governedCategoricalSemanticsChoice;
+            }
+            const governedCategoricalDiscovery = this.governedCategoricalDiscoveryBoundary(response, request);
+            if (governedCategoricalDiscovery) {
+                return governedCategoricalDiscovery;
+            }
+            const canonicalRendererSelectionBoundary = this.canonicalRendererSelectionBoundary(response, request);
+            if (canonicalRendererSelectionBoundary) {
+                return canonicalRendererSelectionBoundary;
+            }
+            const governedCategoricalSelectionBoundary = this.governedCategoricalSelectionBoundary(response, request);
+            if (governedCategoricalSelectionBoundary) {
+                return governedCategoricalSelectionBoundary;
+            }
             const continuedColumnVisibilityPlan = this.columnVisibilityPlanForGroundedClarification(response, request);
             if (continuedColumnVisibilityPlan) {
                 return this.compileAdapterResponse(continuedColumnVisibilityPlan, request);
@@ -2371,7 +2554,7 @@ class TableAgenticAuthoringTurnFlow {
                 if (selectedRecordReadonlyBoundary) {
                     return selectedRecordReadonlyBoundary;
                 }
-                return executableResponse;
+                return this.normalizeGovernedCategoricalSelectionExecutableResponse(executableResponse, request);
             }
             if (compiledExecutable?.type === 'error') {
                 const continuedColumnVisibilityError = this.columnVisibilityPlanForMisroutedSurfaceError(response, request, compiledExecutable);
@@ -2577,7 +2760,93 @@ class TableAgenticAuthoringTurnFlow {
             return visualSurfaceMismatch;
         }
         const openOnlySurfaceRuntimeOperation = this.selectedRecordSurfaceRuntimeOperationForOpenOnlyExecutable(compiledResponse, request);
-        return openOnlySurfaceRuntimeOperation ?? compiledResponse;
+        if (openOnlySurfaceRuntimeOperation)
+            return openOnlySurfaceRuntimeOperation;
+        return this.normalizeGovernedCategoricalSelectionExecutableResponse(compiledResponse, request);
+    }
+    visualPresentationChoiceClarificationBoundary(response, request) {
+        const carriesVisualPayload = (response.optionPayloads ?? [])
+            .some((payload) => this.isVisualPresentationClarificationPayload(payload));
+        if (!carriesVisualPayload)
+            return null;
+        if (!this.promptRequestsPresentationOptions(request?.prompt ?? ''))
+            return null;
+        const message = response.message || 'Encontrei opções de apresentação para essa coluna. Escolha uma opção para aplicar.';
+        return {
+            ...response,
+            type: 'clarification',
+            message,
+            explanation: message,
+            componentEditPlan: undefined,
+            patch: undefined,
+            warnings: [
+                ...(response.warnings ?? []),
+                'visual-presentation-choice-kept-as-clarification',
+            ],
+        };
+    }
+    governedCategoricalSemanticsClarificationBoundary(response) {
+        if (!this.responseHasGovernedCategoricalSemanticsChoice(response))
+            return null;
+        const message = response.message
+            || 'Esta apresentação precisa de uma decisão semântica governada antes de materializar a tabela.';
+        return {
+            ...response,
+            type: 'clarification',
+            message,
+            explanation: message,
+            componentEditPlan: undefined,
+            patch: undefined,
+            warnings: [
+                ...(response.warnings ?? []),
+                'governed-categorical-semantics-choice-kept-as-clarification',
+            ],
+        };
+    }
+    responseHasGovernedCategoricalSemanticsChoice(response) {
+        if ((response.optionPayloads ?? [])
+            .some((payload) => this.isGovernedCategoricalSemanticsChoicePayload(payload))) {
+            return true;
+        }
+        return this.isGovernedCategoricalSemanticsChoiceText([
+            response.message,
+            response.explanation,
+            ...(response.questions ?? []),
+            ...(response.options ?? []),
+        ].filter(Boolean).join(' '));
+    }
+    promptRequestsPresentationOptions(prompt) {
+        const normalized = this.normalizeLabel(prompt);
+        if (!normalized)
+            return false;
+        const asksForOptions = [
+            'opcao',
+            'opcoes',
+            'opção',
+            'opções',
+            'alternativa',
+            'alternativas',
+            'recomenda',
+            'recomende',
+            'sugere',
+            'sugira',
+            'compare',
+        ].some((token) => this.normalizedTextContainsApproxPhrase(normalized, token));
+        if (!asksForOptions)
+            return false;
+        return [
+            'apresentacao',
+            'apresentação',
+            'formatacao',
+            'formatação',
+            'badge',
+            'icone',
+            'ícone',
+            'alinhamento',
+            'duas linhas',
+            'duaslinhas',
+            'visual',
+        ].some((token) => this.normalizedTextContainsApproxPhrase(normalized, token));
     }
     normalizeCategoricalRendererPalette(response, request) {
         const plan = this.toRecord(response.componentEditPlan);
@@ -2707,7 +2976,7 @@ class TableAgenticAuthoringTurnFlow {
     relativeColumnOrderPlanForMisroutedClarification(response, request) {
         if (!request?.prompt)
             return null;
-        const prompt = this.normalizeLabel(request.prompt);
+        const prompt = this.normalizeLabel(request.prompt ?? '');
         const position = this.relativeOrderPosition(prompt);
         if (!position)
             return null;
@@ -4699,6 +4968,8 @@ class TableAgenticAuthoringTurnFlow {
         const responseType = this.stringValue(response.type);
         if (!request || !['clarification', 'info', 'success'].includes(responseType))
             return null;
+        if (this.requestIsCanonicalRendererSelection(request))
+            return null;
         const responseText = [
             response.message ?? '',
             response.explanation ?? '',
@@ -4733,7 +5004,9 @@ class TableAgenticAuthoringTurnFlow {
             ?? this.booleanSimNaoOperationsFromGroundedClarification(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromSingleGroundedBooleanColumn(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromGroundedResponseField(prompt, responseText, columns);
-        const statusPresentationOperations = this.statusPresentationOperationsFromPrompt(prompt, columns);
+        const statusPresentationOperations = this.responseCarriesClarificationChoices(response)
+            ? []
+            : this.statusPresentationOperationsFromPrompt(prompt, columns);
         if (statusPresentationOperations.length) {
             return this.componentEditPlanResponse(statusPresentationOperations, 'Vou ajustar a apresentacao visual do status sem filtrar as linhas.', [
                 ...(response.warnings ?? []),
@@ -4809,6 +5082,9 @@ class TableAgenticAuthoringTurnFlow {
             ]);
         }
         const categoricalRenderer = this.categoricalChipOperationsFromVisualClarification(prompt, responseText, columns);
+        if (categoricalRenderer.length && this.responseHasGovernedCategoricalSemanticsChoice(response)) {
+            return null;
+        }
         if (categoricalRenderer.length) {
             return this.componentEditPlanResponse(categoricalRenderer, 'Vou aplicar chips discretos na coluna indicada.', [
                 ...(response.warnings ?? []),
@@ -4884,6 +5160,14 @@ class TableAgenticAuthoringTurnFlow {
             return response;
         if ((response.warnings ?? []).includes('status-presentation-normalized'))
             return response;
+        if (this.requestIsCanonicalRendererSelection(request))
+            return response;
+        if (this.requestHasGovernedCategoricalSelection(request))
+            return response;
+        if ((response.optionPayloads?.length ?? 0) > 0)
+            return response;
+        if (this.responseHasGovernedCategoricalSemanticsChoice(response))
+            return response;
         const currentConfig = this.adapter.getCurrentConfig?.();
         const columns = Array.isArray(currentConfig?.['columns'])
             ? currentConfig['columns']
@@ -4929,101 +5213,673 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
-    normalizeNumericBandConditionalStylePlan(response, request) {
-        if (!request)
-            return response;
-        if ((response.warnings ?? []).includes('numeric-band-conditional-style-normalized'))
-            return response;
-        const currentConfig = this.adapter.getCurrentConfig?.();
-        const columns = Array.isArray(currentConfig?.['columns'])
-            ? currentConfig['columns']
-                .map((column) => this.toRecord(column))
-                .filter((column) => !!column && !!this.stringValue(column['field']))
-            : [];
-        if (!columns.length)
-            return response;
-        const operations = this.numericBandConditionalStyleOperationsFromPrompt(this.componentPresentationPromptForTurn(request), [
-            response.message,
-            response.explanation,
-            ...(response.questions ?? []),
-        ].join(' '), columns);
-        if (!operations.length)
-            return response;
-        const fields = new Set(operations
-            .map((operation) => this.operationTargetField(operation))
-            .filter((field) => !!field));
-        const originalPlan = this.toRecord(response.componentEditPlan);
-        const originalOperations = this.componentEditOperations(originalPlan)
-            .filter((operation) => {
-            const field = this.operationTargetField(operation);
-            return !(field && fields.has(field) && this.stringValue(operation['operationId']) === 'column.conditionalStyle.add');
-        });
+    requestIsCanonicalRendererSelection(request) {
+        if (this.requestHasGovernedCategoricalSelection(request))
+            return false;
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const requestHints = this.toRecord(request.contextHints);
+        const actionSelection = this.toRecord(this.toRecord(actionHints?.['optionSelected'])?.['selection']);
+        const requestSelection = this.toRecord(this.toRecord(requestHints?.['optionSelected'])?.['selection']);
+        const mode = this.normalizeLabel(this.stringValue(actionSelection?.['mode']) || this.stringValue(requestSelection?.['mode']));
+        if (mode === 'renderer')
+            return true;
+        const prompt = this.normalizeLabel(request.prompt ?? '');
+        return this.normalizedTextIncludesAny(prompt, [
+            'two_lines',
+            'two lines',
+            'two line',
+            'two-line',
+            'twolines',
+            'twoline',
+            'duas linhas',
+            'duas_linhas',
+            'duaslinhas',
+            'segunda linha',
+        ]);
+    }
+    canonicalRendererSelectionBoundary(response, request) {
+        if (!request || !this.requestIsCanonicalRendererSelection(request))
+            return null;
+        if (response.type === 'error')
+            return null;
+        if (this.responseCarriesClarificationChoices(response))
+            return null;
+        const selection = this.canonicalRendererSelection(request);
+        const field = this.stringValue(selection?.['field']);
+        if (!field)
+            return null;
+        const hasExecutableEnvelope = this.responseMayContainExecutableEnvelope(response)
+            || this.componentEditOperations(response.componentEditPlan).length > 0
+            || !!this.toRecord(response.patch);
+        if (hasExecutableEnvelope && this.responseTargetsSelectedRendererField(response, field)) {
+            return null;
+        }
+        const label = this.stringValue(request.action?.displayPrompt)
+            || this.stringValue(request.action?.value)
+            || this.stringValue(selection?.['value'])
+            || 'opção selecionada';
+        const header = this.humanizeField(field);
         return {
-            ...response,
-            ...(response.type === 'clarification' || response.type === 'info' ? { type: 'patch' } : {}),
-            componentEditPlan: {
-                ...(originalPlan ?? {}),
-                kind: this.stringValue(originalPlan?.['kind']) || 'praxis.table.component-edit-plan',
-                version: this.stringValue(originalPlan?.['version']) || '1.0',
-                componentId: this.stringValue(originalPlan?.['componentId'])
-                    || this.adapter.componentId
-                    || request.componentId
-                    || 'praxis-table',
-                operations: [...originalOperations, ...operations],
-            },
-            explanation: response.explanation || 'Vou aplicar formatacao condicional em faixas visuais na coluna numerica indicada.',
+            type: 'info',
+            sessionId: response.sessionId,
+            observationId: response.observationId,
+            message: `A opção "${label}" foi selecionada, mas a resposta ainda não trouxe um plano governado aplicável para ${header}.`,
             warnings: [
                 ...(response.warnings ?? []),
-                'numeric-band-conditional-style-normalized',
-                'Residual continuity guard grounded numeric band thresholds from the canonical dataProfile when available, avoiding accidental thresholds from prose or visual token numbers.',
+                'canonical-renderer-selection-kept-non-executable',
+                'A guided renderer option was selected from canonical optionSelected context; the returned answer did not target the selected field with an executable presentation plan, so the table runtime kept the turn non-applicable instead of synthesizing a status boolean patch.',
             ],
         };
     }
-    componentEditPlanHasAnyOperation(componentEditPlan, operationIds) {
-        if (!operationIds.length)
-            return false;
-        const expected = new Set(operationIds);
-        return this.componentEditOperations(componentEditPlan)
-            .some((operation) => expected.has(this.componentEditPlanOperationIdentity(operation)));
+    canonicalRendererSelection(request) {
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const requestHints = this.toRecord(request.contextHints);
+        return this.toRecord(this.toRecord(actionHints?.['optionSelected'])?.['selection'])
+            ?? this.toRecord(this.toRecord(requestHints?.['optionSelected'])?.['selection']);
     }
-    responseHasComputedColumnAuthoringDecision(response) {
-        if (this.componentEditPlanHasAnyOperation(response.componentEditPlan, ['column.computed.add', 'column.computed.set'])) {
+    responseTargetsSelectedRendererField(response, field) {
+        const normalizedField = this.normalizeLabel(field);
+        if (!normalizedField)
+            return false;
+        const operations = this.componentEditOperations(response.componentEditPlan);
+        if (operations.some((operation) => this.normalizeLabel(this.operationTargetField(operation)) === normalizedField)) {
             return true;
         }
         const patch = this.toRecord(response.patch);
-        const columns = Array.isArray(patch?.['columns']) ? patch['columns'] : [];
-        return columns
+        const columns = this.toArray(patch?.['columns'])
             .map((column) => this.toRecord(column))
-            .some((column) => !!column?.['computed']);
+            .filter((column) => !!column);
+        return columns.some((column) => this.normalizeLabel(this.stringValue(column['field'])) === normalizedField);
     }
-    normalizeComputedColumnAuxiliaryMaterializations(response) {
-        const plan = this.toRecord(response.componentEditPlan);
-        const operations = this.componentEditOperations(plan);
-        if (!plan || operations.length < 2)
-            return response;
-        const computedFields = new Set(operations
-            .filter((operation) => this.componentEditPlanOperationIdentity(operation) === 'column.computed.add'
-            || this.componentEditPlanOperationIdentity(operation) === 'column.computed.set')
-            .map((operation) => this.operationTargetField(operation))
-            .filter((field) => !!field));
-        if (!computedFields.size) {
-            return response;
-        }
-        const auxiliaryAddedFields = new Set();
-        for (const operation of operations) {
-            const operationId = this.componentEditPlanOperationIdentity(operation);
-            const field = this.operationTargetField(operation);
-            if (!field)
-                continue;
-            if (operationId === 'column.add' && !computedFields.has(field)) {
-                auxiliaryAddedFields.add(field);
-            }
-        }
-        const removableFields = auxiliaryAddedFields;
-        if (!removableFields.size)
-            return response;
-        const normalizedOperations = operations.filter((operation) => {
-            const operationId = this.componentEditPlanOperationIdentity(operation);
+    governedCategoricalSelectionBoundary(response, request) {
+        if (!request || !this.requestHasGovernedCategoricalSelection(request))
+            return null;
+        if (response.type === 'error')
+            return null;
+        if (this.responseCarriesClarificationChoices(response))
+            return null;
+        const hasExecutableEnvelope = this.responseMayContainExecutableEnvelope(response)
+            || this.componentEditOperations(response.componentEditPlan).length > 0
+            || !!this.toRecord(response.patch);
+        if (hasExecutableEnvelope)
+            return null;
+        const field = this.governedCategoricalSelectionTargetField(request, response);
+        return {
+            type: 'info',
+            sessionId: response.sessionId,
+            observationId: response.observationId,
+            message: field
+                ? `A opção governada foi selecionada, mas a resposta ainda não trouxe um plano aplicável para ${this.humanizeField(field)}.`
+                : 'A opção governada foi selecionada, mas a resposta ainda não trouxe um plano aplicável para esta coluna.',
+            warnings: [
+                ...(response.warnings ?? []),
+                'governed-categorical-selection-kept-non-executable',
+            ],
+        };
+    }
+    governedCategoricalDiscoveryBoundary(response, request) {
+        if (!request || !this.requestHasGovernedCategoricalSelection(request))
+            return null;
+        if (!this.requestSelectsCategoricalFieldSemanticsDiscovery(request))
+            return null;
+        if (response.type === 'error')
+            return null;
+        if (this.responseCarriesClarificationChoices(response))
+            return null;
+        const hasExecutableEnvelope = this.responseMayContainExecutableEnvelope(response)
+            || this.componentEditOperations(response.componentEditPlan).length > 0
+            || !!this.toRecord(response.patch);
+        if (hasExecutableEnvelope)
+            return null;
+        const field = this.governedCategoricalSelectionTargetField(request, response);
+        if (!field)
+            return null;
+        const column = this.currentConfigColumns()
+            .find((candidate) => this.stringValue(candidate['field']) === field);
+        const label = this.stringValue(column?.['header']) || this.humanizeField(field);
+        const values = this.currentCategoricalValuesForField(field);
+        const valuesMessage = values.length
+            ? `Valores observados em ${label}: ${values.join(', ')}.`
+            : `Ainda não recebi amostras de valores para ${label}.`;
+        return {
+            type: 'clarification',
+            sessionId: response.sessionId ?? request.sessionId,
+            observationId: response.observationId ?? request.observationId ?? null,
+            message: `${valuesMessage} Posso aplicar uma apresentação categórica neutra agora; para ícones, cores ou prioridade por valor, preciso de uma política semântica governada para estes valores.`,
+            questions: [`Como quer materializar ${label} agora?`],
+            optionPayloads: [
+                this.categoricalPresentationOptionPayload(field, label, 'apply_neutral_categorical_renderer', `Aplicar chips neutros em ${label}`, 'Usar leitura visual categórica sem política por valor.', 'sell', 'neutral'),
+            ],
+            warnings: [
+                ...(response.warnings ?? []),
+                'governed-categorical-discovery-grounded-in-current-rows',
+                'The guided categorical discovery option was continued with current table values and kept non-executable because no governed value-level semantic policy was returned.',
+            ],
+        };
+    }
+    normalizeGovernedCategoricalSelectionExecutableResponse(response, request) {
+        if (!request || !this.requestHasGovernedCategoricalSelection(request))
+            return response;
+        if (this.requestSelectsCategoricalFieldSemanticsDiscovery(request)) {
+            return this.governedCategoricalDiscoveryBoundary({
+                type: 'info',
+                sessionId: response.sessionId,
+                observationId: response.observationId ?? null,
+                warnings: [
+                    ...(response.warnings ?? []),
+                    'governed-categorical-discovery-executable-response-blocked',
+                ],
+            }, request) ?? {
+                type: 'info',
+                sessionId: response.sessionId,
+                observationId: response.observationId ?? null,
+                message: 'A descoberta governada foi mantida sem aplicação porque a resposta retornou um plano executável antes de uma política semântica por valor.',
+                warnings: [
+                    ...(response.warnings ?? []),
+                    'governed-categorical-discovery-executable-response-blocked',
+                ],
+            };
+        }
+        const field = this.governedCategoricalSelectionTargetField(request, response);
+        if (field && !this.responseTargetsSelectedRendererField(response, field)) {
+            return {
+                type: 'info',
+                sessionId: response.sessionId,
+                observationId: response.observationId,
+                message: `A opção governada foi selecionada, mas o plano retornado não mira ${this.humanizeField(field)}.`,
+                warnings: [
+                    ...(response.warnings ?? []),
+                    'governed-categorical-selection-target-mismatch',
+                ],
+            };
+        }
+        const label = this.stringValue(request.action?.displayPrompt)
+            || this.stringValue(request.action?.value)
+            || this.stringValue(request.prompt)
+            || 'opção governada';
+        const target = field ? this.humanizeField(field) : 'a coluna categórica';
+        const isNeutralFallback = this.normalizeLabel(label).includes('neutro');
+        const booleanPlanBlocked = this.governedCategoricalBooleanPlanBoundary(response, request, field, isNeutralFallback);
+        if (booleanPlanBlocked)
+            return booleanPlanBlocked;
+        if (!isNeutralFallback && !this.responseHasBooleanStatusNarrative(response))
+            return response;
+        const normalizedExplanation = isNeutralFallback
+            ? `Vou aplicar chips neutros em ${target}, sem política por valor.`
+            : `Vou aplicar a opção governada em ${target}.`;
+        return {
+            ...response,
+            explanation: normalizedExplanation,
+            message: undefined,
+            componentEditPlan: undefined,
+            warnings: [
+                ...(response.warnings ?? []),
+                'governed-categorical-selection-review-text-normalized',
+                isNeutralFallback
+                    ? 'The executable plan was preserved, but the neutral categorical guided option explanation was kept as the human review text instead of a generic renderer summary.'
+                    : 'The executable plan was preserved, but a stale boolean Status/Ativo/Inativo narrative was replaced because the selected guided option targets categorical presentation semantics.',
+            ],
+        };
+    }
+    governedCategoricalBooleanPlanBoundary(response, request, field, isNeutralFallback) {
+        if (!field)
+            return null;
+        const column = this.currentConfigColumns()
+            .find((candidate) => this.stringValue(candidate['field']) === field);
+        if (!column || this.booleanColumnCandidate(column))
+            return null;
+        const hasBooleanOperations = this.responseHasBooleanStatusOperations(response);
+        if (!hasBooleanOperations && (isNeutralFallback || !this.responseHasBooleanStatusNarrative(response))) {
+            return null;
+        }
+        const label = this.stringValue(column['header']) || this.humanizeField(field);
+        return {
+            type: 'clarification',
+            sessionId: response.sessionId ?? request.sessionId,
+            observationId: response.observationId ?? request.observationId ?? null,
+            message: `A coluna ${label} não é booleana no estado atual. Mantive a opção governada sem aplicação para não materializar Ativo/Inativo.`,
+            questions: [`Como quer materializar ${label} agora?`],
+            optionPayloads: [
+                this.categoricalPresentationOptionPayload(field, label, 'author_categorical_field_semantics', `Descobrir semântica dos valores de ${label}`, 'Gerar chips/ícones por valor real da coluna.', 'auto_awesome', 'primary'),
+                this.categoricalPresentationOptionPayload(field, label, 'apply_neutral_categorical_renderer', `Aplicar chips neutros em ${label}`, 'Usar leitura visual categórica sem política por valor.', 'sell', 'neutral'),
+            ],
+            warnings: [
+                ...(response.warnings ?? []),
+                'governed-categorical-boolean-plan-blocked',
+                'The selected governed categorical option returned boolean Status/Ativo/Inativo semantics for a non-boolean field; the executable plan was blocked.',
+            ],
+        };
+    }
+    requestHasGovernedCategoricalSelection(request) {
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const requestHints = this.toRecord(request.contextHints);
+        const actionText = this.normalizeLabel([
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+        ].map((value) => this.stringValue(value)).join(' '));
+        const actionRawText = [
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+        ].map((value) => this.stringValue(value)).join(' ');
+        return this.isGovernedCategoricalSemanticsChoiceText(actionText)
+            || actionRawText.includes('apply_neutral_categorical_renderer')
+            || actionRawText.includes('author_categorical_field_semantics')
+            || !!this.toRecord(actionHints?.['categoricalFieldSemantics'])
+            || !!this.toRecord(requestHints?.['categoricalFieldSemantics'])
+            || this.governanceStatusIsNeutralCategoricalFallback(this.toRecord(actionHints?.['badge'])?.['governanceStatus'])
+            || this.governanceStatusIsNeutralCategoricalFallback(this.toRecord(requestHints?.['badge'])?.['governanceStatus']);
+    }
+    requestSelectsCategoricalFieldSemanticsDiscovery(request) {
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const requestHints = this.toRecord(request.contextHints);
+        const actionSelection = this.toRecord(this.toRecord(actionHints?.['optionSelected'])?.['selection']);
+        const requestSelection = this.toRecord(this.toRecord(requestHints?.['optionSelected'])?.['selection']);
+        const text = [
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+            actionSelection?.['value'],
+            requestSelection?.['value'],
+        ].map((value) => this.stringValue(value)).join(' ');
+        return text.includes('author_categorical_field_semantics');
+    }
+    governanceStatusIsNeutralCategoricalFallback(value) {
+        const raw = this.stringValue(value);
+        const normalized = this.normalizeLabel(raw);
+        return normalized.includes('ungoverned neutral fallback')
+            || raw.includes('ungoverned_neutral_fallback');
+    }
+    governedCategoricalSelectionTargetField(request, response) {
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const requestHints = this.toRecord(request.contextHints);
+        const actionSemantics = this.toRecord(actionHints?.['categoricalFieldSemantics']);
+        const requestSemantics = this.toRecord(requestHints?.['categoricalFieldSemantics']);
+        return this.stringValue(actionSemantics?.['field'])
+            || this.stringValue(requestSemantics?.['field'])
+            || this.visualPresentationTargetField(response, request);
+    }
+    responseHasBooleanStatusNarrative(response) {
+        const text = this.normalizeLabel([
+            response.message,
+            response.explanation,
+        ].map((value) => this.stringValue(value)).join(' '));
+        return this.normalizedTextIncludesAny(text, [
+            'ativo para verdadeiro',
+            'inativo para falso',
+            'status como badge ativo',
+            'status como badge inativo',
+        ]);
+    }
+    incompatibleBooleanStatusPresentationBoundary(response, request) {
+        if (!request)
+            return null;
+        if (this.requestIsCanonicalRendererSelection(request))
+            return null;
+        if (this.requestHasGovernedCategoricalSelection(request))
+            return null;
+        if (this.responseCarriesClarificationChoices(response))
+            return null;
+        if (!this.promptRequestsVisualOrStructuralEdit(this.normalizeLabel(this.componentPresentationPromptForTurn(request)))) {
+            return null;
+        }
+        const columns = this.currentConfigColumns();
+        if (!columns.length)
+            return null;
+        const targetField = this.booleanStatusPresentationTargetField(response, request, columns);
+        if (!targetField)
+            return null;
+        const targetColumn = columns.find((column) => this.stringValue(column['field']) === targetField);
+        if (!targetColumn || this.booleanColumnCandidate(targetColumn))
+            return null;
+        if (!this.responseHasBooleanStatusNarrative(response) && !this.responseHasBooleanStatusOperations(response)) {
+            return null;
+        }
+        const label = this.stringValue(targetColumn['header']) || this.humanizeField(targetField);
+        return {
+            type: 'clarification',
+            sessionId: response.sessionId ?? request.sessionId,
+            observationId: response.observationId ?? request.observationId ?? null,
+            message: `A coluna ${label} não é booleana no estado atual. Posso formatá-la como categoria, mas não vou assumir Ativo/Inativo.`,
+            questions: [`Qual apresentação categórica você quer aplicar em ${label}?`],
+            optionPayloads: [
+                this.categoricalPresentationOptionPayload(targetField, label, 'author_categorical_field_semantics', `Descobrir semântica dos valores de ${label}`, 'Gerar chips/ícones por valor real da coluna.', 'auto_awesome', 'primary'),
+                this.categoricalPresentationOptionPayload(targetField, label, 'apply_neutral_categorical_renderer', `Aplicar chips neutros em ${label}`, 'Usar leitura visual categórica sem política por valor.', 'sell', 'neutral'),
+            ],
+            warnings: [
+                ...(response.warnings ?? []),
+                'boolean-status-presentation-blocked-for-categorical-column',
+                'The LLM returned boolean Status/Ativo/Inativo presentation semantics, but the current table column is not boolean; the table runtime kept the turn as governed categorical clarification instead of compiling an incompatible patch.',
+            ],
+        };
+    }
+    currentConfigColumns() {
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        return Array.isArray(currentConfig?.['columns'])
+            ? currentConfig['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+    }
+    currentConfigRows() {
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        for (const source of [currentConfig]) {
+            for (const key of ['data', 'rows', 'items']) {
+                const rows = this.toArray(source?.[key])
+                    .map((row) => this.toRecord(row))
+                    .filter((row) => !!row);
+                if (rows.length)
+                    return rows;
+            }
+            const dataSourceRows = this.toArray(this.toRecord(source?.['dataSource'])?.['data'])
+                .map((row) => this.toRecord(row))
+                .filter((row) => !!row);
+            if (dataSourceRows.length)
+                return dataSourceRows;
+        }
+        return [];
+    }
+    currentCategoricalValuesForField(field) {
+        const scopedSamples = this.adapterFieldValueSamples(field);
+        if (scopedSamples.length)
+            return scopedSamples;
+        const values = this.currentConfigRows()
+            .map((row) => this.readableCellValue(row[field]))
+            .filter((value) => !!value);
+        return Array.from(new Set(values)).slice(0, 12);
+    }
+    adapterFieldValueSamples(field) {
+        const adapter = this.adapter;
+        const result = adapter.getFieldValueSamples?.(field, 12);
+        const rawValues = Array.isArray(result)
+            ? result
+            : this.toArray(this.toRecord(result)?.['values']);
+        const values = rawValues
+            .map((value) => this.readableCellValue(value))
+            .filter((value) => !!value);
+        return Array.from(new Set(values)).slice(0, 12);
+    }
+    booleanStatusPresentationTargetField(response, request, columns) {
+        const operationFields = this.componentEditOperations(response.componentEditPlan)
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field);
+        const patch = this.toRecord(response.patch);
+        const patchFields = this.toArray(patch?.['columns'])
+            .map((column) => this.stringValue(this.toRecord(column)?.['field']))
+            .filter((field) => !!field);
+        const fields = [...operationFields, ...patchFields];
+        for (const field of fields) {
+            if (columns.some((column) => this.stringValue(column['field']) === field))
+                return field;
+        }
+        return this.explicitVisualPresentationTargetField(response, request, columns);
+    }
+    explicitVisualPresentationTargetField(response, request, columns) {
+        const text = this.normalizeLabel([
+            request.prompt,
+            request.pendingClarification?.sourcePrompt,
+            request.pendingClarification?.assistantMessage,
+            response.message,
+            response.explanation,
+            ...(response.questions ?? []),
+        ].filter(Boolean).join(' '));
+        const matched = columns
+            .map((column) => {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                return null;
+            const header = this.stringValue(column['header']) || field;
+            const score = Math.max(this.visualPresentationTargetFieldScore(text, field), this.visualPresentationTargetFieldScore(text, header));
+            return score > 0 ? { field, score } : null;
+        })
+            .filter((entry) => !!entry)
+            .sort((a, b) => b.score - a.score)[0];
+        return matched?.field ?? null;
+    }
+    responseHasBooleanStatusOperations(response) {
+        const hasBooleanOperation = this.componentEditOperations(response.componentEditPlan).some((operation) => {
+            const operationId = this.stringValue(operation['operationId']);
+            if (operationId !== 'column.conditionalRenderer.add'
+                && operationId !== 'column.conditionalStyle.add'
+                && operationId !== 'column.renderer.set') {
+                return false;
+            }
+            const input = this.toRecord(operation['input']);
+            if (!input)
+                return false;
+            return this.booleanConditionValue(input['condition']) !== null
+                || this.safeJsonText(input).includes('"Ativo"')
+                || this.safeJsonText(input).includes('"Inativo"');
+        });
+        if (hasBooleanOperation)
+            return true;
+        const patchText = this.safeJsonText(response.patch);
+        return patchText.includes('"Ativo"')
+            || patchText.includes('"Inativo"')
+            || patchText.includes('"true"')
+            || patchText.includes('"false"');
+    }
+    categoricalPresentationOptionPayload(field, label, value, optionLabel, description, icon, tone) {
+        return {
+            label: optionLabel,
+            value,
+            description,
+            contextHints: {
+                categoricalFieldSemantics: {
+                    field,
+                    label,
+                },
+                optionSelected: {
+                    targetField: field,
+                    selection: {
+                        mode: value === 'author_categorical_field_semantics'
+                            ? 'categorical_semantics'
+                            : 'renderer',
+                        field,
+                        value,
+                    },
+                },
+            },
+            presentation: {
+                kind: 'guided-option',
+                icon,
+                tone,
+                ctaLabel: 'Aplicar opção',
+            },
+        };
+    }
+    visualPresentationTargetMismatchBoundary(response, request) {
+        if (!request)
+            return null;
+        if (this.requestIsCanonicalRendererSelection(request))
+            return null;
+        if (this.requestHasGovernedCategoricalSelection(request))
+            return null;
+        if (this.responseCarriesClarificationChoices(response))
+            return null;
+        if (!this.promptRequestsVisualOrStructuralEdit(this.normalizeLabel(this.componentPresentationPromptForTurn(request)))) {
+            return null;
+        }
+        const columns = this.currentConfigColumns();
+        if (!columns.length)
+            return null;
+        const requestedField = this.explicitVisualPresentationTargetFieldFromRequest(request, columns);
+        if (!requestedField)
+            return null;
+        const responseFields = this.responsePresentationTargetFields(response, columns);
+        if (!responseFields.length)
+            return null;
+        if (responseFields.some((field) => field === requestedField))
+            return null;
+        const requestedColumn = columns.find((column) => this.stringValue(column['field']) === requestedField);
+        const requestedLabel = this.stringValue(requestedColumn?.['header']) || this.humanizeField(requestedField);
+        return {
+            type: 'clarification',
+            sessionId: response.sessionId ?? request.sessionId,
+            observationId: response.observationId ?? request.observationId ?? null,
+            message: `Entendi que o alvo do ajuste é ${requestedLabel}. Para evitar aplicar uma formatação em outra coluna, vou seguir com uma decisão categórica segura para ${requestedLabel}.`,
+            questions: [`Qual apresentação categórica você quer aplicar em ${requestedLabel}?`],
+            optionPayloads: [
+                this.categoricalPresentationOptionPayload(requestedField, requestedLabel, 'author_categorical_field_semantics', `Descobrir semântica dos valores de ${requestedLabel}`, 'Gerar chips/ícones por valor real da coluna.', 'auto_awesome', 'primary'),
+                this.categoricalPresentationOptionPayload(requestedField, requestedLabel, 'apply_neutral_categorical_renderer', `Aplicar chips neutros em ${requestedLabel}`, 'Usar leitura visual categórica sem política por valor.', 'sell', 'neutral'),
+            ],
+            warnings: [
+                ...(response.warnings ?? []),
+                'visual-presentation-target-mismatch-blocked',
+                'The LLM returned an executable visual presentation plan for a different column than the explicit user target; the table runtime kept the turn non-applicable instead of compiling a patch for the wrong column.',
+            ],
+        };
+    }
+    explicitVisualPresentationTargetFieldFromRequest(request, columns) {
+        const text = this.normalizeLabel([
+            request.prompt,
+            request.action?.displayPrompt,
+            request.pendingClarification?.sourcePrompt,
+        ].filter(Boolean).join(' '));
+        return this.explicitColumnMentionFromText(text, columns);
+    }
+    explicitColumnMentionFromText(normalizedText, columns) {
+        const matched = columns
+            .map((column) => {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                return null;
+            const header = this.stringValue(column['header']) || field;
+            const score = Math.max(this.visualPresentationTargetFieldScore(normalizedText, field), this.visualPresentationTargetFieldScore(normalizedText, header));
+            return score > 0 ? { field, score } : null;
+        })
+            .filter((entry) => !!entry)
+            .sort((a, b) => b.score - a.score);
+        const mentionedFields = [...new Set(matched.map((entry) => entry.field))];
+        return mentionedFields.length === 1 ? mentionedFields[0] : null;
+    }
+    responsePresentationTargetFields(response, columns) {
+        const operationFields = this.componentEditOperations(response.componentEditPlan)
+            .filter((operation) => this.operationIsColumnPresentationEdit(operation))
+            .map((operation) => this.operationTargetField(operation));
+        const patch = this.toRecord(response.patch);
+        const patchFields = this.toArray(patch?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column)
+            .filter((column) => this.patchColumnCarriesPresentationEdit(column))
+            .map((column) => this.stringValue(column['field']));
+        const knownFields = new Set(columns.map((column) => this.stringValue(column['field'])).filter((field) => !!field));
+        return [...new Set([...operationFields, ...patchFields].filter((field) => knownFields.has(field)))];
+    }
+    operationIsColumnPresentationEdit(operation) {
+        const operationId = this.stringValue(operation['operationId']);
+        return [
+            'column.renderer.set',
+            'column.conditionalRenderer.add',
+            'column.conditionalStyle.add',
+            'column.format.set',
+            'column.alignment.set',
+        ].includes(operationId);
+    }
+    patchColumnCarriesPresentationEdit(column) {
+        return !!this.toRecord(column['renderer'])
+            || Array.isArray(column['conditionalRenderers'])
+            || Array.isArray(column['conditionalStyles'])
+            || !!this.stringValue(column['format'])
+            || !!this.stringValue(column['align'])
+            || !!this.stringValue(column['alignment']);
+    }
+    normalizeNumericBandConditionalStylePlan(response, request) {
+        if (!request)
+            return response;
+        if ((response.warnings ?? []).includes('numeric-band-conditional-style-normalized'))
+            return response;
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        const columns = Array.isArray(currentConfig?.['columns'])
+            ? currentConfig['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+        if (!columns.length)
+            return response;
+        const operations = this.numericBandConditionalStyleOperationsFromPrompt(this.componentPresentationPromptForTurn(request), [
+            response.message,
+            response.explanation,
+            ...(response.questions ?? []),
+        ].join(' '), columns);
+        if (!operations.length)
+            return response;
+        const fields = new Set(operations
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field));
+        const originalPlan = this.toRecord(response.componentEditPlan);
+        const originalOperations = this.componentEditOperations(originalPlan)
+            .filter((operation) => {
+            const field = this.operationTargetField(operation);
+            return !(field && fields.has(field) && this.stringValue(operation['operationId']) === 'column.conditionalStyle.add');
+        });
+        return {
+            ...response,
+            ...(response.type === 'clarification' || response.type === 'info' ? { type: 'patch' } : {}),
+            componentEditPlan: {
+                ...(originalPlan ?? {}),
+                kind: this.stringValue(originalPlan?.['kind']) || 'praxis.table.component-edit-plan',
+                version: this.stringValue(originalPlan?.['version']) || '1.0',
+                componentId: this.stringValue(originalPlan?.['componentId'])
+                    || this.adapter.componentId
+                    || request.componentId
+                    || 'praxis-table',
+                operations: [...originalOperations, ...operations],
+            },
+            explanation: response.explanation || 'Vou aplicar formatacao condicional em faixas visuais na coluna numerica indicada.',
+            warnings: [
+                ...(response.warnings ?? []),
+                'numeric-band-conditional-style-normalized',
+                'Residual continuity guard grounded numeric band thresholds from the canonical dataProfile when available, avoiding accidental thresholds from prose or visual token numbers.',
+            ],
+        };
+    }
+    componentEditPlanHasAnyOperation(componentEditPlan, operationIds) {
+        if (!operationIds.length)
+            return false;
+        const expected = new Set(operationIds);
+        return this.componentEditOperations(componentEditPlan)
+            .some((operation) => expected.has(this.componentEditPlanOperationIdentity(operation)));
+    }
+    responseHasComputedColumnAuthoringDecision(response) {
+        if (this.componentEditPlanHasAnyOperation(response.componentEditPlan, ['column.computed.add', 'column.computed.set'])) {
+            return true;
+        }
+        const patch = this.toRecord(response.patch);
+        const columns = Array.isArray(patch?.['columns']) ? patch['columns'] : [];
+        return columns
+            .map((column) => this.toRecord(column))
+            .some((column) => !!column?.['computed']);
+    }
+    normalizeComputedColumnAuxiliaryMaterializations(response) {
+        const plan = this.toRecord(response.componentEditPlan);
+        const operations = this.componentEditOperations(plan);
+        if (!plan || operations.length < 2)
+            return response;
+        const computedFields = new Set(operations
+            .filter((operation) => this.componentEditPlanOperationIdentity(operation) === 'column.computed.add'
+            || this.componentEditPlanOperationIdentity(operation) === 'column.computed.set')
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field));
+        if (!computedFields.size) {
+            return response;
+        }
+        const auxiliaryAddedFields = new Set();
+        for (const operation of operations) {
+            const operationId = this.componentEditPlanOperationIdentity(operation);
+            const field = this.operationTargetField(operation);
+            if (!field)
+                continue;
+            if (operationId === 'column.add' && !computedFields.has(field)) {
+                auxiliaryAddedFields.add(field);
+            }
+        }
+        const removableFields = auxiliaryAddedFields;
+        if (!removableFields.size)
+            return response;
+        const normalizedOperations = operations.filter((operation) => {
+            const operationId = this.componentEditPlanOperationIdentity(operation);
             const field = this.operationTargetField(operation);
             return !(field && removableFields.has(field) && (operationId === 'column.add'
                 || operationId === 'column.renderer.set'));
@@ -5191,18 +6047,7 @@ class TableAgenticAuthoringTurnFlow {
             .sort((left, right) => left - right)[0] ?? -1;
     }
     columnPresentationAliases(column) {
-        const aliases = new Set(this.columnMentionAliases(column));
-        const field = this.normalizeLabel(this.stringValue(column['field']));
-        const header = this.normalizeLabel(this.stringValue(column['header']));
-        if (field.startsWith('nome') || header.includes('nome'))
-            aliases.add('nome');
-        if (field.includes('funcionario') || header.includes('funcionario'))
-            aliases.add('nome');
-        if (field.includes('salario') || header.includes('salario'))
-            aliases.add('salario');
-        if (field.includes('salario') || header.includes('salario'))
-            aliases.add('salário');
-        return [...aliases].sort((left, right) => right.length - left.length);
+        return this.columnMentionAliases(column);
     }
     mergeCompoundColumnPresentationOperations(originalOperations, intendedOperations) {
         const protectedFields = new Map();
@@ -5302,15 +6147,8 @@ class TableAgenticAuthoringTurnFlow {
             return null;
         }
         const column = columns.find((candidate) => {
-            const text = this.normalizeLabel([
-                candidate['field'],
-                candidate['header'],
-                candidate['type'],
-                candidate['dataType'],
-                this.humanizeField(this.stringValue(candidate['field'])),
-            ].map((value) => this.stringValue(value)).join(' '));
             return (this.textMentionsColumn(prompt, candidate) || this.textMentionsColumn(responseText, candidate))
-                && this.normalizedTextIncludesAny(text, ['ativo', 'status', 'boolean', 'bool']);
+                && this.booleanColumnCandidate(candidate);
         });
         return this.booleanSimNaoOperationsForColumn(column);
     }
@@ -5345,7 +6183,8 @@ class TableAgenticAuthoringTurnFlow {
                 candidate['dataType'],
                 this.humanizeField(this.stringValue(candidate['field'])),
             ].map((value) => this.stringValue(value)).join(' '));
-            return this.normalizedTextIncludesAny(text, ['status', 'ativo', 'boolean', 'bool']);
+            return this.booleanColumnCandidate(candidate)
+                && this.normalizedTextIncludesAny(text, ['status', 'ativo', 'boolean', 'bool']);
         });
         const field = this.stringValue(column?.['field']);
         if (!field)
@@ -5484,28 +6323,20 @@ class TableAgenticAuthoringTurnFlow {
         ]);
     }
     numericColumnCandidate(column) {
-        const text = this.normalizeLabel([
-            column['field'],
-            column['header'],
+        const typeText = this.normalizeLabel([
             column['type'],
             column['dataType'],
             column['format'],
-            this.humanizeField(this.stringValue(column['field'])),
         ].map((value) => this.stringValue(value)).join(' '));
-        return this.normalizedTextIncludesAny(text, [
+        return this.normalizedTextIncludesAny(typeText, [
             'number',
             'numeric',
             'decimal',
             'integer',
             'currency',
             'moeda',
-            'valor',
-            'preco',
-            'preço',
-            'salario',
-            'salário',
             'brl',
-        ]);
+        ]) || this.numericBandThresholdsFromDataProfile(this.stringValue(column['field'])) !== null;
     }
     numericBandThresholdsForField(field, text) {
         return this.numericBandThresholdsFromDataProfile(field)
@@ -5609,14 +6440,7 @@ class TableAgenticAuthoringTurnFlow {
             return null;
         }
         const booleanColumns = columns.filter((candidate) => {
-            const text = this.normalizeLabel([
-                candidate['field'],
-                candidate['header'],
-                candidate['type'],
-                candidate['dataType'],
-                this.humanizeField(this.stringValue(candidate['field'])),
-            ].map((value) => this.stringValue(value)).join(' '));
-            return this.normalizedTextIncludesAny(text, ['ativo', 'status', 'boolean', 'bool'])
+            return this.booleanColumnCandidate(candidate)
                 && (this.textMentionsColumn(prompt, candidate) || this.textMentionsColumn(responseText, candidate));
         });
         return this.booleanSimNaoOperationsForColumn(booleanColumns[0]);
@@ -5628,16 +6452,7 @@ class TableAgenticAuthoringTurnFlow {
             || this.normalizedTextIncludesAny(normalizedResponse, ['sim nao', 'sim não', 'sim ou nao', 'sim ou não']);
         if (!simNaoRequested)
             return null;
-        const booleanColumns = columns.filter((candidate) => {
-            const text = this.normalizeLabel([
-                candidate['field'],
-                candidate['header'],
-                candidate['type'],
-                candidate['dataType'],
-                this.humanizeField(this.stringValue(candidate['field'])),
-            ].map((value) => this.stringValue(value)).join(' '));
-            return this.normalizedTextIncludesAny(text, ['ativo', 'status', 'boolean', 'bool']);
-        });
+        const booleanColumns = columns.filter((candidate) => this.booleanColumnCandidate(candidate));
         return booleanColumns.length === 1
             ? this.booleanSimNaoOperationsForColumn(booleanColumns[0])
             : null;
@@ -5776,18 +6591,21 @@ class TableAgenticAuthoringTurnFlow {
     }
     inferSpecificColumnFormatFromPrompt(prompt, column, availableFormats) {
         const normalizedPrompt = this.normalizeLabel(prompt);
-        const columnText = this.normalizeLabel([
-            column['field'],
-            column['header'],
+        const columnTypeText = this.normalizeLabel([
             column['type'],
             column['dataType'],
-            this.humanizeField(this.stringValue(column['field'])),
+            column['format'],
         ].map((value) => this.stringValue(value)).filter(Boolean).join(' '));
-        const dateLikeColumn = this.normalizedTextIncludesAny(columnText, [
+        const dateLikeColumn = this.normalizedTextIncludesAny(columnTypeText, [
             'data',
             'date',
-            'admissao',
-            'admissão',
+            'time',
+            'dd/mm/yyyy',
+            'yyyy-mm-dd',
+            'shortdate',
+            'mediumdate',
+            'longdate',
+            'fulldate',
         ]);
         const brDateRequested = this.normalizedTextIncludesAny(normalizedPrompt, [
             'dia mes ano',
@@ -5801,15 +6619,7 @@ class TableAgenticAuthoringTurnFlow {
         if (dateLikeColumn && brDateRequested && availableFormats.has('dd/MM/yyyy')) {
             return 'dd/MM/yyyy';
         }
-        const currencyLikeColumn = this.normalizedTextIncludesAny(columnText, [
-            'salario',
-            'salário',
-            'salary',
-            'remuneracao',
-            'remuneração',
-            'currency',
-            'moeda',
-        ]);
+        const currencyLikeColumn = this.numericColumnCandidate(column);
         const brlRequested = this.normalizedTextIncludesAny(normalizedPrompt, [
             'real',
             'reais',
@@ -6258,8 +7068,6 @@ class TableAgenticAuthoringTurnFlow {
             return null;
         if (!response.patch || this.tableFilterApplyOperations(response.patch).length === 0)
             return null;
-        if (this.responseDeclaresTableMutation(response))
-            return null;
         const contextHints = this.contextHintsFor(request);
         return {
             type: 'info',
@@ -6293,6 +7101,30 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    selectedRecordReadonlyPresentationBoundaryResponse(response, request) {
+        if (!this.selectedRecordReadOnlyAnalysisRequested(request))
+            return null;
+        if (response.patch)
+            return null;
+        const contextHints = this.contextHintsFor(request);
+        if (!this.selectedRecordSampleRows(contextHints).length)
+            return null;
+        const hasPresentationOptions = (response.optionPayloads ?? [])
+            .some((payload) => this.isVisualPresentationClarificationPayload(payload)
+            || this.isGovernedCategoricalSemanticsChoicePayload(payload));
+        if (!hasPresentationOptions && !this.responseHasGovernedCategoricalSemanticsChoice(response))
+            return null;
+        return {
+            type: 'info',
+            sessionId: response.sessionId ?? request?.sessionId,
+            message: this.selectedRecordsAnalyticalSummary(contextHints),
+            warnings: [
+                ...(response.warnings ?? []),
+                'selected-record-readonly-analysis-presentation-misroute-collapsed',
+                'A plataforma respondeu a analise read-only usando selectedRecordsContext.sampleRows porque a resposta semantica retornou opcoes de apresentacao visual para uma pergunta consultiva.',
+            ],
+        };
+    }
     responseAsksForSelectedRecordAnalysisDimension(response) {
         const text = [
             response.message,
@@ -6338,30 +7170,180 @@ class TableAgenticAuthoringTurnFlow {
             return false;
         }
         const normalizedPrompt = this.normalizeLabel(request?.prompt ?? '');
-        if (this.promptExplicitlyForbidsTableMutation(normalizedPrompt))
-            return true;
-        if (this.promptRequestsSelectedRecordDerivedOperation(normalizedPrompt))
+        if (this.promptExplicitlyForbidsTableMutation(normalizedPrompt))
+            return true;
+        if (this.promptRequestsSelectedRecordDerivedOperation(normalizedPrompt))
+            return false;
+        const responseContract = this.toRecord(contextHints?.['responseContract'])
+            ?? this.toRecord(request?.action?.contextHints?.['responseContract']);
+        if (responseContract) {
+            const preferredResponse = this.normalizeLabel(this.stringValue(responseContract['preferredResponse']));
+            const mutatesTable = responseContract['mutatesTable'];
+            if (preferredResponse === 'info' || mutatesTable === false)
+                return true;
+            if (mutatesTable === true)
+                return false;
+        }
+        const authoringMode = this.normalizeLabel(this.stringValue(contextHints?.['authoringMode']).replace(/[._-]+/gu, ' '));
+        if (authoringMode === 'table selection readonly analysis')
+            return true;
+        return this.selectedRecordPromptLooksConsultative(normalizedPrompt);
+    }
+    selectedRecordGenericCommonalityAnalysisRequested(request) {
+        if (!this.selectedRecordReadOnlyAnalysisRequested(request))
+            return false;
+        const normalizedPrompt = this.normalizeLabel(request?.prompt ?? '');
+        if (!normalizedPrompt)
+            return false;
+        if (!this.normalizedTextContainsApproxPhrase(normalizedPrompt, 'em comum')
+            && !this.normalizedTextContainsApproxPhrase(normalizedPrompt, 'tem comum')) {
+            return false;
+        }
+        if (this.promptRequestsSelectedRecordDerivedOperation(normalizedPrompt))
+            return false;
+        const contextHints = this.contextHintsFor(request);
+        const selectedRecordsContext = this.selectedRecordsContextRecord(contextHints);
+        const fieldTargets = [
+            ...(Array.isArray(selectedRecordsContext?.['fields']) ? selectedRecordsContext['fields'] : []),
+            ...this.filterFieldCatalogEntries.flatMap((entry) => [
+                entry.name,
+                entry.label,
+                ...entry.aliases,
+                ...entry.relatedColumnFields,
+                ...entry.relatedColumnLabels,
+            ]),
+            ...this.selectedRecordFilterCandidates(contextHints).flatMap((candidate) => [
+                candidate['field'],
+                candidate['label'],
+                ...(Array.isArray(candidate['relatedColumnFields']) ? candidate['relatedColumnFields'] : []),
+            ]),
+            ...this.selectedRecordSurfaces(contextHints).flatMap((surface) => [
+                surface['id'],
+                surface['label'],
+                surface['title'],
+            ]),
+        ]
+            .map((target) => this.normalizeLabel(this.stringValue(target)))
+            .filter((target) => target.length > 2)
+            .filter((target) => !this.selectedRecordGenericCommonalityScopeTarget(target));
+        return !fieldTargets.some((target) => this.normalizedTextHasStandaloneToken(normalizedPrompt, target)
+            || this.normalizedTextContainsApproxPhrase(normalizedPrompt, target));
+    }
+    selectedRecordLocalReadonlyAnalysisRequested(request) {
+        const contextHints = this.contextHintsFor(request);
+        if (!this.selectedRecordSampleRows(contextHints).length)
+            return false;
+        if (this.toRecord(contextHints?.['selectedRecordsFilter'])
+            || this.toRecord(request?.action?.contextHints?.['selectedRecordsFilter'])
+            || this.toRecord(contextHints?.['tableRuntimeOperation'])
+            || this.toRecord(request?.action?.contextHints?.['tableRuntimeOperation'])) {
+            return false;
+        }
+        const normalizedPrompt = this.normalizeLabel(request?.prompt ?? '');
+        if (!normalizedPrompt)
             return false;
-        const responseContract = this.toRecord(contextHints?.['responseContract'])
-            ?? this.toRecord(request?.action?.contextHints?.['responseContract']);
-        if (responseContract) {
-            const preferredResponse = this.normalizeLabel(this.stringValue(responseContract['preferredResponse']));
-            const mutatesTable = responseContract['mutatesTable'];
-            if (preferredResponse === 'info' || mutatesTable === false)
-                return true;
-            if (mutatesTable === true)
-                return false;
+        if (this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
+            || this.promptRequestsExportOperation(normalizedPrompt)) {
+            return this.promptExplicitlyForbidsTableMutation(normalizedPrompt);
         }
-        const authoringMode = this.normalizeLabel(this.stringValue(contextHints?.['authoringMode']).replace(/[._-]+/gu, ' '));
-        if (authoringMode === 'table selection readonly analysis')
+        if (this.promptRequestsSelectedRecordDerivedOperation(normalizedPrompt))
+            return false;
+        return this.promptExplicitlyForbidsTableMutation(normalizedPrompt)
+            || this.selectedRecordPromptTargetsSelectedSet(normalizedPrompt);
+    }
+    selectedRecordPromptTargetsSelectedSet(normalizedPrompt) {
+        if (!normalizedPrompt)
+            return false;
+        const selectedSetSignals = [
+            'selecionado',
+            'selecionados',
+            'marcado',
+            'marcados',
+            'linha marcada',
+            'linhas marcadas',
+            'registro marcado',
+            'registros marcados',
+            'registro selecionado',
+            'registros selecionados',
+            'esses',
+            'essas',
+            'nestes',
+            'nestas',
+            'nesses',
+            'nessas',
+            'desses',
+            'dessas',
+            'tres',
+            'três',
+            '3',
+        ];
+        const analyticalSignals = [
+            'em comum',
+            'tem comum',
+            'igual',
+            'iguais',
+            'compare',
+            'comparar',
+            'resuma',
+            'resume',
+            'resumir',
+            'analise',
+            'analisar',
+            'padrao',
+            'padrão',
+            'fora do padrao',
+            'fora do padrão',
+            'ganha mais',
+            'ganha menos',
+            'quem ganha',
+            'faixa salarial',
+            'faixa de salario',
+            'faixa de salário',
+            'faixa de admissao',
+            'faixa de admissão',
+            'periodo de admissao',
+            'período de admissão',
+            'departamento',
+            'cargo',
+            'cargos',
+            'salario',
+            'salário',
+            'admissao',
+            'admissão',
+        ];
+        const hasSelectedScope = selectedSetSignals.some((signal) => this.normalizedTextHasStandaloneToken(normalizedPrompt, signal)
+            || this.normalizedTextContainsApproxPhrase(normalizedPrompt, signal));
+        if (!hasSelectedScope)
+            return false;
+        return analyticalSignals.some((signal) => this.normalizedTextHasStandaloneToken(normalizedPrompt, signal)
+            || this.normalizedTextContainsApproxPhrase(normalizedPrompt, signal));
+    }
+    selectedRecordGenericCommonalityScopeTarget(normalizedTarget) {
+        if (!normalizedTarget)
             return true;
-        return this.selectedRecordPromptLooksConsultative(normalizedPrompt);
+        return [
+            'funcionario',
+            'funcionarios',
+            'colaborador',
+            'colaboradores',
+            'registro',
+            'registros',
+            'linha',
+            'linhas',
+            'selecionado',
+            'selecionados',
+            'selected',
+            'record',
+            'records',
+            'row',
+            'rows',
+        ].some((scopeTerm) => this.normalizedTextHasStandaloneToken(normalizedTarget, scopeTerm)
+            || normalizedTarget === scopeTerm);
     }
     selectedRecordPromptLooksConsultative(normalizedPrompt) {
         if (!normalizedPrompt)
             return false;
-        if (this.promptRequestsRuntimeFilter(normalizedPrompt)
-            || this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
+        if (this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
             || this.promptRequestsExportOperation(normalizedPrompt)) {
             return this.promptExplicitlyForbidsTableMutation(normalizedPrompt);
         }
@@ -6408,6 +7390,30 @@ class TableAgenticAuthoringTurnFlow {
         // This ranks explicit selected-record operation wording after selectedRecordsContext is already available.
         // The primary intent still comes from the semantic turn/contract; these phrases only prevent a read-only
         // safety boundary from cancelling an operation the user explicitly asked to materialize.
+        if (this.selectedRecordPromptLooksConsultative(normalizedPrompt)) {
+            const explicitOperationSignals = [
+                'filtrar',
+                'filtra',
+                'filtro',
+                'filtre',
+                'buscar registros',
+                'procurar registros',
+                'acha quem',
+                'achar quem',
+                'outros registros',
+                'quero outros',
+                'quero os mesmo',
+                'quero os mesmos',
+                'quero ver gente',
+                'pega a turma',
+                'pegar a turma',
+            ].map((signal) => this.normalizeLabel(signal));
+            const explicitlyRequestsOperation = explicitOperationSignals.some((signal) => signal.includes(' ')
+                ? this.normalizedTextContainsExactPhrase(normalizedPrompt, signal)
+                : this.normalizedTextHasStandaloneToken(normalizedPrompt, signal));
+            if (!explicitlyRequestsOperation)
+                return false;
+        }
         return [
             'filtrar',
             'filtra',
@@ -6415,6 +7421,10 @@ class TableAgenticAuthoringTurnFlow {
             'filtre',
             'buscar registros',
             'procurar registros',
+            'acha quem',
+            'achar quem',
+            'pega a turma',
+            'pegar a turma',
             'outros registros',
             'registro parecido',
             'registros parecidos',
@@ -6433,7 +7443,20 @@ class TableAgenticAuthoringTurnFlow {
             'quero os mesmo',
             'quero os mesmos',
             'quero ver gente',
-        ].some((signal) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, signal));
+            'mesma banda',
+            'nessa mesma banda',
+            'nessa epoca',
+            'nessa época',
+        ].some((signal) => {
+            const normalizedSignal = this.normalizeLabel(signal);
+            if (!normalizedSignal)
+                return false;
+            if (normalizedSignal.includes(' ')) {
+                return this.normalizedTextContainsExactPhrase(normalizedPrompt, normalizedSignal);
+            }
+            return this.normalizedTextHasStandaloneToken(normalizedPrompt, normalizedSignal)
+                || this.normalizedTextContainsApproxToken(normalizedPrompt, normalizedSignal);
+        });
     }
     promptExplicitlyForbidsTableMutation(normalizedPrompt) {
         if (!normalizedPrompt)
@@ -6523,16 +7546,17 @@ class TableAgenticAuthoringTurnFlow {
             .slice(0, 4);
         const dateRanges = fields
             .map((field) => {
-            const timestamps = rows
-                .map((row) => this.dateTimestamp(row[field]))
-                .filter((value) => value !== null);
-            if (timestamps.length < 2)
+            const values = rows
+                .map((row) => this.analysisDateValue(row[field]))
+                .filter((value) => !!value);
+            if (values.length < 2)
                 return null;
-            const min = Math.min(...timestamps);
-            const max = Math.max(...timestamps);
-            if (min === max)
+            const sorted = [...values].sort((left, right) => left.sort - right.sort);
+            const min = sorted[0];
+            const max = sorted[sorted.length - 1];
+            if (!min || !max || min.sort === max.sort)
                 return null;
-            return `${labelByField.get(field) || this.humanizeField(field)}: ${this.formatAnalysisDate(min)} até ${this.formatAnalysisDate(max)}`;
+            return `${labelByField.get(field) || this.humanizeField(field)}: ${min.label} até ${max.label}`;
         })
             .filter((entry) => !!entry)
             .slice(0, 3);
@@ -6588,6 +7612,27 @@ class TableAgenticAuthoringTurnFlow {
                 : Number.NaN;
         return Number.isFinite(raw) ? raw : null;
     }
+    analysisDateValue(value) {
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            const dateOnly = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(trimmed);
+            if (dateOnly) {
+                const year = Number(dateOnly[1]);
+                const month = Number(dateOnly[2]);
+                const day = Number(dateOnly[3]);
+                if (Number.isInteger(year) && Number.isInteger(month) && Number.isInteger(day)) {
+                    return {
+                        sort: year * 10000 + month * 100 + day,
+                        label: `${String(day).padStart(2, '0')}/${String(month).padStart(2, '0')}/${String(year)}`,
+                    };
+                }
+            }
+        }
+        const timestamp = this.dateTimestamp(value);
+        return timestamp === null
+            ? null
+            : { sort: timestamp, label: this.formatAnalysisDate(timestamp) };
+    }
     formatAnalysisDate(timestamp) {
         return new Intl.DateTimeFormat('pt-BR', {
             day: '2-digit',
@@ -6924,6 +7969,8 @@ class TableAgenticAuthoringTurnFlow {
         return operations;
     }
     requestCarriesVisualPresentationContext(request) {
+        if (this.requestHasGovernedCategoricalSelection(request))
+            return true;
         const actionHints = this.toRecord(request.action?.contextHints);
         const requestHints = this.toRecord(request.contextHints);
         const pendingDiagnostics = this.toRecord(request.pendingClarification?.diagnostics);
@@ -7406,7 +8453,10 @@ class TableAgenticAuthoringTurnFlow {
         add(header);
         add(field);
         add(this.humanizeField(field));
-        for (const source of [header, field, this.humanizeField(field)]) {
+        for (const alias of this.stringArrayValue(column['aliases'])) {
+            add(alias);
+        }
+        for (const source of [header, field, this.humanizeField(field), ...this.stringArrayValue(column['aliases'])]) {
             const normalized = this.normalizeLabel(source);
             const tokens = normalized.split(' ').filter((token) => token.length >= 3
                 && !['nome', 'valor', 'data', 'campo', 'codigo', 'id'].includes(token));
@@ -7617,6 +8667,24 @@ class TableAgenticAuthoringTurnFlow {
             ...(memory ? { tableComponentEditDecision: memory } : {}),
         };
     }
+    errorRetryDiagnostics(request, response) {
+        const actionHints = this.toRecord(request.action?.contextHints);
+        const retryableAction = request.action && actionHints
+            ? {
+                kind: request.action.kind || 'clarify',
+                value: this.stringValue(request.action.value) || request.prompt || '',
+                displayPrompt: this.stringValue(request.action.displayPrompt),
+                contextHints: actionHints,
+            }
+            : null;
+        const warnings = response.warnings?.filter(Boolean) ?? [];
+        if (!retryableAction && !warnings.length)
+            return undefined;
+        return {
+            ...(warnings.length ? { warnings } : {}),
+            ...(retryableAction ? { retryAction: retryableAction } : {}),
+        };
+    }
     tableConversationMemoryHints(request) {
         const diagnostics = this.toRecord(request.diagnostics);
         const decision = this.toRecord(diagnostics?.['tableComponentEditDecision']);
@@ -7691,6 +8759,9 @@ class TableAgenticAuthoringTurnFlow {
     completePendingComponentEditClarification(request) {
         if (request.action?.kind !== 'clarify')
             return null;
+        const computedColumnCreation = this.completePendingComputedColumnClarification(request);
+        if (computedColumnCreation)
+            return computedColumnCreation;
         const diagnostics = this.toRecord(request.pendingClarification?.diagnostics);
         const continuation = this.toRecord(diagnostics?.['tableComponentEditContinuation']);
         if (!continuation)
@@ -7719,6 +8790,127 @@ class TableAgenticAuthoringTurnFlow {
             explanation: 'Clarificacao aplicada ao ajuste pendente.',
         };
     }
+    completePendingComputedColumnClarification(request) {
+        const sourcePrompt = request.pendingClarification?.sourcePrompt?.trim()
+            || this.recoverComputedColumnClarificationSourcePromptFromMessages(request);
+        if (!sourcePrompt)
+            return null;
+        const normalizedSourcePrompt = this.normalizeLabel(sourcePrompt);
+        if (!this.promptRequestsComputedColumnCreation(normalizedSourcePrompt))
+            return null;
+        const selectedField = this.selectedNewComputedFieldFromClarification(request);
+        if (!selectedField)
+            return null;
+        const columns = this.currentTableColumnsForAuthoring();
+        if (columns.some((column) => this.stringValue(column['field']).toLowerCase() === selectedField.toLowerCase())) {
+            return null;
+        }
+        const baseFields = this.computedColumnBaseFieldsFromPrompt(normalizedSourcePrompt, columns);
+        if (baseFields.length < 2)
+            return null;
+        const operation = {
+            operationId: 'column.computed.add',
+            target: { kind: 'column', field: selectedField },
+            input: {
+                field: selectedField,
+                header: this.humanizeField(selectedField),
+                expression: {
+                    cat: baseFields.flatMap((field, index) => (index === 0 ? [{ var: field }] : [' - ', { var: field }])),
+                },
+                outputType: 'string',
+                dependencies: baseFields,
+            },
+        };
+        return {
+            type: 'patch',
+            sessionId: request.sessionId,
+            componentEditPlan: {
+                kind: 'praxis.table.component-edit-plan',
+                version: '1.0',
+                componentId: this.adapter.componentId || request.componentId || 'praxis-table',
+                ...operation,
+            },
+            explanation: `Vou criar a coluna calculada **${this.humanizeField(selectedField)}** combinando ${baseFields.map((field) => `**${this.humanizeField(field)}**`).join(' e ')}.`,
+            warnings: [
+                'computed-column-clarification-continuation-materialized',
+                'A resposta curta de clarificacao foi materializada usando pendingClarification.sourcePrompt e colunas declaradas da tabela; a intencao primaria ja estava ancorada em coluna calculada.',
+            ],
+        };
+    }
+    selectedNewComputedFieldFromClarification(request) {
+        const value = [
+            request.action?.value,
+            request.action?.displayPrompt,
+            request.prompt,
+        ]
+            .map((candidate) => this.stringValue(candidate).trim())
+            .find((candidate) => !!candidate);
+        if (!value || /\s/u.test(value) || value.length > 80)
+            return null;
+        const cleaned = value.replace(/[^A-Za-z0-9_]/gu, '');
+        return cleaned || null;
+    }
+    recoverComputedColumnClarificationSourcePromptFromMessages(request) {
+        const messages = [...(request.messages ?? [])];
+        if (messages.length < 2)
+            return null;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            const message = messages[index];
+            if (message.role !== 'assistant')
+                continue;
+            const assistantText = this.normalizeLabel(message.text ?? '');
+            if (!assistantText.includes('coluna correta') && !assistantText.includes('qual coluna'))
+                continue;
+            const sourcePrompt = [...messages.slice(0, index)]
+                .reverse()
+                .find((candidate) => candidate.role === 'user')
+                ?.text?.trim();
+            if (sourcePrompt && this.promptRequestsComputedColumnCreation(this.normalizeLabel(sourcePrompt))) {
+                return sourcePrompt;
+            }
+        }
+        return null;
+    }
+    promptRequestsComputedColumnCreation(normalizedPrompt) {
+        if (!normalizedPrompt)
+            return false;
+        const wantsComputed = normalizedPrompt.includes('calculad')
+            || normalizedPrompt.includes('computed')
+            || normalizedPrompt.includes('derivad')
+            || normalizedPrompt.includes('formula');
+        const wantsJoin = normalizedPrompt.includes('combin')
+            || normalizedPrompt.includes('concat')
+            || normalizedPrompt.includes('juntar')
+            || normalizedPrompt.includes('unir')
+            || normalizedPrompt.includes('mesclar')
+            || normalizedPrompt.includes('merge');
+        return wantsComputed && wantsJoin;
+    }
+    currentTableColumnsForAuthoring() {
+        return this.toArray(this.adapter.getCurrentConfig()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column && !!this.stringValue(column['field']));
+    }
+    computedColumnBaseFieldsFromPrompt(normalizedPrompt, columns) {
+        const fields = [];
+        for (const column of columns) {
+            const field = this.stringValue(column['field']);
+            const header = this.stringValue(column['header']) || field;
+            if (!field)
+                continue;
+            if (this.normalizedPromptMentionsColumn(normalizedPrompt, field)
+                || this.normalizedPromptMentionsColumn(normalizedPrompt, header)) {
+                fields.push(field);
+            }
+        }
+        return [...new Set(fields)];
+    }
+    normalizedPromptMentionsColumn(normalizedPrompt, value) {
+        const normalizedValue = this.normalizeLabel(value);
+        if (!normalizedValue)
+            return false;
+        return normalizedPrompt.includes(normalizedValue);
+    }
     describeBooleanStateRenderers(operations) {
         if (operations.length < 2)
             return null;
@@ -8439,7 +9631,6 @@ class TableAgenticAuthoringTurnFlow {
         };
     }
     buildComponentPresentationAuthoringSystemPolicy(contextHints, prompt) {
-        void contextHints;
         const normalizedPrompt = this.normalizeLabel(prompt);
         const presentationIntent = this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
             || this.promptRequestsCompoundColumnPresentationEdit(normalizedPrompt);
@@ -8458,6 +9649,11 @@ class TableAgenticAuthoringTurnFlow {
             const type = this.stringValue(column['type'] ?? column['dataType']) || 'unknown';
             return `- ${field} (${label}; ${type}; ${visible})`;
         });
+        const targetGroundingLines = this.componentPresentationTargetGroundingLines(normalizedPrompt, columns);
+        const contextField = this.stringValue(contextHints?.['targetField']);
+        const contextTargetLine = contextField
+            ? `Declared context target: ${contextField}.`
+            : 'Declared context target: none.';
         return {
             role: 'system',
             content: [
@@ -8468,11 +9664,90 @@ class TableAgenticAuthoringTurnFlow {
                 '- For compound prompts, preserve the action attached to each declared column: hide only columns in the hide/privacy scope, pin/fix columns with column.sticky.set, and highlight/destacar columns with renderer or style operations. Never hide a column that the user asked to pin or highlight.',
                 '- If the user answers a previous component-edit clarification with a short option such as "sim", "opcao 2", or "prosseguir", continue the previous component-edit intent instead of treating the answer as a new filter request.',
                 '- Ask clarification only when the declared source columns or authoring capabilities are insufficient to choose a safe componentEditPlan. Do not ask clarification solely to pick an internal field id for a newly named computed column.',
+                '- Target grounding candidates below are ranking evidence after this turn has been resolved as presentation authoring; they are not the primary intent router.',
+                '- When one high-confidence target candidate is declared, prefer that field for componentEditPlan targets unless the user explicitly names another field. Do not substitute a semantically adjacent field such as priority for status.',
+                '- If the generated plan would target a different field than the high-confidence candidate, ask a short clarification instead of returning an executable componentEditPlan.',
                 'Declared table columns:',
                 ...columnLines,
+                contextTargetLine,
+                targetGroundingLines.length ? 'Target grounding candidates:' : 'Target grounding candidates: none declared.',
+                ...targetGroundingLines,
             ].join('\n'),
         };
     }
+    componentPresentationTargetGroundingLines(normalizedPrompt, columns) {
+        return this.componentPresentationTargetGroundingCandidates(normalizedPrompt, columns)
+            .map((candidate) => [
+            `- ${candidate.field} (${candidate.label})`,
+            `confidence=${candidate.confidence}`,
+            `evidence=${candidate.evidence.join(', ')}`,
+        ].join('; '));
+    }
+    componentPresentationTargetGroundingHints(prompt) {
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const presentationIntent = this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
+            || this.promptRequestsCompoundColumnPresentationEdit(normalizedPrompt);
+        if (!presentationIntent)
+            return null;
+        const columns = this.toArray(this.adapter.getCurrentConfig()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column && !!this.stringValue(column['field']))
+            .slice(0, 20);
+        const candidates = this.componentPresentationTargetGroundingCandidates(normalizedPrompt, columns);
+        if (!candidates.length)
+            return null;
+        return {
+            presentationTargetGrounding: {
+                kind: 'praxis.table.presentation-target-grounding.v1',
+                scope: 'presentation-authoring',
+                candidates: candidates.map((candidate) => ({
+                    field: candidate.field,
+                    label: candidate.label,
+                    confidence: candidate.confidence,
+                    evidence: candidate.evidence,
+                })),
+            },
+        };
+    }
+    componentPresentationTargetGroundingCandidates(normalizedPrompt, columns) {
+        return columns
+            .map((column) => {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                return null;
+            const label = this.stringValue(column['header']) || this.humanizeField(field);
+            const fieldScore = this.visualPresentationTargetFieldScore(normalizedPrompt, field);
+            const labelScore = this.visualPresentationTargetFieldScore(normalizedPrompt, label);
+            const valueMatches = this.componentPresentationObservedValueMatches(normalizedPrompt, field);
+            const score = Math.max(fieldScore, labelScore) + (valueMatches.length ? 12 : 0);
+            if (score <= 0)
+                return null;
+            const evidence = [
+                fieldScore > 0 ? 'field mention' : null,
+                labelScore > 0 ? 'header mention' : null,
+                ...valueMatches.map((value) => `observed value "${value}"`),
+            ].filter((value) => !!value);
+            const confidence = score >= 12 ? 'high' : 'medium';
+            return {
+                field,
+                label,
+                score,
+                confidence,
+                evidence,
+            };
+        })
+            .filter((candidate) => !!candidate)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 5);
+    }
+    componentPresentationObservedValueMatches(normalizedPrompt, field) {
+        return this.adapterFieldValueSamples(field)
+            .map((value) => this.stringValue(value))
+            .filter((value) => !!value)
+            .filter((value) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, value))
+            .map((value) => (value.length > 48 ? `${value.slice(0, 45)}...` : value))
+            .slice(0, 3);
+    }
     buildComponentLayoutAuthoringSystemPolicy(contextHints, prompt) {
         const normalizedPrompt = this.normalizeLabel(prompt);
         const position = this.relativeOrderPosition(normalizedPrompt);
@@ -8722,6 +9997,8 @@ class TableAgenticAuthoringTurnFlow {
         const record = this.toRecord(payload);
         if (!record)
             return false;
+        if (this.isGovernedCategoricalSemanticsChoicePayload(record))
+            return false;
         return this.isVisualPresentationClarificationText([
             record['label'],
             record['value'],
@@ -8750,6 +10027,48 @@ class TableAgenticAuthoringTurnFlow {
             'apresentação',
         ].some((token) => this.normalizedTextContainsApproxPhrase(text, token));
     }
+    isGovernedCategoricalSemanticsChoicePayload(payload) {
+        const record = this.toRecord(payload);
+        if (!record)
+            return false;
+        const contextHintsText = this.safeJsonText(record['contextHints']);
+        return this.isGovernedCategoricalSemanticsChoiceText([
+            record['label'],
+            record['value'],
+            record['description'],
+            contextHintsText,
+        ].filter(Boolean).join(' '));
+    }
+    isGovernedCategoricalSemanticsChoiceText(value) {
+        const text = this.normalizeLabel(value);
+        if (!text)
+            return false;
+        return [
+            'author categorical field semantics',
+            'author categorical semantics',
+            'categorical field semantics',
+            'semantica visual governada',
+            'semântica visual governada',
+            'governed visual semantics',
+            'apply neutral categorical renderer',
+            'apply neutral categorical chip',
+            'aplicar chips neutros',
+            'chips neutros por enquanto',
+            'ungoverned neutral fallback',
+        ]
+            .map((token) => this.normalizeLabel(token))
+            .some((token) => text.includes(token));
+    }
+    safeJsonText(value) {
+        if (value === null || value === undefined)
+            return '';
+        try {
+            return JSON.stringify(value) ?? '';
+        }
+        catch {
+            return '';
+        }
+    }
     textMentionsFilterCatalogEntry(normalizedText) {
         if (!normalizedText || !this.filterFieldCatalogEntries.length)
             return false;
@@ -8853,17 +10172,40 @@ class TableAgenticAuthoringTurnFlow {
                 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;
+                const isGovernedCategoricalSemanticsChoice = this.isGovernedCategoricalSemanticsChoicePayload(option);
+                const isVisualPresentation = !isGovernedCategoricalSemanticsChoice
+                    && this.isVisualPresentationClarificationPayload(option);
+                const visualRenderer = isVisualPresentation
+                    ? this.visualPresentationRendererValue([rawLabel, canonicalValue].join(' '))
+                    : null;
+                const optionHints = this.optionContextHints(option);
+                const optionSelected = this.toRecord(optionHints?.['optionSelected']);
+                const selection = this.toRecord(optionSelected?.['selection']);
+                const visualField = visualRenderer
+                    ? this.stringValue(selection?.['field'])
+                        || this.stringValue(optionSelected?.['targetField'])
+                        || this.visualPresentationTargetField(response, request)
+                    : null;
+                const prompt = visualRenderer
+                    ? this.visualPresentationClarificationPromptFromSelection(visualRenderer, visualField)
+                    : isGovernedCategoricalSemanticsChoice
+                        ? label
+                        : isVisualPresentation
+                            ? this.visualPresentationClarificationPrompt(option, canonicalValue)
+                            : label;
                 return {
                     id: `option-${index + 1}`,
                     label,
-                    prompt: label,
-                    value: canonicalValue,
+                    prompt,
+                    value: visualRenderer ?? 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),
+                    contextHints: visualRenderer
+                        ? this.visualPresentationOptionContextHints(visualRenderer, visualField)
+                        : optionHints,
                 };
             });
         }
@@ -8872,17 +10214,139 @@ class TableAgenticAuthoringTurnFlow {
         }
         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',
+            .map((option, index) => {
+            const rawOption = option.trim();
+            const label = this.humanizeClarificationOptionLabel(rawOption);
+            const visualRenderer = this.visualPresentationRendererValue(rawOption);
+            const visualField = visualRenderer
+                ? this.visualPresentationTargetField(response, request)
+                : null;
+            const prompt = visualRenderer
+                ? this.visualPresentationClarificationPromptFromSelection(visualRenderer, visualField)
+                : rawOption;
+            return {
+                id: `option-${index + 1}`,
+                label,
+                prompt,
+                value: visualRenderer ?? rawOption,
+                kind: 'clarification-option',
+                presentation: {
+                    kind: 'guided-option',
+                    icon: visualRenderer ? this.visualPresentationIcon(visualRenderer) : 'check',
+                    ctaLabel: visualRenderer ? 'Aplicar opção' : 'Usar esta opção',
+                },
+                ...(visualRenderer
+                    ? { contextHints: this.visualPresentationOptionContextHints(visualRenderer, visualField) }
+                    : {}),
+            };
+        });
+    }
+    visualPresentationClarificationPrompt(option, canonicalValue) {
+        const contextHints = this.toRecord(option.contextHints);
+        const optionSelected = this.toRecord(contextHints?.['optionSelected']);
+        const selection = this.toRecord(optionSelected?.['selection']);
+        const field = this.stringValue(selection?.['field']) || this.stringValue(optionSelected?.['targetField']);
+        const rendererValue = this.stringValue(selection?.['value']) || canonicalValue;
+        return this.visualPresentationClarificationPromptFromSelection(rendererValue, field);
+    }
+    visualPresentationClarificationPromptFromSelection(rendererValue, field) {
+        return field
+            ? `Aplique a apresentacao visual ${rendererValue} na coluna ${field}.`
+            : `Aplique a apresentacao visual ${rendererValue}.`;
+    }
+    visualPresentationRendererValue(option) {
+        if (!this.isVisualPresentationClarificationText(option))
+            return null;
+        const normalized = this.normalizeLabel(option);
+        if (normalized.includes('two lines')
+            || normalized.includes('two line')
+            || normalized.includes('two-line')
+            || normalized.includes('twolines')
+            || normalized.includes('twoline')
+            || normalized.includes('duas linhas')
+            || normalized.includes('duaslinhas')
+            || normalized.includes('duas_linhas')
+            || normalized.includes('segunda linha')) {
+            return 'two_lines';
+        }
+        if (normalized.includes('badge') || normalized.includes('chip') || normalized.includes('etiqueta')) {
+            return 'badge';
+        }
+        if (normalized.includes('icone') || normalized.includes('icon')) {
+            return 'icon';
+        }
+        if (normalized.includes('alinhamento') || normalized.includes('alinhar')) {
+            return 'alignment';
+        }
+        return null;
+    }
+    visualPresentationTargetField(response, request) {
+        const text = this.normalizeLabel([
+            request?.prompt,
+            request?.pendingClarification?.sourcePrompt,
+            request?.pendingClarification?.assistantMessage,
+            response.message,
+            ...(response.questions ?? []),
+        ].filter(Boolean).join(' '));
+        const columns = this.toArray(this.adapter.getCurrentConfig()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column);
+        const matched = columns
+            .map((column) => {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                return null;
+            const header = this.stringValue(column['header']) || field;
+            const score = Math.max(this.visualPresentationTargetFieldScore(text, field), this.visualPresentationTargetFieldScore(text, header));
+            return score > 0 ? { field, score } : null;
+        })
+            .filter((entry) => !!entry)
+            .sort((a, b) => b.score - a.score)[0];
+        if (matched)
+            return matched.field;
+        const visibleColumns = columns.filter((column) => column['visible'] !== false);
+        const lastVisibleField = this.stringValue(visibleColumns[visibleColumns.length - 1]?.['field']);
+        return lastVisibleField || null;
+    }
+    visualPresentationTargetFieldScore(normalizedText, value) {
+        return this.filterFieldMentionVariants(value)
+            .filter((variant) => !!variant && this.normalizedTextContainsApproxPhrase(normalizedText, variant))
+            .reduce((score, variant) => Math.max(score, variant.length), 0);
+    }
+    visualPresentationOptionContextHints(rendererValue, field) {
+        const selected = {
+            selection: {
+                mode: 'renderer',
+                ...(field ? { field } : {}),
+                value: rendererValue,
+            },
+        };
+        if (field) {
+            selected['targetField'] = field;
+        }
+        return {
+            optionSelected: selected,
             presentation: {
                 kind: 'guided-option',
-                icon: 'check',
-                ctaLabel: 'Usar esta opção',
+                ctaLabel: 'Aplicar opção',
+                icon: this.visualPresentationIcon(rendererValue),
+                tone: 'primary',
             },
-        }));
+        };
+    }
+    visualPresentationIcon(rendererValue) {
+        switch (rendererValue) {
+            case 'badge':
+                return 'sell';
+            case 'icon':
+                return 'stars';
+            case 'alignment':
+                return 'format_align_left';
+            case 'two_lines':
+                return 'format_line_spacing';
+            default:
+                return 'check';
+        }
     }
     filterFieldCatalogEntryForClarificationLabel(label) {
         const normalized = this.normalizeLabel(label);