@praxisui/dynamic-form 8.0.0-beta.20 → 8.0.0-beta.22

package/README.md

@@ -585,6 +585,8 @@ Guia completo: `projects/praxis-dynamic-form/docs/layout-items-visual-blocks.md`
 
 ## IA — catálogo de capacidades (composição)
 
+O copiloto semântico do formulário usa o shell global de `@praxisui/ai` e registra uma sessão segura no `PraxisAssistantSessionRegistryService`. O botão local apenas abre o contexto do formulário; minimizar/reabrir deve preservar a sessão no cockpit global, sem tratar o formulário como fonte primária de regra de negócio.
+
 O assistente usa um catálogo agregado de capabilities para gerar patches seguros:
 
 - **Macro (FormConfig)**: layout, regras, ações, hooks e mensagens (`form-ai-capabilities`).
@@ -593,6 +595,8 @@ O assistente usa um catálogo agregado de capabilities para gerar patches seguro
 
 Os paths micro são normalizados para `fieldMetadata[].<prop>` para garantir que os patches apontem para a raiz correta do formulário.
 
+O fluxo agentic-authoring do formulário exige `componentEditPlan` validado pelo `PRAXIS_DYNAMIC_FORM_AUTHORING_MANIFEST` antes de aplicar patch local. Prompts de regra de negócio, política, elegibilidade, compliance, LGPD, aprovação/publicação ou decisão compartilhada devem seguir para `domain-rules`/`shared_rule_authoring`; em `view` sem customização ou readonly, o assistente opera apenas como ajuda/diagnóstico e não aplica mutação local.
+
 ## Regras de formulário (novo contrato)
 
 - Formato: cada regra tem `targetType` (`field | section | action | row | column | visualBlock`), `targets: string[]` (IDs canônicos do alvo), e `effect` com `condition` (`JsonLogicExpression | null`), `properties` e `propertiesWhenFalse`.
@@ -600,7 +604,7 @@ Os paths micro são normalizados para `fieldMetadata[].<prop>` para garantir que
 - Compatibilidade: regras antigas (`context/targetField`) são migradas para `properties/targets` automaticamente; prefixes legados `section:/action:/row:/column:` continuam sendo normalizados quando representarem alvos tradicionais. Para header actions de seção, o ID canônico é preservado como `section:<sectionId>:header-action:<actionLogicalId>`.
 - Semântica de limpeza: valores `null` em `properties/propertiesWhenFalse` removem o override e retornam ao valor base do layout; ausência mantém o valor base.
 - Whitelist por tipo (somente propriedades a seguir são aplicadas; demais são descartadas e logadas em dev):
-  - `field`: `visible`, `required`, `readonly`, `disabled`, `className`, `style`, `label`, `description`, `placeholder`, `hint`, `tooltip`, `prefixIcon`, `suffixIcon`, `prefixText`, `suffixText`, `defaultValue`, `options` (array `{label,value,disabled?}`), `appearance` (`fill|outline`), `color` (`primary|accent|warn`), `floatLabel` (`auto|always|never`), `hintPosition` (`start|end`), `validators` (primitivos por chave).
+  - `field`: `visible`, `required`, `readonly`, `disabled`, `className`, `style`, `label`, `description`, `placeholder`, `hint`, `tooltip`, `prefixIcon`, `suffixIcon`, `prefixText`, `suffixText`, `defaultValue`, `value`, `options` (array `{label,value,disabled?}`), `appearance` (`fill|outline`), `color` (`primary|accent|warn`), `floatLabel` (`auto|always|never`), `hintPosition` (`start|end`), `validators` (primitivos por chave).
   - `section`: `visible`, `title`, `description`, `icon`, `sectionHeader` (objeto rico), `headerActions` (ações contextuais do cabeçalho) e tambem subpropriedades tipadas como `sectionHeader.mode`, `sectionHeader.sourceField`, `sectionHeader.initialsSourceField`, `sectionHeader.altField`, `sectionHeader.fallbackIcon`, `sectionHeader.emptyState`, `sectionHeader.size`, `sectionHeader.initialsMaxLength`, `className`, `style`, `collapsible`, `collapsed`, `headerTooltip`, `headerAlign` (`start|center`), `appearance` (`card|plain|step`), `stepLabel`, gaps (`gapBottom`, `titleGapBottom`, `descriptionGapBottom`), cores/tipografia (`titleColor`, `descriptionColor`, `titleStyle`, `descriptionStyle`).
   - `action`: `visible`, `disabled`, `loading`, `label`, `icon`, `tooltip`, `color` (`primary|accent|warn|basic`), `variant` (`raised|stroked|flat|fab`), `size` (`small|medium|large`), `className`, `style`.
   - `row`: `visible`, `gap`, `rowGap`, `className`, `style`.
