yugoo-design 0.2.7 → 0.2.8

package/payload/shared/bundles/flow_design/licenses/third-party/elkjs-0.10.2/upstream-build.gradle

@@ -0,0 +1,322 @@
+/*
+  # Task depencencies
+  The dependencies are specified at the end of this file,
+  not within the task definitions.
+
+  1) copy (and preprocess) relevant source code
+  2) generate code for .melk and .xtend files
+  3) compile java source code
+  4) run gwt compiler
+
+  # Build directory layout
+  src
+   +-- elk
+   +-- elkjs
+   +-- melk
+   +-- xtend-gen
+*/
+plugins {
+  // The documentation of the plugin [1] states "tested up to [gradle] 7.2". 
+  // [1] https://xtext.github.io/xtext-gradle-plugin/xtext-builder.html
+  id 'org.xtext.builder' version '3.0.2' // according to the docu, tested up to gradle 7.2
+  id 'org.xtext.xtend'   version '3.0.2'
+  id 'java'
+}
+
+// make sure all compile tasks use utf8
+tasks.withType(JavaCompile) {
+  options.encoding = 'UTF-8'
+}
+
+// GWT 2.10 allows to run Java [8, 17]
+//  (http://www.gwtproject.org/release-notes.html#Release_Notes_2_10_0)
+if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_8) 
+    || JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_18)) {
+    throw new GradleException("elkjs build requires to be run with Java [8, 17] (due to GWT compilation). You are running " + JavaVersion.current() + ".")
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                         Settings
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+ext.versions = [
+  emfGwt: '2.12.4',
+  gwt:    '2.11.0',
+  guava:  '31.1-jre',
+  melk:   '0.11.0-SNAPSHOT',
+  xtext:  '2.36.0',
+
+  // From 2.26 on Xtext supports Java 17, however,
+  //   "Xtext now supports running on Java 17 with Java 8 and 11 targets. Source and Target 17 are not supported yet".
+  // https://www.eclipse.org/Xtext/releasenotes.html#/releasenotes/2022/08/29/version-2-28-0
+  sourceTargetCompatibility: JavaVersion.current().ordinal() < 11 - 1 ? '1.8' : '11' 
+]
+
+java {
+  sourceCompatibility = "$versions.sourceTargetCompatibility"
+  targetCompatibility = "$versions.sourceTargetCompatibility"
+}
+
+project.logger.lifecycle("You are running Java version ${JavaVersion.current()}.")
+project.logger.lifecycle("Due to current Xtext's limitations ($versions.xtext), source and target compatibility have been set to ${versions.sourceTargetCompatibility}.")
+
+if (!hasProperty('elkRepo')) {
+	ext.elkRepo = '../elk'
+}
+
+def elkSources = [
+  // The core and graph format
+  "${elkRepo}/plugins/org.eclipse.elk.core/src",
+  "${elkRepo}/plugins/org.eclipse.elk.graph/src",
+  "${elkRepo}/plugins/org.eclipse.elk.graph.json/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.common/src",
+  // The algorithms
+  // FIXME: DisCo breaks Github Actions for unknown reasons, see https://github.com/kieler/elkjs/issues/291
+  //"${elkRepo}/plugins/org.eclipse.elk.alg.disco/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.force/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.layered/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.mrtree/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.rectpacking/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.radial/src",
+  "${elkRepo}/plugins/org.eclipse.elk.alg.spore/src"
+]
+
+// the directory to which all sources are copied for compilation
+def srcDir = "${buildDir}/src"
+def distDir = "${buildDir}/js"
+
+def gwtModule = "org.eclipse.elk.js.ElkJs"
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//            Repositories, Source Sets, and Dependencies
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+repositories {
+    jcenter()
+    // for melk compiler
+    maven {
+        url 'https://oss.sonatype.org/content/repositories/snapshots'
+    }
+}
+
+configurations {
+    gwt
+}
+
+sourceSets {
+  // compile xtext related sources. This includes:
+  // xtend -> java
+  // melk -> java
+  xtext {
+    java {
+      srcDirs = [ "$srcDir/elk" ]
+    }
+    xtendOutputDir = "$srcDir/xtend-gen"
+  }
+
+  main {
+    java {
+      srcDirs = [ srcDir ]
+    }
+  }
+}
+
+def gwtClasspath = [
+      // gwt requires the folder structure to equal the package structure
+      "$srcDir/elk",
+      "$srcDir/elkjs",
+      "$srcDir/melk",
+      "$srcDir/xtend-gen",
+      sourceSets.main.output.classesDirs,
+
+      configurations.gwt
+    ]
+
+dependencies {
+  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  // melk language
+  xtextLanguages "org.eclipse.elk:org.eclipse.elk.core.meta:$versions.melk"
+
+  // for the minus sign to work in melk files
+  xtextImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:$versions.xtext"
+
+  xtextImplementation "com.google.guava:guava:$versions.guava"
+
+  xtextImplementation "org.gwtproject:gwt-dev:$versions.gwt"
+  xtextImplementation "org.gwtproject:gwt-user:$versions.gwt"
+
+  xtextImplementation "com.genmymodel.emf.gwt:emf-common:$versions.emfGwt"
+  xtextImplementation "com.genmymodel.emf.gwt:emf-ecore:$versions.emfGwt"
+
+  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  // emf for gwt
+  implementation "com.genmymodel.emf.gwt:emf-common:$versions.emfGwt"
+  implementation "com.genmymodel.emf.gwt:emf-ecore:$versions.emfGwt"
+  // guava
+  implementation "com.google.guava:guava:$versions.guava"
+  // gwt
+  implementation "org.gwtproject:gwt-user:$versions.gwt"
+  implementation "org.gwtproject:gwt-dev:$versions.gwt"
+  // xtend libs
+  implementation "org.eclipse.xtend:org.eclipse.xtend.lib:$versions.xtext"
+  implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:$versions.xtext"
+
+  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  gwt "com.google.guava:guava-gwt:$versions.guava"
+
+  gwt "org.gwtproject:gwt:$versions.gwt"
+  gwt "org.gwtproject:gwt-dev:$versions.gwt"
+  gwt "org.gwtproject:gwt-user:$versions.gwt"
+
+  gwt "com.genmymodel.emf.gwt:emf-common:$versions.emfGwt:sources"
+  gwt "com.genmymodel.emf.gwt:emf-ecore:$versions.emfGwt:sources"
+
+  // the xtext/xtend gwt plugins only contain the '.gwt.xml' files
+  // thus the source code has to be retrieved separately
+  gwt "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:$versions.xtext:sources"
+  gwt "org.eclipse.xtend:org.eclipse.xtend.lib:$versions.xtext:sources"
+  gwt "org.eclipse.xtext:org.eclipse.xtext.xbase.lib.gwt:$versions.xtext"
+  gwt "org.eclipse.xtend:org.eclipse.xtend.lib.gwt:$versions.xtext"
+
+}
+
+// configure the melk language
+xtext {
+  languages {
+    melk {
+      fileExtension = 'melk'
+      setup = 'org.eclipse.elk.core.meta.MetaDataStandaloneSetup'
+      generator.outlet.producesJava = true
+    }
+  }
+}
+
+// don't bother the xtext generator with irrelevant source sets
+generateXtext.enabled = false
+
+clean {
+  delete distDir
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                         Copy Tasks
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+task copyElk(type: Copy) {
+  from elkSources
+  into "$srcDir/elk/"
+
+  include "**/*.java"
+  include "**/*.xtend"
+  include "**/*.melk"
+
+  // the gson based json import
+  exclude "**/ElkGraphJson.java"   // java-based api
+  exclude "**/JsonAdapter.xtend"   // the gson implementation
+  exclude "**/JsonExporter.xtend"  // not required here (should be compatible though)
+
+  // class is in there for convenience reasons
+  // usually the factories are generated by the melk compiler
+  exclude "**/AlgorithmFactory.java"
+
+  // exclude because they require ecore.xmi
+  exclude "**/ElkGraphResource.java"
+  exclude "**/ElkGraphXMIHelper.java"
+  exclude "**/ElkGraphXMISave.java"
+  exclude "**/ElkGraphResourceFactory.java"
+
+  // incompatible api, an emulating class is used (java-additional)
+  exclude "**/alg/common/utils/SVGImage.java"
+
+  // after copying, remove those parts of the code
+  // that have been marked to be incompatible with gwt
+  doLast {
+    ant.replaceregexp(
+        match: '// elkjs-exclude-start(.+?)elkjs-exclude-end',
+        replace: '',
+        flags: 'gis',
+        byline: false) {
+      fileset(dir: "$srcDir/elk/")
+    }
+  }
+}
+
+task copyEmul(type: Copy) {
+  from([
+    // contains the implementation for json->elk graph importer
+    // using gwt's json
+    "./src/java-additional"
+  ])
+  into "$srcDir/elk/"
+}
+
+task copyMelk(type: Copy) {
+  from "$buildDir/melk/xtext"
+  into "$srcDir/melk"
+}
+
+task copyElkJs(type: Copy) {
+  from "./src/java"
+  into "$srcDir/elkjs"
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                         GWT Compilation
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+def gwtInputs = [
+  fileTree(srcDir),
+  sourceSets.main.output.classesDirs
+]
+
+task gwtc (type: JavaExec) {
+  main = 'com.google.gwt.dev.Compiler'
+  classpath { gwtClasspath }
+  args = [ gwtModule, '-war', "$buildDir/dist", '-style', 'PRETTY' ]
+  maxHeapSize = '2G'
+
+  inputs.files(gwtInputs)
+  outputs.dir("$buildDir/dist/elk")
+}
+
+task gwtcMinified (type: JavaExec) {
+  main = 'com.google.gwt.dev.Compiler'
+  classpath { gwtClasspath }
+  args = [ gwtModule, '-war', "$buildDir/distMinified" ]
+  maxHeapSize = '2G'
+
+  inputs.files(gwtInputs)
+  outputs.dir("$buildDir/distMinified/elk")
+}
+
+task copyPretty(type: Copy) {
+  from "$buildDir/dist/elk"
+  into distDir
+  include "**/*.js"
+}
+
+task copyMinified(type: Copy) {
+  from "$buildDir/distMinified/elk"
+  into distDir
+  include "**/*.js"
+  rename '(.*).js', '$1.min.js'
+}
+
+task lib(dependsOn: [ copyPretty, copyMinified ])
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                      Task Dependencies
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+generateXtextXtext.dependsOn copyElk
+generateXtextXtext.dependsOn copyEmul
+copyMelk.dependsOn generateXtextXtext
+compileJava.dependsOn copyMelk
+compileJava.dependsOn copyElkJs
+gwtc.dependsOn compileJava
+gwtcMinified.dependsOn compileJava
+copyPretty.dependsOn gwtc
+copyMinified.dependsOn gwtcMinified

package/payload/shared/bundles/flow_design/licenses/third-party/elkjs-0.10.2/upstream-ci.yml

@@ -0,0 +1,67 @@
+name: elkjs CI
+
+on:
+  push:
+    branches:
+      - master 
+  repository_dispatch:
+  schedule:
+    - cron:  '0 3 * * *'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    continue-on-error: true
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [ 14.x, 22.x ]
+        java-version: [ 17 ] 
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        path: elkjs
+    - uses: actions/checkout@v4
+      with:
+        repository: eclipse/elk
+        ref: master
+        path: elk
+    - name: Set up JDK ${{ matrix.java-version }}
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'zulu'
+        java-version: ${{ matrix.java-version }}
+    - name: Cache gradle packages
+      uses: actions/cache@v4
+      with:
+        path: ~/.gradle/caches
+        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
+        restore-keys: ${{ runner.os }}-gradle
+    - name: Cache npm 
+      uses: actions/cache@v4
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package.json') }}
+        restore-keys: ${{ runner.os }}-node-
+    - name: Grant execute permission for gradlew
+      run: |
+        chmod +x elkjs/gradlew
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: npm install, build, and test
+      run: |
+        cd elkjs
+        npm install
+        npm run build --if-present
+        npm test
+      env:
+        CI: true

package/payload/shared/bundles/flow_design/reference/artifact-contract.md

@@ -6,10 +6,14 @@ new design and reconstruction without replacing domain-specific rules.
 
 Shared by authoring and reconstruction; convert established behavior into BPMN without inventing policy. Canonical state is `flow_design/flow_design.json`; active processes are listed by `process_order`, stakeholders reuse `roles[].name`. The installed schema/validation are unchanged.
 
-For product automation, the existing built-in role is
-`{"id":"System","name":"系统"}`. `System` is its ID, not its stakeholder or
-lane label: process stakeholders and BPMN lanes use the exact name `系统`.
-Check this in the canonical plan as well as the XML before accepting a file.
+For product automation, keep exactly one built-in role with stable `id: "System"`
+and a non-empty display name in the authored language, for example
+`{"id":"System","name":"系统"}` in Chinese or
+`{"id":"System","name":"System"}` in English. Role IDs and display names
+remain unique. Process stakeholders and BPMN lanes reuse the exact canonical
+`roles[].name`; resolve the product's display name by its `System` ID, never by
+a translated-name whitelist or lane ID. Check the cast, participating roles and
+automated/human task ownership before accepting a file.
 
 Bind serial/delegated activity using `artifact_kind: "flow_bpmn"`, the stable process ID and `artifact_file: "flow_design/<process_id>.bpmn"`. A Worker receives the matching process descriptor, focused evidence and this shared contract; the Producer integrates its returned file reference.
 
@@ -25,10 +29,13 @@ model tool arguments.
 Validate the file with `run_skill_script`: use `path: "bpmn-validator.mjs"`,
 `args: ["validate-bpmn-file"]`, `input_file` equal to the pre-bound BPMN path,
 and `input_context` containing
-`{"process_id":"P-...","process":{...}}`. The bounded `process` object is the
+`{"process_id":"P-...","process":{...},"roles":[...]}`. `roles` is the existing
+canonical role cast, not a new process field. The bounded `process` object is the
 matching canonical descriptor; it needs the supplied stakeholders,
 system_responsibilities, trigger_hints, and process_type. The validator returns
 only validity and diagnostics. Repair the same file and retry until it passes.
+Older calls without `roles` retain the original Chinese system-lane semantics;
+always include the canonical cast for new or revised localized files.
 
 Next call `run_skill_script` with `path: "layout.mjs"`, the same `input_file`, no
 args, and `output_file` equal to that same BPMN path. On exit 0 the Host writes the

package/payload/shared/bundles/flow_design/reference/bpmn_authoring.md

@@ -26,9 +26,11 @@ not useful.
 
 ## Product boundary and lanes
 
-`系统` is the product being designed, not an invented organization role. The
-brief always states its grounded responsibilities. Realize those
-responsibilities in the `系统` lane; if a proposed process has no product
+The role with stable `id: "System"` is the product being designed, not an invented
+organization role. Its display name comes from the supplied canonical cast
+(`系统` in the Chinese example below, `System` in English). The brief always
+states its grounded responsibilities. Realize those responsibilities in that
+role's exact display-name lane; if a proposed process has no product
 responsibility, it should not have reached this worker.
 
 For two or more participating roles, create exactly one lane per supplied role
@@ -57,14 +59,15 @@ decoration and do not flatten known semantics into generic tasks.
 |---|---|
 | Human works in/with the product | `userTask` in that human role lane |
 | Human performs offline work | `manualTask` in that human role lane |
-| Product runs an automated operation | `serviceTask` in `系统` |
-| Product evaluates a stated decision table/rule | `businessRuleTask` in `系统` |
-| Product sends a message/notification | `sendTask` in `系统` |
-| Product waits for a message | `receiveTask` in `系统` |
+| Product runs an automated operation | `serviceTask` in the System role lane |
+| Product evaluates a stated decision table/rule | `businessRuleTask` in the System role lane |
+| Product sends a message/notification | `sendTask` in the System role lane |
+| Product waits for a message | `receiveTask` in the System role lane |
 | Evidence does not distinguish a more specific activity | `task` |
 
-Never place `userTask`/`manualTask` in `系统`. Never place
-`serviceTask`/`businessRuleTask`/`sendTask`/`receiveTask` in a human lane.
+Never place `userTask`/`manualTask` in the System role lane, and do not use a generic
+`task` for its automated responsibility. Never place
+`serviceTask`/`businessRuleTask`/`scriptTask`/`sendTask`/`receiveTask` in a human lane.
 
 Use gateways by their actual control-flow semantics:
 
@@ -184,7 +187,7 @@ the structure to the brief; never copy its business facts or ids blindly.
 2. All ids are ASCII and process-prefixed; all references resolve.
 3. Lane names exactly match supplied stakeholders; every node belongs to one
    responsible lane.
-4. `系统` responsibilities are typed system activities; human work stays in
+4. The System role's responsibilities are typed system activities; human work stays in
    human lanes.
 5. Every supplied trigger hint is realized, and no ungrounded trigger appears.
 6. Exclusive outcomes are named; parallel/event-driven shapes use the matching

package/payload/shared/bundles/flow_design/reference/canvas-guide.md

@@ -19,7 +19,8 @@ uses the existing SKILL's product-boundary and process-granularity methods.
 Use the installed Bundle's structure-validation → layout → final-validation
 pipeline by file path. The layout script produces BPMN DI; never hand-author a
 second layout or patch truncated output. Lane labels use actual supplied names;
-the built-in System ID and the exact lane/stakeholder name follow the contract.
+resolve the built-in System display name from its stable ID in the canonical
+role cast, and pass that cast to both file validators as the contract specifies.
 Ports/bindings and routing remain BPMN/layout behavior, not the AI midpoint rule.
 Review readable node/condition labels and real branch/return meaning; valid DI
 does not prove readability or correct process semantics. Missing sources stay

package/payload/shared/bundles/flow_design/schema.yaml

@@ -21,7 +21,7 @@ properties:
       type: object
       properties:
         id: { type: string }     # ASCII slug for lane ids, e.g. "Buyer"
-        name: { type: string }   # Chinese display name, e.g. "采购员"
+        name: { type: string }   # Canonical display name in the authored language, e.g. "采购员" or "Buyer"
   processes:
     type: map
     value:

package/payload/shared/bundles/flow_design/scripts/bpmn-validator.mjs

@@ -136,13 +136,12 @@ function semanticDiagnostic(code, message, repair) {
 	return `${code}: ${message} Repair: ${repair}`;
 }
 /**
-* Validate the canonical process plan before any BPMN artifact work begins.
-* @param state - complete flow_design state proposed by the Producer.
-* @returns actionable plan diagnostics; empty accepts the canonical role cast and active processes.
+* Resolve product identity from the canonical role cast, independently of its language.
+* @param rawRoles - the existing roles array from flow_design.json.
 */
-function flowDesignStateErrors(state) {
+function flowRoleContext(rawRoles) {
 	const diagnostics = [];
-	const roles = Array.isArray(state.roles) ? state.roles.map(record$1) : [];
+	const roles = Array.isArray(rawRoles) ? rawRoles.map(record$1) : [];
 	const roleIds = roles.map((role) => typeof role.id === "string" ? role.id.trim() : "");
 	const roleNames = roles.map((role) => typeof role.name === "string" ? role.name.trim() : "");
 	const normalizedRoleNames = roleNames.map((name) => name.normalize("NFKC").toLowerCase());
@@ -151,9 +150,24 @@ function flowDesignStateErrors(state) {
 	const duplicateRoleNames = [...new Set(roleNames.filter((name, index) => name !== "" && normalizedRoleNames.indexOf(name.normalize("NFKC").toLowerCase()) !== index))].sort();
 	if (duplicateRoleIds.length > 0) diagnostics.push(semanticDiagnostic("flow_design.duplicate_role_id", `role ids are duplicated: ${duplicateRoleIds.join(", ")}.`, "Keep one stable id for each product-wide role."));
 	if (duplicateRoleNames.length > 0) diagnostics.push(semanticDiagnostic("flow_design.duplicate_role_name", `role names are duplicated: ${duplicateRoleNames.join(", ")}.`, "Keep one canonical display name for each product-wide role and reuse it in every process."));
-	const systemRoles = roles.filter((role) => role.id === "System" || role.name === "系统");
-	if (systemRoles.length !== 1 || systemRoles[0]?.id !== "System" || systemRoles[0]?.name !== "系统") diagnostics.push(semanticDiagnostic("flow_design.missing_system_role", "the product-wide role cast must contain exactly one canonical role {id: \"System\", name: \"系统\"}.", "Add or normalize the single built-in System/系统 role before describing active processes."));
+	const systemRoles = roles.filter((role) => role.id === "System");
+	if (systemRoles.length !== 1) diagnostics.push(semanticDiagnostic("flow_design.missing_system_role", "the product-wide role cast must contain exactly one role with stable id \"System\".", "Keep the built-in System identity and give it one non-empty canonical display name in the authored language."));
 	const roleNameSet = new Set(roleNames);
+	const systemName = systemRoles.length === 1 && typeof systemRoles[0]?.name === "string" ? systemRoles[0].name.trim() : "";
+	return { diagnostics, roleNameSet, systemName };
+}
+function processRoleErrors(process, processId, { roleNameSet, systemName }) {
+	const diagnostics = [];
+	const stakeholders = stringList(process.stakeholders);
+	const unknown = stakeholders.filter((role) => !roleNameSet.has(role));
+	if (unknown.length > 0) diagnostics.push(semanticDiagnostic("flow_design.unknown_stakeholder", `process ${processId} uses stakeholders outside the product-wide role cast: ${[...new Set(unknown)].sort().join(", ")}.`, "Reuse exact role names from roles, or establish the missing evidenced role in the shared cast first."));
+	if (systemName !== "" && !stakeholders.includes(systemName)) diagnostics.push(semanticDiagnostic("flow_design.system_not_participating", `process ${processId} does not include the System role ${JSON.stringify(systemName)} as a stakeholder.`, "Include its canonical display name and established product responsibility, or omit a procedure in which the product has no responsibility."));
+	if (stringList(process.system_responsibilities).length === 0) diagnostics.push(semanticDiagnostic("flow_design.missing_system_responsibility", `process ${processId} does not state any product/system responsibility.`, "Describe what the product validates, stores, decides, sends, or waits for before BPMN authoring."));
+	return diagnostics;
+}
+function flowDesignStateErrors(state) {
+	const roleContext = flowRoleContext(state.roles);
+	const diagnostics = [...roleContext.diagnostics];
 	const processes = record$1(state.processes);
 	const order = Array.isArray(state.process_order) ? state.process_order : [];
 	for (const rawProcessId of order) {
@@ -161,11 +175,7 @@ function flowDesignStateErrors(state) {
 		const process = record$1(processes[processId]);
 		if (Object.keys(process).length === 0 || process.deleted === true) continue;
 		if (process.process_id !== processId) diagnostics.push(semanticDiagnostic("flow_design.process_id_mismatch", `process map key ${processId} does not match process_id ${JSON.stringify(process.process_id)}.`, "Set process_id to the exact process map key before authoring or laying out BPMN."));
-		const stakeholders = stringList(process.stakeholders);
-		const unknown = stakeholders.filter((role) => !roleNameSet.has(role));
-		if (unknown.length > 0) diagnostics.push(semanticDiagnostic("flow_design.unknown_stakeholder", `process ${processId} uses stakeholders outside the product-wide role cast: ${[...new Set(unknown)].sort().join(", ")}.`, "Reuse exact role names from roles, or establish the missing evidenced role in the shared cast first."));
-		if (!stakeholders.includes("系统")) diagnostics.push(semanticDiagnostic("flow_design.system_not_participating", `process ${processId} does not include 系统 as a stakeholder.`, "Add 系统 and its established product responsibility, or omit a procedure in which the product has no responsibility."));
-		if (stringList(process.system_responsibilities).length === 0) diagnostics.push(semanticDiagnostic("flow_design.missing_system_responsibility", `process ${processId} does not state any product/system responsibility.`, "Describe what the product validates, stores, decides, sends, or waits for before BPMN authoring."));
+		diagnostics.push(...processRoleErrors(process, processId, roleContext));
 	}
 	return Object.freeze(diagnostics);
 }
@@ -174,10 +184,15 @@ function flowDesignStateErrors(state) {
 * @param xml - complete or structure-only BPMN XML after syntax validation.
 * @param processId - canonical process id used in diagnostics.
 * @param process - canonical process descriptor from flow_design.json.
+* @param roles - canonical role cast; omitted only by legacy Chinese file callers.
 * @returns actionable semantic diagnostics; empty accepts the process.
 */
-function semanticErrors(xml, processId, process) {
-	const diagnostics = [];
+function semanticErrors(xml, processId, process, roles) {
+	// Old file callers have no cast and retain the original Chinese lane semantics.
+	// New callers supply the existing canonical cast; identity never comes from a label.
+	const roleContext = roles === void 0 ? void 0 : flowRoleContext(roles);
+	const systemName = roleContext?.systemName ?? "系统";
+	const diagnostics = roleContext === void 0 ? [] : [...roleContext.diagnostics, ...processRoleErrors(process, processId, roleContext)];
 	const nodes = bpmnNodes(xml);
 	const expectedRoles = stringList(process.stakeholders);
 	const systemResponsibilities = stringList(process.system_responsibilities);
@@ -200,8 +215,8 @@ function semanticErrors(xml, processId, process) {
 		const duplicated = [...nodeLanes].filter(([, owners]) => owners.length !== 1).map(([nodeId]) => nodeId).sort();
 		if (duplicated.length > 0) diagnostics.push(semanticDiagnostic("flow_design.ambiguous_lane_assignment", `process ${processId}: flow nodes belong to more than one lane: ${duplicated.slice(0, 8).join(", ")}.`, "Keep exactly one flowNodeRef for each flow node in exactly one responsible lane."));
 	}
-	if (expectedRoles.includes("系统")) {
-		const systemActivities = [...expectedRoles.length === 1 && laneNames.length === 0 ? new Set(nodes.keys()) : new Set(laneNodes.get("系统") ?? [])].map((nodeId) => [nodeId, nodes.get(nodeId)?.tag]).filter((entry) => entry[1] !== void 0 && BPMN_ACTIVITY_TAGS.has(entry[1]));
+	if (expectedRoles.includes(systemName)) {
+		const systemActivities = [...expectedRoles.length === 1 && laneNames.length === 0 ? new Set(nodes.keys()) : new Set(laneNodes.get(systemName) ?? [])].map((nodeId) => [nodeId, nodes.get(nodeId)?.tag]).filter((entry) => entry[1] !== void 0 && BPMN_ACTIVITY_TAGS.has(entry[1]));
 		const humanTasks = systemActivities.filter(([, tag]) => tag === "userTask" || tag === "manualTask").map(([nodeId]) => nodeId).sort();
 		if (humanTasks.length > 0) diagnostics.push(semanticDiagnostic("flow_design.human_task_in_system_lane", `process ${processId}: system lane contains human-owned tasks: ${humanTasks.slice(0, 8).join(", ")}.`, "Move human/manual actions to a human lane or use an evidenced automated activity type."));
 		const genericTasks = systemActivities.filter(([, tag]) => tag === "task").map(([nodeId]) => nodeId).sort();
@@ -209,12 +224,12 @@ function semanticErrors(xml, processId, process) {
 		if (systemResponsibilities.length > 0 && !systemActivities.some(([, tag]) => BPMN_SYSTEM_ACTIVITY_TAGS.has(tag))) diagnostics.push(semanticDiagnostic("flow_design.system_responsibility_unrealized", `process ${processId}: no typed automated activity realizes the supplied system responsibilities.`, "Add system-lane semantic activities for established responsibilities without inventing new ones."));
 	}
 	for (const [role, refs] of laneNodes) {
-		if (role === "系统") continue;
+		if (role === systemName) continue;
 		const automated = refs.filter((ref) => {
 			const tag = nodes.get(ref)?.tag;
 			return tag !== void 0 && BPMN_SYSTEM_ACTIVITY_TAGS.has(tag);
 		}).sort();
-		if (automated.length > 0) diagnostics.push(semanticDiagnostic("flow_design.automation_in_human_lane", `process ${processId}: human lane ${JSON.stringify(role)} owns automated activities: ${automated.slice(0, 8).join(", ")}.`, "Move automated work to the 系统 lane and keep human work as userTask or manualTask."));
+		if (automated.length > 0) diagnostics.push(semanticDiagnostic("flow_design.automation_in_human_lane", `process ${processId}: human lane ${JSON.stringify(role)} owns automated activities: ${automated.slice(0, 8).join(", ")}.`, "Move automated work to the canonical System role's lane and keep human work as userTask or manualTask."));
 	}
 	const hintedKinds = new Set(triggerHints.map((hint) => typeof hint.kind === "string" ? hint.kind : ""));
 	const presentKinds = new Set(Object.entries(BPMN_TRIGGER_DEFINITIONS).filter(([, definition]) => new RegExp(`<bpmn:${definition}\\b`).test(xml)).map(([kind]) => kind));
@@ -404,7 +419,7 @@ async function validateFlowDesignProducerArtifacts(state, artifacts) {
 		const stakeholders = Array.isArray(process.stakeholders) ? process.stakeholders : [];
 		diagnostics.push(...layoutErrors(xml).map((message) => `process ${processId}: ${message}`));
 		diagnostics.push(...structuralErrors(structure, processId, stakeholders.length).map((message) => `process ${processId}: ${message}`));
-		diagnostics.push(...semanticErrors(structure, processId, process));
+		diagnostics.push(...semanticErrors(structure, processId, process, state.roles));
 	}
 	return Object.freeze(diagnostics);
 }
@@ -447,7 +462,7 @@ try {
 			...sourceDiagnostics,
 			...(operation === "validate-final-bpmn-file" ? layoutErrors(xml) : []),
 			...structuralErrors(structure, processId, (Array.isArray(processRecord.stakeholders) ? processRecord.stakeholders : []).length),
-			...semanticErrors(structure, processId, processRecord)
+			...semanticErrors(structure, processId, processRecord, context.roles)
 		]);
 	} else throw new Error("usage: bpmn-validator.mjs <validate-bpmn-file|validate-final-bpmn-file>");
 } catch (error) {

package/payload/shared/bundles/function_modules/locales/en-US.json

@@ -1,9 +1,9 @@
 {
   "bundleDescription": "- **Capability**: organize the product into user-facing function cards.\n- **Resolves**: S gaps by turning an established product goal and core scenarios into a non-overlapping capability map.\n- **Candidate when**: the outcome, primary users, and material boundary are established, or the user explicitly asks to split or revise functions.\n- **Do not infer**: an app category, domain name, or generic product goal is not enough evidence to invent a function map.\n- **Output**: a function-module panel grouped by Epic for browsing.",
   "functions": "Function modules", "function": "Function", "empty": "Add a function, or describe the capability in the conversation.",
-  "details": "Functional details", "functionId": "Function ID", "name": "Function name", "description": "Description", "epic": "Group", "epicHelp": "Groups are labels on functions, not separate design records.",
+  "details": "Function details", "functionId": "Function ID", "name": "Function name", "description": "Description", "epic": "Group", "epicHelp": "Groups are labels on functions, not separate design records.",
   "priority": "Priority", "high": "High", "medium": "Medium", "low": "Low", "rejected": "Rejected",
-  "source": "Origin", "ai": "AI proposal", "user": "User added", "reason": "Notes", "references": "Pinned sources",
+  "source": "Origin", "ai": "AI proposal", "user": "User added", "reason": "Notes", "references": "Source references",
   "situation": "Usage scenario", "behaviors": "Core behaviors", "behavior": "Behavior", "inputs": "Inputs", "input": "Input",
   "outputs": "Outcomes", "output": "Outcome", "limits": "Scope boundaries", "limit": "Boundary", "exceptions": "Exception handling", "exception": "Exception", "condition": "Condition", "response": "System response",
   "guidance": "Check that the functions cover what users need to accomplish. Look for omissions, overlap or excess scope, and adjust descriptions and priorities.",

package/payload/shared/bundles/function_modules/panel.yaml

@@ -6,6 +6,7 @@ i18n:
 empty_description: $t:empty
 sections:
   - id: functions
+    order: function_order
     title: $t:functions
     item_name: $t:function
     confirm_delete: true

package/payload/shared/bundles/function_modules/reference/artifact-contract.md

@@ -75,6 +75,11 @@ do not send it to a differently pinned validator or rewrite its retained state.
 }
 ```
 
+- Optional `function_order` holds function map keys in the user’s chosen reading order.
+  Preserve it during revisions, remove deleted keys and append new keys without
+  changing unaffected positions. If absent, existing map order is used; the Panel
+  writes an order only when the user actually moves a card. Grouping still comes
+  from `function_epic`, not another membership list.
 - `function_id`, `function_name`, `function_description`, `function_epic`
   are required for every function. `priority` is optional (panel default Medium).
 - `rejected` means the user rejected the function. It remains visible in the

package/payload/shared/bundles/function_modules/reference/preview.json

@@ -1,4 +1,5 @@
 {
+  "function_order": ["F-PREVIEW-001", "F-PREVIEW-002"],
   "functions": {
     "F-PREVIEW-001": {
       "function_id": "F-PREVIEW-001",