redmine-context 1.0.0 → 1.2.0

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."] })) }) })] }));
 }