@nocobase/plugin-flow-engine 2.2.0-beta.5 → 2.2.0-beta.6

package/dist/server/flow-surfaces/service.js

@@ -689,6 +689,7 @@ function assertNoFlowSurfaceIdTitleFieldSettings(value, options = {}) {
   };
   visit(value, options.basePath || []);
 }
+const DEFAULT_ADMIN_UI_LAYOUT_UID = "admin-layout-model";
 class FlowSurfacesService {
   constructor(plugin) {
     this.plugin = plugin;
@@ -1030,6 +1031,101 @@ class FlowSurfacesService {
       ...extras
     };
   }
+  hasDesktopRouteUiLayoutsRelation() {
+    var _a, _b;
+    try {
+      return !!this.db.getCollection("uiLayouts") && !!((_b = (_a = this.db.getCollection("desktopRoutes")) == null ? void 0 : _a.getField) == null ? void 0 : _b.call(_a, "uiLayouts"));
+    } catch (error) {
+      return false;
+    }
+  }
+  normalizeDesktopRouteRelationId(routeId) {
+    return import_lodash.default.isNil(routeId) ? void 0 : routeId;
+  }
+  async readDesktopRouteUiLayoutUids(routeId, transaction) {
+    const relationRouteId = this.normalizeDesktopRouteRelationId(routeId);
+    if (import_lodash.default.isUndefined(relationRouteId) || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const uiLayouts = await this.db.getRepository("desktopRoutes.uiLayouts", relationRouteId).find({
+      fields: ["uid"],
+      transaction
+    });
+    return import_lodash.default.uniq(
+      uiLayouts.map((uiLayout) => {
+        var _a;
+        return String(((_a = uiLayout == null ? void 0 : uiLayout.get) == null ? void 0 : _a.call(uiLayout, "uid")) || (uiLayout == null ? void 0 : uiLayout.uid) || "").trim();
+      }).filter(Boolean)
+    );
+  }
+  async resolveDefaultDesktopRouteUiLayoutUids(transaction) {
+    if (!this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const defaultLayout = await this.db.getRepository("uiLayouts").findOne({
+      filter: {
+        uid: DEFAULT_ADMIN_UI_LAYOUT_UID,
+        enabled: true
+      },
+      transaction
+    });
+    return defaultLayout ? [DEFAULT_ADMIN_UI_LAYOUT_UID] : [];
+  }
+  async resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction) {
+    const parentRouteId = this.readRouteField(parentRoute, "id");
+    if (!import_lodash.default.isNil(parentRouteId)) {
+      const parentLayoutUids = await this.readDesktopRouteUiLayoutUids(parentRouteId, transaction);
+      if (parentLayoutUids.length) {
+        return parentLayoutUids;
+      }
+    }
+    return this.resolveDefaultDesktopRouteUiLayoutUids(transaction);
+  }
+  async setDesktopRouteUiLayouts(routeId, uiLayoutUids, transaction) {
+    const relationRouteId = this.normalizeDesktopRouteRelationId(routeId);
+    if (import_lodash.default.isUndefined(relationRouteId) || !uiLayoutUids.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return;
+    }
+    await this.db.getRepository("desktopRoutes.uiLayouts", relationRouteId).set({
+      tk: uiLayoutUids,
+      transaction
+    });
+  }
+  async attachDesktopRouteUiLayoutsToRouteAndChildren(routeId, uiLayoutUids, transaction) {
+    if (import_lodash.default.isNil(routeId) || !uiLayoutUids.length || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return;
+    }
+    await this.setDesktopRouteUiLayouts(routeId, uiLayoutUids, transaction);
+    const children = await this.db.getRepository("desktopRoutes").find({
+      fields: ["id"],
+      filter: {
+        parentId: routeId
+      },
+      transaction
+    });
+    for (const child of children) {
+      await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+        this.readRouteField(child, "id"),
+        uiLayoutUids,
+        transaction
+      );
+    }
+  }
+  async ensureDesktopRouteUiLayouts(route, transaction) {
+    const routeId = this.readRouteField(route, "id");
+    if (import_lodash.default.isNil(routeId) || !this.hasDesktopRouteUiLayoutsRelation()) {
+      return [];
+    }
+    const existingLayoutUids = await this.readDesktopRouteUiLayoutUids(routeId, transaction);
+    if (existingLayoutUids.length) {
+      return existingLayoutUids;
+    }
+    const parentRouteId = this.readRouteField(route, "parentId");
+    const parentRoute = import_lodash.default.isNil(parentRouteId) ? null : await this.findMenuRouteById(parentRouteId, transaction);
+    const inheritedLayoutUids = await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction);
+    await this.setDesktopRouteUiLayouts(routeId, inheritedLayoutUids, transaction);
+    return inheritedLayoutUids;
+  }
   isValidMenuIconName(value) {
     const normalized = String(value || "").trim();
     return !!normalized && ANT_DESIGN_ICON_NAMES.has(normalized);
@@ -1111,7 +1207,7 @@ class FlowSurfacesService {
     this.assertVisibleNavigationIcon("createMenu", "values", values);
     const schemaUid = values.schemaUid || (0, import_utils.uid)();
     const desktopRoutes = this.db.getRepository("desktopRoutes");
-    await desktopRoutes.create({
+    const route = await desktopRoutes.create({
       values: {
         type: "group",
         sort: this.allocateRouteSortValue(),
@@ -1124,10 +1220,11 @@ class FlowSurfacesService {
       },
       transaction
     });
-    const route = await desktopRoutes.findOne({
-      filter: { schemaUid },
+    await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+      this.readRouteField(route, "id"),
+      await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction),
       transaction
-    });
+    );
     return this.buildMenuResult(route);
   }
   async createFlowMenuItem(values, transaction) {
@@ -1142,7 +1239,7 @@ class FlowSurfacesService {
     const title = values.title || pageSchemaUid;
     const tabTitle = values.tabTitle || "Untitled";
     const desktopRoutes = this.db.getRepository("desktopRoutes");
-    await desktopRoutes.create({
+    const createdRoute = await desktopRoutes.create({
       values: {
         type: "flowPage",
         sort: this.allocateRouteSortValue(),
@@ -1177,6 +1274,11 @@ class FlowSurfacesService {
       },
       transaction
     });
+    await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+      this.readRouteField(createdRoute, "id"),
+      await this.resolveInheritedDesktopRouteUiLayoutUids(parentRoute, transaction),
+      transaction
+    );
     const route = await desktopRoutes.findOne({
       filter: { schemaUid: pageSchemaUid },
       appends: ["children"],
@@ -5879,7 +5981,7 @@ class FlowSurfacesService {
       (0, import_errors.throwBadRequest)("flowSurfaces updateMenu requires menuRouteId");
     }
     const route = await this.assertMenuRouteUpdatable(menuRouteId, options.transaction);
-    await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
+    const nextParentRoute = await this.assertMenuParentIsGroup(values.parentMenuRouteId, options.transaction);
     await this.assertMenuParentNotSelfOrDescendant(route, values.parentMenuRouteId, options.transaction);
     const nextOptions = { ...this.readRouteOptions(route) };
     const updateValues = {};
@@ -5910,6 +6012,13 @@ class FlowSurfacesService {
       });
     }
     const updated = await this.findMenuRouteById(menuRouteId, options.transaction);
+    if (updated && Object.prototype.hasOwnProperty.call(values, "parentMenuRouteId")) {
+      await this.attachDesktopRouteUiLayoutsToRouteAndChildren(
+        this.readRouteField(updated, "id"),
+        await this.resolveInheritedDesktopRouteUiLayoutUids(nextParentRoute, options.transaction),
+        options.transaction
+      );
+    }
     return this.buildMenuResult(updated);
   }
   async initializeFlowPageForRoute(route, values, transaction) {
@@ -5917,6 +6026,7 @@ class FlowSurfacesService {
     const pageSchemaUid = this.readRouteField(route, "schemaUid");
     const structure = await this.loadRouteBackedPageStructure(route, transaction);
     let tabRoute = structure.tabRoutes[0];
+    const routeUiLayoutUids = await this.ensureDesktopRouteUiLayouts(route, transaction);
     const routeOptions = this.readRouteOptions(route);
     if (!routeOptions[FLOW_SURFACE_MENU_BINDABLE_OPTION_KEY]) {
       (0, import_errors.throwBadRequest)(`flowSurfaces createPage only accepts a bindable menu route created by createMenu(type="item")`);
@@ -5938,7 +6048,7 @@ class FlowSurfacesService {
       const tabSchemaUid2 = values.tabSchemaUid || (0, import_utils.uid)();
       const tabSchemaName2 = values.tabSchemaName || (0, import_utils.uid)();
       const tabTitle = values.tabTitle || "Untitled";
-      await this.db.getRepository("desktopRoutes").create({
+      tabRoute = await this.db.getRepository("desktopRoutes").create({
         values: {
           type: "tabs",
           sort: this.allocateRouteSortValue(1),
@@ -5955,10 +6065,7 @@ class FlowSurfacesService {
         },
         transaction
       });
-      tabRoute = await this.db.getRepository("desktopRoutes").findOne({
-        filter: { schemaUid: tabSchemaUid2 },
-        transaction
-      });
+      await this.setDesktopRouteUiLayouts(this.readRouteField(tabRoute, "id"), routeUiLayoutUids, transaction);
     } else {
       await this.db.getRepository("desktopRoutes").update({
         filterByTk: String(this.readRouteField(tabRoute, "id")),
@@ -5982,6 +6089,9 @@ class FlowSurfacesService {
         transaction
       });
     }
+    if (tabRoute) {
+      await this.setDesktopRouteUiLayouts(this.readRouteField(tabRoute, "id"), routeUiLayoutUids, transaction);
+    }
     await this.ensureFlowRoutePageSchemaShell(pageSchemaUid, transaction);
     await this.db.getRepository("desktopRoutes").update({
       filterByTk: String(routeId),
@@ -6121,6 +6231,11 @@ class FlowSurfacesService {
       },
       transaction: options.transaction
     });
+    await this.setDesktopRouteUiLayouts(
+      route.get("id"),
+      await this.ensureDesktopRouteUiLayouts(pageRoute, options.transaction),
+      options.transaction
+    );
     const gridUid = await this.ensureGridChild(tabSchemaUid, "BlockGridModel", options.transaction);
     const result = {
       pageUid: pageTarget.uid,
@@ -11524,6 +11639,7 @@ class FlowSurfacesService {
     }
     if (this.isAIEmployeeActionUse(current == null ? void 0 : current.use) && this.hasAIEmployeePublicSettings(normalizedValues)) {
       const enabledPackages = await this.resolveEnabledPluginPackages(options);
+      const hasRawAIEmployeeStepTasks = import_lodash.default.has(normalizedValues, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
       const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
         "updateSettings",
         import_lodash.default.pick(normalizedValues, AI_EMPLOYEE_PUBLIC_SETTING_KEYS),
@@ -11536,7 +11652,8 @@ class FlowSurfacesService {
           promptContext: {
             kind: "target",
             targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
-          }
+          },
+          skipExistingTaskWorkContextRebase: hasRawAIEmployeeStepTasks
         }
       );
       AI_EMPLOYEE_PUBLIC_SETTING_KEYS.forEach((key) => {
@@ -11670,6 +11787,12 @@ class FlowSurfacesService {
     if (Object.keys(nextPayload).length === 1) {
       return { uid: current.uid };
     }
+    await this.assertNoDuplicateAIEmployeeActionForUpdateSettings(
+      options.openViewActionName || "updateSettings",
+      current,
+      effectiveNode,
+      options.transaction
+    );
     if (target.kind === "tab" && target.tabRoute) {
       await this.routeSync.persistTabSettings(target, current, nextPayload, options.transaction);
       return {
@@ -17709,19 +17832,21 @@ class FlowSurfacesService {
     }
     return JSON.stringify(value);
   }
-  buildAIEmployeeActionDedupIdentity(values) {
+  buildAIEmployeeActionDedupIdentity(values, defaultActionWorkContext) {
     var _a, _b, _c, _d, _e, _f;
     const username = String(((_b = (_a = values == null ? void 0 : values.props) == null ? void 0 : _a.aiEmployee) == null ? void 0 : _b.username) || "").trim();
     if (!username) {
       return "";
     }
+    const workContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_d = (_c = values == null ? void 0 : values.props) == null ? void 0 : _c.context) == null ? void 0 : _d.workContext,
+      defaultActionWorkContext
+    );
     return this.stableSerializeAIEmployeeValue({
       username,
-      auto: typeof ((_c = values == null ? void 0 : values.props) == null ? void 0 : _c.auto) === "boolean" ? values.props.auto : false,
-      workContext: this.normalizeAIEmployeeWorkContextForDedupIdentity((_e = (_d = values == null ? void 0 : values.props) == null ? void 0 : _d.context) == null ? void 0 : _e.workContext),
-      tasks: this.normalizeAIEmployeeTasksForDedupIdentity(
-        import_lodash.default.get(values, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])
-      ),
+      auto: typeof ((_e = values == null ? void 0 : values.props) == null ? void 0 : _e.auto) === "boolean" ? values.props.auto : false,
+      workContext,
+      tasks: this.normalizeAIEmployeeTasksForDedupIdentity(this.readAIEmployeePersistedTasks(values), workContext),
       style: {
         ...AI_EMPLOYEE_DEFAULT_STYLE,
         ...import_lodash.default.isPlainObject((_f = values == null ? void 0 : values.props) == null ? void 0 : _f.style) ? import_lodash.default.pick(values.props.style, AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
@@ -17729,11 +17854,35 @@ class FlowSurfacesService {
     });
   }
   normalizeAIEmployeeWorkContextForDedupIdentity(value) {
-    return import_lodash.default.castArray(value || []).map(
-      (item) => import_lodash.default.isPlainObject(item) ? import_lodash.default.pick(item, AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS) : item
-    );
+    return import_lodash.default.castArray(value || []).map((item) => {
+      if (!import_lodash.default.isPlainObject(item)) {
+        return item;
+      }
+      const output = import_lodash.default.pick(item, AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS);
+      if (!Object.prototype.hasOwnProperty.call(output, "type") || import_lodash.default.isUndefined(output.type) || output.type === null) {
+        output.type = "flow-model";
+      }
+      return output;
+    });
+  }
+  normalizeAIEmployeeActionWorkContextForDedupIdentity(value, defaultWorkContext) {
+    if (!Array.isArray(value)) {
+      return import_lodash.default.cloneDeep(defaultWorkContext || []);
+    }
+    return this.normalizeAIEmployeeWorkContextForDedupIdentity(value);
   }
-  normalizeAIEmployeeTasksForDedupIdentity(value) {
+  normalizeAIEmployeeDefaultActionWorkContextForSelfUid(selfUid) {
+    const uid2 = String(selfUid || "").trim();
+    return uid2 ? [{ type: "flow-model", uid: uid2 }] : [];
+  }
+  normalizeAIEmployeeTaskWorkContextForDedupIdentity(value, defaultWorkContext) {
+    const normalized = this.normalizeAIEmployeeWorkContextForDedupIdentity(value);
+    if (Array.isArray(defaultWorkContext) && !normalized.length) {
+      return import_lodash.default.cloneDeep(defaultWorkContext);
+    }
+    return normalized;
+  }
+  normalizeAIEmployeeTasksForDedupIdentity(value, defaultWorkContext) {
     return import_lodash.default.castArray(value || []).map((task) => {
       if (!import_lodash.default.isPlainObject(task)) {
         return task;
@@ -17742,9 +17891,19 @@ class FlowSurfacesService {
       if (import_lodash.default.isPlainObject(output.message)) {
         output.message = import_lodash.default.pick(output.message, AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS);
         if (Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
-          output.message.workContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(output.message.workContext);
+          output.message.workContext = this.normalizeAIEmployeeTaskWorkContextForDedupIdentity(
+            output.message.workContext,
+            defaultWorkContext
+          );
         }
       }
+      if (!import_lodash.default.isPlainObject(output.message) && Array.isArray(defaultWorkContext)) {
+        output.message = {
+          workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+        };
+      } else if (import_lodash.default.isPlainObject(output.message) && !Object.prototype.hasOwnProperty.call(output.message, "workContext")) {
+        output.message.workContext = import_lodash.default.cloneDeep(defaultWorkContext || []);
+      }
       if (import_lodash.default.isPlainObject(output.model)) {
         output.model = import_lodash.default.pick(output.model, AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS);
       }
@@ -17754,25 +17913,38 @@ class FlowSurfacesService {
       return output;
     });
   }
-  async assertNoDuplicateAIEmployeeAction(actionName, parentUid, values, transaction) {
+  async assertNoDuplicateAIEmployeeAction(actionName, parentUid, values, transaction, excludeUid) {
     var _a;
-    const identity = this.buildAIEmployeeActionDedupIdentity(values);
-    if (!identity) {
-      return;
-    }
     const parentNode = await this.repository.findModelById(parentUid, {
       transaction,
       includeAsyncNode: true
     });
-    const duplicate = import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a.actions) || []).find((action) => {
+    const defaultActionWorkContext = this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(
+      await this.resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction)
+    );
+    const identity = this.buildAIEmployeeActionDedupIdentity(values, defaultActionWorkContext);
+    if (!identity) {
+      return;
+    }
+    let duplicate;
+    for (const action of import_lodash.default.castArray(((_a = parentNode == null ? void 0 : parentNode.subModels) == null ? void 0 : _a.actions) || [])) {
       if (!this.isAIEmployeeActionUse(action == null ? void 0 : action.use)) {
-        return false;
+        continue;
       }
-      return this.buildAIEmployeeActionDedupIdentity({
-        props: action.props,
-        stepParams: action.stepParams
-      }) === identity;
-    });
+      if (excludeUid && String((action == null ? void 0 : action.uid) || "") === excludeUid) {
+        continue;
+      }
+      if (this.buildAIEmployeeActionDedupIdentity(
+        {
+          props: action.props,
+          stepParams: action.stepParams
+        },
+        defaultActionWorkContext
+      ) === identity) {
+        duplicate = action;
+        break;
+      }
+    }
     if (!(duplicate == null ? void 0 : duplicate.uid)) {
       return;
     }
@@ -17787,6 +17959,25 @@ class FlowSurfacesService {
       }
     );
   }
+  async assertNoDuplicateAIEmployeeActionForUpdateSettings(actionName, current, effectiveNode, transaction) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      return;
+    }
+    const parentUid = String((current == null ? void 0 : current.parentId) || "").trim() || ((current == null ? void 0 : current.uid) ? await this.locator.findParentUid(current.uid, transaction).catch(() => "") : "");
+    if (!parentUid) {
+      return;
+    }
+    await this.assertNoDuplicateAIEmployeeAction(
+      actionName,
+      parentUid,
+      {
+        props: effectiveNode == null ? void 0 : effectiveNode.props,
+        stepParams: effectiveNode == null ? void 0 : effectiveNode.stepParams
+      },
+      transaction,
+      String((current == null ? void 0 : current.uid) || "")
+    );
+  }
   hasAIEmployeePublicSettings(settings) {
     return import_lodash.default.isPlainObject(settings) && AI_EMPLOYEE_PUBLIC_SETTING_KEYS.some((key) => Object.prototype.hasOwnProperty.call(settings, key));
   }
@@ -17841,11 +18032,24 @@ class FlowSurfacesService {
     var _a;
     const stepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
     if (Array.isArray(stepTasks)) {
-      return stepTasks;
+      return this.normalizeAIEmployeeLegacyInheritedTaskWorkContext(stepTasks);
     }
-    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const legacyPropsTasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext((_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks);
     return Array.isArray(legacyPropsTasks) ? legacyPropsTasks : [];
   }
+  normalizeAIEmployeeLegacyInheritedTaskWorkContext(tasks) {
+    if (!Array.isArray(tasks)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      if (!import_lodash.default.isPlainObject(task) || !import_lodash.default.isPlainObject(task.message) || task.message.workContext !== null) {
+        return task;
+      }
+      const nextTask = import_lodash.default.cloneDeep(task);
+      delete nextTask.message.workContext;
+      return nextTask;
+    });
+  }
   buildAIEmployeeTaskStepParams(tasks) {
     const stepParams = {};
     import_lodash.default.set(stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH, import_lodash.default.cloneDeep(tasks));
@@ -17874,7 +18078,7 @@ class FlowSurfacesService {
     if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
       return;
     }
-    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const legacyPropsTasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext((_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks);
     const hasLegacyPropsTasks = Array.isArray(legacyPropsTasks);
     const hasNextStepTasks = import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
     const currentStepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
@@ -18046,6 +18250,20 @@ class FlowSurfacesService {
       };
     });
   }
+  normalizeAIEmployeeEffectiveActionWorkContext(actionName, settings, currentProps, options) {
+    var _a;
+    const hasSettingsWorkContext = Object.prototype.hasOwnProperty.call(settings, "workContext");
+    const currentWorkContext = (_a = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _a.workContext;
+    if (!hasSettingsWorkContext && !Array.isArray(currentWorkContext) && !options.requireUsername && !options.selfUid) {
+      return void 0;
+    }
+    const rawWorkContext = hasSettingsWorkContext ? settings.workContext : Array.isArray(currentWorkContext) ? currentWorkContext : [{ type: "flow-model", target: "self" }];
+    return this.normalizeAIEmployeeWorkContext(actionName, rawWorkContext, {
+      selfUid: options.selfUid,
+      keyMap: options.keyMap,
+      path: "settings.workContext"
+    });
+  }
   normalizeAIEmployeeTaskModel(actionName, path, value) {
     if (import_lodash.default.isUndefined(value) || value === null) {
       return value;
@@ -18361,6 +18579,7 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     );
   }
   async normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options) {
+    var _a, _b, _c, _d;
     if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
       return;
     }
@@ -18369,15 +18588,63 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       return;
     }
     const actionName = options.openViewActionName || "updateSettings";
-    const normalizedTasks = this.normalizeAIEmployeeTasks(
+    const selfUid = await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction);
+    const currentPropsForDefault = import_lodash.default.mergeWith(
+      {},
+      import_lodash.default.isPlainObject(current == null ? void 0 : current.props) ? current.props : {},
+      import_lodash.default.isPlainObject(nextPayload.props) ? nextPayload.props : {},
+      (_currentValue, nextValue) => {
+        if (Array.isArray(nextValue)) {
+          return import_lodash.default.cloneDeep(nextValue);
+        }
+        return void 0;
+      }
+    );
+    const defaultWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
       actionName,
-      tasks,
-      this.readAIEmployeePersistedTasks(current),
+      {},
+      currentPropsForDefault,
       {
-        selfUid: await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction),
-        path: "stepParams.shortcutSettings.editTasks.tasks"
+        selfUid,
+        requireUsername: true
       }
     );
+    const currentTasks = this.readAIEmployeePersistedTasks(current);
+    const previousActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_b = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.context) == null ? void 0 : _b.workContext,
+      this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(selfUid)
+    );
+    const nextActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_c = currentPropsForDefault == null ? void 0 : currentPropsForDefault.context) == null ? void 0 : _c.workContext,
+      defaultWorkContext
+    );
+    if (Array.isArray(defaultWorkContext) && !import_lodash.default.isEqual((_d = currentPropsForDefault == null ? void 0 : currentPropsForDefault.context) == null ? void 0 : _d.workContext, defaultWorkContext)) {
+      nextPayload.props = import_lodash.default.mergeWith(
+        {},
+        currentPropsForDefault,
+        {
+          context: {
+            workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+          }
+        },
+        (_currentValue, nextValue) => {
+          if (Array.isArray(nextValue)) {
+            return import_lodash.default.cloneDeep(nextValue);
+          }
+          return void 0;
+        }
+      );
+    }
+    const currentTasksForNormalization = this.rebaseAIEmployeeInheritedTaskWorkContext(
+      currentTasks,
+      previousActionWorkContext,
+      nextActionWorkContext
+    );
+    const normalizedTasks = this.normalizeAIEmployeeTasks(actionName, tasks, currentTasksForNormalization, {
+      selfUid,
+      defaultWorkContext,
+      path: "stepParams.shortcutSettings.editTasks.tasks"
+    });
     import_lodash.default.set(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH], normalizedTasks);
   }
   normalizeAIEmployeeTaskMessage(actionName, path, value, existing, options) {
@@ -18406,13 +18673,18 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     if (Object.prototype.hasOwnProperty.call(nextMessage, "user") && typeof nextMessage.user !== "string") {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.user must be a string`);
     }
-    if (Object.prototype.hasOwnProperty.call(value, "workContext")) {
+    if (value.workContext === null) {
+      delete nextMessage.workContext;
+    } else if (Object.prototype.hasOwnProperty.call(value, "workContext")) {
       nextMessage.workContext = this.normalizeAIEmployeeWorkContext(actionName, value.workContext, {
         selfUid: options.selfUid,
         keyMap: options.keyMap,
         path: `${path}.workContext`
       });
     }
+    if (!Object.prototype.hasOwnProperty.call(nextMessage, "workContext") && this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(options.defaultWorkContext)) {
+      nextMessage.workContext = import_lodash.default.cloneDeep(options.defaultWorkContext);
+    }
     return nextMessage;
   }
   normalizeAIEmployeeTaskPatch(actionName, patch, existing, options) {
@@ -18436,7 +18708,8 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       if (key === "message") {
         next.message = this.normalizeAIEmployeeTaskMessage(actionName, `${options.path}.message`, value, next.message, {
           selfUid: options.selfUid,
-          keyMap: options.keyMap
+          keyMap: options.keyMap,
+          defaultWorkContext: options.defaultWorkContext
         });
         return;
       }
@@ -18486,6 +18759,9 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     if (!import_lodash.default.isPlainObject(next.message)) {
       next.message = {};
     }
+    if (!Object.prototype.hasOwnProperty.call(next.message, "workContext") && this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(options.defaultWorkContext)) {
+      next.message.workContext = import_lodash.default.cloneDeep(options.defaultWorkContext);
+    }
     if (import_lodash.default.isPlainObject(next.skillSettings)) {
       if (Array.isArray(next.skillSettings.skills) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "skillsVersion")) {
         next.skillSettings.skillsVersion = 2;
@@ -18512,10 +18788,52 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       nextTasks[index] = this.normalizeAIEmployeeTaskPatch(actionName, task, existingTasks[index], {
         selfUid: options.selfUid,
         keyMap: options.keyMap,
-        path: `${options.path}[${index}]`
+        path: `${options.path}[${index}]`,
+        defaultWorkContext: options.defaultWorkContext
       });
     });
-    return nextTasks;
+    return this.withAIEmployeeTaskDefaultWorkContext(nextTasks, options.defaultWorkContext);
+  }
+  withAIEmployeeTaskDefaultWorkContext(tasks, defaultWorkContext) {
+    const nextTasks = Array.isArray(tasks) ? import_lodash.default.cloneDeep(tasks) : [];
+    if (!this.shouldMaterializeAIEmployeeTaskDefaultWorkContext(defaultWorkContext)) {
+      return nextTasks;
+    }
+    return nextTasks.map((task) => {
+      if (!import_lodash.default.isPlainObject(task)) {
+        return task;
+      }
+      const nextTask = import_lodash.default.cloneDeep(task);
+      if (!import_lodash.default.isPlainObject(nextTask.message)) {
+        nextTask.message = {
+          workContext: import_lodash.default.cloneDeep(defaultWorkContext)
+        };
+      } else if (!Object.prototype.hasOwnProperty.call(nextTask.message, "workContext")) {
+        nextTask.message.workContext = import_lodash.default.cloneDeep(defaultWorkContext);
+      }
+      return nextTask;
+    });
+  }
+  shouldMaterializeAIEmployeeTaskDefaultWorkContext(defaultWorkContext) {
+    return Array.isArray(defaultWorkContext) && defaultWorkContext.length > 0;
+  }
+  rebaseAIEmployeeInheritedTaskWorkContext(currentTasks, previousActionWorkContext, nextActionWorkContext) {
+    const tasks = this.normalizeAIEmployeeLegacyInheritedTaskWorkContext(currentTasks) || [];
+    if (!previousActionWorkContext.length || import_lodash.default.isEqual(previousActionWorkContext, nextActionWorkContext)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      const nextTask = import_lodash.default.cloneDeep(task);
+      if (import_lodash.default.isPlainObject(nextTask == null ? void 0 : nextTask.message)) {
+        const currentTaskWorkContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(
+          nextTask.message.workContext
+        );
+        if (import_lodash.default.isEqual(currentTaskWorkContext, previousActionWorkContext)) {
+          delete nextTask.message.workContext;
+        }
+      }
+      return nextTask;
+    });
   }
   normalizeAIEmployeeActionSettingsReferences(actionName, settings, options) {
     if (!this.hasAIEmployeePublicSettings(settings)) {
@@ -18529,15 +18847,22 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       });
     }
     if (Object.prototype.hasOwnProperty.call(nextSettings, "tasks")) {
+      const defaultWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
+        actionName,
+        nextSettings,
+        {},
+        options
+      );
       nextSettings.tasks = this.normalizeAIEmployeeTasks(actionName, nextSettings.tasks, [], {
         ...options,
-        path: "settings.tasks"
+        path: "settings.tasks",
+        defaultWorkContext
       });
     }
     return nextSettings;
   }
   async normalizeAIEmployeeActionPublicSettings(actionName, settings, options) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     this.assertAIEmployeePluginEnabled(actionName, options.enabledPackages);
     if (!import_lodash.default.isPlainObject(settings)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} AI employee settings must be an object`);
@@ -18557,6 +18882,17 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
     }
     const props = {};
     const stepParams = {};
+    const effectiveActionWorkContext = this.normalizeAIEmployeeEffectiveActionWorkContext(
+      actionName,
+      settings,
+      currentProps,
+      options
+    );
+    const previousActionWorkContext = this.normalizeAIEmployeeActionWorkContextForDedupIdentity(
+      (_c = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _c.workContext,
+      this.normalizeAIEmployeeDefaultActionWorkContextForSelfUid(options.selfUid)
+    );
+    const nextActionWorkContext = this.normalizeAIEmployeeWorkContextForDedupIdentity(effectiveActionWorkContext);
     if (effectiveUsername && (hasUsername || options.requireUsername)) {
       props.aiEmployee = {
         ...import_lodash.default.isPlainObject(currentProps.aiEmployee) ? import_lodash.default.cloneDeep(currentProps.aiEmployee) : {},
@@ -18570,28 +18906,25 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       }
       props.auto = auto;
     }
-    if (Object.prototype.hasOwnProperty.call(settings, "workContext") || options.requireUsername) {
-      const rawWorkContext = Object.prototype.hasOwnProperty.call(settings, "workContext") ? settings.workContext : [{ type: "flow-model", target: "self" }];
+    if (Array.isArray(effectiveActionWorkContext) && (Object.prototype.hasOwnProperty.call(settings, "workContext") || options.requireUsername || !import_lodash.default.isEqual((_d = currentProps == null ? void 0 : currentProps.context) == null ? void 0 : _d.workContext, effectiveActionWorkContext))) {
       props.context = {
         ...import_lodash.default.isPlainObject(currentProps.context) ? import_lodash.default.cloneDeep(currentProps.context) : {},
-        workContext: this.normalizeAIEmployeeWorkContext(actionName, rawWorkContext, {
-          selfUid: options.selfUid,
-          keyMap: options.keyMap,
-          path: "settings.workContext"
-        })
+        workContext: import_lodash.default.cloneDeep(effectiveActionWorkContext)
       };
     }
     if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
-      const normalizedTasks = this.normalizeAIEmployeeTasks(
-        actionName,
-        settings.tasks,
-        this.readAIEmployeePersistedTasks(options.current),
-        {
-          selfUid: options.selfUid,
-          keyMap: options.keyMap,
-          path: "settings.tasks"
-        }
+      const currentTasks = this.readAIEmployeePersistedTasks(options.current);
+      const currentTasksForNormalization = this.rebaseAIEmployeeInheritedTaskWorkContext(
+        currentTasks,
+        previousActionWorkContext,
+        nextActionWorkContext
       );
+      const normalizedTasks = this.normalizeAIEmployeeTasks(actionName, settings.tasks, currentTasksForNormalization, {
+        selfUid: options.selfUid,
+        keyMap: options.keyMap,
+        path: "settings.tasks",
+        defaultWorkContext: effectiveActionWorkContext
+      });
       const validation = options.promptContext && normalizedTasks.length ? await this.buildAIEmployeePromptValidationContext(
         actionName,
         [
@@ -18612,6 +18945,17 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       const tasks = this.appendAIEmployeeCurrentRecordPromptVariableToTasks(normalizedTasks, validation);
       this.assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation);
       import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
+    } else if (!options.skipExistingTaskWorkContextRebase && Object.prototype.hasOwnProperty.call(settings, "workContext") && !import_lodash.default.isEqual(previousActionWorkContext, nextActionWorkContext)) {
+      const currentTasks = this.readAIEmployeePersistedTasks(options.current);
+      const rebasedTasks = this.rebaseAIEmployeeInheritedTaskWorkContext(
+        currentTasks,
+        previousActionWorkContext,
+        nextActionWorkContext
+      );
+      const tasks = this.withAIEmployeeTaskDefaultWorkContext(rebasedTasks, effectiveActionWorkContext);
+      if (tasks.length) {
+        import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
+      }
     }
     if (Object.prototype.hasOwnProperty.call(settings, "style") || options.requireUsername) {
       const style = Object.prototype.hasOwnProperty.call(settings, "style") ? settings.style : {};
@@ -18653,7 +18997,16 @@ ${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROM
       transaction,
       includeAsyncNode: true
     });
-    if (["TableActionsColumnModel", "ListItemModel", "GridCardItemModel"].includes(String((parentNode == null ? void 0 : parentNode.use) || ""))) {
+    return await this.resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction) || parentUid;
+  }
+  async resolveAIEmployeeActionSelfUidFromParentNode(parentNode, transaction) {
+    const parentUid = String((parentNode == null ? void 0 : parentNode.uid) || "").trim();
+    if (!parentUid) {
+      return "";
+    }
+    if (["TableActionsColumnModel", "ListItemModel", "GridCardItemModel", "CommentItemModel"].includes(
+      String((parentNode == null ? void 0 : parentNode.use) || "")
+    )) {
       const ownerUid = String((parentNode == null ? void 0 : parentNode.parentId) || "").trim() || ((parentNode == null ? void 0 : parentNode.uid) ? await this.locator.findParentUid(parentNode.uid, transaction).catch(() => "") : "");
       return ownerUid || parentUid;
     }