@@ -608,10 +612,15 @@ Os paths micro são normalizados para `fieldMetadata[].<prop>` para garantir que
   - `visualBlock`: `visible`, `hidden`, `layout`, `className`, `rootClassName`, `style`, `text`, `title`, `message`; para documentos compostos, use `textNodeId`, `titleNodeId` ou `messageNodeId` para apontar o node textual seguro.
 - IDs canônicos de regras para actions do header de seção usam o formato `section:<sectionId>:header-action:<actionLogicalId>`, evitando colisão com botões globais e com ações repetidas em seções diferentes.
 - Se a seção ainda não tiver `id`, o runtime aceita o fallback `header-action:<actionLogicalId>` por compatibilidade; para contratos persistidos, prefira sempre materializar `section.id`.
-- Runtime (FormRulesService): filtra por whitelist, converte tipos (enum/number/boolean/string), saneia objetos (`options/validators/style`), aplica remoção de chaves com `null` e retorna mapas `fieldProps/sectionProps/actionProps/rowProps/columnProps/visualBlockProps`.
+- Valores calculados: regras de `targetType: "field"` podem escrever `effect.properties.value` ou `effect.propertiesWhenFalse.value`. Use envelope fechado e exclusivo: exatamente `{ "expression": <JsonLogic> }` para calcular ou exatamente `{ "literal": <valor> }` para valor estruturado. Primitivos, `null` e arrays continuam aceitos como literais; objetos literais devem usar `{ "literal": ... }` para não serem tratados como Json Logic legado. Envelopes com chaves extras ou com `literal` e `expression` juntos são inválidos.
+- Ordem de regras: valores calculados são resolvidos em fase anterior, com iteração limitada até estabilizar, antes da aplicação das demais propriedades. Assim uma regra pode calcular `age` e outra regra pode depender de `age` sem depender da posição no array.
+- Comandos condicionais: `formCommandRules` é a superfície aditiva para side effects governados, avaliada depois que `formRules` estabilizam valores calculados. O primeiro corte suporta `effects[].kind: "global-action"` com `globalAction: GlobalActionRef`, policy operacional (`trigger`, `distinct`, `distinctBy`, `debounceMs`, `errorPolicy`, `runOnInitialEvaluation`) e default `trigger: "on-condition-enter"`. Comandos não devem ser colocados em `formRules[].effect.properties`. No editor visual, `payloadExpr` permanece escape hatch de JSON avancado: ele e preservado quando ja existe e nenhum payload estruturado e definido, mas novos campos visuais authoram `payload` literal.
+- Runtime (FormRulesService): filtra por whitelist, converte tipos (enum/number/boolean/string), saneia objetos (`options/validators/style`), aplica remoção de chaves com `null`, resolve `fieldValues` calculados e retorna mapas `fieldProps/sectionProps/actionProps/rowProps/columnProps/visualBlockProps`.
 - Renderização: `PraxisDynamicForm` aplica overrides em campos/seções/ações/linhas/colunas/blocos visuais (visibilidade, gaps, padding, classes, estilos, labels e texto seguro, conforme o tipo); colunas respeitam `align/span/offset/order/hidden/padding` vindo das regras.
 - Regras de `visualBlock` são visual-only: elas não criam `FieldMetadata`, `FormControl`, valor em `formData` ou payload HTTP. Use campo local com `submitPolicy` quando a experiência precisar de valor persistível ou leitura em `rawFormData`.
 
