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

package/fesm2022/{praxisui-table-table-agentic-authoring-turn-flow-Dhte2er9.mjs → praxisui-table-table-agentic-authoring-turn-flow-4Deh8QJU.mjs}

@@ -301,6 +301,9 @@ class TableAgenticAuthoringTurnFlow {
         return this.selectedRecordSurfaces(contextHints).length > 0;
     }
     localRecommendedIntentResponse(request, contextHints) {
+        const declaredFilterConfirmation = this.localDeclaredFilterConfirmationResponse(request, contextHints);
+        if (declaredFilterConfirmation)
+            return declaredFilterConfirmation;
         const declaredFilterClarification = this.localDeclaredFilterClarificationCompletionResponse(request, contextHints);
         if (declaredFilterClarification)
             return declaredFilterClarification;
@@ -559,6 +562,76 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    localDeclaredFilterConfirmationResponse(request, contextHints) {
+        const pendingClarification = request.pendingClarification
+            ?? this.recoverDeclaredFilterConfirmationPendingClarificationFromMessages(request);
+        if (!pendingClarification)
+            return null;
+        if (request.action?.kind && !['clarify', 'submit'].includes(request.action.kind))
+            return null;
+        if (!this.runtimeOperationAllowed(contextHints, 'table.filter.apply'))
+            return null;
+        if (!this.pendingClarificationCanContinueDeclaredFilterApply(pendingClarification))
+            return null;
+        const normalizedPrompt = this.normalizeLabel([
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+        ].map((value) => this.stringValue(value)).filter(Boolean).join(' '));
+        if (!normalizedPrompt)
+            return null;
+        if (this.isShortNegativeClarificationAnswer(normalizedPrompt)) {
+            return {
+                type: 'info',
+                sessionId: request.sessionId,
+                message: 'Tudo bem, não alterei a tabela.',
+                warnings: [
+                    'declared-filter-confirmation-cancelled-by-short-negative',
+                ],
+            };
+        }
+        if (!this.isShortAffirmativeClarificationAnswer(normalizedPrompt))
+            return null;
+        const sourcePrompt = this.declaredFilterClarificationSourcePrompt(pendingClarification);
+        const normalizedGroundingPrompt = this.normalizeLabel([
+            sourcePrompt,
+            pendingClarification.assistantMessage,
+        ].filter(Boolean).join(' '));
+        if (!normalizedGroundingPrompt || !this.promptRequestsRuntimeFilter(normalizedGroundingPrompt))
+            return null;
+        if (this.promptRequestsVisualOrStructuralEdit(normalizedGroundingPrompt))
+            return null;
+        const criteria = this.resolveDeclaredFilterConfirmationCriteria(normalizedGroundingPrompt, pendingClarification, contextHints);
+        if (!criteria || !Object.keys(criteria).length)
+            return null;
+        const completedCriteria = this.dedupeRuntimeFilterCriteriaAgainstDiscreteDimensions(this.completeRuntimeFilterCriteriaWithSelectedCandidates(criteria, {
+            ...request,
+            prompt: sourcePrompt || pendingClarification.assistantMessage || request.prompt,
+        }));
+        return {
+            type: 'patch',
+            sessionId: request.sessionId,
+            patch: {
+                tableRuntimeOperations: {
+                    kind: 'praxis.table.runtime-operation.batch',
+                    source: 'declared-filter-confirmation-continuation',
+                    operations: [{
+                            operationId: 'table.filter.apply',
+                            input: {
+                                criteria: completedCriteria,
+                                criteriaSemantics: 'simple-conjunction',
+                                source: 'declared-filter-confirmation',
+                            },
+                        }],
+                },
+            },
+            explanation: 'Filtro confirmado a partir da clarificação anterior.',
+            warnings: [
+                'declared-filter-confirmation-continuation-materialized',
+                'A resposta curta confirmou uma clarificacao anterior ja ancorada em table.filter.apply e no filterFieldCatalog.',
+            ],
+        };
+    }
     localDeclaredFilterClarificationCompletionResponse(request, contextHints) {
         const pendingClarification = request.pendingClarification
             ?? this.recoverDeclaredFilterPendingClarificationFromMessages(request);
@@ -568,7 +641,7 @@ class TableAgenticAuthoringTurnFlow {
             return null;
         if (!this.runtimeOperationAllowed(contextHints, 'table.filter.apply'))
             return null;
-        const sourcePrompt = pendingClarification.sourcePrompt?.trim();
+        const sourcePrompt = this.declaredFilterClarificationSourcePrompt(pendingClarification);
         if (!sourcePrompt)
             return null;
         const normalizedSourcePrompt = this.normalizeLabel(sourcePrompt);
@@ -578,9 +651,15 @@ class TableAgenticAuthoringTurnFlow {
             return null;
         if (!this.pendingClarificationAsksForDeclaredFilter(request, pendingClarification))
             return null;
+        if (this.declaredFilterClarificationResponseIsNewFilterRequest(request, contextHints))
+            return null;
         const selectedEntry = this.filterFieldCatalogEntryForClarificationResponse(request, sourcePrompt);
-        if (!selectedEntry)
+        if (!selectedEntry) {
+            const unresolvedShortResponse = this.unresolvedDeclaredFilterShortConfirmationResponse(request, pendingClarification, sourcePrompt);
+            if (unresolvedShortResponse)
+                return unresolvedShortResponse;
             return null;
+        }
         const criteria = this.resolveDeclaredFilterCriteriaFromPrompt(normalizedSourcePrompt, contextHints) ?? {};
         const clarified = this.resolveClarifiedFilterCriterionFromSourcePrompt(normalizedSourcePrompt, selectedEntry, contextHints, criteria);
         if (!clarified)
@@ -616,6 +695,119 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    unresolvedDeclaredFilterShortConfirmationResponse(request, pendingClarification, sourcePrompt) {
+        const normalizedPrompt = this.normalizeLabel([
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+        ].map((value) => this.stringValue(value)).filter(Boolean).join(' '));
+        if (!normalizedPrompt)
+            return null;
+        if (this.isShortNegativeClarificationAnswer(normalizedPrompt)) {
+            return {
+                type: 'info',
+                sessionId: request.sessionId,
+                message: 'Tudo bem, não alterei a tabela. Você pode escolher um filtro ou fazer um novo pedido.',
+                warnings: [
+                    'declared-filter-clarification-cancelled-by-short-negative',
+                ],
+            };
+        }
+        if (!this.isShortAffirmativeClarificationAnswer(normalizedPrompt))
+            return null;
+        const optionPayloads = this.declaredFilterClarificationReminderOptionPayloads(request, pendingClarification, sourcePrompt);
+        if (optionPayloads.length <= 1)
+            return null;
+        return {
+            type: 'clarification',
+            sessionId: request.sessionId,
+            message: 'Ainda preciso que você escolha qual filtro deve receber esse critério antes de alterar a tabela.',
+            questions: ['Escolha uma das opções abaixo para continuar.'],
+            optionPayloads,
+            diagnostics: {
+                tableDeclaredFilterClarification: {
+                    sourcePrompt,
+                },
+            },
+            warnings: [
+                'declared-filter-short-affirmative-needs-explicit-field-choice',
+            ],
+        };
+    }
+    declaredFilterClarificationSourcePrompt(pendingClarification) {
+        const diagnostics = this.toRecord(pendingClarification?.diagnostics);
+        const declaredFilter = this.toRecord(diagnostics?.['tableDeclaredFilterClarification']);
+        const diagnosticSourcePrompt = this.stringValue(declaredFilter?.['sourcePrompt']).trim();
+        if (diagnosticSourcePrompt)
+            return diagnosticSourcePrompt;
+        return pendingClarification?.sourcePrompt?.trim() ?? '';
+    }
+    isShortAffirmativeClarificationAnswer(normalizedPrompt) {
+        return ['sim', 's', 'ok', 'okay', 'isso', 'pode', 'confirmo', 'confirmar']
+            .includes(normalizedPrompt);
+    }
+    isShortNegativeClarificationAnswer(normalizedPrompt) {
+        return ['nao', 'não', 'n', 'cancelar', 'cancela', 'deixa', 'deixa pra la', 'deixa pra lá']
+            .includes(normalizedPrompt);
+    }
+    declaredFilterClarificationReminderOptionPayloads(request, pendingClarification, sourcePrompt) {
+        const normalizedSourcePrompt = this.normalizeLabel(sourcePrompt);
+        const labels = [
+            ...(pendingClarification?.questions ?? []).flatMap((question) => (question.options ?? []).map((option) => option.label || option.value || option.id)),
+            ...this.declaredFilterQuickReplyOptions(normalizedSourcePrompt, {
+                ...request,
+                prompt: sourcePrompt,
+            }),
+        ]
+            .map((label) => this.stringValue(label).trim())
+            .filter((label) => !!label);
+        const seen = new Set();
+        return labels
+            .map((label) => this.filterFieldCatalogEntryForClarificationLabel(label) ?? {
+            name: label,
+            label: this.humanizeClarificationOptionLabel(label),
+        })
+            .filter((entry) => {
+            const key = this.normalizeLabel(entry.name || entry.label);
+            if (!key || seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        })
+            .map((entry) => ({
+            label: entry.label,
+            value: entry.name,
+            contextHints: {
+                tableFilterClarification: {
+                    source: 'declared-filter-field',
+                    field: entry.name,
+                    label: entry.label,
+                },
+            },
+        }));
+    }
+    declaredFilterClarificationResponseIsNewFilterRequest(request, contextHints) {
+        if (this.toRecord(request.action?.contextHints?.['tableFilterClarification']))
+            return false;
+        if (request.action?.kind === 'clarify')
+            return false;
+        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
+        if (!normalizedPrompt || !this.promptRequestsRuntimeFilter(normalizedPrompt))
+            return false;
+        if (this.promptRequestsVisualOrStructuralEdit(normalizedPrompt))
+            return false;
+        if (this.normalizedTextHasStandaloneToken(normalizedPrompt, 'agora'))
+            return true;
+        if (this.promptHasCompensationRangeIntent(normalizedPrompt) || this.promptHasDateRangeComparison(normalizedPrompt)) {
+            return true;
+        }
+        if (this.promptHasNumericRangeComparison(normalizedPrompt)
+            && this.filterFieldCatalogEntries.filter((entry) => this.isNumericRangeFilterEntry(entry)).length === 1) {
+            return true;
+        }
+        const criteria = this.resolveDeclaredFilterCriteriaFromPrompt(normalizedPrompt, contextHints);
+        return !!criteria && Object.keys(criteria).length > 0;
+    }
     pendingClarificationAsksForDeclaredFilter(request, pending) {
         const hinted = this.toRecord(request.action?.contextHints?.['tableFilterClarification']);
         if (hinted)
@@ -661,6 +853,78 @@ class TableAgenticAuthoringTurnFlow {
         }
         return null;
     }
+    recoverDeclaredFilterConfirmationPendingClarificationFromMessages(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;
+            if (!this.pendingClarificationCanContinueDeclaredFilterApply({
+                assistantMessage: message.text,
+                sourcePrompt: '',
+                questions: [],
+            }))
+                continue;
+            const sourcePrompt = [...messages.slice(0, index)]
+                .reverse()
+                .find((candidate) => candidate.role === 'user')
+                ?.text?.trim();
+            if (!sourcePrompt)
+                return null;
+            return {
+                sourcePrompt,
+                assistantMessage: message.text,
+                questions: [],
+            };
+        }
+        return null;
+    }
+    pendingClarificationConfirmsDeclaredFilterApply(pending) {
+        const text = this.normalizeLabel([
+            pending?.assistantMessage,
+            ...(pending?.questions ?? []).map((question) => [
+                question.label,
+                ...(question.options ?? []).map((option) => option.label),
+            ].flat().join(' ')),
+        ].filter(Boolean).join(' '));
+        if (!text)
+            return false;
+        const asksConfirmation = text.includes('confirma')
+            || text.includes('confirmar')
+            || text.includes('posso filtrar')
+            || text.includes('aplique esse filtro')
+            || text.includes('aplicar esse filtro');
+        const mentionsRuntimeFilter = text.includes('filtrar')
+            || text.includes('filtro')
+            || text.includes('apenas funcionarios')
+            || text.includes('apenas funcionários');
+        return asksConfirmation && mentionsRuntimeFilter;
+    }
+    pendingClarificationCanContinueDeclaredFilterApply(pending) {
+        return this.pendingClarificationConfirmsDeclaredFilterApply(pending)
+            || this.pendingClarificationDeclaresDeclaredFilterApply(pending);
+    }
+    pendingClarificationDeclaresDeclaredFilterApply(pending) {
+        const text = this.normalizeLabel([
+            pending?.assistantMessage,
+            ...(pending?.questions ?? []).map((question) => [
+                question.label,
+                ...(question.options ?? []).map((option) => option.label),
+            ].flat().join(' ')),
+        ].filter(Boolean).join(' '));
+        if (!text)
+            return false;
+        const declaresRuntimeOperation = text.includes('table.filter.apply')
+            || text.includes('operacao table filter apply')
+            || text.includes('operação table filter apply');
+        const declaresFiltering = text.includes('vou filtrar')
+            || text.includes('filtrar a tabela')
+            || text.includes('executando operacao')
+            || text.includes('executando operação');
+        return declaresRuntimeOperation && declaresFiltering;
+    }
     filterFieldCatalogEntryForClarificationResponse(request, sourcePrompt) {
         const hinted = this.toRecord(request.action?.contextHints?.['tableFilterClarification']);
         const hintedField = this.stringValue(hinted?.['field']);
@@ -746,12 +1010,60 @@ class TableAgenticAuthoringTurnFlow {
         const token = this.ungroundedFilterValueTokens(normalizedSourcePrompt, entry, criteria)[0];
         return token ? this.restoreFilterValueToken(token, normalizedSourcePrompt) : '';
     }
+    resolveImplicitTextCriteriaFromValueHints(normalizedPrompt, criteria) {
+        if (!normalizedPrompt)
+            return;
+        const matches = this.filterFieldCatalogEntries
+            .filter((entry) => criteria[entry.name] === undefined)
+            .filter((entry) => this.isTextualFilterCriterion(entry))
+            .map((entry) => ({
+            entry,
+            match: this.bestFilterValueHintMatch(normalizedPrompt, entry),
+        }))
+            .filter((candidate) => !!candidate.match)
+            .sort((left, right) => right.match.score - left.match.score || left.entry.label.localeCompare(right.entry.label));
+        if (!matches.length)
+            return;
+        const topScore = matches[0].match.score;
+        const winners = matches.filter((candidate) => candidate.match.score === topScore);
+        if (winners.length !== 1)
+            return;
+        criteria[winners[0].entry.name] = this.normalizeRuntimeFilterCriterionForCatalogEntry(winners[0].match.value, winners[0].entry);
+    }
+    bestFilterValueHintMatch(normalizedPrompt, entry) {
+        let best = null;
+        for (const hint of entry.valueHints) {
+            for (const candidate of this.filterValueHintCandidates(hint)) {
+                const normalizedCandidate = this.normalizeLabel(candidate);
+                if (!normalizedCandidate || normalizedCandidate.length < 4)
+                    continue;
+                if (!this.normalizedTextContainsApproxPhrase(normalizedPrompt, normalizedCandidate))
+                    continue;
+                const score = normalizedCandidate.split(/\s+/u).length * 25 + normalizedCandidate.length;
+                if (!best || score > best.score) {
+                    best = { value: candidate, score };
+                }
+            }
+        }
+        return best;
+    }
+    filterValueHintCandidates(hint) {
+        const trimmed = hint.trim();
+        if (!trimmed)
+            return [];
+        const candidates = new Set([trimmed]);
+        const prefix = trimmed.split(/\s+-\s+/u)[0]?.trim();
+        if (prefix && prefix.length >= 4)
+            candidates.add(prefix);
+        return [...candidates];
+    }
     ungroundedFilterValueTokens(normalizedPrompt, entry, criteria) {
         const ignoredTokens = new Set([
             'filtra',
             'filtrar',
             'filtre',
             'filtro',
+            'agora',
             'quero',
             'ver',
             'mostra',
@@ -762,6 +1074,26 @@ class TableAgenticAuthoringTurnFlow {
             'busca',
             'procura',
             'procurar',
+            'confirma',
+            'confirmar',
+            'aplique',
+            'aplicar',
+            'posso',
+            'para',
+            'eu',
+            'esse',
+            'essa',
+            'tabela',
+            'funcionario',
+            'funcionarios',
+            'funcionário',
+            'funcionários',
+            'qualquer',
+            'qq',
+            'depto',
+            'departamento',
+            'departamentos',
+            'serve',
             'de',
             'do',
             'da',
@@ -805,6 +1137,18 @@ class TableAgenticAuthoringTurnFlow {
             'admitidas',
             'admitiu',
             'admitiram',
+            'ganha',
+            'ganham',
+            'ganhando',
+            'recebe',
+            'recebem',
+            'recebendo',
+            'remuneracao',
+            'remuneração',
+            'pagamento',
+            'folha',
+            'salario',
+            'salário',
         ].map((token) => this.normalizeLabel(token)));
         const fieldMentionTokens = new Set([
             entry.name,
@@ -848,8 +1192,41 @@ class TableAgenticAuthoringTurnFlow {
     }
     unresolvedFilterCriterionOptions(normalizedPrompt, criteria) {
         const usedFields = new Set(Object.keys(criteria));
-        const ranked = this.filterFieldCatalogEntries
+        const hasSymbolicFilterValue = normalizedPrompt
+            .split(/\s+/u)
+            .some((token) => token.length >= 2
+            && /[&/+.]/u.test(token)
+            && !this.tokenIsGroundedByAppliedCriteria(token, criteria));
+        const hasUnresolvedDiscreteFilter = this.promptContainsMentionedUnresolvedDiscreteFilter(normalizedPrompt, criteria);
+        const narrowsByValueShape = !hasSymbolicFilterValue
+            && !hasUnresolvedDiscreteFilter
+            && (this.promptHasCompensationRangeIntent(normalizedPrompt)
+                || this.promptHasNumericRangeComparison(normalizedPrompt)
+                || this.promptHasDateRangeComparison(normalizedPrompt));
+        const candidateEntries = this.filterFieldCatalogEntries
             .filter((entry) => !usedFields.has(entry.name))
+            .filter((entry) => !this.promptMentionsFilterFieldAsNonRestrictiveScope(normalizedPrompt, entry))
+            .filter((entry) => {
+            if (!narrowsByValueShape)
+                return true;
+            if (this.promptHasCompensationRangeIntent(normalizedPrompt)) {
+                return this.isCompensationRangeFilterEntry(entry);
+            }
+            if (this.promptHasNumericRangeComparison(normalizedPrompt)) {
+                return this.isNumericRangeFilterEntry(entry);
+            }
+            if (this.promptHasDateRangeComparison(normalizedPrompt)) {
+                return this.isDateRangeFilterEntry(entry);
+            }
+            return true;
+        });
+        if (narrowsByValueShape && !candidateEntries.length) {
+            return [];
+        }
+        const fallbackEntries = this.filterFieldCatalogEntries
+            .filter((entry) => !usedFields.has(entry.name))
+            .filter((entry) => !this.promptMentionsFilterFieldAsNonRestrictiveScope(normalizedPrompt, entry));
+        const ranked = (candidateEntries.length ? candidateEntries : fallbackEntries)
             .map((entry) => ({
             entry,
             score: this.selectedRecordFilterValuePromptScore(entry, normalizedPrompt)
@@ -920,6 +1297,7 @@ class TableAgenticAuthoringTurnFlow {
                 ...entry.aliases,
                 ...entry.relatedColumnFields,
                 ...entry.relatedColumnLabels,
+                ...entry.valueHints,
                 ...displayValues,
             ];
             return values.some((value) => value && this.promptContainsAnyVariant(token, value));
@@ -937,7 +1315,9 @@ class TableAgenticAuthoringTurnFlow {
             'filtrar',
             'filtre',
             'filtro',
+            'agora',
             'quero',
+            'quem',
             'ver',
             'mostra',
             'mostrar',
@@ -947,6 +1327,26 @@ class TableAgenticAuthoringTurnFlow {
             'busca',
             'procura',
             'procurar',
+            'confirma',
+            'confirmar',
+            'aplique',
+            'aplicar',
+            'posso',
+            'para',
+            'eu',
+            'esse',
+            'essa',
+            'tabela',
+            'funcionario',
+            'funcionarios',
+            'funcionário',
+            'funcionários',
+            'qualquer',
+            'qq',
+            'depto',
+            'departamento',
+            'departamentos',
+            'serve',
             'de',
             'do',
             'da',
@@ -990,6 +1390,18 @@ class TableAgenticAuthoringTurnFlow {
             'admitidas',
             'admitiu',
             'admitiram',
+            'ganha',
+            'ganham',
+            'ganhando',
+            'recebe',
+            'recebem',
+            'recebendo',
+            'remuneracao',
+            'remuneração',
+            'pagamento',
+            'folha',
+            'salario',
+            'salário',
         ].map((token) => this.normalizeLabel(token)));
         const fieldMentionTokens = new Set([
             entry.name,
@@ -1023,12 +1435,14 @@ class TableAgenticAuthoringTurnFlow {
                 ? selectedCandidate['displayValues'].map((value) => this.stringValue(value)).filter((value) => !!value)
                 : [];
             return [
+                this.stringValue(criteria[field]),
                 entry.name,
                 entry.label,
                 this.humanizeFilterField(entry.name),
                 ...entry.aliases,
                 ...entry.relatedColumnFields,
                 ...entry.relatedColumnLabels,
+                ...entry.valueHints,
                 ...displayValues,
             ].some((value) => value && this.promptContainsAnyVariant(token, value));
         });
@@ -1046,6 +1460,7 @@ class TableAgenticAuthoringTurnFlow {
             'buscar',
             'procura',
             'procurar',
+            'quem',
             'mostra',
             'mostrar',
             'liste',
@@ -1062,6 +1477,19 @@ class TableAgenticAuthoringTurnFlow {
             'apos',
             'após',
             'desde',
+            'mais de',
+            'mais que',
+            'menos de',
+            'menos que',
+            'ganha',
+            'ganham',
+            'ganhando',
+            'recebe',
+            'recebem',
+            'remuneracao',
+            'remuneração',
+            'salario',
+            'salário',
         ].some((token) => normalizedPrompt.includes(this.normalizeLabel(token)));
     }
     promptRequestsVisualOrStructuralEdit(normalizedPrompt) {
@@ -1101,8 +1529,31 @@ class TableAgenticAuthoringTurnFlow {
         this.completeImplicitBooleanCriteriaFromPrompt(normalizedPrompt, criteria);
         this.completeImplicitDateRangeCriteriaFromPrompt(normalizedPrompt, criteria);
         this.completeImplicitNumericRangeCriteriaFromPrompt(normalizedPrompt, criteria);
+        if (!Object.keys(criteria).length) {
+            this.resolveImplicitTextCriteriaFromValueHints(normalizedPrompt, criteria);
+        }
         return Object.keys(criteria).length ? criteria : null;
     }
+    resolveDeclaredFilterConfirmationCriteria(normalizedGroundingPrompt, pendingClarification, contextHints) {
+        const criteria = this.resolveDeclaredFilterCriteriaFromPrompt(normalizedGroundingPrompt, contextHints);
+        if (criteria && Object.keys(criteria).length)
+            return criteria;
+        const assistantText = this.normalizeLabel(pendingClarification?.assistantMessage ?? '');
+        if (!assistantText)
+            return null;
+        const confirmedCriteria = {};
+        for (const entry of this.filterFieldCatalogEntries) {
+            if (!this.isTextualFilterCriterion(entry))
+                continue;
+            if (!this.promptMentionsFilterField(assistantText, entry.name))
+                continue;
+            const textValue = this.extractClarifiedTextFilterValue(assistantText, entry, confirmedCriteria);
+            if (textValue) {
+                confirmedCriteria[entry.name] = this.normalizeRuntimeFilterCriterionForCatalogEntry(textValue, entry);
+            }
+        }
+        return Object.keys(confirmedCriteria).length ? confirmedCriteria : null;
+    }
     completeImplicitBooleanCriteriaFromPrompt(normalizedPrompt, criteria) {
         if (!this.promptHasBooleanFilterValue(normalizedPrompt))
             return;
@@ -1202,13 +1653,33 @@ class TableAgenticAuthoringTurnFlow {
         const candidates = this.filterFieldCatalogEntries
             .filter((entry) => criteria[entry.name] === undefined)
             .filter((entry) => this.isNumericRangeFilterEntry(entry));
-        if (candidates.length !== 1)
+        const mentioned = candidates.filter((entry) => this.promptMentionsFilterField(normalizedPrompt, entry.name));
+        const compensation = mentioned.length ? [] : candidates.filter((entry) => this.isCompensationRangeFilterEntry(entry));
+        const eligible = mentioned.length ? mentioned : (this.promptHasCompensationRangeIntent(normalizedPrompt) ? compensation : candidates);
+        if (eligible.length !== 1)
             return;
-        const criterion = this.resolveRangeFilterValue(normalizedPrompt, candidates[0]);
+        const criterion = this.resolveRangeFilterValue(normalizedPrompt, eligible[0]);
         if (criterion !== undefined) {
-            criteria[candidates[0].name] = criterion;
+            criteria[eligible[0].name] = criterion;
         }
     }
+    promptHasCompensationRangeIntent(normalizedPrompt) {
+        return this.promptHasNumericRangeComparison(normalizedPrompt)
+            && [
+                'ganha',
+                'ganham',
+                'ganhando',
+                'recebe',
+                'recebem',
+                'recebendo',
+                'remuneracao',
+                'remuneração',
+                'pagamento',
+                'folha',
+                'salario',
+                'salário',
+            ].some((token) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, this.normalizeLabel(token)));
+    }
     promptHasNumericRangeComparison(normalizedPrompt) {
         return /\b\d+(?:[,.]\d+)?(?:\s*(?:mil|k))?\b/u.test(normalizedPrompt)
             && this.promptHasAnyToken(normalizedPrompt, [
@@ -1257,6 +1728,34 @@ class TableAgenticAuthoringTurnFlow {
             || valueShape.includes('number');
         return isRange && isNumericLike && !isDateLike;
     }
+    isCompensationRangeFilterEntry(entry) {
+        if (!this.isNumericRangeFilterEntry(entry))
+            return false;
+        const text = this.normalizeLabel([
+            entry.name,
+            entry.label,
+            this.humanizeFilterField(entry.name),
+            entry.controlType,
+            entry.criterionKind,
+            entry.criterionValueShape,
+            ...entry.aliases,
+            ...entry.relatedColumnFields,
+            ...entry.relatedColumnLabels,
+        ].join(' '));
+        return [
+            'salario',
+            'salário',
+            'salary',
+            'remuneracao',
+            'remuneração',
+            'compensacao',
+            'compensação',
+            'pagamento',
+            'folha',
+            'wage',
+            'pay',
+        ].some((token) => this.normalizedTextContainsApproxPhrase(text, this.normalizeLabel(token)));
+    }
     resolveDeclaredFilterCriterionValue(normalizedPrompt, entry, contextHints) {
         const type = this.normalizeLabel(entry.type ?? '');
         const controlType = this.normalizeLabel(entry.controlType ?? '');
@@ -1671,16 +2170,24 @@ class TableAgenticAuthoringTurnFlow {
         if (response.type === 'clarification') {
             const questions = this.toClarificationQuestions(response, request);
             const diagnostics = this.buildClarificationDiagnostics(response);
+            const sourcePrompt = this.pendingClarificationSourcePromptForTurn(request, diagnostics);
+            const assistantMessage = response.message || 'Preciso de mais detalhes para continuar.';
             return {
                 state: 'clarification',
                 phase: 'clarify',
                 sessionId: response.sessionId ?? request.sessionId,
                 observationId: response.observationId ?? request.observationId ?? null,
-                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                assistantMessage,
                 clarificationQuestions: questions,
                 quickReplies: this.toQuickReplies(response, request),
                 canApply: false,
                 diagnostics,
+                pendingClarification: {
+                    sourcePrompt,
+                    assistantMessage,
+                    questions,
+                    diagnostics,
+                },
             };
         }
         if (response.type === 'info') {
@@ -1765,6 +2272,10 @@ class TableAgenticAuthoringTurnFlow {
             if (continuedEarlyColumnPlan) {
                 return this.compileAdapterResponse(continuedEarlyColumnPlan, request);
             }
+            const continuedColumnVisibilityPlan = this.columnVisibilityPlanForGroundedClarification(response, request);
+            if (continuedColumnVisibilityPlan) {
+                return this.compileAdapterResponse(continuedColumnVisibilityPlan, request);
+            }
             const compiledExecutable = !this.responseCarriesClarificationChoices(response)
                 && this.responseMayContainExecutableEnvelope(response)
                 ? this.adapter.compileAiResponse?.(response)
@@ -1784,6 +2295,10 @@ class TableAgenticAuthoringTurnFlow {
                     warnings: warnings.length ? warnings : undefined,
                 };
                 delete executableResponse.type;
+                const columnVisibilitySurfaceMismatch = this.columnVisibilityPlanForMisroutedSurfaceRuntime(executableResponse, request);
+                if (columnVisibilitySurfaceMismatch) {
+                    return this.compileAdapterResponse(columnVisibilitySurfaceMismatch, request);
+                }
                 const visualSurfaceMismatch = this.visualPresentationSurfaceRuntimeMismatch(executableResponse, request);
                 if (visualSurfaceMismatch) {
                     return visualSurfaceMismatch;
@@ -1795,6 +2310,10 @@ class TableAgenticAuthoringTurnFlow {
                 return executableResponse;
             }
             if (compiledExecutable?.type === 'error') {
+                const continuedColumnVisibilityError = this.columnVisibilityPlanForMisroutedSurfaceError(response, request, compiledExecutable);
+                if (continuedColumnVisibilityError) {
+                    return this.compileAdapterResponse(continuedColumnVisibilityError, request);
+                }
                 const continuedInvalidExecutable = this.selectedRecordSurfaceRuntimeOperationForInvalidExecutable(response, request, compiledExecutable.warnings);
                 if (continuedInvalidExecutable) {
                     return continuedInvalidExecutable;
@@ -1809,6 +2328,10 @@ class TableAgenticAuthoringTurnFlow {
                     warnings: compiledExecutable.warnings,
                 };
             }
+            const continuedColumnVisibilityNarrative = this.columnVisibilityPlanForGroundedNarrative(response, request);
+            if (continuedColumnVisibilityNarrative) {
+                return this.compileAdapterResponse(continuedColumnVisibilityNarrative, request);
+            }
             const continuedSurfaceRowActionFromInfo = this.selectedRecordSurfaceRowActionPlanForInfo(response, request);
             if (continuedSurfaceRowActionFromInfo) {
                 return this.compileAdapterResponse(continuedSurfaceRowActionFromInfo, request);
@@ -1887,6 +2410,10 @@ class TableAgenticAuthoringTurnFlow {
             };
         }
         if (!compiled) {
+            const continuedColumnVisibilityNarrative = this.columnVisibilityPlanForGroundedNarrative(response, request);
+            if (continuedColumnVisibilityNarrative) {
+                return this.compileAdapterResponse(continuedColumnVisibilityNarrative, request);
+            }
             const continuedColumnFormatNarrative = this.columnFormatPlanForNonExecutableNarrative(response, request);
             if (continuedColumnFormatNarrative) {
                 return this.compileAdapterResponse(continuedColumnFormatNarrative, request);
@@ -1898,6 +2425,10 @@ class TableAgenticAuthoringTurnFlow {
             return response;
         }
         if (compiled.type === 'error') {
+            const continuedColumnVisibilityError = this.columnVisibilityPlanForMisroutedSurfaceError(response, request, compiled);
+            if (continuedColumnVisibilityError) {
+                return this.compileAdapterResponse(continuedColumnVisibilityError, request);
+            }
             const continuedBulkRouteAction = this.bulkRouteActionPlanForInvalidExecutable(response, request, compiled.warnings);
             if (continuedBulkRouteAction) {
                 return this.compileAdapterResponse(continuedBulkRouteAction, request);
@@ -1953,6 +2484,10 @@ class TableAgenticAuthoringTurnFlow {
             patch: normalizedCompiled.patch,
             warnings: warnings.length ? warnings : undefined,
         };
+        const columnVisibilitySurfaceMismatch = this.columnVisibilityPlanForMisroutedSurfaceRuntime(compiledResponse, request);
+        if (columnVisibilitySurfaceMismatch) {
+            return this.compileAdapterResponse(columnVisibilitySurfaceMismatch, request);
+        }
         const visualSurfaceMismatch = this.visualPresentationSurfaceRuntimeMismatch(compiledResponse, request);
         if (visualSurfaceMismatch) {
             return visualSurfaceMismatch;
@@ -4100,6 +4635,28 @@ class TableAgenticAuthoringTurnFlow {
             ?? this.booleanSimNaoOperationsFromGroundedClarification(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromSingleGroundedBooleanColumn(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromGroundedResponseField(prompt, responseText, columns);
+        const promptRequestsSimNao = this.normalizedTextIncludesAny(this.normalizeLabel(prompt), [
+            'sim nao',
+            'sim/nao',
+            'sim não',
+            'sim/não',
+            'sim ou nao',
+            'sim ou não',
+        ]);
+        const responseGroundsBooleanSimNao = this.normalizedTextIncludesAny(normalizedResponse, [
+            'sim quando true',
+            'sim quando verdadeiro',
+            'nao quando false',
+            'não quando false',
+            'nao quando falso',
+            'não quando falso',
+            'sim para true',
+            'sim para verdadeiro',
+            'nao para false',
+            'não para false',
+            'nao para falso',
+            'não para falso',
+        ]);
         const booleanFormatClarification = !!booleanOperations?.length && this.normalizedTextIncludesAny(normalizedResponse, [
             'sim nao',
             'sim / nao',
@@ -4110,7 +4667,7 @@ class TableAgenticAuthoringTurnFlow {
             'badges com textos sim nao',
             'mostrar apenas texto sim nao',
             'valores booleanos como sim ou nao',
-        ]);
+        ]) || (!!booleanOperations?.length && promptRequestsSimNao && responseGroundsBooleanSimNao);
         if (booleanOperations?.length && (booleanInfo || booleanFormatClarification)) {
             return this.componentEditPlanResponse(booleanOperations, 'Vou mostrar o booleano como Sim/Nao na coluna indicada.', [
                 ...(response.warnings ?? []),
@@ -4882,6 +5439,199 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    columnVisibilityPlanForMisroutedSurfaceRuntime(response, request) {
+        if (!request)
+            return null;
+        const prompt = this.columnVisibilityPromptForTurn(request);
+        if (!this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(prompt)))
+            return null;
+        if (!this.patchContainsRuntimeOperationId(response.patch, 'dynamicPage.surface.open'))
+            return null;
+        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']))
+            : [];
+        const operations = this.columnVisibilityOperationsFromPrompt(prompt, columns);
+        if (!operations.length) {
+            return {
+                type: 'clarification',
+                sessionId: request.sessionId,
+                message: 'Entendi que o pedido é sobre ocultar ou exibir colunas, não sobre abrir uma superfície do registro.',
+                questions: ['Quais colunas você quer ocultar ou exibir?'],
+                options: columns
+                    .slice(0, 8)
+                    .map((column) => this.stringValue(column['header']) || this.stringValue(column['field']))
+                    .filter((label) => !!label),
+                warnings: [
+                    ...(response.warnings ?? []),
+                    'column-visibility-request-blocked-surface-runtime-operation',
+                ],
+            };
+        }
+        return this.componentEditPlanResponse(operations, 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
+            ...(response.warnings ?? []),
+            'column-visibility-continued-from-surface-runtime-misroute',
+            'Residual continuity guard acted only after the LLM proposed dynamicPage.surface.open for a column visibility/privacy request grounded in declared table columns.',
+        ]);
+    }
+    columnVisibilityPlanForGroundedClarification(response, request) {
+        if (!request)
+            return null;
+        if (response.type !== 'clarification')
+            return null;
+        const prompt = this.columnVisibilityPromptForTurn(request);
+        if (!this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(prompt)))
+            return null;
+        const questionText = [
+            response.message,
+            ...(response.questions ?? []),
+            ...(response.options ?? []),
+        ].join(' ');
+        const asksForColumn = this.normalizedTextIncludesAny(this.normalizeLabel(questionText), [
+            'qual coluna',
+            'quais colunas',
+            'coluna devo usar',
+            'colunas devo usar',
+        ]);
+        const asksForVisibilityScope = this.normalizedTextIncludesAny(this.normalizeLabel(questionText), [
+            'globalmente',
+            'todos os usuarios',
+            'todos os usuários',
+            'apresentacao publica',
+            'apresentação pública',
+            'visualizacao publica',
+            'visualização pública',
+            'vista padrao',
+            'vista padrão',
+            'confirma qual opcao',
+            'confirma qual opção',
+        ]);
+        if (!asksForColumn && !asksForVisibilityScope)
+            return null;
+        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']))
+            : [];
+        const operations = this.columnVisibilityOperationsFromPrompt(prompt, columns);
+        if (!operations.length)
+            return null;
+        return this.componentEditPlanResponse(operations, 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
+            ...(response.warnings ?? []),
+            'column-visibility-continued-from-grounded-clarification',
+            'Residual continuity guard acted only after the LLM asked which column to use even though the column visibility request was grounded in declared table columns.',
+        ]);
+    }
+    columnVisibilityPlanForGroundedNarrative(response, request) {
+        if (!request)
+            return null;
+        const prompt = this.columnVisibilityPromptForTurn(request);
+        if (!this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(prompt)))
+            return null;
+        const responseText = this.normalizeLabel([
+            response.message,
+            response.explanation,
+            response.code,
+        ].join(' '));
+        const narratesVisibilityPlan = this.normalizedTextIncludesAny(responseText, [
+            'componenteditplan',
+            'column.visibility.set',
+            'visible false',
+            'invisivel',
+            'invisível',
+            'ocultar a coluna',
+            'ocultar as colunas',
+        ]);
+        if (!narratesVisibilityPlan)
+            return null;
+        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']))
+            : [];
+        const operations = this.columnVisibilityOperationsFromPrompt(prompt, columns);
+        if (!operations.length)
+            return null;
+        return this.componentEditPlanResponse(operations, 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
+            ...(response.warnings ?? []),
+            'column-visibility-continued-from-non-executable-narrative',
+            'Residual continuity guard acted only after the LLM narrated a column visibility plan without returning an executable envelope.',
+        ]);
+    }
+    columnVisibilityPlanForMisroutedSurfaceError(response, request, compiledError) {
+        if (!request)
+            return null;
+        const prompt = this.columnVisibilityPromptForTurn(request);
+        if (!this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(prompt)))
+            return null;
+        const errorText = this.normalizeLabel([
+            response.message,
+            response.explanation,
+            compiledError.message,
+            compiledError.explanation,
+            ...(compiledError.warnings ?? []),
+        ].join(' '));
+        if (!this.normalizedTextIncludesAny(errorText, [
+            'dynamicpage.surface.open',
+            'surface.open',
+            'superficie',
+            'superfície',
+        ]))
+            return null;
+        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']))
+            : [];
+        const operations = this.columnVisibilityOperationsFromPrompt(prompt, columns);
+        if (!operations.length)
+            return null;
+        return this.componentEditPlanResponse(operations, 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
+            ...(response.warnings ?? []),
+            ...(compiledError.warnings ?? []),
+            'column-visibility-continued-from-surface-runtime-error',
+            'Residual continuity guard acted only after a misrouted surface runtime operation failed validation for a column visibility request.',
+        ]);
+    }
+    columnVisibilityPromptForTurn(request) {
+        const currentPrompt = (request.prompt ?? '').trim();
+        if (this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(currentPrompt))) {
+            return currentPrompt;
+        }
+        const previousVisibilityPrompt = [...(request.messages ?? [])]
+            .reverse()
+            .filter((message) => message.role === 'user')
+            .map((message) => message.text.trim())
+            .find((message) => this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(message)));
+        return [previousVisibilityPrompt, currentPrompt]
+            .filter((part) => !!part)
+            .join(' ');
+    }
+    columnVisibilityOperationsFromPrompt(prompt, columns) {
+        const hide = !this.normalizedTextIncludesAny(this.normalizeLabel(prompt), [
+            'exibir',
+            'mostrar coluna',
+            'mostra coluna',
+            'revelar',
+        ]);
+        const operations = [];
+        for (const column of columns) {
+            const field = this.stringValue(column['field']);
+            if (!field || !this.textMentionsColumn(prompt, column))
+                continue;
+            operations.push({
+                operationId: 'column.visibility.set',
+                target: { kind: 'column', field },
+                input: { visible: !hide },
+            });
+        }
+        return operations;
+    }
     requestCarriesVisualPresentationContext(request) {
         const actionHints = this.toRecord(request.action?.contextHints);
         const requestHints = this.toRecord(request.contextHints);
@@ -4907,6 +5657,8 @@ class TableAgenticAuthoringTurnFlow {
         if (!normalizedPrompt)
             return false;
         const entry = this.filterFieldCatalogEntries.find((candidate) => candidate.name === fieldName);
+        if (entry && this.promptMentionsFilterFieldAsNonRestrictiveScope(normalizedPrompt, entry))
+            return false;
         const rawCandidates = [
             fieldName,
             this.humanizeFilterField(fieldName),
@@ -4919,6 +5671,59 @@ class TableAgenticAuthoringTurnFlow {
             .flatMap((candidate) => this.filterFieldMentionVariants(candidate ?? ''))
             .some((candidate) => candidate && this.normalizedTextContainsApproxPhrase(normalizedPrompt, candidate));
     }
+    promptMentionsFilterFieldAsNonRestrictiveScope(normalizedPrompt, entry) {
+        const variants = [
+            entry.name,
+            entry.label,
+            this.humanizeFilterField(entry.name),
+            ...entry.aliases,
+            ...entry.relatedColumnFields,
+            ...entry.relatedColumnLabels,
+        ].flatMap((candidate) => this.filterFieldMentionVariants(candidate ?? ''));
+        return variants.some((variant) => {
+            if (!variant)
+                return false;
+            return [
+                `qualquer ${variant}`,
+                `qq ${variant}`,
+                `tanto faz ${variant}`,
+                `${variant} tanto faz`,
+                `${variant} qualquer`,
+                `independente de ${variant}`,
+                `nao importa ${variant}`,
+                `${variant} nao importa`,
+            ].some((phrase) => this.normalizedTextContainsExactPhrase(normalizedPrompt, this.normalizeLabel(phrase)));
+        });
+    }
+    removeNonRestrictiveFilterFieldClauses(value) {
+        let normalized = value.trim();
+        if (!normalized)
+            return '';
+        const fieldTerms = this.filterFieldCatalogEntries
+            .flatMap((entry) => [
+            entry.name,
+            entry.label,
+            this.humanizeFilterField(entry.name),
+            ...entry.aliases,
+            ...entry.relatedColumnFields,
+            ...entry.relatedColumnLabels,
+        ])
+            .flatMap((term) => this.filterFieldMentionVariants(term ?? ''))
+            .filter((term, index, terms) => !!term && terms.indexOf(term) === index);
+        for (const term of fieldTerms) {
+            const escaped = term.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+            normalized = normalized
+                .replace(new RegExp(`(?:,|;)?\\s*(?:tanto faz|qualquer|qq|independente de|nao importa|não importa)\\s+${escaped}\\b`, 'giu'), '')
+                .replace(new RegExp(`(?:,|;)?\\s*${escaped}\\s+(?:tanto faz|qualquer|nao importa|não importa)\\b`, 'giu'), '');
+        }
+        return normalized.trim();
+    }
+    normalizedTextContainsExactPhrase(normalizedText, normalizedPhrase) {
+        if (!normalizedText || !normalizedPhrase)
+            return false;
+        const escaped = normalizedPhrase.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&').replace(/\s+/gu, '\\s+');
+        return new RegExp(`(^|[^a-z0-9])${escaped}($|[^a-z0-9])`, 'u').test(normalizedText);
+    }
     selectedRecordFilterPromptGroundingScore(prompt, candidate) {
         const fieldName = this.stringValue(candidate['field']);
         if (!fieldName)
@@ -5471,7 +6276,20 @@ class TableAgenticAuthoringTurnFlow {
     }
     buildClarificationDiagnostics(response) {
         const continuation = this.extractPendingComponentEditContinuation(response);
-        return continuation ? { tableComponentEditContinuation: continuation } : undefined;
+        const responseDiagnostics = this.toRecord(response.diagnostics);
+        if (!continuation && !responseDiagnostics)
+            return undefined;
+        return {
+            ...(responseDiagnostics ?? {}),
+            ...(continuation ? { tableComponentEditContinuation: continuation } : {}),
+        };
+    }
+    pendingClarificationSourcePromptForTurn(request, diagnostics) {
+        const declaredFilter = this.toRecord(diagnostics?.['tableDeclaredFilterClarification']);
+        return this.stringValue(declaredFilter?.['sourcePrompt']).trim()
+            || request.pendingClarification?.sourcePrompt?.trim()
+            || request.prompt?.trim()
+            || '';
     }
     buildReviewDiagnostics(response, warnings) {
         const memory = this.extractComponentEditDecisionMemory(response);
@@ -6355,6 +7173,9 @@ class TableAgenticAuthoringTurnFlow {
         const normalizedOptions = new Set(options
             .map((option) => this.normalizeLabel(option))
             .filter((option) => !!option));
+        if (this.promptRequestsColumnVisibilityEdit(prompt)) {
+            return null;
+        }
         const promptLooksLikeFilter = this.promptRequestsRuntimeFilter(prompt)
             || ['filtro', 'filtrar', 'busca', 'buscar', 'procura', 'procurar', 'mostra', 'mostrar'].some((token) => this.normalizedTextContainsApproxToken(prompt, token));
         const responseLooksFilterFieldClarification = responseText.includes('filtro declarado')
@@ -6516,7 +7337,7 @@ class TableAgenticAuthoringTurnFlow {
             return quoted;
         const match = trimmed.match(/\b(?:de|da|do|dos|das|por|com|contendo|contem|contém)\s+(.{2,})$/iu);
         const candidate = (match?.[1] ?? '').trim();
-        return candidate
+        return this.removeNonRestrictiveFilterFieldClauses(candidate)
             .replace(/[?.!,;:]+$/u, '')
             .trim();
     }
@@ -6554,6 +7375,7 @@ class TableAgenticAuthoringTurnFlow {
                     };
                 });
             }
+            return [];
         }
         if ((response.type === 'clarification' || response.type === 'info')
             && this.shouldCurateVisibilityClarificationQuickReplies(response, prompt)) {
@@ -6662,6 +7484,49 @@ class TableAgenticAuthoringTurnFlow {
         // semantic scope choices the user needs to answer.
         return true;
     }
+    promptRequestsColumnVisibilityEdit(normalizedPrompt) {
+        if (!normalizedPrompt)
+            return false;
+        const asksVisibilityOrPrivacy = [
+            'ocultacao',
+            'ocultação',
+            'oculta',
+            'ocultar',
+            'esconde',
+            'esconder',
+            'remova a coluna',
+            'remover a coluna',
+            'remova as colunas',
+            'remover as colunas',
+            'tirar da visualizacao',
+            'tirar da visualização',
+            'publico',
+            'público',
+            'privacidade',
+            'sensivel',
+            'sensível',
+        ].some((token) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, token));
+        if (!asksVisibilityOrPrivacy)
+            return false;
+        const mentionsColumnScope = [
+            'coluna',
+            'colunas',
+            'visualizacao',
+            'visualização',
+            'tabela',
+            'email',
+            'e-mail',
+            'salario',
+            'salário',
+            'cpf',
+            'documento',
+            'telefone',
+        ].some((token) => this.normalizedTextContainsApproxPhrase(normalizedPrompt, token));
+        // Residual guard only: the LLM/authoring contract still decides the primary
+        // intent. Once a turn is already in a column-visibility scope, filter
+        // quick-reply curation must not reinterpret it as row filtering.
+        return mentionsColumnScope;
+    }
     visibilityClarificationQuickReplyOptions() {
         return [
             {
@@ -6706,6 +7571,10 @@ class TableAgenticAuthoringTurnFlow {
         const optionCount = response.options?.length ?? 0;
         if (payloadCount <= 0 && optionCount <= 0)
             return false;
+        if (this.promptRequestsColumnVisibilityEdit(normalizedPrompt))
+            return false;
+        if (payloadCount > 0 && normalizedPrompt && !this.promptRequestsRuntimeFilter(normalizedPrompt))
+            return false;
         if (this.responseAsksForDeclaredFilterField(response))
             return true;
         if (!normalizedPrompt || !this.promptRequestsRuntimeFilter(normalizedPrompt))