@appaflytech/zeyrek-ai-mcp 0.0.28 → 0.0.30

package/dist/tools/bpmOperations.js

@@ -0,0 +1,230 @@
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { identityHeaders } from '../platform/tokenVault.js';
+import { PolicyBlockError } from '../knowledge/policy.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { assertProcessNotProduction } from './bpm.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const workingDays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+const timeOfDay = z.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).describe("'08:00' ya da '08:00:00'");
+const asUserParam = z.string().min(1).optional()
+    .describe("Uygulama kullanıcısının kimliği (ham JWT ya da tok_… referansı). Vekaleti kendisi için açan kişi bu kullanıcıdır; verilmezse gateway'in Studio kullanıcısı adına gider.");
+const holidayDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+const holiday = z.union([
+    holidayDate,
+    z.object({
+        date: holidayDate,
+        name: z.string().max(100).optional(),
+        workEnd: timeOfDay.optional().describe("yarım gün: iş bu saatte biter ('13:00'); verilmezse gün tam tatildir")
+    })
+]);
+const calendarBody = {
+    code: z.string().min(1).max(100).describe("kebab-case; 'default' kurum takvimidir"),
+    organizationUnitId: guid.optional().describe('Birim takvimi; aynı birimdeki SLA hesapları bu takvimi kullanır'),
+    workingDays: z.array(z.enum(workingDays)).min(1),
+    workStart: timeOfDay,
+    workEnd: timeOfDay,
+    holidays: z.array(holiday).max(1000).optional().describe("'2026-10-29' (tam gün) ya da { date: '2026-10-28', name: 'Cumhuriyet Bayramı arifesi', workEnd: '13:00' } (yarım gün); bir tarih yalnız bir kez"),
+    timeZone: z.string().min(1).max(100).describe("IANA adı, ör. 'Europe/Istanbul'")
+};
+/** Dates become the holiday objects the backend stores, a half day's end gets its seconds; a date given twice stops the call */
+function holidayBodies(tool, holidays) {
+    if (!holidays)
+        return undefined;
+    const bodies = holidays.map(item => typeof item === 'string'
+        ? { date: item }
+        : { date: item.date, name: item.name, workEnd: item.workEnd ? toSeconds(item.workEnd) : undefined });
+    const dates = bodies.map(body => body.date);
+    const repeated = dates.find((date, index) => dates.indexOf(date) !== index);
+    if (repeated)
+        throw new PlatformApiError(`${tool}: ${repeated} tatillerde iki kez var — bir tarih takvimde yalnız bir kez yer alır; birini çıkarın (istek gönderilmedi).`, 400);
+    return bodies;
+}
+/** Backend Delegation.Overlaps: same principal, intersecting ranges (open end = forever) and processes (empty = all) */
+function overlapsDelegation(row, fromUserId, startsAt, endsAt, processSlugs) {
+    if (row.endedAt || row.fromUserId !== fromUserId)
+        return false;
+    const rowStart = row.startsAt ? Date.parse(row.startsAt) : Number.NEGATIVE_INFINITY;
+    const rowEnd = row.endsAt ? Date.parse(row.endsAt) : Number.POSITIVE_INFINITY;
+    const start = Date.parse(startsAt);
+    const end = endsAt ? Date.parse(endsAt) : Number.POSITIVE_INFINITY;
+    const rowSlugs = row.processSlugs ?? [];
+    return rowStart < end && start < rowEnd && (rowSlugs.length === 0 || processSlugs.length === 0 || rowSlugs.some(slug => processSlugs.includes(slug)));
+}
+function toSeconds(value) {
+    return /^\d{2}:\d{2}$/.test(value) ? `${value}:00` : value;
+}
+export function registerBpmOperationsTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('process_calendar_list', {
+        title: 'İş takvimlerini listele',
+        description: 'SLA ve süre hesaplarında kullanılan iş takvimlerini listeler (çalışma günleri, saatleri, tatiller { date, name, workEnd }, saat dilimi). workEnd olan tatil yarım gündür: o gün iş workEnd\'de biter ve süre o saate kadar sayılır. Tanımsız projede yerleşik Pzt–Cum 08:00–18:00 kullanılır.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/calendars', { environment })));
+    server.registerTool('process_calendar_create', {
+        title: 'İş takvimi oluştur',
+        description: "İş takvimi oluşturur. SLA sayacı 'calendar' kodu, sonra örneğin birimi, sonra 'default' kodlu takvimle hesaplanır. Aynı kod 409 döner. Yetki process.manage.",
+        inputSchema: { project: projectParam, environment: environmentParam, ...calendarBody },
+        annotations: writes
+    }, handle(config, async ({ project, environment, workStart, workEnd, holidays, ...body }) => {
+        assertProcessNotProduction('process_calendar_create', environment, config);
+        return platform.tenant('POST', project, '/bpm/calendars', { environment, body: { ...body, workStart: toSeconds(workStart), workEnd: toSeconds(workEnd), holidays: holidayBodies('process_calendar_create', holidays) } });
+    }));
+    server.registerTool('process_calendar_update', {
+        title: 'İş takvimini güncelle',
+        description: "İş takvimini tümüyle değiştirir (tam gövde; kayıtta code, workingDays, workStart, workEnd ve timeZone zorunlu). Yeni takvim yalnız bundan sonra kurulan sayaçlara uygulanır; kurulmuş timer vadeleri değişmez. remove:true yalnız id ile takvimi siler: bir süreç düğümü ya da SLA sayacı takvime işaret ediyorsa 422 ReferencedByProcess döner. 'default' kodlu ya da birime bağlı takvime tanım referans vermez; silinince SLA zinciri (kod → birim → default → yerleşik Pzt–Cum 08–18) sonraki halkaya düşer.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid,
+            remove: z.boolean().optional(),
+            ...calendarBody,
+            code: calendarBody.code.optional(),
+            workingDays: calendarBody.workingDays.optional(),
+            workStart: timeOfDay.optional(),
+            workEnd: timeOfDay.optional(),
+            timeZone: calendarBody.timeZone.optional()
+        },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id, remove, workStart, workEnd, holidays, ...body }) => {
+        assertProcessNotProduction('process_calendar_update', environment, config);
+        if (remove)
+            return platform.tenant('DELETE', project, `/bpm/calendars/${id}`, { environment });
+        const missing = [['code', body.code], ['workingDays', body.workingDays], ['workStart', workStart], ['workEnd', workEnd], ['timeZone', body.timeZone]]
+            .filter(([, value]) => value === undefined || value === '')
+            .map(([field]) => field);
+        if (missing.length)
+            throw new PlatformApiError(`process_calendar_update: tam gövde için ${missing.join(', ')} zorunlu — önce process_calendar_list ile takvimi okuyun (istek gönderilmedi).`, 400);
+        return platform.tenant('PUT', project, `/bpm/calendars/${id}`, { environment, body: { ...body, workStart: toSeconds(workStart), workEnd: toSeconds(workEnd), holidays: holidayBodies('process_calendar_update', holidays) } });
+    }));
+    server.registerTool('process_delegation_list', {
+        title: 'Vekaletleri listele',
+        description: 'Kullanıcının verdiği ve aldığı vekaletleri listeler. userId verilmezse asUser (ya da gateway kullanıcısı); başkasınınkini görmek birim yöneticiliği ya da process.manage ister.',
+        inputSchema: { project: projectParam, environment: environmentParam, userId: z.string().max(64).optional(), asUser: asUserParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, userId, asUser }) => platform.tenant('GET', project, '/bpm/delegations', { environment, query: userId ? { userId } : undefined, headers: identityHeaders(asUser, undefined, undefined) })));
+    server.registerTool('process_delegation_create', {
+        title: 'Vekalet aç',
+        description: "Tarih aralıklı görev vekaleti açar: aralıkta asıl kişiye düşecek yeni görevler vekile gider (görevde principalUserId asıl kalır), aralık öncesinden açık görevleri vekil 'delegated' sekmesinde görür ve tamamlayabilir. onBehalfOf verilirse başkası adına açılır (birim/üst birim yöneticisi ya da process.manage; kaynak 'manager'). processSlugs boşsa tüm süreçler. Vekil process.manage devralmaz, zincir yok: vekilin kendisi kesişen tarih aralığında ve kesişen süreçlerde (boş liste = tümü) kendi görevlerini devretmişse BPM-008 ile istek gitmez; çağıranın vekilin vekaletlerini okuma yetkisi yoksa ön denetim atlanır ve sunucu 422 DelegationChainNotAllowed döner. Çakışan vekalet 409.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            toUserId: z.string().min(1).max(64),
+            onBehalfOf: z.string().max(64).optional().describe('asıl kişi (fromUserId); verilmezse çağıran kişi'),
+            startsAt: z.string().datetime({ offset: true }),
+            endsAt: z.string().datetime({ offset: true }).optional(),
+            processSlugs: z.array(z.string().min(1).max(100)).optional(),
+            reason: z.string().max(1000).optional(),
+            asUser: asUserParam
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, toUserId, onBehalfOf, startsAt, endsAt, processSlugs, reason, asUser }) => {
+        assertProcessNotProduction('process_delegation_create', environment, config);
+        const headers = identityHeaders(asUser, undefined, undefined);
+        let existing;
+        try {
+            existing = await platform.tenant('GET', project, '/bpm/delegations', { environment, query: { userId: toUserId }, headers });
+        }
+        catch (error) {
+            if (!(error instanceof PlatformApiError && error.status === 403))
+                throw error;
+        }
+        if ((existing?.data ?? []).some(delegation => overlapsDelegation(delegation, toUserId, startsAt, endsAt, processSlugs ?? []))) {
+            throw new PolicyBlockError([{
+                    ruleId: 'BPM-008',
+                    severity: 'block',
+                    message: `process_delegation_create: vekil '${toUserId}' aynı tarih aralığında ve süreçlerde kendi görevlerini başkasına devretmiş. Vekalet zincirlenemez — başka bir vekil seçin, aralığı ya da süreçleri değiştirin veya o vekaleti process_delegation_delete ile bitirin.`,
+                    guide: 'ngapps://guides/bpm'
+                }]);
+        }
+        return platform.tenant('POST', project, '/bpm/delegations', {
+            environment,
+            body: { fromUserId: onBehalfOf, toUserId, startsAt, endsAt, processSlugs, reason },
+            headers
+        });
+    }));
+    server.registerTool('process_delegation_delete', {
+        title: 'Vekaleti bitir',
+        description: 'Vekaleti şimdi bitirir (kayıt silinmez, endedAt yazılır; geçmiş görevlerde principalUserId kalır). Bitişten sonra yeni görevler asıla gider; vekilin başlattığı görevler vekilde biter.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, asUser: asUserParam },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id, asUser }) => {
+        assertProcessNotProduction('process_delegation_delete', environment, config);
+        return platform.tenant('POST', project, `/bpm/delegations/${id}/end`, { environment, headers: identityHeaders(asUser, undefined, undefined) });
+    }));
+    server.registerTool('process_handover_preview', {
+        title: 'Devir önizlemesi',
+        description: "YAN ETKİSİZ okuma — ayrılan/uzun süre yok olacak kullanıcının üzerindeki iş: assigned-tasks ve candidate-tasks (süreç başına sayı + önerilen hedef), started-instances, managed-units, held-positions, delegations. process_handover_create kararları bu kalemlerin kind/key değerleriyle verilir. Yetki process.manage.",
+        inputSchema: { project: projectParam, environment: environmentParam, userId: z.string().min(1).max(64) },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, userId }) => platform.tenant('GET', project, `/bpm/handovers/preview/${encodeURIComponent(userId)}`, { environment })));
+    server.registerTool('process_handover_create', {
+        title: 'Devri uygula',
+        description: "Devir kararlarını uygular. decisions[]: { kind: assigned-tasks | candidate-tasks, key: süreç slug'ı, target: manager | user | group | admin-queue, targetUserId (user için) }. force:false iken kararı olmayan grup 422 HandoverIncomplete; force:true iken kararı olmayan assigned-tasks grubu yöneticiye (yoksa admin-queue), candidate-tasks grubu gruba gider (kişi adaylıktan çıkar; aday kalmazsa admin-queue). Açık vekaletler biter; pozisyon devri önizlemedeki held-positions kalemiyle organizasyon ucundan yapılır. Açık görevi olan kullanıcıyı pasifleştirmeden önce bu devir tamamlanmalıdır (OpenTasksExist).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            userId: z.string().min(1).max(64),
+            decisions: z.array(z.object({
+                kind: z.enum(['assigned-tasks', 'candidate-tasks']),
+                key: z.string().min(1).max(100),
+                target: z.enum(['manager', 'user', 'group', 'admin-queue']),
+                targetUserId: z.string().max(64).optional()
+            })).optional(),
+            force: z.boolean().optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, userId, decisions, force }) => {
+        assertProcessNotProduction('process_handover_create', environment, config);
+        return platform.tenant('POST', project, '/bpm/handovers', { environment, body: { userId, decisions: decisions ?? [], force: force ?? false } });
+    }));
+    server.registerTool('process_batch_execute', {
+        title: 'Toplu işlem',
+        description: "Toplu işlem başlatır ve batchOperationId döner; ilerleme process_batch_get ile izlenir. operation start → slug + items[{subjectRowId, vars}] (en çok 100.000; 500'lük parçalarla arka planda) | reassign → taskIds + targetUserId | extend-due → taskIds + dueAt (bekleyen SLA/hatırlatma timer'ları aynı farkla kayar) | cancel → taskIds + reason (görevlerin örnekleri iptal edilir). Görev işlemleri en çok 500 görev, eşzamanlı. Yetki process.start (start) / process.manage (diğerleri).",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            operation: z.enum(['start', 'reassign', 'extend-due', 'cancel']),
+            slug: z.string().max(100).optional(),
+            applicationId: guid.optional(),
+            items: z.array(z.object({ subjectRowId: z.string().max(64).optional(), vars: z.record(z.unknown()).optional() })).optional(),
+            taskIds: z.array(guid).max(500).optional(),
+            targetUserId: z.string().max(64).optional(),
+            dueAt: z.string().datetime({ offset: true }).optional(),
+            reason: z.string().max(1000).optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, operation, slug, applicationId, items, taskIds, targetUserId, dueAt, reason }) => {
+        assertProcessNotProduction('process_batch_execute', environment, config);
+        if (operation === 'start') {
+            if (!slug || !items?.length)
+                throw new PlatformApiError("process_batch_execute: 'start' için slug ve items zorunlu (istek gönderilmedi).", 400);
+            return platform.tenant('POST', project, `/bpm/processes/${encodeURIComponent(slug)}/start-batch`, { environment, body: { applicationId, items } });
+        }
+        if (!taskIds?.length)
+            throw new PlatformApiError(`process_batch_execute: '${operation}' için taskIds zorunlu (istek gönderilmedi).`, 400);
+        if (operation === 'reassign' && !targetUserId)
+            throw new PlatformApiError("process_batch_execute: 'reassign' targetUserId ister (istek gönderilmedi).", 400);
+        if (operation === 'extend-due' && !dueAt)
+            throw new PlatformApiError("process_batch_execute: 'extend-due' dueAt ister (istek gönderilmedi).", 400);
+        if (operation === 'cancel' && !reason?.trim())
+            throw new PlatformApiError("process_batch_execute: 'cancel' reason ister (istek gönderilmedi).", 400);
+        return platform.tenant('POST', project, '/bpm/tasks/batch', { environment, body: { kind: operation, taskIds, targetUserId, dueAt, reason } });
+    }));
+    server.registerTool('process_batch_get', {
+        title: 'Toplu işlemi getir',
+        description: 'Toplu işlemin durumu: state (running | completed), total, done, failed, errors[] (ilk 100 satır hatası, index ile), undoneAt.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, id }) => platform.tenant('GET', project, `/bpm/batch-operations/${id}`, { environment })));
+    server.registerTool('process_batch_update', {
+        title: 'Toplu işlemi geri al',
+        description: "operation undo: reassign işleminde eski atananlar, extend-due işleminde eski terminler (ve timer vadeleri) geri gelir. start ve cancel geri alınamaz → 422 BatchOperationNotUndoable; ikinci geri alma da 422.",
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid, operation: z.enum(['undo']) },
+        annotations: updates
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('process_batch_update', environment, config);
+        return platform.tenant('POST', project, `/bpm/batch-operations/${id}/undo`, { environment });
+    }));
+}