+Politica de erro dos comandos condicionais: falhas de `GlobalActionService.executeRef(...)` geram diagnostico sem propagar excecao para o ciclo do form, e a memoria `distinct` evita repeticao enquanto a condicao segue verdadeira. Sem `GlobalActionService`, actions mutaveis (`api.post`, `api.put`, `api.patch`, `api.delete`) falham fechado e nao sao emitidas via `customAction`.
+
 ### Builder integrado
 
 - No editor visual, use a aba “Propriedades” (integrada ao builder) para selecionar o alvo (`targetType` + autocomplete de IDs de campos/seções/ações/linhas/colunas/blocos visuais), escolher propriedades whitelisted e definir valores para `properties` (branch true) e `propertiesWhenFalse` (branch false). Botão “Limpar override” remove a propriedade (equivalente a `null`).
@@ -817,6 +826,7 @@ Apache-2.0 – see the `LICENSE` packaged with this library or the repository ro
 - Guia de implementação e metadados da cascata: `docs/CASCADE-NATIVA.md`
 - Padrões de endpoints (Options vs Filter) para selects: `projects/praxis-dynamic-fields/docs/generic-crud-service.md` (canônico) e `docs/DEVS-GENERIC-CRUD-SERVICE.md` (resumo operacional)
 - Recipe oficial de Entity Lookup corporativo com `RESOURCE_ENTITY`, `dependsOn`, `dependencyFilterMap`, reidratação por `by-ids` e política de seleção: `examples/ai-recipes/praxis-dynamic-form.entity-lookup-procurement.json`
+- Recipe oficial de comandos condicionais governados com `formCommandRules`, `GlobalActionRef`, policy operacional, valor calculado e date range confirmado: `examples/ai-recipes/praxis-dynamic-form.command-rules.json`
 
 ## Verificação de Schema (ETag/If-None-Match)
 

package/docs/dynamic-form-llm-rule-authoring-guide.md

@@ -119,6 +119,9 @@ obrigatorio e visivel. Quando nao for temporario, dataFim deve ficar opcional.
 
 Use somente JSON Logic canonico.
 Use somente alvos existentes no target catalog.
+Para valores calculados de campos, use somente envelope fechado
+`{ "expression": <JsonLogic> }` ou `{ "literal": <valor> }`.
+Nao misture `literal` e `expression` nem adicione chaves extras ao envelope.
 Nao altere formRulesState.
 Marque metadata.origin como "llm" e metadata.reviewStatus como "pending".
 Explique o impacto antes de aplicar.
@@ -252,6 +255,8 @@ Mapeamento operacional:
 | `field-target-not-found` | Trocar por `fieldMetadata[].name` existente. |
 | `target-not-found` | Trocar por alvo existente no mesmo `targetType`. |
 | `invalid-condition` | Reescrever como Json Logic canonico. |
+| `invalid-value-expression` | Corrigir `effect.properties.value` ou `propertiesWhenFalse.value` para Json Logic valido ou envelope fechado `{ "expression": ... }` / `{ "literal": ... }`. |
+| `computed-value-iteration-limit` | Remover ciclo ou ambiguidade entre valores calculados encadeados. |
 | `unsupported-property` | Usar propriedade permitida por `RULE_PROPERTY_SCHEMA`. |
 | `unsupported-target-type` | Escolher um `targetType` permitido. |
 | `missing-effect` | Criar `effect.condition` e `effect.properties`. |

package/docs/dynamic-form-rules-authoring-plan.md

@@ -81,7 +81,7 @@ A funcionalidade completa tem oito partes, que hoje estao espalhadas:
 | Condicao | Builder converte condicoes simples para Json Logic. | Condicoes complexas podem virar runtime-only. |
 | Efeito | `RULE_PROPERTY_SCHEMA` define propriedades permitidas por alvo. | UI mostra propriedades por alvo, rejeicoes do sanitizer e oferece correcao assistida. |
 | Conversao | `rule-converters.ts` faz round-trip `formRules` <-> `RuleBuilderState` e preserva metadados semanticos como `type: "visualBlockGuidance"` via `config.ruleType`. | Nao ha status explicito de compatibilidade visual. |
