redmine-context 1.0.0 → 1.2.0

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/fetch-last-issues.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Orquestração "últimas issues" — tool MCP `get_last` e comando CLI `last`.
+ *
+ * Função fina do core reutilizável pelas superfícies (CLI e MCP): lista as
+ * issues mais recentes segundo uma ORDEM escolhida e devolve o BUNDLE COMPLETO
+ * de cada uma — o atalho de um passo para "me dá a última issue", sem exigir
+ * que o chamador descubra o id antes.
+ *
+ * Diferença para `fetchIssueSearch`: aquela responde "quais issues casam com
+ * estes filtros?" com uma lista compacta; esta responde "qual é a mais recente?"
+ * com o contexto inteiro (descrição, histórico, custom fields, anexos, relações).
+ *
+ * Ordem (parâmetro, com default):
+ *  - `updated`  → `sort=updated_on:desc` (DEFAULT — "no que se mexeu por último")
+ *  - `created`  → `sort=created_on:desc` ("o que entrou de novo", triagem)
+ *  - `priority` → `sort=priority:desc,updated_on:desc` ("o que é mais urgente",
+ *                 desempatando pela mais recente)
+ *
+ * ESCOPO: não passa `status_id`, então vale o default do Redmine em
+ * `/issues.json` — apenas issues ABERTAS. Quem precisa de fechadas/filtros usa
+ * `fetchIssueSearch`, que expõe `status_id` e os demais filtros estruturados.
+ *
+ * Mantém a fronteira do ADR-005: encapsula os módulos internos (`client`) e
+ * reutiliza `fetchIssueBundle` para o empacotamento, sem duplicar a pipeline.
+ */
+import type { CoreEvent } from './contract.js';
+import { type BundleFormat } from './fetch-issue-bundle.js';
+/** Critério de ordenação aceito por {@link fetchLastIssues}. */
+export type LastIssuesOrder = 'updated' | 'created' | 'priority';
+/** Ordem usada quando a superfície não informa `order`. */
+export declare const LAST_DEFAULT_ORDER: LastIssuesOrder;
+/** Quantidade default de issues: só a última. */
+export declare const LAST_DEFAULT_COUNT = 1;
+/**
+ * Teto de issues por chamada. Baixo de propósito: cada item é um bundle
+ * COMPLETO (histórico + anexos), então o custo em tokens/latência cresce rápido.
+ * Quem quer uma visão ampla usa `fetchIssueSearch` (lista compacta).
+ */
+export declare const LAST_MAX_COUNT = 5;
+/** Opções de {@link fetchLastIssues}: credenciais já resolvidas + ordem + formato. */
+export interface FetchLastIssuesOptions {
+    /** URL base da instância Redmine (ex.: `https://redmine.example`). */
+    baseUrl: string;
+    /** api_key já resolvida pela cascata da superfície. */
+    apiKey: string;
+    /** Critério de ordenação. Default: {@link LAST_DEFAULT_ORDER}. */
+    order?: LastIssuesOrder | undefined;
+    /**
+     * Quantas issues empacotar. Default: {@link LAST_DEFAULT_COUNT}. Valores fora
+     * de `[1, LAST_MAX_COUNT]` são reduzidos ao intervalo (sem erro).
+     */
+    count?: number | undefined;
+    /** Formato de saída de cada bundle. */
+    format: BundleFormat;
+    /** Versão da ferramenta gravada nos bundles. */
+    toolVersion: string;
+    /** Permite `http://` (sem TLS) com aviso ruidoso. Default: `false`. */
+    insecure?: boolean | undefined;
+    /** Extrai o texto (OCR) dos anexos e o embute nos bundles. Default: `false`. */
+    extractAttachments?: boolean | undefined;
+    /** Modo cache-first não-bloqueante (M4-11) repassado a `fetchIssueBundle`. */
+    cacheFirst?: boolean | undefined;
+    /** Raiz do cache em disco repassada a `fetchIssueBundle`. */
+    cacheDir?: string | undefined;
+}
+/** Resultado final: bundles das últimas issues, prontos para stdout/CallToolResult. */
+export interface LastIssuesResult {
+    /** Ids empacotados, na ordem de saída (mais recente primeiro). */
+    issueIds: number[];
+    /** Ordem efetivamente aplicada (útil quando a superfície omitiu `order`). */
+    order: LastIssuesOrder;
+    /** Formato efetivo do conteúdo. */
+    format: BundleFormat;
+    /**
+     * Bundles serializados. Em `md`, concatenados e separados por `---`. Em
+     * `json`, SEMPRE um array JSON válido (inclusive com um único item ou nenhum)
+     * — `get_last` devolve uma coleção, diferente de `fetchIssueBundle`, que
+     * devolve o bundle de uma issue.
+     */
+    content: string;
+}
+/**
+ * Lista as issues mais recentes e empacota o bundle completo de cada uma.
+ *
+ * @param options - Ver {@link FetchLastIssuesOptions}.
+ * @returns Sequência de {@link ProgressEvent} terminada por um {@link Result}
+ *   com o {@link LastIssuesResult}.
+ * @throws {RedmineAuthError} Em 401 (propagado do client).
+ * @throws {RedmineHttpError} Em outros status ≥ 400.
+ * @throws {Error} Em falha de rede/TLS/JSON inválido.
+ * @example
+ * for await (const event of fetchLastIssues({ ...creds, order: 'priority', format: 'md' })) {
+ *   if (event.kind === 'result') process.stdout.write(event.value.content);
+ * }
+ */
+export declare function fetchLastIssues(options: FetchLastIssuesOptions): AsyncIterable<CoreEvent<LastIssuesResult>>;

