redmine-context 1.1.0 → 1.2.0

package/dist/bundle/journal-detail.js

@@ -113,6 +113,23 @@ const RELATION_TYPES = new Set([
 function idToken(raw) {
     return /^\d+$/.test(raw) ? raw : undefined;
 }
+/**
+ * Achata um valor de alteração em UMA linha.
+ *
+ * Editar a descrição de uma issue guarda o texto INTEIRO — com quebras de linha
+ * — nos dois lados do detail. Um resumo de alteração é, por definição, de uma
+ * linha: no bundle o valor multi-linha quebra o formato `- campo: antes → depois`
+ * (e escapa visualmente da fence); na TUI vira várias linhas de tela, furando a
+ * conta do viewport, que assume um item por linha.
+ *
+ * O conteúdo completo continua disponível na seção Descrição do bundle.
+ *
+ * @param raw - Valor bruto do detail.
+ * @returns O mesmo texto com quebras e espaços repetidos colapsados.
+ */
+function flatten(raw) {
+    return raw.replace(/\s*\r?\n\s*/g, ' ').trim();
+}
 /**
  * Ref ATUAL da issue correspondente a um atributo, quando o contrato a carrega.
  *
@@ -206,18 +223,21 @@ export function journalDetailLabel(detail, issue) {
 export function journalDetailValue(detail, raw, issue, lookups) {
     if (raw === null || raw === undefined || raw === '')
         return undefined;
-    const id = idToken(raw);
+    const flat = flatten(raw);
+    if (flat === '')
+        return undefined;
+    const id = idToken(flat);
     // Um detail `relation` registra a issue do outro lado da relação.
     if (detail.property === 'relation') {
-        return id === undefined ? { text: raw, trusted: false } : { text: `issue #${id}`, trusted: true };
+        return id === undefined ? { text: flat, trusted: false } : { text: `issue #${id}`, trusted: true };
     }
     if (detail.property !== 'attr')
-        return { text: raw, trusted: false };
+        return { text: flat, trusted: false };
     if (detail.name === 'done_ratio') {
-        return id === undefined ? { text: raw, trusted: false } : { text: `${id}%`, trusted: true };
+        return id === undefined ? { text: flat, trusted: false } : { text: `${id}%`, trusted: true };
     }
     if (ISSUE_REF_ATTRS.has(detail.name)) {
-        return id === undefined ? { text: raw, trusted: false } : { text: `issue #${id}`, trusted: true };
+        return id === undefined ? { text: flat, trusted: false } : { text: `issue #${id}`, trusted: true };
     }
     // Dicionário da instância primeiro: resolve QUALQUER id, inclusive o valor
     // histórico que não corresponde mais ao estado atual.
@@ -236,5 +256,5 @@ export function journalDetailValue(detail, raw, issue, lookups) {
     if (id !== undefined && ATTR_LABELS[detail.name] !== undefined && detail.name.endsWith('_id')) {
         return { text: `#${id}`, trusted: true };
     }
-    return { text: raw, trusted: false };
+    return { text: flat, trusted: false };
 }

package/dist/fetch-issue-search.d.ts

@@ -16,6 +16,7 @@
  * Mantém a fronteira do ADR-005: encapsula os módulos internos (`client`,
  * `bundle`) para que a superfície permaneça fina e sem acesso a URL/host.
  */
+import { type SearchListItem } from './bundle/index.js';
 /** Limite default de resultados quando a superfície não informa `limit`. */
 export declare const SEARCH_DEFAULT_LIMIT = 25;
 /**
@@ -51,6 +52,15 @@ export interface FetchIssueSearchOptions {
 export interface IssueSearchResult {
     /** Lista compacta em Markdown pronta para o CallToolResult. */
     content: string;
+    /**
+     * Os mesmos itens em forma ESTRUTURADA.
+     *
+     * O `content` é Markdown com fences `<untrusted-content>` — marcação
+     * anti prompt-injection destinada ao LLM. Uma interface que o exiba mostra
+     * essas tags ao usuário, que é ruído: a TUI renderiza a partir daqui e aplica
+     * sua própria apresentação.
+     */
+    items: readonly SearchListItem[];
     /** Número de itens retornados. */
     count: number;
     /** Avisos de degradação (ex.: `/search` indisponível). Vazio no caminho feliz. */

package/dist/fetch-issue-search.js

@@ -116,5 +116,5 @@ export async function fetchIssueSearch(options) {
     }
     const items = payloads.slice(0, limit).map(toSearchListItem);
     const content = buildSearchListMarkdown(items, { query, warnings });
-    return { content, count: items.length, warnings, degraded };
+    return { content, items, count: items.length, warnings, degraded };
 }

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { extractIssueAttachments, type ExtractIssueAttachmentsOptions, } from '.
 export { fetchAttachmentText, fetchAttachmentTextCacheFirst, AttachmentNotFoundError, type FetchAttachmentTextOptions, type FetchAttachmentTextCacheFirstOptions, type AttachmentTextResult, } from './fetch-attachment-text.js';
 export { extractIssueAttachmentsCacheFirst, makeQueueBackgroundExtractor, processingResult, type BackgroundExtractionTarget, type BackgroundExtractor, type BackgroundCompute, type CacheFirstExtractionOptions, type QueueBackgroundOptions, } from './cache-first.js';
 export { fetchIssueSearch, SEARCH_DEFAULT_LIMIT, type FetchIssueSearchOptions, type IssueSearchFilters, type IssueSearchResult, } from './fetch-issue-search.js';
+export type { SearchListItem } from './bundle/index.js';
 export { searchIssues, type SearchIssuesOptions, type SearchIssuesPage } from './client/index.js';
 export { fetchLastIssues, LAST_DEFAULT_ORDER, LAST_DEFAULT_COUNT, LAST_MAX_COUNT, type LastIssuesOrder, type FetchLastIssuesOptions, type LastIssuesResult, } from './fetch-last-issues.js';
 export { createHttpClient, type HttpClient, type HttpClientOptions, type QueryParams, } from './client/index.js';

package/dist/surfaces/tui/app.js

@@ -35,12 +35,13 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { Breadcrumb } from './components/breadcrumb.js';
 import { isUnicodeSupported } from './glyphs.js';
-import { TerminalSizeProvider, useTerminalHeight } from './hooks/use-terminal-width.js';
+import { TerminalHeightProvider, TerminalSizeProvider, useTerminalHeight, } from './hooks/use-terminal-width.js';
 import { applyTerminalColors } from './terminal-colors.js';
 import { ReAuthAbortedError } from './hooks/use-auth-guard.js';
 import { consumeEscapeInterceptor } from './hooks/use-escape-interceptor.js';
 import { useExitGuard } from './hooks/use-exit-guard.js';
 import { useOnboardingCallbacks } from './hooks/use-onboarding-callbacks.js';
+import { isTyping } from './hooks/use-typing-guard.js';
 import { JobRegistryProvider } from './job-registry.js';
 import { NavigationProvider, useNavigation, useNavigationStack } from './navigation.js';
 import { HomeSelectionProvider } from './screens/home-selection.js';
@@ -75,6 +76,8 @@ export function borderStyleFor(unicode) {
 }
 /** Estilo resolvido para o ambiente atual — decidido uma vez, no import. */
 const BORDER_STYLE = borderStyleFor(isUnicodeSupported());
+/** Linhas consumidas pela moldura (topo + base). */
+const BORDER_ROWS = 2;
 /**
  * Decide a ação de `Esc`: abandono do re-auth (fix do review #119) quando a
  * tela atual é do fluxo de onboarding (`onboarding-*`) E há um `reAuth` em
@@ -165,7 +168,10 @@ function AppShell() {
     const abortReAuthRef = useRef(abortReAuth);
     abortReAuthRef.current = abortReAuth;
     const handleGlobalInput = useCallback((input, key) => {
-        if (input === 'q') {
+        // `q` só sai FORA de campo de texto: o Ink entrega a tecla a todos os
+        // handlers, então sem esta guarda digitar uma URL com "q" (ou uma senha)
+        // fecharia a TUI no meio do onboarding (ver ./hooks/use-typing-guard.ts).
+        if (input === 'q' && !isTyping()) {
             exitRef.current();
             return;
         }
@@ -207,5 +213,5 @@ function AppShell() {
     // não nas telas, então nenhuma tela precisa saber que existe uma. As duas
     // linhas da borda saem do minHeight para o conteúdo não estourar a altura do
     // terminal (o que empurraria o topo para fora no modo full-screen).
-    _jsxs(Box, { flexDirection: "column", minHeight: Math.max(1, rows - 2), borderStyle: BORDER_STYLE, borderColor: theme.border, children: [_jsx(Breadcrumb, { stack: stack }), armed ? (_jsx(Box, { paddingX: 1, marginBottom: 1, children: _jsxs(Text, { color: theme.warning, children: [symbols.warning, " Pressione Ctrl+C de novo para sair."] }) })) : null, _jsx(Box, { flexGrow: 1, flexDirection: "column", children: _jsx(Screen, {}) })] }));
+    _jsxs(Box, { flexDirection: "column", minHeight: Math.max(1, rows - BORDER_ROWS), borderStyle: BORDER_STYLE, borderColor: theme.border, children: [_jsx(Breadcrumb, { stack: stack }), armed ? (_jsx(Box, { paddingX: 1, marginBottom: 1, children: _jsxs(Text, { color: theme.warning, children: [symbols.warning, " Pressione Ctrl+C de novo para sair."] }) })) : null, _jsx(Box, { flexGrow: 1, flexDirection: "column", children: _jsx(TerminalHeightProvider, { height: Math.max(1, rows - BORDER_ROWS), children: _jsx(Screen, {}) }) })] }));
 }

package/dist/surfaces/tui/components/text-input.js

@@ -30,6 +30,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useCallback, useRef } from 'react';
 import { Text, useInput } from 'ink';
+import { useTypingGuard } from '../hooks/use-typing-guard.js';
 import { useTheme } from '../theme.js';
 import { truncate, truncateStart } from '../truncate.js';
 /**
@@ -79,21 +80,39 @@ export function TextInput({ value, onChange, onSubmit, mask, placeholder, isActi
             return;
         }
         if (key.backspace || key.delete) {
-            onChangeRef.current(valueRef.current.slice(0, -1));
+            // A ref avança JUNTO com a emissão: sincronizá-la só no render (abaixo)
+            // faz duas teclas chegadas antes do commit do React partirem do mesmo
+            // valor velho — a última vencia e as anteriores se perdiam. Digitar uma
+            // URL em velocidade normal corrompia o campo.
+            const next = valueRef.current.slice(0, -1);
+            valueRef.current = next;
+            onChangeRef.current(next);
             return;
         }
-        // Reason: tecla ÚNICA reservada por um controle da tela pai (ex.: "f"
-        // cicla o filtro de status na busca da home, M2-07/#30) — ignorada
+        // Reason: tecla ÚNICA reservada por um controle da tela pai — ignorada
         // aqui para não virar texto digitado; a tela pai trata o mesmo evento
         // via seu próprio `useInput()`. Só bloqueia o caractere isolado, não
         // uma sequência colada maior que o contenha.
+        //
+        // Sem consumidor em produção hoje: o caso original ("f" ciclando o filtro
+        // da home) foi resolvido pelo caminho inverso — os ATALHOS é que se
+        // suspendem enquanto há campo ativo (`../hooks/use-typing-guard.ts`), o
+        // que cobre qualquer tecla sem a tela precisar declarar uma lista. A prop
+        // segue disponível e testada para o caso de uma tela precisar reservar
+        // uma tecla ESPECÍFICA mantendo os demais atalhos vivos.
         if (reservedCharsRef.current.includes(input)) {
             return;
         }
         if (input.length > 0) {
-            onChangeRef.current(valueRef.current + input);
+            const next = valueRef.current + input;
+            valueRef.current = next;
+            onChangeRef.current(next);
         }
     }, []);
+    // Suspende os atalhos de LETRA enquanto este campo captura teclado: o Ink
+    // entrega a tecla a todos os handlers, então sem isto um `q` digitado aqui
+    // dispararia o atalho global de sair (ver ../hooks/use-typing-guard.ts).
+    useTypingGuard(isActive);
     useInput(handleInput, { isActive });
     // Reason: cursor em bloco simples (inversão de cor, sem literal — não
     // conta como cor hardcoded) só quando o campo está ativo, reforçando

package/dist/surfaces/tui/glyphs.d.ts

@@ -27,6 +27,10 @@ export interface Glyphs {
     readonly arrowUp: string;
     /** Seta "para baixo" das dicas de navegação. */
     readonly arrowDown: string;
+    /** Seta "para a esquerda" (página anterior nas listas longas). */
+    readonly arrowLeft: string;
+    /** Seta "para a direita" (próxima página nas listas longas). */
+    readonly arrowRight: string;
     /** Caractere da máscara de senha/api_key (`components/text-input.tsx`). */
     readonly maskBullet: string;
     /** Frames do spinner (`components/spinner.tsx`). */

package/dist/surfaces/tui/glyphs.js

@@ -58,6 +58,8 @@ export const UNICODE_GLYPHS = {
     emptyPlaceholder: '—',
     arrowUp: '↑',
     arrowDown: '↓',
+    arrowLeft: '←',
+    arrowRight: '→',
     maskBullet: '•',
     spinnerFrames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
     gaugeFull: '█',
@@ -70,6 +72,8 @@ export const ASCII_GLYPHS = {
     emptyPlaceholder: '-',
     arrowUp: '^',
     arrowDown: 'v',
+    arrowLeft: '<',
+    arrowRight: '>',
     maskBullet: '*',
     spinnerFrames: ['|', '/', '-', '\\'],
     gaugeFull: '#',

package/dist/surfaces/tui/hooks/use-issue-search.d.ts

@@ -1,8 +1,17 @@
-import { fetchIssueSearch, resolveApiKey } from '../../../index.js';
+import { fetchIssueSearch, resolveApiKey, type SearchListItem } from '../../../index.js';
 /** Debounce (ms) default aplicado a `query` antes de disparar a busca. */
 export declare const DEFAULT_DEBOUNCE_MS = 300;
 /** Filtro rápido de status (tecla `f` cicla entre os três, ver `../screens/home.tsx`). */
-export type SearchStatusFilter = 'open' | 'closed' | 'all';
+/**
+ * Filtro de status da home/busca.
+ *
+ * `'all'`/`'open'`/`'closed'` são os agregados do Redmine; um NÚMERO é o id de
+ * um status específico da instância (`/issue_statuses.json`). Os agregados
+ * sozinhos não serviam: uma instância real tem uma dezena de status (Nova,
+ * Fila, Estimativa, Atribuída, Em Andamento, Validação...) e todos eles são
+ * "abertos" — alternar aberto/fechado devolvia exatamente a mesma lista.
+ */
+export type SearchStatusFilter = 'open' | 'closed' | 'all' | number;
 /**
  * Estado da busca, consumido por `../screens/home.tsx`. Mesmo vocabulário de
  * `MyIssuesState` (`use-my-issues.ts`) + um `idle` inicial próprio: a busca
@@ -16,7 +25,10 @@ export type IssueSearchState = {
     status: 'loading';
 } | {
     status: 'loaded';
+    /** Markdown do bundle (com as fences) — mantido para quem precisar dele. */
     content: string;
+    /** Itens ESTRUTURADOS: é o que a tela renderiza (ver ../screens/home.tsx). */
+    items: readonly SearchListItem[];
     count: number;
     degraded: boolean;
     warnings: string[];
@@ -55,6 +67,17 @@ export interface UseIssueSearchResult {
      */
     clear: () => void;
 }
+/**
+ * Mapeia o filtro rápido de status para o `status_id` de `/issues.json`
+ * (`*` = todas).
+ *
+ * Exportada porque a LISTA da home (`./use-my-issues.ts`) aplica o mesmo filtro
+ * que a busca — duas traduções separadas divergiriam.
+ *
+ * @param filter - Filtro rápido escolhido na tela.
+ * @returns O valor de `status_id` para a query.
+ */
+export declare function statusIdFor(filter: SearchStatusFilter): string;
 /**
  * Busca issues (filtros + full-text best-effort) via o core, com debounce de
  * digitação e o filtro rápido de status.

package/dist/surfaces/tui/hooks/use-issue-search.js

@@ -34,8 +34,19 @@ import { useEnvFallbackAllowed } from '../instance.js';
 import { ReAuthAbortedError, useAuthGuard } from './use-auth-guard.js';
 /** Debounce (ms) default aplicado a `query` antes de disparar a busca. */
 export const DEFAULT_DEBOUNCE_MS = 300;
-/** Mapeia o filtro rápido de status para o `status_id` de `/issues.json` (`*` = todas). */
-function statusIdFor(filter) {
+/**
+ * Mapeia o filtro rápido de status para o `status_id` de `/issues.json`
+ * (`*` = todas).
+ *
+ * Exportada porque a LISTA da home (`./use-my-issues.ts`) aplica o mesmo filtro
+ * que a busca — duas traduções separadas divergiriam.
+ *
+ * @param filter - Filtro rápido escolhido na tela.
+ * @returns O valor de `status_id` para a query.
+ */
+export function statusIdFor(filter) {
+    if (typeof filter === 'number')
+        return String(filter);
     if (filter === 'open')
         return 'open';
     if (filter === 'closed')
@@ -124,6 +135,7 @@ export function useIssueSearch(query, statusFilter, options = {}) {
                 setState({
                     status: 'loaded',
                     content: result.content,
+                    items: result.items,
                     count: result.count,
                     degraded: result.degraded,
                     warnings: result.warnings,

package/dist/surfaces/tui/hooks/use-list-navigation.d.ts

@@ -14,6 +14,14 @@ export interface UseListNavigationOptions {
      * inline da home, M2-07/#30). Default: `true`.
      */
     isActive?: boolean;
+    /**
+     * Itens saltados por uma "página" (setas ESQUERDA/DIREITA e PageUp/PageDown).
+     *
+     * Navegar item a item não escala: uma lista filtrada por status pode ter
+     * centenas de entradas. A tela deve passar a ALTURA da sua janela visível,
+     * para que uma página corresponda a uma tela cheia. Default: 10.
+     */
+    pageSize?: number;
     /**
      * Cursor inicial — default `0`. Aplicado assim que `itemCount` deixa de
      * ser `0` pela primeira vez (clampado); mudanças subsequentes NÃO

package/dist/surfaces/tui/hooks/use-list-navigation.js

@@ -27,7 +27,7 @@ import { useEffect, useRef, useState } from 'react';
  * });
  */
 export function useListNavigation(itemCount, options = {}) {
-    const { onSelect, isActive = true, initialIndex } = options;
+    const { onSelect, isActive = true, initialIndex, pageSize = 10 } = options;
     // Ref (não dep de efeito): a aplicação do `initialIndex` deve acontecer uma
     // única vez, na primeira vez que a lista deixa de estar vazia — mesmo que
     // `initialIndex` mude entre renders (ex.: o contexto de origem re-renderiza
@@ -54,6 +54,17 @@ export function useListNavigation(itemCount, options = {}) {
             setSelectedIndex((current) => (current + 1) % itemCount);
             return;
         }
+        // Página: ao contrário de ↑/↓, NÃO dá a volta — saltar do topo para o fim
+        // da lista desorienta. Para nas bordas, como em qualquer paginador.
+        const page = Math.max(1, pageSize);
+        if (key.leftArrow || key.pageUp) {
+            setSelectedIndex((current) => Math.max(0, current - page));
+            return;
+        }
+        if (key.rightArrow || key.pageDown) {
+            setSelectedIndex((current) => Math.min(itemCount - 1, current + page));
+            return;
+        }
         if (key.return) {
             onSelect?.(selectedIndex);
         }

package/dist/surfaces/tui/hooks/use-my-issues.d.ts

@@ -1,4 +1,5 @@
 import { createHttpClient, listIssues, resolveApiKey } from '../../../index.js';
+import { type SearchStatusFilter } from './use-issue-search.js';
 /** Issue resumida exibida numa linha da lista da home — só os campos usados por `IssueRow`. */
 export interface MyIssue {
     /** Id numérico da issue (`#id` na linha). */
@@ -37,6 +38,14 @@ export type MyIssuesState = {
 };
 /** Dependências injetáveis do hook — todas opcionais, com defaults de produção via o core. */
 export interface UseMyIssuesOptions {
+    /**
+     * Filtro rápido de status (`f` na home). Default `'all'`.
+     *
+     * A LISTA precisa respeitá-lo: antes, o filtro só alimentava a busca — cujos
+     * resultados só aparecem com a busca ABERTA —, então ciclar o status não
+     * mudava nada na tela.
+     */
+    statusFilter?: SearchStatusFilter;
     /** Ambiente consultado para `REDMINE_URL`; default `process.env`. */
     env?: NodeJS.ProcessEnv;
     /** Resolve a api_key pela cascata M2; default `resolveApiKey` do core. */

package/dist/surfaces/tui/hooks/use-my-issues.js

@@ -32,6 +32,7 @@ import { useCallback, useEffect, useState } from 'react';
 import { createHttpClient, listIssues, resolveApiKey, RedmineForbiddenError, } from '../../../index.js';
 import { useEnvFallbackAllowed } from '../instance.js';
 import { ReAuthAbortedError, useAuthGuard } from './use-auth-guard.js';
+import { statusIdFor } from './use-issue-search.js';
 /** Estreita `unknown` para um objeto indexável, ou `undefined` se não for. */
 function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
@@ -65,6 +66,7 @@ function instanceFromEnv(env) {
  * const { state, retry } = useMyIssues(); // deps de produção (process.env, core real)
  */
 export function useMyIssues(options = {}) {
+    const statusFilter = options.statusFilter ?? 'all';
     const env = options.env ?? process.env;
     const resolve = options.resolveApiKey ?? resolveApiKey;
     const buildClient = options.createHttpClient ?? createHttpClient;
@@ -109,7 +111,9 @@ export function useMyIssues(options = {}) {
                 // Fix do review #120: envolvida por `guard()` — em 401, a Promise só
                 // resolve após o re-login ter sucesso e a busca ser refeita
                 // automaticamente; o estado do hook permanece `loading` enquanto isso.
-                const raw = await guard(() => fetchIssues(http, { filters: { assigned_to_id: 'me' } }));
+                const raw = await guard(() => fetchIssues(http, {
+                    filters: { assigned_to_id: 'me', status_id: statusIdFor(statusFilter) },
+                }));
                 if (cancelled)
                     return;
                 const issues = raw.map(toMyIssue).filter((issue) => issue !== undefined);
@@ -146,6 +150,6 @@ export function useMyIssues(options = {}) {
         // entre renders com as deps de produção (defaults do módulo, ou
         // `process.env`, ou a identidade estável de `useAuthGuard().guard`) — o
         // efeito só precisa refazer a busca quando `reloadToken` muda (retry).
-    }, [env, allowEnvFallback, resolve, buildClient, fetchIssues, guard, reloadToken]);
+    }, [statusFilter, env, allowEnvFallback, resolve, buildClient, fetchIssues, guard, reloadToken]);
     return { state, retry };
 }

package/dist/surfaces/tui/hooks/use-status-options.d.ts

@@ -0,0 +1,38 @@
+import { createHttpClient, fetchEnumerations, resolveApiKey } from '../../../index.js';
+import type { SearchStatusFilter } from './use-issue-search.js';
+/** Uma opção do seletor: o valor do filtro + o rótulo exibido. */
+export interface StatusOption {
+    /** Valor aplicado ao filtro. */
+    readonly value: SearchStatusFilter;
+    /** Rótulo legível (nome do status na instância, ou o agregado). */
+    readonly label: string;
+}
+/** Opções injetáveis (testes não tocam a rede). */
+export interface UseStatusOptionsOptions {
+    /** Ambiente consultado para `REDMINE_URL`; default `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Resolve a api_key pela cascata; default `resolveApiKey` do core. */
+    resolveApiKey?: typeof resolveApiKey;
+    /** Constrói o client HTTP; default `createHttpClient` do core. */
+    createHttpClient?: typeof createHttpClient;
+    /** Busca as enumerações; default `fetchEnumerations` do core. */
+    fetchEnumerations?: typeof fetchEnumerations;
+}
+/**
+ * Opções do filtro de status: agregados + os status reais da instância.
+ *
+ * @param options - Dependências injetáveis (ver {@link UseStatusOptionsOptions}).
+ * @returns A lista de opções; só os agregados enquanto carrega ou se falhar.
+ * @example
+ * const options = useStatusOptions();
+ * // [{ value: 'all', label: 'Todas' }, ..., { value: 7, label: 'Atribuída' }]
+ */
+export declare function useStatusOptions(options?: UseStatusOptionsOptions): readonly StatusOption[];
+/**
+ * Rótulo de um filtro, resolvido contra as opções carregadas.
+ *
+ * @param options - Opções disponíveis.
+ * @param filter - Filtro corrente.
+ * @returns O rótulo da opção, ou `#id` se o status não constar (degradação).
+ */
+export declare function statusFilterLabel(options: readonly StatusOption[], filter: SearchStatusFilter): string;

package/dist/surfaces/tui/hooks/use-status-options.js

@@ -0,0 +1,86 @@
+/**
+ * Opções do filtro de status da home (#30, revisto).
+ *
+ * O ciclo `todas → abertas → fechadas` não servia a uma instância real: todos os
+ * status de trabalho (Nova, Fila, Estimativa, Atribuída, Em Andamento,
+ * Validação…) são ABERTOS, então alternar entre "todas" e "abertas" devolvia a
+ * mesma lista e o filtro parecia quebrado.
+ *
+ * Este hook carrega os status DA INSTÂNCIA (`/issue_statuses.json`, já memoizado
+ * por `fetchEnumerations`) e os oferece como opções, com os dois agregados úteis
+ * no topo. Degrada em silêncio: sem permissão ou sem rede, sobram os agregados —
+ * o mesmo comportamento de antes, nunca um erro na tela.
+ */
+import { useEffect, useState } from 'react';
+import { createHttpClient, fetchEnumerations, resolveApiKey, } from '../../../index.js';
+import { useEnvFallbackAllowed } from '../instance.js';
+/** Agregados sempre disponíveis, mesmo sem as enumerações da instância. */
+const BASE_OPTIONS = [
+    { value: 'all', label: 'Todas' },
+    { value: 'open', label: 'Abertas' },
+    { value: 'closed', label: 'Fechadas' },
+];
+/** Lê `REDMINE_URL` do ambiente, tratando string vazia como ausente. */
+function instanceFromEnv(env) {
+    const value = env.REDMINE_URL;
+    return value !== undefined && value.length > 0 ? value : undefined;
+}
+/**
+ * Opções do filtro de status: agregados + os status reais da instância.
+ *
+ * @param options - Dependências injetáveis (ver {@link UseStatusOptionsOptions}).
+ * @returns A lista de opções; só os agregados enquanto carrega ou se falhar.
+ * @example
+ * const options = useStatusOptions();
+ * // [{ value: 'all', label: 'Todas' }, ..., { value: 7, label: 'Atribuída' }]
+ */
+export function useStatusOptions(options = {}) {
+    const env = options.env ?? process.env;
+    const resolve = options.resolveApiKey ?? resolveApiKey;
+    const buildClient = options.createHttpClient ?? createHttpClient;
+    const loadEnumerations = options.fetchEnumerations ?? fetchEnumerations;
+    const allowEnvFallback = useEnvFallbackAllowed();
+    const [statuses, setStatuses] = useState([]);
+    useEffect(() => {
+        let cancelled = false;
+        const instanceUrl = instanceFromEnv(env);
+        if (instanceUrl === undefined)
+            return undefined;
+        void (async () => {
+            try {
+                const cascade = { env, allowEnvFallback };
+                const apiKey = await resolve(instanceUrl, cascade);
+                if (apiKey === undefined || cancelled)
+                    return;
+                const enums = await loadEnumerations(buildClient({ baseUrl: instanceUrl, apiKey }), instanceUrl);
+                if (cancelled)
+                    return;
+                // Ordem estável por id: a lista não pode dançar entre renders.
+                setStatuses([...enums.status.entries()]
+                    .sort(([a], [b]) => a - b)
+                    .map(([id, label]) => ({ value: id, label })));
+            }
+            catch {
+                // Enriquecimento, não dado essencial: sem os status da instância o
+                // seletor segue com os agregados.
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [env, allowEnvFallback, resolve, buildClient, loadEnumerations]);
+    return statuses.length === 0 ? BASE_OPTIONS : [...BASE_OPTIONS, ...statuses];
+}
+/**
+ * Rótulo de um filtro, resolvido contra as opções carregadas.
+ *
+ * @param options - Opções disponíveis.
+ * @param filter - Filtro corrente.
+ * @returns O rótulo da opção, ou `#id` se o status não constar (degradação).
+ */
+export function statusFilterLabel(options, filter) {
+    const found = options.find((option) => option.value === filter);
+    if (found !== undefined)
+        return found.label;
+    return typeof filter === 'number' ? `#${filter}` : filter;
+}

package/dist/surfaces/tui/hooks/use-terminal-width.d.ts

@@ -34,6 +34,22 @@ export declare function TerminalWidthProvider({ width, children }: {
  * consumidor (ex.: cada linha da lista) assinar o próprio `resize` — o que
  * estourava o limite de 10 listeners do EventEmitter (MaxListenersExceededWarning).
  */
+/**
+ * Sobrescreve a ALTURA disponível para as telas abaixo.
+ *
+ * Usado pelo shell (`../app.tsx`) para descontar as linhas que a moldura da
+ * aplicação consome: as telas pedem `useTerminalHeight()` e devem receber o
+ * espaço que sobra, sem precisar saber que existe uma moldura — do contrário
+ * cada tela carregaria uma constante acoplada ao desenho do shell (e os testes,
+ * que montam telas sem moldura, veriam um valor errado).
+ *
+ * @param props.height - Altura disponível, em linhas.
+ * @param props.children - Subárvore que passa a enxergar essa altura.
+ */
+export declare function TerminalHeightProvider({ height, children }: {
+    height: number;
+    children: ReactNode;
+}): import("react").JSX.Element;
 export declare function TerminalSizeProvider({ children }: {
     children: ReactNode;
 }): import("react").JSX.Element;

package/dist/surfaces/tui/hooks/use-terminal-width.js

@@ -47,6 +47,21 @@ export function TerminalWidthProvider({ width, children }) {
  * consumidor (ex.: cada linha da lista) assinar o próprio `resize` — o que
  * estourava o limite de 10 listeners do EventEmitter (MaxListenersExceededWarning).
  */
+/**
+ * Sobrescreve a ALTURA disponível para as telas abaixo.
+ *
+ * Usado pelo shell (`../app.tsx`) para descontar as linhas que a moldura da
+ * aplicação consome: as telas pedem `useTerminalHeight()` e devem receber o
+ * espaço que sobra, sem precisar saber que existe uma moldura — do contrário
+ * cada tela carregaria uma constante acoplada ao desenho do shell (e os testes,
+ * que montam telas sem moldura, veriam um valor errado).
+ *
+ * @param props.height - Altura disponível, em linhas.
+ * @param props.children - Subárvore que passa a enxergar essa altura.
+ */
+export function TerminalHeightProvider({ height, children }) {
+    return _jsx(TerminalHeightContext.Provider, { value: height, children: children });
+}
 export function TerminalSizeProvider({ children }) {
     const [size, setSize] = useState(() => ({ width: readProcessColumns(), height: readProcessRows() }));
     useEffect(() => {

package/dist/surfaces/tui/hooks/use-typing-guard.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Há algum campo de texto ativo agora?
+ *
+ * Chamado pelos handlers de atalho ANTES de reagir a uma tecla de letra.
+ *
+ * @returns `true` enquanto qualquer `TextInput` ativo estiver montado.
+ */
+export declare function isTyping(): boolean;
+/** Zera o contador — para os testes não vazarem estado entre casos. */
+export declare function resetTypingGuard(): void;
+/**
+ * Registra um campo de texto como ativo enquanto `active` for `true`.
+ *
+ * @param active - `true` enquanto o campo captura teclado.
+ * @example
+ * // dentro de um componente de input:
+ * useTypingGuard(isActive);
+ */
+export declare function useTypingGuard(active: boolean): void;

package/dist/surfaces/tui/hooks/use-typing-guard.js

@@ -0,0 +1,58 @@
+/**
+ * Guarda de DIGITAÇÃO para os atalhos de letra.
+ *
+ * O Ink entrega cada tecla a TODOS os `useInput` registrados na árvore — um
+ * campo de texto ativo não "consome" a tecla. Sem esta guarda, qualquer atalho
+ * global de letra dispara no meio da digitação: `q` (sair) fecha a TUI enquanto
+ * se digita a URL da instância no onboarding (`https://redmine.qualquer...`) ou
+ * uma senha que contenha a letra.
+ *
+ * As telas que já sabem quando estão em modo de texto (a busca da home) checam
+ * o próprio estado; este módulo cobre o caso GERAL — qualquer `TextInput` ativo
+ * em qualquer tela suspende os atalhos de letra enquanto durar.
+ *
+ * Mesmo desenho de `./use-escape-interceptor.ts`: estado mutável em nível de
+ * módulo, não Context/Provider — a TUI sustenta uma tela por vez e um Provider
+ * seria complexidade sem benefício. Aqui é um CONTADOR (não um booleano) porque
+ * uma tela pode montar mais de um campo (ex.: usuário + senha) e a ordem de
+ * montagem/desmontagem entre eles não é garantida.
+ *
+ * Atalhos com modificador (`Ctrl+C`) continuam livres: eles não colidem com
+ * texto. `Command+<letra>` não é alternativa em TUI — no macOS o terminal
+ * intercepta antes de a tecla chegar à aplicação.
+ */
+import { useEffect } from 'react';
+/** Quantidade de campos de texto ATIVOS no momento. */
+let activeInputs = 0;
+/**
+ * Há algum campo de texto ativo agora?
+ *
+ * Chamado pelos handlers de atalho ANTES de reagir a uma tecla de letra.
+ *
+ * @returns `true` enquanto qualquer `TextInput` ativo estiver montado.
+ */
+export function isTyping() {
+    return activeInputs > 0;
+}
+/** Zera o contador — para os testes não vazarem estado entre casos. */
+export function resetTypingGuard() {
+    activeInputs = 0;
+}
+/**
+ * Registra um campo de texto como ativo enquanto `active` for `true`.
+ *
+ * @param active - `true` enquanto o campo captura teclado.
+ * @example
+ * // dentro de um componente de input:
+ * useTypingGuard(isActive);
+ */
+export function useTypingGuard(active) {
+    useEffect(() => {
+        if (!active)
+            return undefined;
+        activeInputs += 1;
+        return () => {
+            activeInputs = Math.max(0, activeInputs - 1);
+        };
+    }, [active]);
+}

package/dist/surfaces/tui/list-window.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Janela visível de uma lista longa, seguindo o cursor.
+ *
+ * A home renderizava TODAS as issues de uma vez. Enquanto a lista era curta
+ * (as abertas de uma pessoa) isso passava; filtrando por um status com centenas
+ * de itens, a lista estoura a altura do terminal, o rodapé é empurrado para fora
+ * e o cursor — que começa no topo — some da tela: "cadê meu cursor".
+ *
+ * Esta é a contraparte de `./components/scroll-view.tsx` para listas
+ * SELECIONÁVEIS: lá o deslocamento é dirigido pelo teclado sobre conteúdo
+ * estático; aqui ele acompanha o índice selecionado, que é quem manda.
+ *
+ * Sem estado próprio de propósito: a janela é função do (total, selecionado,
+ * altura). Guardar um offset exigiria sincronizá-lo com a seleção, com a troca
+ * de filtro e com o redimensionamento do terminal — três fontes de divergência.
+ */
+/** Intervalo `[start, end)` de itens a renderizar. */
+export interface ListWindow {
+    /** Índice do primeiro item visível. */
+    readonly start: number;
+    /** Índice logo APÓS o último visível (exclusivo, pronto para `slice`). */
+    readonly end: number;
+}
+/**
+ * Calcula a fatia visível mantendo o item selecionado dentro dela.
+ *
+ * O cursor é mantido ao MEIO da janela sempre que possível; nas pontas a janela
+ * gruda no início ou no fim, para não sobrar espaço vazio.
+ *
+ * @param total - Quantidade de itens da lista.
+ * @param selected - Índice selecionado (fora da faixa é fixado nela).
+ * @param height - Linhas disponíveis; `<= 0` devolve uma janela vazia.
+ * @returns O intervalo `[start, end)` para `slice`.
+ * @example
+ * listWindow(347, 0, 20);   // { start: 0, end: 20 }
+ * listWindow(347, 200, 20); // { start: 190, end: 210 } — cursor centrado
+ * listWindow(347, 346, 20); // { start: 327, end: 347 } — grudado no fim
+ */
+export declare function listWindow(total: number, selected: number, height: number): ListWindow;

package/dist/surfaces/tui/list-window.js

@@ -0,0 +1,41 @@
+/**
+ * Janela visível de uma lista longa, seguindo o cursor.
+ *
+ * A home renderizava TODAS as issues de uma vez. Enquanto a lista era curta
+ * (as abertas de uma pessoa) isso passava; filtrando por um status com centenas
+ * de itens, a lista estoura a altura do terminal, o rodapé é empurrado para fora
+ * e o cursor — que começa no topo — some da tela: "cadê meu cursor".
+ *
+ * Esta é a contraparte de `./components/scroll-view.tsx` para listas
+ * SELECIONÁVEIS: lá o deslocamento é dirigido pelo teclado sobre conteúdo
+ * estático; aqui ele acompanha o índice selecionado, que é quem manda.
+ *
+ * Sem estado próprio de propósito: a janela é função do (total, selecionado,
+ * altura). Guardar um offset exigiria sincronizá-lo com a seleção, com a troca
+ * de filtro e com o redimensionamento do terminal — três fontes de divergência.
+ */
+/**
+ * Calcula a fatia visível mantendo o item selecionado dentro dela.
+ *
+ * O cursor é mantido ao MEIO da janela sempre que possível; nas pontas a janela
+ * gruda no início ou no fim, para não sobrar espaço vazio.
+ *
+ * @param total - Quantidade de itens da lista.
+ * @param selected - Índice selecionado (fora da faixa é fixado nela).
+ * @param height - Linhas disponíveis; `<= 0` devolve uma janela vazia.
+ * @returns O intervalo `[start, end)` para `slice`.
+ * @example
+ * listWindow(347, 0, 20);   // { start: 0, end: 20 }
+ * listWindow(347, 200, 20); // { start: 190, end: 210 } — cursor centrado
+ * listWindow(347, 346, 20); // { start: 327, end: 347 } — grudado no fim
+ */
+export function listWindow(total, selected, height) {
+    if (height <= 0 || total <= 0)
+        return { start: 0, end: 0 };
+    if (total <= height)
+        return { start: 0, end: total };
+    const cursor = Math.min(Math.max(selected, 0), total - 1);
+    const half = Math.floor(height / 2);
+    const start = Math.min(Math.max(0, cursor - half), total - height);
+    return { start, end: start + height };
+}

package/dist/surfaces/tui/screens/export.js

@@ -53,6 +53,7 @@ import { useExportBundle } from '../hooks/use-export-bundle.js';
 import { useListNavigation } from '../hooks/use-list-navigation.js';
 import { useJobRegistry } from '../job-registry.js';
 import { useTerminalWidth } from '../hooks/use-terminal-width.js';
+import { isTyping } from '../hooks/use-typing-guard.js';
 import { useNavigation } from '../navigation.js';
 import { symbols } from '../symbols.js';
 import { useTheme } from '../theme.js';
@@ -154,8 +155,11 @@ export function ExportScreen() {
             return;
         }
         // "b" não interrompe uma exportação em andamento — evita voltar no meio
-        // de uma gravação em disco.
-        if (input === 'b' && stateStatusRef.current !== 'exporting') {
+        // de uma gravação em disco — nem dispara enquanto o campo "Destino" está
+        // capturando teclado: o Ink entrega a tecla aos dois handlers, então um
+        // caminho como `~/backup/` ou `bundle.json` fecharia a tela no meio da
+        // digitação (ver ../hooks/use-typing-guard.ts).
+        if (input === 'b' && !isTyping() && stateStatusRef.current !== 'exporting') {
             popRef.current();
             return;
         }

package/dist/surfaces/tui/screens/home.js

@@ -21,7 +21,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * retry.
  *
  * M2-07 (#30) acrescenta a busca/filtros inline: `/` abre um `TextInput`
- * QUANDO a home está ativa; `f` cicla o filtro com a busca FECHADA (badge no
+ * QUANDO a home está ativa; `f` abre o seletor de status com a busca FECHADA (badge no
  * cabeçalho); Esc fecha a busca sem refetch, interceptado via
  * `../hooks/use-escape-interceptor.ts` para não desempilhar a home.
  *
@@ -43,12 +43,15 @@ import { Spinner } from '../components/spinner.js';
 import { TextInput } from '../components/text-input.js';
 import { glyphs } from '../glyphs.js';
 import { useEscapeInterceptor } from '../hooks/use-escape-interceptor.js';
+import { isTyping } from '../hooks/use-typing-guard.js';
+import { listWindow } from '../list-window.js';
+import { statusFilterLabel, useStatusOptions } from '../hooks/use-status-options.js';
 import { useIssueSearch } from '../hooks/use-issue-search.js';
 import { useListNavigation } from '../hooks/use-list-navigation.js';
 import { useMyIssues } from '../hooks/use-my-issues.js';
-import { useTerminalWidth } from '../hooks/use-terminal-width.js';
+import { useTerminalHeight, useTerminalWidth } from '../hooks/use-terminal-width.js';
 import { useNavigation } from '../navigation.js';
-import { statusColor } from '../status-color.js';
+import { statusColor, statusFilterColor } from '../status-color.js';
 import { symbols } from '../symbols.js';
 import { useTheme } from '../theme.js';
 import { truncate } from '../truncate.js';
@@ -61,20 +64,14 @@ const SCREEN_PADDING_X = 2;
 // literal `[]` inline em cada render seria recriado a cada chamada,
 // invalidando memoizações a jusante (`useListNavigation`) sem necessidade.
 const EMPTY_ISSUES = [];
-/** Rótulo do badge de cada filtro rápido de status (tecla `f` cicla, M2-07/#30). */
-const STATUS_FILTER_LABELS = {
-    open: 'aberta',
-    closed: 'fechada',
-    all: 'todas',
-};
-/** Próximo filtro no ciclo `aberta → fechada → todas → aberta` (tecla `f`). */
-function nextStatusFilter(current) {
-    if (current === 'open')
-        return 'closed';
-    if (current === 'closed')
-        return 'all';
-    return 'open';
-}
+/**
+ * Linhas ocupadas fora da lista NESTA tela (breadcrumb, cabeçalho, contador,
+ * rodapé, paddings). A moldura da aplicação não entra: o shell já entrega a
+ * altura sem ela (ver `TerminalHeightProvider` em `../app.tsx`).
+ */
+const LIST_OVERHEAD_ROWS = 9;
+/** Piso da janela da lista (terminais muito baixos). */
+const LIST_MIN_HEIGHT = 5;
 /**
  * Espaço fixo ocupado pela linha FORA do subject (M2-16, #39): ponteiro (2),
  * `#id ` (id + `#`/espaço), 1 espaço final após o subject, `[status]`
@@ -89,6 +86,20 @@ function fixedRowOverhead(idLength, statusLength) {
     return POINTER_WIDTH + ID_PREFIX_WIDTH + SUBJECT_TRAILING_SPACE + STATUS_BRACKETS_WIDTH + SCREEN_PADDING_X;
 }
 /** Uma linha da lista: `#id` em `theme.muted`, subject truncado ao orçamento de largura, badge de status. */
+/**
+ * Uma linha de RESULTADO DE BUSCA.
+ *
+ * Espelha o layout do {@link IssueRow} (id · assunto · status), mas a partir do
+ * item estruturado da busca — sem passar pelo Markdown do bundle, que traria as
+ * fences `<untrusted-content>` para a tela.
+ */
+function SearchResultRow({ item, selected }) {
+    const theme = useTheme();
+    const terminalWidth = useTerminalWidth();
+    const overhead = fixedRowOverhead(String(item.id).length, item.status.length);
+    const subjectBudget = Math.max(terminalWidth - overhead, MIN_SUBJECT_WIDTH);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: selected ? `${symbols.pointerSmall} ` : '  ' }), _jsxs(Text, { color: theme.muted, children: ["#", item.id, " "] }), _jsx(Text, { ...(selected ? { color: theme.primary } : {}), children: truncate(item.subject ?? '(sem assunto)', subjectBudget) }), _jsxs(Text, { color: statusColor(theme, item.status), children: [" [", item.status, "]"] }), _jsxs(Text, { color: theme.muted, children: [" ", item.assignee] })] }));
+}
 function IssueRow({ issue, selected }) {
     const theme = useTheme();
     const terminalWidth = useTerminalWidth();
@@ -100,28 +111,64 @@ function IssueRow({ issue, selected }) {
 export function HomeScreen() {
     const theme = useTheme();
     const { push } = useNavigation();
-    const { state, retry } = useMyIssues();
     // #31: índice preservado entre remounts + registro de qual issue foi aberta
     // (ver o JSDoc do módulo e de `./home-selection.js`).
     const { selectedIndex: persistedIndex, setSelectedIndex: persistIndex, setSelectedIssueId } = useHomeSelection();
     // --- Busca/filtros inline (M2-07, #30) ---
     const [isSearching, setIsSearching] = useState(false);
     const [query, setQuery] = useState('');
-    const [statusFilter, setStatusFilter] = useState('all');
-    const search = useIssueSearch(query, statusFilter);
+    // Default ABERTAS, não "todas": a home é a lista de trabalho. Com `all` o
+    // Redmine devolve o histórico inteiro (centenas de fechadas), que estoura a
+    // tela e enterra o que importa — era o default implícito antes do filtro
+    // chegar à lista (a API omite fechadas quando `status_id` não é enviado).
+    const [statusFilter, setStatusFilter] = useState('open');
+    // Seletor de status (#30, revisto): `f` abre uma LISTA em vez de ciclar às
+    // cegas — a instância tem uma dezena de status e o usuário não tem como
+    // adivinhar qual vem a seguir num ciclo.
+    const [isPickingStatus, setIsPickingStatus] = useState(false);
+    const statusOptions = useStatusOptions();
+    const [statusIndex, setStatusIndex] = useState(0);
+    // Seleção dentro dos RESULTADOS da busca: achar o chamado e não conseguir
+    // abrir é o mesmo que não ter achado. As setas não são texto, então navegam
+    // os resultados enquanto o campo continua recebendo letras.
+    const [searchIndex, setSearchIndex] = useState(0);
+    const searchIndexRef = useRef(searchIndex);
+    searchIndexRef.current = searchIndex;
+    // O filtro só vai para a BUSCA quando ela está aberta: com ela fechada, quem
+    // aplica o status é a lista (abaixo), e passar o filtro aqui dispararia um
+    // request cujo resultado nunca é renderizado — dois GETs por `f` em vez de um.
+    const search = useIssueSearch(query, isSearching ? statusFilter : 'all');
+    // O filtro rápido (`f`) precisa valer para a LISTA visível — antes ele só
+    // alimentava a busca, cujos resultados só aparecem com a busca ABERTA, então
+    // trocar o status não mudava nada na tela.
+    const { state, retry } = useMyIssues({ statusFilter });
     // Handler ESTÁVEL: `search.clear` é a única dependência mutável (mas já é
     // estável por construção, ver `use-issue-search.ts`) — fecha a busca e
     // restaura os 3 estados neutros de uma vez (query/filtro/hook de busca).
     const closeSearch = useCallback(() => {
         setIsSearching(false);
         setQuery('');
-        setStatusFilter('all');
+        // O filtro de status NÃO é resetado: desde que ele governa a LISTA (e não
+        // só a busca), zerá-lo aqui desfazia uma escolha que o usuário fez ANTES de
+        // abrir a busca — `f`, depois `/`, depois `Esc` devolvia [Todas].
         search.clear();
     }, [search.clear]);
     // Desvia o Esc GLOBAL (`../app.tsx`) enquanto a busca está aberta — sem
     // isso, Esc desempilharia a home inteira em vez de só fechar a busca.
+    // Resultado novo, cursor no topo: manter o índice de uma busca anterior faria
+    // o Enter abrir uma issue que não é a que está sob o cursor.
+    useEffect(() => {
+        setSearchIndex(0);
+        searchIndexRef.current = 0;
+    }, [query, statusFilter]);
     useEscapeInterceptor(isSearching, closeSearch);
+    const closeStatusPicker = useCallback(() => setIsPickingStatus(false), []);
+    useEscapeInterceptor(isPickingStatus, closeStatusPicker);
     const issues = state.status === 'loaded' ? state.issues : EMPTY_ISSUES;
+    // Altura da lista: o terminal menos a moldura, breadcrumb, cabeçalho, contador
+    // e rodapé. A lista rola DENTRO dessa janela em vez de empurrar o resto da
+    // tela para fora — e a mesma altura é o salto de uma página.
+    const listHeight = Math.max(LIST_MIN_HEIGHT, useTerminalHeight() - LIST_OVERHEAD_ROWS);
     // Handlers ESTÁVEIS (useCallback + refs, padrão do repo): identidade nova a
     // cada render des/re-subscreve o useInput e pode perder uma tecla rápida.
     const pushRef = useRef(push);
@@ -139,8 +186,13 @@ export function HomeScreen() {
     // última posição persistida (sobrevive ao unmount via home-selection).
     const { selectedIndex } = useListNavigation(issues.length, {
         onSelect: handleSelect,
-        isActive: !isSearching,
+        // Também desligada com o SELETOR DE STATUS aberto: o Ink entrega a tecla a
+        // todos os handlers, então o Enter que aplica o filtro abria a issue
+        // selecionada por baixo, ao mesmo tempo.
+        isActive: !isSearching && !isPickingStatus,
         initialIndex: persistedIndex,
+        // Uma página = uma tela da janela visível (ver ../list-window.ts).
+        pageSize: listHeight,
     });
     // Espelha `selectedIndex` ao contexto — a cópia externa sobrevive ao
     // unmount desta tela (ver ./home-selection.js).
@@ -155,6 +207,16 @@ export function HomeScreen() {
     statusRef.current = state.status;
     const isSearchingRef = useRef(isSearching);
     isSearchingRef.current = isSearching;
+    const isPickingStatusRef = useRef(isPickingStatus);
+    isPickingStatusRef.current = isPickingStatus;
+    const optionsRef = useRef(statusOptions);
+    optionsRef.current = statusOptions;
+    const statusIndexRef = useRef(statusIndex);
+    statusIndexRef.current = statusIndex;
+    const filterRef = useRef(statusFilter);
+    filterRef.current = statusFilter;
+    const searchItemsRef = useRef([]);
+    searchItemsRef.current = search.state.status === 'loaded' ? search.state.items : [];
     const handleRetryInput = useCallback((input) => {
         // M2-07 (#30): "r" digitado como texto de busca não deve disparar retry.
         if (isSearchingRef.current)
@@ -168,33 +230,99 @@ export function HomeScreen() {
         }
     }, []);
     useInput(handleRetryInput);
-    // "/" abre a busca; "f" cicla o filtro rápido de status (só com a busca já
-    // aberta). Reason: dentro do campo de texto, "f" digitado NÃO vira
-    // caractere da query — é a tecla de controle do filtro, trade-off
-    // Com a busca ABERTA, toda letra pertence à query (buscar "workflow" exige
-    // digitar "f") — o ciclo de filtro por "f" só vale com a busca fechada.
+    // "/" abre a busca; "f" abre o seletor de status. Ambos só FORA de campo de
+    // texto: com a busca aberta toda letra pertence à query (buscar "workflow"
+    // exige digitar "f") — ver ../hooks/use-typing-guard.ts.
     const handleSearchControlInput = useCallback((input) => {
-        if (input === '/' && !isSearchingRef.current) {
+        if (isPickingStatusRef.current)
+            return;
+        if (input === '/' && !isTyping()) {
             setIsSearching(true);
             return;
         }
-        if (input === 'f' && !isSearchingRef.current) {
-            setStatusFilter((current) => nextStatusFilter(current));
+        if (input === 'f' && !isTyping()) {
+            // Abre já posicionado no filtro atual, para o usuário ver onde está.
+            const start = Math.max(0, optionsRef.current.findIndex((o) => o.value === filterRef.current));
+            statusIndexRef.current = start;
+            setStatusIndex(start);
+            setIsPickingStatus(true);
         }
     }, []);
     useInput(handleSearchControlInput);
+    // Navegação do seletor de status.
+    const handleStatusPickerInput = useCallback((input, key) => {
+        if (!isPickingStatusRef.current)
+            return;
+        const total = optionsRef.current.length;
+        // A ref avança JUNTO com o estado: sincronizá-la só no render faz o
+        // `Enter` logo após um `j`/`k` ler o índice ANTIGO (o React ainda não
+        // commitou) e aplicar o filtro errado — mesmo defeito que o TextInput
+        // tinha ao perder teclas digitadas rápido.
+        const move = (delta) => {
+            const next = (statusIndexRef.current + delta + total) % total;
+            statusIndexRef.current = next;
+            setStatusIndex(next);
+        };
+        if (key.upArrow || input === 'k') {
+            move(-1);
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            move(1);
+            return;
+        }
+        if (key.return) {
+            const picked = optionsRef.current[statusIndexRef.current];
+            if (picked !== undefined)
+                setStatusFilter(picked.value);
+            setIsPickingStatus(false);
+        }
+    }, []);
+    useInput(handleStatusPickerInput);
+    // Navegação dos RESULTADOS da busca (setas + Enter). O campo de texto ignora
+    // setas e Enter, então não há disputa: as letras seguem indo para a query.
+    const handleSearchResultsInput = useCallback((_input, key) => {
+        const items = searchItemsRef.current;
+        if (!isSearchingRef.current || items.length === 0)
+            return;
+        if (key.upArrow) {
+            setSearchIndex((i) => (i - 1 + items.length) % items.length);
+            return;
+        }
+        if (key.downArrow) {
+            setSearchIndex((i) => (i + 1) % items.length);
+            return;
+        }
+        if (key.return) {
+            const picked = items[searchIndexRef.current];
+            if (picked !== undefined) {
+                setSelectedIssueIdRef.current(picked.id);
+                pushRef.current('issue-detail');
+            }
+        }
+    }, []);
+    useInput(handleSearchResultsInput);
     // #34 (M2-11): "t" abre o painel de jobs da sessão (`./jobs.js`) — só fora
     // da busca (mesma guarda de "/"/"f" acima: dentro do campo, "t" é texto da
     // query, não um atalho).
     const handleJobsShortcut = useCallback((input) => {
-        if (input === 't' && !isSearchingRef.current) {
+        if (input === 't' && !isTyping()) {
             pushRef.current('jobs');
         }
     }, []);
     useInput(handleJobsShortcut);
+    const listWindow_ = listWindow(issues.length, selectedIndex, listHeight);
     const searchState = search.state;
-    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: "Minhas issues" }), _jsxs(Text, { color: theme.muted, children: [" [", STATUS_FILTER_LABELS[statusFilter], "]"] }), !isSearching ? (_jsx(Text, { color: theme.muted, children: `  / busca ${glyphs.middleDot} f filtro ${glyphs.middleDot} t jobs` })) : null] }), isSearching ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: "Buscar: " }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: `digite para buscar${glyphs.ellipsis}`, isActive: isSearching }), _jsxs(Text, { color: theme.muted, children: [" [", STATUS_FILTER_LABELS[statusFilter], "]"] })] }), searchState.status === 'idle' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Digite para buscar ou pressione f para ciclar o filtro de status." }) })) : null, searchState.status === 'loading' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Spinner, {}), " Buscando..."] }) })) : null, searchState.status === 'loaded' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [searchState.degraded ? (_jsxs(Text, { color: theme.warning, children: [symbols.warning, " ", searchState.warnings.join(' ')] })) : null, _jsx(Text, { children: searchState.content })] })) : null, searchState.status === 'error-network' || searchState.status === 'error-forbidden' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", searchState.message] }) })) : null, searchState.status === 'auth-aborted' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: searchState.message }) })) : null] })) : (_jsxs(_Fragment, { children: [state.status === 'loading' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Spinner, {}), " Carregando issues..."] }) })) : null, state.status === 'empty' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "nenhuma issue atribu\u00EDda" }) })) : null, state.status === 'error-network' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " Falha ao carregar suas issues: ", state.message] }), _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "r" }), ' ', "para tentar de novo."] })] })) : null, state.status === 'error-forbidden' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", state.message] }), _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "r" }), ' ', "para tentar de novo."] })] })) : null, state.status === 'auth-aborted' ? (
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: "Minhas issues" }), _jsxs(Text, { color: statusFilterColor(theme, statusFilter, statusFilterLabel(statusOptions, statusFilter)), children: [' ', "[", statusFilterLabel(statusOptions, statusFilter), "]"] }), state.status === 'loaded' ? (_jsx(Text, { color: theme.muted, children: ` ${glyphs.middleDot} ${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}` })) : null, !isSearching && !isPickingStatus ? (_jsx(Text, { color: theme.muted, children: `  / busca ${glyphs.middleDot} f filtro ${glyphs.middleDot} t jobs` })) : null] }), isPickingStatus ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.primary, children: "Filtrar por status" }), statusOptions.map((option, i) => {
+                        const selected = i === statusIndex;
+                        const current = option.value === statusFilter;
+                        // Divisor entre os AGREGADOS do Redmine e os status da instância:
+                        // sem ele, "Fechadas" (agregado) e "Fechada" (status) ficam coladas
+                        // e parecem duplicata.
+                        const firstConcrete = typeof option.value === 'number' && typeof statusOptions[i - 1]?.value !== 'number';
+                        return (_jsxs(Box, { flexDirection: "column", children: [firstConcrete ? (_jsx(Text, { color: theme.border, children: `  ${'─'.repeat(18)}` })) : null, _jsxs(Box, { children: [_jsxs(Text, { color: selected ? theme.primary : theme.muted, children: [selected ? symbols.pointer : ' ', ' '] }), _jsx(Text, { color: statusFilterColor(theme, option.value, option.label), children: option.label }), current ? _jsxs(Text, { color: theme.muted, children: [" ", symbols.tick, " atual"] }) : null] })] }, String(option.value)));
+                    }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}/${glyphs.arrowDown}` }), " escolhe", ' ', glyphs.middleDot, " ", _jsx(Text, { color: theme.accent, children: "Enter" }), " aplica ", glyphs.middleDot, ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), " cancela"] }) })] })) : null, isSearching ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: "Buscar: " }), _jsx(TextInput, { value: query, onChange: setQuery, placeholder: `digite para buscar${glyphs.ellipsis}`, isActive: isSearching }), _jsxs(Text, { color: statusFilterColor(theme, statusFilter, statusFilterLabel(statusOptions, statusFilter)), children: [' ', "[", statusFilterLabel(statusOptions, statusFilter), "]"] })] }), searchState.status === 'idle' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Digite para buscar. Esc fecha a busca (o filtro de status \u00E9 o f com a busca fechada)." }) })) : null, searchState.status === 'loading' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Spinner, {}), " Buscando..."] }) })) : null, searchState.status === 'loaded' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [searchState.degraded ? (_jsxs(Text, { color: theme.warning, children: [symbols.warning, " ", searchState.warnings.join(' ')] })) : null, searchState.items.length === 0 ? (_jsx(Text, { color: theme.muted, children: "nenhuma issue encontrada" })) : (searchState.items.map((item, index) => (_jsx(SearchResultRow, { item: item, selected: index === searchIndex }, item.id))))] })) : null, searchState.status === 'error-network' || searchState.status === 'error-forbidden' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", searchState.message] }) })) : null, searchState.status === 'auth-aborted' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: searchState.message }) })) : null] })) : (_jsxs(_Fragment, { children: [state.status === 'loading' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Spinner, {}), " Carregando issues..."] }) })) : null, state.status === 'empty' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "nenhuma issue atribu\u00EDda" }) })) : null, state.status === 'error-network' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " Falha ao carregar suas issues: ", state.message] }), _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "r" }), ' ', "para tentar de novo."] })] })) : null, state.status === 'error-forbidden' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", state.message] }), _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "r" }), ' ', "para tentar de novo."] })] })) : null, state.status === 'auth-aborted' ? (
                     // Fix do review #120: estado NEUTRO (abandono consciente do re-login,
                     // Esc) — `theme.muted`, não `theme.danger` (não é uma falha).
-                    _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Text, { color: theme.muted, children: state.message }) })) : null, state.status === 'loaded' ? (_jsx(Box, { marginTop: 1, flexDirection: "column", children: state.issues.map((issue, index) => (_jsx(IssueRow, { issue: issue, selected: index === selectedIndex }, issue.id))) })) : null] })), _jsx(Box, { flexGrow: 1 }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: isSearching ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "fecha a busca,", ' ', _jsx(Text, { color: theme.accent, children: "f" }), ' ', "cicla o filtro."] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}/${glyphs.arrowDown}` }), ' ', "navega,", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "abre a issue,", ' ', _jsx(Text, { color: theme.accent, children: "/" }), ' ', "busca,", ' ', _jsx(Text, { color: theme.accent, children: "t" }), ' ', "jobs,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "volta."] })) }) })] }));
+                    _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Text, { color: theme.muted, children: state.message }) })) : null, state.status === 'loaded' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [state.issues.slice(listWindow_.start, listWindow_.end).map((issue, index) => (_jsx(IssueRow, { issue: issue, selected: listWindow_.start + index === selectedIndex }, issue.id))), state.issues.length > listWindow_.end - listWindow_.start ? (_jsxs(Text, { color: theme.muted, children: [`  ${listWindow_.start + 1}-${listWindow_.end} de ${state.issues.length}`, listWindow_.start > 0 ? ` ${glyphs.arrowUp}` : '', listWindow_.end < state.issues.length ? ` ${glyphs.arrowDown}` : ''] })) : null] })) : null] })), _jsx(Box, { flexGrow: 1 }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: isSearching ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "fecha a busca,", ' ', _jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}/${glyphs.arrowDown}` }), " navega os resultados,", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), " abre. O filtro \u00E9 o", ' ', _jsx(Text, { color: theme.accent, children: "f" }), " com a busca fechada."] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}/${glyphs.arrowDown}` }), ' ', "navega,", ' ', _jsx(Text, { color: theme.accent, children: `${glyphs.arrowLeft}/${glyphs.arrowRight}` }), ' ', "p\u00E1gina,", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "abre a issue,", ' ', _jsx(Text, { color: theme.accent, children: "/" }), ' ', "busca,", ' ', _jsx(Text, { color: theme.accent, children: "t" }), ' ', "jobs,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "volta."] })) }) })] }));
 }

