wuic-framework-lib 1.2.0 → 1.3.0

package/types/wuic-framework-lib.d.ts

@@ -594,6 +594,15 @@ declare class TranslationManagerService {
      * del missing key).
      */
     private _langMismatchReloadInFlight;
+    /**
+     * Ultimo locale risolto in modo AFFIDABILE (da override localStorage o da
+     * `userInfo`). Usato come fallback stabile in `resolveCurrentLocale()` quando
+     * `getuserInfo()` torna momentaneamente vuoto (succede durante navigazione/
+     * edit/reload metadata): senza, il locale driftarebbe a `navigator.language`/
+     * default, cambiando la `translationCacheKey` e innescando il self-heal che
+     * faceva sparire le traduzioni fino al refresh.
+     */
+    private _stableLocale;
     /**
      * Bundle minimo di traduzioni hardcoded per il SOLO scenario firstRun (DB
      * metadati ancora non inizializzato → tabella `_wuic_translations` non
@@ -1160,9 +1169,17 @@ declare class DataSourceComponent implements OnInit, OnDestroy {
      * DI) invece che da costruttore per non rompere i call site manuali tipo
      * `new DataSourceComponent(metaSrv, dataSrv, ...)` in designer.component.ts
      * e metadata-editor.service.ts (che mantengono i 7 params posizionali storici).
-     * `{ optional: true }` rende il field null fuori da un Angular DI context
-     * (es. unit test che istanziano la classe a mano) — il consumo in ngOnInit
-     * usa `?.nativeElement` per sopportare entrambi i path.
+     *
+     * ATTENZIONE: `{ optional: true }` rende il field `null` solo se il TOKEN non e'
+     * risolvibile, NON quando si e' fuori da un injection context. Fuori contesto
+     * (istanziazione manuale via `new`, es. metadata-editor.service che crea un
+     * DataSource headless per fetch schema/dati) `inject()` lancia SEMPRE `NG0203`
+     * a prescindere da `optional`. Per questo lo avvolgiamo in try/catch: nel path
+     * Angular normale ritorna l'ElementRef host; nei call site manuali ritorna
+     * `null` (il consumo in ngOnInit usa `?.nativeElement`, quindi entrambi i path
+     * sono supportati). Senza questo guard, un doppio-click su una label del
+     * parametric dialog (che passa per metadata-editor.service -> `new DataSource`)
+     * crashava con NG0203.
      * Scopo: esporre `this` su `host.__wuicCmp` per E2E introspection senza
      * dipendere da `window.ng.getComponent` (tree-shaken in prod build).
      */
