From 54ce6fb658576ba1bcfe374ae06ecd1e9b854f3f Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 10:06:52 -0700
Subject: [PATCH 1/7] feat(task): add baseMixin support in TaskTypes

- Add baseMixin field to TaskType interface (plugins/task/src/index.ts)
- Add @Prop decorator for baseMixin in model (models/task/src/index.ts)
- Modify mixin creation logic to use baseMixin when provided (plugins/task/src/utils.ts)
- Add validateMixinHierarchy function for inheritance validation
- Create MixinSelector.svelte component for UI selection
- Add i18n strings for BaseMixin, BaseMixinDescription, NoBaseMixin

This allows TaskTypes to inherit attributes from existing mixins while maintaining backwards compatibility.

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 models/task/src/index.ts                      |  3 +
 plugins/task-assets/lang/en.json              |  3 +
 .../components/taskTypes/MixinSelector.svelte | 82 +++++++++++++++++++
 plugins/task-resources/src/plugin.ts          |  5 +-
 plugins/task/src/index.ts                     |  3 +
 plugins/task/src/utils.ts                     | 20 ++++-
 6 files changed, 114 insertions(+), 2 deletions(-)
 create mode 100644 plugins/task-resources/src/components/taskTypes/MixinSelector.svelte

diff --git a/models/task/src/index.ts b/models/task/src/index.ts
index 288c95d57ff..266f1e1f43c 100644
--- a/models/task/src/index.ts
+++ b/models/task/src/index.ts
@@ -210,6 +210,9 @@ export class TTaskType extends TDoc implements TaskType {
   @Prop(ArrOf(TypeRef(task.class.TaskType)), getEmbeddedLabel('Parent'))
     allowedAsChildOf!: Ref<TaskType>[] // In case of specified, task type is for sub-tasks
 
+  @Prop(TypeRef(core.class.Mixin), getEmbeddedLabel('Base Mixin'))
+    baseMixin?: Ref<Mixin<Task>> // Existing mixin to inherit attributes from
+
   @Prop(TypeRef(core.class.Class), getEmbeddedLabel('Task class'))
     ofClass!: Ref<Class<Task>> // Base class for task
 
diff --git a/plugins/task-assets/lang/en.json b/plugins/task-assets/lang/en.json
index 3c9edeb61cb..ea10c4b4a78 100644
--- a/plugins/task-assets/lang/en.json
+++ b/plugins/task-assets/lang/en.json
@@ -79,6 +79,9 @@
     "StatusChange": "Status changed",
     "TaskCreated": "Task created",
     "TaskType": "Task type",
+    "BaseMixin": "Base Mixin",
+    "BaseMixinDescription": "Inherit attributes from an existing mixin",
+    "NoBaseMixin": "None (create new)",
     "ManageProjects": "Project types",
     "Export": "Export",
     "CreateProjectType": "Create project type",
diff --git a/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
new file mode 100644
index 00000000000..4be3c0ca0a2
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
@@ -0,0 +1,82 @@
+<script lang="ts">
+  import { Class, Mixin, Ref } from '@hcengineering/core'
+  import { Task } from '@hcengineering/task'
+  import { ButtonMenu, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let baseClass: Ref<Class<Task>>
+  export let value: Ref<Mixin<Task>> | undefined = undefined
+  export let readonly = false
+  export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
+  export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+
+  const dispatch = createEventDispatcher()
+  const client = getClient()
+  const hierarchy = client.getHierarchy()
+
+  // Find all mixins that derive from baseClass
+  function getAvailableMixins (): Array<{ id: string; label: string }> {
+    const result: Array<{ id: string; label: string }> = [
+      { id: '', label: 'None (create new)' }
+    ]
+
+    try {
+      const descendants = hierarchy.getDescendants(baseClass)
+      for (const descendant of descendants) {
+        const cls = hierarchy.getClass(descendant)
+        if (cls.kind === 'mixin' && descendant !== baseClass) {
+          result.push({
+            id: descendant as string,
+            label: cls.label ?? descendant
+          })
+        }
+      }
+    } catch (e) {
+      console.error('Error getting available mixins:', e)
+    }
+
+    return result
+  }
+
+  function handleSelect (evt: CustomEvent<string>): void {
+    if (evt.detail !== undefined) {
+      value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
+      dispatch('change', value)
+    }
+  }
+
+  $: items = getAvailableMixins()
+  $: selected = items.find((it) => it.id === (value ?? ''))
+</script>
+
+<div class="mixin-selector">
+  <Label label={plugin.string.BaseMixin} />
+  {#if readonly}
+    {#if selected}
+      <span class="selected-value">{selected.label}</span>
+    {/if}
+  {:else}
+    <ButtonMenu
+      selected={value ?? ''}
+      {items}
+      label={selected?.label ?? plugin.string.NoBaseMixin}
+      kind={buttonKind}
+      size={buttonSize}
+      on:selected={handleSelect}
+    />
+  {/if}
+</div>
+
+<style lang="scss">
+  .mixin-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .selected-value {
+    color: var(--theme-content-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/plugin.ts b/plugins/task-resources/src/plugin.ts
index 88ef8abd842..ab8be834d26 100644
--- a/plugins/task-resources/src/plugin.ts
+++ b/plugins/task-resources/src/plugin.ts
@@ -89,7 +89,10 @@ export default mergeIds(taskId, task, {
     RenameStatus: '' as IntlString,
     UpdateTasksStatusRequest: '' as IntlString,
     TaskTypes: '' as IntlString,
-    Collections: '' as IntlString
+    Collections: '' as IntlString,
+    BaseMixin: '' as IntlString,
+    BaseMixinDescription: '' as IntlString,
+    NoBaseMixin: '' as IntlString
   },
   status: {
     AssigneeRequired: '' as IntlString
diff --git a/plugins/task/src/index.ts b/plugins/task/src/index.ts
index 412161345ce..547bc2b4e73 100644
--- a/plugins/task/src/index.ts
+++ b/plugins/task/src/index.ts
@@ -120,6 +120,9 @@ export interface TaskType extends Doc, IconProps {
   // Specify if task is allowed to be used as subtask of following tasks.
   allowedAsChildOf?: Ref<TaskType>[]
 
+  // Existing mixin to inherit attributes from (optional)
+  baseMixin?: Ref<Mixin<Task>>
+
   ofClass: Ref<Class<Task>> // Base class for task
   targetClass: Ref<Class<Task>> // Class or Mixin mixin to hold all user defined attributes.
 
diff --git a/plugins/task/src/utils.ts b/plugins/task/src/utils.ts
index 69f43946385..f88cf3a83d3 100644
--- a/plugins/task/src/utils.ts
+++ b/plugins/task/src/utils.ts
@@ -21,6 +21,7 @@ import core, {
   DocumentQuery,
   Hierarchy,
   IdMap,
+  Mixin,
   Ref,
   Status,
   TxOperations,
@@ -330,11 +331,14 @@ async function createTaskTypes (
       const targetClassId = `${taskId}:type:mixin` as Ref<Class<Task>>
       tdata.targetClass = targetClassId
 
+      // Use baseMixin if provided, otherwise extend ofClass directly
+      const extendsClass = data.baseMixin ?? data.ofClass
+
       await client.createDoc(
         core.class.Mixin,
         core.space.Model,
         {
-          extends: data.ofClass,
+          extends: extendsClass,
           kind: ClassifierKind.MIXIN,
           label: ofClassClass.label,
           icon: ofClassClass.icon
@@ -353,3 +357,17 @@ async function createTaskTypes (
   }
   return hasUpdates
 }
+
+/**
+ * @public
+ * Validates that a baseMixin is compatible with the ofClass hierarchy.
+ * Returns true if baseMixin is undefined or if it derives from ofClass.
+ */
+export function validateMixinHierarchy (
+  hierarchy: Hierarchy,
+  baseMixin: Ref<Mixin<Task>> | undefined,
+  ofClass: Ref<Class<Task>>
+): boolean {
+  if (baseMixin === undefined) return true
+  return hierarchy.isDerived(baseMixin, ofClass)
+}

From c5450c4fa7fee43c8c0cd060cb5de52185ba0814 Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 11:09:19 -0700
Subject: [PATCH 2/7] feat(task): integrate MixinSelector into CreateTaskType
 UI

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 .../components/taskTypes/CreateTaskType.svelte   | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
index 9d7dfa4844c..dd5d2aac72e 100644
--- a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
+++ b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
@@ -28,6 +28,7 @@
   import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu } from '@hcengineering/ui'
   import task from '../../plugin'
   import TaskTypeKindEditor from './TaskTypeKindEditor.svelte'
+  import MixinSelector from './MixinSelector.svelte'
   import { clearSettingsStore } from '@hcengineering/setting-resources'
 
   const client = getClient()
@@ -68,6 +69,8 @@
   let { kind, name, targetClass, statusCategories, statuses, allowedAsChildOf } =
     taskType !== undefined ? { ...taskType } : { ...defaultTaskType(type) }
 
+  let baseMixin = taskType?.baseMixin
+
   function findStatusClass (_class: Ref<Class<Task>>): Ref<Class<Status>> | undefined {
     const h = getClient().getHierarchy()
     const attrs = h.getAllAttributes(_class)
@@ -98,7 +101,8 @@
       allowedAsChildOf,
       statusClass: findStatusClass(ofClass) ?? core.class.Status,
       parent: type._id,
-      icon: descr.icon
+      icon: descr.icon,
+      baseMixin
     }
 
     if (taskType === undefined && descr.statusCategoriesFunc !== undefined) {
@@ -136,8 +140,10 @@
     } else {
       const ofClassClass = client.getHierarchy().getClass(ofClass)
       // Create target class for custom field.
+      // Use baseMixin if provided, otherwise use ofClass
+      const extendsClass = baseMixin ?? ofClass
       _taskType.targetClass = await client.createDoc(core.class.Class, core.space.Model, {
-        extends: ofClass,
+        extends: extendsClass,
         kind: ClassifierKind.MIXIN,
         label: getEmbeddedLabel(name),
         icon: ofClassClass.icon
@@ -181,6 +187,12 @@
       </span>
       <TaskTypeKindEditor bind:kind />
     </div>
+    <div class="hulyModal-content__settingsSet-line">
+      <MixinSelector
+        baseClass={taskTypeDescriptor?.baseClass ?? task.class.Task}
+        bind:value={baseMixin}
+      />
+    </div>
     {#if taskTypeDescriptors.length > 1}
       <div class="hulyModal-content__settingsSet-line">
         <span class="label">

From 6fa4c2ccd7574b2971722fe70b1f3ad8985ba4a8 Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 11:21:38 -0700
Subject: [PATCH 3/7] feat(task): query existing TaskTypes for inheritance
 selector

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 plugins/task-assets/lang/en.json              |  4 +-
 .../components/taskTypes/MixinSelector.svelte | 63 +++++++++++--------
 2 files changed, 39 insertions(+), 28 deletions(-)

diff --git a/plugins/task-assets/lang/en.json b/plugins/task-assets/lang/en.json
index ea10c4b4a78..c5c4ea53682 100644
--- a/plugins/task-assets/lang/en.json
+++ b/plugins/task-assets/lang/en.json
@@ -79,8 +79,8 @@
     "StatusChange": "Status changed",
     "TaskCreated": "Task created",
     "TaskType": "Task type",
-    "BaseMixin": "Base Mixin",
-    "BaseMixinDescription": "Inherit attributes from an existing mixin",
+    "BaseMixin": "Inherit from",
+    "BaseMixinDescription": "Inherit attributes from an existing task type",
     "NoBaseMixin": "None (create new)",
     "ManageProjects": "Project types",
     "Export": "Export",
diff --git a/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
index 4be3c0ca0a2..9532bd9bb98 100644
--- a/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
+++ b/plugins/task-resources/src/components/taskTypes/MixinSelector.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
   import { Class, Mixin, Ref } from '@hcengineering/core'
-  import { Task } from '@hcengineering/task'
+  import task, { Task, TaskType } from '@hcengineering/task'
   import { ButtonMenu, Label } from '@hcengineering/ui'
   import { createEventDispatcher } from 'svelte'
-  import { getClient } from '@hcengineering/presentation'
+  import { createQuery, getClient } from '@hcengineering/presentation'
   import plugin from '../../plugin'
 
   export let baseClass: Ref<Class<Task>>
@@ -11,48 +11,55 @@
   export let readonly = false
   export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
   export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+  export let excludeTaskType: Ref<TaskType> | undefined = undefined
 
   const dispatch = createEventDispatcher()
   const client = getClient()
   const hierarchy = client.getHierarchy()
 
-  // Find all mixins that derive from baseClass
-  function getAvailableMixins (): Array<{ id: string; label: string }> {
-    const result: Array<{ id: string; label: string }> = [
-      { id: '', label: 'None (create new)' }
-    ]
+  let availableTaskTypes: TaskType[] = []
 
-    try {
-      const descendants = hierarchy.getDescendants(baseClass)
-      for (const descendant of descendants) {
-        const cls = hierarchy.getClass(descendant)
-        if (cls.kind === 'mixin' && descendant !== baseClass) {
-          result.push({
-            id: descendant as string,
-            label: cls.label ?? descendant
-          })
-        }
-      }
-    } catch (e) {
-      console.error('Error getting available mixins:', e)
-    }
+  // Query all TaskTypes that have a compatible ofClass
+  const taskTypeQuery = createQuery()
+  $: {
+    // Get all classes derived from baseClass to find compatible TaskTypes
+    const compatibleClasses = hierarchy.getDescendants(baseClass)
 
-    return result
+    taskTypeQuery.query(
+      task.class.TaskType,
+      { ofClass: { $in: compatibleClasses } },
+      (res) => {
+        // Filter out the current TaskType if editing
+        availableTaskTypes = excludeTaskType !== undefined
+          ? res.filter((tt: TaskType) => tt._id !== excludeTaskType)
+          : res
+      }
+    )
   }
 
+  // Build items list from TaskTypes
+  $: items = [
+    { id: '', label: 'None (create new)' },
+    ...availableTaskTypes.map((tt) => ({
+      id: tt.targetClass as string,
+      label: tt.name
+    }))
+  ]
+
+  $: selected = items.find((it) => it.id === (value ?? ''))
+
   function handleSelect (evt: CustomEvent<string>): void {
     if (evt.detail !== undefined) {
       value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
       dispatch('change', value)
     }
   }
-
-  $: items = getAvailableMixins()
-  $: selected = items.find((it) => it.id === (value ?? ''))
 </script>
 
 <div class="mixin-selector">
-  <Label label={plugin.string.BaseMixin} />
+  <span class="label">
+    <Label label={plugin.string.BaseMixin} />
+  </span>
   {#if readonly}
     {#if selected}
       <span class="selected-value">{selected.label}</span>
@@ -79,4 +86,8 @@
   .selected-value {
     color: var(--theme-content-color);
   }
+
+  .label {
+    color: var(--theme-halfcontent-color);
+  }
 </style>

From 04d1c91bf1d74a9a6223794a986f813d581b06f9 Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 11:37:14 -0700
Subject: [PATCH 4/7] feat(task): add Clone Existing TaskTypes feature

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 plugins/task-assets/lang/en.json              |   5 +
 .../taskTypes/CreateTaskType.svelte           | 180 ++++++++++++++---
 .../taskTypes/LinkTaskTypeSelector.svelte     | 188 ++++++++++++++++++
 plugins/task-resources/src/plugin.ts          |   7 +-
 4 files changed, 346 insertions(+), 34 deletions(-)
 create mode 100644 plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte

diff --git a/plugins/task-assets/lang/en.json b/plugins/task-assets/lang/en.json
index c5c4ea53682..8b345751cef 100644
--- a/plugins/task-assets/lang/en.json
+++ b/plugins/task-assets/lang/en.json
@@ -82,6 +82,11 @@
     "BaseMixin": "Inherit from",
     "BaseMixinDescription": "Inherit attributes from an existing task type",
     "NoBaseMixin": "None (create new)",
+    "CreateNew": "Create new",
+    "CloneExisting": "Clone existing",
+    "CloneTaskTypes": "Clone",
+    "SelectTaskTypesToClone": "Select task types to clone",
+    "NoTaskTypesAvailable": "No task types available to clone",
     "ManageProjects": "Project types",
     "Export": "Export",
     "CreateProjectType": "Create project type",
diff --git a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
index dd5d2aac72e..fe742d507e7 100644
--- a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
+++ b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
@@ -25,10 +25,11 @@
     createState,
     findStatusAttr
   } from '@hcengineering/task'
-  import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu } from '@hcengineering/ui'
+  import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu, Toggle } from '@hcengineering/ui'
   import task from '../../plugin'
   import TaskTypeKindEditor from './TaskTypeKindEditor.svelte'
   import MixinSelector from './MixinSelector.svelte'
+  import LinkTaskTypeSelector from './LinkTaskTypeSelector.svelte'
   import { clearSettingsStore } from '@hcengineering/setting-resources'
 
   const client = getClient()
@@ -71,6 +72,10 @@
 
   let baseMixin = taskType?.baseMixin
 
+  // Mode: 'create' for new TaskType, 'clone' for cloning existing
+  let mode: 'create' | 'clone' = 'create'
+  let selectedTaskTypesToClone: Ref<TaskType>[] = []
+
   function findStatusClass (_class: Ref<Class<Task>>): Ref<Class<Status>> | undefined {
     const h = getClient().getHierarchy()
     const attrs = h.getAllAttributes(_class)
@@ -86,6 +91,12 @@
   async function save (): Promise<void> {
     if (type === undefined) return
 
+    // Clone mode: clone selected TaskTypes
+    if (mode === 'clone') {
+      await cloneSelectedTaskTypes()
+      return
+    }
+
     const descr = taskTypeDescriptors.find((it) => it._id === taskTypeDescriptor._id)
     if (descr === undefined) return
 
@@ -164,55 +175,158 @@
     icon: it.icon,
     label: it.name
   }))
+
+  async function cloneSelectedTaskTypes (): Promise<void> {
+    if (selectedTaskTypesToClone.length === 0) return
+
+    // Fetch the selected TaskTypes
+    const sourceTaskTypes = await client.findAll(task.class.TaskType, {
+      _id: { $in: selectedTaskTypesToClone }
+    })
+
+    for (const source of sourceTaskTypes) {
+      const newTaskTypeId: Ref<TaskType> = generateId()
+
+      // Create new targetClass (mixin) that extends the source's targetClass
+      const sourceClass = client.getHierarchy().getClass(source.ofClass)
+      const newTargetClass = await client.createDoc(core.class.Class, core.space.Model, {
+        extends: source.targetClass, // Inherit from source's mixin
+        kind: ClassifierKind.MIXIN,
+        label: getEmbeddedLabel(source.name),
+        icon: sourceClass.icon
+      })
+
+      // Clone statuses for this TaskType
+      const clonedStatuses: Ref<Status>[] = []
+      const statusAttr = findStatusAttr(client.getHierarchy(), source.ofClass) ??
+        client.getHierarchy().getAttribute(task.class.Task, 'status')
+
+      for (const statusId of source.statuses) {
+        const originalStatus = await client.findOne(core.class.Status, { _id: statusId })
+        if (originalStatus !== undefined) {
+          const newStatus = await createState(client, source.statusClass, {
+            name: originalStatus.name,
+            ofAttribute: statusAttr._id,
+            category: originalStatus.category
+          })
+          clonedStatuses.push(newStatus)
+
+          // Add to ProjectType statuses
+          if (type.statuses.find((it) => it._id === newStatus) === undefined) {
+            await client.update(type, {
+              $push: { statuses: { _id: newStatus, taskType: newTaskTypeId } }
+            })
+          }
+        }
+      }
+
+      // Create the cloned TaskType
+      const clonedTaskType: Data<TaskType> = {
+        name: source.name,
+        kind: source.kind,
+        parent: type._id,
+        descriptor: source.descriptor,
+        ofClass: source.ofClass,
+        targetClass: newTargetClass,
+        statusCategories: source.statusCategories,
+        statuses: clonedStatuses,
+        statusClass: source.statusClass,
+        allowedAsChildOf: source.allowedAsChildOf,
+        baseMixin: source.targetClass, // Point to source's targetClass for inheritance
+        icon: source.icon,
+        color: source.color
+      }
+
+      await client.createDoc(task.class.TaskType, core.space.Model, clonedTaskType, newTaskTypeId)
+
+      // Add to ProjectType tasks array
+      if (!type.tasks.includes(newTaskTypeId)) {
+        await client.update(type, { $push: { tasks: newTaskTypeId } })
+      }
+    }
+
+    clearSettingsStore()
+  }
+
+  $: canSave = mode === 'create' ? name.trim().length > 0 : selectedTaskTypesToClone.length > 0
 </script>
 
 <Modal
   label={task.string.TaskType}
   type={'type-aside'}
   okAction={save}
-  canSave
-  okLabel={taskType !== undefined ? presentation.string.Save : presentation.string.Create}
+  canSave={canSave}
+  okLabel={mode === 'clone' ? task.string.CloneTaskTypes : (taskType !== undefined ? presentation.string.Save : presentation.string.Create)}
   on:changeContent
   onCancel={() => {
     clearSettingsStore()
   }}
 >
-  <div class="hulyModal-content__titleGroup">
-    <ModernEditbox bind:value={name} label={task.string.TaskName} size={'large'} kind={'ghost'} autoFocus />
-  </div>
-  <div class="hulyModal-content__settingsSet">
-    <div class="hulyModal-content__settingsSet-line">
-      <span class="label">
-        <Label label={task.string.TaskType} />
-      </span>
-      <TaskTypeKindEditor bind:kind />
+  <!-- Mode Toggle -->
+  {#if taskType === undefined}
+    <div class="hulyModal-content__settingsSet">
+      <div class="hulyModal-content__settingsSet-line mode-toggle">
+        <span class="label">
+          <Label label={task.string.CreateNew} />
+        </span>
+        <Toggle
+          on={mode === 'clone'}
+          on:change={() => { mode = mode === 'create' ? 'clone' : 'create' }}
+        />
+        <span class="label">
+          <Label label={task.string.CloneExisting} />
+        </span>
+      </div>
     </div>
-    <div class="hulyModal-content__settingsSet-line">
-      <MixinSelector
-        baseClass={taskTypeDescriptor?.baseClass ?? task.class.Task}
-        bind:value={baseMixin}
+  {/if}
+
+  {#if mode === 'clone' && taskType === undefined}
+    <!-- Clone Mode: Select existing TaskTypes -->
+    <div class="hulyModal-content__settingsSet">
+      <LinkTaskTypeSelector
+        currentProjectType={type._id}
+        bind:selectedTaskTypes={selectedTaskTypesToClone}
       />
     </div>
-    {#if taskTypeDescriptors.length > 1}
+  {:else}
+    <!-- Create Mode: Original form -->
+    <div class="hulyModal-content__titleGroup">
+      <ModernEditbox bind:value={name} label={task.string.TaskName} size={'large'} kind={'ghost'} autoFocus />
+    </div>
+    <div class="hulyModal-content__settingsSet">
       <div class="hulyModal-content__settingsSet-line">
         <span class="label">
-          <Label label={task.string.Type} />
+          <Label label={task.string.TaskType} />
         </span>
-        <ButtonMenu
-          selected={taskTypeDescriptor._id}
-          items={descriptorItems}
-          icon={taskTypeDescriptor.icon}
-          label={taskTypeDescriptor.name}
-          kind={'secondary'}
-          size={'large'}
-          on:selected={(evt) => {
-            if (evt.detail != null) {
-              const tt = taskTypeDescriptors.find((tt) => tt._id === evt.detail)
-              if (tt) taskTypeDescriptor = tt
-            }
-          }}
+        <TaskTypeKindEditor bind:kind />
+      </div>
+      <div class="hulyModal-content__settingsSet-line">
+        <MixinSelector
+          baseClass={taskTypeDescriptor?.baseClass ?? task.class.Task}
+          bind:value={baseMixin}
         />
       </div>
-    {/if}
-  </div>
+      {#if taskTypeDescriptors.length > 1}
+        <div class="hulyModal-content__settingsSet-line">
+          <span class="label">
+            <Label label={task.string.Type} />
+          </span>
+          <ButtonMenu
+            selected={taskTypeDescriptor._id}
+            items={descriptorItems}
+            icon={taskTypeDescriptor.icon}
+            label={taskTypeDescriptor.name}
+            kind={'secondary'}
+            size={'large'}
+            on:selected={(evt) => {
+              if (evt.detail != null) {
+                const tt = taskTypeDescriptors.find((tt) => tt._id === evt.detail)
+                if (tt) taskTypeDescriptor = tt
+              }
+            }}
+          />
+        </div>
+      {/if}
+    </div>
+  {/if}
 </Modal>
diff --git a/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte b/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte
new file mode 100644
index 00000000000..5e64184ada5
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/LinkTaskTypeSelector.svelte
@@ -0,0 +1,188 @@
+<script lang="ts">
+  import { Ref, SortingOrder } from '@hcengineering/core'
+  import task, { ProjectType, TaskType } from '@hcengineering/task'
+  import { CheckBox, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { createQuery, getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let currentProjectType: Ref<ProjectType>
+  export let selectedTaskTypes: Ref<TaskType>[] = []
+
+  const dispatch = createEventDispatcher()
+  getClient() // Initialize client for queries
+
+  let allTaskTypes: TaskType[] = []
+  let projectTypes: ProjectType[] = []
+
+  // Query all TaskTypes except those already in current ProjectType
+  const taskTypeQuery = createQuery()
+  $: taskTypeQuery.query(
+    task.class.TaskType,
+    { parent: { $ne: currentProjectType } },
+    (res) => {
+      allTaskTypes = res
+    },
+    { sort: { name: SortingOrder.Ascending } }
+  )
+
+  // Query all ProjectTypes for grouping
+  const projectTypeQuery = createQuery()
+  $: projectTypeQuery.query(
+    task.class.ProjectType,
+    {},
+    (res) => {
+      projectTypes = res
+    }
+  )
+
+  // Group TaskTypes by their parent ProjectType
+  $: groupedTaskTypes = projectTypes
+    .filter((pt) => pt._id !== currentProjectType)
+    .map((pt) => ({
+      projectType: pt,
+      taskTypes: allTaskTypes.filter((tt) => tt.parent === pt._id)
+    }))
+    .filter((group) => group.taskTypes.length > 0)
+
+  function toggleSelection (taskTypeId: Ref<TaskType>): void {
+    const index = selectedTaskTypes.indexOf(taskTypeId)
+    if (index === -1) {
+      selectedTaskTypes = [...selectedTaskTypes, taskTypeId]
+    } else {
+      selectedTaskTypes = selectedTaskTypes.filter((id) => id !== taskTypeId)
+    }
+    dispatch('change', selectedTaskTypes)
+  }
+
+  function isSelected (taskTypeId: Ref<TaskType>): boolean {
+    return selectedTaskTypes.includes(taskTypeId)
+  }
+</script>
+
+<div class="link-selector">
+  <div class="header">
+    <Label label={plugin.string.SelectTaskTypesToClone} />
+  </div>
+
+  {#if groupedTaskTypes.length === 0}
+    <div class="empty">
+      <Label label={plugin.string.NoTaskTypesAvailable} />
+    </div>
+  {:else}
+    <div class="groups">
+      {#each groupedTaskTypes as group}
+        <div class="group">
+          <div class="group-header">
+            {group.projectType.name}
+          </div>
+          <div class="group-items">
+            {#each group.taskTypes as taskType}
+              <button
+                class="task-type-item"
+                class:selected={isSelected(taskType._id)}
+                on:click={() => { toggleSelection(taskType._id) }}
+              >
+                <CheckBox checked={isSelected(taskType._id)} />
+                <span class="name">{taskType.name}</span>
+                <span class="kind">({taskType.kind})</span>
+              </button>
+            {/each}
+          </div>
+        </div>
+      {/each}
+    </div>
+  {/if}
+
+  {#if selectedTaskTypes.length > 0}
+    <div class="selection-count">
+      {selectedTaskTypes.length} selected
+    </div>
+  {/if}
+</div>
+
+<style lang="scss">
+  .link-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    max-height: 400px;
+    overflow-y: auto;
+  }
+
+  .header {
+    font-weight: 500;
+    color: var(--theme-content-color);
+  }
+
+  .empty {
+    color: var(--theme-halfcontent-color);
+    padding: 1rem;
+    text-align: center;
+  }
+
+  .groups {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .group {
+    border: 1px solid var(--theme-divider-color);
+    border-radius: 0.5rem;
+    overflow: hidden;
+  }
+
+  .group-header {
+    background: var(--theme-bg-accent-color);
+    padding: 0.5rem 1rem;
+    font-weight: 500;
+    font-size: 0.875rem;
+    color: var(--theme-halfcontent-color);
+  }
+
+  .group-items {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .task-type-item {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    text-align: left;
+    width: 100%;
+    transition: background-color 0.15s;
+
+    &:hover {
+      background: var(--theme-bg-accent-hover);
+    }
+
+    &.selected {
+      background: var(--theme-bg-accent-color);
+    }
+
+    .name {
+      flex: 1;
+      color: var(--theme-content-color);
+    }
+
+    .kind {
+      color: var(--theme-halfcontent-color);
+      font-size: 0.875rem;
+    }
+  }
+
+  .selection-count {
+    padding: 0.5rem;
+    text-align: center;
+    background: var(--theme-bg-accent-color);
+    border-radius: 0.25rem;
+    font-size: 0.875rem;
+    color: var(--theme-accent-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/plugin.ts b/plugins/task-resources/src/plugin.ts
index ab8be834d26..8ecdb5a2cd3 100644
--- a/plugins/task-resources/src/plugin.ts
+++ b/plugins/task-resources/src/plugin.ts
@@ -92,7 +92,12 @@ export default mergeIds(taskId, task, {
     Collections: '' as IntlString,
     BaseMixin: '' as IntlString,
     BaseMixinDescription: '' as IntlString,
-    NoBaseMixin: '' as IntlString
+    NoBaseMixin: '' as IntlString,
+    CreateNew: '' as IntlString,
+    CloneExisting: '' as IntlString,
+    CloneTaskTypes: '' as IntlString,
+    SelectTaskTypesToClone: '' as IntlString,
+    NoTaskTypesAvailable: '' as IntlString
   },
   status: {
     AssigneeRequired: '' as IntlString

From a33d3f56d058ea56781acaf5a613cff29dd04c1a Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 11:58:27 -0700
Subject: [PATCH 5/7] feat(task): add hierarchical class/mixin selector for
 TaskType inheritance

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 .../taskTypes/ClassMixinSelector.svelte       | 119 ++++++++++++++++++
 .../taskTypes/CreateTaskType.svelte           |   4 +-
 2 files changed, 121 insertions(+), 2 deletions(-)
 create mode 100644 plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte

diff --git a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
new file mode 100644
index 00000000000..33f4c2b3e24
--- /dev/null
+++ b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
@@ -0,0 +1,119 @@
+<script lang="ts">
+  import { Class, ClassifierKind, Doc, Mixin, Ref } from '@hcengineering/core'
+  import { Task } from '@hcengineering/task'
+  import { ButtonMenu, Label } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { getClient } from '@hcengineering/presentation'
+  import plugin from '../../plugin'
+
+  export let baseClass: Ref<Class<Task>>
+  export let value: Ref<Mixin<Task>> | undefined = undefined
+  export let readonly = false
+  export let buttonKind: 'primary' | 'secondary' | 'tertiary' | 'negative' = 'secondary'
+  export let buttonSize: 'large' | 'medium' | 'small' = 'large'
+
+  const dispatch = createEventDispatcher()
+  const client = getClient()
+  const hierarchy = client.getHierarchy()
+
+  interface MixinItem {
+    id: string
+    label: string
+    level: number
+    _class: Ref<Class<Doc>>
+  }
+
+  function buildMixinHierarchy (rootClass: Ref<Class<Doc>>, level: number = 0): MixinItem[] {
+    const result: MixinItem[] = []
+    const descendants = hierarchy.getDescendants(rootClass)
+
+    for (const desc of descendants) {
+      try {
+        const cls = hierarchy.getClass(desc)
+        // Only include direct children (extends === rootClass) and mixins
+        if (cls.extends === rootClass && cls.kind === ClassifierKind.MIXIN && cls.label !== undefined) {
+          // Get the label string
+          let labelStr = ''
+          try {
+            const labelValue = client.getModel().findAllSync(cls._class, { _id: cls._id })[0]
+            labelStr = (labelValue as any)?.label ?? cls._id.split(':').pop() ?? cls._id
+          } catch {
+            labelStr = cls._id.split(':').pop() ?? cls._id
+          }
+
+          result.push({
+            id: cls._id,
+            label: '  '.repeat(level) + labelStr,
+            level,
+            _class: cls._id
+          })
+
+          // Recursively add children
+          const children = buildMixinHierarchy(cls._id, level + 1)
+          result.push(...children)
+        }
+      } catch {
+        // Skip invalid classes
+      }
+    }
+
+    return result
+  }
+
+  // Build the hierarchical list of mixins
+  $: mixinItems = buildMixinHierarchy(baseClass)
+
+  // Build items for ButtonMenu
+  $: items = [
+    { id: '', label: 'None (create new)' },
+    ...mixinItems.map((m) => ({
+      id: m.id,
+      label: m.label
+    }))
+  ]
+
+  $: selected = items.find((it) => it.id === (value ?? ''))
+
+  function handleSelect (evt: CustomEvent<string>): void {
+    if (evt.detail !== undefined) {
+      value = evt.detail === '' ? undefined : (evt.detail as Ref<Mixin<Task>>)
+      dispatch('change', value)
+    }
+  }
+</script>
+
+<div class="mixin-selector">
+  <span class="label">
+    <Label label={plugin.string.BaseMixin} />
+  </span>
+  {#if readonly}
+    {#if selected}
+      <span class="selected-value">{selected.label}</span>
+    {/if}
+  {:else}
+    <ButtonMenu
+      selected={value ?? ''}
+      {items}
+      label={selected?.label ?? plugin.string.NoBaseMixin}
+      kind={buttonKind}
+      size={buttonSize}
+      on:selected={handleSelect}
+    />
+  {/if}
+</div>
+
+<style lang="scss">
+  .mixin-selector {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .selected-value {
+    color: var(--theme-content-color);
+  }
+
+  .label {
+    color: var(--theme-halfcontent-color);
+  }
+</style>
diff --git a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
index fe742d507e7..5289cc42bfe 100644
--- a/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
+++ b/plugins/task-resources/src/components/taskTypes/CreateTaskType.svelte
@@ -28,7 +28,7 @@
   import { DropdownIntlItem, Modal, ModernEditbox, Label, ButtonMenu, Toggle } from '@hcengineering/ui'
   import task from '../../plugin'
   import TaskTypeKindEditor from './TaskTypeKindEditor.svelte'
-  import MixinSelector from './MixinSelector.svelte'
+  import ClassMixinSelector from './ClassMixinSelector.svelte'
   import LinkTaskTypeSelector from './LinkTaskTypeSelector.svelte'
   import { clearSettingsStore } from '@hcengineering/setting-resources'
 
@@ -301,7 +301,7 @@
         <TaskTypeKindEditor bind:kind />
       </div>
       <div class="hulyModal-content__settingsSet-line">
-        <MixinSelector
+        <ClassMixinSelector
           baseClass={taskTypeDescriptor?.baseClass ?? task.class.Task}
           bind:value={baseMixin}
         />

From 035eb08a2a24b4346231f4136a7cd813690051d6 Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 13:00:41 -0700
Subject: [PATCH 6/7] fix(task): use TaskType names for readable labels in
 ClassMixinSelector

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 .../taskTypes/ClassMixinSelector.svelte       | 96 ++++++++++++-------
 1 file changed, 63 insertions(+), 33 deletions(-)

diff --git a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
index 33f4c2b3e24..cf8254b04a9 100644
--- a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
+++ b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
-  import { Class, ClassifierKind, Doc, Mixin, Ref } from '@hcengineering/core'
-  import { Task } from '@hcengineering/task'
+  import { Class, Mixin, Ref, SortingOrder } from '@hcengineering/core'
+  import task, { Task, TaskType } from '@hcengineering/task'
   import { ButtonMenu, Label } from '@hcengineering/ui'
   import { createEventDispatcher } from 'svelte'
-  import { getClient } from '@hcengineering/presentation'
+  import { createQuery, getClient } from '@hcengineering/presentation'
   import plugin from '../../plugin'
 
   export let baseClass: Ref<Class<Task>>
@@ -19,49 +19,79 @@
   interface MixinItem {
     id: string
     label: string
-    level: number
-    _class: Ref<Class<Doc>>
+    targetClass: Ref<Mixin<Task>>
+    parentMixin: Ref<Mixin<Task>> | undefined
   }
 
-  function buildMixinHierarchy (rootClass: Ref<Class<Doc>>, level: number = 0): MixinItem[] {
+  let allTaskTypes: TaskType[] = []
+
+  // Query all TaskTypes to get their names and targetClass mixins
+  const taskTypeQuery = createQuery()
+  $: {
+    const compatibleClasses = hierarchy.getDescendants(baseClass)
+    taskTypeQuery.query(
+      task.class.TaskType,
+      { ofClass: { $in: compatibleClasses } },
+      (res) => {
+        allTaskTypes = res
+      },
+      { sort: { name: SortingOrder.Ascending } }
+    )
+  }
+
+  // Build hierarchical items from TaskTypes
+  // Each TaskType has a targetClass mixin and optionally a baseMixin (parent)
+  function buildItems (taskTypes: TaskType[]): MixinItem[] {
     const result: MixinItem[] = []
-    const descendants = hierarchy.getDescendants(rootClass)
-
-    for (const desc of descendants) {
-      try {
-        const cls = hierarchy.getClass(desc)
-        // Only include direct children (extends === rootClass) and mixins
-        if (cls.extends === rootClass && cls.kind === ClassifierKind.MIXIN && cls.label !== undefined) {
-          // Get the label string
-          let labelStr = ''
-          try {
-            const labelValue = client.getModel().findAllSync(cls._class, { _id: cls._id })[0]
-            labelStr = (labelValue as any)?.label ?? cls._id.split(':').pop() ?? cls._id
-          } catch {
-            labelStr = cls._id.split(':').pop() ?? cls._id
-          }
 
+    // Create a map of targetClass -> TaskType for lookup
+    const targetClassToTaskType = new Map<string, TaskType>()
+    for (const tt of taskTypes) {
+      targetClassToTaskType.set(tt.targetClass as string, tt)
+    }
+
+    // Find root TaskTypes (those without baseMixin or with baseMixin that's not another TaskType's targetClass)
+    const rootTaskTypes = taskTypes.filter((tt) => {
+      if (tt.baseMixin === undefined) return true
+      return !targetClassToTaskType.has(tt.baseMixin as string)
+    })
+
+    // Add root items
+    for (const tt of rootTaskTypes) {
+      result.push({
+        id: tt.targetClass as string,
+        label: tt.name,
+        targetClass: tt.targetClass,
+        parentMixin: tt.baseMixin
+      })
+
+      // Find and add children (TaskTypes that have this targetClass as baseMixin)
+      const children = taskTypes.filter((child) => child.baseMixin === tt.targetClass)
+      for (const child of children) {
+        result.push({
+          id: child.targetClass as string,
+          label: '  ' + child.name,
+          targetClass: child.targetClass,
+          parentMixin: child.baseMixin
+        })
+
+        // Add grandchildren
+        const grandchildren = taskTypes.filter((gc) => gc.baseMixin === child.targetClass)
+        for (const gc of grandchildren) {
           result.push({
-            id: cls._id,
-            label: '  '.repeat(level) + labelStr,
-            level,
-            _class: cls._id
+            id: gc.targetClass as string,
+            label: '    ' + gc.name,
+            targetClass: gc.targetClass,
+            parentMixin: gc.baseMixin
           })
-
-          // Recursively add children
-          const children = buildMixinHierarchy(cls._id, level + 1)
-          result.push(...children)
         }
-      } catch {
-        // Skip invalid classes
       }
     }
 
     return result
   }
 
-  // Build the hierarchical list of mixins
-  $: mixinItems = buildMixinHierarchy(baseClass)
+  $: mixinItems = buildItems(allTaskTypes)
 
   // Build items for ButtonMenu
   $: items = [

From 7dc247e251256c6e3f476ff5cf32b8017c5976f7 Mon Sep 17 00:00:00 2001
From: Luis Rosas <luisrosasx@users.noreply.github.com>
Date: Mon, 9 Feb 2026 13:09:03 -0700
Subject: [PATCH 7/7] fix(task): improve ClassMixinSelector with tree hierarchy
 formatting

Signed-off-by: Luis Rosas <luisrosasx@users.noreply.github.com>
---
 .../taskTypes/ClassMixinSelector.svelte       | 60 +++++++++----------
 1 file changed, 28 insertions(+), 32 deletions(-)

diff --git a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
index cf8254b04a9..209ec822f29 100644
--- a/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
+++ b/plugins/task-resources/src/components/taskTypes/ClassMixinSelector.svelte
@@ -39,8 +39,7 @@
     )
   }
 
-  // Build hierarchical items from TaskTypes
-  // Each TaskType has a targetClass mixin and optionally a baseMixin (parent)
+  // Build hierarchical items from TaskTypes using recursive tree structure
   function buildItems (taskTypes: TaskType[]): MixinItem[] {
     const result: MixinItem[] = []
 
@@ -50,44 +49,41 @@
       targetClassToTaskType.set(tt.targetClass as string, tt)
     }
 
-    // Find root TaskTypes (those without baseMixin or with baseMixin that's not another TaskType's targetClass)
-    const rootTaskTypes = taskTypes.filter((tt) => {
-      if (tt.baseMixin === undefined) return true
-      return !targetClassToTaskType.has(tt.baseMixin as string)
-    })
-
-    // Add root items
-    for (const tt of rootTaskTypes) {
-      result.push({
-        id: tt.targetClass as string,
-        label: tt.name,
-        targetClass: tt.targetClass,
-        parentMixin: tt.baseMixin
+    // Find children of a given targetClass
+    function getChildren (parentTargetClass: Ref<Mixin<Task>> | undefined): TaskType[] {
+      return taskTypes.filter((tt) => tt.baseMixin === parentTargetClass)
+    }
+
+    // Get root TaskTypes (those without baseMixin or with baseMixin not in our set)
+    function getRoots (): TaskType[] {
+      return taskTypes.filter((tt) => {
+        if (tt.baseMixin === undefined) return true
+        return !targetClassToTaskType.has(tt.baseMixin as string)
       })
+    }
+
+    // Recursively add items with proper indentation
+    function addItems (parent: Ref<Mixin<Task>> | undefined, level: number, prefix: string): void {
+      const children = parent === undefined ? getRoots() : getChildren(parent)
+
+      for (let i = 0; i < children.length; i++) {
+        const tt = children[i]
+        const isLast = i === children.length - 1
+        const connector = level === 0 ? '' : (isLast ? '└─ ' : '├─ ')
+        const nextPrefix = level === 0 ? '' : (isLast ? '   ' : '│  ')
 
-      // Find and add children (TaskTypes that have this targetClass as baseMixin)
-      const children = taskTypes.filter((child) => child.baseMixin === tt.targetClass)
-      for (const child of children) {
         result.push({
-          id: child.targetClass as string,
-          label: '  ' + child.name,
-          targetClass: child.targetClass,
-          parentMixin: child.baseMixin
+          id: tt.targetClass as string,
+          label: prefix + connector + tt.name,
+          targetClass: tt.targetClass,
+          parentMixin: tt.baseMixin
         })
 
-        // Add grandchildren
-        const grandchildren = taskTypes.filter((gc) => gc.baseMixin === child.targetClass)
-        for (const gc of grandchildren) {
-          result.push({
-            id: gc.targetClass as string,
-            label: '    ' + gc.name,
-            targetClass: gc.targetClass,
-            parentMixin: gc.baseMixin
-          })
-        }
+        addItems(tt.targetClass, level + 1, prefix + nextPrefix)
       }
     }
 
+    addItems(undefined, 0, '')
     return result
   }