@hotmeshio/long-tail 0.1.6 → 0.1.8

package/build/routes/dba.js

@@ -34,8 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
+const api = __importStar(require("../api/dba"));
 const auth_1 = require("../modules/auth");
-const dbaService = __importStar(require("../services/dba"));
 const router = (0, express_1.Router)();
 /**
  * POST /api/dba/prune
@@ -53,38 +53,28 @@ const router = (0, express_1.Router)();
  * Returns: { jobs, streams, attributes, transient, marked }
  */
 router.post('/prune', auth_1.requireAdmin, async (req, res) => {
-    try {
-        const result = await dbaService.prune({
-            expire: req.body.expire,
-            jobs: req.body.jobs,
-            streams: req.body.streams,
-            engineStreams: req.body.engineStreams,
-            engineStreamsExpire: req.body.engineStreamsExpire,
-            workerStreams: req.body.workerStreams,
-            workerStreamsExpire: req.body.workerStreamsExpire,
-            attributes: req.body.attributes,
-            entities: req.body.entities,
-            pruneTransient: req.body.pruneTransient,
-            keepHmark: req.body.keepHmark,
-        });
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.prune({
+        expire: req.body.expire,
+        jobs: req.body.jobs,
+        streams: req.body.streams,
+        engineStreams: req.body.engineStreams,
+        engineStreamsExpire: req.body.engineStreamsExpire,
+        workerStreams: req.body.workerStreams,
+        workerStreamsExpire: req.body.workerStreamsExpire,
+        attributes: req.body.attributes,
+        entities: req.body.entities,
+        pruneTransient: req.body.pruneTransient,
+        keepHmark: req.body.keepHmark,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/dba/deploy
  * Deploy the server-side prune function and run migrations.
  * Idempotent — safe to call on startup or from CI/CD.
  */
-router.post('/deploy', auth_1.requireAdmin, async (req, res) => {
-    try {
-        await dbaService.deploy();
-        res.json({ ok: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+router.post('/deploy', auth_1.requireAdmin, async (_req, res) => {
+    const result = await api.deploy();
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

package/build/routes/escalations/bulk.js

@@ -34,209 +34,34 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerBulkRoutes = registerBulkRoutes;
-const escalationService = __importStar(require("../../services/escalation"));
-const taskService = __importStar(require("../../services/task"));
-const userService = __importStar(require("../../services/user"));
-const workers_1 = require("../../workers");
-const defaults_1 = require("../../modules/defaults");
-const publish_1 = require("../../lib/events/publish");
-// ── Shared helpers ──────────────────────────────────────────────────────────
-function validateIds(ids) {
-    return Array.isArray(ids) && ids.length > 0;
-}
-async function requireBulkPermission(userId, ids, res) {
-    const isSuperAdminUser = await userService.isSuperAdmin(userId);
-    if (isSuperAdminUser)
-        return true;
-    const roles = await escalationService.getEscalationRoles(ids);
-    for (const role of roles) {
-        const canManage = await userService.isGroupAdmin(userId, role);
-        if (!canManage) {
-            res.status(403).json({ error: `Insufficient permissions for role "${role}"` });
-            return false;
-        }
-    }
-    return true;
-}
-function publishBulkClaimEvents(ids, assignedTo) {
-    for (const id of ids) {
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.claimed',
-            source: 'api',
-            workflowId: '',
-            workflowName: '',
-            taskQueue: '',
-            escalationId: id,
-            status: 'claimed',
-            data: { assigned_to: assignedTo, bulk: true },
-        });
-    }
-}
-// ── Routes ──────────────────────────────────────────────────────────────────
+const api = __importStar(require("../../api/escalations"));
 function registerBulkRoutes(router) {
     router.post('/release-expired', async (_req, res) => {
-        try {
-            const released = await escalationService.releaseExpiredClaims();
-            res.json({ released });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.releaseExpiredClaims();
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     router.patch('/priority', async (req, res) => {
-        try {
-            const { ids, priority } = req.body || {};
-            if (!validateIds(ids))
-                return res.status(400).json({ error: 'ids must be a non-empty array' });
-            if (![1, 2, 3, 4].includes(priority))
-                return res.status(400).json({ error: 'priority must be 1, 2, 3, or 4' });
-            if (!await requireBulkPermission(req.auth.userId, ids, res))
-                return;
-            const updated = await escalationService.updateEscalationsPriority(ids, priority);
-            res.json({ updated });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.updatePriority({ ids: req.body?.ids, priority: req.body?.priority }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     router.post('/bulk-claim', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const { ids, durationMinutes } = req.body || {};
-            if (!validateIds(ids))
-                return res.status(400).json({ error: 'ids must be a non-empty array' });
-            if (!await requireBulkPermission(userId, ids, res))
-                return;
-            const result = await escalationService.bulkClaimEscalations(ids, userId, durationMinutes ?? 30);
-            res.json(result);
-            if (result.claimed > 0)
-                publishBulkClaimEvents(ids, userId);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.bulkClaim({ ids: req.body?.ids, durationMinutes: req.body?.durationMinutes }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     router.post('/bulk-assign', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const { ids, targetUserId, durationMinutes } = req.body || {};
-            if (!validateIds(ids))
-                return res.status(400).json({ error: 'ids must be a non-empty array' });
-            if (!targetUserId || typeof targetUserId !== 'string')
-                return res.status(400).json({ error: 'targetUserId is required' });
-            if (!await requireBulkPermission(userId, ids, res))
-                return;
-            // Non-superadmin: target user must hold each escalation's role
-            const isSuperAdminUser = await userService.isSuperAdmin(userId);
-            if (!isSuperAdminUser) {
-                const roles = await escalationService.getEscalationRoles(ids);
-                for (const role of roles) {
-                    const targetHasRole = await userService.hasRole(targetUserId, role);
-                    if (!targetHasRole) {
-                        return res.status(400).json({ error: `Target user does not hold the "${role}" role` });
-                    }
-                }
-            }
-            const result = await escalationService.bulkAssignEscalations(ids, targetUserId, durationMinutes ?? 30);
-            res.json(result);
-            if (result.assigned > 0)
-                publishBulkClaimEvents(ids, targetUserId);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.bulkAssign({
+            ids: req.body?.ids,
+            targetUserId: req.body?.targetUserId,
+            durationMinutes: req.body?.durationMinutes,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     router.patch('/bulk-escalate', async (req, res) => {
-        try {
-            const { ids, targetRole } = req.body || {};
-            if (!validateIds(ids))
-                return res.status(400).json({ error: 'ids must be a non-empty array' });
-            if (!targetRole || typeof targetRole !== 'string')
-                return res.status(400).json({ error: 'targetRole is required' });
-            if (!await requireBulkPermission(req.auth.userId, ids, res))
-                return;
-            const updated = await escalationService.bulkEscalateToRole(ids, targetRole);
-            res.json({ updated });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.bulkEscalate({ ids: req.body?.ids, targetRole: req.body?.targetRole }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     router.post('/bulk-triage', async (req, res) => {
-        try {
-            const { ids, hint } = req.body || {};
-            if (!validateIds(ids))
-                return res.status(400).json({ error: 'ids must be a non-empty array' });
-            if (!await requireBulkPermission(req.auth.userId, ids, res))
-                return;
-            const resolved = await escalationService.bulkResolveForTriage(ids, hint);
-            const client = (0, workers_1.createClient)();
-            const workflowIds = [];
-            for (const escalation of resolved) {
-                const triageWorkflowId = await startTriageWorkflow(escalation, hint, req.auth?.userId, client);
-                workflowIds.push(triageWorkflowId);
-            }
-            res.json({ triaged: resolved.length, workflows: workflowIds });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
-    });
-}
-// ── Triage workflow launcher ────────────────────────────────────────────────
-async function startTriageWorkflow(escalation, hint, userId, client) {
-    let escalationPayload = {};
-    if (escalation.escalation_payload) {
-        try {
-            escalationPayload = JSON.parse(escalation.escalation_payload);
-        }
-        catch { }
-    }
-    let envelope = {};
-    if (escalation.envelope) {
-        try {
-            envelope = JSON.parse(escalation.envelope);
-        }
-        catch { }
-    }
-    const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
-    const triageEnvelope = {
-        data: {
-            escalationId: escalation.id,
-            originId: escalation.origin_id ?? undefined,
-            originalWorkflowType: escalation.workflow_type,
-            originalTaskQueue: escalation.task_queue,
-            originalTaskId: escalation.task_id,
-            escalationPayload,
-            resolverPayload: {
-                _lt: { needsTriage: true, ...(hint ? { hint } : {}) },
-            },
-        },
-        metadata: envelope.metadata || {},
-        lt: { ...(envelope.lt || {}), userId },
-    };
-    const routing = escalation.task_id
-        ? (await taskService.getTask(escalation.task_id))?.metadata
-        : null;
-    await taskService.createTask({
-        workflow_id: triageWorkflowId,
-        workflow_type: 'mcpTriage',
-        lt_type: 'mcpTriage',
-        task_queue: 'long-tail-system',
-        signal_id: `lt-triage-${triageWorkflowId}`,
-        parent_workflow_id: routing?.parentWorkflowId || triageWorkflowId,
-        origin_id: escalation.origin_id || triageWorkflowId,
-        parent_id: escalation.parent_id ?? undefined,
-        envelope: JSON.stringify(triageEnvelope),
-        metadata: routing || undefined,
-    });
-    await client.workflow.start({
-        workflowName: 'mcpTriage',
-        args: [triageEnvelope],
-        taskQueue: 'long-tail-system',
-        workflowId: triageWorkflowId,
-        expire: defaults_1.JOB_EXPIRE_SECS,
-        entity: 'mcpTriage',
+        const result = await api.bulkTriage({ ids: req.body?.ids, hint: req.body?.hint }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
-    return triageWorkflowId;
 }

package/build/routes/escalations/list.js

@@ -34,40 +34,49 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerListRoutes = registerListRoutes;
-const escalationService = __importStar(require("../../services/escalation"));
-const helpers_1 = require("./helpers");
+const api = __importStar(require("../../api/escalations"));
 function registerListRoutes(router) {
+    /**
+     * POST /api/escalations
+     * Create a standalone escalation (not tied to a workflow).
+     *
+     * RBAC: caller must hold the target role or be superadmin.
+     *
+     * Body: { type, role, subtype?, description?, priority?, envelope?,
+     *         metadata?, escalation_payload? }
+     */
+    router.post('/', async (req, res) => {
+        const result = await api.createEscalation({
+            type: req.body?.type,
+            subtype: req.body?.subtype,
+            role: req.body?.role,
+            description: req.body?.description,
+            priority: req.body?.priority,
+            envelope: req.body?.envelope,
+            metadata: req.body?.metadata,
+            escalation_payload: req.body?.escalation_payload,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
+    });
     /**
      * GET /api/escalations
      * List escalations with optional filters.
      * RBAC: superadmin sees all; others see only roles they belong to.
      */
     router.get('/', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
-            if (visibleRoles && visibleRoles.length === 0) {
-                res.json({ escalations: [], total: 0 });
-                return;
-            }
-            const result = await escalationService.listEscalations({
-                status: req.query.status,
-                role: req.query.role,
-                type: req.query.type,
-                subtype: req.query.subtype,
-                assigned_to: req.query.assigned_to,
-                priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
-                limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
-                offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
-                sort_by: req.query.sort_by,
-                order: req.query.order,
-                visibleRoles,
-            });
-            res.json(result);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.listEscalations({
+            status: req.query.status,
+            role: req.query.role,
+            type: req.query.type,
+            subtype: req.query.subtype,
+            assigned_to: req.query.assigned_to,
+            priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+            sort_by: req.query.sort_by,
+            order: req.query.order,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * GET /api/escalations/available
@@ -75,42 +84,25 @@ function registerListRoutes(router) {
      * RBAC: superadmin sees all; others see only roles they belong to.
      */
     router.get('/available', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
-            if (visibleRoles && visibleRoles.length === 0) {
-                res.json({ escalations: [], total: 0 });
-                return;
-            }
-            const result = await escalationService.listAvailableEscalations({
-                role: req.query.role,
-                type: req.query.type,
-                subtype: req.query.subtype,
-                priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
-                limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
-                offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
-                sort_by: req.query.sort_by,
-                order: req.query.order,
-                visibleRoles,
-            });
-            res.json(result);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.listAvailableEscalations({
+            role: req.query.role,
+            type: req.query.type,
+            subtype: req.query.subtype,
+            priority: req.query.priority ? parseInt(req.query.priority, 10) : undefined,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+            sort_by: req.query.sort_by,
+            order: req.query.order,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * GET /api/escalations/types
      * Returns distinct escalation type values.
      */
     router.get('/types', async (_req, res) => {
-        try {
-            const types = await escalationService.listDistinctTypes();
-            res.json({ types });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.listDistinctTypes();
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**
      * GET /api/escalations/stats
@@ -118,23 +110,7 @@ function registerListRoutes(router) {
      * RBAC: superadmin sees all; others scoped to their roles.
      */
     router.get('/stats', async (req, res) => {
-        try {
-            const userId = req.auth.userId;
-            const visibleRoles = await (0, helpers_1.getVisibleRoles)(userId);
-            if (visibleRoles && visibleRoles.length === 0) {
-                res.json({
-                    pending: 0, claimed: 0,
-                    created: 0, resolved: 0,
-                    by_role: [], by_type: [],
-                });
-                return;
-            }
-            const period = req.query.period || undefined;
-            const stats = await escalationService.getEscalationStats(visibleRoles, period);
-            res.json(stats);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.getEscalationStats({ period: req.query.period || undefined }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
 }

package/build/routes/escalations/resolve.js

@@ -34,14 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerResolveRoutes = registerResolveRoutes;
-const escalationService = __importStar(require("../../services/escalation"));
-const taskService = __importStar(require("../../services/task"));
-const escalation_strategy_1 = require("../../services/escalation-strategy");
-const publish_1 = require("../../lib/events/publish");
-const ephemeral_1 = require("../../services/iam/ephemeral");
-const deployer_1 = require("../../services/yaml-workflow/deployer");
-const workers_1 = require("../../workers");
-const defaults_1 = require("../../modules/defaults");
+const api = __importStar(require("../../api/escalations"));
 function registerResolveRoutes(router) {
     /**
      * POST /api/escalations/:id/resolve
@@ -51,190 +44,7 @@ function registerResolveRoutes(router) {
      * Body: { resolverPayload: Record<string, any> }
      */
     router.post('/:id/resolve', async (req, res) => {
-        try {
-            const { resolverPayload } = req.body || {};
-            if (!resolverPayload) {
-                res.status(400).json({ error: 'resolverPayload is required' });
-                return;
-            }
-            // 1. Read escalation (verify pending)
-            const escalation = await escalationService.getEscalation(req.params.id);
-            if (!escalation) {
-                res.status(404).json({ error: 'Escalation not found' });
-                return;
-            }
-            if (escalation.status !== 'pending') {
-                res.status(409).json({ error: 'Escalation not available for resolution' });
-                return;
-            }
-            // 2. waitFor signal escalation -- signal the paused workflow directly
-            const signalRouting = escalation.metadata?.signal_routing;
-            if (signalRouting?.signalId) {
-                // Replace password fields with ephemeral tokens so plaintext never enters the signal store
-                let signalPayload = resolverPayload;
-                const formSchema = escalation.metadata?.form_schema;
-                if (formSchema?.properties) {
-                    signalPayload = { ...resolverPayload };
-                    for (const [key, def] of Object.entries(formSchema.properties)) {
-                        if (def?.format === 'password' && typeof signalPayload[key] === 'string') {
-                            const uuid = await (0, ephemeral_1.storeEphemeral)(signalPayload[key], {
-                                ttlSeconds: 900,
-                                label: key,
-                            });
-                            signalPayload[key] = (0, ephemeral_1.formatEphemeralToken)(uuid, key);
-                        }
-                    }
-                }
-                if (signalRouting.engine === 'yaml' && signalRouting.hookTopic && signalRouting.appId) {
-                    // YAML workflow: signal the HotMesh engine directly via hook topic.
-                    // Include job_id for hook match condition ({$job.metadata.jid} === {$self.hook.data.job_id}).
-                    const engine = await (0, deployer_1.getEngine)(signalRouting.appId);
-                    await engine.signal(signalRouting.hookTopic, {
-                        ...signalPayload,
-                        escalationId: escalation.id,
-                        job_id: signalRouting.jobId,
-                    });
-                }
-                else if (signalRouting.workflowId) {
-                    // Durable workflow: signal via workflow handle
-                    const client = (0, workers_1.createClient)();
-                    const handle = await client.workflow.getHandle(signalRouting.taskQueue, signalRouting.workflowType, signalRouting.workflowId);
-                    await handle.signal(signalRouting.signalId, signalPayload);
-                }
-                await escalationService.resolveEscalation(escalation.id, resolverPayload);
-                (0, publish_1.publishEscalationEvent)({
-                    type: 'escalation.resolved',
-                    source: 'api',
-                    workflowId: escalation.workflow_id || signalRouting.workflowId,
-                    workflowName: escalation.workflow_type || signalRouting.workflowType,
-                    taskQueue: escalation.task_queue || signalRouting.taskQueue || signalRouting.appId,
-                    taskId: escalation.task_id,
-                    escalationId: escalation.id,
-                    originId: escalation.origin_id ?? undefined,
-                    status: 'resolved',
-                });
-                res.json({ signaled: true, escalationId: escalation.id, workflowId: signalRouting.workflowId || signalRouting.appId });
-                return;
-            }
-            // 3. Reconstruct the original envelope from the escalation or task
-            let envelope = {};
-            if (escalation.envelope) {
-                try {
-                    envelope = JSON.parse(escalation.envelope);
-                }
-                catch { /* use empty */ }
-            }
-            else if (escalation.task_id) {
-                const task = await taskService.getTask(escalation.task_id);
-                if (task?.envelope) {
-                    try {
-                        envelope = JSON.parse(task.envelope);
-                    }
-                    catch { /* use empty */ }
-                }
-            }
-            // 4. Check escalation strategy for triage routing
-            const strategy = escalation_strategy_1.escalationStrategyRegistry.current;
-            if (strategy) {
-                const directive = await strategy.onResolution({
-                    escalation,
-                    resolverPayload,
-                    envelope,
-                });
-                if (directive.action === 'triage') {
-                    // Route to MCP triage orchestrator instead of standard re-run
-                    const originalTask = escalation.task_id
-                        ? await taskService.getTask(escalation.task_id)
-                        : null;
-                    const routing = originalTask?.metadata;
-                    const triageWorkflowId = `triage-${escalation.id}-${Date.now()}`;
-                    const client = (0, workers_1.createClient)();
-                    // Triage lives on a separate axis -- do NOT copy the original
-                    // task's parent routing (signalId, parentWorkflowId) into the
-                    // triage task. Otherwise the container interceptor would signal
-                    // the original parent when triage completes, prematurely closing
-                    // the original workflow. Triage exits the vortex by creating a
-                    // targeted escalation on the original task instead.
-                    await taskService.createTask({
-                        workflow_id: triageWorkflowId,
-                        workflow_type: 'mcpTriageRouter',
-                        lt_type: 'mcpTriage',
-                        task_queue: 'long-tail-system',
-                        signal_id: `lt-triage-${triageWorkflowId}`,
-                        parent_workflow_id: triageWorkflowId,
-                        origin_id: escalation.origin_id || triageWorkflowId,
-                        parent_id: escalation.parent_id ?? undefined,
-                        envelope: JSON.stringify(directive.triageEnvelope),
-                    });
-                    await client.workflow.start({
-                        workflowName: 'mcpTriageRouter',
-                        args: [directive.triageEnvelope],
-                        taskQueue: 'long-tail-system',
-                        workflowId: triageWorkflowId,
-                        expire: defaults_1.JOB_EXPIRE_SECS,
-                        entity: 'mcpTriageRouter',
-                    });
-                    // Mark escalation as resolved (triage is handling it)
-                    await escalationService.resolveEscalation(escalation.id, {
-                        ...resolverPayload,
-                        _lt: { ...resolverPayload._lt, triaged: true, triageWorkflowId },
-                    });
-                    (0, publish_1.publishEscalationEvent)({
-                        type: 'escalation.resolved',
-                        source: 'api',
-                        workflowId: escalation.workflow_id,
-                        workflowName: escalation.workflow_type,
-                        taskQueue: escalation.task_queue,
-                        taskId: escalation.task_id,
-                        escalationId: escalation.id,
-                        originId: escalation.origin_id ?? undefined,
-                        status: 'resolved',
-                    });
-                    res.json({
-                        started: true,
-                        escalationId: escalation.id,
-                        workflowId: triageWorkflowId,
-                        triage: true,
-                    });
-                    return;
-                }
-            }
-            // 5. If no workflow_type, this is a notification-only escalation -- acknowledge and close
-            if (!escalation.workflow_type || !escalation.task_queue) {
-                await escalationService.resolveEscalation(escalation.id, resolverPayload);
-                res.json({ acknowledged: true, escalationId: escalation.id });
-                return;
-            }
-            // 6. Standard re-run: inject resolver data and start original workflow
-            envelope.resolver = resolverPayload;
-            envelope.lt = {
-                ...envelope.lt,
-                escalationId: escalation.id,
-            };
-            const newWorkflowId = `rerun-${escalation.id}-${Date.now()}`;
-            const client = (0, workers_1.createClient)();
-            await client.workflow.start({
-                workflowName: escalation.workflow_type,
-                args: [envelope],
-                taskQueue: escalation.task_queue,
-                workflowId: newWorkflowId,
-                expire: 180,
-            });
-            (0, publish_1.publishEscalationEvent)({
-                type: 'escalation.resolved',
-                source: 'api',
-                workflowId: escalation.workflow_id,
-                workflowName: escalation.workflow_type,
-                taskQueue: escalation.task_queue,
-                taskId: escalation.task_id,
-                escalationId: escalation.id,
-                originId: escalation.origin_id ?? undefined,
-                status: 'resolved',
-            });
-            res.json({ started: true, escalationId: escalation.id, workflowId: newWorkflowId });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message });
-        }
+        const result = await api.resolveEscalation({ id: req.params.id, resolverPayload: req.body?.resolverPayload }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
     });
 }