@payconductor/houndsman 0.5.0 → 0.6.0

package/src/harness/investigation/rule-analyzer.ts

@@ -0,0 +1,178 @@
+/**
+ * Análise determinística de regras (`RuleAnalyzer`).
+ *
+ * Transforma uma regra textual em polaridade, categoria, keywords, sinais e
+ * checks. É a base do planner e do `rule_signals` tool. Um analyzer por IA pode
+ * complementar regras ambíguas, mas o resultado continua validado.
+ */
+
+import { POLARITY_WORDS, polarityOf, type RuleIntent } from "../../core/rule-text";
+import type { Rule, Severity } from "../../core/types";
+import {
+	DefaultRuleCheckFactory,
+	HeuristicRuleSignalExtractor,
+	type RuleCheck,
+	type RuleCheckFactory,
+	type RuleSignal,
+	type RuleSignalExtractor,
+} from "./rule-signals";
+
+export { polarityOf, type RuleIntent } from "../../core/rule-text";
+
+/** Categoria da regra. */
+export type RuleCategory =
+	| "architecture"
+	| "security"
+	| "data"
+	| "tests"
+	| "performance"
+	| "style"
+	| "other";
+
+/** Regra analisada (entrada do planner). */
+export type RuleAnalysis = {
+	rule: string;
+	severity: Severity;
+	intent: RuleIntent;
+	category: RuleCategory;
+	keywords: string[];
+	signals: RuleSignal[];
+	checks: RuleCheck[];
+	confidence: "high" | "medium" | "low";
+};
+
+const GENERIC_STOPWORDS = [
+	"para",
+	"pelo",
+	"pela",
+	"como",
+	"ser",
+	"que",
+	"com",
+	"sem",
+	"uma",
+	"dos",
+	"das",
+	"nos",
+	"nas",
+	"por",
+	"usar",
+	"todo",
+	"toda",
+	"quando",
+	"onde",
+] as const;
+
+/** Stopwords + palavras de polaridade (fonte única em `core/rule-text`). */
+const STOPWORDS = new Set<string>([...GENERIC_STOPWORDS, ...POLARITY_WORDS]);
+
+const CATEGORY_HINTS: readonly [RuleCategory, readonly string[]][] = [
+	[
+		"security",
+		[
+			"segredo",
+			"senha",
+			"token",
+			"auth",
+			"sanit",
+			"injection",
+			"sql",
+			"cripto",
+			"permiss",
+		],
+	],
+	["data", ["banco", "database", "db", "query", "migration", "schema", "transa"]],
+	["tests", ["teste", "test", "spec", "cobertura", "mock", "fixture"]],
+	[
+		"performance",
+		["cache", "performance", "latência", "latencia", "n+1", "índice", "indice"],
+	],
+	[
+		"architecture",
+		[
+			"camada",
+			"arquitetura",
+			"rota",
+			"controller",
+			"service",
+			"domínio",
+			"dominio",
+			"depend",
+		],
+	],
+	["style", ["nome", "formata", "lint", "coment", "estilo", "padrão", "padrao"]],
+];
+
+/** Analisador determinístico. */
+export class RuleAnalyzer {
+	private readonly extractor: RuleSignalExtractor;
+	private readonly checks: RuleCheckFactory;
+
+	constructor(
+		extractor: RuleSignalExtractor = new HeuristicRuleSignalExtractor(),
+		checks: RuleCheckFactory = new DefaultRuleCheckFactory(),
+	) {
+		this.extractor = extractor;
+		this.checks = checks;
+	}
+
+	/** Analisa todas as regras (ordem estável). */
+	analyze(rules: readonly Rule[]): RuleAnalysis[] {
+		return rules.map((rule) => this.analyzeRule(rule));
+	}
+
+	/** Analisa uma regra. */
+	analyzeRule(rule: Rule): RuleAnalysis {
+		const intent = polarityOf(rule.text);
+		const signals = this.extractor.extract(rule);
+		const category = categoryOf(rule.text, signals);
+		const confidence = confidenceOf(rule, signals);
+		return {
+			rule: rule.text,
+			severity: rule.severity,
+			intent,
+			category,
+			keywords: keywordsOf(rule.text),
+			signals,
+			checks: this.checks.create(rule, signals),
+			confidence,
+		};
+	}
+}
+
+/** Categoria inferida por keywords e sinais. */
+export function categoryOf(text: string, signals: readonly RuleSignal[]): RuleCategory {
+	const haystack =
+		`${text} ${signals.map((signal) => signal.value).join(" ")}`.toLowerCase();
+	for (const [category, hints] of CATEGORY_HINTS) {
+		if (hints.some((hint) => haystack.includes(hint))) return category;
+	}
+	return "other";
+}
+
+/** Keywords normalizadas (sem stopwords, limitadas). */
+export function keywordsOf(text: string): string[] {
+	const words = text
+		.toLowerCase()
+		.replace(/[^\p{L}\p{N}+\-/]+/gu, " ")
+		.split(/\s+/)
+		.filter((word) => word.length >= 4 && !STOPWORDS.has(word));
+	return [...new Set(words)].slice(0, 12);
+}
+
+/** Confiança da análise (hints explícitos valem mais que heurística). */
+function confidenceOf(
+	rule: Rule,
+	signals: readonly RuleSignal[],
+): RuleAnalysis["confidence"] {
+	const hints = rule.hints;
+	const hintCount =
+		(hints?.symbols?.length ?? 0) +
+		(hints?.imports?.length ?? 0) +
+		(hints?.decorators?.length ?? 0) +
+		(hints?.paths?.length ?? 0) +
+		(hints?.checks?.length ?? 0);
+	if (hintCount > 0) return "high";
+	if (signals.length > 0) return "medium";
+	return "low";
+}

