wp-typia 0.16.9 → 0.16.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wp-typia",
-  "version": "0.16.9",
+  "version": "0.16.11",
   "description": "Canonical CLI package for wp-typia scaffolding and project workflows",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -65,7 +65,7 @@
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.4",
-    "@wp-typia/project-tools": "0.16.8",
+    "@wp-typia/project-tools": "0.16.10",
     "better-result": "^2.7.0",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",

package/src/cli.ts

@@ -73,6 +73,15 @@ function resolveGeneratedMetadataPath(moduleUrl: string): string {
 	return fileURLToPath(new URL("../.bunli/commands.gen.ts", moduleUrl));
 }
 
+async function formatCliError(error: unknown): Promise<string> {
+	try {
+		const { formatCliDiagnosticError } = await import("@wp-typia/project-tools/cli-diagnostics");
+		return formatCliDiagnosticError(error);
+	} catch {
+		return error instanceof Error ? error.message : String(error);
+	}
+}
+
 export async function createWpTypiaCli(options: {
 	configOverridePath?: string;
 } = {}): Promise<CLI> {
@@ -117,10 +126,14 @@ export async function main(argv = process.argv.slice(2)): Promise<void> {
 }
 
 if (import.meta.main) {
-	void main().catch((error) => {
-		console.error(error instanceof Error ? error.message : error);
-		process.exit(1);
-	});
+	void (async () => {
+		try {
+			await main();
+		} catch (error) {
+			console.error(await formatCliError(error));
+			process.exit(1);
+		}
+	})();
 }
 
 export default createWpTypiaCli;

package/src/command-contract.ts

@@ -32,12 +32,16 @@ const STRING_OPTION_NAMES_BY_COMMAND = {
 		"anchor",
 		"block",
 		"data-storage",
+		"external-layer-id",
+		"external-layer-source",
 		"persistence-policy",
 		"position",
 		"template",
 	]),
 	create: new Set([
 		"data-storage",
+		"external-layer-id",
+		"external-layer-source",
 		"namespace",
 		"package-manager",
 		"persistence-policy",

package/src/commands/add.ts

@@ -34,6 +34,14 @@ const addOptions = {
 		description: "Persistence storage mode for persistence-capable templates.",
 		schema: z.string().optional(),
 	},
+	"external-layer-id": {
+		description: "Explicit layer id when an external layer package exposes multiple selectable layers.",
+		schema: z.string().optional(),
+	},
+	"external-layer-source": {
+		description: "Local path, GitHub locator, or npm package that exposes wp-typia.layers.json for built-in block templates.",
+		schema: z.string().optional(),
+	},
 	"persistence-policy": {
 		description: "Persistence write policy for persistence-capable templates.",
 		schema: z.string().optional(),
@@ -49,6 +57,7 @@ const addOptions = {
 };
 
 export const addCommand = defineCommand({
+	defaultFormat: "toon",
 	description: "Extend an official wp-typia workspace with blocks, variations, patterns, binding sources, or hooked blocks.",
 	handler: async (args) => {
 		await executeAddCommand({
@@ -76,6 +85,12 @@ export const addCommand = defineCommand({
 								"data-storage":
 									(args.flags["data-storage"] as string | undefined) ??
 									config["data-storage"],
+								"external-layer-id":
+									(args.flags["external-layer-id"] as string | undefined) ??
+									config["external-layer-id"],
+								"external-layer-source":
+									(args.flags["external-layer-source"] as string | undefined) ??
+									config["external-layer-source"],
 								anchor: (args.flags.anchor as string | undefined) ?? "",
 								block: (args.flags.block as string | undefined) ?? "",
 								kind:

package/src/commands/create.ts

@@ -26,6 +26,14 @@ const createOptions = {
 		description: "Persistence storage mode for persistence-capable templates.",
 		schema: z.string().optional(),
 	},
+	"external-layer-id": {
+		description: "Explicit layer id when an external layer package exposes multiple selectable layers.",
+		schema: z.string().optional(),
+	},
+	"external-layer-source": {
+		description: "Local path, GitHub locator, or npm package that exposes wp-typia.layers.json for built-in templates.",
+		schema: z.string().optional(),
+	},
 	namespace: {
 		description: "Override the default block namespace.",
 		schema: z.string().optional(),
@@ -85,11 +93,16 @@ const createOptions = {
 };
 
 export const createCommand = defineCommand({
+	defaultFormat: "toon",
 	description: "Scaffold a new wp-typia project.",
 	handler: async (args) => {
 		const projectDir = args.positional[0];
 		if (!projectDir) {
-			throw new Error("`wp-typia create` requires <project-dir>.");
+			const { createCliCommandError } = await import("@wp-typia/project-tools/cli-diagnostics");
+			throw createCliCommandError({
+				command: "create",
+				detailLines: ["`wp-typia create` requires <project-dir>."],
+			});
 		}
 		await executeCreateCommand({
 			cwd: args.cwd,
@@ -115,6 +128,12 @@ export const createCommand = defineCommand({
 								"data-storage":
 									(args.flags["data-storage"] as string | undefined) ??
 									config["data-storage"],
+								"external-layer-id":
+									(args.flags["external-layer-id"] as string | undefined) ??
+									config["external-layer-id"],
+								"external-layer-source":
+									(args.flags["external-layer-source"] as string | undefined) ??
+									config["external-layer-source"],
 								namespace:
 									(args.flags.namespace as string | undefined) ?? config.namespace,
 								"no-install": Boolean(

package/src/commands/doctor.ts

@@ -2,18 +2,26 @@ import { defineCommand } from "@bunli/core";
 import { executeDoctorCommand } from "../runtime-bridge";
 
 export const doctorCommand = defineCommand({
+	defaultFormat: "toon",
 	description: "Run repository and project diagnostics.",
 	handler: async (args) => {
 		const prefersStructuredOutput =
 			(args.formatExplicit && args.format !== "toon") ||
-			args.agent ||
 			Boolean(args.context?.store?.isAIAgent);
 		if (prefersStructuredOutput) {
-			const { getDoctorChecks } = await import("@wp-typia/project-tools/cli-doctor");
+			const [{ getDoctorChecks }, { createCliCommandError, getDoctorFailureDetailLines }] =
+				await Promise.all([
+					import("@wp-typia/project-tools/cli-doctor"),
+					import("@wp-typia/project-tools/cli-diagnostics"),
+				]);
 			const checks = await getDoctorChecks(args.cwd);
 			args.output({ checks });
 			if (checks.some((check) => check.status === "fail")) {
-				throw new Error("Doctor found one or more failing checks.");
+				throw createCliCommandError({
+					command: "doctor",
+					detailLines: getDoctorFailureDetailLines(checks),
+					summary: "One or more doctor checks failed.",
+				});
 			}
 			return;
 		}

package/src/commands/migrate.ts

@@ -58,6 +58,7 @@ const migrateOptions = {
 };
 
 export const migrateCommand = defineCommand({
+	defaultFormat: "toon",
 	description: "Run migration workflows for migration-capable wp-typia projects.",
 	handler: async (args) => {
 		await executeMigrateCommand({

package/src/config.ts

@@ -12,6 +12,8 @@ export type WpTypiaSchemaSource = {
 export type WpTypiaUserConfig = {
 	create?: {
 		"data-storage"?: string;
+		"external-layer-id"?: string;
+		"external-layer-source"?: string;
 		namespace?: string;
 		"no-install"?: boolean;
 		"package-manager"?: string;
@@ -28,6 +30,8 @@ export type WpTypiaUserConfig = {
 	add?: {
 		block?: {
 			"data-storage"?: string;
+			"external-layer-id"?: string;
+			"external-layer-source"?: string;
 			"persistence-policy"?: string;
 			template?: string;
 		};

package/src/runtime-bridge.ts

@@ -29,9 +29,12 @@ type AddExecutionInput = {
 	cwd: string;
 	emitOutput?: boolean;
 	flags: Record<string, unknown>;
+	interactive?: boolean;
 	kind?: string;
 	name?: string;
 	printLine?: PrintLine;
+	prompt?: ReadlinePrompt;
+	warnLine?: PrintLine;
 };
 
 type TemplatesExecutionInput = {
@@ -56,6 +59,12 @@ type MigrateExecutionInput = {
 
 type PrintLine = (line: string) => void;
 type PackageManagerId = "bun" | "npm" | "pnpm" | "yarn";
+type CliCommandId = "add" | "create" | "doctor" | "migrate";
+type ExternalLayerSelectOption = {
+	description?: string;
+	extends: string[];
+	id: string;
+};
 
 type SyncProjectContext = {
 	cwd: string;
@@ -65,18 +74,56 @@ type SyncProjectContext = {
 };
 
 const loadCliAddRuntime = () => import("@wp-typia/project-tools/cli-add");
+const loadCliDiagnosticsRuntime = () => import("@wp-typia/project-tools/cli-diagnostics");
 const loadCliDoctorRuntime = () => import("@wp-typia/project-tools/cli-doctor");
 const loadCliPromptRuntime = () => import("@wp-typia/project-tools/cli-prompt");
 const loadCliScaffoldRuntime = () => import("@wp-typia/project-tools/cli-scaffold");
 const loadCliTemplatesRuntime = () => import("@wp-typia/project-tools/cli-templates");
 const loadMigrationsRuntime = () => import("@wp-typia/project-tools/migrations");
 
+async function wrapCliCommandError(command: CliCommandId, error: unknown) {
+	const { createCliCommandError } = await loadCliDiagnosticsRuntime();
+	return createCliCommandError({ command, error });
+}
+
+function shouldWrapCliCommandError(options: {
+	emitOutput?: boolean;
+	renderLine?: ((line: string) => void) | undefined;
+}): boolean {
+	if (options.emitOutput === false) {
+		return false;
+	}
+
+	if (options.renderLine) {
+		return false;
+	}
+
+	return true;
+}
+
 function printBlock(lines: string[], printLine: PrintLine): void {
 	for (const line of lines) {
 		printLine(line);
 	}
 }
 
+function formatExternalLayerSelectHint(option: ExternalLayerSelectOption): string | undefined {
+	const details = [
+		option.description,
+		option.extends.length > 0 ? `extends ${option.extends.join(", ")}` : undefined,
+	].filter((value): value is string => typeof value === "string" && value.length > 0);
+
+	return details.length > 0 ? details.join(" · ") : undefined;
+}
+
+function toExternalLayerPromptOptions(options: ExternalLayerSelectOption[]) {
+	return options.map((option) => ({
+		hint: formatExternalLayerSelectHint(option),
+		label: option.id,
+		value: option.id,
+	}));
+}
+
 export function printCompletionPayload(
 	payload: AlternateBufferCompletionPayload,
 	options: {
@@ -172,6 +219,7 @@ function buildAddCompletionPayload(options: {
 	kind: "binding-source" | "block" | "hooked-block" | "pattern" | "variation";
 	projectDir: string;
 	values: Record<string, string>;
+	warnings?: string[];
 }): AlternateBufferCompletionPayload {
 	switch (options.kind) {
 		case "variation":
@@ -218,6 +266,7 @@ function buildAddCompletionPayload(options: {
 					`Project directory: ${options.projectDir}`,
 				],
 				title: "✅ Added workspace block",
+				warningLines: options.warnings,
 			};
 	}
 }
@@ -431,11 +480,15 @@ export async function executeCreateCommand({
 	const shouldPrompt =
 		interactive ?? (!Boolean(flags.yes) && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY));
 	const activePrompt = shouldPrompt ? (prompt ?? createReadlinePrompt()) : undefined;
+	const shouldPromptForExternalLayerSelection =
+		Boolean(activePrompt) && activePrompt !== prompt;
 
 	try {
 		const flow = await runScaffoldFlow({
 			cwd,
 			dataStorageMode: readOptionalLooseStringFlag(flags, "data-storage"),
+			externalLayerId: readOptionalLooseStringFlag(flags, "external-layer-id"),
+			externalLayerSource: readOptionalLooseStringFlag(flags, "external-layer-source"),
 			isInteractive: Boolean(activePrompt),
 			namespace: readOptionalLooseStringFlag(flags, "namespace"),
 			noInstall: Boolean(flags["no-install"]),
@@ -449,6 +502,14 @@ export async function executeCreateCommand({
 			selectDataStorage: activePrompt
 				? () => activePrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1)
 				: undefined,
+			selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt
+				? (options) =>
+						activePrompt.select(
+							"Select an external layer",
+							toExternalLayerPromptOptions(options),
+							1,
+						)
+				: undefined,
 			selectPackageManager: activePrompt
 				? () => activePrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1)
 				: undefined,
@@ -495,6 +556,11 @@ export async function executeCreateCommand({
 			});
 		}
 		return payload;
+	} catch (error) {
+		if (!shouldWrapCliCommandError({ emitOutput })) {
+			throw error;
+		}
+		throw await wrapCliCommandError("create", error);
 	} finally {
 		if (activePrompt && activePrompt !== prompt) {
 			activePrompt.close();
@@ -506,9 +572,12 @@ export async function executeAddCommand({
 	cwd,
 	emitOutput = true,
 	flags,
+	interactive,
 	kind,
 	name,
 	printLine = console.log as PrintLine,
+	prompt,
+	warnLine = console.warn as PrintLine,
 }: AddExecutionInput): Promise<AlternateBufferCompletionPayload | void> {
 	if (!kind) {
 		const { formatAddHelpText } = await loadCliAddRuntime();
@@ -517,168 +586,205 @@ export async function executeAddCommand({
 	}
 
 	const addRuntime = await loadCliAddRuntime();
+	let activePrompt: ReadlinePrompt | undefined;
 
-	if (kind === "variation") {
-		if (!name) {
-			throw new Error(
-				"`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
-			);
+	try {
+		if (kind === "variation") {
+			if (!name) {
+				throw new Error(
+					"`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
+				);
+			}
+
+			const blockSlug = readOptionalStringFlag(flags, "block");
+			if (!blockSlug) {
+				throw new Error("`wp-typia add variation` requires --block <block-slug>.");
+			}
+
+			const result = await addRuntime.runAddVariationCommand({
+				blockName: blockSlug,
+				cwd,
+				variationName: name,
+			});
+			const payload = buildAddCompletionPayload({
+				kind: "variation",
+				projectDir: result.projectDir,
+				values: {
+					blockSlug: result.blockSlug,
+					variationSlug: result.variationSlug,
+				},
+			});
+			if (emitOutput) {
+				printCompletionPayload(payload, { printLine });
+			}
+			return payload;
 		}
 
-		const blockSlug = readOptionalStringFlag(flags, "block");
-		if (!blockSlug) {
-			throw new Error("`wp-typia add variation` requires --block <block-slug>.");
-		}
+		if (kind === "pattern") {
+			if (!name) {
+				throw new Error(
+					"`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.",
+				);
+			}
 
-		const result = await addRuntime.runAddVariationCommand({
-			blockName: blockSlug,
-			cwd,
-			variationName: name,
-		});
-		const payload = buildAddCompletionPayload({
-			kind: "variation",
-			projectDir: result.projectDir,
-			values: {
-				blockSlug: result.blockSlug,
-				variationSlug: result.variationSlug,
-			},
-		});
-		if (emitOutput) {
-			printCompletionPayload(payload, { printLine });
+			const result = await addRuntime.runAddPatternCommand({
+				cwd,
+				patternName: name,
+			});
+			const payload = buildAddCompletionPayload({
+				kind: "pattern",
+				projectDir: result.projectDir,
+				values: {
+					patternSlug: result.patternSlug,
+				},
+			});
+			if (emitOutput) {
+				printCompletionPayload(payload, { printLine });
+			}
+			return payload;
 		}
-		return payload;
-	}
 
-	if (kind === "pattern") {
-		if (!name) {
-			throw new Error(
-				"`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.",
-			);
+		if (kind === "binding-source") {
+			if (!name) {
+				throw new Error(
+					"`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name>.",
+				);
+			}
+
+			const result = await addRuntime.runAddBindingSourceCommand({
+				bindingSourceName: name,
+				cwd,
+			});
+			const payload = buildAddCompletionPayload({
+				kind: "binding-source",
+				projectDir: result.projectDir,
+				values: {
+					bindingSourceSlug: result.bindingSourceSlug,
+				},
+			});
+			if (emitOutput) {
+				printCompletionPayload(payload, { printLine });
+			}
+			return payload;
 		}
 
-		const result = await addRuntime.runAddPatternCommand({
-			cwd,
-			patternName: name,
-		});
-		const payload = buildAddCompletionPayload({
-			kind: "pattern",
-			projectDir: result.projectDir,
-			values: {
-				patternSlug: result.patternSlug,
-			},
-		});
-		if (emitOutput) {
-			printCompletionPayload(payload, { printLine });
+		if (kind === "hooked-block") {
+			if (!name) {
+				throw new Error(
+					"`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
+				);
+			}
+
+			const anchorBlockName = readOptionalStringFlag(flags, "anchor");
+			if (!anchorBlockName) {
+				throw new Error("`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+			}
+
+			const position = readOptionalStringFlag(flags, "position");
+			if (!position) {
+				throw new Error(
+					"`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.",
+				);
+			}
+
+			const result = await addRuntime.runAddHookedBlockCommand({
+				anchorBlockName,
+				blockName: name,
+				cwd,
+				position,
+			});
+			const payload = buildAddCompletionPayload({
+				kind: "hooked-block",
+				projectDir: result.projectDir,
+				values: {
+					anchorBlockName: result.anchorBlockName,
+					blockSlug: result.blockSlug,
+					position: result.position,
+				},
+			});
+			if (emitOutput) {
+				printCompletionPayload(payload, { printLine });
+			}
+			return payload;
 		}
-		return payload;
-	}
 
-	if (kind === "binding-source") {
-		if (!name) {
+		if (kind !== "block") {
 			throw new Error(
-				"`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name>.",
+				`Unknown add kind "${kind}". Expected one of: block, variation, pattern, binding-source, hooked-block.`,
 			);
 		}
 
-		const result = await addRuntime.runAddBindingSourceCommand({
-			bindingSourceName: name,
-			cwd,
-		});
-		const payload = buildAddCompletionPayload({
-			kind: "binding-source",
-			projectDir: result.projectDir,
-			values: {
-				bindingSourceSlug: result.bindingSourceSlug,
-			},
-		});
-		if (emitOutput) {
-			printCompletionPayload(payload, { printLine });
-		}
-		return payload;
-	}
-
-	if (kind === "hooked-block") {
 		if (!name) {
 			throw new Error(
-				"`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
+				"`wp-typia add block` requires <name>. Usage: wp-typia add block <name> --template <basic|interactivity|persistence|compound>",
 			);
 		}
 
-		const anchorBlockName = readOptionalStringFlag(flags, "anchor");
-		if (!anchorBlockName) {
-			throw new Error("`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-		}
-
-		const position = readOptionalStringFlag(flags, "position");
-		if (!position) {
+		if (!flags.template) {
 			throw new Error(
-				"`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.",
+				"`wp-typia add block` requires --template <basic|interactivity|persistence|compound>.",
 			);
 		}
 
-		const result = await addRuntime.runAddHookedBlockCommand({
-			anchorBlockName,
+		const externalLayerId = readOptionalStringFlag(flags, "external-layer-id");
+		const externalLayerSource = readOptionalStringFlag(flags, "external-layer-source");
+		const shouldPromptForLayerSelection =
+			Boolean(externalLayerSource) &&
+			!Boolean(externalLayerId) &&
+			(interactive ?? (Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY)));
+		const promptRuntime = shouldPromptForLayerSelection
+			? await loadCliPromptRuntime()
+			: undefined;
+		activePrompt = shouldPromptForLayerSelection
+			? (prompt ?? promptRuntime?.createReadlinePrompt())
+			: undefined;
+		const selectPrompt = activePrompt;
+
+		const result = await addRuntime.runAddBlockCommand({
 			blockName: name,
 			cwd,
-			position,
+			dataStorageMode: readOptionalStringFlag(flags, "data-storage"),
+			externalLayerId,
+			externalLayerSource,
+			persistencePolicy: readOptionalStringFlag(flags, "persistence-policy"),
+			selectExternalLayerId: selectPrompt
+				? (options) =>
+						selectPrompt.select(
+							"Select an external layer",
+							toExternalLayerPromptOptions(options),
+							1,
+						)
+				: undefined,
+			templateId: readOptionalStringFlag(flags, "template") as
+				| "basic"
+				| "interactivity"
+				| "persistence"
+				| "compound",
 		});
+
 		const payload = buildAddCompletionPayload({
-			kind: "hooked-block",
+			kind: "block",
 			projectDir: result.projectDir,
 			values: {
-				anchorBlockName: result.anchorBlockName,
-				blockSlug: result.blockSlug,
-				position: result.position,
+				blockSlugs: result.blockSlugs.join(", "),
+				templateId: result.templateId,
 			},
+			warnings: result.warnings,
 		});
 		if (emitOutput) {
-			printCompletionPayload(payload, { printLine });
+			printCompletionPayload(payload, { printLine, warnLine });
 		}
 		return payload;
+	} catch (error) {
+		if (!shouldWrapCliCommandError({ emitOutput })) {
+			throw error;
+		}
+		throw await wrapCliCommandError("add", error);
+	} finally {
+		if (activePrompt && activePrompt !== prompt) {
+			activePrompt.close();
+		}
 	}
-
-	if (kind !== "block") {
-		throw new Error(
-			`Unknown add kind "${kind}". Expected one of: block, variation, pattern, binding-source, hooked-block.`,
-		);
-	}
-
-	if (!name) {
-		throw new Error(
-			"`wp-typia add block` requires <name>. Usage: wp-typia add block <name> --template <basic|interactivity|persistence|compound>",
-		);
-	}
-
-	if (!flags.template) {
-		throw new Error(
-			"`wp-typia add block` requires --template <basic|interactivity|persistence|compound>.",
-		);
-	}
-
-	const result = await addRuntime.runAddBlockCommand({
-		blockName: name,
-		cwd,
-		dataStorageMode: readOptionalStringFlag(flags, "data-storage"),
-		persistencePolicy: readOptionalStringFlag(flags, "persistence-policy"),
-		templateId: readOptionalStringFlag(flags, "template") as
-			| "basic"
-			| "interactivity"
-			| "persistence"
-			| "compound",
-	});
-
-	const payload = buildAddCompletionPayload({
-		kind: "block",
-		projectDir: result.projectDir,
-		values: {
-			blockSlugs: result.blockSlugs.join(", "),
-			templateId: result.templateId,
-		},
-	});
-	if (emitOutput) {
-		printCompletionPayload(payload, { printLine });
-	}
-	return payload;
 }
 
 export async function executeTemplatesCommand(
@@ -720,8 +826,12 @@ export async function executeTemplatesCommand(
 }
 
 export async function executeDoctorCommand(cwd: string): Promise<void> {
-	const { runDoctor } = await loadCliDoctorRuntime();
-	await runDoctor(cwd);
+	try {
+		const { runDoctor } = await loadCliDoctorRuntime();
+		await runDoctor(cwd);
+	} catch (error) {
+		throw await wrapCliCommandError("doctor", error);
+	}
 }
 
 export async function loadAddWorkspaceBlockOptions(cwd: string) {
@@ -767,53 +877,60 @@ export async function executeMigrateCommand({
 		return;
 	}
 
-	const argv = [command];
-	pushFlag(argv, "all", flags.all);
-	pushFlag(argv, "force", flags.force);
-	pushFlag(
-		argv,
-		"current-migration-version",
-		readOptionalLooseStringFlag(flags, "current-migration-version"),
-	);
-	pushFlag(argv, "migration-version", readOptionalLooseStringFlag(flags, "migration-version"));
-	pushFlag(
-		argv,
-		"from-migration-version",
-		readOptionalLooseStringFlag(flags, "from-migration-version"),
-	);
-	pushFlag(
-		argv,
-		"to-migration-version",
-		readOptionalLooseStringFlag(flags, "to-migration-version"),
-	);
-	pushFlag(argv, "iterations", readOptionalLooseStringFlag(flags, "iterations"));
-	pushFlag(argv, "seed", readOptionalLooseStringFlag(flags, "seed"));
-
-	const parsed = parseMigrationArgs(argv);
-	const lines: string[] | null = renderLine ? [] : null;
-	const captureLine = (line: string) => {
-		lines?.push(line);
+	try {
+		const argv = [command];
+		pushFlag(argv, "all", flags.all);
+		pushFlag(argv, "force", flags.force);
+		pushFlag(
+			argv,
+			"current-migration-version",
+			readOptionalLooseStringFlag(flags, "current-migration-version"),
+		);
+		pushFlag(argv, "migration-version", readOptionalLooseStringFlag(flags, "migration-version"));
+		pushFlag(
+			argv,
+			"from-migration-version",
+			readOptionalLooseStringFlag(flags, "from-migration-version"),
+		);
+		pushFlag(
+			argv,
+			"to-migration-version",
+			readOptionalLooseStringFlag(flags, "to-migration-version"),
+		);
+		pushFlag(argv, "iterations", readOptionalLooseStringFlag(flags, "iterations"));
+		pushFlag(argv, "seed", readOptionalLooseStringFlag(flags, "seed"));
+
+		const parsed = parseMigrationArgs(argv);
+		const lines: string[] | null = renderLine ? [] : null;
+		const captureLine = (line: string) => {
+			lines?.push(line);
+			if (renderLine) {
+				renderLine(line);
+				return;
+			}
+			console.log(line);
+		};
+		const result = await runMigrationCommand(parsed, cwd, {
+			prompt,
+			renderLine: captureLine,
+		});
 		if (renderLine) {
-			renderLine(line);
-			return;
+			return result && typeof result === "object" && "cancelled" in result && result.cancelled === true
+					? undefined
+					: buildMigrationCompletionPayload({
+						command: parsed.command ?? "plan",
+						lines: lines ?? [],
+					});
 		}
-		console.log(line);
-	};
-	const result = await runMigrationCommand(parsed, cwd, {
-		prompt,
-		renderLine: captureLine,
-	});
-	if (renderLine) {
-		return result && typeof result === "object" && "cancelled" in result && result.cancelled === true
-				? undefined
-				: buildMigrationCompletionPayload({
-					command: parsed.command ?? "plan",
-					lines: lines ?? [],
-				});
-	}
 
-	if (result && typeof result === "object" && "cancelled" in result && result.cancelled === true) {
-		return;
+		if (result && typeof result === "object" && "cancelled" in result && result.cancelled === true) {
+			return;
+		}
+	} catch (error) {
+		if (!shouldWrapCliCommandError({ renderLine })) {
+			throw error;
+		}
+		throw await wrapCliCommandError("migrate", error);
 	}
 }
 

package/src/ui/add-flow-model.ts

@@ -11,6 +11,8 @@ export const addFlowSchema = z.object({
 	anchor: z.string().optional(),
 	block: z.string().optional(),
 	"data-storage": z.string().optional(),
+	"external-layer-id": z.string().optional(),
+	"external-layer-source": z.string().optional(),
 	kind: z
 		.enum(["block", "variation", "pattern", "binding-source", "hooked-block"])
 		.default("block"),
@@ -116,5 +118,17 @@ export function sanitizeAddSubmitValues(values: AddFlowValues): Record<string, u
 		}
 	}
 
+	if ((values.kind ?? "block") === "block") {
+		for (const hiddenFieldName of ["external-layer-source", "external-layer-id"] as const) {
+			const value = values[hiddenFieldName];
+			if (typeof value === "string") {
+				const trimmed = value.trim();
+				if (trimmed.length > 0) {
+					sanitized[hiddenFieldName] = trimmed;
+				}
+			}
+		}
+	}
+
 	return sanitized;
 }

package/src/ui/add-flow.tsx

@@ -310,6 +310,7 @@ export function AddFlow({ cwd, initialValues }: AddFlowProps) {
 						cwd,
 						emitOutput: false,
 						flags,
+						interactive: false,
 						kind: values.kind,
 						name: typeof flags.name === "string" ? flags.name : undefined,
 					});

package/src/ui/create-flow-model.ts

@@ -10,6 +10,8 @@ import {
 
 export const createFlowSchema = z.object({
 	"data-storage": z.string().optional(),
+	"external-layer-id": z.string().optional(),
+	"external-layer-source": z.string().optional(),
 	namespace: z.string().optional(),
 	"no-install": z.boolean().default(false),
 	"package-manager": z.string().optional(),
@@ -82,6 +84,24 @@ export function isCreatePersistenceTemplate(template?: string): boolean {
 	return template === "persistence" || template === "compound";
 }
 
+function supportsCreateExternalLayers(template?: string): boolean {
+	return (
+		template === "basic" ||
+		template === "interactivity" ||
+		template === "persistence" ||
+		template === "compound"
+	);
+}
+
+function normalizeOptionalHiddenString(value?: string): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
 export function getVisibleCreateFieldNames(
 	values: Partial<CreateFlowValues>,
 ): Array<CreateFieldName> {
@@ -113,12 +133,22 @@ export function getCreateScrollTop(options: {
 }
 
 export function sanitizeCreateSubmitValues(values: CreateFlowValues): CreateFlowValues {
+	const normalizedValues: CreateFlowValues = {
+		...values,
+		"external-layer-id": supportsCreateExternalLayers(values.template)
+			? normalizeOptionalHiddenString(values["external-layer-id"])
+			: undefined,
+		"external-layer-source": supportsCreateExternalLayers(values.template)
+			? normalizeOptionalHiddenString(values["external-layer-source"])
+			: undefined,
+	};
+
 	if (isCreatePersistenceTemplate(values.template)) {
-		return values;
+		return normalizedValues;
 	}
 
 	return {
-		...values,
+		...normalizedValues,
 		"data-storage": undefined,
 		"persistence-policy": undefined,
 	};