redmine-context 1.0.0 → 1.2.0

package/dist/surfaces/tui/banner.js

@@ -0,0 +1,93 @@
+/**
+ * Arte ASCII do banner da tela de abertura (#190 — pacote estético).
+ *
+ * As três variantes são CONSTANTES, não geradas em runtime: o texto é sempre
+ * `redmine-context`, então trazer uma dependência de fontes (figlet/cfonts) para
+ * recalcular a mesma string a cada boot não se paga — custaria peso no pacote e
+ * tempo de start. Para regenerar (fonte `ANSI Shadow` / `Small` do figlet):
+ *
+ *   npx figlet -f "ANSI Shadow" redmine-context
+ *   npx figlet -f "ANSI Shadow" redmine ; npx figlet -f "ANSI Shadow" context
+ *   npx figlet -f Small redmine-context
+ *
+ * A seleção é PURA ({@link selectBanner}) e depende de dois sinais que a TUI já
+ * possui: a largura do terminal (`../hooks/use-terminal-width.js`) e o suporte a
+ * Unicode (`../glyphs.js`) — o mesmo sinal que degrada os frames braille do
+ * spinner no terminal legado do Windows (M5-09, #84). Sem essa degradação, os
+ * blocos `█`/`╗` do ANSI Shadow virariam mojibake.
+ */
+const WIDE_LINES = [
+    '██████╗ ███████╗██████╗ ███╗   ███╗██╗███╗   ██╗███████╗     ██████╗ ██████╗ ███╗   ██╗████████╗███████╗██╗  ██╗████████╗',
+    '██╔══██╗██╔════╝██╔══██╗████╗ ████║██║████╗  ██║██╔════╝    ██╔════╝██╔═══██╗████╗  ██║╚══██╔══╝██╔════╝╚██╗██╔╝╚══██╔══╝',
+    '██████╔╝█████╗  ██║  ██║██╔████╔██║██║██╔██╗ ██║█████╗█████╗██║     ██║   ██║██╔██╗ ██║   ██║   █████╗   ╚███╔╝    ██║   ',
+    '██╔══██╗██╔══╝  ██║  ██║██║╚██╔╝██║██║██║╚██╗██║██╔══╝╚════╝██║     ██║   ██║██║╚██╗██║   ██║   ██╔══╝   ██╔██╗    ██║   ',
+    '██║  ██║███████╗██████╔╝██║ ╚═╝ ██║██║██║ ╚████║███████╗    ╚██████╗╚██████╔╝██║ ╚████║   ██║   ███████╗██╔╝ ██╗   ██║   ',
+    '╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚══════╝     ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝   ╚═╝   ',
+];
+const STACKED_LINES = [
+    '██████╗ ███████╗██████╗ ███╗   ███╗██╗███╗   ██╗███████╗',
+    '██╔══██╗██╔════╝██╔══██╗████╗ ████║██║████╗  ██║██╔════╝',
+    '██████╔╝█████╗  ██║  ██║██╔████╔██║██║██╔██╗ ██║█████╗  ',
+    '██╔══██╗██╔══╝  ██║  ██║██║╚██╔╝██║██║██║╚██╗██║██╔══╝  ',
+    '██║  ██║███████╗██████╔╝██║ ╚═╝ ██║██║██║ ╚████║███████╗',
+    '╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚══════╝',
+    ' ██████╗ ██████╗ ███╗   ██╗████████╗███████╗██╗  ██╗████████╗',
+    '██╔════╝██╔═══██╗████╗  ██║╚══██╔══╝██╔════╝╚██╗██╔╝╚══██╔══╝',
+    '██║     ██║   ██║██╔██╗ ██║   ██║   █████╗   ╚███╔╝    ██║   ',
+    '██║     ██║   ██║██║╚██╗██║   ██║   ██╔══╝   ██╔██╗    ██║   ',
+    '╚██████╗╚██████╔╝██║ ╚████║   ██║   ███████╗██╔╝ ██╗   ██║   ',
+    ' ╚═════╝ ╚═════╝ ╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═╝   ╚═╝   ',
+];
+const ASCII_LINES = [
+    '             _       _                         _           _   ',
+    '  _ _ ___ __| |_ __ (_)_ _  ___ ___ __ ___ _ _| |_ _____ _| |_ ',
+    ' | \'_/ -_) _` | \'  \\| | \' \\/ -_)___/ _/ _ \\ \' \\  _/ -_) \\ /  _|',
+    ' |_| \\___\\__,_|_|_|_|_|_||_\\___|   \\__\\___/_||_\\__\\___/_\\_\\\\__|',
+];
+/** Largura mínima (colunas) exigida por cada variante. */
+const MIN_WIDTH = {
+    wide: 121,
+    stacked: 61,
+    ascii: 63,
+};
+/** Linhas de cada variante, na ordem de renderização. */
+const LINES = {
+    wide: WIDE_LINES,
+    stacked: STACKED_LINES,
+    ascii: ASCII_LINES,
+};
+/**
+ * Escolhe a variante do banner para o terminal atual.
+ *
+ * Ordem de preferência, sempre respeitando a largura disponível:
+ * `wide` (uma linha, Unicode) → `stacked` (duas linhas, Unicode) → `ascii`
+ * (ASCII puro) → `plain` (sem arte; a tela cai no nome em texto).
+ *
+ * @param width - Colunas disponíveis (ver `useTerminalWidth`).
+ * @param unicode - `true` quando o terminal renderiza os blocos do ANSI Shadow.
+ * @returns A variante a renderizar.
+ * @example
+ * selectBanner(140, true) // 'wide'
+ * selectBanner(80, true)  // 'stacked' (não cabe a wide)
+ * selectBanner(80, false) // 'ascii'  (sem Unicode)
+ */
+export function selectBanner(width, unicode) {
+    if (unicode) {
+        if (width >= MIN_WIDTH.wide)
+            return 'wide';
+        if (width >= MIN_WIDTH.stacked)
+            return 'stacked';
+    }
+    if (width >= MIN_WIDTH.ascii)
+        return 'ascii';
+    return 'plain';
+}
+/**
+ * Linhas da variante escolhida.
+ *
+ * @param variant - Variante de {@link selectBanner}.
+ * @returns As linhas da arte; vazio para `plain`.
+ */
+export function bannerLines(variant) {
+    return variant === 'plain' ? [] : LINES[variant];
+}

