@payconductor/houndsman 0.12.0 → 0.13.0

package/src/cli/index.ts

@@ -15,6 +15,7 @@
  *   --finalize           Passo 3 — consolidar os findings em review.md
  *   context              Passo 0 — coletar o contexto da PR via `gh`
  *   findings <sub>       Triagem/correção dos findings (list/set/done/sync/batch/verify/submit/...)
+ *   hunt [flags]         Harness local (maki): prepare → watchdogs via maki → finalize
  *   status [ping]        Mostra o status da run; `ping` renova o heartbeat da execução
  *   server               Sobe a UI local de triagem (Bun.serve)
  *   setup                Cria a configuração inicial do projeto (config + skills)
@@ -30,7 +31,7 @@
 import type { HoundsmanConfig } from "../core/config";
 import { loadConfig } from "../core/config-loader";
 import { HoundsmanEngine } from "../core/engine/houndsman-engine";
-import { logger } from "../core/logging";
+import { formatDuration, logger } from "../core/logging";
 import { syncProjectLayerForRoot } from "../core/services/worktree-manager";
 import { ArgParser } from "./arg-parser";
 import type { CliContext } from "./commands/command";
@@ -38,6 +39,7 @@ import { ContextCommand } from "./commands/context-command";
 import { DoctorCommand } from "./commands/doctor-command";
 import { FindingsCommand } from "./commands/findings-command";
 import { HelpCommand } from "./commands/help-command";
+import { HuntCommand } from "./commands/hunt-command";
 import { CommandRegistry } from "./commands/registry";
 import { ReviewCommand } from "./commands/review-command";
 import { ServerCommand } from "./commands/server-command";
