pi-crew 0.9.16 → 0.9.18

package/src/config/config.ts

@@ -3,12 +3,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { type Static, type TSchema, Type } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
-import {
-	PiTeamsAutonomyProfileSchema,
-	PiTeamsConfigSchema,
-} from "../schema/config-schema.ts";
-import { withFileLockSync } from "../state/locks.ts";
+import { PiTeamsAutonomyProfileSchema, PiTeamsConfigSchema } from "../schema/config-schema.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
+import { withFileLockSync } from "../state/locks.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot, projectPiRoot } from "../utils/paths.ts";
 import { suggestConfigKey } from "./suggestions.ts";
@@ -69,6 +66,108 @@ import type {
 	UpdateConfigOptions,
 } from "./types.ts";
 
+// (F16) loadConfig was called 1 Hz idle / 6 Hz active with 0 cache — added 2s TTL+mtime cache following the manifestCache pattern in state-store.ts:75-130.
+const CONFIG_CACHE_TTL_MS = 2000;
+
+interface ConfigCacheEntry {
+	value: LoadedPiTeamsConfig;
+	mtimes: Record<string, number>;
+	cachedAt: number;
+}
+
+interface ConfigCacheKeyParts {
+	filePath: string;
+	legacyPath: string;
+	projectPath: string;
+	projectPiCrewJsonPath: string;
+	cwd: string | null;
+}
+
+const configCache = new Map<string, ConfigCacheEntry>();
+
+/** @internal — TTL override for unit tests (matches __test__setManifestCache pattern in state-store.ts:82). */
+export function __test__setConfigCacheTtlMs(ttlMs: number): void {
+	configCacheTtlMsOverride = ttlMs;
+}
+
+/** @internal — read the effective TTL in use by the cache. */
+export function __test__getConfigCacheTtlMs(): number {
+	return configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+}
+
+/** @internal — peek at the cached entry for a given key shape. */
+export function __test__getConfigCacheEntry(parts: ConfigCacheKeyParts): ConfigCacheEntry | undefined {
+	return configCache.get(buildConfigCacheKey(parts));
+}
+
+/** @internal — number of cached entries (for tests/diagnostics). */
+export function __test__configCacheSize(): number {
+	return configCache.size;
+}
+
+let configCacheTtlMsOverride: number | null = null;
+
+function buildConfigCacheKey(parts: ConfigCacheKeyParts): string {
+	return JSON.stringify([parts.filePath, parts.legacyPath, parts.projectPath, parts.projectPiCrewJsonPath, parts.cwd]);
+}
+
+function statMtimeMs(filePath: string): number | undefined {
+	try {
+		return fs.statSync(filePath).mtimeMs;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+function readCachedConfigParts(filePath: string, legacyPath: string, cwd: string | undefined): ConfigCacheKeyParts {
+	const projectPath = cwd ? projectConfigPath(cwd) : "";
+	const piCrewJsonPath = cwd ? projectPiCrewJsonPath(cwd) : "";
+	return {
+		filePath,
+		legacyPath,
+		projectPath,
+		projectPiCrewJsonPath: piCrewJsonPath,
+		cwd: cwd ?? null,
+	};
+}
+
+function readCacheMtimes(parts: ConfigCacheKeyParts): Record<string, number> {
+	const mtimes: Record<string, number> = {};
+	for (const p of [parts.filePath, parts.legacyPath, parts.projectPath, parts.projectPiCrewJsonPath]) {
+		if (!p) continue; // skip empty (cwd-undefined project paths)
+		const m = statMtimeMs(p);
+		if (m !== undefined) mtimes[p] = m;
+	}
+	return mtimes;
+}
+
+function matchesCachedMtimes(cached: Record<string, number>, current: Record<string, number>): boolean {
+	const cachedKeys = Object.keys(cached);
+	const currentKeys = Object.keys(current);
+	if (cachedKeys.length !== currentKeys.length) return false;
+	for (const key of cachedKeys) {
+		if (current[key] !== cached[key]) return false;
+	}
+	return true;
+}
+
+function setConfigCache(key: string, value: LoadedPiTeamsConfig, mtimes: Record<string, number>): void {
+	if (configCache.has(key)) configCache.delete(key);
+	configCache.set(key, { value, mtimes, cachedAt: Date.now() });
+	const ttlMs = configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+	// TTL eviction on insert (mirrors manifestCache eviction in state-store.ts:108-117)
+	const now = Date.now();
+	for (const [k, entry] of configCache.entries()) {
+		if (now - entry.cachedAt > ttlMs) configCache.delete(k);
+	}
+}
+
+/** Drop all cached loadConfig results. Call after config writes or from tests. */
+export function invalidateConfigCache(): void {
+	configCache.clear();
+}
+
 function resolveHomeDir(): string {
 	const envValue = process.env.PI_TEAMS_HOME?.trim();
 	const defaultHome = os.homedir();
@@ -112,14 +211,7 @@ export function configPath(): string {
 }
 
 export function legacyConfigPath(): string {
-	return path.join(
-		resolveHomeDir(),
-		".pi",
-		"agent",
-		"extensions",
-		"pi-crew",
-		"config.json",
-	);
+	return path.join(resolveHomeDir(), ".pi", "agent", "extensions", "pi-crew", "config.json");
 }
 
 export function projectConfigPath(cwd: string): string {
@@ -134,23 +226,14 @@ export function projectPiCrewJsonPath(cwd: string): string {
 	return path.join(projectPiRoot(cwd), "pi-crew.json");
 }
 
-function withoutUndefined<T extends Record<string, unknown>>(
-	value: T,
-): Partial<T> {
-	return Object.fromEntries(
-		Object.entries(value).filter(([, entry]) => entry !== undefined),
-	) as Partial<T>;
+function withoutUndefined<T extends Record<string, unknown>>(value: T): Partial<T> {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as Partial<T>;
 }
 
 function errorPathFromValidation(error: unknown): string {
 	if (error && typeof error === "object") {
-		if (typeof (error as { path?: unknown }).path === "string")
-			return (error as { path: string }).path;
-		if (
-			typeof (error as { instancePath?: unknown }).instancePath ===
-			"string"
-		)
-			return (error as { instancePath: string }).instancePath;
+		if (typeof (error as { path?: unknown }).path === "string") return (error as { path: string }).path;
+		if (typeof (error as { instancePath?: unknown }).instancePath === "string") return (error as { instancePath: string }).instancePath;
 		if (
 			typeof (error as { keyword?: unknown }).keyword === "string" &&
 			typeof (error as { schemaPath?: unknown }).schemaPath === "string"
@@ -161,28 +244,18 @@ function errorPathFromValidation(error: unknown): string {
 }
 
 /** Known top-level config keys from the schema — used for fuzzy suggestions. */
-const KNOWN_TOP_LEVEL_KEYS = Object.keys(
-	PiTeamsConfigSchema.properties ?? {},
-) as string[];
+const KNOWN_TOP_LEVEL_KEYS = Object.keys(PiTeamsConfigSchema.properties ?? {}) as string[];
 
 function validateConfigWithWarnings(raw: unknown): string[] {
 	if (!Value.Check(PiTeamsConfigSchema, raw)) {
 		return [...Value.Errors(PiTeamsConfigSchema, raw)].map((error) => {
 			const path = errorPathFromValidation(error);
-			const message =
-				(error as { message?: unknown }).message ?? "invalid value";
+			const message = (error as { message?: unknown }).message ?? "invalid value";
 			// Enhance "additionalProperties" errors with fuzzy suggestions
-			if (
-				(error as { keyword?: unknown }).keyword ===
-				"additionalProperties"
-			) {
+			if ((error as { keyword?: unknown }).keyword === "additionalProperties") {
 				const offendingKey = path.split("/").pop() ?? path;
-				const suggestion = suggestConfigKey(
-					offendingKey,
-					KNOWN_TOP_LEVEL_KEYS,
-				);
-				if (suggestion)
-					return `${path}: ${message} (did you mean '${suggestion}'?)`;
+				const suggestion = suggestConfigKey(offendingKey, KNOWN_TOP_LEVEL_KEYS);
+				if (suggestion) return `${path}: ${message} (did you mean '${suggestion}'?)`;
 			}
 			return `${path}: ${message}`;
 		});
@@ -190,18 +263,11 @@ function validateConfigWithWarnings(raw: unknown): string[] {
 	return [];
 }
 
-function projectOverrideWarning(
-	projectPath: string,
-	dottedPath: string,
-): string {
+function projectOverrideWarning(projectPath: string, dottedPath: string): string {
 	return `${projectPath}: project-level sensitive config '${dottedPath}' is ignored; set it in user config to trust it explicitly`;
 }
 
-function sanitizeProjectConfig(
-	projectPath: string,
-	userConfig: PiTeamsConfig,
-	config: PiTeamsConfig,
-): ConfigValidationResult {
+function sanitizeProjectConfig(projectPath: string, userConfig: PiTeamsConfig, config: PiTeamsConfig): ConfigValidationResult {
 	const sanitized: PiTeamsConfig = { ...config };
 	const warnings: string[] = [];
 	const dropTopLevel = (key: keyof PiTeamsConfig): void => {
@@ -214,73 +280,36 @@ function sanitizeProjectConfig(
 	dropTopLevel("requireCleanWorktreeLeader");
 	if (config.runtime) {
 		const runtime = { ...config.runtime };
-		for (const key of [
-			"mode",
-			"preferLiveSession",
-			"allowChildProcessFallback",
-			"inheritContext",
-			"isolationPolicy",
-		] as const) {
+		for (const key of ["mode", "preferLiveSession", "allowChildProcessFallback", "inheritContext", "isolationPolicy"] as const) {
 			if (runtime[key] !== undefined) {
 				delete runtime[key];
-				warnings.push(
-					projectOverrideWarning(projectPath, `runtime.${key}`),
-				);
+				warnings.push(projectOverrideWarning(projectPath, `runtime.${key}`));
 			}
 		}
 		if (runtime.requirePlanApproval === false) {
 			delete runtime.requirePlanApproval;
-			warnings.push(
-				projectOverrideWarning(
-					projectPath,
-					"runtime.requirePlanApproval",
-				),
-			);
+			warnings.push(projectOverrideWarning(projectPath, "runtime.requirePlanApproval"));
 		}
-		sanitized.runtime = Object.values(runtime).some(
-			(entry) => entry !== undefined,
-		)
-			? runtime
-			: undefined;
+		sanitized.runtime = Object.values(runtime).some((entry) => entry !== undefined) ? runtime : undefined;
 	}
 	if (config.autonomous) {
 		const autonomous = { ...config.autonomous };
-		for (const key of [
-			"profile",
-			"enabled",
-			"injectPolicy",
-			"preferAsyncForLongTasks",
-			"allowWorktreeSuggestion",
-		] as const) {
+		for (const key of ["profile", "enabled", "injectPolicy", "preferAsyncForLongTasks", "allowWorktreeSuggestion"] as const) {
 			if (autonomous[key] !== undefined) {
 				delete autonomous[key];
-				warnings.push(
-					projectOverrideWarning(projectPath, `autonomous.${key}`),
-				);
+				warnings.push(projectOverrideWarning(projectPath, `autonomous.${key}`));
 			}
 		}
-		sanitized.autonomous = Object.values(autonomous).some(
-			(entry) => entry !== undefined,
-		)
-			? autonomous
-			: undefined;
+		sanitized.autonomous = Object.values(autonomous).some((entry) => entry !== undefined) ? autonomous : undefined;
 	}
 	if (config.worktree?.setupHook !== undefined) {
 		sanitized.worktree = { ...config.worktree, setupHook: undefined };
-		if (
-			!Object.values(sanitized.worktree).some(
-				(entry) => entry !== undefined,
-			)
-		)
-			sanitized.worktree = undefined;
-		warnings.push(
-			projectOverrideWarning(projectPath, "worktree.setupHook"),
-		);
+		if (!Object.values(sanitized.worktree).some((entry) => entry !== undefined)) sanitized.worktree = undefined;
+		warnings.push(projectOverrideWarning(projectPath, "worktree.setupHook"));
 	}
 	if (config.otlp?.headers !== undefined) {
 		sanitized.otlp = { ...config.otlp, headers: undefined };
-		if (!Object.values(sanitized.otlp).some((entry) => entry !== undefined))
-			sanitized.otlp = undefined;
+		if (!Object.values(sanitized.otlp).some((entry) => entry !== undefined)) sanitized.otlp = undefined;
 		warnings.push(projectOverrideWarning(projectPath, "otlp.headers"));
 	}
 	// FIX: Block project config from setting otlp.endpoint — it controls where
@@ -288,66 +317,37 @@ function sanitizeProjectConfig(
 	if (config.otlp?.endpoint !== undefined) {
 		if (!sanitized.otlp) sanitized.otlp = { ...config.otlp, endpoint: undefined };
 		else sanitized.otlp = { ...sanitized.otlp, endpoint: undefined };
-		if (!Object.values(sanitized.otlp).some((entry) => entry !== undefined))
-			sanitized.otlp = undefined;
+		if (!Object.values(sanitized.otlp).some((entry) => entry !== undefined)) sanitized.otlp = undefined;
 		warnings.push(projectOverrideWarning(projectPath, "otlp.endpoint"));
 	}
-	if (
-		config.agents?.disableBuiltins !== undefined ||
-		config.agents?.overrides !== undefined
-	) {
+	if (config.agents?.disableBuiltins !== undefined || config.agents?.overrides !== undefined) {
 		const agents = { ...config.agents };
 		if (agents.disableBuiltins !== undefined) {
 			delete agents.disableBuiltins;
-			warnings.push(
-				projectOverrideWarning(projectPath, "agents.disableBuiltins"),
-			);
+			warnings.push(projectOverrideWarning(projectPath, "agents.disableBuiltins"));
 		}
 		if (agents.overrides !== undefined) {
 			delete agents.overrides;
-			warnings.push(
-				projectOverrideWarning(projectPath, "agents.overrides"),
-			);
+			warnings.push(projectOverrideWarning(projectPath, "agents.overrides"));
 		}
-		sanitized.agents = Object.values(agents).some(
-			(entry) => entry !== undefined,
-		)
-			? agents
-			: undefined;
+		sanitized.agents = Object.values(agents).some((entry) => entry !== undefined) ? agents : undefined;
 	}
-	if (
-		config.tools?.enableSteer !== undefined ||
-		config.tools?.terminateOnForeground !== undefined
-	) {
+	if (config.tools?.enableSteer !== undefined || config.tools?.terminateOnForeground !== undefined) {
 		const tools = { ...config.tools };
 		if (tools.enableSteer !== undefined) {
 			delete tools.enableSteer;
-			warnings.push(
-				projectOverrideWarning(projectPath, "tools.enableSteer"),
-			);
+			warnings.push(projectOverrideWarning(projectPath, "tools.enableSteer"));
 		}
 		if (tools.terminateOnForeground !== undefined) {
 			delete tools.terminateOnForeground;
-			warnings.push(
-				projectOverrideWarning(
-					projectPath,
-					"tools.terminateOnForeground",
-				),
-			);
+			warnings.push(projectOverrideWarning(projectPath, "tools.terminateOnForeground"));
 		}
-		sanitized.tools = Object.values(tools).some(
-			(entry) => entry !== undefined,
-		)
-			? tools
-			: undefined;
+		sanitized.tools = Object.values(tools).some((entry) => entry !== undefined) ? tools : undefined;
 	}
 	return { config: sanitized, warnings };
 }
 
-function mergeConfig(
-	base: PiTeamsConfig,
-	override: PiTeamsConfig,
-): PiTeamsConfig {
+function mergeConfig(base: PiTeamsConfig, override: PiTeamsConfig): PiTeamsConfig {
 	const warnings: string[] = [];
 	const merged: PiTeamsConfig = {
 		...base,
@@ -356,41 +356,31 @@ function mergeConfig(
 	if (base.autonomous || override.autonomous) {
 		merged.autonomous = {
 			...(base.autonomous ?? {}),
-			...withoutUndefined(
-				(override.autonomous ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.autonomous ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.limits || override.limits) {
 		merged.limits = {
 			...(base.limits ?? {}),
-			...withoutUndefined(
-				(override.limits ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.limits ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.runtime || override.runtime) {
 		merged.runtime = {
 			...(base.runtime ?? {}),
-			...withoutUndefined(
-				(override.runtime ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.runtime ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.control || override.control) {
 		merged.control = {
 			...(base.control ?? {}),
-			...withoutUndefined(
-				(override.control ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.control ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.worktree || override.worktree) {
 		merged.worktree = {
 			...(base.worktree ?? {}),
-			...withoutUndefined(
-				(override.worktree ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.worktree ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.ui || override.ui) {
@@ -402,75 +392,52 @@ function mergeConfig(
 	if (base.agents || override.agents) {
 		merged.agents = {
 			...(base.agents ?? {}),
-			...withoutUndefined(
-				(override.agents ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.agents ?? {}) as Record<string, unknown>),
 			overrides: {
 				...(base.agents?.overrides ?? {}),
-				...(withoutUndefined(
-					(override.agents?.overrides ?? {}) as Record<
-						string,
-						unknown
-					>,
-				) as Record<string, AgentOverrideConfig>),
+				...(withoutUndefined((override.agents?.overrides ?? {}) as Record<string, unknown>) as Record<string, AgentOverrideConfig>),
 			},
 		};
 	}
 	if (base.tools || override.tools) {
 		merged.tools = {
 			...(base.tools ?? {}),
-			...withoutUndefined(
-				(override.tools ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.tools ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.telemetry || override.telemetry) {
 		merged.telemetry = {
 			...(base.telemetry ?? {}),
-			...withoutUndefined(
-				(override.telemetry ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.telemetry ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.policy || override.policy) {
 		merged.policy = {
 			...(base.policy ?? {}),
-			...withoutUndefined(
-				(override.policy ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.policy ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.notifications || override.notifications) {
 		merged.notifications = {
 			...(base.notifications ?? {}),
-			...withoutUndefined(
-				(override.notifications ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.notifications ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.observability || override.observability) {
 		merged.observability = {
 			...(base.observability ?? {}),
-			...withoutUndefined(
-				(override.observability ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.observability ?? {}) as Record<string, unknown>),
 		};
 	}
 	if (base.reliability || override.reliability) {
 		merged.reliability = {
 			...(base.reliability ?? {}),
-			...withoutUndefined(
-				(override.reliability ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.reliability ?? {}) as Record<string, unknown>),
 			retryPolicy:
-				base.reliability?.retryPolicy ||
-				override.reliability?.retryPolicy
+				base.reliability?.retryPolicy || override.reliability?.retryPolicy
 					? {
 							...(base.reliability?.retryPolicy ?? {}),
-							...withoutUndefined(
-								(override.reliability?.retryPolicy ??
-									{}) as Record<string, unknown>,
-							),
+							...withoutUndefined((override.reliability?.retryPolicy ?? {}) as Record<string, unknown>),
 						}
 					: undefined,
 		};
@@ -478,16 +445,13 @@ function mergeConfig(
 	if (base.otlp || override.otlp) {
 		merged.otlp = {
 			...(base.otlp ?? {}),
-			...withoutUndefined(
-				(override.otlp ?? {}) as Record<string, unknown>,
-			),
+			...withoutUndefined((override.otlp ?? {}) as Record<string, unknown>),
 			headers: {
 				...(base.otlp?.headers ?? {}),
 				...(override.otlp?.headers ?? {}),
 			},
 		};
-		if (Object.keys(merged.otlp.headers ?? {}).length === 0)
-			delete merged.otlp.headers;
+		if (Object.keys(merged.otlp.headers ?? {}).length === 0) delete merged.otlp.headers;
 		// Validate OTLP headers for injection attacks:
 		// - Check top-level keys for dangerous prototype pollution patterns
 		// - Block ALL control characters except tab (0x09) to prevent header
@@ -506,22 +470,23 @@ function mergeConfig(
 				if (DANGEROUS_OBJECT_KEYS.has(lowerKey)) return true;
 				return false;
 			};
-			if (checkKey(k)) { invalidHeaders.push(k); continue; }
+			if (checkKey(k)) {
+				invalidHeaders.push(k);
+				continue;
+			}
 			// Block any control characters except tab (0x09) in values.
 			// Round 28 fix: /[\x00-\x08\x0a-\x1f]/ blocks LF (0x0A) and CR (0x0D) too.
 			const valStr = String(v);
-			if (/[\x00-\x08\x0a-\x1f]/.test(valStr)) { invalidHeaders.push(k); }
+			if (/[\x00-\x08\x0a-\x1f]/.test(valStr)) {
+				invalidHeaders.push(k);
+			}
 		}
 		if (invalidHeaders.length > 0) {
 			delete merged.otlp.headers;
 			warnings.push(`OTLP headers blocked due to invalid characters: ${invalidHeaders.join(", ")}`);
 		}
 	}
-	if (
-		merged.agents?.overrides &&
-		Object.keys(merged.agents.overrides).length === 0
-	)
-		delete merged.agents.overrides;
+	if (merged.agents?.overrides && Object.keys(merged.agents.overrides).length === 0) delete merged.agents.overrides;
 	return merged;
 }
 
@@ -580,8 +545,7 @@ function sanitizeObject(obj: Record<string, unknown>): Record<string, unknown> {
 }
 
 export function asRecord(value: unknown): Record<string, unknown> | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value))
-		return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
 	// Defensive: create a sanitized copy to prevent prototype pollution.
 	// Uses Object.create(null) so the result has no prototype chain.
 	// WARNING: The returned object has no prototype methods (no hasOwnProperty,
@@ -590,11 +554,7 @@ export function asRecord(value: unknown): Record<string, unknown> | undefined {
 	return sanitizeObject(value as Record<string, unknown>);
 }
 
-function parseWithSchema<T extends TSchema>(
-	schema: T,
-	value: unknown,
-	context?: string,
-): Static<T> | undefined {
+function parseWithSchema<T extends TSchema>(schema: T, value: unknown, context?: string): Static<T> | undefined {
 	if (!Value.Check(schema, value)) {
 		if (context) {
 			logInternalError("config.parseWithSchema", undefined, `${context}: schema validation failed`);
@@ -604,18 +564,11 @@ function parseWithSchema<T extends TSchema>(
 	return Value.Decode(schema, value);
 }
 
-function parseIntegerInRange(
-	value: unknown,
-	minimum = 1,
-	maximum = Number.MAX_SAFE_INTEGER,
-): number | undefined {
+function parseIntegerInRange(value: unknown, minimum = 1, maximum = Number.MAX_SAFE_INTEGER): number | undefined {
 	return parseWithSchema(Type.Integer({ minimum, maximum }), value);
 }
 
-function parsePositiveInteger(
-	value: unknown,
-	max = Number.MAX_SAFE_INTEGER,
-): number | undefined {
+function parsePositiveInteger(value: unknown, max = Number.MAX_SAFE_INTEGER): number | undefined {
 	return parseIntegerInRange(value, 1, max);
 }
 
@@ -626,34 +579,21 @@ function parseProfile(value: unknown): PiTeamsAutonomyProfile | undefined {
 function parseStringList(value: unknown): string[] | undefined {
 	const items = parseWithSchema(Type.Array(Type.String()), value);
 	if (!items || items.length === 0) return undefined;
-	const normalized = items
-		.map((entry) => entry.trim())
-		.filter((entry) => entry.length > 0);
+	const normalized = items.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 	return normalized.length > 0 ? normalized : undefined;
 }
 
 function parseStringArrayOrFalse(value: unknown): string[] | false | undefined {
 	if (value === false) return false;
-	if (typeof value === "string")
-		return value.trim() === "" ? [] : parseStringList(value.split(","));
+	if (typeof value === "string") return value.trim() === "" ? [] : parseStringList(value.split(","));
 	return parseStringList(value);
 }
 
 export function effectiveAutonomousConfig(
 	config: PiTeamsAutonomousConfig | undefined,
-): Required<
-	Pick<
-		PiTeamsAutonomousConfig,
-		| "profile"
-		| "enabled"
-		| "injectPolicy"
-		| "preferAsyncForLongTasks"
-		| "allowWorktreeSuggestion"
-	>
-> &
+): Required<Pick<PiTeamsAutonomousConfig, "profile" | "enabled" | "injectPolicy" | "preferAsyncForLongTasks" | "allowWorktreeSuggestion">> &
 	Pick<PiTeamsAutonomousConfig, "magicKeywords"> {
-	const profile =
-		config?.enabled === false ? "manual" : (config?.profile ?? "suggested");
+	const profile = config?.enabled === false ? "manual" : (config?.profile ?? "suggested");
 	const profileDefaults: Record<
 		PiTeamsAutonomyProfile,
 		{
@@ -693,21 +633,14 @@ export function effectiveAutonomousConfig(
 		profile,
 		enabled: config?.enabled ?? defaults.enabled,
 		injectPolicy: config?.injectPolicy ?? defaults.injectPolicy,
-		preferAsyncForLongTasks:
-			config?.preferAsyncForLongTasks ?? defaults.preferAsyncForLongTasks,
-		allowWorktreeSuggestion:
-			config?.allowWorktreeSuggestion ?? defaults.allowWorktreeSuggestion,
+		preferAsyncForLongTasks: config?.preferAsyncForLongTasks ?? defaults.preferAsyncForLongTasks,
+		allowWorktreeSuggestion: config?.allowWorktreeSuggestion ?? defaults.allowWorktreeSuggestion,
 		magicKeywords: config?.magicKeywords,
 	};
 }
 
-function parseStringArrayRecord(
-	value: unknown,
-): Record<string, string[]> | undefined {
-	const record = parseWithSchema(
-		Type.Record(Type.String({ minLength: 1 }), Type.Array(Type.String())),
-		value,
-	);
+function parseStringArrayRecord(value: unknown): Record<string, string[]> | undefined {
+	const record = parseWithSchema(Type.Record(Type.String({ minLength: 1 }), Type.Array(Type.String())), value);
 	if (!record) return undefined;
 	const result: Record<string, string[]> = {};
 	for (const [key, rawValues] of Object.entries(record)) {
@@ -717,87 +650,42 @@ function parseStringArrayRecord(
 	return Object.keys(result).length > 0 ? result : undefined;
 }
 
-function parseAutonomousConfig(
-	value: unknown,
-): PiTeamsAutonomousConfig | undefined {
+function parseAutonomousConfig(value: unknown): PiTeamsAutonomousConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const config: PiTeamsAutonomousConfig = {
 		profile: parseProfile(obj.profile),
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 		injectPolicy: parseWithSchema(Type.Boolean(), obj.injectPolicy),
-		preferAsyncForLongTasks: parseWithSchema(
-			Type.Boolean(),
-			obj.preferAsyncForLongTasks,
-		),
-		allowWorktreeSuggestion: parseWithSchema(
-			Type.Boolean(),
-			obj.allowWorktreeSuggestion,
-		),
+		preferAsyncForLongTasks: parseWithSchema(Type.Boolean(), obj.preferAsyncForLongTasks),
+		allowWorktreeSuggestion: parseWithSchema(Type.Boolean(), obj.allowWorktreeSuggestion),
 		magicKeywords: parseStringArrayRecord(obj.magicKeywords),
 	};
-	return Object.values(config).some((entry) => entry !== undefined)
-		? config
-		: undefined;
+	return Object.values(config).some((entry) => entry !== undefined) ? config : undefined;
 }
 
 function parseLimitsConfig(value: unknown): CrewLimitsConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const limits: CrewLimitsConfig = {
-		maxConcurrentWorkers: parsePositiveInteger(
-			obj.maxConcurrentWorkers,
-			LIMIT_CEILINGS.maxConcurrentWorkers,
-		),
-		allowUnboundedConcurrency: parseWithSchema(
-			Type.Boolean(),
-			obj.allowUnboundedConcurrency,
-		),
-		maxTaskDepth: parsePositiveInteger(
-			obj.maxTaskDepth,
-			LIMIT_CEILINGS.maxTaskDepth,
-		),
-		maxChildrenPerTask: parsePositiveInteger(
-			obj.maxChildrenPerTask,
-			LIMIT_CEILINGS.maxChildrenPerTask,
-		),
-		maxRunMinutes: parsePositiveInteger(
-			obj.maxRunMinutes,
-			LIMIT_CEILINGS.maxRunMinutes,
-		),
-		maxRetriesPerTask: parsePositiveInteger(
-			obj.maxRetriesPerTask,
-			LIMIT_CEILINGS.maxRetriesPerTask,
-		),
-		maxTasksPerRun: parsePositiveInteger(
-			obj.maxTasksPerRun,
-			LIMIT_CEILINGS.maxTasksPerRun,
-		),
-		heartbeatStaleMs: parsePositiveInteger(
-			obj.heartbeatStaleMs,
-			LIMIT_CEILINGS.heartbeatStaleMs,
-		),
+		maxConcurrentWorkers: parsePositiveInteger(obj.maxConcurrentWorkers, LIMIT_CEILINGS.maxConcurrentWorkers),
+		allowUnboundedConcurrency: parseWithSchema(Type.Boolean(), obj.allowUnboundedConcurrency),
+		maxTaskDepth: parsePositiveInteger(obj.maxTaskDepth, LIMIT_CEILINGS.maxTaskDepth),
+		maxChildrenPerTask: parsePositiveInteger(obj.maxChildrenPerTask, LIMIT_CEILINGS.maxChildrenPerTask),
+		maxRunMinutes: parsePositiveInteger(obj.maxRunMinutes, LIMIT_CEILINGS.maxRunMinutes),
+		maxRetriesPerTask: parsePositiveInteger(obj.maxRetriesPerTask, LIMIT_CEILINGS.maxRetriesPerTask),
+		maxTasksPerRun: parsePositiveInteger(obj.maxTasksPerRun, LIMIT_CEILINGS.maxTasksPerRun),
+		heartbeatStaleMs: parsePositiveInteger(obj.heartbeatStaleMs, LIMIT_CEILINGS.heartbeatStaleMs),
 	};
-	return Object.values(limits).some((entry) => entry !== undefined)
-		? limits
-		: undefined;
+	return Object.values(limits).some((entry) => entry !== undefined) ? limits : undefined;
 }
 
-function parseIsolationPolicy(
-	value: unknown,
-): CrewRuntimeConfig["isolationPolicy"] | undefined {
+function parseIsolationPolicy(value: unknown): CrewRuntimeConfig["isolationPolicy"] | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const isolatedRoles = parseStringList(obj.isolatedRoles);
-	const defaultRuntime = parseWithSchema(
-		Type.Union([
-			Type.Literal("live-session"),
-			Type.Literal("child-process"),
-		]),
-		obj.defaultRuntime,
-	);
-	if (isolatedRoles === undefined && defaultRuntime === undefined)
-		return undefined;
+	const defaultRuntime = parseWithSchema(Type.Union([Type.Literal("live-session"), Type.Literal("child-process")]), obj.defaultRuntime);
+	if (isolatedRoles === undefined && defaultRuntime === undefined) return undefined;
 	return {
 		...(isolatedRoles !== undefined ? { isolatedRoles } : {}),
 		...(defaultRuntime !== undefined ? { defaultRuntime } : {}),
@@ -809,73 +697,29 @@ function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 	if (!obj) return undefined;
 	const runtime: CrewRuntimeConfig = {
 		mode: parseWithSchema(
-			Type.Union([
-				Type.Literal("auto"),
-				Type.Literal("scaffold"),
-				Type.Literal("child-process"),
-				Type.Literal("live-session"),
-			]),
+			Type.Union([Type.Literal("auto"), Type.Literal("scaffold"), Type.Literal("child-process"), Type.Literal("live-session")]),
 			obj.mode,
 		),
-		preferLiveSession: parseWithSchema(
-			Type.Boolean(),
-			obj.preferLiveSession,
-		),
-		allowChildProcessFallback: parseWithSchema(
-			Type.Boolean(),
-			obj.allowChildProcessFallback,
-		),
-		maxTurns: parsePositiveInteger(
-			obj.maxTurns,
-			LIMIT_CEILINGS.runtimeMaxTurns,
-		),
-		graceTurns: parsePositiveInteger(
-			obj.graceTurns,
-			LIMIT_CEILINGS.runtimeGraceTurns,
-		),
+		preferLiveSession: parseWithSchema(Type.Boolean(), obj.preferLiveSession),
+		allowChildProcessFallback: parseWithSchema(Type.Boolean(), obj.allowChildProcessFallback),
+		maxTurns: parsePositiveInteger(obj.maxTurns, LIMIT_CEILINGS.runtimeMaxTurns),
+		graceTurns: parsePositiveInteger(obj.graceTurns, LIMIT_CEILINGS.runtimeGraceTurns),
 		inheritContext: parseWithSchema(Type.Boolean(), obj.inheritContext),
-		promptMode: parseWithSchema(
-			Type.Union([Type.Literal("replace"), Type.Literal("append")]),
-			obj.promptMode,
-		),
-		groupJoin: parseWithSchema(
-			Type.Union([
-				Type.Literal("off"),
-				Type.Literal("group"),
-				Type.Literal("smart"),
-			]),
-			obj.groupJoin,
-		),
-		groupJoinAckTimeoutMs: parsePositiveInteger(
-			obj.groupJoinAckTimeoutMs,
-			86_400_000,
-		),
-		requirePlanApproval: parseWithSchema(
-			Type.Boolean(),
-			obj.requirePlanApproval,
-		),
+		promptMode: parseWithSchema(Type.Union([Type.Literal("replace"), Type.Literal("append")]), obj.promptMode),
+		groupJoin: parseWithSchema(Type.Union([Type.Literal("off"), Type.Literal("group"), Type.Literal("smart")]), obj.groupJoin),
+		groupJoinAckTimeoutMs: parsePositiveInteger(obj.groupJoinAckTimeoutMs, 86_400_000),
+		requirePlanApproval: parseWithSchema(Type.Boolean(), obj.requirePlanApproval),
 		completionMutationGuard: parseWithSchema(
-			Type.Union([
-				Type.Literal("off"),
-				Type.Literal("warn"),
-				Type.Literal("fail"),
-			]),
+			Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("fail")]),
 			obj.completionMutationGuard,
 		),
 		effectivenessGuard: parseWithSchema(
-			Type.Union([
-				Type.Literal("off"),
-				Type.Literal("warn"),
-				Type.Literal("block"),
-				Type.Literal("fail"),
-			]),
+			Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("block"), Type.Literal("fail")]),
 			obj.effectivenessGuard,
 		),
 		isolationPolicy: parseIsolationPolicy(obj.isolationPolicy),
 	};
-	return Object.values(runtime).some((entry) => entry !== undefined)
-		? runtime
-		: undefined;
+	return Object.values(runtime).some((entry) => entry !== undefined) ? runtime : undefined;
 }
 
 function parseControlConfig(value: unknown): CrewControlConfig | undefined {
@@ -885,9 +729,7 @@ function parseControlConfig(value: unknown): CrewControlConfig | undefined {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 		needsAttentionAfterMs: parsePositiveInteger(obj.needsAttentionAfterMs),
 	};
-	return Object.values(control).some((entry) => entry !== undefined)
-		? control
-		: undefined;
+	return Object.values(control).some((entry) => entry !== undefined) ? control : undefined;
 }
 
 function parseWorktreeConfig(value: unknown): CrewWorktreeConfig | undefined {
@@ -897,21 +739,14 @@ function parseWorktreeConfig(value: unknown): CrewWorktreeConfig | undefined {
 	const setupHook = rawSetupHook?.trim();
 	const worktree: CrewWorktreeConfig = {
 		setupHook: setupHook ? setupHook : undefined,
-		setupHookTimeoutMs: parsePositiveInteger(
-			obj.setupHookTimeoutMs,
-			300_000,
-		),
+		setupHookTimeoutMs: parsePositiveInteger(obj.setupHookTimeoutMs, 300_000),
 		linkNodeModules: parseWithSchema(Type.Boolean(), obj.linkNodeModules),
 	};
-	return Object.values(worktree).some((entry) => entry !== undefined)
-		? worktree
-		: undefined;
+	return Object.values(worktree).some((entry) => entry !== undefined) ? worktree : undefined;
 }
 
 /** Parse goalWrap config (RFC v0.5 vision: apply goal completion-guarantee to builtins). */
-function parseGoalWrapConfig(
-	value: unknown,
-): Record<string, GoalWrapWorkflowConfig> | undefined {
+function parseGoalWrapConfig(value: unknown): Record<string, GoalWrapWorkflowConfig> | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const result: Record<string, GoalWrapWorkflowConfig> = {};
@@ -932,9 +767,12 @@ function parseGoalWrapConfig(
 			const commands = Array.isArray(verObj.commands)
 				? verObj.commands.filter((c): c is string => typeof c === "string" && c.length > 0)
 				: undefined;
-			const mode = verObj.mode === "text-only" ? "text-only" as const : undefined;
+			const mode = verObj.mode === "text-only" ? ("text-only" as const) : undefined;
 			if (commands || mode) {
-				parsed.verification = { ...(commands ? { commands } : { commands: [] }), ...(mode ? { mode } : {}) };
+				parsed.verification = {
+					...(commands ? { commands } : { commands: [] }),
+					...(mode ? { mode } : {}),
+				};
 			}
 		}
 		if (Object.values(parsed).some((v) => v !== undefined)) {
@@ -950,65 +788,34 @@ function parseAgentOverride(value: unknown): AgentOverrideConfig | undefined {
 	if (!obj) return undefined;
 	const override: AgentOverrideConfig = {
 		disabled: parseWithSchema(Type.Boolean(), obj.disabled),
-		model: parseWithSchema(
-			Type.Union([Type.String(), Type.Literal(false)]),
-			obj.model,
-		),
+		model: parseWithSchema(Type.Union([Type.String(), Type.Literal(false)]), obj.model),
 		fallbackModels: parseStringArrayOrFalse(obj.fallbackModels),
-		thinking: parseWithSchema(
-			Type.Union([Type.String(), Type.Literal(false)]),
-			obj.thinking,
-		),
+		thinking: parseWithSchema(Type.Union([Type.String(), Type.Literal(false)]), obj.thinking),
 		tools: parseStringArrayOrFalse(obj.tools),
 		skills: parseStringArrayOrFalse(obj.skills),
 	};
-	return Object.values(override).some((entry) => entry !== undefined)
-		? override
-		: undefined;
+	return Object.values(override).some((entry) => entry !== undefined) ? override : undefined;
 }
 
 function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
-	const rawWidgetPlacement = parseWithSchema(
-		Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")]),
-		obj.widgetPlacement,
-	);
-	const rawDashboardPlacement = parseWithSchema(
-		Type.Union([Type.Literal("center"), Type.Literal("right")]),
-		obj.dashboardPlacement,
-	);
+	const rawWidgetPlacement = parseWithSchema(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")]), obj.widgetPlacement);
+	const rawDashboardPlacement = parseWithSchema(Type.Union([Type.Literal("center"), Type.Literal("right")]), obj.dashboardPlacement);
 	const ui: CrewUiConfig = {
 		widgetPlacement: rawWidgetPlacement,
 		widgetMaxLines: parsePositiveInteger(obj.widgetMaxLines, 50),
 		powerbar: parseWithSchema(Type.Boolean(), obj.powerbar),
 		dashboardPlacement: rawDashboardPlacement,
 		dashboardWidth: parseIntegerInRange(obj.dashboardWidth, 32, 120),
-		dashboardLiveRefreshMs: parseIntegerInRange(
-			obj.dashboardLiveRefreshMs,
-			250,
-			60_000,
-		),
-		autoOpenDashboard: parseWithSchema(
-			Type.Boolean(),
-			obj.autoOpenDashboard,
-		),
-		autoOpenDashboardForForegroundRuns: parseWithSchema(
-			Type.Boolean(),
-			obj.autoOpenDashboardForForegroundRuns,
-		),
+		dashboardLiveRefreshMs: parseIntegerInRange(obj.dashboardLiveRefreshMs, 250, 60_000),
+		autoOpenDashboard: parseWithSchema(Type.Boolean(), obj.autoOpenDashboard),
+		autoOpenDashboardForForegroundRuns: parseWithSchema(Type.Boolean(), obj.autoOpenDashboardForForegroundRuns),
 		showModel: parseWithSchema(Type.Boolean(), obj.showModel),
 		showTokens: parseWithSchema(Type.Boolean(), obj.showTokens),
 		showTools: parseWithSchema(Type.Boolean(), obj.showTools),
-		transcriptTailBytes: parseIntegerInRange(
-			obj.transcriptTailBytes,
-			1024,
-			50 * 1024 * 1024,
-		),
-		mascotStyle: parseWithSchema(
-			Type.Union([Type.Literal("cat"), Type.Literal("armin")]),
-			obj.mascotStyle,
-		),
+		transcriptTailBytes: parseIntegerInRange(obj.transcriptTailBytes, 1024, 50 * 1024 * 1024),
+		mascotStyle: parseWithSchema(Type.Union([Type.Literal("cat"), Type.Literal("armin")]), obj.mascotStyle),
 		mascotEffect: parseWithSchema(
 			Type.Union([
 				Type.Literal("random"),
@@ -1024,23 +831,15 @@ function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 			obj.mascotEffect,
 		),
 	};
-	return Object.values(ui).some((entry) => entry !== undefined)
-		? ui
-		: undefined;
+	return Object.values(ui).some((entry) => entry !== undefined) ? ui : undefined;
 }
 
 function parseAgentsConfig(value: unknown): CrewAgentsConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const overrides: Record<string, AgentOverrideConfig> = {};
-	if (
-		obj.overrides &&
-		typeof obj.overrides === "object" &&
-		!Array.isArray(obj.overrides)
-	) {
-		for (const [name, rawOverride] of Object.entries(
-			obj.overrides as Record<string, unknown>,
-		)) {
+	if (obj.overrides && typeof obj.overrides === "object" && !Array.isArray(obj.overrides)) {
+		for (const [name, rawOverride] of Object.entries(obj.overrides as Record<string, unknown>)) {
 			const parsed = parseAgentOverride(rawOverride);
 			if (parsed && name.trim()) overrides[name.trim()] = parsed;
 		}
@@ -1049,28 +848,18 @@ function parseAgentsConfig(value: unknown): CrewAgentsConfig | undefined {
 		disableBuiltins: parseWithSchema(Type.Boolean(), obj.disableBuiltins),
 		overrides: Object.keys(overrides).length > 0 ? overrides : undefined,
 	};
-	return Object.values(agents).some((entry) => entry !== undefined)
-		? agents
-		: undefined;
+	return Object.values(agents).some((entry) => entry !== undefined) ? agents : undefined;
 }
 
 function parseToolsConfig(value: unknown): CrewToolsConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const tools: CrewToolsConfig = {
-		enableClaudeStyleAliases: parseWithSchema(
-			Type.Boolean(),
-			obj.enableClaudeStyleAliases,
-		),
+		enableClaudeStyleAliases: parseWithSchema(Type.Boolean(), obj.enableClaudeStyleAliases),
 		enableSteer: parseWithSchema(Type.Boolean(), obj.enableSteer),
-		terminateOnForeground: parseWithSchema(
-			Type.Boolean(),
-			obj.terminateOnForeground,
-		),
+		terminateOnForeground: parseWithSchema(Type.Boolean(), obj.terminateOnForeground),
 	};
-	return Object.values(tools).some((entry) => entry !== undefined)
-		? tools
-		: undefined;
+	return Object.values(tools).some((entry) => entry !== undefined) ? tools : undefined;
 }
 
 function parseTelemetryConfig(value: unknown): CrewTelemetryConfig | undefined {
@@ -1079,125 +868,68 @@ function parseTelemetryConfig(value: unknown): CrewTelemetryConfig | undefined {
 	const telemetry: CrewTelemetryConfig = {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 	};
-	return Object.values(telemetry).some((entry) => entry !== undefined)
-		? telemetry
-		: undefined;
+	return Object.values(telemetry).some((entry) => entry !== undefined) ? telemetry : undefined;
 }
 
 function parsePolicyConfig(value: unknown): CrewPolicyConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const policy: CrewPolicyConfig = {
-		requireIntentForDestructiveActions: parseWithSchema(
-			Type.Boolean(),
-			obj.requireIntentForDestructiveActions,
-		),
-		disabledCapabilities: parseWithSchema(
-			Type.Array(Type.String()),
-			obj.disabledCapabilities,
-		),
+		requireIntentForDestructiveActions: parseWithSchema(Type.Boolean(), obj.requireIntentForDestructiveActions),
+		disabledCapabilities: parseWithSchema(Type.Array(Type.String()), obj.disabledCapabilities),
 	};
-	return Object.values(policy).some((entry) => entry !== undefined)
-		? policy
-		: undefined;
+	return Object.values(policy).some((entry) => entry !== undefined) ? policy : undefined;
 }
 
-function parseNotificationsConfig(
-	value: unknown,
-): CrewNotificationsConfig | undefined {
+function parseNotificationsConfig(value: unknown): CrewNotificationsConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const notifications: CrewNotificationsConfig = {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 		severityFilter: parseWithSchema(
-			Type.Array(
-				Type.Union([
-					Type.Literal("info"),
-					Type.Literal("warning"),
-					Type.Literal("error"),
-					Type.Literal("critical"),
-				]),
-			),
+			Type.Array(Type.Union([Type.Literal("info"), Type.Literal("warning"), Type.Literal("error"), Type.Literal("critical")])),
 			obj.severityFilter,
 		),
-		dedupWindowMs: parsePositiveInteger(
-			obj.dedupWindowMs,
-			24 * 60 * 60 * 1000,
-		),
-		batchWindowMs: parseWithSchema(
-			Type.Integer({ minimum: 0, maximum: 60_000 }),
-			obj.batchWindowMs,
-		),
-		quietHours: parseWithSchema(
-			Type.String({ pattern: "^\\d{2}:\\d{2}-\\d{2}:\\d{2}$" }),
-			obj.quietHours,
-		),
+		dedupWindowMs: parsePositiveInteger(obj.dedupWindowMs, 24 * 60 * 60 * 1000),
+		batchWindowMs: parseWithSchema(Type.Integer({ minimum: 0, maximum: 60_000 }), obj.batchWindowMs),
+		quietHours: parseWithSchema(Type.String({ pattern: "^\\d{2}:\\d{2}-\\d{2}:\\d{2}$" }), obj.quietHours),
 		sinkRetentionDays: parsePositiveInteger(obj.sinkRetentionDays, 90),
 	};
-	return Object.values(notifications).some((entry) => entry !== undefined)
-		? notifications
-		: undefined;
+	return Object.values(notifications).some((entry) => entry !== undefined) ? notifications : undefined;
 }
 
-function parseObservabilityConfig(
-	value: unknown,
-): CrewObservabilityConfig | undefined {
+function parseObservabilityConfig(value: unknown): CrewObservabilityConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const observability: CrewObservabilityConfig = {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
-		pollIntervalMs: parseWithSchema(
-			Type.Integer({ minimum: 1000, maximum: 60_000 }),
-			obj.pollIntervalMs,
-		),
+		pollIntervalMs: parseWithSchema(Type.Integer({ minimum: 1000, maximum: 60_000 }), obj.pollIntervalMs),
 		metricRetentionDays: parsePositiveInteger(obj.metricRetentionDays, 365),
 	};
-	return Object.values(observability).some((entry) => entry !== undefined)
-		? observability
-		: undefined;
+	return Object.values(observability).some((entry) => entry !== undefined) ? observability : undefined;
 }
 
-function parseReliabilityConfig(
-	value: unknown,
-): CrewReliabilityConfig | undefined {
+function parseReliabilityConfig(value: unknown): CrewReliabilityConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
 	const retryObj = asRecord(obj.retryPolicy);
 	const retryPolicy: CrewRetryPolicyConfig | undefined = retryObj
 		? {
 				maxAttempts: parsePositiveInteger(retryObj.maxAttempts, 10),
-				backoffMs: parseWithSchema(
-					Type.Integer({ minimum: 100, maximum: 60_000 }),
-					retryObj.backoffMs,
-				),
-				jitterRatio: parseWithSchema(
-					Type.Number({ minimum: 0, maximum: 1 }),
-					retryObj.jitterRatio,
-				),
-				exponentialFactor: parseWithSchema(
-					Type.Number({ minimum: 1, maximum: 5 }),
-					retryObj.exponentialFactor,
-				),
+				backoffMs: parseWithSchema(Type.Integer({ minimum: 100, maximum: 60_000 }), retryObj.backoffMs),
+				jitterRatio: parseWithSchema(Type.Number({ minimum: 0, maximum: 1 }), retryObj.jitterRatio),
+				exponentialFactor: parseWithSchema(Type.Number({ minimum: 1, maximum: 5 }), retryObj.exponentialFactor),
 				retryableErrors: parseStringList(retryObj.retryableErrors),
 			}
 		: undefined;
 	const reliability: CrewReliabilityConfig = {
 		autoRetry: parseWithSchema(Type.Boolean(), obj.autoRetry),
-		retryPolicy:
-			retryPolicy &&
-			Object.values(retryPolicy).some((entry) => entry !== undefined)
-				? retryPolicy
-				: undefined,
+		retryPolicy: retryPolicy && Object.values(retryPolicy).some((entry) => entry !== undefined) ? retryPolicy : undefined,
 		autoRecover: parseWithSchema(Type.Boolean(), obj.autoRecover),
 		deadletterThreshold: parsePositiveInteger(obj.deadletterThreshold),
-		cleanupOrphanedTempDirs: parseWithSchema(
-			Type.Boolean(),
-			obj.cleanupOrphanedTempDirs,
-		),
+		cleanupOrphanedTempDirs: parseWithSchema(Type.Boolean(), obj.cleanupOrphanedTempDirs),
 	};
-	return Object.values(reliability).some((entry) => entry !== undefined)
-		? reliability
-		: undefined;
+	return Object.values(reliability).some((entry) => entry !== undefined) ? reliability : undefined;
 }
 
 function parseOtlpConfig(value: unknown): CrewOtlpConfig | undefined {
@@ -1236,14 +968,9 @@ function parseOtlpConfig(value: unknown): CrewOtlpConfig | undefined {
 		enabled: parseWithSchema(Type.Boolean(), obj.enabled),
 		endpoint: parseWithSchema(Type.String({ minLength: 1 }), obj.endpoint),
 		headers: Object.keys(headers).length > 0 ? headers : undefined,
-		intervalMs: parseWithSchema(
-			Type.Integer({ minimum: 5000 }),
-			obj.intervalMs,
-		),
+		intervalMs: parseWithSchema(Type.Integer({ minimum: 5000 }), obj.intervalMs),
 	};
-	return Object.values(otlp).some((entry) => entry !== undefined)
-		? otlp
-		: undefined;
+	return Object.values(otlp).some((entry) => entry !== undefined) ? otlp : undefined;
 }
 
 export function parseConfig(raw: unknown): PiTeamsConfig {
@@ -1252,14 +979,8 @@ export function parseConfig(raw: unknown): PiTeamsConfig {
 	return {
 		asyncByDefault: parseWithSchema(Type.Boolean(), obj.asyncByDefault),
 		executeWorkers: parseWithSchema(Type.Boolean(), obj.executeWorkers),
-		notifierIntervalMs: parseWithSchema(
-			Type.Number({ minimum: 1_000 }),
-			obj.notifierIntervalMs,
-		),
-		requireCleanWorktreeLeader: parseWithSchema(
-			Type.Boolean(),
-			obj.requireCleanWorktreeLeader,
-		),
+		notifierIntervalMs: parseWithSchema(Type.Number({ minimum: 1_000 }), obj.notifierIntervalMs),
+		requireCleanWorktreeLeader: parseWithSchema(Type.Boolean(), obj.requireCleanWorktreeLeader),
 		autonomous: parseAutonomousConfig(obj.autonomous),
 		limits: parseLimitsConfig(obj.limits),
 		runtime: parseRuntimeConfig(obj.runtime),
@@ -1279,8 +1000,7 @@ export function parseConfig(raw: unknown): PiTeamsConfig {
 }
 
 export function parseConfigWithWarnings(raw: unknown): ConfigValidationResult {
-	if (!raw || typeof raw !== "object" || Array.isArray(raw))
-		return { config: {}, warnings: [] };
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { config: {}, warnings: [] };
 	const parsed = parseConfig(raw);
 	const warnings = validateConfigWithWarnings(raw as Record<string, unknown>);
 	return { config: parsed, warnings };
@@ -1292,8 +1012,7 @@ function unsetPath(record: Record<string, unknown>, dottedPath: string): void {
 	let target: Record<string, unknown> = record;
 	for (const part of parts.slice(0, -1)) {
 		const current = target[part];
-		if (!current || typeof current !== "object" || Array.isArray(current))
-			return;
+		if (!current || typeof current !== "object" || Array.isArray(current)) return;
 		target = current as Record<string, unknown>;
 	}
 	delete target[parts[parts.length - 1]!];
@@ -1333,17 +1052,14 @@ function readOptionalConfig(filePath: string): {
 	config: PiTeamsConfig;
 	warnings: string[];
 } {
-	if (!fs.existsSync(filePath))
-		return { exists: false, config: {}, warnings: [] };
+	if (!fs.existsSync(filePath)) return { exists: false, config: {}, warnings: [] };
 	try {
 		const raw = readConfigRecord(filePath);
 		const parsed = parseConfigWithWarnings(raw);
 		return {
 			exists: true,
 			config: parsed.config,
-			warnings: parsed.warnings.map(
-				(warning) => `${filePath}: ${warning}`,
-			),
+			warnings: parsed.warnings.map((warning) => `${filePath}: ${warning}`),
 		};
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -1358,6 +1074,27 @@ function readOptionalConfig(filePath: string): {
 export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 	const filePath = configPath();
 	const legacyPath = legacyConfigPath();
+
+	// (F16) Quick-win cache: skip the expensive full-reparse on hot paths
+	// (preload tick 1 Hz, per-write validation, subagent completion) when the
+	// on-disk config files are unchanged. See CONFIG_CACHE_TTL_MS at the
+	// top of this file for the rationale and the manifestCache pattern in
+	// state-store.ts:75-130 for the canonical implementation we mirror.
+	const cacheParts = readCachedConfigParts(filePath, legacyPath, cwd);
+	const cacheKey = buildConfigCacheKey(cacheParts);
+	const cached = configCache.get(cacheKey);
+	const ttlMs = configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+	if (cached && Date.now() - cached.cachedAt <= ttlMs) {
+		const currentMtimes = readCacheMtimes(cacheParts);
+		if (matchesCachedMtimes(cached.mtimes, currentMtimes)) {
+			// Refresh insertion order so a frequently-accessed key isn't
+			// evicted from the Map on the next eviction sweep.
+			configCache.delete(cacheKey);
+			configCache.set(cacheKey, cached);
+			return cached.value;
+		}
+	}
+
 	const paths = cwd ? [filePath, projectConfigPath(cwd)] : [filePath];
 	const warnings: string[] = [];
 	const legacyConfig = readOptionalConfig(legacyPath);
@@ -1367,12 +1104,7 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 	}
 	const userConfig = readOptionalConfig(filePath);
 	warnings.push(...userConfig.warnings);
-	let config = mergeConfig(
-		legacyConfig.exists && legacyPath !== filePath
-			? legacyConfig.config
-			: {},
-		userConfig.config,
-	);
+	let config = mergeConfig(legacyConfig.exists && legacyPath !== filePath ? legacyConfig.config : {}, userConfig.config);
 	if (cwd) {
 		const projectPath = projectConfigPath(cwd);
 		const projectConfig = readOptionalConfig(projectPath);
@@ -1381,15 +1113,8 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 		// Sensitive fields have already been sanitized by sanitizeProjectConfig.
 		let effectiveConfig = {};
 		if (projectConfig.exists) {
-			const projectSafeConfig = sanitizeProjectConfig(
-				projectPath,
-				config,
-				projectConfig.config,
-			);
-			warnings.push(
-				...projectConfig.warnings,
-				...projectSafeConfig.warnings,
-			);
+			const projectSafeConfig = sanitizeProjectConfig(projectPath, config, projectConfig.config);
+			warnings.push(...projectConfig.warnings, ...projectSafeConfig.warnings);
 			// merge(base=projectConfig, override=userConfig) → override wins
 			effectiveConfig = mergeConfig(effectiveConfig, projectSafeConfig.config);
 		}
@@ -1397,7 +1122,6 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 		effectiveConfig = mergeConfig(effectiveConfig, config);
 		config = effectiveConfig;
 
-
 		// `.pi/pi-crew.json` is the project-owned config file.
 		// Merge project config FIRST (base), then user config on top (override).
 		// This ensures user preferences always take precedence over project settings.
@@ -1406,11 +1130,7 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 		const piCrewJsonConfig = readOptionalConfig(piCrewJsonPath);
 		if (piCrewJsonConfig.exists) {
 			warnings.push(...piCrewJsonConfig.warnings);
-			const projectPart = sanitizeProjectConfig(
-				piCrewJsonPath,
-				config,
-				piCrewJsonConfig.config,
-			);
+			const projectPart = sanitizeProjectConfig(piCrewJsonPath, config, piCrewJsonConfig.config);
 			warnings.push(...projectPart.warnings);
 			// base=project config, override=user config → user wins
 			const mergedProject = mergeConfig(projectPart.config, config);
@@ -1418,53 +1138,49 @@ export function loadConfig(cwd?: string): LoadedPiTeamsConfig {
 			paths.push(piCrewJsonPath);
 		}
 	}
-	return {
+	const result: LoadedPiTeamsConfig = {
 		path: filePath,
 		paths,
 		config,
 		warnings: warnings.length > 0 ? warnings : undefined,
 	};
+	// Only cache when at least one of the watched paths exists — this avoids
+	// pinning stale empty results when a user later creates one of these files
+	// in the cache window. mtime stat below picks up the new file (it appears
+	// in currentMtimes but not in cached.mtimes) and triggers a re-parse.
+	if (Object.keys(readCacheMtimes(cacheParts)).length > 0) {
+		setConfigCache(cacheKey, result, readCacheMtimes(cacheParts));
+	}
+	return result;
 }
 
-export function updateConfig(
-	patch: PiTeamsConfig,
-	options: UpdateConfigOptions = {},
-): SavedPiTeamsConfig {
-	const filePath =
-		options.scope === "project" && options.cwd
-			? projectConfigPath(options.cwd)
-			: configPath();
+export function updateConfig(patch: PiTeamsConfig, options: UpdateConfigOptions = {}): SavedPiTeamsConfig {
+	const filePath = options.scope === "project" && options.cwd ? projectConfigPath(options.cwd) : configPath();
 	const lockPath = filePath + ".lock";
 	return withFileLockSync(lockPath, () => {
 		let current: Record<string, unknown>;
 		try {
 			current = readConfigRecord(filePath);
 		} catch (error) {
-			const message =
-				error instanceof Error ? error.message : String(error);
+			const message = error instanceof Error ? error.message : String(error);
 			throw new Error(`Could not update pi-crew config: ${message}`);
 		}
 		let merged = mergeConfig(parseConfig(current), patch);
 		if (options.unsetPaths?.length) {
-			const raw = JSON.parse(JSON.stringify(merged)) as Record<
-				string,
-				unknown
-			>;
+			const raw = JSON.parse(JSON.stringify(merged)) as Record<string, unknown>;
 			for (const unset of options.unsetPaths) unsetPath(raw, unset);
 			merged = parseConfig(raw);
 		}
 		fs.mkdirSync(path.dirname(filePath), { recursive: true });
-		atomicWriteFile(
-			filePath,
-			`${JSON.stringify(merged, null, 2)}\n`,
-		);
+		atomicWriteFile(filePath, `${JSON.stringify(merged, null, 2)}\n`);
+		// (F16) Invalidate the loadConfig cache after a write — the next
+		// caller must see the new value, not a 0-2s stale snapshot.
+		invalidateConfigCache();
 		return { path: filePath, config: merged };
 	});
 }
 
-export function updateAutonomousConfig(
-	patch: PiTeamsAutonomousConfig,
-): SavedPiTeamsConfig {
+export function updateAutonomousConfig(patch: PiTeamsAutonomousConfig): SavedPiTeamsConfig {
 	const filePath = configPath();
 	const lockPath = filePath + ".lock";
 	return withFileLockSync(lockPath, () => {
@@ -1472,21 +1188,17 @@ export function updateAutonomousConfig(
 		try {
 			current = readConfigRecord(filePath);
 		} catch (error) {
-			const message =
-				error instanceof Error ? error.message : String(error);
+			const message = error instanceof Error ? error.message : String(error);
 			throw new Error(`Could not update pi-crew config: ${message}`);
 		}
 		const currentAutonomous =
-			current.autonomous &&
-			typeof current.autonomous === "object" &&
-			!Array.isArray(current.autonomous)
+			current.autonomous && typeof current.autonomous === "object" && !Array.isArray(current.autonomous)
 				? (current.autonomous as Record<string, unknown>)
 				: {};
 		current.autonomous = { ...currentAutonomous, ...patch };
-		atomicWriteFile(
-			filePath,
-			`${JSON.stringify(current, null, 2)}\n`,
-		);
+		atomicWriteFile(filePath, `${JSON.stringify(current, null, 2)}\n`);
+		// (F16) Invalidate the loadConfig cache after a write — see updateConfig.
+		invalidateConfigCache();
 		return { path: filePath, config: parseConfig(current) };
 	});
 }