@appaflytech/zeyrek-ai-mcp 0.0.5 → 0.0.7

package/dist/tools/microfunctions.js

@@ -0,0 +1,155 @@
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+import { unmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.js';
+import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
+import { policyRules } from '../knowledge/rules.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const policyOverrideParam = z.boolean().optional()
+    .describe("true: politika block bulgularını warn'a indirir (bilinçli istisna; yanıtta işaretlenir)");
+const behaviorParam = z.enum(['primitive', 'object', 'array']);
+const statusParam = z.enum(['draft', 'publishing', 'published', 'publish-failed']);
+const environmentVariablesParam = z.record(z.string())
+    .describe("Runtime'a geçen env değişkenleri; anahtar ^[A-Z_][A-Z0-9_]*$ ve toplam ≤ 4 KB (Lambda sınırı). Fonksiyon bunları Node'da process.env, Python'da os.environ üzerinden okur — SIR DEĞER KOYMAYIN: kayıt düz metin tutulur");
+// Create ve Update aynı gövdeyi taşır (Update yalnız id ekler): iki tool'un şeması tek yerde durur,
+// backend komutlarındaki alan çifti ayrışırsa `unmappedMembers` iki tool'da da aynı anda konuşur.
+const definitionInput = {
+    name: z.string().min(1).max(255).describe("Fonksiyon adı; tenant içinde BENZERSİZ. Slug bundan türetilir ve runtime fonksiyon adına girer (zf-{proje}-{ortam}-{slug}). SLUG DA BENZERSİZDİR: 'Sipariş' ile 'Siparis' farklı adlardır ama aynı slug'ı üretir ve ikincisi 409 alır"),
+    description: z.string().optional().describe('Fonksiyonun ne yaptığı; Studio listesinde görünür, çalışma zamanını etkilemez'),
+    language: z.enum(['node', 'python']).describe("Çalışma dili. Inline kaynakta dosya adı sabittir: node → function.js (exports.handler = async (args, context) => …), python → function.py (def handler(args, context))"),
+    provider: z.enum(['built-in', 'aws-lambda']).describe("'built-in' platformun kendi Fission kümesinde koşar ve runtime hesabı İSTEMEZ (runtimeId boş kalır); 'aws-lambda' müşterinin kendi hesabında koşar ve runtimeId ZORUNLUDUR. 'azure-functions' enum'da tanımlı ama v1'de reddedilir (Faz 2)"),
+    runtimeId: guid.optional().describe("AWS Lambda hesabı (microfunction_runtime_list). provider 'built-in' ise VERİLMEZ; 'aws-lambda' ise zorunlu ve hesabın provider'ı fonksiyonunkiyle aynı olmalı"),
+    sourceKind: z.enum(['inline', 'archive']).describe("'inline' ⇒ code zorunlu (≤ 512 KB, standart kütüphane; bağımlılık YOK); 'archive' ⇒ önce kayıt açılır, zip Studio'dan yüklenir (MCP'de zip yükleme yok — Faz 2) ve entrypoint 'modül.fonksiyon' olarak verilir"),
+    code: z.string().optional().describe("Inline kaynak kodu. Sözleşme: tek bir handler dışa aktarılır, args çağrı argümanları, context SALT OKUNUR anlık görüntüdür (input/variables/steps/user/request/language/project/environment). Yazma yalnız dönüş değeriyle olur. Ayrıntı: platform_guide('microfunction')"),
+    entrypoint: z.string().optional().describe("Zip kaynağında 'modül.fonksiyon' (ör. 'handlers/sum.handler'). Inline kaynakta gateway'in de platformun da beklediği sabit 'function.handler'dır — vermeyin"),
+    parameterDtoId: guid.optional().describe("Çağrı argümanlarının sözleşmesi (DataTransferObject). Workflow step'i ifadeyi bu şemaya göre yazar; boşsa args = {} gider"),
+    parameterBehavior: behaviorParam.optional().describe('parameterDtoId verildiyse zorunlu: primitive | object | array'),
+    returnDtoId: guid.optional().describe('Dönüş sözleşmesi; step çıktısının şeması bundan üretilir'),
+    returnBehavior: behaviorParam.optional().describe('returnDtoId verildiyse zorunlu: primitive | object | array'),
+    timeoutSeconds: z.number().int().min(1).max(900).optional().describe("Fonksiyon bütçesi; varsayılan 30. Built-In üst sınırı 300, Lambda 900. Bütçe dolarsa çağrı MicrofunctionInvocationTimeoutException ile step'in fail dalına düşer"),
+    memoryMb: z.number().int().min(128).max(3008).optional().describe("Varsayılan 256. Built-In'de yalnız kaydedilir (küme environment limiti geçerlidir); Lambda'da gerçekten uygulanır"),
+    environmentVariables: environmentVariablesParam.optional(),
+    publish: z.boolean().optional().describe("true: kayıt açıldıktan/güncellendikten sonra aynı çağrıda yayın istenir ('Kaydet ve yayınla'). Yayın ASENKRONDUR — çağrı status: 'publishing' döner; sonucu microfunction_get ile izleyin (published | publish-failed + publishError)")
+};
+const runtimeInput = {
+    name: z.string().min(1).max(255).describe('Hesap adı; benzersiz'),
+    provider: z.literal('aws-lambda').optional().describe("v1'de yalnız 'aws-lambda' kabul edilir; gönderilmezse gateway onu koyar"),
+    region: z.string().min(1).describe("AWS bölge kodu, ör. 'eu-central-1'"),
+    accessKeyId: z.string().min(1).describe('AWS access key id'),
+    secretAccessKey: z.string().min(1).describe("AWS secret access key. Kayıt düz metin tutulur; platform DTO'da maskeler (**** + son 4), gateway bu tool'ların yanıtında değeri tümüyle '***' yapar"),
+    roleArn: z.string().optional().describe("Lambda execution rolü: arn:aws:iam::<12 hane>:role/<ad>. Rolü müşteri oluşturur; fonksiyon bu rolle koşar")
+};
+export function registerMicrofunctionTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('microfunction_list', {
+        title: 'Microfunction listele',
+        description: "Proje kapsamındaki microfunction'ları listeler. Workflow step'i kurmadan ÖNCE bunu status: 'published' ile çağırın: step yalnız yayındaki kaydı koşturur, taslak seçilirse koşum fail dalına düşer (WF-MF-001). Süzgeç ve sayfalama SUNUCUDA uygulanır: searchTerm ad/slug/açıklama içinde arar, sayfa boyu verilmezse gateway 200 gönderir (platform varsayılanı 10'dur).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            status: statusParam.optional().describe("Durum süzgeci; step editörü için 'published'"),
+            searchTerm: z.string().optional().describe('Ad, slug ve açıklamada geçen metin; büyük/küçük harf duyarsız'),
+            ...pagingParams
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, status, searchTerm, pageIndex, pageLength, order, isDescending }) => platform.tenant('GET', project, '/microfunctions', {
+        environment,
+        query: { status, searchTerm, pageIndex: pageIndex ?? 0, pageLength: pageLength ?? 200, order, isDescending }
+    })));
+    server.registerTool('microfunction_get', {
+        title: 'Microfunction getir',
+        description: "Tek bir microfunction'ın tanımını ve yayın durumunu getirir: status, revision/publishedRevision, hasUnpublishedChanges (kayıt yayında ama üstüne yazılmış), publishError, parameterScheme/returnScheme. Yayın asenkron olduğu için 'publishing' durumunda birkaç saniye arayla tekrar çağırın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microfunctions/${id}`, { environment })));
+    server.registerTool('microfunction_create', {
+        title: 'Microfunction tanımla',
+        description: "Yeni microfunction kaydeder. Kayıt DRAFT doğar; yayına almadan hiçbir workflow step'i onu koşturamaz (publish: true ile aynı çağrıda yayın isteyebilirsiniz). Yayın adımı kodu runtime'a kurar ve bir 'probe' çağrısıyla duman testi yapar: sözdizimi/import hatası yayın anında publish-failed olur, koşumda değil. Protokol ve sınırlar: platform_guide('microfunction'). " + constraintSummary('CreateMicrofunctionCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, ...definitionInput, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, policyOverride, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunction', body, { operation: 'create' }, policyOverride));
+        const drift = unmappedMembers('CreateMicrofunctionCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('POST', project, '/microfunctions', { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_update', {
+        title: 'Microfunction güncelle',
+        description: "Microfunction'ın TAMAMINI değiştirir (PUT — değiştirmediğiniz alanları da gönderin; önce microfunction_get). Her güncelleme revision'ı artırır: yayındaki kayıt güncellenirse runtime ESKİ sürümü koşmaya devam eder ve kayıt hasUnpublishedChanges: true olur — yeni kodu canlıya almak için publish: true verin ya da microfunction_publish çağırın. PROVIDER YAYINDAYKEN DEĞİŞMEZ: bir kez yayınlanmış kaydın provider'ını değiştiren PUT 400 döner (MicrofunctionProviderChangeNotAllowedException) — kaydı silip yeniden oluşturun. " + constraintSummary('UpdateMicrofunctionCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...definitionInput, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, policyOverride, ...body }) => {
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunction', body, { operation: 'update' }, policyOverride));
+        const drift = unmappedMembers('UpdateMicrofunctionCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('PUT', project, `/microfunctions/${id}`, { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_publish', {
+        title: 'Microfunction yayınla',
+        description: "Kaydı runtime'a kurar. Çağrı 202 ile hemen döner ve kayıt 'publishing' olur; sonucu microfunction_get ile izleyin — 'published' (publishedReference: Fission fonksiyon adı ya da Lambda ARN) ya da 'publish-failed' (publishError). Zaten yayınlanmakta olan bir kayıt için çağrı 400 döner.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: updates
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microfunctions/${id}/publish`, { environment })));
+    server.registerTool('microfunction_delete', {
+        title: 'Microfunction sil',
+        description: "Microfunction'ı siler ve runtime'daki fonksiyonu kaldırır. Bir workflow step'i kaydı kullanıyorsa 400 ile reddedilir (CantDeleteUsedMicrofunctionException) ve mesaj çağıran akışın adını taşır — önce step'i kaldırın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/microfunctions/${id}`, { environment })));
+    server.registerTool('microfunction_invoke', {
+        title: 'Microfunction çağır',
+        description: "Yayındaki fonksiyonu GERÇEK runtime'da koşturur ve zarfı döner: { ok, output, error, logs, durationMs }. Test çağrısıdır ama rollback YOKTUR — fonksiyon dış dünyaya ne yaptıysa kalır. ok:false ise error.type/message/stack okunur; aynı hata workflow'da step'i fail dalına düşürür. Taslak kayıtta çağrı MicrofunctionNotPublishedException ile döner. Kaydetmeden koşma yolu yoktur: önce microfunction_update + publish.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            args: z.record(z.unknown()).optional().describe("Fonksiyona giden argüman nesnesi (handler'ın ilk parametresi); parameterDtoId varsa o şemaya uymalı"),
+            preview: z.boolean().optional().describe("true: shim logları (console.log/print) zarfın logs alanında döner. false/boş: logs boş gelir — hata ayıklarken açın")
+        },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, args, preview }) => platform.tenant('POST', project, `/microfunctions/${id}/invoke`, { environment, body: { args, preview } })));
+    server.registerTool('microfunction_runtime_list', {
+        title: 'Microfunction runtime hesaplarını listele',
+        description: "Bulut runtime hesaplarını (v1: AWS Lambda) listeler; secretAccessKey maskeli döner. Built-In fonksiyonların runtime kaydı YOKTUR — liste boşsa yalnız provider: 'built-in' fonksiyon tanımlayabilirsiniz.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/microfunction-runtimes', { environment })));
+    server.registerTool('microfunction_runtime_get', {
+        title: 'Microfunction runtime hesabını getir',
+        description: 'Tek bir runtime hesabını getirir (secretAccessKey maskeli).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microfunction-runtimes/${id}`, { environment })));
+    server.registerTool('microfunction_runtime_create', {
+        title: 'Microfunction runtime hesabı tanımla',
+        description: "AWS Lambda hesabı kaydeder: bölge + erişim anahtarları + Lambda execution rolü (roleArn). Kimlik bilgileri düz metin tutulur (Datasource emsali) — dar yetkili bir IAM kullanıcısı verin. Kaydettikten sonra microfunction_runtime_test_connection ile doğrulayın. " + constraintSummary('CreateMicrofunctionRuntimeCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, ...runtimeInput, policyOverride: policyOverrideParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, policyOverride, ...input }) => {
+        const body = { ...input, provider: input.provider ?? 'aws-lambda' };
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunctionRuntime', body, { operation: 'create' }, policyOverride));
+        const drift = unmappedMembers('CreateMicrofunctionRuntimeCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('POST', project, '/microfunction-runtimes', { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_runtime_update', {
+        title: 'Microfunction runtime hesabını güncelle',
+        description: 'Runtime hesabının tamamını değiştirir (PUT). secretAccessKey maskeli okunduğu için güncellemede GERÇEK değeri yeniden gönderin — maskeyi geri yazmayın. ' + constraintSummary('UpdateMicrofunctionRuntimeCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...runtimeInput, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, policyOverride, ...input }) => {
+        const body = { ...input, provider: input.provider ?? 'aws-lambda' };
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microfunctionRuntime', body, { operation: 'update' }, policyOverride));
+        const drift = unmappedMembers('UpdateMicrofunctionRuntimeCommand', body);
+        return attachFindings(withUnmappedMembers(await platform.tenant('PUT', project, `/microfunction-runtimes/${id}`, { environment, body }), drift), findings);
+    }));
+    server.registerTool('microfunction_runtime_delete', {
+        title: 'Microfunction runtime hesabını sil',
+        description: 'Runtime hesabını siler. Bir microfunction hesabı kullanıyorsa 400 ile reddedilir (CantDeleteUsedMicrofunctionRuntimeException).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/microfunction-runtimes/${id}`, { environment })));
+    server.registerTool('microfunction_runtime_test_connection', {
+        title: 'Microfunction runtime bağlantısını test et',
+        description: "Kayıtlı hesabın kimlik bilgilerini gerçek bulut ucunda dener (Lambda: ListFunctions). Hata 400 olarak döner ve mesaj AWS'in kendi cümlesidir — yayın denemeden önce buradan doğrulayın.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: updates
+    }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microfunction-runtimes/${id}/test-connection`, { environment })));
+}

package/dist/tools/microservices.js

@@ -1,15 +1,71 @@
-import { guid, projectParam, environmentParam, definitionParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
+import { guid, appRef, withResolved, projectParam, environmentParam, definitionParam, languageParam, pagingParams, readOnly, writes, updates, destructive, microOps } from './common.js';
+import { languageHeader } from '../knowledge/languageCodes.js';
+import { hydrateMicroserviceRefs } from '../knowledge/hydrate.js';
+import { RefResolver } from '../platform/refs.js';
 import { normalizeMicroserviceDefinition, withNormalization } from '../knowledge/normalize.js';
 import { evaluatePolicy, enforcePolicy, attachFindings } from '../knowledge/policy.js';
-import { microserviceOutline, resolvePart, resolvePatchOperations } from '../knowledge/outlines.js';
+import { microserviceOutline, workflowOutline, resolvePart, resolvePatchOperations } from '../knowledge/outlines.js';
+import { patchResult, baseVersionOf } from '../platform/patch.js';
 import { policyRules } from '../knowledge/rules.js';
+import { writeDiff, withWriteDiff } from '../platform/writeDiff.js';
+import { identityHeaders } from '../platform/tokenVault.js';
+import { PlatformApiError } from '../platform/errors.js';
 import { handle } from '../platform/responses.js';
 import fastJsonPatch from 'fast-json-patch';
 import { z } from 'zod';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+import { unmappedMembers, introducedUnmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.js';
 const policyOverrideParam = z.boolean().optional()
     .describe('true: politika block bulgularını warn\'a indirir (bilinçli istisna; yanıtta işaretlenir)');
+/**
+ * MS-015 — query kaynaklı uçta kimlik kapsaması sunucuda ZORLANAMAZ.
+ *
+ * Query kaynaklı ucun parametreleri yalnız çağrının kendisinden bağlanır (body → query-string →
+ * header, `Query.PrepareQueryParameters` → `FindValue`); ifade değerlendirmesi yoktur, yani
+ * middleware'in kurduğu `user` bu yola hiç girmez. Uca bir middleware bağlıysa ortada bir kimlik
+ * VARDIR ve sorgunun kimlik/tenant adı taşıyan parametresi büyük olasılıkla bir KAPSAMDIR —
+ * gövdeye bırakıldığı sürece sahtelenebilir (2026-09-07'de ölçüldü).
+ *
+ * Kural bu yüzden sorgunun parametre adlarına bakar: bir tur maliyeti vardır ama yalnız
+ * "query kaynaklı + middleware bağlı" uçlarda ödenir, ve cümlesi KOŞULLUDUR — kullanıcının
+ * serbestçe seçebileceği bir filtreyi suçlamaz. Sorgu okunamazsa kural susar: bir yazmayı
+ * kendi teşhis turu yüzünden engellemez.
+ */
+const SCOPE_PARAMETER_PATTERN = /(^|_)(user|owner|tenant|company|firma|sirket|musteri|customer|account|organization|org|member|kullanici)(_?(id|key|slug|code))?$/i;
+async function queryScopeFindings(platform, project, environment, definition) {
+    // POLICY=off lint'i tamamen kapatır; kural kendi teşhis turunu da o modda atmalıdır.
+    if (platform.config.policyMode === 'off')
+        return [];
+    if (String(definition.source ?? '') !== 'query')
+        return [];
+    if (!Array.isArray(definition.middlewareIds) || definition.middlewareIds.length === 0)
+        return [];
+    const queryId = typeof definition.queryId === 'string' ? definition.queryId : null;
+    if (!queryId)
+        return [];
+    let scoped = [];
+    try {
+        const payload = await platform.tenant('GET', project, `/queries/${queryId}`, { environment });
+        scoped = (payload?.data?.parameterScheme ?? [])
+            .map(parameter => String(parameter?.name ?? ''))
+            .filter(name => name !== '' && SCOPE_PARAMETER_PATTERN.test(name));
+    }
+    catch {
+        return [];
+    }
+    return scoped.length > 0
+        ? [{
+                ruleId: 'MS-015',
+                severity: 'warn',
+                message: `Uç bir middleware'in arkasında ama kaynağı 'query': sorgunun ${scoped.map(name => `'${name}'`).join(', ')} parametresi ÇAĞRIDAN geliyor (body → query-string → header) ve middleware'in kurduğu 'user' bu yola girmiyor. Bu parametre bir kimlik/tenant KAPSAMIYSA çağıran başkasının değerini yazıp o kapsamın verisini okuyabilir (ölçüldü 2026-09-07). Sunucu tarafında zorlamak için aynı sorguyu bir workflow query adımından çağırın: uç source:'workflow' + aynı middlewareIds, adımın rule.expression'ı "{ ${scoped[0]}: user.${scoped[0]} }". Parametre kullanıcının serbestçe seçebileceği bir filtreyse (yönetici raporunda şirket seçimi gibi) bu uyarıyı yok sayın. Reçete: platform_guide('microservice') §'Kimlik kapsaması × uç kaynağı'.`,
+                guide: 'ngapps://guides/microservice'
+            }]
+        : [];
+}
 const patchOperationsParam = z.array(z.record(z.unknown())).min(1)
     .describe("RFC 6902 JSON Patch işlemleri; path'leri view:'outline'/'part' ile keşfedin. Dizi öğelerinde indeks yerine seçici kullanılabilir: '/sourceParameters/joins[alias=customers]/path' — seçici gövde platforma gitmeden indekse çevrilir, çözülemezse istek hiç gönderilmez.");
+const asUserParam = z.string().min(1).optional().describe("Uygulama üyesinin kimliği: istek gateway'in servis jetonu yerine bu kimlikle gider. Jeton HEM Authorization başlığında HEM NG_AccessToken çerezinde taşınır, böylece jetonu ÇEREZDEN okuyan middleware de geçer — uca middleware bağlandığı anda bu alan olmadan çağrı 401 döner (09-05 koşusu S-21). İKİ ŞEKİL kabul edilir: (1) ham JWT, (2) `tok_…` referansı (giriş ucunu çağırdığınızda yanıtın tokenRefs alanında döner, 15 dk geçerli). anonymous ile birlikte verilemez.");
+const cookiesParam = z.record(z.string()).optional().describe("İsteğe eklenecek çerezler (ad → değer): uygulamanın KENDİ oturum çerezi buraya verilir (ör. { CORE_Token: '<jwt>' }). asUser verildiğinde gateway NG_AccessToken çerezini zaten kendisi kurar; bu alan yalnız uygulama başka bir çerez adı okuyorsa gerekir. anonymous ile birlikte verilemez.");
 const executeInput = {
     project: projectParam,
     environment: environmentParam,
@@ -21,8 +77,62 @@ const executeInput = {
     body: z.union([z.record(z.unknown()), z.array(z.record(z.unknown()))]).optional()
         .describe('İstek gövdesi: tek nesne ya da nesne dizisi (bulk uçlar için)'),
     headers: z.record(z.string()).optional().describe("İsteğe eklenecek header'lar. 'Authorization' verirseniz gateway KENDİ token'ını KOYMAZ — istek tamamen sizin kimliğinizle gider (middleware'li uçları üye token'ıyla test etmenin yolu budur)"),
-    anonymous: z.boolean().optional().describe("true: istek HİÇBİR Authorization header'ı olmadan gider — 'korumalı uç tokensız ne döner?' sorusunun cevabı budur (korumalı uçtan 401, anonim uçtan 200 beklenir). Gateway normalde her çağrıya kendi token'ını koyduğu için bu bayrak olmadan anonim erişim testi yapılamaz.")
+    anonymous: z.boolean().optional().describe("true: istek HİÇBİR Authorization header'ı olmadan gider — 'korumalı uç tokensız ne döner?' sorusunun cevabı budur (korumalı uçtan 401, anonim uçtan 200 beklenir). Gateway normalde her çağrıya kendi token'ını koyduğu için bu bayrak olmadan anonim erişim testi yapılamaz."),
+    asUser: asUserParam,
+    cookies: cookiesParam,
+    language: languageParam,
+    expectFailure: z.boolean().optional().describe("true: bu çağrıda bir hata dönmesi BEKLENİYOR (kasıtlı negatif test — yanlış parola, yetkisiz erişim, geçersiz gövde). Yanıt yine httpStatus'u/hatayı taşır, ama ölçüm aracı bu satırı plansız hata saymaz (page_screenshot'taki expectFailure deseniyle aynı).")
 };
+/**
+ * `anonymous` ile kimlik birlikte verilemez: biri kimliksiz isteği, diğeri belirli bir üyenin
+ * kimliğiyle atılan isteği ister. `page_screenshot`'taki kural aynen geçerli (G-20).
+ */
+function runIdentity(anonymous, asUser, cookies, headers) {
+    if (anonymous === true && (asUser !== undefined || cookies !== undefined)) {
+        throw new PlatformApiError("anonymous:true ile asUser/cookies birlikte verilemez — biri kimliksiz isteği, diğeri belirli bir üyenin kimliğiyle atılan isteği ister.", 400);
+    }
+    return identityHeaders(asUser, cookies, headers);
+}
+/**
+ * Debug çıktısındaki `executionItems` ucun kendi adımlarıdır; middleware AYRI bir workflow olarak
+ * ucun ÖNÜNDE koşar ve ağaçta hiç görünmez — 09-04 koşusunda sessizce açık kalan şirket kapısı
+ * (Y-03) bu yüzden adım ağacından teşhis edilemedi. Gateway zinciri kendisi çözüp listeler.
+ */
+async function middlewareChain(platform, project, environment, application, microservice, httpStatus) {
+    try {
+        const resolver = new RefResolver(platform, project, environment);
+        const applicationId = await resolver.applicationId(application);
+        const list = await platform.tenant('GET', project, `/microservices/${applicationId}`, { environment, query: { pageIndex: 0, pageLength: 200 } });
+        const record = (list?.data ?? []).find(entry => String(entry.slug ?? '') === microservice);
+        if (!record) {
+            return { middlewareNote: `'${microservice}' ucu application listesinde bulunamadı; middleware zinciri çözülemedi. Slug'ı microservice_list ile doğrulayın.` };
+        }
+        // LİSTE DTO'su middlewareIds taşımaz (yalnız id/ad/slug/tip/kaynak) — not bu yüzden bağlı bir
+        // uçta bile "bağlı değil" diyordu ve okuyanı yanlış yere baktırıyordu (09-05 koşusu S-21).
+        // Kimlik listeden, bağlar DETAYDAN okunur.
+        const detail = await platform.tenant('GET', project, `/microservices/${applicationId}/${String(record.id ?? '')}`, { environment });
+        const definition = (detail?.data ?? detail ?? {});
+        const middlewareIds = (Array.isArray(definition.middlewareIds) ? definition.middlewareIds : []).map(String).slice(0, 10);
+        if (middlewareIds.length === 0) {
+            return { middlewareNote: "Bu uca middleware bağlı değil (microservice_get middlewareIds boş) — executionItems ağacı isteğin TAMAMINI anlatıyor. Yetki/oturum kapısı bekliyorsanız uca middleware bağlamanız gerekir (platform_guide('middleware'))." };
+        }
+        const middlewares = [];
+        for (const middlewareId of middlewareIds) {
+            const detail = await platform.tenant('GET', project, `/workflows/${applicationId}/${middlewareId}`, { environment });
+            middlewares.push(workflowOutline((detail?.data ?? detail)));
+        }
+        const blocked = typeof httpStatus === 'number' && (httpStatus === 401 || httpStatus === 403);
+        return {
+            middlewares,
+            middlewareNote: blocked
+                ? `Bu uca ${middlewareIds.length} middleware bağlı ve istek ${httpStatus} ile KESİLDİ — executionItems ağacının kökü ucun kendi adımları değil, kesen middleware'in adımlarıdır. Gateway'in servis jetonu uygulamanın kendi kullanıcısı değildir; uygulama kullanıcısıyla denemek için asUser (giriş ucundan gelen tok_… referansı) verin.`
+                : "Bu middleware'ler ucun ÖNÜNDE koşar ve geçirdiler; debug çıktısındaki executionItems ağacı ucun kendi adımlarıdır. Kapının açık kalıp kalmadığını buradaki adımlardan okuyun; middleware ifadelerini ayrıca workflow_get ile inceleyebilirsiniz."
+        };
+    }
+    catch (error) {
+        return { middlewareNote: `Middleware zinciri çözülemedi: ${error instanceof Error ? error.message : String(error)}. Uca bağlı middleware'leri microservice_get ile okuyabilirsiniz.` };
+    }
+}
 function executePath(prefix, application, microservice, routeParams) {
     const routeSuffix = routeParams && routeParams.length > 0
         ? `/${routeParams.map(encodeURIComponent).join('/')}`
@@ -81,7 +191,7 @@ export function registerMicroserviceTools(server, platform) {
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            applicationId: guid,
+            applicationId: appRef,
             searchTerm: z.string().optional(),
             httpMethod: z.string().optional(),
             entityId: guid.optional(),
@@ -91,75 +201,119 @@ export function registerMicroserviceTools(server, platform) {
             ...pagingParams
         },
         annotations: readOnly
-    }, handle(config, ({ project, environment, applicationId, ...query }) => platform.tenant('GET', project, `/microservices/${applicationId}`, { environment, query })));
+    }, handle(config, async ({ project, environment, applicationId, ...query }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        return withResolved(await platform.tenant('GET', project, `/microservices/${resolvedApplicationId}`, { environment, query }), resolver.resolved);
+    }));
     server.registerTool('microservice_get', {
         title: 'Microservice getir',
         description: "Microservice tanımını getirir. Büyük tanımda önce view:'outline' (kaynak/alan özeti), sonra view:'part' ile tek parça çekin.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
-            applicationId: guid,
+            applicationId: appRef,
             id: guid,
             view: z.enum(['full', 'outline', 'part']).optional().describe('varsayılan full'),
             part: z.string().optional().describe("view:'part' için yol, ör. sourceParameters.joins veya validations[0]")
         },
         annotations: readOnly
     }, handle(config, async ({ project, environment, applicationId, id, view, part }) => {
-        const payload = await platform.tenant('GET', project, `/microservices/${applicationId}/${id}`, { environment });
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        const payload = await platform.tenant('GET', project, `/microservices/${resolvedApplicationId}/${id}`, { environment });
         const definition = (payload?.data ?? payload);
         if (view === 'part') {
             if (!part)
                 throw new Error("view:'part' için 'part' parametresi zorunlu.");
-            return { part, value: resolvePart(definition, part) };
+            return withResolved({ part, value: resolvePart(definition, part) }, resolver.resolved);
         }
-        const resolvedUrl = await resolveRuntimeUrl(platform, project, environment, applicationId, definition);
+        const resolvedUrl = await resolveRuntimeUrl(platform, project, environment, resolvedApplicationId, definition);
         if (view === 'outline')
-            return { ...microserviceOutline(definition), resolvedUrl };
-        return { ...payload, resolvedUrl };
+            return withResolved({ ...microserviceOutline(definition), resolvedUrl }, resolver.resolved);
+        return withResolved({ ...payload, resolvedUrl }, resolver.resolved);
     }));
     server.registerTool('microservice_create', {
         title: 'Microservice oluştur',
-        description: "Yeni microservice tanımlar (definition = CreateMicroserviceCommand). İlk kullanımdan önce platform_guide('microservice') okuyun: kaynak seçimi (table > query) ve selectFields disiplini. 'description' ZORUNLUDUR (MS-014, block): çağıranın bu uçtan ne elde ettiğini yazın. Auth/oturum gerektiren uçlarda definition.middlewareIds ile middleware bağlayın; kimlik kapsaması filtrede source:'expression' + value:'user.id' ile yapılır (platform_guide('middleware')). Ucun gerçek bir tuzağı varsa (auth istemiyor, sayfalama yok, atomik değil) 'caution' alanına yazın — OPSİYONELDİR, tuzak yoksa boş bırakın. Gövde politika kontrolünden geçer.",
-        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Yeni microservice tanımlar (definition = CreateMicroserviceCommand). İlk kullanımdan önce platform_guide('microservice') okuyun: kaynak seçimi (table > query) ve selectFields disiplini. 'description' ZORUNLUDUR (MS-014, block): çağıranın bu uçtan ne elde ettiğini yazın. Auth/oturum gerektiren uçlarda definition.middlewareIds ile middleware bağlayın; kimlik kapsaması filtrede source:'expression' + value:'user.id' ile yapılır (platform_guide('middleware')). BU YALNIZ source:'table' UÇLARDA VAR: query kaynaklı ucun parametreleri ÇAĞRIDAN gelir (body → query-string → header) ve middleware'in kurduğu user o yola girmez — kapsamı gövdeye bırakan uç sahtelenebilir (ölçüldü 2026-09-07). Kapsanmış agregasyon ucu sorguyu bir workflow query adımından çağırır: platform_guide('microservice') §'Kimlik kapsaması × uç kaynağı'. Ucun gerçek bir tuzağı varsa (auth istemiyor, sayfalama yok, atomik değil) 'caution' alanına yazın — OPSİYONELDİR, tuzak yoksa boş bırakın. Gövde politika kontrolünden geçer. " + constraintSummary('CreateMicroserviceCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: appRef, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: writes
     }, handle(config, async ({ project, environment, applicationId, definition, policyOverride }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        const hydrated = await hydrateMicroserviceRefs(definition, resolver);
         const normalized = normalizeMicroserviceDefinition(definition);
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'create' }, policyOverride));
-        const payload = await platform.tenant('POST', project, `/microservices/${applicationId}`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        const findings = [
+            ...enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'create' }, policyOverride)),
+            ...await queryScopeFindings(platform, project, environment, definition)
+        ];
+        const drift = unmappedMembers('CreateMicroserviceCommand', definition);
+        const payload = await platform.tenant('POST', project, `/microservices/${resolvedApplicationId}`, { environment, body: definition });
+        return attachFindings(withUnmappedMembers(withWriteDiff(withResolved(withNormalization(payload, normalized), [...resolver.resolved, ...hydrated]), writeDiff(definition, payload)), drift), findings);
     }));
     server.registerTool('microservice_update', {
         title: 'Microservice güncelle',
-        description: 'Microservice tanımını günceller (tam gövde). Hedefli değişiklik için microservice_patch tercih edin. \'description\' ZORUNLUDUR (MS-014, block). Ucun gerçek bir tuzağı varsa (auth istemiyor, sayfalama yok, atomik değil) \'caution\' alanına yazın — OPSİYONELDİR, tuzak yoksa boş bırakın. Gövde politika kontrolünden geçer.',
-        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: 'Microservice tanımını günceller (tam gövde). Hedefli değişiklik için microservice_patch tercih edin. \'description\' ZORUNLUDUR (MS-014, block). Ucun gerçek bir tuzağı varsa (auth istemiyor, sayfalama yok, atomik değil) \'caution\' alanına yazın — OPSİYONELDİR, tuzak yoksa boş bırakın. Gövde politika kontrolünden geçer. ' + constraintSummary('UpdateMicroserviceCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: appRef, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
         annotations: updates
     }, handle(config, async ({ project, environment, applicationId, id, definition, policyOverride }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        const hydrated = await hydrateMicroserviceRefs(definition, resolver);
         const normalized = normalizeMicroserviceDefinition(definition);
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'update' }, policyOverride));
-        const payload = await platform.tenant('PUT', project, `/microservices/${applicationId}/${id}`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        const findings = [
+            ...enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'update' }, policyOverride)),
+            ...await queryScopeFindings(platform, project, environment, definition)
+        ];
+        const drift = unmappedMembers('UpdateMicroserviceCommand', definition);
+        const payload = await platform.tenant('PUT', project, `/microservices/${resolvedApplicationId}/${id}`, { environment, body: definition });
+        return attachFindings(withUnmappedMembers(withWriteDiff(withResolved(withNormalization(payload, normalized), [...resolver.resolved, ...hydrated]), writeDiff(definition, payload)), drift), findings);
     }));
     server.registerTool('microservice_patch', {
         title: 'Microservice\'e patch uygula',
         description: 'Tam gövdeyi bağlama almadan hedefli değişiklik: gateway mevcut tanımı çeker, JSON Patch uygular, politika kontrolünden geçirir, geri yazar. Yanıt outline özetidir.',
-        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid, operations: patchOperationsParam, policyOverride: policyOverrideParam },
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: appRef, id: guid, operations: patchOperationsParam.optional(), ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı) — sayfa micro-op tool'larıyla aynı adı kullanabilmeniz için"), policyOverride: policyOverrideParam },
         annotations: updates
