@appaflytech/zeyrek-ai-mcp 0.0.4 → 0.0.6

package/dist/tools/layouts.js

@@ -1,11 +1,18 @@
-import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive } from './common.js';
-import { normalizeComponentDefaults, componentDefaultsNote, blockSizeNote, heightTypeNote, invalidScreenEventNames, invalidWidgetTypeNodes, verticalGapWarnings, withNormalization } from '../knowledge/normalize.js';
+import { guid, projectParam, environmentParam, pagingParams, readOnly, writes, updates, destructive, microOps } from './common.js';
+import { resolvePatchOperations } from '../knowledge/outlines.js';
+import { patchResult, baseVersionOf } from '../platform/patch.js';
+import fastJsonPatch from 'fast-json-patch';
+import { normalizeComponentDefaults, componentDefaultsNote, flexSizeWarnings, verticalGapWarnings, withNormalization } from '../knowledge/normalize.js';
 import { fetchHost, layoutUpdateBody, schemaParam, eventsParam, modeParam, summarize, findNode } from './screens.js';
-import { applyCatalogLayoutRules } from './components.js';
+import { assertScreenWriteGuards, screenCatalogNotes } from './screenWrite.js';
+import { applyPropTypesToSchema, isSetPropTypeOp, setPropTypeErrors } from '../knowledge/propTypes.js';
+import { writeDiff, withWriteDiff } from '../platform/writeDiff.js';
 import { PlatformApiError } from '../platform/errors.js';
 import { handle } from '../platform/responses.js';
 import { z } from 'zod';
