@praxisui/page-builder 8.0.0-beta.27 → 8.0.0-beta.29

package/fesm2022/praxisui-page-builder.mjs

@@ -25,7 +25,7 @@ import * as i6$1 from '@angular/material/divider';
 import { MatDividerModule } from '@angular/material/divider';
 import * as i6$2 from '@angular/material/select';
 import { MatSelectModule } from '@angular/material/select';
-import { BehaviorSubject, merge, timeout, map, switchMap, Observable, firstValueFrom, from, concatMap, catchError, of, lastValueFrom } from 'rxjs';
+import { BehaviorSubject, merge, timeout, map, switchMap, Observable, from, firstValueFrom, concatMap, catchError, of, filter, take } from 'rxjs';
 import { SETTINGS_PANEL_DATA } from '@praxisui/settings-panel';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import * as i7 from '@angular/material/tabs';
@@ -2401,13 +2401,14 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.panelAria': 'AI page authoring',
     'praxis.pageBuilder.agentic.title': 'Praxis semantic copilot',
     'praxis.pageBuilder.agentic.subtitle': 'Author governed decisions with previews, confirmation, and runtime materialization.',
-    'praxis.pageBuilder.agentic.header.title.page': 'Praxis page copilot',
+    'praxis.pageBuilder.agentic.header.title.page': 'Praxis page decision copilot',
     'praxis.pageBuilder.agentic.header.title.widget': 'Praxis widget copilot',
     'praxis.pageBuilder.agentic.header.title.review': 'Praxis review copilot',
     'praxis.pageBuilder.agentic.header.title.governed': 'Praxis governed copilot',
-    'praxis.pageBuilder.agentic.header.subtitle.page': 'Author page-level layout, widgets and governed materialization.',
+    'praxis.pageBuilder.agentic.header.subtitle.page': 'Turn intent into layout, widgets, and governed materializations.',
     'praxis.pageBuilder.agentic.header.subtitle.route': 'Authoring page route {route}.',
     'praxis.pageBuilder.agentic.header.subtitle.widget': 'Focused on {target}.',
+    'praxis.pageBuilder.agentic.header.subtitle.reviewBlocked': 'Preview ready for governed review.',
     'praxis.pageBuilder.agentic.header.subtitle.review': 'Preview ready for review and persistence.',
     'praxis.pageBuilder.agentic.header.subtitle.governed': 'Continue the governed semantic-decision flow.',
     'praxis.pageBuilder.agentic.header.mode.page': 'Page',
@@ -2429,7 +2430,9 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.dock.summaryIdle': 'Conversation preserved. Continue where you stopped.',
     'praxis.pageBuilder.agentic.promptLabel': 'Message',
     'praxis.pageBuilder.agentic.promptPlaceholder': 'Describe the page, dashboard, form, or change you need.',
-    'praxis.pageBuilder.agentic.emptyConversation': 'Tell me what you want to create or change. I will ask follow-up questions before applying the preview.',
+    'praxis.pageBuilder.agentic.emptyConversation': 'Describe the outcome you want. I will ground the context, prepare a governed preview, and wait for review before applying anything.',
+    'praxis.pageBuilder.agentic.emptyConversation.blankGeneric': 'This host page is still blank. Tell me what decision or activity this app needs to support. I can suggest a dashboard, table, form, or review flow, then turn it into a governed preview for you to review before anything changes.',
+    'praxis.pageBuilder.agentic.emptyConversation.existingPage': 'Tell me what you want to improve here. I can read the current layout, widgets, route, and governed context, then prepare a preview for you to review before anything changes.',
     'praxis.pageBuilder.agentic.conversationAria': 'AI conversation',
     'praxis.pageBuilder.agentic.quickRepliesAria': 'Quick replies',
     'praxis.pageBuilder.agentic.contextAria': 'Active context',
@@ -2445,6 +2448,23 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.context.governedDomainContextRequest': 'Requested context',
     'praxis.pageBuilder.agentic.context.governedDomainContextSize': 'Grounding size',
     'praxis.pageBuilder.agentic.context.sharedRuleTargetLayer': 'Target materialization',
+    'praxis.pageBuilder.agentic.context.semanticDecisionResource': 'Source',
+    'praxis.pageBuilder.agentic.context.semanticDecisionKind': 'Goal',
+    'praxis.pageBuilder.agentic.context.semanticDecisionEvidence': 'Review',
+    'praxis.pageBuilder.agentic.context.operationCreate': 'Create',
+    'praxis.pageBuilder.agentic.context.operationUpdate': 'Adjust',
+    'praxis.pageBuilder.agentic.context.operationRead': 'Explore',
+    'praxis.pageBuilder.agentic.context.artifactDashboard': 'dashboard',
+    'praxis.pageBuilder.agentic.context.artifactTable': 'table',
+    'praxis.pageBuilder.agentic.context.artifactForm': 'form',
+    'praxis.pageBuilder.agentic.context.artifactPage': 'screen',
+    'praxis.pageBuilder.agentic.context.changeAnalytics': 'with analysis',
+    'praxis.pageBuilder.agentic.context.changeDashboard': 'with dashboard view',
+    'praxis.pageBuilder.agentic.context.changeTable': 'with details',
+    'praxis.pageBuilder.agentic.context.changeForm': 'with editing',
+    'praxis.pageBuilder.agentic.context.evidenceReviewRequired': 'Needs field review',
+    'praxis.pageBuilder.agentic.context.evidenceLowConfidence': 'Needs source confirmation',
+    'praxis.pageBuilder.agentic.context.evidenceGrounded': 'Source confirmed',
     'praxis.pageBuilder.agentic.editMessage': 'Edit',
     'praxis.pageBuilder.agentic.resendMessage': 'Resend',
     'praxis.pageBuilder.agentic.removeAttachment': 'Remove attachment',
@@ -2454,7 +2474,7 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.mode.diagnostic': 'Diagnostic',
     'praxis.pageBuilder.agentic.mode.review': 'Review',
     'praxis.pageBuilder.agentic.mode.inlineHelp': 'Help',
-    'praxis.pageBuilder.agentic.state.idle': 'Idle',
+    'praxis.pageBuilder.agentic.state.idle': 'Ready',
     'praxis.pageBuilder.agentic.state.listening': 'Ready',
     'praxis.pageBuilder.agentic.state.processing': 'Processing',
     'praxis.pageBuilder.agentic.state.clarification': 'Waiting for input',
@@ -2486,9 +2506,16 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.exploratory.capability.table': 'tables',
     'praxis.pageBuilder.agentic.exploratory.capability.form': 'forms',
     'praxis.pageBuilder.agentic.exploratory.capability.masterDetail': 'master-detail pages',
-    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'I found APIs that can feed this screen. Choose one before generating the preview.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'I found {sourceCount} for this screen. I recommend starting with {first} because it is the best fit for charts, KPIs, and drill-down. Review the cards below to see what each source is good for, what it returns, and what I will create after you select it.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.sourceCountSingular': '1 candidate source',
+    'praxis.pageBuilder.agentic.resourceDiscovery.sourceCountPlural': '{count} candidate sources',
     'praxis.pageBuilder.agentic.resourceDiscovery.empty': 'I did not find a matching API yet. Describe the business data this screen should use.',
     'praxis.pageBuilder.agentic.resourceDiscovery.useResource': 'Use {resourcePath}',
+    'praxis.pageBuilder.agentic.resourceDiscovery.defaultRecommendedLabel': 'the first option',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardDescription': 'Recommended source for turning {label} into a dashboard: helps choose charts, lists, filters, and formats before materializing the screen.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardBestFor': 'Use when you want to understand whether {label} answers the business goal before creating widgets.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardReturns': 'Suggests metrics, dimensions, filters, value formats, charts, and detail lists compatible with the source.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardNextStep': 'Select it so I can propose a governed preview with rich cards, drill-down, and sensible default formats.',
     'praxis.pageBuilder.agentic.diagnostics.title': 'LLM diagnostics',
     'praxis.pageBuilder.agentic.diagnostics.badge': 'Debug',
     'praxis.pageBuilder.agentic.diagnostics.description': 'Prompt, context bundle, and tool catalog returned by the backend for this turn.',
@@ -2510,10 +2537,12 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.status.refinedCandidates': 'Reviewing the retrieved resources with the AI...',
     'praxis.pageBuilder.agentic.status.projectKnowledgeRetrieved': 'Retrieved governed project knowledge for this authoring turn.',
     'praxis.pageBuilder.agentic.status.projectKnowledgeRetrievedCount': 'Retrieved {count} governed project knowledge signals for this authoring turn.',
-    'praxis.pageBuilder.agentic.status.projectKnowledgeAuditCited': '{cited} of {count} governed project knowledge signals were cited in sourceRefs.',
+    'praxis.pageBuilder.agentic.status.projectKnowledgeAuditCited': 'Governed knowledge cited: {cited} of {count}.',
     'praxis.pageBuilder.agentic.status.previewing': 'Generating preview...',
     'praxis.pageBuilder.agentic.status.previewCompile': 'Compiling preview...',
     'praxis.pageBuilder.agentic.status.previewReady': 'Preview applied to the page.',
+    'praxis.pageBuilder.agentic.status.reviewReady': 'Ready for review.',
+    'praxis.pageBuilder.agentic.status.reviewNeedsAttention': 'Review the pending points before saving.',
     'praxis.pageBuilder.agentic.status.acceptedAddLocalField': 'Local field added to the form.',
     'praxis.pageBuilder.agentic.status.acceptedRemoveLocalField': 'Local field removed from the form.',
     'praxis.pageBuilder.agentic.status.acceptedRelabelField': 'Field label updated.',
@@ -2820,9 +2849,10 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.header.title.widget': 'Copiloto de componente Praxis',
     'praxis.pageBuilder.agentic.header.title.review': 'Copiloto de revisão Praxis',
     'praxis.pageBuilder.agentic.header.title.governed': 'Copiloto governado Praxis',
-    'praxis.pageBuilder.agentic.header.subtitle.page': 'Autore layout, widgets e materialização governada no nível da página.',
+    'praxis.pageBuilder.agentic.header.subtitle.page': 'Transforme intenção em layout, widgets e materializações governadas.',
     'praxis.pageBuilder.agentic.header.subtitle.route': 'Autoria da rota {route}.',
     'praxis.pageBuilder.agentic.header.subtitle.widget': 'Foco em {target}.',
+    'praxis.pageBuilder.agentic.header.subtitle.reviewBlocked': 'Prévia pronta para revisão governada.',
     'praxis.pageBuilder.agentic.header.subtitle.review': 'Prévia pronta para revisão e persistência.',
     'praxis.pageBuilder.agentic.header.subtitle.governed': 'Continue o fluxo governado de decisão semântica.',
     'praxis.pageBuilder.agentic.header.mode.page': 'Página',
@@ -2844,7 +2874,9 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.dock.summaryIdle': 'Conversa preservada. Continue de onde parou.',
     'praxis.pageBuilder.agentic.promptLabel': 'Mensagem',
     'praxis.pageBuilder.agentic.promptPlaceholder': 'Descreva a página, dashboard, formulário ou alteração que você precisa.',
-    'praxis.pageBuilder.agentic.emptyConversation': 'Diga o que você quer criar ou alterar. Vou fazer perguntas antes de aplicar a pré-visualização.',
+    'praxis.pageBuilder.agentic.emptyConversation': 'Descreva o resultado que você quer. Vou fundamentar o contexto, preparar uma prévia governada e aguardar revisão antes de aplicar qualquer mudança.',
+    'praxis.pageBuilder.agentic.emptyConversation.blankGeneric': 'Esta página do host ainda está em branco. Conte qual decisão ou atividade este app precisa apoiar. Posso sugerir um dashboard, tabela, formulário ou fluxo de revisão e transformar isso em uma prévia governada para você revisar antes de qualquer mudança.',
+    'praxis.pageBuilder.agentic.emptyConversation.existingPage': 'Conte o que você quer melhorar aqui. Posso ler o layout atual, widgets, rota e contexto governado, depois preparar uma prévia para você revisar antes de qualquer mudança.',
     'praxis.pageBuilder.agentic.conversationAria': 'Conversa com IA',
     'praxis.pageBuilder.agentic.quickRepliesAria': 'Respostas rápidas',
     'praxis.pageBuilder.agentic.contextAria': 'Contexto ativo',
