@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/knowledge/rules.js

@@ -1,6 +1,11 @@
+import { applyPolicyMode } from './policy.js';
+import { PlatformApiError } from '../platform/errors.js';
 import { reservedTenantTables } from './reservedTables.js';
-const terminalStepTypes = new Set(['response', 'convert', 'revert', 'end']);
-const DESCRIPTION_EXEMPT_STEPS = new Set(['start', 'end']);
+import { headersAccessNames, isHeadersAccessGuarded } from './flowGuards.js';
+import { callsItself, functionCallRefs, isValidParameterName, mentionsAwait, nameProblem, sourceOf, callPrefix } from './functionGuards.js';
+import { backendPolicyRules } from './backendConstraints.js';
+const terminalStepTypes = new Set(['response', 'convert', 'revert']);
+const DESCRIPTION_EXEMPT_STEPS = new Set(['start']);
 const stepKindMatrix = {
     start: ['workflow', 'automation', 'middleware'],
     condition: ['workflow', 'automation', 'middleware'],
@@ -12,14 +17,14 @@ const stepKindMatrix = {
     workflow: ['workflow', 'automation', 'middleware'],
     email: ['workflow', 'automation', 'middleware'],
     'file-upload': ['workflow', 'automation', 'middleware'],
+    microfunction: ['workflow', 'automation', 'middleware'],
     variable: ['middleware'],
     'set-user': ['middleware'],
     setcookie: ['middleware'],
     redirect: ['middleware'],
     response: ['workflow', 'middleware'],
     convert: ['workflow'],
-    revert: ['automation'],
-    end: ['workflow', 'automation', 'middleware']
+    revert: ['automation']
 };
 function asArray(value) {
     return Array.isArray(value) ? value : [];
@@ -96,9 +101,41 @@ const flowBranchNames = {
     start: ['always'],
     microservice: ['always', 'success'],
     confirm: ['yes', 'no', 'always'],
+    function: ['always'],
     end: []
 };
+/**
+ * Gateway'in tanıdığı sayfa akışı adım tipleri — frontend `FlowTaskType` enum'unun aynası
+ * (`ng-apps-flow/src/flow-execution.enums.ts`). `flowBranchNames[type] ?? ['always']` varsayımı
+ * her tipi kabul ettiği için sürüklenme ancak bu AÇIK listeyle ölçülür
+ * (`test/flow-step-parity.test.ts`). Frontend'e yeni tip girince buraya da yazılır.
+ */
+export const knownFlowStepTypes = new Set([
+    'start', 'end', 'query', 'setter', 'download', 'condition', 'redirect', 'setcookie', 'alert', 'confirm',
+    'microservice', 'validation', 'flow-trigger', 'storage', 'navigate', 'code', 'function'
+]);
 const flowFreeBranchTypes = new Set(['condition']);
+/** `condition.types.ts` ConditionArgumentRuleType — motorun tanıdığı üçlü. */
+const conditionRuleTypes = new Set(['if', 'else-if', 'else']);
+// Sayfa akışında kuralın id'si hem dal adıdır (condition.ts `engine.next(rule.id)`) hem de
+// backend'de bir Guid'dir (StepManagementSchema.cs `public Guid Id { get; set; }`), yani
+// okunabilir bir ad iki uçta birden tutmaz: istek System.Guid çevrimiyle reddedilir.
+const conditionRuleIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// alert.ts ve confirm.ts `task.argument.message`'ı doğrudan toast/dialog'a geçirir; argüman
+// Runtime.svelte'de HAM verilir (`argument: step.args`), yani bu alanlarda ifade değerlendirilmez.
+const flowLiteralTextFields = new Map([
+    ['alert', ['message', 'description']],
+    ['confirm', ['message']]
+]);
+const flowExpressionLooking = /\$\{|\b(?:Steps|Page|Row|Widget|LocalStorage|state|self|item|event|error|cookie)\s*(?:\?\.|\.|\[)/;
+// Barındırıcıya özel tipler (`navigate` web'de, `confirm`/`download` mobilde register edilmez)
+// BURADA kural üretmez. `navigate`i gateway normalizasyonu zaten `redirect`e çeviriyor
+// (normalize.ts `normalizeFlowHostGaps`) — `redirect` iki barındırıcıda da koşar, yani vaka
+// uyarılmaz, ORTADAN KALKAR. Geriye kalan `confirm`/`download` tek başına kusur değildir: sayfa
+// tek bir uygulamaya aittir (`Page.ApplicationId`), uygulamanın tipi web ya da mobile'dır
+// (`ApplicationType.cs`) ve gateway hangisi olduğunu bilmez. Mobil ayağı uygulama tarafında
+// kapanır (`ScreenRuntime.tsx`), lint'te değil.
+const flowUnregisteredStepTypes = new Set(['end', 'query']);
 const flowSetterIterateeTypes = new Set(['change', 'fill']);
 function flowStepList(value) {
     return asArray(value).filter((step) => Boolean(step) && typeof step === 'object');
@@ -109,8 +146,20 @@ function flowAllSteps(definition) {
 function flowStepLabel(step) {
     return step.stepId || step.name || step.type || '?';
 }
+/**
+ * Dal listesi İKİ biçimde gelebilir ve motor ikisini de aynı şekle eşler (Runtime.svelte
+ * `mapStepBranches`, ScreenRuntime.tsx aynısı): dizi `[{ name, nextStepId }]` ya da nesne
+ * `{ <dal adı>: <nextStepId> }`. Studio'nun kendi varsayılan şeması nesne biçimini kullanır
+ * (`event-actions.constants.ts` DEFAULT_SCHEMA `branches: { always: '' }`), bu yüzden lint
+ * nesne biçimini görmezse Studio'dan gelen gövdeler bütün dal kurallarını atlar.
+ */
 function flowBranches(step) {
-    return asArray(step.branches).filter((branch) => Boolean(branch) && typeof branch === 'object');
+    const branches = step.branches;
+    if (branches && typeof branches === 'object' && !Array.isArray(branches)) {
+        return Object.entries(branches)
+            .map(([name, nextStepId]) => ({ name, nextStepId: nextStepId ?? null }));
+    }
+    return asArray(branches).filter((branch) => Boolean(branch) && typeof branch === 'object');
 }
 function flowIteratees(step) {
     return asArray((step.args ?? {}).iteratees).filter((iteratee) => Boolean(iteratee) && typeof iteratee === 'object');
@@ -171,10 +220,41 @@ function flowCodeExpressions(step) {
     }
     return expressions;
 }
-/** `Steps.ad.headers` / `Steps["ad"].headers` yakalar, `Steps.ad?.headers` guard'lısını yakalamaz. */
-const flowHeadersAccess = /Steps\s*(?:\.\s*([A-Za-z_$][\w$]*)|\[\s*['"]([^'"]+)['"]\s*\])\s*\.\s*headers\b/g;
+/**
+ * Kod ifadesi taşıyan her alan: `flowCodeExpressions` + condition kurallarının `expression`ı.
+ * FLOW-025 (`Functions.<ad>` çağrı taraması) bunu tarar; FLOW-011'in taradığı küme değişmez.
+ */
+export function flowExpressionSites(step) {
+    const shaped = step;
+    const sites = flowCodeExpressions(shaped);
+    if (shaped.type === 'condition') {
+        for (const rule of asArray((shaped.args ?? {}).rules).filter((rule) => Boolean(rule) && typeof rule === 'object')) {
+            if (typeof rule.expression === 'string' && rule.expression.trim() !== '')
+                sites.push({ expression: rule.expression, origin: `rules['${String(rule.id ?? '?')}'].expression` });
+        }
+    }
+    return sites;
+}
 const writeOperations = new Set(['create', 'update', 'delete', 'upsert']);
-const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith']);
+/** Built-in `roles` entity'si ve slug alanı — SeedData her projeye SABİT id'lerle açar (EntityConstants.cs). */
+const rolesEntityId = '01917ede-88a2-72ea-8397-2619e5d5dca0';
+const rolesSlugFieldId = '0199c35d-cfc8-77d4-9c20-29b857153147';
+function writesRolesWithoutSlug(entityId, parameters) {
+    if (String(entityId ?? '').toLowerCase() !== rolesEntityId)
+        return false;
+    const operation = String(parameters?.operation ?? '').toLowerCase();
+    // Yalnız SATIR ÜRETEN yollar: 'update' var olan satırın slug'ını zaten taşır, orada slug
+    // yazdırmak eski slug'a bakan yetki ifadelerini kırar (aynı tuzağın upsert ayağı MS-016).
+    if (operation !== 'create' && operation !== 'upsert')
+        return false;
+    return !asArray(parameters?.fields)
+        .filter((field) => Boolean(field) && typeof field === 'object')
+        .some(field => String(field.fieldId ?? '').toLowerCase() === rolesSlugFieldId
+        || String(field.fieldSlug ?? field.slug ?? '') === 'slug');
+}
+const rolesSlugMessage = "Built-in 'roles' entity'sine slug YAZMADAN rol satırı ÜRETİLİYOR (operation create/upsert). Insert 200 döner, satır role_list'te görünür ve page.roleIds ile bağlanır — ama yetkilendirme SLUG karşılaştırır: platformun get-user sorgusu roles+user_roles join'inden slug dizisi üretir ve Authorized(user.roles) o rol için hiçbir zaman tutmaz. fields'a slug'ı ekleyin ('super-admin' slug'ını vermeyin — platform süper yöneticiyi o slug ile arar). Upsert'te slug'ı İFADEYLE üretmeyin: UPDATE yolunda ifade yeniden değerlendirilir ve var olan rolün slug'ı sessizce değişir (MS-016) — üretilen slug'ı yalnız create ucunda yazın. Rolü kullanıcıya bağlamak ayrı bir user_roles satırıdır.";
+const contractKeys = ['returnDtoId', 'parameterDtoId', 'returnBehavior', 'parameterBehavior'];
+const filterOperators = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'contains', 'icontains', 'in', 'notin', 'startswith', 'endswith', 'istartswith', 'iendswith', 'isnull', 'isnotnull']);
 function flattenFilterTree(filters) {
     return filters
         .filter((filter) => Boolean(filter) && typeof filter === 'object')
@@ -266,6 +346,8 @@ function unreadSelectFields(step, steps) {
         .map(field => String(field.fieldSlug ?? field.slug ?? ''))
         .filter(slug => slug.length > 0 && !new RegExp(`\\b${escapeForPattern(slug)}\\b`).test(usage));
 }
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const functionsGuide = 'ngapps://guides/functions';
 export const policyRules = [
     {
         id: 'MS-001',
@@ -300,6 +382,95 @@ export const policyRules = [
                     guide: 'ngapps://guides/microservice'
                 }]
     },
+    {
+        id: 'MS-015',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "TableMicroserviceExecutor.ProcessFilterExpressions (TableMicroserviceExecutor.cs:495-510) filter.Value'yu Source'a BAKMADAN engine.Evaluate'e verir; query-string/body/header kaynaklı bir filtreye value yazmak çalışma anında 'JavaScriptException: <value> is not defined' → HTTP 500 üretir. Bu kaynaklarda değer çağrıdan gelir, parametre adı alan slug'ından türer (İK koşusu M-2)",
+        check: definition => {
+            const parameters = (definition.sourceParameters ?? {});
+            const offenders = [];
+            const pending = [...asArray(parameters.filters)];
+            while (pending.length > 0) {
+                const filter = pending.shift();
+                if (!filter || typeof filter !== 'object')
+                    continue;
+                pending.push(...asArray(filter.children));
+                const source = String(filter.source ?? '');
+                const value = filter.value;
+                if (source !== 'query-string' && source !== 'body' && source !== 'header')
+                    continue;
+                if (value === null || value === undefined || String(value).trim() === '')
+                    continue;
+                offenders.push(`${String(filter.alias ?? '?')} · source: '${source}' · value: ${JSON.stringify(value)}`);
+            }
+            if (offenders.length === 0)
+                return [];
+            return [{
+                    ruleId: 'MS-015',
+                    severity: 'block',
+                    message: `query-string/body/header kaynaklı filtreye 'value' yazılmış (${offenders.join(' | ')}): platform filtre değerini kaynağa bakmadan JS olarak değerlendiriyor, bu yüzden uç çağrıldığında 'JavaScriptException: … is not defined' ile 500 döner. Bu kaynaklarda 'value' HİÇ verilmez — parametre adı alan slug'ından türer; sabit bir ön-süzme istiyorsanız source: 'expression' kullanın.`,
+                    guide: 'ngapps://guides/microservice'
+                }];
+        }
+    },
+    {
+        id: 'MS-016',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "İK koşusu M-3: operation 'upsert' olan uçta expression'la yazılan alan UPDATE yolunda yeniden değerlendiriliyor; Incremental sicil alanı EMP-0005 → EMP-0006 diye sessizce değişti. Platformda alan bazlı writeOn (create|update|always) YOK — bu kural o gelene kadarki tek uyarı",
+        check: definition => {
+            const parameters = (definition.sourceParameters ?? {});
+            if (String(parameters.operation ?? '') !== 'upsert')
+                return [];
+            const generated = asArray(parameters.fields)
+                .map(entry => entry)
+                .filter(field => String(field.source ?? '') === 'expression')
+                .map(field => String(field.alias ?? field.fieldId ?? '?'));
+            if (generated.length === 0)
+                return [];
+            return [{
+                    ruleId: 'MS-016',
+                    severity: 'warn',
+                    message: `upsert ucunda expression kaynaklı alan var (${generated.join(', ')}): upsert UPDATE yolunda da bu ifadeyi yeniden değerlendirir, yani sicil/kod gibi ÜRETİLEN bir değer güncellemede sessizce değişir. Alanı yalnız oluşturmada yazmak istiyorsanız create ve update için iki ayrı uç kurun — platformda alan bazlı 'yalnız create'te yaz' ifadesi henüz yok.`,
+                    guide: 'ngapps://guides/microservice'
+                }];
+        }
+    },
+    {
+        id: 'QRY-006',
+        module: 'query',
+        appliesTo: ['create', 'update'],
+        sourceRef: "2026-09-09 koşusu S-1: query_create gövdesine yazılan description komut şemasında YOKTU ve sessizce düştü; alan backend'e eklendi (Query.Description + 20260909075142_AddQueryDescription). MS-014'ün query karşılığı, ama warn: uç açıklaması sorgununkinin yerine geçmez ve block bugün açıklamasız yazan her çağrıyı kırardı",
+        check: definition => hasText(definition.description)
+            ? []
+            : [{
+                    ruleId: 'QRY-006',
+                    severity: 'warn',
+                    message: "Sorgunun 'description' alanı boş. 1-2 cümleyle bu sorgunun NE DÖNDÜRDÜĞÜNÜ yazın — sorgu listesinde ad ve slug dışında hiçbir ipucu yok ve aynı datasource üzerinde onlarca ham SQL birikiyor. Ucun kendi açıklaması (MS-014) bunun yerine geçmez: bir sorgu birden çok uçtan tüketilebilir ve uç sözleşmeyi anlatırken sorgu veriyi anlatır.",
+                    guide: 'ngapps://guides/microservice'
+                }]
+    },
+    {
+        id: 'MS-018',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "2026-09-09 koşusu S-2: microservice_create gövdesine yazılan returnDtoId sessizce düştü — platform 200 döndü, uç sözleşmesiz kaldı. Alan Create/UpdateMicroserviceCommand şemasında YOK (additionalProperties:false); sözleşme Workflow.ReturnDtoId'ye ait (WF-002)",
+        check: definition => {
+            const written = contractKeys.filter(key => definition[key] !== undefined && definition[key] !== null);
+            if (written.length === 0)
+                return [];
+            const workflowId = String(definition.workflowId ?? '');
+            const dtoId = String(definition.returnDtoId ?? definition.parameterDtoId ?? '<dtoId>');
+            const patch = `workflow_patch(id: '${workflowId === '' ? '<workflowId>' : workflowId}', ops: [{ op: 'add', path: '/returnDtoId', value: '${dtoId}' }, { op: 'add', path: '/returnBehavior', value: 'object' }])`;
+            return [{
+                    ruleId: 'MS-018',
+                    severity: 'block',
+                    message: `Uç komutunda DTO sözleşmesi alanı YOK — gövdeye yazılan ${written.join(', ')} platforma gitse 200 dönerdi ve alan SESSİZCE düşerdi; uç sözleşmesiz kalır (ölçüldü 2026-09-09, S-2). table/query/view kaynaklı ucun yanıt şekli kaynağın KENDİSİNDEN türer (selectFields / sorgunun returnScheme'i / view indeksi); açık yanıt sözleşmesi WORKFLOW kavramıdır. Reçete: ucu source:'workflow' + workflowId ile kurun, DTO'yu workflow'a bağlayın — ${patch}. WF-002: type:'workflow' akışta returnDtoId ZORUNLUDUR, returnBehavior'ı boş bırakırsanız gateway 'object' ile doldurur. Sözleşme yalnız 2xx yanıtlarda uygulanır (WF-026). Uç gövdesinden bu alanları çıkarıp yeniden çağırın.`,
+                    guide: 'ngapps://guides/microservice'
+                }];
+        }
+    },
     {
         id: 'MS-002',
         module: 'microservice',
@@ -423,17 +594,57 @@ export const policyRules = [
             const kind = context.workflowKind ?? body.type;
             if (!kind)
                 return [];
-            return workflowSteps(body)
-                .filter(step => {
+            return workflowSteps(body).flatMap(step => {
                 const allowedKinds = stepKindMatrix[String(step.type)];
-                return allowedKinds && !allowedKinds.includes(kind);
-            })
-                .map(step => ({
-                ruleId: 'WF-005',
-                severity: 'block',
-                message: `'${stepLabel(step)}' step'i (${step.type}) ${kind} tipinde kullanılamaz. İzin matrisi: variable/set-user/setcookie/redirect yalnız middleware; convert yalnız workflow; revert yalnız automation; response workflow+middleware.`,
-                guide: 'ngapps://guides/workflow'
-            }));
+                if (!allowedKinds) {
+                    return [{
+                            ruleId: 'WF-005',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' adımındaki '${step.type}' geçerli bir workflow step tipi değil. Geçerli tipler: ${Object.keys(stepKindMatrix).join(', ')}. Akışı bitirmek için ayrı bir end adımı eklemeyin; son dalda nextStepId: null kullanın.`,
+                            guide: 'ngapps://guides/workflow'
+                        }];
+                }
+                if (allowedKinds.includes(kind))
+                    return [];
+                return [{
+                        ruleId: 'WF-005',
+                        severity: 'block',
+                        message: `'${stepLabel(step)}' step'i (${step.type}) ${kind} tipinde kullanılamaz. İzin matrisi: variable/set-user/setcookie/redirect yalnız middleware; convert yalnız workflow; revert yalnız automation; response workflow+middleware.`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            });
+        }
+    },
+    {
+        id: 'WF-MF-001',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "MicrofunctionStep.cs: rule.MicrofunctionId ile kayıt yüklenir, Status != Published ise FailedOutput(MicrofunctionNotPublishedException) — adım hata dalına düşer, akış 200 dönse bile iş yapılmaz. Ölçüldü 2026-09-10 (B4 doğrulaması: taslak fonksiyona bağlı uç 500 MicrofunctionNotPublishedException)",
+        check: definition => {
+            const body = workflowBody(definition);
+            return workflowSteps(body)
+                .filter(step => step.type === 'microfunction')
+                .flatMap((step) => {
+                const rule = (step.rule ?? {});
+                const microfunctionId = rule.microfunctionId;
+                if (!hasText(microfunctionId)) {
+                    return [{
+                            ruleId: 'WF-MF-001',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' microfunction adımında rule.microfunctionId yok — adım hangi fonksiyonu koşturacağını bilmez. microfunction_list(status: 'published') ile id seçin; argümanlar rule.expression'a yazılır (fonksiyonun parameterDto'su varsa o şemaya göre).`,
+                            guide: 'ngapps://guides/microfunction'
+                        }];
+                }
+                if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(String(microfunctionId))) {
+                    return [{
+                            ruleId: 'WF-MF-001',
+                            severity: 'block',
+                            message: `'${stepLabel(step)}' adımının rule.microfunctionId'si GUID değil: '${String(microfunctionId)}'. Platform alanı Guid'e çeviremediği için 400 döner.`,
+                            guide: 'ngapps://guides/microfunction'
+                        }];
+                }
+                return [];
+            });
         }
     },
     {
@@ -524,7 +735,32 @@ export const policyRules = [
             return [{
                     ruleId: 'WF-024',
                     severity: 'block',
-                    message: `Açıklama eksik — ${parts.join('; ')}. Her adıma ve akışın kendisine 1-2 cümle 'description' yazın: Studio kanvasında adımın yanında ⓘ ikonu olarak görünür ve akışı devralan geliştiricinin tek okuma kaynağıdır. NE YAPTIĞINI değil NEDEN olduğunu yazın: 'assignments tablosunu status=Aktif ile okur' mekanizmadır ve zaten koddan okunuyor; 'kullanıcının asal pozisyonunu seçer, birden fazla aktif atama varsa is_primary olanı tercih eder' niyettir. start/end adımları muaftır.`,
+                    message: `Açıklama eksik — ${parts.join('; ')}. Her adıma ve akışın kendisine 1-2 cümle 'description' yazın: Studio kanvasında adımın yanında ⓘ ikonu olarak görünür ve akışı devralan geliştiricinin tek okuma kaynağıdır. NE YAPTIĞINI değil NEDEN olduğunu yazın: 'assignments tablosunu status=Aktif ile okur' mekanizmadır ve zaten koddan okunuyor; 'kullanıcının asal pozisyonunu seçer, birden fazla aktif atama varsa is_primary olanı tercih eder' niyettir. start adımı muaftır.`,
+                    guide: 'ngapps://guides/workflow'
+                }];
+        }
+    },
+    {
+        id: 'WF-025',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "WorkflowService.UpdateAsync adımları silip yeniden yazar; gövdede olmayan bir adıma bakan branches.next_step_id INSERT'te FK'ya takılır. Ölçüldü 2026-09-08 (workflow_patch ile bir adım silindi, kalan dal ona bakıyordu): 400 'This record is in use. Related table: Steps, column: Next Step Id'. Flow tarafındaki karşılığı FLOW-005",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const steps = workflowSteps(body);
+            if (steps.length === 0)
+                return [];
+            const stepIds = new Set(steps.map(step => String(step.id ?? '')).filter(id => id !== ''));
+            const dangling = steps.flatMap(step => asArray(step.branches)
+                .map(branch => ({ branch: branch, nextStepId: String(branch.nextStepId ?? '') }))
+                .filter(entry => entry.nextStepId !== '' && !stepIds.has(entry.nextStepId))
+                .map(entry => `${stepLabel(step)} · '${entry.branch.name ?? entry.branch.type}' → ${entry.nextStepId}`));
+            if (dangling.length === 0)
+                return [];
+            return [{
+                    ruleId: 'WF-025',
+                    severity: 'block',
+                    message: `Hedefi gövdede olmayan dal var: ${dangling.join(', ')}. Workflow dalının 'nextStepId'si adımın GUID'idir ve platform onu silinmiş adıma bağlayamaz — istek 400 'This record is in use … Next Step Id' ile döner. Adımı silmeden ÖNCE ona bakan dalların 'nextStepId' değerini null yapın (aynı patch çağrısında iki op olarak gönderilebilir).`,
                     guide: 'ngapps://guides/workflow'
                 }];
         }
@@ -547,6 +783,32 @@ export const policyRules = [
                 : [];
         }
     },
+    {
+        id: 'WF-025',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "Ölçüm 2026-09-07 (canlı, emrah/development): kayıtlı sorgunun parameterScheme'i doluyken library query adımı rule.queryParameters'ı HİÇ okumadı, rule.expression dalına düştü ve parametreler null bağlandı — çağrı 200 + 0 satır döndü, hiçbir katman uyarmadı (teşhis microservice_debug: adımın input girdisi ifadesiz/değersiz). Depo kodu düzeltilmiş (QueryStep.ExecuteLibraryAsync, fe7b923a — önce ruleParameters, expression yedek) ama canlı backend o commit'ten geride: B-63. Kural, dağıtım güncellenince düşer",
+        check: (definition, context) => {
+            const body = workflowBody(definition, context.workflowKind);
+            const unboundSteps = workflowSteps(body)
+                .filter(step => step.type === 'query')
+                .filter(step => {
+                const rule = (step.rule ?? {});
+                if (String(rule.queryStepSourceType ?? 'library') === 'custom')
+                    return false;
+                return asArray(rule.queryParameters).length > 0 && String(rule.expression ?? '').trim() === '';
+            })
+                .map(stepLabel);
+            return unboundSteps.length > 0
+                ? [{
+                        ruleId: 'WF-025',
+                        severity: 'warn',
+                        message: `Query adımı yalnız 'queryParameters' ile bağlanmış (${unboundSteps.join(', ')}) ve 'rule.expression' boş. Kayıtlı sorgunun parametreleri bildirilmişse ÇALIŞAN MOTOR BU DİZİYİ OKUMUYOR: parametreler null bağlanıyor ve çağrı 200 + SIFIR SATIR dönüyor — hata yok, uyarı yok (ölçüldü 2026-09-07; düzeltme depoda var, canlı dağıtım geride — B-63). Aynı bağlamayı 'rule.expression'a nesne literali olarak da yazın: "{ year: input.year, company_id: user.company_id }". Kapsam parametresini middleware'den okumanın yolu da budur (platform_guide('workflow') §'Query adımı').`,
+                        guide: 'ngapps://guides/workflow'
+                    }]
+                : [];
+        }
+    },
     {
         id: 'WF-010',
         module: 'workflow',
@@ -687,6 +949,28 @@ export const policyRules = [
             return [];
         }
     },
+    {
+        id: 'AUT-002',
+        module: 'workflow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "2026-09-05 ölçümü + 2026-09-07 ürün sahibi cevabı (S-7): revert yapısı gereği exception fırlatır ve İKİ koşum yolunda da içinde bulunduğu transaction'ı geri alır — fark, o transaction'ın tetikleyen satır yazmasını kapsayıp kapsamamasıdır. isQueue:false → RowConsumer/AutomationConsumer, automation KENDİ transaction'ında (QueuedEventConsumer) satır COMMIT olduktan sonra koşar; akışın yazdıkları geri alınır, olay 'failed' damgalanır (beklenen iz, kusur değil), çağıran 200'ü çoktan almıştır. isQueue:true → TriggerAutomationWhenRowEventHandlerBase, satır işlemiyle AYNI transaction'da koşar; çağırana 400 { code: revertType, message: revertMessage } döner ve tetikleyen satır da geri alınır. Backend adlandırması: Entity.cs:735-736 GetSyncEventQueueAutomations = IsQueue==true",
+        check: (definition, context) => {
+            if (context.workflowKind !== 'automation')
+                return [];
+            const automation = definition.automation;
+            if (!automation || typeof automation !== 'object' || automation.isQueue === true)
+                return [];
+            const steps = [...asArray(definition.steps), ...asArray(automation.steps)];
+            if (!steps.some(step => step?.type === 'revert'))
+                return [];
+            return [{
+                    ruleId: 'AUT-002',
+                    severity: 'warn',
+                    message: "Bu automation 'revert' taşıyor ve isQueue:false — akış RabbitMQ üzerinden ASYNC koşar. O yolda revert kendi transaction'ını geri alır (akışın yazdıkları kalmaz) ve olay 'failed' damgalanır; bu beklenen davranıştır, kapının çalıştığının izidir. Kapsam dışında kalan tek şey tetikleyen satırdır: o revert'e varılmadan COMMIT olmuş ve çağıran 200 almıştır. İş kuralı ÇAĞIRANI reddetmeli ve tetikleyen satır da geri alınmalıysa isQueue:true + queueOrder verin — o yol satır işlemiyle aynı transaction'da koşar ve çağırana 400 { code: revertType, message: revertMessage } döner.",
+                    guide: 'ngapps://guides/workflow'
+                }];
+        }
+    },
     {
         id: 'MS-004',
         module: 'microservice',
@@ -935,7 +1219,7 @@ export const policyRules = [
         id: 'ENT-004',
         module: 'entity',
         appliesTo: ['create', 'update'],
-        sourceRef: 'ik-hrm teslim notu PLT-002: display alanı tekil',
+        sourceRef: "ik-hrm teslim notu PLT-002: display alanı tekil. Backend'de de doğrulayıcı kuralı: CreateEntityCommandValidator / UpdateEntityCommandValidator Fields.Count(Display) <= 1 → 422 DuplicateValue 'Display' (2026-09-08 madenciliği; warn → block, çünkü gövde gitseydi aynı red gelirdi)",
         check: definition => {
             const displayFields = asArray(definition.fields)
                 .filter((field) => Boolean(field) && typeof field === 'object')
@@ -943,13 +1227,142 @@ export const policyRules = [
             return displayFields.length > 1
                 ? [{
                         ruleId: 'ENT-004',
-                        severity: 'warn',
-                        message: `Birden çok display alanı var (${displayFields.map(field => field.slug ?? field.name).join(', ')}) — entity başına yalnız BİR display alanı olabilir.`,
+                        severity: 'block',
+                        message: `Birden çok display alanı var (${displayFields.map(field => field.slug ?? field.name).join(', ')}) — entity başına yalnız BİR display alanı olabilir; platform 422 "Duplicate value: 'Display'" döner.`,
                         guide: 'ngapps://guides/entity'
                     }]
                 : [];
         }
     },
+    {
+        id: 'ENT-013',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: "EntityIndexDto.cs: alan adları `unique` ve `fieldIds`, doğrulayıcı FieldIds NotEmpty + tekrarsız, ad önek hariç ≤32; Create/UpdateEntityCommandValidator ad benzersizliğini büyük/küçük harf duyarsız arıyor. B-57 (2026-09-06): 422 yalnız İLK yanlış anahtarı söylediği için `fields`→`fieldIds` öğrenildi ama `isUnique` öğrenilemedi — platform onu yok sayıp index'i UNIQUE OLMADAN kurdu",
+        check: definition => {
+            const indexes = asArray(definition.indexes).filter((index) => Boolean(index) && typeof index === 'object');
+            if (indexes.length === 0)
+                return [];
+            const findings = [];
+            const guide = 'ngapps://guides/entity';
+            const knownFieldIds = new Set(asArray(definition.fields)
+                .filter((field) => Boolean(field) && typeof field === 'object')
+                .map(field => field.id)
+                .filter((id) => typeof id === 'string' && id !== ''));
+            const nameCounts = new Map();
+            indexes.forEach((index, position) => {
+                const name = typeof index.name === 'string' ? index.name : '';
+                const label = name === '' ? `indexes[${position}]` : `'${name}'`;
+                if (Object.hasOwn(index, 'isUnique')) {
+                    findings.push({
+                        ruleId: 'ENT-013',
+                        severity: 'block',
+                        message: `${label} index'inde 'isUnique' anahtarı var — platform bu adı TANIMAZ, sessizce yok sayar ve index UNIQUE OLMADAN kurulur. Doğru anahtar 'unique'.`,
+                        guide
+                    });
+                }
+                if (Object.hasOwn(index, 'fields')) {
+                    findings.push({
+                        ruleId: 'ENT-013',
+                        severity: 'block',
+                        message: `${label} index'inde 'fields' anahtarı var — doğru anahtar 'fieldIds' ve alan ID'si ister, slug değil.`,
+                        guide
+                    });
+                }
+                else {
+                    const fieldIds = asArray(index.fieldIds).filter((id) => typeof id === 'string' && id !== '');
+                    if (fieldIds.length === 0) {
+                        findings.push({
+                            ruleId: 'ENT-013',
+                            severity: 'block',
+                            message: `${label} index'inin 'fieldIds' alanı boş — platform 422 döner ("'Field Ids' must not be empty"). Alan id'lerini entity_get view:'outline' çıktısından alın.`,
+                            guide
+                        });
+                    }
+                    if (new Set(fieldIds).size !== fieldIds.length) {
+                        findings.push({
+                            ruleId: 'ENT-013',
+                            severity: 'block',
+                            message: `${label} index'inde aynı alan birden çok kez var — 'fieldIds' tekrar edemez.`,
+                            guide
+                        });
+                    }
+                    const foreign = knownFieldIds.size === 0 ? [] : fieldIds.filter(id => !knownFieldIds.has(id));
+                    if (foreign.length > 0) {
+                        findings.push({
+                            ruleId: 'ENT-013',
+                            severity: 'warn',
+                            message: `${label} index'i gövdedeki hiçbir alana ait olmayan id taşıyor (${foreign.join(', ')}). Alan id'lerini platform ÜRETİR: entity'yi önce kurup id'leri okuyun ya da 'fields[].id'leri kendiniz verip aynı guid'leri kullanın. Yollarsanız platform yanıltıcı bir mesajla reddeder: "This record is in use. Related table: 'Fields', column: 'Field Id'." — ortada bağımlılık yoktur, alan yoktur.`,
+                            guide
+                        });
+                    }
+                }
+                if (name === '') {
+                    findings.push({
+                        ruleId: 'ENT-013',
+                        severity: 'block',
+                        message: `indexes[${position}] adsız — 'name' zorunludur.`,
+                        guide
+                    });
+                    return;
+                }
+                // Uzunluk sınırı ÖNEK HARİÇ ölçülür: platform ada `IX_<5 hane>_` ekler ve okuma yolu
+                // önekli adı döndürür, yani bir gidiş-dönüş gövdesi sırf önek yüzünden ihlal etmemeli.
+                if (name.replace(/^IX_[0-9a-fA-F]{5}_/, '').length > 32) {
+                    findings.push({
+                        ruleId: 'ENT-013',
+                        severity: 'block',
+                        message: `${label} index adı çok uzun — platformun eklediği 'IX_<5 hane>_' öneki hariç en fazla 32 karakter olabilir.`,
+                        guide
+                    });
+                }
+                const key = name.toLocaleLowerCase('tr');
+                nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
+            });
+            for (const [name, count] of nameCounts) {
+                if (count < 2)
+                    continue;
+                findings.push({
+                    ruleId: 'ENT-013',
+                    severity: 'block',
+                    message: `'${name}' adı ${count} index'te birden kullanılmış — index adları entity içinde büyük/küçük harf duyarsız benzersizdir.`,
+                    guide
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'ENT-011',
+        module: 'entity',
+        appliesTo: ['create', 'update'],
+        sourceRef: "FieldDto.cs:170-178 When(IsLocalized): PrimaryKey/Identity/Unique false, RelationType None, CommonType Text zorunlu — beşi de platform validator'ında hard 400 (OnlyTextCanBeLocalizedException). İstek gitmeden yakalanır",
+        check: definition => {
+            const findings = [];
+            for (const field of asArray(definition.fields).filter((entry) => Boolean(entry) && typeof entry === 'object')) {
+                if (field.isLocalized !== true)
+                    continue;
+                const name = String(field.slug ?? field.name ?? '?');
+                const relationType = String(field.relationType ?? 'none').toLowerCase();
+                const conflicts = [
+                    field.primaryKey === true ? 'primaryKey' : null,
+                    field.identity === true ? 'identity' : null,
+                    field.unique === true ? 'unique' : null,
+                    relationType !== 'none' && relationType !== '' ? `relationType: '${field.relationType}'` : null,
+                    field.commonType !== undefined && field.commonType !== 'text' ? `commonType: '${field.commonType}'` : null
+                ].filter((entry) => entry !== null);
+                if (conflicts.length === 0)
+                    continue;
+                findings.push({
+                    ruleId: 'ENT-011',
+                    severity: 'block',
+                    message: `'${name}' alanı isLocalized ama ${conflicts.join(', ')} taşıyor — platform yalnız düz METİN alanını çok dilli yapar. Bu gövde 400 ile reddedilir (FieldDto validator'ı isLocalized alanında primaryKey/identity/unique false, relationType 'none' ve commonType 'text' ister). Çeviriyi metin alanında tutun; anahtar, benzersizlik ve ilişki ana tabloda kalır. Ayrıntı: platform_guide('entity') §'Çoklu dilli alan'.`,
+                    guide: 'ngapps://guides/entity'
+                });
+            }
+            return findings;
+        }
+    },
     {
         id: 'MS-007',
         module: 'microservice',
@@ -1355,6 +1768,203 @@ export const policyRules = [
                 }];
         })
     },
+    {
+        id: 'FN-001',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: "GlobalFunctionRules.cs IsValidName(name, source)/IsValidParameterName → 422 GlobalFunctionNameInvalid; function-source.ts isValidName — geçersiz ad iki dünyada da fonksiyonu ATLATIR. Kaynağa özel ayrılmış ad: studio 'Functions' (K1), workflow WorkflowReservedNames (motor globalleri)",
+        check: definition => {
+            const name = String(definition.name ?? '');
+            const source = sourceOf(definition);
+            const findings = [];
+            const problem = nameProblem(definition.name, source);
+            if (problem !== undefined) {
+                findings.push({
+                    ruleId: 'FN-001',
+                    severity: 'block',
+                    message: source === 'workflow'
+                        ? `Fonksiyon adı '${name}' geçersiz: ${problem}. Ad /^[A-Za-z_$][A-Za-z0-9_$]*$/ kalıbına uymalı, JavaScript ayrılmış sözcüğü ve workflow motorunun global adı (system, input, Now, crypto…) olmamalı — platform 422 GlobalFunctionNameInvalid döner.`
+                        : `Fonksiyon adı '${name}' geçersiz: ${problem}. Ad /^[A-Za-z_$][A-Za-z0-9_$]*$/ kalıbına uymalı, JavaScript ayrılmış sözcüğü ve 'Functions' olmamalı — platform 422 GlobalFunctionNameInvalid döner; kayıt bir yolla geçse bile runtime böyle bir adı atlar ve Functions.${name} tanımsız kalır.`,
+                    guide: functionsGuide
+                });
+            }
+            for (const parameter of asArray(definition.parameters).filter(isRecord)) {
+                if (isValidParameterName(parameter.name))
+                    continue;
+                findings.push({
+                    ruleId: 'FN-001',
+                    severity: 'block',
+                    message: `'${name}' fonksiyonunun parametre adı '${String(parameter.name ?? '')}' geçersiz (${nameProblem(parameter.name) ?? 'geçersiz'}) — platform 422 GlobalFunctionNameInvalid döner; runtime geçersiz parametre adlı fonksiyonu TÜMÜYLE atlar.`,
+                    guide: functionsGuide
+                });
+            }
+            return findings;
+        }
+    },
+    {
+        id: 'FN-002',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'CreateGlobalFunctionCommandValidator: parametre adı tekrarı → 422 GlobalFunctionParameterNameDuplicate; bildirim parametreleri konumsal bağlar, aynı ad ikinci değeri gölgeler',
+        check: definition => {
+            const names = asArray(definition.parameters).filter(isRecord).map(parameter => String(parameter.name ?? ''));
+            const duplicates = [...new Set(names.filter((entry, index) => entry !== '' && names.indexOf(entry) !== index))];
+            return duplicates.length === 0
+                ? []
+                : [{
+                        ruleId: 'FN-002',
+                        severity: 'block',
+                        message: `'${String(definition.name ?? '?')}' fonksiyonunda parametre adı tekrar ediyor: ${duplicates.join(', ')} — platform 422 GlobalFunctionParameterNameDuplicate döner. Çağrı konumsaldır (K5); aynı ad iki konumu birden alamaz.`,
+                        guide: functionsGuide
+                    }];
+        }
+    },
+    {
+        id: 'FN-003',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'K15: fonksiyon başka fonksiyonu çağırabilir, tanım sırası önemsiz — kendini çağıran gövde durma koşulu yoksa sonsuz özyinelemedir; runCode RangeError\'ı yutar, sunucuda Jint LimitRecursion henüz yok (B-16, Faz 9)',
+        check: definition => {
+            const name = String(definition.name ?? '');
+            const source = sourceOf(definition);
+            const body = typeof definition.body === 'string' ? definition.body : '';
+            if (name === '' || !callsItself(name, body, source))
+                return [];
+            return [{
+                    ruleId: 'FN-003',
+                    severity: 'warn',
+                    message: `'${name}' gövdesi ${callPrefix(source)}${name}(…) ile KENDİNİ çağırıyor. Durma koşulu yoksa ${source === 'workflow' ? 'Jint sınırsız özyinelemeye girer (B-16 sertleştirmesi Faz 9\'da)' : "tarayıcıda 'Maximum call stack size exceeded' (runCode yutar, hedef prop yazılmaz)"}. Bilinçli özyinelemeyse yok sayın.`,
+                    guide: functionsGuide
+                }];
+        }
+    },
+    {
+        id: 'FN-004',
+        module: 'function',
+        appliesTo: ['create', 'update'],
+        sourceRef: "K6: isAsync istemci semantiğidir — function-source.ts compiles(): await taşıyan senkron gövde derlenmez ve atlanır; {{ }} inline bağlama Promise'i [object Promise] çizer. source:'workflow' senkron Jint motorunda koşar: GlobalFunction.ValidateState isAsync'i reddeder (422 GlobalFunctionAsyncNotAllowed)",
+        check: definition => {
+            const name = String(definition.name ?? '?');
+            const body = typeof definition.body === 'string' ? definition.body : '';
+            const isAsync = definition.isAsync === true;
+            if (isAsync && sourceOf(definition) === 'workflow') {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'block',
+                        message: `'${name}' source:'workflow' ama isAsync=true — workflow motoru senkron çalışır, async bildirimin dönüşü Promise olur ve code adımı '[object Promise]' görür; platform 422 GlobalFunctionAsyncNotAllowed döner. isAsync:false yapın; await gerekiyorsa bu bir studio fonksiyonudur.`,
+                        guide: functionsGuide
+                    }];
+            }
+            if (isAsync && !mentionsAwait(body)) {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'warn',
+                        message: `'${name}' isAsync=true ama gövdede await yok — async gereksiz ve bedeli var: {{ }} inline bağlamada dönüş Promise'dir ve ekrana '[object Promise]' yazılır. await gerekmiyorsa isAsync:false yapın.`,
+                        guide: functionsGuide
+                    }];
+            }
+            if (!isAsync && mentionsAwait(body)) {
+                return [{
+                        ruleId: 'FN-004',
+                        severity: 'warn',
+                        message: `'${name}' gövdesi await içeriyor ama isAsync=false — senkron function içinde await SyntaxError'dur: tarayıcı gövdeyi derleyemez ve fonksiyonu ATLAR (function-source.ts compiles), sunucu da derleyemediği gövdeyi atlar; Functions.${name} hiçbir yerde tanımlı olmaz. Ya isAsync:true yapın (o zaman yalnız tarayıcıda, function/code adımından çağrılır) ya da await'i kaldırın.`,
+                        guide: functionsGuide
+                    }];
+            }
+            return [];
+        }
+    },
+    {
+        id: 'FN-005',
+        module: 'function',
+        appliesTo: ['create'],
+        sourceRef: "CreateGlobalFunctionCommandValidator When(source): workflow ⇒ applicationId/pageId/scope null (422 GlobalFunctionSourceWorkflowScopeForbidden); studio ⇒ applicationId ve scope zorunlu, scope=page ⇒ pageId (422 GlobalFunctionScopePageRequired), scope=application ⇒ pageId yok (422 GlobalFunctionScopeApplicationPageForbidden)",
+        check: definition => {
+            const name = String(definition.name ?? '?');
+            const source = sourceOf(definition);
+            const has = (key) => definition[key] !== undefined && definition[key] !== null && definition[key] !== '';
+            const block = (message) => ({ ruleId: 'FN-005', severity: 'block', message, guide: functionsGuide });
+            if (source === 'workflow') {
+                const extras = ['applicationId', 'pageId', 'scope'].filter(has);
+                return extras.length === 0
+                    ? []
+                    : [block(`'${name}' source:'workflow' ama ${extras.join(', ')} verilmiş — workflow fonksiyonu TENANT genelidir, uygulamaya/kapsama/sayfaya bağlanmaz (platform 422 GlobalFunctionSourceWorkflowScopeForbidden). Alanları kaldırın; uygulamaya özel bir tarayıcı fonksiyonu istiyorsanız source:'studio'.`)];
+            }
+            if (!has('applicationId'))
+                return [block(`'${name}' source:'studio' ama applicationId yok — studio fonksiyonu bir uygulamaya aittir (platform 422). application_list ile uygulama id'sini verin; tenant geneli bir SUNUCU fonksiyonu istiyorsanız source:'workflow'.`)];
+            if (!has('scope'))
+                return [block(`'${name}' source:'studio' ama scope yok — 'application' (her sayfada) ya da 'page' (tek sayfa, pageId zorunlu) seçin (platform 422).`)];
+            if (definition.scope === 'page' && !has('pageId'))
+                return [block(`'${name}' scope:'page' ama pageId yok — platform 422 GlobalFunctionScopePageRequired verir; page_list ile sayfa id'sini alın.`)];
+            if (definition.scope === 'application' && has('pageId'))
+                return [block(`'${name}' scope:'application' fonksiyonda pageId verilmez — platform 422 GlobalFunctionScopeApplicationPageForbidden verir; sayfaya bağlamak istiyorsanız scope:'page'.`)];
+            return [];
+        }
+    },
+    {
+        id: 'FLOW-024',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: 'K9 + B-19: function adımında args.functionId zorunlu ve uygulamada var olmalı (CreateFlowCommandHandler ilk satırında 422 UiFunctionNotFound); tasks/function/function.ts önce id, sonra functionName ile çözer; parameters bildirim sırasına göre ada göre eşlenir',
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'function')
+            .flatMap(step => {
+            const args = (step.args ?? {});
+            const label = flowStepLabel(step);
+            const findings = [];
+            if (typeof args.functionId !== 'string' || !conditionRuleIdPattern.test(args.functionId)) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında args.functionId ${args.functionId === undefined || args.functionId === null ? 'yok' : `geçersiz ('${String(args.functionId)}')`} — platform 422 UiFunctionNotFound döner. Gerçek id'yi function_list ile alın; runtime fonksiyonu ÖNCE id ile çözer, functionName yalnız yedektir (K9).`,
+                    guide: functionsGuide
+                });
+            }
+            if (typeof args.functionName !== 'string' || args.functionName.trim() === '') {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'warn',
+                    message: `'${label}' function adımında args.functionName boş — Studio adım özeti 'seçili fonksiyon yok' gösterir ve id çözülemezse ad yedeği de kalmaz. functionName: '<fonksiyon adı>' yazın.`,
+                    guide: functionsGuide
+                });
+            }
+            if (args.parameters !== undefined && args.parameters !== null && !Array.isArray(args.parameters)) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında args.parameters dizi değil (${typeof args.parameters}) — şekil: [{ name: '<bildirimdeki ad>', value: { type: 'static'|'property'|'storage'|'state'|'code'|'variable'|'page'|'item', ref } }].`,
+                    guide: functionsGuide
+                });
+            }
+            const nameless = asArray(args.parameters).filter(isRecord).filter(parameter => typeof parameter.name !== 'string' || parameter.name.trim() === '');
+            if (nameless.length > 0) {
+                findings.push({
+                    ruleId: 'FLOW-024',
+                    severity: 'block',
+                    message: `'${label}' function adımında ${nameless.length} parametrenin name'i yok — eşleme bildirimdeki ada göre yapılır, adsız parametre hiçbir argümana bağlanmaz.`,
+                    guide: functionsGuide
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'WF-030',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "2026-09-10 kararı (Owner MR notu, zeyrek-backend docs/global-functions/02 §1): sunucu UI fonksiyonlarını YÜKLEMEZ — WorkflowContext'in 'Functions' ad alanı ve yükleme yolu kaldırıldı. Workflow/middleware/automation ifadesindeki Functions.<ad>(…) çağrısı Jint'te 'Functions is not defined' ile düşer (canlı ölçüldü: workflow_preview code adımı). Sunucuda paylaşılan hesap source:'workflow' fonksiyondur, çıplak adla çağrılır",
+        check: (definition, context) => {
+            const names = [...new Set(functionCallRefs(JSON.stringify(workflowBody(definition, context.workflowKind) ?? {})).map(ref => ref.name))];
+            return names.length === 0
+                ? []
+                : [{
+                        ruleId: 'WF-030',
+                        severity: 'block',
+                        message: `İfadeler ${names.map(name => `Functions.${name}(…)`).join(', ')} çağırıyor ama SUNUCUDA 'Functions' ad alanı YOKTUR (2026-09-10): motor kullanıcı fonksiyonlarını yüklemez, çağrı 'Functions is not defined' ile düşer ve adım hata yoluna girer. Sunucuda paylaşılan hesap source:'workflow' fonksiyondur — function_create source:'workflow' ile tanımlayıp ifadede çıplak adla çağırın ('${names[0]}(…)'). Kullanıcı fonksiyonları yalnız tarayıcıda çalışır ({{ }} bağlaması ve UI flow adımları).`,
+                        guide: functionsGuide
+                    }];
+        }
+    },
     {
         id: 'FLOW-005',
         module: 'flow',
@@ -1460,6 +2070,199 @@ export const policyRules = [
             });
         }
     },