package/dist/fetch-last-issues.js

@@ -0,0 +1,120 @@
+/**
+ * Orquestração "últimas issues" — tool MCP `get_last` e comando CLI `last`.
+ *
+ * Função fina do core reutilizável pelas superfícies (CLI e MCP): lista as
+ * issues mais recentes segundo uma ORDEM escolhida e devolve o BUNDLE COMPLETO
+ * de cada uma — o atalho de um passo para "me dá a última issue", sem exigir
+ * que o chamador descubra o id antes.
+ *
+ * Diferença para `fetchIssueSearch`: aquela responde "quais issues casam com
+ * estes filtros?" com uma lista compacta; esta responde "qual é a mais recente?"
+ * com o contexto inteiro (descrição, histórico, custom fields, anexos, relações).
+ *
+ * Ordem (parâmetro, com default):
+ *  - `updated`  → `sort=updated_on:desc` (DEFAULT — "no que se mexeu por último")
+ *  - `created`  → `sort=created_on:desc` ("o que entrou de novo", triagem)
+ *  - `priority` → `sort=priority:desc,updated_on:desc` ("o que é mais urgente",
+ *                 desempatando pela mais recente)
+ *
+ * ESCOPO: não passa `status_id`, então vale o default do Redmine em
+ * `/issues.json` — apenas issues ABERTAS. Quem precisa de fechadas/filtros usa
+ * `fetchIssueSearch`, que expõe `status_id` e os demais filtros estruturados.
+ *
+ * Mantém a fronteira do ADR-005: encapsula os módulos internos (`client`) e
+ * reutiliza `fetchIssueBundle` para o empacotamento, sem duplicar a pipeline.
+ */
+import { createHttpClient, listIssues } from './client/index.js';
+import { fetchIssueBundle } from './fetch-issue-bundle.js';
+/** Ordem usada quando a superfície não informa `order`. */
+export const LAST_DEFAULT_ORDER = 'updated';
+/** Quantidade default de issues: só a última. */
+export const LAST_DEFAULT_COUNT = 1;
+/**
+ * Teto de issues por chamada. Baixo de propósito: cada item é um bundle
+ * COMPLETO (histórico + anexos), então o custo em tokens/latência cresce rápido.
+ * Quem quer uma visão ampla usa `fetchIssueSearch` (lista compacta).
+ */
+export const LAST_MAX_COUNT = 5;
+/** Tradução ordem → parâmetro `sort` do `/issues.json`. */
+const SORT_BY_ORDER = {
+    updated: 'updated_on:desc',
+    created: 'created_on:desc',
+    // Desempate explícito: mesma prioridade → a mexida mais recente vem primeiro.
+    priority: 'priority:desc,updated_on:desc',
+};
+/** Separador entre bundles Markdown consecutivos. */
+const MARKDOWN_SEPARATOR = '\n\n---\n\n';
+/** Conteúdo devolvido quando a instância não tem nenhuma issue aberta. */
+const EMPTY_MARKDOWN = '_(nenhuma issue encontrada)_';
+/** Helper: constrói um evento de progresso tipado. */
+function progress(stage, message) {
+    return { kind: 'progress', stage, message };
+}
+/** Reduz `count` ao intervalo `[1, LAST_MAX_COUNT]`. */
+function clampCount(count) {
+    if (count === undefined || !Number.isFinite(count))
+        return LAST_DEFAULT_COUNT;
+    return Math.min(Math.max(Math.trunc(count), 1), LAST_MAX_COUNT);
+}
+/**
+ * Lista as issues mais recentes e empacota o bundle completo de cada uma.
+ *
+ * @param options - Ver {@link FetchLastIssuesOptions}.
+ * @returns Sequência de {@link ProgressEvent} terminada por um {@link Result}
+ *   com o {@link LastIssuesResult}.
+ * @throws {RedmineAuthError} Em 401 (propagado do client).
+ * @throws {RedmineHttpError} Em outros status ≥ 400.
+ * @throws {Error} Em falha de rede/TLS/JSON inválido.
+ * @example
+ * for await (const event of fetchLastIssues({ ...creds, order: 'priority', format: 'md' })) {
+ *   if (event.kind === 'result') process.stdout.write(event.value.content);
+ * }
+ */
+export async function* fetchLastIssues(options) {
+    const { baseUrl, apiKey, format, toolVersion, insecure = false } = options;
+    const order = options.order ?? LAST_DEFAULT_ORDER;
+    const count = clampCount(options.count);
+    yield progress('connect', `Conectando a ${baseUrl}`);
+    const http = createHttpClient({ baseUrl, apiKey, insecure });
+    yield progress('list', `Listando as ${count} issue(s) mais recentes (ordem: ${order})`);
+    const filters = { sort: SORT_BY_ORDER[order] };
+    const payloads = await listIssues(http, { filters, pageSize: count, maxItems: count });
+    const issueIds = payloads.map((payload) => payload.id);
+    if (issueIds.length === 0) {
+        const empty = {
+            kind: 'result',
+            value: { issueIds, order, format, content: format === 'json' ? '[]' : EMPTY_MARKDOWN },
+        };
+        yield empty;
+        return;
+    }
+    // Reuso da pipeline de bundle (uma issue por vez), repassando o progresso de
+    // cada uma para a superfície — nada de duplicar get → normalize → bundle.
+    const contents = [];
+    for (const issueId of issueIds) {
+        for await (const event of fetchIssueBundle({
+            baseUrl,
+            apiKey,
+            issueId,
+            format,
+            toolVersion,
+            insecure,
+            extractAttachments: options.extractAttachments ?? false,
+            ...(options.cacheFirst !== undefined ? { cacheFirst: options.cacheFirst } : {}),
+            ...(options.cacheDir !== undefined ? { cacheDir: options.cacheDir } : {}),
+        })) {
+            if (event.kind === 'progress') {
+                yield event;
+            }
+            else {
+                contents.push(event.value.content);
+            }
+        }
+    }
+    const content = format === 'json' ? `[${contents.join(',')}]` : contents.join(MARKDOWN_SEPARATOR);
+    const result = {
+        kind: 'result',
+        value: { issueIds, order, format, content },
+    };
+    yield result;
+}

