@sprintdock/backend 0.4.2

package/dist/index.js

@@ -0,0 +1,4103 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors/backend-errors.ts
+var BackendError = class extends Error {
+  statusCode;
+  /**
+   * @param message Human-readable error message.
+   * @param statusCode HTTP status code for mapping in REST/MCP layers.
+   */
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "BackendError";
+    this.statusCode = statusCode;
+  }
+};
+var NotFoundError = class extends BackendError {
+  /**
+   * @param entityName Domain entity label (for example, Plan or Task).
+   * @param id Identifier that was not found.
+   */
+  constructor(entityName, id) {
+    super(`${entityName} not found: ${id}`, 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends BackendError {
+  /**
+   * @param message Human-readable validation message.
+   */
+  constructor(message) {
+    super(message, 400);
+    this.name = "ValidationError";
+  }
+};
+var StorageError = class extends BackendError {
+  /**
+   * @param message Human-readable storage failure message.
+   */
+  constructor(message) {
+    super(message, 500);
+    this.name = "StorageError";
+  }
+};
+
+// src/domain/services/plan-domain.service.ts
+var PlanDomainService = class {
+  transitions = {
+    draft: ["active"],
+    active: ["completed", "archived"],
+    completed: ["archived"],
+    archived: []
+  };
+  /**
+   * @param from Current plan status.
+   * @param to Requested plan status.
+   * @returns True when the transition is allowed (including no-op same status).
+   */
+  canTransitionStatus(from, to) {
+    if (from === to) {
+      return true;
+    }
+    return this.transitions[from].includes(to);
+  }
+  /**
+   * @param from Current plan status.
+   * @param to Requested plan status.
+   * @throws ValidationError when the transition is not allowed.
+   */
+  validateTransition(from, to) {
+    if (!this.canTransitionStatus(from, to)) {
+      throw new ValidationError(
+        `Illegal plan status transition: ${from} -> ${to}`
+      );
+    }
+  }
+};
+
+// src/domain/services/sprint-domain.service.ts
+var SprintDomainService = class {
+  transitions = {
+    planned: ["active"],
+    active: ["completed", "archived"],
+    completed: ["archived"],
+    archived: []
+  };
+  /**
+   * @param from Current sprint status.
+   * @param to Requested sprint status.
+   * @returns True when the transition is allowed (including no-op same status).
+   */
+  canTransitionStatus(from, to) {
+    if (from === to) {
+      return true;
+    }
+    return this.transitions[from].includes(to);
+  }
+  /**
+   * @param from Current sprint status.
+   * @param to Requested sprint status.
+   * @throws ValidationError when the transition is not allowed.
+   */
+  validateTransition(from, to) {
+    if (!this.canTransitionStatus(from, to)) {
+      throw new ValidationError(
+        `Illegal sprint status transition: ${from} -> ${to}`
+      );
+    }
+  }
+};
+
+// src/domain/services/task-domain.service.ts
+var TaskDomainService = class {
+  transitions = {
+    todo: ["in_progress", "blocked", "done"],
+    in_progress: ["blocked", "done", "todo"],
+    blocked: ["in_progress", "todo"],
+    /** Allow reopening from Done on the Kanban (done → any non-terminal workflow state). */
+    done: ["todo", "in_progress", "blocked"]
+  };
+  /**
+   * @param from Current task status.
+   * @param to Requested task status.
+   * @returns True when the transition is allowed (including no-op same status).
+   */
+  canTransitionStatus(from, to) {
+    if (from === to) {
+      return true;
+    }
+    return this.transitions[from].includes(to);
+  }
+  /**
+   * @param from Current task status.
+   * @param to Requested task status.
+   * @throws ValidationError when the transition is not allowed.
+   */
+  validateTransition(from, to) {
+    if (!this.canTransitionStatus(from, to)) {
+      throw new ValidationError(
+        `Illegal task status transition: ${from} -> ${to}`
+      );
+    }
+  }
+  /**
+   * @param tasks Tasks whose {@link Task.order} values must be unique within this set.
+   * @throws ValidationError when two tasks share the same order value.
+   */
+  validateOrderUniqueness(tasks2) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of tasks2) {
+      if (seen.has(t.order)) {
+        throw new ValidationError(`Duplicate task order: ${t.order}`);
+      }
+      seen.add(t.order);
+    }
+  }
+  /**
+   * Ensures dependencies only reference known tasks and form a directed acyclic graph.
+   *
+   * @param tasks Tasks participating in the graph.
+   * @param dependencies Directed edges: taskId depends on dependsOnTaskId.
+   * @throws ValidationError when an endpoint is missing or a cycle exists.
+   */
+  validateDependencyGraph(tasks2, dependencies) {
+    const ids = new Set(tasks2.map((t) => t.id));
+    for (const d of dependencies) {
+      if (!ids.has(d.taskId) || !ids.has(d.dependsOnTaskId)) {
+        throw new ValidationError(
+          `Dependency references unknown task (${d.taskId} -> ${d.dependsOnTaskId})`
+        );
+      }
+    }
+    const adj = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      adj.set(id, []);
+    }
+    for (const d of dependencies) {
+      adj.get(d.taskId).push(d.dependsOnTaskId);
+    }
+    const color = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      color.set(id, 0);
+    }
+    const dfs = (u, stack) => {
+      color.set(u, 1);
+      stack.push(u);
+      for (const v of adj.get(u) ?? []) {
+        const c = color.get(v) ?? 0;
+        if (c === 1) {
+          const i = stack.indexOf(v);
+          const segment = stack.slice(i);
+          throw new ValidationError(
+            `Dependency cycle: ${segment.join(" -> ")} -> ${v}`
+          );
+        }
+        if (c === 0) {
+          dfs(v, stack);
+        }
+      }
+      stack.pop();
+      color.set(u, 2);
+    };
+    for (const id of ids) {
+      if (color.get(id) === 0) {
+        dfs(id, []);
+      }
+    }
+  }
+  /**
+   * @param dependsOnIds Task ids that must exist as prerequisites.
+   * @param existingTaskIds Task ids that are allowed as dependency targets.
+   * @throws ValidationError when any prerequisite id is not in the allowed set.
+   */
+  validateDependencyReferences(dependsOnIds, existingTaskIds) {
+    const allowed = new Set(existingTaskIds);
+    for (const id of dependsOnIds) {
+      if (!allowed.has(id)) {
+        throw new ValidationError(`Unknown dependency target task: ${id}`);
+      }
+    }
+  }
+};
+
+// src/application/plan.service.ts
+var PlanService = class {
+  constructor(planRepo, planDomain) {
+    this.planRepo = planRepo;
+    this.planDomain = planDomain;
+  }
+  /** @returns All plans in creation order. */
+  async listPlans() {
+    return this.planRepo.list();
+  }
+  /**
+   * Creates a plan and activates it when it is the only plan in storage.
+   */
+  async createPlan(input) {
+    const beforeCount = (await this.planRepo.list()).length;
+    const plan = await this.planRepo.create(input);
+    if (beforeCount === 0) {
+      await this.planRepo.setActive(plan.id);
+      const refreshed = await this.planRepo.findById(plan.id);
+      if (!refreshed) {
+        throw new NotFoundError("Plan", plan.id);
+      }
+      return refreshed;
+    }
+    return plan;
+  }
+  /**
+   * Loads a plan by id, then by slug.
+   *
+   * @throws NotFoundError when neither matches.
+   */
+  async getPlan(idOrSlug) {
+    const byId = await this.planRepo.findById(idOrSlug);
+    if (byId) {
+      return byId;
+    }
+    const bySlug = await this.planRepo.findBySlug(idOrSlug);
+    if (bySlug) {
+      return bySlug;
+    }
+    throw new NotFoundError("Plan", idOrSlug);
+  }
+  /**
+   * @throws NotFoundError when no plan is marked active.
+   */
+  async getActivePlan() {
+    const active = await this.planRepo.findActive();
+    if (!active) {
+      throw new NotFoundError("Active plan", "none");
+    }
+    return active;
+  }
+  /**
+   * Marks the resolved plan as the sole active plan.
+   */
+  async setActivePlan(idOrSlug) {
+    const plan = await this.getPlan(idOrSlug);
+    await this.planRepo.setActive(plan.id);
+  }
+  /**
+   * Updates fields; validates plan status transitions through the domain service.
+   */
+  async updatePlan(idOrSlug, input) {
+    const existing = await this.getPlan(idOrSlug);
+    if (input.status !== void 0 && input.status !== existing.status) {
+      this.planDomain.validateTransition(existing.status, input.status);
+    }
+    const updated = await this.planRepo.update(existing.id, input);
+    if (!updated) {
+      throw new NotFoundError("Plan", existing.id);
+    }
+    return updated;
+  }
+  /**
+   * Deletes a plan by id.
+   *
+   * @throws NotFoundError when the plan does not exist.
+   */
+  async deletePlan(id) {
+    const deleted = await this.planRepo.delete(id);
+    if (!deleted) {
+      throw new NotFoundError("Plan", id);
+    }
+  }
+  /**
+   * Resolves the current plan from an optional id or slug, otherwise the active plan.
+   *
+   * @throws NotFoundError when lookup fails or no active plan exists.
+   */
+  async resolvePlan(idOrSlug) {
+    if (idOrSlug === void 0 || idOrSlug === "") {
+      return this.getActivePlan();
+    }
+    return this.getPlan(idOrSlug);
+  }
+};
+
+// src/application/sprint.service.ts
+var SprintService = class {
+  constructor(sprintRepo, planRepo, planService, sprintDomain) {
+    this.sprintRepo = sprintRepo;
+    this.planRepo = planRepo;
+    this.planService = planService;
+    this.sprintDomain = sprintDomain;
+  }
+  /** @param planIdOrSlug When omitted, the active plan is used. */
+  async listSprints(planIdOrSlug) {
+    const plan = await this.planService.resolvePlan(planIdOrSlug);
+    return this.sprintRepo.listByPlanId(plan.id);
+  }
+  /**
+   * Creates a sprint under the resolved plan; {@link CreateSprintInput.planId} is overwritten.
+   */
+  async createSprint(planIdOrSlug, input) {
+    const plan = await this.planService.resolvePlan(planIdOrSlug);
+    return this.sprintRepo.create({ ...input, planId: plan.id });
+  }
+  /**
+   * @throws NotFoundError when the sprint does not exist.
+   */
+  async getSprint(id) {
+    const sprint = await this.sprintRepo.findById(id);
+    if (!sprint) {
+      throw new NotFoundError("Sprint", id);
+    }
+    return sprint;
+  }
+  /**
+   * Finds a sprint by plan scope and slug.
+   *
+   * @throws NotFoundError when the sprint is missing.
+   */
+  async getSprintBySlug(planIdOrSlug, sprintSlug) {
+    const plan = await this.planService.resolvePlan(planIdOrSlug);
+    const sprint = await this.sprintRepo.findBySlug(plan.id, sprintSlug);
+    if (!sprint) {
+      throw new NotFoundError("Sprint", sprintSlug);
+    }
+    return sprint;
+  }
+  /**
+   * Updates sprint fields (name, goal, dates, order) without changing status.
+   * Use {@link updateSprintStatus} for lifecycle transitions.
+   */
+  async updateSprint(id, input) {
+    const existing = await this.getSprint(id);
+    const updated = await this.sprintRepo.update(existing.id, input);
+    if (!updated) {
+      throw new NotFoundError("Sprint", id);
+    }
+    return updated;
+  }
+  /**
+   * Updates sprint status after validating the transition.
+   */
+  async updateSprintStatus(id, status) {
+    const existing = await this.getSprint(id);
+    this.sprintDomain.validateTransition(existing.status, status);
+    const updated = await this.sprintRepo.update(existing.id, { status });
+    if (!updated) {
+      throw new NotFoundError("Sprint", id);
+    }
+    return updated;
+  }
+  /**
+   * @throws NotFoundError when the sprint does not exist.
+   */
+  async deleteSprint(id) {
+    const removed = await this.sprintRepo.delete(id);
+    if (!removed) {
+      throw new NotFoundError("Sprint", id);
+    }
+  }
+};
+
+// src/application/task.service.ts
+var PENDING_TASK_ID = "__pending__";
+function emptyStatusCounts() {
+  return { todo: 0, in_progress: 0, blocked: 0, done: 0 };
+}
+var TaskService = class {
+  constructor(taskRepo, sprintRepo, planService, taskDomain) {
+    this.taskRepo = taskRepo;
+    this.sprintRepo = sprintRepo;
+    this.planService = planService;
+    this.taskDomain = taskDomain;
+  }
+  /**
+   * Lists tasks for a sprint, or all tasks in a resolved plan when {@link sprintId} is omitted.
+   */
+  async listTasks(sprintId, planIdOrSlug, filter) {
+    if (sprintId !== void 0 && sprintId !== "") {
+      return this.taskRepo.listBySprintId(sprintId, filter);
+    }
+    const plan = await this.planService.resolvePlan(planIdOrSlug);
+    return this.taskRepo.listByPlanId(plan.id, filter);
+  }
+  /**
+   * Creates a task after validating sprint ownership, order uniqueness, and dependencies.
+   */
+  async createTask(input, planIdOrSlug) {
+    const sprint = await this.sprintRepo.findById(input.sprintId);
+    if (!sprint) {
+      throw new NotFoundError("Sprint", input.sprintId);
+    }
+    let plan;
+    if (planIdOrSlug !== void 0 && planIdOrSlug !== "") {
+      plan = await this.planService.resolvePlan(planIdOrSlug);
+      if (sprint.planId !== plan.id) {
+        throw new ValidationError(
+          "Sprint does not belong to the resolved plan"
+        );
+      }
+    } else {
+      plan = await this.planService.getPlan(sprint.planId);
+    }
+    const sprintTasks = await this.taskRepo.listBySprintId(input.sprintId);
+    let order;
+    if (input.order === void 0) {
+      order = sprintTasks.length === 0 ? 0 : Math.max(...sprintTasks.map((t) => t.order)) + 1;
+    } else {
+      order = input.order;
+    }
+    const pendingTask = {
+      id: PENDING_TASK_ID,
+      sprintId: input.sprintId,
+      title: input.title,
+      description: input.description ?? null,
+      status: "todo",
+      priority: input.priority,
+      order,
+      assignee: input.assignee ?? null,
+      tags: input.tags ?? null,
+      touchedFiles: [],
+      createdAt: "",
+      updatedAt: ""
+    };
+    this.taskDomain.validateOrderUniqueness([...sprintTasks, pendingTask]);
+    const planTasks = await this.taskRepo.listByPlanId(plan.id);
+    const prereqs = input.dependsOnTaskIds ?? [];
+    if (prereqs.length > 0) {
+      this.taskDomain.validateDependencyReferences(
+        prereqs,
+        planTasks.map((t) => t.id)
+      );
+      const existingDeps = [];
+      for (const t of planTasks) {
+        existingDeps.push(...await this.taskRepo.getDependencies(t.id));
+      }
+      const newEdges = prereqs.map((dependsOnTaskId) => ({
+        taskId: PENDING_TASK_ID,
+        dependsOnTaskId
+      }));
+      this.taskDomain.validateDependencyGraph(
+        [...planTasks, pendingTask],
+        [...existingDeps, ...newEdges]
+      );
+    }
+    return this.taskRepo.create({
+      ...input,
+      order
+    });
+  }
+  /**
+   * @throws NotFoundError when the task does not exist.
+   */
+  async getTask(id) {
+    const task = await this.taskRepo.findById(id);
+    if (!task) {
+      throw new NotFoundError("Task", id);
+    }
+    return task;
+  }
+  /**
+   * Updates title, description, priority, tags, or order (not status).
+   */
+  async updateTask(id, input) {
+    const existing = await this.getTask(id);
+    const merged = {
+      ...existing,
+      title: input.title ?? existing.title,
+      description: input.description !== void 0 ? input.description : existing.description,
+      priority: input.priority ?? existing.priority,
+      order: input.order ?? existing.order,
+      assignee: input.assignee !== void 0 ? input.assignee : existing.assignee,
+      tags: input.tags !== void 0 ? input.tags : existing.tags,
+      touchedFiles: existing.touchedFiles
+    };
+    if (input.order !== void 0 && input.order !== existing.order) {
+      const sprintTasks = await this.taskRepo.listBySprintId(existing.sprintId);
+      this.taskDomain.validateOrderUniqueness(
+        sprintTasks.map((t) => t.id === id ? merged : t)
+      );
+    }
+    const updated = await this.taskRepo.update(existing.id, input);
+    if (!updated) {
+      throw new NotFoundError("Task", id);
+    }
+    return updated;
+  }
+  /**
+   * Replaces prerequisite edges for a task after validating the dependency DAG.
+   */
+  async setTaskDependencies(taskId, dependsOnTaskIds, planIdOrSlug) {
+    const task = await this.getTask(taskId);
+    const sprint = await this.sprintRepo.findById(task.sprintId);
+    if (!sprint) {
+      throw new NotFoundError("Sprint", task.sprintId);
+    }
+    const plan = await this.planService.getPlan(sprint.planId);
+    if (planIdOrSlug !== void 0 && planIdOrSlug !== "") {
+      const scoped = await this.planService.resolvePlan(planIdOrSlug);
+      if (scoped.id !== plan.id) {
+        throw new ValidationError(
+          "Task does not belong to the resolved plan"
+        );
+      }
+    }
+    const planTasks = await this.taskRepo.listByPlanId(plan.id);
+    this.taskDomain.validateDependencyReferences(
+      dependsOnTaskIds,
+      planTasks.map((t) => t.id)
+    );
+    const existingDeps = [];
+    for (const t of planTasks) {
+      if (t.id === taskId) {
+        continue;
+      }
+      existingDeps.push(...await this.taskRepo.getDependencies(t.id));
+    }
+    const newEdges = dependsOnTaskIds.map((dependsOnTaskId) => ({
+      taskId,
+      dependsOnTaskId
+    }));
+    this.taskDomain.validateDependencyGraph(planTasks, [
+      ...existingDeps,
+      ...newEdges
+    ]);
+    await this.taskRepo.setDependencies(taskId, dependsOnTaskIds);
+  }
+  /**
+   * Loads prerequisite tasks and tasks that depend on this task.
+   */
+  async getTaskDependencyInfo(taskId, planIdOrSlug) {
+    const task = await this.getTask(taskId);
+    if (planIdOrSlug !== void 0 && planIdOrSlug !== "") {
+      const plan = await this.planService.resolvePlan(planIdOrSlug);
+      const sprint = await this.sprintRepo.findById(task.sprintId);
+      if (!sprint || sprint.planId !== plan.id) {
+        throw new ValidationError(
+          "Task does not belong to the resolved plan"
+        );
+      }
+    }
+    const depRows = await this.taskRepo.getDependencies(taskId);
+    const dependsOn = [];
+    for (const d of depRows) {
+      dependsOn.push(await this.getTask(d.dependsOnTaskId));
+    }
+    const dependentIds = await this.taskRepo.listDependentTaskIds(taskId);
+    const dependedOnBy = [];
+    for (const id of dependentIds) {
+      dependedOnBy.push(await this.getTask(id));
+    }
+    return { dependsOn, dependedOnBy };
+  }
+  /**
+   * Updates task status after validating the transition.
+   */
+  async updateTaskStatus(id, status) {
+    const existing = await this.getTask(id);
+    this.taskDomain.validateTransition(existing.status, status);
+    const updated = await this.taskRepo.update(existing.id, { status });
+    if (!updated) {
+      throw new NotFoundError("Task", id);
+    }
+    return updated;
+  }
+  /**
+   * Sets or clears the task assignee.
+   */
+  async assignTask(id, assignee) {
+    const existing = await this.getTask(id);
+    const updated = await this.taskRepo.update(existing.id, { assignee });
+    if (!updated) {
+      throw new NotFoundError("Task", id);
+    }
+    return updated;
+  }
+  /**
+   * Moves a task to another sprint in the same plan.
+   */
+  async moveTask(taskId, targetSprintId) {
+    const task = await this.getTask(taskId);
+    const sourceSprint = await this.sprintRepo.findById(task.sprintId);
+    const targetSprint = await this.sprintRepo.findById(targetSprintId);
+    if (!sourceSprint) {
+      throw new NotFoundError("Sprint", task.sprintId);
+    }
+    if (!targetSprint) {
+      throw new NotFoundError("Sprint", targetSprintId);
+    }
+    if (sourceSprint.planId !== targetSprint.planId) {
+      throw new ValidationError(
+        "Cannot move a task to a sprint in a different plan"
+      );
+    }
+    const moved = await this.taskRepo.move(taskId, targetSprintId);
+    if (!moved) {
+      throw new NotFoundError("Task", taskId);
+    }
+    return moved;
+  }
+  /**
+   * @throws NotFoundError when the task does not exist.
+   */
+  async deleteTask(id) {
+    const removed = await this.taskRepo.delete(id);
+    if (!removed) {
+      throw new NotFoundError("Task", id);
+    }
+  }
+  /**
+   * Loads all sprints for the plan (ordered) and task counts by status per sprint, plus plan rollup.
+   */
+  async getPlanSprintTaskAnalytics(planIdOrSlug) {
+    const plan = await this.planService.resolvePlan(planIdOrSlug);
+    const [sprintList, tasks2] = await Promise.all([
+      this.sprintRepo.listByPlanId(plan.id),
+      this.taskRepo.listByPlanId(plan.id)
+    ]);
+    const perSprint = /* @__PURE__ */ new Map();
+    for (const s of sprintList) {
+      perSprint.set(s.id, emptyStatusCounts());
+    }
+    const rollup = emptyStatusCounts();
+    for (const t of tasks2) {
+      rollup[t.status] += 1;
+      const row = perSprint.get(t.sprintId);
+      if (row !== void 0) {
+        row[t.status] += 1;
+      }
+    }
+    const sprints2 = sprintList.map(
+      (sprint) => {
+        const c = perSprint.get(sprint.id) ?? emptyStatusCounts();
+        const totalTasks2 = c.todo + c.in_progress + c.blocked + c.done;
+        return {
+          sprint,
+          tasksByStatus: { ...c },
+          totalTasks: totalTasks2
+        };
+      }
+    );
+    const totalTasks = rollup.todo + rollup.in_progress + rollup.blocked + rollup.done;
+    return {
+      planId: plan.id,
+      sprints: sprints2,
+      rollup: {
+        tasksByStatus: { ...rollup },
+        totalTasks,
+        sprintCount: sprintList.length
+      }
+    };
+  }
+  /**
+   * Fleet Command throughput: counts across all tasks (all plans). Blocked tasks are omitted from the trio.
+   */
+  async getGlobalTaskThroughput() {
+    const c = await this.taskRepo.countByStatusGlobally();
+    return {
+      todo: c.todo,
+      inProgress: c.in_progress,
+      done: c.done
+    };
+  }
+};
+
+// src/application/container.ts
+function createApplicationServices(repos) {
+  const planDomain = new PlanDomainService();
+  const sprintDomain = new SprintDomainService();
+  const taskDomain = new TaskDomainService();
+  const planService = new PlanService(repos.plans, planDomain);
+  const sprintService = new SprintService(
+    repos.sprints,
+    repos.plans,
+    planService,
+    sprintDomain
+  );
+  const taskService = new TaskService(
+    repos.tasks,
+    repos.sprints,
+    planService,
+    taskDomain
+  );
+  return { planService, sprintService, taskService };
+}
+
+// src/infrastructure/repositories/drizzle/drizzle-plan.repository.ts
+import { asc, eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+
+// src/db/schema/plans.ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var plans = sqliteTable("plans", {
+  id: text("id").primaryKey(),
+  slug: text("slug").notNull().unique(),
+  title: text("title").notNull(),
+  description: text("description"),
+  markdownContent: text("markdown_content"),
+  status: text("status").notNull(),
+  isActive: integer("is_active", { mode: "boolean" }).notNull().default(false),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+
+// src/infrastructure/repositories/drizzle/row-mappers.ts
+function toPlanEntity(row) {
+  return {
+    id: row.id,
+    slug: row.slug,
+    title: row.title,
+    description: row.description ?? null,
+    markdownContent: row.markdownContent ?? null,
+    status: row.status,
+    isActive: row.isActive,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toSprintEntity(row) {
+  return {
+    id: row.id,
+    slug: row.slug,
+    planId: row.planId,
+    name: row.name,
+    goal: row.goal,
+    markdownContent: row.markdownContent ?? null,
+    status: row.status,
+    order: row.sprintOrder,
+    startDate: row.startDate ?? null,
+    endDate: row.endDate ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toTaskEntity(row) {
+  return {
+    id: row.id,
+    sprintId: row.sprintId,
+    title: row.title,
+    description: row.description ?? null,
+    status: row.status,
+    priority: row.priority,
+    order: row.taskOrder,
+    assignee: row.assignee ?? null,
+    tags: row.tags ?? null,
+    touchedFiles: [],
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toTaskTouchedFileEntity(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    path: row.path,
+    fileType: row.fileType
+  };
+}
+function toTaskDependencyEntity(row) {
+  return {
+    taskId: row.taskId,
+    dependsOnTaskId: row.dependsOnTaskId
+  };
+}
+
+// src/infrastructure/repositories/drizzle/drizzle-plan.repository.ts
+var DrizzlePlanRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /** @inheritdoc */
+  async create(input) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.insert(plans).values({
+      id,
+      slug: input.slug,
+      title: input.title,
+      description: input.description ?? null,
+      markdownContent: input.markdownContent ?? null,
+      status: "draft",
+      isActive: false,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    const created = this.db.select().from(plans).where(eq(plans.id, id)).get();
+    if (!created) {
+      throw new StorageError("Failed to read plan after insert");
+    }
+    return toPlanEntity(created);
+  }
+  /** @inheritdoc */
+  async findById(id) {
+    const row = this.db.select().from(plans).where(eq(plans.id, id)).get();
+    return row ? toPlanEntity(row) : null;
+  }
+  /** @inheritdoc */
+  async findBySlug(slug) {
+    const row = this.db.select().from(plans).where(eq(plans.slug, slug)).get();
+    return row ? toPlanEntity(row) : null;
+  }
+  /** @inheritdoc */
+  async findActive() {
+    const row = this.db.select().from(plans).where(eq(plans.isActive, true)).orderBy(asc(plans.createdAt)).limit(1).get();
+    return row ? toPlanEntity(row) : null;
+  }
+  /** @inheritdoc */
+  async list() {
+    const rows = this.db.select().from(plans).orderBy(asc(plans.createdAt)).all();
+    return rows.map(toPlanEntity);
+  }
+  /** @inheritdoc */
+  async update(id, input) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.update(plans).set({
+      title: input.title ?? existing.title,
+      description: input.description !== void 0 ? input.description : existing.description,
+      markdownContent: input.markdownContent !== void 0 ? input.markdownContent : existing.markdownContent,
+      status: input.status ?? existing.status,
+      updatedAt: now
+    }).where(eq(plans.id, id)).run();
+    return this.findById(id);
+  }
+  /** @inheritdoc */
+  async setActive(id) {
+    this.db.transaction((tx) => {
+      tx.update(plans).set({ isActive: false }).run();
+      tx.update(plans).set({
+        isActive: true,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }).where(eq(plans.id, id)).run();
+    });
+  }
+  /** @inheritdoc */
+  async delete(id) {
+    const before = await this.findById(id);
+    if (!before) {
+      return false;
+    }
+    this.db.delete(plans).where(eq(plans.id, id)).run();
+    return await this.findById(id) === null;
+  }
+};
+
+// src/infrastructure/repositories/drizzle/drizzle-sprint.repository.ts
+import { and, asc as asc2, eq as eq2 } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/db/schema/sprints.ts
+import { sqliteTable as sqliteTable2, text as text2, integer as integer2, uniqueIndex } from "drizzle-orm/sqlite-core";
+var sprints = sqliteTable2(
+  "sprints",
+  {
+    id: text2("id").primaryKey(),
+    slug: text2("slug").notNull(),
+    planId: text2("plan_id").notNull().references(() => plans.id, { onDelete: "cascade" }),
+    name: text2("name").notNull(),
+    goal: text2("goal").notNull(),
+    markdownContent: text2("markdown_content"),
+    status: text2("status").notNull(),
+    sprintOrder: integer2("order").notNull().default(0),
+    startDate: text2("start_date"),
+    endDate: text2("end_date"),
+    createdAt: text2("created_at").notNull(),
+    updatedAt: text2("updated_at").notNull()
+  },
+  (table) => ({
+    planSlugUnique: uniqueIndex("sprints_plan_id_slug_unique").on(
+      table.planId,
+      table.slug
+    )
+  })
+);
+
+// src/infrastructure/repositories/drizzle/drizzle-sprint.repository.ts
+var DrizzleSprintRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /** @inheritdoc */
+  async create(input) {
+    const id = randomUUID2();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let order;
+    if (input.order === void 0) {
+      const rows = this.db.select().from(sprints).where(eq2(sprints.planId, input.planId)).all();
+      order = rows.length === 0 ? 0 : Math.max(...rows.map((r) => r.sprintOrder)) + 1;
+    } else {
+      order = input.order;
+    }
+    this.db.insert(sprints).values({
+      id,
+      slug: input.slug,
+      planId: input.planId,
+      name: input.name,
+      goal: input.goal,
+      markdownContent: input.markdownContent ?? null,
+      status: "planned",
+      sprintOrder: order,
+      startDate: input.startDate ?? null,
+      endDate: input.endDate ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    const created = this.db.select().from(sprints).where(eq2(sprints.id, id)).get();
+    if (!created) {
+      throw new StorageError("Failed to read sprint after insert");
+    }
+    return toSprintEntity(created);
+  }
+  /** @inheritdoc */
+  async findById(id) {
+    const row = this.db.select().from(sprints).where(eq2(sprints.id, id)).get();
+    return row ? toSprintEntity(row) : null;
+  }
+  /** @inheritdoc */
+  async findBySlug(planId, slug) {
+    const row = this.db.select().from(sprints).where(and(eq2(sprints.planId, planId), eq2(sprints.slug, slug))).get();
+    return row ? toSprintEntity(row) : null;
+  }
+  /** @inheritdoc */
+  async listByPlanId(planId) {
+    const rows = this.db.select().from(sprints).where(eq2(sprints.planId, planId)).orderBy(asc2(sprints.sprintOrder)).all();
+    return rows.map(toSprintEntity);
+  }
+  /** @inheritdoc */
+  async update(id, input) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.update(sprints).set({
+      name: input.name ?? existing.name,
+      goal: input.goal ?? existing.goal,
+      markdownContent: input.markdownContent !== void 0 ? input.markdownContent : existing.markdownContent,
+      status: input.status ?? existing.status,
+      sprintOrder: input.order ?? existing.order,
+      startDate: input.startDate !== void 0 ? input.startDate : existing.startDate,
+      endDate: input.endDate !== void 0 ? input.endDate : existing.endDate,
+      updatedAt: now
+    }).where(eq2(sprints.id, id)).run();
+    return this.findById(id);
+  }
+  /** @inheritdoc */
+  async delete(id) {
+    const before = await this.findById(id);
+    if (!before) {
+      return false;
+    }
+    this.db.delete(sprints).where(eq2(sprints.id, id)).run();
+    return await this.findById(id) === null;
+  }
+};
+
+// src/infrastructure/repositories/drizzle/drizzle-task.repository.ts
+import { and as and2, asc as asc3, eq as eq3, inArray } from "drizzle-orm";
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/db/schema/tasks.ts
+import {
+  sqliteTable as sqliteTable3,
+  text as text3,
+  integer as integer3,
+  primaryKey,
+  uniqueIndex as uniqueIndex2
+} from "drizzle-orm/sqlite-core";
+var tasks = sqliteTable3("tasks", {
+  id: text3("id").primaryKey(),
+  sprintId: text3("sprint_id").notNull().references(() => sprints.id, { onDelete: "cascade" }),
+  title: text3("title").notNull(),
+  description: text3("description"),
+  status: text3("status").notNull(),
+  priority: text3("priority").notNull(),
+  taskOrder: integer3("order").notNull().default(0),
+  assignee: text3("assignee"),
+  tags: text3("tags", { mode: "json" }).$type(),
+  createdAt: text3("created_at").notNull(),
+  updatedAt: text3("updated_at").notNull()
+});
+var taskDependencies = sqliteTable3(
+  "task_dependencies",
+  {
+    taskId: text3("task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    dependsOnTaskId: text3("depends_on_task_id").notNull().references(() => tasks.id, { onDelete: "cascade" })
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.taskId, t.dependsOnTaskId] })
+  })
+);
+var taskTouchedFiles = sqliteTable3(
+  "task_touched_files",
+  {
+    id: text3("id").primaryKey(),
+    taskId: text3("task_id").notNull().references(() => tasks.id, { onDelete: "cascade" }),
+    path: text3("path").notNull(),
+    fileType: text3("file_type").notNull()
+  },
+  (t) => ({
+    taskPathUnique: uniqueIndex2("task_touched_files_task_id_path_unique").on(
+      t.taskId,
+      t.path
+    )
+  })
+);
+
+// src/infrastructure/repositories/drizzle/drizzle-task.repository.ts
+var TOUCHED_FILE_TYPES = /* @__PURE__ */ new Set([
+  "test",
+  "implementation",
+  "doc",
+  "config",
+  "other"
+]);
+function validateTouchedFileInputs(items) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of items) {
+    const path = raw.path.trim();
+    if (path.length === 0) {
+      throw new ValidationError("Touched file path cannot be empty");
+    }
+    const norm = path.replace(/\\/g, "/");
+    if (norm.split("/").some((s) => s === "..")) {
+      throw new ValidationError("Touched file path cannot contain '..'");
+    }
+    if (!TOUCHED_FILE_TYPES.has(raw.fileType)) {
+      throw new ValidationError(`Invalid touched file type: ${raw.fileType}`);
+    }
+    if (seenPaths.has(norm)) {
+      throw new ValidationError(`Duplicate touched path: ${path}`);
+    }
+    seenPaths.add(norm);
+    out.push({ path, fileType: raw.fileType });
+  }
+  return out;
+}
+var DrizzleTaskRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  replaceTouchedFiles(taskId, items) {
+    this.db.transaction((tx) => {
+      tx.delete(taskTouchedFiles).where(eq3(taskTouchedFiles.taskId, taskId)).run();
+      for (const item of items) {
+        tx.insert(taskTouchedFiles).values({
+          id: randomUUID3(),
+          taskId,
+          path: item.path,
+          fileType: item.fileType
+        }).run();
+      }
+    });
+  }
+  touchedFilesByTaskIds(taskIds) {
+    const map = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      map.set(id, []);
+    }
+    if (taskIds.length === 0) {
+      return map;
+    }
+    const rows = this.db.select().from(taskTouchedFiles).where(inArray(taskTouchedFiles.taskId, taskIds)).all();
+    for (const r of rows) {
+      const e = toTaskTouchedFileEntity(r);
+      const list = map.get(e.taskId);
+      if (list !== void 0) {
+        list.push(e);
+      }
+    }
+    for (const list of map.values()) {
+      list.sort(
+        (a, b) => a.path.localeCompare(b.path, void 0, { sensitivity: "base" })
+      );
+    }
+    return map;
+  }
+  attachTouchedFiles(taskList) {
+    if (taskList.length === 0) {
+      return taskList;
+    }
+    const byId = this.touchedFilesByTaskIds(taskList.map((t) => t.id));
+    return taskList.map((t) => ({
+      ...t,
+      touchedFiles: byId.get(t.id) ?? []
+    }));
+  }
+  /** @inheritdoc */
+  async create(input) {
+    const id = randomUUID3();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let order;
+    if (input.order === void 0) {
+      const rows = this.db.select().from(tasks).where(eq3(tasks.sprintId, input.sprintId)).all();
+      order = rows.length === 0 ? 0 : Math.max(...rows.map((r) => r.taskOrder)) + 1;
+    } else {
+      order = input.order;
+    }
+    const clash = this.db.select().from(tasks).where(
+      and2(eq3(tasks.sprintId, input.sprintId), eq3(tasks.taskOrder, order))
+    ).get();
+    if (clash) {
+      throw new ValidationError(`Duplicate task order in sprint: ${order}`);
+    }
+    this.db.insert(tasks).values({
+      id,
+      sprintId: input.sprintId,
+      title: input.title,
+      description: input.description ?? null,
+      status: "todo",
+      priority: input.priority,
+      taskOrder: order,
+      assignee: input.assignee ?? null,
+      tags: input.tags ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    const created = this.db.select().from(tasks).where(eq3(tasks.id, id)).get();
+    if (!created) {
+      throw new StorageError("Failed to read task after insert");
+    }
+    if (input.dependsOnTaskIds?.length) {
+      await this.setDependencies(id, [...new Set(input.dependsOnTaskIds)]);
+    }
+    const finalRow = this.db.select().from(tasks).where(eq3(tasks.id, id)).get();
+    if (!finalRow) {
+      throw new StorageError("Failed to read task after dependency write");
+    }
+    if (input.touchedFiles !== void 0) {
+      this.replaceTouchedFiles(id, validateTouchedFileInputs(input.touchedFiles));
+    }
+    const hydrated = this.attachTouchedFiles([toTaskEntity(finalRow)])[0];
+    if (!hydrated) {
+      throw new StorageError("Failed to hydrate task after create");
+    }
+    return hydrated;
+  }
+  /** @inheritdoc */
+  async findById(id) {
+    const row = this.db.select().from(tasks).where(eq3(tasks.id, id)).get();
+    if (!row) {
+      return null;
+    }
+    return this.attachTouchedFiles([toTaskEntity(row)])[0] ?? null;
+  }
+  /** @inheritdoc */
+  async listBySprintId(sprintId, filter) {
+    const conditions = [eq3(tasks.sprintId, sprintId)];
+    if (filter?.status) {
+      conditions.push(eq3(tasks.status, filter.status));
+    }
+    if (filter?.priority) {
+      conditions.push(eq3(tasks.priority, filter.priority));
+    }
+    if (filter?.assignee !== void 0) {
+      conditions.push(eq3(tasks.assignee, filter.assignee));
+    }
+    const rows = this.db.select().from(tasks).where(and2(...conditions)).orderBy(asc3(tasks.taskOrder)).all();
+    return this.attachTouchedFiles(rows.map(toTaskEntity));
+  }
+  /** @inheritdoc */
+  async listByPlanId(planId, filter) {
+    const conditions = [eq3(sprints.planId, planId)];
+    if (filter?.status) {
+      conditions.push(eq3(tasks.status, filter.status));
+    }
+    if (filter?.priority) {
+      conditions.push(eq3(tasks.priority, filter.priority));
+    }
+    if (filter?.assignee !== void 0) {
+      conditions.push(eq3(tasks.assignee, filter.assignee));
+    }
+    const rows = this.db.select().from(tasks).innerJoin(sprints, eq3(tasks.sprintId, sprints.id)).where(and2(...conditions)).orderBy(asc3(tasks.taskOrder)).all();
+    return this.attachTouchedFiles(rows.map((row) => toTaskEntity(row.tasks)));
+  }
+  /** @inheritdoc */
+  async update(id, input) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (input.order !== void 0 && input.order !== existing.order) {
+      const clash = this.db.select().from(tasks).where(
+        and2(
+          eq3(tasks.sprintId, existing.sprintId),
+          eq3(tasks.taskOrder, input.order)
+        )
+      ).get();
+      if (clash && clash.id !== id) {
+        throw new ValidationError(
+          `Duplicate task order in sprint: ${input.order}`
+        );
+      }
+    }
+    this.db.update(tasks).set({
+      title: input.title ?? existing.title,
+      description: input.description !== void 0 ? input.description : existing.description,
+      status: input.status ?? existing.status,
+      priority: input.priority ?? existing.priority,
+      taskOrder: input.order ?? existing.order,
+      assignee: input.assignee !== void 0 ? input.assignee : existing.assignee,
+      tags: input.tags !== void 0 ? input.tags : existing.tags,
+      updatedAt: now
+    }).where(eq3(tasks.id, id)).run();
+    if (input.touchedFiles !== void 0) {
+      this.replaceTouchedFiles(id, validateTouchedFileInputs(input.touchedFiles));
+    }
+    return this.findById(id);
+  }
+  /** @inheritdoc */
+  async move(taskId, targetSprintId) {
+    const existing = await this.findById(taskId);
+    if (!existing) {
+      return null;
+    }
+    this.db.transaction((tx) => {
+      const rows = tx.select().from(tasks).where(eq3(tasks.sprintId, targetSprintId)).all();
+      const nextOrder = rows.length === 0 ? 0 : Math.max(...rows.map((r) => r.taskOrder)) + 1;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      tx.update(tasks).set({
+        sprintId: targetSprintId,
+        taskOrder: nextOrder,
+        updatedAt: now
+      }).where(eq3(tasks.id, taskId)).run();
+    });
+    return this.findById(taskId);
+  }
+  /** @inheritdoc */
+  async delete(id) {
+    const before = await this.findById(id);
+    if (!before) {
+      return false;
+    }
+    this.db.delete(tasks).where(eq3(tasks.id, id)).run();
+    return await this.findById(id) === null;
+  }
+  /** @inheritdoc */
+  async getDependencies(taskId) {
+    const rows = this.db.select().from(taskDependencies).where(eq3(taskDependencies.taskId, taskId)).all();
+    return rows.map(toTaskDependencyEntity);
+  }
+  /** @inheritdoc */
+  async listDependentTaskIds(dependsOnTaskId) {
+    const rows = this.db.select().from(taskDependencies).where(eq3(taskDependencies.dependsOnTaskId, dependsOnTaskId)).all();
+    return rows.map((r) => r.taskId);
+  }
+  /** @inheritdoc */
+  async setDependencies(taskId, dependsOnTaskIds) {
+    const unique = [...new Set(dependsOnTaskIds)];
+    this.db.transaction((tx) => {
+      tx.delete(taskDependencies).where(eq3(taskDependencies.taskId, taskId)).run();
+      for (const dependsOnTaskId of unique) {
+        tx.insert(taskDependencies).values({ taskId, dependsOnTaskId }).run();
+      }
+    });
+  }
+  /** @inheritdoc */
+  async countByStatusGlobally() {
+    const rows = this.db.select().from(tasks).all();
+    const out = {
+      todo: 0,
+      in_progress: 0,
+      blocked: 0,
+      done: 0
+    };
+    for (const r of rows) {
+      const s = r.status;
+      if (s in out) {
+        out[s] += 1;
+      }
+    }
+    return out;
+  }
+};
+
+// src/infrastructure/repositories/repository-factory.ts
+function createRepositories(adapter, config) {
+  if (adapter !== "sqlite") {
+    throw new Error(`Unsupported storage adapter: ${adapter}`);
+  }
+  const db = config.sqlite?.db;
+  if (!db) {
+    throw new Error('createRepositories("sqlite") requires config.sqlite.db');
+  }
+  return {
+    plans: new DrizzlePlanRepository(db),
+    sprints: new DrizzleSprintRepository(db),
+    tasks: new DrizzleTaskRepository(db)
+  };
+}
+
+// src/http/app-factory.ts
+import express from "express";
+
+// src/http/routes/v1/index.ts
+import { Router } from "express";
+
+// src/http/controllers/plan.controller.ts
+var PlanController = class {
+  constructor(planService, sprintService, taskService) {
+    this.planService = planService;
+    this.sprintService = sprintService;
+    this.taskService = taskService;
+  }
+  list = async (_req, res, next) => {
+    try {
+      const plans2 = await this.planService.listPlans();
+      res.json({ plans: plans2 });
+    } catch (e) {
+      next(e);
+    }
+  };
+  create = async (req, res, next) => {
+    try {
+      const plan = await this.planService.createPlan(req.body);
+      res.status(201).json({ plan });
+    } catch (e) {
+      next(e);
+    }
+  };
+  getPlanAnalytics = async (req, res, next) => {
+    try {
+      const { idOrSlug } = req.params;
+      const analytics = await this.taskService.getPlanSprintTaskAnalytics(
+        idOrSlug
+      );
+      res.json({ analytics });
+    } catch (e) {
+      next(e);
+    }
+  };
+  getOne = async (req, res, next) => {
+    try {
+      const { idOrSlug } = req.params;
+      const plan = await this.planService.getPlan(idOrSlug);
+      res.json({ plan });
+    } catch (e) {
+      next(e);
+    }
+  };
+  update = async (req, res, next) => {
+    try {
+      const { idOrSlug } = req.params;
+      const plan = await this.planService.updatePlan(idOrSlug, req.body);
+      res.json({ plan });
+    } catch (e) {
+      next(e);
+    }
+  };
+  activate = async (req, res, next) => {
+    try {
+      const { idOrSlug } = req.params;
+      await this.planService.setActivePlan(idOrSlug);
+      res.json({ ok: true });
+    } catch (e) {
+      next(e);
+    }
+  };
+  getExecutionContext = async (_req, res, next) => {
+    try {
+      const plan = await this.planService.getActivePlan();
+      const sprints2 = await this.sprintService.listSprints(plan.id);
+      const activeSprints = sprints2.filter((s) => s.status === "active");
+      res.json({ plan, activeSprints });
+    } catch (e) {
+      next(e);
+    }
+  };
+  /** Composes execution context with global task throughput for the dashboard. */
+  getDashboardOverview = async (_req, res, next) => {
+    try {
+      const throughput = await this.taskService.getGlobalTaskThroughput();
+      let plan;
+      try {
+        plan = await this.planService.getActivePlan();
+      } catch (e) {
+        if (e instanceof NotFoundError) {
+          res.json({
+            execution: { plan: null, activeSprints: [] },
+            throughput
+          });
+          return;
+        }
+        throw e;
+      }
+      const sprints2 = await this.sprintService.listSprints(plan.id);
+      const activeSprints = sprints2.filter((s) => s.status === "active");
+      res.json({
+        execution: { plan, activeSprints },
+        throughput
+      });
+    } catch (e) {
+      next(e);
+    }
+  };
+};
+
+// src/http/controllers/sprint.controller.ts
+var SprintController = class {
+  constructor(sprintService, taskService) {
+    this.sprintService = sprintService;
+    this.taskService = taskService;
+  }
+  listByPlan = async (req, res, next) => {
+    try {
+      const { planId } = req.params;
+      const sprints2 = await this.sprintService.listSprints(planId);
+      res.json({ sprints: sprints2 });
+    } catch (e) {
+      next(e);
+    }
+  };
+  create = async (req, res, next) => {
+    try {
+      const { planId } = req.params;
+      const sprint = await this.sprintService.createSprint(planId, {
+        ...req.body,
+        planId
+      });
+      res.status(201).json({ sprint });
+    } catch (e) {
+      next(e);
+    }
+  };
+  getOne = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const sprint = await this.sprintService.getSprint(id);
+      const tasks2 = await this.taskService.listTasks(sprint.id);
+      res.json({ sprint, tasks: tasks2 });
+    } catch (e) {
+      next(e);
+    }
+  };
+  patch = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const b = req.body;
+      const sprint = await this.sprintService.updateSprint(id, {
+        ...b.name !== void 0 ? { name: b.name } : {},
+        ...b.goal !== void 0 ? { goal: b.goal } : {},
+        ...b.markdownContent !== void 0 ? { markdownContent: b.markdownContent } : {},
+        ...b.startDate !== void 0 ? { startDate: b.startDate } : {},
+        ...b.endDate !== void 0 ? { endDate: b.endDate } : {},
+        ...b.order !== void 0 ? { order: b.order } : {}
+      });
+      res.json({ sprint });
+    } catch (e) {
+      next(e);
+    }
+  };
+  updateStatus = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const { status } = req.body;
+      const sprint = await this.sprintService.updateSprintStatus(id, status);
+      res.json({ sprint });
+    } catch (e) {
+      next(e);
+    }
+  };
+};
+
+// src/http/controllers/task.controller.ts
+var TaskController = class {
+  constructor(taskService) {
+    this.taskService = taskService;
+  }
+  listBySprint = async (req, res, next) => {
+    try {
+      const { sprintId } = req.params;
+      const q = req.validatedQuery ?? {};
+      const filter = q.status || q.priority || q.assignee !== void 0 ? {
+        ...q.status ? { status: q.status } : {},
+        ...q.priority ? { priority: q.priority } : {},
+        ...q.assignee !== void 0 ? { assignee: q.assignee } : {}
+      } : void 0;
+      const tasks2 = await this.taskService.listTasks(sprintId, void 0, filter);
+      res.json({ tasks: tasks2 });
+    } catch (e) {
+      next(e);
+    }
+  };
+  create = async (req, res, next) => {
+    try {
+      const { sprintId } = req.params;
+      const task = await this.taskService.createTask(
+        { ...req.body, sprintId },
+        void 0
+      );
+      res.status(201).json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  getOne = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const task = await this.taskService.getTask(id);
+      res.json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  patch = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const b = req.body;
+      const task = await this.taskService.updateTask(id, {
+        ...b.title !== void 0 ? { title: b.title } : {},
+        ...b.description !== void 0 ? { description: b.description } : {},
+        ...b.priority !== void 0 ? { priority: b.priority } : {},
+        ...b.assignee !== void 0 ? { assignee: b.assignee } : {},
+        ...b.tags !== void 0 ? { tags: b.tags } : {},
+        ...b.order !== void 0 ? { order: b.order } : {},
+        ...b.touchedFiles !== void 0 ? { touchedFiles: b.touchedFiles } : {}
+      });
+      res.json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  updateStatus = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const { status } = req.body;
+      const task = await this.taskService.updateTaskStatus(id, status);
+      res.json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  assign = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const { assignee } = req.body;
+      const task = await this.taskService.assignTask(id, assignee);
+      res.json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  move = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      const { targetSprintId } = req.body;
+      const task = await this.taskService.moveTask(id, targetSprintId);
+      res.json({ task });
+    } catch (e) {
+      next(e);
+    }
+  };
+  remove = async (req, res, next) => {
+    try {
+      const { id } = req.params;
+      await this.taskService.deleteTask(id);
+      res.json({ deleted: true });
+    } catch (e) {
+      next(e);
+    }
+  };
+};
+
+// src/http/controllers/health.controller.ts
+import { readFileSync } from "fs";
+function readPackageVersion() {
+  const path = new URL("../../../package.json", import.meta.url);
+  const raw = readFileSync(path, "utf8");
+  const pkg = JSON.parse(raw);
+  return pkg.version ?? "0.0.0";
+}
+var HealthController = class {
+  version = readPackageVersion();
+  check = (_req, res, _next) => {
+    res.json({
+      status: "ok",
+      version: this.version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+};
+
+// src/http/middleware/validate.ts
+import { z } from "zod";
+function validate(schemas) {
+  return (req, res, next) => {
+    try {
+      if (schemas.body) {
+        req.body = schemas.body.parse(req.body);
+      }
+      if (schemas.query) {
+        const rawQuery = req.query && typeof req.query === "object" ? { ...req.query } : {};
+        req.validatedQuery = schemas.query.parse(rawQuery);
+      }
+      if (schemas.params) {
+        req.params = schemas.params.parse({
+          ...req.params
+        });
+      }
+      next();
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        res.status(400).json({
+          error: {
+            message: "Validation failed",
+            details: e.issues
+          }
+        });
+        return;
+      }
+      next(e);
+    }
+  };
+}
+
+// src/http/routes/v1/schemas.ts
+import { z as z2 } from "zod";
+var planStatusSchema = z2.enum([
+  "draft",
+  "active",
+  "completed",
+  "archived"
+]);
+var sprintStatusSchema = z2.enum([
+  "planned",
+  "active",
+  "completed",
+  "archived"
+]);
+var taskStatusSchema = z2.enum([
+  "todo",
+  "in_progress",
+  "blocked",
+  "done"
+]);
+var taskPrioritySchema = z2.enum([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+var idOrSlugParams = z2.object({
+  idOrSlug: z2.string().min(1)
+});
+var planIdParams = z2.object({
+  planId: z2.string().min(1)
+});
+var sprintIdParams = z2.object({
+  sprintId: z2.string().min(1)
+});
+var sprintIdPathParams = z2.object({
+  id: z2.string().min(1)
+});
+var taskIdPathParams = z2.object({
+  id: z2.string().min(1)
+});
+var createPlanBody = z2.object({
+  slug: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().nullable().optional(),
+  markdownContent: z2.string().nullable().optional()
+});
+var updatePlanBody = z2.object({
+  title: z2.string().min(1).optional(),
+  description: z2.string().nullable().optional(),
+  markdownContent: z2.string().nullable().optional(),
+  status: planStatusSchema.optional()
+}).refine(
+  (v) => v.title !== void 0 || v.description !== void 0 || v.markdownContent !== void 0 || v.status !== void 0,
+  { message: "At least one field is required" }
+);
+var createSprintBody = z2.object({
+  slug: z2.string().min(1),
+  name: z2.string().min(1),
+  goal: z2.string(),
+  markdownContent: z2.string().nullable().optional(),
+  order: z2.number().int().optional(),
+  startDate: z2.string().nullable().optional(),
+  endDate: z2.string().nullable().optional()
+});
+var updateSprintBody = z2.object({
+  name: z2.string().min(1).optional(),
+  goal: z2.string().optional(),
+  markdownContent: z2.string().nullable().optional(),
+  startDate: z2.string().nullable().optional(),
+  endDate: z2.string().nullable().optional(),
+  order: z2.number().int().optional()
+}).refine(
+  (v) => v.name !== void 0 || v.goal !== void 0 || v.markdownContent !== void 0 || v.startDate !== void 0 || v.endDate !== void 0 || v.order !== void 0,
+  { message: "At least one field is required" }
+);
+var updateSprintStatusBody = z2.object({
+  status: sprintStatusSchema
+});
+var taskListQuery = z2.object({
+  status: taskStatusSchema.optional(),
+  priority: taskPrioritySchema.optional(),
+  assignee: z2.string().optional()
+});
+var taskTouchedFileTypeSchema = z2.enum([
+  "test",
+  "implementation",
+  "doc",
+  "config",
+  "other"
+]);
+var taskTouchedFileItemSchema = z2.object({
+  path: z2.string().min(1).max(2048),
+  fileType: taskTouchedFileTypeSchema
+});
+var createTaskBody = z2.object({
+  title: z2.string().min(1),
+  priority: taskPrioritySchema,
+  description: z2.string().nullable().optional(),
+  order: z2.number().int().optional(),
+  assignee: z2.string().nullable().optional(),
+  tags: z2.array(z2.string()).nullable().optional(),
+  dependsOnTaskIds: z2.array(z2.string().min(1)).optional(),
+  touchedFiles: z2.array(taskTouchedFileItemSchema).optional()
+});
+var updateTaskBody = z2.object({
+  title: z2.string().min(1).optional(),
+  description: z2.string().nullable().optional(),
+  priority: taskPrioritySchema.optional(),
+  assignee: z2.string().nullable().optional(),
+  tags: z2.array(z2.string()).nullable().optional(),
+  order: z2.number().int().optional(),
+  touchedFiles: z2.array(taskTouchedFileItemSchema).optional()
+}).refine(
+  (v) => v.title !== void 0 || v.description !== void 0 || v.priority !== void 0 || v.assignee !== void 0 || v.tags !== void 0 || v.order !== void 0 || v.touchedFiles !== void 0,
+  { message: "At least one field is required" }
+);
+var updateTaskStatusBody = z2.object({
+  status: taskStatusSchema
+});
+var assignTaskBody = z2.object({
+  assignee: z2.union([z2.string().min(1), z2.null()])
+});
+var moveTaskBody = z2.object({
+  targetSprintId: z2.string().min(1)
+});
+
+// src/http/routes/v1/plan.routes.ts
+function registerPlanRoutes(router, c) {
+  router.get(
+    "/dashboard-overview",
+    (req, res, next) => void c.getDashboardOverview(req, res, next)
+  );
+  router.get("/plans", (req, res, next) => void c.list(req, res, next));
+  router.post(
+    "/plans",
+    validate({ body: createPlanBody }),
+    (req, res, next) => void c.create(req, res, next)
+  );
+  router.get(
+    "/plans/:idOrSlug/analytics",
+    validate({ params: idOrSlugParams }),
+    (req, res, next) => void c.getPlanAnalytics(req, res, next)
+  );
+  router.get(
+    "/plans/:idOrSlug",
+    validate({ params: idOrSlugParams }),
+    (req, res, next) => void c.getOne(req, res, next)
+  );
+  router.patch(
+    "/plans/:idOrSlug",
+    validate({ params: idOrSlugParams, body: updatePlanBody }),
+    (req, res, next) => void c.update(req, res, next)
+  );
+  router.post(
+    "/plans/:idOrSlug/activate",
+    validate({ params: idOrSlugParams }),
+    (req, res, next) => void c.activate(req, res, next)
+  );
+  router.get(
+    "/execution-context",
+    (req, res, next) => void c.getExecutionContext(req, res, next)
+  );
+}
+
+// src/http/routes/v1/sprint.routes.ts
+function registerSprintRoutes(router, c) {
+  router.get(
+    "/plans/:planId/sprints",
+    validate({ params: planIdParams }),
+    (req, res, next) => void c.listByPlan(req, res, next)
+  );
+  router.post(
+    "/plans/:planId/sprints",
+    validate({ params: planIdParams, body: createSprintBody }),
+    (req, res, next) => void c.create(req, res, next)
+  );
+  router.get(
+    "/sprints/:id",
+    validate({ params: sprintIdPathParams }),
+    (req, res, next) => void c.getOne(req, res, next)
+  );
+  router.patch(
+    "/sprints/:id",
+    validate({ params: sprintIdPathParams, body: updateSprintBody }),
+    (req, res, next) => void c.patch(req, res, next)
+  );
+  router.patch(
+    "/sprints/:id/status",
+    validate({ params: sprintIdPathParams, body: updateSprintStatusBody }),
+    (req, res, next) => void c.updateStatus(req, res, next)
+  );
+}
+
+// src/http/routes/v1/task.routes.ts
+function registerTaskRoutes(router, c) {
+  router.get(
+    "/sprints/:sprintId/tasks",
+    validate({ params: sprintIdParams, query: taskListQuery }),
+    (req, res, next) => void c.listBySprint(req, res, next)
+  );
+  router.post(
+    "/sprints/:sprintId/tasks",
+    validate({ params: sprintIdParams, body: createTaskBody }),
+    (req, res, next) => void c.create(req, res, next)
+  );
+  router.get(
+    "/tasks/:id",
+    validate({ params: taskIdPathParams }),
+    (req, res, next) => void c.getOne(req, res, next)
+  );
+  router.patch(
+    "/tasks/:id",
+    validate({ params: taskIdPathParams, body: updateTaskBody }),
+    (req, res, next) => void c.patch(req, res, next)
+  );
+  router.patch(
+    "/tasks/:id/status",
+    validate({ params: taskIdPathParams, body: updateTaskStatusBody }),
+    (req, res, next) => void c.updateStatus(req, res, next)
+  );
+  router.patch(
+    "/tasks/:id/assign",
+    validate({ params: taskIdPathParams, body: assignTaskBody }),
+    (req, res, next) => void c.assign(req, res, next)
+  );
+  router.post(
+    "/tasks/:id/move",
+    validate({ params: taskIdPathParams, body: moveTaskBody }),
+    (req, res, next) => void c.move(req, res, next)
+  );
+  router.delete(
+    "/tasks/:id",
+    validate({ params: taskIdPathParams }),
+    (req, res, next) => void c.remove(req, res, next)
+  );
+}
+
+// src/http/routes/v1/index.ts
+function createV1Router(services) {
+  const router = Router();
+  const health = new HealthController();
+  const planController = new PlanController(
+    services.planService,
+    services.sprintService,
+    services.taskService
+  );
+  const sprintController = new SprintController(
+    services.sprintService,
+    services.taskService
+  );
+  const taskController = new TaskController(services.taskService);
+  router.get("/health", health.check);
+  registerPlanRoutes(router, planController);
+  registerSprintRoutes(router, sprintController);
+  registerTaskRoutes(router, taskController);
+  return router;
+}
+
+// src/http/middleware/cors.ts
+var DEFAULT_METHODS = "GET,POST,PATCH,DELETE,OPTIONS,HEAD";
+var DEFAULT_ALLOWED_HEADERS = "Content-Type, Authorization, X-Request-Id";
+function corsMiddleware(options) {
+  const origin = options?.origin ?? "*";
+  const methods = options?.methods ?? DEFAULT_METHODS;
+  const allowedHeaders = options?.allowedHeaders ?? DEFAULT_ALLOWED_HEADERS;
+  return (req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Access-Control-Allow-Methods", methods);
+    res.setHeader("Access-Control-Allow-Headers", allowedHeaders);
+    if (req.method === "OPTIONS") {
+      res.status(204).end();
+      return;
+    }
+    next();
+  };
+}
+
+// src/http/middleware/error-handler.ts
+function errorHandler(err, _req, res, next) {
+  if (res.headersSent) {
+    next(err);
+    return;
+  }
+  if (err instanceof BackendError) {
+    res.status(err.statusCode).json({
+      error: {
+        message: err.message,
+        statusCode: err.statusCode
+      }
+    });
+    return;
+  }
+  const message = err instanceof Error ? err.message : "Internal server error";
+  const payload = {
+    error: {
+      message,
+      statusCode: 500
+    }
+  };
+  if (process.env.NODE_ENV !== "production" && err instanceof Error && err.stack) {
+    payload.error.stack = err.stack;
+  }
+  res.status(500).json(payload);
+}
+
+// src/http/middleware/request-id.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var HEADER = "x-request-id";
+function requestIdMiddleware(req, res, next) {
+  const incoming = req.get(HEADER);
+  const id = typeof incoming === "string" && incoming.trim().length > 0 ? incoming.trim() : randomUUID4();
+  req.id = id;
+  res.setHeader("X-Request-Id", id);
+  next();
+}
+
+// src/http/app-factory.ts
+function createHttpApp(services, options) {
+  const app = express();
+  if (options?.trustProxy) {
+    app.set("trust proxy", true);
+  }
+  app.use(express.json());
+  if (options?.cors !== false) {
+    app.use(corsMiddleware());
+  }
+  app.use(requestIdMiddleware);
+  app.get("/", (_req, res) => {
+    res.type("application/json").status(200).send({
+      service: "sprintdock-rest",
+      message: "JSON API lives under /api/v1. Open /api/v1/health to verify the server.",
+      apiBase: "/api/v1",
+      health: "/api/v1/health",
+      webUi: "The browser UI is a separate Vite app (@sprintdock/webui); run pnpm dev:web with SPRINTDOCK_API_BASE_URL pointing at this origin."
+    });
+  });
+  app.use("/api/v1", createV1Router(services));
+  app.use(errorHandler);
+  return app;
+}
+
+// src/mcp/sprintdock-mcp-runtime.ts
+import { getEnv } from "@sprintdock/env-manager";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { resolveWorkspaceRoot as resolveWorkspaceRoot2 } from "@sprintdock/shared";
+
+// src/infrastructure/observability/audit-log.ts
+var ConsoleAuditLog = class {
+  /** @inheritdoc */
+  write(event) {
+    process.stderr.write(`[audit] ${JSON.stringify(event)}
+`);
+  }
+};
+
+// src/infrastructure/observability/request-correlation.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var RequestCorrelation = class {
+  /**
+   * Creates a new unique correlation identifier.
+   *
+   * @returns Correlation id string.
+   */
+  create() {
+    return randomUUID5();
+  }
+};
+
+// src/infrastructure/security/auth-context.ts
+var LocalAuthContextResolver = class {
+  /** @inheritdoc */
+  async resolve(transport) {
+    return {
+      principalId: "local-dev-principal",
+      scopes: ["sprintdock:read", "sprintdock:write"],
+      transport
+    };
+  }
+};
+
+// src/infrastructure/security/rate-limiter.ts
+var InMemoryBackendRateLimiter = class {
+  maxRequests;
+  windowMs;
+  requestWindows;
+  /**
+   * @param maxRequests Maximum allowed requests per window.
+   * @param windowMs Window size in milliseconds.
+   */
+  constructor(maxRequests = 120, windowMs = 6e4) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.requestWindows = /* @__PURE__ */ new Map();
+  }
+  /** @inheritdoc */
+  check(key) {
+    const now = Date.now();
+    const threshold = now - this.windowMs;
+    const previous = this.requestWindows.get(key) ?? [];
+    const currentWindow = previous.filter((timestamp) => timestamp > threshold);
+    if (currentWindow.length >= this.maxRequests) {
+      const oldestRequestTimestamp = currentWindow[0] ?? now;
+      const retryAfterSeconds = Math.max(
+        1,
+        Math.ceil((oldestRequestTimestamp + this.windowMs - now) / 1e3)
+      );
+      this.requestWindows.set(key, currentWindow);
+      return {
+        allowed: false,
+        retryAfterSeconds
+      };
+    }
+    currentWindow.push(now);
+    this.requestWindows.set(key, currentWindow);
+    return {
+      allowed: true,
+      retryAfterSeconds: 0
+    };
+  }
+};
+
+// src/mcp/bootstrap-sprintdock-sqlite.ts
+import { mkdirSync } from "fs";
+import { dirname as dirname2, isAbsolute, join as join2 } from "path";
+import {
+  ensureSprintdockDirectory,
+  resolveSprintdockDbPath,
+  resolveWorkspaceRoot
+} from "@sprintdock/shared";
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// src/db/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  plans: () => plans,
+  plansRelations: () => plansRelations,
+  sprints: () => sprints,
+  sprintsRelations: () => sprintsRelations,
+  taskDependencies: () => taskDependencies,
+  taskTouchedFiles: () => taskTouchedFiles,
+  taskTouchedFilesRelations: () => taskTouchedFilesRelations,
+  tasks: () => tasks,
+  tasksRelations: () => tasksRelations
+});
+
+// src/db/schema/relations.ts
+import { relations } from "drizzle-orm";
+var plansRelations = relations(plans, ({ many }) => ({
+  sprints: many(sprints)
+}));
+var sprintsRelations = relations(sprints, ({ one, many }) => ({
+  plan: one(plans, {
+    fields: [sprints.planId],
+    references: [plans.id]
+  }),
+  tasks: many(tasks)
+}));
+var tasksRelations = relations(tasks, ({ one, many }) => ({
+  sprint: one(sprints, {
+    fields: [tasks.sprintId],
+    references: [sprints.id]
+  }),
+  touchedFiles: many(taskTouchedFiles)
+}));
+var taskTouchedFilesRelations = relations(taskTouchedFiles, ({ one }) => ({
+  task: one(tasks, {
+    fields: [taskTouchedFiles.taskId],
+    references: [tasks.id]
+  })
+}));
+
+// src/db/connection.ts
+function createSqliteConnection(dbPath) {
+  const sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  sqlite.pragma("busy_timeout = 5000");
+  return drizzle(sqlite, { schema: schema_exports });
+}
+
+// src/db/migrator.ts
+import { existsSync } from "fs";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function resolveMigrationsFolder() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(dir, "drizzle");
+    if (existsSync(join(candidate, "meta", "_journal.json"))) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new Error(
+    "Sprintdock: could not find drizzle migrations (expected drizzle/meta/_journal.json next to @sprintdock/backend)."
+  );
+}
+var migrationsFolder = resolveMigrationsFolder();
+function runMigrations(db) {
+  migrate(db, { migrationsFolder });
+}
+
+// src/mcp/bootstrap-sprintdock-sqlite.ts
+async function bootstrapSprintdockSqlite() {
+  const workspaceRoot = resolveWorkspaceRoot();
+  await ensureSprintdockDirectory({ workspaceRoot });
+  const envPath = process.env.SPRINTDOCK_DB_PATH?.trim();
+  const dbPath = envPath && envPath.length > 0 ? isAbsolute(envPath) ? envPath : join2(workspaceRoot, envPath) : resolveSprintdockDbPath({ workspaceRoot });
+  mkdirSync(dirname2(dbPath), { recursive: true });
+  const db = createSqliteConnection(dbPath);
+  runMigrations(db);
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const services = createApplicationServices(repos);
+  return { db, services, dbPath };
+}
+
+// src/mcp/plugins/context-tools.plugin.ts
+import { z as z3 } from "zod";
+
+// src/mcp/mcp-query-helpers.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function looksLikeUuid(value) {
+  return UUID_RE.test(value);
+}
+async function resolvePlanOrActive(planService, planSlug) {
+  if (planSlug !== void 0 && planSlug !== "") {
+    return planService.resolvePlan(planSlug);
+  }
+  return planService.getActivePlan();
+}
+function countByTaskStatus(tasks2) {
+  const base = {
+    todo: 0,
+    in_progress: 0,
+    blocked: 0,
+    done: 0
+  };
+  for (const t of tasks2) {
+    base[t.status] += 1;
+  }
+  return base;
+}
+async function getSprintForPlan(sprintService, plan, sprintIdOrSlug) {
+  if (looksLikeUuid(sprintIdOrSlug)) {
+    const sp = await sprintService.getSprint(sprintIdOrSlug);
+    if (sp.planId !== plan.id) {
+      throw new ValidationError("Sprint does not belong to the resolved plan");
+    }
+    return sp;
+  }
+  return sprintService.getSprintBySlug(plan.id, sprintIdOrSlug);
+}
+async function ensureSprintInPlan(sprintService, plan, sprintId) {
+  const sp = await sprintService.getSprint(sprintId);
+  if (sp.planId !== plan.id) {
+    throw new ValidationError("Sprint does not belong to the resolved plan");
+  }
+  return sp;
+}
+async function ensureTaskInPlan(taskService, sprintService, plan, taskId) {
+  const task = await taskService.getTask(taskId);
+  await ensureSprintInPlan(sprintService, plan, task.sprintId);
+  return task;
+}
+
+// src/mcp/mcp-text-formatters.ts
+var STATUS_ORDER = [
+  "todo",
+  "in_progress",
+  "blocked",
+  "done"
+];
+function shortId(uuid) {
+  return uuid.replace(/-/g, "").slice(0, 8);
+}
+function formatTaskCounts(counts) {
+  const parts = [];
+  for (const s of STATUS_ORDER) {
+    const n = counts[s];
+    if (n > 0) {
+      parts.push(`${n} ${s}`);
+    }
+  }
+  return parts.join(", ");
+}
+function formatTaskLine(task, indent = "") {
+  const assignee = task.assignee !== null && task.assignee !== "" ? `, assignee: ${task.assignee}` : "";
+  return `${indent}- [${task.status}] "${task.title}" (priority: ${task.priority}${assignee}) id:${shortId(task.id)}`;
+}
+function formatPlanList(plans2, activePlanId) {
+  const header = `Plans (${plans2.length}):`;
+  if (plans2.length === 0) {
+    return header;
+  }
+  const lines = plans2.map((p) => {
+    const activeSuffix = p.isActive || p.id === activePlanId ? " (active plan)" : "";
+    return `- ${p.slug} [${p.status}] "${p.title}"${activeSuffix}`;
+  });
+  return `${header}
+${lines.join("\n")}`;
+}
+function formatSprintList(planSlug, sprints2) {
+  const header = `Sprints for '${planSlug}' (${sprints2.length}):`;
+  if (sprints2.length === 0) {
+    return header;
+  }
+  const lines = sprints2.map((s) => {
+    const tc = formatTaskCounts(s.taskCounts);
+    const countsPart = tc.length > 0 ? ` | ${tc}` : "";
+    return `- ${s.slug} [${s.status}] "${s.name}"${countsPart} | sprintId:${s.id}`;
+  });
+  return `${header}
+${lines.join("\n")}`;
+}
+function formatTaskList(tasks2, headerLabel = "Tasks") {
+  const header = `${headerLabel} (${tasks2.length}):`;
+  if (tasks2.length === 0) {
+    return header;
+  }
+  const lines = tasks2.map((t) => formatTaskLine(t));
+  return `${header}
+${lines.join("\n")}`;
+}
+function formatPlanSummary(plan, sprintsOut) {
+  let totalTasks = 0;
+  for (const s of sprintsOut) {
+    totalTasks += Object.values(s.taskCounts).reduce((a, b) => a + b, 0);
+  }
+  const sprintWord = sprintsOut.length === 1 ? "sprint" : "sprints";
+  const taskWord = totalTasks === 1 ? "task" : "tasks";
+  const head = `Plan '${plan.slug}' ("${plan.title}") -- ${sprintsOut.length} ${sprintWord}, ${totalTasks} ${taskWord} total`;
+  if (sprintsOut.length === 0) {
+    return head;
+  }
+  const breakdown = sprintsOut.map((s) => {
+    const tc = formatTaskCounts(s.taskCounts);
+    const countsPart = tc.length > 0 ? `: ${tc}` : ":";
+    return `- ${s.sprintSlug} [${s.status}]${countsPart} (id: ${shortId(s.sprintId)})`;
+  });
+  return `${head}
+
+Sprint breakdown:
+${breakdown.join("\n")}`;
+}
+function formatExecutionContext(planSlug, activeSprints) {
+  const head = `Execution context for '${planSlug}':
+Active sprints (${activeSprints.length}):`;
+  if (activeSprints.length === 0) {
+    return head;
+  }
+  const blocks = activeSprints.map((block) => {
+    const sp = block.sprint;
+    const title = `Sprint '${sp.slug}' "${sp.name}" (id: ${shortId(sp.id)}):`;
+    const taskLines = block.tasks.length === 0 ? "  (no tasks)" : block.tasks.map((t) => formatTaskLine(t, "  ")).join("\n");
+    const summary = `  Summary: ${formatTaskCounts(block.taskCounts)}`;
+    return `${title}
+${taskLines}
+${summary}`;
+  });
+  return `${head}
+
+${blocks.join("\n\n")}`;
+}
+function formatPlanProgress(planSlug, done, totalTasks, sprints2) {
+  const pct = totalTasks === 0 ? 0 : Math.round(done / totalTasks * 100);
+  const head = `Plan '${planSlug}' progress: ${pct}% complete (${done}/${totalTasks} tasks done)`;
+  if (sprints2.length === 0) {
+    return head;
+  }
+  const lines = sprints2.map((s) => {
+    const spct = s.total === 0 ? 0 : Math.round(s.done / s.total * 100);
+    return `- ${s.name} (${s.slug}) [${s.status}]: ${s.done}/${s.total} done (${spct}%)`;
+  });
+  return `${head}
+${lines.join("\n")}`;
+}
+function formatSprintDetail(sprint, tasks2) {
+  const dates = sprint.startDate || sprint.endDate ? `
+Dates: start=${sprint.startDate ?? "\u2014"}, end=${sprint.endDate ?? "\u2014"}` : "";
+  const md = sprint.markdownContent != null && sprint.markdownContent.trim().length > 0 ? `
+
+--- Markdown ---
+${sprint.markdownContent}` : "";
+  const header = `Sprint '${sprint.name}' (${sprint.slug}) [${sprint.status}]
+Goal: ${sprint.goal}${dates}${md}`;
+  const body = formatTaskList(tasks2, "Tasks");
+  return `${header}
+
+${body}`;
+}
+
+// src/mcp/mcp-tool-error.ts
+function toMcpToolError(error) {
+  if (error instanceof BackendError) {
+    return { content: [{ type: "text", text: error.message }], isError: true };
+  }
+  if (error instanceof Error) {
+    return { content: [{ type: "text", text: error.message }], isError: true };
+  }
+  throw error;
+}
+
+// src/mcp/plugins/context-tools.plugin.ts
+var contextToolsPlugin = {
+  id: "sprintdock/context-tools",
+  register(server, ctx) {
+    const { deps, kit } = ctx;
+    const { jsonStructured: jsonStructured2, optionalPlanSlug: optionalPlanSlug2 } = kit;
+    const { planService, sprintService, taskService } = deps.services;
+    server.registerTool(
+      "get_sprint_detail",
+      {
+        description: "Loads one sprint by UUID or sprint slug within the resolved plan, including goal, dates, status, and a full task list with metadata. Prefer this over get_sprint when you need tasks.",
+        inputSchema: z3.object({
+          sprintIdOrSlug: z3.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const tasks2 = await taskService.listTasks(sprint.id);
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatSprintDetail(sprint, tasks2)
+              }
+            ],
+            structuredContent: jsonStructured2({
+              sprintSlug: sprint.slug,
+              sprint,
+              tasks: tasks2
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_execution_context",
+      {
+        description: "Returns the working plan plus every active sprint, each with its full task list and per-status counts. This is the main tool to see what to work on next.",
+        inputSchema: z3.object({ planSlug: optionalPlanSlug2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const all = await sprintService.listSprints(plan.id);
+          const activeSprints = [];
+          for (const sp of all) {
+            if (sp.status !== "active") continue;
+            const tasks2 = await taskService.listTasks(sp.id);
+            activeSprints.push({
+              sprintSlug: sp.slug,
+              sprint: sp,
+              tasks: tasks2,
+              taskCounts: countByTaskStatus(tasks2)
+            });
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatExecutionContext(plan.slug, activeSprints)
+              }
+            ],
+            structuredContent: jsonStructured2({
+              planSlug: plan.slug,
+              planTitle: plan.title,
+              activeSprints
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+  }
+};
+
+// src/mcp/plugins/plan-tools.plugin.ts
+import { z as z4 } from "zod";
+
+// src/mcp/tool-guard.ts
+async function guardToolExecution(authContextResolver, requestCorrelation, rateLimiter, toolName) {
+  const authContext = await authContextResolver.resolve("stdio");
+  const correlationId = requestCorrelation.create();
+  const rateLimit = rateLimiter.check(`${authContext.principalId}:${toolName}`);
+  if (!rateLimit.allowed) {
+    throw new Error(
+      `Rate limit exceeded for tool '${toolName}'. Retry after ${rateLimit.retryAfterSeconds}s.`
+    );
+  }
+  return {
+    principalId: authContext.principalId,
+    correlationId
+  };
+}
+function writeToolAudit(auditLog, action, principalId, correlationId, resourceId, metadata) {
+  auditLog.write({
+    action,
+    principalId,
+    transport: "stdio",
+    resourceId,
+    correlationId,
+    metadata
+  });
+}
+
+// src/mcp/plugins/plan-tools.plugin.ts
+var planToolsPlugin = {
+  id: "sprintdock/plan-tools",
+  register(server, ctx) {
+    const { deps, kit } = ctx;
+    const {
+      jsonStructured: jsonStructured2,
+      applyPagination: applyPagination2,
+      paginationNote: paginationNote2,
+      optionalPlanSlug: optionalPlanSlug2,
+      paginationSchema: paginationSchema2
+    } = kit;
+    const { planService, sprintService, taskService } = deps.services;
+    server.registerTool(
+      "list_plans",
+      {
+        description: "Lists every plan in the SQLite database with slug, title, status, and which plan is active. Use this first to discover planSlug values. Optional limit/offset paginate results; omit both to return the full list.",
+        inputSchema: z4.object({ ...paginationSchema2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plansAll = await planService.listPlans();
+          const { page, total } = applyPagination2(
+            plansAll,
+            input.limit,
+            input.offset
+          );
+          let activePlanId = null;
+          try {
+            activePlanId = (await planService.getActivePlan()).id;
+          } catch {
+            activePlanId = null;
+          }
+          const text4 = formatPlanList(page, activePlanId) + paginationNote2(total, input.limit, input.offset);
+          return {
+            content: [{ type: "text", text: text4 }],
+            structuredContent: jsonStructured2({ plans: page, total })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "create_plan",
+      {
+        description: "Creates a new plan with a kebab-case slug. The first plan in an empty database becomes the active plan automatically. Returns the new plan record.",
+        inputSchema: z4.object({
+          planSlug: z4.string().min(1),
+          title: z4.string().min(1).optional(),
+          initialBody: z4.string().optional()
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "create_plan"
+          );
+          const plan = await planService.createPlan({
+            slug: input.planSlug,
+            title: input.title ?? input.planSlug,
+            markdownContent: input.initialBody ?? null
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "create_plan",
+            guard.principalId,
+            guard.correlationId,
+            plan.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Created plan '${plan.slug}' (${plan.id}).`
+              }
+            ],
+            structuredContent: jsonStructured2({ planSlug: plan.slug, plan })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "set_active_plan",
+      {
+        description: "Switches the active plan used when tools omit planSlug. Pass the plan slug or UUID. Only one plan can be active at a time.",
+        inputSchema: z4.object({ planSlug: z4.string().min(1) }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "set_active_plan"
+          );
+          await planService.setActivePlan(input.planSlug);
+          writeToolAudit(
+            deps.auditLog,
+            "set_active_plan",
+            guard.principalId,
+            guard.correlationId,
+            input.planSlug
+          );
+          return {
+            content: [
+              { type: "text", text: `Active plan set to '${input.planSlug}'.` }
+            ],
+            structuredContent: jsonStructured2({ planSlug: input.planSlug })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_active_plan",
+      {
+        description: "Returns the active plan (or the plan matching optional planSlug) with title, id, and the on-disk plan markdown path.",
+        inputSchema: z4.object({ planSlug: optionalPlanSlug2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Plan '${plan.slug}' (${plan.title}).`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              planSlug: plan.slug,
+              title: plan.title,
+              planId: plan.id,
+              planMarkdownPath: `.sprintdock/plans/${plan.slug}/plan.md`
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_plan_summary",
+      {
+        description: "Returns plan title, updated time, and every sprint with slug, status, id, and task counts by status (todo, in_progress, blocked, done). Use for dashboards before drilling into sprints.",
+        inputSchema: z4.object({ planSlug: optionalPlanSlug2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprints2 = await sprintService.listSprints(plan.id);
+          const sprintsOut = [];
+          for (const sp of sprints2) {
+            const tasks2 = await taskService.listTasks(sp.id);
+            sprintsOut.push({
+              sprintSlug: sp.slug,
+              sprintId: sp.id,
+              name: sp.name,
+              status: sp.status,
+              taskCounts: countByTaskStatus(tasks2)
+            });
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatPlanSummary(plan, sprintsOut)
+              }
+            ],
+            structuredContent: jsonStructured2({
+              planSlug: plan.slug,
+              title: plan.title,
+              updatedAt: plan.updatedAt,
+              sprints: sprintsOut
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_plan_markdown",
+      {
+        description: "Overwrites the plan body markdown stored in SQLite for the resolved plan. Requires auth/rate-limit guard; use for syncing plan docs from agents.",
+        inputSchema: z4.object({
+          content: z4.string(),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_plan_markdown"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const updated = await planService.updatePlan(plan.id, {
+            markdownContent: input.content
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "update_plan_markdown",
+            guard.principalId,
+            guard.correlationId,
+            updated.id
+          );
+          return {
+            content: [{ type: "text", text: "Plan markdown updated." }],
+            structuredContent: jsonStructured2({ ok: true, plan: updated })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "delete_plan",
+      {
+        description: "Deletes a plan and cascades all sprints and tasks. Cannot delete the currently active plan; switch active plan first. Guarded mutation.",
+        inputSchema: z4.object({ planSlug: z4.string().min(1) }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "delete_plan"
+          );
+          const plan = await planService.getPlan(input.planSlug);
+          let active;
+          try {
+            active = await planService.getActivePlan();
+          } catch {
+            active = { id: "" };
+          }
+          if (active.id === plan.id) {
+            throw new ValidationError(
+              "Cannot delete the active plan; set another plan active first."
+            );
+          }
+          await planService.deletePlan(plan.id);
+          writeToolAudit(
+            deps.auditLog,
+            "delete_plan",
+            guard.principalId,
+            guard.correlationId,
+            plan.id,
+            { slug: plan.slug }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Plan '${plan.slug}' ("${plan.title}") deleted.`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              deleted: true,
+              planSlug: plan.slug
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_plan",
+      {
+        description: "Updates plan title, description, or status with domain validation on status transitions. Resolves the plan from optional planSlug or the active plan; at least one field must be provided.",
+        inputSchema: z4.object({
+          planSlug: optionalPlanSlug2,
+          title: z4.string().min(1).optional(),
+          description: z4.string().nullable().optional(),
+          status: z4.enum(["draft", "active", "completed", "archived"]).optional()
+        }).strict().refine(
+          (v) => v.title !== void 0 || v.description !== void 0 || v.status !== void 0,
+          {
+            message: "Provide at least one of title, description, or status."
+          }
+        )
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_plan"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const updated = await planService.updatePlan(plan.id, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.status !== void 0 ? { status: input.status } : {}
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "update_plan",
+            guard.principalId,
+            guard.correlationId,
+            updated.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Plan '${updated.slug}' ("${updated.title}") updated [${updated.status}].`
+              }
+            ],
+            structuredContent: jsonStructured2({ plan: updated })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_plan_progress",
+      {
+        description: "Computes done vs total tasks for the plan and each sprint, with completion percentages. Use for burndown-style snapshots.",
+        inputSchema: z4.object({ planSlug: optionalPlanSlug2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprints2 = await sprintService.listSprints(plan.id);
+          let doneAll = 0;
+          let totalAll = 0;
+          const rows = [];
+          for (const sp of sprints2) {
+            const tasks2 = await taskService.listTasks(sp.id);
+            const done = tasks2.filter((t) => t.status === "done").length;
+            const total = tasks2.length;
+            doneAll += done;
+            totalAll += total;
+            rows.push({
+              slug: sp.slug,
+              name: sp.name,
+              status: sp.status,
+              done,
+              total
+            });
+          }
+          const text4 = formatPlanProgress(plan.slug, doneAll, totalAll, rows);
+          return {
+            content: [{ type: "text", text: text4 }],
+            structuredContent: jsonStructured2({
+              planSlug: plan.slug,
+              done: doneAll,
+              total: totalAll,
+              sprints: rows
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+  }
+};
+
+// src/mcp/plugins/sprint-tools.plugin.ts
+import { z as z5 } from "zod";
+var sprintToolsPlugin = {
+  id: "sprintdock/sprint-tools",
+  register(server, ctx) {
+    const { deps, kit } = ctx;
+    const {
+      jsonStructured: jsonStructured2,
+      applyPagination: applyPagination2,
+      paginationNote: paginationNote2,
+      optionalPlanSlug: optionalPlanSlug2,
+      paginationSchema: paginationSchema2
+    } = kit;
+    const { planService, sprintService, taskService } = deps.services;
+    server.registerTool(
+      "create_sprint",
+      {
+        description: "Creates a sprint under the active or named plan with slug, name, goal, and optional start/end dates. New sprints start in planned status.",
+        inputSchema: z5.object({
+          sprintSlug: z5.string().min(1),
+          name: z5.string().min(1),
+          goal: z5.string().min(1),
+          markdownContent: z5.string().nullable().optional(),
+          startDate: z5.string().datetime().nullable().optional(),
+          endDate: z5.string().datetime().nullable().optional(),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "create_sprint"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await sprintService.createSprint(plan.slug, {
+            slug: input.sprintSlug,
+            planId: plan.id,
+            name: input.name,
+            goal: input.goal,
+            markdownContent: input.markdownContent ?? null,
+            startDate: input.startDate ?? null,
+            endDate: input.endDate ?? null
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "create_sprint",
+            guard.principalId,
+            guard.correlationId,
+            sprint.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Created sprint '${sprint.name}' (${sprint.slug}, id: ${shortId(sprint.id)}).`
+              }
+            ],
+            structuredContent: jsonStructured2(sprint)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "list_sprints",
+      {
+        description: "Lists sprints for the resolved plan with slug, status, name, and live task counts by status. Optional limit/offset paginate; omit both for the full list.",
+        inputSchema: z5.object({ planSlug: optionalPlanSlug2, ...paginationSchema2 }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprints2 = await sprintService.listSprints(plan.id);
+          const withCounts = [];
+          for (const s of sprints2) {
+            const tasks2 = await taskService.listTasks(s.id);
+            withCounts.push({
+              ...s,
+              sprintSlug: s.slug,
+              taskCounts: countByTaskStatus(tasks2)
+            });
+          }
+          const { page, total } = applyPagination2(
+            withCounts,
+            input.limit,
+            input.offset
+          );
+          const text4 = formatSprintList(plan.slug, page) + paginationNote2(total, input.limit, input.offset) + "\nPass each line's slug or `sprintId:<uuid>` as create_task / bulk_create_tasks **sprintIdOrSlug** (with the same planSlug). Full UUIDs are in structuredContent.sprints[].id.";
+          return {
+            content: [{ type: "text", text: text4 }],
+            structuredContent: jsonStructured2({ sprints: page, total })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_sprint",
+      {
+        description: "Loads sprint metadata (name, goal, dates, status) by UUID or sprint slug under the resolved plan. Does not include tasks; use get_sprint_detail for tasks.",
+        inputSchema: z5.object({
+          sprintIdOrSlug: z5.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Sprint '${sprint.name}' (${sprint.slug}) is in status '${sprint.status}' (id: ${shortId(sprint.id)}).`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              ...sprint,
+              sprintSlug: sprint.slug
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_sprint_status",
+      {
+        description: "Moves a sprint through its lifecycle (planned, active, completed, archived) with domain validation. Accepts sprint UUID or slug scoped to the plan.",
+        inputSchema: z5.object({
+          sprintIdOrSlug: z5.string().min(1),
+          status: z5.enum(["planned", "active", "completed", "archived"]),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_sprint_status"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const resolved = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const sprint = await sprintService.updateSprintStatus(
+            resolved.id,
+            input.status
+          );
+          writeToolAudit(
+            deps.auditLog,
+            "update_sprint_status",
+            guard.principalId,
+            guard.correlationId,
+            sprint.id,
+            { status: sprint.status }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Sprint '${sprint.name}' (${sprint.slug}) updated to '${sprint.status}'.`
+              }
+            ],
+            structuredContent: jsonStructured2(sprint)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "delete_sprint",
+      {
+        description: "Deletes a sprint and all of its tasks (cascade). Accepts sprint UUID or slug under the resolved plan. Guarded mutation.",
+        inputSchema: z5.object({
+          sprintIdOrSlug: z5.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "delete_sprint"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          await sprintService.deleteSprint(sprint.id);
+          writeToolAudit(
+            deps.auditLog,
+            "delete_sprint",
+            guard.principalId,
+            guard.correlationId,
+            sprint.id,
+            { slug: sprint.slug }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Sprint '${sprint.name}' (${sprint.slug}, id: ${shortId(sprint.id)}) deleted.`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              deleted: true,
+              sprintId: sprint.id
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_sprint",
+      {
+        description: "Updates sprint name, goal, start/end dates, or order without changing lifecycle status (use update_sprint_status for status). Accepts sprint UUID or slug. Guarded mutation.",
+        inputSchema: z5.object({
+          sprintIdOrSlug: z5.string().min(1),
+          name: z5.string().min(1).optional(),
+          goal: z5.string().min(1).optional(),
+          markdownContent: z5.string().nullable().optional(),
+          startDate: z5.string().datetime().nullable().optional(),
+          endDate: z5.string().datetime().nullable().optional(),
+          order: z5.number().int().optional(),
+          planSlug: optionalPlanSlug2
+        }).strict().refine(
+          (v) => v.name !== void 0 || v.goal !== void 0 || v.markdownContent !== void 0 || v.startDate !== void 0 || v.endDate !== void 0 || v.order !== void 0,
+          { message: "Provide at least one field to update." }
+        )
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_sprint"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const updated = await sprintService.updateSprint(sprint.id, {
+            ...input.name !== void 0 ? { name: input.name } : {},
+            ...input.goal !== void 0 ? { goal: input.goal } : {},
+            ...input.markdownContent !== void 0 ? { markdownContent: input.markdownContent } : {},
+            ...input.startDate !== void 0 ? { startDate: input.startDate } : {},
+            ...input.endDate !== void 0 ? { endDate: input.endDate } : {},
+            ...input.order !== void 0 ? { order: input.order } : {}
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "update_sprint",
+            guard.principalId,
+            guard.correlationId,
+            updated.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Sprint '${updated.name}' (${updated.slug}) updated. (id: ${shortId(updated.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2(updated)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_sprint_markdown",
+      {
+        description: "Overwrites sprint markdown notes (GFM) in SQLite for a sprint under the active or named plan. Use list_sprints / get_sprint_detail to resolve slugs. Guarded mutation.",
+        inputSchema: z5.object({
+          sprintIdOrSlug: z5.string().min(1),
+          content: z5.string(),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_sprint_markdown"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const updated = await sprintService.updateSprint(sprint.id, {
+            markdownContent: input.content
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "update_sprint_markdown",
+            guard.principalId,
+            guard.correlationId,
+            updated.id
+          );
+          return {
+            content: [{ type: "text", text: "Sprint markdown updated." }],
+            structuredContent: jsonStructured2({ ok: true, sprint: updated })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+  }
+};
+
+// src/mcp/plugins/task-tools.plugin.ts
+import { z as z6 } from "zod";
+var TOUCHED_FILE_TYPE = z6.enum([
+  "test",
+  "implementation",
+  "doc",
+  "config",
+  "other"
+]);
+var touchedFilesSchema = z6.array(
+  z6.object({
+    path: z6.string().min(1).max(2048),
+    fileType: TOUCHED_FILE_TYPE
+  })
+).optional();
+var taskToolsPlugin = {
+  id: "sprintdock/task-tools",
+  register(server, ctx) {
+    const { deps, kit } = ctx;
+    const {
+      jsonStructured: jsonStructured2,
+      applyPagination: applyPagination2,
+      paginationNote: paginationNote2,
+      optionalPlanSlug: optionalPlanSlug2,
+      paginationSchema: paginationSchema2,
+      TASK_STATUS_SCHEMA: TASK_STATUS_SCHEMA2,
+      TASK_PRIORITY_SCHEMA: TASK_PRIORITY_SCHEMA2
+    } = kit;
+    const { planService, sprintService, taskService } = deps.services;
+    server.registerTool(
+      "create_task",
+      {
+        description: "Creates a task in a sprint. Pass sprintIdOrSlug: full sprint UUID or sprint slug under the resolved plan (same pattern as get_sprint). Do not read SQLite directly. Order defaults to the end of the sprint. Optional dependsOnTaskIds must reference tasks in the same plan. Optional touchedFiles lists repo paths with file types (test, implementation, doc, config, other). Guarded mutation.",
+        inputSchema: z6.object({
+          title: z6.string().min(1),
+          description: z6.string().default(""),
+          priority: TASK_PRIORITY_SCHEMA2.default("medium"),
+          sprintIdOrSlug: z6.string().min(1),
+          assignee: z6.string().nullable().optional(),
+          tags: z6.array(z6.string()).default([]),
+          order: z6.number().int().optional(),
+          dependsOnTaskIds: z6.array(z6.string()).optional(),
+          touchedFiles: touchedFilesSchema,
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "create_task"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const task = await taskService.createTask(
+            {
+              title: input.title,
+              description: input.description || null,
+              priority: input.priority ?? "medium",
+              sprintId: sprint.id,
+              assignee: input.assignee ?? null,
+              tags: input.tags ?? [],
+              order: input.order,
+              dependsOnTaskIds: input.dependsOnTaskIds,
+              touchedFiles: input.touchedFiles
+            },
+            input.planSlug
+          );
+          writeToolAudit(
+            deps.auditLog,
+            "create_task",
+            guard.principalId,
+            guard.correlationId,
+            task.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Created task '${task.title}' (id: ${shortId(task.id)}).`
+              }
+            ],
+            structuredContent: jsonStructured2(task)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "list_tasks",
+      {
+        description: "Lists tasks for an optional sprint UUID or across the whole plan when sprintId is omitted, with optional filters (status, priority, assignee). Optional limit/offset paginate; omit both for the full filtered list.",
+        inputSchema: z6.object({
+          sprintId: z6.string().optional(),
+          status: TASK_STATUS_SCHEMA2.optional(),
+          priority: TASK_PRIORITY_SCHEMA2.optional(),
+          assignee: z6.string().optional(),
+          planSlug: optionalPlanSlug2,
+          ...paginationSchema2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const filter = input.status || input.priority || input.assignee !== void 0 ? {
+            ...input.status ? { status: input.status } : {},
+            ...input.priority ? { priority: input.priority } : {},
+            ...input.assignee !== void 0 ? { assignee: input.assignee } : {}
+          } : void 0;
+          const tasksAll = await taskService.listTasks(
+            input.sprintId,
+            input.planSlug,
+            filter
+          );
+          const { page, total } = applyPagination2(
+            tasksAll,
+            input.limit,
+            input.offset
+          );
+          const text4 = formatTaskList(page) + paginationNote2(total, input.limit, input.offset);
+          return {
+            content: [{ type: "text", text: text4 }],
+            structuredContent: jsonStructured2({ tasks: page, total })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_task",
+      {
+        description: "Returns one task by UUID with title, status, priority, assignee, tags, order, and sprint. When planSlug is set, verifies the task belongs to that plan.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+          }
+          const task = await taskService.getTask(input.taskId);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${task.title}' currently has status '${task.status}'.`
+              }
+            ],
+            structuredContent: jsonStructured2(task)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_task_status",
+      {
+        description: "Updates a task status with domain transition rules (e.g. done cannot jump back arbitrarily). Guarded mutation; returns the updated task.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          status: TASK_STATUS_SCHEMA2,
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_task_status"
+          );
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+          }
+          const task = await taskService.updateTaskStatus(
+            input.taskId,
+            input.status
+          );
+          writeToolAudit(
+            deps.auditLog,
+            "update_task_status",
+            guard.principalId,
+            guard.correlationId,
+            task.id,
+            { status: task.status }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${task.title}' updated to '${task.status}'. (id: ${shortId(task.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2(task)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "assign_task",
+      {
+        description: "Sets or clears the assignee string on a task (null clears). Guarded mutation; scoped with planSlug when provided.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          assignee: z6.string().nullable(),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "assign_task"
+          );
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+          }
+          const task = await taskService.assignTask(
+            input.taskId,
+            input.assignee
+          );
+          writeToolAudit(
+            deps.auditLog,
+            "assign_task",
+            guard.principalId,
+            guard.correlationId,
+            task.id,
+            { assignee: task.assignee }
+          );
+          const who = task.assignee ?? "unassigned";
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${task.title}' assigned to '${who}'. (id: ${shortId(task.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2(task)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "move_task",
+      {
+        description: "Moves a task to another sprint in the same plan (target sprint UUID). Guarded mutation; confirms the task and target sprint share a plan when planSlug is provided.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          targetSprintId: z6.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "move_task"
+          );
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+            await ensureSprintInPlan(
+              sprintService,
+              plan,
+              input.targetSprintId
+            );
+          }
+          const targetSprint = await sprintService.getSprint(
+            input.targetSprintId
+          );
+          const task = await taskService.moveTask(
+            input.taskId,
+            input.targetSprintId
+          );
+          writeToolAudit(
+            deps.auditLog,
+            "move_task",
+            guard.principalId,
+            guard.correlationId,
+            task.id,
+            { targetSprintId: task.sprintId }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${task.title}' moved to sprint '${targetSprint.name}' (${targetSprint.slug}). (id: ${shortId(task.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2(task)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "delete_task",
+      {
+        description: "Permanently deletes a task by UUID and removes its dependency edges. Guarded mutation. Use delete_sprint to remove a whole sprint. Returns confirmation with the task title and short id.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "delete_task"
+          );
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+          }
+          const before = await taskService.getTask(input.taskId);
+          await taskService.deleteTask(input.taskId);
+          writeToolAudit(
+            deps.auditLog,
+            "delete_task",
+            guard.principalId,
+            guard.correlationId,
+            input.taskId,
+            { title: before.title }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${before.title}' (${shortId(before.id)}) deleted.`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              deleted: true,
+              taskId: input.taskId
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_task",
+      {
+        description: "Updates task title, description, priority, tags, sort order, or touchedFiles (replaces all file rows when set). Does not change status (use update_task_status). Guarded mutation.",
+        inputSchema: z6.object({
+          taskId: z6.string().min(1),
+          title: z6.string().min(1).optional(),
+          description: z6.string().nullable().optional(),
+          priority: TASK_PRIORITY_SCHEMA2.optional(),
+          tags: z6.array(z6.string()).optional(),
+          order: z6.number().int().optional(),
+          touchedFiles: touchedFilesSchema,
+          planSlug: optionalPlanSlug2
+        }).strict().refine(
+          (v) => v.title !== void 0 || v.description !== void 0 || v.priority !== void 0 || v.tags !== void 0 || v.order !== void 0 || v.touchedFiles !== void 0,
+          { message: "Provide at least one field to update." }
+        )
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_task"
+          );
+          if (input.planSlug !== void 0 && input.planSlug !== "") {
+            const plan = await planService.resolvePlan(input.planSlug);
+            await ensureTaskInPlan(
+              taskService,
+              sprintService,
+              plan,
+              input.taskId
+            );
+          }
+          const updated = await taskService.updateTask(input.taskId, {
+            ...input.title !== void 0 ? { title: input.title } : {},
+            ...input.description !== void 0 ? { description: input.description } : {},
+            ...input.priority !== void 0 ? { priority: input.priority } : {},
+            ...input.tags !== void 0 ? { tags: input.tags } : {},
+            ...input.order !== void 0 ? { order: input.order } : {},
+            ...input.touchedFiles !== void 0 ? { touchedFiles: input.touchedFiles } : {}
+          });
+          writeToolAudit(
+            deps.auditLog,
+            "update_task",
+            guard.principalId,
+            guard.correlationId,
+            updated.id
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${updated.title}' updated. (id: ${shortId(updated.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2(updated)
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+  }
+};
+
+// src/mcp/plugins/task-workflow.plugin.ts
+import { z as z7 } from "zod";
+var taskWorkflowPlugin = {
+  id: "sprintdock/task-workflow",
+  register(server, ctx) {
+    const { deps, kit } = ctx;
+    const { jsonStructured: jsonStructured2, optionalPlanSlug: optionalPlanSlug2, TASK_STATUS_SCHEMA: TASK_STATUS_SCHEMA2, TASK_PRIORITY_SCHEMA: TASK_PRIORITY_SCHEMA2 } = kit;
+    const { planService, sprintService, taskService } = deps.services;
+    server.registerTool(
+      "bulk_create_tasks",
+      {
+        description: "Creates up to 50 tasks in one sprint in a single call. Pass sprintIdOrSlug (full UUID or sprint slug under the resolved plan). Each entry supports title, description, priority, assignee, and tags. Guarded mutation.",
+        inputSchema: z7.object({
+          sprintIdOrSlug: z7.string().min(1),
+          tasks: z7.array(
+            z7.object({
+              title: z7.string().min(1),
+              description: z7.string().default(""),
+              priority: TASK_PRIORITY_SCHEMA2.default("medium"),
+              assignee: z7.string().nullable().optional(),
+              tags: z7.array(z7.string()).default([])
+            }).strict()
+          ).min(1).max(50),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "bulk_create_tasks"
+          );
+          const plan = await resolvePlanOrActive(planService, input.planSlug);
+          const sprint = await getSprintForPlan(
+            sprintService,
+            plan,
+            input.sprintIdOrSlug
+          );
+          const created = [];
+          for (const t of input.tasks) {
+            const task = await taskService.createTask(
+              {
+                title: t.title,
+                description: t.description || null,
+                priority: t.priority ?? "medium",
+                sprintId: sprint.id,
+                assignee: t.assignee ?? null,
+                tags: t.tags ?? []
+              },
+              input.planSlug
+            );
+            created.push(task);
+          }
+          writeToolAudit(
+            deps.auditLog,
+            "bulk_create_tasks",
+            guard.principalId,
+            guard.correlationId,
+            sprint.id,
+            { count: created.length }
+          );
+          const lines = created.map(
+            (x) => `- '${x.title}' (id: ${shortId(x.id)})`
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Created ${created.length} task(s):
+${lines.join("\n")}`
+              }
+            ],
+            structuredContent: jsonStructured2({ tasks: created })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "bulk_update_task_status",
+      {
+        description: "Updates status on up to 50 tasks in one call. Each pair must include taskId and target status. Guarded mutation.",
+        inputSchema: z7.object({
+          updates: z7.array(
+            z7.object({
+              taskId: z7.string().min(1),
+              status: TASK_STATUS_SCHEMA2
+            }).strict()
+          ).min(1).max(50),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "bulk_update_task_status"
+          );
+          const done = [];
+          for (const u of input.updates) {
+            if (input.planSlug !== void 0 && input.planSlug !== "") {
+              const plan = await planService.resolvePlan(input.planSlug);
+              await ensureTaskInPlan(
+                taskService,
+                sprintService,
+                plan,
+                u.taskId
+              );
+            }
+            const task = await taskService.updateTaskStatus(
+              u.taskId,
+              u.status
+            );
+            done.push(task);
+          }
+          writeToolAudit(
+            deps.auditLog,
+            "bulk_update_task_status",
+            guard.principalId,
+            guard.correlationId,
+            "bulk",
+            { count: done.length }
+          );
+          const lines = done.map(
+            (x) => `- '${x.title}' -> ${x.status} (id: ${shortId(x.id)})`
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Updated ${done.length} task(s):
+${lines.join("\n")}`
+              }
+            ],
+            structuredContent: jsonStructured2({ tasks: done })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "get_task_dependencies",
+      {
+        description: "Returns tasks this task depends on (prerequisites) and tasks that depend on it (dependents), scoped to the plan when planSlug is set.",
+        inputSchema: z7.object({
+          taskId: z7.string().min(1),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const { dependsOn, dependedOnBy } = await taskService.getTaskDependencyInfo(
+            input.taskId,
+            input.planSlug
+          );
+          const task = await taskService.getTask(input.taskId);
+          const preLines = dependsOn.map(
+            (t) => `- '${t.title}' (id: ${shortId(t.id)})`
+          );
+          const postLines = dependedOnBy.map(
+            (t) => `- '${t.title}' (id: ${shortId(t.id)})`
+          );
+          const text4 = [
+            `Dependencies for '${task.title}' (id: ${shortId(task.id)}):`,
+            "Depends on:",
+            preLines.length ? preLines.join("\n") : "(none)",
+            "Depended on by:",
+            postLines.length ? postLines.join("\n") : "(none)"
+          ].join("\n");
+          return {
+            content: [{ type: "text", text: text4 }],
+            structuredContent: jsonStructured2({
+              task,
+              dependsOn,
+              dependedOnBy
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+    server.registerTool(
+      "update_task_dependencies",
+      {
+        description: "Replaces the full prerequisite list for a task (depends-on edges). Validates acyclic graph within the plan. Guarded mutation.",
+        inputSchema: z7.object({
+          taskId: z7.string().min(1),
+          dependsOnTaskIds: z7.array(z7.string()),
+          planSlug: optionalPlanSlug2
+        }).strict()
+      },
+      async (input) => {
+        try {
+          const guard = await guardToolExecution(
+            deps.authContextResolver,
+            deps.requestCorrelation,
+            deps.rateLimiter,
+            "update_task_dependencies"
+          );
+          await taskService.setTaskDependencies(
+            input.taskId,
+            input.dependsOnTaskIds,
+            input.planSlug
+          );
+          const task = await taskService.getTask(input.taskId);
+          writeToolAudit(
+            deps.auditLog,
+            "update_task_dependencies",
+            guard.principalId,
+            guard.correlationId,
+            input.taskId,
+            { count: input.dependsOnTaskIds.length }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Task '${task.title}' dependencies set (${input.dependsOnTaskIds.length} edge(s)). (id: ${shortId(task.id)})`
+              }
+            ],
+            structuredContent: jsonStructured2({
+              taskId: input.taskId,
+              dependsOnTaskIds: input.dependsOnTaskIds
+            })
+          };
+        } catch (e) {
+          return toMcpToolError(e);
+        }
+      }
+    );
+  }
+};
+
+// src/mcp/plugins/default-plugins.ts
+var defaultSprintdockMcpPlugins = [
+  planToolsPlugin,
+  contextToolsPlugin,
+  sprintToolsPlugin,
+  taskToolsPlugin,
+  taskWorkflowPlugin
+];
+
+// src/mcp/plugins/mcp-tool-kit.ts
+import { z as z8 } from "zod";
+var optionalPlanSlug = z8.string().min(1).optional();
+var paginationSchema = {
+  limit: z8.number().int().min(1).max(100).optional(),
+  offset: z8.number().int().min(0).optional()
+};
+var TASK_STATUS_SCHEMA = z8.enum([
+  "todo",
+  "in_progress",
+  "blocked",
+  "done"
+]);
+var TASK_PRIORITY_SCHEMA = z8.enum([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+function applyPagination(items, limit, offset) {
+  const total = items.length;
+  if (limit === void 0 && offset === void 0) {
+    return { page: items, total };
+  }
+  const off = offset ?? 0;
+  const lim = limit ?? 50;
+  return { page: items.slice(off, off + lim), total };
+}
+function paginationNote(total, limit, offset) {
+  if (limit === void 0 && offset === void 0) {
+    return "";
+  }
+  const off = offset ?? 0;
+  const lim = limit ?? 50;
+  if (total === 0) {
+    return " (showing 0 of 0)";
+  }
+  const end = Math.min(off + lim, total);
+  return ` (showing ${off + 1}-${end} of ${total})`;
+}
+function jsonStructured(data) {
+  return JSON.parse(JSON.stringify(data));
+}
+var kitSingleton = {
+  jsonStructured,
+  applyPagination,
+  paginationNote,
+  optionalPlanSlug,
+  paginationSchema,
+  TASK_STATUS_SCHEMA,
+  TASK_PRIORITY_SCHEMA
+};
+function createSprintdockMcpToolKit() {
+  return kitSingleton;
+}
+
+// src/mcp/register-sprintdock-mcp-tools.ts
+function registerSprintdockMcpTools(server, d, options) {
+  const kit = createSprintdockMcpToolKit();
+  const ctx = { deps: d, kit };
+  const plugins = options?.plugins ?? [...defaultSprintdockMcpPlugins];
+  for (const plugin of plugins) {
+    plugin.register(server, ctx);
+  }
+}
+
+// src/mcp/sprintdock-mcp-capabilities.ts
+var SPRINTDOCK_MCP_CAPABILITIES = {
+  tools: {
+    listChanged: true
+  },
+  logging: {}
+};
+
+// src/mcp/transports/http-app-factory.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+function createSprintdockMcpHttpApp(serverFactory, host) {
+  const app = createMcpExpressApp({ host });
+  app.use("/mcp", async (request, response) => {
+    const server = serverFactory();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID6()
+    });
+    await server.connect(transport);
+    await transport.handleRequest(request, response);
+  });
+  return app;
+}
+
+// src/mcp/transports/http-entry.ts
+async function runHttpTransport(serverFactory, host, port) {
+  const app = createSprintdockMcpHttpApp(serverFactory, host);
+  await new Promise((resolve) => {
+    app.listen(port, host, () => {
+      process.stderr.write(
+        `[sprintdock:backend:mcp] streamable-http listening at http://${host}:${port}/mcp
+`
+      );
+      resolve();
+    });
+  });
+  return 0;
+}
+
+// src/mcp/transports/stdio-entry.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function runStdioTransport(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write("[sprintdock:backend:mcp] stdio transport connected\n");
+  return 0;
+}
+
+// src/mcp/sprintdock-mcp-runtime.ts
+var SprintdockMcpRuntime = class {
+  options;
+  workspaceRoot;
+  toolDeps = null;
+  constructor(options) {
+    this.workspaceRoot = resolveWorkspaceRoot2();
+    const transportEnv = getEnv("SPRINTDOCK_MCP_TRANSPORT", "stdio", {
+      projectRoot: this.workspaceRoot
+    });
+    this.options = {
+      transport: options?.transport ?? transportEnv,
+      httpHost: options?.httpHost,
+      httpPort: options?.httpPort
+    };
+  }
+  /**
+   * Boots SQLite, registers tools, and starts the selected transport.
+   *
+   * @returns Process-style exit code (0 on success).
+   */
+  async run() {
+    const { services, dbPath } = await bootstrapSprintdockSqlite();
+    process.stderr.write(
+      `[sprintdock:backend:mcp] sqlite database: ${dbPath}
+`
+    );
+    this.toolDeps = {
+      services,
+      auditLog: new ConsoleAuditLog(),
+      rateLimiter: new InMemoryBackendRateLimiter(),
+      requestCorrelation: new RequestCorrelation(),
+      authContextResolver: new LocalAuthContextResolver()
+    };
+    if (this.options.transport === "http") {
+      const host = this.options.httpHost ?? getEnv("SPRINTDOCK_MCP_HTTP_HOST", "127.0.0.1", {
+        projectRoot: this.workspaceRoot
+      });
+      const portRaw = this.options.httpPort ?? Number(
+        getEnv("SPRINTDOCK_MCP_HTTP_PORT", "3030", {
+          projectRoot: this.workspaceRoot
+        })
+      );
+      if (!Number.isFinite(portRaw)) {
+        throw new Error("SPRINTDOCK_MCP_HTTP_PORT must be a valid number.");
+      }
+      return runHttpTransport(() => this.createMcpServer(), host, portRaw);
+    }
+    return runStdioTransport(this.createMcpServer());
+  }
+  createMcpServer() {
+    if (!this.toolDeps) {
+      throw new Error("SprintdockMcpRuntime tool dependencies not initialized");
+    }
+    const server = new McpServer(
+      {
+        name: "sprintdock-backend",
+        version: "0.2.0"
+      },
+      {
+        capabilities: SPRINTDOCK_MCP_CAPABILITIES,
+        instructions: "Sprintdock MCP (SQLite): data lives in .sprintdock/sprintdock.db. Use list_plans / create_plan / set_active_plan. Optional planSlug on sprint/task tools scopes to that plan. Plan/sprint/task tools include update_plan_markdown and update_sprint_markdown for long-form notes."
+      }
+    );
+    registerSprintdockMcpTools(server, this.toolDeps);
+    return server;
+  }
+};
+async function runSprintdockMcpServer(options) {
+  const runtime = new SprintdockMcpRuntime(options);
+  return runtime.run();
+}
+export {
+  SprintdockMcpRuntime,
+  bootstrapSprintdockSqlite,
+  createApplicationServices,
+  createHttpApp,
+  createRepositories,
+  createSprintdockMcpToolKit,
+  defaultSprintdockMcpPlugins,
+  registerSprintdockMcpTools,
+  runSprintdockMcpServer
+};