+    {
+        id: 'FLOW-019',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "code.ts:18 kod gövdesini `task.argument?.value` alanından okur ve boşsa adımı NO-OP sayıp engine.next('always') çağırır. Gövde `args.value` alanındadır; `args.expression`/`args.script` gibi uydurma anahtarlar StepManagementArgument sözleşmesinde YOKTUR ve platform onları sessizce düşürür (ölçüldü 2026-09-05, Corecruiter koşusu S-19: akış koştu, filtre hiçbir şey yapmadı, teşhis ~10 dk sürdü)",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'code')
+            .flatMap((step) => {
+            const args = (step.args ?? {});
+            const body = typeof args.value === 'string' ? args.value.trim() : '';
+            if (body.length > 0)
+                return [];
+            const strays = ['expression', 'script', 'code', 'body', 'source']
+                .filter(key => typeof args[key] === 'string' && String(args[key]).trim().length > 0);
+            return [{
+                    ruleId: 'FLOW-019',
+                    severity: 'block',
+                    message: `'${flowStepLabel(step)}' code adımının gövdesi yok. Kod JS METNİ olarak args.value alanında durur — runtime onu \`(async () => { <value> })()\` içinde koşturur; alan boşken adım hata vermeden NO-OP olur ve akış hiçbir şey yapmadan devam eder.${strays.length > 0 ? ` Gövdeyi args.${strays.join('/args.')} alanına yazmışsınız: bu anahtar StepManagementArgument sözleşmesinde YOK ve platform onu sessizce düşürür — args.value olarak yazın.` : ''} Değeri bir komponentten okuyacaksanız code adımına hiç gerek yoktur: parametreye value { type: 'property', ref: { source: 'component', element, property } } verin.`,
+                    guide: 'ngapps://guides/page'
+                }];
+        })
+    },
+    {
+        id: 'FLOW-020',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "ng-apps-flow/tasks/condition/condition.ts + condition.types.ts: gövde `task.argument.rules: [{ id, expression, type: 'if'|'else-if'|'else' }]`; process() YALNIZ rules[0].type==='if' iken başlar, dal adı rule.id'dir (engine.next(rule.id) → Runtime.svelte:330 branch.name→branch.id → flow-engine.ts:93), 'else' yalnız expression BOŞKEN fallback'tir, eşleşmeyen kural rules[index+1]'e geçer. rule.id backend'de Guid'dir (StepManagementSchema.cs `public Guid Id { get; set; } = Guid.CreateVersion7()`): okunabilir ad System.Guid çevrimiyle reddedilir, id hiç verilmezse backend kendi GUID'ini üretir ve branches[].name ölü kalır. 'always' yalnız EŞLEŞEN dalın completed/stopped'ından çağrılır — rules boş / rules[0].type!=='if' / hiçbir kural tutmuyor ve boş ifadeli else yok hâllerinde engine.next('always') HİÇ çalışmaz. Backend workflow'unun rule.items[].branchId şekli (StepArgument.cs StepRule) sayfa akışında HİÇ okunmaz — 2026-09-06·2 koşusu S-12: istek 200, adım kaydedildi, Studio çizdi, motor kuralı hiç değerlendirmedi",
+        check: definition => flowAllSteps(definition)
+            .filter(step => step.type === 'condition')
+            .flatMap((step) => {
+            const args = (step.args ?? {});
+            const rules = asArray(args.rules).filter((rule) => Boolean(rule) && typeof rule === 'object');
+            const label = flowStepLabel(step);
+            const shape = "args.rules: [{ id: '<TAZE GUID>', expression: '<JS ifadesi>', type: 'if' }, { id: '<TAZE GUID>', expression: '', type: 'else' }] — id GERÇEK bir GUID olmalı (backend Guid'e çevirir) ve her rule.id için branches: [{ name: '<aynı GUID>', nextStepId: '<hedef stepId>' }]";
+            if (rules.length === 0) {
+                const workflowShape = args.rule !== undefined || args.items !== undefined || step.rule !== undefined;
+                return [{
+                        ruleId: 'FLOW-020',
+                        severity: 'block',
+                        message: workflowShape
+                            ? `'${label}' condition adımı BACKEND WORKFLOW şeklini taşıyor (rule/items). Sayfa akışının motoru başka bir motordur ve yalnız 'args.rules' okur (condition.ts); workflow şekli 200 ile kaydedilir, Studio çizer ve kural HİÇ değerlendirilmez — akış sessizce dalsız kalır. Doğru gövde: ${shape}`
+                            : `'${label}' condition adımında 'args.rules' yok ya da boş. Motor kural listesi boşken hiçbir dala girmez ve akış o adımda sessizce biter (condition.ts). Doğru gövde: ${shape}`,
+                        guide: 'ngapps://guides/page'
+                    }];
+            }
+            const findings = [];
+            const first = rules[0];
+            if (first.type !== 'if') {
+                findings.push({
+                    ruleId: 'FLOW-020',
+                    severity: 'block',
+                    message: `'${label}' condition adımının İLK kuralı type:'${String(first.type ?? '')}' — motor zinciri yalnız rules[0].type === 'if' iken başlatır (condition.ts), aksi hâlde adım hiçbir dala girmez ve akış sessizce biter. Zincirin başına 'if' kuralını koyun; devamı 'else-if', kapanışı boş ifadeli 'else' olur.`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            // YALNIZ `name` — motor dalı adıyla arar (Runtime.svelte:330 `branch.name || ''`).
+            // `id` GUID'dir; kümeye karıştırılırsa hiçbir rule id'si tutmaz ve kural sahte blok üretir.
+            const branchNames = new Set(flowBranches(step)
+                .map(branch => (typeof branch.name === 'string' ? branch.name : ''))
+                .filter(name => name.length > 0));
+            for (const rule of rules) {
+                const id = typeof rule.id === 'string' ? rule.id : '';
+                const type = String(rule.type ?? '');
+                const expression = typeof rule.expression === 'string' ? rule.expression : '';
+                const ruleLabel = id || type || '?';
+                if (id.length === 0) {
+                    findings.push({
+                        ruleId: 'FLOW-020',
+                        severity: 'block',
+                        message: `'${label}' condition adımının '${type || '?'}' kuralında 'id' yok. Dal adı kuralın id'sidir (engine.next(rule.id)); id vermezseniz backend kendi GUID'ini üretir (StepManagementSchema.cs \`Guid.CreateVersion7()\`), yazdığınız branches[].name ona ASLA eşleşmez ve dal sessizce ölür. Taze bir GUID üretip hem rule.id'ye hem branches[].name'e aynısını yazın.`,
+                        guide: 'ngapps://guides/page'
+                    });
+                    continue;
+                }
+                if (!conditionRuleIdPattern.test(id)) {
+                    findings.push({
+                        ruleId: 'FLOW-020',
+                        severity: 'block',
+                        message: `'${label}' condition adımının '${ruleLabel}' kuralında id GUID değil. Backend bu alanı Guid'e çevirir (StepManagementSchema.cs) ve okunabilir bir ad isteği \`The JSON value could not be converted to System.Guid\` ile reddeder. Dal adı da aynı GUID olmak zorunda olduğu için iki yerde birden okunabilir ad kullanamazsınız: taze bir GUID üretip hem rule.id'ye hem branches[].name'e yazın.`,
+                        guide: 'ngapps://guides/page'
+                    });
+                    continue;
+                }
+                if (!conditionRuleTypes.has(type)) {
+                    findings.push({
+                        ruleId: 'FLOW-020',
+                        severity: 'block',
+                        message: `'${label}' condition adımının '${ruleLabel}' kuralında type:'${type}' geçersiz — kabul edilen küme 'if' · 'else-if' · 'else' (condition.types.ts).`,
+                        guide: 'ngapps://guides/page'
+                    });
+                }
+                if (type === 'else' && expression.trim().length > 0) {
+                    findings.push({
+                        ruleId: 'FLOW-020',
+                        severity: 'warn',
+                        message: `'${label}' condition adımının '${ruleLabel}' kuralı type:'else' ama 'expression' dolu. Motor else dalını YALNIZ ifade boşken fallback sayar (condition.ts \`!rule.expression && rule.type === 'else'\`); dolu else normal bir karşılaştırmaya döner. Hiçbir kural tutmazsa akış dalsız biter ve 'always' dalı DA koşmaz — motor always'i yalnız eşleşen dalın completed/stopped'ından çağırır. Fallback istiyorsanız expression'ı boş bırakın.`,
+                        guide: 'ngapps://guides/page'
+                    });
+                }
+                if (branchNames.size > 0 && !branchNames.has(id)) {
+                    findings.push({
+                        ruleId: 'FLOW-020',
+                        severity: 'block',
+                        message: `'${label}' condition adımının '${ruleLabel}' kuralının id'si hiçbir branches[].name ile eşleşmiyor. Motor dalı adıyla arar (Runtime.svelte:330 branch.name → branch.id, flow-engine.ts:93) — eşleşme yoksa kural tutsa bile akış o dalda durur. branches'a { name: '${id}', nextStepId: '<hedef stepId>' } ekleyin.`,
+                        guide: 'ngapps://guides/page'
+                    });
+                }
+            }
+            // Hiç 'else' kuralı yoksa fallback de yoktur. Dolu ifadeli else zaten yukarıda
+            // uyarıldığı için burada YALNIZ else'siz zinciri raporluyoruz — aynı derdi iki kez
+            // söylemeyelim.
+            if (!rules.some(rule => String(rule.type ?? '') === 'else')) {
+                findings.push({
+                    ruleId: 'FLOW-020',
+                    severity: 'warn',
+                    message: `'${label}' condition adımında 'else' kuralı yok. Hiçbir ifade tutmazsa motor zinciri sessizce bitirir: akış dalsız kalır ve 'always' dalı DA koşmaz — always yalnız eşleşen dalın completed/stopped'ından tetiklenir (condition.ts). Yükleniyor bayrağını always ile kapatıyorsanız bayrak açık kalır. Zinciri boş ifadeli bir { type: 'else', expression: '' } kuralıyla kapatın.`,
+                    guide: 'ngapps://guides/page'
+                });
+            }
+            return findings;
+        })
+    },
+    {
+        id: 'FLOW-021',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "flow-engine.ts hasErrorFlow(): `flow.errorTasks.some(t => t.type !== 'start')` — yalnız start taşıyan errorSteps hata yolu SAYILMAZ, onError false döner ve akış hata gövdesiyle 'always' dalından devam eder (2026-09-06·2 koşusu S-13)",
+        check: definition => {
+            const errorSteps = flowStepList(definition.errorSteps);
+            if (errorSteps.length === 0)
+                return [];
+            return errorSteps.some(step => step.type !== 'start')
+                ? []
+                : [{
+                        ruleId: 'FLOW-021',
+                        severity: 'warn',
+                        message: "errorSteps yalnız 'start' adımı taşıyor — motor bunu hata yolu SAYMAZ (flow-engine.ts hasErrorFlow: start dışında en az bir adım arar). Hata yolu kurulmuş görünür ama uç 4xx dönünce onError false döner, akış 'always' dalından hata gövdesiyle devam eder ve kullanıcıya hiçbir mesaj ulaşmaz. start'ın ardına en az bir adım bağlayın: ucun kendi mesajını göstereceksen setter (value.type:'code' → Steps.error.message), sabit bir uyarı yetiyorsa alert — alert'in 'message' alanı DÜZ METİNDİR (alert.ts task.argument.message'ı doğrudan toast'a geçirir), oraya ifade yazarsanız kullanıcı ifadenin kendisini görür.",
+                        guide: 'ngapps://guides/page'
+                    }];
+        }
+    },
+    {
+        id: 'FLOW-022',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "alert.ts `const { message, alertType, description } = task.argument` → toast.error(message, { description }) / dialog.alert(message); confirm.ts `dialog.confirm(task.argument.message)`. Argüman Runtime.svelte'de HAM geçer (`argument: step.args`) — bu alanlarda hiçbir ifade değerlendirilmez, yazılan metin ekranda harfi harfine görünür (2026-09-06·2 koşusu S-13'ün ikinci turu: rehber hata mesajını göstermek için alert adımını öneriyordu)",
+        check: definition => flowAllSteps(definition)
+            .flatMap((step) => {
+            const type = String(step.type ?? '');
+            const fields = flowLiteralTextFields.get(type);
+            if (!fields)
+                return [];
+            const args = (step.args ?? {});
+            return fields
+                .filter(field => typeof args[field] === 'string' && flowExpressionLooking.test(args[field]))
+                .map(field => ({
+                ruleId: 'FLOW-022',
+                severity: 'warn',
+                message: `'${flowStepLabel(step)}' ${type} adımının '${field}' alanı ifade içeriyor ama bu alan DÜZ METİNDİR: ${type}.ts task.argument.${field}'i doğrudan ekrana geçirir ve args hiçbir yerde değerlendirilmez (Runtime.svelte \`argument: step.args\`). Kullanıcı ifadenin sonucunu değil ifadenin KENDİSİNİ görür. Ucun mesajını göstermek için bir setter (ya da code) adımı kullanın — value { type: 'code', ref: 'Steps.error?.message' }; hata metninin nerede durduğu page.md §hata yolu'nda.`,
+                guide: 'ngapps://guides/page'
+            }));
+        })
+    },
+    {
+        id: 'FLOW-023',
+        module: 'flow',
+        appliesTo: ['create', 'update'],
+        sourceRef: "Adım tipi sözlüğü backend'indir (StepType.cs) ama koşan tipler barındırıcıdan gelir: flow-engine.ts start·setter·code·condition·microservice·validation·flow-trigger register eder, web Runtime.svelte alert·confirm·redirect·download·storage·setcookie ekler, mobil ScreenRuntime.tsx alert·redirect·navigate·storage·setcookie ekler. navigate web'de, confirm/download mobilde YOKTUR; end ve query hiçbir barındırıcıda yoktur (Studio kataloğu da bunu visibility ile söyler: navigate 'mobile', confirm/download 'web'; End eklenebilir adımlar arasında değil — EventActionsAdd.svelte). Register edilmemiş tipe gelen akış SESSİZCE durur: flow-engine.ts process() callback bulamazsa hiçbir şey yapmaz (next yok, completed/stopped yok, hata yok, log yok), run() Promise'i çözülmez ve flowRunFinished() hiç koşmaz — __ngAppsFlowActivity.running sıfıra inmez, page_screenshot'ın hazır bekleyişi her eylemde bütçesini sonuna kadar yakar",
+        check: definition => {
+            const steps = flowAllSteps(definition);
+            // Studio her akış tuvaline dekoratif bir End düğümü koyar ve onu sildirmez; zararlı olan
+            // düğümün VARLIĞI değil, bir dalın oraya İŞARET ETMESİDİR — motor o adıma girer ve çıkamaz.
+            const targeted = new Set(steps.flatMap(step => flowBranches(step)
+                .map(branch => String(branch.nextStepId ?? ''))
+                .filter(id => id.length > 0)));
+            const silentStop = "Register edilmemiş bir tipe gelen akış SESSİZCE durur — flow-engine.ts process() callback bulamazsa hiçbir şey yapmaz: next() yok, completed/stopped yok, hata yok, log yok. Akışın kalanı ölür ve run() Promise'i çözülmediği için flowRunFinished() hiç koşmaz; __ngAppsFlowActivity.running sıfıra inmez ve page_screenshot'ın hazır bekleyişi her eylemde bütçesini sonuna kadar yakar.";
+            return steps.flatMap((step) => {
+                const type = String(step.type ?? '');
+                if (flowUnregisteredStepTypes.has(type)) {
+                    const reachable = type !== 'end' || targeted.has(String(step.stepId ?? ''));
+                    if (!reachable)
+                        return [];
+                    return [{
+                            ruleId: 'FLOW-023',
+                            severity: 'block',
+                            message: `'${flowStepLabel(step)}' adımının tipi '${type}' ve bir dal oraya işaret ediyor — bu tipi HİÇBİR barındırıcı register etmiyor (ne flow-engine.ts, ne web Runtime.svelte, ne mobil ScreenRuntime.tsx); Studio da onu eklenebilir adımlar arasında göstermez. ${silentStop} Akışı bitirmek için ayrı bir adım gerekmez: son adımın dalına nextStepId: null verin. Dekoratif bir '${type}' düğümü tutmak serbesttir, yeter ki hiçbir dal ona işaret etmesin.`,
+                            guide: 'ngapps://guides/page'
+                        }];
+                }
+                return [];
+            });
+        }
+    },
     {
         id: 'FLOW-017',
         module: 'flow',
@@ -1624,31 +2427,32 @@ export const policyRules = [
             const microserviceStepsByName = new Map(steps
                 .filter(step => step.type === 'microservice' && step.name)
                 .map(step => [String(step.name), step]));
-            return steps.flatMap(step => flowCodeExpressions(step).flatMap(({ expression, origin }) => {
-                flowHeadersAccess.lastIndex = 0;
-                const findings = [];
-                let match;
-                while ((match = flowHeadersAccess.exec(expression)) !== null) {
-                    const name = match[1] ?? match[2] ?? '';
+            return steps.flatMap(step => {
+                const seen = new Set();
+                return flowCodeExpressions(step).flatMap(({ expression, origin }) => headersAccessNames(expression).flatMap((name) => {
+                    if (seen.has(name))
+                        return [];
                     const source = microserviceStepsByName.get(name);
                     if (source && (source.args ?? {}).isRaw === true) {
-                        findings.push({
+                        seen.add(name);
+                        return [{
+                                ruleId: 'FLOW-011',
+                                severity: 'block',
+                                message: `'${flowStepLabel(step)}' adımının ${origin} ifadesi Steps.${name}.headers okuyor ama '${name}' adımı isRaw=true ile çalışıyor — o zaman storage ham response.data'dır, 'headers' diye bir alan HİÇ yazılmaz (microservice.ts:88). İfade her koşuda TypeError verir. isRaw'ı kaldırın (normalize false'a çeker) ya da header okumaktan vazgeçin.`,
+                                guide: 'ngapps://guides/page'
+                            }];
+                    }
+                    if (isHeadersAccessGuarded(expression, name))
+                        return [];
+                    seen.add(name);
+                    return [{
                             ruleId: 'FLOW-011',
-                            severity: 'block',
-                            message: `'${flowStepLabel(step)}' adımının ${origin} ifadesi Steps.${name}.headers okuyor ama '${name}' adımı isRaw=true ile çalışıyor — o zaman storage ham response.data'dır, 'headers' diye bir alan HİÇ yazılmaz (microservice.ts:88). İfade her koşuda TypeError verir. isRaw'ı kaldırın (normalize false'a çeker) ya da header okumaktan vazgeçin.`,
+                            severity: 'warn',
+                            message: `'${flowStepLabel(step)}' adımının ${origin} ifadesinde Steps.${name}.headers guard'sız okunuyor. İstek HATA aldığında storage { error, data } olarak yazılır ve 'headers' alanı yoktur (microservice.ts:132) → TypeError; runCode undefined döner (prop'a NaN yazılır), ifade hatası toast'ı düşer ve flow-engine.ts:53 akışı onError'a çevirip durdurabilir. Guard'lı yazın: Number(Steps.${name}?.headers?.["total-count"] ?? 0) ya da Steps.${name}.headers && … önkoşulu.`,
                             guide: 'ngapps://guides/page'
-                        });
-                        continue;
-                    }
-                    findings.push({
-                        ruleId: 'FLOW-011',
-                        severity: 'warn',
-                        message: `'${flowStepLabel(step)}' adımının ${origin} ifadesinde Steps.${name}.headers guard'sız okunuyor. İstek HATA aldığında storage { error, data } olarak yazılır ve 'headers' alanı yoktur (microservice.ts:132) → TypeError; runCode undefined döner (prop'a NaN yazılır), ifade hatası toast'ı düşer ve flow-engine.ts:53 akışı onError'a çevirip durdurabilir. Guard'lı yazın: Number(Steps.${name}?.headers?.["total-count"] ?? 0).`,
-                        guide: 'ngapps://guides/page'
-                    });
-                }
-                return findings;
-            }));
+                        }];
+                }));
+            });
         }
     },
     {
@@ -1881,6 +2685,35 @@ export const policyRules = [
                 }];
         }
     },