package/dist/tools/bpmReporting.js

@@ -0,0 +1,154 @@
+import { guid, projectParam, environmentParam, readOnly, writes, destructive } from './common.js';
+import { assertInline, writeLocalFile } from './bpmGovernance.js';
+import { checkOcel, checkXes } from '../knowledge/mining.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { assertProcessNotProduction } from './bpm.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const maxReportWindowDays = 366;
+/**
+ * Pencere sınırı backend doğrulayıcısıyla aynı hesaplanır: saat dilimsiz tarih-saat UTC sayılır. JS
+ * `Date.parse` tarih-yalnız metni UTC, dilimsiz tarih-saati yerel saat okur; gateway Europe/Istanbul'da
+ * koşarken '2026-01-01T00:00' – '2027-01-02' 366,125 gün çıkıyor ve backend'in kabul ettiği istek
+ * gitmeden duruyordu (Faz 9 incelemesi).
+ */
+const windowTime = (value) => Date.parse(/^\d{4}-\d{2}-\d{2}T[^zZ+]*$/.test(value) && !/[+-]\d{2}:?\d{2}$/.test(value.slice(10)) ? `${value}Z` : value);
+const guidPattern = /^\{?[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\}?$/i;
+const processSlugPattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export function registerBpmReportingTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('process_report_get', {
+        title: 'Süreç raporunu getir',
+        description: "Bir sürecin defterden türetilen raporu (GET bpm/reports/{slug}): startedCount, completedCount, openCount, averageCycleHours (instance-started → instance-completed), slaWithinPercent (terminli ve tamamlanmış görevlerde son termin, uzatma dahil), rejectLoops (ardından yeni görev açılan ret), adminInterventions (atlama, zıplama, göç, yönetici eliyle yeniden atama/iptal/askı), steps[] (düğüm başına görev sayısı, ortalama saat, workedMinutes), units[] (başlatanın birincil birimi), slaBreaches[], longRunningInstanceIds (30 günden eski açık örnekler), isTruncated (5000 örnek tavanı), historyLevel (minimal'de rejectLoops 0 ve slaBreaches boş döner — defter bu satırları yazmaz). Pencere [from, to) en çok 366 gün; arşivlenmiş örnekler rapora girmez. Yetki process.view-all.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            slug: z.string().min(1).max(100),
+            from: z.string().min(10).max(40).describe('ISO 8601, ör. 2026-09-01'),
+            to: z.string().min(10).max(40).describe('ISO 8601, hariç; from\'dan sonra'),
+            applicationId: guid.optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, slug, from, to, applicationId }) => {
+        const fromTime = windowTime(from);
+        const toTime = windowTime(to);
+        if (Number.isNaN(fromTime) || Number.isNaN(toTime))
+            throw new PlatformApiError('process_report_get: from ve to ISO 8601 tarih olmalı (istek gönderilmedi).', 400);
+        if (toTime <= fromTime)
+            throw new PlatformApiError("process_report_get: 'to' 'from'dan sonra olmalı (istek gönderilmedi).", 400);
+        if ((toTime - fromTime) / 86_400_000 > maxReportWindowDays)
+            throw new PlatformApiError(`process_report_get: pencere en çok ${maxReportWindowDays} gün; aralığı bölün (istek gönderilmedi).`, 400);
+        return platform.tenant('GET', project, `/bpm/reports/${encodeURIComponent(slug)}`, { environment, query: { from, to, applicationId } });
+    }));
+    server.registerTool('process_export_get', {
+        title: 'Süreç madenciliği günlüğünü dışa aktar',
+        description: "Bir sürecin defterini süreç madenciliği biçiminde indirir (GET bpm/export/{format}): xes — IEEE 1849-2016 XES (iz = örnek, olay = defter satırı; concept:name düğüm, lifecycle:transition, time:timestamp, org:resource eylemci, vekalette asıl sahip zeyrek:principal); ocel — OCEL 2.0 JSON, dosya .json (nesneler process-instance, task, subject, document; olaylar nesne ilişkileriyle). Onay kararı ve imza XES'te ayrı etkinliktir ('kontrol:decided', 'kontrol:signed'), planlama (schedule) olayında org:resource yok. isTruncated true ise dosya 5000 örnekle kırpılmıştır (X-Mining-Truncated) — pencereyi bölün. Pencere rapor gibi: from–to arasında başlayan örnekler, en çok 366 gün, 5000 örnek tavanı; yetki process.view-all. Gateway dosyayı YAPISAL olarak yeniden denetler (XES: log/xes.version, iz ve olay concept:name, tarih; OCEL: dört dizi, bildirilmiş türler, var olan nesneye ilişki) ve { validated, validation: 'structural', problems } döner — resmî XSD/JSON şema doğrulaması değildir. ProM, Celonis ya da PM4Py için outPath verin; satır içi yanıt en çok 256 KB, aşarsa 413.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            format: z.enum(['xes', 'ocel']),
+            definition: z.string().min(1).max(100).describe('süreç slug'),
+            from: z.string().min(10).max(40).describe('ISO 8601, ör. 2026-09-01'),
+            to: z.string().min(10).max(40).describe("ISO 8601, hariç; from'dan sonra"),
+            applicationId: guid.optional(),
+            outPath: z.string().min(1).optional().describe('verilirse dosya bu yerel yola yazılır ve yanıt yalnız özet döner')
+        },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment, format, definition, from, to, applicationId, outPath }) => {
+        const fromTime = windowTime(from);
+        const toTime = windowTime(to);
+        if (Number.isNaN(fromTime) || Number.isNaN(toTime))
+            throw new PlatformApiError('process_export_get: from ve to ISO 8601 tarih olmalı (istek gönderilmedi).', 400);
+        if (toTime <= fromTime)
+            throw new PlatformApiError("process_export_get: 'to' 'from'dan sonra olmalı (istek gönderilmedi).", 400);
+        if ((toTime - fromTime) / 86_400_000 > maxReportWindowDays)
+            throw new PlatformApiError(`process_export_get: pencere en çok ${maxReportWindowDays} gün; aralığı bölün (istek gönderilmedi).`, 400);
+        const response = await platform.tenantWithHeaders('GET', project, `/bpm/export/${format}`, { environment, query: { definition, from, to, applicationId }, expectBinary: true });
+        const payload = response.body;
+        const content = payload.bytes.toString('utf8').replace(/^\uFEFF/, '');
+        const fileName = /filename\*?=(?:UTF-8'')?"?([^";]+)"?/i.exec(response.headers['content-disposition'] ?? '')?.[1] ?? `${definition}.${format === 'xes' ? 'xes' : 'json'}`;
+        const summary = {
+            format,
+            fileName,
+            sizeBytes: payload.bytes.byteLength,
+            isTruncated: response.headers['x-mining-truncated'] === 'true',
+            ...(format === 'xes' ? checkXes(content) : checkOcel(content))
+        };
+        if (outPath)
+            return { ...summary, path: await writeLocalFile('process_export_get', outPath, content) };
+        const inline = { ...summary, content };
+        assertInline('process_export_get', config, inline);
+        return inline;
+    }));
+    server.registerTool('process_analytics_get', {
+        title: 'Süreç analitiğini getir',
+        description: "Defterden süreç analitiği (GET bpm/analytics/{slug}/{view}): variants — yol varyantları (art arda aynı düğüm tek adım), örnek sayısı, pay % (paydada yolu olan örnekler; yolu olmayan örnek — history: minimal ya da etkinlik satırı yok — listeye ve paya girmez), ortalama çevrim saati, en çok beş örnek kimliği; heatmap — insan görevi düğümü başına ziyaret, tamamlanan, ortalama ve medyan saat (servis/karar düğümü yok); conformance — tanım dışı geçişler (instance-jumped hedefiyle, node-skipped, instance-migrated), eylemci ve gerekçe; prediction — açık örnek başına kalan süre: aynı yol önekini paylaşan tamamlanmış örneklerin medyanı eksi son adımdan beri geçen süre (sampleSize 0 ise remainingHours alanı yanıtta yok; model eğitimi yok). variants/heatmap/conformance yalnız pencerede başlayan örnekleri, prediction ayrıca pencereden önce başlayıp hâlâ açık olanları kapsar. Yalnız istenen liste gelir, diğer listeler yanıtta yok (gateway boş değerleri budar); isTruncated 5000 örnek tavanı; historyLevel minimal'de yol eksik. Pencere en çok 366 gün; yetki process.view-all.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            definition: z.string().min(1).max(100).describe('süreç slug'),
+            view: z.enum(['variants', 'heatmap', 'conformance', 'prediction']),
+            from: z.string().min(10).max(40).describe('ISO 8601, ör. 2026-09-01'),
+            to: z.string().min(10).max(40).describe("ISO 8601, hariç; from'dan sonra"),
+            applicationId: guid.optional()
+        },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, definition, view, from, to, applicationId }) => {
+        const fromTime = windowTime(from);
+        const toTime = windowTime(to);
+        if (Number.isNaN(fromTime) || Number.isNaN(toTime))
+            throw new PlatformApiError('process_analytics_get: from ve to ISO 8601 tarih olmalı (istek gönderilmedi).', 400);
+        if (toTime <= fromTime)
+            throw new PlatformApiError("process_analytics_get: 'to' 'from'dan sonra olmalı (istek gönderilmedi).", 400);
+        if ((toTime - fromTime) / 86_400_000 > maxReportWindowDays)
+            throw new PlatformApiError(`process_analytics_get: pencere en çok ${maxReportWindowDays} gün; aralığı bölün (istek gönderilmedi).`, 400);
+        return platform.tenant('GET', project, `/bpm/analytics/${encodeURIComponent(definition)}/${view}`, { environment, query: { from, to, applicationId } });
+    }));
+    server.registerTool('process_legal_hold_list', {
+        title: 'Yasal bekletmeleri listele',
+        description: 'Yasal bekletmeleri (legal hold) en yeniden eskiye listeler: scope (process | instance | user), scopeKey, reason, placedBy/At, releasedBy/At, isActive. Etkin hold kapsadığı kapanmış örneğin arşive taşınmasını ve arşivden silinmesini durdurur. Yetki process.manage.',
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/legal-holds', { environment })));
+    server.registerTool('process_legal_hold_create', {
+        title: 'Yasal bekletme koy',
+        description: "Yasal bekletme koyar (POST bpm/legal-holds). scope process: scopeKey süreç slug'ı; instance: örnek kimliği (defterine legal-hold-placed yazılır); user: kullanıcı kimliği (başlatan, atanan, tamamlayan ya da vekâlet veren olduğu örnekler). Aynı kapsam ve anahtarda etkin hold varsa yenisi açılmaz, o döner (200). Olmayan süreç ya da örnek 404; süreç slug'ı küçük harfe çevrilir. reason zorunlu (dava/denetim numarası). production hedefi istek gitmeden durur (BPM-001) — production'daki bekletme insan işidir. Yetki process.manage.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            scope: z.enum(['process', 'instance', 'user']),
+            scopeKey: z.string().min(1).max(200),
+            reason: z.string().min(1).max(1000)
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, scope, scopeKey, reason }) => {
+        assertProcessNotProduction('process_legal_hold_create', environment, config);
+        const normalizedKey = scope === 'process' ? scopeKey.trim().toLowerCase() : scopeKey.trim();
+        if (scope === 'instance' && !guidPattern.test(normalizedKey))
+            throw new PlatformApiError("process_legal_hold_create: scope 'instance' için scopeKey örnek kimliği (GUID) olmalı; process_instance_list ile bulun (istek gönderilmedi).", 400);
+        if (scope === 'process' && !processSlugPattern.test(normalizedKey))
+            throw new PlatformApiError("process_legal_hold_create: scope 'process' için scopeKey süreç slug'ı olmalı (küçük harf, rakam, tire); process_definition_list ile bulun (istek gönderilmedi).", 400);
+        return platform.tenant('POST', project, '/bpm/legal-holds', { environment, body: { scope, scopeKey: normalizedKey, reason } });
+    }));
+    server.registerTool('process_legal_hold_delete', {
+        title: 'Yasal bekletmeyi kaldır',
+        description: 'Yasal bekletmeyi kaldırır (DELETE bpm/legal-holds/{id}); kayıt silinmez, releasedAt dolar ve saklama işi kapsadığı örnekleri bir sonraki koşuda arşive taşır. Kaldırılmış hold ikinci kez kaldırılamaz (400). production hedefi istek gitmeden durur (BPM-001). Yetki process.manage.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, ({ project, environment, id }) => {
+        assertProcessNotProduction('process_legal_hold_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/legal-holds/${id}`, { environment });
+    }));
+    server.registerTool('process_health_get', {
+        title: 'Süreç motoru sağlığı',
+        description: "Proje ve ortam için süreç motoru sağlığı (GET bpm/health): status healthy | degraded | unhealthy, timerLagSeconds (vadesi geçmiş en eski timer; 60 sn üstü degraded, 600 sn üstü unhealthy), notificationLagSeconds (gönderilmemiş en eski bildirim; 300 sn üstü degraded), faultedInstanceCount (10 üstü degraded). unhealthy'de platform 503 döner; araç gövdeyi yine verir. Yetki process.view-all.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, async ({ project, environment }) => {
+        const response = await platform.tenantRaw('GET', project, '/bpm/health', { environment });
+        const body = response.body;
+        if (response.httpStatus === 200 || (response.httpStatus === 503 && typeof body?.data?.status === 'string'))
+            return response.body;
+        throw new PlatformApiError(`process_health_get: HTTP ${response.httpStatus}${body?.message ? ` — ${body.message}` : ''}`, response.httpStatus);
+    }));
+}

