@appaflytech/zeyrek-ai-mcp 0.0.11 → 0.0.12

package/dist/knowledge/errorPath.js

@@ -1,5 +1,25 @@
 import { randomUUID } from 'node:crypto';
 const ERROR_STEP_NAME = 'gatewayOnError';
+const ERROR_STEP_NAME_PATTERN = /^gatewayOnError\d*$/;
+/**
+ * Global-error dalında `error` = `WorkflowError.ToObject()`: `{ code, message, detail, type,
+ * step: { id, name, type, data, input } }` (`ActivityContext.EnterGlobalErrorHandling`). Gövde
+ * `step`'i ALT KÜME olarak yazar, çünkü (1) `ResponseStep` global-error kipinde gövdedeki `step`
+ * `error.step` ile birebir aynıysa onu siler, (2) `step.input` adımın ifade değerlerini (parola
+ * dahil) taşır. Zincir önce `error.cause`'tan okunur: backend 2026-09-17'den beri her seviyeyi
+ * `{ code, message, detail, type, step: { name, type }, cause }` olarak orada verir — loop iterasyonu
+ * (`<loop>[<sıra>]`) ve istisnasız 2xx dışı dönen çocuk dahil (`WorkflowError.ToObject`). Eski backend'de
+ * `error.cause` yoktur; o zaman yalnız patlayan `workflow` adımının `step.data`'sı okunur: fırlatan
+ * çocukta `WorkflowError.ToResponseObject()`, 2xx dışı dönen çocukta çocuğun KENDİ yanıtı. İkincisi
+ * keyfî olabilir (elle yazılmış `({ err: error })` input taşır), bu yüzden `pick` her iki kaynağı seviye
+ * seviye beyaz listeye süzer: `code/message/detail/type/step{name,type}/cause`. Hiçbiri yoksa `cause`
+ * yazılmaz. Loop adımının `data`'sı tamamlanan öğelerdir — okunmaz. Canlı ölçüm 2026-09-16 (lokal `emrah/web`, üç seviyeli
+ * zincir + `/m/`). ES5: motor Jint 4 ama desteklenen yüzey belgesiz (RFQ W-4); null alan yazılmaz.
+ */
+export const GATEWAY_ERROR_BODY_EXPRESSION = "(function () { function pick(source, depth) { if (!source || typeof source !== 'object') return null; var picked = {}; if (source.code) picked.code = source.code; if (source.message) picked.message = source.message; if (source.detail) picked.detail = source.detail; if (source.type) picked.type = source.type; if (source.step && source.step.name) { picked.step = { name: source.step.name }; if (source.step.type) picked.step.type = source.step.type; } if (depth < 8 && source.cause) { var inner = pick(source.cause, depth + 1); if (inner) picked.cause = inner; } return picked.code || picked.message || picked.step || picked.cause ? picked : null; } var body = { code: error.code, message: error.message }; if (error.detail) body.detail = error.detail; if (error.type) body.type = error.type; if (error.step) body.step = { name: error.step.name, type: error.step.type }; var cause = pick(error.cause, 0) || (error.step && error.step.type === 'workflow' ? pick(error.step.data, 0) : null); if (cause) body.cause = cause; return body; })()";
+export const LEGACY_GATEWAY_ERROR_BODY_EXPRESSION = '({ code: error.code, message: error.message })';
+const ERROR_STEP_DESCRIPTION = "Gateway'in eklediği hata yolu: akışın herhangi bir adımı patlarsa buraya düşer ve 500 ile { code, message, detail, type, step: { name, type } } döner; patlayan adım bir alt akışsa çocuğun hata gövdesi cause içinde iç içe gelir. Kendi hata gövdeni istiyorsan bu adımın bodyExpression'ını değiştir.";
+const LEGACY_ERROR_STEP_DESCRIPTION = "Gateway'in eklediği hata yolu: akışın herhangi bir adımı patlarsa buraya düşer ve 500 ile { code, message } döner. Kendi hata gövdeni istiyorsan bu adımın bodyExpression'ını değiştir.";
 const INJECTED_KINDS = new Set(['workflow', 'middleware']);
 function asSteps(value) {
     return (Array.isArray(value) ? value : []).filter((step) => Boolean(step) && typeof step === 'object');
@@ -35,8 +55,9 @@ export function ensureWorkflowErrorPath(definition, kind) {
     if (steps.some(step => step !== startStep && (Array.isArray(step.branches) ? step.branches : []).some(branch => branch?.type === 'global-error')))
         return [];
     const branches = Array.isArray(startStep.branches) ? startStep.branches : [];
-    if (branches.some(branch => branch?.type === 'global-error' && branch.nextStepId))
-        return [];
+    const wired = branches.find(branch => branch?.type === 'global-error' && branch.nextStepId);
+    if (wired)
+        return upgradeLegacyErrorBody(steps, String(wired.nextStepId));
     const name = availableName(steps);
     const errorStepId = randomUUID();
     const unwired = branches.find(branch => branch?.type === 'global-error');
@@ -44,12 +65,12 @@ export function ensureWorkflowErrorPath(definition, kind) {
         id: errorStepId,
         name,
         type: 'response',
-        description: "Gateway'in eklediği hata yolu: akışın herhangi bir adımı patlarsa buraya düşer ve 500 ile { code, message } döner. Kendi hata gövdeni istiyorsan bu adımın bodyExpression'ını değiştir.",
+        description: ERROR_STEP_DESCRIPTION,
         caution: "Bu adımı gateway ekledi; silersen akışın hata yolu kaybolur ve patlayan adım istemciye ham hata döndürür.",
         rule: {
             stepType: 'response',
             httpStatusCode: 500,
-            bodyExpression: '({ code: error.code, message: error.message })'
+            bodyExpression: GATEWAY_ERROR_BODY_EXPRESSION
         },
         branches: []
     });
@@ -60,5 +81,27 @@ export function ensureWorkflowErrorPath(definition, kind) {
         branches.push({ id: randomUUID(), name: 'global-error', type: 'global-error', nextStepId: errorStepId });
     }
     startStep.branches = branches;
-    return [`hata yolu eklendi: start adımına 'global-error' dalı + '${name}' response adımı (500, { code, message }). Hata yolu olmayan akış patladığında platform WorkflowStepFailedException fırlatır (HTTP 500 { code, message, detail, type }; zamanlanmış işte failed + "Step 'x' failed: …"); bu adım çıktıyı { code, message } ile denetim altına alır, zamanlanmış işte sonuç yine failed düşer. Kendi hata gövdenizi istiyorsanız bu adımın bodyExpression'ını değiştirin.`];
+    return [`hata yolu eklendi: start adımına 'global-error' dalı + '${name}' response adımı (500, { code, message, detail, type, step: { name, type }, cause }). Hata yolu olmayan akış patladığında platform WorkflowStepFailedException fırlatır (HTTP 500 { code, message, detail, type }, 2026-09-17 backend'inde step ve cause da; zamanlanmış işte failed + "Step 'x' failed: …"); bu adım aynı şekli ele alınmış 500 olarak döner — patlayan adımın adı ve tipi, alt akış ya da loop iterasyonu zinciri cause içinde — ve zamanlanmış işte sonuç yine failed düşer. Kendi hata gövdenizi istiyorsanız bu adımın bodyExpression'ını değiştirin.`];
+}
+/**
+ * Bu dosyanın 2026-09-16 öncesi sürümü hata adımına `{ code, message }` yazıyordu; o kayıtlar
+ * `detail`, `type` ve patlayan adımı dışarı vermez. Yalnız gateway'in KENDİ yazdığı ve kimsenin
+ * dokunmadığı adım yükseltilir: global-error dalının hedefi, adı `gatewayOnError[n]`, tipi
+ * `response`, ifadesi eski varsayılanla birebir aynı VE açıklaması eski gateway metni (ya da boş).
+ * Açıklama şartı, yükseltilmiş bir adımı aynı çağrıda bilerek eski gövdeye döndüren kullanıcıyı
+ * korur: yükseltme açıklamayı da yenilediği için geri dönüş bir daha ezilmez.
+ */
+function upgradeLegacyErrorBody(steps, errorStepId) {
+    const target = steps.find(step => String(step.id ?? '') === errorStepId);
+    const rule = target?.rule;
+    if (!target || target.type !== 'response' || !ERROR_STEP_NAME_PATTERN.test(String(target.name ?? '')) || !rule)
+        return [];
+    if (typeof rule.bodyExpression !== 'string' || rule.bodyExpression.trim() !== LEGACY_GATEWAY_ERROR_BODY_EXPRESSION)
+        return [];
+    const untouchedDescription = target.description === undefined || target.description === null || String(target.description).trim() === '' || target.description === LEGACY_ERROR_STEP_DESCRIPTION;
+    if (!untouchedDescription)
+        return [];
+    rule.bodyExpression = GATEWAY_ERROR_BODY_EXPRESSION;
+    target.description = ERROR_STEP_DESCRIPTION;
+    return [`hata gövdesi genişletildi: '${String(target.name)}' adımının bodyExpression'ı gateway'in eski varsayılanıydı ({ code, message }); yeni varsayılan detail, type, patlayan adımın { name, type } bilgisini ve adım bir alt akışsa çocuğun hata gövdesini cause olarak da döner. Çocuk gövdesi yalnız code/message/detail/type/step{name,type}/cause alanlarına süzülür. Yanıta alan EKLENİR, mevcut code/message değişmez. Açıklaması ya da ifadesi elle değiştirilmiş hata adımına dokunulmaz; eski gövdede kalmak için bu adımın açıklamasını değiştirin.`];
 }