-    }, handle(config, async ({ project, environment, applicationId, id, operations, policyOverride }) => {
-        const current = await platform.tenant('GET', project, `/microservices/${applicationId}/${id}`, { environment });
+    }, handle(config, async ({ project, environment, applicationId, id, operations: givenOperations, ops, policyOverride }) => {
+        const operations = microOps('microservice_patch', ops, givenOperations);
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        const current = await platform.tenant('GET', project, `/microservices/${resolvedApplicationId}/${id}`, { environment });
         const definition = structuredClone((current?.data ?? current));
         const resolved = resolvePatchOperations(definition, operations);
         const patched = fastJsonPatch.applyPatch(definition, resolved.operations, true, false).newDocument;
+        // Patch gövdesi tam PUT olarak geri yazılır: okunan kayıtta olmayan alan yazmada da SİLİNİR.
+        // 09-04 koşusunda gidiş-dönüş 'description'ı düşürdü ve MS-014 patch'i bloke etti; genel
+        // MS-014 mesajı sebebi söylemediği için tuzağı burada adıyla anlatıyoruz (Y-16).
+        if (typeof patched.description !== 'string' || patched.description.trim() === '') {
+            throw new PlatformApiError(`microservice_patch: okunan kayıtta 'description' yok, bu gövdeyi geri yazmak açıklamayı SİLER (MS-014 de bloke eder). Aynı çağrıya açıklamayı ekleyin: { "op": "add", "path": "/description", "value": "<ucun ne işe yaradığı>" }. Kayıtta bir açıklama olduğunu düşünüyorsanız microservice_get ile kontrol edin — platform okuma yolunda alanı düşürüyorsa (09-04 Y-16) tek turda yeniden yazmak gerekir.`, 400);
+        }
         const normalized = normalizeMicroserviceDefinition(patched);
-        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', patched, { operation: 'update' }, policyOverride));
-        await platform.tenant('PUT', project, `/microservices/${applicationId}/${id}`, { environment, body: patched });
-        return attachFindings(withNormalization({ applied: operations.length, outline: microserviceOutline(patched) }, [...normalized, ...resolved.notes.map(note => `patch yolu seçiciden indekse çözüldü: ${note}`)]), findings);
+        const findings = [
+            ...enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', patched, { operation: 'update' }, policyOverride)),
+            ...await queryScopeFindings(platform, project, environment, patched)
+        ];
+        const drift = introducedUnmappedMembers('UpdateMicroserviceCommand', (current?.data ?? current), patched);
+        // Gövde değil FARK gönderilir: gateway normalizasyonları da op'a çevrilsin diye net diff
+        // okunan kayıt ile son hâl arasından hesaplanır (tam PUT yok, yalnız değişen alanlar yazılır).
+        const netOps = fastJsonPatch.compare(definition, patched);
+        const saved = await platform.tenant('PATCH', project, `/microservices/${resolvedApplicationId}/${id}`, {
+            environment,
+            body: { baseVersion: baseVersionOf(definition, 'microservice_get'), ops: netOps }
+        });
+        const written = patchResult(saved, patched);
+        return attachFindings(withUnmappedMembers(withWriteDiff(withResolved(withNormalization({ applied: operations.length, newVersion: written.newVersion, outline: microserviceOutline(written.data) }, [...normalized, ...resolved.notes.map(note => `patch yolu seçiciden indekse çözüldü: ${note}`)]), resolver.resolved), writeDiff(patched, written.data)), drift), findings);
     }));
     server.registerTool('microservice_delete', {
         title: 'Microservice sil',
         description: 'Microservice tanımını siler.',
-        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, id: guid },
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: appRef, id: guid },
         annotations: destructive
