wp-typia 0.22.8 → 0.22.10

package/dist-bunli/{command-list-hbcv3bz6.js → command-list-h96cft88.js}

@@ -11,13 +11,15 @@ import {
   WP_TYPIA_TOP_LEVEL_COMMAND_NAMES,
   buildCommandOptions,
   emitCliDiagnosticFailure,
+  formatAddKindList,
+  formatAddKindUsagePlaceholder,
   getAddBlockDefaults,
   getCreateDefaults,
   getMcpSchemaSources,
   package_default,
   prefersStructuredCliOutput,
   resolveCommandOptionValues
-} from "./cli-e7n7hbvr.js";
+} from "./cli-spdrcg8k.js";
 import {
   Result,
   TaggedError,
@@ -42,10 +44,12 @@ import {
   createCliDiagnosticCodeError
 } from "./cli-p95wr1q8.js";
 import {
+  PACKAGE_MANAGER_IDS,
   formatInstallCommand,
   formatPackageExecCommand,
   formatRunScript,
-  inferPackageManagerId
+  inferPackageManagerId,
+  parsePackageManagerField
 } from "./cli-52ke0ptp.js";
 import {
   __require,
@@ -67,7 +71,7 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
   }
   const missingCandidates = candidates.map((candidate) => fileURLToPath(new URL(candidate, baseUrl)));
   const label = options.moduleLabel ?? "bundled wp-typia runtime module";
-  throw new Error([
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_BUILD_ARTIFACT, [
     `Missing bundled build artifacts for ${label}.`,
     "None of the expected files were found:",
     ...missingCandidates.map((candidatePath) => `- ${candidatePath}`),
@@ -76,63 +80,7 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
 `));
 }
 
-// src/cli-string-flags.ts
-function readOptionalCliStringFlagValue(flags, name, mode) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    if (mode === "strict") {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-    }
-    return;
-  }
-  return mode === "strict" ? value : trimmed;
-}
-function readOptionalLooseStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "loose");
-}
-function readOptionalStrictStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "strict");
-}
-function requireStrictStringFlag(flags, name, message) {
-  const value = readOptionalStrictStringFlag(flags, name);
-  if (!value) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return value;
-}
-function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
-  const leftValue = readOptionalStrictStringFlag(flags, leftName);
-  const rightValue = readOptionalStrictStringFlag(flags, rightName);
-  if (Boolean(leftValue) !== Boolean(rightValue)) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
-
-// src/external-layer-prompt-options.ts
-function formatExternalLayerSelectHint(option2) {
-  const details = [
-    option2.description,
-    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions(options) {
-  return options.map((option2) => ({
-    hint: formatExternalLayerSelectHint(option2),
-    label: option2.id,
-    value: option2.id
-  }));
-}
-
-// src/add-kind-registry.ts
+// src/add-kind-registry-shared.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -214,509 +162,627 @@ function isAddPersistenceTemplate(template) {
 function formatAddBlockTemplateIds(addRuntime) {
   return addRuntime.ADD_BLOCK_TEMPLATE_IDS.join(", ");
 }
+function getMistypedAddBlockTemplateMessage(addRuntime, templateId) {
+  const suggestion = addRuntime.suggestAddBlockTemplateId(templateId);
+  if (!suggestion) {
+    return null;
+  }
+  return `Unknown add-block template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\`, or run \`wp-typia templates list\` to inspect available templates.`;
+}
 function assertAddBlockTemplateId(context, templateId) {
+  if (templateId === "query-loop") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+  }
   if (context.addRuntime.isAddBlockTemplateId(templateId)) {
     return templateId;
   }
-  if (templateId === "query-loop") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+  const mistypedAddBlockTemplateMessage = getMistypedAddBlockTemplateMessage(context.addRuntime, templateId);
+  if (mistypedAddBlockTemplateMessage) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedAddBlockTemplateMessage);
   }
   throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
 }
