@praxisui/page-builder 8.0.0-beta.103 → 8.0.0-beta.104

package/fesm2022/praxisui-page-builder.mjs

@@ -7,7 +7,7 @@ import { MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
 import * as i2$1 from '@angular/material/icon';
 import { MatIconModule } from '@angular/material/icon';
 import * as i2$2 from '@praxisui/core';
-import { PraxisIconDirective, BUILTIN_SHELL_PRESETS, providePraxisI18n, PraxisI18nService, GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, PRAXIS_GLOBAL_ACTION_CATALOG, SurfaceOpenActionEditorComponent, SETTINGS_PANEL_DATA as SETTINGS_PANEL_DATA$1, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, deepMerge, generateId, ComponentMetadataRegistry, domainKnowledgeTimelineToRichContentDocument, DomainRuleService, DomainKnowledgeService, SETTINGS_PANEL_BRIDGE, DynamicWidgetPageComponent, DYNAMIC_PAGE_SHELL_EDITOR } from '@praxisui/core';
+import { PraxisIconDirective, BUILTIN_SHELL_PRESETS, providePraxisI18n, PraxisI18nService, GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, PRAXIS_GLOBAL_ACTION_CATALOG, SurfaceOpenActionEditorComponent, SETTINGS_PANEL_DATA as SETTINGS_PANEL_DATA$1, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, deepMerge, generateId, ComponentMetadataRegistry, PraxisRuntimeComponentObservationRegistryService, domainKnowledgeTimelineToRichContentDocument, DomainRuleService, DomainKnowledgeService, SETTINGS_PANEL_BRIDGE, DynamicWidgetPageComponent, DYNAMIC_PAGE_SHELL_EDITOR } from '@praxisui/core';
 export { WidgetShellComponent } from '@praxisui/core';
 import * as i3 from '@angular/material/tooltip';
 import { MatTooltipModule } from '@angular/material/tooltip';
@@ -25,7 +25,7 @@ import * as i6 from '@angular/material/divider';
 import { MatDividerModule } from '@angular/material/divider';
 import * as i6$1 from '@angular/material/select';
 import { MatSelectModule } from '@angular/material/select';
-import { BehaviorSubject, merge, timeout, map, catchError, throwError, from, firstValueFrom, share, concatMap, of, timer, takeUntil, filter, take } from 'rxjs';
+import { BehaviorSubject, merge, timeout, map, catchError, throwError, from, firstValueFrom, share, concatMap, of, timer, takeUntil, Subject, 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';
@@ -2549,12 +2549,12 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     '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': 'Turn intent into layout, widgets, and governed materializations.',
-    'praxis.pageBuilder.agentic.header.subtitle.route': 'Authoring page route {route}.',
+    'praxis.pageBuilder.agentic.header.subtitle.page': 'Turn a domain need into a table, form, or dashboard.',
+    'praxis.pageBuilder.agentic.header.subtitle.route': 'Creating or adjusting page {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.subtitle.reviewBlocked': 'Preview ready, with points to review.',
+    'praxis.pageBuilder.agentic.header.subtitle.review': 'Preview ready to review and save.',
+    'praxis.pageBuilder.agentic.header.subtitle.governed': 'Continue the rule review before creating the screen.',
     'praxis.pageBuilder.agentic.header.mode.page': 'Page',
     'praxis.pageBuilder.agentic.header.mode.widget': 'Widget',
     'praxis.pageBuilder.agentic.header.mode.governed': 'Governed',
@@ -2570,13 +2570,13 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.dock.badgeGoverned': 'Governed',
     'praxis.pageBuilder.agentic.dock.badgeReady': 'Ready',
     'praxis.pageBuilder.agentic.dock.summaryReview': 'Preview ready. Reopen to review or save.',
-    'praxis.pageBuilder.agentic.dock.summaryGoverned': 'Governed handoff preserved. Continue the semantic decision flow.',
+    'praxis.pageBuilder.agentic.dock.summaryGoverned': 'Review preserved. Continue where you left off.',
     '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': '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.emptyConversation.blankGeneric': 'This screen is still empty. Tell me which domain activity it should support. I can suggest a dashboard, table, or form and prepare a preview for you to review before saving.',
+    'praxis.pageBuilder.agentic.emptyConversation.existingPage': 'Tell me what you want to improve on this screen. I will read what already exists and prepare a preview for you to review before saving.',
     'praxis.pageBuilder.agentic.conversationAria': 'AI conversation',
     'praxis.pageBuilder.agentic.quickRepliesAria': 'Quick replies',
     'praxis.pageBuilder.agentic.contextAria': 'Active context',
@@ -2692,8 +2692,39 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.status.acceptedRelabelField': 'Field label updated.',
     'praxis.pageBuilder.agentic.status.saving': 'Saving page...',
     'praxis.pageBuilder.agentic.status.saved': 'Page saved.',
-    'praxis.pageBuilder.agentic.status.sharedRuleTargetSelected': 'Shared-rule target selected. Continue by creating the governed definition.',
-    'praxis.pageBuilder.agentic.sharedRuleCockpit.targetSelected': 'Shared-rule target selected. The next safe step is creating the governed definition.',
+    'praxis.pageBuilder.agentic.status.sharedRuleTargetSelected': 'Continue this request in the rule review.',
+    'praxis.pageBuilder.agentic.governedRoute.streamUnavailable': 'This request needs to continue through governed business-rule review. I will not create a local preview while that review is unavailable.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.title': 'Governed rule review',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.description': 'Review the business rule before creating or saving screen changes.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.expand': 'Expand',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.collapse': 'Collapse',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.targetSelected': 'Rule identified. The next safe step is reviewing the rule before creating the screen.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.running': 'Running review step',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.definitionId': 'Rule',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.simulation': 'Simulation',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.publication': 'Publication',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.materializations': 'Created screens',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.timeline': 'History',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementState': 'Validation',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementMatrix': 'Change validation',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementMatrixDescription': 'Changes the platform can apply after publication.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.pending': 'pending',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.applied': 'applied',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.waiting': 'waiting',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_definition.label': 'Review rule',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_definition.description': 'Open or create the governed rule review.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.simulate.label': 'Simulate',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.simulate.description': 'Test the result before publishing.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.approve.label': 'Approve',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.approve.description': 'Approve the rule after review.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.publish.label': 'Publish changes',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.publish.description': 'Publish the rule and prepare derived screens.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.materialize.label': 'View created screens',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.materialize.description': 'View the screens generated from the approved rule.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.validate_enforcement.label': 'Validate application',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.validate_enforcement.description': 'Check whether published changes are ready to use.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_timeline.label': 'View history',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_timeline.description': 'Open the safe history for this decision.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timeline': 'Safe timeline',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timelineEmpty': 'No safe timeline events published for this change-set yet.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.rejected': 'Project Knowledge change-set rejected. No governed knowledge projection was applied.',
@@ -2704,7 +2735,6 @@ const PRAXIS_PAGE_BUILDER_EN_US = {
     'praxis.pageBuilder.agentic.errors.streamTimeout': 'The assistant took too long to finish this request. Try again with a narrower request or review the active context.',
     'praxis.pageBuilder.agentic.errors.streamProcessing': 'The assistant could not finish this authoring request. Try again or ask support to review the diagnostics.',
     'praxis.pageBuilder.agentic.errors.streamConnection': 'The assistant stream was interrupted before the turn finished. Try again or ask support to check the stream connection.',
-    'praxis.pageBuilder.agentic.governedRoute.streamUnavailable': 'This request must continue through the governed semantic-decision flow in /api/praxis/config/domain-rules. The backend stream is unavailable, so local preview/apply is blocked.',
     'praxis.pageBuilder.agentic.errors.duplicateField': 'This field already exists in the selected form.',
     'praxis.pageBuilder.agentic.errors.nonLocalFieldRemoval': 'Only local fields created by AI can be removed in this flow.',
     'praxis.pageBuilder.agentic.errors.invalidTableContract': 'I found the data source, but the generated plan used properties that are incompatible with the table component. I will adjust it to use only supported fields.',
@@ -2993,12 +3023,12 @@ 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': '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.page': 'Transforme uma necessidade do domínio em tabela, formulário ou painel.',
+    'praxis.pageBuilder.agentic.header.subtitle.route': 'Criando ou ajustando a página {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.subtitle.reviewBlocked': 'Prévia pronta, com pontos para revisar.',
+    'praxis.pageBuilder.agentic.header.subtitle.review': 'Prévia pronta para revisar e salvar.',
+    'praxis.pageBuilder.agentic.header.subtitle.governed': 'Continue a revisão da regra antes de criar a tela.',
     'praxis.pageBuilder.agentic.header.mode.page': 'Página',
     'praxis.pageBuilder.agentic.header.mode.widget': 'Widget',
     'praxis.pageBuilder.agentic.header.mode.governed': 'Governado',
@@ -3014,13 +3044,13 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.dock.badgeGoverned': 'Governado',
     'praxis.pageBuilder.agentic.dock.badgeReady': 'Pronto',
     'praxis.pageBuilder.agentic.dock.summaryReview': 'Prévia pronta. Reabra para revisar ou salvar.',
-    'praxis.pageBuilder.agentic.dock.summaryGoverned': 'Handoff governado preservado. Continue o fluxo de decisão semântica.',
+    'praxis.pageBuilder.agentic.dock.summaryGoverned': 'Revisão preservada. Continue de onde parou.',
     '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': '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.emptyConversation.blankGeneric': 'Esta tela ainda está vazia. Diga qual atividade do domínio ela precisa apoiar. Posso sugerir um painel, tabela ou formulário e montar uma prévia para você revisar antes de salvar.',
+    'praxis.pageBuilder.agentic.emptyConversation.existingPage': 'Diga o que você quer melhorar nesta tela. Eu leio o que já existe e preparo uma prévia para você revisar antes de salvar.',
     'praxis.pageBuilder.agentic.conversationAria': 'Conversa com IA',
     'praxis.pageBuilder.agentic.quickRepliesAria': 'Respostas rápidas',
     'praxis.pageBuilder.agentic.contextAria': 'Contexto ativo',
@@ -3136,8 +3166,39 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.status.acceptedRelabelField': 'Rótulo do campo atualizado.',
     'praxis.pageBuilder.agentic.status.saving': 'Salvando página...',
     'praxis.pageBuilder.agentic.status.saved': 'Página salva.',
-    'praxis.pageBuilder.agentic.status.sharedRuleTargetSelected': 'Alvo de regra compartilhada selecionado. Continue criando a definição governada.',
-    'praxis.pageBuilder.agentic.sharedRuleCockpit.targetSelected': 'Alvo de regra compartilhada selecionado. O próximo passo seguro é criar a definição governada.',
+    'praxis.pageBuilder.agentic.status.sharedRuleTargetSelected': 'Continue este pedido na revisão da regra.',
+    'praxis.pageBuilder.agentic.governedRoute.streamUnavailable': 'Este pedido precisa continuar pela revisão governada da regra de negócio. Não vou criar uma prévia local enquanto essa revisão não estiver disponível.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.title': 'Revisão governada da regra',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.description': 'Revise a regra de negócio antes de criar ou salvar alterações na tela.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.expand': 'Expandir',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.collapse': 'Recolher',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.targetSelected': 'Regra identificada. O próximo passo seguro é revisar a regra antes de criar a tela.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.running': 'Executando etapa de revisão',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.definitionId': 'Regra',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.simulation': 'Simulação',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.publication': 'Publicação',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.materializations': 'Telas criadas',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.timeline': 'Histórico',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementState': 'Validação',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementMatrix': 'Validação das alterações',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.enforcementMatrixDescription': 'Alterações que a plataforma poderá aplicar depois da publicação.',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.pending': 'pendente',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.applied': 'aplicadas',
+    'praxis.pageBuilder.agentic.sharedRuleCockpit.waiting': 'aguardando',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_definition.label': 'Revisar regra',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_definition.description': 'Abrir ou criar a revisão governada da regra.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.simulate.label': 'Simular',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.simulate.description': 'Testar o resultado antes de publicar.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.approve.label': 'Aprovar',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.approve.description': 'Aprovar a regra depois da revisão.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.publish.label': 'Publicar alterações',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.publish.description': 'Publicar a regra e preparar as telas derivadas.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.materialize.label': 'Ver telas criadas',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.materialize.description': 'Ver as telas geradas a partir da regra aprovada.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.validate_enforcement.label': 'Validar aplicação',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.validate_enforcement.description': 'Verificar se as alterações publicadas já podem ser usadas.',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_timeline.label': 'Ver histórico',
+    'praxis.pageBuilder.agentic.governedContinuation.sharedRule.open_timeline.description': 'Abrir o histórico seguro desta decisão.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timeline': 'Timeline segura',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.timelineEmpty': 'Ainda não há eventos seguros de timeline publicados para este change-set.',
     'praxis.pageBuilder.agentic.projectKnowledgeCockpit.rejected': 'Change-set de Project Knowledge rejeitado. Nenhuma projeção de conhecimento governado foi aplicada.',
@@ -3148,7 +3209,6 @@ const PRAXIS_PAGE_BUILDER_PT_BR = {
     'praxis.pageBuilder.agentic.errors.streamTimeout': 'Ainda não consegui concluir este pedido. Tente novamente com um pedido mais específico ou revise o contexto ativo.',
     'praxis.pageBuilder.agentic.errors.streamProcessing': 'Não consegui concluir este pedido de autoria. Tente novamente ou peça ao suporte para revisar o diagnóstico.',
     'praxis.pageBuilder.agentic.errors.streamConnection': 'O stream do assistente foi interrompido antes de concluir o turno. Tente novamente ou acione o suporte para verificar a conexão do stream.',
-    'praxis.pageBuilder.agentic.governedRoute.streamUnavailable': 'Este pedido deve continuar pelo fluxo governado de decisão semântica em /api/praxis/config/domain-rules. O stream do backend está indisponível, então pré-visualização/aplicação local fica bloqueada.',
     'praxis.pageBuilder.agentic.errors.duplicateField': 'Este campo já existe no formulário selecionado.',
     'praxis.pageBuilder.agentic.errors.nonLocalFieldRemoval': 'Somente campos locais criados pela IA podem ser removidos neste fluxo.',
     'praxis.pageBuilder.agentic.errors.invalidTableContract': 'Encontrei a fonte de dados, mas o plano gerado usou propriedades incompatíveis com o componente de tabela. Vou ajustar para usar apenas os campos suportados.',
@@ -13864,6 +13924,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
     service;
     context;
     mode = 'agentic-authoring';
+    runtimeRelatedSurfaceDisambiguationContext = null;
     constructor(service, context) {
         this.service = service;
         this.context = context;
@@ -14071,7 +14132,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             phase: 'contextualize',
             assistantMessage: undefined,
             canApply: false,
-            statusText: this.context.tx('agentic.status.preparingTurnStream', 'Preparing the AI authoring context...'),
+            statusText: this.context.tx('agentic.status.preparingTurnStream', 'Organizando as informações do pedido...'),
             errorText: '',
             preview: null,
         };
@@ -14082,7 +14143,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             phase: 'contextualize',
             assistantMessage: undefined,
             canApply: false,
-            statusText: this.context.tx('agentic.status.turnStreamContextReady', 'AI authoring context is ready. Starting backend stream...'),
+            statusText: this.context.tx('agentic.status.turnStreamContextReady', 'Informações prontas. Preparando a resposta...'),
             errorText: '',
             preview: null,
             diagnostics: {
@@ -14096,7 +14157,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             phase: 'contextualize',
             assistantMessage: undefined,
             canApply: false,
-            statusText: this.context.tx('agentic.status.preparingTurnStreamWaiting', 'Still preparing the AI authoring stream. Checking catalog, context, and backend availability...'),
+            statusText: this.context.tx('agentic.status.preparingTurnStreamWaiting', 'Ainda conferindo domínio, tela atual e fontes disponíveis...'),
             errorText: '',
             preview: null,
             diagnostics: {
@@ -14112,7 +14173,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
         return {
             state: 'listening',
             phase: 'capture',
-            assistantMessage: this.context.tx('agentic.status.cancelled', 'Request cancelled.'),
+            assistantMessage: this.context.tx('agentic.status.cancelled', 'Pedido cancelado.'),
             quickReplies: [],
             canApply: false,
             statusText: '',
@@ -15008,6 +15069,77 @@ class PageBuilderAgenticAuthoringTurnFlow {
         }
         return JSON.parse(JSON.stringify(value));
     }
+    captureRuntimeRelatedSurfaceDisambiguationContext(payload, event) {
+        const disambiguation = this.findRuntimeRelatedSurfaceDisambiguation(payload);
+        const rawOptions = Array.isArray(disambiguation?.['options'])
+            ? disambiguation['options']
+            : [];
+        const options = rawOptions
+            .map((option) => this.toJsonObject(option))
+            .filter((option) => !!option)
+            .filter((option) => !!this.readString(option, 'surfaceRef')
+            && this.readString(option, 'optionRef') === `runtime-surface-option:${this.readString(option, 'surfaceRef')}`
+            && this.readString(option, 'candidateRef').startsWith('runtime-surface-candidate:'))
+            .slice(0, 4)
+            .map((option) => ({
+            surfaceRef: this.readString(option, 'surfaceRef'),
+            optionRef: this.readString(option, 'optionRef'),
+            candidateRef: this.readString(option, 'candidateRef'),
+            label: this.readString(option, 'label') || this.readString(option, 'surfaceRef'),
+            semanticAliases: Array.isArray(option['semanticAliases'])
+                ? option['semanticAliases']
+                    .filter((alias) => typeof alias === 'string' && !!alias.trim())
+                    .map((alias) => alias.trim())
+                    .slice(0, 12)
+                : [],
+        }));
+        if (options.length < 2) {
+            return;
+        }
+        const evidenceBundle = this.toJsonObject(payload['evidenceBundle']);
+        const runtimeContext = this.toJsonObject(evidenceBundle?.['runtimeConsultableContext'])
+            ?? this.toJsonObject(evidenceBundle?.['runtimeContext'])
+            ?? null;
+        this.runtimeRelatedSurfaceDisambiguationContext = {
+            schemaVersion: 'praxis-runtime-related-surface-disambiguation-context.v1',
+            source: 'runtimeRelatedSurfaceDisambiguation',
+            authority: 'grounding_only',
+            sessionId: event?.threadId ?? '',
+            sourceTurnId: event?.turnId ?? '',
+            pageId: this.readString(runtimeContext, 'pageId'),
+            capturedAt: new Date().toISOString(),
+            ttlMs: 300000,
+            optionCount: options.length,
+            options,
+            rawRuntimeValuesCopied: false,
+        };
+    }
+    findRuntimeRelatedSurfaceDisambiguation(value) {
+        const root = this.toJsonObject(value);
+        if (!root) {
+            return null;
+        }
+        if (root['schemaVersion'] === 'praxis-runtime-related-surface-disambiguation.v1') {
+            return root;
+        }
+        for (const child of Object.values(root)) {
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    const found = this.findRuntimeRelatedSurfaceDisambiguation(item);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            else {
+                const found = this.findRuntimeRelatedSurfaceDisambiguation(child);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
     async buildTurnStreamRequest(request, prompt) {
         const startedAt = Date.now();
         const capabilitiesStartedAt = Date.now();
@@ -15017,6 +15149,9 @@ class PageBuilderAgenticAuthoringTurnFlow {
         const selectedWidgetKey = this.context.selectedWidgetKey();
         const authoringContext = this.buildAuthoringContext(request);
         const authoringContextElapsedMs = Math.max(0, Date.now() - authoringContextStartedAt);
+        const runtimeObservationsStartedAt = Date.now();
+        const runtimeObservationResult = await this.collectRuntimeComponentObservations(request);
+        const runtimeObservationsElapsedMs = Math.max(0, Date.now() - runtimeObservationsStartedAt);
         const streamRequest = {
             userPrompt: prompt,
             targetApp: this.context.targetApp,
@@ -15029,6 +15164,19 @@ class PageBuilderAgenticAuthoringTurnFlow {
             apiKey: this.context.apiKey(),
             componentCapabilities,
             ...authoringContext,
+            ...(this.runtimeRelatedSurfaceDisambiguationContext
+                ? {
+                    diagnostics: {
+                        runtimeRelatedSurfaceDisambiguationContext: this.cloneJsonObject(this.runtimeRelatedSurfaceDisambiguationContext),
+                    },
+                }
+                : {}),
+            ...(runtimeObservationResult.observations.length
+                ? {
+                    runtimeComponentObservations: runtimeObservationResult.observations,
+                    runtimeComponentObservationTrustBoundary: 'untrusted_frontend_observation',
+                }
+                : {}),
         };
         return {
             streamRequest,
@@ -15038,19 +15186,49 @@ class PageBuilderAgenticAuthoringTurnFlow {
                 totalElapsedMs: Math.max(0, Date.now() - startedAt),
                 capabilitiesElapsedMs,
                 authoringContextElapsedMs,
+                runtimeObservationsElapsedMs,
                 catalogCount: componentCapabilities.catalogs?.length ?? 0,
                 capabilityCount: componentCapabilities.catalogs
                     .reduce((count, catalog) => count + (catalog.capabilities?.length ?? 0), 0),
                 attachmentCount: authoringContext.attachmentSummaries?.length ?? 0,
                 hasPendingClarification: !!authoringContext.pendingClarification,
                 hasContextHints: !!authoringContext.contextHints,
+                runtimeObservationCount: runtimeObservationResult.observations.length,
+                runtimeObservationSource: runtimeObservationResult.source,
+                runtimeObservationUnavailable: runtimeObservationResult.unavailable,
             },
         };
     }
+    async collectRuntimeComponentObservations(request) {
+        try {
+            const collected = await this.context.collectRuntimeComponentObservations?.();
+            if (collected?.length) {
+                return {
+                    observations: collected,
+                    source: 'page-builder-explicit',
+                    unavailable: false,
+                };
+            }
+        }
+        catch {
+            const fallback = request.runtimeComponentObservations || [];
+            return {
+                observations: fallback,
+                source: fallback.length ? 'assistant-request' : 'none',
+                unavailable: true,
+            };
+        }
+        const fallback = request.runtimeComponentObservations || [];
+        return {
+            observations: fallback,
+            source: fallback.length ? 'assistant-request' : 'none',
+            unavailable: false,
+        };
+    }
     async toTurnResultFromStreamEvent(event, request, prompt) {
         const payload = this.toJsonObject(event.payload) ?? {};
         if (event.type === 'result') {
-            return this.toResultTurnFromStreamPayload(payload, request, prompt);
+            return this.toResultTurnFromStreamPayload(payload, request, prompt, event);
         }
         if (event.type === 'error') {
             const message = this.describeStreamError(payload);
@@ -15069,7 +15247,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             return {
                 state: 'listening',
                 phase: 'capture',
-                assistantMessage: this.context.tx('agentic.status.cancelled', 'Request cancelled.'),
+                assistantMessage: this.context.tx('agentic.status.cancelled', 'Pedido cancelado.'),
                 quickReplies: [],
                 canApply: false,
                 statusText: '',
@@ -15088,7 +15266,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             preview: null,
         };
     }
-    async toResultTurnFromStreamPayload(payload, request, prompt) {
+    async toResultTurnFromStreamPayload(payload, request, prompt, event) {
         const intentResolution = this.normalizeIntentResolutionResult(payload['intentResolution']);
         const preview = payload['preview'];
         if (!intentResolution) {
@@ -15110,6 +15288,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
             ? payload['quickReplies']
             : intentResolution.quickReplies ?? [];
         const quickReplies = this.resolveShellQuickReplies(intentResolution, rawQuickReplies);
+        this.captureRuntimeRelatedSurfaceDisambiguationContext(payload, event);
         const assistantMessage = this.normalizeAssistantMessageForQuickReplies(rawAssistantMessage, quickReplies);
         const canApply = payload['canApply'] === true && !!preview?.valid;
         const contextualExecutableIntent = request
@@ -15821,23 +16000,23 @@ class PageBuilderAgenticAuthoringTurnFlow {
     describeDashboardQualityWarning(code) {
         switch (code) {
             case 'dashboard-without-chart-widget':
-                return this.context.tx('agentic.dashboardQuality.warning.chart', 'chart widget missing');
+                return this.context.tx('agentic.dashboardQuality.warning.chart', 'faltou um gráfico');
             case 'dashboard-without-kpi-widget':
-                return this.context.tx('agentic.dashboardQuality.warning.kpi', 'KPI block missing');
+                return this.context.tx('agentic.dashboardQuality.warning.kpi', 'faltaram indicadores');
             case 'dashboard-kpi-placeholder-values':
-                return this.context.tx('agentic.dashboardQuality.warning.kpiValues', 'KPI values are placeholders');
+                return this.context.tx('agentic.dashboardQuality.warning.kpiValues', 'indicadores ainda estão sem dados reais');
             case 'dashboard-without-filter-widget':
-                return this.context.tx('agentic.dashboardQuality.warning.filter', 'filter widget missing');
+                return this.context.tx('agentic.dashboardQuality.warning.filter', 'faltaram filtros');
             case 'dashboard-without-record-detail-widget':
-                return this.context.tx('agentic.dashboardQuality.warning.details', 'record detail widget missing');
+                return this.context.tx('agentic.dashboardQuality.warning.details', 'faltou uma área de detalhe');
             case 'dashboard-without-composition-links':
-                return this.context.tx('agentic.dashboardQuality.warning.links', 'widget interactions missing');
+                return this.context.tx('agentic.dashboardQuality.warning.links', 'faltou conectar as partes do painel');
             case 'dashboard-filter-not-connected':
-                return this.context.tx('agentic.dashboardQuality.warning.filterConnection', 'filter is not connected');
+                return this.context.tx('agentic.dashboardQuality.warning.filterConnection', 'o filtro ainda não controla o painel');
             case 'dashboard-chart-not-interactive':
-                return this.context.tx('agentic.dashboardQuality.warning.chartInteraction', 'chart interaction missing');
+                return this.context.tx('agentic.dashboardQuality.warning.chartInteraction', 'o gráfico ainda não abre detalhes');
             case 'dashboard-without-surface-actions':
-                return this.context.tx('agentic.dashboardQuality.warning.surfaces', 'surface actions missing');
+                return this.context.tx('agentic.dashboardQuality.warning.surfaces', 'faltaram ações para consultar detalhes');
             default:
                 return code;
         }
@@ -15883,8 +16062,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-without-kpi-widget')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-add-kpis',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.addKpis', 'Add KPIs'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.addKpis', 'Add a compact KPI block with the most useful metrics for this dashboard, preferably using praxis-rich-content statGroup or metric nodes.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.addKpis', 'Adicionar indicadores'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.addKpis', 'Inclua um bloco compacto com os indicadores mais úteis para acompanhar esse painel.'),
                 icon: 'monitoring',
                 changeKind: 'add_dashboard_kpis',
                 contextHints,
@@ -15893,8 +16072,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-kpi-placeholder-values')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-bind-kpis',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.bindKpis', 'Bind KPI values'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.bindKpis', 'Replace placeholder KPI values with real metric bindings from the dashboard DTO/source, keeping labels and formatting human-readable.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.bindKpis', 'Usar dados reais nos indicadores'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.bindKpis', 'Substitua valores de exemplo dos indicadores por dados reais da fonte escolhida, mantendo nomes e formatos fáceis de entender.'),
                 icon: 'data_object',
                 changeKind: 'bind_dashboard_kpis',
                 contextHints,
@@ -15903,8 +16082,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-without-filter-widget')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-add-filters',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.addFilters', 'Add filters'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.addFilters', 'Add canonical dashboard filters from the DTO fields and connect their requestSearch output to charts and detail widgets through queryContext.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.addFilters', 'Adicionar filtros'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.addFilters', 'Adicione filtros úteis para o analista refinar os dados do painel.'),
                 icon: 'filter_alt',
                 changeKind: 'add_dashboard_filters',
                 contextHints,
@@ -15913,8 +16092,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-without-chart-widget')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-add-chart',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.addChart', 'Add chart'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.addChart', 'Add the most relevant analytical chart to this dashboard, using the same data source and connecting it to the detail widgets.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.addChart', 'Adicionar gráfico'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.addChart', 'Adicione o gráfico mais útil para explicar os dados desse painel e conecte-o aos detalhes quando possível.'),
                 icon: 'insert_chart',
                 changeKind: 'add_dashboard_chart',
                 contextHints,
@@ -15923,8 +16102,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-without-record-detail-widget')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-add-details',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.addDetails', 'Add details'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.addDetails', 'Add a rich record detail widget, preferably a Praxis list or table, using the same dashboard data source.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.addDetails', 'Adicionar detalhes'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.addDetails', 'Inclua uma área de detalhes para o analista consultar os registros por trás dos indicadores.'),
                 icon: 'view_list',
                 changeKind: 'add_dashboard_detail_widget',
                 contextHints,
@@ -15935,8 +16114,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
             || warnings.includes('dashboard-chart-not-interactive')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-connect-widgets',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.connectWidgets', 'Connect widgets'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.connectWidgets', 'Connect the dashboard widgets so filter and chart selections update the detail widgets through queryContext.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.connectWidgets', 'Conectar painel e detalhes'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.connectWidgets', 'Faça filtros e escolhas no gráfico atualizarem a área de detalhes do painel.'),
                 icon: 'hub',
                 changeKind: 'connect_dashboard_widgets',
                 contextHints,
@@ -15945,8 +16124,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
         if (warnings.includes('dashboard-without-surface-actions')) {
             replies.push(this.dashboardQualityQuickReply({
                 id: 'dashboard-quality-add-surfaces',
-                label: this.context.tx('agentic.dashboardQuality.quickReply.addSurfaces', 'Add surfaces'),
-                prompt: this.context.tx('agentic.dashboardQuality.prompt.addSurfaces', 'Add surface.open actions so dashboard selections can open richer drill-down details in a modal or drawer.'),
+                label: this.context.tx('agentic.dashboardQuality.quickReply.addSurfaces', 'Abrir detalhes relacionados'),
+                prompt: this.context.tx('agentic.dashboardQuality.prompt.addSurfaces', 'Permita abrir detalhes relacionados a partir das seleções do painel, sem expor termos técnicos ao usuário.'),
                 icon: 'open_in_new',
                 changeKind: 'add_dashboard_surfaces',
                 contextHints,
@@ -16068,45 +16247,45 @@ class PageBuilderAgenticAuthoringTurnFlow {
         let status = null;
         switch (phase) {
             case 'context.bundle':
-                status = this.context.tx('agentic.status.contextBundle', 'Preparing context...');
+                status = this.context.tx('agentic.status.contextBundle', 'Organizando informações...');
                 break;
             case 'intent.resolve':
                 if (this.isSecondPassStreamPayload(payload)) {
-                    status = this.context.tx('agentic.status.refinedCandidates', 'Reviewing the retrieved resources with the AI...');
+                    status = this.context.tx('agentic.status.refinedCandidates', 'Conferindo as fontes encontradas...');
                     break;
                 }
-                status = this.context.tx('agentic.status.resolvingIntent', 'Resolving intent...');
+                status = this.context.tx('agentic.status.resolvingIntent', 'Entendendo o pedido...');
                 break;
             case 'resource.discovery':
                 if (this.isBackendResourceDiscoveryPayload(payload)) {
-                    status = this.context.tx('agentic.status.resourceDiscoveryBackend', 'Found API resources in the backend catalog.');
+                    status = this.context.tx('agentic.status.resourceDiscoveryBackend', 'Encontrei fontes de dados no catálogo do domínio.');
                     break;
                 }
-                status = this.context.tx('agentic.status.resourceDiscovery', 'Finding API resources...');
+                status = this.context.tx('agentic.status.resourceDiscovery', 'Buscando fontes de dados...');
                 break;
             case 'projectKnowledge.retrieve':
                 status = this.projectKnowledgeStatusForStreamPayload(payload);
                 break;
             case 'preview.plan':
-                status = this.context.tx('agentic.status.previewing', 'Generating preview...');
+                status = this.context.tx('agentic.status.previewing', 'Criando prévia...');
                 break;
             case 'preview.compile':
-                status = this.context.tx('agentic.status.previewCompile', 'Compiling preview...');
+                status = this.context.tx('agentic.status.previewCompile', 'Montando a tela...');
                 break;
             case 'stream.waiting':
-                status = this.context.tx('agentic.status.streamWaiting', 'The backend is still working on this dashboard. Keeping the request alive...');
+                status = this.context.tx('agentic.status.streamWaiting', 'Ainda estou montando este painel. Mantendo o pedido em andamento...');
                 break;
             case 'stream.start.accepted':
-                status = this.context.tx('agentic.status.streamStartAccepted', 'Backend accepted the authoring stream. Opening live progress...');
+                status = this.context.tx('agentic.status.streamStartAccepted', 'Pedido recebido. Abrindo o acompanhamento da criação...');
                 break;
             case 'stream.probe.ready':
-                status = this.context.tx('agentic.status.streamProbeReady', 'Authoring stream endpoint is reachable.');
+                status = this.context.tx('agentic.status.streamProbeReady', 'Acompanhamento da criação disponível.');
                 break;
             case 'stream.transport.opening':
-                status = this.context.tx('agentic.status.streamTransportOpening', 'Opening the live authoring stream...');
+                status = this.context.tx('agentic.status.streamTransportOpening', 'Abrindo acompanhamento em tempo real...');
                 break;
             case 'stream.first-event.received':
-                status = this.context.tx('agentic.status.streamFirstEventReceived', 'Live authoring progress started.');
+                status = this.context.tx('agentic.status.streamFirstEventReceived', 'Criação iniciada.');
                 break;
             default:
                 status = this.readString(payload, 'summary') || this.readString(payload, 'message');
@@ -16123,17 +16302,17 @@ class PageBuilderAgenticAuthoringTurnFlow {
             return status;
         }
         return this.context
-            .tx('agentic.status.backendProgressElapsed', '{status} Backend still working for {seconds}s.')
+            .tx('agentic.status.backendProgressElapsed', '{status} Ainda trabalhando nisso há {seconds}s.')
             .replace('{status}', status)
             .replace('{seconds}', `${Math.round(elapsedSeconds)}`);
     }
     projectKnowledgeStatusForStreamPayload(payload) {
         const diagnostics = this.toJsonObject(payload['diagnostics']);
         const influenceCount = this.readNumber(diagnostics ?? {}, 'influenceCount');
-        const base = this.context.tx('agentic.status.projectKnowledgeRetrieved', 'Retrieved governed project knowledge for this authoring turn.');
+        const base = this.context.tx('agentic.status.projectKnowledgeRetrieved', 'Encontrei conhecimento governado do projeto para orientar este pedido.');
         if (influenceCount && influenceCount > 0) {
             return this.context
-                .tx('agentic.status.projectKnowledgeRetrievedCount', 'Retrieved {count} governed project knowledge signals for this authoring turn.')
+                .tx('agentic.status.projectKnowledgeRetrievedCount', 'Encontrei {count} sinais governados do projeto para orientar este pedido.')
                 .replace('{count}', String(influenceCount));
         }
         return base;
@@ -16144,8 +16323,8 @@ class PageBuilderAgenticAuthoringTurnFlow {
             return normalized;
         }
         return canApply
-            ? this.context.tx('agentic.status.reviewReady', 'Ready for review.')
-            : this.context.tx('agentic.status.reviewNeedsAttention', 'Review the pending points before saving.');
+            ? this.context.tx('agentic.status.reviewReady', 'Pronto para revisão.')
+            : this.context.tx('agentic.status.reviewNeedsAttention', 'Revise os pontos pendentes antes de salvar.');
     }
     shouldReplaceReviewStatus(status) {
         const normalized = status.toLocaleLowerCase();
@@ -16166,13 +16345,13 @@ class PageBuilderAgenticAuthoringTurnFlow {
     describeStreamError(payload) {
         const code = this.readString(payload, 'code');
         if (code === 'agentic-authoring-timeout') {
-            return this.context.tx('agentic.errors.streamTimeout', 'The assistant took too long to finish this request. Try again with a narrower request or review the active context.');
+            return this.context.tx('agentic.errors.streamTimeout', 'O assistente demorou para concluir este pedido. Tente de novo com um recorte menor ou revise o contexto ativo.');
         }
         if (code === 'agentic-authoring-processing-failed') {
-            return this.context.tx('agentic.errors.streamProcessing', 'The assistant could not finish this authoring request. Try again or ask support to review the diagnostics.');
+            return this.context.tx('agentic.errors.streamProcessing', 'Não consegui concluir este pedido. Tente novamente ou peça uma revisão dos detalhes.');
         }
         return this.readString(payload, 'assistantMessage')
-            || this.context.tx('agentic.errors.generic', 'AI authoring failed.');
+            || this.context.tx('agentic.errors.generic', 'Não consegui concluir este pedido.');
     }
     toTurnStreamTransportErrorResult(error) {
         const message = this.isTurnStreamConnectionError(error)
@@ -16249,7 +16428,7 @@ class PageBuilderAgenticAuthoringTurnFlow {
     toGovernedRouteFailClosedResult(request, prompt, error) {
         const contextHints = this.buildContextHints(request);
         const domainCatalog = this.toJsonObject(contextHints?.['domainCatalog']);
-        const assistantMessage = this.context.tx('agentic.governedRoute.streamUnavailable', 'This request must continue through the governed semantic-decision flow in /api/praxis/config/domain-rules. The backend stream is unavailable, so local preview/apply is blocked.');
+        const assistantMessage = this.context.tx('agentic.governedRoute.streamUnavailable', 'Este pedido precisa continuar pela revisão governada da regra de negócio. Não vou criar uma prévia local enquanto essa revisão não estiver disponível.');
         const intentResolution = {
             valid: false,
             operationKind: 'route',
@@ -16463,9 +16642,9 @@ class PageBuilderAgenticAuthoringTurnFlow {
             return backendText;
         }
         const firstLabel = quickReplies[0]?.label?.trim()
-            || this.context.tx('agentic.resourceDiscovery.defaultRecommendedLabel', 'the first option');
+            || this.context.tx('agentic.resourceDiscovery.defaultRecommendedLabel', 'a primeira opção');
         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.')
+        return this.context.tx('agentic.resourceDiscovery.found', 'Encontrei {sourceCount} para esta tela. Recomendo começar por {first}, porque parece a melhor opção para indicadores, gráficos e detalhes. Revise as opções abaixo e escolha a fonte que melhor combina com o que você quer criar.')
             .replace('{sourceCount}', sourceCount)
             .replace('{first}', firstLabel);
     }
@@ -17554,13 +17733,13 @@ function deriveSharedRuleContinuationActions(input) {
         return status === 'applied' || status === 'active';
     });
     return [
-        sharedRuleAction('open_definition', 'Create definition', 'Create or open the governed definition.', target, enabledWhen(!busy && hasAuthoringTarget && !definitionId, busy ? 'busy' : definitionId ? 'definition_already_available' : !handoff ? 'missing_handoff' : 'missing_authoring_target')),
-        sharedRuleAction('simulate', 'Simulate', 'Run canonical backend simulation before publication.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
-        sharedRuleAction('approve', 'Approve', 'Approve the governed definition after review.', target, enabledWhen(!busy && !!definitionId && definitionStatus !== 'approved' && definitionStatus !== 'active', busy ? 'busy' : !definitionId ? 'missing_definition' : 'definition_already_available')),
-        sharedRuleAction('publish', 'Publish/materialize', 'Publish the decision and derive eligible runtime materializations.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
-        sharedRuleAction('materialize', 'Inspect materializations', 'Inspect derived materializations without making the UI the source of truth.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
-        sharedRuleAction('validate_enforcement', 'Validate enforcement', 'Check whether applied materializations are ready for runtime validation.', target, enabledWhen(!busy && !!definitionId && hasAppliedMaterialization, busy ? 'busy' : !definitionId ? 'missing_definition' : 'missing_materialization')),
-        sharedRuleAction('open_timeline', 'Open timeline', 'Open safe timeline observability for this governed decision.', target, enabledWhen(!busy && !!definitionId && hasTimelineEvents, busy ? 'busy' : !definitionId ? 'missing_definition' : 'timeline_unavailable')),
+        sharedRuleAction('open_definition', 'Preparar regra', 'Preparar ou abrir a regra governada para revisão.', target, enabledWhen(!busy && hasAuthoringTarget && !definitionId, busy ? 'busy' : definitionId ? 'definition_already_available' : !handoff ? 'missing_handoff' : 'missing_authoring_target')),
+        sharedRuleAction('simulate', 'Simular impacto', 'Verificar o efeito da regra antes de publicar.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
+        sharedRuleAction('approve', 'Aprovar revisão', 'Aprovar a regra governada depois da conferência.', target, enabledWhen(!busy && !!definitionId && definitionStatus !== 'approved' && definitionStatus !== 'active', busy ? 'busy' : !definitionId ? 'missing_definition' : 'definition_already_available')),
+        sharedRuleAction('publish', 'Publicar alteração', 'Publicar a decisão aprovada e atualizar as telas que dependem dela.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
+        sharedRuleAction('materialize', 'Ver telas afetadas', 'Ver quais telas serão atualizadas por essa decisão governada.', target, enabledWhen(!busy && !!definitionId, busy ? 'busy' : 'missing_definition')),
+        sharedRuleAction('validate_enforcement', 'Validar aplicação', 'Conferir se a alteração publicada já está pronta para uso.', target, enabledWhen(!busy && !!definitionId && hasAppliedMaterialization, busy ? 'busy' : !definitionId ? 'missing_definition' : 'missing_materialization')),
+        sharedRuleAction('open_timeline', 'Ver histórico', 'Abrir o histórico seguro dessa decisão governada.', target, enabledWhen(!busy && !!definitionId && hasTimelineEvents, busy ? 'busy' : !definitionId ? 'missing_definition' : 'timeline_unavailable')),
     ];
 }
 function deriveProjectKnowledgeContinuationActions(input) {
@@ -17575,12 +17754,12 @@ function deriveProjectKnowledgeContinuationActions(input) {
     const hasTimelineEvents = (input.timeline?.events?.length ?? 0) > 0;
     const target = projectKnowledgeTarget(changeSet, candidate?.conceptKey ?? null);
     return [
-        projectKnowledgeAction('create_knowledge_change_set', 'Create change-set', 'Create a governed proposal from cited Project Knowledge.', target, enabledWhen(!busy && !!audit && !!candidate && !changeSet, busy ? 'busy' : !audit ? 'missing_project_knowledge_audit' : !candidate ? 'missing_project_knowledge_candidate' : 'change_set_already_available')),
-        projectKnowledgeAction('validate_knowledge_change_set', 'Validate change-set', 'Run deterministic validation before review.', target, enabledWhen(!busy && !!changeSet && validationStatus !== 'valid', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'validation_already_valid')),
-        projectKnowledgeAction('approve', 'Approve', 'Approve the valid change-set explicitly.', target, enabledWhen(!busy && !!changeSet && validationValid && status !== 'approved' && status !== 'applied', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'validation_required')),
-        projectKnowledgeAction('reject', 'Reject', 'Reject the proposed change-set without applying knowledge.', target, enabledWhen(!busy && !!changeSet && status !== 'applied', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'already_applied')),
-        projectKnowledgeAction('apply_knowledge_change_set', 'Apply change-set', 'Apply only after approval and valid persisted validation.', target, enabledWhen(!busy && !!changeSet && validationValid && status === 'approved', busy ? 'busy' : !changeSet ? 'missing_change_set' : !validationValid ? 'validation_required' : status === 'applied' ? 'already_applied' : 'approval_required')),
-        projectKnowledgeAction('open_timeline', 'Open timeline', 'Open safe Domain Knowledge timeline observability.', target, enabledWhen(!busy && !!changeSet && hasTimelineEvents, busy ? 'busy' : !changeSet ? 'missing_change_set' : 'timeline_unavailable')),
+        projectKnowledgeAction('create_knowledge_change_set', 'Preparar revisão', 'Preparar uma proposta governada a partir do conhecimento citado.', target, enabledWhen(!busy && !!audit && !!candidate && !changeSet, busy ? 'busy' : !audit ? 'missing_project_knowledge_audit' : !candidate ? 'missing_project_knowledge_candidate' : 'change_set_already_available')),
+        projectKnowledgeAction('validate_knowledge_change_set', 'Validar proposta', 'Conferir a proposta antes da revisão.', target, enabledWhen(!busy && !!changeSet && validationStatus !== 'valid', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'validation_already_valid')),
+        projectKnowledgeAction('approve', 'Aprovar revisão', 'Aprovar explicitamente a proposta validada.', target, enabledWhen(!busy && !!changeSet && validationValid && status !== 'approved' && status !== 'applied', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'validation_required')),
+        projectKnowledgeAction('reject', 'Rejeitar proposta', 'Rejeitar a proposta sem aplicar mudanças no conhecimento.', target, enabledWhen(!busy && !!changeSet && status !== 'applied', busy ? 'busy' : !changeSet ? 'missing_change_set' : 'already_applied')),
+        projectKnowledgeAction('apply_knowledge_change_set', 'Aplicar conhecimento', 'Aplicar somente depois da aprovação e da validação.', target, enabledWhen(!busy && !!changeSet && validationValid && status === 'approved', busy ? 'busy' : !changeSet ? 'missing_change_set' : !validationValid ? 'validation_required' : status === 'applied' ? 'already_applied' : 'approval_required')),
+        projectKnowledgeAction('open_timeline', 'Ver histórico', 'Abrir o histórico seguro dessa revisão de conhecimento.', target, enabledWhen(!busy && !!changeSet && hasTimelineEvents, busy ? 'busy' : !changeSet ? 'missing_change_set' : 'timeline_unavailable')),
     ];
 }
 function selectProjectKnowledgeContinuationCandidate(audit) {
@@ -17634,6 +17813,7 @@ function projectKnowledgeTarget(changeSet, conceptKey) {
     };
 }
 
+const AGENTIC_AUTHORING_TURN_TERMINAL_TIMEOUT_MS = 120_000;
 const AGENTIC_PAGE_COMPOSITION_REQUEST_OUTPUT = 'agenticPageCompositionRequested';
 class DynamicPageBuilderComponent {
     dialog;
@@ -17644,6 +17824,7 @@ class DynamicPageBuilderComponent {
     agenticAuthoring = inject(PageBuilderAgenticAuthoringService);
     agenticTurnOrchestrator = inject(PraxisAssistantTurnOrchestratorService);
     assistantSessions = inject(PraxisAssistantSessionRegistryService);
+    runtimeObservationRegistry = inject(PraxisRuntimeComponentObservationRegistryService, { optional: true });
     agenticAuthoringOptions = inject(PAGE_BUILDER_AGENTIC_AUTHORING_OPTIONS, { optional: true });
     runtime;
     page;
@@ -17722,6 +17903,9 @@ class DynamicPageBuilderComponent {
     agenticComponentCapabilities;
     agenticComponentCapabilitiesPromise;
     agenticTurnController;
+    agenticTurnCancel$ = new Subject();
+    agenticTurnRunId = 0;
+    agenticAuthoringTurnTerminalTimeoutMs = AGENTIC_AUTHORING_TURN_TERMINAL_TIMEOUT_MS;
     sharedRuleHandoffRevision = 0;
     agenticAuthoringPanelLayoutTouched = false;
     constructor(dialog, settingsPanel) {
@@ -17743,6 +17927,10 @@ class DynamicPageBuilderComponent {
             this.resetAgenticAuthoringSessionState();
         }
     }
+    ngOnDestroy() {
+        this.cancelActiveAgenticTurn();
+        this.agenticTurnCancel$.complete();
+    }
     showSettings() {
         return !!this.enableCustomization && !this.previewMode;
     }
@@ -17956,24 +18144,24 @@ class DynamicPageBuilderComponent {
     agenticAuthoringHeaderSubtitle() {
         const selectedWidgetLabel = this.resolveSelectedWidgetLabel();
         if (this.agenticAuthoringSharedRuleHandoffState()) {
-            return this.tx('agentic.header.subtitle.governed', 'Continue the governed semantic-decision flow.');
+            return this.tx('agentic.header.subtitle.governed', 'Continue a revisão da regra antes de criar a tela.');
         }
         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.reviewBlocked', 'Prévia pronta, com pontos para revisar.');
             }
-            return this.tx('agentic.header.subtitle.review', 'Preview ready for review and persistence.');
+            return this.tx('agentic.header.subtitle.review', 'Prévia pronta para revisar e salvar.');
         }
         if (selectedWidgetLabel) {
-            return this.tx('agentic.header.subtitle.widget', 'Focused on {target}.')
+            return this.tx('agentic.header.subtitle.widget', 'Foco em {target}.')
                 .replace('{target}', selectedWidgetLabel);
         }
         const routePath = this.pageIdentity?.routePath?.trim();
         if (routePath) {
-            return this.tx('agentic.header.subtitle.route', 'Authoring page route {route}.')
+            return this.tx('agentic.header.subtitle.route', 'Criando ou ajustando a página {route}.')
                 .replace('{route}', routePath);
         }
-        return this.tx('agentic.header.subtitle.page', 'Turn intent into layout, widgets, and governed materializations.');
+        return this.tx('agentic.header.subtitle.page', 'Transforme uma necessidade do domínio em tabela, formulário ou painel.');
     }
     agenticAuthoringHeaderModeLabel() {
         if (this.agenticAuthoringSharedRuleHandoffState()) {
@@ -17992,8 +18180,8 @@ class DynamicPageBuilderComponent {
             prompt: this.tx('agentic.promptLabel', 'Message'),
             promptPlaceholder: this.tx('agentic.promptPlaceholder', 'Describe the page, dashboard, form or change you need.'),
             emptyConversation: this.agenticAuthoringEmptyConversationMessage(),
-            submit: this.tx('agentic.preview', 'Generate preview'),
-            apply: this.tx('agentic.persist', 'Save'),
+            submit: this.tx('agentic.preview', 'Criar prévia'),
+            apply: this.tx('agentic.persist', 'Salvar'),
             conversationAria: this.tx('agentic.conversationAria', 'AI conversation'),
             quickRepliesAria: this.tx('agentic.quickRepliesAria', 'Quick replies'),
             dragHandleAria: this.tx('agentic.dragHandleAria', 'Move AI assistant'),
@@ -18026,9 +18214,9 @@ class DynamicPageBuilderComponent {
             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.blankGeneric', 'Esta tela ainda está vazia. Diga qual atividade do domínio ela precisa apoiar. Posso sugerir um painel, tabela ou formulário e montar uma prévia para você revisar antes de salvar.');
         }
-        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.');
+        return this.tx('agentic.emptyConversation.existingPage', 'Diga o que você quer melhorar nesta tela. Eu leio o que já existe e preparo uma prévia para você revisar antes de salvar.');
     }
     resolveAgenticAuthoredOpeningMessage() {
         const hints = this.toRecord(this.agenticAuthoringContextHints);
@@ -18057,7 +18245,7 @@ class DynamicPageBuilderComponent {
         return !!this.agenticAuthoringPreviewResult()?.valid && !this.agenticAuthoringCanApply();
     }
     agenticAuthoringSubmitAction() {
-        const label = this.tx('agentic.preview', 'Generate preview');
+        const label = this.tx('agentic.preview', 'Criar prévia');
         return {
             id: 'submit',
             kind: 'submit-prompt',
@@ -18108,12 +18296,12 @@ class DynamicPageBuilderComponent {
             return this.truncateAgenticDockText(lastMessage.text);
         }
         if (this.agenticAuthoringPreviewResult()?.valid) {
-            return this.tx('agentic.dock.summaryReview', 'Preview ready. Reopen to review or save.');
+            return this.tx('agentic.dock.summaryReview', 'Prévia pronta. Reabra para revisar ou salvar.');
         }
         if (this.agenticAuthoringSharedRuleHandoffState()) {
-            return this.tx('agentic.dock.summaryGoverned', 'Governed handoff preserved. Continue the semantic decision flow.');
+            return this.tx('agentic.dock.summaryGoverned', 'Revisão preservada. Continue de onde parou.');
         }
-        return this.tx('agentic.dock.summaryIdle', 'Conversation preserved. Continue where you stopped.');
+        return this.tx('agentic.dock.summaryIdle', 'Conversa preservada. Continue de onde parou.');
     }
     agenticAuthoringShellState() {
         if (this.agenticAuthoringBusy())
@@ -18621,6 +18809,7 @@ class DynamicPageBuilderComponent {
         const prompt = this.agenticAuthoringPrompt().trim();
         if (!prompt || this.agenticAuthoringBusy())
             return;
+        const turnRunId = this.beginAgenticTurn();
         this.agenticAuthoringBusy.set(true);
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
@@ -18628,37 +18817,43 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Entendendo o pedido...'));
         try {
             const controller = this.ensureAgenticTurnController();
             const editingMessageId = this.agenticAuthoringEditingMessageId();
             await this.consumeAgenticTurn(editingMessageId
                 ? controller.submitEditedMessage(editingMessageId, prompt)
-                : controller.submitPrompt(prompt));
+                : controller.submitPrompt(prompt), turnRunId);
             this.agenticAuthoringEditingMessageId.set(null);
             this.agenticAuthoringPrompt.set('');
         }
         catch (error) {
+            if (!this.isCurrentAgenticTurn(turnRunId))
+                return;
             this.agenticAuthoringStatus.set('');
             const message = this.describeAgenticError(error);
             this.agenticAuthoringError.set(message);
             this.appendAgenticMessage('error', message);
         }
         finally {
-            this.agenticAuthoringBusy.set(false);
+            if (this.isCurrentAgenticTurn(turnRunId)) {
+                this.agenticAuthoringBusy.set(false);
+            }
         }
     }
     async submitAgenticQuickReply(reply) {
         const replyKind = (reply.kind || 'suggestion').trim().toLowerCase();
         if (replyKind === 'cancel') {
+            this.cancelActiveAgenticTurn();
+            this.agenticAuthoringBusy.set(false);
             this.agenticAuthoringEditingMessageId.set(null);
-            await this.consumeAgenticTurn(this.ensureAgenticTurnController().cancel());
+            await this.applyAgenticTurnState(await firstValueFrom(this.ensureAgenticTurnController().cancel()));
             return;
         }
         if (replyKind === 'revise') {
             this.agenticAuthoringEditingMessageId.set(null);
             this.agenticAuthoringQuickReplies.set([]);
-            this.agenticAuthoringStatus.set(this.tx('agentic.status.waitingRevision', 'Refine your prompt and preview again.'));
+            this.agenticAuthoringStatus.set(this.tx('agentic.status.waitingRevision', 'Ajuste o pedido e crie uma nova prévia.'));
             return;
         }
         this.agenticAuthoringEditingMessageId.set(null);
@@ -18669,6 +18864,7 @@ class DynamicPageBuilderComponent {
             return;
         }
         this.agenticAuthoringPrompt.set(visiblePrompt);
+        const turnRunId = this.beginAgenticTurn();
         this.agenticAuthoringQuickReplies.set([]);
         this.agenticAuthoringBusy.set(true);
         this.agenticAuthoringError.set('');
@@ -18677,7 +18873,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Entendendo o pedido...'));
         try {
             const controller = this.ensureAgenticTurnController();
             const actionKind = controller.snapshot().state === 'clarification'
@@ -18690,17 +18886,21 @@ class DynamicPageBuilderComponent {
                 value: reply.prompt,
                 displayPrompt: visiblePrompt,
                 contextHints,
-            }));
+            }), turnRunId);
             this.agenticAuthoringPrompt.set('');
         }
         catch (error) {
+            if (!this.isCurrentAgenticTurn(turnRunId))
+                return;
             this.agenticAuthoringStatus.set('');
             const message = this.describeAgenticError(error);
             this.agenticAuthoringError.set(message);
             this.appendAgenticMessage('error', message);
         }
         finally {
-            this.agenticAuthoringBusy.set(false);
+            if (this.isCurrentAgenticTurn(turnRunId)) {
+                this.agenticAuthoringBusy.set(false);
+            }
         }
     }
     agenticQuickReplyVisiblePrompt(reply, contextHints) {
@@ -18894,54 +19094,64 @@ class DynamicPageBuilderComponent {
             return;
         this.agenticAuthoringEditingMessageId.set(message.id);
         this.agenticAuthoringPrompt.set(message.text);
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.waitingRevision', 'Refine your prompt and preview again.'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.waitingRevision', 'Ajuste o pedido e crie uma nova prévia.'));
     }
     async resendAgenticMessage(message) {
         if (message.role !== 'user' || this.agenticAuthoringBusy())
             return;
+        const turnRunId = this.beginAgenticTurn();
         this.agenticAuthoringEditingMessageId.set(null);
         this.agenticAuthoringBusy.set(true);
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Entendendo o pedido...'));
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
         this.agenticAuthoringCanApply.set(false);
         this.clearProjectKnowledgeCockpitState();
         try {
-            await this.consumeAgenticTurn(this.ensureAgenticTurnController().resendMessage(message.id));
+            await this.consumeAgenticTurn(this.ensureAgenticTurnController().resendMessage(message.id), turnRunId);
         }
         catch (error) {
+            if (!this.isCurrentAgenticTurn(turnRunId))
+                return;
             this.agenticAuthoringStatus.set('');
             const errorMessage = this.describeAgenticError(error);
             this.agenticAuthoringError.set(errorMessage);
             this.appendAgenticMessage('error', errorMessage);
         }
         finally {
-            this.agenticAuthoringBusy.set(false);
+            if (this.isCurrentAgenticTurn(turnRunId)) {
+                this.agenticAuthoringBusy.set(false);
+            }
         }
     }
     async retryAgenticAuthoring() {
         if (this.agenticAuthoringBusy())
             return;
+        const turnRunId = this.beginAgenticTurn();
         this.agenticAuthoringEditingMessageId.set(null);
         this.agenticAuthoringBusy.set(true);
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Resolving intent...'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.resolvingIntent', 'Entendendo o pedido...'));
         this.agenticAuthoringError.set('');
         try {
-            await this.consumeAgenticTurn(this.ensureAgenticTurnController().retry());
+            await this.consumeAgenticTurn(this.ensureAgenticTurnController().retry(), turnRunId);
         }
         catch (error) {
+            if (!this.isCurrentAgenticTurn(turnRunId))
+                return;
             this.agenticAuthoringStatus.set('');
             const errorMessage = this.describeAgenticError(error);
             this.agenticAuthoringError.set(errorMessage);
             this.appendAgenticMessage('error', errorMessage);
         }
         finally {
-            this.agenticAuthoringBusy.set(false);
+            if (this.isCurrentAgenticTurn(turnRunId)) {
+                this.agenticAuthoringBusy.set(false);
+            }
         }
     }
     async cancelAgenticAuthoring() {
-        if (this.agenticAuthoringBusy())
-            return;
+        this.cancelActiveAgenticTurn();
+        this.agenticAuthoringBusy.set(false);
         this.agenticAuthoringEditingMessageId.set(null);
         this.agenticAuthoringPrompt.set('');
         this.agenticAuthoringPreviewResult.set(null);
@@ -18950,7 +19160,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringSharedRuleHandoffState.set(null);
         this.clearSharedRuleCockpitState();
         this.clearProjectKnowledgeCockpitState();
-        await this.consumeAgenticTurn(this.ensureAgenticTurnController().cancel());
+        await this.applyAgenticTurnState(await firstValueFrom(this.ensureAgenticTurnController().cancel()));
     }
     async persistAgenticAuthoring() {
         const preview = this.agenticAuthoringPreviewResult();
@@ -18963,7 +19173,7 @@ class DynamicPageBuilderComponent {
         }
         this.agenticAuthoringBusy.set(true);
         this.agenticAuthoringError.set('');
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.saving', 'Saving page...'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.saving', 'Salvando tela...'));
         try {
             const compiledFormPatch = this.resolvePreviewCompiledFormPatch(preview);
             const result = await firstValueFrom(this.agenticAuthoring.applyPage({
@@ -18983,7 +19193,7 @@ class DynamicPageBuilderComponent {
             this.agenticAuthoringCanApply.set(false);
             this.agenticAuthoringQuickReplies.set([]);
             this.agenticAuthoringPrompt.set('');
-            this.agenticAuthoringStatus.set(this.tx('agentic.status.saved', 'Page saved.'));
+            this.agenticAuthoringStatus.set(this.tx('agentic.status.saved', 'Tela salva.'));
             this.syncAgenticAuthoringSession();
         }
         catch (error) {
@@ -19543,14 +19753,14 @@ class DynamicPageBuilderComponent {
         next.ruleKey = current.ruleKey || this.resolveSharedRuleKey(next, false);
         this.agenticAuthoringPrompt.set(visiblePrompt);
         this.agenticAuthoringQuickReplies.set([]);
-        this.agenticAuthoringStatus.set(this.tx('agentic.status.sharedRuleTargetSelected', 'Shared-rule target selected. Continue by creating the governed definition.'));
+        this.agenticAuthoringStatus.set(this.tx('agentic.status.sharedRuleTargetSelected', 'Continue this request in the rule review.'));
         this.agenticAuthoringError.set('');
         this.agenticAuthoringPreviewResult.set(null);
         this.agenticAuthoringCanApply.set(false);
         this.agenticAuthoringSharedRuleHandoffState.set(next);
         this.agenticAuthoringSharedRuleHandoff.emit(next);
         this.appendAgenticMessage('user', visiblePrompt);
-        this.appendAgenticMessage('assistant', this.tx('agentic.sharedRuleCockpit.targetSelected', 'Shared-rule target selected. The next safe step is creating the governed definition.'));
+        this.appendAgenticMessage('assistant', this.tx('agentic.sharedRuleCockpit.targetSelected', 'Rule identified. The next safe step is reviewing the rule before creating the screen.'));
         return true;
     }
     resolveSharedRuleQuickReplyRuleType(contextHints, text) {
@@ -19763,6 +19973,12 @@ class DynamicPageBuilderComponent {
         });
         return this.agenticComponentCapabilitiesPromise;
     }
+    async collectRuntimeComponentObservationsForAgenticTurn() {
+        if (!this.runtimeObservationRegistry) {
+            return [];
+        }
+        return this.runtimeObservationRegistry.listActive();
+    }
     ensureAgenticTurnController() {
         if (!this.agenticTurnController) {
             const flow = new PageBuilderAgenticAuthoringTurnFlow(this.agenticAuthoring, {
@@ -19775,6 +19991,7 @@ class DynamicPageBuilderComponent {
                 apiKey: () => this.agenticAuthoringApiKey,
                 enableTurnStream: () => this.agenticAuthoringEnableStreaming,
                 includeLlmDiagnostics: () => this.agenticAuthoringIncludeLlmDiagnostics,
+                collectRuntimeComponentObservations: () => this.collectRuntimeComponentObservationsForAgenticTurn(),
                 loadComponentCapabilities: () => this.loadAgenticComponentCapabilities(),
                 applyLocalPreview: (result) => this.applyAgenticPreviewLocally(result),
                 describePreviewFailure: (result) => this.describeAgenticPreviewFailure(result),
@@ -19804,7 +20021,7 @@ class DynamicPageBuilderComponent {
         if (!applied.success && this.isAgenticTableContractError(applied.error)) {
             return {
                 ...applied,
-                error: this.tx('agentic.errors.invalidTableContract', 'I found the data source, but the generated plan used properties that are incompatible with the table component. I will adjust it to use only supported fields.'),
+                error: this.tx('agentic.errors.invalidTableContract', 'Encontrei a fonte de dados, mas a tabela proposta usa informações que esse componente não aceita. Vou ajustar para usar apenas campos compatíveis.'),
             };
         }
         return applied;
@@ -19816,7 +20033,7 @@ class DynamicPageBuilderComponent {
         this.agenticAuthoringConversation.set(state.messages);
         this.agenticAuthoringQuickReplies.set(state.quickReplies);
         this.agenticAuthoringStatus.set(handoff && !preview?.valid
-            ? this.tx('agentic.status.sharedRuleHandoff', 'Continue this request in the shared-rules flow.')
+            ? this.tx('agentic.status.sharedRuleHandoff', 'Continue este pedido na revisão da regra.')
             : state.statusText);
         this.agenticAuthoringError.set(state.errorText);
         this.agenticAuthoringPreviewResult.set(preview);
@@ -20018,8 +20235,69 @@ class DynamicPageBuilderComponent {
         }
         return Object.keys(merged).length ? merged : undefined;
     }
-    consumeAgenticTurn(states$) {
-        return firstValueFrom(states$.pipe(concatMap((state) => from(this.applyAgenticTurnState(state)).pipe(map(() => state))), filter((state) => this.isAgenticTurnTerminalState(state)), take(1)));
+    consumeAgenticTurn(states$, turnRunId) {
+        return firstValueFrom(states$.pipe(takeUntil(this.agenticTurnCancel$), concatMap((state) => {
+            if (!this.isCurrentAgenticTurn(turnRunId)) {
+                return of(state);
+            }
+            return from(this.applyAgenticTurnState(state)).pipe(map(() => state));
+        }), filter((state) => this.isAgenticTurnTerminalState(state)), timeout({
+            first: this.agenticAuthoringTurnTerminalTimeoutMs,
+            with: () => of(this.createAgenticTurnTimeoutState()),
+        }), take(1))).then(async (state) => {
+            if (this.isCurrentAgenticTurn(turnRunId) && this.isAgenticTurnTimeoutState(state)) {
+                await this.applyAgenticTurnState(state);
+            }
+            return state;
+        });
+    }
+    beginAgenticTurn() {
+        this.cancelActiveAgenticTurn();
+        this.agenticTurnRunId += 1;
+        return this.agenticTurnRunId;
+    }
+    cancelActiveAgenticTurn() {
+        this.agenticTurnRunId += 1;
+        this.agenticTurnCancel$.next();
+    }
+    isCurrentAgenticTurn(turnRunId) {
+        return this.agenticTurnRunId === turnRunId;
+    }
+    createAgenticTurnTimeoutState() {
+        const message = this.tx('agentic.errors.streamTimeout', 'Ainda não consegui concluir este pedido. Tente novamente com um pedido mais específico ou revise o contexto ativo.');
+        return {
+            mode: 'agentic-authoring',
+            state: 'error',
+            phase: 'contextualize',
+            statusText: '',
+            errorText: message,
+            messages: [
+                ...this.agenticAuthoringConversation(),
+                {
+                    id: `${Date.now()}-timeout-error`,
+                    role: 'error',
+                    text: message,
+                },
+            ],
+            quickReplies: [],
+            clarificationQuestions: [],
+            contextItems: this.agenticAuthoringContextItems(),
+            attachments: this.agenticAuthoringAttachments(),
+            canApply: false,
+            preview: null,
+            diagnostics: {
+                timeout: {
+                    schemaVersion: 'praxis-page-builder-agentic-turn-timeout.v1',
+                    source: 'dynamic-page-builder',
+                    elapsedMs: this.agenticAuthoringTurnTerminalTimeoutMs,
+                },
+            },
+        };
+    }
+    isAgenticTurnTimeoutState(state) {
+        const diagnostics = this.toRecord(state.diagnostics);
+        const timeoutDiagnostics = this.toRecord(diagnostics?.['timeout']);
+        return timeoutDiagnostics?.['source'] === 'dynamic-page-builder';
     }
     isAgenticTurnTerminalState(state) {
         return state.state === 'review'
@@ -20226,16 +20504,16 @@ class DynamicPageBuilderComponent {
     formatAgenticFailures(failureCodes) {
         const codes = (failureCodes ?? []).filter((code) => !!code);
         if (codes.length === 0) {
-            return this.tx('agentic.errors.invalidPreview', 'Generated preview is invalid.');
+            return this.tx('agentic.errors.invalidPreview', 'Não consegui montar uma prévia segura para este pedido.');
         }
-        return `${this.tx('agentic.errors.invalidPreview', 'Generated preview is invalid.')}: ${codes.join(', ')}`;
+        return this.tx('agentic.errors.invalidPreviewWithDetails', 'Não consegui montar uma prévia segura. Revise o pedido ou escolha outra fonte de dados.');
     }
     describeAgenticPreviewFailure(result) {
         switch (result.diagnostics?.fieldScopeDecision) {
             case 'rejected-duplicate-field':
-                return this.tx('agentic.errors.duplicateField', 'This field already exists in the selected form.');
+                return this.tx('agentic.errors.duplicateField', 'Este campo já existe no formulário selecionado.');
             case 'rejected-non-local-field-removal':
-                return this.tx('agentic.errors.nonLocalFieldRemoval', 'Only local fields created by AI can be removed in this flow.');
+                return this.tx('agentic.errors.nonLocalFieldRemoval', 'Só posso remover, por aqui, campos que foram criados nesta própria prévia.');
             default:
                 return this.formatAgenticFailures(result.failureCodes);
         }
@@ -20249,13 +20527,13 @@ class DynamicPageBuilderComponent {
         }
         switch (result.diagnostics?.fieldScopeDecision) {
             case 'accepted-add-local-field':
-                return this.tx('agentic.status.acceptedAddLocalField', 'Local field added to the form.');
+                return this.tx('agentic.status.acceptedAddLocalField', 'Campo adicionado ao formulário.');
             case 'accepted-remove-local-field':
-                return this.tx('agentic.status.acceptedRemoveLocalField', 'Local field removed from the form.');
+                return this.tx('agentic.status.acceptedRemoveLocalField', 'Campo removido do formulário.');
             case 'accepted-relabel-server-backed-field':
-                return this.tx('agentic.status.acceptedRelabelField', 'Field label updated.');
+                return this.tx('agentic.status.acceptedRelabelField', 'Nome do campo atualizado.');
             default:
-                return this.tx('agentic.status.previewReady', 'Preview applied to the page.');
+                return this.tx('agentic.status.previewReady', 'Prévia aplicada na tela.');
         }
     }
     isAgenticTableContractError(error) {
@@ -20278,7 +20556,7 @@ class DynamicPageBuilderComponent {
     }
     describeAgenticError(error) {
         if (error?.name === 'TimeoutError') {
-            return this.tx('agentic.errors.streamTimeout', 'The assistant took too long to finish this request. Try again with a narrower request or review the active context.');
+            return this.tx('agentic.errors.streamTimeout', 'O assistente demorou para concluir este pedido. Tente de novo com um recorte menor ou revise o contexto ativo.');
         }
         if (typeof error?.error?.message === 'string' && error.error.message.trim()) {
             return error.error.message.trim();
@@ -20290,9 +20568,9 @@ class DynamicPageBuilderComponent {
             return error.message.trim();
         }
         if (typeof error?.status === 'number') {
-            return `HTTP ${error.status}`;
+            return this.tx('agentic.errors.status', 'Não consegui concluir este pedido. Revise a conexão e tente novamente.');
         }
-        return this.tx('agentic.errors.generic', 'AI authoring failed.');
+        return this.tx('agentic.errors.generic', 'Não consegui concluir este pedido.');
     }
     cloneValue(value) {
         if (value == null || typeof value !== 'object') {
@@ -20409,7 +20687,7 @@ class DynamicPageBuilderComponent {
           </header>
           @if (!agenticAuthoringLlmDiagnosticsCollapsed()) {
             <p class="agentic-diagnostics-panel__description">
-              {{ tx('agentic.diagnostics.description', 'Prompt, context bundle, and tool catalog returned by the backend for this turn.') }}
+              {{ tx('agentic.diagnostics.description', 'Informações usadas para explicar como o assistente chegou à resposta deste pedido.') }}
             </p>
             <pre>{{ agenticAuthoringLlmDiagnosticsText() }}</pre>
           }
@@ -20422,11 +20700,11 @@ class DynamicPageBuilderComponent {
           [class.shared-rule-cockpit--collapsed]="sharedRuleCockpitCollapsed()"
           data-testid="page-builder-shared-rule-cockpit"
           role="region"
-          [attr.aria-label]="tx('agentic.sharedRuleCockpit.title', 'Shared-rule governed actions')"
+          [attr.aria-label]="tx('agentic.sharedRuleCockpit.title', 'Revisão governada da regra')"
           >
           <header class="shared-rule-cockpit__header">
             <div>
-              <strong>{{ tx('agentic.sharedRuleCockpit.title', 'Shared-rule governed actions') }}</strong>
+              <strong>{{ tx('agentic.sharedRuleCockpit.title', 'Revisão governada da regra') }}</strong>
               <span>{{ handoff.ruleKey || handoff.recommendedRuleType || handoff.flowId }}</span>
             </div>
             <div class="shared-rule-cockpit__header-actions">
@@ -20446,7 +20724,7 @@ class DynamicPageBuilderComponent {
           </header>
           @if (!sharedRuleCockpitCollapsed()) {
             <p class="shared-rule-cockpit__description">
-              {{ tx('agentic.sharedRuleCockpit.description', 'Continue the semantic decision in the governed domain-rules lifecycle. The cockpit calls canonical backend actions and only displays derived materializations.') }}
+              {{ tx('agentic.sharedRuleCockpit.description', 'Continue a revisão da regra de negócio antes de criar ou salvar alterações na tela.') }}
             </p>
             <div class="shared-rule-cockpit__actions">
               @for (action of sharedRuleGovernedContinuationActions(); track trackGovernedContinuationAction($index, action)) {
@@ -20850,7 +21128,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
           </header>
           @if (!agenticAuthoringLlmDiagnosticsCollapsed()) {
             <p class="agentic-diagnostics-panel__description">
-              {{ tx('agentic.diagnostics.description', 'Prompt, context bundle, and tool catalog returned by the backend for this turn.') }}
+              {{ tx('agentic.diagnostics.description', 'Informações usadas para explicar como o assistente chegou à resposta deste pedido.') }}
             </p>
             <pre>{{ agenticAuthoringLlmDiagnosticsText() }}</pre>
           }
@@ -20863,11 +21141,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
           [class.shared-rule-cockpit--collapsed]="sharedRuleCockpitCollapsed()"
           data-testid="page-builder-shared-rule-cockpit"
           role="region"
-          [attr.aria-label]="tx('agentic.sharedRuleCockpit.title', 'Shared-rule governed actions')"
+          [attr.aria-label]="tx('agentic.sharedRuleCockpit.title', 'Revisão governada da regra')"
           >
           <header class="shared-rule-cockpit__header">
             <div>
-              <strong>{{ tx('agentic.sharedRuleCockpit.title', 'Shared-rule governed actions') }}</strong>
+              <strong>{{ tx('agentic.sharedRuleCockpit.title', 'Revisão governada da regra') }}</strong>
               <span>{{ handoff.ruleKey || handoff.recommendedRuleType || handoff.flowId }}</span>
             </div>
             <div class="shared-rule-cockpit__header-actions">
@@ -20887,7 +21165,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
           </header>
           @if (!sharedRuleCockpitCollapsed()) {
             <p class="shared-rule-cockpit__description">
-              {{ tx('agentic.sharedRuleCockpit.description', 'Continue the semantic decision in the governed domain-rules lifecycle. The cockpit calls canonical backend actions and only displays derived materializations.') }}
+              {{ tx('agentic.sharedRuleCockpit.description', 'Continue a revisão da regra de negócio antes de criar ou salvar alterações na tela.') }}
             </p>
             <div class="shared-rule-cockpit__actions">
               @for (action of sharedRuleGovernedContinuationActions(); track trackGovernedContinuationAction($index, action)) {