package/dist/knowledge/rules.js

@@ -47,6 +47,47 @@ function hasText(value) {
 function stepLabel(step) {
     return step.name || step.type || step.id || '?';
 }
+const GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * `workflow` adımının (ve `loop` içindeki `stepType: 'workflow'` çocuğunun) alt akışı çağıran
+ * kuralı. `WorkflowStep.cs` yalnız `rule.WorkflowId` + `rule.Expression` okur; girdiyi başka
+ * bir alanla göndermeye çalışan gövde ya kaydedilip okunmaz (şema üyeleri) ya da hiç
+ * kaydedilmez (şema dışı adlar, `unmappedMembers`) — iki durumda da alt akış SESSİZCE girdisiz
+ * koşar (RFQ koşusu W-7, 2026-09-14). Platform her adım kuralını `fields: []`,
+ * `customParameters: null` gibi boş varsayılanlarla geri okuttuğu için yalnız DOLU değer sayılır;
+ * aksi hâlde `workflow_get` gövdesiyle yapılan her `workflow_patch`/`update`/`preview` kendi
+ * kendine bloklanırdı.
+ */
+const WORKFLOW_STEP_SAVED_BUT_UNREAD_KEYS = ['payloadExpression', 'customParameters', 'queryParameters', 'bodyExpression', 'fields'];
+const WORKFLOW_STEP_UNMAPPED_INPUT_KEYS = ['parameters', 'parameter', 'input', 'payload', 'arguments', 'args', 'variables'];
+function carriesValue(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'string')
+        return value.trim() !== '';
+    return true;
+}
+function workflowCallSites(body) {
+    return workflowSteps(body).flatMap((step) => {
+        const rule = (step.rule ?? {});
+        if (step.type === 'workflow')
+            return [{ step, rule, label: stepLabel(step) }];
+        if (step.type === 'loop' && rule.stepType === 'workflow' && rule.stepRule && typeof rule.stepRule === 'object') {
+            return [{ step, rule: rule.stepRule, label: `${stepLabel(step)} (loop çocuğu)` }];
+        }
+        return [];
+    });
+}
+function literalShapeOf(expression) {
+    const head = expression.trim().replace(/^[(\s]+/, '');
+    if (head.startsWith('{'))
+        return 'object';
+    if (head.startsWith('['))
+        return 'array';
+    return undefined;
+}
 /**
  * Start'tan başlayıp `global-error` dalları HARİÇ tüm dalları izleyerek erişilen adımlar.
  * Gateway her `workflow`/`middleware` tanımına global-error dalının ucunda bir `response` adımı
@@ -698,6 +739,45 @@ export const policyRules = [
             });
         }
     },
+    {
+        id: 'WF-032',
+        module: 'workflow',
+        appliesTo: ['create', 'update', 'preview'],
+        sourceRef: "WorkflowStep.cs EvaluateAsync: kural yalnız rule.WorkflowId ve rule.Expression okur; girdi workflow.HasParameter iken Expression'ın DataTransferObjectExpression.Eval'iyle bağlanır, başka hiçbir alan okunmaz. Studio WorkflowTrigger.svelte de yalnız bu iki alanı yazar ve expression'ı çağrılan akışın parameterScheme'inden nesne literali olarak doldurur. RFQ koşusu W-7 (2026-09-14): payloadExpression/customParameters kaydedildi, alt akış girdisiz koştu",
+        check: (definition, context) => workflowCallSites(workflowBody(definition, context.workflowKind)).flatMap(({ label, rule }) => {
+            const workflowId = rule.workflowId;
+            if (!hasText(workflowId)) {
+                return [{
+                        ruleId: 'WF-032',
+                        severity: 'block',
+                        message: `'${label}' workflow adımında rule.workflowId yok — adım hangi akışı çağıracağını bilmez. workflow_list(applicationId, type: 'workflow') ile id seçin; girdi rule.expression'a nesne literali olarak yazılır (çağrılan akışın parametre DTO'suna göre).`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            if (!GUID_PATTERN.test(String(workflowId))) {
+                return [{
+                        ruleId: 'WF-032',
+                        severity: 'block',
+                        message: `'${label}' adımının rule.workflowId'si GUID değil: '${String(workflowId)}'. Platform alanı Guid'e çeviremediği için 400 döner; slug değil id verin (workflow_list).`,
+                        guide: 'ngapps://guides/workflow'
+                    }];
+            }
+            const savedButUnread = WORKFLOW_STEP_SAVED_BUT_UNREAD_KEYS.filter(key => carriesValue(rule[key]));
+            const unmapped = WORKFLOW_STEP_UNMAPPED_INPUT_KEYS.filter(key => carriesValue(rule[key]));
+            if (savedButUnread.length === 0 && unmapped.length === 0)
+                return [];
+            const fate = [
+                savedButUnread.length > 0 ? `${savedButUnread.map(key => `rule.${key}`).join(', ')} kaydedilir ama WorkflowStep okumaz` : '',
+                unmapped.length > 0 ? `${unmapped.map(key => `rule.${key}`).join(', ')} StepRuleDto'da yok, platform hiç kaydetmez (unmappedMembers)` : ''
+            ].filter(part => part !== '').join('; ');
+            return [{
+                    ruleId: 'WF-032',
+                    severity: 'block',
+                    message: `'${label}' adımı alt akışa girdiyi yanlış alandan gönderiyor — ${fate}. WorkflowStep yalnız rule.workflowId ve rule.expression okur: iki durumda da alt akış boş girdiyle koşar ve 200 döner (RFQ koşusu W-7). Eşlemeyi rule.expression'a nesne literali olarak yazın — her anahtar çağrılan akışın parametre DTO'sundaki bir alan, her değer bir JS ifadesi: "({ title: input.title, source: 'telemetry' })". Aynı adlı alan code adımında GÖVDE, workflow/microfunction adımında GİRDİDİR. Alan listesini workflow_step_schema (parameterScheme) ya da workflow_get(<workflowId>).parameterDtoId → dto_get verir.`,
+                    guide: 'ngapps://guides/workflow'
+                }];
+        })
+    },
     {
         id: 'WF-006',
         module: 'workflow',
@@ -2873,6 +2953,89 @@ export async function microfunctionStepFindings(platform, project, environment,
     }
     return applyPolicyMode(platform.config, findings, policyOverride);
 }
+/**
+ * WF-032'nin ikinci yarısı. `rule.expression`'ın işe yarayıp yaramayacağı gövdeden görülemez:
+ * `WorkflowStep` ifadeyi YALNIZ çağrılan akışın parametre DTO'su varken değerlendirir
+ * (`workflow.HasParameter`); DTO'suz alt akışa yazılan ifade hiç koşmaz ve girdi boş gider.
+ * Karar çağrılan akışın kaydında yaşar — gateway `workflow_get` ucunu okur ve bulguyu aynı
+ * `policyFindings` kanalına koyar; `policyOverride` / `POLICY=warn` kaçışları aynen geçerlidir.
+ *
+ * Okuma başarısız olursa kural SUSAR (WF-MF-001 ile aynı gerekçe). Uygulama kimliği ne
+ * parametrede ne gövdede varsa (automation yolu `entityId` ile çalışır) da susar: statik yarı
+ * yine koşar, canlı yarı bir kolaylıktır.
+ */
+export async function workflowStepFindings(platform, project, environment, applicationId, definition, kind, policyOverride = false) {
+    if (platform.config.policyMode === 'off')
+        return [];
+    const application = hasText(applicationId)
+        ? String(applicationId)
+        : hasText(definition.applicationId) ? String(definition.applicationId) : undefined;
+    if (application === undefined)
+        return [];
+    const sites = workflowCallSites(workflowBody(definition, kind))
+        .filter(site => GUID_PATTERN.test(String(site.rule.workflowId ?? '')));
+    if (sites.length === 0)
+        return [];
+    const guide = 'ngapps://guides/workflow';
+    const records = new Map();
+    const findings = [];
+    for (const { label, rule } of sites) {
+        const workflowId = String(rule.workflowId);
+        if (!records.has(workflowId)) {
+            try {
+                const payload = await platform.tenant('GET', project, `/workflows/${application}/${workflowId}`, { environment });
+                records.set(workflowId, (payload?.data ?? payload));
+            }
+            catch (error) {
+                records.set(workflowId, error instanceof PlatformApiError && error.status === 404 ? 'missing' : 'unreadable');
+            }
+        }
+        const record = records.get(workflowId);
+        if (record === undefined || record === 'unreadable')
+            continue;
+        if (record === 'missing') {
+            findings.push({
+                ruleId: 'WF-032',
+                severity: 'block',
+                message: `'${label}' adımının workflowId'si (${workflowId}) bu ortamda YOK (platform kaydı yalnız id ile arar, uygulama kimliğine bakmaz). Adım kuralı step_rules.workflow_id ile kayda FK'lıdır: gövde gitseydi platform 400 dönerdi. workflow_list(applicationId: '${application}', type: 'workflow') ile bu ortamdaki akışları görün — alt akış başka bir dalda ya da ortamda kalmış, ya da henüz yaratılmamış olabilir.`,
+                guide
+            });
+            continue;
+        }
+        const calleeName = String(record.name ?? record.slug ?? workflowId);
+        const parameterDtoId = hasText(record.parameterDtoId) ? String(record.parameterDtoId) : undefined;
+        const expression = hasText(rule.expression) ? String(rule.expression) : '';
+        if (expression !== '' && parameterDtoId === undefined) {
+            findings.push({
+                ruleId: 'WF-032',
+                severity: 'block',
+                message: `'${label}' adımı '${calleeName}' akışına rule.expression ile girdi geçiriyor ama o akışın parametre DTO'su YOK (parameterDtoId boş). WorkflowStep ifadeyi yalnız workflow.HasParameter iken değerlendirir: bu hâliyle ifade HİÇ çalışmaz, alt akış boş girdiyle koşar ve 200 döner. Önce alt akışa girdi sözleşmesi verin — dto_create ile alan listesini tanımlayın, sonra workflow_patch(id: '${workflowId}', ops: [{ op: 'add', path: '/parameterDtoId', value: '<dtoId>' }, { op: 'add', path: '/parameterBehavior', value: 'object' }]); alt akışın adımları girdiyi input.<alan> ile okur.`,
+                guide
+            });
+            continue;
+        }
+        if (expression === '' && parameterDtoId !== undefined) {
+            findings.push({
+                ruleId: 'WF-032',
+                severity: 'warn',
+                message: `'${label}' adımında rule.expression boş ama '${calleeName}' akışının parametre DTO'su var (parameterDtoId: ${parameterDtoId}). Alt akış input olarak boş nesne alır, kendi input.<alan> okumaları undefined döner. Girdiyi nesne literaliyle geçirin — alan listesini workflow_step_schema çıktısındaki parameterScheme ya da dto_get('${parameterDtoId}') verir.`,
+                guide
+            });
+            continue;
+        }
+        const behavior = String(record.parameterBehavior ?? '').toLowerCase();
+        const literal = literalShapeOf(expression);
+        if (literal !== undefined && ((behavior === 'array' && literal === 'object') || (behavior === 'object' && literal === 'array'))) {
+            findings.push({
+                ruleId: 'WF-032',
+                severity: 'warn',
+                message: `'${label}' adımının ifadesi ${literal === 'object' ? 'nesne' : 'dizi'} literaliyle başlıyor ama '${calleeName}' akışının parameterBehavior'ı '${behavior}': alt akış input olarak ${behavior === 'array' ? 'DİZİ bekler; nesne alınca öğe okumaları' : 'NESNE bekler; dizi alınca input.<alan> okumaları'} undefined döner. İfadeyi davranışa uydurun ya da alt akışın parameterBehavior'ını değiştirin.`,
+                guide
+            });
+        }
+    }
+    return applyPolicyMode(platform.config, findings, policyOverride);
+}
 const partialWriteOperations = new Set(['create', 'update', 'upsert']);
 const inputReferencePattern = /\binput\.([A-Za-z_$][\w$]*)/g;
 function inputReferencesOf(rule) {

package/dist/platform/errors.js

@@ -177,6 +177,79 @@ function diagnoseKnownFailure(status, message, code, context) {
     }
     return '';
 }
+const MaxErrorCauseWalk = 32;
+const MaxErrorPathShown = 6;
+const MaxErrorTextLength = 400;
+function nonEmptyText(value) {
+    if (typeof value !== 'string' || value.trim() === '')
+        return undefined;
+    return value.length > MaxErrorTextLength ? `${value.slice(0, MaxErrorTextLength)}…` : value;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function errorLevels(body) {
+    const levels = [];
+    let current = asRecord(body);
+    while (current) {
+        if (levels.length === MaxErrorCauseWalk)
+            return { levels, truncated: true };
+        const step = asRecord(current.step);
+        const name = nonEmptyText(step?.name);
+        const stepType = nonEmptyText(step?.type);
+        levels.push({
+            step: name ? `'${name}'${stepType ? ` (${stepType})` : ''}` : undefined,
+            code: nonEmptyText(current.code),
+            message: nonEmptyText(current.message),
+            detail: nonEmptyText(current.detail),
+            type: nonEmptyText(current.type)
+        });
+        current = asRecord(current.cause);
+    }
+    return { levels, truncated: false };
+}
+function seenKey(...parts) {
+    return JSON.stringify(parts);
+}
+/**
+ * Workflow 5xx gövdesinden, başlıkta zaten yazılmış `code`/`message` dışında kalan bilgiyi çıkarır.
+ * İki gövde şekli okunur: platformun `WorkflowStepErrorResponse`'u `{ code, message, detail, type }`
+ * (hata yolu olmayan akış, `ExceptionHandler.cs`) ve gateway hata adımının gövdesi
+ * `{ …, step: { name, type }, cause }` (`errorPath.ts`). `cause` zinciri alt akış seviyelerini
+ * taşır; aynı kod+mesaj her seviyede tekrarlandığı için mesaj EN DERİNDEN başlanarak bir kez, hatanın
+ * doğduğu adıma atfedilerek yazılır. Kodla aynı `type` ve mesajla aynı `detail` gürültüdür. Uzun
+ * zincirde yolun başı ve SONU gösterilir (hatanın doğduğu adım kaybolmasın); metinler kırpılır.
+ */
+export function describeErrorBody(body, shown) {
+    const { levels, truncated } = errorLevels(body);
+    const fragments = [];
+    const path = levels.map(level => level.step).filter((step) => step !== undefined);
+    const shownPath = path.length > MaxErrorPathShown ? [...path.slice(0, 2), '…', ...path.slice(-3)] : path;
+    if (shownPath.length > 0)
+        fragments.push(`hata yolu: ${shownPath.join(' → ')}${truncated ? ' → …' : ''}`);
+    const seen = new Set();
+    if (shown) {
+        seen.add(seenKey('head', shown.code, shown.message));
+        if (levels[0])
+            seen.add(seenKey('head', levels[0].code, levels[0].message));
+    }
+    for (const level of [...levels].reverse()) {
+        const key = seenKey('head', level.code, level.message);
+        if ((level.code || level.message) && !seen.has(key)) {
+            seen.add(key);
+            fragments.push(`${level.step ? `${level.step} ` : ''}${[level.code, level.message].filter(Boolean).join(': ')}`);
+        }
+        if (level.detail && level.detail !== level.message && !seen.has(seenKey('detail', level.detail))) {
+            seen.add(seenKey('detail', level.detail));
+            fragments.push(`detail: ${level.detail}`);
+        }
+        if (level.type && level.type !== level.code && !seen.has(seenKey('type', level.type))) {
+            seen.add(seenKey('type', level.type));
+            fragments.push(`type: ${level.type}`);
+        }
+    }
+    return fragments;
+}
 export function mapPlatformError(status, payload, context) {
     const body = payload && typeof payload === 'object' ? payload : {};
     const code = typeof body.code === 'string' ? body.code : undefined;
@@ -222,7 +295,9 @@ export function mapPlatformError(status, payload, context) {
     }
     const fallbackValidationMessages = collectValidationMessages(body);
     const fallbackDetail = fallbackValidationMessages.length > 0 ? ` → ${fallbackValidationMessages.join(' ; ')}` : '';
-    return new PlatformApiError(`Platform hatası ${status} (${location}): ${apiMessage ?? 'beklenmeyen hata'}${code ? ` [${code}]` : ''}${fallbackDetail}${diagnoseKnownFailure(status, apiMessage ?? '', code, context)}`, status, code);
+    const errorBody = status >= 500 ? describeErrorBody(body, { code, message: apiMessage }) : [];
+    const errorBodyDetail = errorBody.length > 0 ? ` — ${errorBody.join(' · ')}` : '';
+    return new PlatformApiError(`Platform hatası ${status} (${location}): ${apiMessage ?? 'beklenmeyen hata'}${code ? ` [${code}]` : ''}${errorBodyDetail}${fallbackDetail}${diagnoseKnownFailure(status, apiMessage ?? '', code, context)}`, status, code);
 }
 export function mapNetworkError(error, context) {
     const cause = error instanceof Error ? error : new Error(String(error));

package/dist/platform/responses.js

@@ -1,5 +1,5 @@
 import { logError, logStep } from '../observability/trace.js';
-import { PlatformApiError } from './errors.js';
+import { PlatformApiError, describeErrorBody } from './errors.js';
 import { PolicyBlockError } from '../knowledge/policy.js';
 import { maskSecrets } from './secrets.js';
 export function prune(value) {
@@ -76,6 +76,17 @@ export function runtimeErrorSummary(payload) {
     const errors = [];
     if (typeof record.httpStatus === 'number' && record.httpStatus >= 400) {
         errors.push(`httpStatus: ${record.httpStatus} — çağrı ${record.httpStatus} ile bitti; gövde başarı çıktısı değil hata gövdesidir. Adım adım bakmak için microservice_debug kullanın.`);
+        // Yalnız 5xx: 4xx gövdeleri (422 doğrulama, 401) bilinçli iş yanıtıdır ve zaten gövdede okunur.
+        // `/debug/` ucu gövdeyi her zaman, `/m/` ve servis önizlemesi ise uiActions kurulmuşsa
+        // `{ data, uiActions[, executionItems] }` ile sarar (MicroservicesController.Debug / HandleResult).
+        const raw = record.body && typeof record.body === 'object' && !Array.isArray(record.body) ? record.body : undefined;
+        const wrapped = raw !== undefined && ('executionItems' in raw || 'uiActions' in raw) && raw.data && typeof raw.data === 'object' && !Array.isArray(raw.data);
+        const errorBody = wrapped ? raw.data : raw;
+        const describable = record.httpStatus >= 500 && errorBody !== undefined &&
+            (typeof errorBody.code === 'string' || Boolean(errorBody.step && typeof errorBody.step === 'object') || Boolean(errorBody.cause && typeof errorBody.cause === 'object'));
+        const fragments = describable ? describeErrorBody(errorBody) : [];
+        if (fragments.length > 0)
+            errors.push(`hata gövdesi — ${fragments.join(' · ')}`);
     }
     const stepErrors = [];
     collectStepErrors(body.steps, stepErrors);

package/dist/resources/guides/workflow.md

@@ -227,19 +227,68 @@ tanımı kendi global-error dalınla gönder — dal **bağlıysa** (`nextStepId
 dokunmaz. `nextStepId: null` ile bağlanmamış gönderirsen gateway ikinci bir dal eklemez, mevcut
 dalını enjekte ettiği hata adımına bağlar.
 
-**Fail dallarını tek tek bağlamana gerek yok.** Bir adımın `fail` dalı bağlanmamışsa
-(`nextStepId: null`) ya da hiç yoksa, hata **kendiliğinden** global-error dalına gider. `fail`
-dalını yalnız o adıma özel bir telafi akışı (örn. "kayıt yoksa oluştur") istiyorsan bağla.
+### `gatewayOnError`'un 500 gövdesi: patlayan adım ve alt akış zinciri (2026-09-16)
+
+```jsonc
+// POST /m/web/ticket-ac → 500   (ebeveyn → callChild → çocuk akış → childBoom patladı)
+{ "code": "JavaScriptException", "message": "Error: x is not defined\n   at <anonymous>:1:8",
+  "detail": "…", "type": "JavaScriptException",
+  "step":  { "name": "callChild", "type": "workflow" },          // bu akışta patlayan adım
+  "cause": { "code": "JavaScriptException", "message": "…",       // alt akışın KENDİ hata gövdesi
+             "step": { "name": "childBoom", "type": "code" } } }   // çocukta patlayan adım
+```
+
+- **`step` yalnız `{ name, type }`'tır.** `error.step.input` ifade değerlerini (parola dahil),
+  `error.step.data` adımın çıktısını taşır; ikisi de dışarı yazılmaz. `error.step`'i bütün olarak
+  gövdeye koyarsan platform onu **siler** (`ResponseStep` global-error kipinde `error.step` ile
+  birebir aynı `step` alanını kaldırır) — alt küme yaz.
+- **`cause` bir seviye aşağıyı taşır** ve her seviyede yalnız `code`, `message`, `detail`, `type`,
+  `step { name, type }` ve `cause` geçer (gateway beyaz listeye süzer, en fazla dokuz seviye). Backend
+  2026-09-17'den beri zinciri `error.cause`'ta kendisi kurar; üç durum kapsanır:
+  - **Alt akış patladı:** `cause.step` çocukta patlayan adım, çocuk da alt akış çağırıyorsa zincir
+    seviye seviye iç içe iner. Çocuk Studio'da hata yolsuz kurulduysa da adım adı gelir.
+  - **Loop iterasyonu patladı:** `step` loop adımı, `cause.step.name` `loopRows[0]` gibi
+    `<loop adı>[<sıra>]`, iterasyondaki alt akışın zinciri onun altında.
+  - **Çocuk istisnasız 2xx dışı döndü** (`response` 422): `code` `SubWorkflowFailedException`,
+    `message` `Sub-workflow '<ad>' returned 422 (<gövde code>): <gövde message>`.
+
+  Eski backend'de `error.cause` yoktur; gateway o zaman patlayan `workflow` adımının `step.data`'sına
+  (çocuğun kendi gövdesi) düşer — loop ve istisnasız çocuk orada kaybolur. Çocuk kendi 4xx/5xx yanıtını
+  elle yazdıysa (`({ success: false, token })`, `({ err: error })`) o gövdenin yalnız bu alanları geçer.
+  Canlı ölçüldü (2026-09-16/17): torunun `token` ve `step.input`'u üst gövdeye ulaşmadı; üç seviyeli
+  zincir ve `loopRows` → `loopRows[0]` → `boomStep` hem hata yolsuz hem gateway hata yollu uçta döndü.
+- **Gateway zinciri okur (yalnız 5xx):** `microservice_execute`/`debug`/`preview` `runtimeErrors`'a
+  `hata gövdesi — hata yolu: 'callChild' (workflow) → 'childBoom' (code) · 'childBoom' (code)
+  JavaScriptException: …` satırını ekler (debug ucunun `{ data, executionItems }` sarmalı açılır);
+  fırlatan çağrıların (senkron automation'lı `row_create`, `workflow_preview`…) araç hatası da
+  gövdede bulunan `detail`'i, koddan farklı `type`'ı ve varsa zinciri yazar. 4xx gövdeleri
+  süslenmez — onlar bilinçli iş yanıtıdır.
+- **Eski kayıtlar:** 2026-09-16 öncesi gateway `({ code: error.code, message: error.message })`
+  yazıyordu. Global-error dalının hedefi olan, adı `gatewayOnError[n]`, ifadesi bu metinle AYNEN
+  aynı ve açıklaması gateway'in eski metni (ya da boş) olan adım bir sonraki
+  `workflow_create`/`update`/`patch`/`preview`'da yeni gövdeye yükseltilir (`gatewayNormalized`:
+  "hata gövdesi genişletildi"; önizleme kaydetmez). Yanıta alan eklenir, `code`/`message` değişmez.
+  Açıklaması ya da ifadesi elle değiştirilmiş adıma dokunulmaz; yükseltme açıklamayı da yenilediği
+  için sonradan bilerek eski gövdeye dönen `bodyExpression` bir daha ezilmez.
+- **Dışarı ne verdiğine sen karar verirsin.** Adım adları iç yapıyı, `detail` iç istisna mesajını
+  (kısıt adı, host) gösterebilir. **Middleware'in 500 gövdesi korumalı uçların anonim çağıranına da
+  gider** (`ExecuteMicroserviceBehavior`). Herkese açık yüzeyde istemiyorsan hata adımının
+  `bodyExpression`'ını daralt, örn. `({ code: error.code, message: error.message })`.
 
 Global-error dalında `error` değişkeni tanımlıdır:
 
 ```jsonc
 { "code": "RowAlreadyExists", "message": "…", "detail": "…", "type": "…",
-  "step": { "id": "…", "name": "writeRow", "type": "table", "data": …, "input": [ … ] } }
+  "step": { "id": "…", "name": "writeRow", "type": "table", "data": …, "input": [ … ] },
+  "cause": null }   // alt akış / loop iterasyonunda { code, message, detail, type, step: { name, type }, cause }
 ```
 
-`error.step` hangi adımın patladığını söyler — hata yanıtına koymadan önce iki kez düşün, iç
-yapıyı dışarı sızdırır.
+Fail dalında aynı zincir `<adım adı>.error.cause`'tadır (`<adım adı>.error` = `{ code, message, detail,
+type, cause }`).
+
+`error.step` hangi adımın patladığını söyler. `input`/`data` alanları ifade değerlerini ve adım
+çıktısını taşır — gövdeye yalnız ihtiyaç duyduğun alt kümeyi yaz (gateway'in varsayılanı
+`{ name, type }`'tır, yukarıdaki §`gatewayOnError`'un 500 gövdesi).
 
 **Kurallar ve sınırlar:**
 
@@ -257,9 +306,14 @@ yapıyı dışarı sızdırır.
   bağlı — §izin matrisi) ya da `email`/`table` adımına bağla. Bağlı hata yolu yoksa `WF-021` uyarır.
 - **Hata yolu hiç yoksa** (fail dalı ve global-error dalı bağlı değil) adım patladığında motor
   canlıda `WorkflowStepFailedException` fırlatır (2026-09-16): HTTP yanıt 500 +
-  `{ code, message, detail, type }` (patlayan adımın hatası), zamanlanmış iş ve automation geçmişi
-  `failed` + `Step 'x' failed: <sebep>`, senkron automation tetikleyen satır yazımını düşürür.
-  Önizlemede fırlatmaz, ağaç döner. Çalışır, ama çıktı lokalize değildir.
+  `{ code, message, detail, type, step: { name, type }, cause }` — `step` ve `cause` 2026-09-17'den
+  beri, gateway hata adımıyla aynı şekil (yerel ortamda ayrıca `stackTrace`). Zamanlanmış iş ve
+  automation geçmişi `failed` + `Step 'x' failed: <sebep>`, senkron automation tetikleyen satır
+  yazımını düşürür. Önizlemede fırlatmaz, ağaç döner. Çalışır, ama çıktı lokalize değildir.
+- **Adım hata yolunun DIŞINDA patlarsa** (ör. `revert`'in `revertType` ifadesi tırnaksız) kod
+  `EvaluateWorkflowStepFailedException`, mesaj `Step '<ad>' threw outside its error path: <sebep>`
+  olur: fail dalı ve global-error dalı ÇALIŞMAZ, canlı koşu düşer. 2026-09-17'den beri önizleme
+  ağacı kaybolmaz; adım `hasError: true` ile işaretlenir.
 
 > **Preview HTTP 200 dönerken bile akış patlamış olabilir.** `executionSuccess` yalnız SON adıma
 > bakar; ortada patlayıp hata dalından dönen akış `true` gösterir. Gateway tüm adımları (iç içe
@@ -347,6 +401,63 @@ gidilir, hiçbiri tutmazsa `else` dalı yürür:
 > `rule.isExpression` bayrağı bu iki alan için **okunmaz**.
 
 
+## Workflow adımı: başka bir akışı parametreyle çağırmak (WF-032)
+
+Ortak mantığı (kayıt açma, bildirim, numaralandırma) **bir kez** `type:'workflow'` akışı olarak
+yazıp diğer akışlardan çağırmanın yolu budur — 30 adımı kopyalamak değil. Adım tipi `workflow`;
+üç akış tipinde de kullanılabilir. Kuralı **iki alan** taşır ve girdi eşlemesi ikincisidir:
+
+```jsonc
+{ "id": "<GUID>", "name": "createTicket", "type": "workflow",
+  "description": "Telemetri olayından create-ticket akışıyla kayıt açar.",
+  "rule": {
+    "workflowId": "<create-ticket akışının id'si>",
+    "expression": "({ title: input.title, source: 'telemetry', payload: parseEvent.data })"
+  },
+  "branches": [
+    { "id": "<GUID>", "name": "success", "type": "success", "nextStepId": "<sonraki>" },
+    { "id": "<GUID>", "name": "fail", "type": "fail", "nextStepId": "<hata adımı>" }
+  ] }
+```
+
+- **Eşleme `rule.expression`'daki nesne literalidir: her anahtar çağrılan akışın parametre
+  DTO'sundaki bir alan, her değer bir JS ifadesi** (`input.x`, önceki adımın `<ad>.data.x`'i,
+  sabit). Studio'nun adım editörü de aynı şeyi yapar — akış seçilince ifadeyi `parameterScheme`'den
+  `{ "alan": <örnek> }` olarak doldurur (`WorkflowTrigger.svelte`). Table adımının `fields[]`
+  listesinin buradaki karşılığı budur; ayrı bir liste alanı **yoktur** ve gerekmez.
+- **Çağrılan akışın `parameterDtoId` + `parameterBehavior`'ı OLMAK ZORUNDA.** `WorkflowStep`
+  ifadeyi yalnız `workflow.HasParameter` iken değerlendirir (`WorkflowStep.cs`); DTO'suz alt
+  akışa yazılan ifade hiç koşmaz, alt akış boş `input` ile çalışır ve **200 döner**. Gateway
+  çağrılan akışı okuyup bunu **block** eder (WF-032). Reçete: `dto_create` → `workflow_patch(id:
+  <alt akış>, ops: [{ op: 'add', path: '/parameterDtoId', value: <dtoId> }, { op: 'add', path:
+  '/parameterBehavior', value: 'object' }])`.
+- **Başka hiçbir alan girdi taşımaz.** Şema üyeleri (`payloadExpression`, `customParameters`,
+  `queryParameters`, `bodyExpression`, `fields`) kaydedilir ama `WorkflowStep` okumaz; şema dışı
+  adlar (`parameters`, `input`, `payload`, `args`…) platformda hiç kaydedilmez (`unmappedMembers`).
+  İki durumda da alt akış boş girdi alır (RFQ koşusu W-7, 2026-09-14: beş biçim denendi, beşinde
+  de boş girdi). Gateway DOLU değer görürse block eder; `workflow_get`'in geri okuttuğu
+  `fields: []` / `customParameters: null` gibi boş varsayılanlar kuralı tetiklemez.
+- **Ad tuzağı:** `rule.expression` `code` adımında GÖVDE (çalıştırılan kod), `workflow` ve
+  `microfunction` adımında GİRDİ (argüman nesnesi) demektir. Aynı ad, iki anlam.
+- **Alt akış girdiyi `input.<alan>` ile okur ve onun `input`'u bu nesnedir** — çağıranın
+  `input`'unu görmez; çağıranın bir alanı gerekiyorsa eşlemeye koy. `parameterBehavior: 'array'`
+  ise ifade dizi üretmelidir (gateway nesne literali görürse uyarır).
+- **Çıktı alt akışın yanıt gövdesidir** (`response` adımının `returnDtoId` süzgecinden geçmiş
+  hâli) ve sonraki adımlara `<adım adı>.data` ile akar. Alt akış 2xx dışı dönerse ya da bir
+  adımı düşerse çağıran adım **fail** dalına gider; `<adım adı>.data` o zaman alt akışın hata
+  gövdesidir.
+- **Şekli tahmin etme, oku:** `workflow_step_schema(step)` çağrılan akışın `parameterScheme` ve
+  `returnScheme`'ini döner; ya da `workflow_get(<workflowId>)` → `parameterDtoId` → `dto_get`.
+- **Loop içinde:** `rule.stepType: 'workflow'`, `rule.arrayExpression`, çocuk kural
+  `rule.stepRule: { workflowId, expression: "({ title: loopItem.title })" }` — WF-032 çocuğu da
+  denetler.
+- **Önizlemede** alt akışın kendi adım izi `steps[].children[]` altında `kind: 'subWorkflow'` ile
+  gelir; çağıran adımın `input[]` listesinde `member: 'parameter'` satırı ifadenin ürettiği nesneyi
+  gösterir — **satır yoksa ya da değeri boşsa girdi bağlanmamıştır.** Alt akışı tek başına
+  sınamak için kendi `previewPayload`'ı ile `workflow_preview` çağır.
+- Aynı alt akışı birden çok adımdan çağırmak serbesttir; özyineleme runner'ın koşum sayacına
+  takılır (kural envanteri WF-028 — gateway kuralı değil, backend davranışı).
+
 ## Loop step — dizinin her öğesi için bir adım koştur
 
 Tek uçta "başlık + N alt kayıt" yazmanın yolu budur (anket + sorular + seçenekler tek çağrıda;

package/dist/tools/automations.js

@@ -2,7 +2,7 @@ import { guid, entityRef, resolveEntityId, withResolved, projectParam, environme
 import { RefResolver } from '../platform/refs.js';
 import { normalizeWorkflowDefinition, withNormalization } from '../knowledge/normalize.js';
 import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
-import { policyRules, microfunctionStepFindings } from '../knowledge/rules.js';
+import { policyRules, microfunctionStepFindings, workflowStepFindings } from '../knowledge/rules.js';
 import { languageHeader } from '../knowledge/languageCodes.js';
 import { handle } from '../platform/responses.js';
 import { z } from 'zod';
@@ -40,7 +40,8 @@ export function registerAutomationTools(server, platform) {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'create', workflowKind: 'automation' }, policyOverride),
-            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride)
+            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride),
+            ...await workflowStepFindings(platform, project, environment, undefined, definition, 'automation', policyOverride)
         ]);
         const resolver = new RefResolver(platform, project, environment);
         const resolvedEntityId = await resolveEntityId(resolver, entityId);
@@ -56,7 +57,8 @@ export function registerAutomationTools(server, platform) {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'update', workflowKind: 'automation' }, policyOverride),
-            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride)
+            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride),
+            ...await workflowStepFindings(platform, project, environment, undefined, definition, 'automation', policyOverride)
         ]);
         const resolver = new RefResolver(platform, project, environment);
         const resolvedEntityId = await resolveEntityId(resolver, entityId);
@@ -135,7 +137,8 @@ export function registerAutomationTools(server, platform) {
         const normalized = normalizeWorkflowDefinition(definition);
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'preview', workflowKind: 'automation' }, policyOverride),
-            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride)
+            ...await microfunctionStepFindings(platform, project, environment, definition, 'automation', policyOverride),
+            ...await workflowStepFindings(platform, project, environment, undefined, definition, 'automation', policyOverride)
         ]);
         const resolver = new RefResolver(platform, project, environment);
         const resolvedEntityId = await resolveEntityId(resolver, entityId);

package/dist/tools/workflows.js

@@ -4,7 +4,7 @@ import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/poli
 import { workflowOutline, resolvePart, resolvePatchOperations } from '../knowledge/outlines.js';
 import { patchResult, baseVersionOf } from '../platform/patch.js';
 import { writeDiff, withWriteDiff } from '../platform/writeDiff.js';
-import { policyRules, microfunctionStepFindings, undefinedInputFieldFindings } from '../knowledge/rules.js';
+import { policyRules, microfunctionStepFindings, workflowStepFindings, undefinedInputFieldFindings } from '../knowledge/rules.js';
 import { languageHeader } from '../knowledge/languageCodes.js';
 import { handle } from '../platform/responses.js';
 import fastJsonPatch from 'fast-json-patch';
@@ -119,6 +119,7 @@ export function registerWorkflowTools(server, platform) {
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'create', workflowKind: definition.type }, policyOverride),
             ...await microfunctionStepFindings(platform, project, environment, definition, definition.type, policyOverride),
+            ...await workflowStepFindings(platform, project, environment, applicationId, definition, definition.type, policyOverride),
             ...await undefinedInputFieldFindings(platform, project, environment, definition, definition.type, policyOverride)
         ]);
         const drift = unmappedMembers('CreateWorkflowCommand', definition);
@@ -135,6 +136,7 @@ export function registerWorkflowTools(server, platform) {
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'update', workflowKind: definition.type }, policyOverride),
             ...await microfunctionStepFindings(platform, project, environment, definition, definition.type, policyOverride),
+            ...await workflowStepFindings(platform, project, environment, applicationId, definition, definition.type, policyOverride),
             ...await undefinedInputFieldFindings(platform, project, environment, definition, definition.type, policyOverride)
         ]);
         const drift = unmappedMembers('UpdateWorkflowCommand', definition);
@@ -156,6 +158,7 @@ export function registerWorkflowTools(server, platform) {
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', patched, { operation: 'update', workflowKind: patched.type }, policyOverride),
             ...await microfunctionStepFindings(platform, project, environment, patched, patched.type, policyOverride),
+            ...await workflowStepFindings(platform, project, environment, applicationId, patched, patched.type, policyOverride),
             ...await undefinedInputFieldFindings(platform, project, environment, patched, patched.type, policyOverride)
         ]);
         const drift = introducedUnmappedMembers('UpdateWorkflowCommand', (current?.data ?? current), patched);
@@ -202,6 +205,7 @@ export function registerWorkflowTools(server, platform) {
         const findings = enforcePolicy([
             ...evaluatePolicy(config, policyRules, 'workflow', definition, { operation: 'preview', workflowKind: definition.type }, policyOverride),
             ...await microfunctionStepFindings(platform, project, environment, definition, definition.type, policyOverride),
+            ...await workflowStepFindings(platform, project, environment, applicationId, definition, definition.type, policyOverride),
             ...await undefinedInputFieldFindings(platform, project, environment, definition, definition.type, policyOverride)
         ]);
         const payload = await platform.tenant('POST', project, `/workflows/${applicationId}/preview`, { environment, body: definition, headers: languageHeader(language, normalized) });
@@ -209,7 +213,7 @@ export function registerWorkflowTools(server, platform) {
     }));
     server.registerTool('workflow_step_schema', {
         title: 'Step şeması üret',
-        description: 'Verilen step tanımı için çıktı şemasını üretir; step yazarken definition\'ı doğrulamanın en hızlı yolu.',
+        description: "Verilen step tanımı için girdi/çıktı şemasını üretir (parameterScheme / returnScheme); step yazarken definition'ı doğrulamanın en hızlı yolu. type:'workflow' adımında (rule.workflowId) çağrılan akışın parametre ve dönüş DTO'sunu döner — alt akışa girdi YALNIZ rule.expression ile geçer, nesne literalinin anahtarları bu parameterScheme'in alanlarıdır (WF-032; platform_guide('workflow') §Workflow adımı).",
         inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid, step: definitionParam },
         annotations: readOnly
     }, handle(config, ({ project, environment, applicationId, id, step }) => platform.tenant('POST', project, `/workflows/${applicationId}/${id}/steps/schema`, { environment, body: step })));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appaflytech/zeyrek-ai-mcp",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "type": "module",
   "description": "Zeyrek (NgApps) platform APIs as MCP tools — data, logic and Studio design surface in one gateway",
   "license": "UNLICENSED",
@@ -35,6 +35,7 @@
     "harvest-examples": "tsx scripts/harvest-examples.ts",
     "kabul:import-adres": "tsx scripts/import-kabul-adres.ts",
     "kabul:import-senaryolar": "tsx scripts/import-kabul-senaryolar.ts",
+    "kabul:workflow-hata-zinciri": "tsx scripts/kabul-workflow-hata-zinciri.ts",
     "benchmark:report": "tsx scripts/benchmark-report.ts"
   },
   "dependencies": {