-var ADD_KIND_REGISTRY = {
-  "admin-view": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/admin-views/${values.adminViewSlug}/ and inc/admin-views/${values.adminViewSlug}.php.`,
-        "Run your workspace build or dev command to verify the generated DataViews admin screen."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Admin view: ${values.adminViewSlug}`,
-        ...values.source ? [`Source: ${values.source}`] : [],
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added DataViews admin screen"
-    },
-    description: "Add an opt-in DataViews-powered admin screen",
-    nameLabel: "Admin view name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
-      const source = readOptionalStrictStringFlag(context.flags, "source");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
-          adminViewName: name2,
-          cwd,
-          source
-        }),
-        getValues: (result) => ({
-          adminViewSlug: result.adminViewSlug,
-          ...result.source ? { source: result.source } : {}
-        }),
-        missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
-        name
-      });
-    },
-    sortOrder: 10,
-    supportsDryRun: true,
-    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
-    visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
-  }),
-  "binding-source": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/bindings/${values.bindingSourceSlug}/server.php and src/bindings/${values.bindingSourceSlug}/editor.ts.`,
-        ...values.blockSlug && values.attributeName ? [
-          `Review src/blocks/${values.blockSlug}/block.json for the ${values.attributeName} bindable attribute.`
-        ] : [],
-        "Run your workspace build or dev command to verify the binding source hooks and editor registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Binding source: ${values.bindingSourceSlug}`,
-        ...values.blockSlug && values.attributeName ? [`Target: ${values.blockSlug}.${values.attributeName}`] : [],
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added binding source"
-    },
-    description: "Add a shared block bindings source",
-    nameLabel: "Binding source name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
-          attributeName,
-          bindingSourceName: name2,
-          blockName,
-          cwd
-        }),
-        getValues: (result) => ({
-          ...result.attributeName ? { attributeName: result.attributeName } : {},
-          ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
-          bindingSourceSlug: result.bindingSourceSlug
-        }),
-        missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
-        name
-      });
-    },
-    sortOrder: 70,
-    supportsDryRun: true,
-    usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
-  }),
-  block: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: () => [
-        "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
-        "Run your workspace build or dev command to verify the new scaffolded block family."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Blocks: ${values.blockSlugs}`,
-        `Template family: ${values.templateId}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace block"
-    },
-    description: "Add a real block slice",
-    hiddenStringSubmitFields: ["external-layer-id", "external-layer-source"],
-    nameLabel: "Block name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
-      const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
-      const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
-      const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
-      const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-      const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
-      const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
-      const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
-      const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
-      const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
-      let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
-      if (!resolvedTemplateId && context.isInteractiveSession) {
-        const templatePrompt = await context.getOrCreatePrompt();
-        resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
-          hint: `Scaffold the ${templateId} block family`,
-          label: templateId,
-          value: templateId
-        })), 1);
-      }
-      resolvedTemplateId ??= "basic";
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
-          alternateRenderTargets,
-          blockName: name2,
-          cwd,
-          dataStorageMode,
-          externalLayerId,
-          externalLayerSource,
-          innerBlocksPreset,
-          persistencePolicy,
-          selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
-          templateId: resolvedTemplateId
-        }),
-        getValues: (result) => ({
-          blockSlugs: result.blockSlugs.join(", "),
-          templateId: result.templateId
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
-        name,
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 20,
-    supportsDryRun: true,
-    usage: "wp-typia add block <name> [--template <basic|interactivity|persistence|compound>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--inner-blocks-preset <freeform|ordered|horizontal|locked-structure>] [--alternate-render-targets <email,mjml,plain-text>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--dry-run]",
-    visibleFieldNames: ({ template }) => BLOCK_VISIBLE_FIELD_ORDER.filter((fieldName) => {
-      if (fieldName === "alternate-render-targets") {
-        return isAddPersistenceTemplate(template);
-      }
-      if (fieldName === "inner-blocks-preset") {
-        return template === "compound";
-      }
-      if (fieldName === "data-storage" || fieldName === "persistence-policy") {
-        return isAddPersistenceTemplate(template);
-      }
-      return true;
-    })
-  }),
-  ability: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
-        "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Ability: ${values.abilitySlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workflow ability"
-    },
-    description: "Add a typed server/client workflow ability scaffold",
-    nameLabel: "Ability name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
-          abilityName: name,
-          cwd
-        }),
-        getValues: (result) => ({
-          abilitySlug: result.abilitySlug
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.",
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 90,
-    supportsDryRun: true,
-    usage: "wp-typia add ability <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  "editor-plugin": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/editor-plugins/${values.editorPluginSlug}/.`,
-        "Run your workspace build or dev command to verify the new editor plugin registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Editor plugin: ${values.editorPluginSlug}`,
-        `Slot: ${values.slot}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added editor plugin"
-    },
-    description: "Add a slot-aware document editor extension shell",
-    nameLabel: "Editor plugin name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
-      const slot = readOptionalStrictStringFlag(context.flags, "slot");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
-          cwd,
-          editorPluginName: name2,
-          slot
-        }),
-        getValues: (result) => ({
-          editorPluginSlug: result.editorPluginSlug,
-          slot: result.slot
-        }),
-        missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
-        name
-      });
-    },
-    sortOrder: 120,
-    supportsDryRun: true,
-    usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
-    visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
-  }),
-  "hooked-block": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
-        "Run your workspace build or dev command to verify the updated hooked-block metadata."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block: ${values.blockSlug}`,
-        `Anchor: ${values.anchorBlockName}`,
-        `Position: ${values.position}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added blockHooks metadata"
-    },
-    description: "Add block.json hook metadata to an existing block",
-    nameLabel: "Target block",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`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 = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
-          anchorBlockName,
-          blockName: name2,
-          cwd,
-          position
-        }),
-        getValues: (result) => ({
-          anchorBlockName: result.anchorBlockName,
-          blockSlug: result.blockSlug,
-          position: result.position
-        }),
-        missingNameMessage: "`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>.",
-        name
-      });
-    },
-    sortOrder: 110,
-    supportsDryRun: true,
-    usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
-    visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
-  }),
-  pattern: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/patterns/${values.patternSlug}.php.`,
-        "Run your workspace build or dev command to verify the new pattern registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Pattern: ${values.patternSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace pattern"
-    },
-    description: "Add a PHP block pattern shell",
-    nameLabel: "Pattern name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
-          cwd,
-          patternName: name
-        }),
-        getValues: (result) => ({
-          patternSlug: result.patternSlug
-        }),
-        missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
-      });
-    },
-    sortOrder: 60,
-    supportsDryRun: true,
-    usage: "wp-typia add pattern <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  style: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/styles/${values.styleSlug}.ts.`,
-        "Run your workspace build or dev command to verify the new block style registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block style: ${values.styleSlug}`,
-        `Target block: ${values.blockSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added block style"
-    },
-    description: "Add a Block Styles registration to an existing block",
-    nameLabel: "Style name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
-          blockName: blockSlug,
-          cwd,
-          styleName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          styleSlug: result.styleSlug
-        }),
-        missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
-        name
-      });
-    },
-    sortOrder: 40,
-    supportsDryRun: true,
-    usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
-  }),
-  transform: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/transforms/${values.transformSlug}.ts.`,
-        "Run your workspace build or dev command to verify the new block transform registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block transform: ${values.transformSlug}`,
-        `From: ${values.fromBlockName}`,
-        `To: ${values.toBlockName}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added block transform"
-    },
-    description: "Add a block-to-block transform into a workspace block",
-    nameLabel: "Transform name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
-      const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
-          cwd,
-          fromBlockName,
-          toBlockName,
-          transformName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          fromBlockName: result.fromBlockName,
-          toBlockName: result.toBlockName,
-          transformSlug: result.transformSlug
-        }),
-        missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
-        name
-      });
-    },
-    sortOrder: 50,
-    supportsDryRun: true,
-    usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
-  }),
-  "rest-resource": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
-        "Run your workspace build or dev command to verify the generated REST resource contract."
-      ],
-      summaryLines: (values, projectDir) => [
-        `REST resource: ${values.restResourceSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Methods: ${values.methods}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added plugin-level REST resource"
-    },
-    description: "Add a plugin-level typed REST resource",
-    nameLabel: "REST resource name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
-      const methods = readOptionalStrictStringFlag(context.flags, "methods");
-      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
-          cwd,
-          methods,
-          namespace,
-          restResourceName: name2
-        }),
-        getValues: (result) => ({
-          methods: result.methods.join(", "),
-          namespace: result.namespace,
-          restResourceSlug: result.restResourceSlug
-        }),
-        missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].",
-        name
-      });
-    },
-    sortOrder: 80,
-    supportsDryRun: true,
-    usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
-  }),
-  "ai-feature": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
-        "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
-      ],
-      summaryLines: (values, projectDir) => [
-        `AI feature: ${values.aiFeatureSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added server-only AI feature"
-    },
-    description: "Add a server-owned WordPress AI feature endpoint",
-    nameLabel: "AI feature name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
-      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
-          aiFeatureName: name2,
-          cwd,
-          namespace
-        }),
-        getValues: (result) => ({
-          aiFeatureSlug: result.aiFeatureSlug,
-          namespace: result.namespace
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
-        name,
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 100,
-    supportsDryRun: true,
-    usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
-  }),
-  variation: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
-        "Run your workspace build or dev command to pick up the new variation."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Variation: ${values.variationSlug}`,
-        `Target block: ${values.blockSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace variation"
-    },
-    description: "Add a variation to an existing block",
-    nameLabel: "Variation name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
-          blockName: blockSlug,
-          cwd,
-          variationName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          variationSlug: result.variationSlug
-        }),
-        missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
-        name
-      });
-    },
-    sortOrder: 30,
-    supportsDryRun: true,
-    usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+
+// src/add-kinds/ability.ts
+var ABILITY_MISSING_NAME_MESSAGE = "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.";
+var abilityAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
+      "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Ability: ${values.abilitySlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workflow ability"
+  },
+  description: "Add a typed server/client workflow ability scaffold",
+  nameLabel: "Ability name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
+        abilityName: name,
+        cwd
+      }),
+      getValues: (result) => ({
+        abilitySlug: result.abilitySlug
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: ABILITY_MISSING_NAME_MESSAGE,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 90,
+  supportsDryRun: true,
+  usage: "wp-typia add ability <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/cli-string-flags.ts
+function readOptionalCliStringFlagValue(flags, name, mode) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+    }
+    return;
+  }
+  return mode === "strict" ? value : trimmed;
+}
+function readOptionalLooseStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "loose");
+}
+function readOptionalStrictStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "strict");
+}
+function requireStrictStringFlag(flags, name, message) {
+  const value = readOptionalStrictStringFlag(flags, name);
+  if (!value) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return value;
+}
+function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
+  const leftValue = readOptionalStrictStringFlag(flags, leftName);
+  const rightValue = readOptionalStrictStringFlag(flags, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
+
+// src/add-kinds/admin-view.ts
+var ADMIN_VIEW_MISSING_NAME_MESSAGE = "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].";
+var adminViewAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/admin-views/${values.adminViewSlug}/ and inc/admin-views/${values.adminViewSlug}.php.`,
+      "Run your workspace build or dev command to verify the generated DataViews admin screen."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Admin view: ${values.adminViewSlug}`,
+      ...values.source ? [`Source: ${values.source}`] : [],
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added DataViews admin screen"
+  },
+  description: "Add an opt-in DataViews-powered admin screen",
+  nameLabel: "Admin view name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, ADMIN_VIEW_MISSING_NAME_MESSAGE);
+    const source = readOptionalStrictStringFlag(context.flags, "source");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
+        adminViewName: name2,
+        cwd,
+        source
+      }),
+      getValues: (result) => ({
+        adminViewSlug: result.adminViewSlug,
+        ...result.source ? { source: result.source } : {}
+      }),
+      missingNameMessage: ADMIN_VIEW_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 10,
+  supportsDryRun: true,
+  usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
+  visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/ai-feature.ts
+var AI_FEATURE_MISSING_NAME_MESSAGE = "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].";
+var aiFeatureAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
+      "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
+    ],
+    summaryLines: (values, projectDir) => [
+      `AI feature: ${values.aiFeatureSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added server-only AI feature"
+  },
+  description: "Add a server-owned WordPress AI feature endpoint",
+  nameLabel: "AI feature name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, AI_FEATURE_MISSING_NAME_MESSAGE);
+    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
+        aiFeatureName: name2,
+        cwd,
+        namespace
+      }),
+      getValues: (result) => ({
+        aiFeatureSlug: result.aiFeatureSlug,
+        namespace: result.namespace
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: AI_FEATURE_MISSING_NAME_MESSAGE,
+      name,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 100,
+  supportsDryRun: true,
+  usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/binding-source.ts
+var BINDING_SOURCE_MISSING_NAME_MESSAGE = "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].";
+var bindingSourceAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/bindings/${values.bindingSourceSlug}/server.php and src/bindings/${values.bindingSourceSlug}/editor.ts.`,
+      ...values.blockSlug && values.attributeName ? [
+        `Review src/blocks/${values.blockSlug}/block.json for the ${values.attributeName} bindable attribute.`
+      ] : [],
+      "Run your workspace build or dev command to verify the binding source hooks and editor registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Binding source: ${values.bindingSourceSlug}`,
+      ...values.blockSlug && values.attributeName ? [`Target: ${values.blockSlug}.${values.attributeName}`] : [],
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added binding source"
+  },
+  description: "Add a shared block bindings source",
+  nameLabel: "Binding source name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, BINDING_SOURCE_MISSING_NAME_MESSAGE);
+    const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
+        attributeName,
+        bindingSourceName: name2,
+        blockName,
+        cwd
+      }),
+      getValues: (result) => ({
+        ...result.attributeName ? { attributeName: result.attributeName } : {},
+        ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
+        bindingSourceSlug: result.bindingSourceSlug
+      }),
+      missingNameMessage: BINDING_SOURCE_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 70,
+  supportsDryRun: true,
+  usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
+});
+
+// src/external-layer-prompt-options.ts
+function formatExternalLayerSelectHint(option2) {
+  const details = [
+    option2.description,
+    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" \xB7 ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option2) => ({
+    hint: formatExternalLayerSelectHint(option2),
+    label: option2.id,
+    value: option2.id
+  }));
+}
+
+// src/add-kinds/block.ts
+var BLOCK_MISSING_NAME_MESSAGE = "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]";
+var blockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: () => [
+      "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
+      "Run your workspace build or dev command to verify the new scaffolded block family."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Blocks: ${values.blockSlugs}`,
+      `Template family: ${values.templateId}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace block"
+  },
+  description: "Add a real block slice",
+  hiddenStringSubmitFields: ["external-layer-id", "external-layer-source"],
+  nameLabel: "Block name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, BLOCK_MISSING_NAME_MESSAGE);
+    const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
+    const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
+    const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
+    const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
+    const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
+    const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
+    const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
+    const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
+    const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
+    let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
+    if (!resolvedTemplateId && context.isInteractiveSession) {
+      const templatePrompt = await context.getOrCreatePrompt();
+      resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
+        hint: `Scaffold the ${templateId} block family`,
+        label: templateId,
+        value: templateId
+      })), 1);
+    }
+    resolvedTemplateId ??= "basic";
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
+        alternateRenderTargets,
+        blockName: name2,
+        cwd,
+        dataStorageMode,
+        externalLayerId,
+        externalLayerSource,
+        innerBlocksPreset,
+        persistencePolicy,
+        selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
+        templateId: resolvedTemplateId
+      }),
+      getValues: (result) => ({
+        blockSlugs: result.blockSlugs.join(", "),
+        templateId: result.templateId
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: BLOCK_MISSING_NAME_MESSAGE,
+      name,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 20,
+  supportsDryRun: true,
+  usage: "wp-typia add block <name> [--template <basic|interactivity|persistence|compound>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--inner-blocks-preset <freeform|ordered|horizontal|locked-structure>] [--alternate-render-targets <email,mjml,plain-text>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--dry-run]",
+  visibleFieldNames: ({ template }) => BLOCK_VISIBLE_FIELD_ORDER.filter((fieldName) => {
+    if (fieldName === "alternate-render-targets") {
+      return isAddPersistenceTemplate(template);
+    }
+    if (fieldName === "inner-blocks-preset") {
+      return template === "compound";
+    }
+    if (fieldName === "data-storage" || fieldName === "persistence-policy") {
+      return isAddPersistenceTemplate(template);
+    }
+    return true;
   })
+});
+
+// src/add-kinds/editor-plugin.ts
+var EDITOR_PLUGIN_MISSING_NAME_MESSAGE = "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].";
+var editorPluginAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/editor-plugins/${values.editorPluginSlug}/.`,
+      "Run your workspace build or dev command to verify the new editor plugin registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Editor plugin: ${values.editorPluginSlug}`,
+      `Slot: ${values.slot}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added editor plugin"
+  },
+  description: "Add a slot-aware document editor extension shell",
+  nameLabel: "Editor plugin name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, EDITOR_PLUGIN_MISSING_NAME_MESSAGE);
+    const slot = readOptionalStrictStringFlag(context.flags, "slot");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
+        cwd,
+        editorPluginName: name2,
+        slot
+      }),
+      getValues: (result) => ({
+        editorPluginSlug: result.editorPluginSlug,
+        slot: result.slot
+      }),
+      missingNameMessage: EDITOR_PLUGIN_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 120,
+  supportsDryRun: true,
+  usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
+  visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
+});
+
+// src/add-kinds/hooked-block.ts
+var HOOKED_BLOCK_MISSING_NAME_MESSAGE = "`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>.";
+var hookedBlockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
+      "Run your workspace build or dev command to verify the updated hooked-block metadata."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block: ${values.blockSlug}`,
+      `Anchor: ${values.anchorBlockName}`,
+      `Position: ${values.position}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added blockHooks metadata"
+  },
+  description: "Add block.json hook metadata to an existing block",
+  nameLabel: "Target block",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, HOOKED_BLOCK_MISSING_NAME_MESSAGE);
+    const anchorBlockName = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+    const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
+        anchorBlockName,
+        blockName: name2,
+        cwd,
+        position
+      }),
+      getValues: (result) => ({
+        anchorBlockName: result.anchorBlockName,
+        blockSlug: result.blockSlug,
+        position: result.position
+      }),
+      missingNameMessage: HOOKED_BLOCK_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 110,
+  supportsDryRun: true,
+  usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
+  visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
+});
+
+// src/add-kinds/pattern.ts
+var PATTERN_MISSING_NAME_MESSAGE = "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.";
+var patternAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/patterns/${values.patternSlug}.php.`,
+      "Run your workspace build or dev command to verify the new pattern registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Pattern: ${values.patternSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace pattern"
+  },
+  description: "Add a PHP block pattern shell",
+  nameLabel: "Pattern name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
+        cwd,
+        patternName: name
+      }),
+      getValues: (result) => ({
+        patternSlug: result.patternSlug
+      }),
+      missingNameMessage: PATTERN_MISSING_NAME_MESSAGE,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 60,
+  supportsDryRun: true,
+  usage: "wp-typia add pattern <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/add-kinds/rest-resource.ts
+var REST_RESOURCE_MISSING_NAME_MESSAGE = "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>].";
+var restResourceAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
+      "Run your workspace build or dev command to verify the generated REST resource contract."
+    ],
+    summaryLines: (values, projectDir) => [
+      `REST resource: ${values.restResourceSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Methods: ${values.methods}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added plugin-level REST resource"
+  },
+  description: "Add a plugin-level typed REST resource",
+  nameLabel: "REST resource name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, REST_RESOURCE_MISSING_NAME_MESSAGE);
+    const methods = readOptionalStrictStringFlag(context.flags, "methods");
+    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
+        cwd,
+        methods,
+        namespace,
+        restResourceName: name2
+      }),
+      getValues: (result) => ({
+        methods: result.methods.join(", "),
+        namespace: result.namespace,
+        restResourceSlug: result.restResourceSlug
+      }),
+      missingNameMessage: REST_RESOURCE_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 80,
+  supportsDryRun: true,
+  usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
+});
+
+// src/add-kinds/style.ts
+var STYLE_MISSING_NAME_MESSAGE = "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.";
+var styleAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/styles/${values.styleSlug}.ts.`,
+      "Run your workspace build or dev command to verify the new block style registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block style: ${values.styleSlug}`,
+      `Target block: ${values.blockSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added block style"
+  },
+  description: "Add a Block Styles registration to an existing block",
+  nameLabel: "Style name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, STYLE_MISSING_NAME_MESSAGE);
+    const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
+        blockName: blockSlug,
+        cwd,
+        styleName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        styleSlug: result.styleSlug
+      }),
+      missingNameMessage: STYLE_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 40,
+  supportsDryRun: true,
+  usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kinds/transform.ts
+var TRANSFORM_MISSING_NAME_MESSAGE = "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.";
+var transformAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/transforms/${values.transformSlug}.ts.`,
+      "Run your workspace build or dev command to verify the new block transform registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block transform: ${values.transformSlug}`,
+      `From: ${values.fromBlockName}`,
+      `To: ${values.toBlockName}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added block transform"
+  },
+  description: "Add a block-to-block transform into a workspace block",
+  nameLabel: "Transform name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, TRANSFORM_MISSING_NAME_MESSAGE);
+    const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+    const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
+        cwd,
+        fromBlockName,
+        toBlockName,
+        transformName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        fromBlockName: result.fromBlockName,
+        toBlockName: result.toBlockName,
+        transformSlug: result.transformSlug
+      }),
+      missingNameMessage: TRANSFORM_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 50,
+  supportsDryRun: true,
+  usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
+});
+
+// src/add-kinds/variation.ts
+var VARIATION_MISSING_NAME_MESSAGE = "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>";
+var variationAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
+      "Run your workspace build or dev command to pick up the new variation."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Variation: ${values.variationSlug}`,
+      `Target block: ${values.blockSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace variation"
+  },
+  description: "Add a variation to an existing block",
+  nameLabel: "Variation name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, VARIATION_MISSING_NAME_MESSAGE);
+    const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
+        blockName: blockSlug,
+        cwd,
+        variationName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        variationSlug: result.variationSlug
+      }),
+      missingNameMessage: VARIATION_MISSING_NAME_MESSAGE,
+      name
+    });
+  },
+  sortOrder: 30,
+  supportsDryRun: true,
+  usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kind-registry.ts
+var ADD_KIND_REGISTRY = {
+  "admin-view": adminViewAddKindEntry,
+  block: blockAddKindEntry,
+  variation: variationAddKindEntry,
+  style: styleAddKindEntry,
+  transform: transformAddKindEntry,
+  pattern: patternAddKindEntry,
+  "binding-source": bindingSourceAddKindEntry,
+  "rest-resource": restResourceAddKindEntry,
+  ability: abilityAddKindEntry,
+  "ai-feature": aiFeatureAddKindEntry,
+  "hooked-block": hookedBlockAddKindEntry,
+  "editor-plugin": editorPluginAddKindEntry
 };
 function isAddKindId(value) {
   return typeof value === "string" && ADD_KIND_IDS.includes(value);
@@ -732,16 +798,28 @@ function buildAddKindCompletionDetails(kind, options) {
     title: descriptor.title
   };
 }
-function formatAddKindList() {
-  return ADD_KIND_IDS.join(", ");
-}
-function formatAddKindUsagePlaceholder() {
-  return `<${ADD_KIND_IDS.join("|")}>`;
-}
 function supportsAddKindDryRun(kind) {
   return ADD_KIND_REGISTRY[kind].supportsDryRun;
 }
 
+// src/cli-error-messages.ts
+var MISSING_CREATE_PROJECT_DIR_DETAIL_LINES = [
+  "`wp-typia create` requires <project-dir>.",
+  "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
+];
+function formatMissingAddKindDetailLine() {
+  return `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`;
+}
+function shouldPrintMissingAddKindHelp(options) {
+  if (typeof options.emitOutput === "boolean") {
+    return options.emitOutput;
+  }
+  return options.format !== "json";
+}
+function buildMissingCreateProjectDirDetailLines() {
+  return [...MISSING_CREATE_PROJECT_DIR_DETAIL_LINES];
+}
+
 // src/runtime-bridge-add-dry-run.ts
 import fs2 from "fs";
 import { promises as fsp } from "fs";
@@ -766,6 +844,55 @@ async function copyWorkspaceProject(sourceDir, targetDir) {
     recursive: true
   });
 }
+function formatInstallMarkerError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function formatInstallMarkerFailures(failures) {
+  return failures.map((failure) => `${failure.operation}: ${failure.reason}`).join("; ");
+}
+function ensureWorkspaceInstallMarker({
+  fsAdapter = fs2,
+  sourceMarker,
+  targetMarker
+}) {
+  const failures = [];
+  try {
+    fsAdapter.symlinkSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "symlink",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  try {
+    fsAdapter.linkSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "hard link",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  try {
+    fsAdapter.copyFileSync(sourceMarker, targetMarker);
+    return;
+  } catch (error) {
+    failures.push({
+      operation: "copy",
+      reason: formatInstallMarkerError(error)
+    });
+  }
+  throw new Error([
+    "Failed to prepare dry-run install marker.",
+    `Source: ${sourceMarker}`,
+    `Target: ${targetMarker}`,
+    `Fallback failures: ${formatInstallMarkerFailures(failures)}`
+  ].join(" "));
+}
 function ensureWorkspaceInstallMarkers(sourceDir, targetDir) {
   const sourceNodeModules = path.join(sourceDir, "node_modules");
   if (fs2.existsSync(sourceNodeModules)) {
@@ -777,15 +904,7 @@ function ensureWorkspaceInstallMarkers(sourceDir, targetDir) {
       continue;
     }
     const targetMarker = path.join(targetDir, marker);
-    try {
-      fs2.symlinkSync(sourceMarker, targetMarker);
-    } catch {
-      try {
-        fs2.linkSync(sourceMarker, targetMarker);
-      } catch {
-        fs2.copyFileSync(sourceMarker, targetMarker);
-      }
-    }
+    ensureWorkspaceInstallMarker({ sourceMarker, targetMarker });
   }
 }
 async function listWorkspaceFiles(rootDir) {
@@ -946,40 +1065,38 @@ function stripLeadingOutputMarker(text, kind) {
   return text.replace(new RegExp(`^(?:${markerPattern})\\s*`, "u"), "");
 }
 
-// src/runtime-bridge-output.ts
-function printCompletionPayload(payload, options = {}) {
-  const printLine = options.printLine ?? console.log;
-  const warnLine = options.warnLine ?? printLine;
-  for (const line of payload.preambleLines ?? []) {
-    printLine(line);
-  }
-  for (const warning of payload.warningLines ?? []) {
-    warnLine(formatOutputMarker("warning", warning, options.markerOptions));
-  }
-  const hasDetails = (payload.summaryLines?.length ?? 0) > 0 || (payload.nextSteps?.length ?? 0) > 0 || (payload.optionalLines?.length ?? 0) > 0 || Boolean(payload.optionalNote);
-  const hasLeadingContext = (payload.preambleLines?.length ?? 0) > 0 || (payload.warningLines?.length ?? 0) > 0;
-  printLine(hasLeadingContext && hasDetails ? `
-${payload.title}` : payload.title);
-  for (const line of payload.summaryLines ?? []) {
-    printLine(line);
-  }
-  if ((payload.nextSteps?.length ?? 0) > 0) {
-    printLine("Next steps:");
-    for (const step of payload.nextSteps ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if ((payload.optionalLines?.length ?? 0) > 0) {
-    printLine(`
-${payload.optionalTitle ?? "Optional:"}`);
-    for (const step of payload.optionalLines ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if (payload.optionalNote) {
-    printLine(`Note: ${payload.optionalNote}`);
-  }
+// src/runtime-output/init.ts
+function buildInitCompletionPayload(plan, markerOptions) {
+  const changeLines = [
+    ...plan.packageChanges.addDevDependencies.map((dependency) => `devDependency ${dependency.action} ${dependency.name} -> ${dependency.requiredValue}`),
+    ...plan.packageChanges.packageManagerField ? [
+      `packageManager ${plan.packageChanges.packageManagerField.action} -> ${plan.packageChanges.packageManagerField.requiredValue}`
+    ] : [],
+    ...plan.packageChanges.scripts.map((script) => `script ${script.action} ${script.name} -> ${script.requiredValue}`),
+    ...plan.plannedFiles.map((filePlan) => `file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`),
+    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts.map((artifactPath) => `generated artifact ${artifactPath}`) : []
+  ];
+  const modeLine = plan.commandMode === "apply" ? plan.status === "already-initialized" ? "Mode: apply requested; no files were written because the retrofit surface already existed." : "Mode: apply; package.json and retrofit helper files were written." : "Mode: preview only; no files were written.";
+  const optionalTitle = plan.commandMode === "apply" ? `Applied adoption changes (${changeLines.length}):` : `Planned adoption changes (${changeLines.length}):`;
+  const title = plan.status === "already-initialized" ? formatOutputMarker("success", `wp-typia init: ${plan.projectName} is already initialized`, markerOptions) : plan.commandMode === "apply" ? formatOutputMarker("success", `Applied retrofit init for ${plan.projectName}`, markerOptions) : formatOutputMarker("dryRun", `Retrofit init plan for ${plan.projectName}`, markerOptions);
+  return {
+    nextSteps: plan.nextSteps,
+    optionalLines: changeLines,
+    optionalNote: plan.summary,
+    optionalTitle,
+    summaryLines: [
+      `Project directory: ${plan.projectDir}`,
+      `Detected layout: ${plan.detectedLayout.description}`,
+      ...plan.detectedLayout.blockNames.length > 0 ? [`Block targets: ${plan.detectedLayout.blockNames.join(", ")}`] : [],
+      `Package manager: ${plan.packageManager}`,
+      modeLine
+    ],
+    title,
+    warningLines: plan.notes
+  };
 }
+
+// src/runtime-output/structured.ts
 function toNonEmptyArray(values) {
   return values && values.length > 0 ? values : undefined;
 }
@@ -1040,12 +1157,35 @@ function buildStructuredInitSuccessPayload(plan) {
     }
   };
 }
+// src/runtime-output/create.ts
+function escapeRegExp2(source) {
+  return source.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+var LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN = new RegExp(`^(?:corepack\\s+)?(${PACKAGE_MANAGER_IDS.map(escapeRegExp2).join("|")})(?=$|[@:/+\\s])`, "iu");
+function parseCreateCompletionPackageManager(packageManager) {
+  const normalizedPackageManager = packageManager.trim();
+  const parsedPackageManager = parsePackageManagerField(normalizedPackageManager);
+  if (parsedPackageManager) {
+    return parsedPackageManager;
+  }
+  const looseMatch = LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN.exec(normalizedPackageManager);
+  const loosePackageManager = looseMatch?.[1]?.toLowerCase();
+  return PACKAGE_MANAGER_IDS.includes(loosePackageManager) ? loosePackageManager : null;
+}
+function resolveCreateCompletionPackageManager(packageManager) {
+  const parsedPackageManager = parseCreateCompletionPackageManager(packageManager);
+  if (parsedPackageManager) {
+    return parsedPackageManager;
+  }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unsupported package manager "${packageManager}" in create completion payload. Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}.`);
+}
 function formatCreateProgressLine(payload, markerOptions) {
   return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
 }
 function buildCreateCompletionPayload(flow, markerOptions) {
+  const packageManager = resolveCreateCompletionPackageManager(flow.packageManager);
   const verificationSteps = [
-    formatPackageExecCommand(flow.packageManager, `wp-typia@${package_default.version}`, "doctor"),
+    formatPackageExecCommand(packageManager, `wp-typia@${package_default.version}`, "doctor"),
     ...flow.optionalOnboarding.steps
   ];
   return {
@@ -1084,42 +1224,7 @@ function buildCreateDryRunPayload(flow, markerOptions) {
     warningLines: flow.result.warnings
   };
 }
-function buildInitCompletionPayload(plan, markerOptions) {
-  const changeLines = [
-    ...plan.packageChanges.addDevDependencies.map((dependency) => `devDependency ${dependency.action} ${dependency.name} -> ${dependency.requiredValue}`),
-    ...plan.packageChanges.packageManagerField ? [
-      `packageManager ${plan.packageChanges.packageManagerField.action} -> ${plan.packageChanges.packageManagerField.requiredValue}`
-    ] : [],
-    ...plan.packageChanges.scripts.map((script) => `script ${script.action} ${script.name} -> ${script.requiredValue}`),
-    ...plan.plannedFiles.map((filePlan) => `file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`),
-    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts.map((artifactPath) => `generated artifact ${artifactPath}`) : []
-  ];
-  const modeLine = plan.commandMode === "apply" ? plan.status === "already-initialized" ? "Mode: apply requested; no files were written because the retrofit surface already existed." : "Mode: apply; package.json and retrofit helper files were written." : "Mode: preview only; no files were written.";
-  const optionalTitle = plan.commandMode === "apply" ? `Applied adoption changes (${changeLines.length}):` : `Planned adoption changes (${changeLines.length}):`;
-  const title = plan.status === "already-initialized" ? formatOutputMarker("success", `wp-typia init: ${plan.projectName} is already initialized`, markerOptions) : plan.commandMode === "apply" ? formatOutputMarker("success", `Applied retrofit init for ${plan.projectName}`, markerOptions) : formatOutputMarker("dryRun", `Retrofit init plan for ${plan.projectName}`, markerOptions);
-  return {
-    nextSteps: plan.nextSteps,
-    optionalLines: changeLines,
-    optionalNote: plan.summary,
-    optionalTitle,
-    summaryLines: [
-      `Project directory: ${plan.projectDir}`,
-      `Detected layout: ${plan.detectedLayout.description}`,
-      ...plan.detectedLayout.blockNames.length > 0 ? [`Block targets: ${plan.detectedLayout.blockNames.join(", ")}`] : [],
-      `Package manager: ${plan.packageManager}`,
-      modeLine
-    ],
-    title,
-    warningLines: plan.notes
-  };
-}
-function buildMigrationCompletionPayload(options, markerOptions) {
-  const summaryLines = options.lines.filter((line) => line.trim().length > 0);
-  return {
-    summaryLines,
-    title: formatOutputMarker("success", `Completed wp-typia migrate ${options.command}`, markerOptions)
-  };
-}
+// src/runtime-output/add.ts
 function buildAddCompletionPayload(options, markerOptions) {
   const verificationLines = [
     formatPackageExecCommand(options.packageManager ?? inferPackageManagerId(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
@@ -1151,6 +1256,15 @@ function buildAddDryRunPayload(options, markerOptions) {
     warningLines: options.completion.warningLines
   };
 }
+// src/runtime-output/migrate.ts
+function buildMigrationCompletionPayload(options, markerOptions) {
+  const summaryLines = options.lines.filter((line) => line.trim().length > 0);
+  return {
+    summaryLines,
+    title: formatOutputMarker("success", `Completed wp-typia migrate ${options.command}`, markerOptions)
+  };
+}
+// src/runtime-output/sync.ts
 function buildSyncDryRunPayload(options, markerOptions) {
   const targetSuffix = options.target === "ai" ? " ai" : "";
   const targetSummary = options.target === "ai" ? "Sync target: AI artifacts only." : options.target === "default" ? "Sync target: generated project defaults." : undefined;
@@ -1167,232 +1281,62 @@ function buildSyncDryRunPayload(options, markerOptions) {
     title: formatOutputMarker("dryRun", `Dry run for wp-typia sync${targetSuffix}`, markerOptions)
   };
 }
-function printBlock(lines, printLine) {
+// src/print-block.ts
+function printBlock(printLine, lines) {
   for (const line of lines) {
     printLine(line);
   }
 }
 
-// src/runtime-capabilities.ts
-function isInteractiveTerminal({
-  stdin = process.stdin,
-  stdout = process.stdout,
-  term = process.env.TERM
-} = {}) {
-  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== "dumb";
-}
-function supportsInteractiveTui(options = {}) {
-  const hasBunRuntime = options.hasBunRuntime ?? typeof Bun !== "undefined";
-  return hasBunRuntime && isInteractiveTerminal(options);
-}
-// src/runtime-bridge-sync.ts
-import { spawnSync } from "child_process";
-import fs3 from "fs";
-import path2 from "path";
-var SYNC_INSTALL_MARKERS = [
-  "node_modules",
-  ".pnp.cjs",
-  ".pnp.loader.mjs"
-];
-var LOCAL_SYNC_TOOL_PATTERN = /(^|[\s;&|()])(?:tsx|wp-scripts)(?=($|[\s;&|()]))/u;
-var CAPTURED_SYNC_OUTPUT_MAX_BUFFER = 16 * 1024 * 1024;
-function resolveSyncExecutionTarget(subcommand) {
-  if (!subcommand) {
-    return "default";
-  }
-  if (subcommand === "ai") {
-    return "ai";
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
-}
-function getSyncRootError(cwd) {
-  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
-}
-function resolveSyncProjectContext(cwd) {
-  const packageJsonPath = path2.join(cwd, "package.json");
-  if (!fs3.existsSync(packageJsonPath)) {
-    throw getSyncRootError(cwd);
-  }
-  const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
-  const scripts = packageJson.scripts ?? {};
-  const syncScripts = {
-    sync: typeof scripts.sync === "string" ? {
-      command: scripts.sync,
-      scriptName: "sync"
-    } : undefined,
-    "sync-ai": typeof scripts["sync-ai"] === "string" ? {
-      command: scripts["sync-ai"],
-      scriptName: "sync-ai"
-    } : typeof scripts["sync-wordpress-ai"] === "string" ? {
-      command: scripts["sync-wordpress-ai"],
-      scriptName: "sync-wordpress-ai"
-    } : undefined,
-    "sync-rest": typeof scripts["sync-rest"] === "string" ? {
-      command: scripts["sync-rest"],
-      scriptName: "sync-rest"
-    } : undefined,
-    "sync-types": typeof scripts["sync-types"] === "string" ? {
-      command: scripts["sync-types"],
-      scriptName: "sync-types"
-    } : undefined
-  };
-  return {
-    cwd,
-    packageJsonPath,
-    packageManager: inferPackageManagerId(cwd, packageJson.packageManager),
-    scripts: syncScripts
-  };
-}
-function findInstalledDependencyMarkerDir(projectDir) {
-  let currentDir = path2.resolve(projectDir);
-  while (true) {
-    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path2.join(currentDir, marker)))) {
-      return currentDir;
-    }
-    const parentDir = path2.dirname(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-function scriptsLikelyNeedInstalledDependencies(project, target) {
-  const candidateScripts = target === "ai" ? [project.scripts["sync-ai"]] : project.scripts.sync ? [project.scripts.sync] : [
-    project.scripts["sync-types"],
-    project.scripts["sync-rest"],
-    project.scripts["sync-ai"]
-  ];
-  return candidateScripts.some((script) => script !== undefined && LOCAL_SYNC_TOOL_PATTERN.test(script.command));
-}
-function assertSyncDependenciesInstalled(project, target) {
-  if (!scriptsLikelyNeedInstalledDependencies(project, target)) {
-    return;
-  }
-  const markerDir = findInstalledDependencyMarkerDir(project.cwd);
-  if (markerDir) {
-    return;
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.DEPENDENCIES_NOT_INSTALLED, `Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
-}
-function getPackageManagerRunInvocation(packageManager, scriptName, extraArgs) {
-  switch (packageManager) {
-    case "bun":
-      return { args: ["run", scriptName, ...extraArgs], command: "bun" };
-    case "npm":
-      return {
-        args: [
-          "run",
-          scriptName,
-          ...extraArgs.length > 0 ? ["--", ...extraArgs] : []
-        ],
-        command: "npm"
-      };
-    case "pnpm":
-      return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
-    case "yarn":
-      return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
-  }
-}
-function createSyncPlannedCommand(project, scriptName, extraArgs) {
-  const script = project.scripts[scriptName];
-  if (!script) {
-    return null;
-  }
-  const invocation = getPackageManagerRunInvocation(project.packageManager, script.scriptName, extraArgs);
-  return {
-    args: invocation.args,
-    command: invocation.command,
-    displayCommand: formatRunScript(project.packageManager, script.scriptName, extraArgs.join(" ")),
-    scriptName: script.scriptName
-  };
-}
-function buildSyncPlannedCommands(project, extraArgs, target) {
-  if (target === "ai") {
-    const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
-    if (!syncAiCommand2) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
-    }
-    return [syncAiCommand2];
+// src/runtime-output/print.ts
+function printCompletionPayload(payload, options = {}) {
+  const printLine = options.printLine ?? console.log;
+  const warnLine = options.warnLine ?? printLine;
+  for (const line of payload.preambleLines ?? []) {
+    printLine(line);
   }
-  if (project.scripts.sync) {
-    return [createSyncPlannedCommand(project, "sync", extraArgs)];
+  for (const warning of payload.warningLines ?? []) {
+    warnLine(formatOutputMarker("warning", warning, options.markerOptions));
   }
-  const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
-  if (!syncTypesCommand) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+  const hasDetails = (payload.summaryLines?.length ?? 0) > 0 || (payload.nextSteps?.length ?? 0) > 0 || (payload.optionalLines?.length ?? 0) > 0 || Boolean(payload.optionalNote);
+  const hasLeadingContext = (payload.preambleLines?.length ?? 0) > 0 || (payload.warningLines?.length ?? 0) > 0;
+  printLine(hasLeadingContext && hasDetails ? `
+${payload.title}` : payload.title);
+  for (const line of payload.summaryLines ?? []) {
+    printLine(line);
   }
-  const plannedCommands = [syncTypesCommand];
-  const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
-  if (syncRestCommand) {
-    plannedCommands.push(syncRestCommand);
+  if ((payload.nextSteps?.length ?? 0) > 0) {
+    printLine("Next steps:");
+    for (const step of payload.nextSteps ?? []) {
+      printLine(`  ${step}`);
+    }
   }
-  const syncAiCommand = createSyncPlannedCommand(project, "sync-ai", extraArgs);
-  if (syncAiCommand) {
-    plannedCommands.push(syncAiCommand);
+  if ((payload.optionalLines?.length ?? 0) > 0) {
+    printLine(`
+${payload.optionalTitle ?? "Optional:"}`);
+    for (const step of payload.optionalLines ?? []) {
+      printLine(`  ${step}`);
+    }
   }
-  return plannedCommands;
-}
-function runProjectScript(project, plannedCommand, options) {
-  const result = spawnSync(plannedCommand.command, plannedCommand.args, {
-    cwd: project.cwd,
-    encoding: options.captureOutput ? "utf8" : undefined,
-    ...options.captureOutput ? { maxBuffer: CAPTURED_SYNC_OUTPUT_MAX_BUFFER } : {},
-    shell: process.platform === "win32",
-    stdio: options.captureOutput ? "pipe" : "inherit"
-  });
-  const stderr = options.captureOutput && typeof result.stderr === "string" ? result.stderr : undefined;
-  const stdout = options.captureOutput && typeof result.stdout === "string" ? result.stdout : undefined;
-  if (result.error || result.status !== 0) {
-    throw new Error(`\`${plannedCommand.displayCommand}\` failed.`, {
-      cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
-    });
+  if (payload.optionalNote) {
+    printLine(`Note: ${payload.optionalNote}`);
   }
-  return {
-    ...plannedCommand,
-    exitCode: result.status ?? 0,
-    ...stderr !== undefined ? { stderr } : {},
-    ...stdout !== undefined ? { stdout } : {}
-  };
 }
-async function executeSyncCommand({
-  captureOutput = false,
-  check = false,
-  cwd,
-  dryRun = false,
-  target = "default"
-}) {
-  const project = resolveSyncProjectContext(cwd);
-  const extraArgs = check ? ["--check"] : [];
-  const plannedCommands = buildSyncPlannedCommands(project, extraArgs, target);
-  const result = {
-    check,
-    dryRun,
-    packageJsonPath: project.packageJsonPath,
-    packageManager: project.packageManager,
-    plannedCommands,
-    projectDir: project.cwd,
-    target
-  };
-  if (dryRun) {
-    return result;
-  }
-  assertSyncDependenciesInstalled(project, target);
-  result.executedCommands = plannedCommands.map((plannedCommand) => runProjectScript(project, plannedCommand, {
-    captureOutput
-  }));
-  return result;
+// src/runtime-capabilities.ts
+function isInteractiveTerminal({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  term = process.env.TERM
+} = {}) {
+  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== "dumb";
+}
+function supportsInteractiveTui(options = {}) {
+  const hasBunRuntime = options.hasBunRuntime ?? typeof Bun !== "undefined";
+  return hasBunRuntime && isInteractiveTerminal(options);
 }
 
-// src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("./cli-add-1xvw17yg.js");
+// src/runtime-bridge-shared.ts
 var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-5dvztm7q.js");
-var loadCliDoctorRuntime = () => import("./cli-doctor-bjv6z74k.js");
-var loadCliInitRuntime = () => import("./cli-init-zdfrmp3y.js");
-var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-pbb67zxg.js");
-var loadCliTemplatesRuntime = () => import("./cli-templates-hc71dfc2.js");
-var loadCreateTemplateValidationRuntime = () => import("./create-template-validation-7k2752mz.js");
-var loadMigrationsRuntime = () => import("./migrations-ads3j14z.js");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError } = await loadCliDiagnosticsRuntime();
   return createCliCommandError({ command, error });
@@ -1406,6 +1350,15 @@ function shouldWrapCliCommandError(options) {
   }
   return true;
 }
+function emitCompletion(payload, options) {
+  if (options.emitOutput) {
+    printCompletionPayload(payload, {
+      printLine: options.printLine,
+      warnLine: options.warnLine
+    });
+  }
+  return payload;
+}
 function pushFlag(argv, name, value) {
   if (value === undefined || value === null || value === false) {
     return;
@@ -1416,6 +1369,10 @@ function pushFlag(argv, name, value) {
   }
   argv.push(`--${name}`, String(value));
 }
+
+// src/runtime-bridge-add.ts
+var loadCliAddRuntime = () => import("./cli-add-8rvmezy0.js");
+var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
 async function executeWorkspaceAddWithOptionalDryRun(options) {
   const simulated = options.dryRun ? await simulateWorkspaceAddDryRun({
     cwd: options.cwd,
@@ -1459,6 +1416,72 @@ async function executePlannedAddKind(kind, executionContext, context) {
   const plan = await getAddKindExecutionPlan(kind, executionContext);
   return executePreparedAddKind(kind, context, plan);
 }
+async function executeAddCommand({
+  cwd,
+  emitOutput = true,
+  flags,
+  interactive,
+  kind,
+  name,
+  printLine = console.log,
+  prompt,
+  warnLine = console.warn
+}) {
+  let activePrompt;
+  const dryRun = Boolean(flags["dry-run"]);
+  try {
+    const addRuntime = await loadCliAddRuntime();
+    const isInteractiveSession = interactive ?? isInteractiveTerminal();
+    if (!kind) {
+      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
+        printLine(addRuntime.formatAddHelpText());
+      }
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, formatMissingAddKindDetailLine());
+    }
+    if (!isAddKindId(kind)) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
+    }
+    if (dryRun && !supportsAddKindDryRun(kind)) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
+    }
+    const executionContext = {
+      addRuntime,
+      cwd,
+      flags,
+      getOrCreatePrompt: async () => {
+        if (activePrompt) {
+          return activePrompt;
+        }
+        const { createReadlinePrompt } = await loadCliPromptRuntime();
+        activePrompt = prompt ?? createReadlinePrompt();
+        return activePrompt;
+      },
+      isInteractiveSession,
+      name,
+      warnLine
+    };
+    return await executePlannedAddKind(kind, executionContext, {
+      cwd,
+      dryRun,
+      emitOutput,
+      printLine
+    });
+  } catch (error) {
+    if (!shouldWrapCliCommandError({ emitOutput })) {
+      throw error;
+    }
+    throw await wrapCliCommandError("add", error);
+  } finally {
+    if (activePrompt && activePrompt !== prompt) {
+      activePrompt.close();
+    }
+  }
+}
+// src/runtime-bridge-create.ts
+var loadCliPromptRuntime2 = () => import("./cli-prompt-614tq57c.js");
+var loadCliScaffoldRuntime = () => import("./cli-scaffold-b1ex2y80.js");
+var loadCliTemplatesRuntime = () => import("./cli-templates-hc71dfc2.js");
+var loadCreateTemplateValidationRuntime = () => import("./create-template-validation-rtec5sng.js");
 var PACKAGE_MANAGER_PROMPT_OPTIONS = [
   { label: "npm", value: "npm", hint: "Use npm" },
   { label: "pnpm", value: "pnpm", hint: "Use pnpm" },
@@ -1485,15 +1508,6 @@ var BOOLEAN_PROMPT_OPTIONS = [
   { label: "Yes", value: "yes", hint: "Enable this option" },
   { label: "No", value: "no", hint: "Keep the default disabled state" }
 ];
-function emitCompletion(payload, options) {
-  if (options.emitOutput) {
-    printCompletionPayload(payload, {
-      printLine: options.printLine,
-      warnLine: options.warnLine
-    });
-  }
-  return payload;
-}
 async function executeCreateCommand({
   projectDir,
   cwd,
@@ -1514,7 +1528,7 @@ async function executeCreateCommand({
       { runScaffoldFlow },
       { getTemplateSelectOptions }
     ] = await Promise.all([
-      loadCliPromptRuntime(),
+      loadCliPromptRuntime2(),
       loadCliScaffoldRuntime(),
       loadCliTemplatesRuntime()
     ]);
@@ -1583,100 +1597,24 @@ async function executeCreateCommand({
       activePrompt.close();
     }
   }
-}
-async function executeAddCommand({
-  cwd,
-  emitOutput = true,
-  flags,
-  interactive,
-  kind,
-  name,
-  printLine = console.log,
-  prompt,
-  warnLine = console.warn
-}) {
-  let activePrompt;
-  const dryRun = Boolean(flags["dry-run"]);
-  try {
-    const addRuntime = await loadCliAddRuntime();
-    const isInteractiveSession = interactive ?? isInteractiveTerminal();
-    if (!kind) {
-      if (emitOutput) {
-        printLine(addRuntime.formatAddHelpText());
-      }
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
-    }
-    if (!isAddKindId(kind)) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
-    }
-    if (dryRun && !supportsAddKindDryRun(kind)) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
-    }
-    const executionContext = {
-      addRuntime,
-      cwd,
-      flags,
-      getOrCreatePrompt: async () => {
-        if (activePrompt) {
-          return activePrompt;
-        }
-        const { createReadlinePrompt } = await loadCliPromptRuntime();
-        activePrompt = prompt ?? createReadlinePrompt();
-        return activePrompt;
-      },
-      isInteractiveSession,
-      name,
-      warnLine
-    };
-    return await executePlannedAddKind(kind, executionContext, {
-      cwd,
-      dryRun,
-      emitOutput,
-      printLine
-    });
-  } catch (error) {
-    if (!shouldWrapCliCommandError({ emitOutput })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("add", error);
-  } finally {
-    if (activePrompt && activePrompt !== prompt) {
-      activePrompt.close();
-    }
-  }
-}
-async function executeTemplatesCommand({ flags }, printLine = console.log) {
-  const {
-    formatTemplateDetails,
-    formatTemplateFeatures,
-    formatTemplateSummary,
-    getTemplateById,
-    listTemplates
-  } = await loadCliTemplatesRuntime();
-  const subcommand = flags.subcommand ?? "list";
-  if (subcommand === "list") {
-    for (const template of listTemplates()) {
-      printBlock([formatTemplateSummary(template), formatTemplateFeatures(template)], printLine);
-    }
-    return;
-  }
-  if (subcommand === "inspect") {
-    if (!flags.id) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
-    }
-    const template = getTemplateById(flags.id);
-    if (!template) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
-    }
-    printBlock([formatTemplateDetails(template)], printLine);
-    return;
+}
+// src/runtime-bridge-doctor.ts
+var loadCliDoctorRuntime = () => import("./cli-doctor-5m6xyx9q.js");
+async function executeDoctorCommand(cwd) {
+  try {
+    const { runDoctor } = await loadCliDoctorRuntime();
+    await runDoctor(cwd);
+  } catch (error) {
+    throw await wrapCliCommandError("doctor", error);
   }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
 }
+// src/runtime-bridge-init.ts
+import path2 from "path";
+var loadCliInitRuntime = () => import("./cli-init-qv3zxmvc.js");
 async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
   try {
     const { runInitCommand } = await loadCliInitRuntime();
-    const resolvedProjectDir = projectDir ? (await import("path")).resolve(cwd, projectDir) : cwd;
+    const resolvedProjectDir = projectDir ? path2.resolve(cwd, projectDir) : cwd;
     const plan = await runInitCommand({
       apply,
       packageManager,
@@ -1697,14 +1635,8 @@ async function executeInitCommand({ apply, cwd, packageManager, projectDir }, op
     throw await wrapCliCommandError("init", error);
   }
 }
-async function executeDoctorCommand(cwd) {
-  try {
-    const { runDoctor } = await loadCliDoctorRuntime();
-    await runDoctor(cwd);
-  } catch (error) {
-    throw await wrapCliCommandError("doctor", error);
-  }
-}
+// src/runtime-bridge-migrate.ts
+var loadMigrationsRuntime = () => import("./migrations-7g9rag5d.js");
 async function executeMigrateCommand({
   command,
   cwd,
@@ -1712,12 +1644,17 @@ async function executeMigrateCommand({
   prompt,
   renderLine
 }) {
-  const { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand } = await loadMigrationsRuntime();
-  if (!command) {
-    console.log(formatMigrationHelpText());
-    return;
-  }
   try {
+    const { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand } = await loadMigrationsRuntime();
+    if (!command) {
+      const helpText = formatMigrationHelpText();
+      if (renderLine) {
+        renderLine(helpText);
+      } else {
+        console.log(helpText);
+      }
+      return;
+    }
     const argv = [command];
     pushFlag(argv, "all", flags.all);
     pushFlag(argv, "force", flags.force);
@@ -1757,11 +1694,246 @@ async function executeMigrateCommand({
     throw await wrapCliCommandError("migrate", error);
   }
 }
+// src/runtime-bridge-templates.ts
+var loadCliTemplatesRuntime2 = () => import("./cli-templates-hc71dfc2.js");
+async function executeTemplatesCommand({ flags }, printLine = console.log) {
+  const {
+    formatTemplateDetails,
+    formatTemplateFeatures,
+    formatTemplateSummary,
+    getTemplateById,
+    listTemplates
+  } = await loadCliTemplatesRuntime2();
+  const subcommand = flags.subcommand ?? "list";
+  if (subcommand === "list") {
+    for (const template of listTemplates()) {
+      printBlock(printLine, [formatTemplateSummary(template), formatTemplateFeatures(template)]);
+    }
+    return;
+  }
+  if (subcommand === "inspect") {
+    if (!flags.id) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
+    }
+    const template = getTemplateById(flags.id);
+    if (!template) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
+    }
+    printBlock(printLine, [formatTemplateDetails(template)]);
+    return;
+  }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+}
 async function listTemplatesForRuntime() {
-  const { listTemplates } = await loadCliTemplatesRuntime();
+  const { listTemplates } = await loadCliTemplatesRuntime2();
   return listTemplates();
 }
-
+// src/runtime-bridge-sync.ts
+import { spawnSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var SYNC_INSTALL_MARKERS = [
+  "node_modules",
+  ".pnp.cjs",
+  ".pnp.loader.mjs"
+];
+var LOCAL_SYNC_TOOL_PATTERN = /(^|[\s;&|()])(?:tsx|wp-scripts)(?=($|[\s;&|()]))/u;
+var CAPTURED_SYNC_OUTPUT_MAX_BUFFER = 16 * 1024 * 1024;
+function resolveSyncExecutionTarget(subcommand) {
+  if (!subcommand) {
+    return "default";
+  }
+  if (subcommand === "ai") {
+    return "ai";
+  }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+}
+function getSyncRootError(cwd) {
+  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
+}
+function readSyncPackageJson(packageJsonPath) {
+  const source = fs3.readFileSync(packageJsonPath, "utf8");
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to parse ${packageJsonPath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+  }
+}
+function resolveSyncProjectContext(cwd) {
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    throw getSyncRootError(cwd);
+  }
+  const packageJson = readSyncPackageJson(packageJsonPath);
+  const scripts = packageJson.scripts ?? {};
+  const syncScripts = {
+    sync: typeof scripts.sync === "string" ? {
+      command: scripts.sync,
+      scriptName: "sync"
+    } : undefined,
+    "sync-ai": typeof scripts["sync-ai"] === "string" ? {
+      command: scripts["sync-ai"],
+      scriptName: "sync-ai"
+    } : typeof scripts["sync-wordpress-ai"] === "string" ? {
+      command: scripts["sync-wordpress-ai"],
+      scriptName: "sync-wordpress-ai"
+    } : undefined,
+    "sync-rest": typeof scripts["sync-rest"] === "string" ? {
+      command: scripts["sync-rest"],
+      scriptName: "sync-rest"
+    } : undefined,
+    "sync-types": typeof scripts["sync-types"] === "string" ? {
+      command: scripts["sync-types"],
+      scriptName: "sync-types"
+    } : undefined
+  };
+  return {
+    cwd,
+    packageJsonPath,
+    packageManager: inferPackageManagerId(cwd, packageJson.packageManager),
+    scripts: syncScripts
+  };
+}
+function findInstalledDependencyMarkerDir(projectDir) {
+  let currentDir = path3.resolve(projectDir);
+  while (true) {
+    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path3.join(currentDir, marker)))) {
+      return currentDir;
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function scriptsLikelyNeedInstalledDependencies(project, target) {
+  const candidateScripts = target === "ai" ? [project.scripts["sync-ai"]] : project.scripts.sync ? [project.scripts.sync] : [
+    project.scripts["sync-types"],
+    project.scripts["sync-rest"],
+    project.scripts["sync-ai"]
+  ];
+  return candidateScripts.some((script) => script !== undefined && LOCAL_SYNC_TOOL_PATTERN.test(script.command));
+}
+function assertSyncDependenciesInstalled(project, target) {
+  if (!scriptsLikelyNeedInstalledDependencies(project, target)) {
+    return;
+  }
+  const markerDir = findInstalledDependencyMarkerDir(project.cwd);
+  if (markerDir) {
+    return;
+  }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.DEPENDENCIES_NOT_INSTALLED, `Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
+}
+function getPackageManagerRunInvocation(packageManager, scriptName, extraArgs) {
+  switch (packageManager) {
+    case "bun":
+      return { args: ["run", scriptName, ...extraArgs], command: "bun" };
+    case "npm":
+      return {
+        args: [
+          "run",
+          scriptName,
+          ...extraArgs.length > 0 ? ["--", ...extraArgs] : []
+        ],
+        command: "npm"
+      };
+    case "pnpm":
+      return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
+    case "yarn":
+      return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
+  }
+}
+function createSyncPlannedCommand(project, scriptName, extraArgs) {
+  const script = project.scripts[scriptName];
+  if (!script) {
+    return null;
+  }
+  const invocation = getPackageManagerRunInvocation(project.packageManager, script.scriptName, extraArgs);
+  return {
+    args: invocation.args,
+    command: invocation.command,
+    displayCommand: formatRunScript(project.packageManager, script.scriptName, extraArgs.join(" ")),
+    scriptName: script.scriptName
+  };
+}
+function buildSyncPlannedCommands(project, extraArgs, target) {
+  if (target === "ai") {
+    const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
+    if (!syncAiCommand2) {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
+    }
+    return [syncAiCommand2];
+  }
+  if (project.scripts.sync) {
+    return [createSyncPlannedCommand(project, "sync", extraArgs)];
+  }
+  const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
+  if (!syncTypesCommand) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+  }
+  const plannedCommands = [syncTypesCommand];
+  const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
+  if (syncRestCommand) {
+    plannedCommands.push(syncRestCommand);
+  }
+  const syncAiCommand = createSyncPlannedCommand(project, "sync-ai", extraArgs);
+  if (syncAiCommand) {
+    plannedCommands.push(syncAiCommand);
+  }
+  return plannedCommands;
+}
+function runProjectScript(project, plannedCommand, options) {
+  const result = spawnSync(plannedCommand.command, plannedCommand.args, {
+    cwd: project.cwd,
+    encoding: options.captureOutput ? "utf8" : undefined,
+    ...options.captureOutput ? { maxBuffer: CAPTURED_SYNC_OUTPUT_MAX_BUFFER } : {},
+    shell: process.platform === "win32",
+    stdio: options.captureOutput ? "pipe" : "inherit"
+  });
+  const stderr = options.captureOutput && typeof result.stderr === "string" ? result.stderr : undefined;
+  const stdout = options.captureOutput && typeof result.stdout === "string" ? result.stdout : undefined;
+  if (result.error || result.status !== 0) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
+      cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
+    });
+  }
+  return {
+    ...plannedCommand,
+    exitCode: result.status ?? 0,
+    ...stderr !== undefined ? { stderr } : {},
+    ...stdout !== undefined ? { stdout } : {}
+  };
+}
+async function executeSyncCommand({
+  captureOutput = false,
+  check = false,
+  cwd,
+  dryRun = false,
+  target = "default"
+}) {
+  const project = resolveSyncProjectContext(cwd);
+  const extraArgs = check ? ["--check"] : [];
+  const plannedCommands = buildSyncPlannedCommands(project, extraArgs, target);
+  const result = {
+    check,
+    dryRun,
+    packageJsonPath: project.packageJsonPath,
+    packageManager: project.packageManager,
+    plannedCommands,
+    projectDir: project.cwd,
+    target
+  };
+  if (dryRun) {
+    return result;
+  }
+  assertSyncDependenciesInstalled(project, target);
+  result.executedCommands = plannedCommands.map((plannedCommand) => runProjectScript(project, plannedCommand, {
+    captureOutput
+  }));
+  return result;
+}
 // src/ui/lazy-flow.tsx
 var import_react33 = __toESM(require_react(), 1);
 
@@ -2279,10 +2451,7 @@ var createCommand = defineCommand({
       emitCliDiagnosticFailure(args, {
         code: CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT,
         command: "create",
-        detailLines: [
-          "`wp-typia create` requires <project-dir>.",
-          "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
-        ]
+        detailLines: buildMissingCreateProjectDirDetailLines()
       });
       return;
     }
@@ -2344,7 +2513,7 @@ var doctorCommand = defineCommand({
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     if (prefersStructuredOutput) {
       const [{ getDoctorChecks }, { getDoctorFailureDetailLines }] = await Promise.all([
-        import("./cli-doctor-bjv6z74k.js"),
+        import("./cli-doctor-5m6xyx9q.js"),
         import("./cli-diagnostics-5dvztm7q.js")
       ]);
       const checks = await getDoctorChecks(args.cwd);
@@ -2403,7 +2572,7 @@ var initCommand = defineCommand({
 
 // src/mcp.ts
 import fs4 from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -2422,7 +2591,7 @@ class McpToolsProviderError extends TaggedError("McpToolsProviderError")() {
 function jsonSchemaToZodSchema(schema, options = {}) {
   return convertSchema(schema, options, "$");
 }
-function convertSchema(schema, options, path3) {
+function convertSchema(schema, options, path4) {
   const { coerce = true } = options;
   if (!schema || typeof schema !== "object") {
     return Result.ok(exports_external.unknown());
@@ -2437,49 +2606,49 @@ function convertSchema(schema, options, path3) {
         return Result.ok(exports_external.enum(enumValues));
       }
       const literals = enumValues.map((v) => exports_external.literal(v));
-      return unionFromSchemas(literals, path3);
+      return unionFromSchemas(literals, path4);
     }
   }
   if (schema.anyOf && schema.anyOf.length > 0) {
-    const schemas = mapSchemas(schema.anyOf, options, `${path3}.anyOf`);
+    const schemas = mapSchemas(schema.anyOf, options, `${path4}.anyOf`);
     if (Result.isError(schemas)) {
       return schemas;
     }
-    return unionFromSchemas(schemas.value, `${path3}.anyOf`);
+    return unionFromSchemas(schemas.value, `${path4}.anyOf`);
   }
   if (schema.oneOf && schema.oneOf.length > 0) {
-    const schemas = mapSchemas(schema.oneOf, options, `${path3}.oneOf`);
+    const schemas = mapSchemas(schema.oneOf, options, `${path4}.oneOf`);
     if (Result.isError(schemas)) {
       return schemas;
     }
-    return unionFromSchemas(schemas.value, `${path3}.oneOf`);
+    return unionFromSchemas(schemas.value, `${path4}.oneOf`);
   }
   const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
   switch (schemaType) {
     case "string":
-      return buildStringSchema(schema, path3);
+      return buildStringSchema(schema, path4);
     case "number":
     case "integer":
       return Result.ok(buildNumberSchema(schema, coerce));
     case "boolean":
       return Result.ok(buildBooleanSchema());
     case "array":
-      return buildArraySchema(schema, options, path3);
+      return buildArraySchema(schema, options, path4);
     case "object":
-      return buildObjectSchema(schema, options, path3);
+      return buildObjectSchema(schema, options, path4);
     case "null":
       return Result.ok(exports_external.null());
     default:
       if (schema.properties) {
-        return buildObjectSchema(schema, options, path3);
+        return buildObjectSchema(schema, options, path4);
       }
       if (schema.items) {
-        return buildArraySchema(schema, options, path3);
+        return buildArraySchema(schema, options, path4);
       }
       return Result.ok(exports_external.unknown());
   }
 }
-function buildStringSchema(schema, path3) {
+function buildStringSchema(schema, path4) {
   let zodSchema = exports_external.string();
   if (schema.minLength !== undefined) {
     zodSchema = zodSchema.min(schema.minLength);
@@ -2492,7 +2661,7 @@ function buildStringSchema(schema, path3) {
     const regexResult = Result.try({
       try: () => new RegExp(pattern),
       catch: (cause) => new SchemaConversionError({
-        path: path3,
+        path: path4,
         message: `Invalid regex pattern "${pattern}"`,
         cause
       })
@@ -2549,19 +2718,19 @@ function buildNumberSchema(schema, coerce) {
 function buildBooleanSchema() {
   return exports_external.boolean();
 }
-function buildArraySchema(schema, options, path3) {
+function buildArraySchema(schema, options, path4) {
   let itemSchema = exports_external.unknown();
   if (schema.items) {
     if (Array.isArray(schema.items)) {
       if (schema.items.length > 0) {
-        const itemResult = convertSchema(schema.items[0], options, `${path3}.items[0]`);
+        const itemResult = convertSchema(schema.items[0], options, `${path4}.items[0]`);
         if (Result.isError(itemResult)) {
           return itemResult;
         }
         itemSchema = itemResult.value;
       }
     } else {
-      const itemResult = convertSchema(schema.items, options, `${path3}.items`);
+      const itemResult = convertSchema(schema.items, options, `${path4}.items`);
       if (Result.isError(itemResult)) {
         return itemResult;
       }
@@ -2577,14 +2746,14 @@ function buildArraySchema(schema, options, path3) {
   }
   return Result.ok(zodSchema);
 }
-function buildObjectSchema(schema, options, path3) {
+function buildObjectSchema(schema, options, path4) {
   if (!schema.properties) {
     return Result.ok(exports_external.record(exports_external.string(), exports_external.unknown()));
   }
   const shape = {};
   const requiredFields = new Set(schema.required || []);
   for (const [propName, propSchema] of Object.entries(schema.properties)) {
-    const propResult = convertSchema(propSchema, options, `${path3}.properties.${propName}`);
+    const propResult = convertSchema(propSchema, options, `${path4}.properties.${propName}`);
     if (Result.isError(propResult)) {
       return propResult;
     }
@@ -2599,10 +2768,10 @@ function buildObjectSchema(schema, options, path3) {
   }
   return Result.ok(exports_external.object(shape));
 }
-function mapSchemas(schemas, options, path3) {
+function mapSchemas(schemas, options, path4) {
   const zodSchemas = [];
   for (let index = 0;index < schemas.length; index += 1) {
-    const converted = convertSchema(schemas[index], options, `${path3}[${index}]`);
+    const converted = convertSchema(schemas[index], options, `${path4}[${index}]`);
     if (Result.isError(converted)) {
       return converted;
     }
@@ -2610,11 +2779,11 @@ function mapSchemas(schemas, options, path3) {
   }
   return Result.ok(zodSchemas);
 }
-function unionFromSchemas(schemas, path3) {
+function unionFromSchemas(schemas, path4) {
   if (schemas.length === 0) {
     return Result.err(new SchemaConversionError({
-      path: path3,
-      message: `Cannot create union from an empty schema set at ${path3}`,
+      path: path4,
+      message: `Cannot create union from an empty schema set at ${path4}`,
       cause: new Error("Empty schema union")
     }));
   }
@@ -2937,7 +3106,7 @@ function getErrorCauseOptions(error) {
   return error instanceof Error ? { cause: error } : undefined;
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path3.resolve(cwd, source.path);
+  const schemaPath = path4.resolve(cwd, source.path);
   const raw = await fs4.readFile(schemaPath, "utf8");
   let parsed;
   try {
@@ -2959,7 +3128,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path4.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -2982,7 +3151,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".
     }
   }
   await fs4.mkdir(outputDir, { recursive: true });
-  await fs4.writeFile(path3.join(outputDir, "registry.json"), `${JSON.stringify(registry, null, 2)}
+  await fs4.writeFile(path4.join(outputDir, "registry.json"), `${JSON.stringify(registry, null, 2)}
 `, "utf8");
   return {
     commandCount: registry.reduce((count, group) => count + group.tools.length, 0),
@@ -2992,12 +3161,31 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".
 }
 
 // src/commands/mcp.ts
+var defaultPrintLine = (line) => {
+  process.stdout.write(`${line}
+`);
+};
+function resolveMcpPrintLine(args) {
+  return args.printLine ?? defaultPrintLine;
+}
+function printMcpToolGroupSummary(summary, printLine) {
+  for (const group of summary) {
+    printLine(`${group.namespace} (${group.toolCount})`);
+    for (const tool of group.tools) {
+      printLine(`  - ${tool}`);
+    }
+  }
+}
+function printMcpSyncSummary(result, printLine) {
+  printLine(`Synced ${result.commandCount} MCP tools across ${result.groups.length} namespaces into ${result.outputDir}.`);
+}
 var mcpCommand = defineCommand({
   defaultFormat: "json",
   description: "Inspect or sync schema-driven MCP metadata for wp-typia.",
   handler: async (args) => {
     const subcommand = args.positional[0] ?? "list";
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
+    const printLine = resolveMcpPrintLine(args);
     const userConfig = args.context?.store?.wpTypiaUserConfig && typeof args.context.store.wpTypiaUserConfig === "object" ? args.context.store.wpTypiaUserConfig : {};
     const schemaSources = getMcpSchemaSources(userConfig);
     if (schemaSources.length === 0) {
@@ -3022,12 +3210,7 @@ var mcpCommand = defineCommand({
           args.output({ groups: summary });
           return;
         }
-        for (const group of summary) {
-          console.log(`${group.namespace} (${group.toolCount})`);
-          for (const tool of group.tools) {
-            console.log(`  - ${tool}`);
-          }
-        }
+        printMcpToolGroupSummary(summary, printLine);
         return;
       }
       if (subcommand === "sync") {
@@ -3037,7 +3220,7 @@ var mcpCommand = defineCommand({
           args.output({ sync: result });
           return;
         }
-        console.log(`Synced ${result.commandCount} MCP tools across ${result.groups.length} namespaces into ${result.outputDir}.`);
+        printMcpSyncSummary(result, printLine);
         return;
       }
       emitCliDiagnosticFailure(args, {
@@ -3221,4 +3404,4 @@ export {
   wpTypiaCommands
 };
 
-//# debugId=C86915DD4AD0BB9C64756E2164756E21
+//# debugId=8B3272B9527B417864756E2164756E21