@appaflytech/zeyrek-ai-mcp 0.0.28 → 0.0.30

package/dist/tools/connectors.js

@@ -0,0 +1,193 @@
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { assertProcessNotProduction } from './bpm.js';
+import { z } from 'zod';
+const credentialKinds = ['api-key', 'basic', 'bearer', 'oauth2-client', 'oauth2-auth-code', 'webhook'];
+const eventSourceKinds = ['http', 'rabbitmq', 'kafka', 'service-bus'];
+const mailSourceKinds = ['imap', 'graph'];
+const credentialFields = {
+    name: z.string().min(1).max(100).describe("kasa adı (tekil); düğümde credentialRef, kanal kimliklerinde sabit ad: notification-sms · notification-teams · notification-slack"),
+    connectorName: z.string().min(1).max(50).describe('connector_list adı; kaydedildikten sonra değişmez'),
+    kind: z.enum(credentialKinds),
+    baseUrl: z.string().max(500).optional().describe('instance/taban URL (Salesforce instance, Jira site, Camunda REST kökü)'),
+    tokenUrl: z.string().max(500).optional().describe('oauth2 belirteç ucu'),
+    clientId: z.string().max(200).optional(),
+    username: z.string().max(200).optional(),
+    scopes: z.array(z.string().max(200)).max(50).optional(),
+    apiKeyHeader: z.string().max(100).optional().describe("api-key başlığı; yoksa Authorization"),
+    clientSecret: z.string().max(4000).optional(),
+    password: z.string().max(4000).optional(),
+    apiKey: z.string().max(4000).optional().describe('webhook türünde webhook URL\'si buraya yazılır'),
+    refreshToken: z.string().max(4000).optional(),
+    accessToken: z.string().max(4000).optional()
+};
+function catalogOf(payload) {
+    const data = payload?.data ?? payload;
+    return Array.isArray(data) ? data : [];
+}
+export function registerConnectorTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('connector_list', {
+        title: 'Bağlayıcı kataloğu',
+        description: "Kayıtlı bağlayıcıları listeler (GET bpm/connectors): ad, kategori (ai | process-engine | productivity | messaging | business-app | rpa), başlık, sürüm, desteklenen kimlik türleri ve işlem adları. category verilirse yalnız o kategori döner (süzme gateway'de). İşlem girdi/çıktı şemaları için connector_get. Süreçte kullanım: service düğümü connector { name, operation, credentialRef, input } ya da dış motor için externalEngine { engine: camunda8 | camunda7 | flowable, processKey, credentialRef, input }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            category: z.enum(['ai', 'process-engine', 'productivity', 'messaging', 'business-app', 'rpa']).optional().describe('yalnız bu kategorideki bağlayıcılar')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, category }) => catalogOf(await platform.tenant('GET', project, '/bpm/connectors', { environment }))
+        .filter(connector => !category || connector.category === category)
+        .map(connector => ({
+        name: connector.name,
+        category: connector.category,
+        title: connector.title,
+        version: connector.version,
+        credentialKinds: connector.credentialKinds,
+        operations: (Array.isArray(connector.operations) ? connector.operations : []).map(operation => operation.name)
+    }))));
+    server.registerTool('connector_get', {
+        title: 'Bağlayıcıyı getir',
+        description: 'Bağlayıcının işlemlerini girdi ve çıktı şemalarıyla döner (katalogdan adla). Girdi doğrulaması zorunlu alanlar ve temel türlerle sınırlıdır; düğümde input değerleri Jint ifadesidir.',
+        inputSchema: { project: projectParam, environment: environmentParam, name: z.string().min(1).max(50) },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, name }) => {
+        const catalog = catalogOf(await platform.tenant('GET', project, '/bpm/connectors', { environment }));
+        const connector = catalog.find(candidate => candidate.name === name);
+        if (!connector)
+            throw new PlatformApiError(`connector_get: '${name}' diye bağlayıcı yok. Mevcutlar: ${catalog.map(candidate => String(candidate.name)).join(', ')}.`, 404);
+        return connector;
+    }));
+    server.registerTool('connector_credential_list', {
+        title: 'Kimlik kasasını listele',
+        description: "Kasa kayıtlarını listeler (GET bpm/connector-credentials): ad, bağlayıcı, tür, taban/belirteç URL'si, istemci kimliği, kapsamlar, secretFields (yalnız saklı sırların ADLARI) ve anahtar sürümü. Platform sırrı hiç döndürmez; gateway sır ya da belirteç adlı alanları ayrıca *** ile maskeler (BPM-017). Yetki process.manage.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/connector-credentials', { environment })));
+    server.registerTool('connector_credential_create', {
+        title: 'Kasaya kimlik yaz',
+        description: "Bağlayıcı kimliği oluşturur (POST bpm/connector-credentials). Sırlar (clientSecret, password, apiKey, refreshToken, accessToken) proje veri anahtarıyla şifrelenir; yanıtta ve gateway günlüğünde görünmez (BPM-017). Türler: basic · api-key (apiKeyHeader) · bearer · oauth2-client (tokenUrl, clientId, clientSecret, scopes) · oauth2-auth-code (refreshToken elle) · webhook (URL apiKey'de; teams-webhook, slack). Yazdıktan sonra connector_credential_update { operation: 'test' }.",
+        inputSchema: { project: projectParam, environment: environmentParam, ...credentialFields },
+        annotations: writes
+    }, handle(config, async ({ project, environment, ...credential }) => {
+        assertProcessNotProduction('connector_credential_create', environment, config);
+        return platform.tenant('POST', project, '/bpm/connector-credentials', { environment, body: credential });
+    }));
+    server.registerTool('connector_credential_update', {
+        title: 'Kasa kimliğini güncelle / test et / döndür',
+        description: "operation save (varsayılan; PUT bpm/connector-credentials/{id}, tam gövde — bütün sır alanları boşsa saklı sırlar korunur; TEK bir sır alanı bile gönderilirse saklı sırların tamamı gönderilenle değişir, o türün bütün sırlarını birlikte verin: oauth2-client clientSecret · oauth2-auth-code clientSecret + refreshToken · basic password · api-key/webhook apiKey · bearer accessToken) · test (POST …/{id}/test-connection; bağlayıcının bağlantı denemesi, hata 502 ConnectorFailed) · rotate (POST …/rotate; bütün sırları en yeni proje anahtar sürümüyle yeniden şifreler, id almaz, değişen sayısını döner; şifreleme anahtarı yapılandırılmamışsa kasa boş olsa bile ProtectionKeyUnavailable hatası döner — 0 başarı değildir).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional().describe('save ve test için zorunlu'),
+            operation: z.enum(['save', 'test', 'rotate']).optional(),
+            ...z.object(credentialFields).partial().shape
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, operation, ...credential }) => {
+        assertProcessNotProduction('connector_credential_update', environment, config);
+        const resolvedOperation = operation ?? 'save';
+        if (resolvedOperation === 'rotate')
+            return platform.tenant('POST', project, '/bpm/connector-credentials/rotate', { environment });
+        if (!id)
+            throw new PlatformApiError(`connector_credential_update: operation '${resolvedOperation}' id ister (istek gönderilmedi).`, 400);
+        if (resolvedOperation === 'test')
+            return platform.tenant('POST', project, `/bpm/connector-credentials/${id}/test-connection`, { environment });
+        if (!credential.name || !credential.connectorName || !credential.kind)
+            throw new PlatformApiError("connector_credential_update: save tam gövde ister — name, connectorName, kind (connector_credential_list çıktısından) (istek gönderilmedi).", 400);
+        return platform.tenant('PUT', project, `/bpm/connector-credentials/${id}`, { environment, body: credential });
+    }));
+    server.registerTool('connector_credential_delete', {
+        title: 'Kasa kimliğini sil',
+        description: 'Kimliği siler (DELETE bpm/connector-credentials/{id}). Bir süreç düğümü kullanıyorsa 422 ReferencedByProcess, bir olay ya da e-posta kaynağı kullanıyorsa 400 RowHasExistingRelation döner; önce başvuruları değiştirin.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('connector_credential_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/connector-credentials/${id}`, { environment });
+    }));
+    server.registerTool('process_event_source_list', {
+        title: 'Olay kaynaklarını listele',
+        description: 'Olay kaynaklarını listeler (GET bpm/event-sources): ad, tür, adres, mesaj adı, korelasyon anahtarı ifadesi, tampon süresi, etkinlik ve son olay zamanı.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/event-sources', { environment })));
+    server.registerTool('process_event_source_create', {
+        title: 'Olay kaynağı yaz',
+        description: "Dış olayı BPM mesajına çeviren kaynak oluşturur (POST bpm/event-sources) ya da id verilirse tam gövdeyle günceller (PUT …/{id}). Olay girişi process_trigger { kind: 'event-source', name, eventId, payload }: payload korelasyon anahtarı Jint ifadesiyle (ör. 'payload.siparisNo') mesaja dönüşür, aynı eventId ikinci kez işlenmez. kind http taşımadan bağımsızdır; kafka/service-bus tüketicisi henüz yok (NuGet), rabbitmq dinleyicisi borç.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional().describe('verilirse güncelleme'),
+            name: z.string().min(1).max(100),
+            kind: z.enum(eventSourceKinds),
+            address: z.string().max(500).optional().describe('konu/kuyruk adresi'),
+            credentialRef: z.string().max(100).optional().describe('kasadaki kaydın adı (connector_credential_list); olmayan ad 404'),
+            messageName: z.string().min(1).max(100),
+            correlationKey: z.string().max(500).optional().describe("Jint ifadesi, ör. 'payload.siparisNo'"),
+            bufferSeconds: z.number().int().min(0).max(86400).optional(),
+            isActive: z.boolean().optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, ...source }) => {
+        assertProcessNotProduction('process_event_source_create', environment, config);
+        return id
+            ? platform.tenant('PUT', project, `/bpm/event-sources/${id}`, { environment, body: source })
+            : platform.tenant('POST', project, '/bpm/event-sources', { environment, body: source });
+    }));
+    server.registerTool('process_event_source_delete', {
+        title: 'Olay kaynağını sil',
+        description: 'Olay kaynağını siler (DELETE bpm/event-sources/{id}); o ada gelen olaylar 404 alır.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('process_event_source_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/event-sources/${id}`, { environment });
+    }));
+    server.registerTool('process_mail_source_list', {
+        title: 'E-posta kaynaklarını listele',
+        description: 'E-posta kaynaklarını listeler (GET bpm/mail-sources): tür (imap | graph), sunucu, posta kutusu, klasör, kurallar, son UID ve son yoklama zamanı.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/mail-sources', { environment })));
+    server.registerTool('process_mail_source_create', {
+        title: 'E-posta kaynağı yaz',
+        description: "Gelen e-postayı kurallarla BPM mesajına çeviren kaynak oluşturur (POST bpm/mail-sources) ya da id verilirse günceller (PUT …/{id}). Kural { subjectPattern, fromPattern (regex), messageName, correlationKey (Jint; mail.subject, mail.from, match.groups) }; ekler files'a yazılır, aynı Message-ID ikinci kez işlenmez. credentialRef kasadaki bir kaydın adıdır (connector_credential_list): kayıtta kimliğe çözülür, olmayan ad 404 (connector-credential: <ad>) döner; kasa kaydının adı sonradan değişirse kaynak yeni adı gösterir. imap kimliği 'imap' bağlayıcısının kasa kaydıdır (basic), graph kimliği 'microsoft-graph' (oauth2-client). Zamanlanmış yoklama yok: process_trigger { kind: 'mail-source', sourceId }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional().describe('verilirse güncelleme'),
+            name: z.string().min(1).max(100),
+            kind: z.enum(mailSourceKinds),
+            host: z.string().max(200).optional(),
+            port: z.number().int().min(1).max(65535).optional(),
+            useSsl: z.boolean().optional(),
+            mailbox: z.string().max(200).optional(),
+            folder: z.string().max(200).optional(),
+            credentialRef: z.string().min(1).max(100).describe('kasadaki kaydın adı (connector_credential_list); olmayan ad 404'),
+            rules: z.array(z.object({
+                subjectPattern: z.string().max(500).optional(),
+                fromPattern: z.string().max(500).optional(),
+                messageName: z.string().min(1).max(100),
+                correlationKey: z.string().max(500).optional()
+            })).min(1).max(50),
+            isActive: z.boolean().optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, ...source }) => {
+        assertProcessNotProduction('process_mail_source_create', environment, config);
+        return id
+            ? platform.tenant('PUT', project, `/bpm/mail-sources/${id}`, { environment, body: source })
+            : platform.tenant('POST', project, '/bpm/mail-sources', { environment, body: source });
+    }));
+    server.registerTool('process_mail_source_delete', {
+        title: 'E-posta kaynağını sil',
+        description: 'E-posta kaynağını siler (DELETE bpm/mail-sources/{id}).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('process_mail_source_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/mail-sources/${id}`, { environment });
+    }));
+}

package/dist/tools/datasources.js

@@ -75,7 +75,7 @@ export function registerDatasourceTools(server, platform) {
         inputSchema: { project: projectParam, environment: environmentParam, ...connectionInput },
         annotations: writes
     }, handle(config, async ({ project, environment, ...body }) => {
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'create' }));
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'create' }), false);
         return attachFindings(await platform.tenant('POST', project, '/datasources', { environment, body }), findings);
     }));
     server.registerTool('datasource_update', {
@@ -84,7 +84,7 @@ export function registerDatasourceTools(server, platform) {
         inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...connectionInput },
         annotations: updates
     }, handle(config, async ({ project, environment, id, ...body }) => {
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'update' }));
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'datasource', body, { operation: 'update' }), false);
         return attachFindings(await platform.tenant('PUT', project, `/datasources/${id}`, { environment, body }), findings);
     }));
     server.registerTool('datasource_delete', {
@@ -118,7 +118,7 @@ export function registerDatasourceTools(server, platform) {
     }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/datasources/resources', { environment })));
     server.registerTool('datasource_configuration_options', {
         title: 'Yapılandırma seçenekleri',
-        description: "Datasource'un alan tipi kataloğunu döner: commonType başına dbType listesi, varsayılan tip, tipin kabul ettiği seçenek anahtarları (length/precision/collation/...) ve dönüştürülebilir tipler; ayrıca ilişki kuralları (onUpdate/onDelete) ve identity generation tipleri. VARSAYILAN YANIT ÖZETTİR (~5 KB): collation DEĞER listesi (816 kayıt, tam yanıtın %79'u) dışarıdadır — tipin collation kabul edip etmediği zaten options'ta yazar. Collation değerleri gerçekten gerekiyorsa includeCollations: true ile tam yanıtı isteyin (~45 KB).",
+        description: "Datasource'un alan tipi kataloğunu döner: commonType başına dbType listesi, varsayılan tip, tipin kabul ettiği seçenek anahtarları (length/precision/collation/...) ve dönüştürülebilir tipler; ayrıca ilişki kuralları (onUpdate/onDelete) ve identity generation tipleri. İlişki alanına yazarken kuralı SAYI olarak verin (`None` 0 · `Cascade` 1 · `SetNull` 2 · `SetDefault` 3 — `Rule` sırası): her backend sürümünde çalışır. Katalog adı listeler; `onDelete` adı (`Cascade`) 2026-09-27'den sonraki backend'de de kabul edilir, `onUpdate` adı hâlâ reddedilir (500). VARSAYILAN YANIT ÖZETTİR (~5 KB): collation DEĞER listesi (816 kayıt, tam yanıtın %79'u) dışarıdadır — tipin collation kabul edip etmediği zaten options'ta yazar. Collation değerleri gerçekten gerekiyorsa includeCollations: true ile tam yanıtı isteyin (~45 KB).",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,

package/dist/tools/decisions.js

@@ -0,0 +1,206 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive, microOps } from './common.js';
+import { applyPolicyMode, attachFindings, PolicyBlockError } from '../knowledge/policy.js';
+import { assertInline, writeLocalFile } from './bpmGovernance.js';
+import { assertProcessNotProduction, dataOf } from './bpm.js';
+import { unmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.js';
+import { resolvePatchOperations } from '../knowledge/outlines.js';
+import { decisionFindings } from '../knowledge/decision.js';
+import { withNormalization } from '../knowledge/normalize.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { readFile } from 'node:fs/promises';
+import fastJsonPatch from 'fast-json-patch';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+const maxInlineXmlBytes = 256_000;
+const maxDmnBytes = 5_000_000;
+const decisionParam = z.record(z.unknown())
+    .describe("Karar modeli: { slug, name, kind: table | literal, hitPolicy: unique | any | first | priority | collect | rule-order | output-order, aggregation?, inputs[{ id, label, expression, typeRef, allowedValues }], outputs[{ id, name, typeRef, allowedValues, defaultOutputEntry }], rules[{ id, description, inputEntries[], outputEntries[] }], requires[], inputData[], literalExpression?, typeRef? }. Hücreler FEEL; '-' joker. Ayrıntı platform_guide('decision').");
+const policyOverrideParam = z.boolean().optional()
+    .describe("true: politika block bulgularını warn'a indirir (bilinçli istisna; yanıtta işaretlenir)");
+const patchOperationsParam = z.array(z.record(z.unknown())).min(1)
+    .describe("RFC 6902 JSON Patch işlemleri, yollar karar modeline göre. Kural ve sütun hedeflerken İNDEKS YERİNE SEÇİCİ: { op: 'replace', path: '/rules[id=buyuk]/outputEntries/0', value: '3' }; yeni kural '/rules/-'.");
+function lintDecision(config, decision, policyOverride) {
+    if (config.policyMode === 'off')
+        return [];
+    const findings = applyPolicyMode(config, decisionFindings(decision), policyOverride === true);
+    const blocking = findings.filter(finding => finding.severity === 'block');
+    if (blocking.length > 0)
+        throw new PolicyBlockError(blocking);
+    return findings;
+}
+export function registerDecisionTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('decision_list', {
+        title: 'Kararları listele',
+        description: "DMN karar tablolarını ve literal kararları listeler (GET bpm/decisions): slug, ad, kind, hitPolicy, aktif ve taslak sürüm numarası. Süreçte 'decision' düğümü decisionSlug ile başvurur.",
+        inputSchema: { project: projectParam, environment: environmentParam, searchTerm: z.string().max(200).optional(), applicationId: guid.optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, ...query }) => platform.tenant('GET', project, '/bpm/decisions', { environment, query })));
+    server.registerTool('decision_get', {
+        title: 'Kararı getir',
+        description: "Kararı getirir (GET bpm/decisions/{id}): decision güncel model (taslak varsa taslak), activeDecision yayındaki model, versions[] (draft → active → retiring → retired). Değerlendirme için decision_preview.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/bpm/decisions/${id}`, { environment })));
+    server.registerTool('decision_create', {
+        title: 'Karar oluştur',
+        description: "Yeni karar yazar (POST bpm/decisions; taslak sürüm). İlk kullanımdan önce platform_guide('decision') okuyun. Gateway yazmadan önce denetler: DMN-001 (unique tabloda aynı girdiyi eşleyen iki kural, block) ve DMN-002 (FEEL alt kümesinde olmayan işlev, warn — backend yine de yazımı 422 ile reddeder). Yayın decision_publish; süreçte kullanım 'decision' düğümü { decisionSlug, input, output }.",
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid.optional(), decision: decisionParam, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, decision, policyOverride }) => {
+        assertProcessNotProduction('decision_create', environment, config);
+        const findings = lintDecision(config, decision, policyOverride);
+        const saved = await platform.tenant('POST', project, '/bpm/decisions', { environment, body: { applicationId, decision } });
+        return withUnmappedMembers(attachFindings(dataOf(saved), findings), unmappedMembers('CreateDecisionCommand', { applicationId, decision }));
+    }));
+    server.registerTool('decision_update', {
+        title: 'Kararı güncelle',
+        description: "Kararın taslağını tam modelle yazar (PUT bpm/decisions/{id}; taslak yoksa açılır) ya da retireVersion ile aktif/emekliye ayrılan sürümü emekliye ayırır (POST …/versions/{n}/retire). İkisinden biri. Backend sürüm denetimi yapmaz: aynı kararı iki ajan yazıyorsa son yazan kazanır; hedefli değişiklik için decision_patch. Yayından sonra slug değişmez. DMN-001/002 denetimi decision_create ile aynı.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            decision: decisionParam.optional(),
+            retireVersion: z.number().int().min(1).optional().describe('emekliye ayrılacak sürüm numarası (decision yerine)'),
+            policyOverride: policyOverrideParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, decision, retireVersion, policyOverride }) => {
+        assertProcessNotProduction('decision_update', environment, config);
+        if (Boolean(decision) === (retireVersion !== undefined))
+            throw new PlatformApiError("decision_update: 'decision' ya da 'retireVersion' — yalnız biri (istek gönderilmedi).", 400);
+        if (retireVersion !== undefined)
+            return dataOf(await platform.tenant('POST', project, `/bpm/decisions/${id}/versions/${retireVersion}/retire`, { environment }));
+        const findings = lintDecision(config, decision, policyOverride);
+        return withUnmappedMembers(attachFindings(dataOf(await platform.tenant('PUT', project, `/bpm/decisions/${id}`, { environment, body: { decision } })), findings), unmappedMembers('UpdateDecisionCommand', { decision }));
+    }));
+    server.registerTool('decision_patch', {
+        title: 'Karara patch uygula',
+        description: "Tam modeli bağlama almadan hedefli değişiklik: gateway güncel modeli okur (GET), seçicileri (/rules[id=x], /inputs[id=x]) çözer, yamayı yerelde uygular, DMN-001/002 denetiminden geçirir ve tam modeli taslağa yazar (PUT). Backend sürüm denetimi yok: okuma ile yazma arasında başka yazan olursa değişikliği ezilir. Yanıt { patchTargets, decision }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            operations: patchOperationsParam.optional(),
+            ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı)"),
+            policyOverride: policyOverrideParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, operations: givenOperations, ops, policyOverride }) => {
+        assertProcessNotProduction('decision_patch', environment, config);
+        const operations = microOps('decision_patch', ops, givenOperations);
+        const current = dataOf(await platform.tenant('GET', project, `/bpm/decisions/${id}`, { environment }));
+        const model = structuredClone((current.decision ?? {}));
+        const resolved = resolvePatchOperations(model, operations, 'decision_get');
+        let patched;
+        try {
+            patched = fastJsonPatch.applyPatch(model, resolved.operations, true, false).newDocument;
+        }
+        catch (error) {
+            throw new PlatformApiError(`decision_patch: yama uygulanamadı — ${error instanceof Error ? error.message : String(error)} (istek gönderilmedi). Yolları decision_get çıktısına göre kurun.`, 400);
+        }
+        const findings = lintDecision(config, patched, policyOverride);
+        const saved = dataOf(await platform.tenant('PUT', project, `/bpm/decisions/${id}`, { environment, body: { decision: patched } }));
+        return withNormalization(attachFindings({ patchTargets: resolved.targets, decision: saved.decision ?? patched }, findings), resolved.notes);
+    }));
+    server.registerTool('decision_delete', {
+        title: 'Kararı sil',
+        description: "Kararı ve bütün sürümlerini siler (DELETE bpm/decisions/{id}). Bir süreç tanımı decisionSlug ile başvuruyorsa 422 ReferencedByProcess, başka karar requires ile başvuruyorsa 422 DecisionInvalid.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('decision_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/decisions/${id}`, { environment });
+    }));
+    server.registerTool('decision_clone', {
+        title: 'Kararı klonla',
+        description: 'Kararın güncel modelinden yeni slug ile taslak kopya oluşturur (GET + POST bpm/decisions). variable verilmemişse slug\'dan türetildiği için üst kararlar yeni adı görür; requires başvuruları kopyalanır.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, slug: z.string().min(1).max(100) },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, slug }) => {
+        assertProcessNotProduction('decision_clone', environment, config);
+        const current = dataOf(await platform.tenant('GET', project, `/bpm/decisions/${id}`, { environment }));
+        const decision = { ...structuredClone((current.decision ?? {})), slug };
+        return dataOf(await platform.tenant('POST', project, '/bpm/decisions', { environment, body: { applicationId: current.applicationId ?? undefined, decision } }));
+    }));
+    server.registerTool('decision_preview', {
+        title: 'Kararı değerlendir (kuru)',
+        description: "Kararı verilen girdilerle YAN ETKİSİZ değerlendirir (POST bpm/decisions/{id}/evaluate; transaction açmaz, defter yazmaz — tablo tasarımını denemenin yolu, platform_guide('decision') §Deneme): version verilmezse taslak (yoksa aktif). DRD'deki alt kararlar (requires) önce değerlendirilir. Yanıt { value, outputs, matchedRules, decisions[] (her karar için inputs, value, matchedRules) }. unique'te birden çok kural eşleşirse 422 DecisionHitPolicyViolated (eşleşen kural kimlikleriyle); hiçbiri eşleşmezse defaultOutputEntry ya da null.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            inputs: z.record(z.unknown()).describe("girdi adları → değerler, ör. { tutar: 180000, kategori: 'makine' }; tarih '2026-09-17', süre 'P3D'"),
+            version: z.number().int().min(1).optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, inputs, version }) => platform.tenant('POST', project, `/bpm/decisions/${id}/evaluate`, { environment, query: { version }, body: { inputs } })));
+    server.registerTool('decision_publish', {
+        title: 'Kararı yayınla',
+        description: "Taslağı aktif sürüm yapar (POST bpm/decisions/{id}/publish); önceki aktif sürüm retiring olur. requires içindeki her kararın aktif sürümü olmalı (422 DecisionUnknown) ve döngü olmamalı (422 DecisionInvalid). Gateway yayından önce taslağı DMN-001/002 ile denetler. production hedefi durur (BPM-001).",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, policyOverride }) => {
+        assertProcessNotProduction('decision_publish', environment, config);
+        const current = dataOf(await platform.tenant('GET', project, `/bpm/decisions/${id}`, { environment }));
+        const findings = lintDecision(config, (current.decision ?? {}), policyOverride);
+        return attachFindings(dataOf(await platform.tenant('POST', project, `/bpm/decisions/${id}/publish`, { environment })), findings);
+    }));
+    server.registerTool('decision_dmn_get', {
+        title: 'Kararı DMN 1.3 XML olarak dışa aktar',
+        description: "Kararı ve requires ile bağlı alt kararlarını DMN 1.3 XML'e çevirir (GET bpm/decisions/{id}/dmn; zeyrek: uzantısı kaynak ve kategori bilgisini taşır). version verilmezse taslak (yoksa aktif). Yanıt { decisionId, versionNumber, state, sizeBytes, xml }; 256 KB üstü için outPath verin.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            version: z.number().int().min(1).optional(),
+            outPath: z.string().min(1).optional().describe('verilirse XML bu yerel yola yazılır ve yanıt yalnız özet döner')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, version, outPath }) => {
+        const response = await platform.tenantWithHeaders('GET', project, `/bpm/decisions/${id}/dmn`, { environment, query: { version }, expectBinary: true });
+        const payload = response.body;
+        const xml = payload.bytes.toString('utf8').replace(/^\uFEFF/, '');
+        const summary = {
+            decisionId: id,
+            versionNumber: Number(response.headers['x-decision-version']) || null,
+            state: response.headers['x-decision-version-state'] ?? null,
+            sizeBytes: payload.bytes.byteLength
+        };
+        if (outPath)
+            return { ...summary, path: await writeLocalFile('decision_dmn_get', outPath, xml) };
+        const inline = { ...summary, xml };
+        assertInline('decision_dmn_get', config, inline);
+        return inline;
+    }));
+    server.registerTool('decision_dmn_update', {
+        title: 'DMN 1.3 XML içe aktar',
+        description: "DMN 1.3 XML'deki kararları içe aktarır (POST bpm/decisions/import-dmn): slug'ı (decision id) mevcut karar taslağına yazılır, yoksa yeni karar oluşur; DRD bilgi gereksinimleri requires olur. xml (≤ 256 KB) ya da filePath (≤ 5 MB) — biri. Camunda/Trisotech tablolarında desteklenmeyen FEEL işlevi değerlendirmede 422 ExpressionInvalid döner; içe aktardıktan sonra decision_preview ile deneyin. DTD/dış varlık içeren XML 400.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid.optional(),
+            xml: z.string().min(1).max(maxInlineXmlBytes).optional(),
+            filePath: z.string().min(1).optional().describe('yerel .dmn dosyası')
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, xml, filePath }) => {
+        assertProcessNotProduction('decision_dmn_update', environment, config);
+        if (Boolean(xml) === Boolean(filePath))
+            throw new PlatformApiError("decision_dmn_update: 'xml' ya da 'filePath' — yalnız biri (istek gönderilmedi).", 400);
+        let content = xml ?? '';
+        if (filePath) {
+            try {
+                content = await readFile(resolve(filePath), 'utf8');
+            }
+            catch (error) {
+                throw new PlatformApiError(`decision_dmn_update: dosya okunamadı — ${resolve(filePath)} (${error instanceof Error ? error.message : String(error)}). Yol gateway sürecinin çalıştığı makineye göre çözülür (istek gönderilmedi).`, 400);
+            }
+        }
+        content = content.replace(/^/, '');
+        if (Buffer.byteLength(content, 'utf8') > maxDmnBytes)
+            throw new PlatformApiError(`decision_dmn_update: XML en çok ${maxDmnBytes} B (istek gönderilmedi).`, 413);
+        return platform.tenant('POST', project, '/bpm/decisions/import-dmn', { environment, body: { applicationId, xml: content } });
+    }));
+}

