kizlo 0.18.0 → 0.20.0

package/dist/adapters/auth.d.ts

@@ -1,27 +1,28 @@
-import { Promisify } from "@kizlo/shared";
+import { JsonValue, Promisify } from "@kizlo/shared";
 
 //#region src/adapters/auth.d.ts
 interface AuthUser {
-  /** The WordPress user id this caller maps to. */
-  id: number;
-  /** The user's email, if known. */
-  email?: string;
-  /** The user's phone number, if known. */
-  phone?: string;
-  /** The user's first name. */
-  firstName: string;
-  /** The user's last name. */
-  lastName: string;
+  /** The third-party auth id. This is the identity provider's own id, never a WordPress user id. */
+  id: string;
+  /** The user's email. The single join key that maps this session to a WordPress user. */
+  email: string;
+  /** The user's first name, if known. */
+  firstName?: string;
+  /** The user's last name, if known. */
+  lastName?: string;
+  /** Arbitrary claims the auth service carries alongside the identity. */
+  meta?: Record<string, JsonValue>;
 }
-type AuthGetUser = (request: Request | null) => Promisify<AuthUser | null>;
+type AuthGetSession = (request: Request | null) => Promisify<AuthUser | null>;
 interface AuthAdapter {
-  /** Resolve the authenticated user from the request, or `null` when there is no session. Receives `null` for server-side (non-HTTP) invocations. */
-  getUser: AuthGetUser;
+  /** Resolve the authenticated session from the request, or `null` when there is no session. Receives `null` for server-side (non-HTTP) invocations. */
+  getSession: AuthGetSession;
 }
 /** Author a custom auth adapter, typed against the {@link AuthAdapter} contract. */
 declare function createAuthAdapter(adapter: AuthAdapter): AuthAdapter;
 declare function authMock(options?: {
-  mockUserId?: number;
+  id?: string;
+  email?: string;
 }): AuthAdapter;
 //#endregion
-export { AuthAdapter, AuthGetUser, AuthUser, authMock, createAuthAdapter };
+export { AuthAdapter, AuthGetSession, AuthUser, authMock, createAuthAdapter };

package/dist/adapters/auth.js

