@payconductor/houndsman 0.12.0 → 0.14.0

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

@@ -0,0 +1,51 @@
+/**
+ * Contexto de uma run (engine) — storage + review + staging + raiz operacional.
+ *
+ * É criado uma vez por `ReviewSession` e injetado nas pipelines. Não existe
+ * contexto ambiente: duas runs concorrentes no mesmo processo mantêm contextos
+ * isolados (um singleton mutável trocaria root/git/storage entre `await`s).
+ */
+
+import { GitRepository } from "../services/git-repository";
+import { ProjectFiles } from "../services/project-files";
+import type { ReviewRecord, StorageProvider } from "../storage/types";
+import { ReviewWorkArea } from "../storage/work-area";
+
+/** Workspace onde os arquivos da review são lidos. */
+export type ReviewWorkspaceContext = {
+	/** Raiz operacional (worktree ou clone principal). */
+	root?: string;
+	/** Raiz do clone principal (identidade/config). */
+	mainRoot?: string;
+	git?: GitRepository;
+};
+
+/** Contexto de uma run: storage + review + staging + raiz operacional. */
+export type ReviewContext = {
+	storage: StorageProvider;
+	review: ReviewRecord;
+	work: ReviewWorkArea;
+	root: string;
+	mainRoot: string;
+	git: GitRepository;
+	/** Leitor relativo à raiz operacional (evita repetir `fileReader(root)`). */
+	files: ProjectFiles;
+};
+
+/** Cria o contexto de uma review existente. */
+export function reviewContext(
+	storage: StorageProvider,
+	review: ReviewRecord,
+	workspace: ReviewWorkspaceContext = {},
+): ReviewContext {
+	const root = workspace.root ?? process.cwd();
+	return {
+		storage,
+		review,
+		work: new ReviewWorkArea(review),
+		root,
+		mainRoot: workspace.mainRoot ?? root,
+		git: workspace.git ?? new GitRepository(),
+		files: new ProjectFiles(root),
+	};
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Opções de uma run (flags do CLI já resolvidas).
+ *
+ * Fica fora do `orchestrator` para as pipelines importarem o tipo sem ciclo.
+ */
+
+export type ReviewOptions = {
+	base: string;
+	head: string;
+	branch?: string;
+	/**
+	 * Rótulo da variante A/B. Cada variante vira uma run própria
+	 * (`repoKey`, `branch`, `variant`) — permite comparar sem apagar a anterior.
+	 */
+	variant?: string;
+	finalize: boolean;
+	failOnBlocking: boolean;
+	clean: boolean;
+	noJev: boolean;
+	/** Desativa a análise estrutural (AST) nesta run. */
+	noAst: boolean;
+	/** Força review completo (ignora o modo incremental). */
+	full: boolean;
+	/** Desativa as features de IA do fluxo normal. */
+	noAi: boolean;
+	/** PR de origem (resolvida via `--pr`). */
+	pr?: number;
+	/** Worktree informado via flag (`--worktree`). */
+	worktree?: string;
+	/** Worktree resolvido (absoluto; ausente = clone principal). */
+	worktreePath?: string;
+};
+
+/** Valores default das opções (o CLI sobrepõe com as flags). */
+export function defaultOptions(): ReviewOptions {
+	return {
+		base: "main",
+		head: "HEAD",
+		finalize: false,
+		failOnBlocking: false,
+		clean: false,
+		noJev: false,
+		noAst: false,
+		full: false,
+		noAi: false,
+	};
+}

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

@@ -52,28 +52,47 @@ export type ReviewScope =
 			kind: "review";
 			classification: RunClassification;
 			diff: DiffSource;
+			/**
+			 * Patch `-U0` sem truncar (path → hunks). É o insumo dos briefs: cada
+			 * watchdog recebe os trechos alterados em vez de reler arquivos inteiros.
+			 */
+			patch: Map<string, string>;
 			reviewedFrom?: string;
 			/** Fatos/delta por arquivo alterado (quando o AST está habilitado). */
 			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,27 +119,37 @@ 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,
+				patch: scopeDiff.byFile,
 				ast,
 				classification: {
 					...result,
@@ -136,16 +165,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,
@@ -160,7 +198,49 @@ export class ReviewScopeResolver {
 				ast,
 			}),
 		};