-| Execucao | `FormRulesService` aplica propriedades saneadas e o editor oferece preview true/false para revisar o efeito antes de persistir. | Falta ampliar mensagens de diagnóstico para casos de sanitizer parcial. |
+| Execucao | `FormRulesService` resolve valores calculados de campos em fase anterior, aplica propriedades saneadas e o editor oferece preview true/false para revisar o efeito antes de persistir. | Falta ampliar mensagens de diagnóstico para casos de sanitizer parcial. |
 | LLM | Manifesto publica operacoes locais de component/form authoring e preserva `rule.visualBlockGuidance.add` apenas como projecao visual opcional. | Business-rule authoring deve entrar por `domain-rules`/`shared_rule_authoring` antes de virar `form_config`. |
 | Visual blocks | Alvo `visualBlock` existe, entra em `targetSchemas.visualBlocks`, aceita `text`, `title` e `message` saneados e o painel de propriedades guia `textNodeId`, `titleNodeId` e `messageNodeId`. | Falta apenas ampliar biblioteca de exemplos visuais por domínio, sem mudar o contrato. |
 | Governanca | Propriedades nao whitelisted sao descartadas, aparecem para o autor e podem ser corrigidas pelo painel de diagnosticos. | Expandir telemetria/curadoria conforme o catalogo publico amadurecer. |
@@ -110,6 +110,8 @@ Toda regra deve receber um status calculado:
 | `valid` | Executavel no runtime. |
 | `invalid-target` | Um ou mais targets nao existem. |
 | `invalid-condition` | Condicao nao e Json Logic valida. |
+| `invalid-value-expression` | Valor calculado de campo usa Json Logic invalido ou envelope ambiguo. |
+| `computed-value-iteration-limit` | Valores calculados encadeados nao estabilizaram dentro do limite do runtime. |
 | `unsupported-property` | Efeito contem propriedade fora do whitelist. |
 | `runtime-only` | Regra executa, mas nao reabre fielmente no builder visual. |
 | `visual-builder-compatible` | Regra executa e reabre no builder visual. |
@@ -133,6 +135,14 @@ LLM pode sugerir materializacoes visuais derivadas, mas deve seguir estas politi
   `rule.visualBlockGuidance.add` com `type: "visualBlockGuidance"`,
   `targetType: "visualBlock"` e `context: "notification"`.
 - Toda condicao deve ser Json Logic canonico.
+- Valores calculados em `effect.properties.value` e
+  `effect.propertiesWhenFalse.value` devem usar envelope fechado e exclusivo:
+  exatamente `{ "expression": <JsonLogic> }` ou exatamente
+  `{ "literal": <valor> }`. Objetos literais estruturados precisam do envelope
+  `literal`; envelopes com chaves extras sao rejeitados.
+- Valores calculados sao resolvidos antes das demais propriedades por iteracao
+  limitada ate estabilizacao, entao regras dependentes nao devem depender da
+  ordem no array de `formRules`.
 - Toda propriedade deve existir em `RULE_PROPERTY_SCHEMA[targetType]`.
 - Todo target deve existir no `ruleBuilderConfig.targetSchemas`.
 - Remocao de regra exige confirmacao humana.

package/fesm2022/praxisui-dynamic-form-dynamic-form-agentic-authoring-turn-flow-DuH1ad7h.mjs

