@trismegisto/spine 2.1.1 → 3.0.0

package/types/trismegisto-spine-layout.d.ts

@@ -1,15 +1,15 @@
 import * as _angular_core from '@angular/core';
 import { OnDestroy, OnInit, ElementRef, InjectionToken, Type, Provider } from '@angular/core';
 import { Router } from '@angular/router';
-import * as _orfeu_angular_core from '@orfeu/angular/core';
-import { AuthorizationService, ViewService, UserProfile, AppDef, RealmAppsService } from '@orfeu/angular/core';
 import * as _trismegisto_spine from '@trismegisto/spine';
-import { SpineConfig, SpineNewsSlide, Route, ThemeService, ThemePresetService, DensityService, SpinePreferencesService } from '@trismegisto/spine';
+import { SpineConfig, SpineNewsSlide, Route, ThemeService, ThemePresetService, DensityService, SpineHourCyclePreference, SpineStartPagePreference, SpineNoticeType, SpinePreferencesService, SpineMcpServer, SpineFeatures } from '@trismegisto/spine';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import * as _trismegisto_angular from '@trismegisto/angular';
-import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, SidebarNode, HermesSidebarService, SegmentedOption, HermesThemeMode, HermesDensity, ComboboxOption } from '@trismegisto/angular';
+import { HermesShortcutItem, WorkspaceStore, TabItem, MenuItem, SidebarNode, HermesThemeMode, HermesDensity, HermesSidebarService, SegmentedOption, ComboboxOption } from '@trismegisto/angular';
 import * as _trismegisto_primitives from '@trismegisto/primitives';
-import { formatMessage, HermesFont } from '@trismegisto/primitives';
+import { formatMessage, HermesMotionPreference, Weekday, AlertVariant, HermesFont } from '@trismegisto/primitives';
+import * as _orfeu_angular_core from '@orfeu/angular/core';
+import { AuthorizationService, ViewService, UserProfile, AppDef, RealmAppsService } from '@orfeu/angular/core';
 import * as _trismegisto_tokens from '@trismegisto/tokens';
 import * as _trismegisto_spine_layout from '@trismegisto/spine/layout';
 import { RouteDocument } from '@trismegisto/spine/routing';
