taskin 1.0.4 → 1.0.6

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -9,6 +10,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // ../../node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
@@ -23,11 +28,172 @@ var init_esm_shims = __esm({
   }
 });
 
+// ../fs-task-provider/dist/task-validator.js
+var task_validator_exports = {};
+__export(task_validator_exports, {
+  createLintResult: () => createLintResult,
+  fixTaskFile: () => fixTaskFile,
+  validateTaskFile: () => validateTaskFile
+});
+import { readFile, writeFile } from "fs/promises";
+async function fixTaskFile(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const hasInlineStatus = /^Status:\s*.+$/im.test(content);
+    const hasInlineType = /^Type:\s*.+$/im.test(content);
+    const hasInlineAssignee = /^Assignee:\s*.+$/im.test(content);
+    if (!hasInlineStatus && !hasInlineType && !hasInlineAssignee) {
+      return false;
+    }
+    const statusMatch = content.match(/^Status:\s*(.+)$/im);
+    const typeMatch = content.match(/^Type:\s*(.+)$/im);
+    const assigneeMatch = content.match(/^Assignee:\s*(.+)$/im);
+    let newContent = content;
+    if (statusMatch) {
+      newContent = newContent.replace(/^Status:\s*.+$/im, "");
+    }
+    if (typeMatch) {
+      newContent = newContent.replace(/^Type:\s*.+$/im, "");
+    }
+    if (assigneeMatch) {
+      newContent = newContent.replace(/^Assignee:\s*.+$/im, "");
+    }
+    newContent = newContent.replace(/\n{3,}/g, "\n\n");
+    const titleLineIdx = newContent.split("\n").findIndex((line) => line.trim().startsWith("# "));
+    if (titleLineIdx === -1) {
+      return false;
+    }
+    const contentLines = newContent.split("\n");
+    const beforeTitle = contentLines.slice(0, titleLineIdx + 1);
+    const afterTitle = contentLines.slice(titleLineIdx + 1);
+    const sections = [];
+    if (statusMatch) {
+      sections.push("", "## Status", "", statusMatch[1].trim());
+    }
+    if (typeMatch) {
+      sections.push("", "## Type", "", typeMatch[1].trim());
+    }
+    if (assigneeMatch) {
+      sections.push("", "## Assignee", "", assigneeMatch[1].trim());
+    }
+    const fixed = [...beforeTitle, ...sections, "", ...afterTitle].join("\n");
+    const finalContent = fixed.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+    await writeFile(filePath, finalContent, "utf-8");
+    return true;
+  } catch (error2) {
+    console.error(`Failed to fix ${filePath}:`, error2);
+    return false;
+  }
+}
+async function validateTaskFile(filePath) {
+  const issues = [];
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const hasTitleSection = lines.some((line) => line.trim().startsWith("# "));
+    const hasStatusSection = content.includes("## Status");
+    const hasInlineStatus = /^Status:\s*.+$/im.test(content);
+    const hasDescriptionSection = content.includes("## Description") || content.includes("## Descri\xE7\xE3o");
+    if (!hasTitleSection) {
+      issues.push({
+        file: filePath,
+        line: 1,
+        message: "Task file must start with a title (# Task Title)",
+        severity: "error",
+        suggestion: "Add a level-1 heading at the start: # Your Task Title"
+      });
+    }
+    if (hasInlineStatus) {
+      const statusLineIdx = lines.findIndex((line) => /^Status:/i.test(line.trim()));
+      issues.push({
+        file: filePath,
+        line: statusLineIdx >= 0 ? statusLineIdx + 1 : void 0,
+        message: 'Inline metadata ("Status: ...") is not allowed. Use a "## Status" section instead.',
+        severity: "error",
+        suggestion: "Replace inline metadata with a section:\n## Status\n<todo|in-progress|done>"
+      });
+    }
+    if (!hasStatusSection) {
+      issues.push({
+        file: filePath,
+        message: "Task file must have a ## Status section",
+        severity: "error",
+        suggestion: "Add a section:\n## Status\n<todo|in-progress|done>"
+      });
+    } else {
+      const statusMatch = content.match(/## Status\s*\n\s*([^\n\r]+)/i);
+      const statusValue = statusMatch ? statusMatch[1].trim().toLowerCase() : "";
+      if (!["todo", "in-progress", "done", "pending"].includes(statusValue)) {
+        const statusLineIdx = lines.findIndex((line) => line.trim() === "## Status");
+        issues.push({
+          file: filePath,
+          line: statusLineIdx >= 0 ? statusLineIdx + 2 : void 0,
+          message: "Status must be one of: todo, in-progress, done, pending",
+          severity: "error",
+          suggestion: "Set status to: todo, in-progress, done, or pending"
+        });
+      }
+    }
+    if (!hasDescriptionSection) {
+      issues.push({
+        file: filePath,
+        message: "Task file should have a description section (## Description or ## Descri\xE7\xE3o)",
+        severity: "warning",
+        suggestion: "Add a description section to explain the task"
+      });
+    }
+    const fileName = filePath.split("/").pop() || "";
+    if (!fileName.match(/^task-\d{3}-.*\.md$/)) {
+      issues.push({
+        file: filePath,
+        message: "Task filename should follow pattern: task-NNN-description.md (e.g., task-001-my-task.md)",
+        severity: "warning",
+        suggestion: "Rename the file to match the pattern task-001-description.md"
+      });
+    }
+    const titleLine = lines.findIndex((line) => line.trim().startsWith("# "));
+    if (titleLine >= 0 && lines[titleLine].trim() === "#") {
+      issues.push({
+        file: filePath,
+        line: titleLine + 1,
+        message: "Task title cannot be empty",
+        severity: "error",
+        suggestion: "Add a meaningful title after the # symbol"
+      });
+    }
+  } catch (error2) {
+    issues.push({
+      file: filePath,
+      message: `Failed to read or parse task file: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      severity: "error"
+    });
+  }
+  return issues;
+}
+function createLintResult(allIssues) {
+  const errorCount = allIssues.filter((issue) => issue.severity === "error").length;
+  const warningCount = allIssues.filter((issue) => issue.severity === "warning").length;
+  const infoCount = allIssues.filter((issue) => issue.severity === "info").length;
+  return {
+    valid: errorCount === 0,
+    issues: allIssues,
+    errorCount,
+    warningCount,
+    infoCount
+  };
+}
+var init_task_validator = __esm({
+  "../fs-task-provider/dist/task-validator.js"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/index.ts
 init_esm_shims();
 import { Command } from "commander";
 
-// src/commands/finish.ts
+// src/commands/dashboard.ts
 init_esm_shims();
 
 // ../fs-task-provider/dist/index.js
@@ -37,10 +203,53 @@ init_esm_shims();
 init_esm_shims();
 import { promises as fs } from "fs";
 import path2 from "path";
+
+// ../fs-task-provider/dist/i18n.js
+init_esm_shims();
+var i18nConfig = {
+  "en-US": {
+    status: "Status",
+    type: "Type",
+    assignee: "Assignee",
+    description: "Description",
+    tasks: "Tasks",
+    notes: "Notes",
+    defaultAssignee: "To be defined",
+    descriptionPlaceholder: "Add task description here...",
+    notesPlaceholder: "Add any relevant notes or links here."
+  },
+  "pt-BR": {
+    status: "Status",
+    type: "Tipo",
+    assignee: "Respons\xE1vel",
+    description: "Descri\xE7\xE3o",
+    tasks: "Tarefas",
+    notes: "Notas",
+    defaultAssignee: "A definir",
+    descriptionPlaceholder: "Adicione a descri\xE7\xE3o da tarefa aqui...",
+    notesPlaceholder: "Adicione notas ou links relevantes aqui."
+  }
+};
+function getI18n(locale = "en-US") {
+  return i18nConfig[locale];
+}
+function detectLocale(content) {
+  if (content.includes("## Descri\xE7\xE3o") || content.includes("## Tipo") || content.includes("## Respons\xE1vel") || content.includes("## Tarefas")) {
+    return "pt-BR";
+  }
+  return "en-US";
+}
+
+// ../fs-task-provider/dist/fs-task-provider.js
+init_task_validator();
 var FileSystemTaskProvider = class {
   tasksDirectory;
-  constructor(tasksDirectory) {
+  userRegistry;
+  locale;
+  constructor(tasksDirectory, userRegistry, locale = "en-US") {
     this.tasksDirectory = tasksDirectory;
+    this.userRegistry = userRegistry;
+    this.locale = locale;
   }
   async findTask(taskId) {
     const files = await fs.readdir(this.tasksDirectory);
@@ -52,25 +261,59 @@ var FileSystemTaskProvider = class {
     const content = await fs.readFile(filePath, "utf-8");
     const titleMatch = content.match(/^# .*Task.*?[—-]\s*(.+)$/im);
     const title = titleMatch ? titleMatch[1].trim() : "Untitled";
-    const headerSection = content.split(/^##/m)[0];
-    const statusMatch = headerSection.match(/^Status:\s*(.+)$/im);
-    const typeMatch = headerSection.match(/^Type:\s*(.+)$/im);
-    const userMatch = headerSection.match(/^Assignee:\s*(.+)$/im);
+    const contentLocale = detectLocale(content);
+    const i18n = getI18n(contentLocale);
+    const extractSection = (name, localizedName) => {
+      const names = localizedName && localizedName !== name ? [localizedName, name] : [name];
+      for (const n of names) {
+        const rx = new RegExp(`##\\s*${n}\\s*\\n\\s*([^\\n\\r]+)`, "i");
+        const m = content.match(rx);
+        if (m)
+          return m[1].trim();
+      }
+      return null;
+    };
+    const statusMatch = extractSection("Status", i18n.status);
+    const typeMatch = extractSection("Type", i18n.type);
+    const assigneeMatch = extractSection("Assignee", i18n.assignee);
+    let assignee;
+    if (assigneeMatch) {
+      const assigneeValue = assigneeMatch.trim();
+      assignee = this.userRegistry.resolveUser(assigneeValue);
+      if (!assignee) {
+        console.warn(`[FS Provider] User "${assigneeValue}" not found in registry, creating temporary user`);
+        assignee = this.userRegistry.createTemporaryUser(assigneeValue);
+      }
+    }
     const task = {
       id: taskId,
       title,
       content,
       filePath,
-      userId: userMatch ? userMatch[1].trim() : void 0,
-      status: statusMatch ? statusMatch[1].trim().toLowerCase() : "pending",
-      type: typeMatch ? typeMatch[1].trim().toLowerCase() : "feat",
+      assignee,
+      status: statusMatch ? statusMatch.trim().toLowerCase() : "pending",
+      type: typeMatch ? typeMatch.trim().toLowerCase() : "feat",
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     return task;
   }
   async updateTask(task) {
     const currentContent = await fs.readFile(task.filePath, "utf-8");
-    const updatedContent = currentContent.replace(/^Status:\s*.+$/im, `Status: ${task.status}`);
+    const hasInlineMetadata = /^(Status|Type|Assignee):\s*.+$/im.test(currentContent);
+    if (hasInlineMetadata) {
+      const { fixTaskFile: fixTaskFile2 } = await Promise.resolve().then(() => (init_task_validator(), task_validator_exports));
+      await fixTaskFile2(task.filePath);
+    }
+    const content = await fs.readFile(task.filePath, "utf-8");
+    let updatedContent;
+    if (/##\s*Status/i.test(content)) {
+      updatedContent = content.replace(/(##\s*Status\s*\n\s*)([^\n\r]*)/i, `$1${task.status}`);
+    } else {
+      updatedContent = content.replace(/(^#.*\n)/, `$1
+## Status
+${task.status}
+`);
+    }
     await fs.writeFile(task.filePath, updatedContent, "utf-8");
   }
   async getAllTasks() {
@@ -84,24 +327,236 @@ var FileSystemTaskProvider = class {
       const taskId = idMatch ? idMatch[1] : "unknown";
       const titleMatch = content.match(/^# .*Task.*?[—-]\s*(.+)$/im);
       const title = titleMatch ? titleMatch[1].trim() : "Untitled";
-      const headerSection = content.split(/^##/m)[0];
-      const statusMatch = headerSection.match(/^Status:\s*(.+)$/im);
-      const typeMatch = headerSection.match(/^Type:\s*(.+)$/im);
-      const userMatch = headerSection.match(/^Assignee:\s*(.+)$/im);
+      const contentLocale = detectLocale(content);
+      const i18n = getI18n(contentLocale);
+      const extractSection = (name, localizedName) => {
+        const names = localizedName && localizedName !== name ? [localizedName, name] : [name];
+        for (const n of names) {
+          const rx = new RegExp(`##\\s*${n}\\s*\\n\\s*([^\\n\\r]+)`, "i");
+          const m = content.match(rx);
+          if (m)
+            return m[1].trim();
+        }
+        return null;
+      };
+      const statusMatch = extractSection("Status", i18n.status);
+      const typeMatch = extractSection("Type", i18n.type);
+      const assigneeMatch = extractSection("Assignee", i18n.assignee);
+      let assignee;
+      if (assigneeMatch) {
+        const assigneeValue = assigneeMatch.trim();
+        assignee = this.userRegistry.resolveUser(assigneeValue);
+        if (!assignee) {
+          assignee = this.userRegistry.createTemporaryUser(assigneeValue);
+        }
+      }
       const task = {
         id: taskId,
         title,
         content,
         filePath,
-        userId: userMatch ? userMatch[1].trim() : void 0,
-        status: statusMatch ? statusMatch[1].trim().toLowerCase() : "pending",
-        type: typeMatch ? typeMatch[1].trim().toLowerCase() : "feat",
+        assignee,
+        status: statusMatch ? statusMatch.trim().toLowerCase() : "pending",
+        type: typeMatch ? typeMatch.trim().toLowerCase() : "feat",
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       tasks.push(task);
     }
     return tasks;
   }
+  async createTask(options) {
+    const i18n = getI18n(this.locale);
+    const allTasks = await this.getAllTasks();
+    const taskNumbers = allTasks.map((task2) => {
+      const match = task2.id.match(/^(\d+)$/);
+      return match ? parseInt(match[1], 10) : 0;
+    }).filter((num) => !isNaN(num));
+    const nextNumber = taskNumbers.length > 0 ? Math.max(...taskNumbers) + 1 : 1;
+    const taskId = String(nextNumber).padStart(3, "0");
+    const titleSlug = options.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const fileName = `task-${taskId}-${titleSlug}.md`;
+    const filePath = path2.join(this.tasksDirectory, fileName);
+    const fileExists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (fileExists) {
+      throw new Error(`Task file already exists: ${fileName}`);
+    }
+    let assignee;
+    if (options.assignee) {
+      assignee = this.userRegistry.resolveUser(options.assignee);
+      if (!assignee) {
+        assignee = this.userRegistry.createTemporaryUser(options.assignee);
+      }
+    }
+    const taskContent = this.generateTaskMarkdown({
+      id: taskId,
+      title: options.title,
+      type: options.type,
+      description: options.description || "",
+      assignee: assignee?.name || i18n.defaultAssignee,
+      i18n
+    });
+    await fs.writeFile(filePath, taskContent, "utf-8");
+    const task = await this.findTask(taskId);
+    if (!task) {
+      throw new Error(`Failed to create task ${taskId}`);
+    }
+    return {
+      task,
+      taskId,
+      filePath
+    };
+  }
+  generateTaskMarkdown(data) {
+    const { id, title, type, description, assignee, i18n } = data;
+    return `# \u{1F9E9} Task ${id} \u2014 ${title}
+
+## ${i18n.status}
+
+pending
+
+## ${i18n.type}
+
+${type}
+
+## ${i18n.assignee}
+
+${assignee}
+
+## ${i18n.description}
+
+${description || i18n.descriptionPlaceholder}
+
+## ${i18n.tasks}
+
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## ${i18n.notes}
+
+${i18n.notesPlaceholder}
+`;
+  }
+  async lint(fix) {
+    const files = await fs.readdir(this.tasksDirectory);
+    const taskFiles = files.filter((file) => file.startsWith("task-") && file.endsWith(".md")).map((file) => path2.join(this.tasksDirectory, file));
+    if (fix) {
+      let fixedCount = 0;
+      for (const filePath of taskFiles) {
+        const wasFixed = await fixTaskFile(filePath);
+        if (wasFixed) {
+          fixedCount++;
+        }
+      }
+      if (fixedCount > 0) {
+        console.log(`\u2728 Fixed ${fixedCount} task file(s)`);
+      }
+    }
+    const allIssues = [];
+    for (const filePath of taskFiles) {
+      const issues = await validateTaskFile(filePath);
+      allIssues.push(...issues);
+    }
+    return createLintResult(allIssues);
+  }
+};
+
+// ../fs-task-provider/dist/user-registry.js
+init_esm_shims();
+import { promises as fs2 } from "fs";
+import path3 from "path";
+var UserRegistry = class {
+  config;
+  users = /* @__PURE__ */ new Map();
+  usersFilePath;
+  constructor(config) {
+    this.config = config;
+    this.usersFilePath = path3.join(config.taskinDir, "users.json");
+  }
+  /**
+   * Load users from users.json
+   */
+  async load() {
+    try {
+      const content = await fs2.readFile(this.usersFilePath, "utf-8");
+      const data = JSON.parse(content);
+      this.users.clear();
+      for (const [id, user] of Object.entries(data.users)) {
+        this.users.set(id, user);
+      }
+      console.log(`[UserRegistry] Loaded ${this.users.size} users`);
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        console.warn(
+          "[UserRegistry] users.json not found, starting with empty registry"
+        );
+        this.users.clear();
+      } else {
+        throw error2;
+      }
+    }
+  }
+  /**
+   * Get user by ID
+   */
+  getUser(userId) {
+    return this.users.get(userId);
+  }
+  /**
+   * Resolve user from name or ID
+   * Tries to match by ID first, then by name
+   */
+  resolveUser(nameOrId) {
+    const byId = this.users.get(nameOrId);
+    if (byId) return byId;
+    const slug = nameOrId.toLowerCase().replace(/\s+/g, "-");
+    const bySlug = this.users.get(slug);
+    if (bySlug) return bySlug;
+    for (const user of this.users.values()) {
+      if (user.name.toLowerCase() === nameOrId.toLowerCase()) {
+        return user;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Create a temporary user if not found in registry
+   * Useful for backward compatibility
+   */
+  createTemporaryUser(nameOrId) {
+    const slug = nameOrId.toLowerCase().replace(/\s+/g, "-");
+    return {
+      id: slug,
+      name: nameOrId,
+      email: `${slug.replace(/\s+/g, ".")}@example.com`
+    };
+  }
+  /**
+   * Get all users
+   */
+  getAllUsers() {
+    return Array.from(this.users.values());
+  }
+  /**
+   * Add or update a user
+   */
+  async saveUser(user) {
+    this.users.set(user.id, user);
+    await this.save();
+  }
+  /**
+   * Save users to users.json
+   */
+  async save() {
+    const data = {
+      users: Object.fromEntries(this.users.entries())
+    };
+    await fs2.writeFile(
+      this.usersFilePath,
+      JSON.stringify(data, null, 2),
+      "utf-8"
+    );
+  }
 };
 
 // ../task-manager/dist/index.js
@@ -138,29 +593,141 @@ var TaskManager = class {
     await this.taskProvider.updateTask(updatedTask);
     return updatedTask;
   }
+  async createTask(options) {
+    return this.taskProvider.createTask(options);
+  }
+  async lint(fix) {
+    return this.taskProvider.lint(fix);
+  }
 };
 
-// ../task-manager/dist/task-manager.mock.js
+// ../task-manager/dist/task-manager.types.js
 init_esm_shims();
 
-// ../task-manager/dist/task-manager.types.js
+// src/commands/dashboard.ts
+import { TaskWebSocketServer } from "@opentask/taskin-task-server-ws";
+
+// ../utils/dist/index.js
 init_esm_shims();
 
-// src/commands/finish.ts
-import path5 from "path";
+// ../utils/dist/security.js
+init_esm_shims();
+import { z } from "zod";
+var HostSchema = z.string().refine((host) => {
+  if (!host || host.length === 0)
+    return false;
+  if (host === "localhost")
+    return true;
+  const parts = host.split(".");
+  const allNumeric = parts.every((p) => /^\d+$/.test(p));
+  if (allNumeric) {
+    if (parts.length !== 4)
+      return false;
+    return parts.every((part) => {
+      const num = parseInt(part, 10);
+      return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
+    });
+  }
+  const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+  return hostnameRegex.test(host);
+}, {
+  message: "Invalid host. Must be localhost, a valid IPv4 address, or hostname."
+});
+var PortSchema = z.union([
+  z.number().int().min(1).max(65535),
+  z.string().regex(/^\d+$/).transform((val) => parseInt(val, 10)).pipe(z.number().int().min(1).max(65535))
+]);
+var WebSocketUrlSchema = z.string().refine((url) => {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "ws:" || parsed.protocol === "wss:";
+  } catch {
+    return false;
+  }
+}, { message: "Invalid WebSocket URL. Must use ws:// or wss:// protocol." });
+var TaskIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/, {
+  message: "Task ID must contain only alphanumeric characters, hyphens, and underscores."
+});
+var UserIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9._-]+$/, {
+  message: "User ID must contain only alphanumeric characters, dots, hyphens, and underscores."
+});
+var EmailSchema = z.string().email().max(254);
+var SafePathSchema = z.string().refine((filePath) => {
+  if (!filePath || filePath.length === 0)
+    return false;
+  const dangerousPatterns = [
+    /\.\./,
+    // Parent directory (..)
+    /~\//,
+    // Home directory
+    /^\//,
+    // Absolute path
+    /^[A-Za-z]:\\/
+    // Windows absolute path
+  ];
+  return !dangerousPatterns.some((pattern) => pattern.test(filePath));
+}, {
+  message: "Invalid path. Must be a relative path without traversal patterns."
+});
+var DashboardOptionsSchema = z.object({
+  host: HostSchema.optional(),
+  port: PortSchema.optional(),
+  wsPort: PortSchema.optional()
+});
+function isValidHost(host) {
+  return HostSchema.safeParse(host).success;
+}
+function isValidPort(port) {
+  return PortSchema.safeParse(port).success;
+}
+function escapeHtml(text) {
+  if (!text || typeof text !== "string") {
+    return "";
+  }
+  const htmlEscapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "/": "&#x2F;"
+  };
+  return text.replace(/[&<>"'/]/g, (char) => htmlEscapeMap[char]);
+}
 
-// src/lib/colors.ts
+// ../utils/dist/ui.js
 init_esm_shims();
 import chalk from "chalk";
 var colors = {
-  info: chalk.cyan,
+  primary: chalk.blue,
+  secondary: chalk.gray,
   success: chalk.green,
   warning: chalk.yellow,
   error: chalk.red,
-  highlight: chalk.bold.white,
-  secondary: chalk.gray,
+  info: chalk.cyan,
+  highlight: chalk.magenta,
   normal: chalk.white
 };
+
+// src/commands/dashboard.ts
+import chalk3 from "chalk";
+import express from "express";
+import { createServer } from "http";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/colors.ts
+init_esm_shims();
+import chalk2 from "chalk";
+var colors2 = {
+  info: chalk2.cyan,
+  success: chalk2.green,
+  warning: chalk2.yellow,
+  error: chalk2.red,
+  highlight: chalk2.bold.white,
+  secondary: chalk2.gray,
+  normal: chalk2.white
+};
 var icons = {
   rocket: "\u{1F680}",
   list: "\u{1F4CA}",
@@ -172,27 +739,27 @@ var icons = {
 };
 function printHeader(title, icon) {
   console.log();
-  console.log(colors.highlight("\u2550".repeat(60)));
-  console.log(colors.highlight(`${icon}  ${title}`));
-  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log(colors2.highlight("\u2550".repeat(60)));
+  console.log(colors2.highlight(`${icon}  ${title}`));
+  console.log(colors2.highlight("\u2550".repeat(60)));
   console.log();
 }
 function success(message) {
-  console.log(colors.success(`\u2713 ${message}`));
+  console.log(colors2.success(`\u2713 ${message}`));
 }
 function error(message) {
-  console.error(colors.error(`\u2717 ${message}`));
+  console.error(colors2.error(`\u2717 ${message}`));
 }
 function info(message) {
-  console.log(colors.info(`\u2139 ${message}`));
+  console.log(colors2.info(`\u2139 ${message}`));
 }
 
 // src/lib/project-check.ts
 init_esm_shims();
 import { existsSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 function isTaskinProject(cwd = process.cwd()) {
-  return existsSync(path3.join(cwd, ".taskin.json"));
+  return existsSync(path4.join(cwd, ".taskin.json"));
 }
 function requireTaskinProject(cwd = process.cwd()) {
   if (!isTaskinProject(cwd)) {
@@ -203,35 +770,6 @@ function requireTaskinProject(cwd = process.cwd()) {
   }
 }
 
-// src/lib/sound-player.ts
-init_esm_shims();
-import { existsSync as existsSync2 } from "fs";
-import path4 from "path";
-import player from "play-sound";
-var soundPlayer = player({});
-function playSound(soundName) {
-  try {
-    const possiblePaths = [
-      // In development (from src)
-      path4.join(process.cwd(), "packages", "cli", "sounds", `${soundName}.mp3`),
-      // In production (relative to dist)
-      path4.join(__dirname, "..", "sounds", `${soundName}.mp3`),
-      // Custom sound in project root
-      path4.join(process.cwd(), ".taskin", `${soundName}.mp3`)
-    ];
-    const soundPath = possiblePaths.find((p) => existsSync2(p));
-    if (!soundPath) {
-      return;
-    }
-    soundPlayer.play(soundPath, (err) => {
-      if (err) {
-        return;
-      }
-    });
-  } catch {
-  }
-}
-
 // src/commands/define-command/index.ts
 init_esm_shims();
 
@@ -262,6 +800,233 @@ var defineCommand = (config) => {
 // src/commands/define-command/define-command.types.ts
 init_esm_shims();
 
+// src/commands/dashboard.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+var dashboardCommand = defineCommand({
+  name: "dashboard",
+  description: "\u{1F4CA} Start the Taskin dashboard with WebSocket server",
+  alias: "dash",
+  options: [
+    {
+      flags: "-p, --port <port>",
+      description: "Vite dev server port",
+      defaultValue: "5173"
+    },
+    {
+      flags: "-w, --ws-port <port>",
+      description: "WebSocket server port",
+      defaultValue: "3001"
+    },
+    {
+      flags: "-h, --host <host>",
+      description: "Host to bind servers",
+      defaultValue: "localhost"
+    },
+    {
+      flags: "-o, --open",
+      description: "Open browser automatically"
+    }
+  ],
+  handler: async (options) => {
+    await startDashboard(options);
+  }
+});
+async function startDashboard(options) {
+  requireTaskinProject();
+  const host = options.host || "localhost";
+  if (!isValidHost(host)) {
+    error("Security validation failed");
+    error(
+      `Invalid host: ${host}. Must be localhost, a valid IPv4 address, or hostname.`
+    );
+    process.exit(1);
+  }
+  if (typeof options.port === "string" && !isValidPort(options.port)) {
+    error("Security validation failed");
+    error(`Invalid port: ${options.port}. Must be between 1 and 65535.`);
+    process.exit(1);
+  }
+  if (typeof options.wsPort === "string" && !isValidPort(options.wsPort)) {
+    error("Security validation failed");
+    error(
+      `Invalid WebSocket port: ${options.wsPort}. Must be between 1 and 65535.`
+    );
+    process.exit(1);
+  }
+  const port = typeof options.port === "string" ? parseInt(options.port, 10) : options.port || 5173;
+  const wsPort = typeof options.wsPort === "string" ? parseInt(options.wsPort, 10) : options.wsPort || 3001;
+  if (!isValidPort(port)) {
+    error("Security validation failed");
+    error(`Invalid port: ${port}. Must be between 1 and 65535.`);
+    process.exit(1);
+  }
+  if (!isValidPort(wsPort)) {
+    error("Security validation failed");
+    error(`Invalid WebSocket port: ${wsPort}. Must be between 1 and 65535.`);
+    process.exit(1);
+  }
+  printHeader("Starting Taskin Dashboard", "\u{1F4CA}");
+  try {
+    info("Initializing task provider...");
+    let currentDir = process.cwd();
+    let tasksDir = path5.join(currentDir, "TASKS");
+    try {
+      await import("fs").then((fs3) => fs3.promises.access(tasksDir));
+    } catch {
+      while (currentDir !== path5.dirname(currentDir)) {
+        const workspaceFile = path5.join(currentDir, "pnpm-workspace.yaml");
+        try {
+          await import("fs").then((fs3) => fs3.promises.access(workspaceFile));
+          tasksDir = path5.join(currentDir, "TASKS");
+          break;
+        } catch {
+          currentDir = path5.dirname(currentDir);
+        }
+      }
+    }
+    info(`Using tasks directory: ${tasksDir}`);
+    const monorepoRoot = path5.dirname(tasksDir);
+    const taskinDir = path5.join(monorepoRoot, ".taskin");
+    const userRegistry = new UserRegistry({ taskinDir });
+    await userRegistry.load();
+    const provider = new FileSystemTaskProvider(tasksDir, userRegistry);
+    const manager = new TaskManager(provider);
+    info(`Starting WebSocket server on ${host}:${wsPort}...`);
+    const wsServer = new TaskWebSocketServer({
+      taskManager: manager,
+      taskProvider: provider,
+      options: {
+        port: wsPort,
+        host
+      }
+    });
+    await wsServer.start();
+    success(`\u2713 WebSocket server running on ws://${host}:${wsPort}`);
+    info(`Starting dashboard server on http://${host}:${port}...`);
+    const isDev = __dirname2.includes("/src/");
+    const dashboardDist = isDev ? path5.join(__dirname2, "..", "..", "dashboard-dist") : path5.join(__dirname2, "..", "dashboard-dist");
+    const app = express();
+    app.disable("x-powered-by");
+    app.use((req, res, next) => {
+      res.setHeader("X-Frame-Options", "DENY");
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("X-XSS-Protection", "1; mode=block");
+      res.setHeader(
+        "Content-Security-Policy",
+        "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self' ws: wss:;"
+      );
+      next();
+    });
+    app.use((req, res, next) => {
+      if (req.path === "/" || req.path === "/index.html") {
+        import("fs").then(
+          (fs3) => fs3.promises.readFile(
+            path5.join(dashboardDist, "index.html"),
+            "utf-8"
+          )
+        ).then((html) => {
+          const safeHost = escapeHtml(host);
+          const safeWsPort = escapeHtml(String(wsPort));
+          const injectedHtml = html.replace(
+            "</head>",
+            `<script>window.VITE_WS_URL = 'ws://${safeHost}:${safeWsPort}';</script></head>`
+          );
+          res.send(injectedHtml);
+        }).catch((err) => {
+          console.error("Failed to read index.html:", err);
+          res.status(500).send("Internal Server Error");
+        });
+      } else {
+        next();
+      }
+    });
+    app.use(
+      express.static(dashboardDist, {
+        dotfiles: "deny",
+        // Deny access to dotfiles
+        index: false,
+        // Don't serve index.html here (handled above)
+        redirect: false
+        // Don't redirect to trailing slash
+      })
+    );
+    app.use((req, res) => {
+      res.status(404).send("Not Found");
+    });
+    const httpServer = createServer(app);
+    await new Promise((resolve) => {
+      httpServer.listen(port, host, () => {
+        resolve();
+      });
+    });
+    success(`\u2713 Dashboard available at http://${host}:${port}`);
+    if (options.open) {
+      const url = `http://${host}:${port}`;
+      await import("child_process").then((cp) => {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        cp.exec(`${cmd} ${url}`);
+      });
+    }
+    info("");
+    info(chalk3.bold("Dashboard Controls:"));
+    info(`  \u2022 Dashboard: ${chalk3.cyan(`http://${host}:${port}`)}`);
+    info(`  \u2022 WebSocket: ${chalk3.cyan(`ws://${host}:${wsPort}`)}`);
+    info(`  \u2022 Press ${chalk3.bold("Ctrl+C")} to stop both servers`);
+    info("");
+    const cleanup = async () => {
+      info("\nShutting down servers...");
+      await new Promise((resolve) => {
+        httpServer.close(() => resolve());
+      });
+      await wsServer.stop();
+      success("\u2713 Servers stopped");
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  } catch (err) {
+    error("Failed to start dashboard");
+    if (err instanceof Error) {
+      error(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/finish.ts
+init_esm_shims();
+import path7 from "path";
+
+// src/lib/sound-player.ts
+init_esm_shims();
+import { existsSync as existsSync2 } from "fs";
+import path6 from "path";
+import player from "play-sound";
+var soundPlayer = player({});
+function playSound(soundName) {
+  try {
+    const possiblePaths = [
+      // In development (from src)
+      path6.join(process.cwd(), "packages", "cli", "sounds", `${soundName}.mp3`),
+      // In production (relative to dist)
+      path6.join(__dirname, "..", "sounds", `${soundName}.mp3`),
+      // Custom sound in project root
+      path6.join(process.cwd(), ".taskin", `${soundName}.mp3`)
+    ];
+    const soundPath = possiblePaths.find((p) => existsSync2(p));
+    if (!soundPath) {
+      return;
+    }
+    soundPlayer.play(soundPath, (err) => {
+      if (err) {
+        return;
+      }
+    });
+  } catch {
+  }
+}
+
 // src/commands/finish.ts
 var finishCommand = defineCommand({
   name: "finish <task-id>",
@@ -285,8 +1050,12 @@ async function finishTask(taskId, options) {
   requireTaskinProject();
   printHeader(`Finishing Task ${taskId}`, "\u2705");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path5.join(process.cwd(), "TASKS");
-  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const tasksDir = path7.join(process.cwd(), "TASKS");
+  const monorepoRoot = path7.dirname(tasksDir);
+  const taskinDir = path7.join(monorepoRoot, ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  await userRegistry.load();
+  const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
   const taskManager = new TaskManager(taskProvider);
   const task = await taskProvider.findTask(normalizedId);
   if (!task) {
@@ -311,14 +1080,14 @@ async function finishTask(taskId, options) {
   info("Suggested commit message:");
   const commitType = task.type || "feat";
   console.log(
-    colors.highlight(`  ${commitType}(task-${normalizedId}): ${task.title}`)
+    colors2.highlight(`  ${commitType}(task-${normalizedId}): ${task.title}`)
   );
   console.log();
   info("Next steps:");
-  console.log(colors.secondary("  1. Review your changes"));
-  console.log(colors.secondary("  2. Commit: git add . && git commit"));
-  console.log(colors.secondary("  3. Push: git push"));
-  console.log(colors.secondary("  4. Create a Pull Request"));
+  console.log(colors2.secondary("  1. Review your changes"));
+  console.log(colors2.secondary("  2. Commit: git add . && git commit"));
+  console.log(colors2.secondary("  3. Push: git push"));
+  console.log(colors2.secondary("  4. Create a Pull Request"));
   console.log();
   success("Great work! \u{1F680}");
   console.log();
@@ -572,7 +1341,7 @@ async function initializeTaskin(options) {
   let providerId;
   if (options.provider) {
     providerId = options.provider;
-    info(`Using provider from command line: ${colors.highlight(providerId)}`);
+    info(`Using provider from command line: ${colors2.highlight(providerId)}`);
   } else if (process.env.CI === "true") {
     providerId = "fs";
     info("CI environment detected, using default provider: fs");
@@ -594,7 +1363,7 @@ async function initializeTaskin(options) {
     process.exit(1);
   }
   console.log();
-  info(`Setting up task provider: ${colors.highlight(selectedProvider.name)}`);
+  info(`Setting up task provider: ${colors2.highlight(selectedProvider.name)}`);
   console.log();
   const bundledProviders = ["fs"];
   if (!bundledProviders.includes(selectedProvider.id)) {
@@ -610,7 +1379,7 @@ async function initializeTaskin(options) {
   };
   info("Creating configuration file...");
   writeFileSync(configFile, JSON.stringify(config, null, 2), "utf-8");
-  success(`\u2713 Created ${colors.highlight(".taskin.json")}`);
+  success(`\u2713 Created ${colors2.highlight(".taskin.json")}`);
   const gitignorePath = join(cwd, ".gitignore");
   if (existsSync4(gitignorePath)) {
     const gitignoreContent = __require("fs").readFileSync(gitignorePath, "utf-8");
@@ -631,13 +1400,13 @@ async function initializeTaskin(options) {
   success("\u{1F389} Taskin initialized successfully!");
   console.log();
   info("Next steps:");
-  console.log(colors.secondary("  1. Run: taskin list"));
+  console.log(colors2.secondary("  1. Run: taskin list"));
   console.log(
-    colors.secondary(
+    colors2.secondary(
       selectedProvider.id === "fs" ? "  2. Create a new task: taskin new (interactive mode)" : `  2. Tasks will be synced with ${selectedProvider.name}`
     )
   );
-  console.log(colors.secondary("  3. Start working: taskin start <task-id>"));
+  console.log(colors2.secondary("  3. Start working: taskin start <task-id>"));
   console.log();
   info("For more information, run: taskin --help");
   console.log();
@@ -671,9 +1440,9 @@ async function setupFileSystemProvider(cwd) {
   if (!existsSync4(tasksDir)) {
     info(`Creating TASKS directory...`);
     mkdirSync(tasksDir, { recursive: true });
-    success(`\u2713 Created ${colors.highlight("TASKS/")} directory`);
+    success(`\u2713 Created ${colors2.highlight("TASKS/")} directory`);
   } else {
-    info(`${colors.highlight("TASKS/")} directory already exists`);
+    info(`${colors2.highlight("TASKS/")} directory already exists`);
     success("\u2713 Directory is ready to use");
   }
   const sampleTaskFile = join(tasksDir, "task-001-setup-project.md");
@@ -701,7 +1470,7 @@ You can edit or delete this file. Use \`taskin list\` to see all tasks.
 `;
     writeFileSync(sampleTaskFile, sampleTask, "utf-8");
     success(
-      `\u2713 Created sample task ${colors.highlight("task-001-setup-project.md")}`
+      `\u2713 Created sample task ${colors2.highlight("task-001-setup-project.md")}`
     );
   }
   return {
@@ -718,8 +1487,8 @@ init_esm_shims();
 
 // src/lib/file-system-task-linter/file-system-task-linter.ts
 init_esm_shims();
-import chalk2 from "chalk";
-import { readdir, readFile } from "fs/promises";
+import chalk4 from "chalk";
+import { readdir, readFile as readFile2 } from "fs/promises";
 import { join as join2 } from "path";
 var VALID_STATUSES = ["pending", "in-progress", "done", "blocked"];
 var VALID_TYPES = ["feat", "fix", "chore", "docs", "refactor", "test"];
@@ -848,7 +1617,7 @@ var FileSystemTaskLinter = class {
       errors.push(fileNameError);
     }
     try {
-      const content = await readFile(filePath, "utf-8");
+      const content = await readFile2(filePath, "utf-8");
       this.errors = [];
       this.validateContent(fileName, content);
       errors.push(...this.errors);
@@ -874,7 +1643,7 @@ var FileSystemTaskLinter = class {
         if (fileNameError) {
           this.addError(file, fileNameError.message, fileNameError.severity);
         }
-        const content = await readFile(join2(tasksDir, file), "utf-8");
+        const content = await readFile2(join2(tasksDir, file), "utf-8");
         this.validateContent(file, content);
       }
       const errors = this.errors.filter((e) => e.severity === "error");
@@ -892,13 +1661,13 @@ var FileSystemTaskLinter = class {
   static printResults(result) {
     if (result.errors.length === 0 && result.warnings.length === 0) {
       console.log(
-        chalk2.green(`\u2705 All ${result.filesChecked} task files are valid!
+        chalk4.green(`\u2705 All ${result.filesChecked} task files are valid!
 `)
       );
       return;
     }
     console.log(
-      chalk2.bold(
+      chalk4.bold(
         `
 \u{1F4CA} Validation Results (${result.filesChecked} files checked):
 `
@@ -912,19 +1681,19 @@ var FileSystemTaskLinter = class {
       errorsByFile.get(error2.file).push(error2);
     });
     for (const [file, fileErrors] of errorsByFile) {
-      console.log(chalk2.cyan(`
+      console.log(chalk4.cyan(`
 \u{1F4C4} ${file}`));
       for (const error2 of fileErrors) {
-        const icon = error2.severity === "error" ? chalk2.red("\u274C") : chalk2.yellow("\u26A0\uFE0F");
+        const icon = error2.severity === "error" ? chalk4.red("\u274C") : chalk4.yellow("\u26A0\uFE0F");
         const location = error2.line ? `:${error2.line}` : "";
         console.log(`  ${icon} ${error2.message}${location}`);
       }
     }
     console.log("\n" + "\u2500".repeat(60));
     console.log(
-      chalk2.bold(
+      chalk4.bold(
         `
-\u{1F4CA} Summary: ${chalk2.red(result.errors.length + " error(s)")}, ${chalk2.yellow(result.warnings.length + " warning(s)")}
+\u{1F4CA} Summary: ${chalk4.red(result.errors.length + " error(s)")}, ${chalk4.yellow(result.warnings.length + " warning(s)")}
 `
       )
     );
@@ -1013,7 +1782,7 @@ async function executeLint(options) {
 
 // src/commands/list.ts
 init_esm_shims();
-import path6 from "path";
+import path8 from "path";
 var listCommand = defineCommand({
   name: "list [filter]",
   description: "\u{1F4CA} List all tasks in the project",
@@ -1039,11 +1808,15 @@ var listCommand = defineCommand({
 async function listTasks(filter, options) {
   requireTaskinProject();
   printHeader("Task List", "\u{1F4CA}");
-  const tasksDir = path6.join(process.cwd(), "TASKS");
-  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const tasksDir = path8.join(process.cwd(), "TASKS");
+  const monorepoRoot = path8.dirname(tasksDir);
+  const taskinDir = path8.join(monorepoRoot, ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  await userRegistry.load();
+  const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
   const tasks = await taskProvider.getAllTasks();
   if (tasks.length === 0) {
-    console.log(colors.warning("No tasks found in TASKS/ directory"));
+    console.log(colors2.warning("No tasks found in TASKS/ directory"));
     return;
   }
   let filteredTasks = tasks;
@@ -1065,24 +1838,24 @@ async function listTasks(filter, options) {
     );
   }
   if (filteredTasks.length === 0) {
-    console.log(colors.warning("No tasks match the filters"));
+    console.log(colors2.warning("No tasks match the filters"));
     return;
   }
   console.log(
-    colors.highlight(
+    colors2.highlight(
       `${"ID".padEnd(15)} ${"Status".padEnd(15)} ${"Type".padEnd(12)} ${"User".padEnd(15)} ${"Title"}`
     )
   );
-  console.log(colors.secondary("\u2500".repeat(100)));
+  console.log(colors2.secondary("\u2500".repeat(100)));
   filteredTasks.forEach((task) => {
     const statusColor = getStatusColor(task.status);
     const typeColor = getTypeColor(task.type);
     console.log(
-      `${colors.info(task.id.padEnd(15))} ${statusColor(task.status.padEnd(15))} ${typeColor(task.type.padEnd(12))} ${colors.secondary((task.userId || "unknown").padEnd(15))} ${colors.normal(task.title)}`
+      `${colors2.info(task.id.padEnd(15))} ${statusColor(task.status.padEnd(15))} ${typeColor(task.type.padEnd(12))} ${colors2.secondary((task.userId || "unknown").padEnd(15))} ${colors2.normal(task.title)}`
     );
   });
   console.log();
-  console.log(colors.secondary("\u2500".repeat(100)));
+  console.log(colors2.secondary("\u2500".repeat(100)));
   const statusCounts = {
     pending: filteredTasks.filter((t) => t.status === "pending").length,
     "in-progress": filteredTasks.filter((t) => t.status === "in-progress").length,
@@ -1090,7 +1863,7 @@ async function listTasks(filter, options) {
     blocked: filteredTasks.filter((t) => t.status === "blocked").length
   };
   console.log(
-    colors.info(
+    colors2.info(
       `\u{1F4CA} Total: ${filteredTasks.length} tasks | \u23F3 Pending: ${statusCounts.pending} | \u{1F680} In Progress: ${statusCounts["in-progress"]} | \u2705 Done: ${statusCounts.done} | \u{1F6AB} Blocked: ${statusCounts.blocked}`
     )
   );
@@ -1099,33 +1872,125 @@ async function listTasks(filter, options) {
 function getStatusColor(status) {
   switch (status) {
     case "pending":
-      return colors.secondary;
+      return colors2.secondary;
     case "in-progress":
-      return colors.info;
+      return colors2.info;
     case "done":
-      return colors.success;
+      return colors2.success;
     case "blocked":
-      return colors.error;
+      return colors2.error;
     default:
-      return colors.normal;
+      return colors2.normal;
   }
 }
 function getTypeColor(type) {
   switch (type) {
     case "feat":
-      return colors.success;
+      return colors2.success;
     case "fix":
-      return colors.error;
+      return colors2.error;
     case "refactor":
-      return colors.warning;
+      return colors2.warning;
     case "docs":
-      return colors.info;
+      return colors2.info;
     case "test":
-      return colors.secondary;
+      return colors2.secondary;
     case "chore":
-      return colors.normal;
+      return colors2.normal;
     default:
-      return colors.normal;
+      return colors2.normal;
+  }
+}
+
+// src/commands/mcp-server.ts
+init_esm_shims();
+import { TaskMCPServer } from "@opentask/taskin-task-server-mcp";
+import chalk5 from "chalk";
+import path9 from "path";
+var mcpServerCommand = defineCommand({
+  name: "mcp-server",
+  description: "\u{1F916} Start Model Context Protocol server for LLM integration",
+  alias: "mcp",
+  options: [
+    {
+      flags: "-t, --transport <type>",
+      description: "Transport type (stdio or sse)",
+      defaultValue: "stdio"
+    },
+    {
+      flags: "-d, --debug",
+      description: "Enable debug logging"
+    }
+  ],
+  handler: async (options) => {
+    await startMCPServer(options);
+  }
+});
+async function startMCPServer(options) {
+  requireTaskinProject();
+  const transport = options.transport || "stdio";
+  const debug = options.debug || false;
+  printHeader("Starting MCP Server", "\u{1F916}");
+  try {
+    info("Initializing task manager...");
+    const tasksDir = path9.join(process.cwd(), "TASKS");
+    const monorepoRoot = path9.dirname(tasksDir);
+    const taskinDir = path9.join(monorepoRoot, ".taskin");
+    const userRegistry = new UserRegistry({ taskinDir });
+    await userRegistry.load();
+    const provider = new FileSystemTaskProvider(tasksDir, userRegistry);
+    const manager = new TaskManager(provider);
+    info(`Creating MCP server with ${transport} transport...`);
+    const mcpServer = new TaskMCPServer({
+      taskManager: manager,
+      name: "taskin-mcp-server",
+      version: "1.0.0",
+      debug
+    });
+    info("Starting MCP server...");
+    await mcpServer.connect({ transport });
+    success("\u2713 MCP server started successfully");
+    info("");
+    info(chalk5.bold("Server Information:"));
+    info(`  \u2022 Transport: ${chalk5.cyan(transport)}`);
+    info(`  \u2022 Debug: ${chalk5.cyan(debug ? "enabled" : "disabled")}`);
+    info("");
+    info(chalk5.bold("Available Tools:"));
+    info(`  \u2022 ${chalk5.green("start_task")} - Start working on a task`);
+    info(`  \u2022 ${chalk5.green("finish_task")} - Mark a task as finished`);
+    info("");
+    info(chalk5.bold("Available Prompts:"));
+    info(
+      `  \u2022 ${chalk5.green("start-task-workflow")} - Guide for starting tasks`
+    );
+    info(
+      `  \u2022 ${chalk5.green("finish-task-workflow")} - Guide for finishing tasks`
+    );
+    info(`  \u2022 ${chalk5.green("task-summary")} - Get task summary and insights`);
+    info("");
+    info(chalk5.bold("Available Resources:"));
+    info(`  \u2022 ${chalk5.green("taskin://tasks")} - Access all tasks`);
+    info("");
+    info(`Press ${chalk5.bold("Ctrl+C")} to stop the server`);
+    info("");
+    const cleanup = async () => {
+      info("\nShutting down MCP server...");
+      success("\u2713 Server stopped");
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    await new Promise(() => {
+    });
+  } catch (err) {
+    error("Failed to start MCP server");
+    if (err instanceof Error) {
+      error(err.message);
+      if (debug) {
+        console.error(err.stack);
+      }
+    }
+    process.exit(1);
   }
 }
 
@@ -1133,7 +1998,7 @@ function getTypeColor(type) {
 init_esm_shims();
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import inquirer2 from "inquirer";
-import path7 from "path";
+import path10 from "path";
 var createCommand = defineCommand({
   name: "new",
   description: "\u2795 Create a new task",
@@ -1225,11 +2090,15 @@ async function createTask(options) {
     );
     return;
   }
-  const tasksDir = path7.join(process.cwd(), "TASKS");
+  const tasksDir = path10.join(process.cwd(), "TASKS");
   if (!existsSync5(tasksDir)) {
     mkdirSync2(tasksDir, { recursive: true });
   }
-  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const monorepoRoot = path10.dirname(tasksDir);
+  const taskinDir = path10.join(monorepoRoot, ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  await userRegistry.load();
+  const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
   const allTasks = await taskProvider.getAllTasks();
   const taskNumbers = allTasks.map((task) => {
     const match = task.id.match(/^(\d+)$/);
@@ -1239,7 +2108,7 @@ async function createTask(options) {
   const taskId = String(nextNumber).padStart(3, "0");
   const titleSlug = options.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
   const fileName = `task-${taskId}-${titleSlug}.md`;
-  const filePath = path7.join(tasksDir, fileName);
+  const filePath = path10.join(tasksDir, fileName);
   if (existsSync5(filePath)) {
     error(`Task file already exists: ${fileName}`);
     return;
@@ -1254,14 +2123,14 @@ async function createTask(options) {
   writeFileSync2(filePath, taskContent, "utf-8");
   console.log();
   success(`Task ${taskId} created successfully!`);
-  console.log(colors.secondary(`\u{1F4C4} File: ${fileName}`));
-  console.log(colors.secondary(`\u{1F4C1} Path: ${filePath}`));
+  console.log(colors2.secondary(`\u{1F4C4} File: ${fileName}`));
+  console.log(colors2.secondary(`\u{1F4C1} Path: ${filePath}`));
   console.log();
-  console.log(colors.info("Next steps:"));
-  console.log(colors.normal(`  1. Edit the task file to add more details`));
+  console.log(colors2.info("Next steps:"));
+  console.log(colors2.normal(`  1. Edit the task file to add more details`));
   console.log(
-    colors.normal(
-      `  2. Run ${colors.highlight("taskin start " + taskId)} to begin working on it`
+    colors2.normal(
+      `  2. Run ${colors2.highlight("taskin start " + taskId)} to begin working on it`
     )
   );
   console.log();
@@ -1292,7 +2161,7 @@ Add any relevant notes or links here.
 // src/commands/pause.ts
 init_esm_shims();
 import { execSync as execSync2 } from "child_process";
-import path8 from "path";
+import path11 from "path";
 var pauseCommand = defineCommand({
   name: "pause <task-id>",
   description: "\u23F8\uFE0F  Pause work on a task",
@@ -1319,8 +2188,12 @@ async function pauseTask(taskId, options) {
   requireTaskinProject();
   printHeader(`Pausing Task ${taskId}`, "\u23F8\uFE0F");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path8.join(process.cwd(), "TASKS");
-  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const tasksDir = path11.join(process.cwd(), "TASKS");
+  const monorepoRoot = path11.dirname(tasksDir);
+  const taskinDir = path11.join(monorepoRoot, ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  await userRegistry.load();
+  const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
   const task = await taskProvider.findTask(normalizedId);
   if (!task) {
     error(`Task ${normalizedId} not found in TASKS/ directory`);
@@ -1335,12 +2208,12 @@ async function pauseTask(taskId, options) {
   const commitMessage = options.message || `WIP: task-${normalizedId} - ${task.title}`;
   if (options.skipCommit) {
     info("Would create commit with message:");
-    console.log(colors.highlight(`  "${commitMessage}"`));
+    console.log(colors2.highlight(`  "${commitMessage}"`));
     console.log();
     info("Use without --skip-commit to actually commit");
   } else {
     info("Creating commit...");
-    console.log(colors.secondary(`  Message: "${commitMessage}"`));
+    console.log(colors2.secondary(`  Message: "${commitMessage}"`));
     console.log();
     try {
       execSync2("git add -A", { cwd: process.cwd(), stdio: "ignore" });
@@ -1357,9 +2230,9 @@ async function pauseTask(taskId, options) {
     info("Status updated to pending");
     console.log();
     info("Next steps:");
-    console.log(colors.secondary("  1. Switch to another task"));
+    console.log(colors2.secondary("  1. Switch to another task"));
     console.log(
-      colors.secondary("  2. Or continue later with the same branch")
+      colors2.secondary("  2. Or continue later with the same branch")
     );
     if (options.sound !== false) {
       playSound("stop");
@@ -1370,7 +2243,7 @@ async function pauseTask(taskId, options) {
 
 // src/commands/start.ts
 init_esm_shims();
-import path9 from "path";
+import path12 from "path";
 var startCommand = defineCommand({
   name: "start <task-id>",
   description: "\u{1F680} Start working on a task",
@@ -1397,8 +2270,12 @@ async function startTask(taskId, _options) {
   requireTaskinProject();
   printHeader(`Starting Task ${taskId}`, "\u{1F680}");
   const normalizedId = taskId.replace(/^task-/, "").padStart(3, "0");
-  const tasksDir = path9.join(process.cwd(), "TASKS");
-  const taskProvider = new FileSystemTaskProvider(tasksDir);
+  const tasksDir = path12.join(process.cwd(), "TASKS");
+  const monorepoRoot = path12.dirname(tasksDir);
+  const taskinDir = path12.join(monorepoRoot, ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  await userRegistry.load();
+  const taskProvider = new FileSystemTaskProvider(tasksDir, userRegistry);
   const taskManager = new TaskManager(taskProvider);
   const task = await taskProvider.findTask(normalizedId);
   if (!task) {
@@ -1422,12 +2299,12 @@ async function startTask(taskId, _options) {
   console.log();
   info("Next steps:");
   console.log(
-    colors.secondary(
+    colors2.secondary(
       "  1. Create a branch: git checkout -b feat/task-" + normalizedId
     )
   );
-  console.log(colors.secondary("  2. Start coding! \u{1F4BB}"));
-  console.log(colors.secondary('  3. Use "taskin pause" to save progress'));
+  console.log(colors2.secondary("  2. Start coding! \u{1F4BB}"));
+  console.log(colors2.secondary('  3. Use "taskin pause" to save progress'));
   console.log();
   if (_options.sound !== false) {
     playSound("start");
@@ -1438,20 +2315,20 @@ async function startTask(taskId, _options) {
 init_esm_shims();
 function showCustomHelp() {
   printHeader("Taskin - Task Management System", icons.rocket);
-  console.log(colors.info("\u{1F4CB} AVAILABLE COMMANDS"));
-  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log(colors2.info("\u{1F4CB} AVAILABLE COMMANDS"));
+  console.log(colors2.highlight("\u2550".repeat(60)));
   console.log();
   const commands = [
     {
-      name: colors.highlight("taskin init"),
-      alias: colors.secondary("Alias: setup"),
+      name: colors2.highlight("taskin init"),
+      alias: colors2.secondary("Alias: setup"),
       description: "Initialize Taskin in your project",
       examples: ["taskin init", "taskin setup"],
       icon: "\u{1F3AF}"
     },
     {
-      name: colors.highlight("taskin list") + colors.normal(" [filter]"),
-      alias: colors.secondary("Alias: ls"),
+      name: colors2.highlight("taskin list") + colors2.normal(" [filter]"),
+      alias: colors2.secondary("Alias: ls"),
       description: "List all tasks in the project",
       examples: [
         "taskin list",
@@ -1462,8 +2339,8 @@ function showCustomHelp() {
       icon: "\u{1F4CA}"
     },
     {
-      name: colors.highlight("taskin new"),
-      alias: colors.secondary("Alias: create"),
+      name: colors2.highlight("taskin new"),
+      alias: colors2.secondary("Alias: create"),
       description: "Create a new task",
       examples: [
         'taskin new -t feat -T "Add login" -d "Implement user authentication"',
@@ -1473,8 +2350,8 @@ function showCustomHelp() {
       icon: "\u{1F4DD}"
     },
     {
-      name: colors.highlight("taskin start") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: begin"),
+      name: colors2.highlight("taskin start") + colors2.normal(" <task-id>"),
+      alias: colors2.secondary("Alias: begin"),
       description: "Start working on a task",
       examples: [
         "taskin start 001",
@@ -1484,22 +2361,22 @@ function showCustomHelp() {
       icon: "\u{1F680}"
     },
     {
-      name: colors.highlight("taskin pause") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: stop"),
+      name: colors2.highlight("taskin pause") + colors2.normal(" <task-id>"),
+      alias: colors2.secondary("Alias: stop"),
       description: "Pause a task (commit without push)",
       examples: ["taskin pause 001", 'taskin pause 001 -m "saving progress"'],
       icon: "\u23F8\uFE0F"
     },
     {
-      name: colors.highlight("taskin finish") + colors.normal(" <task-id>"),
-      alias: colors.secondary("Alias: done"),
+      name: colors2.highlight("taskin finish") + colors2.normal(" <task-id>"),
+      alias: colors2.secondary("Alias: done"),
       description: "Finish a task",
       examples: ["taskin finish 001", "taskin done task-001"],
       icon: "\u2705"
     },
     {
-      name: colors.highlight("taskin lint") + colors.normal(" [options]"),
-      alias: colors.secondary("Options: -p, --path <directory>"),
+      name: colors2.highlight("taskin lint") + colors2.normal(" [options]"),
+      alias: colors2.secondary("Options: -p, --path <directory>"),
       description: "Validate task markdown files",
       examples: [
         "taskin lint",
@@ -1510,43 +2387,43 @@ function showCustomHelp() {
     }
   ];
   commands.forEach((cmd, index) => {
-    console.log(colors.warning(`${cmd.icon} ${cmd.name}`));
-    console.log(colors.normal(`   ${cmd.alias}`));
-    console.log(colors.info(`   ${cmd.description}`));
+    console.log(colors2.warning(`${cmd.icon} ${cmd.name}`));
+    console.log(colors2.normal(`   ${cmd.alias}`));
+    console.log(colors2.info(`   ${cmd.description}`));
     console.log();
-    console.log(colors.normal(`   ${colors.info("\u{1F4DD} Examples:")}`));
+    console.log(colors2.normal(`   ${colors2.info("\u{1F4DD} Examples:")}`));
     cmd.examples.forEach((example) => {
-      console.log(colors.secondary(`      ${example}`));
+      console.log(colors2.secondary(`      ${example}`));
     });
     if (index < commands.length - 1) {
       console.log();
-      console.log(colors.normal("   " + colors.secondary("\u2500".repeat(50))));
+      console.log(colors2.normal("   " + colors2.secondary("\u2500".repeat(50))));
       console.log();
     }
   });
   console.log();
-  console.log(colors.highlight("\u2550".repeat(60)));
+  console.log(colors2.highlight("\u2550".repeat(60)));
   console.log();
-  console.log(colors.info("\u{1F4A1} QUICK TIPS"));
+  console.log(colors2.info("\u{1F4A1} QUICK TIPS"));
   console.log(
-    colors.normal(
-      `${colors.warning("\u2022")} Use short IDs: ${colors.highlight("001")}, ${colors.highlight("task-001")}`
+    colors2.normal(
+      `${colors2.warning("\u2022")} Use short IDs: ${colors2.highlight("001")}, ${colors2.highlight("task-001")}`
     )
   );
   console.log(
-    colors.normal(
-      `${colors.warning("\u2022")} All commands support ${colors.highlight("--help")} for more options`
+    colors2.normal(
+      `${colors2.warning("\u2022")} All commands support ${colors2.highlight("--help")} for more options`
     )
   );
   console.log(
-    colors.normal(
-      `${colors.warning("\u2022")} Use aliases for faster commands: ${colors.highlight("ls")}, ${colors.highlight("begin")}, ${colors.highlight("stop")}, ${colors.highlight("done")}`
+    colors2.normal(
+      `${colors2.warning("\u2022")} Use aliases for faster commands: ${colors2.highlight("ls")}, ${colors2.highlight("begin")}, ${colors2.highlight("stop")}, ${colors2.highlight("done")}`
     )
   );
   console.log();
-  console.log(colors.info("\u{1F527} FOR MORE HELP"));
+  console.log(colors2.info("\u{1F527} FOR MORE HELP"));
   console.log(
-    colors.secondary("taskin ") + colors.highlight("<command>") + colors.secondary(" --help")
+    colors2.secondary("taskin ") + colors2.highlight("<command>") + colors2.secondary(" --help")
   );
   console.log();
   return "";
@@ -1556,12 +2433,12 @@ function showCustomHelp() {
 init_esm_shims();
 import { readFileSync } from "fs";
 import { dirname, join as join4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname(__filename2);
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname(__filename3);
 function getVersion() {
   try {
-    const packageJsonPath = join4(__dirname2, "../package.json");
+    const packageJsonPath = join4(__dirname3, "../package.json");
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
     return packageJson.version;
   } catch {
@@ -1571,7 +2448,7 @@ function getVersion() {
 
 // src/main.ts
 init_esm_shims();
-import { join as join5 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 
 // src/taskin.ts
 init_esm_shims();
@@ -1590,8 +2467,8 @@ var Taskin = class {
         status: taskFile.status,
         title: taskFile.title,
         type: taskFile.type,
-        assignee: taskFile.userId
-        // Map userId to assignee
+        ...taskFile.userId && { userId: taskFile.userId }
+        // Keep userId if present
       };
       return task;
     }).filter((task) => {
@@ -1601,7 +2478,7 @@ var Taskin = class {
       if (options?.type && task.type !== options.type) {
         return false;
       }
-      if (options?.assignee && task.assignee !== options.assignee) {
+      if (options?.assignee && task.userId !== options.assignee) {
         return false;
       }
       return true;
@@ -1662,7 +2539,12 @@ var Taskin = class {
 // src/main.ts
 function createTaskin(tasksDir) {
   const resolvedTasksDir = tasksDir || join5(process.cwd(), "TASKS");
-  const taskProvider = new FileSystemTaskProvider(resolvedTasksDir);
+  const taskinDir = join5(dirname2(resolvedTasksDir), ".taskin");
+  const userRegistry = new UserRegistry({ taskinDir });
+  const taskProvider = new FileSystemTaskProvider(
+    resolvedTasksDir,
+    userRegistry
+  );
   const taskManager = new TaskManager(taskProvider);
   const linter = new FileSystemTaskLinter();
   return new Taskin(taskProvider, taskManager, linter);
@@ -1683,6 +2565,8 @@ startCommand(program);
 pauseCommand(program);
 finishCommand(program);
 lintCommand(program);
+dashboardCommand(program);
+mcpServerCommand(program);
 if (process.argv.length <= 2) {
   showCustomHelp();
   process.exit(0);