@@ -1514,6 +1531,31 @@ declare class DataSourceComponent implements OnInit, OnDestroy {
   * Svuota la selezione locale delle righe.
   */
     clearSelectedRows(): void;
+    /**
+     * Ritorna i record correntemente selezionati nella `<wuic-list-grid>` (checkbox
+     * di selezione multipla). Usato nelle **toolbar action bulk** per recuperare le
+     * righe su cui agire prima di chiamare un endpoint server.
+     *
+     * Forma canonica nei callback (firma `(datasource, metaInfo, record, event, wtoolbox)`):
+     * ```js
+     * const selected = (datasource.getSelectedRows && datasource.getSelectedRows()) || [];
+     * if (!selected.length) {
+     *   wtoolbox.messageNotificationService.add({ severity:'warn', summary:'Selezione vuota', detail:'Seleziona almeno una riga' });
+     *   return;
+     * }
+     * const ids = selected.map(r => Number(r.id?.value ?? r.id ?? r.Id));
+     * ```
+     *
+     * **Importante**: il parametro `record` passato al callback toolbar è un SINGOLO
+     * record (la riga "corrente"), NON l'array dei selezionati. Per il bulk usare
+     * SEMPRE `datasource.getSelectedRows()` (oggetti completi) o
+     * `datasource.getSelectedKeys()` (solo PK).
+     *
+     * Pre-requisito: la tabella deve avere `mdmultipleselection=1` su
+     * `_metadati__tabelle` (vedi skill `table-actions`).
+     *
+     * @returns Array di record selezionati (vuoto se nulla e' selezionato).
+     */
     getSelectedRows(): any[];
     /**
   * Estrae dalla selezione i valori della chiave primaria; per PK composta restituisce un oggetto per riga.
@@ -2993,6 +3035,32 @@ declare class MetadataProviderService {
      * @param userId Identificativo utente usato per contesto e persistenza.
      */
     private clearMenuAdminMethodsCache;
+    /**
+     * Cancella dalla Dexie locale SOLO i record collegati alla route data, lasciando
+     * intatto il resto del database multi-tenant. Necessario dopo che un'operazione
+     * server-side (es. RAG chatbot Apply, metadata-editor save) modifica i metadati
+     * di una singola route senza invalidare l'intera cache: chiamare
+     * <c>Dexie.delete()</c> per tutto il DB causa una riapertura completa al primo
+     * F5 (costosa: ~MB di re-fetch dal backend per le route che non hanno cambiato);
+     * con questo metodo si esegue un flush mirato sulle 7 tabelle Dexie correlate.
+     *
+     * Tabelle gestite (vedi <c>generateLocalDB</c>):
+     *   - MetadatiTabella           (filter: md_route_name)
+     *   - MetadatiColonna           (filter: md_id derivato)
+     *   - MetadatiCustomActionTabella (filter: md_id)
+     *   - MetadatiUiStiliTabella    (filter: md_id)
+     *   - MetadatiUiStiliColonna    (filter: mc_id ∈ colonne della route)
+     *   - MetadatiUtentiAutorizzazioniColonna (filter: mc_id ∈ colonne della route)
+     *   - MetadatiConditionGroup    (filter: md_id)
+     *
+     * No-op se: route vuota, Dexie non inizializzata, o la route non e' presente in
+     * cache (gia' "lazy" - verra' fetched dal backend al primo accesso).
+     * Best-effort: errori dei singoli delete non bloccano gli altri.
+     *
+     * @param route Nome route metadata (es. "cities", "stockitems") — corrisponde
+     *              a <c>MetadatiTabella.md_route_name</c>.
+     */
+    static deleteRouteFromCache(route: string): Promise<void>;
     /**
      * Invalida la cache menu dell'utente corrente (o dell'utente passato) rimuovendo la voce `menu_{userId}` da localStorage.
      * Se richiesto elimina anche la cache dei metodi amministrativi `menu_admin_methods_{userId}`.
@@ -3007,6 +3075,32 @@ declare class MetadataProviderService {
      * @returns Collezione metadata colonna della tabella richiesta.
      */
     getMetadatiById(md_id: number): Promise<MetadatiColonna[]>;
+    private static _availableRoutesCache;
+    private static _availableRoutesInflight;
+    /**
+     * Lista delle route metadata utente (md_route_name + md_display_string).
+     * Backend: `MetaService.getAvailableRoutes` (admin-only, cached server-side).
+     *
+     * Idempotente + de-duplicato in-flight: chiamate concorrenti condividono
+     * la stessa Promise per evitare race.
+     *
+     * Usata dal chatbot RAG (designer state provider) per:
+     *   1) fornire al LLM la whitelist di route valide,
+     *   2) permettere fuzzy-match semantico ("provincie" -> "provinces"),
+     *   3) fare follow-up question quando l'utente menziona una route ambigua.
+     */
+    getAvailableRoutesAsync(): Promise<Array<{
+        md_id: number;
+        md_route_name: string;
+        md_display_string: string;
+    }>>;
+    /**
+     * Invalida la cache process-wide delle route disponibili. Chiamare dopo
+     * scaffolding (crea/elimina route) per forzare un re-fetch al prossimo
+     * accesso. La cache server-side va invalidata separatamente (boot di
+     * un nuovo worker o gesture esplicita).
+     */
+    clearAvailableRoutesCache(): void;
     /**
      * Restituisce i metadata di una route (o `md_id`) da cache Dexie quando validi; in caso contrario ricarica da backend.
      * Gestisce invalidazione per versioning metadata progetto e bypass cache in modalita client-side CRUD.
@@ -3596,8 +3690,10 @@ declare class DataProviderMetaService {
      */
     private buildStoredParametersPayload;
     /**
-     * Pulisce la cache localStorage preservando le traduzioni gia caricate.
-     * Evita regressioni UX dove, dopo save metadata non-translation, le label tornano alle chiavi raw.
+     * Pulisce la cache localStorage preservando le chiavi user-state della
+     * whitelist centralizzata in `util/wuic-storage.util.ts` (translation cache,
+     * id sessione chatbot RAG, preferenze tema/lingua, ecc.). Vedi i commenti in
+     * quel file per la lista completa e il razionale.
      */
     private clearLocalStoragePreservingTranslation;
     private buildRouteContext;
@@ -6225,6 +6321,9 @@ declare class ListGridComponent implements AfterViewInit, OnInit, OnDestroy, IDa
     private releaseGridStateUrlPushTimer;
     private navigationTriggeredByPopstate;
     private suppressNextPageOnlyQuerySync;
+    private pendingFilterChangeEvent;
+    private pendingFilterChangeTimer;
+    private lastFetchedPayloadHash;
     clientSideCrudToggleBusy: boolean;
     private persistedColumnWidthsByRoute;
     private persistedColumnLayoutByRoute;
@@ -6658,6 +6757,12 @@ declare class ListGridComponent implements AfterViewInit, OnInit, OnDestroy, IDa
      * @returns Risultato elaborato da `pageFilterChange` e restituito al chiamante.
      */
     pageFilterChange(event: any): Promise<void>;
+    /**
+     * Processore reale dell'evento PrimeNG (sort/filter/paging). Chiamato
+     * tail-call da `pageFilterChange` via setTimeout(0) per coalesce.
+     * NON chiamare direttamente: la coalesce e' la guard anti-duplicate-fetch.
+     */
+    private _processPageFilterEvent;
     /**
      * Gestisce la logica operativa di `clearFilter` in modo coerente con l'implementazione corrente.
      * @param table Parametro utilizzato dal metodo nel flusso elaborativo.
@@ -9951,6 +10056,12 @@ interface AppSettingFieldDef {
      * user can't accidentally write `mssqll` and brick the next backend boot.
      */
     options?: string[] | null;
+    /** Se valorizzato, le `options` sono DINAMICHE: vengono fetchate da questo endpoint
+     *  (relativo, es. `api/AppSettings/LlmModels`) passando il valore del campo
+     *  `optionsDependsOn` come query param omonimo. Re-fetch al cambio di quel campo. */
+    optionsEndpoint?: string | null;
+    /** Key (senza prefisso `AppSettings:`) del campo da cui dipendono le options dinamiche. */
+    optionsDependsOn?: string | null;
 }
 interface AppSettingSection {
     name: string;
@@ -10033,6 +10144,14 @@ declare class AppSettingsEditorComponent implements OnInit {
      */
     onFieldChange(key: string, newValue: any): void;
     fieldValue(key: string): any;
+    /** Per ogni field con `optionsEndpoint`, fetcha le options usando il valore corrente
+     *  del campo `optionsDependsOn`. Chiamato dopo ogni loadSchema. */
+    private refreshDynamicOptions;
+    /** Valore corrente del campo identificato da `dependsOnKey` (con/senza prefisso AppSettings:). */
+    private dependsOnValue;
+    /** GET `<endpoint>?<dependsOn>=<depVal>` -> popola `f.options`. Best-effort: su errore
+     *  lascia il campo come testo libero (options resta vuoto). */
+    private fetchFieldOptions;
     /**
      * Ritorna `true` se almeno uno dei changes coinvolge una chiave licenza
      * (`license-email` / `license-payload` / `license-signature`). Usato dal save
@@ -12428,6 +12547,17 @@ declare class DynamicRowTemplateComponent {
   * Gestisce la logica operativa di `classes` usando metadati di tabella/colonna allineati al modello server `_Metadati_*`.
   * @returns Valore calcolato dinamicamente a partire dallo stato corrente del componente.
   */
+    /**
+     * Inline style cumulativo applicato alla `<tr>` quando una entry di
+     * `_metadati__u_i__stili__tabelle` ha `must_attribute_name` con prefisso `style:`
+     * (es. `style:background-color:#9b59b6;color:white`). Permette al chatbot RAG
+     * (tool `propose_table_style`) di proporre colori arbitrari fuori dalla palette
+     * predefinita (`row-danger/warning/info/success`) senza dover aggiungere CSS
+     * lato app. Sintassi: prefisso `style:` letterale + dichiarazioni standard CSS
+     * separate da `;`. Backwards-compatible: entries senza prefisso `style:` restano
+     * trattate come classe CSS (vedi `getTableStyleClasses`).
+     */
+    get inlineStyle(): string | null;
     get classes(): string | null;
     /**
   * Recupera e prepara i dati richiesti dal chiamante normalizzando e trasformando collezioni di record, usando i metadati per determinare campi, chiavi e comportamento runtime, allineando i record al formato atteso dal framework.
@@ -12435,6 +12565,16 @@ declare class DynamicRowTemplateComponent {
   */
     private getTableStyleClasses;
     /**
+     * Inline-style speculare a `getTableStyleClasses`. Filtra le entries di
+     * `_Metadati_UI_Stili_Tabelles` il cui `must_attribute_name` ha prefisso
+     * `style:` letterale; valuta il predicate (`must_attribute_value`) con
+     * stessa semantica e stessa cache (skip su throw); concatena le dichiarazioni
+     * CSS in una stringa unica idonea all'attributo HTML `style`. Restituisce
+     * `null` se nessuna entry matcha — Angular rimuove l'attributo, lasciando
+     * intatto eventuale styling dal CSS.
+     */
+    private getTableInlineStyle;
+    /**
   * Costruisce una struttura di output a partire dal contesto corrente usando i metadati per determinare campi, chiavi e comportamento runtime, allineando i record al formato atteso dal framework.
   * @param conditionCode Valore testuale usato come chiave, campo, route o parametro di configurazione.
   * @returns Valore di tipo `(metaInfo: MetaInfo, record: any, wtoolbox: typeof WtoolboxService) => boolean` costruito dal metodo per i passaggi successivi del flusso.
@@ -12448,6 +12588,17 @@ declare class DynamicRowTemplateComponent {
   */
     getCellClasses(metaColumn: any, rowData: any): string | null;
     /**
+     * Inline-style speculare a `getCellInlineStyle` per le celle. Filtra le
+     * entries di `_Metadati_UI_Stili_Colonnes` il cui `musc_attribute_name` ha
+     * prefisso `style:`; valuta il predicate (`musc_attribute_value` o
+     * `musc_attribute_value_callback`) e concatena le dichiarazioni CSS in una
+     * stringa unica idonea all'attributo HTML `style`. Iniezione automatica di
+     * `!important` su ogni dichiarazione che non ce l'ha gia' (PrimeNG p-table
+     * applica `background` ai td via regole con `!important` per striped/hover —
+     * senza, l'inline style perderebbe la specificity).
+     */
+    getCellInlineStyle(metaColumn: any, rowData: any): string | null;
+    /**
   * Recupera e prepara i dati richiesti dal chiamante usando i metadati per determinare campi, chiavi e comportamento runtime.
   * @param fieldName Valore testuale usato come chiave, campo, route o parametro di configurazione.
   * @returns Valore di tipo `MetadatiColonna | null` costruito dal metodo per i passaggi successivi del flusso.
@@ -14181,11 +14332,15 @@ interface RagChatTurn {
     role: 'user' | 'assistant';
     content: string;
 }
+/** Profilo redazione richiesto dall'UI (toggle). Il server applica
+ * strictest-of(env, richiesta): puo' solo aumentare la redazione. */
+type RagProfile = 'internal' | 'release';
 /** Payload `POST /api/Rag/Query`. */
 interface RagQueryRequest {
     query: string;
     top_k?: number;
     use_lora?: boolean;
+    profile?: RagProfile;
 }
 /** Risposta `POST /api/Rag/Query`. */
 interface RagQueryResponse {
@@ -14197,6 +14352,7 @@ interface RagChatRequest {
     history?: RagChatTurn[];
     top_k?: number;
     model?: string;
+    profile?: RagProfile;
 }
 /**
  * Risposta `POST /api/Rag/Chat`.
@@ -14232,6 +14388,14 @@ interface RagChatSessionDto {
     title?: string | null;
     createdAt: string;
     updatedAt: string;
+    /** Riassunto dei turn pre-compact (iniettato nel system prompt LLM). Null
+     *  finche' la session non e' mai stata compattata. */
+    contextSummary?: string | null;
+    /** JSON array dei memory facts pinnati. Null/[] = nessun fact pinnato. */
+    memoryFactsJson?: string | null;
+    /** Marker: turn con `id <= summaryUpToMessageId` sono coperti dal `contextSummary`
+     *  e vengono trim-mati dalla history passata al LLM. */
+    summaryUpToMessageId?: number | null;
 }
 /** Un messaggio (turno) della cronologia. */
 interface RagChatMessageDto {
@@ -14249,6 +14413,123 @@ interface RagChatMessageDto {
     correlationId: string;
     createdAt: string;
     completedAt?: string | null;
+    /** JSON serializzato della proposta strutturata emessa dall'LLM via tool-use.
+     * Forma: {"kind":"toolbar_action","route":"cities","label":"Genera PDF",
+     *         "icon":"pi pi-file-pdf","callback_js":"...","rationale":"..."}.
+     * Null = nessuna proposta (risposta solo testo). */
+    proposedActionJson?: string | null;
+    /** Timestamp UTC dell'applicazione della proposta. Null = mai applicata. */
+    proposedActionAppliedAt?: string | null;
+    /** JSON array di follow-up question (max 3) emesse dall'LLM via tool
+     *  `suggest_followups`. Renderizzate come chip cliccabili sotto la risposta;
+     *  click su un chip popola l'input box (non invia automaticamente). */
+    followupQuestionsJson?: string | null;
+    /** Token consumati dalla call Anthropic per questo turn (driver del cerchio cue). */
+    contextUsedTokens?: number | null;
+    /** Context window max del modello al momento del turn (es. 200000 per Haiku). */
+    contextWindowMax?: number | null;
+}
+/** Forma deserializzata della proposta. Il client deve gestire SOLO i `kind` che
+ *  conosce — futuro-proof: gli sconosciuti vengono mostrati come "azione non
+ *  supportata da questa versione del client". */
+type RagProposedActionKind = 'toolbar_action' | 'row_action' | 'table_style' | 'column_style' | 'display_formula' | 'form_title_formula' | 'default_value_callback' | 'custom_validation' | 'selection_changed' | 'lifecycle_callback' | 'simple_metadata_update'
+/**
+ * Iniezione di componenti nel canvas del dashboard designer.
+ *
+ * NB: kind CLIENT-ONLY - NON viene applicato dal backend
+ * `RagController.ApplyAction` ma da un handler registrato dal
+ * designer.component via `ChatbotHostRegistryService`. Vedi
+ * docs/pages/_internal/designer-tool-catalog.md per il catalogo
+ * dei tool palette disponibili + constraint.
+ *
+ * Payload: `{ kind, layout: [{tool_name, inputs?, parent_unique_name?, children?}, ...], rationale }`.
+ * Il chatbot popover bypassa `/api/Rag/ApplyAction` quando il
+ * registry ha un handler per questo kind.
+ */
+ | 'designer_inject'
+/**
+ * Scrittura di uno snippet SQL in un campo metadata D3 (super-admin).
+ * Campi gated da `Helpers.SqlFragmentMetadataFields`:
+ * `md_join_override`, `mc_custom_select_clause`, `mc_custom_join`,
+ * `mc_computed_formula`, `mc_ui_lookup_computed_dataTextField`.
+ *
+ * Backend-applied via `RagController.ApplySqlMetadataField` con D3 RBAC
+ * gate (`AssertCanWriteSqlFragmentFields`) + audit log su `_error__logs`.
+ * Payload: `{kind, target_table, target_row_key:{route, column_name?},
+ * field_name, sql_snippet, dbms_target, rationale}`.
+ */
+ | 'sql_metadata_field'
+/**
+ * Creazione di una nuova riga in `_metadati__colonne` (colonna fisica o
+ * calcolata). Step 1 del workflow per colonne calcolate (step 2 = `sql_metadata_field`
+ * con `mc_computed_formula`). Backend-applied via
+ * `RagController.ApplyMetadataColumnCreate` + audit log `_error__logs`.
+ * Payload: `{kind, route, column_name, display_string, ui_column_type,
+ * is_computed, real_column_name?, rationale}`.
+ */
+ | 'metadata_column_create';
+interface RagProposedAction {
+    kind: RagProposedActionKind | string;
+    route?: string;
+    label?: string;
+    icon?: string;
+    callback_js?: string;
+    rationale?: string;
+    /**
+     * Solo per `kind === 'toolbar_action'`. True quando il callback opera sulla
+     * SELEZIONE corrente (bulk delete/archive/export/update via
+     * `datasource.getSelectedRows()`). All'apply, il backend abilita
+     * `md_multiple_selection` sulla route se non gia' attivo (le checkbox di
+     * selezione riga compaiono in UI). Omettere significa false.
+     */
+    requires_multi_selection?: boolean;
+    [key: string]: any;
+}
+/** Payload `POST /api/Rag/ApplyAction`. */
+interface RagApplyActionRequest {
+    messageId: number;
+}
+/** Payload `POST /api/Rag/UpdateProposedAction`. Usato quando l'utente edita
+ *  la classe/stile o il callback nell'UI prima del click "Applica" — il
+ *  componente invia il payload completo e il backend sovrascrive
+ *  `proposed_action_json` (filtri ownership + non-applicata). */
+interface RagUpdateProposedActionRequest {
+    messageId: number;
+    proposedAction: RagProposedAction;
+}
+interface RagUpdateProposedActionResponse {
+    ok: boolean;
+    error?: string;
+    maxBytes?: number;
+}
+interface RagApplyActionResponse {
+    ok: boolean;
+    kind?: string;
+    projectMetadataVersion?: string;
+    error?: string;
+    detail?: string;
+}
+/** Payload `POST /api/Rag/Compact`. */
+interface RagCompactRequest {
+    sessionId: number;
+}
+interface RagCompactResponse {
+    ok?: boolean;
+    noop?: boolean;
+    summaryUpToMessageId?: number;
+    summaryLength?: number;
+    error?: string;
+    reason?: string;
+}
+/** Payload `POST /api/Rag/RenameSession`. */
+interface RagRenameSessionRequest {
+    sessionId: number;
+    title: string;
+}
+interface RagRenameSessionResponse {
+    ok?: boolean;
+    title?: string;
+    error?: string;
 }
 /** Snapshot history completo (sessione + messaggi ordine cronologico). */
 interface RagChatHistorySnapshot {
@@ -14264,6 +14545,17 @@ interface RagAskRequest {
     mode?: 'auto' | 'chat' | 'retrieval';
     topK?: number;
     model?: string;
+    /** Profilo redazione dal toggle UI (strictest-of lato server). */
+    profile?: RagProfile;
+    /**
+     * Contesto della pagina dell'utente (route, tabella metadata, colonne, eventuali
+     * route correlate). Iniettato dal lato client al momento del send: permette
+     * all'LLM di generare snippet che usano i nomi REALI delle colonne (es.
+     * `record.CityName.value`) invece di placeholder generici, e di referenziare
+     * la route effettiva. Niente effetto se vuoto. Costruito da
+     * `WuicRagChatbotComponent.buildRouteContext()`.
+     */
+    routeContext?: string | null;
 }
 /** Risposta `POST /api/Rag/Ask` - ritornato SUBITO, prima del completamento. */
 interface RagAskAcceptedResponse {
@@ -14294,11 +14586,13 @@ declare class WuicRagService {
     query(query: string, options?: {
         topK?: number;
         useLora?: boolean;
+        profile?: RagProfile;
     }): Observable<RagQueryResponse>;
     /** Variant Promise di {@link query}. */
     queryAsync(query: string, options?: {
         topK?: number;
         useLora?: boolean;
+        profile?: RagProfile;
     }): Promise<RagQueryResponse>;
     /**
      * Esegue una chat completa (RAG + Claude). Se il server non ha
@@ -14312,11 +14606,13 @@ declare class WuicRagService {
     chat(query: string, history?: RagChatTurn[], options?: {
         topK?: number;
         model?: string;
+        profile?: RagProfile;
     }): Observable<RagChatResponse>;
     /** Variant Promise di {@link chat}. */
     chatAsync(query: string, history?: RagChatTurn[], options?: {
         topK?: number;
         model?: string;
+        profile?: RagProfile;
     }): Promise<RagChatResponse>;
     /**
      * Stato del server RAG (status, LLM enabled, chunks indicizzati).
@@ -14380,6 +14676,39 @@ declare class WuicRagService {
      */
     ask(req: RagAskRequest): Observable<RagAskAcceptedResponse>;
     askAsync(req: RagAskRequest): Promise<RagAskAcceptedResponse>;
+    /**
+     * Applica la proposta d'azione precedentemente emessa dall'LLM sul messaggio
+     * indicato. Server-side: re-legge la `proposed_action_json` dal DB (non dal
+     * client: prevenzione tampering del `callback_js`), valida, fa INSERT sul
+     * metadata corrispondente + `InvalidateMetadataCachesAndSetVersion`.
+     *
+     * Gating: solo `isSuperAdmin` (server torna `403 admin-required` in caso).
+     * Esiti tipici (`error`): `not-authenticated` | `admin-required` |
+     *   `message-not-found` | `no-proposed-action-on-message` | `already-applied` |
+     *   `unsupported-kind: <x>` | `apply-failed`.
+     */
+    applyProposedAction(req: RagApplyActionRequest): Observable<RagApplyActionResponse>;
+    applyProposedActionAsync(req: RagApplyActionRequest): Promise<RagApplyActionResponse>;
+    /**
+     * Sovrascrive il `proposed_action_json` di un messaggio assistant con il
+     * payload editato dall'utente in UI (campo "Classe/Stile" + textarea callback).
+     * Va chiamato PRIMA di `applyProposedActionAsync` quando l'utente modifica
+     * qualcosa, cosi' che il backend ApplyAction rilegga dal DB il payload giusto.
+     * Filtri di sicurezza nel backend: ownership user_id + non gia' applicata.
+     */
+    updateProposedAction(req: RagUpdateProposedActionRequest): Observable<RagUpdateProposedActionResponse>;
+    updateProposedActionAsync(req: RagUpdateProposedActionRequest): Promise<RagUpdateProposedActionResponse>;
+    /**
+     * Compatta la sessione: chiama il backend che a sua volta chiama il rag_server
+     * per produrre un summary della history. Persiste su `_rag_chat_sessions`
+     * + avanza `summary_up_to_message_id`. Le future call /Ask passeranno il
+     * summary nel system prompt al posto dei turn coperti.
+     */
+    compactSession(req: RagCompactRequest): Observable<RagCompactResponse>;
+    compactSessionAsync(req: RagCompactRequest): Promise<RagCompactResponse>;
+    /** Rinomina il titolo di una session (mostrato nella sessions list). */
+    renameSession(req: RagRenameSessionRequest): Observable<RagRenameSessionResponse>;
+    renameSessionAsync(req: RagRenameSessionRequest): Promise<RagRenameSessionResponse>;
     /**
      * Costruisce l'URL `<api_base>Rag/<action>` rispettando l'eventuale
      * `WtoolboxService.appSettings.api_url` configurato lato runtime (stesso
@@ -14391,6 +14720,147 @@ declare class WuicRagService {
     static ɵprov: i0.ɵɵInjectableDeclaration<WuicRagService>;
 }
 
+/**
+ * Esito ritornato da un host action handler. Il chatbot lo mostra come toast
+ * (success se ok=true, error altrimenti). `message` e' opzionale.
+ */
+interface ChatbotHostActionResult {
+    ok: boolean;
+    message?: string;
+}
+/**
+ * Signature del callback che un componente "host" (es. designer.component)
+ * registra per ricevere le proposed_action_json di kind client-only
+ * (es. 'designer_inject') invece di farle passare dal backend
+ * `/api/Rag/ApplyAction`.
+ *
+ * Il handler DEVE essere async (o ritornare una Promise) cosi' il chatbot
+ * puo' aspettare l'esito prima di marcare il turn come applicato e
+ * mostrare il toast.
+ */
+type ChatbotHostActionHandler = (action: RagProposedAction) => Promise<ChatbotHostActionResult>;
+/**
+ * Singleton (providedIn:'root') che propaga un `ChatbotHostActionHandler`
+ * dal componente host (es. designer.component) al chatbot popover globale
+ * (`<wuic-rag-chatbot-fab>`), evitando il pattern di passare un @Input()
+ * lungo la catena di componenti.
+ *
+ * Pattern d'uso (designer.component.ts):
+ *
+ *   ngOnInit() {
+ *     this.chatbotHostRegistry.register('designer_inject', this.handleDesignerInject.bind(this));
+ *   }
+ *   ngOnDestroy() {
+ *     this.chatbotHostRegistry.unregister('designer_inject');
+ *   }
+ *
+ * Lato chatbot (rag-chatbot.component.ts), in onApplyActionToTurn():
+ *
+ *   const action = turn.proposedAction;
+ *   const hostHandler = this.chatbotHostRegistry.get(action.kind);
+ *   if (hostHandler) {
+ *     // bypass backend - applica client-only
+ *     const result = await hostHandler(action);
+ *     ...
+ *   } else {
+ *     // backend apply standard
+ *     ...
+ *   }
+ *
+ * Registry per-kind: piu' kind possono avere handler distinti
+ * registrati da componenti diversi. Quando l'host viene distrutto,
+ * deve sempre fare unregister(kind) per evitare leak (es. handler
+ * che cattura una vecchia istanza componente non piu' nel DOM).
+ */
+/**
+ * Signature del callback che fornisce uno snapshot testuale (compact tree)
+ * dello state corrente dell'host, da iniettare nel `route_context` del LLM.
+ *
+ * Esempio dump del designer:
+ *   TABLE__123 (rows=2, cols=2)
+ *     TR__124
+ *       TD__125 (top-left)
+ *       TD__126 (top-right)
+ *     TR__127
+ *       TD__128 (bottom-left)
+ *       TD__129 (bottom-right)
+ *
+ * Ritornare `null` se lo state non e' rilevante per questo turn (es.
+ * canvas vuoto), cosi' il chatbot non spreca token nel system prompt.
+ */
+type ChatbotHostStateProvider = () => string | null;
+declare class ChatbotHostRegistryService {
+    private readonly handlers;
+    private readonly stateProviders;
+    /**
+     * Registra (o sostituisce) il handler per un dato `kind`. L'ultima
+     * registrazione vince - utile per scenari edge in cui due viste
+     * concorrenti gestiscono lo stesso kind (raro, ma documentato).
+     */
+    register(kind: string, handler: ChatbotHostActionHandler): void;
+    /**
+     * Rimuove il handler per un dato `kind`. No-op se non registrato.
+     * Da chiamare in ngOnDestroy dell'host per evitare retain.
+     */
+    unregister(kind: string): void;
+    /**
+     * Restituisce il handler registrato per `kind`, o `null` se nessuno
+     * lo gestisce client-side. Il chatbot usa questo per decidere se
+     * bypassare il backend o no.
+     */
+    get(kind: string): ChatbotHostActionHandler | null;
+    /**
+     * Helper diagnostico: lista tutti i kind attualmente registrati.
+     * Usato dai test e dal debug panel.
+     */
+    registeredKinds(): string[];
+    /**
+     * Registra (o sostituisce) un state provider per un dato `kind`.
+     * Il provider verra' chiamato dal chatbot in `buildRouteContext()` per
+     * arricchire il system prompt del LLM con lo state corrente dell'host
+     * (es. designer.dashboardElements serializzati come tree compatto).
+     *
+     * Esempio (designer.component):
+     *   this.chatbotHostRegistry.registerStateProvider(
+     *     'designer_inject',
+     *     () => this.buildCompactStateDump()
+     *   );
+     */
+    registerStateProvider(kind: string, provider: ChatbotHostStateProvider): void;
+    /**
+     * Rimuove il state provider. Da chiamare in ngOnDestroy.
+     */
+    unregisterStateProvider(kind: string): void;
+    /**
+     * Invoca il state provider registrato per `kind` e ritorna il dump.
+     * Se non registrato, ritorna `null`. Errori nel provider sono
+     * swallowed e logged (best-effort: il chatbot deve sempre funzionare
+     * anche se l'host crasha durante il dump).
+     */
+    getStateDump(kind: string): string | null;
+    /**
+     * Helper diagnostico: lista tutti i kind con state provider attivo.
+     */
+    registeredStateKinds(): string[];
+    /**
+     * Invoca SYNC tutti gli state provider registrati ignorandone il risultato.
+     *
+     * Scopo: dare ai provider la possibilita' di triggerare i loro fetch lazy
+     * (es. il designer prefetcha `getAvailableRoutes` solo quando lo state
+     * provider viene invocato — altrimenti spreca chiamate al mount). Chiamato
+     * dal chatbot in ngOnInit: la finestra "apertura chatbot" → "primo prompt
+     * inviato" e' di almeno 1-2 secondi (l'utente deve digitare), tempo
+     * sufficiente perche' la cache sia pronta al primo Ask. Senza warm-up,
+     * il primo prompt vedrebbe state dump 'caricamento' e il LLM
+     * potrebbe hallucinare nomi alternativi inventati.
+     *
+     * Errori dei provider vengono swallowed (lo stesso pattern di getStateDump).
+     */
+    warmUpAllStateProviders(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatbotHostRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatbotHostRegistryService>;
+}
+
 /**
  * Singolo turno della conversazione visualizzato nel chatbot.
  *
@@ -14412,6 +14882,51 @@ interface RagChatbotTurn {
     tokensOut?: number | null;
     /** GUID di correlazione (usato per match notifica completion). */
     correlationId?: string;
+    /** Proposta d'azione emessa dall'LLM via tool-use, gia' parsata da JSON.
+     *  Null = nessuna proposta (risposta solo testo). */
+    proposedAction?: RagProposedAction | null;
+    /** Timestamp ISO dell'applicazione (audit). Null = mai applicata. */
+    proposedActionAppliedAt?: string | null;
+    /** Flag UI: true mentre il bottone "Applica" e' in flight (loading). */
+    applyingAction?: boolean;
+    /** Errore ultimo apply (UI feedback). */
+    applyError?: string | null;
+    /**
+     * Lista di follow-up question parsate dal `followupQuestionsJson` del messaggio.
+     * Renderizzata come chip cliccabili sotto la risposta assistant. Null/empty =
+     * niente chip mostrate.
+     */
+    followupQuestions?: string[] | null;
+    /**
+     * Toggle textarea (default) <-> Monaco editor per il `callback_js` proposto.
+     * Pattern identico a `<lib-code-area-editor>` (vedi
+     * `field/code-area-editor/code-area-editor.component.ts`): di default mostra
+     * una `<textarea>` leggera (niente chunk Monaco scaricato, niente flash nero),
+     * con click su "Apri editor avanzato" si commuta e il `@defer (when ...)`
+     * carica `<wuic-code-editor-lazy>` on-demand.
+     */
+    editorMode?: boolean;
+    /**
+     * True quando l'utente ha editato un campo della `proposedAction` in UI
+     * (classe/stile o body del callback). Triggera la pre-flight
+     * `updateProposedActionAsync` prima di `applyProposedActionAsync` cosi' il
+     * backend rilegge dal DB il payload aggiornato (vedi commento sicurezza in
+     * RagController.ApplyAction). Resettato a false dopo il PATCH riuscito.
+     */
+    proposedActionDirty?: boolean;
+}
+/**
+ * Descrittore di un campo NON-body della proposta editabile dall'utente
+ * sopra la textarea del callback (es. classe/stile per `table_style`, label
+ * per `toolbar_action`). `fieldName` e' la chiave dentro `RagProposedAction`
+ * su cui scrivere. `isInlineStyle` (solo per `css_class`) indica che il valore
+ * UI mostra la parte dopo il prefisso `style:` — il setter ri-prepende.
+ */
+interface RagProposedActionExtraField {
+    label: string;
+    fieldName: string;
+    value: string;
+    isInlineStyle?: boolean;
 }
 /**
  * Componente standalone che espone una chat sopra il RAG del codebase WUIC.
@@ -14436,9 +14951,11 @@ interface RagChatbotTurn {
 declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     private readonly ragService;
     private readonly cdr;
+    private readonly chatbotHostRegistry;
     private readonly route?;
     private readonly router?;
     private readonly notificationRT?;
+    private readonly metaSrv?;
     /** Titolo mostrato nell'header del chatbot. */
     title: string;
     /** Modalita' operativa: vedi nota nella classDoc. */
@@ -14451,12 +14968,52 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     maxHistory: number;
     /** Placeholder dell'input. */
     placeholder: string;
-    /** Modello Claude da usare in modalita' chat (default haiku 4.5). */
+    /** Modello LLM in modalita' chat. Vuoto (default) = usa il model configurato lato
+     *  backend (`rag-llm-default-chat-model`), provider-appropriate. Non hardcodare un
+     *  model Anthropic: su provider openrouter/openai manderebbe un ID invalido (HTTP 400
+     *  -> retrieval-only). Valorizzare solo per forzare un model specifico. */
     model: string;
     /** Altezza fissa dell'area chat in CSS units (default `420px`). */
     chatHeight: string;
     /** Mostra il bottone "Svuota cronologia" nell'header. */
     showClearButton: boolean;
+    /**
+     * Persiste l'id della sessione corrente in `localStorage` e lo ripristina al
+     * boot del componente (es. refresh della pagina) quando NON arriva un
+     * `?sessionId` dalla route. La cronologia completa viene poi ricaricata dal DB
+     * via `/api/Rag/History` (che ritorna TUTTI i messaggi della sessione, non un
+     * sottoinsieme) -> il refresh non svuota piu' la chat. Default true.
+     */
+    persistSession: boolean;
+    /**
+     * Se `true` (default), prima di ogni `Ask` il componente costruisce un
+     * **route context** sintetico (route corrente + tabella metadata + colonne)
+     * dal `MetadataProviderService` e lo invia al rag_server come `routeContext`
+     * nel payload. Il server lo inietta nel system prompt dell'LLM cosi' che le
+     * risposte usino i NOMI REALI delle colonne della pagina corrente invece di
+     * placeholder generici.
+     *
+     * Disabilitare a `false` per la route full-page `/rag-chatbot` (il chatbot
+     * stesso non e' una "business route" — niente context utile da iniettare) o
+     * per UI di privacy avanzata.
+     */
+    sendRouteContext: boolean;
+    /** Chiave `localStorage` dell'ultima sessione (scoped per browser). */
+    private static readonly LAST_SESSION_KEY;
+    /**
+     * Mostra il toggle "Vista Dev / Vista Cliente" nell'header (default OFF).
+     * Da abilitare SOLO nelle pagine dev/demo: la chat spedita al cliente NON
+     * deve esporlo. E' comunque leak-safe (il server applica strictest-of: il
+     * toggle puo' solo aumentare la redazione, mai diminuirla).
+     */
+    allowProfileToggle: boolean;
+    /**
+     * Profilo di redazione corrente scelto dal toggle UI.
+     * - 'internal' = Vista Dev (full source);
+     * - 'release'  = Vista Cliente (firme + niente skill, come on-prem).
+     * Inviato al server solo se {@link allowProfileToggle} e' true.
+     */
+    profileOverride: RagProfile;
     /** Emette quando l'utente clicca su un source chip. */
     resultSelected: EventEmitter<RagSource>;
     /** Emette in caso di errore HTTP non recuperabile. */
@@ -14488,6 +15045,35 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     private processedNotificationIds;
     /** Sub a notificationRT.notifications$ + ActivatedRoute.queryParams. */
     private subs;
+    /**
+     * Context window usage del modello corrente (ultima stima dal backend, 0-100%).
+     * Aggiornato a ogni completion. Driver del cerchio colorato in header:
+     * verde <60% / giallo 60-80% / arancione 80-90% / rosso >90%.
+     */
+    contextUsagePercent: number;
+    /** Token usati (dall'ultima call) / context window max. Mostrati in tooltip. */
+    contextUsedTokens: number | null;
+    contextWindowMax: number | null;
+    /** True quando il dialog "context-overflow" e' aperto: l'ultima call ha
+     *  fallito perche' la history sfora il context. UX: 2 bottoni (Compatta / Nuova). */
+    contextOverflowDialogOpen: boolean;
+    /** True mentre il /compact e' in-flight (loading nel bottone). */
+    compactingSession: boolean;
+    /**
+     * True per tutto il flow `onClearHistory`: apertura prompt di conferma
+     * (PrimeNG Dialog lazy-load, ~300-800ms al primo click) + DELETE backend +
+     * reset stato locale. Driver dello spinner sul bottone cestino in header.
+     * Re-entry guard: blocca click multipli mentre il flow e' in corso.
+     */
+    clearingHistory: boolean;
+    /** True quando il dialog "Sessioni" e' aperto. Lazy-load lista al toggle. */
+    sessionsDialogOpen: boolean;
+    sessionsList: RagChatSessionDto[];
+    sessionsLoading: boolean;
+    /** Map sessionId -> bool: true se quella riga e' in modalita' rinomina. */
+    sessionRenameEditing: Record<number, boolean>;
+    /** Map sessionId -> string: valore temporaneo del titolo durante l'edit inline. */
+    sessionRenameDraft: Record<number, string>;
     /**
      * Source selezionato per il dialog preview. Null = dialog chiuso.
      * Il dialog mostra SOLO lo snippet embedded in RagSource (max 500 char dal
@@ -14497,7 +15083,7 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     selectedSource: RagSource | null;
     inputTextarea?: ElementRef<HTMLTextAreaElement>;
     scrollContainer?: ElementRef<HTMLElement>;
-    constructor(ragService: WuicRagService, cdr: ChangeDetectorRef, route?: ActivatedRoute, router?: Router, notificationRT?: NotificationRealtimeService);
+    constructor(ragService: WuicRagService, cdr: ChangeDetectorRef, chatbotHostRegistry: ChatbotHostRegistryService, route?: ActivatedRoute, router?: Router, notificationRT?: NotificationRealtimeService, metaSrv?: MetadataProviderService);
     ngOnInit(): void;
     ngOnDestroy(): void;
     get effectiveMode(): 'rag-llm' | 'retrieval-only';
@@ -14505,6 +15091,14 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     get modeBadgeSeverity(): 'success' | 'info' | 'warn' | 'danger';
     /** Disabilita il send button SOLO durante la chiamata Ask (~200ms), NON durante il pending. */
     get sendDisabled(): boolean;
+    /** Label del toggle profilo. */
+    get profileToggleLabel(): string;
+    /**
+     * Flippa il profilo di redazione (Dev <-> Cliente). Le risposte gia' in
+     * cronologia restano com'erano (il profilo e' per-richiesta); i prossimi
+     * invii usano il nuovo profilo.
+     */
+    toggleProfile(): void;
     /**
      * Invia il prompt corrente via flow async:
      * 1. Append turno user (placeholder, sara' ricevuto messageId nell'ack);
@@ -14517,6 +15111,13 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     /**
      * Svuota la cronologia chat (soft-delete della sessione corrente sul DB) +
      * reset stato locale.
+     *
+     * Il flag `clearingHistory` resta `true` per tutto il flow (dall'apertura
+     * del dialog di conferma fino al completamento DELETE+reset). Driver dello
+     * spinner sul bottone cestino in header — necessario perche' il PRIMO click
+     * subisce ~300-800ms di lazy-load del bundle PrimeNG Dialog
+     * (`promptDialog` apre un `p-dialog` dinamico, non gia' istanziato). Senza
+     * feedback l'utente cliccava 2-3 volte pensando che non rispondesse.
      */
     onClearHistory(): Promise<void>;
     /**
@@ -14630,12 +15231,219 @@ declare class WuicRagChatbotComponent implements OnInit, OnDestroy {
     private dtoToTurn;
     private applyMessageToTurn;
     private scrollToMessage;
+    /**
+     * Persiste (o cancella se id null) l'ultima sessione in localStorage.
+     * Best-effort: guard SSR + try/catch (private-mode / quota / storage disabled).
+     */
+    private saveLastSession;
+    /** Legge l'ultima sessione salvata (>0) o null. */
+    private readLastSession;
+    /** Parse JSON del field `proposed_action_json` -> oggetto tipato (o null). */
+    private parseProposedAction;
+    /** Parse JSON del field `followup_questions_json` -> array di stringhe (o null). */
+    private parseFollowupQuestions;
+    /**
+     * Click su un chip follow-up: popola l'input box con la domanda (NON invia
+     * automaticamente; l'utente puo' editare prima di premere invio). Coerente
+     * con la scelta UX di non lanciare query "per sbaglio".
+     */
+    applyFollowup(question: string): void;
+    /** Aggiorna lo stato del cerchio cue dato (usedTokens, windowMax). */
+    private updateContextCue;
+    /** Colore del cerchio basato sul `contextUsagePercent`. */
+    get contextCueColor(): string;
+    get contextCueTooltip(): string;
+    /**
+     * Click sul cerchio context cue: conferma + lancia /compact. Disponibile sempre
+     * (anche <60%): l'utente puo' compattare on-demand.
+     */
+    onContextCueClick(): Promise<void>;
+    /**
+     * Chiama l'endpoint /api/Rag/Compact. Aggiorna lo stato dopo successo.
+     * Riusato da: contextCue click, slash-command /compact, dialog overflow "Compatta ora".
+     */
+    doCompactSession(): Promise<void>;
+    /**
+     * Nuova sessione: chiude la corrente (clear localStorage), resetta history, ricomincia.
+     * Chiamato dal bottone "Nuova sessione" del dialog overflow.
+     */
+    startNewSession(): void;
+    openSessionsDialog(): Promise<void>;
+    closeSessionsDialog(): void;
+    /** Switch alla session selezionata (carica history). */
+    selectSession(s: RagChatSessionDto): Promise<void>;
+    /** Apre l'edit inline del titolo. */
+    startRenameSession(s: RagChatSessionDto, event?: Event): void;
+    confirmRenameSession(s: RagChatSessionDto, event?: Event): Promise<void>;
+    cancelRenameSession(s: RagChatSessionDto): void;
+    /**
+     * Cancella una sessione dalla cronologia (chiamato dall'icona cestino
+     * sulla riga della lista sessioni). Confirm via WtoolboxService.promptDialog
+     * (regola 12 AGENTS: mai window.confirm). Backend soft-delete via
+     * POST /api/Rag/DeleteSession (gia' esistente).
+     *
+     * Se la sessione cancellata e' quella CORRENTE: clear della view (history
+     * + currentSessionId reset) e remove da localStorage. Se non corrente:
+     * solo splice dalla lista locale senza toccare la chat aperta.
+     *
+     * Best-effort: errori backend swallowed (la lista si refresha al prossimo
+     * open del dialog comunque, e l'utente puo' riprovare).
+     */
+    onDeleteSessionFromList(s: RagChatSessionDto, event?: Event): Promise<void>;
+    /** Truncate del primo prompt a 100 char per anteprima list (full su tooltip). */
+    sessionPreview(s: RagChatSessionDto): string;
+    /** Formato data sessione (locale). */
+    sessionDate(s: RagChatSessionDto): string;
+    /** Label umana per il bottone/header in base al `kind`. */
+    proposedActionTitle(a: RagProposedAction | null | undefined): string;
+    /**
+     * Estrae il body del code/template della proposta indipendentemente dal kind:
+     *   - toolbar_action / row_action / default_value / custom_validation /
+     *     selection_changed / lifecycle / form_title       → `callback_js` / `formula_js`
+     *   - table_style / column_style                        → `condition_js`
+     *   - display_formula                                   → `template_html` (Angular markup)
+     *                                                         o `formula_js` (legacy backward-compat)
+     *   - sql_metadata_field                                → `sql_snippet` (SQL fragment)
+     * Ritorna stringa vuota se nessun campo body e' presente.
+     */
+    proposedActionJsBody(a: RagProposedAction | null | undefined): string;
+    /**
+     * Campi NON-body della proposta che e' utile mostrare all'utente accanto
+     * al codice (es. per `table_style` la classe CSS o l'inline-style che verra'
+     * applicato alla `<tr>` quando il callback ritorna true; per `toolbar_action`
+     * la label del bottone; per `sql_metadata_field` il field target). Per ogni
+     * kind ritorna 0..N coppie `{label, value}`. Il template li renderizza in
+     * lettura sopra la textarea del body. Mantenere allineato alla definizione
+     * tool in `rag_tools.json`: quando si aggiunge un campo importante a un kind
+     * (es. `inline_style` su `propose_table_style`), aggiungerlo anche qui per
+     * non far perdere visibilita' all'utente sulla decisione del LLM.
+     */
+    proposedActionExtraFields(a: RagProposedAction | null | undefined): Array<RagProposedActionExtraField>;
+    /**
+     * Nome del campo nella `RagProposedAction` che porta il body editabile della
+     * textarea (callback / template / sql snippet). Speculare a
+     * `proposedActionJsBody` ma ritorna l'identificatore del field, cosi' il
+     * `(ngModelChange)` puo' scrivere su `a[name]`. Default `callback_js` per i
+     * kind che non hanno un body editabile (no-op all'edit).
+     */
+    proposedActionJsBodyFieldName(a: RagProposedAction | null | undefined): string;
+    /**
+     * Setter chiamato da `(ngModelChange)` su un campo extra (es. classe/stile).
+     * Per `css_class` con `isInlineStyle=true` ri-prepende il prefisso `style:`
+     * cosi' la convenzione persistita resta omogenea (vedi
+     * `dynamic-template.component.ts:getTableInlineStyle`). Segna il turno come
+     * `proposedActionDirty=true` cosi' `onApplyAction` chiama il PATCH backend
+     * prima dell'Apply.
+     */
+    onProposedExtraFieldEdit(turn: RagChatbotTurn, extra: RagProposedActionExtraField, newValue: string): void;
+    /**
+     * Setter per la textarea del body (callback_js / condition_js / template_html
+     * / formula_js / sql_snippet). Aggiorna il field corretto in base al kind.
+     */
+    onProposedBodyEdit(turn: RagChatbotTurn, newValue: string): void;
+    /**
+     * Stessa `codeContext` che il metadata-editor usa per editare il callback
+     * sullo stesso campo metadata. Permette al Monaco TS provider di applicare
+     * autocomplete + type-check come se l'utente stesse editando in metadata-editor.
+     * Centralizzato qui per kind: future aggiunte = entry nella map.
+     */
+    proposedActionCodeContext(a: RagProposedAction | null | undefined): string;
+    /**
+     * Cache field+record sintetici per `<wuic-code-editor>` indicizzata per messageId.
+     * MOTIVATION: il code-editor accetta `field: MetadatiColonna` e
+     * `record: { [k]: BehaviorSubject<any> }`; ricostruirli ad ogni ciclo di CD
+     * causerebbe re-init pesanti del Monaco (riload types, ecc). Cache stabile per
+     * messageId -> stesse referenze -> niente re-init.
+     */
+    private proposedActionEditorCache;
+    /**
+     * Costruisce (o riusa cached) il `MetadatiColonna` sintetico da passare al
+     * `<wuic-code-editor>` per il box proposta. Inietta il `codeContext` corretto
+     * per il `kind` cosi' il TSProvider Monaco applica autocomplete come nel
+     * metadata-editor stesso. L'editor e' EDITABILE (readOnly:false): le modifiche
+     * vengono propagate a `turn.proposedAction[bodyFieldName]` tramite subscription
+     * al BehaviorSubject del record, e segnano il turno come dirty cosi'
+     * `onApplyAction` chiama il PATCH backend prima dell'Apply.
+     */
+    getProposedActionField(turn: RagChatbotTurn): MetadatiColonna;
+    /** Compagno di `getProposedActionField`: ritorna lo stesso `record` cached. */
+    getProposedActionRecord(turn: RagChatbotTurn): {
+        [key: string]: BehaviorSubject<any>;
+    };
+    /**
+     * Toggle textarea (default) <-> Monaco editor avanzato per il callback proposto.
+     * Pattern `<lib-code-area-editor>`: textarea istantanea, Monaco on-demand via
+     * `@defer (when turn.editorMode)`. Entrando in Monaco ri-sincronizza il
+     * BehaviorSubject del record cached col valore corrente di `proposedAction`
+     * (potrebbe essere stato editato dalla textarea nel frattempo, vedi
+     * `onProposedBodyEdit`).
+     */
+    toggleEditorMode(turn: RagChatbotTurn): void;
+    /** True se il turn ha una proposta non ancora applicata (mostra "Applica"). */
+    canApplyAction(turn: RagChatbotTurn): boolean;
+    /**
+     * Bottone "Applica": chiama POST /api/Rag/ApplyAction con conferma. Il server
+     * re-legge la proposta dal DB (anti-tampering del callback_js), checka admin,
+     * INSERT su metadata, InvalidateMetadataCachesAndSetVersion. La proposta viene
+     * marcata come applicata in DB.
+     */
+    onApplyAction(turn: RagChatbotTurn): Promise<void>;
     private trimHistory;
+    /**
+     * Costruisce un riepilogo testuale della pagina/route corrente che viene
+     * iniettato nel system prompt dell'LLM. Permette di generare snippet che
+     * usano i nomi REALI delle colonne (es. `record.CityName.value`) invece di
+     * placeholder generici.
+     *
+     * Formato (compatto, leggibile dall'LLM):
+     * ```
+     * Route corrente: cities
+     * Tabella: Cities (md_id=42, mdtablename=Cities)
+     * Colonne:
+     *   - CityName: type=text, required=yes (real column: CityName)
+     *   - StateProvince: type=lookupByID -> StateProvinces
+     *   - Location: type=text
+     *   - LatestRecordedPopulation: type=number
+     *   - btn_send: type=button (row action)
+     * ```
+     *
+     * Ritorna `null` se: router assente, route non resolvibile, route NON e'
+     * una business route (framework-docs/rag-chatbot/auth), o metadata
+     * non disponibile in cache (l'utente probabilmente non e' su una list/edit
+     * della route).
+     */
+    private buildRouteContext;
+    /**
+     * Contesto MINIMALE della pagina: SOLO la route/pagina corrente (es. `cities/list`,
+     * `cities/edit`, `designer`). I dettagli di metadata (elenco colonne reali, identita'
+     * SQL schema/tabella, alias di join dei lookup) NON sono inlineati: il LLM li recupera
+     * ON-DEMAND via il tool `request_metadata_detail` (detail='columns'|'lookup_columns'),
+     * risolto lato backend da `RagController.ResolveMetadataDetail`.
+     *
+     * RAZIONALE: inlinare colonne + SQL identity gonfiava OGNI richiesta a prescindere dal
+     * prompt (context window saturato, token sprecati). Col retrieval agentico il model
+     * recupera SOLO cio' che il prompt richiede, e il meccanismo scala a N dimensioni di
+     * metadata (physical_columns, related_routes, enum_values, ...) senza toccare questo
+     * builder. Vale per qualunque pagina, incluse quelle framework (designer, ...): il
+     * model puo' comunque targetizzare una route business via retrieval.
+     */
+    private buildMinimalPageContext;
+    /**
+     * Concatena lo state dump fornito dai componenti host che hanno registrato
+     * un state provider per un proposed_action kind. Tipicamente designer.component
+     * registra `designer_inject` con un tree dei dashboardElements (uniqueName +
+     * inputs significativi), cosi' il LLM puo' identificare componenti via
+     * uniqueName quando l'utente chiede modifiche tipo "cambia background
+     * del riquadro in alto a destra".
+     *
+     * Ritorna `null` se nessun host ha registrato dump per il turn corrente.
+     */
+    private buildHostStateContext;
     private scheduleScrollToBottom;
     private focusInput;
     private extractErrorMessage;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WuicRagChatbotComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WuicRagChatbotComponent, "wuic-rag-chatbot", never, { "title": { "alias": "title"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "topK": { "alias": "topK"; "required": false; }; "showSources": { "alias": "showSources"; "required": false; }; "maxHistory": { "alias": "maxHistory"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "model": { "alias": "model"; "required": false; }; "chatHeight": { "alias": "chatHeight"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; }, { "resultSelected": "resultSelected"; "errorOccurred": "errorOccurred"; "turnAdded": "turnAdded"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WuicRagChatbotComponent, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WuicRagChatbotComponent, "wuic-rag-chatbot", never, { "title": { "alias": "title"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "topK": { "alias": "topK"; "required": false; }; "showSources": { "alias": "showSources"; "required": false; }; "maxHistory": { "alias": "maxHistory"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "model": { "alias": "model"; "required": false; }; "chatHeight": { "alias": "chatHeight"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "persistSession": { "alias": "persistSession"; "required": false; }; "sendRouteContext": { "alias": "sendRouteContext"; "required": false; }; "allowProfileToggle": { "alias": "allowProfileToggle"; "required": false; }; }, { "resultSelected": "resultSelected"; "errorOccurred": "errorOccurred"; "turnAdded": "turnAdded"; }, never, never, true, never>;
 }
 
 /**
@@ -14667,6 +15475,7 @@ declare class WuicRagChatbotFabComponent implements OnInit, OnDestroy {
     private readonly licenseService;
     private readonly notificationRT;
     private readonly cdr;
+    private readonly router;
     /** Tooltip dell'icona FAB. */
     fabTooltip: string;
     /** Titolo del dialog (passato anche al chatbot interno). */
@@ -14702,9 +15511,18 @@ declare class WuicRagChatbotFabComponent implements OnInit, OnDestroy {
     licenseAllowed: boolean;
     /** Counter unread per il badge sul FAB. */
     unreadRagCount: number;
+    /**
+     * True quando la route corrente e' `/rag-chatbot` (o un suo sub-path).
+     * Nascondiamo il FAB in quel caso perche' renderebbe un launcher duplicato
+     * sopra il chatbot gia' aperto a tutta pagina. Aggiornato reattivamente
+     * ai `NavigationEnd` del Router, e inizializzato dal `router.url` corrente
+     * cosi' il primo render (es. F5 mentre sei gia' sulla route) e' coerente.
+     */
+    private onRagChatbotRoute;
     private subs;
-    constructor(licenseService: LicenseFeatureService, notificationRT: NotificationRealtimeService, cdr: ChangeDetectorRef);
+    constructor(licenseService: LicenseFeatureService, notificationRT: NotificationRealtimeService, cdr: ChangeDetectorRef, router: Router);
     ngOnInit(): void;
+    private updateOnRagChatbotRoute;
     ngOnDestroy(): void;
     get visible(): boolean;
     /**
@@ -15036,4 +15854,4 @@ declare function getThemeOptions(): ThemeOption[];
 declare function getThemePrimaryHex(value: string): string;
 
 export { AUTH_REDIRECT_REASON_KEY, AppSettingsEditorComponent, AuthSessionService, BooleanEditorComponent, BoundedRepeaterComponent, ButtonEditorComponent, CallbackPipe, CallbackPipe2, CarouselListComponent, CodeAreaEditorComponent, ColorEditorComponent, CrashReporterService, CustomAttributesService, CustomException, DataActionButtonComponent, DataProviderOdataService, DataRepeaterComponent, DataSourceComponent, DateEditorComponent, DesignerRouteComponent, DictionaryEditorComponent, DynamicCompilerService, DynamicRowTemplateComponent, FieldEditorComponent, FilterBarComponent, FilterInfo, FormatGridViewValuePipe, GetSrcUploadPreviewPipe, GlobalHandler, HtmlEditorComponent, ImageWrapperComponent, ImportExportButtonComponent, IsSelectedRowPipe, KanbanListComponent, KanbanOptions, KanbanStatusColumnItem, LazyChartListComponent, LazyCodeEditorComponent, LazyDataActionButtonComponent, LazyDataSourceComponent, LazyFieldEditorComponent, LazyFirstRunWizardComponent, LazyImageWrapperComponent, LazyKanbanListComponent, LazyMetaMenuComponent, LazyPivotBuilderComponent, LazyReportDesignerComponent, LazyReportViewerComponent, LazySchedulerListComponent, LazySpreadsheetListSfComponent, LicenseFeatureService, ListGridComponent, LookupEditorComponent, MapListComponent, MetaInfo, MetaMenuComponent, MetadataEditorService, MetadataProviderService, MetadatiColonna, MetadatiTabella, NotificationBellComponent, NotificationRealtimeService, NumberEditorComponent, PRIMARY_PALETTES, PagerComponent, ParametricDialogComponent, PropertyArrayEditorComponent, PropertyObjectEditorComponent, THEME_OPTIONS, TextAreaEditorComponent, TextEditorComponent, TranslationManagerService, TreeListComponent, TreeViewSelectorComponent, UploadDialogComponent, UploadEditorComponent, UserInfoService, ValidationRule, ValueChangedPayload, VisibleFieldListPipe, WidgetDefinition, WorkflowDesignerRouteComponent, WorkflowRunnerComponent, WorkflowRuntimeMetadataService, WtoolboxService, WuicAziendaSwitcherComponent, WuicErrorDialogComponent, WuicErrorInterceptor, WuicFeatureDirective, WuicFrozenColumnDirective, WuicRagChatbotComponent, WuicRagChatbotFabComponent, WuicRagService, WuicRowTogglerDirective, _PRIMENG_TABLE_DIRECTIVES_NAMES, authExpiredInterceptor, boundedRepeaterPendingChangesGuard, featureRouteCanActivateGuard, featureRouteCanMatchGuard, getThemeOptions, getThemePrimaryHex, inferTemplateFieldFromBaseClass, loadBooleanEditorComponent, loadButtonEditorComponent, loadCodeAreaEditorComponent, loadColorEditorComponent, loadDateEditorComponent, loadDictionaryEditorComponent, loadHtmlEditorComponent, loadLookupEditorComponent, loadNumberEditorComponent, loadPropertyArrayEditorComponent, loadPropertyObjectEditorComponent, loadTextAreaEditorComponent, loadTextEditorComponent, loadTreeViewSelectorComponent, loadUploadEditorComponent, menuRouteAccessCanActivateGuard, menuRouteAccessCanMatchGuard, routes, wuicErrorInterceptor };
-export type { AuthSessionState, Breadcrumb, CompileDynamicComponentOptions, CrashReportPayload, CrashReportingConfig, CustomAttributeDefinition, CustomAttributeResolved, CustomLookupOption, CustomValue, CvUpsertItem, DataSourceAfterSyncEvent, DataSourceBeforeSyncEvent, DataSourceSyncOperation, ErrorDelegate, ErrorDelegateContext, IDataBoundHostComponent, IFieldEditor, KanbanStatusColumn, LicenseStatusResponse, ListGridAfterRenderEvent, ListGridAfterRowRenderEvent, ListGridBeforeRowRenderEvent, MultiDatasourceMeta, NotificationItem, NotifyOptions, RagAskAcceptedResponse, RagAskRequest, RagChatHistorySnapshot, RagChatMessageDto, RagChatMessageStatus, RagChatRequest, RagChatResponse, RagChatSessionDto, RagChatTurn, RagChatbotTurn, RagHealthResponse, RagQueryRequest, RagQueryResponse, RagSource, RealtimeProgressEvent, ThemeOption, ThemePresetName, ThemePrimaryName, WorkflowRuntimeLinkedActionRouteMetadataEntry, WorkflowRuntimePreviousRouteNodeEntry, WorkflowRuntimeRouteMetadataEntry, WorkflowRuntimeRouteNodePayloadEntry };
+export type { AuthSessionState, Breadcrumb, CompileDynamicComponentOptions, CrashReportPayload, CrashReportingConfig, CustomAttributeDefinition, CustomAttributeResolved, CustomLookupOption, CustomValue, CvUpsertItem, DataSourceAfterSyncEvent, DataSourceBeforeSyncEvent, DataSourceSyncOperation, ErrorDelegate, ErrorDelegateContext, IDataBoundHostComponent, IFieldEditor, KanbanStatusColumn, LicenseStatusResponse, ListGridAfterRenderEvent, ListGridAfterRowRenderEvent, ListGridBeforeRowRenderEvent, MultiDatasourceMeta, NotificationItem, NotifyOptions, RagApplyActionRequest, RagApplyActionResponse, RagAskAcceptedResponse, RagAskRequest, RagChatHistorySnapshot, RagChatMessageDto, RagChatMessageStatus, RagChatRequest, RagChatResponse, RagChatSessionDto, RagChatTurn, RagChatbotTurn, RagCompactRequest, RagCompactResponse, RagHealthResponse, RagProfile, RagProposedAction, RagProposedActionExtraField, RagProposedActionKind, RagQueryRequest, RagQueryResponse, RagRenameSessionRequest, RagRenameSessionResponse, RagSource, RagUpdateProposedActionRequest, RagUpdateProposedActionResponse, RealtimeProgressEvent, ThemeOption, ThemePresetName, ThemePrimaryName, WorkflowRuntimeLinkedActionRouteMetadataEntry, WorkflowRuntimePreviousRouteNodeEntry, WorkflowRuntimeRouteMetadataEntry, WorkflowRuntimeRouteNodePayloadEntry };