@appaflytech/zeyrek-ai-mcp 0.0.32 → 0.0.33

package/dist/tools/applications.js

@@ -1,6 +1,44 @@
 import { guid, pagingParams, readOnly, writes, updates, destructive } from './common.js';
 import { handle } from '../platform/responses.js';
+import { forgetApplication, readApplicationPlatform, resolveApplication } from '../knowledge/platform/resolve.js';
+import { mobileTabsProblems, readMobileTabs } from '../knowledge/platform/mobileTabs.js';
+import { findingLine } from '../knowledge/platform/profile.js';
 import { z } from 'zod';
+/**
+ * MOB-007 (sekme ayarı) — `properties.mobile.tabs` yazan mobil uygulama çağrısının denetimi. Yazım
+ * platforma YİNE gider (D3; backend `properties`'i doğrulamaz): bulgu `platformWarnings`'e düşer.
+ * Sayfa ve widget listesi okunamazsa o denetimler atlanır, biçim denetimi yine koşar.
+ */
+export async function mobileTabsWarnings(platform, applicationId, projectSlug, homepageId, properties) {
+    const tabs = readMobileTabs(properties);
+    if (tabs === undefined)
+        return [];
+    const pages = applicationId && projectSlug
+        ? await platform.tenant('GET', projectSlug, `/pages/${applicationId}`, { query: { pageIndex: 0, pageLength: 200 } })
+            .then(response => (response?.data ?? []).map(page => ({ id: String(page.id ?? '') })))
+            .catch(() => undefined)
+        : undefined;
+    const widgetIds = applicationId && projectSlug
+        ? await platform.tenant('GET', projectSlug, `/components/${applicationId}`, { query: { pageIndex: 0, pageLength: 999 } })
+            .then(response => new Set((response?.data ?? []).filter(entry => entry.kind === 'widget').map(entry => String(entry.id ?? ''))))
+            .catch(() => undefined)
+        : undefined;
+    return mobileTabsProblems(tabs, {
+        ...(pages ? { pages } : {}),
+        ...(homepageId ? { homepageId } : {}),
+        ...(widgetIds ? { widgetIds } : {})
+    }).map(message => findingLine({
+        code: 'MOB-007',
+        severity: 'warn',
+        message,
+        guide: "platform_guide('mobile') §Gezinme"
+    }));
+}
+function withPlatformWarnings(response, warnings) {
+    if (warnings.length === 0 || !response || typeof response !== 'object' || Array.isArray(response))
+        return response;
+    return { ...response, platformWarnings: warnings };
+}
 export function registerApplicationTools(server, platform) {
     const config = platform.config;
     server.registerTool('application_list', {
@@ -34,7 +72,14 @@ export function registerApplicationTools(server, platform) {
             notFoundPageId: guid.optional()
         },
         annotations: writes
-    }, handle(config, ({ projectId, ...body }) => platform.org('POST', `/applications/${projectId}`, { body })));
+    }, handle(config, async ({ projectId, ...body }) => {
+        const warnings = readApplicationPlatform(body.type) === 'mobile'
+            ? await mobileTabsWarnings(platform, undefined, undefined, undefined, body.properties)
+            : [];
+        const response = await platform.org('POST', `/applications/${projectId}`, { body });
+        forgetApplication(platform);
+        return withPlatformWarnings(response, warnings);
+    }));
     server.registerTool('application_update', {
         title: 'Application güncelle',
         description: 'Application bilgilerini günceller; homepageId zorunludur (mevcut değeri application_get ile alın).',
@@ -49,11 +94,23 @@ export function registerApplicationTools(server, platform) {
             notFoundPageId: guid.optional()
         },
         annotations: updates
-    }, handle(config, ({ id, ...body }) => platform.org('PUT', `/applications/${id}`, { body })));
+    }, handle(config, async ({ id, ...body }) => {
+        const current = await resolveApplication(platform, id);
+        const warnings = current?.platform === 'mobile'
+            ? await mobileTabsWarnings(platform, id, current.projectSlug, body.homepageId, body.properties)
+            : [];
+        const response = await platform.org('PUT', `/applications/${id}`, { body });
+        forgetApplication(platform, id);
+        return withPlatformWarnings(response, warnings);
+    }));
     server.registerTool('application_delete', {
         title: 'Application sil',
         description: 'Application\'ı kalıcı olarak siler.',
         inputSchema: { id: guid },
         annotations: destructive
-    }, handle(config, args => platform.org('DELETE', `/applications/${args.id}`)));
+    }, handle(config, async (args) => {
+        const response = await platform.org('DELETE', `/applications/${args.id}`);
+        forgetApplication(platform, args.id);
+        return response;
+    }));
 }