package/dist/index.d.ts

@@ -1,17 +1,22 @@
 export declare const TOOL_NAME = "redmine-context";
-export declare const TOOL_VERSION = "1.0.0";
+/** Versão da ferramenta, sempre igual à `version` do package.json. */
+export declare const TOOL_VERSION: string;
 export * from './contract.js';
 export { fetchIssueBundle, type BundleFormat, type FetchIssueBundleOptions, type IssueBundleResult, } from './fetch-issue-bundle.js';
 export { extractIssueAttachments, type ExtractIssueAttachmentsOptions, } from './extract-issue-attachments.js';
 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';
 export { listIssues, type ListIssuesOptions, type RedmineIssuePayload } from './client/index.js';
 export { getIssue } from './client/index.js';
 export { normalizeIssue } from './normalize/index.js';
 export { buildMarkdownBundle, buildJsonBundle, fenceBlock, type MarkdownBundleMeta, type JsonBundle, type JsonBundleEnvelope, type JsonBundleMeta, type JsonBundleSource, } from './bundle/index.js';
+export { collectUsers, journalDetailLabel, journalDetailValue, type DetailLookups, type DetailPart, } from './bundle/journal-detail.js';
+export { fetchEnumerations, clearEnumerationsCache, type RedmineEnumerations, } from './client/index.js';
 export { RedmineHttpError, RedmineAuthError, RedmineForbiddenError, RedmineNotFoundError, } from './client/index.js';
 export { loginWithPassword, validateApiKey, RedmineLoginError, type LoginOptions, type LoginResult, type ValidateApiKeyOptions, } from './config/index.js';
 export { createCredentialCascade, resolveApiKey, describeCredentialSource, normalizeInstanceUrl, CredentialStoreError, type CredentialCascadeOptions, type CredentialSourceKind, } from './config/index.js';

