@payconductor/houndsman 0.5.0 → 0.6.0

package/src/core/defaults.ts

@@ -18,3 +18,30 @@ export const DEFAULT_MAX_FILES_PER_BRIEF = 40;
 
 /** Concorrência default das chamadas simultâneas ao Jev. */
 export const DEFAULT_JEV_CONCURRENCY = 5;
+
+/** Teto default de bytes por arquivo no AST (evita bundles/minificados). */
+export const DEFAULT_AST_MAX_FILE_BYTES = 512_000;
+
+/** Teto default de arquivos candidatos na análise de impacto. */
+export const DEFAULT_AST_MAX_IMPACT_FILES = 200;
+
+/** Provider default da camada de IA (DeepSeek). */
+export const DEFAULT_AI_PROVIDER = "deepseek" as const;
+
+/** Modelo default da camada de IA. */
+export const DEFAULT_AI_MODEL = "deepseek-v4.1-flash";
+
+/** 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/domain/watchdog.ts

@@ -6,6 +6,7 @@
  * render do brief) sem alterar o contrato do consumidor.
  */
 
+import type { AstFacts } from "../ast/types";
 import { renderBrief } from "../brief";
 import {
 	type ClassifyRule,
@@ -18,16 +19,51 @@ import {
 /** Tipo assumido quando `type` é omitido. */
 const DEFAULT_CLASSIFY_TYPE: NonNullable<ClassifyRule["type"]> = "filename";
 
+/** `true` se algum valor do conjunto casa o padrão. */
+function matchesAny(values: readonly string[], pattern: RegExp): boolean {
+	return values.some((value) => pattern.test(value));
+}
+
 /** `true` se o arquivo casa a entrada de classificação. */
 export function matchesClassifyRule(
 	filePath: string,
 	rule: ClassifyRule,
 	content: string | undefined,
+	facts?: AstFacts,
 ): boolean {
-	if ((rule.type ?? DEFAULT_CLASSIFY_TYPE) === "content") {
-		return content !== undefined && new RegExp(rule.value).test(content);
+	const pattern = new RegExp(rule.value);
+	switch (rule.type ?? DEFAULT_CLASSIFY_TYPE) {
+		case "content":
+			return content !== undefined && pattern.test(content);
+		case "symbol":
+			return (
+				facts !== undefined &&
+				matchesAny(
+					facts.symbols.flatMap((symbol) => [symbol.name, symbol.kind]),
+					pattern,
+				)
+			);
+		case "import":
+			return (
+				facts !== undefined &&
+				matchesAny(
+					facts.imports.flatMap((item) => [item.source, ...item.names]),
+					pattern,
+				)
+			);
+		case "export":
+			return (
+				facts !== undefined &&
+				matchesAny(
+					facts.exports.map((item) => item.name),
+					pattern,
+				)
+			);
+		case "decorator":
+			return facts !== undefined && matchesAny(facts.decorators, pattern);
+		default:
+			return pattern.test(filePath);
 	}
-	return new RegExp(rule.value).test(filePath);
 }
 
 /** Contexto "essencial" do watchdog — SEM regras (docs/UI/inspeção). */
@@ -71,8 +107,10 @@ export class Watchdog {
 	}
 
 	/** `true` se o arquivo é deste domínio. */
-	matches(filePath: string, content?: string): boolean {
-		return this.classify.some((rule) => matchesClassifyRule(filePath, rule, content));
+	matches(filePath: string, content?: string, facts?: AstFacts): boolean {
+		return this.classify.some((rule) =>
+			matchesClassifyRule(filePath, rule, content, facts),
+		);
 	}
 
 	/** Regras ordenadas por severidade (mais grave primeiro). */

package/src/core/engine/houndsman-engine.ts

@@ -6,6 +6,8 @@
  * de instanciar/importar tudo diretamente.
  */
 
+import { AiClient } from "../ai/ai-client";
+import { AstService } from "../ast/service";
 import type { HoundsmanConfig } from "../config";
 import type { ReviewOptions } from "../orchestrator";
 import { ProjectConfig } from "../project-config";
@@ -26,6 +28,8 @@ export type EngineDeps = {
 	fixBatch?: FixBatchBuilder;
 	storage?: StorageProvider;
 	repo?: RepoIdentity;
+	ast?: AstService;
+	ai?: AiClient;
 };
 
 /** Composition root do motor. */
@@ -37,6 +41,8 @@ export class HoundsmanEngine {
 	readonly fixBatch: FixBatchBuilder;
 	readonly storage: StorageProvider;
 	readonly repo: RepoIdentity;
+	readonly ast: AstService;
+	readonly ai: AiClient;
 
 	constructor(raw: HoundsmanConfig, deps: EngineDeps = {}) {
 		this.project = new ProjectConfig(raw);
@@ -46,6 +52,8 @@ export class HoundsmanEngine {
 		this.fixBatch = deps.fixBatch ?? new FixBatchBuilder();
 		this.storage = deps.storage ?? createStorage(raw);
 		this.repo = deps.repo ?? resolveRepoIdentity(this.git);
+		this.ast = deps.ast ?? new AstService(raw, this.git);
+		this.ai = deps.ai ?? new AiClient({ project: this.project });
 	}
 
 	/** Configuração crua (contrato do consumidor). */
@@ -55,7 +63,14 @@ export class HoundsmanEngine {
 
 	/** Abre uma sessão de revisão (prepare/finalize). */
 	session(options: ReviewOptions): ReviewSession {
-		return ReviewSession.from(this.config, options, this.storage, this.repo);
+		return ReviewSession.from(
+			this.config,
+			options,
+			this.storage,
+			this.repo,
+			this.ast,
+			this.ai,
+		);
 	}
 
 	/** Libera o provider (fecha o SQLite e faz checkpoint do WAL). */

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

@@ -5,11 +5,14 @@
  * carrega os findings de arquivos inalterados (carry-over).
  */
 
+import type { AstService } from "../ast/service";
+import type { AstAnalysis, AstFacts } from "../ast/types";
 import type { HoundsmanConfig } from "../config";
 import { churnToRecord, collectDiff, type DiffSource } from "../diff-source";
-import type { ClassificationResult } from "../file-classifier";
+import { type ClassificationResult, parseEntries } from "../file-classifier";
 import type { FindingsStateFile } from "../findings-state";
 import { collectDiffSince, diffEntries, isAncestor } from "../git-revision";
+import { runGit, tryGit } from "../git-runner";
 import type { MergedFinding } from "../report-builder";
 import { FileClassifier } from "../services/file-classifier";
 import { buildCarryover } from "./carryover";
@@ -48,16 +51,20 @@ export type ReviewScope =
 			classification: RunClassification;
 			diff: DiffSource;
 			reviewedFrom?: string;
+			/** Fatos/delta por arquivo alterado (quando o AST está habilitado). */
+			ast?: Map<string, AstAnalysis>;
 	  };
 
 /** Decide entre review completo e incremental. */
 export class ReviewScopeResolver {
 	private readonly options: ScopeOptions;
 	private readonly classifier: FileClassifier;
+	private readonly ast?: AstService;
 
-	constructor(options: ScopeOptions, config: HoundsmanConfig) {
+	constructor(options: ScopeOptions, config: HoundsmanConfig, ast?: AstService) {
 		this.options = options;
 		this.classifier = new FileClassifier(config);
+		this.ast = ast;
 	}
 
 	/**
@@ -68,7 +75,10 @@ export class ReviewScopeResolver {
 	 * Incremental só quando há um `reviewed.headSha` anterior, o `HEAD` atual o
 	 * sucede (sem rebase) e não veio `--full`/`--clean`.
 	 */
-	resolve(previous: FindingsStateFile | null, headSha: string): ReviewScope {
+	async resolve(
+		previous: FindingsStateFile | null,
+		headSha: string,
+	): Promise<ReviewScope> {
 		const prevSha = previous?.reviewed?.headSha;
 
 		if (!this.options.full && !this.options.clean && prevSha === headSha) {
@@ -82,12 +92,25 @@ export class ReviewScopeResolver {
 			!isAncestor(prevSha, headSha)
 		) {
 			const diff = collectDiff(this.options.base, this.options.head);
+			const entries = parseEntries(
+				runGit([
+					"diff",
+					`${this.options.base}...${this.options.head}`,
+					"--name-status",
+				]),
+			);
+			const baseRef =
+				mergeBase(this.options.base, this.options.head) ?? this.options.base;
+			const ast = this.ast
+				? await this.ast.analyze(entries, diff, baseRef)
+				: undefined;
 			return {
 				kind: "review",
 				diff,
+				ast,
 				classification: {
 					...this.classifier
-						.classifyRange(this.options.base, this.options.head, diff)
+						.classify(entries, churnToRecord(diff.churn), factsOf(ast))
 						.toJSON(),
 					headSha,
 					mode: "full",
@@ -99,8 +122,11 @@ export class ReviewScopeResolver {
 		const diff = collectDiffSince(prevSha, headSha);
 		const entries = diffEntries(range);
 		const changedPaths = new Set(entries.map((entry) => entry.path));
+		const ast = this.ast ? await this.ast.analyze(entries, diff, prevSha) : undefined;
 		const classification: RunClassification = {
-			...this.classifier.classify(entries, churnToRecord(diff.churn)).toJSON(),
+			...this.classifier
+				.classify(entries, churnToRecord(diff.churn), factsOf(ast))
+				.toJSON(),
 			base: prevSha,
 			head: this.options.head,
 			headSha,
@@ -108,6 +134,26 @@ export class ReviewScopeResolver {
 			reviewedFrom: prevSha,
 			carryover: buildCarryover(previous, changedPaths),
 		};
-		return { kind: "review", classification, diff, reviewedFrom: prevSha };
+		return { kind: "review", classification, diff, reviewedFrom: prevSha, ast };
 	}
 }
+
+/** Fatos apenas dos arquivos presentes (deletados não classificam). */
+function factsOf(
+	analyses: ReadonlyMap<string, AstAnalysis> | undefined,
+): ReadonlyMap<string, AstFacts> | undefined {
+	if (!analyses) return undefined;
+	const facts = new Map<string, AstFacts>();
+	for (const [path, analysis] of analyses) {
+		if (!analysis.deleted) facts.set(path, analysis.facts);
+	}
+	return facts;
+}
+
+/** SHA do merge-base entre base e head (best effort). */
+function mergeBase(base: string, head: string): string | null {
+	const result = tryGit(["merge-base", base, head]);
+	if (!result.ok) return null;
+	const sha = result.stdout.trim();
+	return sha.length > 0 ? sha : null;
+}

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

@@ -4,6 +4,8 @@
  * É o ponto de entrada do `prepare`/`finalize` para o CLI e para o engine.
  */
 
+import type { AiClient } from "../ai/ai-client";
+import type { AstService } from "../ast/service";
 import type { HoundsmanConfig } from "../config";
 import {
 	type FinalizeResult,
@@ -24,6 +26,8 @@ export class ReviewSession {
 	readonly options: ReviewOptions;
 	readonly branch: string;
 	readonly context: ReviewContext;
+	private readonly ast?: AstService;
+	private readonly ai?: AiClient;
 
 	constructor(
 		config: HoundsmanConfig,
@@ -31,10 +35,14 @@ export class ReviewSession {
 		branch: string,
 		storage: StorageProvider,
 		repo: RepoIdentity,
+		ast?: AstService,
+		ai?: AiClient,
 	) {
 		this.config = config;
 		this.options = options;
 		this.branch = branch;
+		this.ast = ast;
+		this.ai = ai;
 		const review = options.finalize
 			? storage.findReview(repo.key, branch)
 			: storage.getOrCreateReview({
@@ -58,13 +66,30 @@ export class ReviewSession {
 		options: ReviewOptions,
 		storage: StorageProvider,
 		repo: RepoIdentity,
+		ast?: AstService,
+		ai?: AiClient,
 	): ReviewSession {
-		return new ReviewSession(config, options, resolveBranch(options), storage, repo);
+		return new ReviewSession(
+			config,
+			options,
+			resolveBranch(options),
+			storage,
+			repo,
+			ast,
+			ai,
+		);
 	}
 
 	/** Passo 1 — preparar. */
 	prepare(): Promise<PrepareResult> {
-		return prepare(this.options, this.branch, this.config, this.context);
+		return prepare(
+			this.options,
+			this.branch,
+			this.config,
+			this.context,
+			this.ast,
+			this.ai,
+		);
 	}
 
 	/** Passo 3 — finalizar. */

package/src/core/env.ts

@@ -0,0 +1,101 @@
+/**
+ * Variáveis de ambiente do houndsman (fonte única).
+ *
+ * O Bun carrega `.env` do diretório atual automaticamente; o motor lê tudo
+ * daqui em vez de espalhar `process.env.*` pelo código. Chaves ausentes ou
+ * vazias viram `undefined` — o chamador decide se o recurso é opcional.
+ */
+
+/**
+ * Nomes canônicos das variáveis.
+ *
+ * Toda chave de integração do houndsman usa o prefixo `HOUNDSMAN_` — evita
+ * colisão com envs do projeto consumidor. Apenas variáveis nativas do SO/CI
+ * (`LOCALAPPDATA`, `XDG_DATA_HOME`, `NO_COLOR`, `TERM`, `CI`) mantêm o nome
+ * global, porque são convenções do ambiente.
+ */
+export const ENV_NAMES = {
+	typeSafeApiKey: "HOUNDSMAN_TYPE_SAFE_API_KEY",
+	deepSeekApiKey: "HOUNDSMAN_DEEP_SEEK_API_KEY",
+	openAiApiKey: "HOUNDSMAN_OPENAI_API_KEY",
+	anthropicApiKey: "HOUNDSMAN_ANTHROPIC_API_KEY",
+	home: "HOUNDSMAN_HOME",
+	localAppData: "LOCALAPPDATA",
+	xdgDataHome: "XDG_DATA_HOME",
+	noColor: "NO_COLOR",
+	term: "TERM",
+	ci: "CI",
+} as const;
+
+/** Snapshot tipado do ambiente (sem expor segredos). */
+export type HoundsmanEnv = {
+	typeSafeApiKey?: string;
+	deepSeekApiKey?: string;
+	openAiApiKey?: string;
+	anthropicApiKey?: string;
+	home?: string;
+	localAppData?: string;
+	xdgDataHome?: string;
+	noColor?: string;
+	term?: string;
+	ci?: string;
+};
+
+/** Lê uma variável, apara espaços e trata vazio como ausente. */
+function read(name: string): string | undefined {
+	const value = process.env[name]?.trim();
+	return value && value.length > 0 ? value : undefined;
+}
+
+/** Snapshot do ambiente no momento da chamada. */
+export function readEnv(): HoundsmanEnv {
+	return {
+		typeSafeApiKey: read(ENV_NAMES.typeSafeApiKey),
+		deepSeekApiKey: read(ENV_NAMES.deepSeekApiKey),
+		openAiApiKey: read(ENV_NAMES.openAiApiKey),
+		anthropicApiKey: read(ENV_NAMES.anthropicApiKey),
+		home: read(ENV_NAMES.home),
+		localAppData: read(ENV_NAMES.localAppData),
+		xdgDataHome: read(ENV_NAMES.xdgDataHome),
+		noColor: read(ENV_NAMES.noColor),
+		term: read(ENV_NAMES.term),
+		ci: read(ENV_NAMES.ci),
+	};
+}
+
+/**
+ * Acesso sob demanda. Getter (em vez de constante congelada) mantém testes e
+ * processos que alteram o ambiente em runtime funcionando.
+ */
+export const env = {
+	get typeSafeApiKey(): string | undefined {
+		return read(ENV_NAMES.typeSafeApiKey);
+	},
+	get deepSeekApiKey(): string | undefined {
+		return read(ENV_NAMES.deepSeekApiKey);
+	},
+	get openAiApiKey(): string | undefined {
+		return read(ENV_NAMES.openAiApiKey);
+	},
+	get anthropicApiKey(): string | undefined {
+		return read(ENV_NAMES.anthropicApiKey);
+	},
+	get home(): string | undefined {
+		return read(ENV_NAMES.home);
+	},
+	get localAppData(): string | undefined {
+		return read(ENV_NAMES.localAppData);
+	},
+	get xdgDataHome(): string | undefined {
+		return read(ENV_NAMES.xdgDataHome);
+	},
+	get noColor(): string | undefined {
+		return read(ENV_NAMES.noColor);
+	},
+	get term(): string | undefined {
+		return read(ENV_NAMES.term);
+	},
+	get ci(): string | undefined {
+		return read(ENV_NAMES.ci);
+	},
+} as const;

package/src/core/file-classifier.ts

@@ -6,6 +6,7 @@
  */
 
 import { readFileSync } from "node:fs";
+import type { AstFacts } from "./ast/types";
 import type { HoundsmanConfig } from "./config";
 import { churnToRecord, collectChurn, type DiffSource } from "./diff-source";
 import { matchesClassifyRule } from "./domain/watchdog";
@@ -69,12 +70,13 @@ export function matchWatchdogs<TId extends string>(
 	watchdogs: Record<TId, WatchdogDefinition>,
 	watchdogIds: readonly TId[],
 	content?: string,
+	facts?: AstFacts,
 ): TId[] {
 	const ids: TId[] = [];
 	for (const id of watchdogIds) {
 		if (
 			watchdogs[id]?.classify?.some((rule) =>
-				matchesClassifyRule(filePath, rule, content),
+				matchesClassifyRule(filePath, rule, content, facts),
 			)
 		) {
 			ids.push(id);
@@ -88,6 +90,13 @@ export function isExcludedPath(filePath: string, patterns: readonly RegExp[]): b
 	return patterns.some((pattern) => pattern.test(filePath));
 }
 
+/** Id do watchdog de último recurso (primeiro declarado), se houver. */
+export function fallbackWatchdogId<TId extends string>(
+	config: HoundsmanConfig<TId>,
+): TId | undefined {
+	return config.watchdogIds.find((id) => config.watchdogs[id]?.fallback === true);
+}
+
 // ---------------------------------------------------------------------------
 // Parsing de `git diff --name-status`
 // ---------------------------------------------------------------------------
@@ -142,12 +151,15 @@ export function classifyEntries<TId extends string>(
 	entries: FileEntry[],
 	config: HoundsmanConfig<TId>,
 	churn: ChurnMap = {},
+	astFacts?: ReadonlyMap<string, AstFacts>,
 ): ClassificationResult {
 	const watchdogFiles: Record<string, string[]> = {};
 	const files: ClassificationResult["files"] = {};
 	const unclassified: string[] = [];
 	const excluded: string[] = [];
 	const deleted: string[] = [];
+	// Watchdog de último recurso: cobre apenas arquivos sem outro dono.
+	const fallbackId = fallbackWatchdogId(config);
 	// Leitura de conteúdo só é habilitada se algum watchdog declarar regra `content`.
 	const needsContent = hasContentRules(config.watchdogs, config.watchdogIds);
 
@@ -167,15 +179,23 @@ export function classifyEntries<TId extends string>(
 		}
 
 		const content = needsContent ? readFileContent(path) : undefined;
-		const ids: string[] = matchWatchdogs(
+		const facts = astFacts?.get(path);
+		const matched = matchWatchdogs(
 			path,
 			config.watchdogs,
 			config.watchdogIds,
 			content,
+			facts,
 		);
+		const ids = fallbackId ? matched.filter((id) => id !== fallbackId) : matched;
 
 		if (ids.length === 0) {
-			unclassified.push(path);
+			if (fallbackId) {
+				watchdogFiles[fallbackId] ??= [];
+				watchdogFiles[fallbackId].push(path);
+			} else {
+				unclassified.push(path);
+			}
 			continue;
 		}
 
@@ -218,10 +238,11 @@ export function classifyRange<TId extends string>(
 	head: string,
 	config: HoundsmanConfig<TId>,
 	diff?: DiffSource,
+	astFacts?: ReadonlyMap<string, AstFacts>,
 ): ClassificationResult {
 	const entries = parseEntries(runGit(["diff", `${base}...${head}`, "--name-status"]));
 	const churn = diff?.churn ?? collectChurn(base, head);
-	const result = classifyEntries(entries, config, churnToRecord(churn));
+	const result = classifyEntries(entries, config, churnToRecord(churn), astFacts);
 	result.base = base;
 	result.head = head;
 	return result;

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

@@ -5,13 +5,14 @@
  * pipeline de review sem dependências novas de SDK e com tipagem explícita
  * do request/response (`./jev-types`).
  *
- * Config: apenas `TYPESAFE_API_KEY` (via env). Origem e modelo da API são
- * fixos no código (constantes abaixo).
+ * Config: apenas `HOUNDSMAN_TYPE_SAFE_API_KEY` (via `core/env.ts`). Origem e
+ * modelo da API são fixos no código (constantes abaixo).
  *
  * Erros são normalizados em `JevError` — o chamador decide falhar-aberto.
  */
 
 import axios, { type AxiosInstance, isAxiosError } from "axios";
+import { ENV_NAMES, env } from "../env";
 import type { JevEvaluateRequest, JevEvaluateResponse } from "./jev-types";
 
 const DEFAULT_BASE_URL = "https://api.typesafe.ai";
@@ -19,7 +20,7 @@ const DEFAULT_MODEL = "jev-latest";
 const DEFAULT_TIMEOUT_MS = 20_000;
 /** Timeout da verificação de credencial do `doctor` (mais curto que o de review). */
 const DEFAULT_PING_TIMEOUT_MS = 10_000;
-/** Caminho fixo do endpoinft System One. */
+/** Caminho fixo do endpoint System One. */
 const JEV_PATH = "/v1/systemone";
 
 export class JevError extends Error {
@@ -39,7 +40,7 @@ export type JevCredentialCheck =
 	| { ok: false; kind: "invalid" | "unreachable"; detail: string };
 
 export type JevClientOptions = {
-	/** Chave de API (default: `process.env.TYPESAFE_API_KEY`). */
+	/** Chave de API (default: `env.typeSafeApiKey`). */
 	apiKey?: string;
 	/** Sobreposição da origem da API (default: constante `DEFAULT_BASE_URL`). */
 	baseURL?: string;
@@ -57,7 +58,7 @@ export class JevClient {
 	readonly model: string;
 
 	constructor(options: JevClientOptions = {}) {
-		this.apiKey = options.apiKey ?? process.env.TYPESAFE_API_KEY;
+		this.apiKey = options.apiKey ?? env.typeSafeApiKey;
 		this.model = options.model ?? DEFAULT_MODEL;
 		const baseURL = options.baseURL ?? DEFAULT_BASE_URL;
 		this.http =
@@ -79,7 +80,7 @@ export class JevClient {
 	 */
 	async evaluate(request: JevEvaluateRequest): Promise<JevEvaluateResponse> {
 		if (!this.apiKey) {
-			throw new JevError("TYPESAFE_API_KEY não configurada.");
+			throw new JevError(`${ENV_NAMES.typeSafeApiKey} não configurada.`);
 		}
 		try {
 			const { data } = await this.http.post<JevEvaluateResponse>(
@@ -105,7 +106,7 @@ export class JevClient {
 			return {
 				ok: false,
 				kind: "unreachable",
-				detail: "TYPESAFE_API_KEY não configurada.",
+				detail: `${ENV_NAMES.typeSafeApiKey} não configurada.`,
 			};
 		}
 		const request: JevEvaluateRequest = {

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

@@ -7,6 +7,7 @@
  * decide. O custo é uma chamada por arquivo ambíguo, não uma revisão completa.
  */
 
+import { ENV_NAMES } from "../env";
 import { diffPatch, readFileAt } from "../git-revision";
 import type { JevClient } from "./jev-client";
 import type { JevAnswer, JevQuestion } from "./jev-types";
@@ -104,7 +105,7 @@ export class JevVerifier {
 				confidence,
 				checked: 0,
 				skipped: cases.length,
-				reason: "TYPESAFE_API_KEY não configurada",
+				reason: `${ENV_NAMES.typeSafeApiKey} não configurada`,
 			};
 		}
 

package/src/core/logging/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Instância pronta do logger (`import { logger } from "../core/logging"`).
+ *
+ * Infraestrutura compartilhada por `cli`, `harness` e `server`. Módulos de
+ * negócio do core não escrevem saída.
+ */
+
+import { Logger } from "./logger";
+
+export const logger = new Logger();
+
+export type {
+	LoggerLike,
+	LoggerOptions,
+	SpinnerLike,
+} from "./logger";
+export { Logger, SilentLogger } from "./logger";