package/dist/surfaces/tui/components/gauge.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converte a fração de progresso em número de células preenchidas.
+ *
+ * Exportada para teste: as bordas (0, 1 e valores fora da faixa) são o que mais
+ * erra em barra de progresso.
+ *
+ * @param progress - Fração entre 0 e 1; valores fora da faixa são fixados nela.
+ * @param width - Largura total da barra em células.
+ * @returns Quantidade de células preenchidas, sempre em `[0, width]`.
+ */
+export declare function filledCells(progress: number, width: number): number;
+/**
+ * Renderiza uma barra de progresso com percentual.
+ *
+ * @param props.progress - Fração entre 0 e 1.
+ * @param props.color - Cor do preenchimento (token do tema).
+ * @param props.trackColor - Cor do trilho vazio (normalmente `theme.muted`).
+ * @param props.width - Largura em células. Default: {@link DEFAULT_WIDTH}.
+ * @example
+ * <Gauge progress={0.4} color={theme.primary} trackColor={theme.muted} />
+ */
+export declare function Gauge({ progress, color, trackColor, width, }: {
+    progress: number;
+    color: string;
+    trackColor: string;
+    width?: number;
+}): import("react").JSX.Element;

package/dist/surfaces/tui/components/gauge.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Barra de progresso (#190 — pacote estético).
+ *
+ * O `Job` do registro (`../job-registry.tsx`) já carregava `progress`, mas a
+ * tela de jobs só mostrava o status textual — a extração de mídia (OCR, ffmpeg,
+ * whisper) roda em background e o usuário não tinha noção de quanto falta. Este
+ * componente dá essa leitura.
+ *
+ * Glyphs vêm de `../glyphs.js` (`gaugeFull`/`gaugeEmpty`), então a barra degrada
+ * para `#`/`-` no terminal legado do Windows pelo MESMO sinal que já degrada os
+ * frames braille do spinner — sem caractere Unicode solto na tela.
+ *
+ * Cores vêm do tema (varredura `no-hardcoded-colors`): o preenchimento usa a cor
+ * recebida e o trilho usa `muted`, o que preserva contraste tanto nas paletas
+ * escuras quanto nas claras.
+ */
+import { Text } from 'ink';
+import { glyphs } from '../glyphs.js';
+/** Largura default da barra, em células. */
+const DEFAULT_WIDTH = 20;
+/**
+ * Converte a fração de progresso em número de células preenchidas.
+ *
+ * Exportada para teste: as bordas (0, 1 e valores fora da faixa) são o que mais
+ * erra em barra de progresso.
+ *
+ * @param progress - Fração entre 0 e 1; valores fora da faixa são fixados nela.
+ * @param width - Largura total da barra em células.
+ * @returns Quantidade de células preenchidas, sempre em `[0, width]`.
+ */
+export function filledCells(progress, width) {
+    if (!Number.isFinite(progress) || progress <= 0)
+        return 0;
+    if (progress >= 1)
+        return width;
+    return Math.min(width, Math.max(0, Math.round(progress * width)));
+}
+/**
+ * Renderiza uma barra de progresso com percentual.
+ *
+ * @param props.progress - Fração entre 0 e 1.
+ * @param props.color - Cor do preenchimento (token do tema).
+ * @param props.trackColor - Cor do trilho vazio (normalmente `theme.muted`).
+ * @param props.width - Largura em células. Default: {@link DEFAULT_WIDTH}.
+ * @example
+ * <Gauge progress={0.4} color={theme.primary} trackColor={theme.muted} />
+ */
+export function Gauge({ progress, color, trackColor, width = DEFAULT_WIDTH, }) {
+    const filled = filledCells(progress, width);
+    const percent = Math.round(Math.min(1, Math.max(0, progress)) * 100);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: color, children: glyphs.gaugeFull.repeat(filled) }), _jsx(Text, { color: trackColor, children: glyphs.gaugeEmpty.repeat(width - filled) }), _jsxs(Text, { color: trackColor, children: [" ", String(percent).padStart(3), "%"] })] }));
+}