+    {
+        id: 'ROL-002',
+        module: 'microservice',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "Ürün sahibi cevabı 2026-09-07 (S-16): rol yönetimi entity + microservice yoludur. Kaynak: roles kolonları id · name (UNIQUE ix_roles_name) · slug (TenantContextModelSnapshot); yetkilendirme slug'a bakar (QueryConstants.GetUserQuery ARRAY(SELECT r.slug …), Authorized(user.roles)); slug'ı role_list DÖNDÜRMEZ (RoleDto = Id + Name)",
+        check: definition => {
+            const parameters = definition.sourceParameters;
+            if (definition.source !== 'table')
+                return [];
+            return writesRolesWithoutSlug(parameters?.entityId ?? definition.entityId, parameters)
+                ? [{ ruleId: 'ROL-002', severity: 'warn', message: rolesSlugMessage, guide: 'ngapps://guides/entity' }]
+                : [];
+        }
+    },
+    {
+        id: 'ROL-002',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "ROL-002'nin workflow ayağı: table step de aynı tabloya yazar (rule.entityId + rule.fields)",
+        check: (definition, context) => workflowSteps(workflowBody(definition, context.workflowKind))
+            .filter(step => step.type === 'table' && step.rule)
+            .filter(step => writesRolesWithoutSlug(step.rule.entityId, step.rule))
+            .map(step => ({
+            ruleId: 'ROL-002',
+            severity: 'warn',
+            message: `'${stepLabel(step)}' table adımı: ${rolesSlugMessage}`,
+            guide: 'ngapps://guides/entity'
+        }))
+    },
     {
         id: 'MW-003',
         module: 'workflow',
@@ -1902,5 +2735,89 @@ export const policyRules = [
                         guide: 'ngapps://guides/middleware'
                     }];
         }