package/dist/surfaces/tui/screens/issue-detail.js

@@ -47,23 +47,35 @@ import { useNavigation } from '../navigation.js';
 import { statusColor } from '../status-color.js';
 import { symbols } from '../symbols.js';
 import { useTheme } from '../theme.js';
+import { truncate } from '../truncate.js';
 import { wrapText } from '../wrap.js';
 import { useHomeSelection } from './home-selection.js';
 import { useLoadedIssue } from './loaded-issue-context.js';
 /**
- * Overhead de linhas FORA da viewport de descrição (breadcrumb + título + meta +
- * rodapé + paddings). A viewport cresce com o terminal: `altura - OVERHEAD`
- * (#190). Com a altura default dos testes (24) dá 10 — o valor histórico — então
- * os snapshots/asserções de rolagem seguem iguais; em terminal real a descrição
- * usa quase toda a tela e só rola quando passa DE VERDADE.
+ * Overhead de linhas FORA da viewport de descrição: breadcrumb, título, meta,
+ * rodapé e paddings DESTA tela.
+ *
+ * A moldura da aplicação não entra na conta: o shell já entrega a altura sem
+ * ela (`TerminalHeightProvider` em `../app.tsx`). Contar a menos faz o viewport
+ * pedir mais linhas do que cabem — o conteúdo transborda e o Ink, que redesenha
+ * por diff, sobrescreve linhas já impressas.
  */
 const CONTENT_OVERHEAD_ROWS = 14;
 /** Piso da viewport (terminais muito baixos). */
 const CONTENT_MIN_HEIGHT = 6;