@@ -269,7 +269,8 @@ declare class SpineWorkspaceNavService {
  * (`hm-sidebar` fixa + `.main` com `hm-workspace`). **Sem barra de breadcrumb própria** — isso
  * era resíduo do spine antigo (`spine-navigation`), removido: o docs não tem uma, a navegação
  * inteira mora na sidebar. Entre o header e o corpo fica o `spine-connection-banner` (aviso de conexão
- * do `@orfeu/angular`, vazio quando `online`).
+ * do `@orfeu/angular`, vazio quando `online`). Os avisos ficam no `spine-notification` (`NotificationService`) e
+ * no `hm-toast-stack` (`HermesToastService`), os dois montados aqui: o app não monta nenhum.
  *
  * O `<router-outlet>` que sobra aqui é só pra `/no-permission` (a única rota do shell com
  * `component` de verdade — o resto da árvore do backend nunca passa pelo `Router` pra renderizar,
@@ -281,7 +282,6 @@ declare class SpineWorkspaceNavService {
 declare class LayoutComponent implements OnInit {
     private router;
     private theme;
-    private auth;
     private shortcuts;
     private onboarding;
     private news;
@@ -289,7 +289,12 @@ declare class LayoutComponent implements OnInit {
     private readonly preferences;
     protected readonly workspace: SpineWorkspaceNavService;
     private readonly settings;
-    private readonly userStorage;
+    /** Também liga, uma vez, o aviso de falha do logout (`logoutFailed$` do `@orfeu/angular`). */
+    private readonly logoutService;
+    /** Recursos opcionais (`SpineConfig.features`): cada serviço não faz nada com o seu recurso desligado. */
+    private readonly idle;
+    private readonly startPage;
+    private readonly accountPreferences;
     /** Esconde sidebar e área de trabalho quando a rota ATIVA (do Router real, ver
      *  `router.events` abaixo) é a de sem-permissão — nesse caso não existe menu/página válido
      *  como contexto. Note que isto reflete só a URL do painel FOCADO (dona do Router real); um
@@ -297,7 +302,7 @@ declare class LayoutComponent implements OnInit {
      *  o bastante (sem-permissão normalmente bloqueia o app inteiro, não uma aba) pra não justificar
      *  mais complexidade agora. */
     isNoPermission: boolean;
-    constructor(router: Router, theme: ThemeService, auth: AuthorizationService, shortcuts: ShortcutService, onboarding: OnboardingService, news: SpineNewsService);
+    constructor(router: Router, theme: ThemeService, shortcuts: ShortcutService, onboarding: OnboardingService, news: SpineNewsService);
     private matchesNoPermission;
     ngOnInit(): void;
     protected onLocalNavigate(panelId: string, href: string): void;
@@ -358,6 +363,7 @@ declare class HeaderComponent implements OnInit {
     private readonly settings;
     private readonly news;
     private readonly userStorage;
+    private readonly logoutService;
     /** Por usuário (`SpineUserStorage`): `<clientId>_header_recent_searches_<sub>`; apagada no logout. */
     private get recentSearchKey();
     constructor(authService: AuthorizationService, themeService: ThemeService, themePresetService: ThemePresetService, densityService: DensityService, viewService: ViewService, router: Router, onboarding: OnboardingService, shortcuts: ShortcutService, config: SpineConfig | null);
@@ -373,7 +379,8 @@ declare class HeaderComponent implements OnInit {
     get badges(): _orfeu_angular_core.Badge[];
     get profile(): UserProfile;
     switchBadge(badgeTypeId: string): Promise<void>;
-    logout(): void;
+    /** Sai pelo `SpineLogoutService`: com falha no Argos a pessoa fica aqui, com aviso, e o histórico fica. */
+    logout(): Promise<boolean>;
     /** Reabre o tour guiado de onboarding. */
     startTour(): void;
     /** Abre o painel de atalhos de teclado. */
@@ -578,6 +585,7 @@ declare class SpineConnectionBannerComponent {
         signInAgain: string;
         callbackFailedHeading: string;
         callbackFailedText: string;
+        logoutFailed: string;
     };
     private readonly auth;
     private readonly router;
@@ -590,6 +598,42 @@ declare class SpineConnectionBannerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineConnectionBannerComponent, "spine-connection-banner", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Saída da sessão pelo shell: todo botão/atalho de sair do spine passa por aqui (menu do perfil, painel de
+ * configurações, `Mod+Shift+L`, tela `/blocked`).
+ *
+ * - Assina `logoutFailed$` do `@orfeu/angular` (1.3.x) uma vez só: quando o logout no Argos falha (a lib repete uma
+ *   vez e mantém a sessão), mostra o aviso de erro `session.logoutFailed` (`hm-alert` de erro, `role="alert"`). Vale
+ *   também para um `logout()` chamado direto pelo app.
+ * - `logout()` aguarda o resultado: só apaga os históricos do usuário (`SpineUserStorage.clearHistory()`) quando a
+ *   saída deu certo. Com falha, nada muda: a pessoa continua na tela, com a sessão e os recentes.
+ * - `pending` fica `true` enquanto a saída está em andamento e sempre volta a `false` (os botões não travam).
+ *
+ * Com `@orfeu/angular` 1.0.x (sem `logoutFailed$`, `logout()` sem retorno) a saída conta como concluída, como antes.
+ */
+declare class SpineLogoutService {
+    private readonly auth;
+    private readonly userStorage;
+    private readonly notifications;
+    private readonly messages;
+    /** `true` quando a lib avisa a falha por `logoutFailed$` (então o aviso sai por lá, uma vez). */
+    private readonly failureStream;
+    private inFlight;
+    /** Saída em andamento (o botão mostra "saindo…" / fica desabilitado). */
+    readonly pending: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Sai da sessão. Resolve `true` quando saiu (o `@orfeu/angular` já navega para o `/logoff`) e `false` quando o
+     * Argos não confirmou: a sessão continua e o aviso de erro aparece. Nunca rejeita. Cliques repetidos durante a
+     * saída reaproveitam a mesma tentativa.
+     */
+    logout(): Promise<boolean>;
+    private run;
+    private notifyFailure;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineLogoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineLogoutService>;
+}
+
 interface Box {
     top: number;
     left: number;
@@ -727,12 +771,30 @@ declare class ShortcutsCheatsheetComponent implements OnInit, OnDestroy {
 /** Seções que o próprio spine já traz. `key` é também o valor de `?settings=` na URL. */
 declare const SPINE_SETTINGS_KEYS: {
     readonly appearance: "aparencia";
+    /** Tamanho do texto e animações. */
+    readonly accessibility: "acessibilidade";
     readonly region: "regiao";
     readonly shortcuts: "atalhos";
+    /** Novidades e tour guiado. */
+    readonly help: "ajuda";
+    /** Tipos de aviso do app e aviso do navegador (`SpineFeatures.notices`). */
+    readonly notices: "notificacoes";
+    /** Listas guardadas neste navegador (recentes, buscas, favoritos) e restaurar preferências. */
+    readonly data: "dados";
     readonly account: "conta";
+    /** Verificação em duas etapas e códigos de recuperação (API da conta do Argos). */
+    readonly mfa: "mfa";
+    /** Sessão atual, token de acesso, tokens de aplicação e sessões e dispositivos. */
+    readonly sessions: "sessoes";
+    /** @deprecated A seção "Conta e segurança" virou "MFA" e "Sessões": `seguranca` abre a de MFA (ver
+     *  `SPINE_SETTINGS_ALIASES`). Use `mfa` ou `sessions`. */
     readonly security: "seguranca";
     readonly about: "sobre";
 };
+/** Chaves antigas de `?settings=` que continuam abrindo a seção que as substituiu (links já publicados). */
+declare const SPINE_SETTINGS_ALIASES: Readonly<Record<string, string>>;
+/** Chave de seção que vale hoje: troca uma chave antiga pela nova; as demais passam iguais. */
+declare function resolveSettingsSection(section: string): string;
 /** Seção extra do painel, registrada pelo app (ex.: preferências de deploy do hefesto). */
 interface SpineSettingsSection {
     /** Identificador estável; também o que `?settings=<key>` abre. Não repetir os do spine. */
@@ -755,6 +817,7 @@ declare class SpineSettingsService {
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     /** Seção pedida na abertura (vazio = a primeira). */
     readonly section: _angular_core.WritableSignal<string>;
+    /** `section` aceita também as chaves antigas (`seguranca` abre "MFA"). */
     open(section?: string): void;
     close(): void;
     toggle(): void;
@@ -762,11 +825,159 @@ declare class SpineSettingsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineSettingsService>;
 }
 
+/** Espera depois da última mudança antes de gravar. */
+declare const SPINE_PREFERENCES_SAVE_DELAY_MS = 1500;
+/** Documento de preferências guardado no Argos (`PUT {api}/preferences`): chaves planas, todas opcionais. */
+interface SpineAccountPreferencesDoc {
+    v: number;
+    themeMode?: HermesThemeMode;
+    family?: string;
+    density?: HermesDensity;
+    font?: string;
+    sidebar?: 'auto' | 'fixed' | 'compact';
+    language?: string;
+    timeZone?: string;
+    textScale?: number;
+    motion?: HermesMotionPreference;
+    hourCycle?: SpineHourCyclePreference;
+    weekStart?: Weekday | null;
+    characterKeys?: boolean;
+    idleMinutes?: number;
+    startPage?: SpineStartPagePreference;
+    notices?: Record<string, boolean>;
+    browserNotices?: boolean;
+    favorites?: unknown[];
+}
+/** `local`: só no navegador (recurso desligado, sem API da conta, ou Argos sem o endpoint). */
+type SpineAccountPreferencesStatus = 'idle' | 'local' | 'loading' | 'saving' | 'synced' | 'error';
+/**
+ * Preferências na conta (`SpineFeatures.accountPreferences`): espelha no Argos (`GET/PUT {api}/preferences`, por
+ * usuário e aplicação) o que o painel de configurações guarda no navegador — tema, cor, densidade, fonte, menu
+ * lateral, idioma, fuso, relógio, primeiro dia da semana, tamanho do texto, animações, atalhos de tecla única,
+ * inatividade, tela inicial, tipos de aviso e favoritos. As telas Aparência, Região etc. não mudam: o
+ * armazenamento local continua sendo a fonte de cada tela, e este serviço só sincroniza.
+ *
+ * - No início da sessão (`start()`, chamado pelo layout e pelo `/callback`), lê a conta e aplica o que estiver lá
+ *   (pelos mesmos `set*` das telas); favoritos são somados (os da conta primeiro). Conta vazia recebe o que está no
+ *   navegador.
+ * - Depois, cada mudança é gravada na conta, agrupada (`SPINE_PREFERENCES_SAVE_DELAY_MS`).
+ * - Sem a API da conta, com o recurso desligado ou com um Argos que não tem o endpoint (404/400), fica só no
+ *   navegador (`status() === 'local'`), sem erro na tela.
+ */
+declare class SpineAccountPreferencesService {
+    private readonly browser;
+    private readonly api;
+    private readonly preferences;
+    private readonly quickAccess;
+    private readonly hermesTheme;
+    private readonly themeConfig;
+    private readonly theme;
+    private readonly density;
+    private readonly presets;
+    private readonly sidebar;
+    /** Recurso ligado e API da conta disponível. */
+    readonly enabled: boolean;
+    readonly status: _angular_core.WritableSignal<SpineAccountPreferencesStatus>;
+    /** Hora da última leitura/gravação bem-sucedida. */
+    readonly syncedAt: _angular_core.WritableSignal<Date | null>;
+    /** O documento que o navegador tem agora. */
+    readonly snapshot: _angular_core.Signal<SpineAccountPreferencesDoc>;
+    private loaded;
+    private lastSaved;
+    private timer;
+    private readyPromise;
+    constructor();
+    /**
+     * Lê a conta e aplica (uma vez por sessão do app; chamadas seguintes devolvem a mesma promessa). Nunca rejeita.
+     */
+    start(): Promise<void>;
+    /** Como `start()`, mas sem esperar mais que `timeoutMs` (o login não fica parado se o Argos demorar). */
+    ready(timeoutMs?: number): Promise<void>;
+    /** Grava agora o que estiver pendente ("Sincronizar agora"); relê a conta se ela ainda não respondeu. */
+    syncNow(): Promise<void>;
+    private load;
+    /** Aplica o documento da conta pelos mesmos caminhos das telas (cada `set*` também grava no navegador). */
+    private apply;
+    private schedule;
+    private save;
+    private failed;
+    private clearTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAccountPreferencesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineAccountPreferencesService>;
+}
+/** JSON com as chaves dos objetos em ordem (a conta pode devolver outra ordem). */
+declare function stable(value: unknown): string;
+
+/** Um aviso do app (`SpineNoticesService.notify`). */
+interface SpineNotice {
+    title: string;
+    /** Detalhe (segunda linha do aviso do navegador; no aviso da tela vai depois do título). */
+    body?: string;
+    /** Caminho interno (`/solicitacoes/42`) aberto pelo "Abrir" do aviso e pelo clique no aviso do navegador. */
+    url?: string;
+    /** Cor do aviso na tela. Padrão: `info`. */
+    intent?: AlertVariant;
+}
+/** Permissão do navegador para avisos, ou `unsupported` (sem Notification API, ou fora do navegador). */
+type SpineNoticePermission = NotificationPermission | 'unsupported';
+/**
+ * Avisos do app (`SpineFeatures.notices`): o app declara os tipos que emite (`{ id, label }`) e chama
+ * `notify(tipo, aviso)` de onde já sabe do acontecimento (subscription, polling). Cada tipo pode ser desligado em
+ * Configurações › Notificações; tipo desligado não aparece. O aviso ligado:
+ *
+ * - aparece na tela (`HermesToastService`, com "Abrir" quando tem `url`);
+ * - com a aba em segundo plano, o aviso do navegador ligado e a permissão concedida, vira também um aviso do sistema
+ *   (Notification API); clicar nele traz a aba para a frente e abre a `url`.
+ *
+ * Tipo não declarado em `SpineFeatures.notices.types` aparece sempre (em desenvolvimento, com um aviso no console).
+ */
+declare class SpineNoticesService {
+    private readonly browser;
+    private readonly zone;
+    private readonly injector;
+    private readonly toast;
+    private readonly preferences;
+    private readonly messages;
+    private readonly config;
+    private readonly warned;
+    /** Recurso ligado pelo app. */
+    readonly enabled: boolean;
+    /** Tipos declarados pelo app. */
+    readonly types: readonly SpineNoticeType[];
+    /** Permissão atual do navegador. */
+    readonly permission: _angular_core.WritableSignal<SpineNoticePermission>;
+    /** Aviso do navegador valendo de fato: ligado nas configurações e permitido pelo navegador. */
+    readonly browserActive: _angular_core.Signal<boolean>;
+    /** O tipo está ligado (escolha da pessoa ou, sem escolha, o `defaultEnabled` dele). */
+    isEnabled(typeId: string): boolean;
+    setEnabled(typeId: string, enabled: boolean): void;
+    /**
+     * Liga o aviso do navegador: pede a permissão quando ainda não foi pedida. Devolve se ficou ligado (permissão
+     * negada ou navegador sem suporte: continua desligado).
+     */
+    enableBrowser(): Promise<boolean>;
+    disableBrowser(): void;
+    /** Relê a permissão (a pessoa pode ter mudado nas configurações do navegador). */
+    refreshPermission(): void;
+    /** Mostra o aviso, se o tipo estiver ligado. Devolve se mostrou. */
+    notify(typeId: string, notice: SpineNotice): boolean;
+    private system;
+    private open;
+    private readPermission;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineNoticesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineNoticesService>;
+}
+
+/** Uma lista guardada neste navegador que a seção "Dados do navegador" limpa. */
+type BrowserList = 'recents' | 'searches' | 'favorites';
 /**
- * Painel de configurações do shell (substitui as telas do antigo módulo "Sistema"): Aparência,
- * Região, Atalhos, Conta, Conta e segurança (MFA, códigos de recuperação e sessões do Argos) e Sobre, mais
- * as seções que o app registrar com `provideSettingsSection`. Tudo vale na hora — cada controle chama
- * o serviço que já persiste aquela preferência (tema, densidade, menu lateral, fuso).
+ * Painel de configurações do shell (substitui as telas do antigo módulo "Sistema"): Conta (perfil, nível,
+ * sessão, sair), MFA (verificação em duas etapas e códigos de recuperação do Argos), Sessões (token de
+ * acesso, tokens de aplicação e sessões e dispositivos do Argos), Aparência, Acessibilidade (tamanho do texto,
+ * animações), Região (idioma, fuso, formato de hora, primeiro dia da semana), Atalhos, Dados do navegador
+ * (limpar listas, restaurar preferências), Ajuda (novidades, tour) e Sobre, mais as seções que o app registrar
+ * com `provideSettingsSection`. Tudo vale na hora — cada controle chama o serviço que já persiste aquela
+ * preferência (tema, densidade, menu lateral, fuso, tamanho do texto…).
  *
  * Aberto por `SpineSettingsService.open()` — menu do perfil, `Ctrl+,` ou `?settings=<seção>`.
  */
@@ -797,6 +1008,7 @@ declare class SettingsPanelComponent {
         sidebar: string;
         sidebarDescription: string;
         sidebarKeywords: string;
+        sidebarHelp: string;
         sidebarAuto: string;
         sidebarFixed: string;
         sidebarCompact: string;
@@ -810,6 +1022,16 @@ declare class SettingsPanelComponent {
         timeZoneKeywords: string;
         timeZoneHint: string;
         timeZoneAuto: string;
+        hourCycle: string;
+        hourCycleHint: string;
+        hourCycleKeywords: string;
+        hourCycleAuto: string;
+        hourCycle24: string;
+        hourCycle12: string;
+        weekStart: string;
+        weekStartDescription: string;
+        weekStartKeywords: string;
+        weekStartAuto: string;
         shortcuts: string;
         shortcutsDescription: string;
         shortcutsKeywords: string;
@@ -817,6 +1039,47 @@ declare class SettingsPanelComponent {
         tourDescription: string;
         tourKeywords: string;
         replayTour: string;
+        accessibility: string;
+        accessibilityKeywords: string;
+        textSize: string;
+        textSizeDescription: string;
+        textSizeKeywords: string;
+        motion: string;
+        motionDescription: string;
+        motionKeywords: string;
+        motionSystem: string;
+        motionReduce: string;
+        motionFull: string;
+        help: string;
+        helpKeywords: string;
+        news: string;
+        newsDescription: string;
+        newsKeywords: string;
+        showNews: string;
+        browserData: string;
+        browserDataDescription: string;
+        browserDataKeywords: string;
+        recentPages: string;
+        recentPagesKeywords: string;
+        recentSearches: string;
+        recentSearchesKeywords: string;
+        favorites: string;
+        favoritesKeywords: string;
+        pagesCount: _trismegisto_primitives.PluralMessage;
+        searchesCount: _trismegisto_primitives.PluralMessage;
+        clear: string;
+        confirmClear: string;
+        cancel: string;
+        recentPagesCleared: string;
+        recentSearchesCleared: string;
+        favoritesCleared: string;
+        restorePreferences: string;
+        restorePreferencesDescription: string;
+        restorePreferencesHelp: string;
+        restorePreferencesKeywords: string;
+        restore: string;
+        confirmRestore: string;
+        preferencesRestored: string;
         account: string;
         accountKeywords: string;
         user: string;
@@ -833,15 +1096,17 @@ declare class SettingsPanelComponent {
         accessTokenDescription: string;
         accessTokenKeywords: string;
         copy: string;
+        moreAbout: string;
         appTokens: string;
         appTokensDescription: string;
         appTokensKeywords: string;
+        appTokensHelp: string;
         logout: string;
         logoutDescription: string;
         logoutKeywords: string;
-        security: string;
-        securityDescription: string;
-        securityKeywords: string;
+        mfa: string;
+        mfaDescription: string;
+        mfaKeywords: string;
         signedInAccount: string;
         signedInRealm: string;
         twoFactor: string;
@@ -853,6 +1118,9 @@ declare class SettingsPanelComponent {
         sessions: string;
         sessionsDescription: string;
         sessionsKeywords: string;
+        sessionsSection: string;
+        sessionsSectionDescription: string;
+        sessionsSectionKeywords: string;
         about: string;
         aboutKeywords: string;
         application: string;
@@ -880,14 +1148,28 @@ declare class SettingsPanelComponent {
     protected readonly fmt: typeof formatMessage;
     protected readonly keys: {
         readonly appearance: "aparencia";
+        readonly accessibility: "acessibilidade";
         readonly region: "regiao";
         readonly shortcuts: "atalhos";
+        readonly help: "ajuda";
+        readonly notices: "notificacoes";
+        readonly data: "dados";
         readonly account: "conta";
+        readonly mfa: "mfa";
+        readonly sessions: "sessoes";
         readonly security: "seguranca";
         readonly about: "sobre";
     };
+    /** Seção aberta, com a chave antiga já trocada pela nova (`seguranca` → `mfa`). */
+    protected readonly activeSection: _angular_core.Signal<string>;
     private readonly theme;
     private readonly hermesTheme;
+    private readonly themeConfig;
+    private readonly sidebarConfig;
+    private readonly i18n;
+    private readonly news;
+    private readonly quickAccess;
+    private readonly userStorage;
     private readonly presets;
     private readonly density;
     protected readonly sidebar: HermesSidebarService;
@@ -901,6 +1183,85 @@ declare class SettingsPanelComponent {
     private readonly config;
     protected readonly appSections: _trismegisto_spine_layout.SpineSettingsSection[];
     protected readonly appName: string;
+    /** Recursos opcionais ligados pelo app (`SpineConfig.features`). */
+    protected readonly features: _trismegisto_spine.SpineFeatures;
+    protected readonly featureText: {
+        aiAgent: string;
+        aiAgentDescription: string;
+        aiAgentKeywords: string;
+        aiAgentHelp: string;
+        aiAgentStart: string;
+        aiAgentServers: string;
+        aiAgentAccess: string;
+        aiAgentReadOnly: string;
+        aiAgentReadWrite: string;
+        aiAgentWriteHint: string;
+        aiAgentReadOnlyServer: string;
+        aiAgentTokenName: string;
+        aiAgentGenerate: string;
+        aiAgentSelectServer: string;
+        aiAgentResult: string;
+        aiAgentResultHint: string;
+        aiAgentCopy: string;
+        aiAgentCopied: string;
+        aiAgentDone: string;
+        aiAgentCreateError: string;
+        aiAgentUnavailable: string;
+        activity: string;
+        activityDescription: string;
+        activityKeywords: string;
+        activityFilter: string;
+        activityAll: string;
+        activityFailures: string;
+        activityDetail: string;
+        activityApp: string;
+        activityEmpty: string;
+        activityMore: string;
+        activityShowing: string;
+        activityLoadError: string;
+        unknownIp: string;
+        unknownApp: string;
+        idle: string;
+        idleDescription: string;
+        idleKeywords: string;
+        idleNever: string;
+        idleOption: string;
+        idleLimitHint: string;
+        idleWarningHeading: string;
+        idleWarningText: _trismegisto_primitives.PluralMessage;
+        idleStay: string;
+        idleLogout: string;
+        startPage: string;
+        startPageDescription: string;
+        startPageKeywords: string;
+        startHome: string;
+        startLast: string;
+        startFavorite: string;
+        startPageHint: string;
+        defaultBadge: string;
+        defaultBadgeDescription: string;
+        defaultBadgeKeywords: string;
+        defaultBadgeAuto: string;
+        defaultBadgeSaved: string;
+        defaultBadgeError: string;
+        defaultBadgeLoadError: string;
+        notices: string;
+        noticesDescription: string;
+        noticesKeywords: string;
+        browserNotices: string;
+        browserNoticesDescription: string;
+        browserNoticesDenied: string;
+        browserNoticesUnsupported: string;
+        noticeOpen: string;
+        sync: string;
+        syncDescription: string;
+        syncKeywords: string;
+        syncSynced: string;
+        syncSaving: string;
+        syncLocal: string;
+        syncError: string;
+        syncNow: string;
+    };
     /**
      * "Copiar token de acesso" é ferramenta de desenvolvimento: põe o token da sessão (Bearer de tudo que a
      * pessoa pode fazer) na área de transferência, ao alcance de qualquer app/extensão que leia o clipboard.
@@ -922,6 +1283,12 @@ declare class SettingsPanelComponent {
     protected setDensity(value: string): void;
     protected setFont(value: string): void;
     protected setSidebarMode(value: string): void;
+    /** 100%, 110%, 125%, 150% — no formato de porcentagem do idioma. */
+    protected readonly textSizeOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly textSizeValue: _angular_core.Signal<string>;
+    protected readonly motionOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected setTextSize(value: string): void;
+    protected setMotion(value: string): void;
     protected readonly languageOptions: _angular_core.Signal<{
         readonly value: string;
         readonly label: string;
@@ -932,22 +1299,99 @@ declare class SettingsPanelComponent {
     protected readonly timeZoneOptions: _angular_core.Signal<readonly ComboboxOption[]>;
     /** Hora agora no fuso efetivo — prévia de como as datas vão aparecer. */
     protected readonly timeZonePreview: _angular_core.Signal<string>;
+    protected readonly hourCycleOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    /** Hora agora, no relógio escolhido — prévia do formato. */
+    protected readonly hourCyclePreview: _angular_core.Signal<string>;
+    /** Automático, domingo e segunda — os nomes dos dias saem do `Intl`, no idioma. */
+    protected readonly weekStartOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly weekStartValue: _angular_core.Signal<string>;
+    protected setHourCycle(value: string): void;
+    protected setWeekStart(value: string): void;
     /** Atalhos registrados (favoritos numa linha só) + os que outra peça dispara — os mesmos do painel "?". */
     protected readonly shortcutItems: _angular_core.Signal<readonly _trismegisto_angular.HermesShortcutItem[]>;
+    /** "Ver novidades" só quando o app tem alguma vigente (`provideSpineNews`). */
+    protected readonly hasNews: _angular_core.Signal<boolean>;
+    /** Fecha o painel antes: novidades e tour ocupam a tela. */
+    protected showNews(): void;
     protected replayTour(): void;
+    /** Relida quando o painel abre e depois de limpar (as buscas recentes não têm sinal próprio). */
+    private readonly dataVersion;
+    protected readonly counts: _angular_core.Signal<Readonly<Record<BrowserList, number>>>;
+    /** As três listas, com a contagem já no texto da linha. */
+    protected readonly browserLists: _angular_core.Signal<{
+        id: BrowserList;
+        label: string;
+        keywords: string;
+        count: string;
+        empty: boolean;
+    }[]>;
+    /** Ação destrutiva esperando confirmação (uma por vez, como nas listas do painel). */
+    protected readonly confirming: _angular_core.WritableSignal<"preferences" | BrowserList | null>;
+    constructor();
+    protected cancelConfirm(): void;
+    /** 1º clique pede confirmação; o 2º apaga a lista do usuário atual e avisa. */
+    protected clearList(list: BrowserList): void;
+    /**
+     * Restaurar preferências (com confirmação): tema (sistema), cor principal (a padrão do app), densidade
+     * (confortável), fonte (a padrão do app), menu lateral (o modo padrão do app), tamanho do texto (100%),
+     * animações (sistema), formato de hora e primeiro dia da semana (automáticos). Idioma, fuso horário e
+     * atalhos de tecla única ficam: mudam como a pessoa lê e digita, e não são "aparência".
+     */
+    protected restorePreferences(): void;
     protected get profile(): _orfeu_angular_core.UserProfile;
     protected get badge(): _orfeu_angular_core.Badge | null;
     /** Validade da sessão lida do `exp` do próprio token (só leitura do payload, sem validar). */
     protected get sessionExpiry(): string;
     protected copyToken(): Promise<void>;
-    private readonly userStorage;
-    protected logout(): void;
+    private readonly logoutService;
+    /** "Saindo…" no botão; volta a `false` também quando a saída falha. */
+    protected readonly logoutPending: _angular_core.WritableSignal<boolean>;
+    /** O painel fica aberto até a saída dar certo: com falha, a pessoa continua aqui, com o aviso de erro. */
+    protected logout(): Promise<void>;
     /** API da conta no Argos (Bearer com o token da sessão), a partir do `AUTH_CONFIG`. Sem ela (sem
-     *  `authority`/`realmId`, ou com `CHANGE_ME`) a seção não aparece. */
+     *  `authority`/`realmId`, ou com `CHANGE_ME`) a seção MFA e a linha "Sessões e dispositivos" não aparecem. */
     protected readonly accountSecurity: boolean;
     /** Login da pessoa (`preferred_username` do token, ou o e-mail), para dizer QUAL conta do Argos. */
     protected get accountLogin(): string;
+    /** Realm pelo nome (`master`, `Minha Empresa`); um id (UUID) não diz nada a quem lê e fica de fora. */
     protected get accountRealm(): string;
+    /** Linhas da seção Sessões, cada uma com a própria condição. "Tokens de aplicação" sempre aparece (sem
+     *  `SPINE_ADMIN_API` os tokens explicam que não estão disponíveis); o token de acesso só com
+     *  `technicalDocs`; sessões e dispositivos só com a API da conta. A "Sessão" (validade) fica em Conta. */
+    protected readonly sessionsItems: {
+        readonly accessToken: boolean;
+        readonly appTokens: true;
+        readonly aiAgent: boolean;
+        readonly devices: boolean;
+    };
+    /** Sem nenhuma linha visível a seção não aparece. */
+    protected readonly hasSessionsSection: boolean;
+    private readonly idle;
+    private readonly startPageService;
+    private readonly router;
+    protected readonly notices: SpineNoticesService;
+    protected readonly accountPreferences: SpineAccountPreferencesService;
+    /** Conta › "Encerrar por inatividade": opções dentro dos limites do app. */
+    protected readonly idleOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly idleValue: _angular_core.Signal<string>;
+    protected readonly idleHint: string;
+    protected setIdle(value: string): void;
+    /** Conta › "Tela inicial": início, última tela e cada favorito. */
+    protected readonly startPageOptions: _angular_core.Signal<{
+        value: string;
+        label: string;
+    }[]>;
+    /** Favorito escolhido que deixou de ser favorito: mostra "Início" (é para onde o login vai). */
+    protected readonly startPageValue: _angular_core.Signal<SpineStartPagePreference>;
+    protected readonly quickAccessHasFavorites: _angular_core.Signal<boolean>;
+    protected setStartPage(value: string): void;
+    /** Conta › "Crachá padrão": só com mais de um crachá nesta aplicação (claim `badges` do token). */
+    protected get showDefaultBadge(): boolean;
+    /** Notificações: aviso do navegador ligado (escolha + permissão). */
+    protected setBrowserNotices(enabled: boolean): Promise<void>;
+    /** "Preferências na conta": situação da sincronização. */
+    protected readonly syncStatus: _angular_core.Signal<string>;
+    protected syncNow(): void;
     protected readonly dependencies: {
         version: string | undefined;
         name: string;
@@ -1010,6 +1454,8 @@ declare class SpineAppTokensService {
     private readonly auth;
     private readonly adminApi;
     readonly available: boolean;
+    /** Sobe a cada token criado por aqui (o "Conectar um agente de IA" cria um; a lista de tokens relê). */
+    readonly changes: _angular_core.WritableSignal<number>;
     private get baseUrl();
     private get headers();
     list(): Promise<AppTokenList>;
@@ -1077,6 +1523,55 @@ interface AccountSession {
         name: string | null;
     }[];
 }
+/** Uma tentativa de entrar na conta (`GET {api}/activity`): sucesso, falha ou cancelamento. */
+interface AccountActivityEntry {
+    id: string;
+    /** Data e hora (ISO). */
+    at: string;
+    result: 'success' | 'failure' | 'cancelled';
+    /** `local`, `mfa`, `github`, `google`, `keycloak`, `entraid`. */
+    method: string;
+    /** Motivo da falha (`bad_password`, `mfa_failed`, `locked`…); `null` no sucesso. */
+    reason: string | null;
+    ip: string | null;
+    device: {
+        browser?: string | null;
+        os?: string | null;
+        mobile: boolean;
+        label: string;
+    };
+    /** Aplicativo em que a pessoa tentou entrar. */
+    client: {
+        client_id: string;
+        name: string | null;
+    } | null;
+}
+interface AccountActivityPage {
+    attempts: AccountActivityEntry[];
+    total: number;
+    limit: number;
+    offset: number;
+    /** Começo da janela (90 dias). */
+    since: string;
+}
+/** Crachás da pessoa nesta aplicação e o padrão guardado no Argos (`GET {api}/badges`). */
+interface AccountBadges {
+    client: {
+        id: string;
+        name: string | null;
+    };
+    badges: {
+        id: string;
+        name: string;
+    }[];
+    default_badge_id: string | null;
+    active_badge_id: string | null;
+}
+/** Preferências guardadas na conta para esta aplicação (`GET/PUT {api}/preferences`). */
+interface AccountPreferences {
+    preferences: Record<string, unknown>;
+    updated_at: string | null;
+}
 type AccountReauth = {
     password: string;
 } | {
@@ -1133,6 +1628,20 @@ declare class SpineAccountSecurityService {
     endOtherSessions(): Promise<{
         ended: number;
     }>;
+    /** Entradas e tentativas desta conta nos últimos 90 dias, da mais recente. `result` filtra só sucessos ou falhas. */
+    activity(params?: {
+        limit?: number;
+        offset?: number;
+        result?: 'success' | 'failure';
+    }): Promise<AccountActivityPage>;
+    badges(): Promise<AccountBadges>;
+    /** Crachá com que o login entra nesta aplicação (`null` volta ao padrão: o de menor nível). */
+    setDefaultBadge(badgeId: string | null): Promise<{
+        default_badge_id: string | null;
+    }>;
+    preferences(): Promise<AccountPreferences>;
+    /** Substitui o documento de preferências desta aplicação na conta (até 16 KB). */
+    savePreferences(preferences: Record<string, unknown>): Promise<AccountPreferences>;
     private send;
     private request;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineAccountSecurityService, never>;
@@ -1141,6 +1650,360 @@ declare class SpineAccountSecurityService {
 /** Código de erro que o Argos devolveu (`{ error: 'invalid_code' }`), ou `''`. */
 declare function accountErrorCode(err: unknown): string;
 
+/** Monta o `.mcp.json` do Claude Code: uma entrada por servidor, todas com o mesmo token. Com `write`, cada servidor
+ *  que tem `writeScopes` pede esses escopos; os demais (e todos sem `write`) vão com `readScopes`, ou sem o header
+ *  (o MCP já é só leitura sem ele). URL relativa é resolvida contra `origin`. */
+declare function buildMcpConfig(servers: readonly SpineMcpServer[], token: string, write: boolean, origin: string): string;
+/**
+ * Sessões › "Conectar um agente de IA" (`SpineFeatures.aiAgent`): em um passo, cria um token de aplicação pessoal
+ * (`x-app-token`, a mesma API de "Tokens de aplicação") e monta a configuração MCP pronta para o Claude Code, com os
+ * servidores que o app declarou e os escopos do acesso escolhido (só leitura ou leitura e escrita). O token aparece
+ * uma única vez, dentro da configuração; nunca vai para o console nem para o armazenamento do navegador, e some ao
+ * concluir ou fechar o painel.
+ */
+declare class AiAgentComponent {
+    private readonly messages;
+    protected readonly t: {
+        aiAgent: string;
+        aiAgentDescription: string;
+        aiAgentKeywords: string;
+        aiAgentHelp: string;
+        aiAgentStart: string;
+        aiAgentServers: string;
+        aiAgentAccess: string;
+        aiAgentReadOnly: string;
+        aiAgentReadWrite: string;
+        aiAgentWriteHint: string;
+        aiAgentReadOnlyServer: string;
+        aiAgentTokenName: string;
+        aiAgentGenerate: string;
+        aiAgentSelectServer: string;
+        aiAgentResult: string;
+        aiAgentResultHint: string;
+        aiAgentCopy: string;
+        aiAgentCopied: string;
+        aiAgentDone: string;
+        aiAgentCreateError: string;
+        aiAgentUnavailable: string;
+        activity: string;
+        activityDescription: string;
+        activityKeywords: string;
+        activityFilter: string;
+        activityAll: string;
+        activityFailures: string;
+        activityDetail: string;
+        activityApp: string;
+        activityEmpty: string;
+        activityMore: string;
+        activityShowing: string;
+        activityLoadError: string;
+        unknownIp: string;
+        unknownApp: string;
+        idle: string;
+        idleDescription: string;
+        idleKeywords: string;
+        idleNever: string;
+        idleOption: string;
+        idleLimitHint: string;
+        idleWarningHeading: string;
+        idleWarningText: _trismegisto_primitives.PluralMessage;
+        idleStay: string;
+        idleLogout: string;
+        startPage: string;
+        startPageDescription: string;
+        startPageKeywords: string;
+        startHome: string;
+        startLast: string;
+        startFavorite: string;
+        startPageHint: string;
+        defaultBadge: string;
+        defaultBadgeDescription: string;
+        defaultBadgeKeywords: string;
+        defaultBadgeAuto: string;
+        defaultBadgeSaved: string;
+        defaultBadgeError: string;
+        defaultBadgeLoadError: string;
+        notices: string;
+        noticesDescription: string;
+        noticesKeywords: string;
+        browserNotices: string;
+        browserNoticesDescription: string;
+        browserNoticesDenied: string;
+        browserNoticesUnsupported: string;
+        noticeOpen: string;
+        sync: string;
+        syncDescription: string;
+        syncKeywords: string;
+        syncSynced: string;
+        syncSaving: string;
+        syncLocal: string;
+        syncError: string;
+        syncNow: string;
+    };
+    protected readonly tokens: {
+        unavailable: string;
+        created: string;
+        sendHeader: string;
+        copyToken: string;
+        saved: string;
+        loading: string;
+        expiredOn: string;
+        expiresOn: string;
+        lastUsed: string;
+        never: string;
+        revoke: string;
+        confirmRevoke: string;
+        empty: string;
+        noBadges: string;
+        appOnly: string;
+        accessLevel: string;
+        name: string;
+        namePlaceholder: string;
+        nameRequired: string;
+        nameMax: string;
+        validity: string;
+        days30: string;
+        days90: string;
+        months6: string;
+        year1: string;
+        create: string;
+        cancel: string;
+        newToken: string;
+        validCount: string;
+        limit: string;
+        loadError: string;
+        badgesError: string;
+        createError: string;
+        copied: string;
+        copyFailed: string;
+        revoked: string;
+        revokeError: string;
+    };
+    protected readonly fmt: typeof formatMessage;
+    private readonly service;
+    private readonly toast;
+    private readonly preferences;
+    protected readonly available: boolean;
+    protected readonly servers: readonly SpineMcpServer[];
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly starting: _angular_core.WritableSignal<boolean>;
+    protected readonly submitting: _angular_core.WritableSignal<boolean>;
+    protected readonly selected: _angular_core.WritableSignal<ReadonlySet<string>>;
+    protected readonly access: _angular_core.WritableSignal<"read" | "write">;
+    protected readonly badges: _angular_core.WritableSignal<{
+        id: string;
+        name: string;
+    }[]>;
+    protected readonly badgeId: _angular_core.WritableSignal<string>;
+    protected readonly validity: _angular_core.WritableSignal<string>;
+    /** Configuração gerada (com o token), mostrada uma única vez. */
+    protected readonly result: _angular_core.WritableSignal<{
+        config: string;
+        expires: string;
+    } | null>;
+    protected readonly canWrite: _angular_core.Signal<boolean>;
+    protected readonly noBadges: _angular_core.Signal<boolean>;
+    protected readonly canSubmit: _angular_core.Signal<boolean>;
+    protected readonly accessOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly badgeOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected readonly validityOptions: _angular_core.Signal<readonly SegmentedOption<string>[]>;
+    protected serverLabel(server: SpineMcpServer): string;
+    protected toggleServer(name: string, checked: boolean): void;
+    protected start(): Promise<void>;
+    protected cancel(): void;
+    protected generate(): Promise<void>;
+    protected copy(): Promise<void>;
+    protected done(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AiAgentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AiAgentComponent, "spine-ai-agent", never, {}, {}, never, never, true, never>;
+}
+
+/** Limites de "Encerrar por inatividade" já resolvidos a partir de `SpineFeatures.idleTimeout`. */
+interface SpineIdleLimits {
+    enabled: boolean;
+    /** Minutos mínimos (0 = sem mínimo). */
+    min: number;
+    /** Minutos máximos (0 = sem máximo; com máximo a opção "Nunca" some). */
+    max: number;
+    /** Opções oferecidas (0 = nunca), já filtradas pelos limites. */
+    options: readonly number[];
+}
+/** Opções e limites de inatividade do app. Sem o recurso, `enabled` é falso e não há opções. */
+declare function idleLimits(features: SpineFeatures | undefined): SpineIdleLimits;
+/** Minutos que valem de fato: a escolha da pessoa dentro dos limites do app (0 = não encerra). */
+declare function effectiveIdleMinutes(chosen: number, limits: SpineIdleLimits): number;
+
+/** Segundos de aviso antes de encerrar. */
+declare const SPINE_IDLE_WARNING_SECONDS = 60;
+/**
+ * Encerrar por inatividade (`SpineFeatures.idleTimeout`): conta o tempo sem uso (ponteiro, teclado, rolagem) em
+ * TODAS as abas do app — a última atividade vai para o `localStorage` (`hermes_<clientId>_last_activity`) e cada aba
+ * confere a mais recente —, abre o aviso com contagem regressiva `SPINE_IDLE_WARNING_SECONDS` antes do fim e, se
+ * ninguém responder, sai pelo `SpineLogoutService` (o mesmo "Sair" do menu). Com o aviso aberto, só "Continuar
+ * conectado" (ou atividade em outra aba) mantém a sessão: mexer o ponteiro sobre o aviso não conta.
+ *
+ * Os minutos vêm do `SpinePreferencesService.idleMinutes`, limitados pelo app (`effectiveIdleMinutes`). Ligado pelo
+ * `LayoutComponent` (só existe com sessão); não faz nada fora do navegador.
+ */
+declare class SpineIdleService {
+    private readonly browser;
+    private readonly zone;
+    private readonly preferences;
+    private readonly logoutService;
+    private readonly config;
+    private readonly storageKey;
+    readonly limits: _trismegisto_spine_layout.SpineIdleLimits;
+    /** Minutos que valem agora (0 = não encerra). */
+    readonly minutes: _angular_core.Signal<number>;
+    /** Aviso aberto. */
+    readonly warning: _angular_core.WritableSignal<boolean>;
+    /** Segundos que faltam, enquanto o aviso está aberto. */
+    readonly secondsLeft: _angular_core.WritableSignal<number>;
+    private lastActivity;
+    private lastWrite;
+    private timer;
+    private expiring;
+    /** Ligado por `start()` (o layout, que só existe com sessão). */
+    private readonly active;
+    private readonly onActivity;
+    constructor();
+    /** Liga a contagem (idempotente). Para sozinha quando a escolha vira "Nunca". */
+    start(): void;
+    /** "Continuar conectado": fecha o aviso e recomeça a contagem. */
+    stay(): void;
+    /** "Sair agora". */
+    logoutNow(): void;
+    /** Conta uma atividade agora (e a grava para as outras abas no máximo a cada 5 s, ou já, com `force`). */
+    touch(force?: boolean): void;
+    /** Confere o tempo sem uso: abre o aviso, atualiza a contagem ou encerra. Exposto para os testes. */
+    check(now?: number): void;
+    private storedActivity;
+    private run;
+    private stop;
+    private expire;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineIdleService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineIdleService>;
+}
+
+/**
+ * Aviso de "Encerrar por inatividade" (`SpineIdleService`): contagem regressiva, "Continuar conectado" (padrão, e o
+ * que fechar pelo X/Esc faz) e "Sair agora". Montado uma vez no `spine-layout`.
+ */
+declare class SpineIdleWarningComponent {
+    protected readonly idle: SpineIdleService;
+    private readonly messages;
+    protected readonly text: {
+        aiAgent: string;
+        aiAgentDescription: string;
+        aiAgentKeywords: string;
+        aiAgentHelp: string;
+        aiAgentStart: string;
+        aiAgentServers: string;
+        aiAgentAccess: string;
+        aiAgentReadOnly: string;
+        aiAgentReadWrite: string;
+        aiAgentWriteHint: string;
+        aiAgentReadOnlyServer: string;
+        aiAgentTokenName: string;
+        aiAgentGenerate: string;
+        aiAgentSelectServer: string;
+        aiAgentResult: string;
+        aiAgentResultHint: string;
+        aiAgentCopy: string;
+        aiAgentCopied: string;
+        aiAgentDone: string;
+        aiAgentCreateError: string;
+        aiAgentUnavailable: string;
+        activity: string;
+        activityDescription: string;
+        activityKeywords: string;
+        activityFilter: string;
+        activityAll: string;
+        activityFailures: string;
+        activityDetail: string;
+        activityApp: string;
+        activityEmpty: string;
+        activityMore: string;
+        activityShowing: string;
+        activityLoadError: string;
+        unknownIp: string;
+        unknownApp: string;
+        idle: string;
+        idleDescription: string;
+        idleKeywords: string;
+        idleNever: string;
+        idleOption: string;
+        idleLimitHint: string;
+        idleWarningHeading: string;
+        idleWarningText: _trismegisto_primitives.PluralMessage;
+        idleStay: string;
+        idleLogout: string;
+        startPage: string;
+        startPageDescription: string;
+        startPageKeywords: string;
+        startHome: string;
+        startLast: string;
+        startFavorite: string;
+        startPageHint: string;
+        defaultBadge: string;
+        defaultBadgeDescription: string;
+        defaultBadgeKeywords: string;
+        defaultBadgeAuto: string;
+        defaultBadgeSaved: string;
+        defaultBadgeError: string;
+        defaultBadgeLoadError: string;
+        notices: string;
+        noticesDescription: string;
+        noticesKeywords: string;
+        browserNotices: string;
+        browserNoticesDescription: string;
+        browserNoticesDenied: string;
+        browserNoticesUnsupported: string;
+        noticeOpen: string;
+        sync: string;
+        syncDescription: string;
+        syncKeywords: string;
+        syncSynced: string;
+        syncSaving: string;
+        syncLocal: string;
+        syncError: string;
+        syncNow: string;
+    };
+    protected readonly countdown: _angular_core.Signal<string>;
+    protected onOpenChange(open: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineIdleWarningComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpineIdleWarningComponent, "spine-idle-warning", never, {}, {}, never, never, true, never>;
+}
+
+/** Caminho interno seguro (`/x`, nunca `//host` nem `http:`). */
+declare function isInternalPath(url: unknown): url is string;
+/**
+ * Tela inicial (`SpineFeatures.startPage`): para onde o app vai depois do login quando a pessoa não pediu uma URL
+ * (`/callback` sem URL de retorno, ou com `/` ou `/home`) — o início do app, um favorito ou a última tela visitada.
+ *
+ * A última tela fica no `SpineUserStorage` (`lastPage`, por usuário) e só é gravada enquanto a escolha for
+ * "Última tela visitada" (`track()`, ligado pelo `LayoutComponent`); ao contrário dos recentes, ela fica no logout.
+ */
+declare class SpineStartPageService {
+    private readonly browser;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly preferences;
+    private readonly storage;
+    readonly enabled: boolean;
+    private tracking;
+    /** Grava a URL de cada navegação enquanto a escolha for "Última tela visitada" (idempotente). */
+    track(): void;
+    /** Guarda `url` como última tela (só com a escolha "Última tela visitada"). */
+    remember(url: string): void;
+    /** Destino da tela inicial escolhida, ou `null` (início do app, recurso desligado ou favorito que sumiu). */
+    target(): string | null;
+    /** `true` quando o login não pediu uma URL própria (aí a tela inicial manda). */
+    static isDefaultReturn(returnUrl: string | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpineStartPageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SpineStartPageService>;
+}
+
 /** Documento de uma tela que a pessoa logada pode abrir. */
 interface DocsEntry extends RouteDocument {
     /** Chave da tela (router_id ou, sem ele, o do template), sempre em minúsculas. */
@@ -1250,6 +2113,6 @@ declare const SPINE_MARKDOWN_PURIFY_CONFIG: Config;
 /** HTML limpo pelo perfil do spine, ou `null` quando não há DOM (SSR: melhor não renderizar). */
 declare function sanitizeSpineMarkdownHtml(html: string): string | null;
 
-export { AppLauncherComponent, HeaderComponent, LayoutComponent, OnboardingOverlayComponent, OnboardingService, SPINE_BRAND, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineMarkdownComponent, SpineNewsComponent, SpineNewsService, SpineSettingsService, accountErrorCode, argosAccountApi, findTourTarget, provideSettingsSection, sanitizeSpineMarkdownHtml };
-export type { AccountMethod, AccountOverview, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, OnboardingState, OnboardingStep, ShortcutActions, ShortcutGroup, ShortcutGroupId, ShortcutItem, SpineSettingsSection };
+export { AiAgentComponent, AppLauncherComponent, HeaderComponent, LayoutComponent, OnboardingOverlayComponent, OnboardingService, SPINE_BRAND, SPINE_IDLE_WARNING_SECONDS, SPINE_MARKDOWN_PURIFY_CONFIG, SPINE_PREFERENCES_SAVE_DELAY_MS, SPINE_SETTINGS_ALIASES, SPINE_SETTINGS_KEYS, SPINE_SETTINGS_SECTIONS, SettingsPanelComponent, ShortcutService, ShortcutsCheatsheetComponent, SidebarComponent, SpineAccountPreferencesService, SpineAccountSecurityService, SpineAppTokensService, SpineBrandComponent, SpineConnectionBannerComponent, SpineDocsComponent, SpineDocsService, SpineIdleService, SpineIdleWarningComponent, SpineLogoutService, SpineMarkdownComponent, SpineNewsComponent, SpineNewsService, SpineNoticesService, SpineSettingsService, SpineStartPageService, accountErrorCode, argosAccountApi, buildMcpConfig, effectiveIdleMinutes, findTourTarget, idleLimits, isInternalPath, provideSettingsSection, resolveSettingsSection, sanitizeSpineMarkdownHtml, stable };
+export type { AccountActivityEntry, AccountActivityPage, AccountBadges, AccountMethod, AccountOverview, AccountPreferences, AccountReauth, AccountSession, AppToken, AppTokenList, AppTokenOptions, CreatedAppToken, DocsEntry, DocsGroup, DocsView, OnboardingState, OnboardingStep, ShortcutActions, ShortcutGroup, ShortcutGroupId, ShortcutItem, SpineAccountPreferencesDoc, SpineAccountPreferencesStatus, SpineIdleLimits, SpineNotice, SpineNoticePermission, SpineSettingsSection };
 //# sourceMappingURL=trismegisto-spine-layout.d.ts.map