-    }
+    },
+    // Backend doğrulayıcılarının aynası (ENT-015…018, MS-017, WF-026, QRY/VIEW/DTO/ROW/DS/PRJ/TR/FLD/FILE/EXT):
+    // tek liste `backendConstraints.ts`'te durur, buradan yalnız politika motoruna katılır.
+    ...backendPolicyRules()
 ];
+/**
+ * WF-MF-001'in ikinci yarısı. Bir adımın koşup koşmayacağı yalnız GÖVDEDEN anlaşılamaz: karar
+ * seçilen microfunction'ın YAYIN DURUMUNA bağlıdır ve o durum platformda yaşar. Politika
+ * kuralları senkron ve saf olduğu için bu denetim ayrı durur — gateway `microfunction_get`
+ * ucunu okur, bulguyu aynı `policyFindings` kanalına koyar ve `policyOverride` / `POLICY=warn`
+ * kaçışları (applyPolicyMode) aynen geçerli kalır.
+ *
+ * Okuma başarısız olursa (ağ, yetki, beklenmeyen gövde) kural SUSAR: ön-denetim bir kolaylıktır,
+ * gateway'in kendi arızası yüzünden geçerli bir workflow yazılamaz hâle gelmemeli.
+ */
+export async function microfunctionStepFindings(platform, project, environment, definition, kind, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const steps = workflowSteps(workflowBody(definition, kind))
+        .filter(step => step.type === 'microfunction')
+        .filter(step => hasText((step.rule ?? {}).microfunctionId));
+    if (steps.length === 0)
+        return [];
+    const records = new Map();
+    const findings = [];
+    for (const step of steps) {
+        const rule = (step.rule ?? {});
+        const microfunctionId = String(rule.microfunctionId);
+        if (!records.has(microfunctionId)) {
+            try {
+                const payload = await platform.tenant('GET', project, `/microfunctions/${microfunctionId}`, { environment });
+                records.set(microfunctionId, (payload?.data ?? payload));
+            }
+            catch (error) {
+                records.set(microfunctionId, error instanceof PlatformApiError && error.status === 404 ? 'missing' : 'unreadable');
+            }
+        }
+        const record = records.get(microfunctionId);
+        if (record === undefined || record === 'unreadable')
+            continue;
+        if (record === 'missing') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'block',
+                message: `'${stepLabel(step)}' adımının microfunctionId'si (${microfunctionId}) bu ortamda YOK. Adım kuralı step_rules.microfunction_id ile kayda FK'lıdır: gövde gitseydi platform 400 dönerdi. microfunction_list ile bu ortamdaki kayıtları görün — fonksiyon başka bir dalda/ortamda kalmış olabilir.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+            continue;
+        }
+        const status = String(record.status ?? '');
+        if (status === 'draft' || status === 'publish-failed') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'block',
+                message: `'${stepLabel(step)}' adımı '${String(record.name ?? microfunctionId)}' fonksiyonunu seçiyor ama kaydın durumu '${status}'${status === 'publish-failed' && hasText(record.publishError) ? ` (publishError: ${String(record.publishError)})` : ''}. Step YALNIZ yayındaki kaydı koşturur: MicrofunctionStep kaydı yükleyip Status != Published görünce MicrofunctionNotPublishedException ile FAIL dalına düşer — akış kurulur, kaydedilir ve koşumda sessizce hata yoluna girer. Önce microfunction_publish çağırın ve microfunction_get ile 'published' olduğunu görün.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+            continue;
+        }
+        if (status === 'publishing') {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${stepLabel(step)}' adımının fonksiyonu ('${String(record.name ?? microfunctionId)}') şu anda yayınlanıyor. Yayın ASENKRONDUR: bu akış şimdi koşarsa adım fail dalına düşer. microfunction_get ile 'published' olduğunu doğrulayın (yayın başarısız olursa durum 'publish-failed' olur).`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+        if (record.hasUnpublishedChanges === true) {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${String(record.name ?? microfunctionId)}' fonksiyonu yayında ama üstüne yazılmış (hasUnpublishedChanges: true, revision ${String(record.revision ?? '?')} ≠ publishedRevision ${String(record.publishedRevision ?? '?')}). Runtime hâlâ ESKİ sürümü koşuyor — yeni kodu canlıya almak için microfunction_publish çağırın.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+        if (!hasText(rule.expression) && hasText(record.parameterDtoId)) {
+            findings.push({
+                ruleId: 'WF-MF-001',
+                severity: 'warn',
+                message: `'${stepLabel(step)}' adımında rule.expression boş ama '${String(record.name ?? microfunctionId)}' fonksiyonunun bir parametre DTO'su var (parameterDtoId: ${String(record.parameterDtoId)}). Fonksiyon args olarak boş nesne alır ve kendi alanlarını undefined görür. Argümanları ifadeyle geçirin — şemayı microfunction_get çıktısındaki parameterScheme verir.`,
+                guide: 'ngapps://guides/microfunction'
+            });
+        }
+    }
+    return applyPolicyMode(platform.config, findings, policyOverride);
+}