package/dist/tools/bpmRouting.js

@@ -0,0 +1,150 @@
+import { guid, projectParam, environmentParam, readOnly, writes, updates, destructive } from './common.js';
+import { PlatformApiError } from '../platform/errors.js';
+import { currentOrganizationId } from './access.js';
+import { assertProcessNotProduction } from './bpm.js';
+import { handle } from '../platform/responses.js';
+import { z } from 'zod';
+const partnerFields = {
+    code: z.string().min(1).max(100).describe('ilişki kodu; tanımda assignee partner:<kod>'),
+    partnerOrganizationId: guid.describe('karşı organizasyon'),
+    direction: z.enum(['one-way', 'two-way']).describe('one-way: yalnız bu organizasyon partnere görev atar; two-way: iki yön'),
+    processSlugs: z.array(z.string().min(1).max(100)).min(1).describe('ilişkinin izin verdiği süreç slugları'),
+    allowedFields: z.array(z.string().min(1).max(100)).optional().describe('partnerin görebileceği iş satırı alanları')
+};
+export function registerBpmRoutingTools(server, platform) {
+    const config = platform.config;
+    server.registerTool('process_authority_limit_list', {
+        title: 'Yetki limitlerini listele',
+        description: "chain-until-authority atamasında kullanılan yetki limitleri (subjectKind user | position, subjectId, category, limit, currency). Zincir, limiti tutarı karşılayan ilk yöneticide durur; pozisyon limiti kişi limitini ezer.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/authority-limits', { environment })));
+    server.registerTool('process_authority_limit_update', {
+        title: 'Yetki limitini kaydet',
+        description: "Yetki limitini (subjectKind, subjectId, category) üçlüsüne göre ekler ya da günceller; kayıtta subjectKind, subjectId, category ve limit zorunludur. remove:true yalnız id ile siler (id yoksa istek gitmez). Pozisyon öznesi pozisyon kimliği ya da kodudur (P-SATIS). Tanımdaki kullanım: assignee { rule: 'chain', arg: 'until-authority', category, amount: 'vars.tutar' }.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional().describe('remove:true için'),
+            remove: z.boolean().optional(),
+            subjectKind: z.enum(['user', 'position']).optional(),
+            subjectId: z.string().max(100).optional(),
+            category: z.string().max(100).optional(),
+            limit: z.number().nonnegative().optional(),
+            currency: z.string().length(3).optional()
+        },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id, remove, ...body }) => {
+        assertProcessNotProduction('process_authority_limit_update', environment, config);
+        if (remove) {
+            if (!id)
+                throw new PlatformApiError('process_authority_limit_update: remove:true id ister; önce process_authority_limit_list ile kimliği bulun (istek gönderilmedi).', 400);
+            return platform.tenant('DELETE', project, `/bpm/authority-limits/${id}`, { environment });
+        }
+        const missing = ['subjectKind', 'subjectId', 'category', 'limit'].filter(field => body[field] === undefined || body[field] === '');
+        if (missing.length)
+            throw new PlatformApiError(`process_authority_limit_update: kayıt için ${missing.join(', ')} zorunlu (istek gönderilmedi).`, 400);
+        return platform.tenant('PUT', project, '/bpm/authority-limits', { environment, body });
+    }));
+    server.registerTool('process_pool_list', {
+        title: 'Atama havuzlarını listele',
+        description: "pool:<kod> atamasının havuzları: code, name (yoksa null), üyeler (user | role | unit | position), strategy (round-robin | least-loaded | skill-match | manual), requiredSkills, lastAssignedUserId ve usedBy [{ definitionId, slug, name, locations: ['v1/<düğüm>'] }] — havuzu kullanan süreç tanımları. usedBy boş değilse havuz silinemez (422 ReferencedByProcess). least-loaded sıralaması açık görev / haftalık kapasite (bpm/workloads weeklyLimit, saat; ağırlık) oranıdır; maxOpenTasks dolu ve açık görevi o sayıya ulaşmış kişi manual dışı stratejilerde seçilmez.",
+        inputSchema: { project: projectParam, environment: environmentParam },
+        annotations: readOnly
+    }, handle(config, ({ project, environment }) => platform.tenant('GET', project, '/bpm/pools', { environment })));
+    server.registerTool('process_pool_update', {
+        title: 'Atama havuzunu kaydet',
+        description: "id verilmezse yeni havuz oluşturur (aynı kod 409), verilirse adı/üyeleri/stratejiyi/gerekli becerileri değiştirir; kayıtta code, members ve strategy zorunludur. Tam gövde: güncellemede verilmeyen name ve requiredSkills boşalır, code değişmez. remove:true yalnız id ile havuzu siler (id yoksa istek gitmez); bir süreç tanımı havuzu kullanıyorsa 422 ReferencedByProcess döner ve mesaj süreçleri sayar — önce process_pool_list usedBy'a bakın. Kaydetme yanıtında usedBy null'dır, kullanım yalnız listede hesaplanır. skill-match tanımda assignee.skills ifadeleriyle görev başına beceri de ister.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            id: guid.optional().describe('güncelleme ve remove:true için'),
+            remove: z.boolean().optional(),
+            code: z.string().min(1).max(100).optional(),
+            name: z.string().max(200).optional().describe('ekranda görünen ad; boşsa kod gösterilir'),
+            members: z.array(z.object({ kind: z.enum(['user', 'role', 'unit', 'position']), id: z.string().min(1).max(100) })).optional(),
+            strategy: z.enum(['round-robin', 'least-loaded', 'skill-match', 'manual']).optional(),
+            requiredSkills: z.array(z.string().min(1).max(100)).optional()
+        },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id, remove, ...body }) => {
+        assertProcessNotProduction('process_pool_update', environment, config);
+        if (remove) {
+            if (!id)
+                throw new PlatformApiError('process_pool_update: remove:true id ister; önce process_pool_list ile kimliği bulun (istek gönderilmedi).', 400);
+            return platform.tenant('DELETE', project, `/bpm/pools/${id}`, { environment });
+        }
+        const missing = ['code', 'members', 'strategy'].filter(field => body[field] === undefined || body[field] === '');
+        if (missing.length)
+            throw new PlatformApiError(`process_pool_update: kayıt için ${missing.join(', ')} zorunlu (istek gönderilmedi).`, 400);
+        return id
+            ? platform.tenant('PUT', project, `/bpm/pools/${id}`, { environment, body })
+            : platform.tenant('POST', project, '/bpm/pools', { environment, body });
+    }));
+    server.registerTool('process_webhook_subscription_list', {
+        title: 'Webhook aboneliklerini listele',
+        description: 'Giden CloudEvents webhook abonelikleri (url, eventFilters, state active | dead, consecutiveFailures, lastError). Üç ardışık teslim hatasında abonelik dead olur.',
+        inputSchema: { project: projectParam, environment: environmentParam, applicationId: guid.optional() },
+        annotations: readOnly
+    }, handle(config, ({ project, environment, applicationId }) => platform.tenant('GET', project, '/bpm/webhook-subscriptions', { environment, query: applicationId ? { applicationId } : undefined })));
+    server.registerTool('process_webhook_subscription_create', {
+        title: 'Webhook aboneliği oluştur',
+        description: "HTTPS uca imzalı CloudEvents teslimi (X-Zeyrek-Signature, HMAC-SHA256). eventFilters: '*', 'instance.*', 'task.completed', 'sla.breached' gibi. secret en az 16 karakter; yanıtlarda geri dönmez.",
+        inputSchema: {
+            project: projectParam,
+            environment: environmentParam,
+            applicationId: guid.optional(),
+            url: z.string().url().max(2000).refine(url => url.startsWith('https://'), { message: 'url https:// ile başlamalı (sunucu yalnız HTTPS kabul eder)' }),
+            secret: z.string().min(16).max(256),
+            eventFilters: z.array(z.string().min(1).max(100)).optional()
+        },
+        annotations: writes
+    }, handle(config, async ({ project, environment, ...body }) => {
+        assertProcessNotProduction('process_webhook_subscription_create', environment, config);
+        return platform.tenant('POST', project, '/bpm/webhook-subscriptions', { environment, body });
+    }));
+    server.registerTool('process_webhook_subscription_delete', {
+        title: 'Webhook aboneliğini sil',
+        description: 'Aboneliği siler; kuyruktaki teslimler abonelik bulunamadığı için düşer.',
+        inputSchema: { project: projectParam, environment: environmentParam, id: guid },
+        annotations: destructive
+    }, handle(config, async ({ project, environment, id }) => {
+        assertProcessNotProduction('process_webhook_subscription_delete', environment, config);
+        return platform.tenant('DELETE', project, `/bpm/webhook-subscriptions/${id}`, { environment });
+    }));
+    server.registerTool('process_partner_list', {
+        title: 'B2B partner ilişkilerini listele',
+        description: "Organizasyonun taraf olduğu partner ilişkilerini listeler (GET organizations/{organizationId}/partners, Organization.API, organization.read): code, partnerOrganizationId, direction, processSlugs, allowedFields, state (proposed | active | revoked). Süreçte assignee 'partner:<kod>' yalnız active ve süreci izinli ilişkiyle yayınlanır (422 PartnerUnknown).",
+        inputSchema: { organizationId: guid.optional().describe("Verilmezse gateway ORGANIZATION ayarındaki slug'la bulur") },
+        annotations: readOnly
+    }, handle(config, async ({ organizationId }) => platform.org('GET', `/organizations/${organizationId ?? await currentOrganizationId(platform, 'process_partner_list')}/partners`)));
+    server.registerTool('process_partner_create', {
+        title: 'B2B partner ilişkisi öner',
+        description: "Karşı organizasyona partner ilişkisi önerir (POST organizations/{organizationId}/partners, organization.write): state proposed; karşı taraf process_partner_update { operation: accept } ile kabul edene kadar görev atanamaz. Aynı iki organizasyon arasında açık ilişki ya da aynı kod varsa 409.",
+        inputSchema: { organizationId: guid.optional().describe("Verilmezse gateway ORGANIZATION ayarındaki slug'la bulur"), ...partnerFields },
+        annotations: writes
+    }, handle(config, async ({ organizationId, ...body }) => platform.org('POST', `/organizations/${organizationId ?? await currentOrganizationId(platform, 'process_partner_create')}/partners`, { body })));
+    server.registerTool('process_partner_update', {
+        title: 'B2B partner ilişkisini güncelle',
+        description: "operation update (yalnız öneren taraf; TAM kayıt yazar: code, partnerOrganizationId, direction, processSlugs ZORUNLU, verilmeyen allowedFields BOŞALIR, partnerOrganizationId değiştirilemez (400) — önce process_partner_list ile güncel kaydı okuyun; kapsam genişlerse ilişki yeniden proposed olur) | accept (yalnız karşı taraf; proposed → active) | revoke (iki taraf da; revoked, açık partner görevleri kalır). organizationId çağıranın organizasyonudur (Organization.API, organization.write).",
+        inputSchema: {
+            organizationId: guid.optional().describe("Verilmezse gateway ORGANIZATION ayarındaki slug'la bulur"),
+            id: guid,
+            operation: z.enum(['update', 'accept', 'revoke']),
+            code: partnerFields.code.optional(),
+            partnerOrganizationId: partnerFields.partnerOrganizationId.optional(),
+            direction: partnerFields.direction.optional(),
+            processSlugs: partnerFields.processSlugs.optional(),
+            allowedFields: partnerFields.allowedFields
+        },
+        annotations: updates
+    }, handle(config, async ({ organizationId, id, operation, ...fields }) => {
+        const resolvedId = organizationId ?? await currentOrganizationId(platform, 'process_partner_update');
+        if (operation !== 'update')
+            return platform.org('POST', `/organizations/${resolvedId}/partners/${id}/${operation}`);
+        if (!fields.code || !fields.partnerOrganizationId || !fields.direction || !fields.processSlugs) {
+            throw new PlatformApiError("process_partner_update: operation 'update' code, partnerOrganizationId, direction ve processSlugs ister (tam kayıt yazılır; istek gönderilmedi).", 400);
+        }
+        return platform.org('PUT', `/organizations/${resolvedId}/partners/${id}`, { body: fields });
+    }));
+}