From bbc306e371552fedfa0383aab88c4846a8b44859 Mon Sep 17 00:00:00 2001
From: Artyom Savchenko <armisav@gmail.com>
Date: Thu, 4 Sep 2025 12:07:35 +0700
Subject: [PATCH 1/8] Add filter to Home (#9774)

Signed-off-by: Artem Savchenko <armisav@gmail.com>
---
 .../card-resources/src/components/Home.svelte  | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/plugins/card-resources/src/components/Home.svelte b/plugins/card-resources/src/components/Home.svelte
index 99e0d8dde4..e75a91bc1a 100644
--- a/plugins/card-resources/src/components/Home.svelte
+++ b/plugins/card-resources/src/components/Home.svelte
@@ -25,6 +25,7 @@
     Loading,
     showPopup
   } from '@hcengineering/ui'
+  import { FilterBar, FilterButton } from '@hcengineering/view-resources'
   import { createEventDispatcher } from 'svelte'
 
   import HomeCardPresenter from './HomeCardPresenter.svelte'
@@ -42,12 +43,13 @@
   let cards: Card[] = []
   let total = -1
   let isLoading = true
-  let searchQuery: string = ''
+  let search: string = ''
 
-  $: query = searchQuery != null && searchQuery.trim() !== '' ? { $search: searchQuery } : {}
+  $: searchQuery = search != null && search.trim() !== '' ? { $search: search } : {}
+  $: resultQuery = { ...searchQuery }
   $: cardsQuery.query(
     card.class.Card,
-    query,
+    resultQuery,
     (res) => {
       cards = res
       total = res.total
@@ -131,10 +133,18 @@
         <Label label={card.string.Home} />
       </div>
       <div class="flex flex-gap-2">
-        <SearchInput bind:value={searchQuery} collapsed />
+        <SearchInput bind:value={search} collapsed />
+        <FilterButton _class={card.class.Card} />
+        <div class="hulyHeader-divider" />
         <ModernButton icon={IconSettings} on:click={onSettings} size="small" iconSize="small" kind="tertiary" />
       </div>
     </div>
+    <FilterBar
+      _class={card.class.Card}
+      query={searchQuery}
+      space={undefined}
+      on:change={({ detail }) => (resultQuery = detail)}
+    />
     <div class="create-card">
       <ModernEditbox
         bind:value={title}

From 3b14b363c6416aab7750790069c20c24106da0fb Mon Sep 17 00:00:00 2001
From: Alexander Onnikov <aonnikov@hardcoreeng.com>
Date: Thu, 4 Sep 2025 12:12:18 +0700
Subject: [PATCH 2/8] fix: preview text files (#9773)

Signed-off-by: Alexander Onnikov <Alexander.Onnikov@xored.com>
---
 pods/preview/src/providers/doc.ts | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/pods/preview/src/providers/doc.ts b/pods/preview/src/providers/doc.ts
index 7b528137fd..ec02bb703a 100644
--- a/pods/preview/src/providers/doc.ts
+++ b/pods/preview/src/providers/doc.ts
@@ -39,6 +39,9 @@ const ODP_MIME_TYPE = 'application/vnd.oasis.opendocument.presentation'
 // RTF
 const RTF_MIME_TYPE_1 = 'application/rtf'
 const RTF_MIME_TYPE_2 = 'text/rtf'
+// JSON
+const JSON_MIME_TYPE = 'application/json'
+const YAML_MIME_TYPE = 'application/yaml'
 
 const extensions: Record<string, string> = {
   [DOCX_MIME_TYPE]: '.docx',
@@ -51,7 +54,9 @@ const extensions: Record<string, string> = {
   [RTF_MIME_TYPE_2]: '.rtf',
   [ODT_MIME_TYPE]: '.odt',
   [ODS_MIME_TYPE]: '.ods',
-  [ODP_MIME_TYPE]: '.odp'
+  [ODP_MIME_TYPE]: '.odp',
+  [JSON_MIME_TYPE]: '.json',
+  [YAML_MIME_TYPE]: '.yaml'
 }
 
 function getFileExtension (contentType: string): string {
@@ -67,7 +72,7 @@ export class DocProvider implements PreviewProvider {
 
   supports (contentType: string): boolean {
     const mimeType = contentType.split(';')[0].trim().toLowerCase()
-    return extensions[mimeType] !== undefined
+    return extensions[mimeType] !== undefined || contentType.startsWith('text/')
   }
 
   async image (ctx: MeasureContext, workspace: WorkspaceUuid, name: string, contentType: string): Promise<PreviewFile> {

From fd147586b71280d8c9e28c34aff04d2c298553dd Mon Sep 17 00:00:00 2001
From: Artyom Savchenko <armisav@gmail.com>
Date: Thu, 4 Sep 2025 15:15:19 +0700
Subject: [PATCH 3/8] Update card space icon (#9779)

Signed-off-by: Artem Savchenko <armisav@gmail.com>
---
 models/card/src/index.ts                                       | 2 +-
 plugins/card-assets/assets/icons.svg                           | 3 +++
 plugins/card-assets/src/index.ts                               | 3 ++-
 plugins/card-resources/src/components/CardPathPresenter.svelte | 2 +-
 .../src/components/navigator-next/NavigatorSpace.svelte        | 2 +-
 plugins/card/src/index.ts                                      | 3 ++-
 6 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/models/card/src/index.ts b/models/card/src/index.ts
index e123ef4e05..1bb40782f0 100644
--- a/models/card/src/index.ts
+++ b/models/card/src/index.ts
@@ -452,7 +452,7 @@ export function createModel (builder: Builder): void {
             label: core.string.Spaces,
             spaceClass: card.class.CardSpace,
             addSpaceLabel: core.string.Space,
-            icon: card.icon.Card,
+            icon: card.icon.Space,
             // intentionally left empty in order to make space presenter working
             specials: []
           }
diff --git a/plugins/card-assets/assets/icons.svg b/plugins/card-assets/assets/icons.svg
index 3887ba472e..644dd07da5 100644
--- a/plugins/card-assets/assets/icons.svg
+++ b/plugins/card-assets/assets/icons.svg
@@ -49,4 +49,7 @@
   <symbol id="home" viewBox="0 0 32 32">
       <path fill-rule="evenodd" clip-rule="evenodd" d="M15.2929 2.29302C15.6834 1.90249 16.3166 1.90249 16.7071 2.29302L29.7071 15.293C30.0976 15.6835 30.0976 16.3167 29.7071 16.7072C29.3166 17.0978 28.6834 17.0978 28.2929 16.7072L28 16.4143V26.0001C28 27.1047 27.1046 28.0001 26 28.0001H6C4.89543 28.0001 4 27.1047 4 26.0001V16.4143L3.70711 16.7072C3.31658 17.0978 2.68342 17.0978 2.29289 16.7072C1.90237 16.3167 1.90237 15.6835 2.29289 15.293L15.2929 2.29302ZM6 14.4143V26.0001H12V17.0001C12 16.4478 12.4477 16.0001 13 16.0001H19C19.5523 16.0001 20 16.4478 20 17.0001V26.0001H26V14.4143L16 4.41434L6 14.4143ZM18 26.0001V18.0001H14V26.0001H18Z" fill="currentColor"/>
   </symbol>
+  <symbol id="space" viewBox="0 0 32 32">
+    <path fill-rule="evenodd" clip-rule="evenodd" d="M2 9C2 6.23858 4.23858 4 7 4H10.6716C11.4672 4 12.2303 4.31607 12.7929 4.87868L15.6213 7.70711C15.8089 7.89464 16.0632 8 16.3284 8H25C27.7614 8 30 10.2386 30 13V23C30 25.7614 27.7614 28 25 28H7C4.23858 28 2 25.7614 2 23V9ZM7 6C5.34315 6 4 7.34315 4 9V23C4 24.6569 5.34315 26 7 26H25C26.6569 26 28 24.6569 28 23V13C28 11.3431 26.6569 10 25 10H16.3284C15.5328 10 14.7697 9.68393 14.2071 9.12132L11.3787 6.29289C11.1911 6.10536 10.9368 6 10.6716 6H7Z" fill="currentColor"/>
+  </symbol>
 </svg>
diff --git a/plugins/card-assets/src/index.ts b/plugins/card-assets/src/index.ts
index 1976676eda..5a3193780c 100644
--- a/plugins/card-assets/src/index.ts
+++ b/plugins/card-assets/src/index.ts
@@ -24,5 +24,6 @@ loadMetadata(card.icon, {
   File: `${icons}#file`,
   View: `${icons}#view`,
   Document: `${icons}#document`,
-  Home: `${icons}#home`
+  Home: `${icons}#home`,
+  Space: `${icons}#space`
 })
diff --git a/plugins/card-resources/src/components/CardPathPresenter.svelte b/plugins/card-resources/src/components/CardPathPresenter.svelte
index 00013c34c3..f277bf8334 100644
--- a/plugins/card-resources/src/components/CardPathPresenter.svelte
+++ b/plugins/card-resources/src/components/CardPathPresenter.svelte
@@ -30,7 +30,7 @@
 <div class="flex-presenter flex-gap-0-5">
   {#if displaySpace && card.$lookup?.space !== undefined}
     <div class="card-presenter">
-      <Icon icon={cardPlugin.icon.Card} size="small" />
+      <Icon icon={cardPlugin.icon.Space} size="small" />
       <span class="overflow-label max-w-40">
         {card.$lookup?.space.name}
       </span>
diff --git a/plugins/card-resources/src/components/navigator-next/NavigatorSpace.svelte b/plugins/card-resources/src/components/navigator-next/NavigatorSpace.svelte
index 29103030da..3eeaa8316f 100644
--- a/plugins/card-resources/src/components/navigator-next/NavigatorSpace.svelte
+++ b/plugins/card-resources/src/components/navigator-next/NavigatorSpace.svelte
@@ -39,7 +39,7 @@
 
 <TreeNode
   _id={space._id}
-  icon={cardPlugin.icon.Card}
+  icon={cardPlugin.icon.Space}
   title={space.name}
   type={'nested'}
   on:dragstart={(evt) => {
diff --git a/plugins/card/src/index.ts b/plugins/card/src/index.ts
index 92c8af3504..21c7699455 100644
--- a/plugins/card/src/index.ts
+++ b/plugins/card/src/index.ts
@@ -150,7 +150,8 @@ const cardPlugin = plugin(cardId, {
     File: '' as Asset,
     View: '' as Asset,
     Document: '' as Asset,
-    Home: '' as Asset
+    Home: '' as Asset,
+    Space: '' as Asset
   },
   extensions: {
     EditCardExtension: '' as ComponentExtensionId

From db9c52a1bd43a24d56aaa0076c888c785b3ad45f Mon Sep 17 00:00:00 2001
From: Alexander Onnikov <aonnikov@hardcoreeng.com>
Date: Thu, 4 Sep 2025 16:15:00 +0700
Subject: [PATCH 4/8] fix: support transcoding for attachment transactions
 (#9775)

Signed-off-by: Alexander Onnikov <Alexander.Onnikov@xored.com>
---
 pods/media/src/client.ts  |  8 ++++----
 pods/media/src/handler.ts | 19 ++++++++++++-------
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/pods/media/src/client.ts b/pods/media/src/client.ts
index f81684d9cf..268cca4c83 100644
--- a/pods/media/src/client.ts
+++ b/pods/media/src/client.ts
@@ -131,16 +131,16 @@ export class WorkspaceClient {
     const txOps = new TxOperations(this.client, core.account.System)
     await txOps.domainRequest('communication' as OperationDomain, {
       event: {
-        type: MessageEventType.BlobPatch,
+        type: MessageEventType.AttachmentPatch,
         cardId: result.source.cardId,
         messageId: result.source.messageId,
         operations: [
           {
             opcode: 'update',
-            blobs: [
+            attachments: [
               {
-                blobId: result.blobId,
-                metadata
+                id: result.blobId,
+                params: { metadata }
               }
             ]
           }
diff --git a/pods/media/src/handler.ts b/pods/media/src/handler.ts
index f6a29aeba2..137e5000a7 100644
--- a/pods/media/src/handler.ts
+++ b/pods/media/src/handler.ts
@@ -15,6 +15,7 @@
 
 import attachment, { type Attachment } from '@hcengineering/attachment'
 import { Event, MessageEventType } from '@hcengineering/communication-sdk-types'
+import { BlobAttachment } from '@hcengineering/communication-types'
 import drive, { type FileVersion } from '@hcengineering/drive'
 import core, {
   type Blob,
@@ -94,22 +95,26 @@ async function handleCommunicationTx (
   tx: TxDomainEvent<Event>,
   producer: PlatformQueueProducer<VideoTranscodeRequest>
 ): Promise<void> {
-  if (tx.domain === COMMUNICATION && tx.event.type === MessageEventType.BlobPatch) {
+  if (tx.domain === COMMUNICATION && tx.event.type === MessageEventType.AttachmentPatch) {
     const event = tx.event
     const source: BlobSource = {
       source: BlobSourceType.Message,
       cardId: event.cardId,
       messageId: event.messageId
     }
-    const blobs = event.operations
-      .filter((it) => it.opcode === 'attach' || it.opcode === 'set')
-      .flatMap((it) => it.blobs)
-    const messages: VideoTranscodeRequest[] = blobs.map(({ blobId, mimeType }) => ({
+
+    const attachments = event.operations
+      .filter((it) => it.opcode === 'add' || it.opcode === 'set')
+      .flatMap((it) => it.attachments)
+      .filter((it): it is BlobAttachment => 'blobId' in it.params)
+
+    const messages: VideoTranscodeRequest[] = attachments.map(({ params }) => ({
       workspaceUuid,
-      blobId,
-      contentType: mimeType,
+      blobId: params.blobId,
+      contentType: params.mimeType,
       source
     }))
+
     if (messages.length > 0) {
       await producer.send(ctx, workspaceUuid, messages)
     }

From c3902bb9aa021e37ffd7c0331da29ce0662a6238 Mon Sep 17 00:00:00 2001
From: Alexey Zinoviev <alexey.zinoviev@xored.com>
Date: Thu, 4 Sep 2025 16:16:18 +0700
Subject: [PATCH 5/8] UBERF-13485: Restore v6 from storage tool (#9777)

Signed-off-by: Alexey Zinoviev <alexey.zinoviev@xored.com>
---
 dev/tool/src/db.ts    | 233 +++++++++++++++++++++++++++++++++++++-----
 dev/tool/src/index.ts |  99 +++++++++++++++++-
 2 files changed, 306 insertions(+), 26 deletions(-)

diff --git a/dev/tool/src/db.ts b/dev/tool/src/db.ts
index 6f78a575c1..a32c875672 100644
--- a/dev/tool/src/db.ts
+++ b/dev/tool/src/db.ts
@@ -55,7 +55,7 @@ import { type MongoClient } from 'mongodb'
 import type postgres from 'postgres'
 import { type Row } from 'postgres'
 import { getToolToken } from './utils'
-import { createFileBackupStorage, restore } from '@hcengineering/server-backup'
+import { type BackupStorage, createFileBackupStorage, restore } from '@hcengineering/server-backup'
 import { buildStorageFromConfig, storageConfigFromEnv } from '@hcengineering/server-storage'
 import { getPlatformQueue } from '@hcengineering/kafka'
 import {
@@ -1167,7 +1167,8 @@ export async function migrateTrustedV6Accounts (
   accountDB: AccountDB,
   mongoDb: v6MongoAccountDB,
   dryRun: boolean,
-  skipWorkspaces: Set<string>
+  skipWorkspaces: Set<string>,
+  conflictSuffix?: string
 ): Promise<void> {
   // Mapping between <ObjectId, UUID>
   const accountsIdToUuid: Record<string, AccountUuid> = {}
@@ -1229,13 +1230,16 @@ export async function migrateTrustedV6Accounts (
       }
 
       try {
-        const workspaceUuid = await migrateWorkspace(
-          workspace,
-          accountDB,
-          accountsIdToUuid,
-          accountsEmailToUuid,
-          dryRun
-        )
+        const [workspaceUuid] =
+          (await migrateWorkspace(
+            workspace,
+            accountDB,
+            accountsIdToUuid,
+            accountsEmailToUuid,
+            dryRun,
+            'manual-creation',
+            conflictSuffix
+          )) ?? []
 
         if (workspaceUuid !== undefined) {
           workspacesIdToUuid[workspace.workspace] = workspaceUuid
@@ -1394,8 +1398,12 @@ async function migrateWorkspace (
   accountsIdToUuid: Record<string, AccountUuid>,
   accountsEmailToUuid: Record<string, AccountUuid>,
   dryRun = true,
-  forcedMode?: WorkspaceMode
-): Promise<WorkspaceUuid | undefined> {
+  forcedMode?: WorkspaceMode,
+  conflictSuffix?: string,
+  throwExisting?: boolean,
+  region?: string,
+  branding?: string
+): Promise<[WorkspaceUuid, string] | undefined> {
   if (workspace.workspaceUrl == null) {
     console.log('No workspace url, skipping', workspace.workspace)
     return
@@ -1406,14 +1414,19 @@ async function migrateWorkspace (
     console.log('No account found for workspace', workspace.workspace, 'created by', workspace.createdBy)
   }
 
-  const existingByUrl = await accountDB.workspace.findOne({ url: workspace.workspaceUrl })
+  let existingByUrl = await accountDB.workspace.findOne({ url: workspace.workspaceUrl })
   const existingByUuid = await accountDB.workspace.findOne({ uuid: workspace.uuid })
 
   let workspaceUuid: WorkspaceUuid
+  let url = workspace.workspaceUrl
 
   if (existingByUuid == null) {
-    let url = workspace.workspaceUrl
+    if (existingByUrl != null && (conflictSuffix ?? '') !== '') {
+      url = `${url}-${conflictSuffix}`
+      existingByUrl = await accountDB.workspace.findOne({ url })
+    }
     if (existingByUrl != null) {
+      console.log('Conflicting workspace url', url)
       // generate new url
       url = `${url}-${generateId('-')}`
       console.log('Generating new url', url)
@@ -1424,8 +1437,8 @@ async function migrateWorkspace (
       name: workspace.workspaceName,
       url,
       dataId: workspace.workspace,
-      branding: workspace.branding,
-      region: workspace.region,
+      branding: branding ?? workspace.branding,
+      region: region ?? workspace.region,
       createdBy,
       billingAccount: createdBy,
       createdOn: workspace.createdOn ?? Date.now()
@@ -1438,6 +1451,10 @@ async function migrateWorkspace (
       workspaceUuid = generateUuid() as WorkspaceUuid
     }
   } else {
+    if (throwExisting === true) {
+      throw new Error(`Workspace with the same uuid ${workspace.uuid} already exists`)
+    }
+
     workspaceUuid = existingByUuid.uuid
   }
 
@@ -1488,7 +1505,7 @@ async function migrateWorkspace (
     }
   }
 
-  return workspaceUuid
+  return [workspaceUuid, url]
 }
 
 export async function restoreFromv6All (
@@ -1581,14 +1598,15 @@ export async function restoreFromv6All (
 
       try {
         // Create active workspaces as archived until they are actually restored
-        const workspaceUuid = await migrateWorkspace(
-          workspace,
-          accountDB,
-          accountsIdToUuid,
-          accountsEmailToUuid,
-          false,
-          isActive ? 'archived' : undefined
-        )
+        const [workspaceUuid] =
+          (await migrateWorkspace(
+            workspace,
+            accountDB,
+            accountsIdToUuid,
+            accountsEmailToUuid,
+            false,
+            isActive ? 'archived' : undefined
+          )) ?? []
 
         if (workspaceUuid !== undefined) {
           workspacesIdToUuid[workspace.workspace] = workspaceUuid
@@ -1720,3 +1738,170 @@ export async function restoreFromv6All (
     ctx.error('Failed to restore v6 dump', { err })
   }
 }
+
+export async function restoreTrustedV6Workspace (
+  ctx: MeasureMetricsContext,
+  accountDB: AccountDB,
+  workspace: OldWorkspace,
+  accounts: OldAccount[],
+  invites: any[],
+  backupWsStorage: BackupStorage,
+  workspaceStorage: StorageAdapter,
+  txes: Tx[],
+  dbUrl: string,
+  opts?: {
+    conflictSuffix?: string
+    region?: string
+    branding?: string
+    force?: boolean
+  }
+): Promise<void> {
+  const { conflictSuffix, region, branding, force } = opts ?? {}
+  // Mapping between <ObjectId, UUID>
+  const accountsIdToUuid: Record<string, AccountUuid> = {}
+  // Mapping between <email, UUID>
+  const accountsEmailToUuid: Record<string, AccountUuid> = {}
+  let workspaceUuid: WorkspaceUuid | undefined
+  let newWorkspaceUrl: string | undefined
+
+  ctx.info('Restoring workspace accounts...')
+
+  let accountsProcessed = 0
+  for (const account of accounts) {
+    try {
+      const accountUuid = await migrateAccount(account, accountDB, false)
+      if (accountUuid == null) {
+        ctx.warn('Account not restored', account)
+        continue
+      }
+
+      accountsIdToUuid[account._id.toString()] = accountUuid
+      accountsEmailToUuid[account.email] = accountUuid
+
+      accountsProcessed++
+      if (accountsProcessed % 100 === 0) {
+        ctx.info('Processed accounts:', { accountsProcessed })
+      }
+    } catch (err: any) {
+      ctx.error('Failed to restore account', { _id: account._id, email: account.email, err })
+    }
+  }
+
+  ctx.info('Total accounts processed:', { accountsProcessed })
+
+  const oldMode = workspace.mode
+
+  try {
+    // Create workspace with manual-creation mode until it is restored
+    ;[workspaceUuid, newWorkspaceUrl] =
+      (await migrateWorkspace(
+        workspace,
+        accountDB,
+        accountsIdToUuid,
+        accountsEmailToUuid,
+        false,
+        'manual-creation',
+        conflictSuffix,
+        force !== true,
+        region,
+        branding
+      )) ?? []
+
+    if (workspaceUuid === undefined) {
+      ctx.error('Workspace uuid not set', { workspace: workspace.workspace })
+      throw new Error(`Workspace uuid not set ${workspace.workspace}`)
+    }
+
+    if (newWorkspaceUrl == null) {
+      ctx.error('Workspace url not set', { workspace: workspace.workspace })
+      throw new Error(`Workspace url not set ${workspace.workspace}`)
+    }
+
+    let invitesProcessed = 0
+    for (const invite of invites) {
+      try {
+        if (workspace.workspace !== invite.workspace.name) {
+          ctx.error(
+            `Invite workspace ${invite.workspace.name} doesn't match workspace being restored ${workspace.workspace}`
+          )
+          continue
+        }
+
+        const existing = await accountDB.invite.findOne({ migratedFrom: invite._id.toString() })
+        if (existing != null) {
+          continue
+        }
+
+        const inviteRecord = {
+          migratedFrom: invite._id.toString(),
+          workspaceUuid,
+          expiresOn: invite.exp,
+          emailPattern: invite.emailMask,
+          remainingUses: invite.limit,
+          role: invite.role ?? AccountRole.User
+        }
+
+        await accountDB.invite.insertOne(inviteRecord)
+
+        invitesProcessed++
+        if (invitesProcessed % 100 === 0) {
+          ctx.info('Processed invites:', { invitesProcessed })
+        }
+      } catch (err: any) {
+        ctx.error('Failed to restore invite', { _id: invite._id, err })
+      }
+    }
+
+    ctx.info('Total invites processed:', { invitesProcessed })
+
+    const dataId = workspace.workspace
+    const url = newWorkspaceUrl
+    const uuid = workspaceUuid
+
+    const wsIds = {
+      uuid,
+      dataId,
+      url
+    }
+
+    const queue = getPlatformQueue('tool', workspace.region)
+    const wsProducer = queue.getProducer<QueueWorkspaceMessage>(ctx, QueueTopic.Workspace)
+
+    await wsProducer.send(ctx, uuid, [workspaceEvents.restoring()])
+
+    let pipeline: Pipeline | undefined
+    try {
+      pipeline = await createBackupPipeline(ctx, dbUrl, txes, {
+        externalStorage: workspaceStorage,
+        usePassedCtx: true
+      })(ctx, wsIds, createEmptyBroadcastOps(), null)
+      if (pipeline === undefined) {
+        ctx.error('failed to restore, pipeline is undefined', { dataId })
+        return
+      }
+      await sendTransactorEvent(uuid, 'force-maintenance')
+
+      await restore(ctx, pipeline, wsIds, backupWsStorage, {
+        date: -1,
+        merge: false,
+        parallel: 1,
+        recheck: false
+      })
+
+      await sendTransactorEvent(uuid, 'force-close')
+
+      ctx.info('workspace restored', { dataId })
+      await wsProducer.send(ctx, uuid, [workspaceEvents.restored()])
+
+      await accountDB.workspaceStatus.update({ workspaceUuid: uuid }, { mode: oldMode })
+    } catch (err) {
+      ctx.error('failed to restore backup of the workspace', { url, dataId, err })
+    } finally {
+      await pipeline?.close()
+      await queue.shutdown()
+      await workspaceStorage?.close()
+    }
+  } catch (err: any) {
+    ctx.error('Failed to restore workspace', { url: workspace.workspaceUrl, workspace: workspace.workspace, err })
+  }
+}
diff --git a/dev/tool/src/index.ts b/dev/tool/src/index.ts
index 66bb096b89..1126d9886c 100644
--- a/dev/tool/src/index.ts
+++ b/dev/tool/src/index.ts
@@ -51,7 +51,11 @@ import {
 } from '@hcengineering/server-pipeline'
 import serverToken, { decodeToken, generateToken } from '@hcengineering/server-token'
 import { createWorkspace, upgradeWorkspace } from '@hcengineering/workspace-service'
-import { getMongoAccountDB } from '@hcengineering/account-service'
+import {
+  getMongoAccountDB,
+  type Account as OldAccount,
+  type Workspace as OldWorkspace
+} from '@hcengineering/account-service'
 
 import { faker } from '@faker-js/faker'
 import { getPlatformQueue } from '@hcengineering/kafka'
@@ -113,7 +117,8 @@ import {
   migrateMergedAccounts,
   migrateTrustedV6Accounts,
   moveAccountDbFromMongoToPG,
-  restoreFromv6All
+  restoreFromv6All,
+  restoreTrustedV6Workspace
 } from './db'
 import { performGithubAccountMigrations } from './github'
 import { performGmailAccountMigrations } from './gmail'
@@ -2750,6 +2755,96 @@ export function devTool (
       }, dbUrl)
     })
 
+  program
+    .command('restore-v6-from-storage <workspace> <accsRoot>')
+    .description('Restore a workspace from v6 backup storage with accounts info')
+    .option('-r, --region <region>', 'Region to restore workspace to')
+    .option('-b, --branding <branding>', 'Branding to restore workspace with', 'huly')
+    .option('-s, --suffix <suffix>', 'Url suffix if conflicting', 'bold')
+    .option('-f, --force', 'Force restore if the same uuid', false)
+    .action(async (workspace, accsRoot, cmd: { suffix: string, region: string, branding: string, force: boolean }) => {
+      const bucketName = process.env.BUCKET_NAME
+      if (bucketName === '' || bucketName == null) {
+        console.error('please provide bucket name env')
+        process.exit(1)
+      }
+
+      const backupStorageConfig = storageConfigFromEnv(process.env.BACKUP_STORAGE)
+      const backupStorageAdapter = createStorageFromConfig(backupStorageConfig.storages[0])
+      const backupIds = { uuid: bucketName as WorkspaceUuid, dataId: bucketName as WorkspaceDataId, url: '' }
+      const backupAccsStorage = await createStorageBackupStorage(toolCtx, backupStorageAdapter, backupIds, accsRoot)
+      const v6AccountsFile = 'account.accounts.json'
+      const v6WorkspacesFile = 'account.workspaces.json'
+      const v6InvitesFile = 'account.invites.json'
+
+      if (!(await backupAccsStorage.exists(v6AccountsFile))) {
+        toolCtx.error('file not present', { file: v6AccountsFile })
+        throw new Error(`${v6AccountsFile} should be present to restore`)
+      }
+      if (!(await backupAccsStorage.exists(v6WorkspacesFile))) {
+        toolCtx.error('file not present', { file: v6WorkspacesFile })
+        throw new Error(`${v6WorkspacesFile} should be present to restore`)
+      }
+      if (!(await backupAccsStorage.exists(v6InvitesFile))) {
+        toolCtx.error('file not present', { file: v6InvitesFile })
+        throw new Error(`${v6InvitesFile} should be present to restore`)
+      }
+
+      const v6Workspaces = JSON.parse((await backupAccsStorage.loadFile(v6WorkspacesFile)).toString()) as OldWorkspace[]
+      const v6Workspace = v6Workspaces.find((it) => it.workspace === workspace)
+
+      if (v6Workspace == null) {
+        toolCtx.error('workspace not found in the accounts backup', { workspace })
+        throw new Error(`workspace ${workspace} not found in the accounts backup`)
+      }
+
+      const uniqueWorkspaceAccounts = new Set((v6Workspace.accounts ?? []).map((it) => it.toString()))
+      const v6AccountsRaw = JSON.parse((await backupAccsStorage.loadFile(v6AccountsFile)).toString()) as any[]
+      const v6WorkspaceAccountsRaw = v6AccountsRaw.filter((acc) => uniqueWorkspaceAccounts.has(acc._id.toString()))
+
+      const v6WorkspaceAccounts: OldAccount[] = []
+      for (const rawAccount of v6WorkspaceAccountsRaw) {
+        const hashTypedArray = rawAccount.hash != null ? new Uint8Array(rawAccount.hash.data) : null
+        const saltTypedArray = new Uint8Array(rawAccount.salt.data)
+
+        v6WorkspaceAccounts.push({
+          ...rawAccount,
+          hash: hashTypedArray != null ? Buffer.from(hashTypedArray.buffer) : null,
+          salt: Buffer.from(saltTypedArray.buffer)
+        })
+      }
+
+      let v6Invites = JSON.parse((await backupAccsStorage.loadFile(v6InvitesFile)).toString()) as any[]
+      v6Invites = v6Invites.filter((invite: any) => invite.workspace.name === v6Workspace.workspace)
+
+      const { txes, dbUrl } = prepareTools()
+      const backupWsStorage = await createStorageBackupStorage(
+        toolCtx,
+        backupStorageAdapter,
+        backupIds,
+        v6Workspace.uuid ?? v6Workspace.workspace
+      )
+
+      const storageConfig = storageConfigFromEnv()
+      const workspaceStorage: StorageAdapter = buildStorageFromConfig(storageConfig)
+      const { suffix, region, branding, force } = cmd
+
+      await withAccountDatabase(async (pgDb) => {
+        await restoreTrustedV6Workspace(
+          toolCtx,
+          pgDb,
+          v6Workspace,
+          v6WorkspaceAccounts,
+          v6Invites,
+          backupWsStorage,
+          workspaceStorage,
+          txes,
+          dbUrl,
+          { conflictSuffix: suffix, region, branding, force }
+        )
+      }, dbUrl)
+    })
+
   extendProgram?.(program)
 
   process.on('unhandledRejection', (reason, promise) => {

From 016be620c7b1d4d2e679df3a9905834e9449f27b Mon Sep 17 00:00:00 2001
From: Artyom Savchenko <armisav@gmail.com>
Date: Thu, 4 Sep 2025 17:42:22 +0700
Subject: [PATCH 6/8] Migrate channel tags (#9780)

Signed-off-by: Artem Savchenko <armisav@gmail.com>
---
 models/chat/src/migration.ts | 35 ++++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/models/chat/src/migration.ts b/models/chat/src/migration.ts
index edf25d0eaa..b6ada596eb 100644
--- a/models/chat/src/migration.ts
+++ b/models/chat/src/migration.ts
@@ -14,7 +14,7 @@
 //
 
 import card, { type Card, cardId, DOMAIN_CARD, type MasterTag } from '@hcengineering/card'
-import type { Doc, Ref } from '@hcengineering/core'
+import core, { type Doc, type Ref, type Class, DOMAIN_MODEL_TX, type TxCreateDoc } from '@hcengineering/core'
 import {
   type MigrateOperation,
   type MigrationClient,
@@ -40,6 +40,11 @@ export const chatOperation: MigrateOperation = {
         state: 'migrate-parent-info',
         mode: 'upgrade',
         func: migrateParentInfo
+      },
+      {
+        state: 'migrate-channel-tags',
+        mode: 'upgrade',
+        func: migrateChannelTags
       }
     ])
   },
@@ -58,6 +63,34 @@ async function migrateChannelsToThreads (client: MigrationClient): Promise<void>
   )
 }
 
+async function migrateChannelTags (client: MigrationClient): Promise<void> {
+  const tagTxes = await client.find<TxCreateDoc<Class<Card>>>(DOMAIN_MODEL_TX, {
+    _class: core.class.TxCreateDoc,
+    objectClass: { $in: [card.class.MasterTag, card.class.Tag] }
+  })
+  const updates: {
+    filter: MigrationDocumentQuery<TxCreateDoc<Class<Card>>>
+    update: MigrateUpdate<TxCreateDoc<Class<Card>>>
+  }[] = []
+  for (const tagTx of tagTxes) {
+    if (tagTx.attributes.extends !== channelMasterTag) {
+      continue
+    }
+
+    updates.push({
+      filter: { _id: tagTx._id },
+      update: {
+        attributes: {
+          ...tagTx.attributes,
+          extends: chat.masterTag.Thread
+        }
+      }
+    })
+  }
+  await client.bulk(DOMAIN_MODEL_TX, updates)
+  client.logger.log('Migrated channel tags', { allTags: tagTxes.length, updatedTags: updates.length })
+}
+
 async function migrateParentInfo (client: MigrationClient, mode: MigrateMode): Promise<void> {
   await performParentInfoMigration(client, 1000)
 }

From 83313bd6799c6974144517540799026f1af8d073 Mon Sep 17 00:00:00 2001
From: Artyom Savchenko <armisav@gmail.com>
Date: Thu, 4 Sep 2025 18:57:05 +0700
Subject: [PATCH 7/8] Migrate card spaces (#9781)

Signed-off-by: Artem Savchenko <armisav@gmail.com>
---
 models/chat/src/migration.ts | 42 ++++++++++++++++++++++++++++++++++--
 1 file changed, 40 insertions(+), 2 deletions(-)

diff --git a/models/chat/src/migration.ts b/models/chat/src/migration.ts
index b6ada596eb..619687492c 100644
--- a/models/chat/src/migration.ts
+++ b/models/chat/src/migration.ts
@@ -13,8 +13,15 @@
 // limitations under the License.
 //
 
-import card, { type Card, cardId, DOMAIN_CARD, type MasterTag } from '@hcengineering/card'
-import core, { type Doc, type Ref, type Class, DOMAIN_MODEL_TX, type TxCreateDoc } from '@hcengineering/core'
+import card, { type Card, cardId, type CardSpace, DOMAIN_CARD, type MasterTag } from '@hcengineering/card'
+import core, {
+  type Doc,
+  type Ref,
+  type Class,
+  DOMAIN_MODEL_TX,
+  type TxCreateDoc,
+  DOMAIN_SPACE
+} from '@hcengineering/core'
 import {
   type MigrateOperation,
   type MigrationClient,
@@ -45,6 +52,11 @@ export const chatOperation: MigrateOperation = {
         state: 'migrate-channel-tags',
         mode: 'upgrade',
         func: migrateChannelTags
+      },
+      {
+        state: 'migrate-card-spaces',
+        mode: 'upgrade',
+        func: migrateCardSpaces
       }
     ])
   },
@@ -139,3 +151,29 @@ export async function performParentInfoMigration (client: MigrationClient, bulkS
     await iterator.close()
   }
 }
+
+async function migrateCardSpaces (client: MigrationClient): Promise<void> {
+  const cardSpaces = await client.find<CardSpace>(DOMAIN_SPACE, {
+    _class: card.class.CardSpace
+  })
+  const updates: {
+    filter: MigrationDocumentQuery<CardSpace>
+    update: MigrateUpdate<CardSpace>
+  }[] = []
+  for (const cs of cardSpaces) {
+    if (cs.types == null || !cs.types.includes(channelMasterTag)) {
+      continue
+    }
+    const types = cs.types.filter((t) => t !== channelMasterTag)
+    if (!types.includes(chat.masterTag.Thread)) {
+      types.push(chat.masterTag.Thread)
+    }
+    updates.push({
+      filter: { _id: cs._id },
+      update: { types }
+    })
+  }
+
+  await client.bulk(DOMAIN_SPACE, updates)
+  client.logger.log('Migrated card spaces', { allSpaces: cardSpaces.length, updatedSpaces: updates.length })
+}

From dcba4ec1bffddf59b8489ba002fb624193a2c97e Mon Sep 17 00:00:00 2001
From: Denis Bykhov <bykhov.denis@gmail.com>
Date: Thu, 4 Sep 2025 18:20:52 +0500
Subject: [PATCH 8/8] Process result and context (#9782)

Signed-off-by: Denis Bykhov <bykhov.denis@gmail.com>
---
 models/process/src/index.ts                   |   3 +
 .../ContextSelectorPopup.svelte               |  37 +++--
 .../ExecutionContextPresenter.svelte          |  14 +-
 .../ExecutionContextSelector.svelte           |  80 +++++++++++
 .../ProcessContextRawPresenter.svelte         |   1 -
 .../contextEditors/ToDoContextSelector.svelte |   6 +-
 .../settings/AddTransitionPopup.svelte        |  17 ++-
 .../settings/AsideTransitionEditor.svelte     |  12 +-
 .../settings/CardUpdateEditor.svelte          |   4 +-
 .../components/settings/ContextFooter.svelte  |  14 +-
 .../components/settings/ResultEditor.svelte   |  28 ++--
 .../src/components/settings/ToDoEditor.svelte |  11 --
 .../settings/ToDoParamsEditor.svelte          |  22 ++-
 .../components/settings/ToDoPresenter.svelte  |   6 +-
 plugins/process-resources/src/index.ts        |   2 +
 plugins/process-resources/src/middleware.ts   |   8 +-
 plugins/process-resources/src/plugin.ts       |   1 +
 plugins/process-resources/src/utils.ts        | 131 +++++++++++-------
 plugins/process/src/index.ts                  |  10 +-
 plugins/process/src/types.ts                  |  15 +-
 server-plugins/process-resources/src/index.ts |  43 +++---
 services/process/src/main.ts                  |  27 ++--
 22 files changed, 327 insertions(+), 165 deletions(-)
 create mode 100644 plugins/process-resources/src/components/attributeEditors/ExecutionContextSelector.svelte

diff --git a/models/process/src/index.ts b/models/process/src/index.ts
index 06c07f7f1f..c64ea6b144 100644
--- a/models/process/src/index.ts
+++ b/models/process/src/index.ts
@@ -60,6 +60,7 @@ import {
   type Step,
   type Transition,
   type Trigger,
+  type TriggerResult,
   type UpdateCriteriaComponent,
   processId
 } from '@hcengineering/process'
@@ -131,6 +132,8 @@ export class TTransition extends TDoc implements Transition {
     trigger!: Ref<Trigger>
 
   triggerParams!: Record<string, any>
+
+  result?: TriggerResult | null
 }
 
 @Model(process.class.ExecutionLog, core.class.Doc, DOMAIN_PROCESS_LOG)
diff --git a/plugins/process-resources/src/components/attributeEditors/ContextSelectorPopup.svelte b/plugins/process-resources/src/components/attributeEditors/ContextSelectorPopup.svelte
index 7159e57a1a..0751be0e4f 100644
--- a/plugins/process-resources/src/components/attributeEditors/ContextSelectorPopup.svelte
+++ b/plugins/process-resources/src/components/attributeEditors/ContextSelectorPopup.svelte
@@ -19,7 +19,7 @@
   import {
     Context,
     Process,
-    ProcessContext,
+    ProcessExecutionContext,
     ProcessFunction,
     RelatedContext,
     SelectedContext
@@ -83,7 +83,7 @@
     dispatch('close')
   }
 
-  function onProcessContext (ctx: ProcessContext): void {
+  function onProcessContext (ctx: ProcessExecutionContext): void {
     onSelect(ctx.value)
     dispatch('close')
   }
@@ -155,15 +155,30 @@
       <div class="menu-separator" />
     {/if}
     {#if processContext.length > 0}
-      {#each processContext as f}
-        <button
-          on:click={() => {
-            onProcessContext(f)
-          }}
-          class="menu-item"
-        >
-          <ExecutionContextPresenter {process} contextValue={f.value} />
-        </button>
+      {#each processContext as pc}
+        {#if pc.attributes.length > 0}
+          <Submenu
+            component={ExecutionContextPresenter}
+            props={{
+              context: pc,
+              target: attribute,
+              contextValue: pc.value,
+              process,
+              onSelect: onClick
+            }}
+            options={{ component: plugin.component.ExecutionContextSelector }}
+            withHover
+          />
+        {:else}
+          <button
+            on:click={() => {
+              onProcessContext(pc)
+            }}
+            class="menu-item"
+          >
+            <ExecutionContextPresenter {process} contextValue={pc.value} />
+          </button>
+        {/if}
       {/each}
       <div class="menu-separator" />
     {/if}
diff --git a/plugins/process-resources/src/components/attributeEditors/ExecutionContextPresenter.svelte b/plugins/process-resources/src/components/attributeEditors/ExecutionContextPresenter.svelte
index fc05a21a58..e08f6a8ea0 100644
--- a/plugins/process-resources/src/components/attributeEditors/ExecutionContextPresenter.svelte
+++ b/plugins/process-resources/src/components/attributeEditors/ExecutionContextPresenter.svelte
@@ -13,18 +13,28 @@
 // limitations under the License.
 -->
 <script lang="ts">
-  import { Process, SelectedExecutonContext } from '@hcengineering/process'
+  import { Context, Process, SelectedExecutionContext } from '@hcengineering/process'
   import ui, { Label } from '@hcengineering/ui'
   import ProcessContextPresenter from '../contextEditors/ProcessContextPresenter.svelte'
+  import { getClient } from '@hcengineering/presentation'
 
-  export let contextValue: SelectedExecutonContext
+  export let contextValue: SelectedExecutionContext
   export let process: Process
 
+  const client = getClient()
+
   $: ctx = process.context[contextValue.id]
+
+  $: attr = contextValue.key !== '' ? client.getHierarchy().findAttribute(ctx._class, contextValue.key) : undefined
 </script>
 
 {#if ctx !== undefined}
   <ProcessContextPresenter context={ctx} />
+  {#if attr !== undefined}
+    <span class="attr">
+      <Label label={attr.label} />
+    </span>
+  {/if}
 {:else}
   <Label label={ui.string.NotSelected} />
 {/if}
diff --git a/plugins/process-resources/src/components/attributeEditors/ExecutionContextSelector.svelte b/plugins/process-resources/src/components/attributeEditors/ExecutionContextSelector.svelte
new file mode 100644
index 0000000000..0d27519982
--- /dev/null
+++ b/plugins/process-resources/src/components/attributeEditors/ExecutionContextSelector.svelte
@@ -0,0 +1,80 @@
+<!--
+// Copyright © 2025 Hardcore Engineering Inc.
+//
+// Licensed under the Eclipse Public License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License. You may
+// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+<script lang="ts">
+  import { AnyAttribute } from '@hcengineering/core'
+  import { ProcessExecutionContext, SelectedContext } from '@hcengineering/process'
+  import { Label, resizeObserver, Scroller } from '@hcengineering/ui'
+  import { createEventDispatcher } from 'svelte'
+  import { getValueReduceFunc } from '../../utils'
+
+  export let context: ProcessExecutionContext
+  export let target: AnyAttribute
+  export let onSelect: (val: SelectedContext) => void
+
+  const dispatch = createEventDispatcher()
+
+  const elements: HTMLButtonElement[] = []
+
+  const keyDown = (event: KeyboardEvent, index: number): void => {
+    if (event.key === 'ArrowDown') {
+      elements[(index + 1) % elements.length].focus()
+    }
+
+    if (event.key === 'ArrowUp') {
+      elements[(elements.length + index - 1) % elements.length].focus()
+    }
+
+    if (event.key === 'ArrowLeft') {
+      dispatch('close')
+    }
+  }
+
+  function onAttribute (attr: AnyAttribute): void {
+    const valueFunc = getValueReduceFunc(attr, target)
+    onSelect({
+      type: 'context',
+      key: attr.name,
+      id: context.context,
+      functions: valueFunc !== undefined ? [{ func: valueFunc, props: {} }] : []
+    })
+  }
+</script>
+
+<div class="selectPopup" use:resizeObserver={() => dispatch('changeContent')}>
+  <div class="menu-space" />
+  <Scroller>
+    {#each context.attributes as attr, i}
+      <!-- svelte-ignore a11y-mouse-events-have-key-events -->
+      <button
+        bind:this={elements[i]}
+        on:keydown={(event) => {
+          keyDown(event, i)
+        }}
+        on:mouseover={() => {
+          elements[i]?.focus()
+        }}
+        on:click={() => {
+          onAttribute(attr)
+        }}
+        class="menu-item"
+      >
+        <span class="overflow-label pr-1">
+          <Label label={attr.label} />
+        </span>
+      </button>
+    {/each}
+  </Scroller>
+  <div class="menu-space" />
+</div>
diff --git a/plugins/process-resources/src/components/contextEditors/ProcessContextRawPresenter.svelte b/plugins/process-resources/src/components/contextEditors/ProcessContextRawPresenter.svelte
index 5b5c03ae2c..aac7568f6e 100644
--- a/plugins/process-resources/src/components/contextEditors/ProcessContextRawPresenter.svelte
+++ b/plugins/process-resources/src/components/contextEditors/ProcessContextRawPresenter.svelte
@@ -16,7 +16,6 @@
   import { getClient } from '@hcengineering/presentation'
   import { ProcessContext } from '@hcengineering/process'
   import { Label } from '@hcengineering/ui'
-  import process from '../../plugin'
 
   export let context: ProcessContext
 
diff --git a/plugins/process-resources/src/components/contextEditors/ToDoContextSelector.svelte b/plugins/process-resources/src/components/contextEditors/ToDoContextSelector.svelte
index 7e05533043..86808e18e7 100644
--- a/plugins/process-resources/src/components/contextEditors/ToDoContextSelector.svelte
+++ b/plugins/process-resources/src/components/contextEditors/ToDoContextSelector.svelte
@@ -21,7 +21,7 @@
     Process,
     ProcessToDo,
     SelectedContext,
-    SelectedExecutonContext
+    SelectedExecutionContext
   } from '@hcengineering/process'
   import ui, {
     Button,
@@ -52,14 +52,14 @@
 
   const client = getClient()
 
-  function getContext (value: string): SelectedExecutonContext | undefined {
+  function getContext (value: string): SelectedExecutionContext | undefined {
     const context = parseContext(value)
     if (context !== undefined && isExecutionContext(context)) {
       return context
     }
   }
 
-  function isExecutionContext (context: SelectedContext): context is SelectedExecutonContext {
+  function isExecutionContext (context: SelectedContext): context is SelectedExecutionContext {
     return context.type === 'context'
   }
 
diff --git a/plugins/process-resources/src/components/settings/AddTransitionPopup.svelte b/plugins/process-resources/src/components/settings/AddTransitionPopup.svelte
index a3ba02b8ed..0fe072b29b 100644
--- a/plugins/process-resources/src/components/settings/AddTransitionPopup.svelte
+++ b/plugins/process-resources/src/components/settings/AddTransitionPopup.svelte
@@ -15,7 +15,7 @@
 <script lang="ts">
   import core, { Ref } from '@hcengineering/core'
   import { Card, createQuery, getClient } from '@hcengineering/presentation'
-  import { Process, State, Trigger } from '@hcengineering/process'
+  import { Process, State, Trigger, TriggerResult } from '@hcengineering/process'
   import { Component, Dropdown, DropdownIntlItem, DropdownLabelsIntl, Label, ListItem } from '@hcengineering/ui'
   import { createEventDispatcher } from 'svelte'
   import plugin from '../../plugin'
@@ -25,6 +25,7 @@
   const dispatch = createEventDispatcher()
   let to: Ref<State> | undefined = undefined
   let states: State[] = []
+  let result: TriggerResult | null = null
 
   const query = createQuery()
   query.query(plugin.class.State, { process: process._id }, (res) => {
@@ -66,13 +67,19 @@
       trigger,
       triggerParams: params,
       process: process._id,
+      result,
       actions: []
     })
     dispatch('close')
   }
 
   function change (e: CustomEvent<Record<string, any>>): void {
-    params = e.detail
+    if (e.detail?.params !== undefined) {
+      params = e.detail.params
+    }
+    if (e.detail?.result !== undefined) {
+      result = e.detail.result
+    }
   }
 </script>
 
@@ -111,13 +118,17 @@
       items={triggersItems}
       bind:selected={trigger}
       label={plugin.string.Trigger}
+      on:selected={() => {
+        params = {}
+        result = null
+      }}
       justify={'left'}
       width={'100%'}
       kind={'no-border'}
     />
   </div>
   {#if triggerValue?.editor}
-    <Component is={triggerValue.editor} props={{ process, params }} on:change={change} />
+    <Component is={triggerValue.editor} props={{ process, params, result }} on:change={change} />
   {/if}
 </Card>
 
diff --git a/plugins/process-resources/src/components/settings/AsideTransitionEditor.svelte b/plugins/process-resources/src/components/settings/AsideTransitionEditor.svelte
index db7d1442c4..dd5251d58d 100644
--- a/plugins/process-resources/src/components/settings/AsideTransitionEditor.svelte
+++ b/plugins/process-resources/src/components/settings/AsideTransitionEditor.svelte
@@ -20,11 +20,12 @@
   export let transition: Transition
 
   let params = transition.triggerParams ?? {}
+  let result = transition.result ?? null
 
   const client = getClient()
 
   async function save (): Promise<void> {
-    await client.update(transition, { triggerParams: params, trigger: selectedTrigger })
+    await client.update(transition, { triggerParams: params, trigger: selectedTrigger, result })
     clearSettingsStore()
   }
 
@@ -34,7 +35,12 @@
   }
 
   function change (e: CustomEvent<Record<string, any>>): void {
-    params = e.detail
+    if (e.detail?.params !== undefined) {
+      params = e.detail.params
+    }
+    if (e.detail?.result !== undefined) {
+      result = e.detail.result
+    }
   }
 
   let selectedTrigger: Ref<Trigger> = transition.trigger
@@ -79,7 +85,7 @@
       </div>
       {#if trigger.editor !== undefined}
         <div class="editor">
-          <Component is={trigger.editor} props={{ process, params, readonly }} on:change={change} />
+          <Component is={trigger.editor} props={{ process, params, result, readonly }} on:change={change} />
         </div>
       {/if}
     {/if}
diff --git a/plugins/process-resources/src/components/settings/CardUpdateEditor.svelte b/plugins/process-resources/src/components/settings/CardUpdateEditor.svelte
index 6203ebd036..7e78111514 100644
--- a/plugins/process-resources/src/components/settings/CardUpdateEditor.svelte
+++ b/plugins/process-resources/src/components/settings/CardUpdateEditor.svelte
@@ -35,7 +35,7 @@
   function change (e: CustomEvent<any>): void {
     if (readonly || e.detail == null) return
     params = e.detail
-    dispatch('change', params)
+    dispatch('change', { params })
   }
 
   function getKeys (_class: Ref<Class<MasterTag>>): AnyAttribute[] {
@@ -87,7 +87,7 @@
       keys = keys.filter((k) => k !== key)
       // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
       delete (params as any)[key]
-      dispatch('change', params)
+      dispatch('change', { params })
     }
   }
 </script>
diff --git a/plugins/process-resources/src/components/settings/ContextFooter.svelte b/plugins/process-resources/src/components/settings/ContextFooter.svelte
index 4675421379..a95a85ae9b 100644
--- a/plugins/process-resources/src/components/settings/ContextFooter.svelte
+++ b/plugins/process-resources/src/components/settings/ContextFooter.svelte
@@ -16,33 +16,23 @@
 <script lang="ts">
   import { Doc } from '@hcengineering/core'
   import { Process, Step } from '@hcengineering/process'
-  import ProcessContextPresenter from '../contextEditors/ProcessContextPresenter.svelte'
   import { Label } from '@hcengineering/ui'
   import processPlugin from '../../plugin'
+  import ProcessContextPresenter from '../contextEditors/ProcessContextPresenter.svelte'
 
   export let process: Process
   export let step: Step<Doc>
 
   $: currentContext = step.context ? process.context[step.context._id] : undefined
-
-  $: currentResultContext = step.result ? process.context[step.result._id] : undefined
 </script>
 
-{#if currentContext || currentResultContext}
-  <Label label={processPlugin.string.Result} />
-{/if}
 {#if currentContext}
+  <Label label={processPlugin.string.Result} />
   <div class="container">
     <ProcessContextPresenter context={currentContext} />
   </div>
 {/if}
 
-{#if currentResultContext}
-  <div class="container">
-    <ProcessContextPresenter context={currentResultContext} />
-  </div>
-{/if}
-
 <style lang="scss">
   .container {
     padding: 0.25rem 0.5rem;
diff --git a/plugins/process-resources/src/components/settings/ResultEditor.svelte b/plugins/process-resources/src/components/settings/ResultEditor.svelte
index fd536baa6f..d85bfe152a 100644
--- a/plugins/process-resources/src/components/settings/ResultEditor.svelte
+++ b/plugins/process-resources/src/components/settings/ResultEditor.svelte
@@ -13,9 +13,9 @@
 // limitations under the License.
 -->
 <script lang="ts">
-  import core, { Class, Doc, PropertyType, Ref, Type } from '@hcengineering/core'
+  import core, { Class, PropertyType, Ref, Type } from '@hcengineering/core'
   import { getClient } from '@hcengineering/presentation'
-  import { Step } from '@hcengineering/process'
+  import { TriggerResult } from '@hcengineering/process'
   import setting from '@hcengineering/setting-resources/src/plugin'
   import {
     AnyComponent,
@@ -32,10 +32,10 @@
   import plugin from '../../plugin'
   import { generateContextId } from '../../utils'
 
-  export let step: Step<Doc>
+  export let result: TriggerResult | null
 
-  let type: Type<any> | undefined | null = step.result?.type
-  let name: string = step.result?.name ?? ''
+  let type: Type<any> | undefined | null = result?.type
+  let name: string = result?.name ?? ''
   let is: AnyComponent | undefined
   const client = getClient()
   const hierarchy = client.getHierarchy()
@@ -43,15 +43,15 @@
 
   function update (): void {
     if (type == null) {
-      step.result = undefined
+      result = null
     } else {
-      step.result = {
+      result = {
         _id: generateContextId(),
         name,
         type
       }
     }
-    dispatch('change', step)
+    dispatch('change', result)
   }
 
   function getTypes (): DropdownIntlItem[] {
@@ -91,9 +91,9 @@
   }
 
   function handleNameChange (e: any): void {
-    if (step.result != null) {
-      step.result.name = name
-      dispatch('change', step)
+    if (result != null) {
+      result.name = name
+      dispatch('change', result)
     }
   }
 
@@ -110,7 +110,7 @@
 <div class="grid">
   <Label label={plugin.string.Result} />
   <Toggle
-    on={step.result !== undefined}
+    on={result != null}
     on:change={(e) => {
       changeRequired(e.detail)
     }}
@@ -150,14 +150,12 @@
 <style lang="scss">
   .grid {
     display: grid;
-    grid-template-columns: 1fr 1.5fr;
+    grid-template-columns: 1fr 3fr;
     grid-auto-rows: minmax(2rem, max-content);
     justify-content: start;
     align-items: center;
     row-gap: 0.5rem;
     column-gap: 1rem;
-    margin: 0.25rem 2rem 0;
-    width: calc(100% - 4rem);
     height: min-content;
   }
 </style>
diff --git a/plugins/process-resources/src/components/settings/ToDoEditor.svelte b/plugins/process-resources/src/components/settings/ToDoEditor.svelte
index 8a1899341f..b82b15f7e0 100644
--- a/plugins/process-resources/src/components/settings/ToDoEditor.svelte
+++ b/plugins/process-resources/src/components/settings/ToDoEditor.svelte
@@ -36,13 +36,6 @@
   }
 
   const keys = ['title', 'user', 'dueDate']
-
-  function changeResult (e: CustomEvent<any>): void {
-    if (e.detail !== undefined) {
-      step = e.detail
-      dispatch('change', step)
-    }
-  }
 </script>
 
 <ParamsEditor _class={plugin.class.ProcessToDo} {process} {keys} {params} on:change={changeParams} />
@@ -60,10 +53,6 @@
     }}
   />
 </div>
-<div class="divider" />
-{#key step._id}
-  <ResultEditor {step} on:change={changeResult} />
-{/key}
 
 <style lang="scss">
   .divider {
diff --git a/plugins/process-resources/src/components/settings/ToDoParamsEditor.svelte b/plugins/process-resources/src/components/settings/ToDoParamsEditor.svelte
index 285b281bc9..1d318fbeca 100644
--- a/plugins/process-resources/src/components/settings/ToDoParamsEditor.svelte
+++ b/plugins/process-resources/src/components/settings/ToDoParamsEditor.svelte
@@ -14,23 +14,32 @@
 -->
 
 <script lang="ts">
-  import { Process } from '@hcengineering/process'
+  import { Process, TriggerResult } from '@hcengineering/process'
   import { Label } from '@hcengineering/ui'
   import { createEventDispatcher } from 'svelte'
   import plugin from '../../plugin'
   import ToDoContextSelector from '../contextEditors/ToDoContextSelector.svelte'
+  import ResultEditor from './ResultEditor.svelte'
 
   export let readonly: boolean
   export let process: Process
   export let params: Record<string, any>
   export let skipRollback: boolean = false
+  export let result: TriggerResult | null = null
 
   const dispatch = createEventDispatcher()
 
   function change (e: CustomEvent<string>): void {
     if (readonly || e.detail == null) return
     params._id = e.detail
-    dispatch('change', params)
+    dispatch('change', { params })
+  }
+
+  function changeResult (e: CustomEvent<any>): void {
+    if (e.detail !== undefined) {
+      result = e.detail
+      dispatch('change', { result })
+    }
   }
 </script>
 
@@ -38,8 +47,17 @@
   <Label label={plugin.string.ToDo} />
   <ToDoContextSelector {readonly} {skipRollback} {process} value={params._id} on:change={change} />
 </div>
+{#if !skipRollback}
+  <div class="divider" />
+  <ResultEditor {result} on:change={changeResult} />
+{/if}
 
 <style lang="scss">
+  .divider {
+    border-bottom: 1px solid var(--divider-color);
+    margin: 1rem 0;
+  }
+
   .grid {
     display: grid;
     grid-template-columns: 1fr 3fr;
diff --git a/plugins/process-resources/src/components/settings/ToDoPresenter.svelte b/plugins/process-resources/src/components/settings/ToDoPresenter.svelte
index 50611646e2..548bda7977 100644
--- a/plugins/process-resources/src/components/settings/ToDoPresenter.svelte
+++ b/plugins/process-resources/src/components/settings/ToDoPresenter.svelte
@@ -14,7 +14,7 @@
 -->
 
 <script lang="ts">
-  import { parseContext, Process, SelectedContext, SelectedExecutonContext } from '@hcengineering/process'
+  import { parseContext, Process, SelectedContext, SelectedExecutionContext } from '@hcengineering/process'
   import ui, { Label } from '@hcengineering/ui'
   import ExecutionContextPresenter from '../attributeEditors/ExecutionContextPresenter.svelte'
 
@@ -23,7 +23,7 @@
 
   $: context = getContext(params._id)
 
-  function getContext (value: string | undefined): SelectedExecutonContext | undefined {
+  function getContext (value: string | undefined): SelectedExecutionContext | undefined {
     if (value === undefined) return
     const context = parseContext(value)
     if (context !== undefined && isExecutionContext(context)) {
@@ -31,7 +31,7 @@
     }
   }
 
-  function isExecutionContext (context: SelectedContext): context is SelectedExecutonContext {
+  function isExecutionContext (context: SelectedContext): context is SelectedExecutionContext {
     return context.type === 'context'
   }
 </script>
diff --git a/plugins/process-resources/src/index.ts b/plugins/process-resources/src/index.ts
index 5d05c9b1ff..6445795bac 100644
--- a/plugins/process-resources/src/index.ts
+++ b/plugins/process-resources/src/index.ts
@@ -15,6 +15,7 @@ import { type Resources } from '@hcengineering/platform'
 import FunctionSelector from './components/attributeEditors/FunctionSelector.svelte'
 import NestedContextSelector from './components/attributeEditors/NestedContextSelector.svelte'
 import RelatedContextSelector from './components/attributeEditors/RelatedContextSelector.svelte'
+import ExecutionContextSelector from './components/attributeEditors/ExecutionContextSelector.svelte'
 import RequestUserInput from './components/contextEditors/RequestUserInput.svelte'
 import ResultInput from './components/contextEditors/ResultInput.svelte'
 import RoleEditor from './components/contextEditors/RoleEditor.svelte'
@@ -100,6 +101,7 @@ export default async (): Promise<Resources> => ({
     ProcessPresenter,
     NestedContextSelector,
     RelatedContextSelector,
+    ExecutionContextSelector,
     FunctionSelector,
     Main,
     RunProcessCardPopup,
diff --git a/plugins/process-resources/src/middleware.ts b/plugins/process-resources/src/middleware.ts
index 2c66b48c95..23cb079f27 100644
--- a/plugins/process-resources/src/middleware.ts
+++ b/plugins/process-resources/src/middleware.ts
@@ -168,9 +168,11 @@ export class ProcessMiddleware extends BasePresentationMiddleware implements Pre
       if (transition === undefined) return
       const context = await getNextStateUserInput(execution, transition, execution.context)
       const txop = new TxOperations(this.client, getCurrentAccount().primarySocialId)
-      await txop.update(execution, {
-        context
-      })
+      if (context !== undefined) {
+        await txop.update(execution, {
+          context
+        })
+      }
       await requestResult(txop, execution, transition, execution.context)
     }
   }
diff --git a/plugins/process-resources/src/plugin.ts b/plugins/process-resources/src/plugin.ts
index e4a50022c3..ffdd6e5ebb 100644
--- a/plugins/process-resources/src/plugin.ts
+++ b/plugins/process-resources/src/plugin.ts
@@ -38,6 +38,7 @@ export default mergeIds(processId, process, {
     ProcessPresenter: '' as AnyComponent,
     ExecutonPresenter: '' as AnyComponent,
     ExecutonProgressPresenter: '' as AnyComponent,
+    ExecutionContextSelector: '' as AnyComponent,
     NestedContextSelector: '' as AnyComponent,
     RelatedContextSelector: '' as AnyComponent,
     FunctionSelector: '' as AnyComponent,
diff --git a/plugins/process-resources/src/utils.ts b/plugins/process-resources/src/utils.ts
index 9835a2d717..ececd4d139 100644
--- a/plugins/process-resources/src/utils.ts
+++ b/plugins/process-resources/src/utils.ts
@@ -13,9 +13,6 @@
 
 import { type Card, type MasterTag } from '@hcengineering/card'
 import core, {
-  generateId,
-  type Hierarchy,
-  matchQuery,
   type AnyAttribute,
   type ArrOf,
   type Association,
@@ -23,6 +20,9 @@ import core, {
   type Client,
   type Doc,
   type DocumentQuery,
+  generateId,
+  type Hierarchy,
+  matchQuery,
   type ModelDb,
   type Ref,
   type RefTo,
@@ -33,16 +33,16 @@ import core, {
 import { getResource, PlatformError, Severity, Status } from '@hcengineering/platform'
 import { getClient } from '@hcengineering/presentation'
 import {
-  ExecutionStatus,
-  parseContext,
   type Context,
   type ContextId,
   type Execution,
   type ExecutionContext,
+  ExecutionStatus,
   type Method,
   type NestedContext,
+  parseContext,
   type Process,
-  type ProcessContext,
+  type ProcessExecutionContext,
   type ProcessFunction,
   type RelatedContext,
   type SelectedContext,
@@ -174,7 +174,7 @@ export function getContext (
   const functions = getContextFunctions(client, process.masterTag, target, category)
   const nested: Record<string, NestedContext> = {}
   const relations: Record<string, RelatedContext> = {}
-  const executionContext: Record<string, ProcessContext> = {}
+  const executionContext: Record<string, ProcessExecutionContext> = {}
 
   const refs = getClassAttributes(client, process.masterTag, core.class.RefTo, 'attribute')
   for (const ref of refs) {
@@ -241,11 +241,25 @@ export function getContext (
     }
   }
 
-  if (category === 'object') {
-    for (const key in process.context) {
-      const value = process.context[key as ContextId]
-      if (client.getHierarchy().isDerived(value._class, target)) {
-        executionContext[key] = value
+  for (const key in process.context) {
+    const contextId = key as ContextId
+    const value = process.context[contextId]
+    if (client.getHierarchy().isDerived(value._class, target)) {
+      executionContext[key] = {
+        attributes: [],
+        name: value.name,
+        context: contextId,
+        value: value.value
+      }
+    } else {
+      const contextAttributes = getClassAttributes(client, value._class, target, category)
+      if (contextAttributes.length > 0) {
+        executionContext[key] = {
+          name: value.name,
+          context: contextId,
+          value: value.value,
+          attributes: contextAttributes
+        }
       }
     }
   }
@@ -404,11 +418,13 @@ export async function continueExecution (value: Execution): Promise<void> {
   let context = value.context
   const transition = value.error[0].transition
   if (transition == null) {
-    context = await newExecutionUserInput(value.process, context)
+    const res = await newExecutionUserInput(value.process, context)
+    context = res ?? context
   } else {
     const _transition = client.getModel().findObject(transition)
     if (_transition === undefined) return
-    context = await getNextStateUserInput(value, _transition, value.context)
+    const res = await getNextStateUserInput(value, _transition, context)
+    context = res ?? context
   }
   await client.update(value, { status: ExecutionStatus.Active, context })
 }
@@ -417,17 +433,24 @@ export async function requestUserInput (
   processId: Ref<Process>,
   target: Transition,
   userContext: ExecutionContext
-): Promise<ExecutionContext> {
-  userContext = await getTransitionUserInput(processId, target, userContext)
-  userContext = await getSubProcessesUserInput(target, userContext)
-  return userContext
+): Promise<ExecutionContext | undefined> {
+  const tr = await getTransitionUserInput(processId, target, userContext)
+  if (tr !== undefined) {
+    userContext = { ...userContext, ...tr }
+  }
+  const sub = await getSubProcessesUserInput(target, userContext)
+  if (sub !== undefined) {
+    userContext = { ...userContext, ...sub }
+  }
+  return sub !== undefined || tr !== undefined ? userContext : undefined
 }
 
 export async function getTransitionUserInput (
   processId: Ref<Process>,
   transition: Transition,
   userContext: ExecutionContext
-): Promise<ExecutionContext> {
+): Promise<ExecutionContext | undefined> {
+  const changed = false
   for (const action of transition.actions) {
     if (action == null) continue
     for (const key in action.params) {
@@ -451,43 +474,45 @@ export async function getTransitionUserInput (
       }
     }
   }
-  return userContext
+  return changed ? userContext : undefined
 }
 
 export async function getSubProcessesUserInput (
   transition: Transition,
   userContext: ExecutionContext
-): Promise<ExecutionContext> {
+): Promise<ExecutionContext | undefined> {
+  const changed = false
   for (const action of transition.actions) {
     if (action.methodId !== process.method.RunSubProcess) continue
     const processId = action.params._id as Ref<Process>
     if (processId === undefined) continue
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const res = await newExecutionUserInput(processId, {} as ExecutionContext)
-    if (action.context == null) continue
+    const res = await newExecutionUserInput(processId)
+    if (action.context == null || res === undefined) continue
     userContext[action.context._id] = res
   }
-  return userContext
+  return changed ? userContext : undefined
 }
 
 export async function newExecutionUserInput (
   _id: Ref<Process>,
-  userContext: ExecutionContext
-): Promise<ExecutionContext> {
+  userContext?: ExecutionContext
+): Promise<ExecutionContext | undefined> {
   const client = getClient()
   const initTransition = client.getModel().findAllSync(process.class.Transition, {
     process: _id,
     from: null
   })[0]
   if (initTransition === undefined) return userContext
-  return await requestUserInput(_id, initTransition, userContext)
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const emptyContext: ExecutionContext = {} as ExecutionContext
+  return await requestUserInput(_id, initTransition, userContext ?? emptyContext)
 }
 
 export async function getNextStateUserInput (
   execution: Execution,
   transition: Transition,
   userContext: ExecutionContext
-): Promise<ExecutionContext> {
+): Promise<ExecutionContext | undefined> {
   const client = getClient()
   const process = client.getModel().findObject(execution.process)
   if (process === undefined) return userContext
@@ -497,7 +522,7 @@ export async function getNextStateUserInput (
 export async function createExecution (card: Ref<Card>, _id: Ref<Process>, space: Ref<Space>): Promise<void> {
   const client = getClient()
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const context = await newExecutionUserInput(_id, {} as ExecutionContext)
+  const context = await newExecutionUserInput(_id)
   const _process = client.getModel().findObject(_id)
   if (_process === undefined) return
   const initTransition = client.getModel().findAllSync(process.class.Transition, {
@@ -505,12 +530,14 @@ export async function createExecution (card: Ref<Card>, _id: Ref<Process>, space
     from: null
   })[0]
   if (initTransition === undefined) return
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const emptyContext: ExecutionContext = {} as ExecutionContext
   await client.createDoc(process.class.Execution, space, {
     process: _id,
     currentState: initTransition.to,
     card,
     rollback: [],
-    context,
+    context: context ?? emptyContext,
     status: ExecutionStatus.Active
   })
 }
@@ -544,29 +571,27 @@ export async function requestResult (
   transition: Transition,
   context: ExecutionContext
 ): Promise<void> {
-  for (const action of transition.actions) {
-    if (action.result == null) continue
-    const promise = new Promise<void>((resolve, reject) => {
-      showPopup(
-        process.component.ResultInput,
-        { type: action.result?.type, name: action.result?.name },
-        undefined,
-        (res) => {
-          if (action.result?._id === undefined) return
-          if (res?.value !== undefined) {
-            context[action.result._id] = res.value
-            resolve()
-          } else {
-            reject(new PlatformError(new Status(Severity.ERROR, process.error.ResultNotProvided, {})))
-          }
+  if (transition.result == null) return
+  const promise = new Promise<void>((resolve, reject) => {
+    showPopup(
+      process.component.ResultInput,
+      { type: transition.result?.type, name: transition.result?.name },
+      undefined,
+      (res) => {
+        if (transition.result?._id === undefined) return
+        if (res?.value !== undefined) {
+          context[transition.result._id] = res.value
+          resolve()
+        } else {
+          reject(new PlatformError(new Status(Severity.ERROR, process.error.ResultNotProvided, {})))
         }
-      )
-    })
-    await promise
-    await txop.update(execution, {
-      context
-    })
-  }
+      }
+    )
+  })
+  await promise
+  await txop.update(execution, {
+    context
+  })
 }
 
 export function todoTranstionCheck (params: Record<string, any>, doc: Doc): boolean {
diff --git a/plugins/process/src/index.ts b/plugins/process/src/index.ts
index ce3f323a17..4a6446b5e0 100644
--- a/plugins/process/src/index.ts
+++ b/plugins/process/src/index.ts
@@ -17,7 +17,7 @@ import { Asset, IntlString, Plugin, plugin, Resource } from '@hcengineering/plat
 import { ToDo } from '@hcengineering/time'
 import { AnyComponent } from '@hcengineering/ui'
 import { AttributeCategory } from '@hcengineering/view'
-import { SelectedExecutonContext } from './types'
+import { SelectedExecutionContext } from './types'
 
 /**
  * @public
@@ -38,12 +38,12 @@ export interface Process extends Doc {
 export interface ProcessContext {
   name: string
   _class: Ref<Class<Doc>>
-  action: StepId
+  action?: StepId
   index: number
   producer: Ref<Transition>
   isResult?: boolean
   type?: Type<any>
-  value: SelectedExecutonContext
+  value: SelectedExecutionContext
 }
 
 export type ContextId = string & { __contextId: true }
@@ -66,6 +66,7 @@ export interface Transition extends Doc {
   actions: Step<Doc>[]
   trigger: Ref<Trigger>
   triggerParams: Record<string, any>
+  result?: TriggerResult | null
 }
 
 export interface ExecutionLog extends Doc {
@@ -138,7 +139,6 @@ export interface Step<T extends Doc> {
   context: StepContext | null
   methodId: Ref<Method<T>>
   params: MethodParams<T>
-  result?: StepResult
 }
 
 export interface StepContext {
@@ -146,7 +146,7 @@ export interface StepContext {
   _class?: Ref<Class<Doc>> // class of the context
 }
 
-export interface StepResult {
+export interface TriggerResult {
   _id: ContextId // context id
   name: string
   type: Type<any>
diff --git a/plugins/process/src/types.ts b/plugins/process/src/types.ts
index a5744fd8fb..47ea66ed54 100644
--- a/plugins/process/src/types.ts
+++ b/plugins/process/src/types.ts
@@ -1,12 +1,12 @@
 import { Class, Doc, type AnyAttribute, type Association, type Ref } from '@hcengineering/core'
-import { ContextId, ProcessContext, ProcessFunction } from '.'
+import { ContextId, ProcessFunction } from '.'
 
 export interface Context {
   functions: Ref<ProcessFunction>[]
   attributes: AnyAttribute[]
   nested: Record<string, NestedContext>
   relations: Record<string, RelatedContext>
-  executionContext: Record<ContextId, ProcessContext>
+  executionContext: Record<ContextId, ProcessExecutionContext>
 }
 
 export interface NestedContext {
@@ -21,6 +21,13 @@ export interface RelatedContext {
   attributes: AnyAttribute[]
 }
 
+export interface ProcessExecutionContext {
+  name: string
+  context: ContextId
+  value: SelectedExecutionContext
+  attributes: AnyAttribute[]
+}
+
 export interface Func {
   func: Ref<ProcessFunction>
   props: Record<string, any>
@@ -62,7 +69,7 @@ export interface SelectedUserRequest extends BaseSelectedContext {
   id: ContextId
 }
 
-export interface SelectedExecutonContext extends BaseSelectedContext {
+export interface SelectedExecutionContext extends BaseSelectedContext {
   type: 'context'
   id: ContextId
 }
@@ -79,4 +86,4 @@ export type SelectedContext =
   | SelectedNested
   | SelectedUserRequest
   | SelectedContextFunc
-  | SelectedExecutonContext
+  | SelectedExecutionContext
diff --git a/server-plugins/process-resources/src/index.ts b/server-plugins/process-resources/src/index.ts
index bb1f6e740c..1944749776 100644
--- a/server-plugins/process-resources/src/index.ts
+++ b/server-plugins/process-resources/src/index.ts
@@ -21,7 +21,7 @@ import process, {
   Process,
   ProcessContext,
   ProcessToDo,
-  SelectedExecutonContext,
+  SelectedExecutionContext,
   State,
   Transition
 } from '@hcengineering/process'
@@ -267,6 +267,25 @@ async function syncContext (control: TriggerControl, _process: Process): Promise
   let changed = false
   let index = 1
   for (const transition of transitions) {
+    if (transition.result?._id != null) {
+      exists.add(transition.result._id)
+      const context = _process.context[transition.result._id]
+      changed = true
+      const ctx: SelectedExecutionContext = {
+        type: 'context',
+        id: transition.result._id,
+        key: ''
+      }
+      _process.context[transition.result._id] = {
+        name: context?.name ?? transition.result.name,
+        isResult: true,
+        type: transition.result.type,
+        _class: transition.result.type._class,
+        index: index++,
+        producer: transition._id,
+        value: ctx
+      }
+    }
     for (const action of transition.actions) {
       if (action.context != null) {
         exists.add(action.context._id)
@@ -274,7 +293,7 @@ async function syncContext (control: TriggerControl, _process: Process): Promise
         const current = _process.context[action.context._id]
         if (method?.contextClass != null) {
           changed = true
-          const ctx: SelectedExecutonContext = {
+          const ctx: SelectedExecutionContext = {
             type: 'context',
             id: action.context._id,
             key: ''
@@ -289,26 +308,6 @@ async function syncContext (control: TriggerControl, _process: Process): Promise
           }
         }
       }
-      if (action.result?._id != null) {
-        exists.add(action.result._id)
-        const context = _process.context[action.result._id]
-        changed = true
-        const ctx: SelectedExecutonContext = {
-          type: 'context',
-          id: action.result._id,
-          key: ''
-        }
-        _process.context[action.result._id] = {
-          name: context?.name ?? action.result.name,
-          isResult: true,
-          type: action.result.type,
-          _class: action.result.type._class,
-          action: action._id,
-          index: index++,
-          producer: transition._id,
-          value: ctx
-        }
-      }
     }
   }
   const newContext: Record<ContextId, ProcessContext> = {}
diff --git a/services/process/src/main.ts b/services/process/src/main.ts
index 7f303d989a..335b5c1150 100644
--- a/services/process/src/main.ts
+++ b/services/process/src/main.ts
@@ -40,7 +40,7 @@ import process, {
   ProcessError,
   SelectedContext,
   SelectedContextFunc,
-  SelectedExecutonContext,
+  SelectedExecutionContext,
   SelectedNested,
   SelectedRelation,
   SelectedUserRequest,
@@ -621,7 +621,7 @@ async function getContextValue (value: any, control: ProcessControl, execution:
       } else if (context.type === 'function') {
         value = await getFunctionValue(control, execution, context)
       } else if (context.type === 'context') {
-        value = getExecutionContextValue(control, execution, context)
+        value = await getExecutionContextValue(control, execution, context)
       }
       return await fillValue(value, context, control, execution)
     } catch (err: any) {
@@ -684,18 +684,25 @@ function getUserRequestValue (control: ProcessControl, execution: Execution, con
   )
 }
 
-function getExecutionContextValue (
+async function getExecutionContextValue (
   control: ProcessControl,
   execution: Execution,
-  context: SelectedExecutonContext
-): any {
+  context: SelectedExecutionContext
+): Promise<any> {
   const userContext = execution.context[context.id]
-  if (userContext !== undefined) return userContext
   const _process = control.client.getModel().findObject(execution.process)
-  if (_process === undefined) return
-  const ctx = _process.context[context.id]
-  if (ctx === undefined) return
-  throw processError(process.error.ContextValueNotProvided, { name: ctx.name })
+  const processContext = _process?.context?.[context.id]
+  if (userContext !== undefined) {
+    if (context.key === '' || context.key === '_id') return userContext
+    if (processContext !== undefined) {
+      const contextVal = await control.client.findOne(processContext?._class, { _id: userContext })
+      if (contextVal !== undefined) {
+        const val = getObjectValue(context.key, contextVal)
+        return val
+      }
+    }
+  }
+  throw processError(process.error.ContextValueNotProvided, { name: processContext?.name ?? context.id })
 }
 
 async function checkParent (execution: Execution, control: ProcessControl): Promise<void> {