diff --git a/packages/platform/src/index.ts b/packages/platform/src/index.ts
index 6be392fb20..3d87bcb723 100644
--- a/packages/platform/src/index.ts
+++ b/packages/platform/src/index.ts
@@ -20,6 +20,7 @@ export * from './event'
 export * from './i18n'
 export * from './metadata'
 export * from './platform'
+export * from './ident'
 export { default } from './platform'
 export * from './resource'
 export * from './status'
diff --git a/plugins/process-resources/package.json b/plugins/process-resources/package.json
index 76954397fa..3ece02cf64 100644
--- a/plugins/process-resources/package.json
+++ b/plugins/process-resources/package.json
@@ -9,9 +9,11 @@
     "build:docs": "api-extractor run --local",
     "format": "format src",
     "svelte-check": "do-svelte-check",
+    "test": "jest --passWithNoTests --silent",
     "_phase:svelte-check": "do-svelte-check",
     "build:watch": "compile ui",
     "_phase:build": "compile ui",
+    "_phase:test": "jest --passWithNoTests --silent",
     "_phase:format": "format src",
     "_phase:validate": "compile validate"
   },
diff --git a/plugins/process-resources/src/components/ProcessAttribute.svelte b/plugins/process-resources/src/components/ProcessAttribute.svelte
index b4641f4282..03b645db85 100644
--- a/plugins/process-resources/src/components/ProcessAttribute.svelte
+++ b/plugins/process-resources/src/components/ProcessAttribute.svelte
@@ -15,7 +15,7 @@
 <script lang="ts">
   import { MasterTag, Tag } from '@hcengineering/card'
   import { AnyAttribute, Class, Doc, Ref } from '@hcengineering/core'
-  import { Context, parseContext, Process, SelectedContext } from '@hcengineering/process'
+  import { Context, createDSLContext, parseContext, Process, SelectedContext } from '@hcengineering/process'
   import {
     AnySvelteComponent,
     Button,
@@ -69,7 +69,15 @@
   }
 
   function onSelect (res: SelectedContext | null): void {
-    value = res === null ? undefined : '$' + JSON.stringify(res)
+    if (res === null) {
+      value = undefined
+    } else {
+      try {
+        value = createDSLContext(res)
+      } catch {
+        value = '$' + JSON.stringify(res)
+      }
+    }
     dispatch('change', value)
   }
 </script>
diff --git a/plugins/process-resources/src/components/attributeEditors/ConfigurePopup.svelte b/plugins/process-resources/src/components/attributeEditors/ConfigurePopup.svelte
index 860a4d4673..281d9b23e9 100644
--- a/plugins/process-resources/src/components/attributeEditors/ConfigurePopup.svelte
+++ b/plugins/process-resources/src/components/attributeEditors/ConfigurePopup.svelte
@@ -13,7 +13,7 @@
 // limitations under the License.
 -->
 <script lang="ts">
-  import { AnyAttribute, Class, Doc, DocumentQuery, Ref } from '@hcengineering/core'
+  import core, { AnyAttribute, Class, Doc, DocumentQuery, Ref } from '@hcengineering/core'
   import { getClient } from '@hcengineering/presentation'
   import { Context, Func, Process, ProcessFunction, SelectedContext } from '@hcengineering/process'
   import {
@@ -64,11 +64,22 @@
     }
   }
 
-  const reduceFuncs = client
-    .getModel()
-    .findAllSync(plugin.class.ProcessFunction, { type: 'reduce' })
-    .filter((p) => p.category === undefined || (allowArray && p.category === 'array'))
-    .map((it) => it._id)
+  function getReduceFunctions (): Ref<ProcessFunction>[] {
+    const model = client.getModel()
+    const h = client.getHierarchy()
+    const res: Ref<ProcessFunction>[] = []
+    const all = model.findAllSync(plugin.class.ProcessFunction, { type: 'reduce' })
+    for (const f of all) {
+      if (f.category === undefined || (allowArray && f.category === 'array')) {
+        if (f.of === core.class.ArrOf || h.isDerived(f.of, attrClass)) {
+          res.push(f._id)
+        }
+      }
+    }
+    return res
+  }
+
+  const reduceFuncs = getReduceFunctions()
 
   $: availableFunctions = getAvailableFunctions(contextValue.functions, attrClass, category)
 