package/dist/tools/dependencies.js

@@ -9,7 +9,7 @@ export function registerDependencyTools(server, platform) {
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            module: z.string().describe('Modül adı: entity | field | microservice | workflow | query | view | dataTransferObject | global-function (fonksiyon, iki kaynak: onu çağıran flow/workflow listesi; flow düğümü sahibini hostModule/hostId/hostName, bağlandığı komponenti ve olayı componentName/eventName/eventTitle ile taşır) vb. (platform Module enum değeri)'),
+            module: z.string().describe('Modül adı: entity | field | microservice | workflow | query | view | dataTransferObject | process-definition (depends: tanımın başvurduğu entity/workflow/sayfa/DTO/rol/pozisyon/birim/takvim/karar/alt süreç; depended: onu alt süreç olarak çağıran tanımlar — entity ve workflow grafiği de kullanan tanımları gösterir, silmeleri 422 ReferencedByProcess) | global-function (fonksiyon, iki kaynak: onu çağıran flow/workflow listesi; flow düğümü sahibini hostModule/hostId/hostName, bağlandığı komponenti ve olayı componentName/eventName/eventTitle ile taşır) vb. (platform Module enum değeri)'),
             id: guid
         },
         annotations: readOnly

package/dist/tools/deployments.js

@@ -4,13 +4,13 @@ export function registerDeploymentTools(server, platform) {
     const config = platform.config;
     server.registerTool('deployment_start', {
         title: 'Deployment başlat',
-        description: 'Projeyi kaynak environment\'tan hedef environment\'a deploy eder. Asenkron bir saga\'dır: sonuç bu yanıtta bitmez, deployment_status ile izleyin. Environment id\'lerini project_get çıktısından alın.',
+        description: 'Projeyi kaynak environment\'tan hedef environment\'a deploy eder. Asenkron bir saga\'dır: sonuç bu yanıtta bitmez, deployment_status ile izleyin. Environment id\'lerini project_get çıktısından alın. BPM: süreç tanımları ve iş takvimleri taşınır — hedefte farklı aktif model yeni sürüm olarak yayınlanır (production\'da gelişte aktif), hedefin uyarlaması korunur; uyarlama, örnek, görev ve defter taşınmaz; kaynakta olmayan tanım silinir, açık örneği varsa emekliye ayrılır.',
         inputSchema: { projectId: guid, sourceEnvironmentId: guid, targetEnvironmentId: guid },
         annotations: writes
     }, handle(config, ({ projectId, ...body }) => platform.org('POST', `/deployments/${projectId}/deploy`, { body })));
     server.registerTool('deployment_status', {
         title: 'Deployment durumu',
-        description: "Projenin son deployment durumunu döner. 'projectId' ZORUNLUDUR (project_list/project_get'ten alın) — verilmezse çağrı MCP şema katmanında reddedilir, platforma hiç gitmez. Hiç deployment yapılmamış projede yanıt BOŞ gelir; o durumda tool 'hiç deployment kaydı yok' bilgisini açıkça döner, yani boş yanıtı 'tool çalışmadı' diye okumayın.",
+        description: "Projenin son deployment durumunu döner. 'projectId' ZORUNLUDUR (project_list/project_get'ten alın) — verilmezse çağrı MCP şema katmanında reddedilir, platforma hiç gitmez. Hiç deployment yapılmamış projede yanıt BOŞ gelir; o durumda tool 'hiç deployment kaydı yok' bilgisini açıkça döner, yani boş yanıtı 'tool çalışmadı' diye okumayın. Durum satırı modül başına ayrılmaz: süreç tanımları ve iş takvimleri sayfa ve workflow'lardan sonra aynı saga adımında aktarılır; hedefte çalışamayan (eksik workflow/entity/rol) tanım aktarımı DefinitionInvalid ile düşürür.",
         inputSchema: { projectId: guid },
         annotations: readOnly
     }, handle(config, async ({ projectId }) => {

package/dist/tools/designSchemaPatch.js

@@ -1,13 +1,16 @@
 import { orphanedFlowWarnings, orphanedFlowPlan, orphanedFlowMessage, boundEventOps, stripGatewayEventFields, staleSetterWarnings, normalizeSchemaOps, validationNote, componentDefaultsNote, replacePropNote, flexSizeWarnings, nestedRepeaterNodes, nestedRepeaterMessage, stringStyleNodes, stringStyleWarning, inertFlexPropNodes, inertFlexPropWarning, verticalGapWarnings, withNormalization, FLEX_LAYOUT_PROP_NAMES } from '../knowledge/normalize.js';
-import { opsParam, writeViewParam, outlineWriteResponse, unknownEventOps, collectTypes, simulateLayoutOps, removeNodeFromTree, planEventRemovals, planResizes, planPropTypes, assertOpBodies } from './schemaOps.js';
+import { opsParam, writeViewParam, outlineWriteResponse, unknownEventOps, collectTypes, styleTargetTypesFrom, simulateLayoutOps, removeNodeFromTree, planEventRemovals, planResizes, planPropTypes, assertOpBodies, applySkeletonOps, reshapesSkeleton } from './schemaOps.js';
 import { guid, projectParam, environmentParam, updates, microOps } from './common.js';
 import { fetchHost, hostPath } from './screens.js';
 import { assertScreenWriteGuards, screenCatalogNotes } from './screenWrite.js';
 import { emptyWriteDiff, schemaOpDrops, withWriteDiff } from '../platform/writeDiff.js';
 import { fetchComponentEventNames } from './components.js';
 import { PlatformApiError } from '../platform/errors.js';
+import { connectDataOpIssues, connectedPropKeys } from '../knowledge/connectDataDefinition.js';
 import { handle } from '../platform/responses.js';
 import { slotWarning } from './layouts.js';
+import { applicationTypeField, resolveProfile } from '../knowledge/platform/resolve.js';
+import { boundFlowSteps, layoutPatchWarnings, screenProfileWarnings } from './profileWrite.js';
 import { z } from 'zod';
 const HOSTS = {
     layout: {
@@ -58,8 +61,6 @@ export function registerDesignSchemaPatchTool(server, platform, host) {
         const resizeOps = allOps.filter(entry => entry.op === 'resize_component');
         const propTypeOps = allOps.filter(entry => entry.op === 'set_prop_type');
         const opRecords = allOps.filter(entry => !['remove_event', 'resize_component', 'set_prop_type'].includes(String(entry.op)));
-        const normalized = normalizeSchemaOps(opRecords);
-        assertOpBodies(opRecords, propTypeOps);
         const record = await fetchHost(platform, host, project, environment, applicationId, id);
         // Platform ucu kaydın türüne bakmaz: sıradan bir komponentin id'si verilirse kataloğundaki
         // tanımın yanına bir şema yazılırdı.
@@ -68,6 +69,17 @@ export function registerDesignSchemaPatchTool(server, platform, host) {
         }
         const nodes = (record[spec.tree] ?? []);
         const events = host === 'layout' ? record.events : undefined;
+        // Normalizasyon kayıttan SONRA koşar: stil anahtarı çevirisi hedefin komponent TİPİNE bakar
+        // (TB-129, table.style.th/td kebab-case kalır) ve tip yalnız okunan ağaçta var. Gövde hataları
+        // bu yüzden bir okuma sonrasında rapor edilir; karar hiç değişmez, yalnız sıra değişti.
+        const normalized = normalizeSchemaOps(opRecords, styleTargetTypesFrom(opRecords, nodes));
+        assertOpBodies(opRecords, propTypeOps);
+        // CD-005 layout ve widget host'unda da: bağlı prop'u (iç içe yol dahil) ezen yazma ve bağlı olmayan prop'ta
+        // remove_connect_data okunan ağaca bakarak reddedilir (gövde denetimi assertOpBodies'te koştu).
+        const connectedProps = connectedPropKeys(nodes);
+        const connectionIssues = opRecords.flatMap(entry => connectDataOpIssues(entry, connectedProps).map(issue => `${issue.code} — ${issue.message}`));
+        if (connectionIssues.length > 0)
+            throw new PlatformApiError(`Connect Data op gövdesi geçersiz (istek gönderilmedi): ${connectionIssues.join(' · ')}`, 400);
         if (opRecords.some(entry => entry.op === 'set_event' || entry.op === 'add_event')) {
             const bound = boundEventOps(nodes, opRecords);
             if (bound.length > 0)
@@ -85,7 +97,8 @@ export function registerDesignSchemaPatchTool(server, platform, host) {
         if (deletedFlows.length > 0 && allowFlowDeletion !== true)
             throw new PlatformApiError(orphanedFlowMessage(deletedFlows), 400);
         const added = opRecords.filter(entry => entry.op === 'add_component').map(entry => entry.component);
-        assertScreenWriteGuards(spec.kind, { schema: added });
+        const resolved = await resolveProfile(platform, applicationId);
+        assertScreenWriteGuards(spec.kind, { schema: added }, resolved.profile.platform);
         const catalogNotes = await screenCatalogNotes(platform, project, environment, applicationId, added);
         const flowWarnings = opRecords.some(entry => entry.op === 'remove_component')
             ? [...orphanedFlowWarnings(nodes, events, opRecords), ...staleSetterWarnings(Array.isArray(record.flows) ? record.flows : [], opRecords, nodes)]
@@ -100,17 +113,28 @@ export function registerDesignSchemaPatchTool(server, platform, host) {
             || (entry.op === 'replace_prop' && FLEX_LAYOUT_PROP_NAMES.has(String(entry.prop ?? ''))));
         const nested = simulatable ? nestedRepeaterNodes(simulated) : [];
         if (nested.length > 0)
-            throw new PlatformApiError(nestedRepeaterMessage(nested), 400);
+            throw new PlatformApiError(nestedRepeaterMessage(nested, resolved.profile.platform), 400);
         const reshaped = simulatable || opRecords.some(entry => entry.op === 'remove_component');
+        const profileWarnings = await screenProfileWarnings(platform, resolved, project, environment, applicationId, {
+            kind: spec.kind,
+            ops: [...opRecords, ...propTypeOps],
+            savedNodes: nodes,
+            steps: await boundFlowSteps(platform, resolved, project, environment, host, applicationId, id, opRecords)
+        });
         const layoutWarnings = reshaped
             ? [
-                ...verticalGapWarnings(simulated, spec.codes.gap, touched),
+                ...(resolved.profile.layout.blocksMeaningful ? verticalGapWarnings(simulated, spec.codes.gap, touched) : []),
                 ...stringStyleWarning(stringStyleNodes(simulated)),
-                ...inertFlexPropWarning(inertFlexPropNodes(simulated)),
+                ...(resolved.profile.layout.modes.has('grid') ? inertFlexPropWarning(inertFlexPropNodes(simulated)) : []),
                 ...flexSizeWarnings(simulated, spec.codes.flexMismatch, spec.codes.flexInvalid),
                 ...(host === 'layout' ? slotWarning(simulated) : [])
             ]
             : [];
+        if (host === 'layout' && reshapesSkeleton(opRecords)) {
+            const skeleton = structuredClone(simulated);
+            applySkeletonOps(skeleton, opRecords);
+            layoutWarnings.push(...layoutPatchWarnings(resolved, nodes, skeleton));
+        }
         const removedEvents = planEventRemovals(removeEventOps);
         const resized = resizeOps.length > 0 ? planResizes(nodes, resizeOps, spec.readTool) : { serverOps: [], applied: [], warnings: [] };
         const propTypes = propTypeOps.length > 0 ? planPropTypes(nodes, propTypeOps, spec.readTool) : { serverOps: [], applied: [] };
@@ -133,8 +157,9 @@ export function registerDesignSchemaPatchTool(server, platform, host) {
             response.deletedFlows = deletedFlows;
         if (flowWarnings.length > 0)
             response.flowWarnings = flowWarnings;
-        if (layoutWarnings.length > 0)
-            response.layoutWarnings = layoutWarnings;
+        if (layoutWarnings.length > 0 || profileWarnings.length > 0)
+            response.layoutWarnings = [...layoutWarnings, ...profileWarnings];
+        Object.assign(response, applicationTypeField(resolved));
         const contentOps = opRecords.filter(entry => entry.op === 'add_component' || entry.op === 'replace_prop');
         let opDrops = emptyWriteDiff();
         if (contentOps.length > 0) {