@payconductor/houndsman 0.10.0 → 0.12.0

package/src/core/changed-scope.ts

@@ -0,0 +1,207 @@
+/**
+ * Escopo do diff (engine) — o que esta revisão realmente alterou.
+ *
+ * Traduz os hunks do diff (`-U0`) em faixas de linhas revisáveis por arquivo e,
+ * quando o AST está disponível, no menor símbolo folha que contém cada âncora.
+ * É a fonte única usada pelo brief e pela pré-análise para evitar
+ * achados em código pré-existente.
+ *
+ * Fail-open: sem AST (grammar ausente/`--no-ast`/binário) o escopo cai nos
+ * hunks; sem patch, o arquivo fica sem faixas.
+ */
+
+import { changedAnchors } from "./ast/diff";
+import type { AstAnalysis, AstSymbol, AstSymbolKind } from "./ast/types";
+import type { DiffSource } from "./diff-source";
+
+/** Intervalo de linhas (1-based, inclusivo). */
+export type LineRange = { start: number; end: number };
+
+/** Símbolo alterado (o menor símbolo folha que contém uma âncora). */
+export type ChangedSymbol = {
+	name: string;
+	kind: AstSymbolKind;
+	startLine: number;
+	endLine: number;
+};
+
+/** Origem do escopo: AST (símbolos) ou hunks (fallback determinístico). */
+export type ChangedScopeSource = "ast" | "hunks";
+
+/** Escopo de um arquivo alterado. */
+export type FileChangedScope = {
+	/** Faixas revisáveis (símbolos alterados + âncoras soltas), ordenadas. */
+	ranges: LineRange[];
+	/** Símbolos folha tocados pelas âncoras. */
+	symbols: ChangedSymbol[];
+	source: ChangedScopeSource;
+};
+
+/** Escopo do diff: caminho do arquivo → faixas revisáveis. */
+export type ChangedScope = Record<string, FileChangedScope>;
+
+/** Entrada mínima do builder (status do `git diff --name-status`). */
+export type ScopeEntry = { path: string; status: string };
+
+export type BuildChangedScopeInput = {
+	entries: readonly ScopeEntry[];
+	/** Patch por arquivo (idealmente `git diff -U0`, sem truncar). */
+	diff: DiffSource;
+	/** Análises da versão atual (`null`/ausente → fallback nos hunks). */
+	ast?: ReadonlyMap<string, AstAnalysis>;
+};
+
+/** Espécies que representam containers: não expandem sozinhas o escopo. */
+const CONTAINER_KINDS: ReadonlySet<AstSymbolKind> = new Set([
+	"class",
+	"interface",
+	"enum",
+]);
+
+/** Tamanho do intervalo de um símbolo (menor = mais específico). */
+function span(symbol: AstSymbol): number {
+	return symbol.endLine - symbol.startLine;
+}
+
+/** Menor símbolo folha que contém a linha (containers são ignorados). */
+function leafAt(symbols: readonly AstSymbol[], line: number): AstSymbol | undefined {
+	let best: AstSymbol | undefined;
+	for (const symbol of symbols) {
+		if (CONTAINER_KINDS.has(symbol.kind)) continue;
+		if (line < symbol.startLine || line > symbol.endLine) continue;
+		if (!best || span(symbol) < span(best)) best = symbol;
+	}
+	return best;
+}
+
+/** Converte um símbolo AST no shape do escopo. */
+function toChangedSymbol(symbol: AstSymbol): ChangedSymbol {
+	return {
+		name: symbol.name,
+		kind: symbol.kind,
+		startLine: symbol.startLine,
+		endLine: symbol.endLine,
+	};
+}
+
+/** Deduplica símbolos por identidade e posição, mantendo a ordem de leitura. */
+function uniqueSymbols(symbols: readonly AstSymbol[]): ChangedSymbol[] {
+	const seen = new Set<string>();
+	const result: ChangedSymbol[] = [];
+	for (const symbol of symbols) {
+		const key = `${symbol.kind}:${symbol.name}:${symbol.startLine}:${symbol.endLine}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(toChangedSymbol(symbol));
+	}
+	return result.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
+}
+
+/** `true` se a linha está dentro de alguma faixa. */
+export function isLineInScope(scope: ChangedScope, file: string, line: number): boolean {
+	const entry = scope[file];
+	if (!entry) return false;
+	return entry.ranges.some((range) => line >= range.start && line <= range.end);
+}
+
+/** Une intervalos sobrepostos/adjacentes (ordem estável por início). */
+export function mergeRanges(ranges: readonly LineRange[]): LineRange[] {
+	const sorted = [...ranges]
+		.filter((range) => range.end >= range.start)
+		.sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged: LineRange[] = [];
+	for (const range of sorted) {
+		const last = merged.at(-1);
+		if (last && range.start <= last.end + 1) {
+			last.end = Math.max(last.end, range.end);
+			continue;
+		}
+		merged.push({ ...range });
+	}
+	return merged;
+}
+
+/**
+ * Escopo por arquivo alterado. Arquivos deletados/renomeados sem hunks ficam
+ * com faixas vazias (não há código atual para ancorar finding).
+ */
+export function buildChangedScope(input: BuildChangedScopeInput): ChangedScope {
+	const scope: ChangedScope = {};
+
+	for (const entry of input.entries) {
+		if (entry.status === "deleted") continue;
+		const analysis = input.ast?.get(entry.path);
+		if (analysis?.deleted) continue;
+
+		const patch = input.diff.byFile.get(entry.path) ?? "";
+		const { added, deletedAt } = changedAnchors(patch);
+		const anchors = new Set<number>([...added, ...deletedAt]);
+		const source: ChangedScopeSource = analysis ? "ast" : "hunks";
+
+		const touched: AstSymbol[] = [];
+		if (analysis) {
+			for (const line of anchors) {
+				const symbol = leafAt(analysis.facts.symbols, line);
+				if (symbol) touched.push(symbol);
+			}
+		}
+		const symbols = uniqueSymbols(touched);
+
+		// Âncoras fora de símbolo folha (imports, topo do módulo, cabeçalho de
+		// classe) continuam revisáveis como faixas avulsas.
+		const covered = (line: number): boolean =>
+			symbols.some((symbol) => line >= symbol.startLine && line <= symbol.endLine);
+		const loose = [...anchors].filter((line) => !covered(line));
+
+		scope[entry.path] = {
+			ranges: mergeRanges([
+				...symbols.map((symbol) => ({
+					start: symbol.startLine,
+					end: symbol.endLine,
+				})),
+				...loose.map((line) => ({ start: line, end: line })),
+			]),
+			symbols,
+			source,
+		};
+	}
+
+	return scope;
+}
+
+/** Totais do escopo (mensagens, tool e testes). */
+export function summarizeScope(scope: ChangedScope): {
+	files: number;
+	ranges: number;
+	symbols: number;
+} {
+	let ranges = 0;
+	let symbols = 0;
+	for (const entry of Object.values(scope)) {
+		ranges += entry.ranges.length;
+		symbols += entry.symbols.length;
+	}
+	return { files: Object.keys(scope).length, ranges, symbols };
+}
+
+/** Faixas em texto compacto (`10-14, 22`) para prompts e briefs. */
+export function formatRanges(ranges: readonly LineRange[], max = 8): string {
+	if (ranges.length === 0) return "sem linhas alteradas";
+	const shown = ranges
+		.slice(0, max)
+		.map((range) =>
+			range.start === range.end ? `${range.start}` : `${range.start}-${range.end}`,
+		);
+	const rest = ranges.length > max ? ` (+${ranges.length - max})` : "";
+	return `${shown.join(", ")}${rest}`;
+}
+
+/** Símbolos em texto compacto (`` `foo` (10-40)``) para prompts e briefs. */
+export function formatSymbols(symbols: readonly ChangedSymbol[], max = 6): string {
+	if (symbols.length === 0) return "";
+	const shown = symbols
+		.slice(0, max)
+		.map((symbol) => `\`${symbol.name}\` (${symbol.startLine}-${symbol.endLine})`);
+	const rest = symbols.length > max ? ` (+${symbols.length - max})` : "";
+	return `${shown.join(", ")}${rest}`;
+}

