@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/knowledge/rules.js

@@ -1,6 +1,8 @@
 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 { 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'],
@@ -18,8 +20,7 @@ const stepKindMatrix = {
     redirect: ['middleware'],
     response: ['workflow', 'middleware'],
     convert: ['workflow'],
-    revert: ['automation'],
-    end: ['workflow', 'automation', 'middleware']
+    revert: ['automation']
 };
 function asArray(value) {
     return Array.isArray(value) ? value : [];
@@ -99,6 +100,27 @@ const flowBranchNames = {
     end: []
 };
 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 +131,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,9 +205,25 @@ 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;
 const writeOperations = new Set(['create', 'update', 'delete', 'upsert']);
+/** 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']);
 function flattenFilterTree(filters) {
     return filters
@@ -300,6 +350,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 +562,25 @@ 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'
+                    }];
+            });
         }
     },
     {
@@ -524,7 +671,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 +719,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 +885,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 +1155,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 +1163,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',
@@ -1460,6 +1809,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 +2166,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 +2424,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 +2474,8 @@ 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()
 ];