-/** Colunas consumidas fora do texto: moldura da aplicação (2) + padding da tela (2). */
-const CONTENT_WIDTH_OVERHEAD = 4;
+/**
+ * Colunas consumidas fora do texto: moldura da aplicação (2), padding da tela
+ * (2) e uma folga de 2.
+ *
+ * A folga existe porque errar para MENOS é pior que perder duas colunas: uma
+ * linha larga demais seria truncada com `…` bem no fim (ou, sem o truncate,
+ * quebrada pelo Ink, furando a conta do viewport).
+ */
+const CONTENT_WIDTH_OVERHEAD = 6;
 /** Piso da largura de texto (terminais muito estreitos). */
 const CONTENT_MIN_WIDTH = 20;
+/** Corte de cada lado de uma alteração de journal (ver `buildContentRows`). */
+const DETAIL_VALUE_WIDTH = 40;
 /** Placeholder discreto para campos ausentes (assignee, autor/data de journal, old/new value). ASCII no Windows legado (#84). */
 const EMPTY_PLACEHOLDER = glyphs.emptyPlaceholder;
 /** Metadados fixos no topo: id/subject, status/prioridade, autor/responsável, datas. */
@@ -73,7 +85,7 @@ function IssueMeta({ issue, theme }) {
 /** Constrói a linha de um único anexo: nome (texto derivado, puro) · tamanho humanizado · content_type · badge de status. */
 function buildAttachmentRow(attachment, theme) {
     const status = deriveAttachmentExtractionStatus(attachment);
-    return (_jsxs(Text, { children: [attachment.filename, ' ', _jsxs(Text, { color: theme.muted, children: ["(", humanizeFileSize(attachment.filesize), " ", glyphs.middleDot, " ", attachment.content_type ?? EMPTY_PLACEHOLDER, ")"] }), ' ', _jsxs(Text, { color: attachmentStatusColor(theme, status), children: ["[", attachmentStatusLabel(status), "]"] })] }, `attachment-${attachment.id}`));
+    return (_jsxs(Text, { wrap: "truncate", children: [attachment.filename, ' ', _jsxs(Text, { color: theme.muted, children: ["(", humanizeFileSize(attachment.filesize), " ", glyphs.middleDot, " ", attachment.content_type ?? EMPTY_PLACEHOLDER, ")"] }), ' ', _jsxs(Text, { color: attachmentStatusColor(theme, status), children: ["[", attachmentStatusLabel(status), "]"] })] }, `attachment-${attachment.id}`));
 }
 /** Constrói as linhas da seção de anexos (após os journals): cabeçalho + 1 linha por anexo, ou "(nenhum)". */
 function buildAttachmentRows(issue, theme) {
@@ -102,7 +114,7 @@ function buildContentRows(issue, theme, width, lookups) {
         // linhas de tela, e um parágrafo longo (o caso comum de um chamado) faria o
         // Ink quebrá-lo sozinho em várias, estourando o viewport.
         wrapText(issue.description, width).forEach((line, index) => {
-            rows.push(_jsx(Text, { children: line.length > 0 ? line : ' ' }, `desc-${index}`));
+            rows.push(_jsx(Text, { wrap: "truncate", children: line.length > 0 ? line : ' ' }, `desc-${index}`));
         });
     }
     rows.push(_jsx(Text, { children: " " }, "desc-spacer"));
@@ -113,10 +125,10 @@ function buildContentRows(issue, theme, width, lookups) {
     else {
         // Cronológico: preserva a ordem já entregue por `getIssue`/`normalizeIssue`.
         issue.journals.forEach((journal) => {
-            rows.push(_jsxs(Text, { color: theme.muted, children: [journal.user?.name ?? EMPTY_PLACEHOLDER, " ", glyphs.middleDot, " ", journal.created_on] }, `journal-${journal.id}-head`));
+            rows.push(_jsxs(Text, { color: theme.muted, wrap: "truncate", children: [journal.user?.name ?? EMPTY_PLACEHOLDER, " ", glyphs.middleDot, " ", journal.created_on] }, `journal-${journal.id}-head`));
             if (journal.notes !== undefined && journal.notes !== '') {
                 wrapText(journal.notes, width).forEach((line, index) => {
-                    rows.push(_jsx(Text, { children: line }, `journal-${journal.id}-note-${index}`));
+                    rows.push(_jsx(Text, { wrap: "truncate", children: line }, `journal-${journal.id}-note-${index}`));
                 });
             }
             // Details resumidos: `campo: antigo → novo`, sempre em muted. Rótulos e
@@ -127,9 +139,15 @@ function buildContentRows(issue, theme, width, lookups) {
             // interface, não prompt.
             journal.details.forEach((detail, index) => {
                 const label = journalDetailLabel(detail, issue).text;
-                const from = journalDetailValue(detail, detail.old_value, issue, lookups)?.text ?? EMPTY_PLACEHOLDER;
-                const to = journalDetailValue(detail, detail.new_value, issue, lookups)?.text ?? EMPTY_PLACEHOLDER;
-                rows.push(_jsxs(Text, { color: theme.muted, children: ['  ', label, ": ", from, " ", symbols.arrowRight, " ", to] }, `journal-${journal.id}-detail-${index}`));
+                // Valores de campo TEXTO (descrição/assunto) trazem o conteúdo inteiro:
+                // editar a descrição guarda os dois textos completos na alteração. No
+                // histórico interessa O QUE mudou, não o texto todo — o valor completo
+                // está no bundle, para o LLM. Sem o corte, uma linha de centenas de
+                // caracteres fura a conta do viewport (1 item = 1 linha de tela).
+                const short = (part) => truncate(part, DETAIL_VALUE_WIDTH);
+                const from = short(journalDetailValue(detail, detail.old_value, issue, lookups)?.text ?? EMPTY_PLACEHOLDER);
+                const to = short(journalDetailValue(detail, detail.new_value, issue, lookups)?.text ?? EMPTY_PLACEHOLDER);
+                rows.push(_jsxs(Text, { color: theme.muted, wrap: "truncate", children: ['  ', label, ": ", from, " ", symbols.arrowRight, " ", to] }, `journal-${journal.id}-detail-${index}`));
             });
             rows.push(_jsx(Text, { children: " " }, `journal-${journal.id}-spacer`));
         });

package/dist/surfaces/tui/status-color.d.ts

@@ -19,3 +19,24 @@ import type { Theme } from './theme.js';
  * statusColor(theme, 'Fechado') // theme.success
  */
 export declare function statusColor(theme: Theme, statusName: string): string;
+/**
+ * Cor do badge do FILTRO rápido de status (`f` na home).
+ *
+ * Coerente com {@link statusColor}, que já pinta "fechado" de `success` e usa
+ * `primary` para o estado ativo — assim o badge do filtro e o badge de cada
+ * issue na lista não contam histórias diferentes sobre a mesma palavra.
+ *
+ * `all` fica em `muted` de propósito: é a ausência de filtro, e um badge
+ * chamativo aí competiria com o conteúdo. Qualquer estado FILTRADO puxa cor,
+ * que é o sinal de "tem filtro ligado".
+ *
+ * Contraste: todos são tokens do tema, calibrados por paleta (as claras usam
+ * cores saturadas, as escuras cores claras) — ver `./palettes.ts`.
+ *
+ * @param theme - Tema ativo.
+ * @param filter - Filtro corrente (agregado ou id de status da instância).
+ * @param label - Nome do status, quando o filtro é um id — permite casar a cor
+ *   com a que a lista usa para aquele mesmo status.
+ * @returns O token de cor do tema para o badge.
+ */
+export declare function statusFilterColor(theme: Theme, filter: 'open' | 'closed' | 'all' | number, label?: string): string;

package/dist/surfaces/tui/status-color.js

@@ -21,3 +21,36 @@ export function statusColor(theme, statusName) {
     }
     return theme.primary;
 }
+/**
+ * Cor do badge do FILTRO rápido de status (`f` na home).
+ *
+ * Coerente com {@link statusColor}, que já pinta "fechado" de `success` e usa
+ * `primary` para o estado ativo — assim o badge do filtro e o badge de cada
+ * issue na lista não contam histórias diferentes sobre a mesma palavra.
+ *
+ * `all` fica em `muted` de propósito: é a ausência de filtro, e um badge
+ * chamativo aí competiria com o conteúdo. Qualquer estado FILTRADO puxa cor,
+ * que é o sinal de "tem filtro ligado".
+ *
+ * Contraste: todos são tokens do tema, calibrados por paleta (as claras usam
+ * cores saturadas, as escuras cores claras) — ver `./palettes.ts`.
+ *
+ * @param theme - Tema ativo.
+ * @param filter - Filtro corrente (agregado ou id de status da instância).
+ * @param label - Nome do status, quando o filtro é um id — permite casar a cor
+ *   com a que a lista usa para aquele mesmo status.
+ * @returns O token de cor do tema para o badge.
+ */
+export function statusFilterColor(theme, filter, label) {
+    // Status ESPECÍFICO da instância: reusa a heurística por nome, para o badge
+    // do filtro e o badge de cada issue da lista combinarem ("Em Andamento" é
+    // warning nos dois lugares).
+    if (typeof filter === 'number') {
+        return label === undefined ? theme.primary : statusColor(theme, label);
+    }
+    if (filter === 'open')
+        return theme.primary;
+    if (filter === 'closed')
+        return theme.success;
+    return theme.muted;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redmine-context",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Consumidor de Redmine que entrega contexto completo de issues (texto + mídia extraída localmente) para qualquer LLM",
   "type": "module",
   "license": "MIT",