package/src/core/commands/scaffold.ts

@@ -131,16 +131,6 @@ export type Rule = {
 	severity: Severity;
 	text: string;
 	jev?: JevRuleSpec;
-	hints?: RuleHints;
-};
-
-/** Sinais opcionais de uma regra (símbolos, imports, decorators, paths, checks). */
-export type RuleHints = {
-	symbols?: string[];
-	imports?: string[];
-	decorators?: string[];
-	paths?: string[];
-	checks?: string[];
 };
 
 /** Como o watchdog casa um arquivo alterado. \`value\` é sempre regex. */
@@ -235,20 +225,15 @@ export type HoundsmanAiFeatures = {
 /** Overrides de IA por watchdog. */
 export type HoundsmanAiWatchdog = {
 	model?: string;
-	maxSteps?: number;
-	maxOutputTokens?: number;
 };
 
-/** Configuração da camada de IA (briefs, contexto, classificação e hunt nativo). */
+/** Configuração da camada de IA (briefs, contexto, classificação, pré-análise, verify). */
 export type HoundsmanAi = {
 	enabled?: boolean;
 	provider?: AiProviderKind;
 	model?: string;
 	baseURL?: string;
 	concurrency?: number;
-	maxSteps?: number;
-	maxOutputTokens?: number;
-	temperature?: number;
 	providerOptions?: AiProviderOptions;
 	timeoutMs?: number;
 	maxCallsPerReview?: number;
@@ -337,7 +322,6 @@ export const defaultWatchdog = defineWatchdog({
 		{
 			severity: "attention",
 			text: "Promover: nome, contrato e documentação do símbolo correspondem ao comportamento real.",
-			hints: { checks: ["symbol_context"] },
 		},
 		{
 			severity: "attention",
@@ -350,7 +334,6 @@ export const defaultWatchdog = defineWatchdog({
 		{
 			severity: "suggestion",
 			text: "Evitar: lógica de negócio duplicada ou divergente entre camadas.",
-			hints: { checks: ["find_references"] },
 		},
 		{
 			severity: "suggestion",

package/src/core/config-loader.ts

@@ -31,6 +31,12 @@ export type LoadedConfig<TId extends string = string> = {
 	path: string;
 };
 
+/** Forma do módulo de config (default ou export nomeado). */
+type ConfigModule<TId extends string> = {
+	default?: HoundsmanConfig<TId>;
+	houndsmanConfig?: HoundsmanConfig<TId>;
+};
+
 /** Primeiro arquivo de config existente no diretório (ou `null`). */
 export function resolveConfigPath(cwd: string = process.cwd()): string | null {
 	for (const name of CONFIG_FILE_CANDIDATES) {
@@ -61,10 +67,18 @@ export async function loadConfig<TId extends string = string>(
 		throw new Error(MISSING_CONFIG_HINT);
 	}
 
-	const module = (await import(pathToFileURL(path).href)) as {
-		default?: HoundsmanConfig<TId>;
-		houndsmanConfig?: HoundsmanConfig<TId>;
-	};
+	let module: ConfigModule<TId>;
+	try {
+		module = (await import(pathToFileURL(path).href)) as ConfigModule<TId>;
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		// Causa comum: camada gerada ausente (`.houndsman/core`), importada pelos
+		// watchdogs como `../core/types` — típico de worktree ainda não sincronizado.
+		throw new Error(
+			`Falha ao carregar ${path}: ${detail}\n` +
+				"A camada gerada (`.houndsman/core`) existe? Rode `houndsman update` na raiz do projeto.",
+		);
+	}
 	const config = module.default ?? module.houndsmanConfig;
 
 	if (!config) {

package/src/core/config.ts

@@ -13,8 +13,6 @@ import type { WatchdogDefinition } from "./types";
 export {
 	DEFAULT_AI_CONCURRENCY,
 	DEFAULT_AI_MAX_CALLS_PER_REVIEW,
-	DEFAULT_AI_MAX_OUTPUT_TOKENS,
-	DEFAULT_AI_MAX_STEPS,
 	DEFAULT_AI_MODEL,
 	DEFAULT_AI_PROVIDER,
 	DEFAULT_AI_TIMEOUT_MS,
@@ -85,11 +83,9 @@ export type HoundsmanAiFeatures = {
 /** Overrides de IA por watchdog. */
 export type HoundsmanAiWatchdog = {
 	model?: string;
-	maxSteps?: number;
-	maxOutputTokens?: number;
 };
 
-/** Configuração da camada de IA (genérica; o harness nativo também a consome). */
+/** Configuração da camada de IA (briefs, contexto, classificação, pré-análise, verify). */
 export type HoundsmanAi = {
 	/** Liga a IA do fluxo normal (default: `true`; sem chave é fail-open). */
 	enabled?: boolean;
@@ -101,15 +97,6 @@ export type HoundsmanAi = {
 	baseURL?: string;
 	/** Chamadas simultâneas (default: 2). */
 	concurrency?: number;
-	/** Passos por agente (default: 12). */
-	maxSteps?: number;
-	/** Teto de tokens de saída por chamada. */
-	maxOutputTokens?: number;
-	/**
-	 * Temperatura (default: 0). Ignorada quando o provider usa thinking
-	 * (DeepSeek V4 liga thinking por default) — nesse caso o motor não a envia.
-	 */
-	temperature?: number;
 	/** Opções do AI SDK por provider (repassadas sem interpretação). */
 	providerOptions?: AiProviderOptions;
 	/** Timeout por chamada em ms (default: 120_000). */
@@ -180,7 +167,7 @@ export type HoundsmanConfig<TId extends string = string> = {
 	concurrency?: HoundsmanConcurrency;
 	/** AST determinístico (classificação estrutural, brief e impacto). */
 	ast?: HoundsmanAst;
-	/** Camada de IA (briefs, contexto, classificação e o harness nativo). */
+	/** Camada de IA (briefs, contexto, classificação, pré-análise e verify). */
 	ai?: HoundsmanAi;
 };
 

package/src/core/defaults.ts

@@ -41,14 +41,8 @@ export const DEFAULT_AI_MODEL = "deepseek-v4-pro";
 /** Concorrência default das chamadas de IA. */
 export const DEFAULT_AI_CONCURRENCY = 2;
 
-/** Passos default por agente (loop de tools + saída). */
-export const DEFAULT_AI_MAX_STEPS = 12;
-
 /** Timeout default de uma chamada de modelo (ms). */
 export const DEFAULT_AI_TIMEOUT_MS = 120_000;
 
 /** Teto default de chamadas de IA por review. */
 export const DEFAULT_AI_MAX_CALLS_PER_REVIEW = 40;
-
-/** Teto default de tokens de saída por chamada. */
-export const DEFAULT_AI_MAX_OUTPUT_TOKENS = 4096;

package/src/core/engine/review-scope.ts

@@ -7,6 +7,7 @@
 
 import type { AstService } from "../ast/service";
 import type { AstAnalysis, AstFacts } from "../ast/types";
+import { buildChangedScope, type ChangedScope, type ScopeEntry } from "../changed-scope";
 import type { HoundsmanConfig } from "../config";
 import { churnToRecord, type DiffSource } from "../diff-source";
 import { type ClassificationResult, parseEntries } from "../file-classifier";
@@ -34,6 +35,8 @@ export type RunClassification = ClassificationResult & {
 	reviewedFrom?: string;
 	/** Findings preservados do review anterior (arquivos inalterados). */
 	carryover?: MergedFinding[];
+	/** Faixas revisáveis por arquivo (símbolos alterados; hunks como fallback). */
+	changedScope?: ChangedScope;
 };
 
 /** Resultado da resolução de escopo: revisar ou nada a fazer. */
@@ -104,19 +107,30 @@ export class ReviewScopeResolver {
 			const baseRef =
 				this.git.mergeBase(this.options.base, this.options.head) ??
 				this.options.base;
+			// Patch `-U0` sem truncar: mais preciso para delta AST e escopo.
+			const scopeDiff = this.zeroContext(
+				`${this.options.base}...${this.options.head}`,
+				diff,
+			);
 			const ast = this.ast
-				? await this.ast.analyze(entries, diff, baseRef)
+				? await this.ast.analyze(entries, scopeDiff, baseRef)
 				: undefined;
+			const result = this.classifier
+				.classify(entries, churnToRecord(diff.churn), factsOf(ast))
+				.toJSON();
 			return {
 				kind: "review",
 				diff,
 				ast,
 				classification: {
-					...this.classifier
-						.classify(entries, churnToRecord(diff.churn), factsOf(ast))
-						.toJSON(),
+					...result,
 					headSha,
 					mode: "full",
+					changedScope: buildChangedScope({
+						entries: scopeEntries(entries, result),
+						diff: scopeDiff,
+						ast,
+					}),
 				},
 			};
 		}
@@ -125,20 +139,39 @@ export class ReviewScopeResolver {
 		const diff = this.git.collectDiffSince(prevSha, headSha);
 		const entries = parseEntries(this.git.run(["diff", range, "--name-status"]));
 		const changedPaths = new Set(entries.map((entry) => entry.path));
-		const ast = this.ast ? await this.ast.analyze(entries, diff, prevSha) : undefined;
+		const scopeDiff = this.zeroContext(range, diff);
+		const ast = this.ast
+			? await this.ast.analyze(entries, scopeDiff, prevSha)
+			: undefined;
+		const result = this.classifier
+			.classify(entries, churnToRecord(diff.churn), factsOf(ast))
+			.toJSON();
 		const classification: RunClassification = {
-			...this.classifier
-				.classify(entries, churnToRecord(diff.churn), factsOf(ast))
-				.toJSON(),
+			...result,
 			base: prevSha,
 			head: this.options.head,
 			headSha,
 			mode: "incremental",
 			reviewedFrom: prevSha,
 			carryover: buildCarryover(previous, changedPaths),
+			changedScope: buildChangedScope({
+				entries: scopeEntries(entries, result),
+				diff: scopeDiff,
+				ast,
+			}),
 		};
 		return { kind: "review", classification, diff, reviewedFrom: prevSha, ast };
 	}
+
+	/** Patch `-U0` do intervalo; falha aberta cai no diff já coletado. */
+	private zeroContext(range: string, fallback: DiffSource): DiffSource {
+		try {
+			const byFile = this.git.patchZeroContext(range);
+			return byFile.size > 0 ? { byFile, churn: fallback.churn } : fallback;
+		} catch {
+			return fallback;
+		}
+	}
 }
 
 /** Fatos apenas dos arquivos presentes (deletados não classificam). */
@@ -152,3 +185,17 @@ function factsOf(
 	}
 	return facts;
 }
+
+/**
+ * Entradas revisáveis do `--name-status`: exclui arquivos do `exclusions` e
+ * deletados (não há código atual para ancorar finding).
+ */
+function scopeEntries(
+	entries: ReturnType<typeof parseEntries>,
+	result: ClassificationResult,
+): ScopeEntry[] {
+	const excluded = new Set(result.excluded);
+	return entries
+		.filter((entry) => entry.status !== "deleted" && !excluded.has(entry.path))
+		.map((entry) => ({ path: entry.path, status: entry.status }));
+}

package/src/core/engine/review-workspace.ts

@@ -11,7 +11,7 @@ import { createGitRunner } from "../git-runner";
 import { createGhRunner, type GhRunner } from "../services/gh-client";
 import { GitRepository } from "../services/git-repository";
 import { PrResolver } from "../services/pr-resolver";
-import { WorktreeManager } from "../services/worktree-manager";
+import { syncProjectLayer, WorktreeManager } from "../services/worktree-manager";
 import { resolveWorktreesRoot } from "../storage/paths";
 import { resolveRepoIdentity } from "../storage/repo-identity";
 import type { RepoIdentity } from "../storage/types";
@@ -105,9 +105,13 @@ export function resolveReviewWorkspace(
 				`Worktree '${root}' está em detached HEAD. Informe --branch <nome>.`,
 			);
 		}
+		// A camada gerada não vem no checkout; sem ela os comandos no worktree
+		// não carregam a config (`../core/types`).
+		const explicitMainRoot = mainRootOf(git, repo.root);
+		syncProjectLayer(explicitMainRoot, root);
 		return {
 			root,
-			mainRoot: mainRootOf(git, repo.root),
+			mainRoot: explicitMainRoot,
 			repo,
 			git,
 			branch,

package/src/core/jev/jev-detector.ts

@@ -156,10 +156,15 @@ export class JevDetector {
 		const hunk =
 			diff.byFile.get(filePath)?.slice(0, JevDetector.MAX_DIFF_CHARS) ?? "";
 		const parts = [`Arquivo: ${filePath} (${status})`];
+		parts.push(
+			"Escopo: apenas o diff abaixo refere-se ao que mudou nesta revisão.",
+			"O topo do arquivo é contexto para entender imports/declarações — não reporte",
+			"problemas apenas nele.",
+		);
 		if (header) {
-			parts.push("--- topo do arquivo (imports/declarações) ---", header);
+			parts.push("--- topo do arquivo (contexto) ---", header);
 		}
-		if (hunk) parts.push("--- diff ---", hunk);
+		if (hunk) parts.push("--- diff (escopo alterado) ---", hunk);
 		return parts.join("\n").slice(0, JevDetector.MAX_STATE_CHARS);
 	}
 

package/src/core/logging/index.ts

@@ -1,7 +1,7 @@
 /**
  * Instância pronta do logger (`import { logger } from "../core/logging"`).
  *
- * Infraestrutura compartilhada por `cli`, `harness` e `server`. Módulos de
+ * Infraestrutura compartilhada por `cli` e `server`. Módulos de
  * negócio do core não escrevem saída.
  */
 

package/src/core/logging/logger.ts

@@ -1,11 +1,11 @@
 /**
- * Logger único do CLI/harness (infraestrutura).
+ * Logger único do CLI (infraestrutura).
  *
  * Usa `chalk` para cor e `ora` para spinner, mas cai para texto puro quando a
  * saída não é TTY, `NO_COLOR` está definido, `TERM=dumb` ou `--quiet`.
  *
- * Não é usado por módulos de negócio do `core/`: só `cli/`, `harness/` e
- * `server/` escrevem saída.
+ * Não é usado por módulos de negócio do `core/`: só `cli/` e `server/`
+ * escrevem saída.
  */
 
 import { Chalk, type ChalkInstance } from "chalk";

package/src/core/orchestrator.ts

@@ -16,7 +16,7 @@
  * review.<watchdog>.md, context e context-summary.
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { AiClient } from "./ai/ai-client";
 import { AiBriefEnricher } from "./ai/features/brief-enricher";
@@ -28,6 +28,7 @@ import type { BriefPlan } from "./ai/schemas";
 import { assetPath, OUTPUT_FORMAT_FILE } from "./assets";
 import type { AstService } from "./ast/service";
 import type { AstAnalysis, AstFileBrief, AstImpact } from "./ast/types";
+import { summarizeScope } from "./changed-scope";
 import {
 	type HoundsmanConfig,
 	resolveJevConcurrency,
@@ -101,7 +102,7 @@ export type ReviewOptions = {
 	noAst: boolean;
 	/** Força review completo (ignora o modo incremental). */
 	full: boolean;
-	/** Desativa as features de IA do fluxo normal (hunt não usa esta flag). */
+	/** Desativa as features de IA do fluxo normal. */
 	noAi: boolean;
 	/** PR de origem (resolvida via `--pr`). */
 	pr?: number;
@@ -231,7 +232,7 @@ function writeManifest(
 
 function writeBriefs(
 	activeIds: string[],
-	classification: ClassificationResult,
+	classification: RunClassification,
 	ctx: ReviewContext,
 	branch: string,
 	context: ContextSummary | null,
@@ -276,6 +277,7 @@ function writeBriefs(
 			candidates: candidates.filter((c) => c.watchdogId === id),
 			ast: astFiles,
 			aiPlan: aiPlans?.get(id),
+			changedScope: classification.changedScope,
 		});
 		const content = `${brief}\n`;
 		work.writeBrief(id, content);
@@ -322,7 +324,9 @@ async function resolveCandidates(
 				const def = findWatchdog(config, id);
 				if (!def) continue;
 				const inputs = files.slice(0, 5).flatMap((file) => {
-					const snippet = readSnippet(ctx.root, file);
+					// Só o trecho alterado: candidato fora do diff vira ruído de código
+					// pré-existente no brief do watchdog.
+					const snippet = diff.byFile.get(file);
 					return snippet ? [{ file, snippet }] : [];
 				});
 				candidates.push(
@@ -406,6 +410,16 @@ function discoveryMessages(
 	return messages;
 }
 
+/** Resumo do escopo — lembra que só as faixas alteradas são revisáveis. */
+function changedScopeMessage(classification: RunClassification): string[] {
+	const scope = classification.changedScope;
+	if (!scope) return [];
+	const totals = summarizeScope(scope);
+	return [
+		`Escopo: ${totals.files} arquivo(s), ${totals.symbols} símbolo(s) em ${totals.ranges} faixa(s) alterada(s).`,
+	];
+}
+
 /** Resumo do orçamento — só quando algum arquivo ficou de fora (PR grande). */
 function budgetMessage(
 	classification: ClassificationResult,
@@ -422,16 +436,6 @@ function budgetMessage(
 	];
 }
 
-/** Primeiras 80 linhas de um arquivo (pré-análise por IA; fail-open). */
-function readSnippet(root: string, file: string): string | null {
-	try {
-		const path = join(root, file);
-		return readFileSync(path, "utf8").split("\n").slice(0, 80).join("\n");
-	} catch {
-		return null;
-	}
-}
-
 /** Resultado do prepare — mensagens para o CLI imprimir. */
 export type PrepareResult = { messages: string[] };
 
@@ -806,6 +810,7 @@ export async function prepare(
 	messages.push(
 		...discoveryMessages(activeIds, classification, ctx.work.briefsDir),
 		...budgetMessage(classification, config),
+		...changedScopeMessage(classification),
 		...jevSummary(jev),
 	);
 	if (astAnalyses) {

package/src/core/project-config.ts

@@ -19,8 +19,6 @@ import type {
 import {
 	DEFAULT_AI_CONCURRENCY,
 	DEFAULT_AI_MAX_CALLS_PER_REVIEW,
-	DEFAULT_AI_MAX_OUTPUT_TOKENS,
-	DEFAULT_AI_MAX_STEPS,
 	DEFAULT_AI_MODEL,
 	DEFAULT_AI_PROVIDER,
 	DEFAULT_AI_TIMEOUT_MS,
@@ -126,19 +124,6 @@ export class ProjectConfig<TId extends string = string> {
 		return positive(this.ai.concurrency, DEFAULT_AI_CONCURRENCY);
 	}
 
-	get aiMaxSteps(): number {
-		return positive(this.ai.maxSteps, DEFAULT_AI_MAX_STEPS);
-	}
-
-	get aiMaxOutputTokens(): number {
-		return positive(this.ai.maxOutputTokens, DEFAULT_AI_MAX_OUTPUT_TOKENS);
-	}
-
-	get aiTemperature(): number {
-		const value = this.ai.temperature;
-		return typeof value === "number" && Number.isFinite(value) ? value : 0;
-	}
-
 	/** Opções do AI SDK por provider (undefined quando ausentes/vazias). */
 	get aiProviderOptions(): AiProviderOptions | undefined {
 		const value = this.ai.providerOptions;
@@ -177,19 +162,6 @@ export class ProjectConfig<TId extends string = string> {
 		const override = this.ai.watchdogs?.[watchdogId]?.model?.trim();
 		return override && override.length > 0 ? override : this.aiModel;
 	}
-
-	/** Passos efetivos de um watchdog (override por watchdog ou global). */
-	aiMaxStepsFor(watchdogId: string): number {
-		return positive(this.ai.watchdogs?.[watchdogId]?.maxSteps, this.aiMaxSteps);
-	}
-
-	/** Tokens de saída efetivos de um watchdog. */
-	aiMaxOutputTokensFor(watchdogId: string): number {
-		return positive(
-			this.ai.watchdogs?.[watchdogId]?.maxOutputTokens,
-			this.aiMaxOutputTokens,
-		);
-	}
 }
 
 /** Inteiro positivo ou o default. */