@@ -0,0 +1,417 @@
+import { firstValueFrom } from 'rxjs';
+
+class DynamicFormAgenticAuthoringTurnFlow {
+    adapter;
+    aiApi;
+    mode = 'agentic-authoring';
+    constructor(adapter, aiApi) {
+        this.adapter = adapter;
+        this.aiApi = aiApi;
+    }
+    async submit(request) {
+        const prompt = (request.prompt ?? '').trim();
+        if (!prompt) {
+            return {
+                state: 'listening',
+                phase: 'capture',
+                statusText: '',
+            };
+        }
+        const componentId = this.adapter.componentId || request.componentId || 'praxis-dynamic-form';
+        const componentType = this.adapter.componentType || request.componentType || 'form';
+        const currentState = this.toAiJsonObject(this.adapter.getCurrentConfig());
+        const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
+        const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());
+        if (this.shouldRestrictToInlineHelp(contextHints)) {
+            return this.toInlineHelpOnlyResult(prompt, request, contextHints);
+        }
+        if (this.shouldRouteToGovernedDecision(prompt, contextHints)) {
+            return this.toGovernedDecisionHandoff(prompt, request);
+        }
+        const response = await firstValueFrom(this.aiApi.getPatch({
+            componentId,
+            componentType,
+            userPrompt: prompt,
+            sessionId: request.sessionId,
+            clientTurnId: request.clientTurnId,
+            messages: this.toChatMessages(request.messages, prompt),
+            currentState,
+            currentStateDigest: this.buildCurrentStateDigest(currentState, runtimeState),
+            uiContextRef: {
+                componentId,
+                componentType,
+            },
+            ...(runtimeState ? { runtimeState } : {}),
+            ...(contextHints ? { contextHints } : {}),
+        }));
+        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    async apply(request) {
+        const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());
+        if (this.shouldRestrictToInlineHelp(contextHints)) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: 'Este formulario esta em modo de leitura. Posso explicar ou diagnosticar, mas nao aplicar mudancas locais.',
+                errorText: 'Aplicacao bloqueada em view/readonly sem customizacao.',
+                canApply: false,
+                pendingPatch: null,
+            };
+        }
+        const patch = this.toRecord(request.pendingPatch);
+        if (!patch) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: 'Nao ha alteracao de formulario pronta para aplicar.',
+                errorText: 'Nao ha alteracao de formulario pronta para aplicar.',
+                canApply: false,
+            };
+        }
+        const result = await this.adapter.applyPatch(patch, request.prompt);
+        if (!result.success) {
+            return {
+                state: 'error',
+                phase: 'apply',
+                assistantMessage: result.error || 'Nao foi possivel aplicar as alteracoes no formulario.',
+                errorText: result.error || 'Nao foi possivel aplicar as alteracoes no formulario.',
+                canApply: true,
+                pendingPatch: patch,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            assistantMessage: 'Alteracoes aplicadas no formulario.',
+            statusText: 'Alteracoes aplicadas no formulario.',
+            canApply: false,
+            pendingPatch: null,
+            diagnostics: result.warnings?.length ? { warnings: result.warnings } : undefined,
+        };
+    }
+    cancel() {
+        return Promise.resolve({
+            state: 'listening',
+            phase: 'capture',
+            assistantMessage: 'Solicitacao cancelada.',
+            statusText: '',
+            canApply: false,
+            pendingPatch: null,
+            pendingClarification: null,
+        });
+    }
+    retry(request) {
+        const lastPrompt = [...(request.messages ?? [])].reverse()
+            .find((message) => message.role === 'user')?.text;
+        return this.submit({
+            ...request,
+            prompt: lastPrompt ?? request.prompt,
+            action: { kind: 'retry' },
+        });
+    }
+    toTurnResult(response, request) {
+        if (!response) {
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: 'Resposta vazia da IA.',
+                errorText: 'Resposta vazia da IA.',
+            };
+        }
+        if (response.type === 'clarification') {
+            const questions = this.toClarificationQuestions(response);
+            return {
+                state: 'clarification',
+                phase: 'clarify',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                clarificationQuestions: questions,
+                quickReplies: this.toQuickReplies(response),
+                canApply: false,
+            };
+        }
+        if (response.type === 'info') {
+            const message = response.message || response.explanation || 'Informacao gerada.';
+            return {
+                state: 'success',
+                phase: 'summarize',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                statusText: message,
+                canApply: false,
+            };
+        }
+        if (response.type === 'error') {
+            const message = response.message || 'Falha ao gerar alteracao de formulario.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                errorText: message,
+                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+            };
+        }
+        if (response.patch && Object.keys(response.patch).length > 0) {
+            const warnings = response.warnings?.filter(Boolean) ?? [];
+            const suffix = warnings.length ? ` Avisos: ${warnings.join('; ')}` : '';
+            return {
+                state: 'review',
+                phase: 'review',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: `${response.explanation || 'Proposta de alteracao pronta para revisar.'}${suffix}`,
+                statusText: 'Revise a proposta antes de aplicar.',
+                canApply: true,
+                pendingPatch: response.patch,
+                preview: {
+                    kind: 'dynamic-form-config-patch',
+                    diff: response.diff ?? [],
+                },
+                diagnostics: warnings.length ? { warnings } : undefined,
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: response.sessionId ?? request.sessionId,
+            assistantMessage: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            statusText: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            canApply: false,
+        };
+    }
+    compileAdapterResponse(response) {
+        const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled && response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                type: 'error',
+                message: 'O formulario exige componentEditPlan validado pelo manifesto antes de gerar patch local.',
+                warnings: [
+                    'free-dynamic-form-patch-rejected',
+                    'Use componentEditPlan validado contra PRAXIS_DYNAMIC_FORM_AUTHORING_MANIFEST.',
+                ],
+            };
+        }
+        if (!compiled) {
+            return response;
+        }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan do formulario nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
+        const warnings = [
+            ...(response.warnings ?? []),
+            ...(compiled.warnings ?? []),
+        ];
+        return {
+            ...response,
+            ...compiled,
+            patch: compiled.patch,
+            warnings: warnings.length ? warnings : undefined,
+        };
+    }
+    toChatMessages(messages, prompt) {
+        const supported = (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            role: message.role,
+            content: message.text,
+        }))
+            .filter((message) => message.content.trim().length > 0);
+        return supported.length ? supported : [{ role: 'user', content: prompt }];
+    }
+    toClarificationQuestions(response) {
+        const labels = response.questions?.length
+            ? response.questions
+            : response.message
+                ? [response.message]
+                : ['Qual ajuste voce quer aplicar no formulario?'];
+        const options = this.toQuickReplies(response).map((reply) => ({
+            id: reply.id,
+            label: reply.label,
+            value: reply.prompt,
+        }));
+        return labels.map((label, index) => ({
+            id: `dynamic-form-clarification-${index + 1}`,
+            type: options.length ? 'single-choice' : 'text',
+            label,
+            allowCustom: true,
+            options,
+        }));
+    }
+    toQuickReplies(response) {
+        const payloads = response.optionPayloads ?? [];
+        if (payloads.length) {
+            return payloads
+                .map((option, index) => {
+                const label = option.label?.trim() || option.value?.trim() || `Opcao ${index + 1}`;
+                const prompt = option.example?.trim() || option.value?.trim() || label;
+                return {
+                    id: `option-${index + 1}`,
+                    label,
+                    prompt,
+                    kind: 'clarification-option',
+                };
+            });
+        }
+        return (response.options ?? [])
+            .filter((option) => !!option?.trim())
+            .map((option, index) => ({
+            id: `option-${index + 1}`,
+            label: option.trim(),
+            prompt: option.trim(),
+            kind: 'clarification-option',
+        }));
+    }
+    buildCurrentStateDigest(currentState, runtimeState) {
+        const fields = Array.isArray(currentState['fieldMetadata'])
+            ? currentState['fieldMetadata']
+                .map((field) => this.toRecord(field)?.['name'])
+                .filter((field) => typeof field === 'string' && field.length > 0)
+            : undefined;
+        const sections = Array.isArray(currentState['sections']) ? currentState['sections'].length : undefined;
+        return {
+            ...(fields?.length ? { columns: fields } : {}),
+            ...(typeof runtimeState?.['totalFields'] === 'number'
+                ? { rowCount: runtimeState['totalFields'] }
+                : sections !== undefined
+                    ? { rowCount: sections }
+                    : {}),
+        };
+    }
+    shouldRestrictToInlineHelp(contextHints) {
+        const policy = this.toRecord(contextHints?.['runtimeAuthoringPolicy']);
+        return policy?.['canApplyLocalPatch'] === false;
+    }
+    toInlineHelpOnlyResult(prompt, request, contextHints) {
+        const policy = this.toRecord(contextHints?.['runtimeAuthoringPolicy']);
+        const reason = typeof policy?.['reason'] === 'string'
+            ? policy['reason']
+            : 'Formulario em modo de leitura ou readonly.';
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: request.sessionId,
+            assistantMessage: `Posso ajudar explicando este formulario ou diagnosticando o estado atual, mas nao vou aplicar alteracoes locais aqui. Motivo: ${reason}`,
+            statusText: 'Modo somente assistencia.',
+            canApply: false,
+            pendingPatch: null,
+            quickReplies: [
+                {
+                    id: 'explain-current-form',
+                    label: 'Explicar formulario atual',
+                    prompt: `Explique este formulario considerando: ${prompt}`,
+                    kind: 'inline-help',
+                    icon: 'help',
+                },
+            ],
+        };
+    }
+    shouldRouteToGovernedDecision(prompt, contextHints) {
+        const normalized = prompt.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+        const recommendedFlow = this.toRecord(contextHints?.['domainCatalog'])?.['recommendedAuthoringFlow'];
+        if (recommendedFlow === 'shared_rule_authoring')
+            return true;
+        return [
+            'regra',
+            'politica',
+            'policy',
+            'compliance',
+            'lgpd',
+            'privacidade',
+            'aprovacao',
+            'aprovar',
+            'publicar',
+            'materializar',
+            'enforcement',
+            'validacao de negocio',
+            'validar negocio',
+            'elegibilidade',
+            'permissao',
+            'acesso',
+        ].some((term) => normalized.includes(term));
+    }
+    toGovernedDecisionHandoff(prompt, request) {
+        const message = 'Esse pedido parece alterar uma decisao de negocio compartilhada. O formulario pode contextualizar campo/secao, mas a regra deve seguir pelo fluxo governado de domain-rules antes de qualquer materializacao runtime.';
+        return {
+            state: 'clarification',
+            phase: 'clarify',
+            sessionId: request.sessionId,
+            assistantMessage: message,
+            statusText: 'Handoff governado necessario.',
+            canApply: false,
+            quickReplies: [
+                {
+                    id: 'shared-rule-handoff',
+                    label: 'Continuar como regra governada',
+                    prompt,
+                    kind: 'shared-rule-handoff',
+                    description: 'Criar intake de domain-rules em vez de aplicar regra local no formulario.',
+                    icon: 'rule',
+                    tone: 'warning',
+                    contextHints: {
+                        flowId: 'shared_rule_authoring',
+                        source: 'praxis-dynamic-form',
+                        recommendedAction: 'domain-rules/intake',
+                    },
+                },
+            ],
+            clarificationQuestions: [
+                {
+                    id: 'dynamic-form-governed-rule-confirmation',
+                    type: 'confirm',
+                    label: 'Deseja continuar pelo fluxo governado de regras compartilhadas?',
+                    description: 'Esse caminho permite intake, simulacao, aprovacao/publicacao, materializacao e validacao de enforcement.',
+                    required: true,
+                    options: [
+                        {
+                            id: 'shared-rule-handoff',
+                            label: 'Sim, continuar governado',
+                            value: prompt,
+                            description: 'Nao aplicar como patch local do formulario.',
+                            contextHints: {
+                                flowId: 'shared_rule_authoring',
+                                source: 'praxis-dynamic-form',
+                            },
+                        },
+                    ],
+                },
+            ],
+            diagnostics: {
+                governedDecisionHandoff: {
+                    flowId: 'shared_rule_authoring',
+                    sourcePrompt: prompt,
+                    sourceComponent: 'praxis-dynamic-form',
+                },
+            },
+        };
+    }
+    optionalJsonObject(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const object = this.toAiJsonObject(value);
+        return Object.keys(object).length ? object : undefined;
+    }
+    toAiJsonObject(value) {
+        const record = this.toRecord(value);
+        if (!record) {
+            return {};
+        }
+        try {
+            return JSON.parse(JSON.stringify(record));
+        }
+        catch {
+            return {};
+        }
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+}
+
+export { DynamicFormAgenticAuthoringTurnFlow };