-    }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('DELETE', project, `/microservices/${applicationId}/${id}`, { environment })));
+    }, handle(config, async ({ project, environment, applicationId, id }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        return withResolved(await platform.tenant('DELETE', project, `/microservices/${resolvedApplicationId}/${id}`, { environment }), resolver.resolved);
+    }));
     server.registerTool('microservice_clone', {
         title: 'Microservice klonla',
         description: 'Microservice\'in kopyasını oluşturur.',
@@ -168,31 +322,107 @@ export function registerMicroserviceTools(server, platform) {
     }, handle(config, ({ project, environment, id }) => platform.tenant('POST', project, `/microservices/${id}/clone`, { environment })));
     server.registerTool('microservice_execute', {
         title: 'Microservice çalıştır',
-        description: 'Kayıtlı microservice\'i gerçek runtime yolundan çalıştırır (POST /{project}/m/{application}/{microservice SLUG\'ı}). Dönen httpStatus microservice\'in kendi sonucudur (hata da geçerli çıktıdır); beklenmedik sonuçta microservice_debug ile adım adım inceleyin. Anonim erişim testi için anonymous: true.',
+        description: "Kayıtlı microservice'i gerçek runtime yolundan çalıştırır (POST /{project}/m/{application}/{microservice SLUG'ı}). Dönen httpStatus microservice'in kendi sonucudur (hata da geçerli çıktıdır); beklenmedik sonuçta microservice_debug ile adım adım inceleyin. Anonim erişim testi için anonymous: true. Yanıt 'headers' alanında platformun döndüğü header'ları taşır (küçük harf; ör. headers['total-count'] — sayfalı tablo akışlarının okuduğu sözleşme; set-cookie/authorization elenir).",
         inputSchema: executeInput,
         annotations: writes
-    }, handle(config, ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous }) => platform.tenantRaw(method, project, executePath('m', application, microservice, routeParams), { environment, query, body, headers, anonymous })));
+    }, handle(config, async ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous, asUser, cookies, language }) => {
+        const notes = [];
+        const requestHeaders = { ...runIdentity(anonymous, asUser, cookies, headers), ...languageHeader(language, notes) };
+        return withNormalization(await platform.tenantRaw(method, project, executePath('m', application, microservice, routeParams), { environment, query, body, headers: requestHeaders, anonymous, mirrorAuthorizationCookie: true }), notes);
+    }));
     server.registerTool('microservice_debug', {
         title: 'Microservice debug',
-        description: 'Microservice\'i debug modunda çalıştırır; yanıtta adım adım executionItems ağacı döner (her adımın girdi/çıktısı).',
+        description: "Microservice'i debug modunda çalıştırır; yanıtta adım adım executionItems ağacı döner (her adımın girdi/çıktısı). executionItems YALNIZ ucun kendi adımlarını kapsar — ucun ÖNÜNDE koşan middleware'ler ayrıca 'middlewares' alanında adım özetiyle listelenir (09-04 Y-04).",
         inputSchema: executeInput,
         annotations: writes
-    }, handle(config, ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous }) => platform.tenantRaw(method, project, executePath('debug', application, microservice, routeParams), { environment, query, body, headers, anonymous })));
+    }, handle(config, async ({ project, environment, application, microservice, method, routeParams, query, body, headers, anonymous, asUser, cookies, language }) => {
+        const notes = [];
+        const requestHeaders = { ...runIdentity(anonymous, asUser, cookies, headers), ...languageHeader(language, notes) };
+        const payload = await platform.tenantRaw(method, project, executePath('debug', application, microservice, routeParams), { environment, query, body, headers: requestHeaders, anonymous, mirrorAuthorizationCookie: true });
+        return withNormalization({ ...payload, ...await middlewareChain(platform, project, environment, application, microservice, payload?.httpStatus) }, notes);
+    }));
     server.registerTool('microservice_preview', {
         title: 'Microservice önizle',
-        description: 'Kaydedilmemiş microservice tanımını çalıştırır; kaydetmeden önce preview ile doğrulayın. definition = PreviewMicroserviceCommand gövdesi (previewParameters dahil).',
-        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        description: "Microservice tanımını çalıştırır: kaydedilmemiş gövde için definition, KAYITLI bir uç için yalnız id verin (gateway tanımı kendisi çeker — tam gövdeyi bağlama almanız gerekmez). previewParameters ayrı alandır ve ikisiyle de çalışır. Preview tek transaction'da koşar ve sonunda ROLLBACK edilir — kalıcı satır yazmaz; code step'teki dış HTTP çağrıları istisnadır. Davranış kuralları: platform_guide('microservice').",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: appRef,
+            id: guid.optional().describe('Kayıtlı microservice id\'si: verilirse tanım platformdan çekilir ve definition zorunlu olmaz (microservice_list / project_overview)'),
+            definition: definitionParam.optional(),
+            previewParameters: z.record(z.unknown()).optional().describe("Test girdisi: { body: [{…}] } · { queryString: {…} } · { routeParams: {…} }. Tanımsız bir şekil SESSİZCE yutulur (bütün sayaçlar 0 döner) — şekli önce microservice_get çıktısındaki parametre tanımıyla eşleyin."),
+            asUser: asUserParam,
+            cookies: cookiesParam,
+            policyOverride: policyOverrideParam,
+            language: languageParam
+        },
         annotations: writes
-    }, handle(config, async ({ project, environment, applicationId, definition, policyOverride }) => {
+    }, handle(config, async ({ project, environment, applicationId, id, definition: given, previewParameters, asUser, cookies, policyOverride, language }) => {
+        const resolver = new RefResolver(platform, project, environment);
+        const resolvedApplicationId = await resolver.applicationId(applicationId);
+        if (given === undefined && id === undefined) {
+            throw new PlatformApiError('microservice_preview: definition ya da id verin — kaydedilmemiş bir gövdeyi önizlemek için definition, kayıtlı bir ucu önizlemek için id (gateway tanımı kendisi çeker).', 400);
+        }
+        const stored = id === undefined
+            ? undefined
+            : await platform.tenant('GET', project, `/microservices/${resolvedApplicationId}/${id}`, { environment });
+        const base = stored === undefined ? {} : structuredClone((stored.data ?? stored));
+        delete base.id;
+        const definition = {
+            ...base,
+            ...(given ?? {}),
+            ...(previewParameters === undefined ? {} : { previewParameters })
+        };
+        const hydrated = await hydrateMicroserviceRefs(definition, resolver);
         const normalized = normalizeMicroserviceDefinition(definition);
         const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'microservice', definition, { operation: 'preview' }, policyOverride));
-        const payload = await platform.tenantRaw('POST', project, `/microservices/${applicationId}/preview`, { environment, body: definition });
-        return attachFindings(withNormalization(payload, normalized), findings);
+        // Önizleme de ucun middleware'lerini koşturur: kimlik verilmezse korumalı uç 401 döner ve kuru
+        // koşu aracı tam gerektiği anda kullanılamaz hâle gelir (09-05 koşusu S-21).
+        const payload = await platform.tenantRaw('POST', project, `/microservices/${resolvedApplicationId}/preview`, { environment, body: definition, headers: { ...identityHeaders(asUser, cookies, undefined), ...languageHeader(language, normalized) }, mirrorAuthorizationCookie: true });
+        return attachFindings(withResolved(withNormalization(payload, normalized), [...resolver.resolved, ...hydrated]), findings);
     }));
     server.registerTool('microservice_job_history', {
         title: 'Job geçmişi',
-        description: 'Zamanlanmış (job tipli) microservice\'in çalışma geçmişini listeler.',
-        inputSchema: { project: projectParam, environment: environmentParam, id: guid, ...pagingParams },
+        description: 'Zamanlanmış (job tipli) microservice\'in çalışma geçmişini listeler. status ile yalnız running | completed | failed koşular süzülür; order TriggeredAt | CompletedAt | ExecutionStatus | DurationMs.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            status: z.enum(['running', 'completed', 'failed']).optional().describe('Yalnız bu durumdaki koşular'),
+            ...pagingParams
+        },
         annotations: readOnly
     }, handle(config, ({ project, environment, id, ...query }) => platform.tenant('GET', project, `/microservices/${id}/job-history`, { environment, query })));