package/dist/tools/bpm.js

@@ -0,0 +1,343 @@
+import { guid, projectParam, environmentParam, definitionParam, pagingParams, asUserIdParam, readOnly, writes, updates, destructive, microOps } from './common.js';
+import { normalizeProcessDefinition, overridePatchFindings, processNodeSchemas, bpmnExtensionFindings, staleScenarioFindings } from '../knowledge/process.js';
+import { evaluatePolicy, enforcePolicy, attachFindings, applyPolicyMode, PolicyBlockError } from '../knowledge/policy.js';
+import { processOutline, resolvePart, resolvePatchOperations } from '../knowledge/outlines.js';
+import { unmappedMembers, withUnmappedMembers } from '../knowledge/schemaGuard.js';
+import { constraintSummary } from '../knowledge/backendConstraints.js';
+import { writeDiff, withWriteDiff } from '../platform/writeDiff.js';
+import { withNormalization } from '../knowledge/normalize.js';
+import { impersonationHeaders } from '../platform/impersonation.js';
+import { identityHeaders } from '../platform/tokenVault.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { baseVersionOf } from '../platform/patch.js';
+import { policyRules } from '../knowledge/rules.js';
+import { handle } from '../platform/responses.js';
+import fastJsonPatch from 'fast-json-patch';
+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 patchOperationsParam = z.array(z.record(z.unknown())).min(1)
+    .describe("RFC 6902 JSON Patch işlemleri, yollar tanım modeline göre. Düğüm hedeflerken İNDEKS YERİNE SEÇİCİ: { op: 'replace', path: '/nodes[id=kontrol-onay]/policy', value: 'all' }; bölge içi düğüm '/nodes[id=bolge]/nodes[id=onay]/…'. Platform seçicisiz sayısal '/nodes/2' yolunu reddeder. Yeni düğüm '/nodes/-'.");
+export function assertProcessNotProduction(tool, environment, config) {
+    if ((environment ?? config.defaultEnvironment) !== 'production')
+        return;
+    throw new PolicyBlockError([{
+            ruleId: 'BPM-001',
+            severity: 'block',
+            message: `${tool}: süreç yayını ve yürütmesi production'a gönderilmez. Hedef 'development' ya da bir dal olmalı; production'a taşıma insan onaylı deployment işidir.`,
+            guide: 'ngapps://guides/bpm'
+        }], false);
+}
+/**
+ * BPM uçları (`/bpm/*`) platform şemasıyla `[Authorize]` edilir: uygulama oturumu jetonunu
+ * `Authorization` başlığına koymak kimlik doğrulamayı düşürür ve 401 verir (ölçüldü 2026-09-22,
+ * S-1 koşusu). Uygulama kullanıcısı adına iş yapmanın desteklenen yolu `impersonated-user-id`
+ * başlığıdır: `AppSessionMiddleware` platform yolundaki istekte çerezi okumaz ama kimliği
+ * doğrulanmış istekte bu başlığı görürse özneyi o kullanıcı olarak kurar (production dışında).
+ */
+export async function bpmIdentityHeaders(platform, tool, project, environment, identity) {
+    const eye = await impersonationHeaders(platform, tool, project, environment, identity, { runtime: true });
+    return eye ?? identityHeaders(identity.asUser, undefined, undefined);
+}
+const asUserIdBpmParam = asUserIdParam
+    .describe("Parolasız kullanıcı gözü (users satır id'si): istek gateway kimliğiyle gider ve 'impersonated-user-id' başlığını taşır, platform özneyi o kullanıcı olarak kurar. /bpm/* uçları platform şemasıyla [Authorize] edildiği için UYGULAMA JETONU bu uçlarda 401 alabilir — parolasız yol budur. Yalnız development ya da dal; asUser ile birlikte verilemez.");
+const asUserParam = z.string().min(1).optional()
+    .describe("Uygulama yöneticisinin kimliği (ham JWT ya da access_session_create tokenRefs'teki tok_… referansı). Uyarlama yazımı zorunlu ister (BPM-013): Studio jetonu uyarlama yazamaz.");
+const overrideOperations = ['save', 'reset', 'migrate-open'];
+function overrideOutline(view) {
+    const definitionOverride = (view.override ?? null);
+    return {
+        definitionId: view.definitionId ?? null,
+        slug: view.slug ?? null,
+        activeVersionNumber: view.activeVersionNumber ?? null,
+        overrideRevision: view.overrideRevision ?? 0,
+        isReadOnly: view.isReadOnly === true,
+        conflictState: definitionOverride?.conflictState ?? 'none',
+        conflictDetail: definitionOverride?.conflictDetail ?? null,
+        patch: definitionOverride?.patch ?? [],
+        editableScopes: view.editableScopes ?? [],
+        outline: {
+            ...processOutline({ id: view.definitionId, slug: view.slug, definition: view.effectiveModel ?? {} }),
+            hint: "Etkin tanım (aktif sürüm + uyarlama). Uyarlamayı process_override_update ile değiştirin; process_definition_patch geliştiricinin taslağını değiştirir, uyarlamayı değil."
+        }
+    };
+}
+export function dataOf(payload) {
+    const record = (payload ?? {});
+    return (record.data && typeof record.data === 'object' ? record.data : record);
+}
+export function registerBpmTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('process_definition_list', {
+        title: 'Süreç tanımlarını listele',
+        description: "Süreç (BPM) tanımlarını listeler: slug, ad, aktif sürüm. Süreç ≠ workflow: süreç insan görevlerinde bekleyen durumlu akıştır, workflow tek istekte biten sunucu akışıdır. view:'export' projedeki bütün tanımları (tüm sürümler, taslak, RACI) ve iş takvimlerini yedek olarak döner — { exportedAt, calendars[], definitions[] }; geri yükleme process_definition_create { restore }. Yedek büyüktür, yalnız yedek için çağırın; yetki process.manage.",
+        inputSchema: { project: projectParam, environment: environmentParam, view: z.enum(['list', 'export']).optional().describe('varsayılan list'), searchTerm: z.string().optional(), applicationId: guid.optional(), ...pagingParams },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, view, ...query }) => view === 'export'
+        ? platform.tenant('GET', project, '/bpm/export-definitions', { environment })
+        : platform.tenant('GET', project, '/bpm/definitions', { environment, query })));
+    server.registerTool('process_definition_get', {
+        title: 'Süreç tanımını getir',
+        description: "Süreç tanımını getirir. Önce view:'outline' (düğüm · tür · derece · atama · SLA · bölge olayları); tek düğüm için view:'part', part:'definition.nodes[id=<düğüm>]'. Tam gövde son çaredir.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            view: z.enum(['full', 'outline', 'part']).optional().describe('varsayılan outline'),
+            part: z.string().optional().describe("view:'part' için yol, ör. definition.nodes[id=onay]")
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, view, part }) => {
+        const payload = await platform.tenant('GET', project, `/bpm/definitions/${id}`, { environment });
+        const definition = dataOf(payload);
+        if (view === 'full')
+            return payload;
+        if (view === 'part') {
+            if (!part)
+                throw new Error("view:'part' için 'part' parametresi zorunlu.");
+            return { part, value: resolvePart(definition, part) };
+        }
+        return processOutline(definition);
+    }));
+    server.registerTool('process_definition_create', {
+        title: 'Süreç tanımı oluştur',
+        description: "Yeni süreç tanımı yazar (taslak sürüm). bpmn verilirse BPMN 2.0 XML'den tanım oluşturur (POST bpm/definitions/import-bpmn; ≤ 256 KB, büyük dosya için boş tanım + process_bpmn_update { filePath }; zeyrek: uzantısız XML'de derece locked, insan adımı ataması yer tutucu 'initiator' — BPM-016 uyarısı; workflow'suz serviceTask 422). İlk kullanımdan önce platform_guide('bpm') okuyun; altın örnekler ngapps://examples/bpm-gorev-kontrol, bpm-satinalma, bpm-iso-dokuman. Tanım ve HER düğüm 'description' taşır (BPM-002, block). Tanım 'analysis: { purpose, summary }', HER düğüm 'analysis: { what, data, why, example }' taşır, her metin { en, tr } iş diliyle; example adımın gerçek hayattan küçük bir vakası (BPM-023, block; Studio'nun Analiz dokümanı sekmesi okur — platform_guide('bpm') § Analiz dokümanı). Kısa biçimler (assignee: 'unit-manager of initiator', sla: 'P2D', edges: [[from, to]]) gateway'de tam biçime çevrilir ve gatewayNormalized ile bildirilir. Yanıt outline'dır; yayın için process_definition_preview ardından process_definition_publish. " + constraintSummary('CreateProcessDefinitionCommand'),
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid.optional(),
+            definition: definitionParam.optional().describe('yeni tanım; restore ya da bpmn verilmezse zorunlu'),
+            bpmn: z.string().min(1).max(256_000).optional().describe('BPMN 2.0 XML — definition ve restore yerine'),
+            restore: z.object({
+                exportedAt: z.string().min(10).max(40),
+                calendars: z.array(z.record(z.unknown())).max(500),
+                definitions: z.array(z.record(z.unknown())).max(1000),
+                confirmOverwrite: z.literal(true).describe('YIKICI: aynı kodlu takvimler ve değişmiş aktif sürümler üzerine yazılır — bilerek true verin')
+            }).optional().describe("YIKICI geri yükleme — process_definition_list { view: 'export' } çıktısının data'sı + confirmOverwrite: true. Takvimler üzerine yazılır; tanımlar içe aktarılır (aktif sürümü farklı olan yeni sürümle YAYINLANIR; hedefte yayınlanmamış farklı taslak varsa o tanım atlanır ve skippedSlugs'ta döner); yedekte olmayan tanım silinmez, emekliye ayrılmaz. Her aktif/taslak sürüm BPM kurallarından geçer (BPM-002 …). production'a gitmez (BPM-001)."),
+            policyOverride: policyOverrideParam
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, applicationId, definition, bpmn, restore, policyOverride }) => {
+        if (bpmn) {
+            if (definition || restore)
+                throw new PlatformApiError('process_definition_create: bpmn, definition ve restore birlikte verilmez (istek gönderilmedi).', 400);
+            const bpmnFindings = config.policyMode === 'off' ? [] : applyPolicyMode(config, bpmnExtensionFindings(bpmn), policyOverride);
+            return attachFindings(processOutline(dataOf(await platform.tenant('POST', project, '/bpm/definitions/import-bpmn', { environment, body: { applicationId, xml: bpmn } }))), bpmnFindings);
+        }
+        if (restore) {
+            if (definition)
+                throw new PlatformApiError('process_definition_create: definition ve restore birlikte verilmez (istek gönderilmedi).', 400);
+            assertProcessNotProduction('process_definition_create', environment, config);
+            const restoreFindings = enforcePolicy(restore.definitions.flatMap(restoredDefinition => (restoredDefinition.versions ?? [])
+                .filter(version => (version.state === 'active' || version.state === 'draft') && version.model)
+                .flatMap(version => evaluatePolicy(config, policyRules, 'process', version.model, { operation: 'create' }, policyOverride))));
+            const { confirmOverwrite: _confirmOverwrite, ...restoreBody } = restore;
+            return attachFindings(await platform.tenant('POST', project, '/bpm/export-definitions', { environment, body: restoreBody }), restoreFindings);
+        }
+        if (!definition)
+            throw new PlatformApiError('process_definition_create: definition zorunlu (ya da yedekten geri yükleme için restore) (istek gönderilmedi).', 400);
+        const normalized = normalizeProcessDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'process', definition, { operation: 'create' }, policyOverride));
+        const drift = unmappedMembers('CreateProcessDefinitionCommand', { applicationId, definition });
+        const payload = await platform.tenant('POST', project, '/bpm/definitions', { environment, body: { applicationId, definition } });
+        const saved = dataOf(payload);
+        return attachFindings(withUnmappedMembers(withWriteDiff(withNormalization(processOutline(saved), normalized), writeDiff(definition, saved.definition)), drift), findings);
+    }));
+    server.registerTool('process_definition_update', {
+        title: 'Süreç tanımını güncelle',
+        description: "Taslak sürümü tam gövdeyle günceller (definition = tanım modeli). Hedefli değişiklik için process_definition_patch tercih edin. Yayınlanmış tanımda slug değişmez. Tanım ve her düğüm 'description' taşır (BPM-002). İki dilli 'analysis' tanımda ve her düğümde zorunludur (BPM-023). " + constraintSummary('UpdateProcessDefinitionCommand'),
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, definition: definitionParam, policyOverride: policyOverrideParam },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, definition, policyOverride }) => {
+        const normalized = normalizeProcessDefinition(definition);
+        const findings = enforcePolicy(evaluatePolicy(config, policyRules, 'process', definition, { operation: 'update' }, policyOverride));
+        const payload = await platform.tenant('PUT', project, `/bpm/definitions/${id}`, { environment, body: { definition } });
+        const saved = dataOf(payload);
+        return attachFindings(withWriteDiff(withNormalization(processOutline(saved), normalized), writeDiff(definition, saved.definition)), findings);
+    }));
+    server.registerTool('process_definition_patch', {
+        title: "Süreç tanımına patch uygula",
+        description: "Tam gövdeyi bağlama almadan hedefli değişiklik: gateway okunan kaydın 'version'ını baseVersion olarak gönderir, platform seçicileri (/nodes[id=x]) çözer ve taslağa yazar; kayıt bu arada değiştiyse 409 döner ve hiçbir op uygulanmaz. Gateway yazmadan önce yamalanmış tanımı yerelde politika kontrolünden geçirir. Analizi olmayan eski bir tanım her yamada BPM-023'e takılır: eksik 'analysis' alanlarını aynı yamaya ekleyin. Yanıt { applied, newVersion, patchTargets, outline }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            operations: patchOperationsParam.optional(),
+            ops: patchOperationsParam.optional().describe("'operations' ile aynı alan (eşanlamlı)"),
+            policyOverride: policyOverrideParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, operations: givenOperations, ops, policyOverride }) => {
+        const operations = microOps('process_definition_patch', ops, givenOperations);
+        const current = dataOf(await platform.tenant('GET', project, `/bpm/definitions/${id}`, { environment }));
+        const model = structuredClone((current.definition ?? {}));
+        const notes = [];
+        try {
+            const resolved = resolvePatchOperations(model, operations, 'process_definition_get');
+            const patched = fastJsonPatch.applyPatch(model, resolved.operations, true, false).newDocument;
+            enforcePolicy(evaluatePolicy(config, policyRules, 'process', patched, { operation: 'update' }, policyOverride));
+        }
+        catch (error) {
+            if (error instanceof PolicyBlockError)
+                throw error;
+            notes.push(`yerel politika denetimi atlandı (yol yerelde çözülemedi: ${error instanceof Error ? error.message : String(error)}); platform doğrulaması yine çalışır`);
+        }
+        const saved = dataOf(await platform.tenant('PATCH', project, `/bpm/definitions/${id}`, {
+            environment,
+            body: { baseVersion: baseVersionOf(current, 'process_definition_get'), ops: operations }
+        }));
+        return withNormalization({
+            applied: saved.applied ?? operations.length,
+            newVersion: saved.newVersion ?? null,
+            patchTargets: saved.patchTargets ?? [],
+            outline: processOutline((saved.data ?? {}))
+        }, notes);
+    }));
+    server.registerTool('process_definition_delete', {
+        title: 'Süreç tanımını sil',
+        description: 'Süreç tanımını siler. Açık örneği (running, waiting-timer, suspended, faulted) olan tanım silinmez (422 ProcessOpen); önce process_instance_list ile kontrol edin.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/bpm/definitions/${id}`, { environment })));
+    server.registerTool('process_definition_clone', {
+        title: 'Süreç tanımını klonla',
+        description: 'Tanımın güncel modelinden yeni slug ile taslak kopya oluşturur.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, slug: z.string().min(1).max(100) },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, slug }) => processOutline(dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/clone`, { environment, body: { slug } })))));
+    server.registerTool('process_definition_preview', {
+        title: 'Süreç tanımını önizle',
+        description: "YAN ETKİSİZ: tanımı platform doğrulayıcısından geçirir (422 kodlarıyla aynı bulgular) ve id verilirse kuru koşu yapar — her insan adımında KİM görev alacak listesi (org ağacından çözülür, satır/bildirim/görev yazılmaz). Kaydedilmemiş gövde için definition verin; kayıtlı tanım için id (+ subjectRowId, vars, initiatorUserId). Yayından önce findings boş ve steps beklenen kişileri göstermeli. Transaction açmaz, geri alınacak yazma yoktur; kurallar platform_guide('bpm') §Simülasyon ve test.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional(),
+            applicationId: guid.optional(),
+            definition: definitionParam.optional(),
+            subjectRowId: z.string().max(64).optional(),
+            initiatorUserId: z.string().max(64).optional(),
+            vars: z.record(z.unknown()).optional()
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, applicationId, definition, subjectRowId, initiatorUserId, vars }) => {
+        if (!id && !definition)
+            throw new Error("process_definition_preview: 'id' ya da 'definition' verin.");
+        if (id && definition)
+            throw new Error("process_definition_preview: 'id' ve 'definition' birlikte verilmez — doğrulama kaydedilmemiş gövdeyi, kuru koşu kayıtlı modeli okur ve sonuçlar iki ayrı modele ait olur. Önce process_definition_update ile kaydedin, sonra yalnız id ile önizleyin.");
+        const normalized = definition ? normalizeProcessDefinition(definition) : [];
+        const validation = dataOf(await platform.tenant('POST', project, id ? `/bpm/definitions/${id}/validate` : '/bpm/definitions/validate', {
+            environment,
+            body: definition ? { applicationId, definition } : {}
+        }));
+        const simulation = id
+            ? dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/simulate`, { environment, body: { subjectRowId, initiatorUserId, vars } }))
+            : undefined;
+        return withNormalization({
+            findings: validation.findings ?? [],
+            isValid: validation.isValid ?? null,
+            steps: simulation?.steps ?? null,
+            note: id ? undefined : "Kuru koşu (kim yapar) yalnız kayıtlı tanımda çalışır; önce process_definition_create, sonra id ile preview."
+        }, normalized);
+    }));
+    server.registerTool('process_definition_publish', {
+        title: 'Süreç sürümünü yayınla',
+        description: "Taslak sürümü aktif yapar (önceki aktif 'retiring' olur; açık örnekler kendi sürümünde biter). reason verilirse yayın isteği açılır (POST publish-request): aktif sürüm ya da taslak publishPolicy: four-eyes ve ortamda process-publish süreci kuruluysa sürüm YAYINLANMAZ — { isPublished: false, request { id, state: pending, instanceId, changeCount } } döner, onay görevi tanım sahibine düşer, onaylanınca yayınlanır (ret rejected; taslak sonradan değişirse superseded). Onay gerekmiyorsa istek doğrudan yayınlar (isPublished: true). reason'sız çağrı onay gereken tanımda 403 PublishApprovalRequired alır. Gateway taslak sağlamasında yeşil koşmamış senaryoyu uyarır (BPM-015); requireGreenScenarios: true tanımda platform 422 ScenarioFailed döner — istek açılırken de. Yalnız isteyenden farklı kullanıcının onayı yayınlar. Yayın öncesi platform doğrulaması 422 ile durdurabilir. production hedefi istek gitmeden durur (BPM-001).",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, reason: z.string().min(1).max(1000).optional().describe('yayın gerekçesi; verilirse dört göz isteği açılır') },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, reason }) => {
+        assertProcessNotProduction('process_definition_publish', environment, config);
+        const findings = config.policyMode === 'off'
+            ? []
+            : await platform.tenant('GET', project, `/bpm/definitions/${id}`, { environment })
+                .then(async (current) => staleScenarioFindings(dataOf(current), dataOf(await platform.tenant('GET', project, '/bpm/test-scenarios', { environment, query: { definitionId: id } }))))
+                .then(staleFindings => applyPolicyMode(config, staleFindings), () => []);
+        if (!reason)
+            return attachFindings(processOutline(dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/versions`, { environment }))), findings);
+        const publishResult = dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/publish-request`, { environment, body: { reason } }));
+        const publishRequest = (publishResult.request ?? null);
+        return attachFindings({
+            isPublished: publishResult.isPublished === true,
+            request: publishRequest ? { id: publishRequest.id, state: publishRequest.state, instanceId: publishRequest.instanceId ?? null, versionNumber: publishRequest.versionNumber ?? null, changeCount: Array.isArray(publishRequest.changes) ? publishRequest.changes.length : 0 } : null,
+            note: publishResult.isPublished === true ? undefined : 'Onay bekliyor: onay görevi tanım sahibine düştü; process_task_list ile izleyin. Onay gelmeden sürüm aktif olmaz.',
+            outline: processOutline((publishResult.definition ?? {}))
+        }, findings);
+    }));
+    server.registerTool('process_override_get', {
+        title: 'Süreç uyarlamasını getir',
+        description: "Uygulama yöneticisinin ortam uyarlamasını getirir: aktif sürüm, overrideRevision, conflictState (conflicted ise conflictDetail — yeni sürüm uyarlanan bölgeyi kaldırdı ya da kilitledi, yeni örnekler varsayılanla başlar), patch, editableScopes (düğüm · derece · editableParams · limits) ve etkin tanımın outline'ı. view:'studio' salt okunur görünümdür (isReadOnly: true); output:'full' temel ve etkin modelin tam gövdesi. Kurallar platform_guide('bpm') §Uyarlama.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            view: z.enum(['admin', 'studio']).optional().describe('varsayılan admin'),
+            output: z.enum(['outline', 'full']).optional().describe('varsayılan outline'),
+            asUser: asUserParam,
+            asUserId: asUserIdBpmParam
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, view, output, asUser, asUserId }) => {
+        const payload = await platform.tenant('GET', project, `/bpm/definitions/${id}/override`, { environment, query: view ? { view } : undefined, headers: await bpmIdentityHeaders(platform, 'process_override_get', project, environment, { asUser, asUserId }) });
+        return output === 'full' ? payload : overrideOutline(dataOf(payload));
+    }));
+    server.registerTool('process_override_update', {
+        title: 'Süreç uyarlamasını yaz',
+        description: "Uyarlama yazımının tek kapısı: operation save (varsayılan; patch = JSON Patch, seçicili yollar '/nodes[id=bolge]/nodes/-'; mode append mevcut uyarlamanın sonuna ekler, replace tümünü değiştirir) | reset (varsayılana dön) | migrate-open (açık örnekleri güncel uyarlamaya taşı; açık düğümü etkin tanımda olmayan örnek atlanır). Gateway aktif sürüm ve revizyonu okuyup iyimser kilitle gönderir (409 → yeniden okuyun) ve istek gitmeden denetler: kilitli yol BPM-010, bölgenin izin vermediği atama kuralı BPM-011, bölge adım/tür sınırı BPM-012. asUser ZORUNLU (BPM-013); production hedefi durur (BPM-001). Yanıt applied op listesi + güncel uyarlama outline'ı.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            operation: z.enum(overrideOperations).optional().describe('varsayılan save'),
+            patch: patchOperationsParam.optional().describe("save için JSON Patch işlemleri, temel (aktif sürüm) modele göre; düğüm hedeflerken seçici: '/nodes[id=kontrol-bolgesi]/nodes/-'"),
+            mode: z.enum(['append', 'replace']).optional().describe('save için; varsayılan append (çatışmalı uyarlamada yalnız verilen işlemler yazılır)'),
+            policyOverride: policyOverrideParam,
+            asUser: asUserParam,
+            asUserId: asUserIdBpmParam
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, id, operation, patch, mode, policyOverride, asUser, asUserId }) => {
+        assertProcessNotProduction('process_override_update', environment, config);
+        if (!asUser && !asUserId) {
+            throw new PolicyBlockError([{
+                    ruleId: 'BPM-013',
+                    severity: 'block',
+                    message: "process_override_update kimliksiz gönderilmez: uyarlama uygulama yöneticisi adına yazılır, Studio jetonu 403 alır. İki yol var — development'ta parolasız 'asUserId' (users satır id'si) ya da 'asUser' (access_session_create tokenRefs'teki tok_… değeri).",
+                    guide: 'ngapps://guides/bpm'
+                }]);
+        }
+        const headers = await bpmIdentityHeaders(platform, 'process_override_update', project, environment, { asUser, asUserId });
+        if (operation === 'reset')
+            return overrideOutline(dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/override/reset`, { environment, headers })));
+        if (operation === 'migrate-open')
+            return dataOf(await platform.tenant('POST', project, `/bpm/definitions/${id}/override/migrate-open`, { environment, headers }));
+        if (!patch)
+            throw new Error("process_override_update: operation save için 'patch' zorunlu.");
+        const view = dataOf(await platform.tenant('GET', project, `/bpm/definitions/${id}/override`, { environment, headers }));
+        const currentOverride = (view.override ?? null);
+        const isConflicted = currentOverride?.conflictState === 'conflicted';
+        const basePatch = mode === 'replace' || isConflicted ? [] : (currentOverride?.patch ?? []);
+        const fullPatch = [...basePatch, ...patch];
+        const { findings, notes } = config.policyMode === 'off' ? { findings: [], notes: [] } : overridePatchFindings((view.baseModel ?? {}), fullPatch);
+        const policyFindings = enforcePolicy(applyPolicyMode(config, findings, policyOverride));
+        if (isConflicted && mode !== 'replace')
+            notes.push('mevcut uyarlama çatışmalı (conflicted) olduğu için eklenmedi; yalnız verilen işlemler yazıldı');
+        const saved = dataOf(await platform.tenant('PUT', project, `/bpm/definitions/${id}/override`, {
+            environment,
+            headers,
+            body: { baseVersion: view.activeVersionNumber, overrideRevision: view.overrideRevision ?? 0, patch: fullPatch }
+        }));
+        return attachFindings(withNormalization({ applied: patch.map(entry => `${String(entry.op)} ${String(entry.path)}`), ...overrideOutline(saved) }, notes), policyFindings);
+    }));
+    server.registerTool('process_step_schema', {
+        title: 'Süreç düğüm şeması',
+        description: "Düğüm türlerinin alanlarını, zorunlularını ve örneğini döner (start, user-task, approval, service, notify, gateway, timer, wait, send, manual, script, sub-process, region, end). Düğüm yazarken tahmin yerine buradan okuyun.",
+        inputSchema: { type: z.string().optional().describe('tek tür; boşsa hepsi') },
+        annotations: readOnly
+    }, handle(config, async ({ type }) => {
+        if (!type)
+            return { nodeTypes: processNodeSchemas.map(schema => ({ type: schema.type, purpose: schema.purpose, required: schema.required })) };
+        const schema = processNodeSchemas.find(candidate => candidate.type === type);
+        if (!schema)
+            throw new Error(`Bilinmeyen düğüm türü '${type}'. Türler: ${processNodeSchemas.map(candidate => candidate.type).join(', ')}.`);
+        return schema;
+    }));
+}