package/src/harness/investigation/rule-signals.ts

@@ -0,0 +1,110 @@
+/**
+ * Extração determinística de sinais de uma regra em linguagem natural.
+ *
+ * Cada extrator é substituível (`RuleSignalExtractor`); o default usa `hints`
+ * + termos em backticks + identificadores. Nunca chama IA.
+ */
+
+import type { Rule } from "../../core/types";
+
+/** Sinal concreto sugerido por uma regra. */
+export type RuleSignal = {
+	kind: "symbol" | "import" | "decorator" | "path" | "grep" | "ast";
+	value: string;
+	rationale?: string;
+};
+
+/** Contrato de um extrator de sinais. */
+export interface RuleSignalExtractor {
+	extract(rule: Rule): RuleSignal[];
+}
+
+/** Extrai sinais dos `hints`, backticks e identificadores em CamelCase. */
+export class HeuristicRuleSignalExtractor implements RuleSignalExtractor {
+	extract(rule: Rule): RuleSignal[] {
+		const signals: RuleSignal[] = [];
+		const seen = new Set<string>();
+		const push = (kind: RuleSignal["kind"], value: string, rationale?: string) => {
+			const key = `${kind}:${value}`;
+			if (!value.trim() || seen.has(key)) return;
+			seen.add(key);
+			signals.push({ kind, value, ...(rationale ? { rationale } : {}) });
+		};
+
+		const hints = rule.hints ?? {};
+		for (const item of hints.symbols ?? []) push("symbol", item, "hint");
+		for (const item of hints.imports ?? []) push("import", item, "hint");
+		for (const item of hints.decorators ?? []) push("decorator", item, "hint");
+		for (const item of hints.paths ?? []) push("path", item, "hint");
+
+		for (const match of rule.text.matchAll(/`([^`]{2,80})`/g)) {
+			const value = match[1]?.trim();
+			if (value) push(classifyLiteral(value), value, "texto da regra");
+		}
+		for (const match of rule.text.matchAll(/\b([A-Z][a-zA-Z0-9]{2,})\b/g)) {
+			push("symbol", match[1] ?? "", "identificador");
+		}
+		return signals;
+	}
+}
+
+/** Classifica um literal em backticks (import, path, símbolo). */
+function classifyLiteral(value: string): RuleSignal["kind"] {
+	if (value.startsWith("@") || value.includes("/")) {
+		return value.includes("/") && !value.includes("@") ? "path" : "import";
+	}
+	if (/^[A-Z][a-zA-Z0-9]*$/.test(value)) return "symbol";
+	return "grep";
+}
+
+/** Gera checks concretos para uma regra. */
+export interface RuleCheckFactory {
+	create(rule: Rule, signals: readonly RuleSignal[]): RuleCheck[];
+}
+
+/** Check que prova/refuta uma regra usando uma tool. */
+export type RuleCheck = {
+	id: string;
+	description: string;
+	tool: string;
+	input: unknown;
+	required: boolean;
+};
+
+/** Checks default por presença de sinais. */
+export class DefaultRuleCheckFactory implements RuleCheckFactory {
+	create(rule: Rule, signals: readonly RuleSignal[]): RuleCheck[] {
+		const checks: RuleCheck[] = [];
+		const explicit = rule.hints?.checks ?? [];
+		explicit.forEach((tool, index) => {
+			checks.push({
+				id: `${index}:${tool}`,
+				description: `Executar ${tool} para a regra`,
+				tool,
+				input: {},
+				required: true,
+			});
+		});
+		const symbols = signals.filter((signal) => signal.kind === "symbol");
+		if (symbols.length > 0 && explicit.length === 0) {
+			checks.push({
+				id: "symbol-context",
+				description: `Inspecionar o contexto de ${symbols[0]?.value}`,
+				tool: "symbol_context",
+				input: { symbol: symbols[0]?.value },
+				required: false,
+			});
+		}
+		const imports = signals.filter((signal) => signal.kind === "import");
+		if (imports.length > 0) {
+			checks.push({
+				id: "find-references",
+				description: `Procurar usos de ${imports[0]?.value}`,
+				tool: "find_references",
+				input: { symbol: imports[0]?.value },
+				required: false,
+			});
+		}
+		return checks;
+	}
+}

package/src/harness/prompts/agent-schemas.ts

@@ -0,0 +1,57 @@
+/**
+ * Schemas das saídas intermediárias da máquina de estados.
+ */
+
+import { z } from "zod";
+import { SeveritySchema } from "../../core/ai/schemas";
+
+/** ORIENT: hipóteses iniciais. */
+export const OrientOutputSchema = z.object({
+	hypotheses: z.array(z.string()).max(8).default([]),
+});
+export type OrientOutput = z.infer<typeof OrientOutputSchema>;
+
+/** PLAN: tarefas escolhidas do plano determinístico. */
+export const PlanOutputSchema = z.object({
+	taskIds: z.array(z.string()).default([]),
+});
+export type PlanOutput = z.infer<typeof PlanOutputSchema>;
+
+/** INVESTIGATE: drafts + cobertura. */
+export const FindingDraftSchema = z.object({
+	rule: z.string(),
+	severity: SeveritySchema,
+	file: z.string(),
+	line: z.number().int().positive().optional(),
+	message: z.string(),
+	action: z.string(),
+	evidenceIds: z.array(z.string()).default([]),
+	confidence: z.number().min(0).max(1).default(0.6),
+});
+
+export const CoverageOutputSchema = z.object({
+	rule: z.string(),
+	status: z.enum(["checked", "not_applicable", "skipped"]),
+	reason: z.string().optional(),
+});
+
+export const InvestigateOutputSchema = z.object({
+	findingDrafts: z.array(FindingDraftSchema).default([]),
+	coverage: z.array(CoverageOutputSchema).default([]),
+});
+export type InvestigateOutput = z.infer<typeof InvestigateOutputSchema>;
+
+/** VERIFY: decisão do crítico (opcional; determinístico por default). */
+export const CriticOutputSchema = z.object({
+	decisions: z
+		.array(
+			z.object({
+				rule: z.string(),
+				file: z.string(),
+				verdict: z.enum(["keep", "drop", "downgrade"]),
+				reason: z.string().optional(),
+			}),
+		)
+		.default([]),
+});
+export type CriticOutput = z.infer<typeof CriticOutputSchema>;

package/src/harness/prompts/reviewer-prompt-builder.ts

@@ -0,0 +1,101 @@
+/**
+ * System prompt do revisor (harness nativo).
+ *
+ * Ordem estável: papel, regras, escopo, procedimento, contrato e segurança.
+ * Descrições de tools vêm do `ToolRegistry` (nunca hardcoded).
+ */
+
+import { buildSystem } from "../../core/ai/prompts/base";
+import { OUTPUT_FORMAT_PATH } from "../../core/paths";
+import type { AgentContext } from "../agent/agent-context";
+
+/** System prompt do agente. */
+export function buildReviewerSystem(
+	context: AgentContext,
+	toolDescriptions: string,
+): string {
+	const rules = context.watchdog.rules.map(
+		(rule) => `- [${rule.severity}] ${rule.text}`,
+	);
+	return buildSystem(
+		`Você é um revisor sênior de ${context.projectName}, especialista no domínio '${context.watchdog.name}'.`,
+		[
+			"Você investiga o diff com tools read-only e só conclui com evidência.",
+			"Nunca invente achado, arquivo, linha ou regra.",
+			"Toda regra deve terminar com cobertura (checked, not_applicable ou skipped).",
+			"blocking/attention exigem evidência rastreável.",
+			context.watchdog.definition.allowEmergentFindings
+				? "Findings emergentes de lógica/domínio usam `Lógica:`/`Domínio:`, exigem evidência e severidade máxima attention."
+				: "Todo finding deve citar uma regra existente do watchdog.",
+			"",
+			"## Regras do watchdog",
+			...rules,
+			"",
+			"## Escopo",
+			context.watchdog.scope,
+			"",
+			"## Procedimento",
+			"1. ORIENT — entenda regras, diff, AST e impacto.",
+			"2. PLAN — escolha as tarefas priorizadas.",
+			"3. INVESTIGATE — use tools para coletar evidências; refute hipóteses.",
+			"4. VERIFY — cada draft precisa de evidência válida.",
+			"5. CONCLUDE — produza o relatório.",
+			"",
+			"## Tools disponíveis",
+			toolDescriptions,
+			"",
+			"## Contrato de saída",
+			`O relatório final segue ${OUTPUT_FORMAT_PATH}.`,
+			"Em INVESTIGATE produza JSON com findingDrafts e coverage.",
+		],
+	);
+}
+
+/** Prompt do usuário (contexto compactado; nunca arquivo inteiro). */
+export function buildReviewerUser(context: AgentContext): string {
+	const lines = [
+		`Branch: ${context.branch}`,
+		`Watchdog: ${context.watchdog.name} (${context.watchdog.id})`,
+		`Arquivos do domínio (${context.files.length}):`,
+		...context.files.slice(0, 40).map((file) => `- ${file}`),
+	];
+	if (context.overflow.length > 0) {
+		lines.push(
+			"",
+			`Fora do orçamento (${context.overflow.length}) — NÃO ler; registrar em skipped:`,
+			...context.overflow.slice(0, 40).map((file) => `- ${file}`),
+		);
+	}
+	if (context.deleted.length > 0) {
+		lines.push("", "Deletados:", ...context.deleted.map((file) => `- ${file}`));
+	}
+	if (context.context) {
+		lines.push("", "## Contexto da PR");
+		if (context.context.objective)
+			lines.push(`Objetivo: ${context.context.objective}`);
+		if (context.context.motivation)
+			lines.push(`Motivação: ${context.context.motivation}`);
+		for (const item of context.context.changeSummary ?? []) lines.push(`- ${item}`);
+	}
+	if (context.ast.size > 0) {
+		lines.push("", "## Estrutura (AST)");
+		for (const [file, analysis] of context.ast) {
+			if (!analysis.delta) continue;
+			const delta = analysis.delta;
+			lines.push(
+				`- ${file}: +${delta.addedSymbols.length} −${delta.removedSymbols.length} ~${delta.modifiedSymbols.length}`,
+			);
+		}
+	}
+	if (context.impact && context.impact.affectedFiles.length > 0) {
+		lines.push(
+			"",
+			`Impacto: ${context.impact.affectedFiles.length} arquivo(s) importam o diff.`,
+			...context.impact.affectedFiles.slice(0, 20).map((file) => `- ${file}`),
+		);
+	}
+	if (context.docs.length > 0) {
+		lines.push("", "Docs de contexto:", ...context.docs.map((doc) => `- ${doc}`));
+	}
+	return lines.join("\n");
+}

package/src/harness/prompts/states/conclude-prompt.ts

@@ -0,0 +1,16 @@
+/**
+ * Prompt do estado CONCLUDE (documentação do contrato).
+ *
+ * A conclusão do harness é determinística (bits de evidência/coverage); este
+ * texto existe para manter o contrato explícito e servir a um futuro modo
+ * "conclude por modelo".
+ */
+
+/** Instruções de conclusão. */
+export function concludePrompt(): string {
+	return [
+		"Conclua com base apenas nos drafts sobreviventes ao VERIFY.",
+		"Não adicione achados novos.",
+		"Toda regra sem achado deve constar como coverage checked/not_applicable/skipped.",
+	].join("\n");
+}

package/src/harness/prompts/states/investigate-prompt.ts

@@ -0,0 +1,37 @@
+/**
+ * Prompt do estado INVESTIGATE — o coração da coleta de evidências.
+ */
+
+import type { AgentContext } from "../../agent/agent-context";
+import type { InvestigationTask } from "../../investigation/investigation-task";
+
+/** Instruções do estado de investigação. */
+export function investigatePrompt(
+	context: AgentContext,
+	tasks: readonly InvestigationTask[],
+): string {
+	const lines = [
+		"## Tarefas priorizadas",
+		...tasks.map(
+			(task, index) =>
+				`${index + 1}. [${task.severity}] ${task.rule} — arquivos: ${task.files.slice(0, 8).join(", ") || "(domínio)"}`,
+		),
+		"",
+		"## Como investigar",
+		"- Use file_outline/symbol_context/find_references em vez de ler arquivos inteiros.",
+		"- Registre evidência para cada draft (evidenceIds).",
+		"- Prefira não concluir quando faltar evidência: use coverage 'skipped' com motivo.",
+		"- Não cite arquivos fora do domínio/impacto.",
+		"",
+		"## Formato",
+		"Produza JSON: { findingDrafts: [...], coverage: [{ rule, status, reason? }] }.",
+	];
+	if (context.files.length > 0) {
+		lines.push(
+			"",
+			"## Arquivos do domínio",
+			...context.files.slice(0, 40).map((file) => `- ${file}`),
+		);
+	}
+	return lines.join("\n");
+}

package/src/harness/prompts/states/orient-prompt.ts

@@ -0,0 +1,15 @@
+/**
+ * Prompt do estado ORIENT.
+ */
+
+import type { AgentContext } from "../../agent/agent-context";
+
+/** Pede hipóteses iniciais (sem achados). */
+export function orientPrompt(context: AgentContext): string {
+	return [
+		`Oriente a revisão do watchdog '${context.watchdog.name}'.`,
+		"Liste hipóteses de violação que precisam ser investigadas.",
+		"Use as regras e o delta AST fornecidos. Não emita findings neste estado.",
+		"Produza JSON com `hypotheses`.",
+	].join("\n");
+}

package/src/harness/prompts/states/verify-prompt.ts

@@ -0,0 +1,22 @@
+/**
+ * Prompt do estado VERIFY (crítica refutadora).
+ *
+ * O crítico determinístico é o default; este prompt fica disponível para um
+ * crítico por IA, que deve tentar **derrubar** cada draft.
+ */
+
+import type { FindingDraft } from "../../investigation/evidence";
+
+/** Prompt de refutação. */
+export function verifyPrompt(drafts: readonly FindingDraft[]): string {
+	return [
+		"Tente refutar cada draft abaixo.",
+		"Responda `keep` apenas se a evidência sustenta a violação.",
+		"Use `downgrade` quando a evidência sustenta algo mais leve.",
+		...drafts.map(
+			(draft) =>
+				`- ${draft.rule} · ${draft.file}:${draft.line ?? "?"} · confiança ${draft.confidence}`,
+		),
+		"Produza JSON com `decisions`.",
+	].join("\n");
+}

package/src/harness/tools/agent-tool.ts

@@ -0,0 +1,102 @@
+/**
+ * Contrato das tools do harness nativo.
+ *
+ * Cada tool declara metadados (categoria, capabilities, custo, cache, limite) e
+ * um schema Zod. É read-only por construção: não executa shell arbitrário, não
+ * escreve arquivos e não acessa a rede.
+ */
+
+import type { ZodType, ZodTypeAny } from "zod";
+import type { AstService } from "../../core/ast/service";
+import type { DiffSource } from "../../core/diff-source";
+import type { Watchdog } from "../../core/domain/watchdog";
+import type { AgentContext } from "../agent/agent-context";
+import type { AgentReporter } from "../agent/agent-reporter";
+import type { AgentState } from "../investigation/agent-state";
+import type { Evidence } from "../investigation/evidence";
+import type { RuleAnalysis } from "../investigation/rule-analyzer";
+import type { ToolCache } from "./tool-cache";
+import type { ToolCallBudget } from "./tool-call-budget";
+
+/** Categoria de agrupamento (usada no prompt e na policy). */
+export type ToolCategory = "context" | "code" | "symbol" | "ast" | "rules" | "evidence";
+
+/** Capability declarada por uma tool (a policy libera por capability). */
+export type ToolCapability =
+	| "read"
+	| "search"
+	| "outline"
+	| "symbol"
+	| "references"
+	| "ast"
+	| "impact"
+	| "rules"
+	| "tests"
+	| "docs";
+
+/** Metadados estáveis (o prompt é gerado a partir daqui). */
+export type ToolMetadata = {
+	name: string;
+	description: string;
+	category: ToolCategory;
+	capabilities: readonly ToolCapability[];
+	readOnly: true;
+	/** Custo relativo para o planner (1 = barato, 5 = caro). */
+	cost: 1 | 2 | 3 | 4 | 5;
+	cacheTtlMs?: number;
+	maxCallsPerAgent?: number;
+};
+
+/** Resultado de uma tool (sempre estruturado). */
+export type ToolResult<T = unknown> = {
+	ok: boolean;
+	data?: T;
+	evidence?: Evidence[];
+	truncated?: boolean;
+	hint?: string;
+	error?: string;
+};
+
+/** Contexto de execução de uma tool. */
+export type ToolContext = {
+	repoRoot: string;
+	watchdog: Watchdog;
+	diff: DiffSource;
+	ast: AstService;
+	state: AgentState;
+	budget: ToolCallBudget;
+	cache: ToolCache;
+	logger: AgentReporter;
+	agent: AgentContext;
+	/** Análises determinísticas das regras do watchdog (por texto). */
+	rules: ReadonlyMap<string, RuleAnalysis>;
+};
+
+/** Tool executável por um agente. */
+export interface AgentTool<I = unknown, O = unknown> {
+	readonly metadata: ToolMetadata;
+	readonly inputSchema: ZodType<I>;
+	execute(input: I, context: ToolContext): Promise<ToolResult<O>>;
+}
+
+/** Módulo de registro de tools (permite agrupar por domínio). */
+export interface ToolModule {
+	register(registry: ToolRegistryLike): void;
+}
+
+/**
+ * Forma aceita pelo registry. `execute(input: never)` aceita qualquer tool
+ * concreta por contravariância, sem apelar para `any`.
+ */
+export type RegisterableTool = {
+	readonly metadata: ToolMetadata;
+	readonly inputSchema: ZodTypeAny;
+	execute(input: never, context: ToolContext): Promise<ToolResult<unknown>>;
+};
+
+/** Superfície mínima de registro (evita dependência circular com a classe). */
+export interface ToolRegistryLike {
+	registerTool(tool: RegisterableTool): void;
+}
+
+export type { ZodTypeAny };

package/src/harness/tools/builtin/changed-symbols-tool.ts

@@ -0,0 +1,48 @@
+/**
+ * Tool `changed_symbols` — delta AST da revisão (o que realmente mudou).
+ */
+
+import { z } from "zod";
+import type { AgentTool, ToolMetadata, ToolResult } from "../agent-tool";
+
+const Input = z.object({ file: z.string().optional() });
+
+/** Símbolos adicionados/removidos/modificados e assinaturas alteradas. */
+export class ChangedSymbolsTool implements AgentTool<z.infer<typeof Input>, unknown> {
+	readonly metadata: ToolMetadata = {
+		name: "changed_symbols",
+		description: "Delta AST da revisão: símbolos adicionados/removidos/modificados.",
+		category: "ast",
+		capabilities: ["ast"],
+		readOnly: true,
+		cost: 1,
+		cacheTtlMs: 300_000,
+	};
+
+	readonly inputSchema = Input;
+
+	async execute(
+		input: z.infer<typeof Input>,
+		context: import("../tool-context").ToolContext,
+	): Promise<ToolResult<unknown>> {
+		const entries = [];
+		for (const [file, analysis] of context.agent.ast) {
+			if (input.file && file !== input.file) continue;
+			if (!analysis.delta) continue;
+			entries.push({
+				file,
+				added: analysis.delta.addedSymbols.map((symbol) => symbol.name),
+				removed: analysis.delta.removedSymbols.map((symbol) => symbol.name),
+				modified: analysis.delta.modifiedSymbols.map((symbol) => symbol.name),
+				changedSignatures: analysis.delta.changedSignatures,
+				addedImports: analysis.delta.addedImports,
+				removedImports: analysis.delta.removedImports,
+			});
+		}
+		return {
+			ok: true,
+			data: { files: entries },
+			...(entries.length === 0 ? { hint: "Sem delta AST para os filtros." } : {}),
+		};
+	}
+}