agents-task-assigning 0.1.0

package/dist/index.js

@@ -0,0 +1,1672 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+
+// src/db/schema.ts
+function initializeSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS task_groups (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      group_id TEXT NOT NULL REFERENCES task_groups(id),
+      sequence INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      priority TEXT NOT NULL DEFAULT 'medium',
+      assigned_to TEXT,
+      branch_name TEXT,
+      worktree_path TEXT,
+      progress INTEGER NOT NULL DEFAULT 0,
+      progress_note TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      started_at TEXT,
+      completed_at TEXT,
+      merged_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS task_dependencies (
+      task_id TEXT NOT NULL REFERENCES tasks(id),
+      depends_on TEXT NOT NULL REFERENCES tasks(id),
+      PRIMARY KEY (task_id, depends_on)
+    );
+
+    CREATE TABLE IF NOT EXISTS task_file_ownership (
+      task_id TEXT NOT NULL REFERENCES tasks(id),
+      file_pattern TEXT NOT NULL,
+      ownership_type TEXT NOT NULL DEFAULT 'exclusive',
+      PRIMARY KEY (task_id, file_pattern)
+    );
+
+    CREATE TABLE IF NOT EXISTS progress_logs (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL REFERENCES tasks(id),
+      timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+      event TEXT NOT NULL,
+      message TEXT NOT NULL,
+      metadata TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_group ON tasks(group_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_deps_task ON task_dependencies(task_id);
+    CREATE INDEX IF NOT EXISTS idx_deps_depends ON task_dependencies(depends_on);
+    CREATE INDEX IF NOT EXISTS idx_logs_task ON progress_logs(task_id);
+  `);
+}
+
+// src/db/connection.ts
+var instances = /* @__PURE__ */ new Map();
+function resolveDefaultPath() {
+  const envPath = process.env.TASK_DB_PATH;
+  if (envPath) {
+    return resolve(envPath);
+  }
+  return resolve(process.cwd(), ".tasks", "tasks.db");
+}
+function getDb(dbPath) {
+  const resolvedPath = dbPath ? resolve(dbPath) : resolveDefaultPath();
+  const cached = instances.get(resolvedPath);
+  if (cached) {
+    return cached;
+  }
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  const db = new Database(resolvedPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initializeSchema(db);
+  instances.set(resolvedPath, db);
+  return db;
+}
+
+// src/db/queries.ts
+var TaskQueries = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  // ── Task Groups ──────────────────────────────────────────────────
+  createGroup(group) {
+    const stmt = this.db.prepare(`
+      INSERT INTO task_groups (id, title, description, status)
+      VALUES (@id, @title, @description, @status)
+    `);
+    stmt.run(group);
+    return this.getGroup(group.id);
+  }
+  getGroup(id) {
+    const stmt = this.db.prepare(`
+      SELECT id, title, description, status, created_at
+      FROM task_groups WHERE id = ?
+    `);
+    return stmt.get(id);
+  }
+  // ── Tasks ────────────────────────────────────────────────────────
+  createTask(task) {
+    const stmt = this.db.prepare(`
+      INSERT INTO tasks (id, group_id, sequence, title, description, status, priority,
+                         assigned_to, branch_name, worktree_path, progress, progress_note)
+      VALUES (@id, @group_id, @sequence, @title, @description, @status, @priority,
+              @assigned_to, @branch_name, @worktree_path, @progress, @progress_note)
+    `);
+    stmt.run({
+      id: task.id,
+      group_id: task.group_id,
+      sequence: task.sequence,
+      title: task.title,
+      description: task.description,
+      status: task.status,
+      priority: task.priority,
+      assigned_to: task.assigned_to ?? null,
+      branch_name: task.branch_name ?? null,
+      worktree_path: task.worktree_path ?? null,
+      progress: task.progress,
+      progress_note: task.progress_note ?? null
+    });
+    return this.getTask(task.id);
+  }
+  getTask(id) {
+    const stmt = this.db.prepare(`
+      SELECT id, group_id, sequence, title, description, status, priority,
+             assigned_to, branch_name, worktree_path, progress, progress_note,
+             created_at, started_at, completed_at, merged_at
+      FROM tasks WHERE id = ?
+    `);
+    return stmt.get(id);
+  }
+  getTaskBySequenceAndGroup(groupId, sequence) {
+    const stmt = this.db.prepare(`
+      SELECT id, group_id, sequence, title, description, status, priority,
+             assigned_to, branch_name, worktree_path, progress, progress_note,
+             created_at, started_at, completed_at, merged_at
+      FROM tasks WHERE group_id = ? AND sequence = ?
+    `);
+    return stmt.get(groupId, sequence);
+  }
+  listTasks(opts) {
+    let sql = `
+      SELECT id, group_id, sequence, title, description, status, priority,
+             assigned_to, branch_name, worktree_path, progress, progress_note,
+             created_at, started_at, completed_at, merged_at
+      FROM tasks
+    `;
+    const conditions = [];
+    const params = [];
+    if (opts?.group_id) {
+      conditions.push("group_id = ?");
+      params.push(opts.group_id);
+    }
+    if (opts?.status && opts.status.length > 0) {
+      const placeholders = opts.status.map(() => "?").join(", ");
+      conditions.push(`status IN (${placeholders})`);
+      params.push(...opts.status);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    sql += " ORDER BY sequence ASC";
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+  updateTask(id, updates) {
+    const keys = Object.keys(updates).filter(
+      (k) => updates[k] !== void 0
+    );
+    if (keys.length === 0) {
+      return this.getTask(id);
+    }
+    const setClauses = keys.map((k) => `${k} = @${k}`).join(", ");
+    const sql = `UPDATE tasks SET ${setClauses} WHERE id = @id`;
+    const stmt = this.db.prepare(sql);
+    stmt.run({ id, ...updates });
+    return this.getTask(id);
+  }
+  // ── Dependencies ─────────────────────────────────────────────────
+  addDependency(taskId, dependsOn) {
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO task_dependencies (task_id, depends_on)
+      VALUES (?, ?)
+    `);
+    stmt.run(taskId, dependsOn);
+  }
+  getDependencies(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT t.id, t.group_id, t.sequence, t.title, t.description, t.status,
+             t.priority, t.assigned_to, t.branch_name, t.worktree_path,
+             t.progress, t.progress_note, t.created_at, t.started_at,
+             t.completed_at, t.merged_at
+      FROM task_dependencies d
+      JOIN tasks t ON t.id = d.depends_on
+      WHERE d.task_id = ?
+      ORDER BY t.sequence ASC
+    `);
+    return stmt.all(taskId);
+  }
+  getDependents(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT t.id, t.group_id, t.sequence, t.title, t.description, t.status,
+             t.priority, t.assigned_to, t.branch_name, t.worktree_path,
+             t.progress, t.progress_note, t.created_at, t.started_at,
+             t.completed_at, t.merged_at
+      FROM task_dependencies d
+      JOIN tasks t ON t.id = d.task_id
+      WHERE d.depends_on = ?
+      ORDER BY t.sequence ASC
+    `);
+    return stmt.all(taskId);
+  }
+  // ── File Ownership ───────────────────────────────────────────────
+  addFileOwnership(ownership) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO task_file_ownership (task_id, file_pattern, ownership_type)
+      VALUES (@task_id, @file_pattern, @ownership_type)
+    `);
+    stmt.run(ownership);
+  }
+  getFileOwnership(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT task_id, file_pattern, ownership_type
+      FROM task_file_ownership WHERE task_id = ?
+    `);
+    return stmt.all(taskId);
+  }
+  getFileOwnershipConflicts(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT t.id, t.group_id, t.sequence, t.title, t.description, t.status,
+             t.priority, t.assigned_to, t.branch_name, t.worktree_path,
+             t.progress, t.progress_note, t.created_at, t.started_at,
+             t.completed_at, t.merged_at,
+             other_fo.file_pattern AS pattern,
+             other_fo.ownership_type AS ownership_type
+      FROM task_file_ownership my_fo
+      JOIN task_file_ownership other_fo ON my_fo.file_pattern = other_fo.file_pattern
+      JOIN tasks t ON t.id = other_fo.task_id
+      WHERE my_fo.task_id = ?
+        AND other_fo.task_id != ?
+        AND t.status = 'in_progress'
+    `);
+    const rows = stmt.all(taskId, taskId);
+    return rows.map((row) => {
+      const { pattern, ownership_type, ...taskFields } = row;
+      return {
+        task: taskFields,
+        pattern,
+        ownership_type
+      };
+    });
+  }
+  // ── Progress Logs ────────────────────────────────────────────────
+  addProgressLog(log) {
+    const stmt = this.db.prepare(`
+      INSERT INTO progress_logs (id, task_id, event, message, metadata)
+      VALUES (@id, @task_id, @event, @message, @metadata)
+    `);
+    stmt.run({
+      id: log.id,
+      task_id: log.task_id,
+      event: log.event,
+      message: log.message,
+      metadata: log.metadata ? JSON.stringify(log.metadata) : null
+    });
+    return this.getProgressLog(log.id);
+  }
+  getProgressLogs(taskId) {
+    const stmt = this.db.prepare(`
+      SELECT id, task_id, timestamp, event, message, metadata
+      FROM progress_logs WHERE task_id = ?
+      ORDER BY timestamp ASC
+    `);
+    const rows = stmt.all(taskId);
+    return rows.map((row) => ({
+      ...row,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    }));
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  getProgressLog(id) {
+    const stmt = this.db.prepare(`
+      SELECT id, task_id, timestamp, event, message, metadata
+      FROM progress_logs WHERE id = ?
+    `);
+    const row = stmt.get(id);
+    if (!row) return void 0;
+    return {
+      ...row,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null
+    };
+  }
+};
+
+// src/services/dag-service.ts
+var DagService = class {
+  /**
+   * Validate that adding dependencies won't create a cycle.
+   * Uses DFS-based cycle detection.
+   */
+  validateNoCycles(dependencies) {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = /* @__PURE__ */ new Map();
+    for (const [node, deps] of dependencies) {
+      color.set(node, WHITE);
+      for (const dep of deps) {
+        if (!color.has(dep)) {
+          color.set(dep, WHITE);
+        }
+      }
+    }
+    const parent = /* @__PURE__ */ new Map();
+    const dfs = (node) => {
+      color.set(node, GRAY);
+      const neighbors = dependencies.get(node) ?? [];
+      for (const neighbor of neighbors) {
+        const neighborColor = color.get(neighbor) ?? WHITE;
+        if (neighborColor === GRAY) {
+          const cycle = [neighbor, node];
+          let current = node;
+          while (parent.get(current) !== null && parent.get(current) !== neighbor) {
+            current = parent.get(current);
+            cycle.push(current);
+          }
+          cycle.reverse();
+          return cycle;
+        }
+        if (neighborColor === WHITE) {
+          parent.set(neighbor, node);
+          const result = dfs(neighbor);
+          if (result) return result;
+        }
+      }
+      color.set(node, BLACK);
+      return null;
+    };
+    for (const node of color.keys()) {
+      if (color.get(node) === WHITE) {
+        parent.set(node, null);
+        const cycle = dfs(node);
+        if (cycle) {
+          return { valid: false, cycle };
+        }
+      }
+    }
+    return { valid: true };
+  }
+  /**
+   * Get topological order of tasks using Kahn's algorithm.
+   */
+  topologicalSort(dependencies) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const [node, deps] of dependencies) {
+      if (!inDegree.has(node)) {
+        inDegree.set(node, 0);
+      }
+      if (!adjacency.has(node)) {
+        adjacency.set(node, []);
+      }
+      for (const dep of deps) {
+        if (!inDegree.has(dep)) {
+          inDegree.set(dep, 0);
+        }
+        if (!adjacency.has(dep)) {
+          adjacency.set(dep, []);
+        }
+      }
+    }
+    for (const [node, deps] of dependencies) {
+      inDegree.set(node, (inDegree.get(node) ?? 0) + deps.length);
+      for (const dep of deps) {
+        const adj = adjacency.get(dep) ?? [];
+        adj.push(node);
+        adjacency.set(dep, adj);
+      }
+    }
+    const queue = [];
+    for (const [node, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(node);
+      }
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const node = queue.shift();
+      result.push(node);
+      const neighbors = adjacency.get(node) ?? [];
+      for (const neighbor of neighbors) {
+        const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    if (result.length !== inDegree.size) {
+      throw new Error(
+        "Cannot perform topological sort: graph contains a cycle"
+      );
+    }
+    return result;
+  }
+  /**
+   * Check if a task can start (all dependencies completed).
+   */
+  canStart(taskId, dependencies, completedTasks) {
+    const deps = dependencies.get(taskId) ?? [];
+    return deps.every((dep) => completedTasks.has(dep));
+  }
+  /**
+   * Get all tasks that would be unlocked if a given task is completed.
+   * A task is unlocked when ALL of its dependencies are in the completed set.
+   */
+  getUnlockedTasks(completedTaskId, allDependencies, completedTasks) {
+    const newCompleted = new Set(completedTasks);
+    newCompleted.add(completedTaskId);
+    const unlocked = [];
+    for (const [taskId, deps] of allDependencies) {
+      if (newCompleted.has(taskId)) continue;
+      if (!deps.includes(completedTaskId)) continue;
+      if (deps.every((dep) => newCompleted.has(dep))) {
+        unlocked.push(taskId);
+      }
+    }
+    return unlocked;
+  }
+};
+var dagService = new DagService();
+
+// src/services/git-service.ts
+import { execSync } from "child_process";
+var GitService = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+  }
+  /**
+   * Get the repo root directory.
+   */
+  static getRepoRoot() {
+    try {
+      return execSync("git rev-parse --show-toplevel", {
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+    } catch (error) {
+      throw new Error(
+        `Failed to determine git repo root: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Create a new worktree with a new branch.
+   */
+  createWorktree(worktreePath, branchName) {
+    try {
+      execSync(`git worktree add "${worktreePath}" -b "${branchName}"`, {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to create worktree at ${worktreePath} with branch ${branchName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Remove a worktree.
+   */
+  removeWorktree(worktreePath) {
+    try {
+      execSync(`git worktree remove "${worktreePath}" --force`, {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to remove worktree at ${worktreePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Delete a branch.
+   */
+  deleteBranch(branchName) {
+    try {
+      execSync(`git branch -D "${branchName}"`, {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to delete branch ${branchName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get current branch name.
+   */
+  getCurrentBranch() {
+    try {
+      return execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+    } catch (error) {
+      throw new Error(
+        `Failed to get current branch: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if we're on the main/master branch.
+   */
+  isOnMainBranch() {
+    const branch = this.getCurrentBranch();
+    return branch === "main" || branch === "master";
+  }
+  /**
+   * Get the latest commit hash on a branch.
+   */
+  getLatestCommit(branch) {
+    try {
+      const ref = branch ?? "HEAD";
+      return execSync(`git rev-parse "${ref}"`, {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+    } catch (error) {
+      throw new Error(
+        `Failed to get latest commit${branch ? ` for branch ${branch}` : ""}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if a worktree path exists in the list of worktrees.
+   */
+  worktreeExists(worktreePath) {
+    try {
+      const output = execSync("git worktree list --porcelain", {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      return output.includes(worktreePath);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Merge a branch (squash or regular).
+   * Returns success status and any conflicted files.
+   */
+  mergeBranch(branchName, strategy) {
+    try {
+      const cmd = strategy === "squash" ? `git merge --squash "${branchName}"` : `git merge "${branchName}" --no-edit`;
+      execSync(cmd, {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      return { success: true, conflicts: [] };
+    } catch {
+      const conflicts = this.getConflictedFiles();
+      if (conflicts.length > 0) {
+        return { success: false, conflicts };
+      }
+      throw new Error(`Failed to merge branch ${branchName}`);
+    }
+  }
+  /**
+   * Abort a merge in progress.
+   */
+  abortMerge() {
+    try {
+      execSync("git merge --abort", {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to abort merge: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get list of conflicted files.
+   */
+  getConflictedFiles() {
+    try {
+      const output = execSync("git diff --name-only --diff-filter=U", {
+        cwd: this.repoRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      return output.trim().split("\n").filter((f) => f.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if main branch has new commits since a given commit hash.
+   */
+  hasNewCommitsSince(commitHash) {
+    try {
+      let mainBranch = "main";
+      try {
+        execSync("git rev-parse --verify main", {
+          cwd: this.repoRoot,
+          encoding: "utf-8",
+          stdio: "pipe"
+        });
+      } catch {
+        mainBranch = "master";
+      }
+      const output = execSync(
+        `git log --oneline "${commitHash}..${mainBranch}"`,
+        {
+          cwd: this.repoRoot,
+          encoding: "utf-8",
+          stdio: "pipe"
+        }
+      );
+      return output.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+};
+function createGitService(repoRoot) {
+  const root = repoRoot ?? GitService.getRepoRoot();
+  return new GitService(root);
+}
+
+// src/services/conflict-service.ts
+var ConflictService = class {
+  /**
+   * Check if two glob patterns could overlap.
+   * Simple heuristic: check if one pattern is a prefix of another
+   * after removing glob suffixes like **, *.
+   */
+  patternsOverlap(pattern1, pattern2) {
+    const normalize = (p) => p.replace(/\*\*\/?/g, "").replace(/\*/g, "").replace(/\/+$/, "");
+    const base1 = normalize(pattern1);
+    const base2 = normalize(pattern2);
+    if (base1.length === 0 || base2.length === 0) {
+      return true;
+    }
+    return base1.startsWith(base2) || base2.startsWith(base1);
+  }
+  /**
+   * Find potential conflicts between a task's file patterns and other in-progress tasks.
+   * Only exclusive patterns cause conflicts.
+   */
+  findConflicts(taskPatterns, otherTasks) {
+    const conflicts = [];
+    for (const myOwnership of taskPatterns) {
+      for (const other of otherTasks) {
+        for (const otherOwnership of other.patterns) {
+          if ((myOwnership.ownership_type === "exclusive" || otherOwnership.ownership_type === "exclusive") && this.patternsOverlap(
+            myOwnership.file_pattern,
+            otherOwnership.file_pattern
+          )) {
+            conflicts.push({
+              task: other.task,
+              conflicting_pattern: otherOwnership.file_pattern,
+              ownership_type: otherOwnership.ownership_type
+            });
+          }
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Check if a specific file matches any of the given patterns.
+   * Uses simple string matching: startsWith for directory patterns (ending with ** or *).
+   */
+  fileMatchesPatterns(filePath, patterns) {
+    for (const pattern of patterns) {
+      const base = pattern.replace(/\*\*\/?$/, "").replace(/\*$/, "");
+      if (base.length === 0) {
+        return true;
+      }
+      if (filePath.startsWith(base)) {
+        return true;
+      }
+      if (filePath === pattern) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check changed files against other tasks' exclusive patterns.
+   * Returns warning messages for any files that conflict.
+   */
+  checkFileConflicts(changedFiles, otherTasks) {
+    const warnings = [];
+    for (const file of changedFiles) {
+      for (const other of otherTasks) {
+        const exclusivePatterns = other.patterns.filter((p) => p.ownership_type === "exclusive").map((p) => p.file_pattern);
+        if (this.fileMatchesPatterns(file, exclusivePatterns)) {
+          warnings.push(
+            `File "${file}" conflicts with task #${other.task.sequence} "${other.task.title}" which has exclusive ownership`
+          );
+        }
+      }
+    }
+    return warnings;
+  }
+};
+var conflictService = new ConflictService();
+
+// src/services/task-service.ts
+import { v4 as uuidv4 } from "uuid";
+import slugify from "slugify";
+import { resolve as resolve2 } from "path";
+var TaskService = class {
+  queries;
+  dagService;
+  gitService;
+  conflictService;
+  constructor(db, gitRepoRoot) {
+    this.queries = new TaskQueries(db);
+    this.dagService = dagService;
+    this.conflictService = conflictService;
+    if (gitRepoRoot) {
+      this.gitService = new GitService(gitRepoRoot);
+    } else {
+      try {
+        this.gitService = createGitService();
+      } catch {
+        this.gitService = new GitService(process.cwd());
+      }
+    }
+  }
+  // === Task Management ===
+  /**
+   * Create a task group with tasks, dependencies, and file ownership.
+   */
+  createTasks(input) {
+    const groupId = uuidv4();
+    const warnings = [];
+    this.queries.createGroup({
+      id: groupId,
+      title: input.group_title,
+      description: input.group_description,
+      status: "active"
+    });
+    const sequenceToIdMap = /* @__PURE__ */ new Map();
+    const createdTasks = [];
+    for (let i = 0; i < input.tasks.length; i++) {
+      const taskInput = input.tasks[i];
+      const sequence = i + 1;
+      const taskId = uuidv4();
+      sequenceToIdMap.set(sequence, taskId);
+      const task = this.queries.createTask({
+        id: taskId,
+        group_id: groupId,
+        sequence,
+        title: taskInput.title,
+        description: taskInput.description,
+        status: "pending",
+        // Will be updated after dependency analysis
+        priority: taskInput.priority ?? "medium",
+        assigned_to: null,
+        branch_name: null,
+        worktree_path: null,
+        progress: 0,
+        progress_note: null
+      });
+      createdTasks.push(task);
+    }
+    const dependencyMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < input.tasks.length; i++) {
+      const taskInput = input.tasks[i];
+      const sequence = i + 1;
+      const taskId = sequenceToIdMap.get(sequence);
+      const deps = [];
+      if (taskInput.depends_on && taskInput.depends_on.length > 0) {
+        for (const depSequence of taskInput.depends_on) {
+          const depId = sequenceToIdMap.get(depSequence);
+          if (depId) {
+            this.queries.addDependency(taskId, depId);
+            deps.push(depId);
+          } else {
+            warnings.push(
+              `Task #${sequence} "${taskInput.title}" references invalid dependency sequence #${depSequence}`
+            );
+          }
+        }
+      }
+      dependencyMap.set(taskId, deps);
+    }
+    for (let i = 0; i < input.tasks.length; i++) {
+      const taskInput = input.tasks[i];
+      const sequence = i + 1;
+      const taskId = sequenceToIdMap.get(sequence);
+      if (taskInput.file_patterns) {
+        for (const fp of taskInput.file_patterns) {
+          this.queries.addFileOwnership({
+            task_id: taskId,
+            file_pattern: fp.pattern,
+            ownership_type: fp.ownership_type
+          });
+        }
+      }
+    }
+    const validation = this.dagService.validateNoCycles(dependencyMap);
+    if (!validation.valid) {
+      warnings.push(
+        `Dependency cycle detected: ${validation.cycle?.join(" -> ")}`
+      );
+    }
+    for (let i = 0; i < input.tasks.length; i++) {
+      const taskInputI = input.tasks[i];
+      const seqI = i + 1;
+      const taskIdI = sequenceToIdMap.get(seqI);
+      if (!taskInputI.file_patterns) continue;
+      for (let j = i + 1; j < input.tasks.length; j++) {
+        const taskInputJ = input.tasks[j];
+        const seqJ = j + 1;
+        if (!taskInputJ.file_patterns) continue;
+        for (const fpI of taskInputI.file_patterns) {
+          for (const fpJ of taskInputJ.file_patterns) {
+            if ((fpI.ownership_type === "exclusive" || fpJ.ownership_type === "exclusive") && this.conflictService.patternsOverlap(fpI.pattern, fpJ.pattern)) {
+              warnings.push(
+                `File pattern overlap: task #${seqI} "${taskInputI.title}" (${fpI.pattern}) and task #${seqJ} "${taskInputJ.title}" (${fpJ.pattern})`
+              );
+            }
+          }
+        }
+      }
+    }
+    const completedTasks = /* @__PURE__ */ new Set();
+    const outputTasks = [];
+    for (let i = 0; i < createdTasks.length; i++) {
+      const sequence = i + 1;
+      const taskId = sequenceToIdMap.get(sequence);
+      const deps = dependencyMap.get(taskId) ?? [];
+      const hasDeps = deps.length > 0;
+      if (hasDeps) {
+        this.queries.updateTask(taskId, { status: "blocked" });
+      }
+      const canStart = this.dagService.canStart(
+        taskId,
+        dependencyMap,
+        completedTasks
+      );
+      outputTasks.push({
+        id: taskId,
+        sequence,
+        title: createdTasks[i].title,
+        status: hasDeps ? "blocked" : "pending",
+        can_start: canStart
+      });
+    }
+    return {
+      group_id: groupId,
+      tasks: outputTasks,
+      warnings
+    };
+  }
+  /**
+   * List tasks with computed can_start and summary.
+   */
+  listTasks(input) {
+    const tasks = this.queries.listTasks({
+      group_id: input.group_id,
+      status: input.status
+    });
+    const dependencyMap = /* @__PURE__ */ new Map();
+    const completedTasks = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      const deps = this.queries.getDependencies(task.id);
+      dependencyMap.set(
+        task.id,
+        deps.map((d) => d.id)
+      );
+      if (task.status === "completed") {
+        completedTasks.add(task.id);
+      }
+    }
+    const outputTasks = tasks.map((task) => {
+      const deps = this.queries.getDependencies(task.id);
+      const canStart = task.status === "pending" && this.dagService.canStart(task.id, dependencyMap, completedTasks);
+      return {
+        id: task.id,
+        sequence: task.sequence,
+        title: task.title,
+        status: task.status,
+        progress: task.progress,
+        progress_note: task.progress_note,
+        assigned_to: task.assigned_to,
+        branch_name: task.branch_name,
+        worktree_path: task.worktree_path,
+        dependencies: deps.map((d) => ({
+          sequence: d.sequence,
+          title: d.title,
+          status: d.status
+        })),
+        can_start: canStart
+      };
+    });
+    const summary = {
+      total: tasks.length,
+      pending: tasks.filter((t) => t.status === "pending").length,
+      in_progress: tasks.filter((t) => t.status === "in_progress").length,
+      in_review: tasks.filter((t) => t.status === "in_review").length,
+      completed: tasks.filter((t) => t.status === "completed").length,
+      blocked: tasks.filter((t) => t.status === "blocked").length
+    };
+    return { tasks: outputTasks, summary };
+  }
+  /**
+   * Get a task with all related data.
+   */
+  getTask(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    const deps = this.queries.getDependencies(task.id);
+    const fileOwnership = this.queries.getFileOwnership(task.id);
+    const progressLogs = this.queries.getProgressLogs(task.id);
+    return {
+      task,
+      dependencies: deps.map((d) => ({
+        sequence: d.sequence,
+        title: d.title,
+        status: d.status
+      })),
+      file_ownership: fileOwnership,
+      progress_logs: progressLogs
+    };
+  }
+  // === Agent Workflow ===
+  /**
+   * Claim a task for an agent. Uses a transaction for atomicity.
+   */
+  claimTask(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      return {
+        success: false,
+        task: null,
+        error: `Task not found: ${input.task_id}`
+      };
+    }
+    if (task.status !== "pending") {
+      return {
+        success: false,
+        task,
+        error: `Task is not pending (current status: ${task.status})`
+      };
+    }
+    const deps = this.queries.getDependencies(task.id);
+    const unmetDeps = deps.filter((d) => d.status !== "completed");
+    if (unmetDeps.length > 0) {
+      return {
+        success: false,
+        task,
+        error: `Unmet dependencies: ${unmetDeps.map((d) => `#${d.sequence} "${d.title}" (${d.status})`).join(", ")}`
+      };
+    }
+    const conflicts = this.queries.getFileOwnershipConflicts(task.id);
+    if (conflicts.length > 0) {
+      return {
+        success: false,
+        task,
+        error: `File ownership conflicts with in-progress tasks: ${conflicts.map((c) => `#${c.task.sequence} "${c.task.title}" on pattern "${c.pattern}"`).join(", ")}`
+      };
+    }
+    const agentId = input.agent_id ?? `agent-${uuidv4().slice(0, 8)}`;
+    const updatedTask = this.queries.updateTask(task.id, {
+      status: "assigned",
+      assigned_to: agentId
+    });
+    this.queries.addProgressLog({
+      id: uuidv4(),
+      task_id: task.id,
+      event: "claimed",
+      message: `Task claimed by ${agentId}`,
+      metadata: { agent_id: agentId }
+    });
+    return {
+      success: true,
+      task: updatedTask
+    };
+  }
+  /**
+   * Start a task: create git worktree, update task state.
+   */
+  startTask(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    if (task.status !== "assigned") {
+      throw new Error(
+        `Task must be 'assigned' to start (current status: ${task.status})`
+      );
+    }
+    const slugifiedTitle = slugify(task.title, {
+      lower: true,
+      strict: true
+    }).slice(0, 30);
+    const branchName = `task/task-${task.sequence}-${slugifiedTitle}`;
+    const worktreePath = resolve2(
+      this.gitService["repoRoot"],
+      ".worktrees",
+      `task-${task.sequence}-${slugifiedTitle}`
+    );
+    this.gitService.createWorktree(worktreePath, branchName);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedTask = this.queries.updateTask(task.id, {
+      status: "in_progress",
+      branch_name: branchName,
+      worktree_path: worktreePath,
+      started_at: now
+    });
+    this.queries.addProgressLog({
+      id: uuidv4(),
+      task_id: task.id,
+      event: "started",
+      message: `Task started with branch ${branchName}`,
+      metadata: {
+        branch_name: branchName,
+        worktree_path: worktreePath
+      }
+    });
+    const deps = this.queries.getDependencies(task.id);
+    const fileOwnership = this.queries.getFileOwnership(task.id);
+    return {
+      success: true,
+      worktree_path: worktreePath,
+      branch_name: branchName,
+      task: updatedTask,
+      context: {
+        description: task.description,
+        file_patterns: fileOwnership.map((fo) => fo.file_pattern),
+        dependencies_completed: deps.filter((d) => d.status === "completed").map((d) => ({
+          title: d.title,
+          branch_name: d.branch_name ?? ""
+        }))
+      }
+    };
+  }
+  /**
+   * Update progress on a task.
+   */
+  updateProgress(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    this.queries.updateTask(task.id, {
+      progress: input.progress,
+      progress_note: input.note
+    });
+    let conflictWarnings = [];
+    if (input.files_changed && input.files_changed.length > 0) {
+      const allTasks = this.queries.listTasks({
+        group_id: task.group_id,
+        status: ["in_progress"]
+      });
+      const otherTasks = allTasks.filter((t) => t.id !== task.id).map((t) => ({
+        task: t,
+        patterns: this.queries.getFileOwnership(t.id)
+      }));
+      conflictWarnings = this.conflictService.checkFileConflicts(
+        input.files_changed,
+        otherTasks
+      );
+    }
+    let rebaseRecommended = false;
+    if (task.branch_name) {
+      try {
+        const mainCommit = this.gitService.getLatestCommit("HEAD");
+        rebaseRecommended = this.gitService.hasNewCommitsSince(mainCommit);
+      } catch {
+      }
+    }
+    this.queries.addProgressLog({
+      id: uuidv4(),
+      task_id: task.id,
+      event: "progress_update",
+      message: input.note,
+      metadata: {
+        progress: input.progress,
+        files_changed: input.files_changed ?? [],
+        conflict_warnings: conflictWarnings
+      }
+    });
+    return {
+      success: true,
+      conflict_warnings: conflictWarnings,
+      rebase_recommended: rebaseRecommended
+    };
+  }
+  /**
+   * Mark a task as complete and find unlocked downstream tasks.
+   */
+  completeTask(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    if (task.status !== "in_progress") {
+      throw new Error(
+        `Task must be 'in_progress' to complete (current status: ${task.status})`
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedTask = this.queries.updateTask(task.id, {
+      status: "in_review",
+      completed_at: now,
+      progress: 100,
+      progress_note: input.summary
+    });
+    const allGroupTasks = this.queries.listTasks({ group_id: task.group_id });
+    const completedTasks = new Set(
+      allGroupTasks.filter((t) => t.status === "completed" || t.status === "in_review").map((t) => t.id)
+    );
+    completedTasks.add(task.id);
+    const dependencyMap = /* @__PURE__ */ new Map();
+    for (const t of allGroupTasks) {
+      const deps = this.queries.getDependencies(t.id);
+      dependencyMap.set(
+        t.id,
+        deps.map((d) => d.id)
+      );
+    }
+    const unlockedIds = this.dagService.getUnlockedTasks(
+      task.id,
+      dependencyMap,
+      completedTasks
+    );
+    const unlockedTasks = unlockedIds.map((id) => allGroupTasks.find((t) => t.id === id)).filter((t) => t !== void 0).map((t) => ({
+      sequence: t.sequence,
+      title: t.title
+    }));
+    for (const id of unlockedIds) {
+      const t = allGroupTasks.find((at) => at.id === id);
+      if (t && t.status === "blocked") {
+        this.queries.updateTask(id, { status: "pending" });
+      }
+    }
+    this.queries.addProgressLog({
+      id: uuidv4(),
+      task_id: task.id,
+      event: "completed",
+      message: input.summary,
+      metadata: {
+        files_changed: input.files_changed,
+        unlocked_tasks: unlockedTasks
+      }
+    });
+    return {
+      success: true,
+      task: updatedTask,
+      unlocked_tasks: unlockedTasks
+    };
+  }
+  // === Integration ===
+  /**
+   * Merge a task's branch into the main branch.
+   */
+  mergeTask(input) {
+    if (!this.gitService.isOnMainBranch()) {
+      throw new Error(
+        "Must be on main/master branch to merge. Current branch: " + this.gitService.getCurrentBranch()
+      );
+    }
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    if (task.status !== "in_review") {
+      throw new Error(
+        `Task must be 'in_review' to merge (current status: ${task.status})`
+      );
+    }
+    if (!task.branch_name) {
+      throw new Error("Task has no branch to merge");
+    }
+    const strategy = input.strategy ?? "squash";
+    const mergeResult = this.gitService.mergeBranch(task.branch_name, strategy);
+    if (mergeResult.success) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.queries.updateTask(task.id, {
+        status: "completed",
+        merged_at: now
+      });
+      if (task.worktree_path) {
+        try {
+          if (this.gitService.worktreeExists(task.worktree_path)) {
+            this.gitService.removeWorktree(task.worktree_path);
+          }
+        } catch {
+        }
+      }
+      try {
+        this.gitService.deleteBranch(task.branch_name);
+      } catch {
+      }
+      const allGroupTasks = this.queries.listTasks({
+        group_id: task.group_id
+      });
+      const completedTasks = new Set(
+        allGroupTasks.filter((t) => t.status === "completed").map((t) => t.id)
+      );
+      const dependencyMap = /* @__PURE__ */ new Map();
+      for (const t of allGroupTasks) {
+        const deps = this.queries.getDependencies(t.id);
+        dependencyMap.set(
+          t.id,
+          deps.map((d) => d.id)
+        );
+      }
+      const unlockedIds = this.dagService.getUnlockedTasks(
+        task.id,
+        dependencyMap,
+        completedTasks
+      );
+      const unlockedTasks = unlockedIds.map((id) => allGroupTasks.find((t) => t.id === id)).filter((t) => t !== void 0).map((t) => {
+        const canStart = this.dagService.canStart(
+          t.id,
+          dependencyMap,
+          completedTasks
+        );
+        return {
+          sequence: t.sequence,
+          title: t.title,
+          can_start: canStart
+        };
+      });
+      for (const id of unlockedIds) {
+        const t = allGroupTasks.find((at) => at.id === id);
+        if (t && t.status === "blocked") {
+          this.queries.updateTask(id, { status: "pending" });
+        }
+      }
+      this.queries.addProgressLog({
+        id: uuidv4(),
+        task_id: task.id,
+        event: "merged",
+        message: `Task merged via ${strategy} strategy`,
+        metadata: {
+          strategy,
+          unlocked_tasks: unlockedTasks
+        }
+      });
+      return {
+        success: true,
+        merge_result: "clean",
+        unlocked_tasks: unlockedTasks
+      };
+    } else {
+      const conflicts = mergeResult.conflicts.map((file) => ({
+        file,
+        description: `Merge conflict in ${file}`,
+        auto_resolvable: false,
+        suggestion: `Manually resolve conflicts in ${file} and commit the result`
+      }));
+      this.queries.addProgressLog({
+        id: uuidv4(),
+        task_id: task.id,
+        event: "conflict_detected",
+        message: `Merge conflicts detected in ${mergeResult.conflicts.length} file(s)`,
+        metadata: {
+          conflicted_files: mergeResult.conflicts,
+          strategy
+        }
+      });
+      return {
+        success: false,
+        merge_result: "conflict",
+        conflicts,
+        unlocked_tasks: []
+      };
+    }
+  }
+  /**
+   * Clean up a task: remove worktree, delete branch, mark as failed.
+   */
+  cleanupTask(input) {
+    const task = this.queries.getTask(input.task_id);
+    if (!task) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    let worktreeRemoved = false;
+    let branchRemoved = false;
+    if (task.worktree_path) {
+      try {
+        if (this.gitService.worktreeExists(task.worktree_path)) {
+          this.gitService.removeWorktree(task.worktree_path);
+          worktreeRemoved = true;
+        }
+      } catch {
+      }
+    }
+    if (task.branch_name) {
+      try {
+        this.gitService.deleteBranch(task.branch_name);
+        branchRemoved = true;
+      } catch {
+      }
+    }
+    this.queries.updateTask(task.id, {
+      status: "failed"
+    });
+    this.queries.addProgressLog({
+      id: uuidv4(),
+      task_id: task.id,
+      event: "failed",
+      message: input.reason ?? "Task cleaned up and marked as failed",
+      metadata: {
+        reason: input.reason,
+        worktree_removed: worktreeRemoved,
+        branch_removed: branchRemoved
+      }
+    });
+    return {
+      success: true,
+      cleaned: {
+        worktree_removed: worktreeRemoved,
+        branch_removed: branchRemoved
+      }
+    };
+  }
+};
+
+// src/server.ts
+var taskService = null;
+function getTaskService() {
+  if (!taskService) {
+    const db = getDb();
+    taskService = new TaskService(db);
+  }
+  return taskService;
+}
+function createServer() {
+  const server2 = new McpServer({
+    name: "task-manager",
+    version: "0.1.0"
+  });
+  server2.tool(
+    "create_tasks",
+    "Create a group of tasks from a high-level requirement. Analyzes dependencies and file ownership.",
+    {
+      group_title: z.string().describe("Title for the task group"),
+      group_description: z.string().describe("Description of the overall requirement"),
+      tasks: z.array(
+        z.object({
+          title: z.string(),
+          description: z.string(),
+          priority: z.enum(["high", "medium", "low"]).optional().default("medium"),
+          depends_on: z.array(z.number()).optional().default([]),
+          file_patterns: z.array(
+            z.object({
+              pattern: z.string(),
+              ownership_type: z.enum(["exclusive", "shared"])
+            })
+          ).optional().default([])
+        })
+      )
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().createTasks(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "list_tasks",
+    "List tasks with optional filtering by group and status. Can include progress details.",
+    {
+      group_id: z.string().optional(),
+      status: z.array(
+        z.enum([
+          "pending",
+          "assigned",
+          "in_progress",
+          "in_review",
+          "completed",
+          "failed",
+          "blocked"
+        ])
+      ).optional(),
+      include_progress: z.boolean().optional().default(false)
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().listTasks(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_task",
+    "Get detailed information about a specific task including dependencies, file ownership, and progress logs.",
+    {
+      task_id: z.string()
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().getTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "claim_task",
+    "Claim a task for an agent. Assigns the task and checks for dependency and file ownership conflicts.",
+    {
+      task_id: z.string(),
+      agent_id: z.string().optional()
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().claimTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "start_task",
+    "Start working on a claimed task. Creates a git worktree and branch for isolated work.",
+    {
+      task_id: z.string()
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().startTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "update_progress",
+    "Update progress on an in-progress task. Reports percentage complete and checks for file conflicts.",
+    {
+      task_id: z.string(),
+      progress: z.number().min(0).max(100),
+      note: z.string(),
+      files_changed: z.array(z.string()).optional()
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().updateProgress(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "complete_task",
+    "Mark a task as completed with a summary and list of changed files. Moves task to in_review status.",
+    {
+      task_id: z.string(),
+      summary: z.string(),
+      files_changed: z.array(z.string())
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().completeTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "merge_task",
+    "Merge a completed task branch back into the main branch. Supports merge and squash strategies.",
+    {
+      task_id: z.string(),
+      strategy: z.enum(["merge", "squash"]).optional().default("squash")
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().mergeTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "cleanup_task",
+    "Clean up a task by removing its worktree and branch. Used after merging or to abandon a task.",
+    {
+      task_id: z.string(),
+      reason: z.string().optional()
+    },
+    async (params) => {
+      try {
+        const result = getTaskService().cleanupTask(params);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  return server2;
+}
+var server = createServer();
+
+// src/index.ts
+async function main() {
+  const server2 = createServer();
+  const transport = new StdioServerTransport();
+  await server2.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map