gentle-pi 2.1.2 → 2.3.0

package/extensions/sdd-init.ts

@@ -771,33 +771,42 @@ function ensureOpenSpecDirs(cwd: string): void {
 }
 
 export default function (pi: ExtensionAPI) {
-	pi.registerCommand("sdd-init", {
+	pi.registerCommand("gentle-sdd-init", {
 		description:
 			"Auto-detect project stack and bootstrap openspec/config.yaml for SDD.",
 		handler: async (_args: unknown, ctx: any) => {
-			await ensureSddPreflight(ctx, {
-				pi,
-				installAssets: (cwd) => installSddAssets(cwd, false),
-				applyModelConfig: () => applySavedModelConfig(ctx),
-			});
+			const prefs = await ensureSddPreflight(ctx, { pi, installAssets: (cwd) => installSddAssets(cwd, false), applyModelConfig: () => applySavedModelConfig(ctx) }, { promptFields: [] });
+
+			const detection = detectProject(ctx.cwd);
+			const testSummary = detection.testCommand
+				? `strict TDD enabled with \`${detection.testCommand}\``
+				: "strict TDD disabled because no test runner was detected";
+			const layerSummary = `unit: ${detection.commands.unit.length}, integration: ${detection.commands.integration.length}, e2e: ${detection.commands.e2e.length}`;
+
+			const shouldCreateOpenSpec =
+				prefs.artifactStore === "openspec" ||
+				prefs.artifactStore === "hybrid";
+			if (!shouldCreateOpenSpec) {
+				ctx.ui.notify(
+					`SDD initialized for ${prefs.artifactStore}: detected ${detection.stack.join(", ") || "project"}; ${testSummary}; tests found: ${layerSummary}.`,
+					"info",
+				);
+				return;
+			}
+
 			const configPath = join(ctx.cwd, CONFIG_REL_PATH);
 			if (existsSync(configPath)) {
 				ctx.ui.notify(
-					`${CONFIG_REL_PATH} already exists. Edit it manually or remove it before re-running /sdd-init.`,
+					`${CONFIG_REL_PATH} already exists. Edit it manually or remove it before re-running /gentle-sdd-init.`,
 					"warning",
 				);
 				return;
 			}
 
-			const detection = detectProject(ctx.cwd);
 			ensureOpenSpecDirs(ctx.cwd);
 			mkdirSync(dirname(configPath), { recursive: true });
 			writeFileSync(configPath, renderConfig(detection));
 
-			const testSummary = detection.testCommand
-				? `strict TDD enabled with \`${detection.testCommand}\``
-				: "strict TDD disabled because no test runner was detected";
-			const layerSummary = `unit: ${detection.commands.unit.length}, integration: ${detection.commands.integration.length}, e2e: ${detection.commands.e2e.length}`;
 			ctx.ui.notify(
 				`Wrote ${CONFIG_REL_PATH}: detected ${detection.stack.join(", ") || "project"}; ${testSummary}; tests found: ${layerSummary}.`,
 				"info",

package/extensions/skill-registry.ts

@@ -21,7 +21,7 @@ const EXCLUDE_NAMES = new Set(["_shared", "skill-registry"]);
 const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
-const REGISTRY_SCHEMA_VERSION = 6;
+const REGISTRY_SCHEMA_VERSION = 7;
 const NO_SKILL_REGISTRY_FLAG = "no-skill-registry";
 const NO_SKILL_REGISTRY_ENV = "GENTLE_PI_NO_SKILL_REGISTRY";
 const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
@@ -253,7 +253,14 @@ async function fingerprint(files: string[]): Promise<string> {
 	for (const file of files) {
 		try {
 			const info = await stat(file);
-			lines.push(`${file}:${info.mtimeMs}:${info.size}`);
+			let contentHash: string;
+			try {
+				contentHash = createHash("sha1").update(await readFile(file)).digest("hex");
+			} catch {
+				lines.push(`${file}:unreadable`);
+				continue;
+			}
+			lines.push(`${file}:${info.mtimeMs}:${info.size}:${contentHash}`);
 		} catch {
 			lines.push(`${file}:missing`);
 		}
@@ -526,6 +533,7 @@ export const __testing = {
 	normalizeSkillDescription,
 	parseFrontmatter,
 	renderRegistry,
+	regenerateRegistry,
 	shouldSkipSkillRegistryStartup,
 	shouldSkipDuplicateExtensionLoad,
 	startSkillRegistryWatcher,

package/extensions/startup-banner.ts

@@ -553,7 +553,9 @@ export default function (pi: ExtensionAPI) {
         if (selected.startsWith("Rose:")) config.showRose = !config.showRose;
         else if (selected.startsWith("Text logo:")) config.showTextLogo = !config.showTextLogo;
         else if (selected.startsWith("Color:")) {
-          config.color = await ctx.ui.select("Startup banner color", [...BANNER_COLORS]) as BannerColor;
+          const color = await ctx.ui.select("Startup banner color", [...BANNER_COLORS]);
+          if (!color) return;
+          config.color = color as BannerColor;
         }
         await writeBannerConfig(config);
         notifyBannerConfig(ctx, config);
@@ -577,9 +579,13 @@ export default function (pi: ExtensionAPI) {
       handler: async (args, ctx) => {
         const config = await readBannerConfig();
         const requested = String(args ?? "").trim() as BannerColor;
-        config.color = BANNER_COLORS.includes(requested)
-          ? requested
-          : await ctx.ui.select("Startup banner color", [...BANNER_COLORS]) as BannerColor;
+        if (BANNER_COLORS.includes(requested)) {
+          config.color = requested;
+        } else {
+          const selected = await ctx.ui.select("Startup banner color", [...BANNER_COLORS]);
+          if (!selected) return;
+          config.color = selected as BannerColor;
+        }
         await writeBannerConfig(config);
         notifyBannerConfig(ctx, config);
       },

package/lib/gentle-ai-binary.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import {
 	GENTLE_AI_INSTALL_METHOD,
@@ -7,6 +8,7 @@ import {
 	GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM,
 	GENTLE_AI_WINDOWS_SOURCE_PACKAGE_PATH,
 	GENTLE_AI_WINDOWS_SOURCE_TAG,
+	INSTALLER_VERSION,
 	isGentleAiWindowsGoVersionSupported,
 	isWindowsGoSumdbSourceTarget,
 	resolveGentleAiReleaseAsset,
@@ -14,7 +16,10 @@ import {
 import { fileURLToPath } from "node:url";
 
 export const GENTLE_AI_BINARY_MISSING_CODE = "package-local-binary-missing";
-export const GENTLE_AI_VERSION = "2.2.2";
+// Derived from the one authoritative pinned version in
+// scripts/gentle-ai-installer.mjs rather than repeating the literal here, so
+// the two can never independently drift apart the way they once did.
+export const GENTLE_AI_VERSION = INSTALLER_VERSION;
 
 export class PackageLocalGentleAiBinaryMissingError extends Error {
 	readonly code = GENTLE_AI_BINARY_MISSING_CODE;
@@ -42,6 +47,165 @@ function sha256(value: Buffer): string {
 	return createHash("sha256").update(value).digest("hex");
 }
 
+// ---------------------------------------------------------------------------
+// Dev-binary override — the maintainer field-test lane.
+//
+// Two explicit activation paths, in precedence order:
+//   1. GENTLE_PI_GENTLE_AI_DEV_BINARY (session override, absolute path), then
+//   2. the persistent registration file at
+//      <GENTLE_PI_CONFIG_HOME|~/.pi/gentle-ai>/dev-binary.json with the strict
+//      shape {"schema":"gentle-pi.dev-binary/v1","path":"<absolute path>"}.
+//
+// The registration deliberately pins no digest: it is the unpinned field-test
+// mode, and the binary at that path changes on every rebuild. Every resolution
+// re-validates the file and recomputes the sha256, so a rebuilt binary is
+// followed automatically with a fresh digest and no re-registration.
+//
+// Guardrails per resolution: absolute path, regular non-symlink file, POSIX
+// executable. Any failure — including a malformed registration document or a
+// registered-but-missing binary — is a typed error naming its origin, never a
+// silent fallback to the pinned binary: silently running the pin while the
+// maintainer believes he is field-testing main is the worst possible outcome.
+// With neither activation path present, the pinned supply-chain resolution
+// below stays byte-identical.
+// ---------------------------------------------------------------------------
+
+export const GENTLE_AI_DEV_BINARY_ENV = "GENTLE_PI_GENTLE_AI_DEV_BINARY";
+export const GENTLE_AI_DEV_BINARY_REGISTRATION_SCHEMA = "gentle-pi.dev-binary/v1";
+export const GENTLE_AI_DEV_BINARY_OVERRIDE_INVALID_CODE = "dev-binary-override-invalid";
+
+export interface GentleAiDevBinaryEnvironment {
+	env: Record<string, string | undefined>;
+	home: string;
+}
+
+export interface GentleAiDevBinaryOverride {
+	source: "env" | "registration";
+	/** The env var name or registration file path that selected this binary. */
+	origin: string;
+	path: string;
+	sha256: string;
+}
+
+export class GentleAiDevBinaryOverrideError extends Error {
+	readonly code = GENTLE_AI_DEV_BINARY_OVERRIDE_INVALID_CODE;
+	readonly source: "env" | "registration";
+	readonly origin: string;
+	constructor(source: "env" | "registration", origin: string, reason: string) {
+		super(`${GENTLE_AI_DEV_BINARY_OVERRIDE_INVALID_CODE}: ${origin} ${reason}. Fix or remove the override; the pinned binary is never used silently while an override is declared.`);
+		this.name = "GentleAiDevBinaryOverrideError";
+		this.source = source;
+		this.origin = origin;
+	}
+}
+
+let devBinaryEnvironmentTestingOverlay: GentleAiDevBinaryEnvironment | undefined;
+
+/** Testing-only environment overlay; production code never calls this. */
+export function setGentleAiDevBinaryEnvironmentForTesting(environment: GentleAiDevBinaryEnvironment | undefined): void {
+	devBinaryEnvironmentTestingOverlay = environment;
+}
+
+function ambientDevBinaryEnvironment(): GentleAiDevBinaryEnvironment {
+	return devBinaryEnvironmentTestingOverlay ?? { env: process.env, home: homedir() };
+}
+
+export function gentleAiDevBinaryRegistrationPath(environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment()): string {
+	const configHome = environment.env.GENTLE_PI_CONFIG_HOME ?? join(environment.home, ".pi", "gentle-ai");
+	return join(configHome, "dev-binary.json");
+}
+
+function validateDevBinary(source: "env" | "registration", origin: string, path: string, platform: string): GentleAiDevBinaryOverride {
+	if (typeof path !== "string" || path.length === 0) throw new GentleAiDevBinaryOverrideError(source, origin, "declares an empty dev binary path");
+	if (!isAbsolute(path)) throw new GentleAiDevBinaryOverrideError(source, origin, `must name an absolute path, received "${path}"`);
+	let details: ReturnType<typeof lstatSync>;
+	try {
+		details = lstatSync(path);
+	} catch {
+		throw new GentleAiDevBinaryOverrideError(source, origin, `names "${path}", which does not exist`);
+	}
+	if (!details.isFile() || details.isSymbolicLink()) throw new GentleAiDevBinaryOverrideError(source, origin, `names "${path}", which is not a regular non-symlink file`);
+	if (platform !== "win32" && (details.mode & 0o111) === 0) throw new GentleAiDevBinaryOverrideError(source, origin, `names "${path}", which is not a POSIX executable`);
+	let digest: string;
+	try {
+		digest = sha256(readFileSync(path));
+	} catch {
+		throw new GentleAiDevBinaryOverrideError(source, origin, `names "${path}", which could not be read`);
+	}
+	return { source, origin, path, sha256: digest };
+}
+
+function readDevBinaryRegistration(registrationPath: string): string {
+	let contents: string;
+	try {
+		contents = readFileSync(registrationPath, "utf8");
+	} catch {
+		throw new GentleAiDevBinaryOverrideError("registration", registrationPath, "could not be read");
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(contents);
+	} catch {
+		throw new GentleAiDevBinaryOverrideError("registration", registrationPath, "is not valid JSON");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new GentleAiDevBinaryOverrideError("registration", registrationPath, "must be a JSON object");
+	const record = parsed as Record<string, unknown>;
+	const keys = Object.keys(record).sort();
+	if (keys.length !== 2 || keys[0] !== "path" || keys[1] !== "schema") throw new GentleAiDevBinaryOverrideError("registration", registrationPath, `must carry exactly the keys "schema" and "path"`);
+	if (record.schema !== GENTLE_AI_DEV_BINARY_REGISTRATION_SCHEMA) throw new GentleAiDevBinaryOverrideError("registration", registrationPath, `must declare schema ${GENTLE_AI_DEV_BINARY_REGISTRATION_SCHEMA}`);
+	if (typeof record.path !== "string" || record.path.length === 0) throw new GentleAiDevBinaryOverrideError("registration", registrationPath, "must declare a non-empty string path");
+	return record.path;
+}
+
+/**
+ * Resolves the active dev-binary override, if any. Returns undefined only when
+ * neither activation path is present; a present-but-invalid override always
+ * throws a typed GentleAiDevBinaryOverrideError naming its origin.
+ */
+export function resolveGentleAiDevBinaryOverride(
+	environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment(),
+	platform = process.platform,
+): GentleAiDevBinaryOverride | undefined {
+	const envValue = environment.env[GENTLE_AI_DEV_BINARY_ENV];
+	if (envValue !== undefined && envValue.length > 0) return validateDevBinary("env", GENTLE_AI_DEV_BINARY_ENV, envValue, platform);
+	const registrationPath = gentleAiDevBinaryRegistrationPath(environment);
+	if (!existsSync(registrationPath)) return undefined;
+	return validateDevBinary("registration", registrationPath, readDevBinaryRegistration(registrationPath), platform);
+}
+
+/**
+ * Cheap presence probe: is a dev-binary override declared at all? Used by the
+ * native CLI to select the unpinned version gate without hashing the binary.
+ * Declared-but-invalid still counts as configured — the resolution path will
+ * fail loudly with the typed error instead of quietly using the pin.
+ */
+export function gentleAiDevBinaryOverrideConfigured(environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment()): boolean {
+	const envValue = environment.env[GENTLE_AI_DEV_BINARY_ENV];
+	if (envValue !== undefined && envValue.length > 0) return true;
+	return existsSync(gentleAiDevBinaryRegistrationPath(environment));
+}
+
+/** Validates and persistently registers a dev binary; returns the fresh override. */
+export function registerGentleAiDevBinary(
+	path: string,
+	environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment(),
+	platform = process.platform,
+): { registrationPath: string; override: GentleAiDevBinaryOverride } {
+	const registrationPath = gentleAiDevBinaryRegistrationPath(environment);
+	const validated = validateDevBinary("registration", registrationPath, path, platform);
+	mkdirSync(dirname(registrationPath), { recursive: true });
+	writeFileSync(registrationPath, `${JSON.stringify({ schema: GENTLE_AI_DEV_BINARY_REGISTRATION_SCHEMA, path })}\n`);
+	return { registrationPath, override: validated };
+}
+
+/** Deletes the persistent registration; returns whether one existed. */
+export function unregisterGentleAiDevBinary(environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment()): boolean {
+	const registrationPath = gentleAiDevBinaryRegistrationPath(environment);
+	if (!existsSync(registrationPath)) return false;
+	rmSync(registrationPath);
+	return true;
+}
+
 function isConfined(path: string, directory: string): boolean {
 	const relativePath = relative(directory, path);
 	return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
@@ -106,7 +270,14 @@ export function resolveGentleAiBinary(
 	packageRoot = dirname(dirname(fileURLToPath(import.meta.url))),
 	platform = process.platform,
 	readBinary: (path: string) => Buffer = readFileSync,
+	environment: GentleAiDevBinaryEnvironment = ambientDevBinaryEnvironment(),
 ): string {
+	// The explicit dev-binary override wins over the pinned supply-chain path.
+	// Its typed errors propagate: a declared override never falls back to the
+	// pin. Without a declared override this call returns undefined and the
+	// pinned resolution below is byte-identical to the pre-override behavior.
+	const override = resolveGentleAiDevBinaryOverride(environment, platform);
+	if (override !== undefined) return override.path;
 	const binaryPath = gentleAiBinaryPath(packageRoot, platform);
 	const versionDirectory = dirname(binaryPath);
 	const manifestPath = join(versionDirectory, "integrity.json");

package/lib/gentle-ai-renderer.ts

@@ -0,0 +1,70 @@
+import { keyHint, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./terminal-theme.ts";
+
+type GentleAiLifecycleColor = "warning" | "success" | "error" | "dim";
+
+export interface GentleAiRenderTheme {
+	bold(value: string): string;
+	fg(color: GentleAiLifecycleColor, value: string): string;
+}
+
+export interface GentleAiRenderState {
+	lifecycleComponent?: boolean; genericLocked?: boolean;
+}
+
+export interface GentleAiRenderContext {
+	argsComplete?: boolean;
+	executionStarted?: boolean;
+	isPartial?: boolean;
+	isError?: boolean;
+	lastComponent?: unknown;
+	state?: unknown;
+}
+
+export function getGentleAiRenderState(state: unknown): GentleAiRenderState | undefined {
+	if (!state || typeof state !== "object" || Array.isArray(state)) return undefined;
+	const rowState = state as Record<string, unknown>, existing = rowState.gentleAiRender;
+	if (existing && typeof existing === "object" && !Array.isArray(existing)) return existing as GentleAiRenderState;
+	return (rowState.gentleAiRender = {} as GentleAiRenderState);
+}
+
+export interface GentleAiResultRenderOptions {
+	expanded?: boolean;
+}
+
+export function renderGentleAiResult(
+	result: AgentToolResult<unknown>,
+	options: GentleAiResultRenderOptions,
+): Text {
+	const textItems = result.content.flatMap((content) => (content.type === "text" ? [sanitizeTerminalText(content.text)] : []));
+	const text = textItems.join("\n");
+	const hasExpandableText = textItems.some((item) => item.length > 0);
+	const output = !hasExpandableText ? "" : options.expanded ? text : keyHint("app.tools.expand", "to expand");
+	return new Text(output, 0, 0);
+}
+
+export function renderGentleAiLifecycleCall(
+	operationPath: string,
+	theme: GentleAiRenderTheme,
+	context?: GentleAiRenderContext,
+	detail?: string,
+): Text {
+	const status = context?.isError
+		? "failed"
+		: context?.argsComplete === false
+			? "preparing"
+			: !context?.executionStarted || context.isPartial
+				? "running"
+				: "completed";
+	const color = status === "preparing" || status === "running" ? "warning" : status === "completed" ? "success" : "error";
+	const lines = [theme.fg(color, theme.bold(`🌹︎ Gentle AI · ${status} · ${operationPath}`))];
+	if (detail) lines.push(theme.fg("dim", sanitizeTerminalText(detail)));
+	const state = getGentleAiRenderState(context?.state);
+	const component = context?.lastComponent instanceof Text && (!state || state.lifecycleComponent === true)
+		? context.lastComponent
+		: new Text("", 0, 0);
+	if (state) state.lifecycleComponent = true;
+	component.setText(lines.join("\n"));
+	return component;
+}

package/lib/model-routing-authority.ts

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+
+export const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+export interface AgentRoutingEntry {
+	model?: string;
+	thinking?: ThinkingLevel;
+}
+
+export type AgentModelConfig = Record<string, AgentRoutingEntry>;
+
+export type ModelConfigFileResult =
+	| { status: "missing" }
+	| { status: "invalid"; path: string }
+	| { status: "valid"; config: AgentModelConfig };
+
+const SAFE_MODEL_ID_PATTERN = /^[A-Za-z0-9._~:@/+%-]+$/;
+const SAFE_AGENT_NAME_PATTERN = /^[A-Za-z0-9._:@/+%-]+$/;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function isThinkingLevel(value: unknown): value is ThinkingLevel {
+	return (
+		typeof value === "string" &&
+		(THINKING_LEVELS as readonly string[]).includes(value)
+	);
+}
+
+export function normalizeModelId(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const model = value.trim();
+	if (model.length === 0) return undefined;
+	if (!SAFE_MODEL_ID_PATTERN.test(model)) return undefined;
+	return model;
+}
+
+export function normalizeRoutingEntry(value: unknown): AgentRoutingEntry | undefined {
+	if (typeof value === "string") {
+		const model = normalizeModelId(value);
+		return model ? { model } : undefined;
+	}
+	if (!isRecord(value)) return undefined;
+	const model = normalizeModelId(value.model);
+	const thinking = isThinkingLevel(value.thinking) ? value.thinking : undefined;
+	if (!model && !thinking) {
+		return Object.keys(value).length === 0 ? {} : undefined;
+	}
+	return { model, thinking };
+}
+
+export function normalizeModelConfig(value: unknown): AgentModelConfig | undefined {
+	if (!isRecord(value)) return undefined;
+	const cleaned: AgentModelConfig = {};
+	for (const [name, entryValue] of Object.entries(value)) {
+		if (!SAFE_AGENT_NAME_PATTERN.test(name)) continue;
+		const entry = normalizeRoutingEntry(entryValue);
+		if (entry) cleaned[name] = entry;
+	}
+	return cleaned;
+}
+
+function parseModelConfigFileValue(value: Record<string, unknown>): AgentModelConfig {
+	const config: AgentModelConfig = {};
+	for (const [name, entryValue] of Object.entries(value)) {
+		const entry = normalizeRoutingEntry(entryValue);
+		if (entry) config[name] = entry;
+	}
+	return config;
+}
+
+export function readModelConfigFile(path: string): ModelConfigFileResult {
+	if (!existsSync(path)) return { status: "missing" };
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!isRecord(parsed)) return { status: "invalid", path };
+		return { status: "valid", config: parseModelConfigFileValue(parsed) };
+	} catch {
+		return { status: "invalid", path };
+	}
+}
+
+export async function readModelConfigFileAsync(
+	path: string,
+): Promise<ModelConfigFileResult> {
+	if (!(await pathExists(path))) return { status: "missing" };
+	try {
+		const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
+		if (!isRecord(parsed)) return { status: "invalid", path };
+		return { status: "valid", config: parseModelConfigFileValue(parsed) };
+	} catch {
+		return { status: "invalid", path };
+	}
+}
+
+export function readSavedModelConfig(
+	globalPath: string,
+	projectPath: string,
+): ModelConfigFileResult {
+	const globalResult = readModelConfigFile(globalPath);
+	if (globalResult.status !== "missing") return globalResult;
+	return readModelConfigFile(projectPath);
+}
+
+export async function readSavedModelConfigAsync(
+	globalPath: string,
+	projectPath: string,
+): Promise<ModelConfigFileResult> {
+	const globalResult = await readModelConfigFileAsync(globalPath);
+	if (globalResult.status !== "missing") return globalResult;
+	return readModelConfigFileAsync(projectPath);
+}