-const viewsParam = schemaParam.describe("Layout'un komponent ağacı. DİKKAT: layout'ta şema alanının adı 'schema' değil 'views'tir ve sayfa micro-op hattı (page_schema_patch) layout'a uygulanmaz. İçinde MUTLAKA bir { type: 'slot' } komponenti olmalı — sayfa içeriği YALNIZ slot'un içine render edilir, slot'suz layout'a bağlanan sayfalar boş görünür.");
+const patchOperationsParam = z.array(z.record(z.unknown())).min(1)
+    .describe("JSON Patch listesi (RFC 6902): { op, path, value }. Yol seçici alabilir — '/views/0/children[elementId=baslik]/props/content/data'.");
+const viewsParam = schemaParam.describe("Layout'un komponent ağacı. DİKKAT: layout'ta şema alanının adı 'schema' değil 'views'tir ve sayfa micro-op hattı (page_schema_patch) layout'a uygulanmaz. İçinde MUTLAKA bir { type: 'slot' } komponenti olmalı — sayfa içeriği YALNIZ slot'un içine render edilir, slot'suz layout'a bağlanan sayfalar boş görünür. 2026-09-08'den beri views, page_schema_patch'in doğrulama duvarından geçer: tanınmayan prop adı ve geçersiz enum değeri 422 ile REDDEDİLİR (kabul edilen değer listesiyle) ve hiçbir şey kaydedilmez — eskiden sessizce kaydediliyordu (P1-2).");
 function countSlots(nodes) {
     if (!Array.isArray(nodes))
         return 0;
@@ -42,7 +49,7 @@ export function registerLayoutTools(server, platform) {
     }, handle(config, ({ project, environment, applicationId, id }) => platform.tenant('GET', project, `/layouts/${applicationId}/${id}`, { environment })));
     server.registerTool('layout_schema_get', {
         title: "Layout komponent ağacını oku",
-        description: "Layout'un komponent ağacını (views) okur — page_schema_get'in layout karşılığı. DİKKAT: layout'ta micro-op hattı YOKTUR (backend'de PATCH /layouts/.../schema ucu yok), yani buradan okunan updatedAt bir expectedUpdatedAt kontrolünde kullanılamaz; değişiklik layout_update ile tam gövde olarak yazılır.",
+        description: "Layout'un komponent ağacını (views) okur — page_schema_get'in layout karşılığı. Platformda layout micro-op ucu (sayfadaki PATCH /pages/.../schema karşılığı) yoktur, ama PATCH /layouts/{app}/{id} vardır: hedefli değişiklik için layout_patch kullanın — gateway okur, JSON Patch'i çözer ve FARKI `{ baseVersion, ops }` olarak platforma yazar; tam gövde PUT'u atılmaz. Buradaki updatedAt'i ayrıca expectedUpdatedAt olarak kabul eder. Tam ağacı kendiniz yazacaksanız layout_update.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
@@ -71,7 +78,7 @@ export function registerLayoutTools(server, platform) {
     }));
     server.registerTool('layout_create', {
         title: 'Layout oluştur',
-        description: "Yeni layout oluşturur. Şablon için mevcut bir layout'u layout_get ile alın; slot kurgusunu page_state çıktısındaki layoutSlots ile doğrulayın.",
+        description: "Yeni layout oluşturur. Şablon için mevcut bir layout'u layout_get ile alın; slot kurgusunu page_state çıktısındaki layoutSlots ile doğrulayın. views tam doğrulamadan geçer (tanınmayan prop · geçersiz enum · çakışan elementId · blok sınırı) ve tek hata bile tüm gövdeyi düşürür.",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
@@ -83,29 +90,23 @@ export function registerLayoutTools(server, platform) {
         },
         annotations: writes
     }, handle(config, async ({ project, environment, applicationId, name, views, events, parameters }) => {
-        const badEvents = invalidScreenEventNames(events, 'LAY-004');
-        if (badEvents.length > 0)
-            throw new PlatformApiError(`Geçersiz layout olayı (istek gönderilmedi): ${badEvents.join(' · ')}`, 400);
-        const badWidgets = invalidWidgetTypeNodes(views, 'LAY-005');
-        if (badWidgets.length > 0)
-            throw new PlatformApiError(`Geçersiz widget düğümü (istek gönderilmedi): ${badWidgets.join(' · ')}`, 400);
+        assertScreenWriteGuards('layout', { schema: views, events });
         const fixed = normalizeComponentDefaults(views);
-        const catalog = (views ?? []).length > 0
-            ? await applyCatalogLayoutRules(platform, project, environment, applicationId, views)
-            : { clamped: [], heights: [] };
-        const gaps = verticalGapWarnings(views ?? [], 'LAY-003 (uyarı)');
+        const catalogNotes = await screenCatalogNotes(platform, project, environment, applicationId, views);
+        const gaps = [...verticalGapWarnings(views ?? [], 'LAY-003 (uyarı)'), ...flexSizeWarnings(views ?? [], 'LAY-007 (uyarı)', 'LAY-008 (uyarı)')];
         const response = await platform.tenant('POST', project, `/layouts/${applicationId}`, {
             environment,
             body: { name, views: views ?? [], events: events ?? [], parameters: parameters ?? null }
         });
-        const normalized = withNormalization(response, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights), ...slotWarning(views)]);
+        const drops = writeDiff({ name, views: views ?? [], events: events ?? [] }, response);
+        const normalized = withWriteDiff(withNormalization(response, [...componentDefaultsNote(fixed), ...catalogNotes, ...slotWarning(views)]), drops);
         if (gaps.length === 0 || !normalized || typeof normalized !== 'object')
             return normalized;
         return { ...normalized, layoutWarnings: gaps };
     }));
     server.registerTool('layout_update', {
         title: 'Layout güncelle',
-        description: "Layout'u günceller. PUT replace olduğu için gateway kaydı önce okur, yalnız verdiğiniz alanları değiştirip tam gövdeyi geri yazar — views göndermezseniz mevcut ağaç korunur.",
+        description: "Layout'u günceller. PUT replace olduğu için gateway kaydı önce okur, yalnız verdiğiniz alanları değiştirip tam gövdeyi geri yazar — views göndermezseniz mevcut ağaç korunur. Güncelleme yolunda yapısal doğrulama koşar (çakışan elementId · kayıtsız komponent tipi · eksik states/appearance/blok); prop adı ve enum değeri denetimi YALNIZ layout_create'te tamdır, çünkü tam denetim katalog değişince kayıtlı layout'ları geriye dönük kilitler (C-13).",
         inputSchema: {
             project: projectParam,
             environment: environmentParam,
@@ -119,24 +120,97 @@ export function registerLayoutTools(server, platform) {
         annotations: updates
     }, handle(config, async ({ project, environment, applicationId, id, ...changes }) => {
         const overrides = Object.fromEntries(Object.entries(changes).filter(([, value]) => value !== undefined));
-        const badEvents = invalidScreenEventNames(overrides.events, 'LAY-004');
-        if (badEvents.length > 0)
-            throw new PlatformApiError(`Geçersiz layout olayı (istek gönderilmedi): ${badEvents.join(' · ')}`, 400);
-        const badWidgets = invalidWidgetTypeNodes(overrides.views, 'LAY-005');
-        if (badWidgets.length > 0)
-            throw new PlatformApiError(`Geçersiz widget düğümü (istek gönderilmedi): ${badWidgets.join(' · ')}`, 400);
+        assertScreenWriteGuards('layout', { schema: overrides.views, events: overrides.events });
         const current = await fetchHost(platform, 'layout', project, environment, applicationId, id);
         const fixed = normalizeComponentDefaults(overrides.views);
-        const catalog = overrides.views === undefined
-            ? { clamped: [], heights: [] }
-            : await applyCatalogLayoutRules(platform, project, environment, applicationId, overrides.views);
+        const catalogNotes = await screenCatalogNotes(platform, project, environment, applicationId, overrides.views);
         const body = layoutUpdateBody({ ...current, applicationId }, overrides);
         await platform.tenant('PUT', project, `/layouts/${applicationId}/${id}`, { environment, body });
-        const gaps = overrides.views === undefined ? [] : verticalGapWarnings(body.views, 'LAY-003 (uyarı)');
+        const gaps = overrides.views === undefined ? [] : [...verticalGapWarnings(body.views, 'LAY-003 (uyarı)'), ...flexSizeWarnings(body.views, 'LAY-007 (uyarı)', 'LAY-008 (uyarı)')];
         const summary = { id, changed: Object.keys(overrides), preserved: { viewNodes: body.views.length } };
         if (gaps.length > 0)
             summary.layoutWarnings = gaps;
-        return withNormalization(summary, [...componentDefaultsNote(fixed), ...blockSizeNote(catalog.clamped), ...heightTypeNote(catalog.heights), ...slotWarning(body.views)]);
+        return withNormalization(summary, [...componentDefaultsNote(fixed), ...catalogNotes, ...slotWarning(body.views)]);
+    }));
+    server.registerTool('layout_patch', {
+        title: "Layout'a patch uygula",
+        description: "Tam ağacı bağlama almadan hedefli değişiklik: gateway layout'u çeker, JSON Patch'i ve kendi normalizasyonlarını uygular, doğrulamadan geçirir ve FARKI platformun PATCH /layouts/{app}/{id} ucuna `{ baseVersion, ops }` olarak yazar — tek başlık düzeltmesi için 12 düğümlük ağacı yeniden göndermeniz gerekmez (09-04 Y-25) ve tam gövde PUT'u ATILMAZ. Yol İNDEKS yerine SEÇİCİ alabilir: '/views/0/children[elementId=baslik]/props/content/data'. Sürüm kontrolü platformda: okunan kaydın `version` değeri `baseVersion` olarak gider, araya başka bir yazma girdiyse 409 döner ve HİÇBİR op uygulanmaz. expectedUpdatedAt verirseniz gateway ayrıca istek gitmeden önce yerel kontrol yapar. Ayrıca 'set_prop_type' micro-op'unu tanır ({target, prop, propType: 'static'|'code'|'translation', ref?, data?}) — layout header/sidebar etiketini çeviriye bağlamanın yolu budur; JSON Patch ile aynı listede karışık verilebilir, micro-op'lar önce uygulanır.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid,
+            id: guid,
+            operations: patchOperationsParam.optional(),
+            ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı); JSON Patch işlemleriyle set_prop_type micro-op'ları KARIŞIK verilebilir"),
+            expectedUpdatedAt: z.string().optional().describe("layout_schema_get çıktısındaki updatedAt; eşleşmezse patch uygulanmaz (araya giren yazmayı ezmeyi engeller)")
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, applicationId, id, operations: givenOperations, ops, expectedUpdatedAt }) => {
+        const operations = microOps('layout_patch', ops, givenOperations);
+        const current = await fetchHost(platform, 'layout', project, environment, applicationId, id);
+        const audit = current.audit;
+        const updatedAt = audit?.updatedAt ?? audit?.createdAt;
+        if (expectedUpdatedAt !== undefined && String(updatedAt ?? '') !== expectedUpdatedAt) {
+            throw new PlatformApiError(`layout_patch: layout '${expectedUpdatedAt}' okumasından beri değişti (şimdiki updatedAt: ${String(updatedAt ?? 'bilinmiyor')}). Ağacı layout_schema_get ile yeniden okuyup patch'i güncel hâle göre kurun.`, 409);
+        }
+        // `applyPropTypesToSchema` ağacı YERİNDE değiştiriyor; net fark bozulmadan hesaplansın diye
+        // karşılaştırmanın tabanı micro-op'lardan ÖNCE ayrı bir klondan alınır.
+        const original = structuredClone(current);
+        const document = structuredClone(current);
+        const propTypeOps = operations.filter(isSetPropTypeOp);
+        const patchOps = operations.filter(op => !isSetPropTypeOp(op));
+        // Micro-op'lar JSON Patch'ten ÖNCE koşar: patch yolları ağaçtaki mevcut indekslere göre
+        // çözülüyor ve set_prop_type düğüm eklemiyor/çıkarmıyor, yalnız bir prop'un tipini
+        // değiştiriyor — bu sıra iki hattın birbirini bozmadığı tek sıra.
+        const propTypeIssues = setPropTypeErrors(propTypeOps);
+        if (propTypeIssues.length > 0)
+            throw new PlatformApiError(`layout_patch set_prop_type reddedildi (istek gönderilmedi): ${propTypeIssues.join(' · ')}`, 400);
+        const propTypes = propTypeOps.length > 0
+            ? applyPropTypesToSchema((document.views ?? []), propTypeOps)
+            : { applied: [], missingTargets: [] };
+        if (propTypes.missingTargets.length > 0) {
+            throw new PlatformApiError(`set_prop_type hedefi bulunamadı: '${propTypes.missingTargets[0]}'. layout_schema_get ile elementId'leri listeleyin.`, 400);
+        }
+        const resolved = patchOps.length > 0
+            ? resolvePatchOperations(document, patchOps)
+            : { operations: [], targets: [], notes: [] };
+        const patched = patchOps.length > 0
+            ? fastJsonPatch.applyPatch(document, resolved.operations, true, false).newDocument
+            : document;
+        const overrides = Object.fromEntries(['name', 'views', 'events', 'parameters']
+            .filter(key => patched[key] !== undefined)
+            .map(key => [key, patched[key]]));
+        assertScreenWriteGuards('layout', { schema: overrides.views, events: overrides.events });
+        const fixed = normalizeComponentDefaults(overrides.views);
+        const catalogNotes = await screenCatalogNotes(platform, project, environment, applicationId, overrides.views);
+        const body = layoutUpdateBody({ ...current, applicationId }, overrides);
+        // Gövde değil FARK gönderilir: gateway normalizasyonları (komponent varsayılanları, katalog
+        // kuralları, value'suz olayların elenmesi) son hâle işlendikten sonra net diff hesaplanır.
+        const finalDocument = { ...patched, name: body.name, parameters: body.parameters, views: body.views, events: body.events };
+        const netOps = fastJsonPatch.compare(original, finalDocument);
+        const saved = await platform.tenant('PATCH', project, `/layouts/${applicationId}/${id}`, {
+            environment,
+            body: { baseVersion: baseVersionOf(document, 'layout_get'), ops: netOps }
+        });
+        const written = patchResult(saved, finalDocument);
+        const gaps = [...verticalGapWarnings(body.views, 'LAY-003 (uyarı)'), ...flexSizeWarnings(body.views, 'LAY-007 (uyarı)', 'LAY-008 (uyarı)')];
+        const summary = {
+            id,
+            applied: patchOps.length,
+            newVersion: written.newVersion,
+            targets: resolved.targets,
+            viewNodes: body.views.length
+        };
+        if (propTypes.applied.length > 0)
+            summary.propTypes = propTypes.applied;
+        if (gaps.length > 0)
+            summary.layoutWarnings = gaps;
+        return withNormalization(summary, [
+            ...componentDefaultsNote(fixed),
+            ...catalogNotes,
+            ...slotWarning(body.views),
+            ...resolved.notes.map(note => `patch yolu seçiciden indekse çözüldü: ${note}`)
+        ]);
     }));
     server.registerTool('layout_delete', {
         title: 'Layout sil',

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,61 @@ 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
 };
+/**
+ * `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 +190,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 +200,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,26 +321,64 @@ 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',

package/dist/tools/organizations.js

@@ -56,10 +56,9 @@ export function registerOrganizationTools(server, platform) {
         inputSchema: { components: z.array(componentInput).min(1) },
         annotations: updates
     }, handle(config, ({ components }) => platform.org('POST', '/organizations/components/upsert', { body: components })));
-    server.registerTool('organization_sync_users', {
-        title: 'Kullanıcıları tenant şemalarına kopyala',
-        description: 'Organizasyon kullanıcılarını, eksik oldukları üretim-dışı environment şemalarına süper yönetici rolüyle kopyalar. Yeni proje/environment kurulumundan sonra çalıştırılır.',
-        inputSchema: {},
-        annotations: writes
-    }, handle(config, () => platform.org('POST', '/organizations/sync-users')));
+    // `POST /organizations/sync-users` bir BAKIM ucudur: özellik geliştirirken migration/veri
+    // düzeltmesi için yazılmış, ürün yüzeyinin parçası değil (ürün sahibi 2026-09-05'te bunu
+    // söyledi ve uçları temizleyecek). Araç olarak yayınlamak ajanı desteklenmeyen bir yola
+    // sokuyordu; kaldırıldı. İlk kullanıcının nasıl açılacağı için
+    // platform_guide('getting-started') §"İlk kullanıcıyı kim açar?".
 }