@ozdao/martyrs 0.2.601 → 0.2.603

package/dist/governance.server.js

@@ -0,0 +1,1632 @@
+import { C as CRUD } from "./crud-BT5FIvQC.js";
+import { A as ABAC } from "./abac-Blt8bUTL.js";
+import { V as Verifier, a as Validator } from "./core.verifier-DVB2a21y.js";
+function initiativesVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    name: {
+      rule: "required",
+      validator: Validator.schema().string().required("Initiative name is required").min(1, "Name cannot be empty").max(200, "Name must not exceed 200 characters")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      default: "draft",
+      validator: Validator.schema().string().oneOf(["draft", "active", "completed", "archived"], "Invalid status")
+    },
+    client: {
+      rule: "optional",
+      validator: Validator.schema().string().max(100, "Client name must not exceed 100 characters")
+    },
+    url: {
+      rule: "optional",
+      validator: Validator.schema().string().max(200, "URL must not exceed 200 characters")
+    },
+    createdBy: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid user ID format")
+    },
+    cover: {
+      rule: "optional"
+    },
+    published: {
+      rule: "optional"
+    },
+    structure: {
+      rule: "optional"
+    },
+    team: {
+      rule: "optional"
+    },
+    services: {
+      rule: "optional"
+    },
+    date: {
+      rule: "optional"
+    },
+    fullDescription: {
+      rule: "optional"
+    },
+    valueProposition: {
+      rule: "optional"
+    },
+    targetAudience: {
+      rule: "optional"
+    },
+    successCriteria: {
+      rule: "optional"
+    },
+    repositories: {
+      rule: "optional"
+    },
+    links: {
+      rule: "optional"
+    },
+    environments: {
+      rule: "optional"
+    },
+    releases: {
+      rule: "optional"
+    },
+    metrics: {
+      rule: "optional"
+    },
+    sprints: {
+      rule: "optional"
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "active", "completed", "archived"], "Invalid status")
+    },
+    createdBy: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid user ID format")
+    },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100")
+    },
+    skip: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Skip cannot be negative")
+    },
+    sort: {
+      rule: "optional"
+    },
+    populate: {
+      rule: "optional"
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Initiative ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Name cannot be empty").max(200, "Name must not exceed 200 characters")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "active", "completed", "archived"], "Invalid status")
+    },
+    client: {
+      rule: "optional",
+      validator: Validator.schema().string().max(100, "Client name must not exceed 100 characters")
+    },
+    url: {
+      rule: "optional",
+      validator: Validator.schema().string().max(200, "URL must not exceed 200 characters")
+    },
+    cover: {
+      rule: "optional"
+    },
+    published: {
+      rule: "optional"
+    },
+    structure: {
+      rule: "optional"
+    },
+    team: {
+      rule: "optional"
+    },
+    services: {
+      rule: "optional"
+    },
+    date: {
+      rule: "optional"
+    },
+    fullDescription: {
+      rule: "optional"
+    },
+    valueProposition: {
+      rule: "optional"
+    },
+    targetAudience: {
+      rule: "optional"
+    },
+    successCriteria: {
+      rule: "optional"
+    },
+    repositories: {
+      rule: "optional"
+    },
+    links: {
+      rule: "optional"
+    },
+    environments: {
+      rule: "optional"
+    },
+    releases: {
+      rule: "optional"
+    },
+    metrics: {
+      rule: "optional"
+    },
+    sprints: {
+      rule: "optional"
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Initiative ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$4 } = ABAC;
+function RoutesInitiative(app, db) {
+  const abac = getInstance$4(db);
+  const verifier = initiativesVerifierFactory();
+  const initiativesCRUD = new CRUD({
+    app,
+    db,
+    model: db.initiative,
+    modelName: "initiative",
+    basePath: "/api/initiatives",
+    auth: { read: false },
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    policies: {
+      read: { enabled: false }
+    },
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["initiatives", "governance"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  initiativesCRUD.addAction("sprints", {
+    method: "get",
+    path: "/:id/sprints",
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const sprints = await db.sprint.find({
+          initiative: req.params.id
+        }).populate("owner contributors");
+        res.json(sprints);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  initiativesCRUD.addAction("propose-task", {
+    method: "post",
+    path: "/:id/propose-task",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const { title, description, sprint, dueDate } = req.body;
+        const voting = await db.voting.create({
+          type: "create_task",
+          targetModel: "Task",
+          title: `Create task: ${title}`,
+          description: `Proposal to create task: ${description}`,
+          initiative: req.params.id,
+          sprint,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskData: {
+              title,
+              description,
+              sprint,
+              dueDate,
+              initiative: req.params.id
+            }
+          }
+        });
+        res.status(201).json(voting);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  initiativesCRUD.addAction("metrics", {
+    method: "get",
+    path: "/:id/metrics",
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const initiativeId = req.params.id;
+        const [tasks, sprints, initiative] = await Promise.all([
+          db.task.find({ initiative: initiativeId }),
+          db.sprint.find({ initiative: initiativeId }),
+          db.initiative.findById(initiativeId)
+        ]);
+        const totalTasks = tasks.length;
+        const completedTasks = tasks.filter((t) => t.status === "completed").length;
+        const taskProgress = totalTasks > 0 ? Math.round(completedTasks / totalTasks * 100) : 0;
+        const totalSprints = sprints.length;
+        const completedSprints = sprints.filter((m) => m.status === "completed").length;
+        const sprintProgress = totalSprints > 0 ? Math.round(completedSprints / totalSprints * 100) : 0;
+        const now = /* @__PURE__ */ new Date();
+        const incompleteTasks = tasks.filter((t) => t.status !== "completed");
+        const overdueTasks = incompleteTasks.filter((t) => t.dueDate && new Date(t.dueDate) < now);
+        const overdueRatio = incompleteTasks.length > 0 ? overdueTasks.length / incompleteTasks.length : 0;
+        const riskIndex = overdueRatio > 0.3 ? "high" : overdueRatio > 0.1 ? "medium" : "low";
+        const envs = initiative?.environments || [];
+        const healthyEnvs = envs.filter((e) => e.status === "healthy").length;
+        const availabilityIndex = envs.length > 0 ? Math.round(healthyEnvs / envs.length * 100) : 100;
+        const team = initiative?.team || {};
+        const activeUsers = (team.owners?.length || 0) + (team.coreTeam?.length || 0) + (team.contributors?.length || 0);
+        const performance = totalSprints > 0 ? Math.round(completedSprints / totalSprints * 100) : 0;
+        res.json({ taskProgress, sprintProgress, riskIndex, availabilityIndex, activeUsers, performance });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return initiativesCRUD;
+}
+function sprintsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    name: {
+      rule: "required",
+      validator: Validator.schema().string().required("Sprint name is required").min(1, "Name cannot be empty").max(200, "Name must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    status: {
+      rule: "optional",
+      default: "not_started",
+      validator: Validator.schema().string().oneOf(["not_started", "in_progress", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    startDate: {
+      rule: "required",
+      validator: Validator.schema().date().required("Start date is required")
+    },
+    dueDate: {
+      rule: "required",
+      validator: Validator.schema().date().required("Due date is required")
+    },
+    completedDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    progress: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().number().min(0, "Progress cannot be negative").max(100, "Progress cannot exceed 100")
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().string().required("Owner is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
+    },
+    contributors: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid contributor ID format")
+      )
+    },
+    initiative: {
+      rule: "required",
+      validator: Validator.schema().string().required("Initiative is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    priority: {
+      rule: "optional",
+      default: "medium",
+      validator: Validator.schema().string().oneOf(["low", "medium", "high", "urgent"], "Invalid priority")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    dependencies: {
+      rule: "optional"
+    },
+    metadata: {
+      rule: "optional"
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    initiative: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["not_started", "in_progress", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
+    },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100")
+    },
+    skip: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Skip cannot be negative")
+    },
+    sort: {
+      rule: "optional"
+    },
+    populate: {
+      rule: "optional"
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Sprint ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Name cannot be empty").max(200, "Name must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["not_started", "in_progress", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    startDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    dueDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    completedDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    progress: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Progress cannot be negative").max(100, "Progress cannot exceed 100")
+    },
+    contributors: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid contributor ID format")
+      )
+    },
+    priority: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["low", "medium", "high", "urgent"], "Invalid priority")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    dependencies: {
+      rule: "optional"
+    },
+    metadata: {
+      rule: "optional"
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Sprint ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$3 } = ABAC;
+function RoutesSprint(app, db) {
+  const abac = getInstance$3(db);
+  const verifier = sprintsVerifierFactory();
+  const sprintsCRUD = new CRUD({
+    app,
+    db,
+    model: db.sprint,
+    modelName: "sprint",
+    basePath: "/api/sprints",
+    auth: { read: false },
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    policies: {
+      read: { enabled: false }
+    },
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["sprints", "governance"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  sprintsCRUD.addAction("tasks", {
+    method: "get",
+    path: "/:id/tasks",
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const tasks = await db.task.find({
+          sprint: req.params.id
+        }).populate("assignedTo");
+        res.json(tasks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  sprintsCRUD.addAction("propose-task", {
+    method: "post",
+    path: "/:id/propose-task",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const sprint = await db.sprint.findById(req.params.id);
+        if (!sprint) {
+          return res.status(404).json({ error: "Sprint not found" });
+        }
+        const { title, description, dueDate } = req.body;
+        const voting = await db.voting.create({
+          type: "create_task",
+          targetModel: "Task",
+          title: `Create task: ${title}`,
+          description: `Proposal to create task in sprint "${sprint.name}": ${description}`,
+          initiative: sprint.initiative,
+          sprint: req.params.id,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskData: {
+              title,
+              description,
+              sprint: req.params.id,
+              initiative: sprint.initiative,
+              dueDate
+            }
+          }
+        });
+        res.status(201).json(voting);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return sprintsCRUD;
+}
+function tasksVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    title: {
+      rule: "required",
+      validator: Validator.schema().string().required("Task title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      default: "not_started",
+      validator: Validator.schema().string().oneOf(["proposed", "voting", "not_started", "in_progress", "review", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    assignedTo: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid user ID format")
+    },
+    dueDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    sprint: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    initiative: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    priority: {
+      rule: "optional",
+      default: "medium",
+      validator: Validator.schema().string().oneOf(["low", "medium", "high", "urgent"], "Invalid priority")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    proposedByVoting: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    completionVoting: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    completedDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    },
+    sprint: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    initiative: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    assignedTo: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid user ID format")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["proposed", "voting", "not_started", "in_progress", "review", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    priority: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["low", "medium", "high", "urgent"], "Invalid priority")
+    },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100")
+    },
+    skip: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Skip cannot be negative")
+    },
+    sort: {
+      rule: "optional"
+    },
+    populate: {
+      rule: "optional"
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Task ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["proposed", "voting", "not_started", "in_progress", "review", "completed", "blocked", "cancelled"], "Invalid status")
+    },
+    assignedTo: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid user ID format")
+    },
+    dueDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    priority: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["low", "medium", "high", "urgent"], "Invalid priority")
+    },
+    tags: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    completionVoting: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    completedDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Task ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$2 } = ABAC;
+function RoutesTask(app, db) {
+  const abac = getInstance$2(db);
+  const verifier = tasksVerifierFactory();
+  const tasksCRUD = new CRUD({
+    app,
+    db,
+    model: db.task,
+    modelName: "task",
+    basePath: "/api/tasks",
+    auth: { read: false },
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    policies: {
+      read: { enabled: false }
+    },
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["tasks", "governance"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  tasksCRUD.addAction("assign", {
+    method: "post",
+    path: "/:id/assign",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id);
+        if (!task) {
+          return res.status(404).json({ error: "Task not found" });
+        }
+        const { userId } = req.body;
+        const user = await db.user.findById(userId);
+        if (!user) {
+          return res.status(404).json({ error: "User not found" });
+        }
+        task.assignedTo = userId;
+        task.status = "in_progress";
+        await task.save();
+        res.json({ message: "Task assigned successfully", task });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  tasksCRUD.addAction("submit-for-review", {
+    method: "post",
+    path: "/:id/submit-for-review",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id).populate("assignedTo").populate("sprint");
+        if (!task) {
+          return res.status(404).json({ error: "Task not found" });
+        }
+        if (task.status !== "in_progress") {
+          return res.status(400).json({ error: "Task must be in progress to submit for review" });
+        }
+        const voting = await db.voting.create({
+          type: "approve_task",
+          targetModel: "Task",
+          targetId: task._id,
+          title: `Approve completion of task: ${task.title}`,
+          description: `Review and approve the completion of task "${task.title}"`,
+          initiative: task.initiative,
+          sprint: task.sprint,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskId: task._id,
+            completedBy: task.assignedTo
+          }
+        });
+        task.status = "review";
+        task.completionVoting = voting._id;
+        await task.save();
+        res.json({ message: "Task submitted for review", task, voting });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  tasksCRUD.addAction("complete", {
+    method: "post",
+    path: "/:id/complete",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id);
+        if (!task) {
+          return res.status(404).json({ error: "Task not found" });
+        }
+        if (task.status !== "review") {
+          return res.status(400).json({ error: "Task must be in review to complete" });
+        }
+        if (task.completionVoting) {
+          const voting = await db.voting.findById(task.completionVoting);
+          if (voting && voting.result !== "approved") {
+            return res.status(400).json({ error: "Task completion not approved by voting" });
+          }
+        }
+        task.status = "completed";
+        task.completedDate = /* @__PURE__ */ new Date();
+        await task.save();
+        res.json({ message: "Task completed successfully", task });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return tasksCRUD;
+}
+function votesVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    voting: {
+      rule: "required",
+      validator: Validator.schema().string().required("Voting ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    value: {
+      rule: "required",
+      validator: Validator.schema().number().required("Vote value is required")
+    },
+    voter: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voter ID format")
+    },
+    comment: {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Comment must not exceed 500 characters")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid vote ID format")
+    },
+    voting: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    voter: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voter ID format")
+    },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100")
+    },
+    skip: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Skip cannot be negative")
+    },
+    sort: {
+      rule: "optional"
+    },
+    populate: {
+      rule: "optional"
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Vote ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid vote ID format")
+    },
+    value: {
+      rule: "optional",
+      validator: Validator.schema().number()
+    },
+    comment: {
+      rule: "optional",
+      validator: Validator.schema().string().max(500, "Comment must not exceed 500 characters")
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Vote ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid vote ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$1 } = ABAC;
+function RoutesVote(app, db) {
+  const abac = getInstance$1(db);
+  const verifier = votesVerifierFactory();
+  const votesCRUD = new CRUD({
+    app,
+    db,
+    model: db.vote,
+    modelName: "vote",
+    basePath: "/api/votes",
+    auth: {
+      read: false,
+      create: true
+      // Votes are typically created via /api/votings/:id/vote
+    },
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    policies: {
+      read: { enabled: false }
+    },
+    cache: {
+      enabled: true,
+      ttl: 60,
+      tags: ["votes", "governance"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  return votesCRUD;
+}
+function votingsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    title: {
+      rule: "required",
+      validator: Validator.schema().string().required("Voting title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    type: {
+      rule: "required",
+      validator: Validator.schema().string().required("Voting type is required").oneOf(["create_task", "approve_task", "create_initiative", "update_sprint", "general"], "Invalid voting type")
+    },
+    targetModel: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["Task", "Initiative", "Sprint"], "Invalid target model")
+    },
+    targetId: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid target ID format")
+    },
+    threshold: {
+      rule: "optional",
+      default: 51,
+      validator: Validator.schema().number().min(1, "Threshold must be at least 1").max(100, "Threshold cannot exceed 100")
+    },
+    participants: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid participant ID format")
+      )
+    },
+    result: {
+      rule: "optional",
+      default: "pending",
+      validator: Validator.schema().string().oneOf(["pending", "approved", "rejected"], "Invalid result")
+    },
+    initiative: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    sprint: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    task: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    },
+    metadata: {
+      rule: "optional"
+    },
+    startDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    endDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    status: {
+      rule: "optional",
+      default: "pending",
+      validator: Validator.schema().string().oneOf(["pending", "active", "closed"], "Invalid status")
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["create_task", "approve_task", "create_initiative", "update_sprint", "general"], "Invalid voting type")
+    },
+    initiative: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid initiative ID format")
+    },
+    sprint: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid sprint ID format")
+    },
+    task: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    },
+    result: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["pending", "approved", "rejected"], "Invalid result")
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["pending", "active", "closed"], "Invalid status")
+    },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(1, "Limit must be at least 1").max(100, "Limit cannot exceed 100")
+    },
+    skip: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Skip cannot be negative")
+    },
+    sort: {
+      rule: "optional"
+    },
+    populate: {
+      rule: "optional"
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Voting ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    },
+    title: {
+      rule: "optional",
+      validator: Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+    },
+    description: {
+      rule: "optional",
+      validator: Validator.schema().string().max(2e3, "Description must not exceed 2000 characters")
+    },
+    threshold: {
+      rule: "optional",
+      validator: Validator.schema().number().min(1, "Threshold must be at least 1").max(100, "Threshold cannot exceed 100")
+    },
+    participants: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid participant ID format")
+      )
+    },
+    result: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["pending", "approved", "rejected"], "Invalid result")
+    },
+    task: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid task ID format")
+    },
+    metadata: {
+      rule: "optional"
+    },
+    endDate: {
+      rule: "optional",
+      validator: Validator.schema().date()
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["pending", "active", "closed"], "Invalid status")
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Voting ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid voting ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance } = ABAC;
+function RoutesVoting(app, db) {
+  const abac = getInstance(db);
+  const verifier = votingsVerifierFactory();
+  const votingsCRUD = new CRUD({
+    app,
+    db,
+    model: db.voting,
+    modelName: "voting",
+    basePath: "/api/votings",
+    auth: { read: false },
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    policies: {
+      read: { enabled: false }
+    },
+    cache: {
+      enabled: true,
+      ttl: 60,
+      tags: ["votings", "governance"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  votingsCRUD.addAction("vote", {
+    method: "post",
+    path: "/:id/vote",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+        if (!voting) {
+          return res.status(404).json({ error: "Voting not found" });
+        }
+        if (voting.result !== "pending") {
+          return res.status(400).json({ error: "Voting is closed" });
+        }
+        const { value, comment } = req.body;
+        const userId = req.user?._id;
+        if (voting.participants?.length > 0 && !voting.participants.includes(userId)) {
+          return res.status(403).json({ error: "Not authorized to vote" });
+        }
+        const existingVote = await db.vote.findOne({
+          voting: voting._id,
+          voter: userId
+        });
+        if (existingVote) {
+          return res.status(400).json({ error: "Already voted" });
+        }
+        const vote = await db.vote.create({
+          voting: voting._id,
+          voter: userId,
+          value,
+          comment
+        });
+        await checkVotingResults(voting, db);
+        res.status(201).json({ message: "Vote cast successfully", vote });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  votingsCRUD.addAction("results", {
+    method: "get",
+    path: "/:id/results",
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+        if (!voting) {
+          return res.status(404).json({ error: "Voting not found" });
+        }
+        const votes = await db.vote.find({ voting: voting._id }).populate("voter", "name email");
+        const totalVotes = votes.length;
+        const yesVotes = votes.filter((v) => v.value === 1 || v.value === true).length;
+        const noVotes = votes.filter((v) => v.value === 0 || v.value === false).length;
+        const abstainVotes = totalVotes - yesVotes - noVotes;
+        const results = {
+          voting,
+          totalVotes,
+          yesVotes,
+          noVotes,
+          abstainVotes,
+          percentageYes: totalVotes > 0 ? (yesVotes / totalVotes * 100).toFixed(2) : 0,
+          percentageNo: totalVotes > 0 ? (noVotes / totalVotes * 100).toFixed(2) : 0,
+          threshold: voting.threshold || 51,
+          result: voting.result,
+          votes
+        };
+        res.json(results);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  votingsCRUD.addAction("close", {
+    method: "post",
+    path: "/:id/close",
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+        if (!voting) {
+          return res.status(404).json({ error: "Voting not found" });
+        }
+        if (voting.result !== "pending") {
+          return res.status(400).json({ error: "Voting is already closed" });
+        }
+        const result = await checkVotingResults(voting, db);
+        res.json({ message: "Voting closed", result });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+  return votingsCRUD;
+}
+async function checkVotingResults(voting, db) {
+  const votes = await db.vote.find({ voting: voting._id });
+  const totalVotes = votes.length;
+  const yesVotes = votes.filter((v) => v.value === 1 || v.value === true).length;
+  const percentageYes = totalVotes > 0 ? yesVotes / totalVotes * 100 : 0;
+  if (percentageYes >= (voting.threshold || 51)) {
+    voting.result = "approved";
+    if (voting.type === "create_task" && voting.metadata?.taskData) {
+      const task = await db.task.create({
+        ...voting.metadata.taskData,
+        proposedByVoting: voting._id,
+        status: "not_started"
+      });
+      voting.targetId = task._id;
+    } else if (voting.type === "approve_task" && voting.targetId) {
+      const task = await db.task.findById(voting.targetId);
+      if (task) {
+        task.status = "completed";
+        task.completedDate = /* @__PURE__ */ new Date();
+        await task.save();
+      }
+    }
+  } else if (totalVotes >= (voting.participants?.length || 1)) {
+    voting.result = "rejected";
+  }
+  await voting.save();
+  return voting.result;
+}
+const ModelInitiative = (db) => {
+  const InitiativeSchema = new db.mongoose.Schema(
+    {
+      title: { type: String },
+      name: { type: String },
+      description: { type: String },
+      status: { type: String },
+      client: { type: String },
+      date: { type: db.mongoose.Schema.Types.Mixed },
+      url: { type: String },
+      cover: { type: db.mongoose.Schema.Types.Mixed },
+      published: { type: db.mongoose.Schema.Types.Mixed },
+      structure: { type: db.mongoose.Schema.Types.Mixed },
+      team: { type: db.mongoose.Schema.Types.Mixed },
+      services: { type: db.mongoose.Schema.Types.Mixed },
+      createdBy: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      tasks: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "Task"
+        }
+      ]
+    },
+    {
+      timestamps: { currentTime: () => Date.now() },
+      strict: false,
+      collection: "initiatives"
+    }
+  );
+  const Initiative = db.mongoose.model("Initiative", InitiativeSchema);
+  return Initiative;
+};
+const ModelSprint = (db) => {
+  const SprintSchema = new db.mongoose.Schema(
+    {
+      name: {
+        type: String,
+        required: true
+      },
+      description: {
+        type: String
+      },
+      status: {
+        type: String,
+        enum: ["not_started", "in_progress", "completed", "blocked", "cancelled"],
+        default: "not_started"
+      },
+      startDate: {
+        type: Date,
+        required: true
+      },
+      dueDate: {
+        type: Date,
+        required: true
+      },
+      completedDate: {
+        type: Date
+      },
+      progress: {
+        type: Number,
+        min: 0,
+        max: 100,
+        default: 0
+      },
+      owner: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true
+      },
+      contributors: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "User"
+        }
+      ],
+      initiative: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Initiative",
+        required: true
+      },
+      priority: {
+        type: String,
+        enum: ["low", "medium", "high", "urgent"],
+        default: "medium"
+      },
+      tags: [
+        {
+          type: String
+        }
+      ],
+      dependencies: [
+        {
+          sprint: {
+            type: db.mongoose.Schema.Types.ObjectId,
+            ref: "Sprint"
+          },
+          type: {
+            type: String,
+            enum: ["blocks", "blocked_by", "related_to"],
+            required: true
+          }
+        }
+      ],
+      metadata: {
+        estimatedHours: Number,
+        actualHours: Number,
+        budget: Number,
+        actualCost: Number,
+        notes: String
+      }
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      },
+      toJSON: { virtuals: true },
+      toObject: { virtuals: true }
+    }
+  );
+  SprintSchema.virtual("isOverdue").get(function() {
+    return this.dueDate && this.dueDate < /* @__PURE__ */ new Date() && this.status !== "completed";
+  });
+  SprintSchema.virtual("duration").get(function() {
+    return this.dueDate ? Math.ceil((this.dueDate - this.startDate) / (1e3 * 60 * 60 * 24)) : null;
+  });
+  SprintSchema.index({ initiative: 1, status: 1 });
+  SprintSchema.index({ owner: 1 });
+  SprintSchema.index({ dueDate: 1 });
+  SprintSchema.index({ "dependencies.sprint": 1 });
+  const Sprint = db.mongoose.model("Sprint", SprintSchema);
+  return Sprint;
+};
+const ModelTask = (db) => {
+  const TaskSchema = new db.mongoose.Schema(
+    {
+      title: {
+        type: String,
+        required: true
+      },
+      description: {
+        type: String
+      },
+      status: {
+        type: String,
+        enum: ["proposed", "voting", "not_started", "in_progress", "review", "completed", "blocked", "cancelled"],
+        default: "not_started"
+      },
+      assignedTo: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      dueDate: {
+        type: Date
+      },
+      // Reference to sprint
+      sprint: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Sprint"
+      },
+      initiative: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Initiative"
+      },
+      // Added priority
+      priority: {
+        type: String,
+        enum: ["low", "medium", "high", "urgent"],
+        default: "medium"
+      },
+      // Added tags
+      tags: [
+        {
+          type: String
+        }
+      ],
+      // Voting references
+      proposedByVoting: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Voting"
+      },
+      completionVoting: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Voting"
+      },
+      completedDate: {
+        type: Date
+      }
+    },
+    {
+      timestamps: { currentTime: () => Date.now() }
+    }
+  );
+  TaskSchema.index({ sprint: 1 });
+  TaskSchema.index({ assignedTo: 1 });
+  TaskSchema.index({ status: 1 });
+  TaskSchema.index({ dueDate: 1 });
+  const Task = db.mongoose.model("Task", TaskSchema);
+  return Task;
+};
+const ModelVote = (db) => {
+  const VoteSchema = new db.mongoose.Schema(
+    {
+      value: { type: Number, required: true },
+      voter: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true
+      },
+      voting: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Voting",
+        required: true
+      }
+    },
+    {
+      timestamps: { currentTime: () => Date.now() }
+    }
+  );
+  const Vote = db.mongoose.model("Vote", VoteSchema);
+  return Vote;
+};
+const ModelVoting = (db) => {
+  const VotingSchema = new db.mongoose.Schema(
+    {
+      title: { type: String, required: true },
+      description: { type: String },
+      type: {
+        type: String,
+        enum: ["create_task", "approve_task", "create_initiative", "update_sprint", "general"],
+        default: "general",
+        required: true
+      },
+      targetModel: {
+        type: String,
+        enum: ["Task", "Initiative", "Sprint", null]
+      },
+      targetId: {
+        type: db.mongoose.Schema.Types.ObjectId
+      },
+      threshold: {
+        type: Number,
+        default: 51,
+        // Percentage needed for approval
+        min: 1,
+        max: 100
+      },
+      participants: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "User"
+        }
+      ],
+      result: {
+        type: String,
+        enum: ["pending", "approved", "rejected"],
+        default: "pending"
+      },
+      initiative: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Initiative"
+      },
+      sprint: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Sprint"
+      },
+      task: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Task"
+      },
+      metadata: {
+        type: Object
+        // For storing additional data like taskData for create_task voting
+      },
+      startDate: {
+        type: Date,
+        default: Date.now
+      },
+      endDate: {
+        type: Date
+      },
+      status: {
+        type: String,
+        enum: ["pending", "active", "closed"],
+        default: "pending"
+      },
+      votes: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "Vote"
+        }
+      ]
+    },
+    {
+      timestamps: { currentTime: () => Date.now() },
+      toJSON: { virtuals: true },
+      toObject: { virtuals: true }
+    }
+  );
+  VotingSchema.virtual("voteCount").get(function() {
+    return this.votes ? this.votes.length : 0;
+  });
+  VotingSchema.virtual("isActive").get(function() {
+    const now = /* @__PURE__ */ new Date();
+    return this.status === "active" || this.status === "pending" && (!this.endDate || this.endDate > now);
+  });
+  VotingSchema.index({ initiative: 1 });
+  VotingSchema.index({ sprint: 1 });
+  VotingSchema.index({ task: 1 });
+  VotingSchema.index({ type: 1, targetId: 1 });
+  VotingSchema.index({ result: 1 });
+  const Voting = db.mongoose.model("Voting", VotingSchema);
+  return Voting;
+};
+function initializeGovernance({ app, db, origins, publicPath }) {
+  db.initiative = ModelInitiative(db);
+  db.sprint = ModelSprint(db);
+  db.task = ModelTask(db);
+  db.voting = ModelVoting(db);
+  db.vote = ModelVote(db);
+  if (app) {
+    RoutesInitiative(app, db);
+    RoutesSprint(app, db);
+    RoutesTask(app, db);
+    RoutesVoting(app, db);
+    RoutesVote(app, db);
+  }
+}
+const models = {
+  ModelInitiative,
+  ModelSprint,
+  ModelTask,
+  ModelVoting,
+  ModelVote
+};
+const routes = {
+  RoutesInitiative,
+  RoutesSprint,
+  RoutesTask,
+  RoutesVoting,
+  RoutesVote
+};
+const governance_server = {
+  initialize: initializeGovernance,
+  models,
+  routes
+};
+export {
+  governance_server as default,
+  initializeGovernance as initialize,
+  models,
+  routes
+};