package/dist/surfaces/tui/components/gradient-banner.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Renderiza linhas de arte ASCII com gradiente por coluna.
+ *
+ * @param props.lines - Linhas da arte (mesma fonte, alturas iguais).
+ * @param props.colors - Ramp de cores (hex) da paleta ativa; vazia ⇒ sem cor.
+ * @returns O banner, ou `null` quando não há linhas (variante `plain`).
+ * @example
+ * <GradientBanner lines={bannerLines('wide')} colors={theme.gradient ?? []} />
+ */
+export declare function GradientBanner({ lines, colors, }: {
+    lines: readonly string[];
+    colors: readonly string[];
+}): import("react").JSX.Element | null;

package/dist/surfaces/tui/components/gradient-banner.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Banner multi-linha com gradiente HORIZONTAL (#190 — pacote estético).
+ *
+ * Diferença para {@link GradientText}: aquele interpola por CARACTERE ao longo de
+ * uma string única — passar uma arte multi-linha a ele faria a ramp escorrer
+ * pelas quebras de linha e sair na diagonal, com cada linha começando numa cor
+ * diferente. Aqui a ramp é calculada UMA vez pela largura da arte e aplicada por
+ * COLUNA: a coluna `x` tem a mesma cor em todas as linhas, que é o que faz o
+ * logo ler como um objeto só.
+ *
+ * Reutiliza `rampColors` de `./gradient-text.js` — a interpolação é a mesma, só
+ * muda o eixo. Nenhuma cor literal aqui: a ramp vem do tema (varredura
+ * `no-hardcoded-colors`).
+ *
+ * Contraste: as paradas de cor são as da paleta ativa (claras e escuras já vêm
+ * calibradas em `../palettes.ts`), então o banner herda o contraste do tema em
+ * vez de impor um seu. Sem `bold` — o atributo derruba o fg truecolor em alguns
+ * terminais (ver a nota em `./gradient-text.tsx`).
+ */
+import { Box, Text } from 'ink';
+import { rampColors } from './gradient-text.js';
+/**
+ * Renderiza linhas de arte ASCII com gradiente por coluna.
+ *
+ * @param props.lines - Linhas da arte (mesma fonte, alturas iguais).
+ * @param props.colors - Ramp de cores (hex) da paleta ativa; vazia ⇒ sem cor.
+ * @returns O banner, ou `null` quando não há linhas (variante `plain`).
+ * @example
+ * <GradientBanner lines={bannerLines('wide')} colors={theme.gradient ?? []} />
+ */
+export function GradientBanner({ lines, colors, }) {
+    if (lines.length === 0)
+        return null;
+    const width = Math.max(...lines.map((line) => [...line].length));
+    const ramp = rampColors(colors, width);
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, row) => (_jsx(Text, { children: [...line].map((ch, col) => (
+            // Espaço não recebe cor: evita pintar o "fundo" da arte e mantém o
+            // banner legível também em paleta clara.
+            _jsx(Text, { ...(ch === ' ' || ramp.length === 0 ? {} : { color: ramp[col] }), children: ch }, col))) }, row))) }));
+}

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,10 +27,18 @@ 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`). */
     readonly spinnerFrames: readonly string[];
+    /** Célula PREENCHIDA da barra de progresso (`components/gauge.tsx`). */
+    readonly gaugeFull: string;
+    /** Célula VAZIA da barra de progresso (`components/gauge.tsx`). */
+    readonly gaugeEmpty: string;
 }
 /** Glyphs Unicode — terminais modernos (Windows Terminal, iTerm, etc.). */
 export declare const UNICODE_GLYPHS: Glyphs;

package/dist/surfaces/tui/glyphs.js

@@ -58,8 +58,12 @@ export const UNICODE_GLYPHS = {
     emptyPlaceholder: '—',
     arrowUp: '↑',
     arrowDown: '↓',
+    arrowLeft: '←',
+    arrowRight: '→',
     maskBullet: '•',
     spinnerFrames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    gaugeFull: '█',
+    gaugeEmpty: '░',
 };
 /** Fallback ASCII puro — terminal legado do Windows (sem mojibake). */
 export const ASCII_GLYPHS = {
@@ -68,8 +72,12 @@ export const ASCII_GLYPHS = {
     emptyPlaceholder: '-',
     arrowUp: '^',
     arrowDown: 'v',
+    arrowLeft: '<',
+    arrowRight: '>',
     maskBullet: '*',
     spinnerFrames: ['|', '/', '-', '\\'],
+    gaugeFull: '#',
+    gaugeEmpty: '-',
 };
 /**
  * Escolhe o conjunto de glyphs conforme o suporte a Unicode.

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

@@ -1,4 +1,4 @@
-import { createHttpClient, getIssue, normalizeIssue, resolveApiKey, type Issue } from '../../../index.js';
+import { createHttpClient, fetchEnumerations, getIssue, normalizeIssue, resolveApiKey, type DetailLookups, type Issue } from '../../../index.js';
 /**
  * Estado da busca de detalhe de issue, consumido por
  * `../screens/issue-detail.tsx`. `no-selection` cobre o caso defensivo de a
@@ -14,6 +14,7 @@ export type IssueDetailState = {
 } | {
     status: 'loaded';
     issue: Issue;
+    lookups: DetailLookups;
 } | {
     status: 'error-network';
     message: string;
@@ -39,6 +40,11 @@ export interface UseIssueDetailOptions {
     getIssue?: typeof getIssue;
     /** Normaliza o payload bruto no modelo `Issue`; default `normalizeIssue` do core. */
     normalizeIssue?: typeof normalizeIssue;
+    /**
+     * Busca as enumerações da instância (`id → nome`); default
+     * `fetchEnumerations` do core. Injetável para os testes não tocarem a rede.
+     */
+    fetchEnumerations?: typeof fetchEnumerations;
 }
 /** Valor retornado pelo hook. */
 export interface UseIssueDetailResult {

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

@@ -27,7 +27,7 @@
  * `auth-aborted` (neutro, não um erro), com `retry` disponível.
  */
 import { useCallback, useEffect, useState } from 'react';
-import { createHttpClient, getIssue, normalizeIssue, resolveApiKey, RedmineForbiddenError, RedmineNotFoundError, } from '../../../index.js';
+import { createHttpClient, collectUsers, fetchEnumerations, getIssue, normalizeIssue, resolveApiKey, RedmineForbiddenError, RedmineNotFoundError, } from '../../../index.js';
 import { useEnvFallbackAllowed } from '../instance.js';
 import { ReAuthAbortedError, useAuthGuard } from './use-auth-guard.js';
 /** Lê `REDMINE_URL` do ambiente, tratando string vazia como ausente (mesma convenção do doctor/home). */
@@ -52,6 +52,7 @@ export function useIssueDetail(issueId, options = {}) {
     const buildClient = options.createHttpClient ?? createHttpClient;
     const fetchIssue = options.getIssue ?? getIssue;
     const normalize = options.normalizeIssue ?? normalizeIssue;
+    const loadEnumerations = options.fetchEnumerations ?? fetchEnumerations;
     // Mandatório (M2-13, #36): ver o JSDoc do módulo.
     const { guard } = useAuthGuard();
     // SEGURANÇA (#187): origem config (URL persistida) → sem env-key instance-agnóstica.
@@ -93,7 +94,19 @@ export function useIssueDetail(issueId, options = {}) {
                 const payload = await guard(() => fetchIssue(http, issueId));
                 if (cancelled)
                     return;
-                setState({ status: 'loaded', issue: normalize(payload) });
+                const issue = normalize(payload);
+                // Dicionários `id → nome` para o histórico: sem eles a tela mostra
+                // `Status: #12 → Atribuída (#7)` — metade ilegível. `fetchEnumerations`
+                // é memoizado por instância (uma vez por sessão da TUI) e degrada em
+                // silêncio; os usuários saem do próprio payload, sem rede.
+                const enums = issue.journals.length > 0 ? await loadEnumerations(http, instanceUrl) : undefined;
+                if (cancelled)
+                    return;
+                setState({
+                    status: 'loaded',
+                    issue,
+                    lookups: { ...(enums ?? {}), user: collectUsers(issue) },
+                });
             }
             catch (cause) {
                 if (cancelled)

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;