-		return { kind: "review", classification, diff, reviewedFrom: prevSha, ast };
+		return {
+			kind: "review",
+			classification,
+			diff,
+			patch: scopeDiff.byFile,
+			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. */

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,
@@ -19,7 +20,7 @@ import {
 	resolveBranch,
 	reviewContext,
 } from "../orchestrator";
-import { sanitizeBranch } from "../report-builder";
+import { reviewSlug } from "../report-builder";
 import { GitRepository } from "../services/git-repository";
 import type { RepoIdentity, StorageProvider } from "../storage/types";
 
@@ -47,12 +48,14 @@ export class ReviewSession {
 		this.branch = branch;
 		this.ast = ast;
 		this.ai = ai;
+		const variant = options.variant?.trim() || undefined;
 		const review = options.finalize
-			? storage.findReview(repo.key, branch)
+			? storage.findReview(repo.key, branch, variant)
 			: storage.getOrCreateReview({
 					repo,
 					branch,
-					slug: sanitizeBranch(branch),
+					variant,
+					slug: reviewSlug(branch, variant),
 					base: options.base,
 					head: options.head,
 					worktreePath: options.worktreePath,
@@ -60,7 +63,7 @@ export class ReviewSession {
 				});
 		if (!review) {
 			throw new Error(
-				`Nenhuma revisão para '${branch}'. Rode \`houndsman\` (preparar) primeiro.`,
+				`Nenhuma revisão para '${branch}'${variant ? ` (variante '${variant}')` : ""}. Rode \`houndsman\` (preparar) primeiro.`,
 			);
 		}
 		// Um prepare no clone principal invalida um worktree usado antes; o finalize
@@ -104,24 +107,23 @@ export class ReviewSession {
 	}
 
 	/** Passo 1 — preparar. */
-	prepare(): Promise<PrepareResult> {
-		return prepare(
-			this.options,
-			this.branch,
-			this.config,
-			this.context,
-			this.ast,
-			this.ai,
-		);
+	prepare(onProgress?: PrepareProgress): Promise<PrepareResult> {
+		return prepare(this.context, this.config, this.options, {
+			ast: this.ast,
+			ai: this.ai,
+			onProgress,
+		});
 	}
 
 	/** Passo 3 — finalizar. */
 	finalize(): FinalizeResult {
-		return finalize(this.options, this.branch, this.config, this.context);
+		return finalize(this.context, this.config, this.options);
 	}
 
 	/** 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/engine/run-artifacts.ts

@@ -0,0 +1,196 @@
+/**
+ * Artefatos persistidos de uma run (engine) — leitura/escrita tipada.
+ *
+ * Concentra `classification`, `candidates`, `manifest`, resumos e contexto para
+ * que as pipelines não repitam `storage.readArtifact(...)`.
+ */
+
+import type { AstAnalysis, AstImpact } from "../ast/types";
+import { GENERAL_WATCHDOG_ID } from "../builtins";
+import { type BusinessSummary, parseBusinessSummary } from "../business-summary";
+import type { HoundsmanConfig } from "../config";
+import { type JevCandidatesFile, JevCandidatesStore, parseCandidates } from "../jev";
+import {
+	BUSINESS_BRIEF_FILE,
+	BUSINESS_SUMMARY_FILE,
+	TECHNICAL_SUMMARY_FILE,
+} from "../paths";
+import type {
+	ManifestAi,
+	ManifestAst,
+	ManifestBusiness,
+} from "../renderers/manifest-writer";
+import { type ContextSummary, parseContextSummary } from "../report-builder";
+import type { ReviewRecord, StorageProvider } from "../storage/types";
+import type { ReviewWorkArea } from "../storage/work-area";
+import {
+	buildTechnicalSummary,
+	parseTechnicalSummary,
+	type TechnicalSummary,
+} from "../technical-summary";
+import type { RunClassification } from "./review-scope";
+
+/** Acesso tipado aos artefatos de uma review. */
+export class RunArtifacts {
+	constructor(
+		private readonly storage: StorageProvider,
+		private readonly review: ReviewRecord,
+		private readonly work: ReviewWorkArea,
+	) {}
+
+	/** JSON persistido, ou `null` quando ausente/inválido. */
+	json<T>(name: string): T | null {
+		const artifact = this.storage.readArtifact(this.review.id, name);
+		if (!artifact) return null;
+		try {
+			return JSON.parse(artifact.content) as T;
+		} catch {
+			return null;
+		}
+	}
+
+	/** Reaproveita `ast`/`ai`/`business` do manifesto anterior. */
+	manifestExtras(): {
+		ast?: ManifestAst;
+		ai?: ManifestAi;
+		business?: ManifestBusiness;
+	} {
+		const artifact = this.storage.readArtifact(this.review.id, "manifest.json");
+		if (!artifact) return {};
+		try {
+			const parsed = JSON.parse(artifact.content) as {
+				ast?: ManifestAst;
+				ai?: ManifestAi;
+				business?: ManifestBusiness;
+			};
+			return {
+				ast: parsed.ast,
+				ai: parsed.ai,
+				business: parsed.business ?? undefined,
+			};
+		} catch {
+			return {};
+		}
+	}
+
+	/** Lê o `classification.json` persistido pelo prepare (lança se ausente). */
+	classification(): RunClassification {
+		const artifact = this.storage.readArtifact(this.review.id, "classification.json");
+		if (!artifact) {
+			throw new Error(
+				`Não encontrei a classificação da review. Rode \`bun run houndsman\` (preparar) primeiro.`,
+			);
+		}
+		return JSON.parse(artifact.content) as RunClassification;
+	}
+
+	/** Lê os candidatos Jev persistidos (unavailable se ausente/inválido). */
+	candidates(config: HoundsmanConfig): JevCandidatesFile {
+		const artifact = this.storage.readArtifact(this.review.id, "candidates.json");
+		if (!artifact) return JevCandidatesStore.unavailable("candidates.json ausente");
+		try {
+			return (
+				parseCandidates(JSON.parse(artifact.content), [
+					...config.watchdogIds,
+					GENERAL_WATCHDOG_ID,
+				]) ?? JevCandidatesStore.unavailable("candidates.json inválido")
+			);
+		} catch {
+			return JevCandidatesStore.unavailable("candidates.json inválido");
+		}
+	}
+
+	/** Resumo do contexto persistido (usado quando o staging já foi limpo). */
+	contextSummary(): ContextSummary | null {
+		const artifact = this.storage.readArtifact(
+			this.review.id,
+			"context-summary.json",
+		);
+		if (!artifact) return null;
+		try {
+			return parseContextSummary(JSON.parse(artifact.content));
+		} catch {
+			return null;
+		}
+	}
+
+	/** Modelo de intenção persistido pelo prepare/revisor; `null` quando ausente. */
+	businessSummary(): BusinessSummary | null {
+		const raw = this.json<unknown>(BUSINESS_SUMMARY_FILE);
+		return raw ? parseBusinessSummary(raw) : null;
+	}
+
+	/** Pontos técnicos persistidos pelo `prepare`; `null` quando ausentes. */
+	technicalSummary(): TechnicalSummary | null {
+		const raw = this.json<unknown>(TECHNICAL_SUMMARY_FILE);
+		return raw ? parseTechnicalSummary(raw) : null;
+	}
+
+	/** Fallback para runs antigas: reconstrói os destaques dos artefatos de AST. */
+	technicalFallback(classification: RunClassification): TechnicalSummary {
+		const ast = this.json<{ files?: Record<string, AstAnalysis> }>(
+			"ast-summary.json",
+		);
+		return buildTechnicalSummary({
+			classification,
+			ast: ast?.files ? new Map(Object.entries(ast.files)) : undefined,
+			impact: this.json<AstImpact>("ast-impact.json") ?? undefined,
+			headSha: classification.headSha,
+		});
+	}
+
+	/** Persiste o contexto da PR (bruto + resumo) como artefatos, quando existirem. */
+	persistContext(): void {
+		const raw = this.work.readContextRaw();
+		if (raw !== null) {
+			this.storage.writeArtifact(this.review.id, {
+				name: "context.json",
+				kind: "context",
+				content: raw,
+			});
+		}
+		const summary = this.work.readContextSummaryRaw();
+		if (summary !== null) {
+			this.storage.writeArtifact(this.review.id, {
+				name: "context-summary.json",
+				kind: "context-summary",
+				content: summary,
+			});
+		}
+		const brief = this.work.readContextBriefRaw();
+		if (brief !== null) {
+			this.storage.writeArtifact(this.review.id, {
+				name: "context-brief.md",
+				kind: "context-brief",
+				content: brief,
+			});
+		}
+	}
+
+	/**
+	 * Persiste o `business-summary.json` final: o revisor `general` pode ter
+	 * reescrito o modelo no staging durante a revisão.
+	 */
+	persistBusiness(): BusinessSummary | null {
+		const raw = this.work.readBusinessSummaryRaw();
+		if (raw === null) return this.businessSummary();
+		this.storage.writeArtifact(this.review.id, {
+			name: BUSINESS_SUMMARY_FILE,
+			kind: "business",
+			content: raw.endsWith("\n") ? raw : `${raw}\n`,
+		});
+		const brief = this.work.readBusinessBriefRaw();
+		if (brief !== null) {
+			this.storage.writeArtifact(this.review.id, {
+				name: BUSINESS_BRIEF_FILE,
+				kind: "business-brief",
+				content: brief.endsWith("\n") ? brief : `${brief}\n`,
+			});
+		}
+		try {
+			return parseBusinessSummary(JSON.parse(raw), "reviewer");
+		} catch {
+			return this.businessSummary();
+		}
+	}
+}

package/src/core/engine/run-format.ts

@@ -0,0 +1,4 @@
+/** SHA curto para logs (7 chars, como o git). */
+export function shortSha(sha: string): string {
+	return sha.slice(0, 7);
+}

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);
 	},