+    server.registerTool('microservice_schedule_get', {
+        title: 'Zamanlama durumu',
+        description: 'Zamanlanmış (schedule-job) microservice\'in canlı zamanlama durumunu döner: state (scheduled | paused | notScheduled | error | ended), isRunning, nextFireTimeUtc, previousFireTimeUtc, sıradaki 5 koşu (upcomingFireTimesUtc), cron + timeZoneId, serverTimeUtc ve son koşunun özeti (lastExecution). "Bir sonraki sefer ne zaman koşacak?" sorusunu cron\'u yorumlamadan buradan cevaplayın. paused iken nextFireTimeUtc null ve upcoming boştur. notScheduled: kayıt var ama zamanlayıcıda trigger yok — en geç 5 dk içinde uzlaştırma kurar ya da servisi kaydedin (microservice_update). ended: tanımın sonraki koşusu yok (once geçti, end on/after doldu). schedule alanı tanımın kendisidir. Schedule tipli olmayan servis 400 döner.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/microservices/${id}/schedule`, { environment })));
+    server.registerTool('microservice_schedule_forecast', {
+        title: 'Zamanlama öngörüsü',
+        description: 'Bir zamanlama tanımını (typeParameters.schedule biçimi) KAYDETMEDEN doğrular ve sıradaki 5 koşuyu UTC olarak döner: { isValid, errors[{property,message}], upcomingFireTimesUtc[] }. microservice_create/update öncesi tanımın beklenen saatlerde koştuğunu buradan görün; alan listesi için platform_guide(\'microservice\') §Zamanlanmış iş.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            schedule: z.record(z.unknown()).describe('ScheduleDefinition: mode, timeZoneId, startAt, every, unit, timeOfDay, daysOfWeek, daysOfMonth, cronExpression, end')
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, schedule }) => platform.tenant('POST', project, '/microservices/schedule/preview', { environment, body: { schedule } })));
+    server.registerTool('microservice_schedule_control', {
+        title: 'Zamanlamayı yönet',
+        description: 'Zamanlanmış microservice\'i duraklatır (pause), sürdürür (resume) ya da cron\'u beklemeden bir kez koşturur (trigger). pause/resume yalnız zamanlayıcıdaki durumu değiştirir, tanımı değil; duraklatma cron güncellemesi ve deployment senkronundan sonra da korunur. resume: duraklatılmışken bir koşu kaçırıldıysa iş bir kez hemen koşar. trigger KUYRUĞA ALIR, sonucu beklemez: deployment ya da template kurulumu sürüyorsa koşu veto edilir ve geçmişe hiç düşmez — sonucu microservice_job_history ile doğrulayın. Zamanlayıcıda kaydı olmayan iş 400 (ScheduleJobNotRegisteredException) döner. Production ortamında üç eylem de 400 CantWriteInProductionException ile reddedilir; trigger ayrıca deployment/template kurulumu sürerken reddedilir.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            action: z.enum(['pause', 'resume', 'trigger']).describe('pause | resume | trigger')
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, action }) => {
+        await platform.tenant('POST', project, `/microservices/${id}/schedule/${action}`, { environment });
+        return action === 'trigger'
+            ? { action, accepted: true, note: 'Kuyruğa alındı; koşuyu microservice_job_history ile doğrulayın.' }
+            : { action, accepted: true, note: 'Güncel durum için microservice_schedule_get.' };
+    }));
 }