@@ -2860,6 +2892,23 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.context.governedDomainContextRequest': 'Contexto solicitado',
     'praxis.pageBuilder.agentic.context.governedDomainContextSize': 'Tamanho do grounding',
     'praxis.pageBuilder.agentic.context.sharedRuleTargetLayer': 'Materialização alvo',
+    'praxis.pageBuilder.agentic.context.semanticDecisionResource': 'Fonte',
+    'praxis.pageBuilder.agentic.context.semanticDecisionKind': 'Objetivo',
+    'praxis.pageBuilder.agentic.context.semanticDecisionEvidence': 'Revisão',
+    'praxis.pageBuilder.agentic.context.operationCreate': 'Criar',
+    'praxis.pageBuilder.agentic.context.operationUpdate': 'Ajustar',
+    'praxis.pageBuilder.agentic.context.operationRead': 'Consultar',
+    'praxis.pageBuilder.agentic.context.artifactDashboard': 'dashboard',
+    'praxis.pageBuilder.agentic.context.artifactTable': 'tabela',
+    'praxis.pageBuilder.agentic.context.artifactForm': 'formulário',
+    'praxis.pageBuilder.agentic.context.artifactPage': 'tela',
+    'praxis.pageBuilder.agentic.context.changeAnalytics': 'com análise',
+    'praxis.pageBuilder.agentic.context.changeDashboard': 'com visão gerencial',
+    'praxis.pageBuilder.agentic.context.changeTable': 'com detalhes',
+    'praxis.pageBuilder.agentic.context.changeForm': 'com edição',
+    'praxis.pageBuilder.agentic.context.evidenceReviewRequired': 'Precisa revisar campos',
+    'praxis.pageBuilder.agentic.context.evidenceLowConfidence': 'Precisa confirmar fonte',
+    'praxis.pageBuilder.agentic.context.evidenceGrounded': 'Fonte confirmada',
     'praxis.pageBuilder.agentic.editMessage': 'Editar',
     'praxis.pageBuilder.agentic.resendMessage': 'Reenviar',
     'praxis.pageBuilder.agentic.removeAttachment': 'Remover anexo',
@@ -2869,7 +2918,7 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.mode.diagnostic': 'Diagnóstico',
     'praxis.pageBuilder.agentic.mode.review': 'Revisão',
     'praxis.pageBuilder.agentic.mode.inlineHelp': 'Ajuda',
-    'praxis.pageBuilder.agentic.state.idle': 'Ocioso',
+    'praxis.pageBuilder.agentic.state.idle': 'Pronto',
     'praxis.pageBuilder.agentic.state.listening': 'Pronto',
     'praxis.pageBuilder.agentic.state.processing': 'Processando',
     'praxis.pageBuilder.agentic.state.clarification': 'Aguardando resposta',
@@ -2901,9 +2950,16 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.exploratory.capability.table': 'tabelas',
     'praxis.pageBuilder.agentic.exploratory.capability.form': 'formulários',
     'praxis.pageBuilder.agentic.exploratory.capability.masterDetail': 'páginas master-detail',
-    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'Encontrei APIs que podem alimentar esta tela. Escolha uma antes de gerar a pré-visualização.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.found': 'Encontrei {sourceCount} para esta tela. Minha recomendação é começar por {first}, porque parece a melhor opção para gráficos, KPIs e drill-down. Revise os cards abaixo para entender quando usar cada fonte, o que ela retorna e o que eu vou criar depois da seleção.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.sourceCountSingular': '1 fonte candidata',
+    'praxis.pageBuilder.agentic.resourceDiscovery.sourceCountPlural': '{count} fontes candidatas',
     'praxis.pageBuilder.agentic.resourceDiscovery.empty': 'Ainda não encontrei uma API correspondente. Descreva quais dados de negócio esta tela deve usar.',
     'praxis.pageBuilder.agentic.resourceDiscovery.useResource': 'Usar {resourcePath}',
+    'praxis.pageBuilder.agentic.resourceDiscovery.defaultRecommendedLabel': 'a primeira opção',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardDescription': 'Fonte recomendada para transformar {label} em painel: ajuda a escolher gráficos, listas, filtros e formatos antes de materializar a tela.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardBestFor': 'Quando você quer entender se {label} responde ao objetivo de negócio antes de criar widgets.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardReturns': 'Sugere métricas, dimensões, filtros, formatos de valor, gráficos e listas de detalhe compatíveis com a fonte.',
+    'praxis.pageBuilder.agentic.resourceDiscovery.cardNextStep': 'Selecione para eu propor uma pré-visualização governada com cards ricos, drill-down e formatos adequados por padrão.',
     'praxis.pageBuilder.agentic.diagnostics.title': 'Diagnóstico do LLM',
     'praxis.pageBuilder.agentic.diagnostics.badge': 'Debug',
     'praxis.pageBuilder.agentic.diagnostics.description': 'Prompt, pacote de contexto e catálogo de ferramentas retornados pelo backend para este turno.',
@@ -2925,10 +2981,12 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.status.refinedCandidates': 'Estou revisando os recursos encontrados com a IA...',
     'praxis.pageBuilder.agentic.status.projectKnowledgeRetrieved': 'Recuperei conhecimento governado do projeto para este turno de autoria.',
     'praxis.pageBuilder.agentic.status.projectKnowledgeRetrievedCount': 'Recuperei {count} sinais de conhecimento governado do projeto para este turno.',
-    'praxis.pageBuilder.agentic.status.projectKnowledgeAuditCited': '{cited} de {count} sinais de conhecimento governado foram citados em sourceRefs.',
+    'praxis.pageBuilder.agentic.status.projectKnowledgeAuditCited': 'Conhecimento governado citado: {cited} de {count}.',
     'praxis.pageBuilder.agentic.status.previewing': 'Gerando pré-visualização...',
     'praxis.pageBuilder.agentic.status.previewCompile': 'Compilando pré-visualização...',
     'praxis.pageBuilder.agentic.status.previewReady': 'Pré-visualização aplicada à página.',
+    'praxis.pageBuilder.agentic.status.reviewReady': 'Pronto para revisar.',
+    'praxis.pageBuilder.agentic.status.reviewNeedsAttention': 'Revise os pontos pendentes antes de salvar.',
     'praxis.pageBuilder.agentic.status.acceptedAddLocalField': 'Campo local adicionado ao formulário.',
     'praxis.pageBuilder.agentic.status.acceptedRemoveLocalField': 'Campo local removido do formulário.',
     'praxis.pageBuilder.agentic.status.acceptedRelabelField': 'Rótulo do campo atualizado.',