@@ -4,13 +4,12 @@ function createAuthAdapter(adapter) {
 	return adapter;
 }
 function authMock(options) {
-	return { getUser() {
+	return { getSession() {
 		return {
-			id: options?.mockUserId ?? 0,
+			id: options?.id ?? "auth-mock-user",
+			email: options?.email ?? "karan@gmail.com",
 			firstName: "Karan",
-			lastName: "Gill",
-			email: "karan@gmail.con",
-			phone: "12345678901"
+			lastName: "Gill"
 		};
 	} };
 }

package/dist/cli/commands/_wiring.js

@@ -1,5 +1,5 @@
 import { aliasWithSlash, resolveModuleImport, writeFileIfAbsent } from "../utils.js";
-import { CONTRACT_BARREL, WORDPRESS_STUB } from "../daemon/generate.js";
+import { CONTRACT_BARREL, INTROSPECTION_STUB } from "../daemon/generate.js";
 import { resolvePatch } from "../presets/template.js";
 import { orCancel } from "./_setup.js";
 import { applyPatchToSource, patchChanged, renderPatchCode, resolvePatchTargetPath } from "../presets/patch.js";
@@ -8,16 +8,17 @@ import fs from "node:fs";
 import * as p from "@clack/prompts";
 
 //#region src/cli/commands/_wiring.ts
-/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, the import-alias preference, and —
-*  when local WordPress is chosen — `dev.local` + `test.local` so `kizlo dev` and `kizlo test` boot the
-*  fixed `.kizlo/local` install. The alias is always written — `""` for relative imports included — so it
-*  records a made decision a later `kizlo init` reads back instead of prompting for it again. The alias
-*  is written in its canonical `@/` form (never a bare `@`) so it reads like the imports it produces. */
+/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, the import-alias preference, and,
+*  when local WordPress is chosen, `local: true` so `kizlo dev` and `kizlo test` boot the fixed
+*  `.kizlo/local` install (both stacks on with defaults; the object form is for configuring them). The
+*  alias is always written (`""` for relative imports included) so it records a made decision a later
+*  `kizlo init` reads back instead of prompting for it again. The alias is written in its canonical `@/`
+*  form (never a bare `@`) so it reads like the imports it produces. */
 function kizloConfigTemplate(dir, alias, localWordPress = false) {
 	return `import { defineConfig } from "kizlo/config"
 
 export default defineConfig({
-	dir: "${dir}",${`\n\talias: "${aliasWithSlash(alias)}",`}${localWordPress ? `\n\tdev: { local: true },\n\ttest: { local: true },` : ""}
+	dir: "${dir}",${`\n\talias: "${aliasWithSlash(alias)}",`}${localWordPress ? `\n\tlocal: true,` : ""}
 })
 `;
 }
@@ -77,7 +78,7 @@ function writeGeneratedContract(cwd, serverDirRel) {
 	const generatedDirRel = path.join(serverDirRel, "generated");
 	writeFileIfAbsent(path.join(cwd, generatedDirRel, "contract.json"), "{}\n");
 	writeFileIfAbsent(path.join(cwd, generatedDirRel, "index.ts"), CONTRACT_BARREL);
-	writeFileIfAbsent(path.join(cwd, generatedDirRel, "wordpress.ts"), WORDPRESS_STUB);
+	writeFileIfAbsent(path.join(cwd, generatedDirRel, "introspection.ts"), INTROSPECTION_STUB);
 }
 /**
 * Apply every patch a template declares, merging Kizlo wiring into files the project already owns

package/dist/cli/commands/check.js

@@ -1,6 +1,6 @@
 import { log } from "../daemon/logger.js";
-import { resolveConfig, resolveWordPressClientDir } from "../daemon/config.js";
-import { generateWordPressSource, reportGenerationError } from "../daemon/generate.js";
+import { resolveConfig } from "../daemon/config.js";
+import { generateIntrospectionSource, reportGenerationError } from "../daemon/generate.js";
 import { testWordPressCredentials } from "./_test-wordpress.js";
 import path from "node:path";
 import fs from "node:fs";
@@ -26,14 +26,10 @@ function formatGeneratedFileDiff(cwd, mismatch) {
 	const file = path.relative(cwd, mismatch.file) || path.basename(mismatch.file);
 	return createTwoFilesPatch(file, file, mismatch.actual, mismatch.expected, "committed", "generated", { context: 3 });
 }
-/** Every WordPress client the project configuration says it owns, with duplicates collapsed. */
-async function wordPressClientFiles(cwd, dir) {
-	const files = /* @__PURE__ */ new Set();
-	const workspaceDir = await resolveWordPressClientDir(cwd);
-	if (workspaceDir) files.add(path.resolve(cwd, workspaceDir, "wordpress.ts"));
+/** The generated introspection the project configuration owns, if any. */
+async function introspectionFiles(cwd, dir) {
 	const config = await resolveConfig(cwd, { dir });
-	if (config) files.add(path.resolve(cwd, config.wordpressPath));
-	return [...files];
+	return config ? [path.resolve(cwd, config.introspectionPath)] : [];
 }
 const check = defineCommand({
 	meta: {
@@ -52,9 +48,9 @@ const check = defineCommand({
 	},
 	async run({ args }) {
 		const cwd = process.cwd();
-		const files = await wordPressClientFiles(cwd, args.dir);
+		const files = await introspectionFiles(cwd, args.dir);
 		if (files.length === 0) {
-			log.info("No generated WordPress client configured, nothing to check.");
+			log.info("No generated WordPress introspection configured, nothing to check.");
 			return;
 		}
 		let credentials;
@@ -67,18 +63,18 @@ const check = defineCommand({
 		}
 		let expected;
 		try {
-			expected = await generateWordPressSource(cwd, {
+			expected = await generateIntrospectionSource(cwd, {
 				credentials,
 				strict: true
 			});
 		} catch (error) {
-			reportGenerationError("Failed to check the generated WordPress client:", error);
+			reportGenerationError("Failed to check the generated WordPress introspection:", error);
 			process.exitCode = 1;
 			return;
 		}
 		const mismatches = findGeneratedFileMismatches(files, expected);
 		if (mismatches.length === 0) {
-			log.success(`${files.length === 1 ? "WordPress client is" : "WordPress clients are"} current`);
+			log.success("WordPress introspection is current");
 			return;
 		}
 		for (const mismatch of mismatches) {
@@ -90,7 +86,7 @@ const check = defineCommand({
 			args.test ? "--test" : "",
 			args.dir ? `--dir ${args.dir}` : ""
 		].filter(Boolean).join(" ");
-		log.info(`Run \`${command}\` and commit the updated client.`);
+		log.info(`Run \`${command}\` and commit the updated introspection.`);
 		process.exitCode = 1;
 	}
 });

package/dist/cli/commands/dev.js

@@ -25,12 +25,12 @@ async function resolve$1(cwd) {
 }
 /**
 * The lifecycle subcommands (`stop`/`reset`) only act on local WordPress. A project pointing at its
-* own WordPress (no `dev.local`) has nothing to manage, so print a plain note and exit cleanly. Returns
+* own WordPress (no `local`) has nothing to manage, so print a plain note and exit cleanly. Returns
 * true when local WordPress is configured and the caller may proceed.
 */
 async function requireLocalWordPress(cwd) {
 	if (await usesLocalWordPress(cwd)) return true;
-	note("This project doesn't run local WordPress — set `dev.local: true` in kizlo.config.ts to add it.");
+	note("This project doesn't run local WordPress — set `local: true` in kizlo.config.ts to add it.");
 	return false;
 }
 /** A dim, untagged one-liner (no consola timestamp) for the clean dev output. */
@@ -351,7 +351,7 @@ async function watchOnly(cwd) {
 async function bringUp() {
 	const cwd = process.cwd();
 	if (!await usesLocalWordPress(cwd)) {
-		note("This project doesn't run local WordPress — running the contract watcher only. Set `dev.local` in kizlo.config.ts to add it.");
+		note("This project doesn't run local WordPress — running the contract watcher only. Set `local` in kizlo.config.ts to add it.");
 		await watchOnly(cwd);
 		return;
 	}

package/dist/cli/commands/generate.js

@@ -1,6 +1,6 @@
 import { log } from "../daemon/logger.js";
-import { resolveConfig, resolveWordPressClientDir } from "../daemon/config.js";
-import { PartialContractError, generateOnce, generateWorkspaceClientOnce, reportGenerationError } from "../daemon/generate.js";
+import { resolveConfig } from "../daemon/config.js";
+import { PartialContractError, generateOnce, reportGenerationError } from "../daemon/generate.js";
 import { testWordPressCredentials } from "./_test-wordpress.js";
 import path from "node:path";
 import { defineCommand } from "citty";
@@ -12,7 +12,7 @@ import { defineCommand } from "citty";
 * mode did not do to the files on disk.
 */
 function fail(message, error) {
-	if (error instanceof PartialContractError) log.error(`${error.message} The generated client on disk is unchanged.`);
+	if (error instanceof PartialContractError) log.error(`${error.message} The generated introspection on disk is unchanged.`);
 	else reportGenerationError(message, error);
 	process.exit(1);
 }
@@ -28,7 +28,7 @@ const generate = defineCommand({
 		},
 		strict: {
 			type: "boolean",
-			description: "Fail instead of generating a client WordPress had to exclude routes or types from"
+			description: "Fail instead of generating an introspection WordPress had to exclude routes or types from"
 		},
 		test: {
 			type: "boolean",
@@ -50,29 +50,27 @@ const generate = defineCommand({
 			credentials,
 			strict
 		};
-		const wordpressClientDir = await resolveWordPressClientDir(cwd);
-		if (wordpressClientDir) try {
-			const result = await generateWorkspaceClientOnce(cwd, wordpressClientDir, options);
-			const file = path.resolve(cwd, wordpressClientDir, "wordpress.ts");
-			log.success(`WordPress client ${result === "generated" ? "written to" : "already current at"} ${file}`);
-		} catch (error) {
-			fail("Failed to generate the WordPress client:", error);
-		}
 		const cfg = await resolveConfig(cwd, { dir: args.dir });
 		if (!cfg) {
-			if (!wordpressClientDir) log.info("No Kizlo server directory configured, nothing to generate. Set `dir` in kizlo.config.ts or pass --dir.");
+			log.info("Nothing to generate. Set `dir` in kizlo.config.ts or pass --dir.");
 			return;
 		}
-		let ok;
+		let result;
 		try {
-			ok = await generateOnce(cfg, options);
+			result = await generateOnce(cfg, options);
 		} catch (error) {
 			fail("Failed to generate the Kizlo contract:", error);
 		}
-		if (!ok) {
-			log.error(`No Kizlo server found in ${cfg.serverEntry}`);
+		if (result.contract === "empty" && cfg.server) {
+			log.error(`No Kizlo server found in ${cfg.server.entry}`);
 			process.exit(1);
 		}
+		if (result.contract === "none") {
+			const file = path.resolve(cwd, cfg.introspectionPath);
+			log.success(`WordPress introspection ${result.introspection === "generated" ? "written to" : "already current at"} ${file}`);
+			return;
+		}
+		if (result.introspection === "generated") log.success("WordPress introspection generated");
 		log.success("Contract generated");
 	}
 });

package/dist/cli/commands/test.js

@@ -114,9 +114,9 @@ const runArgs = {
 	}
 };
 /**
-* Run the project's tests. When `test.local` is set, boot (+ seed) local WordPress first, run the
-* suite (JS then the plugin's PHPUnit) against it, then leave it up (or tear down). Without
-* `test.local`, there's no Docker WordPress to manage — just run the project's own test script.
+* Run the project's tests. When the test stack is enabled (`local` with `test.enable !== false`), boot
+* (+ seed) local WordPress first, run the suite (JS then the plugin's PHPUnit) against it, then leave it
+* up (or tear down). Otherwise there's no Docker WordPress to manage — just run the project's own test script.
 */
 async function runSuite({ args }) {
 	const cfg = await resolveTestConfig(process.cwd());

package/dist/cli/daemon/config.js

@@ -1,4 +1,4 @@
-import { DEFAULT_WORDPRESS_TAG, LOCAL_DIR_REL, WORDPRESS_META_REL } from "../wp/constants.js";
+import { DEFAULT_WORDPRESS_TAG, INTROSPECTION_META_REL, LOCAL_DIR_REL } from "../wp/constants.js";
 import { credentialsPath, findConfigDir } from "../wp/utils.js";
 import { log } from "./logger.js";
 import { detectPackageManager } from "../utils.js";
@@ -11,39 +11,82 @@ import fs from "node:fs";
 //#region src/cli/daemon/config.ts
 const fixtureSchema = z.custom((value) => typeof value === "object" && value !== null && typeof value.name === "string", { message: "must be a fixture object with a string `name` (use defineFixture)" });
 /**
-* `dev.version` / `test.version`. Validated against Docker's tag grammar here rather than at boot,
-* so `"wordpress:7.1.0"`, which would resolve to `wordpress:wordpress:7.1.0`, is named as a config
-* mistake instead of surfacing as a pull failure seconds into starting a stack.
+* `local.dev.version` / `local.test.version`. Validated against Docker's tag grammar here rather than
+* at boot, so `"wordpress:7.1.0"`, which would resolve to `wordpress:wordpress:7.1.0`, is named as a
+* config mistake instead of surfacing as a pull failure seconds into starting a stack.
 */
 const versionSchema = z.string().regex(WORDPRESS_TAG_PATTERN, "must be a WordPress image tag, like \"7.1.0\" or \"7.1.0-php8.3-apache\" (no \"wordpress:\" prefix)");
+/**
+* A key that moved in the config redesign. It accepts only `undefined`, so an absent key passes and a
+* present one fails validation with a message naming where it went: a hard cutover with no silent
+* fallback. {@link loadConfigFile} surfaces the message through `z.prettifyError`.
+*/
+const removedKey = (message) => z.undefined({ error: message }).optional();
+const dirSchema = z.union([z.string(), z.object({
+	server: z.string().optional(),
+	contract: z.string().optional(),
+	introspection: z.string().optional()
+})]);
+const devStackSchema = z.object({
+	enable: z.boolean().optional(),
+	port: z.number().int().positive().optional(),
+	version: versionSchema.optional(),
+	dbPort: z.number().int().positive().optional(),
+	fixtures: z.array(fixtureSchema).optional()
+});
+const testStackSchema = z.object({
+	enable: z.boolean().optional(),
+	inherit: z.boolean().optional(),
+	port: z.number().int().positive().optional(),
+	version: versionSchema.optional(),
+	fixtures: z.array(fixtureSchema).optional(),
+	packageManager: z.enum([
+		"npm",
+		"pnpm",
+		"yarn",
+		"bun"
+	]).optional(),
+	command: z.string().optional()
+});
+const localSchema = z.union([z.boolean(), z.object({
+	enable: z.boolean().optional(),
+	name: z.string().optional(),
+	worktrees: z.boolean().optional(),
+	dev: devStackSchema.optional(),
+	test: testStackSchema.optional()
+})]);
 /** Runtime shape of `kizlo.config.*` — mirrors {@link KizloGlobalConfig}. */
 const configSchema = z.object({
-	dir: z.string().optional(),
+	dir: dirSchema.optional(),
 	alias: z.string().optional(),
-	name: z.string().optional(),
-	worktrees: z.boolean().optional(),
-	wordpressClientDir: z.string().optional(),
-	dev: z.object({
-		local: z.boolean().optional(),
-		port: z.number().int().positive().optional(),
-		version: versionSchema.optional(),
-		dbPort: z.number().int().positive().optional(),
-		fixtures: z.array(fixtureSchema).optional()
-	}).optional(),
-	test: z.object({
-		local: z.boolean().optional(),
-		port: z.number().int().positive().optional(),
-		version: versionSchema.optional(),
-		fixtures: z.array(fixtureSchema).optional(),
-		packageManager: z.enum([
-			"npm",
-			"pnpm",
-			"yarn",
-			"bun"
-		]).optional(),
-		command: z.string().optional()
-	}).optional()
+	local: localSchema.optional(),
+	wordpressClientDir: removedKey("`wordpressClientDir` has been removed. Use `dir: { introspection }` instead."),
+	name: removedKey("`name` is no longer a config root key. Move it under `local.name`."),
+	worktrees: removedKey("`worktrees` is no longer a config root key. Move it under `local.worktrees`."),
+	dev: removedKey("`dev` is no longer a config root key. Move it under `local.dev`."),
+	test: removedKey("`test` is no longer a config root key. Move it under `local.test`.")
 });
+/** Normalize `local` (absent, `true`, `false`, or the object form) into one shape the resolvers read. */
+function resolveLocal(fileConfig) {
+	const local = fileConfig?.local;
+	if (local === true) return {
+		enabled: true,
+		dev: {},
+		test: {}
+	};
+	if (!local) return {
+		enabled: false,
+		dev: {},
+		test: {}
+	};
+	return {
+		enabled: local.enable !== false,
+		name: local.name,
+		worktrees: local.worktrees,
+		dev: local.dev ?? {},
+		test: local.test ?? {}
+	};
+}
 const CONFIG_FILES = [
 	"kizlo.config.ts",
 	"kizlo.config.js",
@@ -52,6 +95,12 @@ const CONFIG_FILES = [
 const DEFAULT_DEV_PORT = 8080;
 const DEFAULT_DEV_DB_PORT = 3307;
 const DEFAULT_TEST_PORT = 8889;
+/** The generated introspection artifact's filename, written under its resolved directory. */
+const INTROSPECTION_FILE = "introspection.ts";
+/** Strip a leading `./` and trailing slashes so a config path joins cleanly. */
+function normalizeDir(value) {
+	return value.replace(/^\.\//, "").replace(/\/+$/, "");
+}
 async function loadConfigFile(cwd) {
 	const file = CONFIG_FILES.map((name) => path.join(cwd, name)).find((p) => fs.existsSync(p));
 	if (!file) return void 0;
@@ -71,40 +120,56 @@ async function loadConfigFile(cwd) {
 	return result.data;
 }
 /**
-* Resolve the Kizlo server layout from an explicit `dir` — the `--dir` flag or `dir` in
-* `kizlo.config.*`. Returns `undefined` when neither is set: there's no Kizlo server to
-* generate a contract from, so callers skip generation and (for `dev`) run local WordPress
-* alone. There's intentionally no default path — a missing `dir` means "no server", not
-* "look under `lib/kizlo`".
+* Resolve what Kizlo generates and watches from `dir`: the `--dir` flag or `dir` in `kizlo.config.*`.
+* A string is the home Kizlo owns the layout under (sources in `<dir>/server`, generated files under
+* `<dir>/server/generated`); the object form sets `server` / `contract` / `introspection` independently.
+*
+* The introspection is always generated at its resolved path, so a project with no server still gets it.
+* `server` is present only when `dir` resolves a server path (the string form always does, the object
+* form only when `server` is set), and its absence means there is nothing to watch and no contract to
+* build. Returns `undefined` only when nothing at all is configured (no `dir`, or an object naming
+* neither a server nor an introspection path): there is then nothing to generate.
 */
 async function resolveConfig(cwd, flags) {
 	const fileConfig = await loadConfigFile(cwd);
 	const raw = flags?.dir ?? fileConfig?.dir;
-	if (!raw) return void 0;
-	const dir = raw.replace(/^\.\//, "").replace(/\/+$/, "");
-	const serverDir = path.join(dir, "server");
-	const generatedDir = path.join(serverDir, "generated");
+	if (raw === void 0) return void 0;
+	if (typeof raw === "string") {
+		const home = normalizeDir(raw);
+		const serverDir$1 = path.join(home, "server");
+		const contractDir$1 = path.join(serverDir$1, "generated");
+		return {
+			cwd,
+			server: {
+				dir: serverDir$1,
+				entry: path.join(serverDir$1, "index.ts"),
+				contractDir: contractDir$1,
+				contractPath: path.join(contractDir$1, "contract.json"),
+				barrelPath: path.join(contractDir$1, "index.ts")
+			},
+			introspectionPath: path.join(contractDir$1, INTROSPECTION_FILE),
+			introspectionMetaPath: INTROSPECTION_META_REL
+		};
+	}
+	const serverDir = raw.server ? normalizeDir(raw.server) : void 0;
+	const contractDir = serverDir ? raw.contract ? normalizeDir(raw.contract) : path.join(serverDir, "generated") : void 0;
+	const server = serverDir && contractDir ? {
+		dir: serverDir,
+		entry: path.join(serverDir, "index.ts"),
+		contractDir,
+		contractPath: path.join(contractDir, "contract.json"),
+		barrelPath: path.join(contractDir, "index.ts")
+	} : void 0;
+	const introspectionDir = raw.introspection ? normalizeDir(raw.introspection) : contractDir;
+	if (!introspectionDir) return void 0;
 	return {
 		cwd,
-		dir,
-		serverDir,
-		serverEntry: path.join(serverDir, "index.ts"),
-		generatedDir,
-		contractPath: path.join(generatedDir, "contract.json"),
-		barrelPath: path.join(generatedDir, "index.ts"),
-		wordpressPath: path.join(generatedDir, "wordpress.ts"),
-		wordpressMetaPath: WORDPRESS_META_REL
+		server,
+		introspectionPath: path.join(introspectionDir, INTROSPECTION_FILE),
+		introspectionMetaPath: INTROSPECTION_META_REL
 	};
 }
 /**
-* The directory `wordpress.ts` is written to for a workspace with no Kizlo server, from `wordpressClientDir`
-* in `kizlo.config.*`. Resolved on its own rather than through {@link resolveConfig}, which describes a
-* server layout and returns nothing without `dir` — the two are independent.
-*/
-async function resolveWordPressClientDir(cwd) {
-	return (await loadConfigFile(cwd))?.wordpressClientDir;
-}
-/**
 * Sanitize an arbitrary package/dir name into a valid Docker compose project id:
 * lowercase, `@scope/pkg` → `scope-pkg`, dropping anything outside `[a-z0-9_-]`.
 */
@@ -164,61 +229,62 @@ function stackProject(baseName, kind) {
 	return `kizlo-${baseName}-${kind}`;
 }
 /**
-* Resolve the `test` block from `kizlo.config.*` into concrete values for the
-* `test` command, applying defaults (port 8889, auto-detected package manager)
-* and anchoring the credentials artifact to the config directory.
+* Resolve the test stack (`local.test`) into concrete values for the `test` command, applying defaults
+* (port 8889, auto-detected package manager) and anchoring the credentials artifact to the config
+* directory. `version` and `fixtures` fall back to the dev stack unless `test.inherit` is `false`;
+* `port`, `packageManager`, and `command` are never inherited.
 */
 async function resolveTestConfig(cwd) {
 	const configDir = findConfigDir(cwd);
-	const fileConfig = await loadConfigFile(configDir);
-	const test = fileConfig?.test ?? {};
+	const local = resolveLocal(await loadConfigFile(configDir));
+	const { dev, test } = local;
+	const inherit = test.inherit !== false;
 	return {
 		configDir,
-		local: Boolean(test.local),
+		local: local.enabled && test.enable !== false,
 		project: stackProject(resolveStackName(configDir, {
-			name: fileConfig?.name,
-			worktrees: fileConfig?.worktrees
+			name: local.name,
+			worktrees: local.worktrees
 		}), "test"),
 		command: test.command,
 		port: test.port ?? DEFAULT_TEST_PORT,
-		portExplicit: test.port !== void 0 && !fileConfig?.worktrees,
-		wordpressTag: test.version ?? DEFAULT_WORDPRESS_TAG,
-		fixtures: test.fixtures ?? [],
+		portExplicit: test.port !== void 0 && !local.worktrees,
+		wordpressTag: test.version ?? (inherit ? dev.version : void 0) ?? DEFAULT_WORDPRESS_TAG,
+		fixtures: test.fixtures ?? (inherit ? dev.fixtures : void 0) ?? [],
 		credentialsPath: credentialsPath(cwd),
 		packageManager: test.packageManager ?? await detectPackageManager(configDir) ?? "npm"
 	};
 }
 /**
-* Whether this project runs local WordPress under `kizlo dev` — `dev.local` is `true` in
-* `kizlo.config.*`. When false, `kizlo dev` has nothing to boot and runs the contract watcher alone,
-* the path a project pointing at its own WordPress takes. The flag is written by `create`/`init` when
-* local WordPress is chosen, and lives next to the rest of the `dev` config, so it's committed and
-* survives `kizlo dev reset`.
+* Whether this project runs local WordPress under `kizlo dev`: local is enabled and the dev stack is
+* on (`local.dev.enable !== false`) in `kizlo.config.*`. When false, `kizlo dev` has nothing to boot and
+* runs the contract watcher alone, the path a project pointing at its own WordPress takes. Written by
+* `create`/`init` when local WordPress is chosen, so it's committed and survives `kizlo dev reset`.
 */
 async function usesLocalWordPress(cwd) {
-	const fileConfig = await loadConfigFile(findConfigDir(cwd));
-	return Boolean(fileConfig?.dev?.local);
+	const local = resolveLocal(await loadConfigFile(findConfigDir(cwd)));
+	return local.enabled && local.dev.enable !== false;
 }
 /**
-* Resolve the `dev` block from `kizlo.config.*` into concrete values for the `dev` command, applying
-* defaults (port 8080). The install folder is fixed at `.kizlo/local` — no longer a config choice — so
-* there's nothing required here. Callers gate on {@link usesLocalWordPress} first, since a project
-* without local WordPress runs the watcher alone rather than reaching here.
+* Resolve the dev stack (`local.dev`) into concrete values for the `dev` command, applying defaults
+* (port 8080). The install folder is fixed at `.kizlo/local` (no longer a config choice), so there's
+* nothing required here. Callers gate on {@link usesLocalWordPress} first, since a project without
+* local WordPress runs the watcher alone rather than reaching here.
 */
 async function resolveDevConfig(cwd) {
 	const configDir = findConfigDir(cwd);
-	const fileConfig = await loadConfigFile(configDir);
-	const dev = fileConfig?.dev ?? {};
+	const local = resolveLocal(await loadConfigFile(configDir));
+	const { dev } = local;
 	return {
 		configDir,
 		project: stackProject(resolveStackName(configDir, {
-			name: fileConfig?.name,
-			worktrees: fileConfig?.worktrees
+			name: local.name,
+			worktrees: local.worktrees
 		}), "dev"),
 		port: dev.port ?? DEFAULT_DEV_PORT,
-		portExplicit: dev.port !== void 0 && !fileConfig?.worktrees,
+		portExplicit: dev.port !== void 0 && !local.worktrees,
 		dbPort: dev.dbPort ?? DEFAULT_DEV_DB_PORT,
-		dbPortExplicit: dev.dbPort !== void 0 && !fileConfig?.worktrees,
+		dbPortExplicit: dev.dbPort !== void 0 && !local.worktrees,
 		wordpressTag: dev.version ?? DEFAULT_WORDPRESS_TAG,
 		fixtures: dev.fixtures ?? [],
 		wordpressPath: LOCAL_DIR_REL,
@@ -227,4 +293,4 @@ async function resolveDevConfig(cwd) {
 }
 
 //#endregion
-export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, resolveWordPressClientDir, stackProject, usesLocalWordPress };
+export { CONFIG_FILES, DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveConfig, resolveDevConfig, resolveStackName, resolveTestConfig, stackProject, usesLocalWordPress };