@@ -57,6 +59,7 @@ function buildRegistry(): CommandRegistry {
 	return new CommandRegistry()
 		.register(new ReviewCommand(), { fallback: true })
 		.register(new HelpCommand())
+		.register(new HuntCommand())
 		.register(new ContextCommand())
 		.register(new FindingsCommand())
 		.register(new StatusCommand())
@@ -88,14 +91,26 @@ export async function main(): Promise<void> {
 	}
 
 	let loaded: Awaited<ReturnType<typeof loadConfig>> | null = null;
+	// `--json` é contrato de máquina: nada de progresso no stdout.
+	const silentProgress = parser.has("--json");
 	const config = async (): Promise<HoundsmanConfig> => {
 		loaded ??= await (async () => {
+			const started = Date.now();
+			if (!silentProgress) logger.step("Carregando a configuração do projeto…");
 			// Rodando dentro de um worktree, a camada gerada (`.houndsman/core`)
 			// não existe (é ignorada pelo git). Repõe a partir do clone principal
 			// antes de importar a config — sem isso os watchdogs não resolvem
 			// `../core/types`. No clone principal é no-op.
 			syncProjectLayerForRoot(process.cwd());
-			return loadConfig({ configPath: parser.value("--config") });
+			const result = await loadConfig({ configPath: parser.value("--config") });
+			if (!silentProgress) {
+				logger.success(
+					`Configuração: ${result.config.projectName} · ` +
+						`${result.config.watchdogIds.length} watchdog(s) ` +
+						`(${formatDuration(Date.now() - started)})`,
+				);
+			}
+			return result;
 		})();
 		return loaded.config;
 	};

package/src/cli/progress.ts

@@ -0,0 +1,45 @@
+/**
+ * Progresso do CLI por etapa do prepare (apresentação).
+ *
+ * O core emite eventos (`PrepareProgressEvent`); aqui eles viram spinner/linha
+ * com a duração de cada fase — o `hunt` começa a dar sinal de vida antes do
+ * primeiro `Discovery:`.
+ */
+
+import { formatDuration, type LoggerLike, PhaseReporter } from "../core/logging";
+import type { PrepareProgress, PrepareStage } from "../core/orchestrator";
+
+/** Texto de cada etapa (início no gerúndio, fim no particípio). */
+export const PREPARE_STAGE_TEXT: Record<PrepareStage, { start: string; done: string }> = {
+	diff: { start: "Lendo o diff da revisão", done: "Diff lido" },
+	ast: { start: "Analisando a AST dos arquivos alterados", done: "AST analisada" },
+	classify: {
+		start: "Classificando os arquivos por watchdog",
+		done: "Classificação concluída",
+	},
+	impact: { start: "Medindo o impacto nos importadores", done: "Impacto calculado" },
+	jev: { start: "Pré-analisando o diff (Jev/IA)", done: "Pré-análise concluída" },
+	context: { start: "Resumindo o contexto da PR", done: "Contexto resumido" },
+	technical: {
+		start: "Consolidando os pontos técnicos",
+		done: "Pontos técnicos prontos",
+	},
+	"ai-plans": { start: "Planejando os briefs com IA", done: "Planos de brief prontos" },
+	briefs: { start: "Gerando os briefs", done: "Briefs gerados" },
+	manifest: { start: "Gravando o manifesto da revisão", done: "Manifesto gravado" },
+};
+
+/** Cria o callback de progresso do prepare ligado ao logger do CLI. */
+export function prepareProgress(logger: LoggerLike): PrepareProgress {
+	const reporter = new PhaseReporter(logger);
+	return (event) => {
+		const text = PREPARE_STAGE_TEXT[event.stage];
+		if (event.type === "start") reporter.begin(event.stage, text.start);
+		else reporter.end(event.stage, text.done, event.durationMs);
+	};
+}
+
+/** Log de um passo concluído com a duração (usado fora do prepare). */
+export function stepDone(logger: LoggerLike, message: string, startedMs: number): void {
+	logger.success(`${message} (${formatDuration(Date.now() - startedMs)})`);
+}

package/src/core/ai/ai-sdk-model-provider.ts

@@ -31,6 +31,43 @@ function numberOrZero(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 
+/**
+ * Silencia o emissor default de avisos do AI SDK.
+ *
+ * O default usa `process.emitWarning` — com stack trace — a cada chamada, o que
+ * polui o stderr do CLI. Os avisos continuam disponíveis no resultado da
+ * chamada (`ModelResponse.warnings`). Um chamador que queira o comportamento
+ * original basta definir `AI_SDK_LOG_WARNINGS` antes de usar o SDK.
+ */
+function installWarningSink(): void {
+	if (globalThis.AI_SDK_LOG_WARNINGS === undefined) {
+		globalThis.AI_SDK_LOG_WARNINGS = () => {};
+	}
+}
+
+installWarningSink();
+
+/** Normaliza um aviso do provider em texto legível (puro). */
+export function formatSdkWarning(raw: unknown): string {
+	const warning = (raw ?? {}) as Record<string, unknown>;
+	const label = [warning.type, warning.feature, warning.setting]
+		.filter((value): value is string => typeof value === "string" && value !== "")
+		.join(": ");
+	const detail =
+		typeof warning.details === "string"
+			? warning.details
+			: typeof warning.message === "string"
+				? warning.message
+				: "";
+	const head = label || "aviso";
+	return detail ? `${head} — ${detail}` : head;
+}
+
+/** Lista de avisos do provider em texto (puro). */
+export function formatSdkWarnings(raw: unknown): string[] {
+	return Array.isArray(raw) ? raw.map(formatSdkWarning) : [];
+}
+
 /** Argumentos aceitos por `generateText` (inclui `providerOptions` do SDK). */
 type GenerateTextArgs = Parameters<typeof generateText>[0];
 
@@ -86,10 +123,12 @@ export class AiSdkModelProvider implements ModelProvider {
 			const output = request.outputSchema
 				? (result.output as T)
 				: ((result.text ?? "") as unknown as T);
+			const warnings = formatSdkWarnings(result.warnings);
 			return {
 				output,
 				usage: mapUsage(result.usage),
 				finishReason: result.finishReason ?? "unknown",
+				...(warnings.length > 0 ? { warnings } : {}),
 			};
 		} catch (error) {
 			if (error instanceof Error && error.name === "AbortError") {

package/src/core/ai/index.ts

@@ -10,7 +10,12 @@ export type {
 	TextRequest,
 } from "./ai-client";
 export { AiClient } from "./ai-client";
-export { AiSdkModelProvider, mapUsage } from "./ai-sdk-model-provider";
+export {
+	AiSdkModelProvider,
+	formatSdkWarning,
+	formatSdkWarnings,
+	mapUsage,
+} from "./ai-sdk-model-provider";
 export {
 	AiBudgetError,
 	AiConfigurationError,

package/src/core/ai/types.ts

@@ -50,6 +50,8 @@ export type ModelResponse<T> = {
 	output: T;
 	usage: AiUsage;
 	finishReason: string;
+	/** Avisos do provider já normalizados em texto (ex.: modo de compatibilidade). */
+	warnings?: string[];
 };
 
 /** Provider de modelo (adaptador do AI SDK ou fake nos testes). */

package/src/core/commands/scaffold.ts

@@ -242,6 +242,16 @@ export type HoundsmanAi = {
 	watchdogs?: Record<string, HoundsmanAiWatchdog>;
 };
 
+/** Harness local da capability \`hunt\` (\`houndsman hunt\`) — opcional. */
+export type HoundsmanHunt = {
+	enabled?: boolean;
+	model?: string;
+	concurrency?: number;
+	timeoutMs?: number;
+	retries?: number;
+	binaryPath?: string;
+};
+
 /** Contrato de configuração do motor. */
 export type HoundsmanConfig<TId extends string = string> = {
 	projectName: string;
@@ -255,6 +265,7 @@ export type HoundsmanConfig<TId extends string = string> = {
 	concurrency?: HoundsmanConcurrency;
 	ast?: HoundsmanAst;
 	ai?: HoundsmanAi;
+	hunt?: HoundsmanHunt;
 };
 
 /** Helper de autoria (identidade) — apenas tipagem. */

package/src/core/config.ts

@@ -19,7 +19,11 @@ export {
 	DEFAULT_ALWAYS_INCLUDE_DOCS,
 	DEFAULT_AST_MAX_FILE_BYTES,
 	DEFAULT_AST_MAX_IMPACT_FILES,
+	DEFAULT_HUNT_CONCURRENCY,
+	DEFAULT_HUNT_RETRIES,
+	DEFAULT_HUNT_TIMEOUT_MS,
 	DEFAULT_JEV_CONCURRENCY,
+	DEFAULT_MAKI_VERSION,
 	DEFAULT_MAX_FILES_PER_BRIEF,
 } from "./defaults";
 
@@ -122,6 +126,28 @@ export type HoundsmanWorktrees = {
 	location?: "home" | "workspace" | string;
 };
 
+/**
+ * Harness local da capability `hunt` (`houndsman hunt`) — opcional.
+ *
+ * Sem esta config, o comando usa defaults seguros: modelo derivado de `ai`,
+ * 4 processos simultâneos e timeout de 15 min por watchdog. A skill
+ * `/houndsman hunt` (harness externo) não depende deste bloco.
+ */
+export type HoundsmanHunt = {
+	/** Desliga o harness local sem desinstalar o binário (default: ligado). */
+	enabled?: boolean;
+	/** Modelo no formato do maki (`provider/model-id`). Default: derivado de `ai`. */
+	model?: string;
+	/** Processos maki simultâneos (default: 4). */
+	concurrency?: number;
+	/** Timeout por watchdog em ms (default: 900_000). */
+	timeoutMs?: number;
+	/** Tentativas extras quando a saída do watchdog é inválida (default: 1). */
+	retries?: number;
+	/** Caminho explícito do binário (`HOUNDSMAN_MAKI_PATH` tem precedência). */
+	binaryPath?: string;
+};
+
 /** Backend de persistência (reviews, findings e artefatos). */
 export type HoundsmanStorage = {
 	/**
@@ -169,6 +195,8 @@ export type HoundsmanConfig<TId extends string = string> = {
 	ast?: HoundsmanAst;
 	/** Camada de IA (briefs, contexto, classificação, pré-análise e verify). */
 	ai?: HoundsmanAi;
+	/** Harness local da capability `hunt` (maki) — opcional. */
+	hunt?: HoundsmanHunt;
 };
 
 /** Entrada de `defineHoundsmanConfig` — `watchdogIds` é derivado, não informado. */

package/src/core/defaults.ts

@@ -46,3 +46,18 @@ 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;
+
+/** Processos maki simultâneos no harness local (`houndsman hunt`). */
+export const DEFAULT_HUNT_CONCURRENCY = 4;
+
+/** Timeout default de um watchdog no harness local (15 min). */
+export const DEFAULT_HUNT_TIMEOUT_MS = 900_000;
+
+/** Retentativas default quando a saída do watchdog é inválida. */
+export const DEFAULT_HUNT_RETRIES = 1;
+
+/**
+ * Versão do maki fixada pelo houndsman. O binário é baixado por
+ * `houndsman hunt install`; `HOUNDSMAN_MAKI_VERSION` sobrescreve.
+ */
+export const DEFAULT_MAKI_VERSION = "0.6.5";

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

@@ -57,23 +57,37 @@ export type ReviewScope =
 			ast?: Map<string, AstAnalysis>;
 	  };
 
+/** Etapas da resolução de escopo reportadas ao CLI (sem log no core). */
+export type ScopeStage = "diff" | "ast" | "classify";
+
+/** Evento de progresso de uma etapa do escopo. */
+export type ScopeProgressEvent =
+	| { type: "start"; stage: ScopeStage }
+	| { type: "done"; stage: ScopeStage; durationMs: number };
+
+/** Callback de progresso (falhas do callback são ignoradas). */
+export type ScopeProgress = (event: ScopeProgressEvent) => void;
+
 /** Decide entre review completo e incremental. */
 export class ReviewScopeResolver {
 	private readonly options: ScopeOptions;
 	private readonly classifier: FileClassifier;
 	private readonly ast?: AstService;
 	private readonly git: GitRepository;
+	private readonly onProgress?: ScopeProgress;
 
 	constructor(
 		options: ScopeOptions,
 		config: HoundsmanConfig,
 		ast?: AstService,
 		git: GitRepository = new GitRepository(),
+		onProgress?: ScopeProgress,
 	) {
 		this.options = options;
 		this.classifier = new FileClassifier(config);
 		this.ast = ast;
 		this.git = git;
+		this.onProgress = onProgress;
 	}
 
 	/**
@@ -100,24 +114,33 @@ export class ReviewScopeResolver {
 			!prevSha ||
 			!this.git.isAncestor(prevSha, headSha)
 		) {
-			const diff = this.git.collectDiff(this.options.base, this.options.head);
-			const entries = parseEntries(
-				this.git.diffNameStatus(this.options.base, this.options.head),
-			);
-			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, scopeDiff, baseRef)
+			const diffData = this.step("diff", () => {
+				const diff = this.git.collectDiff(this.options.base, this.options.head);
+				const entries = parseEntries(
+					this.git.diffNameStatus(this.options.base, this.options.head),
+				);
+				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,
+				);
+				return { diff, entries, baseRef, scopeDiff };
+			});
+			const { diff, entries, baseRef, scopeDiff } = diffData;
+			const astService = this.ast;
+			const ast = astService
+				? await this.stepAsync("ast", () =>
+						astService.analyze(entries, scopeDiff, baseRef),
+					)
 				: undefined;
-			const result = this.classifier
-				.classify(entries, churnToRecord(diff.churn), factsOf(ast))
-				.toJSON();
+			const result = this.step("classify", () =>
+				this.classifier
+					.classify(entries, churnToRecord(diff.churn), factsOf(ast))
+					.toJSON(),
+			);
 			return {
 				kind: "review",
 				diff,
@@ -136,16 +159,25 @@ export class ReviewScopeResolver {
 		}
 
 		const range = `${prevSha}..${headSha}`;
-		const diff = this.git.collectDiffSince(prevSha, headSha);
-		const entries = parseEntries(this.git.run(["diff", range, "--name-status"]));
+		const diffData = this.step("diff", () => {
+			const diff = this.git.collectDiffSince(prevSha, headSha);
+			const entries = parseEntries(this.git.run(["diff", range, "--name-status"]));
+			const scopeDiff = this.zeroContext(range, diff);
+			return { diff, entries, scopeDiff };
+		});
+		const { diff, entries, scopeDiff } = diffData;
 		const changedPaths = new Set(entries.map((entry) => entry.path));
-		const scopeDiff = this.zeroContext(range, diff);
-		const ast = this.ast
-			? await this.ast.analyze(entries, scopeDiff, prevSha)
+		const astService = this.ast;
+		const ast = astService
+			? await this.stepAsync("ast", () =>
+					astService.analyze(entries, scopeDiff, prevSha),
+				)
 			: undefined;
-		const result = this.classifier
-			.classify(entries, churnToRecord(diff.churn), factsOf(ast))
-			.toJSON();
+		const result = this.step("classify", () =>
+			this.classifier
+				.classify(entries, churnToRecord(diff.churn), factsOf(ast))
+				.toJSON(),
+		);
 		const classification: RunClassification = {
 			...result,
 			base: prevSha,
@@ -163,6 +195,41 @@ export class ReviewScopeResolver {
 		return { kind: "review", classification, diff, reviewedFrom: prevSha, ast };
 	}
 
+	/**
+	 * Executa uma etapa síncrona reportando início/fim. O callback de progresso
+	 * é diagnóstico: nunca derruba a resolução.
+	 */
+	private step<T>(stage: ScopeStage, run: () => T): T {
+		if (!this.onProgress) return run();
+		const started = Date.now();
+		this.report({ type: "start", stage });
+		try {
+			return run();
+		} finally {
+			this.report({ type: "done", stage, durationMs: Date.now() - started });
+		}
+	}
+
+	/** Versão assíncrona de `step`. */
+	private async stepAsync<T>(stage: ScopeStage, run: () => Promise<T> | T): Promise<T> {
+		if (!this.onProgress) return run();
+		const started = Date.now();
+		this.report({ type: "start", stage });
+		try {
+			return await run();
+		} finally {
+			this.report({ type: "done", stage, durationMs: Date.now() - started });
+		}
+	}
+
+	private report(event: ScopeProgressEvent): void {
+		try {
+			this.onProgress?.(event);
+		} catch {
+			// Progresso nunca derruba a revisão.
+		}
+	}
+
 	/** Patch `-U0` do intervalo; falha aberta cai no diff já coletado. */
 	private zeroContext(range: string, fallback: DiffSource): DiffSource {
 		try {

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

@@ -11,6 +11,7 @@ import { createGitRunner } from "../git-runner";
 import {
 	type FinalizeResult,
 	finalize,
+	type PrepareProgress,
 	type PrepareResult,
 	prepare,
 	type ReviewContext,
@@ -104,7 +105,7 @@ export class ReviewSession {
 	}
 
 	/** Passo 1 — preparar. */
-	prepare(): Promise<PrepareResult> {
+	prepare(onProgress?: PrepareProgress): Promise<PrepareResult> {
 		return prepare(
 			this.options,
 			this.branch,
@@ -112,6 +113,7 @@ export class ReviewSession {
 			this.context,
 			this.ast,
 			this.ai,
+			onProgress,
 		);
 	}
 
@@ -121,7 +123,9 @@ export class ReviewSession {
 	}
 
 	/** Executa o passo escolhido em `--finalize`. */
-	run(): Promise<PrepareResult | FinalizeResult> {
-		return this.options.finalize ? Promise.resolve(this.finalize()) : this.prepare();
+	run(onProgress?: PrepareProgress): Promise<PrepareResult | FinalizeResult> {
+		return this.options.finalize
+			? Promise.resolve(this.finalize())
+			: this.prepare(onProgress);
 	}
 }

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

@@ -35,6 +35,8 @@ export type WorkspaceDeps = {
 	worktreesLocation?: string;
 	/** Override explícito da raiz de worktrees (testes). */
 	worktreesRoot?: string;
+	/** Passos longos (gh/worktree) reportados ao CLI; nunca lança. */
+	onProgress?: (message: string) => void;
 };
 
 /** Workspace resolvido para a revisão. */
@@ -85,6 +87,14 @@ export function resolveReviewWorkspace(
 	deps: WorkspaceDeps = {},
 ): ResolvedWorkspace {
 	const messages: string[] = [];
+	/** Progresso é diagnóstico: nunca derruba a resolução. */
+	const report = (message: string): void => {
+		try {
+			deps.onProgress?.(message);
+		} catch {
+			// Progresso nunca derruba a revisão.
+		}
+	};
 	const cwdGit = repoAt(request.cwd);
 	const cwdRoot = resolve(cwdGit.rootPath() ?? request.cwd);
 	const mainRoot = resolve(mainRootOf(cwdGit, cwdRoot));
@@ -108,6 +118,7 @@ export function resolveReviewWorkspace(
 		// 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);
+		report("Sincronizando a camada gerada no worktree…");
 		syncProjectLayer(explicitMainRoot, root);
 		return {
 			root,
@@ -129,6 +140,7 @@ export function resolveReviewWorkspace(
 			deps.ghRunner ?? createGhRunner(mainRoot),
 			mainGit,
 		);
+		report(`Consultando a PR #${request.pr} via gh…`);
 		const resolved = resolver.resolve(request.pr);
 		if (!resolved.ok) {
 			throw new Error(
@@ -136,6 +148,7 @@ export function resolveReviewWorkspace(
 			);
 		}
 		const { pr } = resolved;
+		report("Buscando as refs da PR…");
 		const refs = resolver.prepareRefs(pr);
 		if (refs.warning) messages.push(`GitHub: ${refs.warning}`);
 
@@ -146,6 +159,7 @@ export function resolveReviewWorkspace(
 				deps.worktreesRoot ??
 				resolveWorktreesRoot(deps.worktreesLocation, mainRoot),
 		});
+		report("Criando/reutilizando o worktree da PR…");
 		const worktree = manager.ensure({ branch: pr.headRefName, ref: refs.head });
 		const worktreePath = resolve(worktree.path);
 		messages.push(

package/src/core/env.ts

@@ -19,6 +19,8 @@ export const ENV_NAMES = {
 	deepSeekApiKey: "HOUNDSMAN_DEEP_SEEK_API_KEY",
 	openAiApiKey: "HOUNDSMAN_OPENAI_API_KEY",
 	anthropicApiKey: "HOUNDSMAN_ANTHROPIC_API_KEY",
+	makiPath: "HOUNDSMAN_MAKI_PATH",
+	makiVersion: "HOUNDSMAN_MAKI_VERSION",
 	home: "HOUNDSMAN_HOME",
 	localAppData: "LOCALAPPDATA",
 	xdgDataHome: "XDG_DATA_HOME",
@@ -33,6 +35,10 @@ export type HoundsmanEnv = {
 	deepSeekApiKey?: string;
 	openAiApiKey?: string;
 	anthropicApiKey?: string;
+	/** Caminho explícito do binário do maki (harness local `hunt`). */
+	makiPath?: string;
+	/** Versão do maki a instalar (default: a fixada pelo pacote). */
+	makiVersion?: string;
 	home?: string;
 	localAppData?: string;
 	xdgDataHome?: string;
@@ -54,6 +60,8 @@ export function readEnv(): HoundsmanEnv {
 		deepSeekApiKey: read(ENV_NAMES.deepSeekApiKey),
 		openAiApiKey: read(ENV_NAMES.openAiApiKey),
 		anthropicApiKey: read(ENV_NAMES.anthropicApiKey),
+		makiPath: read(ENV_NAMES.makiPath),
+		makiVersion: read(ENV_NAMES.makiVersion),
 		home: read(ENV_NAMES.home),
 		localAppData: read(ENV_NAMES.localAppData),
 		xdgDataHome: read(ENV_NAMES.xdgDataHome),
@@ -80,6 +88,12 @@ export const env = {
 	get anthropicApiKey(): string | undefined {
 		return read(ENV_NAMES.anthropicApiKey);
 	},
+	get makiPath(): string | undefined {
+		return read(ENV_NAMES.makiPath);
+	},
+	get makiVersion(): string | undefined {
+		return read(ENV_NAMES.makiVersion);
+	},
 	get home(): string | undefined {
 		return read(ENV_NAMES.home);
 	},