@@ -11134,7 +11192,7 @@ function providePageBuilderWidgetAiCatalogs() {
 
 const DEFAULT_AGENTIC_AUTHORING_REQUEST_TIMEOUT_MS = 15000;
 const DEFAULT_TURN_STREAM_START_TIMEOUT_MS = 10000;
-const DEFAULT_TURN_STREAM_TIMEOUT_MS = 60000;
+const DEFAULT_TURN_STREAM_TIMEOUT_MS = 240000;
 const PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS = new InjectionToken('PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS');
 class PageBuilderAgenticAuthoringService {
     http = inject(HttpClient);
@@ -11166,6 +11224,7 @@ class PageBuilderAgenticAuthoringService {
             scope: body.scope,
             tags: body.tags,
             compiledFormPatch: body.compiledFormPatch,
+            semanticDecision: body.semanticDecision ?? null,
         }, {
             headers: this.buildHeaders(ifMatch ? { 'If-Match': this.formatEtag(ifMatch) } : undefined),
         });
@@ -11544,7 +11603,7 @@ const PRAXIS_PAGE_BUILDER_AUTHORING_MANIFEST = {
         { name: 'pageChange', type: 'WidgetPageDefinition', description: 'Emitted after local apply/preview produces a renderable page.' },
         { name: 'agenticAuthoringEnableStreaming', type: 'boolean', description: 'Opt-in flag for the canonical streaming turn endpoints.' },
         { name: 'agenticAuthoringIncludeLlmDiagnostics', type: 'boolean', description: 'Opt-in flag that exposes governed diagnostics as cockpit evidence for validation and debugging.' },
-        { name: 'agenticAuthoringContextHints', type: 'Record<string, unknown>', description: 'Host-provided semantic hints, including governed domain-catalog references used to ground AI-authored decisions.' },
+        { name: 'agenticAuthoringContextHints', type: 'Record<string, unknown>', description: 'Host-provided semantic hints, including governed domain-catalog references and optional RAG-authored openingMessage used to ground AI-authored decisions.' },
     ],
     editableTargets: [
         { kind: 'page', resolver: 'widget-page-definition-root', description: 'Root WidgetPageDefinition document: title, metadata, context and renderable page envelope.' },
@@ -12328,6 +12387,84 @@ function clone(value) {
     }
 }
 
+const RUNTIME_AUTHORING_METADATA_INPUTS = [
+    'schemaVerification',
+    'schemaEvidenceSource',
+    'schemaEvidenceUrl',
+];
+function normalizePageBuilderRuntimePage(page) {
+    if (!page?.widgets?.length) {
+        return page;
+    }
+    return {
+        ...page,
+        widgets: page.widgets.map((widget) => normalizePageBuilderRuntimeWidget(widget)),
+    };
+}
+function normalizePageBuilderRuntimeWidget(widget) {
+    const definition = widget.definition;
+    if (!definition?.inputs) {
+        return widget;
+    }
+    const inputs = { ...definition.inputs };
+    for (const key of RUNTIME_AUTHORING_METADATA_INPUTS) {
+        delete inputs[key];
+    }
+    if (definition.id === 'praxis-rich-content') {
+        if (inputs['kpis'] !== undefined) {
+            const document = isRecord(inputs['document']) ? inputs['document'] : {};
+            inputs['document'] = {
+                ...document,
+                kpis: document['kpis'] ?? inputs['kpis'],
+            };
+        }
+        delete inputs['kpis'];
+        delete inputs['resourcePath'];
+        delete inputs['schemaUrl'];
+    }
+    if (definition.id === 'praxis-filter') {
+        if (!String(inputs['resourcePath'] || '').trim()) {
+            const inferredResourcePath = inferResourcePathFromSchemaUrl(inputs['schemaUrl']);
+            if (inferredResourcePath) {
+                inputs['resourcePath'] = inferredResourcePath;
+            }
+        }
+        delete inputs['schemaUrl'];
+    }
+    if (definition.id === 'praxis-table') {
+        delete inputs['title'];
+        delete inputs['schemaUrl'];
+        delete inputs['submitUrl'];
+        delete inputs['submitMethod'];
+    }
+    return {
+        ...widget,
+        definition: {
+            ...definition,
+            inputs,
+        },
+    };
+}
+function inferResourcePathFromSchemaUrl(schemaUrl) {
+    const raw = String(schemaUrl || '').trim();
+    if (!raw)
+        return undefined;
+    try {
+        const url = new URL(raw, 'http://praxis.local');
+        const path = url.searchParams.get('path') || url.searchParams.get('resourcePath');
+        if (path)
+            return path;
+    }
+    catch {
+        // Keep the fallback below for partial schema URLs.
+    }
+    const match = raw.match(/[?&](?:path|resourcePath)=([^&]+)/);
+    return match?.[1] ? decodeURIComponent(match[1]) : undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
 const LEGACY_OPTIONS_KEY = 'options';
 const LEGACY_LAYOUT_KEY = 'layout';
 class PageBuilderAiAdapter {
@@ -12452,7 +12589,8 @@ class PageBuilderAiAdapter {
             return page;
         const cloned = this.clone(page);
         const { [LEGACY_OPTIONS_KEY]: _legacyOptions, ...rest } = cloned;
-        const widgets = (cloned.widgets || []).map((w) => this.stripLegacyLayoutFields(w));
+        const widgets = (cloned.widgets || [])
+            .map((w) => normalizePageBuilderRuntimeWidget(this.stripLegacyLayoutFields(w)));
         return {
             ...rest,
             widgets,
@@ -12472,7 +12610,8 @@ class PageBuilderAiAdapter {
             return page;
         const cloned = this.clone(page);
         const { [LEGACY_OPTIONS_KEY]: _legacyOptions, ...rest } = cloned;
-        const widgets = (cloned.widgets || []).map((w) => this.stripLegacyLayoutFields(w));
+        const widgets = (cloned.widgets || [])
+            .map((w) => normalizePageBuilderRuntimeWidget(this.stripLegacyLayoutFields(w)));
         return {
             ...rest,
             widgets,
@@ -12846,6 +12985,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 phase: 'capture',
             });
         }
+        const contextualActionContext = this.contextualPreviewActionContextFromRequest(request);
+        if (contextualActionContext) {
+            return from(this.submitContextualPreviewAction(request, prompt, contextualActionContext));
+        }
         if (this.context.enableTurnStream?.() === true && this.service.streamTurn) {
             return this.submitWithTurnStream(request, prompt);
         }
@@ -12863,9 +13006,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
             const componentCapabilities = await this.context.loadComponentCapabilities();
             const selectedWidgetKey = this.context.selectedWidgetKey();
             const intentResolution = await firstValueFrom(this.service.resolveIntent(this.buildIntentResolutionRequest(prompt, selectedWidgetKey, componentCapabilities, authoringContext)));
-            const intentAssistantMessage = this.resolveIntentAssistantMessage(intentResolution);
+            const intentQuickReplies = this.resolveShellQuickReplies(intentResolution);
+            const intentAssistantMessage = this.normalizeAssistantMessageForQuickReplies(this.resolveIntentAssistantMessage(intentResolution), intentQuickReplies);
             if (intentAssistantMessage) {
-                const quickReplies = this.toShellQuickReplies(intentResolution.quickReplies ?? []);
+                const quickReplies = intentQuickReplies;
                 const explicitPendingClarification = this.toShellPendingClarification(intentResolution.pendingClarification);
                 const intentClarification = this.resolveIntentClarification(intentResolution);
                 const routeRequiredClarification = this.resolveSharedRuleRouteClarification(intentResolution, this.resolveEffectivePrompt(intentResolution, prompt), request.clientTurnId);
@@ -12873,10 +13017,13 @@ class PageBuilderAgenticAuthoringTurnFlow {
                     ?? (intentClarification
                         ? this.buildPendingClarificationForNextTurn(request, this.resolveEffectivePrompt(intentResolution, prompt), intentClarification)
                         : routeRequiredClarification);
+                const consultativeCatalogIntent = this.isConsultativeCatalogIntent(intentResolution);
                 const shouldAutoGenerateGuidedPreview = this.shouldAutoGenerateGuidedPreview(intentResolution, quickReplies, prompt) && !this.hasPendingClarificationQuestion(pendingClarification);
-                const mustPauseForClarification = (!this.isExecutableIntent(intentResolution) && !shouldAutoGenerateGuidedPreview)
+                const mustPauseForClarification = (!this.isExecutableIntent(intentResolution, request) && !shouldAutoGenerateGuidedPreview)
                     || this.hasPendingClarificationQuestion(pendingClarification);
-                if (mustPauseForClarification && !this.hasPendingClarificationQuestion(pendingClarification) && quickReplies.length === 0) {
+                if (mustPauseForClarification
+                    && !this.hasPendingClarificationQuestion(pendingClarification)
+                    && (quickReplies.length === 0 || consultativeCatalogIntent)) {
                     return {
                         state: 'success',
                         phase: 'summarize',
@@ -12925,7 +13072,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
                     state: 'clarification',
                     phase: 'clarify',
                     assistantMessage: clarification,
-                    quickReplies: this.toShellQuickReplies(intentResolution.quickReplies ?? []),
+                    quickReplies: this.resolveShellQuickReplies(intentResolution),
                     canApply: false,
                     statusText: '',
                     errorText: '',
@@ -12953,7 +13100,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 model: this.context.model(),
                 apiKey: this.context.apiKey(),
                 currentPage: this.context.currentPage(),
-                selectedWidgetKey,
+                selectedWidgetKey: this.resolveSelectedWidgetKey(selectedWidgetKey, authoringContext.contextHints),
                 intentResolution,
                 componentCapabilities,
                 ...authoringContext,
@@ -12986,14 +13133,13 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 };
             }
             const status = this.context.describePreviewStatus(preview);
-            const statusText = this.withProjectKnowledgeAuditStatus(status, preview);
             return {
                 state: 'review',
                 phase: 'review',
                 assistantMessage: status,
                 quickReplies: [],
                 canApply: true,
-                statusText,
+                statusText: this.reviewStatusText(status, true),
                 errorText: '',
                 preview,
                 diagnostics: { intentResolution },
@@ -13035,21 +13181,68 @@ class PageBuilderAgenticAuthoringTurnFlow {
             pendingPatch: null,
         };
     }
+    async submitContextualPreviewAction(request, prompt, contextHints) {
+        const componentId = this.readString(contextHints, 'targetComponentId')
+            || this.readString(contextHints, 'selectedComponentId');
+        const artifactKind = this.readString(contextHints, 'artifactKind')
+            || (componentId === 'praxis-table' ? 'table' : componentId === 'praxis-dynamic-form' ? 'form' : 'chart');
+        const changeKind = this.readString(contextHints, 'changeKind') || 'contextual_component_action';
+        const intentResolution = {
+            valid: true,
+            operationKind: 'modify',
+            artifactKind,
+            changeKind,
+            authoringProfile: 'component-capability-catalog',
+            targetApp: this.context.targetApp,
+            targetComponentId: this.context.targetComponentId,
+            target: componentId
+                ? {
+                    componentId,
+                    widgetKey: this.readString(contextHints, 'targetWidgetKey')
+                        || this.readString(contextHints, 'selectedWidgetKey')
+                        || this.context.selectedWidgetKey()
+                        || '',
+                    resourcePath: this.readString(contextHints, 'resourcePath'),
+                    schemaUrl: this.readString(contextHints, 'schemaUrl'),
+                    submitUrl: this.readString(contextHints, 'submitUrl'),
+                    submitMethod: this.readString(contextHints, 'submitMethod'),
+                }
+                : null,
+            selectedCandidate: this.contextualActionCandidate(contextHints),
+            candidates: [],
+            gate: {
+                gateId: 'component-capability-catalog',
+                status: 'eligible',
+                messages: [],
+            },
+            effectivePrompt: prompt,
+            assistantMessage: null,
+            quickReplies: [],
+            pendingClarification: null,
+            clarificationQuestions: [],
+            warnings: [],
+            failureCodes: [],
+            currentPageSummary: {},
+            contextHints,
+        };
+        return this.completeExecutableStreamPreview(request, prompt, intentResolution, undefined);
+    }
     async buildTurnStreamRequest(request, prompt) {
         const componentCapabilities = await this.context.loadComponentCapabilities();
         const selectedWidgetKey = this.context.selectedWidgetKey();
+        const authoringContext = this.buildAuthoringContext(request);
         return {
             userPrompt: prompt,
             targetApp: this.context.targetApp,
             targetComponentId: this.context.targetComponentId,
             currentRoute: null,
             currentPage: this.context.currentPage(),
-            selectedWidgetKey,
+            selectedWidgetKey: this.resolveSelectedWidgetKey(selectedWidgetKey, authoringContext.contextHints),
             provider: this.context.provider(),
             model: this.context.model(),
             apiKey: this.context.apiKey(),
             componentCapabilities,
-            ...this.buildAuthoringContext(request),
+            ...authoringContext,
         };
     }
     async toTurnResultFromStreamEvent(event, request, prompt) {
@@ -13108,14 +13301,21 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 preview: null,
             };
         }
-        const assistantMessage = this.readString(payload, 'assistantMessage')
+        const rawAssistantMessage = this.readString(payload, 'assistantMessage')
             || this.resolveIntentAssistantMessage(intentResolution)
             || (preview ? this.context.describePreviewStatus(preview) : '');
         const rawQuickReplies = Array.isArray(payload['quickReplies'])
             ? payload['quickReplies']
             : intentResolution.quickReplies ?? [];
-        const quickReplies = this.toShellQuickReplies(rawQuickReplies);
+        const quickReplies = this.resolveShellQuickReplies(intentResolution, rawQuickReplies);
+        const assistantMessage = this.normalizeAssistantMessageForQuickReplies(rawAssistantMessage, quickReplies);
         const canApply = payload['canApply'] === true && !!preview?.valid;
+        const contextualExecutableIntent = request
+            ? this.toExecutableContextualComponentIntent(intentResolution, request)
+            : null;
+        if (!canApply && contextualExecutableIntent && request && prompt) {
+            return this.completeExecutableStreamPreview(request, prompt, contextualExecutableIntent, preview);
+        }
         if (canApply
             && request
             && prompt
@@ -13123,17 +13323,54 @@ class PageBuilderAgenticAuthoringTurnFlow {
             return this.completeExecutableStreamPreview(request, prompt, intentResolution, undefined);
         }
         if (!canApply) {
+            if (preview && this.hasMaterializablePreview(preview) && this.isGovernedBlockedStreamPreview(payload, preview)) {
+                const applied = await this.context.applyLocalPreview(preview);
+                if (!applied.success) {
+                    const message = applied.error || this.context.tx('agentic.errors.applyLocal', 'Preview could not be applied.');
+                    return {
+                        state: 'error',
+                        phase: 'preview',
+                        assistantMessage: message,
+                        canApply: false,
+                        statusText: '',
+                        errorText: message,
+                        preview: null,
+                        diagnostics: {
+                            intentResolution,
+                            preview,
+                            decisionDiagnostics: this.toJsonObject(payload['decisionDiagnostics']),
+                            toolLoopTrace: Array.isArray(payload['toolLoopTrace']) ? payload['toolLoopTrace'] : undefined,
+                        },
+                    };
+                }
+                return {
+                    state: 'review',
+                    phase: 'review',
+                    assistantMessage,
+                    quickReplies,
+                    canApply: false,
+                    statusText: this.reviewStatusText(assistantMessage, false),
+                    errorText: '',
+                    preview,
+                    diagnostics: {
+                        intentResolution,
+                        preview,
+                        decisionDiagnostics: this.toJsonObject(payload['decisionDiagnostics']),
+                        toolLoopTrace: Array.isArray(payload['toolLoopTrace']) ? payload['toolLoopTrace'] : undefined,
+                    },
+                };
+            }
             const pendingClarification = this.toShellPendingClarification(intentResolution?.pendingClarification)
                 ?? this.resolveSharedRuleRouteClarification(intentResolution, this.resolveEffectivePrompt(intentResolution, assistantMessage));
             if (!pendingClarification
-                && (this.isExecutableIntent(intentResolution)
+                && (this.isExecutableIntent(intentResolution, request)
                     || (!!prompt && this.shouldAutoGenerateGuidedPreview(intentResolution, quickReplies, prompt)))
                 && !this.hasBlockingResourceQuickReply(quickReplies)
                 && request
                 && prompt) {
                 return this.completeExecutableStreamPreview(request, prompt, intentResolution, preview);
             }
-            const requiresChoice = quickReplies.length > 0;
+            const requiresChoice = quickReplies.length > 0 && !this.isConsultativeCatalogIntent(intentResolution);
             return {
                 state: pendingClarification || requiresChoice ? 'clarification' : 'success',
                 phase: pendingClarification || requiresChoice ? 'clarify' : 'summarize',
@@ -13162,14 +13399,13 @@ class PageBuilderAgenticAuthoringTurnFlow {
             };
         }
         const status = assistantMessage || this.context.describePreviewStatus(preview);
-        const statusText = this.withProjectKnowledgeAuditStatus(status, preview);
         return {
             state: 'review',
             phase: 'review',
             assistantMessage: status,
-            quickReplies: [],
+            quickReplies,
             canApply: true,
-            statusText,
+            statusText: this.reviewStatusText(status, true),
             errorText: '',
             preview,
             diagnostics: { intentResolution, preview },
@@ -13182,7 +13418,10 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 return false;
             }
             const contextHints = this.toJsonObject(reply.contextHints);
-            return !!this.readString(contextHints, 'resourcePath');
+            if (this.isContextualPreviewActionReply(reply, contextHints)) {
+                return false;
+            }
+            return !!this.readString(contextHints, 'resourcePath') || this.isResourceQuickReply(reply);
         });
     }
     async completeExecutableStreamPreview(request, prompt, intentResolution, streamPreview) {
@@ -13190,6 +13429,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             const authoringContext = this.buildAuthoringContext(request);
             const componentCapabilities = await this.context.loadComponentCapabilities();
             const selectedWidgetKey = this.context.selectedWidgetKey();
+            const effectiveSelectedWidgetKey = this.resolveSelectedWidgetKey(selectedWidgetKey, authoringContext.contextHints);
             const reusableStreamPreview = streamPreview?.valid
                 && !this.shouldRegenerateStreamPreview(intentResolution, streamPreview);
             const preview = reusableStreamPreview
@@ -13200,7 +13440,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
                     model: this.context.model(),
                     apiKey: this.context.apiKey(),
                     currentPage: this.context.currentPage(),
-                    selectedWidgetKey,
+                    selectedWidgetKey: effectiveSelectedWidgetKey,
                     intentResolution,
                     componentCapabilities,
                     ...authoringContext,
@@ -13233,14 +13473,13 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 };
             }
             const status = this.context.describePreviewStatus(preview);
-            const statusText = this.withProjectKnowledgeAuditStatus(status, preview);
             return {
                 state: 'review',
                 phase: 'review',
                 assistantMessage: status,
                 quickReplies: [],
                 canApply: true,
-                statusText,
+                statusText: this.reviewStatusText(status, true),
                 errorText: '',
                 preview,
                 diagnostics: { intentResolution, preview },
@@ -13272,6 +13511,43 @@ class PageBuilderAgenticAuthoringTurnFlow {
         }
         return true;
     }
+    isGovernedBlockedStreamPreview(payload, preview) {
+        const previewDiagnostics = this.toJsonObject(preview.diagnostics);
+        const decisionDiagnostics = this.toJsonObject(payload['decisionDiagnostics'])
+            ?? this.toJsonObject(previewDiagnostics?.['decisionDiagnostics']);
+        if (decisionDiagnostics) {
+            if (decisionDiagnostics['requiresReview'] === true) {
+                return true;
+            }
+            if (decisionDiagnostics['decisionValid'] === false) {
+                return true;
+            }
+            if (this.readString(decisionDiagnostics, 'reviewReason')) {
+                return true;
+            }
+        }
+        const warnings = Array.isArray(preview.warnings)
+            ? preview.warnings.map((warning) => `${warning}`)
+            : [];
+        const failureCodes = Array.isArray(preview.failureCodes)
+            ? preview.failureCodes.map((code) => `${code}`)
+            : [];
+        return warnings.some((warning) => warning === 'semantic-preview-materialization-mismatch'
+            || warning === 'semantic-axis-schema-verification-pending')
+            || failureCodes.some((code) => code === 'semantic-decision-required'
+                || code.startsWith('semantic-preview-'));
+    }
+    hasMaterializablePreview(preview) {
+        if (!preview) {
+            return false;
+        }
+        if (preview.uiCompositionPlan) {
+            return true;
+        }
+        const patch = this.toJsonObject(preview.compiledFormPatch)?.['patch'];
+        const page = this.toJsonObject(patch)?.['page'];
+        return !!this.toJsonObject(page);
+    }
     phaseForStreamPayload(payload) {
         const phase = this.readString(payload, 'phase');
         if (phase === 'intent.resolve')
@@ -13322,21 +13598,22 @@ class PageBuilderAgenticAuthoringTurnFlow {
         }
         return base;
     }
-    withProjectKnowledgeAuditStatus(status, preview) {
-        const audit = this.toJsonObject(preview?.diagnostics?.projectKnowledgeAudit);
-        if (!audit) {
-            return status;
-        }
-        const influenceCount = this.readNumber(audit, 'influenceCount');
-        const citedCount = this.readNumber(audit, 'citedCount');
-        if (!influenceCount || influenceCount <= 0 || citedCount === null || citedCount < 0) {
-            return status;
+    reviewStatusText(status, canApply) {
+        const normalized = status.trim();
+        if (normalized && !this.shouldReplaceReviewStatus(normalized)) {
+            return normalized;
         }
-        const auditStatus = this.context
-            .tx('agentic.status.projectKnowledgeAuditCited', '{cited} of {count} governed project knowledge signals were cited in sourceRefs.')
-            .replace('{cited}', String(citedCount))
-            .replace('{count}', String(influenceCount));
-        return [status, auditStatus].filter((part) => !!part.trim()).join(' ');
+        return canApply
+            ? this.context.tx('agentic.status.reviewReady', 'Ready for review.')
+            : this.context.tx('agentic.status.reviewNeedsAttention', 'Review the pending points before saving.');
+    }
+    shouldReplaceReviewStatus(status) {
+        const normalized = status.toLocaleLowerCase();
+        return status.length > 80
+            || normalized.includes('preview applied')
+            || normalized.includes('pré-visualização')
+            || normalized.includes('pre-visualizacao')
+            || normalized.includes('sourcerefs');
     }
     isBackendResourceDiscoveryPayload(payload) {
         const diagnostics = this.toJsonObject(payload['diagnostics']);
@@ -13519,10 +13796,9 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const quickReplies = result.quickReplies?.length
             ? this.toShellQuickReplies(result.quickReplies)
             : this.toResourceCandidateQuickReplies(result.candidates, result.artifactKind);
-        const assistantMessage = result.assistantMessage?.trim()
-            || (quickReplies.length
-                ? this.context.tx('agentic.resourceDiscovery.found', 'I found APIs that can feed this screen. Choose one before generating the preview.')
-                : this.context.tx('agentic.resourceDiscovery.empty', 'I did not find a matching API yet. Describe the business data this screen should use.'));
+        const assistantMessage = quickReplies.length
+            ? this.resourceDiscoveryAssistantMessage(result.assistantMessage, quickReplies)
+            : this.context.tx('agentic.resourceDiscovery.empty', 'I did not find a matching API yet. Describe the business data this screen should use.');
         const intentResult = await this.resolveIntentAfterResourceDiscovery(request, request.pendingClarification?.sourcePrompt || prompt, contextHints, result, assistantMessage, quickReplies);
         if (intentResult) {
             return intentResult;
@@ -13569,12 +13845,16 @@ class PageBuilderAgenticAuthoringTurnFlow {
             ...authoringContext,
             contextHints: this.resourceDiscoveryContextHints(contextHints, result),
         })));
-        const assistantMessage = this.resolveIntentAssistantMessage(intentResolution)
+        const resolvedAssistantMessage = this.resolveIntentAssistantMessage(intentResolution)
             || this.resolveIntentClarification(intentResolution)
             || fallbackAssistantMessage;
         const quickReplies = intentResolution.quickReplies?.length
             ? this.toShellQuickReplies(intentResolution.quickReplies)
             : fallbackQuickReplies;
+        const assistantMessage = quickReplies.some((reply) => this.isResourceQuickReply(reply))
+            && this.isGenericResourceDiscoveryMessage(resolvedAssistantMessage)
+            ? fallbackAssistantMessage
+            : resolvedAssistantMessage;
         const explicitPendingClarification = this.toShellPendingClarification(intentResolution.pendingClarification);
         const routeRequiredClarification = this.resolveSharedRuleRouteClarification(intentResolution, this.resolveEffectivePrompt(intentResolution, prompt), request.clientTurnId);
         const pendingClarification = explicitPendingClarification
@@ -13637,6 +13917,37 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const contextHints = this.toJsonObject(request.action?.contextHints);
         return this.readString(contextHints, 'tool') === 'searchApiResources';
     }
+    resourceDiscoveryAssistantMessage(backendMessage, quickReplies) {
+        const backendText = backendMessage?.trim() ?? '';
+        if (backendText && !this.isGenericResourceDiscoveryMessage(backendText)) {
+            return backendText;
+        }
+        const firstLabel = quickReplies[0]?.label?.trim()
+            || this.context.tx('agentic.resourceDiscovery.defaultRecommendedLabel', 'the first option');
+        const sourceCount = this.resourceDiscoverySourceCountLabel(quickReplies.length);
+        return this.context.tx('agentic.resourceDiscovery.found', 'I found {sourceCount} for this screen. I recommend starting with {first} because it is the best fit for charts, KPIs, and drill-down. Review the cards below to see what each source is good for, what it returns, and what I will create after you select it.')
+            .replace('{sourceCount}', sourceCount)
+            .replace('{first}', firstLabel);
+    }
+    resourceDiscoverySourceCountLabel(count) {
+        const key = count === 1
+            ? 'agentic.resourceDiscovery.sourceCountSingular'
+            : 'agentic.resourceDiscovery.sourceCountPlural';
+        const fallback = count === 1 ? '1 candidate source' : '{count} candidate sources';
+        return this.context.tx(key, fallback).replace('{count}', String(count));
+    }
+    normalizeAssistantMessageForQuickReplies(assistantMessage, quickReplies) {
+        const message = assistantMessage?.trim() ?? '';
+        return quickReplies.some((reply) => this.isResourceQuickReply(reply))
+            ? this.resourceDiscoveryAssistantMessage(message, quickReplies)
+            : message;
+    }
+    isGenericResourceDiscoveryMessage(message) {
+        return /(?:encontrei|found).*(?:apis?|fontes?|sources?).*(?:escolha|choose)/iu.test(message)
+            || /(?:encontrei|found).*(?:fontes?|sources?).*(?:candidatas?|candidate)/iu.test(message)
+            || /(?:fonte|source).*(?:encontrada|found).*(?:escolha|choose)/iu.test(message)
+            || /(?:fonte|source).*(?:encontrada|found).*(?:catalogo|catalog)/iu.test(message);
+    }
     toResourceCandidateQuickReplies(candidates, artifactKind) {
         return candidates
             .filter((candidate) => !!candidate.resourcePath?.trim())
@@ -13696,20 +14007,184 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const message = intentResolution.assistantMessage?.trim();
         return message || null;
     }
-    isExecutableIntent(intentResolution) {
+    isExecutableIntent(intentResolution, request) {
         const operationKind = intentResolution.operationKind;
         const artifactKind = intentResolution.artifactKind;
         const allowsMaterializedArtifactOperation = operationKind === 'create'
             || operationKind === 'modify'
             || operationKind === 'remove';
         return !!intentResolution.valid
-            && intentResolution.gate?.status === 'eligible'
-            && ((allowsMaterializedArtifactOperation
-                && !!intentResolution.selectedCandidate
-                && (artifactKind === 'form'
-                    || artifactKind === 'dashboard'
-                    || artifactKind === 'table'))
-                || this.isExecutablePageCompositionIntent(intentResolution));
+            && (this.isExecutableContextualComponentIntent(intentResolution, request)
+                || (intentResolution.gate?.status === 'eligible'
+                    && ((allowsMaterializedArtifactOperation
+                        && !!intentResolution.selectedCandidate
+                        && (artifactKind === 'form'
+                            || artifactKind === 'dashboard'
+                            || artifactKind === 'table'
+                            || artifactKind === 'chart'))
+                        || this.isExecutablePageCompositionIntent(intentResolution))));
+    }
+    isExecutableContextualComponentIntent(intentResolution, request) {
+        const operationKind = intentResolution.operationKind;
+        const requestContextHints = this.contextualPreviewActionContextFromRequest(request)
+            ?? this.toJsonObject(request?.action?.contextHints)
+            ?? this.toJsonObject(request?.contextHints);
+        const requestIsContextualPreviewAction = this.isContextualPreviewActionContext(requestContextHints);
+        if (!requestIsContextualPreviewAction
+            && operationKind !== 'create'
+            && operationKind !== 'modify'
+            && operationKind !== 'remove') {
+            return false;
+        }
+        const contextHints = this.toJsonObject(intentResolution.contextHints)
+            ?? requestContextHints;
+        if (!this.isContextualPreviewActionContext(contextHints) && !requestIsContextualPreviewAction) {
+            return false;
+        }
+        const componentId = this.readString(contextHints, 'targetComponentId')
+            || this.readString(contextHints, 'selectedComponentId')
+            || this.readString(requestContextHints, 'targetComponentId')
+            || this.readString(requestContextHints, 'selectedComponentId')
+            || intentResolution.target?.componentId
+            || '';
+        return componentId === 'praxis-chart'
+            || componentId === 'praxis-table'
+            || componentId === 'praxis-dynamic-form';
+    }
+    toExecutableContextualComponentIntent(intentResolution, request) {
+        const requestContextHints = this.contextualPreviewActionContextFromRequest(request)
+            ?? this.toJsonObject(request.action?.contextHints)
+            ?? this.toJsonObject(request.contextHints);
+        if (!this.isContextualPreviewActionContext(requestContextHints)) {
+            return null;
+        }
+        const intentContextHints = this.toJsonObject(intentResolution.contextHints);
+        const contextHints = {
+            ...(requestContextHints ?? {}),
+            ...(intentContextHints ?? {}),
+        };
+        const componentId = this.readString(contextHints, 'targetComponentId')
+            || this.readString(contextHints, 'selectedComponentId')
+            || intentResolution.target?.componentId
+            || '';
+        if (componentId !== 'praxis-chart'
+            && componentId !== 'praxis-table'
+            && componentId !== 'praxis-dynamic-form') {
+            return null;
+        }
+        const currentOperation = intentResolution.operationKind;
+        const operationKind = currentOperation === 'create'
+            || currentOperation === 'modify'
+            || currentOperation === 'remove'
+            ? currentOperation
+            : 'modify';
+        const artifactKind = intentResolution.artifactKind
+            || this.readString(contextHints, 'artifactKind')
+            || (componentId === 'praxis-chart'
+                ? 'chart'
+                : componentId === 'praxis-table'
+                    ? 'table'
+                    : 'form');
+        const changeKind = this.readString(contextHints, 'changeKind')
+            || intentResolution.changeKind
+            || 'contextual_component_action';
+        return {
+            ...intentResolution,
+            valid: true,
+            operationKind,
+            artifactKind,
+            changeKind,
+            gate: {
+                ...(intentResolution.gate ?? { gateId: '', status: '', messages: [] }),
+                status: 'eligible',
+                messages: [],
+            },
+            pendingClarification: null,
+            clarificationQuestions: [],
+            failureCodes: [],
+            contextHints,
+        };
+    }
+    isContextualPreviewActionContext(contextHints) {
+        const hints = contextHints ?? null;
+        const hintSource = this.readString(hints, 'source');
+        const hintKind = this.readString(hints, 'kind');
+        return hintSource === 'component-capability-catalog'
+            || hintKind === 'contextual-preview-action';
+    }
+    contextualPreviewActionContextFromRequest(request) {
+        const explicit = this.toJsonObject(request?.action?.contextHints);
+        if (this.isContextualPreviewActionContext(explicit)) {
+            return explicit;
+        }
+        const actionId = request?.action?.id?.trim();
+        if (!actionId) {
+            return null;
+        }
+        const base = {
+            source: 'component-capability-catalog',
+            kind: 'contextual-preview-action',
+            operationKind: 'modify',
+        };
+        if (actionId === 'chart-change-line' || actionId === 'chart-change-donut') {
+            return {
+                ...base,
+                artifactKind: 'chart',
+                changeKind: 'set_chart_type',
+                chartType: actionId === 'chart-change-donut' ? 'donut' : 'line',
+                capabilityId: 'praxis-chart.type.set@0.1.0',
+                targetComponentId: 'praxis-chart',
+                selectedComponentId: 'praxis-chart',
+            };
+        }
+        if (actionId === 'chart-add-detail-table' || actionId === 'chart-add-detail-modal') {
+            return {
+                ...base,
+                artifactKind: 'chart',
+                changeKind: 'enable_chart_drilldown',
+                capabilityId: 'praxis-chart.drilldown.enable@0.1.0',
+                targetComponentId: 'praxis-chart',
+                selectedComponentId: 'praxis-chart',
+                ...(actionId === 'chart-add-detail-modal'
+                    ? {
+                        surfacePresentation: 'modal',
+                        surfaceActionId: 'surface.open',
+                        surfaceWidgetId: 'praxis-table',
+                    }
+                    : {}),
+            };
+        }
+        if (actionId === 'table-export-selected-rows') {
+            return {
+                ...base,
+                artifactKind: 'table',
+                changeKind: 'configure_export',
+                capabilityId: 'praxis-table.export.selected-rows@0.1.0',
+                targetComponentId: 'praxis-table',
+                selectedComponentId: 'praxis-table',
+            };
+        }
+        return null;
+    }
+    contextualActionCandidate(contextHints) {
+        const resourcePath = this.readString(contextHints, 'resourcePath');
+        if (!resourcePath) {
+            return null;
+        }
+        const submitUrl = this.readString(contextHints, 'submitUrl') || resourcePath;
+        const submitMethod = this.readString(contextHints, 'submitMethod')
+            || this.readString(contextHints, 'operation')
+            || 'get';
+        return {
+            resourcePath,
+            operation: submitMethod,
+            schemaUrl: this.readString(contextHints, 'schemaUrl'),
+            submitUrl,
+            submitMethod,
+            score: 1,
+            reason: 'component capability context',
+            evidence: ['component-capability-catalog'],
+        };
     }
     shouldAutoGenerateGuidedPreview(intentResolution, quickReplies, prompt) {
         if (!this.isGuidedPreviewIntent(intentResolution)) {
@@ -13734,6 +14209,61 @@ class PageBuilderAgenticAuthoringTurnFlow {
         return (artifactKind === 'dashboard' || artifactKind === 'page' || artifactKind === 'table' || artifactKind === 'form')
             && (intentResolution.operationKind === 'compose' || intentResolution.operationKind === 'explore');
     }
+    isConsultativeCatalogIntent(intentResolution) {
+        if (!intentResolution) {
+            return false;
+        }
+        const operationKind = intentResolution.operationKind;
+        const changeKind = intentResolution.changeKind;
+        return (operationKind === 'explore' || operationKind === 'explain')
+            && intentResolution.artifactKind === 'api_catalog'
+            && (changeKind === 'answer_api_catalog_question'
+                || changeKind === 'answer_catalog_question'
+                || changeKind === 'api_catalog_followup'
+                || intentResolution.authoringProfile === 'api-catalog-qa');
+    }
+    resolveShellQuickReplies(intentResolution, quickReplies = intentResolution.quickReplies ?? []) {
+        const effectiveQuickReplies = this.isConsultativeCatalogIntent(intentResolution)
+            ? quickReplies.filter((reply) => !this.isResourceCandidateQuickReply(reply))
+            : this.shouldSuppressWorkflowQuickReplies(intentResolution)
+                ? quickReplies.filter((reply) => !this.isWorkflowQuickReply(reply))
+                : quickReplies;
+        const shellQuickReplies = this.toShellQuickReplies(effectiveQuickReplies);
+        if (shellQuickReplies.length) {
+            return shellQuickReplies;
+        }
+        return this.contextualCapabilityFallbackQuickReplies(intentResolution);
+    }
+    shouldSuppressWorkflowQuickReplies(intentResolution) {
+        if (intentResolution.selectedCandidate || this.isConsultativeCatalogIntent(intentResolution)) {
+            return false;
+        }
+        const operationKind = (intentResolution.operationKind ?? '').trim().toLowerCase();
+        const artifactKind = (intentResolution.artifactKind ?? '').trim().toLowerCase();
+        const changeKind = (intentResolution.changeKind ?? '').trim().toLowerCase();
+        return artifactKind === 'unknown'
+            || operationKind === 'unknown'
+            || changeKind === 'unknown';
+    }
+    isWorkflowQuickReply(reply) {
+        const kind = (reply.kind ?? '').trim().toLowerCase();
+        return kind === 'revise' || kind === 'cancel' || kind === 'confirm';
+    }
+    isResourceCandidateQuickReply(reply) {
+        const kind = (reply.kind ?? '').trim().toLowerCase();
+        if (kind !== 'suggestion') {
+            return false;
+        }
+        const contextHints = this.toJsonObject(reply.contextHints);
+        if (this.isContextualPreviewActionReply(reply, contextHints)) {
+            return false;
+        }
+        return !!contextHints
+            && (!!contextHints['resourcePath']
+                || !!contextHints['resourceKey']
+                || !!contextHints['submitUrl']
+                || !!contextHints['schemaUrl']);
+    }
     isExplicitPreviewCreationPrompt(prompt) {
         const normalized = prompt
             .normalize('NFD')
@@ -13838,7 +14368,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
     toShellQuickReplies(quickReplies) {
         return quickReplies
             .filter((reply) => !!reply.id && !!reply.label && (!!reply.prompt || reply.kind === 'cancel'))
-            .map((reply) => ({
+            .map((reply) => this.enrichShellQuickReply({
             id: reply.id,
             kind: reply.kind,
             label: reply.label,
@@ -13846,9 +14376,334 @@ class PageBuilderAgenticAuthoringTurnFlow {
             description: reply.description,
             icon: reply.icon,
             tone: reply.tone,
+            presentation: null,
             contextHints: this.toJsonObject(reply.contextHints),
         }));
     }
+    contextualCapabilityFallbackQuickReplies(intentResolution) {
+        if (!this.shouldOfferContextualCapabilityActions(intentResolution)) {
+            return [];
+        }
+        const componentContext = this.resolveCurrentComponentContext(intentResolution);
+        if (componentContext?.componentId !== 'praxis-chart') {
+            return [];
+        }
+        return [
+            this.contextualCapabilityQuickReply({
+                id: 'chart-change-line',
+                label: this.context.tx('agentic.quickReplies.chartChangeLine.label', 'Trocar para linhas'),
+                prompt: this.context.tx('agentic.quickReplies.chartChangeLine.prompt', 'Altere o gráfico selecionado para linhas.'),
+                icon: 'show_chart',
+                changeKind: 'set_chart_type',
+                chartType: 'line',
+                capabilityId: 'praxis-chart.type.set@0.1.0',
+                widgetKey: componentContext.widgetKey,
+            }),
+            this.contextualCapabilityQuickReply({
+                id: 'chart-change-donut',
+                label: this.context.tx('agentic.quickReplies.chartChangeDonut.label', 'Ver como donut'),
+                prompt: this.context.tx('agentic.quickReplies.chartChangeDonut.prompt', 'Altere o gráfico selecionado para donut.'),
+                icon: 'donut_large',
+                changeKind: 'set_chart_type',
+                chartType: 'donut',
+                capabilityId: 'praxis-chart.type.set@0.1.0',
+                widgetKey: componentContext.widgetKey,
+            }),
+            this.contextualCapabilityQuickReply({
+                id: 'chart-add-detail-table',
+                label: this.context.tx('agentic.quickReplies.chartAddDetailTable.label', 'Detalhes em tabela'),
+                prompt: this.context.tx('agentic.quickReplies.chartAddDetailTable.prompt', 'Adicione uma tabela de detalhes para a seleção do gráfico.'),
+                icon: 'table_view',
+                changeKind: 'enable_chart_drilldown',
+                capabilityId: 'praxis-chart.drilldown.enable@0.1.0',
+                widgetKey: componentContext.widgetKey,
+            }),
+        ];
+    }
+    contextualCapabilityQuickReply(options) {
+        return this.enrichContextualActionQuickReply({
+            id: options.id,
+            kind: 'suggestion',
+            label: options.label,
+            prompt: options.prompt,
+            icon: options.icon,
+            tone: 'analytics',
+            contextHints: {
+                source: 'component-capability-catalog',
+                kind: 'contextual-preview-action',
+                operationKind: 'modify',
+                artifactKind: 'chart',
+                changeKind: options.changeKind,
+                ...(options.chartType ? { chartType: options.chartType } : {}),
+                capabilityId: options.capabilityId,
+                targetComponentId: 'praxis-chart',
+                selectedComponentId: 'praxis-chart',
+                ...(options.widgetKey ? { selectedWidgetKey: options.widgetKey } : {}),
+            },
+        });
+    }
+    shouldOfferContextualCapabilityActions(intentResolution) {
+        if (this.isConsultativeCatalogIntent(intentResolution)) {
+            return false;
+        }
+        const operationKind = (intentResolution.operationKind ?? '').trim().toLowerCase();
+        const artifactKind = (intentResolution.artifactKind ?? '').trim().toLowerCase();
+        const changeKind = (intentResolution.changeKind ?? '').trim().toLowerCase();
+        if (operationKind !== 'explore' && operationKind !== 'explain') {
+            return false;
+        }
+        if (artifactKind === 'chart') {
+            return true;
+        }
+        return changeKind.includes('chart')
+            || changeKind.includes('component')
+            || !!this.resolveCurrentComponentContext(intentResolution);
+    }
+    resolveCurrentComponentContext(intentResolution) {
+        const contextHints = this.toJsonObject(intentResolution.contextHints);
+        const targetComponentId = this.readString(contextHints, 'targetComponentId')
+            || this.readString(contextHints, 'selectedComponentId')
+            || intentResolution.target?.componentId
+            || '';
+        const targetWidgetKey = this.readString(contextHints, 'selectedWidgetKey')
+            || intentResolution.target?.widgetKey
+            || this.context.selectedWidgetKey()
+            || '';
+        if (targetComponentId) {
+            return { componentId: targetComponentId, widgetKey: targetWidgetKey || null };
+        }
+        const page = this.currentPageRecord();
+        const widgets = Array.isArray(page?.['widgets']) ? page['widgets'] : [];
+        const selectedWidget = targetWidgetKey
+            ? widgets.find((widget) => this.readWidgetKey(widget) === targetWidgetKey)
+            : null;
+        const selectedComponentId = selectedWidget ? this.readWidgetComponentId(selectedWidget) : '';
+        if (selectedComponentId) {
+            return { componentId: selectedComponentId, widgetKey: targetWidgetKey || null };
+        }
+        const chartWidget = widgets.find((widget) => this.readWidgetComponentId(widget) === 'praxis-chart');
+        if (chartWidget) {
+            return {
+                componentId: 'praxis-chart',
+                widgetKey: this.readWidgetKey(chartWidget) || null,
+            };
+        }
+        return null;
+    }
+    currentPageRecord() {
+        const page = this.context.currentPage();
+        return page && typeof page === 'object' && !Array.isArray(page)
+            ? page
+            : null;
+    }
+    readWidgetKey(widget) {
+        const record = widget && typeof widget === 'object' && !Array.isArray(widget)
+            ? widget
+            : null;
+        const key = record?.['key'];
+        return typeof key === 'string' ? key.trim() : '';
+    }
+    readWidgetComponentId(widget) {
+        const record = widget && typeof widget === 'object' && !Array.isArray(widget)
+            ? widget
+            : null;
+        const definition = record?.['definition'];
+        const definitionRecord = definition && typeof definition === 'object' && !Array.isArray(definition)
+            ? definition
+            : null;
+        const id = definitionRecord?.['id'];
+        return typeof id === 'string' ? id.trim() : '';
+    }
+    enrichShellQuickReply(reply) {
+        if (this.isContextualPreviewActionReply(reply, this.toJsonObject(reply.contextHints))) {
+            return this.enrichContextualActionQuickReply(reply);
+        }
+        if (!this.isResourceQuickReply(reply)) {
+            return reply;
+        }
+        const contextHints = { ...(reply.contextHints ?? {}) };
+        if (!this.hasQuickReplyPresentation(contextHints)) {
+            contextHints['presentation'] = this.resourceQuickReplyPresentation(reply);
+        }
+        return {
+            ...reply,
+            description: this.resourceQuickReplyDescription(reply),
+            icon: reply.icon || 'dataset',
+            tone: reply.tone || 'resource',
+            contextHints,
+        };
+    }
+    enrichContextualActionQuickReply(reply) {
+        const contextHints = this.toJsonObject(reply.contextHints) ?? {};
+        const presentation = {
+            kind: 'contextual-action',
+            categoryLabel: this.context.tx('agentic.quickReplies.contextualAction.category', 'Ação sugerida'),
+            description: this.contextualActionDescription(reply, contextHints),
+            ctaLabel: this.context.tx('agentic.quickReplies.contextualAction.cta', 'Pré-visualizar ajuste'),
+            icon: reply.icon || this.contextualActionIcon(reply, contextHints),
+            tone: reply.tone || 'analytics',
+            evidence: this.contextualActionEvidence(contextHints),
+        };
+        return {
+            ...reply,
+            description: presentation.description,
+            icon: presentation.icon,
+            tone: presentation.tone,
+            presentation,
+        };
+    }
+    contextualActionDescription(reply, contextHints) {
+        const existing = reply.description?.trim() ?? '';
+        if (existing && !this.isGenericContextualActionDescription(existing)) {
+            return existing;
+        }
+        const changeKind = this.readString(contextHints, 'changeKind');
+        switch (changeKind) {
+            case 'set_chart_type':
+                return this.context.tx('agentic.quickReplies.contextualAction.chartType.description', 'Altera apenas a apresentação do gráfico selecionado e mantém a fonte de dados atual.');
+            case 'enable_chart_drilldown':
+                return this.context.tx('agentic.quickReplies.contextualAction.chartDrilldown.description', 'Adiciona uma superfície de detalhe a partir da seleção do gráfico, preservando o contexto do dado.');
+            case 'configure_export':
+                return this.context.tx('agentic.quickReplies.contextualAction.export.description', 'Configura uma ação operacional para exportar a seleção atual sem mudar a consulta base.');
+            default:
+                return this.context.tx('agentic.quickReplies.contextualAction.default.description', 'Prepara um ajuste compatível com as capacidades confirmadas do componente selecionado.');
+        }
+    }
+    contextualActionIcon(reply, contextHints) {
+        const changeKind = this.readString(contextHints, 'changeKind');
+        const chartType = this.readString(contextHints, 'chartType')
+            || this.readString(contextHints, 'targetChartType');
+        const actionId = reply.id?.trim() ?? '';
+        if (changeKind === 'set_chart_type') {
+            return chartType === 'donut' || actionId === 'chart-change-donut'
+                ? 'donut_large'
+                : 'show_chart';
+        }
+        if (changeKind === 'enable_chart_drilldown')
+            return 'table_view';
+        if (changeKind === 'configure_export')
+            return 'ios_share';
+        return 'auto_fix_high';
+    }
+    contextualActionEvidence(contextHints) {
+        const evidence = [];
+        const targetComponentId = this.readString(contextHints, 'targetComponentId')
+            || this.readString(contextHints, 'selectedComponentId');
+        const changeKind = this.readString(contextHints, 'changeKind');
+        const capabilityId = this.readString(contextHints, 'capabilityId');
+        const selectedWidgetKey = this.readString(contextHints, 'selectedWidgetKey');
+        if (targetComponentId) {
+            evidence.push({
+                icon: 'widgets',
+                value: this.shortTechnicalLabel(targetComponentId),
+                ariaLabel: this.context.tx('agentic.quickReplies.contextualAction.componentEvidence', 'Componente {value}').replace('{value}', targetComponentId),
+            });
+        }
+        if (changeKind) {
+            evidence.push({
+                icon: 'rule',
+                value: this.shortTechnicalLabel(changeKind),
+                ariaLabel: this.context.tx('agentic.quickReplies.contextualAction.changeEvidence', 'Mudança {value}').replace('{value}', changeKind),
+            });
+        }
+        if (capabilityId) {
+            evidence.push({
+                icon: 'verified',
+                value: this.context.tx('agentic.quickReplies.contextualAction.capabilityEvidence', 'capability'),
+                ariaLabel: capabilityId,
+            });
+        }
+        if (!capabilityId && selectedWidgetKey) {
+            evidence.push({
+                icon: 'ads_click',
+                value: this.context.tx('agentic.quickReplies.contextualAction.selectionEvidence', 'seleção atual'),
+                ariaLabel: selectedWidgetKey,
+            });
+        }
+        return evidence.slice(0, 4);
+    }
+    isResourceQuickReply(reply) {
+        const kind = (reply.kind || '').trim().toLowerCase();
+        const id = (reply.id || '').trim().toLowerCase();
+        const contextHints = this.toJsonObject(reply.contextHints);
+        if (this.isContextualPreviewActionReply(reply, contextHints)) {
+            return false;
+        }
+        return kind === 'resource'
+            || id.startsWith('resource-')
+            || !!this.readString(contextHints, 'resourcePath');
+    }
+    isContextualPreviewActionReply(reply, contextHints) {
+        const hintSource = typeof contextHints?.['source'] === 'string'
+            ? contextHints['source'].trim()
+            : '';
+        const hintKind = typeof contextHints?.['kind'] === 'string'
+            ? contextHints['kind'].trim()
+            : '';
+        return hintSource === 'component-capability-catalog'
+            || hintKind === 'contextual-preview-action'
+            || (reply.id ?? '').startsWith('chart-')
+            || (reply.id ?? '').startsWith('table-export-');
+    }
+    hasQuickReplyPresentation(contextHints) {
+        const presentation = contextHints['presentation'];
+        if (!presentation || Array.isArray(presentation) || typeof presentation !== 'object') {
+            return false;
+        }
+        return ['bestFor', 'returns', 'nextStep']
+            .some((key) => typeof presentation[key] === 'string'
+            && !!String(presentation[key]).trim());
+    }
+    resourceQuickReplyDescription(reply) {
+        const description = reply.description?.trim() ?? '';
+        if (description
+            && !this.isTechnicalResourceDescription(description)
+            && !this.isGenericResourceDescription(description)) {
+            return description;
+        }
+        return this.context.tx('agentic.resourceDiscovery.cardDescription', 'Fonte recomendada para transformar {label} em painel: ajuda a escolher graficos, listas, filtros e formatos antes de materializar a tela.').replace('{label}', reply.label);
+    }
+    resourceQuickReplyPresentation(reply) {
+        const contextHints = this.toJsonObject(reply.contextHints);
+        const artifactKind = this.readString(contextHints, 'artifactKind');
+        if (artifactKind === 'table') {
+            return {
+                bestFor: `Boa quando voce quer transformar ${reply.label} em uma tabela navegavel.`,
+                returns: 'Retorna uma pre-visualizacao com colunas, filtros e fonte semantica preservada.',
+                nextStep: 'Clique para criar a tabela e revisar antes de salvar.',
+            };
+        }
+        return {
+            bestFor: this.context.tx('agentic.resourceDiscovery.cardBestFor', 'Quando voce quer entender se {label} responde ao objetivo de negocio antes de criar widgets.').replace('{label}', reply.label),
+            returns: this.context.tx('agentic.resourceDiscovery.cardReturns', 'Sugere metricas, dimensoes, filtros, formatos de valor, graficos e listas de detalhe compativeis com a fonte.'),
+            nextStep: this.context.tx('agentic.resourceDiscovery.cardNextStep', 'Selecione para eu propor uma pre-visualizacao governada com cards ricos, drill-down e formatos adequados por padrao.'),
+        };
+    }
+    isTechnicalResourceDescription(description) {
+        return /(?:^|\s)(?:GET|POST|PUT|PATCH|DELETE)\s+\//iu.test(description)
+            || /\/api\//iu.test(description)
+            || /\/schemas\//iu.test(description);
+    }
+    isGenericResourceDescription(description) {
+        return /op(?:c|ç)ao encontrada no cat(?:a|á)logo sem(?:a|â)ntico/iu.test(description)
+            || /fonte candidata encontrada no cat(?:a|á)logo/iu.test(description);
+    }
+    isGenericContextualActionDescription(description) {
+        const normalized = description
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLocaleLowerCase('pt-BR');
+        return normalized.includes('acao sugerida')
+            && normalized.includes('capacidades confirmadas');
+    }
+    shortTechnicalLabel(value) {
+        return value
+            .trim()
+            .replace(/^praxis-/u, '')
+            .replace(/@.*$/u, '')
+            .replace(/[_-]+/gu, ' ')
+            .trim();
+    }
     buildPendingClarificationForNextTurn(request, sourcePrompt, clarification) {
         return this.buildPendingClarification(sourcePrompt, clarification, request.clientTurnId);
     }
@@ -13923,7 +14778,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             targetApp: this.context.targetApp,
             targetComponentId: this.context.targetComponentId,
             currentPage: this.context.currentPage(),
-            selectedWidgetKey,
+            selectedWidgetKey: this.resolveSelectedWidgetKey(selectedWidgetKey, authoringContext.contextHints),
             provider: this.context.provider(),
             model: this.context.model(),
             apiKey: this.context.apiKey(),
@@ -13931,6 +14786,12 @@ class PageBuilderAgenticAuthoringTurnFlow {
             ...authoringContext,
         };
     }
+    resolveSelectedWidgetKey(selectedWidgetKey, contextHints) {
+        const hints = this.toJsonObject(contextHints) ?? null;
+        return this.readString(hints, 'selectedWidgetKey')
+            || this.readString(hints, 'targetWidgetKey')
+            || selectedWidgetKey;
+    }
     buildContextHints(request) {
         const base = this.toJsonObject(request.action?.contextHints)
             ?? this.toJsonObject(request.contextHints);
@@ -14173,6 +15034,8 @@ class DynamicPageBuilderComponent {
     agenticAuthoringStatus = signal('', ...(ngDevMode ? [{ debugName: "agenticAuthoringStatus" }] : []));
     agenticAuthoringError = signal('', ...(ngDevMode ? [{ debugName: "agenticAuthoringError" }] : []));
     agenticAuthoringPreviewResult = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringPreviewResult" }] : []));
+    agenticAuthoringSemanticDecision = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringSemanticDecision" }] : []));
+    agenticAuthoringCanApply = signal(false, ...(ngDevMode ? [{ debugName: "agenticAuthoringCanApply" }] : []));
     agenticAuthoringLastEtag = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringLastEtag" }] : []));
     agenticAuthoringConversation = signal([], ...(ngDevMode ? [{ debugName: "agenticAuthoringConversation" }] : []));
     agenticAuthoringQuickReplies = signal([], ...(ngDevMode ? [{ debugName: "agenticAuthoringQuickReplies" }] : []));
@@ -14198,12 +15061,12 @@ class DynamicPageBuilderComponent {
     agenticAuthoringEditingMessageId = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringEditingMessageId" }] : []));
     selectedWidgetKey = signal(null, ...(ngDevMode ? [{ debugName: "selectedWidgetKey" }] : []));
     agenticAuthoringWidgetContextKey = signal(null, ...(ngDevMode ? [{ debugName: "agenticAuthoringWidgetContextKey" }] : []));
-    agenticAuthoringPanelLayout = signal({
-        left: 16,
-        top: 16,
+    agenticAuthoringPanelLayout = signal(createPraxisAssistantViewportLayout({
         width: 440,
-        height: 560,
-    }, ...(ngDevMode ? [{ debugName: "agenticAuthoringPanelLayout" }] : []));
+        height: 620,
+        top: 96,
+        margin: 24,
+    }), ...(ngDevMode ? [{ debugName: "agenticAuthoringPanelLayout" }] : []));
     previewMode = false;
     agenticComponentCapabilities;
     agenticComponentCapabilitiesPromise;
@@ -14429,7 +15292,7 @@ class DynamicPageBuilderComponent {
         if (this.resolveSelectedWidgetKey()) {
             return this.tx('agentic.header.title.widget', 'Praxis widget copilot');
         }
-        return this.tx('agentic.header.title.page', 'Praxis page copilot');
+        return this.tx('agentic.header.title.page', 'Praxis page decision copilot');
     }
     agenticAuthoringHeaderSubtitle() {
         const selectedWidgetLabel = this.resolveSelectedWidgetLabel();
@@ -14437,6 +15300,9 @@ class DynamicPageBuilderComponent {
             return this.tx('agentic.header.subtitle.governed', 'Continue the governed semantic-decision flow.');
         }
         if (this.agenticAuthoringPreviewResult()?.valid) {
+            if (!this.agenticAuthoringCanApply()) {
+                return this.tx('agentic.header.subtitle.reviewBlocked', 'Preview ready for governed review.');
+            }
             return this.tx('agentic.header.subtitle.review', 'Preview ready for review and persistence.');
         }
         if (selectedWidgetLabel) {
@@ -14448,7 +15314,7 @@ class DynamicPageBuilderComponent {
             return this.tx('agentic.header.subtitle.route', 'Authoring page route {route}.')
                 .replace('{route}', routePath);
         }
-        return this.tx('agentic.header.subtitle.page', 'Author page-level layout, widgets and governed materialization.');
+        return this.tx('agentic.header.subtitle.page', 'Turn intent into layout, widgets, and governed materializations.');
     }
     agenticAuthoringHeaderModeLabel() {
         if (this.agenticAuthoringSharedRuleHandoffState()) {
@@ -14466,7 +15332,7 @@ class DynamicPageBuilderComponent {
             close: this.tx('agentic.minimize', 'Minimize'),
             prompt: this.tx('agentic.promptLabel', 'Message'),
             promptPlaceholder: this.tx('agentic.promptPlaceholder', 'Describe the page, dashboard, form or change you need.'),
-            emptyConversation: this.tx('agentic.emptyConversation', 'Tell me what you want to create or change. I will ask follow-up questions before applying the preview.'),
+            emptyConversation: this.agenticAuthoringEmptyConversationMessage(),
             submit: this.tx('agentic.preview', 'Generate preview'),
             apply: this.tx('agentic.persist', 'Save'),
             conversationAria: this.tx('agentic.conversationAria', 'AI conversation'),
@@ -14485,7 +15351,7 @@ class DynamicPageBuilderComponent {
             modeDiagnostic: this.tx('agentic.mode.diagnostic', 'Diagnostic'),
             modeReview: this.tx('agentic.mode.review', 'Review'),
             modeInlineHelp: this.tx('agentic.mode.inlineHelp', 'Help'),
-            stateIdle: this.tx('agentic.state.idle', 'Idle'),
+            stateIdle: this.tx('agentic.state.idle', 'Ready'),
             stateListening: this.tx('agentic.state.listening', 'Ready'),
             stateProcessing: this.tx('agentic.state.processing', 'Processing'),
             stateClarification: this.tx('agentic.state.clarification', 'Waiting for input'),
@@ -14495,6 +15361,39 @@ class DynamicPageBuilderComponent {
             stateError: this.tx('agentic.state.error', 'Error'),
         };
     }
+    agenticAuthoringEmptyConversationMessage() {
+        const authoredOpening = this.resolveAgenticAuthoredOpeningMessage();
+        if (authoredOpening) {
+            return authoredOpening;
+        }
+        if (this.isAgenticAuthoringPageBlank()) {
+            return this.tx('agentic.emptyConversation.blankGeneric', 'This host page is still blank. Tell me what decision or activity this app needs to support. I can suggest a dashboard, table, form, or review flow, then turn it into a governed preview for you to review before anything changes.');
+        }
+        return this.tx('agentic.emptyConversation.existingPage', 'Tell me what you want to improve here. I can read the current layout, widgets, route, and governed context, then prepare a preview for you to review before anything changes.');
+    }
+    resolveAgenticAuthoredOpeningMessage() {
+        const hints = this.toRecord(this.agenticAuthoringContextHints);
+        if (!hints)
+            return null;
+        const candidateRecords = [
+            hints,
+            this.toRecord(hints['domainOpening']),
+            this.toRecord(hints['ragOpening']),
+            this.toRecord(hints['opening']),
+            this.toRecord(hints['domainSummary']),
+        ];
+        for (const record of candidateRecords) {
+            const message = this.trimmedString(record?.['openingMessage'])
+                || this.trimmedString(record?.['message']);
+            if (message)
+                return message;
+        }
+        return null;
+    }
+    isAgenticAuthoringPageBlank() {
+        const widgets = this.currentPage().widgets;
+        return !Array.isArray(widgets) || widgets.length === 0;
+    }
     agenticAuthoringSubmitAction() {
         const label = this.tx('agentic.preview', 'Generate preview');
         return {
@@ -14585,6 +15484,8 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringStatus.set('');
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringSemanticDecision.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringConversation.set([]);
         this.agenticAuthoringQuickReplies.set([]);
         this.agenticAuthoringAttachments.set([]);
@@ -14830,6 +15731,7 @@ class DynamicPageBuilderComponent {
                 });
             }
         }
+        items.push(...this.agenticAuthoringSemanticDecisionContextItems());
         const handoff = this.agenticAuthoringSharedRuleHandoffState();
         if (handoff) {
             items.push({
@@ -14921,6 +15823,138 @@ class DynamicPageBuilderComponent {
         }
         return items;
     }
+    agenticAuthoringSemanticDecisionContextItems() {
+        const semanticDecision = this.toRecord(this.agenticAuthoringSemanticDecision());
+        if (!semanticDecision) {
+            return [];
+        }
+        const items = [];
+        const selectedResource = this.toRecord(semanticDecision['selectedResource']);
+        const resourcePath = this.trimmedString(selectedResource?.['resourcePath']);
+        const operationKind = this.trimmedString(semanticDecision['operationKind']);
+        const artifactKind = this.trimmedString(semanticDecision['artifactKind']);
+        const changeKind = this.trimmedString(semanticDecision['changeKind']);
+        if (this.shouldHideSemanticDecisionContextItems(operationKind, artifactKind, changeKind, resourcePath)) {
+            return items;
+        }
+        if (resourcePath) {
+            items.push({
+                id: 'semantic-decision-resource',
+                kind: 'custom',
+                label: this.tx('agentic.context.semanticDecisionResource', 'Fonte'),
+                value: this.humanizeAgenticResourcePath(resourcePath),
+                icon: 'dataset',
+            });
+        }
+        const decisionSummary = [operationKind, artifactKind, changeKind]
+            .filter((value) => !!value)
+            .join(' · ');
+        if (decisionSummary) {
+            items.push({
+                id: 'semantic-decision-kind',
+                kind: 'custom',
+                label: this.tx('agentic.context.semanticDecisionKind', 'Objetivo'),
+                value: this.humanizeAgenticDecisionSummary(operationKind ?? '', artifactKind ?? '', changeKind ?? ''),
+                icon: 'account_tree',
+            });
+        }
+        const retrievedEvidence = this.toRecord(semanticDecision['retrievedEvidence']);
+        const retrievalEvidence = this.toRecord(semanticDecision['retrievalEvidence']);
+        const retrievalSource = this.trimmedString(retrievedEvidence?.['retrievalSource'])
+            || this.trimmedString(retrievalEvidence?.['retrievalSource']);
+        const reviewReason = this.trimmedString(semanticDecision['reviewReason']);
+        const confidence = typeof semanticDecision['confidence'] === 'number'
+            ? semanticDecision['confidence']
+            : null;
+        const evidenceSummary = this.humanizeAgenticDecisionEvidence(retrievalSource ?? '', reviewReason ?? '', confidence);
+        if (evidenceSummary) {
+            items.push({
+                id: 'semantic-decision-evidence',
+                kind: 'custom',
+                label: this.tx('agentic.context.semanticDecisionEvidence', 'Revisão'),
+                value: evidenceSummary,
+                icon: reviewReason ? 'policy' : 'verified',
+            });
+        }
+        return items;
+    }
+    shouldHideSemanticDecisionContextItems(operationKind, artifactKind, changeKind, resourcePath) {
+        const operation = (operationKind ?? '').trim().toLowerCase();
+        const artifact = (artifactKind ?? '').trim().toLowerCase();
+        const change = (changeKind ?? '').trim().toLowerCase();
+        return artifact === 'unknown'
+            || artifact === 'api_catalog'
+            || operation === 'explore'
+            || operation === 'explain'
+            || change === 'answer_api_catalog_question'
+            || change === 'answer_catalog_question'
+            || change === 'api_catalog_followup';
+    }
+    humanizeAgenticResourcePath(resourcePath) {
+        const lastSegment = resourcePath.split('?')[0].split('/').filter(Boolean).pop() || resourcePath;
+        return lastSegment
+            .replace(/^vw[-_]/i, '')
+            .replace(/[-_]+/g, ' ')
+            .replace(/\b\w/g, (char) => char.toUpperCase());
+    }
+    humanizeAgenticDecisionSummary(operationKind, artifactKind, changeKind) {
+        const operation = this.humanizeAgenticOperationKind(operationKind);
+        const artifact = this.humanizeAgenticArtifactKind(artifactKind);
+        const change = this.humanizeAgenticChangeKind(changeKind);
+        return [operation, artifact, change].filter((value) => !!value).join(' · ');
+    }
+    humanizeAgenticOperationKind(value) {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'create')
+            return this.tx('agentic.context.operationCreate', 'Criar');
+        if (normalized === 'update')
+            return this.tx('agentic.context.operationUpdate', 'Ajustar');
+        if (normalized === 'read')
+            return this.tx('agentic.context.operationRead', 'Consultar');
+        return this.humanizeAgenticToken(value);
+    }
+    humanizeAgenticArtifactKind(value) {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'dashboard')
+            return this.tx('agentic.context.artifactDashboard', 'dashboard');
+        if (normalized === 'table')
+            return this.tx('agentic.context.artifactTable', 'tabela');
+        if (normalized === 'form')
+            return this.tx('agentic.context.artifactForm', 'formulário');
+        if (normalized === 'page')
+            return this.tx('agentic.context.artifactPage', 'tela');
+        return this.humanizeAgenticToken(value).toLowerCase();
+    }
+    humanizeAgenticChangeKind(value) {
+        const normalized = value.trim().toLowerCase();
+        if (normalized.includes('analytics'))
+            return this.tx('agentic.context.changeAnalytics', 'com análise');
+        if (normalized.includes('dashboard'))
+            return this.tx('agentic.context.changeDashboard', 'com visão gerencial');
+        if (normalized.includes('table'))
+            return this.tx('agentic.context.changeTable', 'com detalhes');
+        if (normalized.includes('form'))
+            return this.tx('agentic.context.changeForm', 'com edição');
+        return this.humanizeAgenticToken(value).toLowerCase();
+    }
+    humanizeAgenticDecisionEvidence(retrievalSource, reviewReason, confidence) {
+        if (reviewReason) {
+            return this.tx('agentic.context.evidenceReviewRequired', 'Precisa revisar campos');
+        }
+        if (confidence !== null && confidence < 0.7) {
+            return this.tx('agentic.context.evidenceLowConfidence', 'Precisa confirmar fonte');
+        }
+        if (retrievalSource) {
+            return this.tx('agentic.context.evidenceGrounded', 'Fonte confirmada');
+        }
+        return '';
+    }
+    humanizeAgenticToken(value) {
+        return value
+            .trim()
+            .replace(/[-_]+/g, ' ')
+            .replace(/\b\w/g, (char) => char.toUpperCase());
+    }
     async previewAgenticAuthoring() {
         const prompt = this.agenticAuthoringPrompt().trim();
         if (!prompt || this.agenticAuthoringBusy())
@@ -14928,6 +15962,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringBusy.set(true);
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
@@ -14939,6 +15974,7 @@ class DynamicPageBuilderComponent {
                 ? controller.submitEditedMessage(editingMessageId, prompt)
                 : controller.submitPrompt(prompt));
             this.agenticAuthoringEditingMessageId.set(null);
+            this.agenticAuthoringPrompt.set('');
         }
         catch (error) {
             this.agenticAuthoringStatus.set('');
@@ -14975,6 +16011,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringBusy.set(true);
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
@@ -14992,6 +16029,7 @@ class DynamicPageBuilderComponent {
                 displayPrompt: visiblePrompt,
                 contextHints,
             }));
+            this.agenticAuthoringPrompt.set('');
         }
         catch (error) {
             this.agenticAuthoringStatus.set('');
@@ -15095,9 +16133,25 @@ class DynamicPageBuilderComponent {
         return visiblePrompt;
     }
     isResourceQuickReply(reply, contextHints) {
+        if (this.isContextualPreviewActionQuickReply(reply, contextHints)) {
+            return false;
+        }
         return this.hasResourceContextHint(contextHints)
             && !['cancel', 'revise'].includes((reply.kind || '').trim().toLowerCase());
     }
+    isContextualPreviewActionQuickReply(reply, contextHints) {
+        const source = typeof contextHints?.['source'] === 'string'
+            ? contextHints['source'].trim()
+            : '';
+        const kind = typeof contextHints?.['kind'] === 'string'
+            ? contextHints['kind'].trim()
+            : '';
+        const id = (reply.id || '').trim();
+        return source === 'component-capability-catalog'
+            || kind === 'contextual-preview-action'
+            || id.startsWith('chart-')
+            || id.startsWith('table-export-');
+    }
     isGovernedConfirmationQuickReply(reply, contextHints) {
         return this.isConfirmationQuickReply(reply)
             && this.hasResourceContextHint(contextHints);
@@ -15165,6 +16219,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.clearProjectKnowledgeCockpitState();
         try {
             await this.consumeAgenticTurn(this.ensureAgenticTurnController().resendMessage(message.id));
@@ -15205,6 +16260,8 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringEditingMessageId.set(null);
         this.agenticAuthoringPrompt.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringSemanticDecision.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
@@ -15212,7 +16269,7 @@ class DynamicPageBuilderComponent {
     }
     async persistAgenticAuthoring() {
         const preview = this.agenticAuthoringPreviewResult();
-        if (!preview || this.agenticAuthoringBusy())
+        if (!preview || !this.agenticAuthoringCanApply() || this.agenticAuthoringBusy())
             return;
         const componentId = this.resolveAgenticComponentId();
         if (!componentId) {
@@ -15232,10 +16289,17 @@ class DynamicPageBuilderComponent {
                 tags: {
                     source: 'page-builder-agentic-authoring',
                 },
+                semanticDecision: this.agenticAuthoringSemanticDecision(),
             }));
             this.agenticAuthoringLastEtag.set(result.etag ?? null);
             this.agenticAuthoringApplied.emit(result);
+            this.agenticAuthoringPreviewResult.set(null);
+            this.agenticAuthoringSemanticDecision.set(null);
+            this.agenticAuthoringCanApply.set(false);
+            this.agenticAuthoringQuickReplies.set([]);
+            this.agenticAuthoringPrompt.set('');
             this.agenticAuthoringStatus.set(this.tx('agentic.status.saved', 'Page saved.'));
+            this.syncAgenticAuthoringSession();
         }
         catch (error) {
             this.agenticAuthoringStatus.set('');
@@ -15797,6 +16861,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringStatus.set(this.tx('agentic.status.sharedRuleTargetSelected', 'Shared-rule target selected. Continue by creating the governed definition.'));
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
+        this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringSharedRuleHandoffState.set(next);
         this.agenticAuthoringSharedRuleHandoff.emit(next);
         this.appendAgenticMessage('user', visiblePrompt);
@@ -16063,12 +17128,14 @@ class DynamicPageBuilderComponent {
         const handoff = this.resolveAgenticSharedRuleHandoff(state);
         const previousHandoff = this.agenticAuthoringSharedRuleHandoffState();
         this.agenticAuthoringConversation.set(state.messages);
-        this.agenticAuthoringQuickReplies.set(preview?.valid ? [] : state.quickReplies);
+        this.agenticAuthoringQuickReplies.set(state.quickReplies);
         this.agenticAuthoringStatus.set(handoff && !preview?.valid
             ? this.tx('agentic.status.sharedRuleHandoff', 'Continue this request in the shared-rules flow.')
             : state.statusText);
         this.agenticAuthoringError.set(state.errorText);
         this.agenticAuthoringPreviewResult.set(preview);
+        this.agenticAuthoringSemanticDecision.set(this.resolveAgenticSemanticDecision(state.diagnostics));
+        this.agenticAuthoringCanApply.set(!!preview?.valid && !!state.canApply);
         this.moveAgenticAuthoringPanelToReviewSidecar(preview);
         this.agenticAuthoringAttachments.set(state.attachments);
         if (!this.sameSharedRuleHandoffIdentity(previousHandoff, handoff)) {
@@ -16124,7 +17191,7 @@ class DynamicPageBuilderComponent {
         }
         this.agenticAuthoringPanelLayout.set(createPraxisAssistantViewportLayout({
             width: 440,
-            height: 560,
+            height: 620,
             top: 96,
             margin: 24,
         }));
@@ -16266,7 +17333,14 @@ class DynamicPageBuilderComponent {
         return Object.keys(merged).length ? merged : undefined;
     }
     consumeAgenticTurn(states$) {
-        return lastValueFrom(states$.pipe(concatMap((state) => from(this.applyAgenticTurnState(state)).pipe(map(() => state)))));
+        return firstValueFrom(states$.pipe(concatMap((state) => from(this.applyAgenticTurnState(state)).pipe(map(() => state))), filter((state) => this.isAgenticTurnTerminalState(state)), take(1)));
+    }
+    isAgenticTurnTerminalState(state) {
+        return state.state === 'review'
+            || state.state === 'clarification'
+            || state.state === 'error'
+            || state.state === 'success'
+            || state.state === 'listening';
     }
     agenticAuthoringDiagnosticsTop() {
         return Math.max(16, this.agenticAuthoringPanelLayout().top);
@@ -16285,6 +17359,11 @@ class DynamicPageBuilderComponent {
         const intentResolution = this.toRecord(diagnostics?.['intentResolution']);
         return this.toRecord(intentResolution?.['llmDiagnostics']);
     }
+    resolveAgenticSemanticDecision(diagnostics) {
+        const intentResolution = this.toRecord(diagnostics?.['intentResolution']);
+        const semanticDecision = this.toRecord(intentResolution?.['semanticDecision']);
+        return semanticDecision ? semanticDecision : null;
+    }
     cloneAgenticContextHints(contextHints) {
         if (!contextHints || typeof contextHints !== 'object' || Array.isArray(contextHints)) {
             return undefined;
@@ -16330,8 +17409,10 @@ class DynamicPageBuilderComponent {
     }
     resolvePreviewCompiledFormPatch(preview) {
         if (preview.uiCompositionPlan || preview.compiledFormPatch?.patch?.page) {
+            const planDiagnostics = this.toRecord(this.toRecord(preview.uiCompositionPlan)?.['diagnostics']);
             return {
                 ...preview.compiledFormPatch,
+                diagnostics: planDiagnostics ?? preview.compiledFormPatch?.['diagnostics'],
                 patch: {
                     ...(preview.compiledFormPatch?.patch ?? {}),
                     page: this.clonePage(this.currentPage()),
@@ -16359,7 +17440,7 @@ class DynamicPageBuilderComponent {
         return this.clonePage(input);
     }
     clonePage(page) {
-        return JSON.parse(JSON.stringify(page));
+        return normalizePageBuilderRuntimePage(JSON.parse(JSON.stringify(page)));
     }
     clearSelectedWidgetIfMissing(page) {
         const selected = this.selectedWidgetKey();
@@ -16580,7 +17661,7 @@ class DynamicPageBuilderComponent {
         [statusText]="agenticAuthoringStatus()"
         [errorText]="agenticAuthoringError()"
         [busy]="agenticAuthoringBusy()"
-        [canApply]="!!agenticAuthoringPreviewResult()?.valid"
+        [canApply]="agenticAuthoringCanApply()"
         [primaryAction]="agenticAuthoringSubmitAction()"
         [showAttachAction]="false"
         [enablePastedAttachments]="false"
@@ -17004,7 +18085,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         [statusText]="agenticAuthoringStatus()"
         [errorText]="agenticAuthoringError()"
         [busy]="agenticAuthoringBusy()"
-        [canApply]="!!agenticAuthoringPreviewResult()?.valid"
+        [canApply]="agenticAuthoringCanApply()"
         [primaryAction]="agenticAuthoringSubmitAction()"
         [showAttachAction]="false"
         [enablePastedAttachments]="false"