package/dist/index.js

@@ -1,6 +1,14 @@
+import { createRequire } from 'node:module';
 export const TOOL_NAME = 'redmine-context';
-// Manter em sincronia com package.json (validado por tests/packaging/smoke-pack.test.ts).
-export const TOOL_VERSION = '1.0.0';
+// A versão é LIDA do package.json, nunca copiada à mão: o bump do changesets
+// altera só o manifesto, e uma constante literal aqui ficava para trás a cada
+// release (foi o que aconteceu no 1.0.0, com o gate de empacotamento reprovando).
+// `../package.json` resolve tanto de `src/` (dev/testes) quanto de `dist/` (pacote
+// publicado — o npm sempre inclui o manifesto no tarball).
+const requireJson = createRequire(import.meta.url);
+const pkg = requireJson('../package.json');
+/** Versão da ferramenta, sempre igual à `version` do package.json. */
+export const TOOL_VERSION = pkg.version;
 // Superfície pública do core: contrato de tipos + padrão de progresso (ADR-005).
 // As superfícies devem consumir o core somente por aqui / por ./contract.js.
 export * from './contract.js';
@@ -22,6 +30,10 @@ export { extractIssueAttachmentsCacheFirst, makeQueueBackgroundExtractor, proces
 export { fetchIssueSearch, SEARCH_DEFAULT_LIMIT, } from './fetch-issue-search.js';
 // Primitiva full-text `/search.json` (usada pela orquestração acima).
 export { searchIssues } from './client/index.js';
+// Orquestração "últimas issues" (tool MCP `get_last` e comando CLI `last`):
+// ordena por updated/created/priority e devolve o BUNDLE COMPLETO das mais
+// recentes — atalho de um passo, sem exigir o id antes.
+export { fetchLastIssues, LAST_DEFAULT_ORDER, LAST_DEFAULT_COUNT, LAST_MAX_COUNT, } from './fetch-last-issues.js';
 // Client HTTP base (auth por api_key + retry) — usado por telas que precisam
 // montar suas próprias chamadas ao core sem uma orquestração pronta (ex.: a
 // home da TUI, #29, que lista "minhas issues" via `listIssues` abaixo).
@@ -46,6 +58,14 @@ export { normalizeIssue } from './normalize/index.js';
 // #31), então gravar o bundle não precisa refazer a busca+normalização via
 // `fetchIssueBundle` — só empacotar o que já foi carregado.
 export { buildMarkdownBundle, buildJsonBundle, fenceBlock, } from './bundle/index.js';
+// Semântica dos journal details (rótulos legíveis + ids resolvidos) — UMA fonte
+// de verdade para o bundle Markdown e para a tela de detalhe da TUI, que antes
+// mostrava os ids crus (`status_id: 12 → 7`). Cada superfície aplica sua própria
+// política de confiança sobre as partes devolvidas.
+export { collectUsers, journalDetailLabel, journalDetailValue, } from './bundle/journal-detail.js';
+// Enumerações da instância (`id → nome`) — resolvem os ids HISTÓRICOS que o
+// estado atual da issue não cobre. Memoizado por instância; degrada em silêncio.
+export { fetchEnumerations, clearEnumerationsCache, } from './client/index.js';
 // Erros HTTP tipados — usados pelas superfícies para mapear exit codes (ADR-005).
 export { RedmineHttpError, RedmineAuthError, RedmineForbiddenError, RedmineNotFoundError, } from './client/index.js';
 // Login por senha (M1-07) e cascata de credenciais (M1-08) para as superfícies.

package/dist/normalize/issue.js

@@ -13,6 +13,22 @@
  */
 import { normalizeChildren, normalizeCustomFields, normalizeParent, normalizeRelations, normalizeWatchers, } from './collections.js';
 import { asArray, asNumber, asRecord, asString, asStringOrNull, isDefined, normalizeRef, } from './helpers.js';
+/**
+ * Normaliza quebras de linha para `\n`.
+ *
+ * O Redmine devolve texto com CRLF (o editor web grava assim). Um `\r` que
+ * sobrevive até a renderização é ATIVO, não decorativo: no terminal ele devolve
+ * o cursor ao início da linha e o texto seguinte SOBRESCREVE o anterior — foi o
+ * que comia o começo dos parágrafos na tela de detalhe ("Solicita-se que a
+ * área..." aparecia como "que a área..."). Em Markdown/JSON o `\r` também é
+ * ruído que não representa nada do conteúdo.
+ *
+ * @param text - Texto derivado do Redmine (descrição, nota de journal).
+ * @returns O mesmo texto com `\r\n` e `\r` isolados convertidos em `\n`.
+ */
+function normalizeNewlines(text) {
+    return text.replace(/\r\n?/g, '\n');
+}
 /** Ref placeholder para campos obrigatórios do contrato ausentes no payload. */
 // Congelado: instância compartilhada entre todas as issues degradadas — mutação
 // acidental corromperia o placeholder globalmente (modo strict lança).
@@ -62,7 +78,7 @@ function normalizeJournal(value) {
     // notes só é significativa quando não-vazia (Redmine devolve "" em journal de detalhe).
     const notes = asString(record.notes);
     if (notes !== undefined && notes !== '')
-        journal.notes = notes;
+        journal.notes = normalizeNewlines(notes);
     const user = normalizeRef(record.user);
     if (user !== undefined)
         journal.user = user;
@@ -139,11 +155,24 @@ export function normalizeIssue(payload, fieldFormats) {
         children: normalizeChildren(record.children),
     };
     const description = asString(record.description);
-    if (description !== undefined && description !== '')
-        issue.description = description;
+    if (description !== undefined && description !== '') {
+        issue.description = normalizeNewlines(description);
+    }
     const assignedTo = normalizeRef(record.assigned_to);
     if (assignedTo !== undefined)
         issue.assigned_to = assignedTo;
+    // Planejamento (contrato: done_ratio/start_date/due_date). O Redmine devolve
+    // `null` nas datas não preenchidas — `asString` já as descarta, mantendo o
+    // campo AUSENTE em vez de vazio, como o resto do normalize.
+    const doneRatio = asNumber(record.done_ratio);
+    if (doneRatio !== undefined)
+        issue.done_ratio = doneRatio;
+    const startDate = asString(record.start_date);
+    if (startDate !== undefined && startDate !== '')
+        issue.start_date = startDate;
+    const dueDate = asString(record.due_date);
+    if (dueDate !== undefined && dueDate !== '')
+        issue.due_date = dueDate;
     const parent = normalizeParent(record.parent);
     if (parent !== undefined)
         issue.parent = parent;

package/dist/surfaces/cli/commands.d.ts

@@ -39,6 +39,23 @@ export declare function exitCodeForError(error: unknown): number;
  * @returns Exit code do processo.
  */
 export declare function runIssue(parsed: ParsedArgs, deps: RunDeps): Promise<number>;
+/**
+ * Comando `last`: emite o bundle completo das issues mais recentes, sem exigir
+ * que o usuário saiba o id.
+ *
+ * A ordem é um parâmetro com default: `updated` (mexida mais recente), `created`
+ * (entrada mais recente) ou `priority` (mais urgente, desempatando pela mais
+ * recente). Considera apenas issues ABERTAS — o `search_issues` do MCP é a
+ * superfície com filtros (projeto, status, responsável).
+ *
+ * Sem `--out`: o conteúdo (potencialmente vários bundles) vai para stdout, e o
+ * progresso para stderr, como no `issue`.
+ *
+ * @param parsed - Argumentos parseados (`--order`, `--count`, `--json`, `--extract`).
+ * @param deps - Dependências injetáveis (I/O, env).
+ * @returns Exit code do processo.
+ */
+export declare function runLast(parsed: ParsedArgs, deps: RunDeps): Promise<number>;
 /**
  * Comando `doctor`: diagnostica os binários de mídia (hoje o `tesseract`) e
  * imprime um relatório em TEXTO PURO no stdout. Degrada naturalmente em

package/dist/surfaces/cli/commands.js

@@ -55,20 +55,17 @@ function stringFlag(parsed, name) {
     return typeof value === 'string' ? value : undefined;
 }
 /**
- * Comando `issue <id>`: resolve credencial pela cascata, empacota e emite o
- * bundle (stdout ou `--out <dir>`), com progresso em stderr.
+ * Resolve instância e credencial para os comandos que falam com o Redmine.
  *
- * @param parsed - Argumentos parseados (posicional `<id>` + flags).
- * @param deps - Dependências injetáveis (I/O, env).
- * @returns Exit code do processo.
+ * Ponto ÚNICO dessa cascata na CLI: `issue` e `last` a compartilham para que a
+ * regra de segurança do `allowEnvFallback` (#187) não possa divergir entre
+ * comandos.
+ *
+ * @param parsed - Argumentos parseados (usa `--url` e `--insecure`).
+ * @param deps - Dependências injetáveis (I/O, env, settings).
+ * @returns A instância resolvida, ou o exit code a devolver em caso de falha.
  */
-export async function runIssue(parsed, deps) {
-    const idRaw = parsed.positionals[1];
-    const issueId = Number(idRaw);
-    if (idRaw === undefined || !Number.isInteger(issueId) || issueId <= 0) {
-        deps.stderr(`Id de issue inválido: ${idRaw ?? '(ausente)'}. Uso: redmine-context issue <id>\n`);
-        return EXIT.GENERIC;
-    }
+async function resolveInstanceAndKey(parsed, deps) {
     // Instância: --url → REDMINE_URL → URL persistida no login (#187).
     const persistedUrl = deps.settings ? await deps.settings.getInstanceUrl() : undefined;
     const resolved = core.resolveInstanceUrl({
@@ -102,6 +99,27 @@ export async function runIssue(parsed, deps) {
         deps.stderr(`Nenhuma credencial encontrada para ${baseUrl}.\nRode: redmine-context login\n`);
         return EXIT.AUTH;
     }
+    return { baseUrl, apiKey, insecure };
+}
+/**
+ * Comando `issue <id>`: resolve credencial pela cascata, empacota e emite o
+ * bundle (stdout ou `--out <dir>`), com progresso em stderr.
+ *
+ * @param parsed - Argumentos parseados (posicional `<id>` + flags).
+ * @param deps - Dependências injetáveis (I/O, env).
+ * @returns Exit code do processo.
+ */
+export async function runIssue(parsed, deps) {
+    const idRaw = parsed.positionals[1];
+    const issueId = Number(idRaw);
+    if (idRaw === undefined || !Number.isInteger(issueId) || issueId <= 0) {
+        deps.stderr(`Id de issue inválido: ${idRaw ?? '(ausente)'}. Uso: redmine-context issue <id>\n`);
+        return EXIT.GENERIC;
+    }
+    const instance = await resolveInstanceAndKey(parsed, deps);
+    if (typeof instance === 'number')
+        return instance;
+    const { baseUrl, apiKey, insecure } = instance;
     const format = parsed.flags.get('json') === true ? 'json' : 'md';
     const outDir = stringFlag(parsed, 'out');
     // --extract liga a extração de texto dos anexos (OCR) no bundle (M3-13).
@@ -145,6 +163,81 @@ export async function runIssue(parsed, deps) {
         return exitCodeForError(error);
     }
 }
+/** Ordens aceitas pelo `--order` do comando `last` (espelha `LastIssuesOrder`). */
+const LAST_ORDERS = ['updated', 'created', 'priority'];
+/** Type guard de `--order` contra {@link LAST_ORDERS}. */
+function isLastOrder(value) {
+    return LAST_ORDERS.includes(value);
+}
+/**
+ * Comando `last`: emite o bundle completo das issues mais recentes, sem exigir
+ * que o usuário saiba o id.
+ *
+ * A ordem é um parâmetro com default: `updated` (mexida mais recente), `created`
+ * (entrada mais recente) ou `priority` (mais urgente, desempatando pela mais
+ * recente). Considera apenas issues ABERTAS — o `search_issues` do MCP é a
+ * superfície com filtros (projeto, status, responsável).
+ *
+ * Sem `--out`: o conteúdo (potencialmente vários bundles) vai para stdout, e o
+ * progresso para stderr, como no `issue`.
+ *
+ * @param parsed - Argumentos parseados (`--order`, `--count`, `--json`, `--extract`).
+ * @param deps - Dependências injetáveis (I/O, env).
+ * @returns Exit code do processo.
+ */
+export async function runLast(parsed, deps) {
+    const orderRaw = stringFlag(parsed, 'order');
+    if (orderRaw !== undefined && !isLastOrder(orderRaw)) {
+        deps.stderr(`Ordem inválida: ${orderRaw}. Use: ${LAST_ORDERS.join(', ')}.\n`);
+        return EXIT.GENERIC;
+    }
+    const countRaw = stringFlag(parsed, 'count');
+    let count;
+    if (countRaw !== undefined) {
+        const value = Number(countRaw);
+        if (!Number.isInteger(value) || value < 1 || value > core.LAST_MAX_COUNT) {
+            deps.stderr(`Valor inválido para --count: ${countRaw}. Use um inteiro entre 1 e ${core.LAST_MAX_COUNT}.\n`);
+            return EXIT.GENERIC;
+        }
+        count = value;
+    }
+    const instance = await resolveInstanceAndKey(parsed, deps);
+    if (typeof instance === 'number')
+        return instance;
+    const { baseUrl, apiKey, insecure } = instance;
+    const format = parsed.flags.get('json') === true ? 'json' : 'md';
+    const extractAttachments = parsed.flags.get('extract') === true;
+    try {
+        let content;
+        for await (const event of core.fetchLastIssues({
+            baseUrl,
+            apiKey,
+            format,
+            order: orderRaw,
+            count,
+            toolVersion: core.TOOL_VERSION,
+            insecure,
+            extractAttachments,
+        })) {
+            if (event.kind === 'progress') {
+                deps.stderr(`... ${event.message}\n`);
+            }
+            else {
+                content = event.value.content;
+            }
+        }
+        if (content === undefined) {
+            deps.stderr('Operação não produziu um bundle.\n');
+            return EXIT.GENERIC;
+        }
+        deps.stdout(content);
+        return 0;
+    }
+    catch (error) {
+        deps.stderr(`${messageOf(error)}\n`);
+        return exitCodeForError(error);
+    }
+}
 /**
  * Comando `doctor`: diagnostica os binários de mídia (hoje o `tesseract`) e
  * imprime um relatório em TEXTO PURO no stdout. Degrada naturalmente em

package/dist/surfaces/cli/main.js

@@ -11,19 +11,20 @@
  */
 import { realpathSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
-import { runDoctor, runIssue, runLogin } from './commands.js';
+import { runDoctor, runIssue, runLast, runLogin } from './commands.js';
 import { createPromptSession } from './prompts.js';
 import { shouldRenderTui } from './tty.js';
 import { TOOL_VERSION, defaultSettingsStore } from '../../index.js';
 import { runStdioServer } from '../mcp/server.js';
 import { runTui } from '../tui/index.js';
 /** Flags que consomem o próximo token como valor (as demais são booleanas). */
-const VALUE_FLAGS = new Set(['out', 'url', 'api-key']);
+const VALUE_FLAGS = new Set(['out', 'url', 'api-key', 'order', 'count']);
 /** Texto do `--help` — limpo, sem referências a ferramentas de IA. */
 const HELP = `redmine-context — contexto completo de issues do Redmine para LLMs
 
 Uso:
   redmine-context issue <id> [opções]
+  redmine-context last [opções]
   redmine-context login [opções]
   redmine-context doctor
   redmine-context mcp
@@ -41,6 +42,21 @@ Comando issue:
   --url <url>       URL da instância Redmine (ou defina REDMINE_URL).
   --insecure        Permite http:// sem TLS (não recomendado).
 
+Comando last:
+  Imprime o bundle completo das issues mais recentes, sem precisar do id.
+  Considera apenas issues abertas.
+
+  --order <ordem>   updated (padrão) | created | priority
+                    updated  = mexida mais recente
+                    created  = entrada mais recente (triagem)
+                    priority = mais urgente, desempatando pela mais recente
+  --count <n>       Quantas issues empacotar (padrão 1, teto 5). Cada item é um
+                    bundle completo.
+  --json            Emite os bundles como um array JSON.
+  --extract         Extrai o texto (OCR) dos anexos de imagem.
+  --url <url>       URL da instância Redmine (ou defina REDMINE_URL).
+  --insecure        Permite http:// sem TLS (não recomendado).
+
 Comando login:
   Autentica por usuário/senha e salva a api_key para a instância.
   Em contas com 2FA, cole a api_key quando solicitado (ou use --api-key).
@@ -57,7 +73,7 @@ Comando doctor:
 
 Comando mcp:
   Sobe um servidor MCP (stdio) expondo as tools read-only get_issue_context,
-  search_issues e get_attachment_text. A instância vem de REDMINE_URL +
+  search_issues, get_attachment_text e get_last. A instância vem de REDMINE_URL +
   credencial da cascata (REDMINE_API_KEY); nenhuma tool aceita URL/host
   arbitrário. Logs vão para stderr.
 
@@ -180,6 +196,9 @@ async function dispatch(argv, deps) {
     if (command === 'issue') {
         return runIssue(parsed, deps);
     }
+    if (command === 'last') {
+        return runLast(parsed, deps);
+    }
     if (command === 'login') {
         return runLogin(parsed, deps);
     }