@appaflytech/zeyrek-ai-mcp 0.0.28 → 0.0.30

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;
+    }));
+}

package/dist/tools/bpmGovernance.js

@@ -0,0 +1,266 @@
+import { guid, projectParam, environmentParam, languageParam, readOnly, writes, updates, destructive } from './common.js';
+import { attachFindings, applyPolicyMode } from '../knowledge/policy.js';
+import { assertProcessNotProduction, dataOf } from './bpm.js';
+import { bpmnExtensionFindings } from '../knowledge/process.js';
+import { processOutline } from '../knowledge/outlines.js';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { normalizeLanguageCode } from '../knowledge/languageCodes.js';
+import { withNormalization } from '../knowledge/normalize.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { handle } from '../platform/responses.js';
+import { dirname, resolve } from 'node:path';
+import { z } from 'zod';
+const maxInlineBytes = 256_000;
+const maxBpmnBytes = 5_000_000;
+const scenarioActions = ['task', 'clock', 'signal', 'message', 'subProcess'];
+const isoDurationPattern = /^P(?!$)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/;
+const versionParam = z.number().int().min(1).optional();
+const outPathParam = z.string().min(1).optional()
+    .describe('verilirse içerik bu yerel yola yazılır ve yanıt yalnız özet döner (256 KB üstü içerik için zorunlu)');
+const scenarioGivenParam = z.object({
+    subjectRowId: z.string().max(64),
+    initiatorUserId: z.string().max(64),
+    vars: z.record(z.unknown())
+}).partial().optional().describe('başlangıç: konu satırı, başlatan kullanıcı, değişkenler (parametre varsayılanlarının üstüne yazılır)');
+const scenarioStepsParam = z.array(z.object({
+    task: z.string().max(100),
+    as: z.string().max(100),
+    action: z.string().max(50),
+    outcome: z.string().max(100),
+    comment: z.string().max(2000),
+    form: z.record(z.unknown()),
+    clock: z.string().max(40),
+    signal: z.string().max(200),
+    message: z.string().max(200),
+    correlationKey: z.string().max(200),
+    payload: z.record(z.unknown()),
+    subProcess: z.string().max(100)
+}).partial()).max(200).optional()
+    .describe("adımlar sırayla; her adım TAM OLARAK BİR eylem: { task: '<düğüm>', as: 'user:<id>', action: 'approve' | 'reject' | 'complete' | 'sign' | 'request-info' | 'provide-info' | '<eylem>', form?, comment? } (görev verisi form'dadır; request-info'da comment soru, provide-info'da başlatanın yanıtı) · { clock: 'P3D' } (vadesi gelen zamanlayıcılar ateşlenir) · { signal, payload } ({ signal: 'withdraw', as: 'user:<başlatan>' } withdrawPolicy'ye göre geri çeker) · { message, correlationKey, payload } · { subProcess: '<düğüm>', outcome }. signature TAŞIYAN düğümde 'approve'/'complete' adımı 422 SignatureRequired ile düşer — o adımı 'sign' ile yazın (senaryo parola istemez, defterine TaskSigned yazar; ret ve çekimser imzasız geçer)");
+const scenarioExpectParam = z.object({
+    path: z.array(z.string().max(100)).max(500),
+    assignees: z.record(z.array(z.string().max(100)).max(50)),
+    outcome: z.string().max(100),
+    state: z.string().max(40),
+    vars: z.record(z.unknown()),
+    writeBack: z.record(z.unknown())
+}).partial().optional()
+    .describe('beklenenler (yazılmayan denetlenmez): path girilen düğüm dizisi birebir · assignees düğüm → kullanıcılar (alt küme) · outcome · state · vars (nokta yolu) · writeBack (satıra yazılacak değerler; koşuda satıra yazılmaz)');
+export async function writeLocalFile(tool, path, content) {
+    const absolute = resolve(path);
+    try {
+        await mkdir(dirname(absolute), { recursive: true });
+        await writeFile(absolute, content, 'utf8');
+    }
+    catch (error) {
+        throw new PlatformApiError(`${tool}: dosya yazılamadı — ${absolute} (${error instanceof Error ? error.message : String(error)}). Yol gateway sürecinin çalıştığı makineye göre çözülür.`);
+    }
+    return absolute;
+}
+export function assertInline(tool, config, payload) {
+    const size = Buffer.byteLength(JSON.stringify(payload), 'utf8');
+    if (size > Math.min(maxInlineBytes, config.maxResponseBytes)) {
+        throw new PlatformApiError(`${tool}: yanıt ${size} B, satır içi sınır ${Math.min(maxInlineBytes, config.maxResponseBytes)} B (MAX_RESPONSE_BYTES); içerik kırpılmasın diye outPath verin.`, 413);
+    }
+}
+function languageQuery(language) {
+    if (!language)
+        return { language: undefined, notes: [] };
+    const normalized = normalizeLanguageCode(language, 'language');
+    return { language: normalized.code, notes: normalized.note ? [normalized.note] : [] };
+}
+function warnings(config, findings) {
+    return config.policyMode === 'off' ? [] : applyPolicyMode(config, findings);
+}
+function assertScenarioSteps(tool, steps) {
+    for (const [index, step] of (steps ?? []).entries()) {
+        const actions = scenarioActions.filter(action => typeof step[action] === 'string' && step[action].trim() !== '');
+        if (actions.length !== 1) {
+            throw new PlatformApiError(`${tool}: steps[${index}] tam olarak bir eylem taşımalı (${scenarioActions.join(' | ')}); bulunan: ${actions.length === 0 ? 'yok' : actions.join(', ')} (istek gönderilmedi).`, 400);
+        }
+        if (typeof step.clock === 'string' && !isoDurationPattern.test(step.clock)) {
+            throw new PlatformApiError(`${tool}: steps[${index}].clock ISO 8601 süresi olmalı (ör. P3D, PT4H) (istek gönderilmedi).`, 400);
+        }
+        if (typeof step.task === 'string' && step.payload !== undefined) {
+            throw new PlatformApiError(`${tool}: steps[${index}].payload görev adımında okunmaz — görevin verisi (ör. sipariş no) 'form' alanıyla gider; payload yalnız signal/message adımında kullanılır (istek gönderilmedi).`, 400);
+        }
+    }
+}
+export function registerBpmGovernanceTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('process_definition_diff', {
+        title: 'Süreç sürümlerini karşılaştır',
+        description: "İki sürüm arasındaki anlamsal farkı okunur satırlarla döner (GET bpm/definitions/{id}/diff): kind (node-added · node-removed · assignee-changed · policy-changed · sla-changed · node-changed · editable-changed · edge-added · edge-removed · edge-condition-changed · param-added · param-removed · param-default-changed · param-type-changed · process-changed), path (/nodes[id=x]/alan), before/after, text ve isOverrideRisk (yöneticinin uyarlamasını bozabilecek değişiklik). to verilmezse taslak (yoksa son sürüm), from verilmezse aktif sürüm. Yayından önce okuyun; hasOverrideRisk true ise process_override_get ile uyarlamayı kontrol edin.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, from: versionParam, to: versionParam, language: languageParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, from, to, language }) => {
+        const requested = languageQuery(language);
+        return withNormalization(await platform.tenant('GET', project, `/bpm/definitions/${id}/diff`, { environment, query: { from, to, language: requested.language } }), requested.notes);
+    }));
+    server.registerTool('process_documentation_get', {
+        title: 'Süreç dokümantasyonunu (SOP) getir',
+        description: "Tanımın SOP dokümanını HTML olarak üretir (GET bpm/definitions/{id}/documentation): başlık ve sürüm damgası, sahip ve RACI, kulvarlar (atama kuralına göre), adım tablosu (SLA, politika), parametreler, gömülü SVG diyagram. version verilmezse aktif (yoksa taslak). PDF henüz yok (b-82). 256 KB üstü HTML için outPath verin.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, version: versionParam, language: languageParam, outPath: outPathParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, version, language, outPath }) => {
+        const requested = languageQuery(language);
+        const payload = await platform.tenant('GET', project, `/bpm/definitions/${id}/documentation`, { environment, query: { version, language: requested.language, format: 'html' }, expectBinary: true });
+        const html = payload.bytes.toString('utf8').replace(/^\uFEFF/, '');
+        if (outPath)
+            return withNormalization({ format: 'html', sizeBytes: payload.bytes.byteLength, path: await writeLocalFile('process_documentation_get', outPath, html) }, requested.notes);
+        const inline = { format: 'html', sizeBytes: payload.bytes.byteLength, html };
+        assertInline('process_documentation_get', config, inline);
+        return withNormalization(inline, requested.notes);
+    }));
+    server.registerTool('process_bpmn_get', {
+        title: 'Süreci BPMN 2.0 XML olarak dışa aktar',
+        description: "Tanımın bir sürümünü BPMN 2.0 XML'e çevirir (GET bpm/definitions/{id}/bpmn): düğüm ve süreç alanları zeyrek: uzantısında, diyagram (DI) saklıysa korunur, yoksa ızgara yerleşimle üretilir; tanınmayan içe aktarılmış öğeler (şerit, not, veri nesnesi) yerine yazılır. version verilmezse taslak (yoksa aktif). Yanıt { versionNumber, versionState, sizeBytes, xml }; 256 KB üstü için outPath verin. Başka modelleyicide açılabilir; geri almak için process_bpmn_update.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, version: versionParam, outPath: outPathParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, id, version, outPath }) => {
+        const response = await platform.tenantWithHeaders('GET', project, `/bpm/definitions/${id}/bpmn`, { environment, query: { version }, expectBinary: true });
+        const payload = response.body;
+        const xml = payload.bytes.toString('utf8').replace(/^\uFEFF/, '');
+        const summary = {
+            definitionId: id,
+            versionNumber: Number(response.headers['x-definition-version']) || null,
+            versionState: response.headers['x-definition-version-state'] ?? null,
+            sizeBytes: payload.bytes.byteLength
+        };
+        if (outPath)
+            return { ...summary, path: await writeLocalFile('process_bpmn_get', outPath, xml) };
+        const inline = { ...summary, xml };
+        assertInline('process_bpmn_get', config, inline);
+        return inline;
+    }));
+    server.registerTool('process_bpmn_update', {
+        title: 'Taslağı BPMN 2.0 XML ile değiştir',
+        description: "BPMN 2.0 XML'i içe aktarıp tanımın TASLAĞINA yazar (PUT bpm/definitions/{id}/bpmn; yeni tanım için process_definition_create { bpmn }). xml (≤ 256 KB) ya da filePath (≤ 5 MB) — biri. zeyrek: uzantılı XML (process_bpmn_get çıktısı) kayıpsız döner; uzantısız XML'de düğümler öğe türünden türetilir, derece locked, insan adımının ataması yer tutucu 'initiator', SLA boş (BPM-016 uyarısı); workflow'suz serviceTask 422. Diyagram ve tanınmayan öğeler saklanır. DTD/dış varlık içeren XML 400; doğrulama hataları 422 DefinitionInvalid. Yanıt outline.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            xml: z.string().min(1).max(maxInlineBytes).optional(),
+            filePath: z.string().min(1).optional().describe('yerel .bpmn dosyası')
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, xml, filePath }) => {
+        if (Boolean(xml) === Boolean(filePath))
+            throw new PlatformApiError("process_bpmn_update: 'xml' ya da 'filePath' — yalnız biri (istek gönderilmedi).", 400);
+        let content = xml ?? '';
+        if (filePath) {
+            try {
+                content = await readFile(resolve(filePath), 'utf8');
+            }
+            catch (error) {
+                throw new PlatformApiError(`process_bpmn_update: dosya okunamadı — ${resolve(filePath)} (${error instanceof Error ? error.message : String(error)}). Yol gateway sürecinin çalıştığı makineye göre çözülür (istek gönderilmedi).`, 400);
+            }
+        }
+        content = content.replace(/^\uFEFF/, '');
+        if (Buffer.byteLength(content, 'utf8') > maxBpmnBytes)
+            throw new PlatformApiError(`process_bpmn_update: XML en çok ${maxBpmnBytes} B (istek gönderilmedi).`, 413);
+        const findings = warnings(config, bpmnExtensionFindings(content));
+        const saved = dataOf(await platform.tenant('PUT', project, `/bpm/definitions/${id}/bpmn`, { environment, body: { xml: content } }));
+        return attachFindings(processOutline(saved), findings);
+    }));
+    server.registerTool('process_comment_list', {
+        title: 'Model yorumlarını listele',
+        description: 'Tanıma bırakılmış tasarım yorumlarını listeler (GET bpm/definitions/{id}/comments): nodeId (boşsa genel), versionNumber (yazıldığı taslak), body, authorUserId, postedAt, resolvedBy/At. Çözülmüşler için includeResolved: true. Süreç örneğinin yorumları değildir (onlar process_instance_get).',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, includeResolved: z.boolean().optional() },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id, includeResolved }) => platform.tenant('GET', project, `/bpm/definitions/${id}/comments`, { environment, query: { includeResolved } })));
+    server.registerTool('process_comment_create', {
+        title: 'Model yorumu yaz',
+        description: 'Tanıma ya da bir düğümüne tasarım yorumu bırakır (POST bpm/definitions/{id}/comments); yorum güncel taslak (yoksa son) sürüme sabitlenir. nodeId tanımda olmalı (400). Yetki process.manage.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, nodeId: z.string().max(100).optional(), body: z.string().min(1).max(4000) },
+        annotations: writes
+    }, handle(config, ({ project, environment, id, nodeId, body }) => platform.tenant('POST', project, `/bpm/definitions/${id}/comments`, { environment, body: { nodeId, body } })));
+    server.registerTool('process_comment_update', {
+        title: 'Model yorumunu çöz ya da yeniden aç',
+        description: 'Model yorumunu çözülmüş işaretler (resolved: true) ya da yeniden açar (resolved: false) (POST bpm/definitions/{id}/comments/{commentId}/resolve). Silme bu araçta yok: yorumu yalnız yazan Studio\'dan siler.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, commentId: guid, resolved: z.boolean() },
+        annotations: updates
+    }, handle(config, ({ project, environment, id, commentId, resolved }) => platform.tenant('POST', project, `/bpm/definitions/${id}/comments/${commentId}/resolve`, { environment, body: { resolved } })));
+    server.registerTool('process_scenario_list', {
+        title: 'Süreç test senaryolarını listele',
+        description: "Tanımın test senaryolarını ve son koşularını listeler (GET bpm/test-scenarios?definitionId): given, stubs, steps, expect, lastRunVersionNumber, lastRunChecksum, lastRunPassed, lastRunDivergence. view:'coverage' kayıtlı son koşulardan yol kapsamasını döner (GET bpm/definitions/{id}/coverage): nodePercent, edgePercent, untestedNodeIds, untestedEdgeKeys ('from->to' — hiç test edilmeyen dal); yalnız son koşusu o sürümün sağlamasıyla yapılmış senaryolar sayılır. version verilmezse taslak, yoksa aktif.",
+        inputSchema: { project: projectParam, environment: environmentParam, definitionId: guid, view: z.enum(['list', 'coverage']).optional().describe('varsayılan list'), version: versionParam.describe("yalnız view:'coverage'") },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, definitionId, view, version }) => view === 'coverage'
+        ? platform.tenant('GET', project, `/bpm/definitions/${definitionId}/coverage`, { environment, query: { version } })
+        : platform.tenant('GET', project, '/bpm/test-scenarios', { environment, query: { definitionId } })));
+    server.registerTool('process_scenario_create', {
+        title: 'Süreç test senaryosu oluştur',
+        description: "Test senaryosu yazar. fromInstanceId: gerçek örneğin defterinden kaydeder (POST bpm/instances/{id}/record-scenario) — insan kararları, zaman atlamaları, sinyal/mesaj/alt süreç sonuçları adım; servis çıktıları stub; girilen düğümler, atananlar, sonuç ve durum beklenen olur. definitionId: senaryoyu elle yazar (POST bpm/test-scenarios). Oynatma gerçek motorla yan etkisiz koşar: writeBack satıra yazılmaz, bildirim/webhook gitmez, service düğümü workflow çağırmaz — stubs anahtarı workflowSlug → workflowId → düğüm id sırasıyla aranır, stub yoksa örnek faulted. Koşu process_scenario_execute. Kurallar platform_guide('bpm') §Simülasyon ve test.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            definitionId: guid.optional(),
+            fromInstanceId: guid.optional(),
+            name: z.string().min(1).max(200),
+            description: z.string().max(2000).optional(),
+            given: scenarioGivenParam,
+            stubs: z.record(z.unknown()).optional().describe("servis düğümü çıktıları: { '<workflowSlug>': { … } }"),
+            steps: scenarioStepsParam,
+            expect: scenarioExpectParam
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, definitionId, fromInstanceId, name, description, given, stubs, steps, expect }) => {
+        if (Boolean(definitionId) === Boolean(fromInstanceId))
+            throw new PlatformApiError("process_scenario_create: 'definitionId' (elle) ya da 'fromInstanceId' (kayıt) — yalnız biri (istek gönderilmedi).", 400);
+        if (fromInstanceId) {
+            if (description !== undefined || given || stubs || steps || expect)
+                throw new PlatformApiError('process_scenario_create: kayıt (fromInstanceId) yalnız name alır; senaryoyu kayıttan sonra process_scenario_update ile düzenleyin (istek gönderilmedi).', 400);
+            return platform.tenant('POST', project, `/bpm/instances/${fromInstanceId}/record-scenario`, { environment, body: { name } });
+        }
+        assertScenarioSteps('process_scenario_create', steps);
+        return platform.tenant('POST', project, '/bpm/test-scenarios', { environment, body: { definitionId, name, description, given, stubs, steps, expect } });
+    }));
+    server.registerTool('process_scenario_update', {
+        title: 'Süreç test senaryosunu güncelle',
+        description: 'Senaryoyu günceller (PUT bpm/test-scenarios/{id}); verilmeyen alanlar güncel senaryodan alınır (gateway önce okur). Düzenleme son koşu sonucunu siler — yeşil sayılması için yeniden koşun.',
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            name: z.string().min(1).max(200).optional(),
+            description: z.string().max(2000).nullable().optional(),
+            given: scenarioGivenParam,
+            stubs: z.record(z.unknown()).optional(),
+            steps: scenarioStepsParam,
+            expect: scenarioExpectParam
+        },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id, name, description, given, stubs, steps, expect }) => {
+        assertScenarioSteps('process_scenario_update', steps);
+        const current = dataOf(await platform.tenant('GET', project, `/bpm/test-scenarios/${id}`, { environment }));
+        return platform.tenant('PUT', project, `/bpm/test-scenarios/${id}`, {
+            environment,
+            body: {
+                name: name ?? current.name,
+                description: description !== undefined ? description : current.description,
+                given: given ?? current.given,
+                stubs: stubs ?? current.stubs,
+                steps: steps ?? current.steps,
+                expect: expect ?? current.expect
+            }
+        });
+    }));
+    server.registerTool('process_scenario_delete', {
+        title: 'Süreç test senaryosunu sil',
+        description: 'Senaryoyu siler (DELETE bpm/test-scenarios/{id}). Tanım requireGreenScenarios: true ise yayın kapısı kalan senaryolara bakar.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => platform.tenant('DELETE', project, `/bpm/test-scenarios/${id}`, { environment })));
+    server.registerTool('process_scenario_execute', {
+        title: 'Süreç test senaryolarını koş',
+        description: "Senaryoları gerçek motorla YAN ETKİSİZ koşar (her senaryo ayrı savepoint; biri istisna atarsa o senaryo error sapması olur, diğerleri koşar) ve son koşu sonucunu kaydeder. Yetki process.manage: definitionId tanımın bütün senaryoları (POST bpm/definitions/{id}/run-scenarios), id tek senaryo (POST bpm/test-scenarios/{id}/run). version verilmezse taslak, yoksa aktif — eski senaryoları yeni taslakta koşmak sürüm regresyonudur. Yanıt { versionNumber, passed, passedCount, failedCount, results[] { name, passed, divergence { kind: step | error | path | assignee | outcome | state | vars | write-back, nodeId, stepIndex, expected, actual, message }, path, state, outcome }, coverage }. Tanımda requireGreenScenarios: true iken taslak sağlamasında yeşil olmayan senaryo yayını 422 ScenarioFailed ile durdurur. production hedefi istek gitmeden durur (BPM-001).",
+        inputSchema: { project: projectParam, environment: environmentParam, definitionId: guid.optional(), id: guid.optional().describe('tek senaryo'), version: versionParam },
+        annotations: writes
+    }, handle(config, async ({ project, environment, definitionId, id, version }) => {
+        if (Boolean(definitionId) === Boolean(id))
+            throw new PlatformApiError("process_scenario_execute: 'definitionId' (bütün senaryolar) ya da 'id' (tek senaryo) — yalnız biri (istek gönderilmedi).", 400);
+        assertProcessNotProduction('process_scenario_execute', environment, config);
+        return dataOf(await platform.tenant('POST', project, id ? `/bpm/test-scenarios/${id}/run` : `/bpm/definitions/${definitionId}/run-scenarios`, { environment, query: { version } }));
+    }));
+}