diff --git a/plugins/process/docs/dsl.md b/plugins/process/docs/dsl.md
new file mode 100644
index 0000000000..b18dd5838b
--- /dev/null
+++ b/plugins/process/docs/dsl.md
@@ -0,0 +1,57 @@
+Process DSL — context expressions
+
+This document describes the small DSL used to reference parts of a process execution context and to apply "modifiers" (functions, source reducers, fallbacks) to those references. The implementation lives in `src/dslContext.ts` and the tests are at `src/__tests__/dslContext.test.ts`.
+
+Overview
+--------
+
+A DSL expression is always enclosed in `${...}` when embedded. The parser and serializer in this package support converting between the typed `SelectedContext` objects and their compact DSL string.
+
+Top-level expression types
+-------------------------
+
+- Attribute: `@<key>` — references an attribute on the current object.
+  - Example: `@name`
+
+- Nested attribute: `@<refKey>.<attrKey>` — follows a reference attribute to another object and takes its attribute.
+  - Example: `@owner.id`
+
+- Relation: `$relation(<associationRef>,<direction>,<key>,<name>)`
+  - Example: `$relation(my.assoc, A, id, title)`
+
+- Execution context: `$context(<id>,<key>)`
+  - Example: `$context(12345, result)`
+
+- User request: `$userRequest(<id>,<key>,<_class>)`
+  - Example: `$userRequest(123, value, MyClass)`
+
+- Const: `#<value>,<key>` — a literal value and a target key.
+  - Numbers, booleans, `null`/`undefined`, quoted strings and arrays are supported.
+  - Example: `#42,answer` or `#"hello",greeting` or `#[1,2,3],arr`
+
+- Function as primary expression: `=><funcRef>(<props...>)`
+  - Example: `=>myFunc(a=1,b="x")`
+
+Modifiers
+---------
+
+Modifiers always start with `=>` and are appended after the main expression separated by spaces (at top-level). Examples:
+
+- Source reducer: `=>SOURCE(<funcRef>,<props...>)`
+- Fallback: `=>FALLBACK(<props...>)` or `=>FALLBACK(<value>)`
+- Arbitrary function modifiers: `=><funcRef>(<props...>)`
+
+Important parsing details
+-------------------------
+
+- Splitting into expression + modifiers is done at top-level only — the parser ignores `=>` inside nested brackets, quotes and template expressions `${...}`.
+- The tokenizer respects nested parentheses `()`, arrays `[]`, object braces `{}`, quoted strings (single/double) with escapes, and `${...}` template blocks.
+- `simplifyFuncRef` is used when serializing to shorten function references; `expandFuncRef` restores those during parsing.
+
+Examples
+--------
+
+- `${@name}` — attribute `name`
+- `${@owner.id =>MYFUNC(a=1) =>FALLBACK(10)}` — nested attribute with a function modifier and a fallback
+- `${#"he\"llo",greet}` — const string with escaped quote
+- `${=>COMPUTE(sum=1)}` — function as primary expression
diff --git a/plugins/process/src/__tests__/dslContext.test.ts b/plugins/process/src/__tests__/dslContext.test.ts
new file mode 100644
index 0000000000..957a547cc9
--- /dev/null
+++ b/plugins/process/src/__tests__/dslContext.test.ts
@@ -0,0 +1,71 @@
+import { createDSLContext, parseDSLContext } from '../dslContext'
+
+describe('dslContext roundtrip', () => {
+  test('attribute', () => {
+    const original = { type: 'attribute', key: 'name' } as any
+    const dsl = createDSLContext(original)
+    const parsed = parseDSLContext(dsl)
+    expect(parsed).toEqual(expect.objectContaining({ type: 'attribute', key: 'name' }))
+  })
+
+  test('nested', () => {
+    const original = { type: 'nested', path: 'owner', key: 'id' } as any
+    const dsl = createDSLContext(original)
+    const parsed = parseDSLContext(dsl)
+    expect(parsed).toEqual(expect.objectContaining({ type: 'nested', path: 'owner', key: 'id' }))
+  })
+
+  test('const number and string', () => {
+    const originalNum = { type: 'const', value: 42, key: 'answer' } as any
+    const dslNum = createDSLContext(originalNum)
+    const parsedNum = parseDSLContext(dslNum)
+    expect(parsedNum).toEqual(expect.objectContaining({ type: 'const', key: 'answer', value: 42 }))
+
+    const originalStr = { type: 'const', value: 'he"llo', key: 'greet' } as any
+    const dslStr = createDSLContext(originalStr)
+    const parsedStr = parseDSLContext(dslStr)
+    expect(parsedStr).toEqual(expect.objectContaining({ type: 'const', key: 'greet', value: 'he"llo' }))
+  })
+
+  test('array const', () => {
+    const original = { type: 'const', value: [1, 2, 3], key: 'arr' } as any
+    const dsl = createDSLContext(original)
+    const parsed = parseDSLContext(dsl)
+    expect(parsed).toEqual(expect.objectContaining({ type: 'const', key: 'arr', value: [1, 2, 3] }))
+  })
+
+  test('function as primary', () => {
+    const original = { type: 'function', func: 'myFunc' as any, props: { a: 1 }, key: '' } as any
+    const dsl = createDSLContext(original)
+    const parsed = parseDSLContext(dsl)
+    expect((parsed as any).type).toBe('function')
+    expect((parsed as any).func).toBeDefined()
+  })
+
+  test('modifiers SOURCE and FALLBACK and extra function', () => {
+    const original = {
+      type: 'attribute',
+      key: 'x',
+      sourceFunction: { func: 'src' as any, props: { p: 'v' } },
+      functions: [{ func: 'f1' as any, props: {} }],
+      fallbackValue: 10
+    } as any
+    const dsl = createDSLContext(original)
+    const parsed = parseDSLContext(dsl)
+    expect(parsed).toBeDefined()
+    expect((parsed as any).sourceFunction).toBeDefined()
+    expect((parsed as any).fallbackValue).toBe(10)
+    expect((parsed as any).functions?.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test('nested template with arrow inside should not split modifiers', () => {
+    // eslint-disable-next-line no-template-curly-in-string
+    const dsl = '${@x=>MYFUNC(${@inner=>OTHER()})=>FALLBACK(1)}'
+    const parsed = parseDSLContext(dsl)
+    expect(parsed).toBeDefined()
+    expect((parsed as any).type).toBe('attribute')
+    expect((parsed as any).key).toBe('x')
+    expect((parsed as any).functions?.length).toBeGreaterThanOrEqual(1)
+    expect((parsed as any).fallbackValue).toBe(1)
+  })
+})
diff --git a/plugins/process/src/dslContext.ts b/plugins/process/src/dslContext.ts
new file mode 100644
index 0000000000..c1f57ecdde
--- /dev/null
+++ b/plugins/process/src/dslContext.ts
@@ -0,0 +1,392 @@
+import { Association, Class, Doc, Ref } from '@hcengineering/core'
+import { _parseId, Resource } from '@hcengineering/platform'
+import { ProcessFunction, processId } from '.'
+import {
+  Func,
+  SelectedConst,
+  SelectedContext,
+  SelectedContextFunc,
+  SelectedExecutionContext,
+  SelectedNested,
+  SelectedRelation,
+  SelectedUserRequest
+} from './types'
+
+export function createDSLContext (context: SelectedContext): string {
+  let expression = ''
+  switch (context.type) {
+    case 'attribute': {
+      expression = `@${context.key}`
+      break
+    }
+    case 'nested': {
+      const nested = context
+      expression = `@${nested.path}.${nested.key}`
+      break
+    }
+    case 'relation': {
+      const rel = context
+      expression = `$relation(${rel.association},${rel.direction},${rel.key},${rel.name})`
+      break
+    }
+    case 'context': {
+      const ctx = context
+      expression = `$context(${ctx.id},${ctx.key})`
+      break
+    }
+    case 'const': {
+      const val = context
+      expression = `#${encodeValue(val.value)},${val.key}`
+      break
+    }
+    case 'function': {
+      const func = context
+      expression = encodeFunc(func)
+      break
+    }
+    case 'userRequest': {
+      const req = context
+      expression = `$userRequest(${req.id},${req.key},${req._class})`
+      break
+    }
+    default: {
+      throw new Error(`Unsupported SelectedContext type: ${(context as any)?.type}`)
+    }
+  }
+  const modifiers: string[] = []
+  if (context.sourceFunction !== undefined) {
+    modifiers.push(encodeSourceFunc(context.sourceFunction))
+  }
+  for (const func of context.functions ?? []) {
+    modifiers.push(encodeFunc(func))
+  }
+  if (context.fallbackValue !== undefined) {
+    modifiers.push(encodeFallback(context.fallbackValue))
+  }
+
+  const payload = modifiers.length > 0 ? `${expression}${modifiers.join('')}` : expression
+  return '${' + payload + '}'
+}
+
+function encodeValue (val: any): string {
+  if (val === null) return 'null'
+  if (val === undefined) return 'undefined'
+  if (Array.isArray(val)) {
+    return `[${val.map((v) => encodeValue(v)).join(',')}]`
+  }
+  switch (typeof val) {
+    case 'number':
+    case 'bigint':
+      return val.toString()
+    case 'boolean':
+      return val ? 'true' : 'false'
+    case 'string':
+      return `"${val.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+    case 'object':
+      try {
+        return JSON.stringify(val)
+      } catch {
+        return String(val)
+      }
+  }
+
+  return String(val)
+}
+
+function encodeSourceFunc (val: Func): string {
+  const ref = simplifyFuncRef(val.func as any)
+  const props = encodeProps(val.props)
+  return props.length > 0 ? `=>SOURCE(${ref},${props})` : `=>SOURCE(${ref})`
+}
+
+function encodeFallback (val: any): string {
+  // If fallback is a simple value, encode it directly. If it's an object, treat as props.
+  if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+    return `=>FALLBACK(${encodeProps(val)})`
+  }
+  return `=>FALLBACK(${encodeValue(val)})`
+}
+
+function encodeFunc (val: Func): string {
+  const ref = simplifyFuncRef(val.func as any)
+  const props = encodeProps(val.props ?? {})
+  return `=>${ref}(${props})`
+}
+
+function encodeProps (props: Record<string, any>): string {
+  const res: string[] = []
+  for (const [key, value] of Object.entries(props)) {
+    res.push(`${key}=${encodeValue(value)}`)
+  }
+  return res.join(',')
+}
+
+function simplifyFuncRef (val: Resource<Ref<ProcessFunction>>): string {
+  try {
+    const parsed = _parseId(val)
+    if (parsed.kind === 'function') {
+      if (parsed.component === processId) return parsed.name
+      return `${parsed.component}.${parsed.name}`
+    }
+    return `${parsed.component}.${parsed.kind}.${parsed.name}`
+  } catch {
+    return val
+  }
+}
+
+type Base<T extends SelectedContext> = Omit<T, 'fallbackValue' | 'functions' | 'sourceFunction'>
+type Modifiers = Pick<SelectedContext, 'fallbackValue' | 'functions' | 'sourceFunction'>
+
+export function parseDSLContext (dsl: string): SelectedContext | undefined {
+  let s = dsl.trim()
+  if (s.startsWith('${') && s.endsWith('}')) {
+    s = s.slice(2, -1).trim()
+  }
+
+  try {
+    const tokens = splitTopLevel(s, '=>')
+    if (tokens.length === 0) return undefined
+
+    const expr = tokens[0]
+    const modifiers = tokens.slice(1)
+
+    const base = parseExpression(expr)
+
+    const { sourceFunction, functions, fallbackValue } = parseModifiers(modifiers)
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const res: SelectedContext = {
+      ...base,
+      functions,
+      sourceFunction,
+      fallbackValue
+    } as SelectedContext
+    return res
+  } catch {
+    return undefined
+  }
+}
+
+function parseExpression (expr: string): Base<SelectedContext> {
+  if (expr.startsWith('@')) {
+    const body = expr.slice(1)
+    const dot = body.indexOf('.')
+    if (dot === -1) {
+      return { type: 'attribute', key: body }
+    }
+    const res: Base<SelectedNested> = { type: 'nested', path: body.slice(0, dot), key: body.slice(dot + 1) }
+    return res
+  }
+
+  if (expr.startsWith('#')) {
+    const lastComma = expr.lastIndexOf(',')
+    if (lastComma === -1) throw new Error('Invalid const expression')
+    const valueStr = expr.slice(1, lastComma)
+    const key = expr.slice(lastComma + 1)
+    const res: Base<SelectedConst> = { type: 'const', value: decodeValue(valueStr), key }
+    return res
+  }
+
+  if (expr.startsWith('$relation(')) {
+    const inside = expr.slice('$relation('.length, -1)
+    const parts = splitTopLevel(inside, ',')
+    const association = parts[0] as Ref<Association>
+    const direction = parts[1] as 'A' | 'B'
+    const key = parts[2]
+    const name = parts[3]
+    const res: Base<SelectedRelation> = { type: 'relation', association, direction, key, name }
+    return res
+  }
+
+  if (expr.startsWith('$context(')) {
+    const inside = expr.slice('$context('.length, -1)
+    const parts = splitTopLevel(inside, ',')
+    const id = decodeValue(parts[0])
+    const key = parts[1]
+    const res: Base<SelectedExecutionContext> = { type: 'context', id, key }
+    return res
+  }
+
+  if (expr.startsWith('$userRequest(')) {
+    const inside = expr.slice('$userRequest('.length, -1)
+    const parts = splitTopLevel(inside, ',')
+    const id = decodeValue(parts[0])
+    const key = parts[1]
+    const _class = parts[2] as Ref<Class<Doc>>
+
+    const res: Base<SelectedUserRequest> = { type: 'userRequest', id, key, _class }
+    return res
+  }
+
+  if (expr.startsWith('=>')) {
+    // function expression as primary
+    const fn = parseFuncToken(expr)
+    const res: Base<SelectedContextFunc> = { type: 'function', func: fn.func, props: fn.props, key: '' }
+    return res
+  }
+
+  throw new Error(`Unsupported DSL expression: ${expr}`)
+}
+
+function parseModifiers (modifiers: string[]): Modifiers {
+  const res: Modifiers = {}
+  for (const m of modifiers) {
+    if (m.startsWith('=>SOURCE(')) {
+      const inside = m.slice('=>SOURCE('.length, -1)
+      const parts = splitTopLevel(inside, ',')
+      const funcRef = parts[0]
+      const props = parts.length > 1 && parts[1].length > 0 ? parseProps(parts[1]) : {}
+      res.sourceFunction = { func: expandFuncRef(funcRef), props }
+    } else if (m.startsWith('=>FALLBACK(')) {
+      const inside = m.slice('=>FALLBACK('.length, -1)
+      if (inside.includes('=')) {
+        res.fallbackValue = parseProps(inside)
+      } else {
+        res.fallbackValue = decodeValue(inside)
+      }
+    } else if (m.startsWith('=>')) {
+      const fn = parseFuncToken(m)
+      res.functions = res.functions ?? []
+      res.functions.push(fn)
+    }
+  }
+  return res
+}
+
+function splitTopLevel (s: string, separator: string): string[] {
+  const res: string[] = []
+  let cur = ''
+  let depth = 0
+  let quote: string | null = null
+  let escaped = false
+  let templateDepth = 0
+
+  const sep = separator
+
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+
+    if (quote !== null) {
+      cur += ch
+      if (escaped) {
+        escaped = false
+        continue
+      }
+      if (ch === '\\') {
+        escaped = true
+        continue
+      }
+      if (ch === quote) quote = null
+      continue
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      cur += ch
+      escaped = false
+      continue
+    }
+
+    if (ch === '$' && s[i + 1] === '{') {
+      cur += '${'
+      templateDepth++
+      depth++
+      i++
+      continue
+    }
+
+    if (ch === '(' || ch === '[' || ch === '{') {
+      depth++
+      cur += ch
+      continue
+    }
+
+    if (ch === ')' || ch === ']' || ch === '}') {
+      if (ch === '}' && templateDepth > 0) templateDepth--
+      depth = Math.max(0, depth - 1)
+      cur += ch
+      continue
+    }
+
+    if (depth === 0 && templateDepth === 0) {
+      if (sep.length === 1) {
+        if (ch === sep) {
+          res.push(cur.trim())
+          cur = ''
+          continue
+        }
+      } else {
+        if (s.substring(i, i + sep.length) === sep) {
+          if (cur.length > 0) res.push(cur)
+          cur = sep
+          i += sep.length - 1
+          continue
+        }
+      }
+    }
+
+    cur += ch
+  }
+
+  if (cur.length > 0) res.push(cur.trim())
+  return res
+}
+
+function parseFuncToken (token: string): Func {
+  const body = token.slice(2)
+  const open = body.indexOf('(')
+  if (open === -1) {
+    return { func: expandFuncRef(body), props: {} }
+  }
+  const ref = body.slice(0, open)
+  const inside = body.slice(open + 1, -1)
+  const props = inside.length > 0 ? parseProps(inside) : {}
+  return { func: expandFuncRef(ref), props }
+}
+
+function parseProps (s: string): Record<string, any> {
+  const out: Record<string, any> = {}
+  if (s.trim().length === 0) return out
+  const parts = splitTopLevel(s, ',')
+  for (const p of parts) {
+    const eq = p.indexOf('=')
+    if (eq === -1) continue
+    const key = p.slice(0, eq)
+    const valStr = p.slice(eq + 1)
+    out[key] = decodeValue(valStr)
+  }
+  return out
+}
+
+function decodeValue (s: string): any {
+  const str = s.trim()
+  if (str === 'null') return null
+  if (str === 'undefined') return undefined
+  if (str === 'true') return true
+  if (str === 'false') return false
+  if (/^-?\d+(?:\.\d+)?$/.test(str)) {
+    const n = Number(str)
+    return Number.isNaN(n) ? str : n
+  }
+  if (str.startsWith('"') && str.endsWith('"')) {
+    return str.slice(1, -1).replace(/\\"/g, '"')
+  }
+  if (str.startsWith('[') && str.endsWith(']')) {
+    const inner = str.slice(1, -1).trim()
+    if (inner === '') return []
+    return inner.split(',').map(decodeValue)
+  }
+  return str
+}
+
+function expandFuncRef (val: any): Ref<ProcessFunction> {
+  if (typeof val !== 'string') return val as Ref<ProcessFunction>
+  const parts = val.split('.')
+  if (parts.length === 1) {
+    return `${processId}:function:${val}` as Ref<ProcessFunction>
+  }
+  if (parts.length === 2) {
+    return `${parts[0]}:function:${parts[1]}` as Ref<ProcessFunction>
+  }
+  return val.replaceAll('.', ':') as Ref<ProcessFunction>
+}
diff --git a/plugins/process/src/index.ts b/plugins/process/src/index.ts
index e53c38c111..c0e29638b6 100644
--- a/plugins/process/src/index.ts
+++ b/plugins/process/src/index.ts
@@ -194,6 +194,7 @@ export interface UpdateCriteriaComponent extends Doc {
 export * from './errors'
 export * from './types'
 export * from './utils'
+export * from './dslContext'
 
 export default plugin(processId, {
   class: {
diff --git a/plugins/process/src/utils.ts b/plugins/process/src/utils.ts
index d025963a3a..2c9507a70c 100644
--- a/plugins/process/src/utils.ts
+++ b/plugins/process/src/utils.ts
@@ -2,6 +2,7 @@ import { Tx, TxUpdateDoc } from '@hcengineering/core/types/tx'
 import { SelectedContext } from './types'
 import core from '@hcengineering/core'
 import { Card } from '@hcengineering/card'
+import { parseDSLContext } from './dslContext'
 
 export function parseContext (value: any): SelectedContext | undefined {
   if (value === undefined) return
@@ -15,7 +16,9 @@ export function parseContext (value: any): SelectedContext | undefined {
     const res = JSON.parse(content) as SelectedContext
     if (res.type === undefined) return
     return res
-  } catch {}
+  } catch {
+    return parseDSLContext(value)
+  }
 }
 
 export function isUpdateTx (etx: Tx): etx is TxUpdateDoc<Card> {