taskin 4.1.0 → 4.1.1

package/dist/index.js

@@ -28,436 +28,868 @@ var init_esm_shims = __esm({
   }
 });
 
-// ../utils/src/security.ts
-import { z } from "zod";
-function isValidHost(host) {
-  return HostSchema.safeParse(host).success;
-}
-function isValidPort(port) {
-  return PortSchema.safeParse(port).success;
-}
-function escapeHtml(text) {
-  if (!text || typeof text !== "string") {
+// ../git-utils/src/commit-message.ts
+function isRecognizedCiSkipTag(tag) {
+  const normalized = tag.trim().toLowerCase();
+  return CI_SKIP_TAGS.some((known) => known === normalized);
+}
+function appendCiSkipTag(subject, ciSkipTag = DEFAULT_CI_SKIP_TAG) {
+  const tag = ciSkipTag.trim();
+  if (tag.length === 0) return subject;
+  if (subject.endsWith(tag)) return subject;
+  return `${subject} ${tag}`;
+}
+function buildTaskStatusCommitMessage(options) {
+  const subject = `docs(TASKS): task-${options.taskId} - atualiza status para ${options.status}`;
+  return appendCiSkipTag(subject, options.ciSkipTag);
+}
+var CI_SKIP_TAGS, DEFAULT_CI_SKIP_TAG;
+var init_commit_message = __esm({
+  "../git-utils/src/commit-message.ts"() {
+    "use strict";
+    init_esm_shims();
+    CI_SKIP_TAGS = ["[skip ci]", "[ci skip]", "[no ci]", "[skip actions]", "[actions skip]"];
+    DEFAULT_CI_SKIP_TAG = "[skip ci]";
+  }
+});
+
+// ../git-utils/src/git.ts
+import { execSync } from "child_process";
+function executeGit(command) {
+  try {
+    return execSync(`git ${command}`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
     return "";
   }
-  const htmlEscapeMap = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#x27;",
-    "/": "&#x2F;"
-  };
-  return text.replace(/[&<>"'/]/g, (char) => htmlEscapeMap[char]);
 }
-var HostSchema, PortSchema, WebSocketUrlSchema, TaskIdSchema2, UserIdSchema, EmailSchema, SafePathSchema, DashboardOptionsSchema;
-var init_security = __esm({
-  "../utils/src/security.ts"() {
+function isGitRepository() {
+  return !!executeGit("rev-parse --is-inside-work-tree");
+}
+function getCurrentBranch() {
+  return executeGit("branch --show-current");
+}
+function createBranch(branchName, baseBranch) {
+  const base = baseBranch || getCurrentBranch();
+  executeGit(`checkout -b ${branchName} ${base}`);
+}
+var init_git = __esm({
+  "../git-utils/src/git.ts"() {
     "use strict";
     init_esm_shims();
-    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 !Number.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."
-      }
-    );
-    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))
-    ]);
-    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." }
-    );
-    TaskIdSchema2 = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/, {
-      message: "Task ID must contain only alphanumeric characters, hyphens, and underscores."
-    });
-    UserIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9._-]+$/, {
-      message: "User ID must contain only alphanumeric characters, dots, hyphens, and underscores."
-    });
-    EmailSchema = z.string().email().max(254);
-    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."
-      }
-    );
-    DashboardOptionsSchema = z.object({
-      host: HostSchema.optional(),
-      port: PortSchema.optional(),
-      wsPort: PortSchema.optional()
-    });
   }
 });
 
-// ../utils/src/string.ts
-function slugify(text) {
-  return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-var init_string = __esm({
-  "../utils/src/string.ts"() {
+// ../git-utils/src/git.types.ts
+var init_git_types = __esm({
+  "../git-utils/src/git.types.ts"() {
     "use strict";
     init_esm_shims();
   }
 });
 
-// ../utils/src/ui.ts
-import chalk3 from "chalk";
-var colors2;
-var init_ui = __esm({
-  "../utils/src/ui.ts"() {
+// ../git-utils/src/git-analyzer.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+function isNodeError(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2;
+}
+async function executeGit2(command, cwd) {
+  try {
+    const { stdout } = await execAsync(`git ${command}`, {
+      cwd: cwd || process.cwd(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+      // 10MB buffer for large repos
+      timeout: 3e4
+      // 30 second timeout
+    });
+    return stdout.trim();
+  } catch (error2) {
+    if (isNodeError(error2)) {
+      if (error2.code === "ENOENT") {
+        throw new Error("Git is not installed or not in PATH");
+      }
+    }
+    return "";
+  }
+}
+var execAsync, GitAnalyzer;
+var init_git_analyzer = __esm({
+  "../git-utils/src/git-analyzer.ts"() {
     "use strict";
     init_esm_shims();
-    colors2 = {
-      primary: chalk3.blue,
-      secondary: chalk3.gray,
-      success: chalk3.green,
-      warning: chalk3.yellow,
-      error: chalk3.red,
-      info: chalk3.cyan,
-      highlight: chalk3.magenta,
-      normal: chalk3.white
+    execAsync = promisify(exec);
+    GitAnalyzer = class {
+      constructor(repositoryPath) {
+        this.repositoryPath = repositoryPath;
+      }
+      async isValidRepository() {
+        try {
+          const result = await executeGit2("rev-parse --is-inside-work-tree", this.repositoryPath);
+          return result === "true";
+        } catch {
+          return false;
+        }
+      }
+      async getRepositoryRoot() {
+        const result = await executeGit2("rev-parse --show-toplevel", this.repositoryPath);
+        if (!result) {
+          throw new Error("Not a git repository");
+        }
+        return result;
+      }
+      async getCommits(options = {}) {
+        const args = ["log"];
+        args.push(
+          "--pretty='format:%H|%an|%aI|%s%x00%b'",
+          "--numstat"
+          // Get file stats
+        );
+        if (options.since) {
+          args.push(`--since="${options.since}"`);
+        }
+        if (options.until) {
+          args.push(`--until=${options.until}`);
+        }
+        if (options.author) {
+          args.push(`--author='${options.author}'`);
+        }
+        if (options.maxCount) {
+          args.push(`-n ${options.maxCount}`);
+        }
+        if (!options.includeMerges) {
+          args.push("--no-merges");
+        }
+        if (options.filePath) {
+          args.push("--", options.filePath);
+        }
+        const command = args.join(" ");
+        const output = await executeGit2(command, this.repositoryPath);
+        if (!output) {
+          return [];
+        }
+        return this.parseCommits(output);
+      }
+      parseCommits(output) {
+        const commits = [];
+        const lines = output.split("\n");
+        let i = 0;
+        while (i < lines.length) {
+          const line = lines[i];
+          if (line === void 0) break;
+          if (!line.trim()) {
+            i++;
+            continue;
+          }
+          if (line.includes("|")) {
+            const [hash, author, date, messageWithBody] = line.split("|");
+            if (hash === void 0 || author === void 0 || date === void 0 || messageWithBody === void 0) {
+              i++;
+              continue;
+            }
+            if (!/^[0-9a-f]{6,40}$/i.test(hash)) {
+              i++;
+              continue;
+            }
+            const nullByteIndex = messageWithBody.indexOf("\0");
+            const subject = nullByteIndex !== -1 ? messageWithBody.substring(0, nullByteIndex) : messageWithBody;
+            const bodyLines = [];
+            if (nullByteIndex !== -1) {
+              bodyLines.push(messageWithBody.substring(nullByteIndex + 1));
+            }
+            i++;
+            while (i < lines.length) {
+              const bodyLine = lines[i];
+              if (bodyLine === void 0 || bodyLine.includes("|") || bodyLine.includes("	")) break;
+              if (bodyLine.trim()) {
+                bodyLines.push(bodyLine);
+              }
+              i++;
+            }
+            const body = bodyLines.join("\n");
+            const fullMessage = body ? `${subject}
+
+${body}` : subject;
+            let filesChanged = 0;
+            let linesAdded = 0;
+            let linesRemoved = 0;
+            while (i < lines.length) {
+              const rawStatLine = lines[i];
+              if (rawStatLine === void 0 || rawStatLine.includes("|")) break;
+              const statLine = rawStatLine.trim();
+              if (!statLine) {
+                i++;
+                continue;
+              }
+              const [added, removed] = statLine.split("	");
+              if (added !== "-" && removed !== "-") {
+                linesAdded += parseInt(added || "0", 10);
+                linesRemoved += parseInt(removed || "0", 10);
+                filesChanged++;
+              }
+              i++;
+            }
+            commits.push({
+              hash,
+              author,
+              date,
+              message: subject,
+              filesChanged,
+              linesAdded,
+              linesRemoved,
+              coAuthors: this.extractCoAuthors(fullMessage)
+            });
+          } else {
+            i++;
+          }
+        }
+        return commits;
+      }
+      extractCoAuthors(message) {
+        const coAuthorRegex = /Co-authored-by:\s*(.+?)\s*<(.+?)>/gi;
+        const matches = Array.from(message.matchAll(coAuthorRegex));
+        const names = matches.flatMap((match) => match[1]?.trim() ?? []);
+        return names.length > 0 ? names : void 0;
+      }
+      async getDiff(from = "HEAD", to = "") {
+        const args = ["diff", "--numstat"];
+        if (to) {
+          args.push(`${from}..${to}`);
+        } else {
+          args.push(from);
+        }
+        const output = await executeGit2(args.join(" "), this.repositoryPath);
+        return this.parseDiff(output);
+      }
+      parseDiff(output) {
+        const files = [];
+        let totalLinesAdded = 0;
+        let totalLinesRemoved = 0;
+        if (!output) {
+          return {
+            files,
+            totalLinesAdded,
+            totalLinesRemoved,
+            netChange: 0
+          };
+        }
+        const lines = output.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          const [added, removed, path12] = line.split("	");
+          if (added === void 0 || removed === void 0 || path12 === void 0) continue;
+          if (added === "-" || removed === "-") {
+            continue;
+          }
+          const linesAdded = parseInt(added, 10);
+          const linesRemoved = parseInt(removed, 10);
+          totalLinesAdded += linesAdded;
+          totalLinesRemoved += linesRemoved;
+          files.push({
+            path: path12,
+            linesAdded,
+            linesRemoved,
+            changeType: "modified"
+            // Simplified - could be enhanced with --name-status
+          });
+        }
+        return {
+          files,
+          totalLinesAdded,
+          totalLinesRemoved,
+          netChange: totalLinesAdded - totalLinesRemoved
+        };
+      }
+      async getFileDiff(filePath, from = "HEAD", to = "") {
+        const args = ["diff", "--numstat"];
+        if (to) {
+          args.push(`${from}..${to}`);
+        } else {
+          args.push(from);
+        }
+        args.push("--", filePath);
+        const output = await executeGit2(args.join(" "), this.repositoryPath);
+        if (!output) {
+          return null;
+        }
+        const [added, removed, path12] = output.split("	");
+        if (added === void 0 || removed === void 0 || path12 === void 0) {
+          return null;
+        }
+        if (added === "-" || removed === "-") {
+          return null;
+        }
+        return {
+          path: path12,
+          linesAdded: parseInt(added, 10),
+          linesRemoved: parseInt(removed, 10),
+          changeType: "modified"
+        };
+      }
+      async getBlame(filePath) {
+        const args = ["blame", "--line-porcelain", filePath];
+        const output = await executeGit2(args.join(" "), this.repositoryPath);
+        if (!output) {
+          return [];
+        }
+        return this.parseBlame(output);
+      }
+      parseBlame(output) {
+        const lines = output.split("\n");
+        const blameInfo = [];
+        let currentHash = "";
+        let currentAuthor = "";
+        let currentDate = "";
+        let lineNumber = 0;
+        for (const line of lines) {
+          if (line.match(/^[0-9a-f]{6,40}/i)) {
+            const [hash, , finalLine] = line.split(" ");
+            currentHash = hash ?? "";
+            lineNumber = parseInt(finalLine ?? "", 10);
+          } else if (line.startsWith("author ")) {
+            currentAuthor = line.substring(7);
+          } else if (line.startsWith("author-time ")) {
+            const timestamp = parseInt(line.substring(12), 10);
+            currentDate = new Date(timestamp * 1e3).toISOString();
+          } else if (line.startsWith("	")) {
+            const content = line.substring(1);
+            blameInfo.push({
+              lineNumber,
+              commitHash: currentHash,
+              author: currentAuthor,
+              date: new Date(currentDate),
+              content
+            });
+          }
+        }
+        return blameInfo;
+      }
+      async getAuthors(options = {}) {
+        const args = ["shortlog", "-sne"];
+        if (options.since) {
+          args.push(`--since=${options.since}`);
+        }
+        if (options.until) {
+          args.push(`--until=${options.until}`);
+        }
+        if (!options.includeMerges) {
+          args.push("--no-merges");
+        }
+        if (options.filePath) {
+          args.push("--", options.filePath);
+        }
+        const command = args.join(" ");
+        const output = await executeGit2(command, this.repositoryPath);
+        if (!output) {
+          return [];
+        }
+        return this.parseAuthors(output);
+      }
+      parseAuthors(output) {
+        const lines = output.split("\n").filter((l) => l.trim());
+        const authors = [];
+        for (const line of lines) {
+          const match = line.match(/^\s*(\d+)\s+(.+?)\s+<(.+?)>/);
+          if (match) {
+            const [, commits, name, email] = match;
+            if (commits === void 0 || name === void 0 || email === void 0) continue;
+            authors.push({
+              name,
+              email,
+              commits: parseInt(commits, 10)
+            });
+          }
+        }
+        return authors;
+      }
+      async getFileHistory(filePath, options = {}) {
+        return this.getCommits({
+          ...options,
+          filePath
+        });
+      }
     };
   }
 });
 
-// ../utils/src/index.ts
-var init_src = __esm({
-  "../utils/src/index.ts"() {
+// ../git-utils/src/git-analyzer.types.ts
+var init_git_analyzer_types = __esm({
+  "../git-utils/src/git-analyzer.types.ts"() {
     "use strict";
     init_esm_shims();
-    init_security();
-    init_string();
-    init_ui();
   }
 });
 
-// ../file-system-task-provider/src/assignee-identity.ts
-function classifyAssignee(raw, registry) {
-  const trimmed = raw.trim();
-  if (trimmed === "" || PLACEHOLDER_ASSIGNEES.includes(trimmed.toLowerCase())) {
-    return { kind: "unassigned", raw };
-  }
-  const user = registry.resolveUser(trimmed);
-  if (user) {
-    return { kind: "resolved", raw, user };
-  }
-  const folded = fold(trimmed);
-  const matches = registry.getAllUsers().filter((candidate) => fold(candidate.id) === folded || fold(candidate.name) === folded);
-  const [onlyMatch] = matches;
-  if (onlyMatch && matches.length === 1) {
-    return { kind: "correctable", raw, user: onlyMatch };
-  }
-  return { kind: "unknown", raw };
-}
-function validateAssignees(tasks, registry) {
-  const issues = [];
-  for (const task of tasks) {
-    if (task.assignee === void 0) continue;
-    const identity = classifyAssignee(task.assignee, registry);
-    switch (identity.kind) {
-      case "resolved":
-      case "unassigned":
-        break;
-      case "correctable":
-        issues.push({
-          file: task.file,
-          message: `Assignee "${identity.raw.trim()}" is not in the user registry, but folds onto exactly one registered user.`,
-          severity: "warning",
-          suggestion: `Rewrite it as "${identity.user.id}" \u2014 lint --fix does this.`
-        });
-        break;
-      case "unknown":
-        issues.push({
-          file: task.file,
-          message: `Assignee "${identity.raw.trim()}" resolves to nobody in the user registry, so it silently becomes a fabricated temporary user.`,
-          severity: "warning",
-          suggestion: `Register them in ${".taskin/.taskin-users.json"}, or fix the spelling \u2014 too ambiguous for --fix to decide.`
-        });
-        break;
-      default:
-        identity;
-    }
-  }
-  return issues;
-}
-async function fixAssignees(tasks, registry, io) {
-  const rewritten = [];
-  for (const task of tasks) {
-    if (task.assignee === void 0) continue;
-    const identity = classifyAssignee(task.assignee, registry);
-    if (identity.kind !== "correctable") continue;
-    const content = await io.readFile(task.file);
-    const next = content.replace(/^(Assignee:[ \t]*)(.*)$/im, (_line, label) => `${label}${identity.user.id}`);
-    if (next !== content) {
-      await io.writeFile(task.file, next);
-      rewritten.push(task.file);
-    }
+// ../git-utils/src/git-service.ts
+import { execSync as execSync2 } from "child_process";
+var GitService;
+var init_git_service = __esm({
+  "../git-utils/src/git-service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_commit_message();
+    init_git();
+    GitService = class {
+      constructor(cwd = process.cwd(), options = {}) {
+        this.cwd = cwd;
+        this.ciSkipTag = options.ciSkipTag ?? DEFAULT_CI_SKIP_TAG;
+      }
+      ciSkipTag;
+      async addFiles(pattern) {
+        try {
+          execSync2(`git add ${pattern}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async commit(message) {
+        try {
+          execSync2(`git commit -m "${message}"`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async addAndCommit(pattern, message) {
+        const added = await this.addFiles(pattern);
+        if (!added) return false;
+        return this.commit(message);
+      }
+      async commitTaskStatusChange(taskId, status) {
+        const pattern = `TASKS/task-${taskId}-*.md`;
+        const message = buildTaskStatusCommitMessage({ taskId, status, ciSkipTag: this.ciSkipTag });
+        return this.addAndCommit(pattern, message);
+      }
+      async commitTaskStatusChangeOnBranch(taskId, status, defaultBranch) {
+        if (!defaultBranch) {
+          return this.commitTaskStatusChange(taskId, status);
+        }
+        try {
+          const currentBranch = execSync2("git rev-parse --abbrev-ref HEAD", {
+            cwd: this.cwd,
+            encoding: "utf8",
+            stdio: "pipe"
+          }).trim();
+          if (currentBranch === defaultBranch) {
+            return this.commitTaskStatusChange(taskId, status);
+          }
+          const taskPattern = `TASKS/task-${taskId}-*.md`;
+          let taskFileContent = null;
+          let taskFilePath = null;
+          try {
+            const files = execSync2(`git ls-files -m ${taskPattern}`, {
+              cwd: this.cwd,
+              encoding: "utf8",
+              stdio: "pipe"
+            }).trim();
+            if (files) {
+              taskFilePath = files.split("\n")[0] ?? null;
+              const { readFileSync: readFileSync4 } = await import("fs");
+              taskFileContent = readFileSync4(`${this.cwd}/${taskFilePath}`, "utf-8");
+            }
+          } catch {
+          }
+          const hasChanges = await this.hasUncommittedChanges();
+          let stashed = false;
+          try {
+            if (hasChanges) {
+              execSync2('git stash push -u -m "taskin-temp-stash"', {
+                cwd: this.cwd,
+                stdio: "ignore"
+              });
+              stashed = true;
+            }
+            execSync2(`git checkout ${defaultBranch}`, {
+              cwd: this.cwd,
+              stdio: "ignore"
+            });
+            let committed = false;
+            if (taskFileContent && taskFilePath) {
+              const { writeFileSync: writeFileSync3 } = await import("fs");
+              writeFileSync3(`${this.cwd}/${taskFilePath}`, taskFileContent, "utf-8");
+              const message = buildTaskStatusCommitMessage({ taskId, status, ciSkipTag: this.ciSkipTag });
+              committed = await this.addAndCommit(taskPattern, message);
+            } else {
+              const message = buildTaskStatusCommitMessage({ taskId, status, ciSkipTag: this.ciSkipTag });
+              committed = await this.addAndCommit(taskPattern, message);
+            }
+            execSync2(`git checkout ${currentBranch}`, {
+              cwd: this.cwd,
+              stdio: "ignore"
+            });
+            if (stashed) {
+              execSync2("git stash pop", {
+                cwd: this.cwd,
+                stdio: "ignore"
+              });
+            }
+            return committed;
+          } catch {
+            try {
+              execSync2(`git checkout ${currentBranch}`, {
+                cwd: this.cwd,
+                stdio: "ignore"
+              });
+              if (stashed) {
+                execSync2("git stash pop", {
+                  cwd: this.cwd,
+                  stdio: "ignore"
+                });
+              }
+            } catch {
+            }
+            return false;
+          }
+        } catch {
+          return false;
+        }
+      }
+      async hasUncommittedChanges() {
+        try {
+          const output = execSync2("git status --porcelain", {
+            cwd: this.cwd,
+            encoding: "utf8",
+            stdio: "pipe"
+          });
+          return output.trim().length > 0;
+        } catch {
+          return false;
+        }
+      }
+      async getCurrentBranch() {
+        try {
+          return execSync2("git branch --show-current", {
+            cwd: this.cwd,
+            encoding: "utf8",
+            stdio: "pipe"
+          }).trim();
+        } catch {
+          return "";
+        }
+      }
+      async isGitRepository() {
+        return Promise.resolve(isGitRepository());
+      }
+      async createBranch(branchName, baseBranch) {
+        try {
+          createBranch(branchName, baseBranch);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async checkoutBranch(branchName) {
+        try {
+          execSync2(`git checkout ${branchName}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async fetch(remote = "origin") {
+        try {
+          execSync2(`git fetch ${remote}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async rebase(branch) {
+        try {
+          execSync2(`git rebase ${branch}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async push(branch, remote = "origin") {
+        try {
+          execSync2(`git push ${remote} ${branch}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async abortRebase() {
+        try {
+          execSync2("git rebase --abort", {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async checkoutFile(branch, pattern) {
+        try {
+          execSync2(`git checkout ${branch} -- ${pattern}`, {
+            cwd: this.cwd,
+            stdio: "ignore"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
   }
-  return rewritten;
-}
-function isSeededUser(user) {
-  const capitalized = user.id.charAt(0).toUpperCase() + user.id.slice(1);
-  return user.email === `${user.id}@example.com` && user.name === capitalized;
-}
-function validateSeededUsers(assignees, registry) {
-  const referenced = new Set(
-    assignees.flatMap((raw) => {
-      if (raw === void 0) return [];
-      const identity = classifyAssignee(raw, registry);
-      return identity.kind === "resolved" || identity.kind === "correctable" ? [identity.user.id] : [];
-    })
-  );
-  return registry.getAllUsers().filter((user) => isSeededUser(user) && !referenced.has(user.id)).map((user) => ({
-    file: `${".taskin/.taskin-users.json"} (${user.id})`,
-    message: `User "${user.id}" looks like the placeholder that older taskin versions seeded on init (${user.email}), and no task points at it.`,
-    severity: "warning",
-    suggestion: `Remove it from the registry, or give it the real name and e-mail of whoever it stands for.`
-  }));
-}
-var PLACEHOLDER_ASSIGNEES, foldAssignee, fold;
-var init_assignee_identity = __esm({
-  "../file-system-task-provider/src/assignee-identity.ts"() {
+});
+
+// ../git-utils/src/git-service.types.ts
+var init_git_service_types = __esm({
+  "../git-utils/src/git-service.types.ts"() {
     "use strict";
     init_esm_shims();
-    PLACEHOLDER_ASSIGNEES = [
-      "a definir",
-      "to be defined",
-      "nome do responsavel",
-      "nome do respons\xE1vel",
-      "tbd",
-      "-"
-    ];
-    foldAssignee = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
-    fold = foldAssignee;
   }
 });
 
-// ../file-system-task-provider/src/auto-sync.ts
-function isNonFastForwardError(error2) {
-  if (error2 instanceof Error) {
-    return error2.message.toLowerCase().includes("non-fast-forward");
+// ../git-utils/src/index.ts
+var init_src = __esm({
+  "../git-utils/src/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_commit_message();
+    init_git();
+    init_git_types();
+    init_git_analyzer();
+    init_git_analyzer_types();
+    init_git_service();
+    init_git_service_types();
   }
-  return false;
+});
+
+// ../utils/src/security.ts
+import { z } from "zod";
+function isValidHost(host) {
+  return HostSchema.safeParse(host).success;
 }
-async function syncBeforeCreate(git, config) {
-  if (!config.autoSync || !config.defaultBranch) {
-    if (config.autoSync && !config.defaultBranch) {
-      console.warn("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
-    }
-    return;
-  }
-  const fetchOk = await safeCall(() => git.fetch());
-  if (!fetchOk) {
-    throw new Error("Fetch failed. Check your network connection.");
-  }
-  const rebaseOk = await safeCall(() => git.rebase(`origin/${config.defaultBranch}`));
-  if (!rebaseOk) {
-    await git.abortRebase();
-    throw new Error("Rebase failed due to conflict. Aborted.");
-  }
+function isValidPort(port) {
+  return PortSchema.safeParse(port).success;
 }
-async function safeCall(fn) {
-  try {
-    return await fn();
-  } catch {
-    return false;
-  }
+function escapeHtml(text) {
+  if (!text || typeof text !== "string") {
+    return "";
+  }
+  const htmlEscapeMap = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "/": "&#x2F;"
+  };
+  return text.replace(/[&<>"'/]/g, (char) => htmlEscapeMap[char]);
 }
-async function attemptPushWithRetry(git, pattern, message, branch, maxAttempts) {
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    if (attempt > 1) {
-      const fetchOk = await safeCall(() => git.fetch());
-      if (!fetchOk) {
-        throw new Error("Fetch failed during retry.");
-      }
-      const rebaseOk = await safeCall(() => git.rebase(`origin/${branch}`));
-      if (!rebaseOk) {
-        throw new Error("Rebase failed during retry.");
-      }
-    }
-    await git.addAndCommit(pattern, message);
-    try {
-      const pushOk = await git.push(branch);
-      if (pushOk) {
-        return;
-      }
-    } catch (error2) {
-      if (!isNonFastForwardError(error2)) {
-        throw error2;
+var HostSchema, PortSchema, WebSocketUrlSchema, TaskIdSchema2, UserIdSchema, EmailSchema, SafePathSchema, DashboardOptionsSchema;
+var init_security = __esm({
+  "../utils/src/security.ts"() {
+    "use strict";
+    init_esm_shims();
+    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 !Number.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."
       }
-      if (attempt >= maxAttempts) {
-        throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
+    );
+    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))
+    ]);
+    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." }
+    );
+    TaskIdSchema2 = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/, {
+      message: "Task ID must contain only alphanumeric characters, hyphens, and underscores."
+    });
+    UserIdSchema = z.string().min(1).max(100).regex(/^[a-zA-Z0-9._-]+$/, {
+      message: "User ID must contain only alphanumeric characters, dots, hyphens, and underscores."
+    });
+    EmailSchema = z.string().email().max(254);
+    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."
       }
-      continue;
-    }
-    if (attempt >= maxAttempts) {
-      throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
-    }
-  }
-  throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
-}
-async function pushAfterCreate(git, options) {
-  const pattern = `TASKS/task-${options.taskId}-*.md`;
-  const message = `docs(TASKS): task-${options.taskId} - ${options.title} [skip-ci]`;
-  await attemptPushWithRetry(git, pattern, message, options.defaultBranch, MAX_RETRY_ATTEMPTS);
-  return true;
-}
-async function getNextTaskNumberAfterSync(options) {
-  const maxLocal = options.localCount;
-  const maxRemote = options.remoteCount;
-  if (options.autoSync) {
-    const maxNumber = Math.max(maxLocal, maxRemote);
-    return maxNumber + 1;
-  }
-  return maxLocal + 1;
-}
-async function createTaskWithSync(git, config, taskOptions) {
-  await syncBeforeCreate(git, config);
-  const nextNumber = await getNextTaskNumberAfterSync({
-    autoSync: config.autoSync,
-    localCount: 0,
-    remoteCount: 0
-  });
-  const taskId = String(nextNumber).padStart(3, "0");
-  if (config.autoSync && config.defaultBranch) {
-    await pushAfterCreate(git, {
-      taskId,
-      title: taskOptions.title,
-      defaultBranch: config.defaultBranch
+    );
+    DashboardOptionsSchema = z.object({
+      host: HostSchema.optional(),
+      port: PortSchema.optional(),
+      wsPort: PortSchema.optional()
     });
   }
-  return { taskId };
+});
+
+// ../utils/src/string.ts
+function slugify(text) {
+  return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-async function squashTaskFileOnDone(git, options) {
-  if (!options.originBranch) {
-    return false;
-  }
-  const currentBranch = await git.getCurrentBranch();
-  const originBranch = options.originBranch;
-  const pattern = `TASKS/task-${options.taskId}-*.md`;
-  const assetsPattern = `TASKS/assets/task-${options.taskId}/`;
-  const coResult = await git.checkoutBranch(originBranch);
-  if (!coResult) {
-    await git.checkoutBranch(currentBranch);
-    return false;
-  }
-  try {
-    const patternsToAdd = [];
-    const fileOk = await git.checkoutFile(options.defaultBranch, pattern);
-    if (fileOk) {
-      patternsToAdd.push(pattern);
-    }
-    const assetsOk = await git.checkoutFile(options.defaultBranch, assetsPattern);
-    if (assetsOk) {
-      patternsToAdd.push(assetsPattern);
-    }
-    if (patternsToAdd.length === 0) {
-      await git.checkoutBranch(currentBranch);
-      return false;
-    }
-    const combinedPattern = patternsToAdd.join(" ");
-    const addOk = await git.addFiles(combinedPattern);
-    if (!addOk) {
-      await git.checkoutBranch(currentBranch);
-      return false;
-    }
-    const message = `docs(TASKS): task-${options.taskId} - done [skip-ci]`;
-    const commitOk = await git.commit(message);
-    if (!commitOk) {
-      await git.checkoutBranch(currentBranch);
-      return false;
-    }
-    for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
-      if (attempt > 1) {
-        await safeCall(() => git.fetch());
-        await safeCall(() => git.rebase(`origin/${originBranch}`));
-      }
-      const pushOk = await safeCall(() => git.push(originBranch));
-      if (pushOk === true) {
-        await git.checkoutBranch(currentBranch);
-        return true;
-      }
-      if (attempt >= MAX_RETRY_ATTEMPTS) {
-        await git.checkoutBranch(currentBranch);
-        throw new Error(`Squash push rejected after ${MAX_RETRY_ATTEMPTS} retries.`);
-      }
-    }
-    await git.checkoutBranch(currentBranch);
-    throw new Error(`Squash push rejected after ${MAX_RETRY_ATTEMPTS} retries.`);
-  } catch (error2) {
-    await git.checkoutBranch(currentBranch);
-    if (error2 instanceof Error) {
-      throw error2;
-    }
-    return false;
+var init_string = __esm({
+  "../utils/src/string.ts"() {
+    "use strict";
+    init_esm_shims();
   }
-}
-var MAX_RETRY_ATTEMPTS;
-var init_auto_sync = __esm({
-  "../file-system-task-provider/src/auto-sync.ts"() {
+});
+
+// ../utils/src/ui.ts
+import chalk3 from "chalk";
+var colors2;
+var init_ui = __esm({
+  "../utils/src/ui.ts"() {
     "use strict";
     init_esm_shims();
-    MAX_RETRY_ATTEMPTS = 3;
+    colors2 = {
+      primary: chalk3.blue,
+      secondary: chalk3.gray,
+      success: chalk3.green,
+      warning: chalk3.yellow,
+      error: chalk3.red,
+      info: chalk3.cyan,
+      highlight: chalk3.magenta,
+      normal: chalk3.white
+    };
   }
 });
 
-// ../file-system-task-provider/src/inline-metadata.ts
-function stripHardBreak(value) {
-  return value.replace(/\\$/, "").trim();
-}
-var HARD_BREAK;
-var init_inline_metadata = __esm({
-  "../file-system-task-provider/src/inline-metadata.ts"() {
+// ../utils/src/index.ts
+var init_src2 = __esm({
+  "../utils/src/index.ts"() {
     "use strict";
     init_esm_shims();
-    HARD_BREAK = "\\";
+    init_security();
+    init_string();
+    init_ui();
   }
 });
 
-// ../file-system-task-provider/src/metadata-style/metadata-block.ts
-function headerEndIndex(lines) {
-  const index = lines.findIndex((line) => SECTION_HEADING.test(line));
-  return index === -1 ? lines.length : index;
+// ../file-system-task-provider/src/i18n.ts
+function getI18n(locale = "en-US") {
+  return i18nConfig[locale];
 }
-function readMetadataBlock(content) {
-  const lines = splitLines(content);
-  const headerEnd = headerEndIndex(lines);
-  let start = -1;
+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";
+}
+var i18nConfig;
+var init_i18n = __esm({
+  "../file-system-task-provider/src/i18n.ts"() {
+    "use strict";
+    init_esm_shims();
+    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.",
+        priority: "Priority",
+        group: "Group",
+        groupName: "GroupName",
+        difficulty: "Difficulty"
+      },
+      "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.",
+        priority: "Prioridade",
+        group: "Grupo",
+        groupName: "NomeGrupo",
+        difficulty: "Dificuldade"
+      }
+    };
+  }
+});
+
+// ../file-system-task-provider/src/inline-metadata.ts
+function stripHardBreak(value) {
+  return value.replace(/\\$/, "").trim();
+}
+var HARD_BREAK;
+var init_inline_metadata = __esm({
+  "../file-system-task-provider/src/inline-metadata.ts"() {
+    "use strict";
+    init_esm_shims();
+    HARD_BREAK = "\\";
+  }
+});
+
+// ../file-system-task-provider/src/metadata-style/metadata-block.ts
+function headerEndIndex(lines) {
+  const index = lines.findIndex((line) => SECTION_HEADING.test(line));
+  return index === -1 ? lines.length : index;
+}
+function readMetadataBlock(content) {
+  const lines = splitLines(content);
+  const headerEnd = headerEndIndex(lines);
+  let start = -1;
   for (let index = 0; index < headerEnd; index++) {
     const line = lines[index] ?? "";
     if (isHeading(line) || line.trim() === "") continue;
@@ -468,16 +900,24 @@ function readMetadataBlock(content) {
   }
   if (start === -1) return void 0;
   let end = start;
-  while (end < headerEnd) {
-    const line = lines[end] ?? "";
-    if (isHeading(line) || !METADATA_LINE.test(line)) break;
-    end++;
+  let cursor = start;
+  while (cursor < headerEnd) {
+    const line = lines[cursor] ?? "";
+    if (isHeading(line)) break;
+    if (line.trim() === "") {
+      cursor++;
+      continue;
+    }
+    if (!METADATA_LINE.test(line)) break;
+    cursor++;
+    end = cursor;
   }
-  const blockLines = lines.slice(start, end);
   const fields = [];
-  for (const line of blockLines) {
+  const blockLines = [];
+  for (const line of lines.slice(start, end)) {
     const match = line.match(METADATA_LINE);
     if (!match?.[1]) continue;
+    blockLines.push(line);
     fields.push({ label: match[1], value: match[2] ?? "" });
   }
   return { fields, lines: blockLines, start, end };
@@ -509,7 +949,7 @@ var init_metadata_block = __esm({
   "../file-system-task-provider/src/metadata-style/metadata-block.ts"() {
     "use strict";
     init_esm_shims();
-    METADATA_LINE = /^(?:-[ \t]+)?([^:\n]{1,40}?)[ \t]*:[ \t]*(.*?)[ \t]*\\?[ \t]*$/;
+    METADATA_LINE = /^(?:-[ \t]+)?([\p{L}\p{N}][^:\n]{0,39}?)[ \t]*:[ \t]*(.*?)[ \t]*\\?[ \t]*$/u;
     SECTION_HEADING = /^#{2,}\s/;
     isHeading = (line) => line.startsWith("#");
     splitLines = (content) => content.split(/\r?\n/);
@@ -673,89 +1113,365 @@ var init_metadata_style2 = __esm({
   }
 });
 
-// ../file-system-task-provider/src/file-system-metrics-adapter.ts
-import {
-  TASK_STATUSES,
-  TASK_TYPES,
-  UserStatsSchema
-} from "@opentask/taskin-types";
-import { promises as fs } from "fs";
-import path3 from "path";
-function toISOString(date) {
-  return date.toISOString();
+// ../file-system-task-provider/src/assignee-identity.ts
+function classifyAssignee(raw, registry) {
+  const trimmed = raw.trim();
+  if (trimmed === "" || PLACEHOLDER_ASSIGNEES.includes(trimmed.toLowerCase())) {
+    return { kind: "unassigned", raw };
+  }
+  const user = registry.resolveUser(trimmed);
+  if (user) {
+    return { kind: "resolved", raw, user };
+  }
+  const folded = fold(trimmed);
+  const matches = registry.getAllUsers().filter((candidate) => fold(candidate.id) === folded || fold(candidate.name) === folded);
+  const [onlyMatch] = matches;
+  if (onlyMatch && matches.length === 1) {
+    return { kind: "correctable", raw, user: onlyMatch };
+  }
+  return { kind: "unknown", raw };
 }
-function emptyCodeMetrics() {
-  return {
-    linesAdded: 0,
-    linesRemoved: 0,
-    netChange: 0,
-    characters: 0,
-    filesChanged: 0,
-    commits: 0
-  };
+function validateAssignees(tasks, registry) {
+  const issues = [];
+  for (const task of tasks) {
+    if (task.assignee === void 0) continue;
+    const identity = classifyAssignee(task.assignee, registry);
+    switch (identity.kind) {
+      case "resolved":
+      case "unassigned":
+        break;
+      case "correctable":
+        issues.push({
+          file: task.file,
+          message: `Assignee "${identity.raw.trim()}" is not in the user registry, but folds onto exactly one registered user.`,
+          severity: "warning",
+          suggestion: `Rewrite it as "${identity.user.id}" \u2014 lint --fix does this.`
+        });
+        break;
+      case "unknown":
+        issues.push({
+          file: task.file,
+          message: `Assignee "${identity.raw.trim()}" resolves to nobody in the user registry, so it silently becomes a fabricated temporary user.`,
+          severity: "warning",
+          suggestion: `Register them in ${".taskin/.taskin-users.json"}, or fix the spelling \u2014 too ambiguous for --fix to decide.`
+        });
+        break;
+      default:
+        identity;
+    }
+  }
+  return issues;
 }
-function emptyTemporalMetrics() {
-  return {
-    byDayOfWeek: {
-      "0": 0,
-      "1": 0,
-      "2": 0,
-      "3": 0,
-      "4": 0,
-      "5": 0,
-      "6": 0
-    },
-    byTimeOfDay: { morning: 0, afternoon: 0, evening: 0, night: 0 },
-    streak: 0,
-    trend: "stable"
-  };
+async function fixAssignees(tasks, registry, io) {
+  const rewritten = [];
+  for (const task of tasks) {
+    if (task.assignee === void 0) continue;
+    const identity = classifyAssignee(task.assignee, registry);
+    if (identity.kind !== "correctable") continue;
+    const content = await io.readFile(task.file);
+    const i18n = getI18n(detectLocale(content));
+    const label = readMetadataField(content, i18n.assignee) === void 0 ? "Assignee" : i18n.assignee;
+    const next = writeMetadataField(content, label, identity.user.id);
+    if (next !== content) {
+      await io.writeFile(task.file, next);
+      rewritten.push(task.file);
+    }
+  }
+  return rewritten;
 }
-function removeCodeBlocks(content) {
-  return content.replace(/```[\s\S]*?```/g, "");
+function isSeededUser(user) {
+  const capitalized = user.id.charAt(0).toUpperCase() + user.id.slice(1);
+  return user.email === `${user.id}@example.com` && user.name === capitalized;
 }
-function resolvePeriod(period = "week") {
-  const now = /* @__PURE__ */ new Date();
-  const until = now;
-  let since;
-  switch (period) {
-    case "day":
-      since = new Date(Date.now() - MILLISECONDS_PER_DAY);
-      break;
-    case "week":
-      since = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
-      break;
-    case "month":
-      since = new Date(Date.now() - 30 * MILLISECONDS_PER_DAY);
-      break;
-    case "quarter":
-      since = new Date(Date.now() - 90 * MILLISECONDS_PER_DAY);
-      break;
-    case "year":
-      since = new Date(Date.now() - 365 * MILLISECONDS_PER_DAY);
-      break;
-    case "all":
-      since = /* @__PURE__ */ new Date(0);
-      break;
-    default:
-      since = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
-  }
-  return { since, until };
+function validateSeededUsers(assignees, registry) {
+  const referenced = new Set(
+    assignees.flatMap((raw) => {
+      if (raw === void 0) return [];
+      const identity = classifyAssignee(raw, registry);
+      return identity.kind === "resolved" || identity.kind === "correctable" ? [identity.user.id] : [];
+    })
+  );
+  return registry.getAllUsers().filter((user) => isSeededUser(user) && !referenced.has(user.id)).map((user) => ({
+    file: `${".taskin/.taskin-users.json"} (${user.id})`,
+    message: `User "${user.id}" looks like the placeholder that older taskin versions seeded on init (${user.email}), and no task points at it.`,
+    severity: "warning",
+    suggestion: `Remove it from the registry, or give it the real name and e-mail of whoever it stands for.`
+  }));
 }
-function calculateActivityFrequency(commits, period) {
-  const daysInPeriod = {
-    day: 1,
-    week: 7,
-    month: 30,
-    quarter: 90,
-    year: 365,
-    all: 365
-    // Use 1 year as baseline for 'all'
-  };
-  return commits / daysInPeriod[period];
+var PLACEHOLDER_ASSIGNEES, foldAssignee, fold;
+var init_assignee_identity = __esm({
+  "../file-system-task-provider/src/assignee-identity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_i18n();
+    init_metadata_style2();
+    PLACEHOLDER_ASSIGNEES = [
+      "a definir",
+      "to be defined",
+      "nome do responsavel",
+      "nome do respons\xE1vel",
+      "tbd",
+      "-"
+    ];
+    foldAssignee = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+    fold = foldAssignee;
+  }
+});
+
+// ../file-system-task-provider/src/auto-sync.ts
+function isNonFastForwardError(error2) {
+  if (error2 instanceof Error) {
+    return error2.message.toLowerCase().includes("non-fast-forward");
+  }
+  return false;
 }
-async function calculateCodeMetrics(gitAnalyzer, username, since, until) {
-  if (!gitAnalyzer) {
-    return emptyCodeMetrics();
+async function syncBeforeCreate(git, config) {
+  if (!config.autoSync || !config.defaultBranch) {
+    if (config.autoSync && !config.defaultBranch) {
+      console.warn("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
+    }
+    return;
+  }
+  const fetchOk = await safeCall(() => git.fetch());
+  if (!fetchOk) {
+    throw new Error("Fetch failed. Check your network connection.");
+  }
+  const rebaseOk = await safeCall(() => git.rebase(`origin/${config.defaultBranch}`));
+  if (!rebaseOk) {
+    await git.abortRebase();
+    throw new Error("Rebase failed due to conflict. Aborted.");
+  }
+}
+async function safeCall(fn) {
+  try {
+    return await fn();
+  } catch {
+    return false;
+  }
+}
+async function attemptPushWithRetry(git, pattern, message, branch, maxAttempts) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1) {
+      const fetchOk = await safeCall(() => git.fetch());
+      if (!fetchOk) {
+        throw new Error("Fetch failed during retry.");
+      }
+      const rebaseOk = await safeCall(() => git.rebase(`origin/${branch}`));
+      if (!rebaseOk) {
+        throw new Error("Rebase failed during retry.");
+      }
+    }
+    await git.addAndCommit(pattern, message);
+    try {
+      const pushOk = await git.push(branch);
+      if (pushOk) {
+        return;
+      }
+    } catch (error2) {
+      if (!isNonFastForwardError(error2)) {
+        throw error2;
+      }
+      if (attempt >= maxAttempts) {
+        throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
+      }
+      continue;
+    }
+    if (attempt >= maxAttempts) {
+      throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
+    }
+  }
+  throw new Error(`Push rejected after ${maxAttempts} retries. Exhausted retry limit.`);
+}
+async function pushAfterCreate(git, options) {
+  const pattern = `TASKS/task-${options.taskId}-*.md`;
+  const message = appendCiSkipTag(`docs(TASKS): task-${options.taskId} - ${options.title}`, options.ciSkipTag);
+  await attemptPushWithRetry(git, pattern, message, options.defaultBranch, MAX_RETRY_ATTEMPTS);
+  return true;
+}
+async function getNextTaskNumberAfterSync(options) {
+  const maxLocal = options.localCount;
+  const maxRemote = options.remoteCount;
+  if (options.autoSync) {
+    const maxNumber = Math.max(maxLocal, maxRemote);
+    return maxNumber + 1;
+  }
+  return maxLocal + 1;
+}
+async function createTaskWithSync(git, config, taskOptions) {
+  await syncBeforeCreate(git, config);
+  const nextNumber = await getNextTaskNumberAfterSync({
+    autoSync: config.autoSync,
+    localCount: 0,
+    remoteCount: 0
+  });
+  const taskId = String(nextNumber).padStart(3, "0");
+  if (config.autoSync && config.defaultBranch) {
+    await pushAfterCreate(git, {
+      taskId,
+      title: taskOptions.title,
+      defaultBranch: config.defaultBranch,
+      ciSkipTag: config.ciSkipTag
+    });
+  }
+  return { taskId };
+}
+async function squashTaskFileOnDone(git, options) {
+  if (!options.originBranch) {
+    return false;
+  }
+  const currentBranch = await git.getCurrentBranch();
+  const originBranch = options.originBranch;
+  const pattern = `TASKS/task-${options.taskId}-*.md`;
+  const assetsPattern = `TASKS/assets/task-${options.taskId}/`;
+  const coResult = await git.checkoutBranch(originBranch);
+  if (!coResult) {
+    await git.checkoutBranch(currentBranch);
+    return false;
+  }
+  try {
+    const patternsToAdd = [];
+    const fileOk = await git.checkoutFile(options.defaultBranch, pattern);
+    if (fileOk) {
+      patternsToAdd.push(pattern);
+    }
+    const assetsOk = await git.checkoutFile(options.defaultBranch, assetsPattern);
+    if (assetsOk) {
+      patternsToAdd.push(assetsPattern);
+    }
+    if (patternsToAdd.length === 0) {
+      await git.checkoutBranch(currentBranch);
+      return false;
+    }
+    const combinedPattern = patternsToAdd.join(" ");
+    const addOk = await git.addFiles(combinedPattern);
+    if (!addOk) {
+      await git.checkoutBranch(currentBranch);
+      return false;
+    }
+    const message = appendCiSkipTag(`docs(TASKS): task-${options.taskId} - done`, options.ciSkipTag);
+    const commitOk = await git.commit(message);
+    if (!commitOk) {
+      await git.checkoutBranch(currentBranch);
+      return false;
+    }
+    for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+      if (attempt > 1) {
+        await safeCall(() => git.fetch());
+        await safeCall(() => git.rebase(`origin/${originBranch}`));
+      }
+      const pushOk = await safeCall(() => git.push(originBranch));
+      if (pushOk === true) {
+        await git.checkoutBranch(currentBranch);
+        return true;
+      }
+      if (attempt >= MAX_RETRY_ATTEMPTS) {
+        await git.checkoutBranch(currentBranch);
+        throw new Error(`Squash push rejected after ${MAX_RETRY_ATTEMPTS} retries.`);
+      }
+    }
+    await git.checkoutBranch(currentBranch);
+    throw new Error(`Squash push rejected after ${MAX_RETRY_ATTEMPTS} retries.`);
+  } catch (error2) {
+    await git.checkoutBranch(currentBranch);
+    if (error2 instanceof Error) {
+      throw error2;
+    }
+    return false;
+  }
+}
+var MAX_RETRY_ATTEMPTS;
+var init_auto_sync = __esm({
+  "../file-system-task-provider/src/auto-sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src();
+    MAX_RETRY_ATTEMPTS = 3;
+  }
+});
+
+// ../file-system-task-provider/src/file-system-metrics-adapter.ts
+import {
+  TASK_STATUSES,
+  TASK_TYPES,
+  UserStatsSchema
+} from "@opentask/taskin-types";
+import { promises as fs } from "fs";
+import path3 from "path";
+function toISOString(date) {
+  return date.toISOString();
+}
+function emptyCodeMetrics() {
+  return {
+    linesAdded: 0,
+    linesRemoved: 0,
+    netChange: 0,
+    characters: 0,
+    filesChanged: 0,
+    commits: 0
+  };
+}
+function emptyTemporalMetrics() {
+  return {
+    byDayOfWeek: {
+      "0": 0,
+      "1": 0,
+      "2": 0,
+      "3": 0,
+      "4": 0,
+      "5": 0,
+      "6": 0
+    },
+    byTimeOfDay: { morning: 0, afternoon: 0, evening: 0, night: 0 },
+    streak: 0,
+    trend: "stable"
+  };
+}
+function removeCodeBlocks(content) {
+  return content.replace(/```[\s\S]*?```/g, "");
+}
+function resolvePeriod(period = "week") {
+  const now = /* @__PURE__ */ new Date();
+  const until = now;
+  let since;
+  switch (period) {
+    case "day":
+      since = new Date(Date.now() - MILLISECONDS_PER_DAY);
+      break;
+    case "week":
+      since = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
+      break;
+    case "month":
+      since = new Date(Date.now() - 30 * MILLISECONDS_PER_DAY);
+      break;
+    case "quarter":
+      since = new Date(Date.now() - 90 * MILLISECONDS_PER_DAY);
+      break;
+    case "year":
+      since = new Date(Date.now() - 365 * MILLISECONDS_PER_DAY);
+      break;
+    case "all":
+      since = /* @__PURE__ */ new Date(0);
+      break;
+    default:
+      since = new Date(Date.now() - DAYS_PER_WEEK * MILLISECONDS_PER_DAY);
+  }
+  return { since, until };
+}
+function calculateActivityFrequency(commits, period) {
+  const daysInPeriod = {
+    day: 1,
+    week: 7,
+    month: 30,
+    quarter: 90,
+    year: 365,
+    all: 365
+    // Use 1 year as baseline for 'all'
+  };
+  return commits / daysInPeriod[period];
+}
+async function calculateCodeMetrics(gitAnalyzer, username, since, until) {
+  if (!gitAnalyzer) {
+    return emptyCodeMetrics();
   }
   try {
     const commits = await gitAnalyzer.getCommits({
@@ -1116,56 +1832,6 @@ var init_file_system_metrics_adapter = __esm({
   }
 });
 
-// ../file-system-task-provider/src/i18n.ts
-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";
-}
-var i18nConfig;
-var init_i18n = __esm({
-  "../file-system-task-provider/src/i18n.ts"() {
-    "use strict";
-    init_esm_shims();
-    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.",
-        priority: "Priority",
-        group: "Group",
-        groupName: "GroupName",
-        difficulty: "Difficulty"
-      },
-      "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.",
-        priority: "Prioridade",
-        group: "Grupo",
-        groupName: "NomeGrupo",
-        difficulty: "Dificuldade"
-      }
-    };
-  }
-});
-
 // ../file-system-task-provider/src/task-validator.ts
 var task_validator_exports = {};
 __export(task_validator_exports, {
@@ -1343,7 +2009,7 @@ var init_task_validator = __esm({
 });
 
 // ../file-system-task-provider/src/user-registry.ts
-import { execSync } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { createHash } from "crypto";
 import { promises as fs2 } from "fs";
 import path4 from "path";
@@ -1460,7 +2126,7 @@ var init_user_registry = __esm({
       }
       readGitConfig(key) {
         try {
-          return execSync(`git config ${key}`, {
+          return execSync3(`git config ${key}`, {
             encoding: "utf-8",
             stdio: "pipe"
           }).trim();
@@ -1636,7 +2302,7 @@ var init_file_system_task_provider = __esm({
   "../file-system-task-provider/src/file-system-task-provider.ts"() {
     "use strict";
     init_esm_shims();
-    init_src();
+    init_src2();
     init_assignee_identity();
     init_i18n();
     init_metadata_style2();
@@ -2045,7 +2711,7 @@ __export(src_exports, {
   validateUsersFileLocation: () => validateUsersFileLocation,
   writeMetadataField: () => writeMetadataField
 });
-var init_src2 = __esm({
+var init_src3 = __esm({
   "../file-system-task-provider/src/index.ts"() {
     "use strict";
     init_esm_shims();
@@ -2068,6 +2734,7 @@ import { Command } from "commander";
 
 // src/commands/config.ts
 init_esm_shims();
+init_src();
 import chalk2 from "chalk";
 import inquirer from "inquirer";
 
@@ -2114,9 +2781,15 @@ function warning(message) {
 
 // src/lib/config-manager.ts
 init_esm_shims();
+init_src();
 import { TaskinConfigSchema } from "@opentask/taskin-types";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
+var DEFAULT_AUTOMATION_CONFIG = {
+  level: "assisted",
+  autoSync: true,
+  ciSkipTag: DEFAULT_CI_SKIP_TAG
+};
 function getAutomationBehavior(level, commits) {
   const presets = {
     manual: {
@@ -2170,6 +2843,9 @@ ${result.error.message}`);
   }
   /**
    * Save configuration to .taskin.json
+   *
+   * Takes the *input* shape: the schema fills in what it has defaults for, so
+   * a caller need not spell out `automation.ciSkipTag` to save a config.
    */
   saveConfig(config) {
     const validated = TaskinConfigSchema.parse(config);
@@ -2193,7 +2869,7 @@ ${result.error.message}`);
   setAutomationLevel(level) {
     const config = this.loadConfig();
     config.automation = {
-      autoSync: true,
+      ...DEFAULT_AUTOMATION_CONFIG,
       ...config.automation,
       level
     };
@@ -2205,11 +2881,33 @@ ${result.error.message}`);
   getAutomationConfig() {
     try {
       const config = this.loadConfig();
-      return config.automation ?? { level: "assisted", autoSync: true };
+      return config.automation ?? DEFAULT_AUTOMATION_CONFIG;
     } catch {
-      return { level: "assisted", autoSync: true };
+      return DEFAULT_AUTOMATION_CONFIG;
     }
   }
+  /**
+   * Tag appended to the commits Taskin writes on its own, so a status change
+   * does not trigger the project's pipeline.
+   *
+   * Returns `[skip ci]` when unconfigured. An empty string is a real answer —
+   * it means the project wants CI to run — so it is returned as-is.
+   */
+  getCiSkipTag() {
+    return this.getAutomationConfig().ciSkipTag ?? DEFAULT_CI_SKIP_TAG;
+  }
+  /**
+   * Set the CI-skip tag, preserving the rest of the automation block.
+   */
+  setCiSkipTag(ciSkipTag) {
+    const config = this.loadConfig();
+    config.automation = {
+      ...DEFAULT_AUTOMATION_CONFIG,
+      ...config.automation,
+      ciSkipTag
+    };
+    this.saveConfig(config);
+  }
   /**
    * Set automation configuration
    */
@@ -2227,7 +2925,8 @@ ${result.error.message}`);
       ...getAutomationBehavior(automation.level, automation.commits),
       defaultBranch: automation.defaultBranch,
       autoSync: automation.autoSync,
-      originBranch: automation.originBranch
+      originBranch: automation.originBranch,
+      ciSkipTag: automation.ciSkipTag ?? DEFAULT_CI_SKIP_TAG
     };
   }
   /**
@@ -2339,6 +3038,14 @@ var defineCommand = (config) => {
 init_esm_shims();
 
 // src/commands/config.ts
+var NO_CI_SKIP_TAG_KEYWORD = "none";
+function normalizeCiSkipTagInput(input) {
+  const trimmed = input.trim();
+  return trimmed.toLowerCase() === NO_CI_SKIP_TAG_KEYWORD ? "" : trimmed;
+}
+function describeCiSkipTag(tag) {
+  return tag.length === 0 ? "no tag \u2014 CI runs on status commits" : tag;
+}
 var configCommand = defineCommand({
   name: "config",
   description: "\u2699\uFE0F  Configure Taskin settings",
@@ -2358,6 +3065,10 @@ var configCommand = defineCommand({
     {
       flags: "--notification-events <events>",
       description: "Comma-separated events (task:start,task:done,task:review)"
+    },
+    {
+      flags: "--ci-skip-tag <tag>",
+      description: `Tag appended to Taskin's own commits so they skip CI (default "${DEFAULT_CI_SKIP_TAG}"; "none" to run CI)`
     }
   ],
   handler: async (options) => {
@@ -2375,8 +3086,12 @@ async function handleConfigCommand(options) {
     await setAutomationLevel(configManager, options.level);
     return;
   }
-  if (options["discord-webhook"]) {
-    await setDiscordNotification(configManager, options["discord-webhook"], options["notification-events"]);
+  if (options.ciSkipTag !== void 0) {
+    setCiSkipTag(configManager, options.ciSkipTag);
+    return;
+  }
+  if (options.discordWebhook) {
+    await setDiscordNotification(configManager, options.discordWebhook, options.notificationEvents);
     return;
   }
   await interactiveConfig(configManager);
@@ -2397,7 +3112,8 @@ async function showConfiguration(configManager) {
       `  Auto-commit status changes: ${behavior.autoCommitStatusChange ? chalk2.green("\u2713 Yes") : chalk2.red("\u2717 No")}`
     );
     console.log(`  Auto-commit on pause: ${behavior.autoCommitPause ? chalk2.green("\u2713 Yes") : chalk2.red("\u2717 No")}`);
-    console.log(`  Auto-commit on finish: ${behavior.autoCommitFinish ? chalk2.green("\u2713 Yes") : chalk2.red("\u2717 No")}
+    console.log(`  Auto-commit on finish: ${behavior.autoCommitFinish ? chalk2.green("\u2713 Yes") : chalk2.red("\u2717 No")}`);
+    console.log(`  CI skip tag: ${chalk2.cyan(describeCiSkipTag(configManager.getCiSkipTag()))}
 `);
     console.log(chalk2.bold("\u{1F514} Notifications"));
     const notifications = configManager.getNotifications();
@@ -2432,6 +3148,24 @@ async function showConfiguration(configManager) {
     process.exit(1);
   }
 }
+function warnAboutUnrecognizedCiSkipTag(tag) {
+  if (tag.length === 0 || isRecognizedCiSkipTag(tag)) return;
+  console.log();
+  console.log(chalk2.yellow("\u26A0\uFE0F  This tag is not one GitHub, GitLab or Bitbucket documents."));
+  if (tag.replace(/\s+/g, "").toLowerCase() === "[skip-ci]") {
+    console.log(chalk2.dim('   "[skip-ci]" with a hyphen is not recognized anywhere \u2014 it triggers CI.'));
+    console.log(chalk2.dim('   Did you mean "[skip ci]", with a space?'));
+  }
+  console.log(chalk2.dim(`   Documented tags: ${CI_SKIP_TAGS.join(", ")}`));
+  console.log(chalk2.dim("   Keeping it anyway \u2014 a self-hosted pipeline can match whatever it likes."));
+}
+function setCiSkipTag(configManager, rawTag) {
+  printHeader("Configure CI Skip Tag", "\u2699\uFE0F");
+  const tag = normalizeCiSkipTagInput(rawTag);
+  configManager.setCiSkipTag(tag);
+  success(`CI skip tag set to ${colors.highlight(describeCiSkipTag(tag))}`);
+  warnAboutUnrecognizedCiSkipTag(tag);
+}
 async function setDiscordNotification(configManager, webhookUrl, eventsFlag) {
   printHeader("Configure Discord Notification", "\u{1F514}");
   const events = eventsFlag ? eventsFlag.split(",").map((e) => e.trim()) : ["task:start", "task:done"];
@@ -2487,6 +3221,7 @@ async function interactiveConfig(configManager) {
         message: "What would you like to configure?",
         choices: [
           { name: "\u{1F916} Automation level", value: "automation" },
+          { name: "\u23ED\uFE0F  CI skip tag", value: "ciSkipTag" },
           { name: "\u{1F514} Discord notification", value: "discord" },
           { name: "\u{1F514} Telegram notification", value: "telegram" }
         ]
@@ -2494,6 +3229,8 @@ async function interactiveConfig(configManager) {
     ]);
     if (section === "automation") {
       await configureAutomation(configManager);
+    } else if (section === "ciSkipTag") {
+      await configureCiSkipTag(configManager);
     } else if (section === "discord") {
       await configureDiscordNotification(configManager);
     } else if (section === "telegram") {
@@ -2545,6 +3282,40 @@ async function configureAutomation(configManager) {
   console.log(chalk2.dim(`  Auto-commit on pause: ${behavior.autoCommitPause ? "\u2713" : "\u2717"}`));
   console.log(chalk2.dim(`  Auto-commit on finish: ${behavior.autoCommitFinish ? "\u2713" : "\u2717"}`));
 }
+async function configureCiSkipTag(configManager) {
+  printHeader("Configure CI Skip Tag", "\u23ED\uFE0F");
+  const current = configManager.getCiSkipTag();
+  console.log(`Current tag: ${chalk2.cyan(describeCiSkipTag(current))}
+`);
+  console.log(chalk2.dim("Taskin appends this to the commits it writes itself \u2014 status changes and"));
+  console.log(chalk2.dim("task files \u2014 so they do not trigger your pipeline.\n"));
+  const { choice } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "Tag for Taskin commits:",
+      default: current.length === 0 ? NO_CI_SKIP_TAG_KEYWORD : current,
+      choices: [
+        { name: `${CI_SKIP_TAGS[0]} \u2014 GitHub, GitLab and Bitbucket (recommended)`, value: CI_SKIP_TAGS[0] },
+        { name: `${CI_SKIP_TAGS[1]} \u2014 GitHub, GitLab and Bitbucket`, value: CI_SKIP_TAGS[1] },
+        { name: `${CI_SKIP_TAGS[2]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[2] },
+        { name: `${CI_SKIP_TAGS[3]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[3] },
+        { name: `${CI_SKIP_TAGS[4]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[4] },
+        { name: "none \u2014 do not mark the commits, let CI run", value: NO_CI_SKIP_TAG_KEYWORD },
+        { name: "custom\u2026 \u2014 another CI (Azure DevOps uses ***NO_CI***)", value: "custom" }
+      ]
+    }
+  ]);
+  const tag = choice === "custom" ? (await inquirer.prompt([
+    {
+      type: "input",
+      name: "customTag",
+      message: "Tag to append:",
+      default: current
+    }
+  ])).customTag : choice;
+  setCiSkipTag(configManager, tag);
+}
 async function configureDiscordNotification(configManager) {
   printHeader("Configure Discord Notification", "\u{1F514}");
   const notifications = configManager.getNotifications() ?? {};
@@ -3000,1220 +3771,640 @@ var TaskWebSocketServer = class {
           await this.handlePauseRequest(client, message);
           break;
         case "ping":
-          this.sendToClient(client.id, { type: "pong" });
-          break;
-        default:
-          this.sendToClient(client.id, {
-            type: "error",
-            payload: { message: `Unknown message type: ${message.type}` }
-          });
-      }
-    } catch (error2) {
-      this.log("Error handling message:", error2);
-      this.sendToClient(client.id, {
-        type: "error",
-        payload: {
-          message: error2 instanceof Error ? error2.message : "Failed to process message"
-        }
-      });
-    }
-  }
-  /**
-   * Reads the task id out of an incoming message.
-   *
-   * Ids on the wire are untrusted strings: a branded `TaskId` is only worth
-   * something if the boundary that produces it actually validates. Answers the
-   * client with a clear error instead of letting a ZodError leak out of the
-   * generic catch.
-   */
-  readTaskId(client, message, field = "taskId") {
-    const raw = message.payload?.[field];
-    const parsed = typeof raw === "string" ? TaskIdSchema.safeParse(raw) : void 0;
-    if (!parsed?.success) {
-      this.sendToClient(client.id, {
-        type: "error",
-        payload: { message: `Invalid task id in '${message.type}' request` },
-        requestId: message.requestId
-      });
-      return void 0;
-    }
-    return parsed.data;
-  }
-  /**
-   * Handle list request
-   */
-  async handleListRequest(client, message) {
-    const tasks = await this.taskProvider.getAllTasks();
-    const [first] = tasks;
-    if (first) {
-      this.log("[WS Server] Sending", tasks.length, "tasks");
-      this.log("[WS Server] First task assignee:", first.assignee);
-    }
-    this.sendToClient(client.id, {
-      type: "tasks",
-      payload: tasks,
-      requestId: message.requestId
-    });
-  }
-  /**
-   * Handle find request
-   */
-  async handleFindRequest(client, message) {
-    const taskId = this.readTaskId(client, message);
-    if (!taskId)
-      return;
-    const task = await this.taskProvider.findTask(taskId);
-    this.sendToClient(client.id, {
-      type: "task:found",
-      payload: task,
-      requestId: message.requestId
-    });
-  }
-  /**
-   * Handle update request
-   */
-  async handleUpdateRequest(client, message) {
-    const taskId = this.readTaskId(client, message, "id");
-    if (!taskId)
-      return;
-    const stored = await this.taskProvider.findTask(taskId);
-    if (!stored) {
-      this.sendToClient(client.id, {
-        type: "error",
-        payload: { message: `Task ${taskId} not found` },
-        requestId: message.requestId
-      });
-      return;
-    }
-    const outcome = applyTaskUpdate(stored, message.payload);
-    if (!outcome.ok) {
-      this.sendToClient(client.id, {
-        type: "error",
-        payload: { message: outcome.message },
-        requestId: message.requestId
-      });
-      return;
-    }
-    await this.taskProvider.updateTask(outcome.task);
-    this.broadcast({
-      type: "task:updated",
-      payload: outcome.task
-    });
-  }
-  /**
-   * Handle start task request
-   */
-  async handleStartRequest(client, message) {
-    const taskId = this.readTaskId(client, message);
-    if (!taskId)
-      return;
-    const task = await this.taskManager.startTask(taskId);
-    this.broadcast({
-      type: "task:updated",
-      payload: task
-    });
-  }
-  /**
-   * Handle finish task request
-   */
-  async handleFinishRequest(client, message) {
-    const taskId = this.readTaskId(client, message);
-    if (!taskId)
-      return;
-    const task = await this.taskManager.finishTask(taskId);
-    this.broadcast({
-      type: "task:updated",
-      payload: task
-    });
-  }
-  /**
-   * Handle pause task request
-   */
-  async handlePauseRequest(client, message) {
-    const taskId = this.readTaskId(client, message);
-    if (!taskId)
-      return;
-    const task = await this.taskManager.pauseTask(taskId);
-    this.broadcast({
-      type: "task:updated",
-      payload: task
-    });
-  }
-  /**
-   * Start heartbeat to check client connections
-   */
-  startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      this.clients.forEach((client) => {
-        if (!client.isAlive) {
-          this.log(`Client ${client.id} timeout, terminating`);
-          client.ws.terminate();
-          this.clients.delete(client.id);
-          return;
-        }
-        client.isAlive = false;
-        client.ws.ping();
-      });
-    }, this.options.heartbeatInterval);
-  }
-  /**
-   * Stop heartbeat
-   */
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-  }
-  /**
-   * Debug logging
-   */
-  log(...args) {
-    if (this.options.debug) {
-      console.log("[TaskWebSocketServer]", ...args);
-    }
-  }
-};
-
-// node_modules/@opentask/taskin-task-server-ws/dist/task-server-ws.mock.js
-init_esm_shims();
-import { parseTaskId } from "@opentask/taskin-types";
-
-// node_modules/@opentask/taskin-task-server-ws/dist/task-server-ws.types.js
-init_esm_shims();
-
-// src/commands/dashboard.ts
-init_src();
-import chalk4 from "chalk";
-import express from "express";
-import { createServer } from "http";
-import path8 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/lib/provider-factory/index.ts
-init_esm_shims();
-
-// src/lib/provider-factory/provider-factory.ts
-init_esm_shims();
-import path7 from "path";
-
-// src/lib/notification/env-resolver.ts
-init_esm_shims();
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
-var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
-function loadDotEnv(dir) {
-  try {
-    const envPath = join2(dir ?? process.cwd(), ".env");
-    const content = readFileSync2(envPath, "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIndex = trimmed.indexOf("=");
-      if (eqIndex === -1) continue;
-      const key = trimmed.slice(0, eqIndex).trim();
-      let value = trimmed.slice(eqIndex + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
-      }
-      if (!process.env[key]) {
-        process.env[key] = value;
-      }
-    }
-  } catch {
-  }
-}
-function resolveEnvVars(value) {
-  return value.replace(ENV_VAR_PATTERN, (_match, varName) => {
-    return process.env[varName] ?? "";
-  });
-}
-
-// src/lib/provider-registry/index.ts
-init_esm_shims();
-
-// src/lib/provider-registry/provider-registry.ts
-init_esm_shims();
-var AVAILABLE_PROVIDERS = [
-  {
-    id: "fs",
-    name: "\u{1F4C1} File System",
-    description: "Store tasks as Markdown files in a local TASKS/ directory",
-    packageName: "@opentask/taskin-file-system-provider",
-    configSchema: {
-      required: ["tasksDir"],
-      properties: {
-        tasksDir: {
-          type: "string",
-          description: "Directory to store task files"
-        },
-        metadataStyle: {
-          type: "string",
-          description: "Marking of the metadata block for new files (list | hard-break | plain)"
-        }
-      }
-    },
-    status: "stable"
-  },
-  {
-    id: "redmine",
-    name: "\u{1F534} Redmine",
-    description: "Sync tasks with Redmine issues via REST API",
-    packageName: "@opentask/taskin-redmine-provider",
-    configSchema: {
-      required: ["apiUrl", "apiKey", "projectId"],
-      properties: {
-        apiUrl: {
-          type: "string",
-          description: "Redmine server URL (e.g., https://redmine.example.com)"
-        },
-        apiKey: {
-          type: "string",
-          description: "Your Redmine API key",
-          secret: true
-        },
-        projectId: {
-          type: "string",
-          description: "Project identifier or ID"
-        }
-      }
-    },
-    status: "coming-soon"
-  },
-  {
-    id: "jira",
-    name: "\u{1F535} Jira",
-    description: "Sync tasks with Jira issues via REST API",
-    packageName: "@opentask/taskin-jira-provider",
-    configSchema: {
-      required: ["apiUrl", "email", "apiToken", "projectKey"],
-      properties: {
-        apiUrl: {
-          type: "string",
-          description: "Jira server URL (e.g., https://company.atlassian.net)"
-        },
-        email: {
-          type: "string",
-          description: "Your Atlassian account email"
-        },
-        apiToken: {
-          type: "string",
-          description: "Your Jira API token",
-          secret: true
-        },
-        projectKey: {
-          type: "string",
-          description: "Project key (e.g., PROJ)"
-        }
-      }
-    },
-    status: "coming-soon"
-  },
-  {
-    id: "github",
-    name: "\u{1F419} GitHub Issues",
-    description: "Sync tasks with GitHub Issues",
-    packageName: "@opentask/taskin-github-provider",
-    configSchema: {
-      required: ["owner", "repo", "token"],
-      properties: {
-        owner: {
-          type: "string",
-          description: "Repository owner (username or organization)"
-        },
-        repo: {
-          type: "string",
-          description: "Repository name"
-        },
-        token: {
-          type: "string",
-          description: "GitHub Personal Access Token",
-          secret: true
-        }
-      }
-    },
-    status: "coming-soon"
-  }
-];
-function getProviderById(id) {
-  return AVAILABLE_PROVIDERS.find((p) => p.id === id);
-}
-function getAllProviders() {
-  return AVAILABLE_PROVIDERS;
-}
-
-// src/lib/provider-registry/provider-registry.types.ts
-init_esm_shims();
-
-// src/lib/provider-factory/provider-factory.ts
-function expandProviderConfig(config) {
-  const expanded = {};
-  for (const [key, value] of Object.entries(config)) {
-    expanded[key] = typeof value === "string" ? resolveEnvVars(value) : value;
-  }
-  return expanded;
-}
-var buildFileSystemProvider = async ({ projectRoot, providerConfig, tasksDirOverride }) => {
-  const { FileSystemTaskProvider: FileSystemTaskProvider2, isMetadataStyleId: isMetadataStyleId2, UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
-  const configuredTasksDir = typeof providerConfig.tasksDir === "string" ? providerConfig.tasksDir : "TASKS";
-  const tasksDir = path7.resolve(projectRoot, tasksDirOverride ?? configuredTasksDir);
-  const userRegistry = new UserRegistry2({ taskinDir: path7.join(projectRoot, ".taskin") });
-  const metadataStyle = isMetadataStyleId2(providerConfig.metadataStyle) ? providerConfig.metadataStyle : void 0;
-  const convertMetadataStyleTo = isMetadataStyleId2(providerConfig.convertMetadataStyleTo) ? providerConfig.convertMetadataStyleTo : void 0;
-  const provider = new FileSystemTaskProvider2(tasksDir, userRegistry, void 0, void 0, {
-    ...metadataStyle !== void 0 && { metadataStyle },
-    ...convertMetadataStyleTo !== void 0 && { convertMetadataStyleTo }
-  });
-  return { provider, userRegistry };
-};
-var PROVIDER_BUILDERS = {
-  fs: buildFileSystemProvider
-};
-function unknownProviderError(providerType, builders) {
-  const known = getProviderById(providerType);
-  if (known) {
-    return new Error(
-      `Provider "${providerType}" (${known.name}) is configured in .taskin.json but has no implementation yet (status: ${known.status}).
-Install/await ${known.packageName}, or change provider.type.`
-    );
-  }
-  const buildable = Object.keys(builders).join(", ");
-  const listed = getAllProviders().map((provider) => provider.id).join(", ");
-  return new Error(
-    `Unknown provider.type "${providerType}" in .taskin.json.
-Usable now: ${buildable}. Known ids: ${listed}.`
-  );
-}
-async function resolveTaskProvider(options = {}, builders = PROVIDER_BUILDERS) {
-  const projectRoot = path7.resolve(options.cwd ?? process.cwd());
-  loadDotEnv(projectRoot);
-  const config = new ConfigManager(projectRoot).loadConfig();
-  const providerType = config.provider.type;
-  const build = builders[providerType];
-  if (!build) {
-    throw unknownProviderError(providerType, builders);
-  }
-  const context = {
-    projectRoot,
-    providerConfig: { ...expandProviderConfig(config.provider.config), ...options.configOverrides },
-    ...options.tasksDir !== void 0 && { tasksDirOverride: options.tasksDir }
-  };
-  const { provider, userRegistry } = await build(context);
-  await userRegistry.load();
-  return { provider, userRegistry, projectRoot, providerType };
-}
-
-// src/lib/provider-factory/provider-factory.types.ts
-init_esm_shims();
-
-// src/commands/dashboard.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path8.dirname(__filename2);
-async function startHttpServer(app, startPort, host, maxAttempts = 10) {
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const tryPort = startPort + attempt;
-    try {
-      const server = createServer(app);
-      await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(tryPort, host, () => resolve());
-      });
-      return { server, port: tryPort };
-    } catch (err) {
-      const nodeErr = err;
-      if (nodeErr.code !== "EADDRINUSE") {
-        throw err;
-      }
-      if (attempt < maxAttempts - 1) {
-        info(`Port ${tryPort} is in use, trying port ${tryPort + 1}...`);
+          this.sendToClient(client.id, { type: "pong" });
+          break;
+        default:
+          this.sendToClient(client.id, {
+            type: "error",
+            payload: { message: `Unknown message type: ${message.type}` }
+          });
       }
+    } catch (error2) {
+      this.log("Error handling message:", error2);
+      this.sendToClient(client.id, {
+        type: "error",
+        payload: {
+          message: error2 instanceof Error ? error2.message : "Failed to process message"
+        }
+      });
     }
   }
-  throw new Error(
-    `Could not find an available port after ${maxAttempts} attempts (tried ${startPort}-${startPort + maxAttempts - 1})`
-  );
-}
-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: "-b, --browser",
-      description: "Open browser automatically"
-    },
-    {
-      flags: "--open",
-      description: "Show only open tasks (pending, in-progress, blocked)"
-    },
-    {
-      flags: "--closed",
-      description: "Show only closed tasks (done, canceled)"
+  /**
+   * Reads the task id out of an incoming message.
+   *
+   * Ids on the wire are untrusted strings: a branded `TaskId` is only worth
+   * something if the boundary that produces it actually validates. Answers the
+   * client with a clear error instead of letting a ZodError leak out of the
+   * generic catch.
+   */
+  readTaskId(client, message, field = "taskId") {
+    const raw = message.payload?.[field];
+    const parsed = typeof raw === "string" ? TaskIdSchema.safeParse(raw) : void 0;
+    if (!parsed?.success) {
+      this.sendToClient(client.id, {
+        type: "error",
+        payload: { message: `Invalid task id in '${message.type}' request` },
+        requestId: message.requestId
+      });
+      return void 0;
     }
-  ],
-  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);
+    return parsed.data;
   }
-  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);
+  /**
+   * Handle list request
+   */
+  async handleListRequest(client, message) {
+    const tasks = await this.taskProvider.getAllTasks();
+    const [first] = tasks;
+    if (first) {
+      this.log("[WS Server] Sending", tasks.length, "tasks");
+      this.log("[WS Server] First task assignee:", first.assignee);
+    }
+    this.sendToClient(client.id, {
+      type: "tasks",
+      payload: tasks,
+      requestId: message.requestId
+    });
   }
-  if (!isValidPort(wsPort)) {
-    error("Security validation failed");
-    error(`Invalid WebSocket port: ${wsPort}. Must be between 1 and 65535.`);
-    process.exit(1);
+  /**
+   * Handle find request
+   */
+  async handleFindRequest(client, message) {
+    const taskId = this.readTaskId(client, message);
+    if (!taskId)
+      return;
+    const task = await this.taskProvider.findTask(taskId);
+    this.sendToClient(client.id, {
+      type: "task:found",
+      payload: task,
+      requestId: message.requestId
+    });
   }
-  printHeader("Starting Taskin Dashboard", "\u{1F4CA}");
-  try {
-    info("Initializing task provider...");
-    let currentDir = process.cwd();
-    let tasksDir = path8.join(currentDir, "TASKS");
-    try {
-      await import("fs").then((fs6) => fs6.promises.access(tasksDir));
-    } catch {
-      while (currentDir !== path8.dirname(currentDir)) {
-        const workspaceFile = path8.join(currentDir, "pnpm-workspace.yaml");
-        try {
-          await import("fs").then((fs6) => fs6.promises.access(workspaceFile));
-          tasksDir = path8.join(currentDir, "TASKS");
-          break;
-        } catch {
-          currentDir = path8.dirname(currentDir);
-        }
-      }
+  /**
+   * Handle update request
+   */
+  async handleUpdateRequest(client, message) {
+    const taskId = this.readTaskId(client, message, "id");
+    if (!taskId)
+      return;
+    const stored = await this.taskProvider.findTask(taskId);
+    if (!stored) {
+      this.sendToClient(client.id, {
+        type: "error",
+        payload: { message: `Task ${taskId} not found` },
+        requestId: message.requestId
+      });
+      return;
     }
-    info(`Using tasks directory: ${tasksDir}`);
-    const monorepoRoot = path8.dirname(tasksDir);
-    const { provider } = await resolveTaskProvider({ cwd: monorepoRoot });
-    const manager = new TaskManager(provider);
-    info(`Starting WebSocket server on ${host}:${wsPort}...`);
-    const wsServer = new TaskWebSocketServer({
-      taskManager: manager,
-      taskProvider: provider,
-      options: {
-        port: wsPort,
-        host
-      }
+    const outcome = applyTaskUpdate(stored, message.payload);
+    if (!outcome.ok) {
+      this.sendToClient(client.id, {
+        type: "error",
+        payload: { message: outcome.message },
+        requestId: message.requestId
+      });
+      return;
+    }
+    await this.taskProvider.updateTask(outcome.task);
+    this.broadcast({
+      type: "task:updated",
+      payload: outcome.task
     });
-    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 ? path8.join(__dirname2, "..", "..", "dashboard-dist") : path8.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();
+  }
+  /**
+   * Handle start task request
+   */
+  async handleStartRequest(client, message) {
+    const taskId = this.readTaskId(client, message);
+    if (!taskId)
+      return;
+    const task = await this.taskManager.startTask(taskId);
+    this.broadcast({
+      type: "task:updated",
+      payload: task
     });
-    app.use((req, res, next) => {
-      if (req.path === "/" || req.path === "/index.html") {
-        import("fs").then((fs6) => fs6.promises.readFile(path8.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();
-      }
+  }
+  /**
+   * Handle finish task request
+   */
+  async handleFinishRequest(client, message) {
+    const taskId = this.readTaskId(client, message);
+    if (!taskId)
+      return;
+    const task = await this.taskManager.finishTask(taskId);
+    this.broadcast({
+      type: "task:updated",
+      payload: task
     });
-    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");
+  }
+  /**
+   * Handle pause task request
+   */
+  async handlePauseRequest(client, message) {
+    const taskId = this.readTaskId(client, message);
+    if (!taskId)
+      return;
+    const task = await this.taskManager.pauseTask(taskId);
+    this.broadcast({
+      type: "task:updated",
+      payload: task
     });
-    const { server: httpServer, port: actualPort } = await startHttpServer(app, port, host);
-    if (actualPort !== port) {
-      warning(`Port ${port} was in use. Dashboard started on port ${actualPort}.`);
-    }
-    success(`\u2713 Dashboard available at http://${host}:${actualPort}`);
-    const filterParams = new URLSearchParams();
-    if (options.open) {
-      filterParams.set("filter", "open");
-    } else if (options.closed) {
-      filterParams.set("filter", "closed");
-    }
-    const filterQuery = filterParams.toString() ? `?${filterParams.toString()}` : "";
-    if (options.browser) {
-      const url = `http://${host}:${actualPort}${filterQuery}`;
-      await import("child_process").then((cp) => {
-        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-        cp.exec(`${cmd} ${url}`);
+  }
+  /**
+   * Start heartbeat to check client connections
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      this.clients.forEach((client) => {
+        if (!client.isAlive) {
+          this.log(`Client ${client.id} timeout, terminating`);
+          client.ws.terminate();
+          this.clients.delete(client.id);
+          return;
+        }
+        client.isAlive = false;
+        client.ws.ping();
       });
+    }, this.options.heartbeatInterval);
+  }
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
     }
-    info("");
-    info(chalk4.bold("Dashboard Controls:"));
-    info(`  \u2022 Dashboard: ${chalk4.cyan(`http://${host}:${actualPort}${filterQuery}`)}`);
-    info(`  \u2022 WebSocket: ${chalk4.cyan(`ws://${host}:${wsPort}`)}`);
-    if (options.open) {
-      info(`  \u2022 Filter: ${chalk4.yellow("Open tasks only")}`);
-    } else if (options.closed) {
-      info(`  \u2022 Filter: ${chalk4.yellow("Closed tasks only")}`);
-    }
-    info(`  \u2022 Press ${chalk4.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);
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[TaskWebSocketServer]", ...args);
     }
-    process.exit(1);
   }
-}
+};
 
-// src/commands/export.ts
+// node_modules/@opentask/taskin-task-server-ws/dist/task-server-ws.mock.js
+init_esm_shims();
+import { parseTaskId } from "@opentask/taskin-types";
+
+// node_modules/@opentask/taskin-task-server-ws/dist/task-server-ws.types.js
 init_esm_shims();
+
+// src/commands/dashboard.ts
 init_src2();
+import chalk4 from "chalk";
+import express from "express";
+import { createServer } from "http";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
-// ../git-utils/src/index.ts
+// src/lib/provider-factory/index.ts
 init_esm_shims();
 
-// ../git-utils/src/git.ts
+// src/lib/provider-factory/provider-factory.ts
 init_esm_shims();
-import { execSync as execSync2 } from "child_process";
-function executeGit(command) {
+import path7 from "path";
+
+// src/lib/notification/env-resolver.ts
+init_esm_shims();
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
+function loadDotEnv(dir) {
   try {
-    return execSync2(`git ${command}`, {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
+    const envPath = join2(dir ?? process.cwd(), ".env");
+    const content = readFileSync2(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) continue;
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
   } catch {
-    return "";
   }
 }
-function isGitRepository() {
-  return !!executeGit("rev-parse --is-inside-work-tree");
-}
-function getCurrentBranch() {
-  return executeGit("branch --show-current");
+function resolveEnvVars(value) {
+  return value.replace(ENV_VAR_PATTERN, (_match, varName) => {
+    return process.env[varName] ?? "";
+  });
 }
-function createBranch(branchName, baseBranch) {
-  const base = baseBranch || getCurrentBranch();
-  executeGit(`checkout -b ${branchName} ${base}`);
+
+// src/lib/provider-registry/index.ts
+init_esm_shims();
+
+// src/lib/provider-registry/provider-registry.ts
+init_esm_shims();
+var AVAILABLE_PROVIDERS = [
+  {
+    id: "fs",
+    name: "\u{1F4C1} File System",
+    description: "Store tasks as Markdown files in a local TASKS/ directory",
+    packageName: "@opentask/taskin-file-system-provider",
+    configSchema: {
+      required: ["tasksDir"],
+      properties: {
+        tasksDir: {
+          type: "string",
+          description: "Directory to store task files"
+        },
+        metadataStyle: {
+          type: "string",
+          description: "Marking of the metadata block for new files (list | hard-break | plain)"
+        }
+      }
+    },
+    status: "stable"
+  },
+  {
+    id: "redmine",
+    name: "\u{1F534} Redmine",
+    description: "Sync tasks with Redmine issues via REST API",
+    packageName: "@opentask/taskin-redmine-provider",
+    configSchema: {
+      required: ["apiUrl", "apiKey", "projectId"],
+      properties: {
+        apiUrl: {
+          type: "string",
+          description: "Redmine server URL (e.g., https://redmine.example.com)"
+        },
+        apiKey: {
+          type: "string",
+          description: "Your Redmine API key",
+          secret: true
+        },
+        projectId: {
+          type: "string",
+          description: "Project identifier or ID"
+        }
+      }
+    },
+    status: "coming-soon"
+  },
+  {
+    id: "jira",
+    name: "\u{1F535} Jira",
+    description: "Sync tasks with Jira issues via REST API",
+    packageName: "@opentask/taskin-jira-provider",
+    configSchema: {
+      required: ["apiUrl", "email", "apiToken", "projectKey"],
+      properties: {
+        apiUrl: {
+          type: "string",
+          description: "Jira server URL (e.g., https://company.atlassian.net)"
+        },
+        email: {
+          type: "string",
+          description: "Your Atlassian account email"
+        },
+        apiToken: {
+          type: "string",
+          description: "Your Jira API token",
+          secret: true
+        },
+        projectKey: {
+          type: "string",
+          description: "Project key (e.g., PROJ)"
+        }
+      }
+    },
+    status: "coming-soon"
+  },
+  {
+    id: "github",
+    name: "\u{1F419} GitHub Issues",
+    description: "Sync tasks with GitHub Issues",
+    packageName: "@opentask/taskin-github-provider",
+    configSchema: {
+      required: ["owner", "repo", "token"],
+      properties: {
+        owner: {
+          type: "string",
+          description: "Repository owner (username or organization)"
+        },
+        repo: {
+          type: "string",
+          description: "Repository name"
+        },
+        token: {
+          type: "string",
+          description: "GitHub Personal Access Token",
+          secret: true
+        }
+      }
+    },
+    status: "coming-soon"
+  }
+];
+function getProviderById(id) {
+  return AVAILABLE_PROVIDERS.find((p) => p.id === id);
+}
+function getAllProviders() {
+  return AVAILABLE_PROVIDERS;
 }
 
-// ../git-utils/src/git.types.ts
+// src/lib/provider-registry/provider-registry.types.ts
 init_esm_shims();
 
-// ../git-utils/src/git-analyzer.ts
-init_esm_shims();
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-function isNodeError(error2) {
-  return typeof error2 === "object" && error2 !== null && "code" in error2;
-}
-async function executeGit2(command, cwd) {
-  try {
-    const { stdout } = await execAsync(`git ${command}`, {
-      cwd: cwd || process.cwd(),
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024,
-      // 10MB buffer for large repos
-      timeout: 3e4
-      // 30 second timeout
-    });
-    return stdout.trim();
-  } catch (error2) {
-    if (isNodeError(error2)) {
-      if (error2.code === "ENOENT") {
-        throw new Error("Git is not installed or not in PATH");
-      }
-    }
-    return "";
+// src/lib/provider-factory/provider-factory.ts
+function expandProviderConfig(config) {
+  const expanded = {};
+  for (const [key, value] of Object.entries(config)) {
+    expanded[key] = typeof value === "string" ? resolveEnvVars(value) : value;
   }
+  return expanded;
 }
-var GitAnalyzer = class {
-  constructor(repositoryPath) {
-    this.repositoryPath = repositoryPath;
-  }
-  async isValidRepository() {
-    try {
-      const result = await executeGit2("rev-parse --is-inside-work-tree", this.repositoryPath);
-      return result === "true";
-    } catch {
-      return false;
-    }
-  }
-  async getRepositoryRoot() {
-    const result = await executeGit2("rev-parse --show-toplevel", this.repositoryPath);
-    if (!result) {
-      throw new Error("Not a git repository");
-    }
-    return result;
-  }
-  async getCommits(options = {}) {
-    const args = ["log"];
-    args.push(
-      "--pretty='format:%H|%an|%aI|%s%x00%b'",
-      "--numstat"
-      // Get file stats
+var buildFileSystemProvider = async ({ projectRoot, providerConfig, tasksDirOverride }) => {
+  const { FileSystemTaskProvider: FileSystemTaskProvider2, isMetadataStyleId: isMetadataStyleId2, UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
+  const configuredTasksDir = typeof providerConfig.tasksDir === "string" ? providerConfig.tasksDir : "TASKS";
+  const tasksDir = path7.resolve(projectRoot, tasksDirOverride ?? configuredTasksDir);
+  const userRegistry = new UserRegistry2({ taskinDir: path7.join(projectRoot, ".taskin") });
+  const metadataStyle = isMetadataStyleId2(providerConfig.metadataStyle) ? providerConfig.metadataStyle : void 0;
+  const convertMetadataStyleTo = isMetadataStyleId2(providerConfig.convertMetadataStyleTo) ? providerConfig.convertMetadataStyleTo : void 0;
+  const provider = new FileSystemTaskProvider2(tasksDir, userRegistry, void 0, void 0, {
+    ...metadataStyle !== void 0 && { metadataStyle },
+    ...convertMetadataStyleTo !== void 0 && { convertMetadataStyleTo }
+  });
+  return { provider, userRegistry };
+};
+var PROVIDER_BUILDERS = {
+  fs: buildFileSystemProvider
+};
+function unknownProviderError(providerType, builders) {
+  const known = getProviderById(providerType);
+  if (known) {
+    return new Error(
+      `Provider "${providerType}" (${known.name}) is configured in .taskin.json but has no implementation yet (status: ${known.status}).
+Install/await ${known.packageName}, or change provider.type.`
     );
-    if (options.since) {
-      args.push(`--since="${options.since}"`);
-    }
-    if (options.until) {
-      args.push(`--until=${options.until}`);
-    }
-    if (options.author) {
-      args.push(`--author='${options.author}'`);
-    }
-    if (options.maxCount) {
-      args.push(`-n ${options.maxCount}`);
-    }
-    if (!options.includeMerges) {
-      args.push("--no-merges");
-    }
-    if (options.filePath) {
-      args.push("--", options.filePath);
-    }
-    const command = args.join(" ");
-    const output = await executeGit2(command, this.repositoryPath);
-    if (!output) {
-      return [];
-    }
-    return this.parseCommits(output);
-  }
-  parseCommits(output) {
-    const commits = [];
-    const lines = output.split("\n");
-    let i = 0;
-    while (i < lines.length) {
-      const line = lines[i];
-      if (line === void 0) break;
-      if (!line.trim()) {
-        i++;
-        continue;
-      }
-      if (line.includes("|")) {
-        const [hash, author, date, messageWithBody] = line.split("|");
-        if (hash === void 0 || author === void 0 || date === void 0 || messageWithBody === void 0) {
-          i++;
-          continue;
-        }
-        if (!/^[0-9a-f]{6,40}$/i.test(hash)) {
-          i++;
-          continue;
-        }
-        const nullByteIndex = messageWithBody.indexOf("\0");
-        const subject = nullByteIndex !== -1 ? messageWithBody.substring(0, nullByteIndex) : messageWithBody;
-        const bodyLines = [];
-        if (nullByteIndex !== -1) {
-          bodyLines.push(messageWithBody.substring(nullByteIndex + 1));
-        }
-        i++;
-        while (i < lines.length) {
-          const bodyLine = lines[i];
-          if (bodyLine === void 0 || bodyLine.includes("|") || bodyLine.includes("	")) break;
-          if (bodyLine.trim()) {
-            bodyLines.push(bodyLine);
-          }
-          i++;
-        }
-        const body = bodyLines.join("\n");
-        const fullMessage = body ? `${subject}
-
-${body}` : subject;
-        let filesChanged = 0;
-        let linesAdded = 0;
-        let linesRemoved = 0;
-        while (i < lines.length) {
-          const rawStatLine = lines[i];
-          if (rawStatLine === void 0 || rawStatLine.includes("|")) break;
-          const statLine = rawStatLine.trim();
-          if (!statLine) {
-            i++;
-            continue;
-          }
-          const [added, removed] = statLine.split("	");
-          if (added !== "-" && removed !== "-") {
-            linesAdded += parseInt(added || "0", 10);
-            linesRemoved += parseInt(removed || "0", 10);
-            filesChanged++;
-          }
-          i++;
-        }
-        commits.push({
-          hash,
-          author,
-          date,
-          message: subject,
-          filesChanged,
-          linesAdded,
-          linesRemoved,
-          coAuthors: this.extractCoAuthors(fullMessage)
-        });
-      } else {
-        i++;
-      }
-    }
-    return commits;
-  }
-  extractCoAuthors(message) {
-    const coAuthorRegex = /Co-authored-by:\s*(.+?)\s*<(.+?)>/gi;
-    const matches = Array.from(message.matchAll(coAuthorRegex));
-    const names = matches.flatMap((match) => match[1]?.trim() ?? []);
-    return names.length > 0 ? names : void 0;
-  }
-  async getDiff(from = "HEAD", to = "") {
-    const args = ["diff", "--numstat"];
-    if (to) {
-      args.push(`${from}..${to}`);
-    } else {
-      args.push(from);
-    }
-    const output = await executeGit2(args.join(" "), this.repositoryPath);
-    return this.parseDiff(output);
-  }
-  parseDiff(output) {
-    const files = [];
-    let totalLinesAdded = 0;
-    let totalLinesRemoved = 0;
-    if (!output) {
-      return {
-        files,
-        totalLinesAdded,
-        totalLinesRemoved,
-        netChange: 0
-      };
-    }
-    const lines = output.split("\n").filter((l) => l.trim());
-    for (const line of lines) {
-      const [added, removed, path12] = line.split("	");
-      if (added === void 0 || removed === void 0 || path12 === void 0) continue;
-      if (added === "-" || removed === "-") {
-        continue;
-      }
-      const linesAdded = parseInt(added, 10);
-      const linesRemoved = parseInt(removed, 10);
-      totalLinesAdded += linesAdded;
-      totalLinesRemoved += linesRemoved;
-      files.push({
-        path: path12,
-        linesAdded,
-        linesRemoved,
-        changeType: "modified"
-        // Simplified - could be enhanced with --name-status
-      });
-    }
-    return {
-      files,
-      totalLinesAdded,
-      totalLinesRemoved,
-      netChange: totalLinesAdded - totalLinesRemoved
-    };
-  }
-  async getFileDiff(filePath, from = "HEAD", to = "") {
-    const args = ["diff", "--numstat"];
-    if (to) {
-      args.push(`${from}..${to}`);
-    } else {
-      args.push(from);
-    }
-    args.push("--", filePath);
-    const output = await executeGit2(args.join(" "), this.repositoryPath);
-    if (!output) {
-      return null;
-    }
-    const [added, removed, path12] = output.split("	");
-    if (added === void 0 || removed === void 0 || path12 === void 0) {
-      return null;
-    }
-    if (added === "-" || removed === "-") {
-      return null;
-    }
-    return {
-      path: path12,
-      linesAdded: parseInt(added, 10),
-      linesRemoved: parseInt(removed, 10),
-      changeType: "modified"
-    };
-  }
-  async getBlame(filePath) {
-    const args = ["blame", "--line-porcelain", filePath];
-    const output = await executeGit2(args.join(" "), this.repositoryPath);
-    if (!output) {
-      return [];
-    }
-    return this.parseBlame(output);
-  }
-  parseBlame(output) {
-    const lines = output.split("\n");
-    const blameInfo = [];
-    let currentHash = "";
-    let currentAuthor = "";
-    let currentDate = "";
-    let lineNumber = 0;
-    for (const line of lines) {
-      if (line.match(/^[0-9a-f]{6,40}/i)) {
-        const [hash, , finalLine] = line.split(" ");
-        currentHash = hash ?? "";
-        lineNumber = parseInt(finalLine ?? "", 10);
-      } else if (line.startsWith("author ")) {
-        currentAuthor = line.substring(7);
-      } else if (line.startsWith("author-time ")) {
-        const timestamp = parseInt(line.substring(12), 10);
-        currentDate = new Date(timestamp * 1e3).toISOString();
-      } else if (line.startsWith("	")) {
-        const content = line.substring(1);
-        blameInfo.push({
-          lineNumber,
-          commitHash: currentHash,
-          author: currentAuthor,
-          date: new Date(currentDate),
-          content
-        });
-      }
-    }
-    return blameInfo;
-  }
-  async getAuthors(options = {}) {
-    const args = ["shortlog", "-sne"];
-    if (options.since) {
-      args.push(`--since=${options.since}`);
-    }
-    if (options.until) {
-      args.push(`--until=${options.until}`);
-    }
-    if (!options.includeMerges) {
-      args.push("--no-merges");
-    }
-    if (options.filePath) {
-      args.push("--", options.filePath);
-    }
-    const command = args.join(" ");
-    const output = await executeGit2(command, this.repositoryPath);
-    if (!output) {
-      return [];
-    }
-    return this.parseAuthors(output);
-  }
-  parseAuthors(output) {
-    const lines = output.split("\n").filter((l) => l.trim());
-    const authors = [];
-    for (const line of lines) {
-      const match = line.match(/^\s*(\d+)\s+(.+?)\s+<(.+?)>/);
-      if (match) {
-        const [, commits, name, email] = match;
-        if (commits === void 0 || name === void 0 || email === void 0) continue;
-        authors.push({
-          name,
-          email,
-          commits: parseInt(commits, 10)
-        });
-      }
-    }
-    return authors;
   }
-  async getFileHistory(filePath, options = {}) {
-    return this.getCommits({
-      ...options,
-      filePath
-    });
+  const buildable = Object.keys(builders).join(", ");
+  const listed = getAllProviders().map((provider) => provider.id).join(", ");
+  return new Error(
+    `Unknown provider.type "${providerType}" in .taskin.json.
+Usable now: ${buildable}. Known ids: ${listed}.`
+  );
+}
+async function resolveTaskProvider(options = {}, builders = PROVIDER_BUILDERS) {
+  const projectRoot = path7.resolve(options.cwd ?? process.cwd());
+  loadDotEnv(projectRoot);
+  const config = new ConfigManager(projectRoot).loadConfig();
+  const providerType = config.provider.type;
+  const build = builders[providerType];
+  if (!build) {
+    throw unknownProviderError(providerType, builders);
   }
-};
+  const context = {
+    projectRoot,
+    providerConfig: { ...expandProviderConfig(config.provider.config), ...options.configOverrides },
+    ...options.tasksDir !== void 0 && { tasksDirOverride: options.tasksDir }
+  };
+  const { provider, userRegistry } = await build(context);
+  await userRegistry.load();
+  return { provider, userRegistry, projectRoot, providerType };
+}
 
-// ../git-utils/src/git-analyzer.types.ts
+// src/lib/provider-factory/provider-factory.types.ts
 init_esm_shims();
 
-// ../git-utils/src/git-service.ts
-init_esm_shims();
-import { execSync as execSync3 } from "child_process";
-var GitService = class {
-  constructor(cwd = process.cwd()) {
-    this.cwd = cwd;
-  }
-  async addFiles(pattern) {
-    try {
-      execSync3(`git add ${pattern}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async commit(message) {
+// src/commands/dashboard.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path8.dirname(__filename2);
+async function startHttpServer(app, startPort, host, maxAttempts = 10) {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const tryPort = startPort + attempt;
     try {
-      execSync3(`git commit -m "${message}"`, {
-        cwd: this.cwd,
-        stdio: "ignore"
+      const server = createServer(app);
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(tryPort, host, () => resolve());
       });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async addAndCommit(pattern, message) {
-    const added = await this.addFiles(pattern);
-    if (!added) return false;
-    return this.commit(message);
-  }
-  async commitTaskStatusChange(taskId, status) {
-    const pattern = `TASKS/task-${taskId}-*.md`;
-    const message = `docs(TASKS): task-${taskId} - atualiza status para ${status} [skip-ci]`;
-    return this.addAndCommit(pattern, message);
-  }
-  async commitTaskStatusChangeOnBranch(taskId, status, defaultBranch) {
-    if (!defaultBranch) {
-      return this.commitTaskStatusChange(taskId, status);
-    }
-    try {
-      const currentBranch = execSync3("git rev-parse --abbrev-ref HEAD", {
-        cwd: this.cwd,
-        encoding: "utf8",
-        stdio: "pipe"
-      }).trim();
-      if (currentBranch === defaultBranch) {
-        return this.commitTaskStatusChange(taskId, status);
-      }
-      const taskPattern = `TASKS/task-${taskId}-*.md`;
-      let taskFileContent = null;
-      let taskFilePath = null;
-      try {
-        const files = execSync3(`git ls-files -m ${taskPattern}`, {
-          cwd: this.cwd,
-          encoding: "utf8",
-          stdio: "pipe"
-        }).trim();
-        if (files) {
-          taskFilePath = files.split("\n")[0] ?? null;
-          const { readFileSync: readFileSync4 } = await import("fs");
-          taskFileContent = readFileSync4(`${this.cwd}/${taskFilePath}`, "utf-8");
-        }
-      } catch {
+      return { server, port: tryPort };
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code !== "EADDRINUSE") {
+        throw err;
       }
-      const hasChanges = await this.hasUncommittedChanges();
-      let stashed = false;
-      try {
-        if (hasChanges) {
-          execSync3('git stash push -u -m "taskin-temp-stash"', {
-            cwd: this.cwd,
-            stdio: "ignore"
-          });
-          stashed = true;
-        }
-        execSync3(`git checkout ${defaultBranch}`, {
-          cwd: this.cwd,
-          stdio: "ignore"
-        });
-        let committed = false;
-        if (taskFileContent && taskFilePath) {
-          const { writeFileSync: writeFileSync3 } = await import("fs");
-          writeFileSync3(`${this.cwd}/${taskFilePath}`, taskFileContent, "utf-8");
-          const message = `docs(TASKS): task-${taskId} - atualiza status para ${status} [skip-ci]`;
-          committed = await this.addAndCommit(taskPattern, message);
-        } else {
-          const message = `docs(TASKS): task-${taskId} - atualiza status para ${status} [skip-ci]`;
-          committed = await this.addAndCommit(taskPattern, message);
-        }
-        execSync3(`git checkout ${currentBranch}`, {
-          cwd: this.cwd,
-          stdio: "ignore"
-        });
-        if (stashed) {
-          execSync3("git stash pop", {
-            cwd: this.cwd,
-            stdio: "ignore"
-          });
-        }
-        return committed;
-      } catch {
-        try {
-          execSync3(`git checkout ${currentBranch}`, {
-            cwd: this.cwd,
-            stdio: "ignore"
-          });
-          if (stashed) {
-            execSync3("git stash pop", {
-              cwd: this.cwd,
-              stdio: "ignore"
-            });
-          }
-        } catch {
-        }
-        return false;
+      if (attempt < maxAttempts - 1) {
+        info(`Port ${tryPort} is in use, trying port ${tryPort + 1}...`);
       }
-    } catch {
-      return false;
     }
   }
-  async hasUncommittedChanges() {
-    try {
-      const output = execSync3("git status --porcelain", {
-        cwd: this.cwd,
-        encoding: "utf8",
-        stdio: "pipe"
-      });
-      return output.trim().length > 0;
-    } catch {
-      return false;
-    }
+  throw new Error(
+    `Could not find an available port after ${maxAttempts} attempts (tried ${startPort}-${startPort + maxAttempts - 1})`
+  );
+}
+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: "-b, --browser",
+      description: "Open browser automatically"
+    },
+    {
+      flags: "--open",
+      description: "Show only open tasks (pending, in-progress, blocked)"
+    },
+    {
+      flags: "--closed",
+      description: "Show only closed tasks (done, canceled)"
+    }
+  ],
+  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);
   }
-  async getCurrentBranch() {
-    try {
-      return execSync3("git branch --show-current", {
-        cwd: this.cwd,
-        encoding: "utf8",
-        stdio: "pipe"
-      }).trim();
-    } catch {
-      return "";
-    }
+  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);
   }
-  async isGitRepository() {
-    return Promise.resolve(isGitRepository());
+  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);
   }
-  async createBranch(branchName, baseBranch) {
-    try {
-      createBranch(branchName, baseBranch);
-      return true;
-    } catch {
-      return false;
-    }
+  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);
   }
-  async checkoutBranch(branchName) {
-    try {
-      execSync3(`git checkout ${branchName}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-      return false;
-    }
+  if (!isValidPort(wsPort)) {
+    error("Security validation failed");
+    error(`Invalid WebSocket port: ${wsPort}. Must be between 1 and 65535.`);
+    process.exit(1);
   }
-  async fetch(remote = "origin") {
+  printHeader("Starting Taskin Dashboard", "\u{1F4CA}");
+  try {
+    info("Initializing task provider...");
+    let currentDir = process.cwd();
+    let tasksDir = path8.join(currentDir, "TASKS");
     try {
-      execSync3(`git fetch ${remote}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
-      });
-      return true;
+      await import("fs").then((fs6) => fs6.promises.access(tasksDir));
     } catch {
-      return false;
+      while (currentDir !== path8.dirname(currentDir)) {
+        const workspaceFile = path8.join(currentDir, "pnpm-workspace.yaml");
+        try {
+          await import("fs").then((fs6) => fs6.promises.access(workspaceFile));
+          tasksDir = path8.join(currentDir, "TASKS");
+          break;
+        } catch {
+          currentDir = path8.dirname(currentDir);
+        }
+      }
     }
-  }
-  async rebase(branch) {
-    try {
-      execSync3(`git rebase ${branch}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-      return false;
+    info(`Using tasks directory: ${tasksDir}`);
+    const monorepoRoot = path8.dirname(tasksDir);
+    const { provider } = await resolveTaskProvider({ cwd: monorepoRoot });
+    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 ? path8.join(__dirname2, "..", "..", "dashboard-dist") : path8.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((fs6) => fs6.promises.readFile(path8.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 { server: httpServer, port: actualPort } = await startHttpServer(app, port, host);
+    if (actualPort !== port) {
+      warning(`Port ${port} was in use. Dashboard started on port ${actualPort}.`);
     }
-  }
-  async push(branch, remote = "origin") {
-    try {
-      execSync3(`git push ${remote} ${branch}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-      return false;
+    success(`\u2713 Dashboard available at http://${host}:${actualPort}`);
+    const filterParams = new URLSearchParams();
+    if (options.open) {
+      filterParams.set("filter", "open");
+    } else if (options.closed) {
+      filterParams.set("filter", "closed");
     }
-  }
-  async abortRebase() {
-    try {
-      execSync3("git rebase --abort", {
-        cwd: this.cwd,
-        stdio: "ignore"
+    const filterQuery = filterParams.toString() ? `?${filterParams.toString()}` : "";
+    if (options.browser) {
+      const url = `http://${host}:${actualPort}${filterQuery}`;
+      await import("child_process").then((cp) => {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        cp.exec(`${cmd} ${url}`);
       });
-      return true;
-    } catch {
-      return false;
     }
-  }
-  async checkoutFile(branch, pattern) {
-    try {
-      execSync3(`git checkout ${branch} -- ${pattern}`, {
-        cwd: this.cwd,
-        stdio: "ignore"
+    info("");
+    info(chalk4.bold("Dashboard Controls:"));
+    info(`  \u2022 Dashboard: ${chalk4.cyan(`http://${host}:${actualPort}${filterQuery}`)}`);
+    info(`  \u2022 WebSocket: ${chalk4.cyan(`ws://${host}:${wsPort}`)}`);
+    if (options.open) {
+      info(`  \u2022 Filter: ${chalk4.yellow("Open tasks only")}`);
+    } else if (options.closed) {
+      info(`  \u2022 Filter: ${chalk4.yellow("Closed tasks only")}`);
+    }
+    info(`  \u2022 Press ${chalk4.bold("Ctrl+C")} to stop both servers`);
+    info("");
+    const cleanup = async () => {
+      info("\nShutting down servers...");
+      await new Promise((resolve) => {
+        httpServer.close(() => resolve());
       });
-      return true;
-    } catch {
-      return false;
+      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);
   }
-};
-
-// ../git-utils/src/git-service.types.ts
-init_esm_shims();
+}
 
 // src/commands/export.ts
+init_esm_shims();
+init_src3();
+init_src();
 import fs5 from "fs/promises";
 import path9 from "path";
 function userStatsToCsv(stats) {
@@ -4291,7 +4482,8 @@ function registerExportCommand(program2) {
 
 // src/commands/finish.ts
 init_esm_shims();
-init_src2();
+init_src3();
+init_src();
 import { execSync as execSync5 } from "child_process";
 
 // src/lib/notification/notify-helper.ts
@@ -4713,6 +4905,14 @@ async function finishTask(taskId, options, gitService) {
   }
   info(`Found task: ${task.title}`);
   info(`Current status: ${task.status}`);
+  const configManager = new ConfigManager(monorepoRoot);
+  const behavior = configManager.getAutomationBehavior();
+  const autoSyncActive = behavior.autoSync && !!behavior.defaultBranch;
+  const statusCommitMessage = buildTaskStatusCommitMessage({
+    taskId: normalizedId,
+    status: "done",
+    ciSkipTag: behavior.ciSkipTag
+  });
   if (options.dryRun) {
     console.log();
     info("\u{1F50D} Dry run mode - showing what would be executed:");
@@ -4724,7 +4924,7 @@ async function finishTask(taskId, options, gitService) {
     info("Git operations:");
     console.log(
       colors.secondary(
-        `  - Commit status: git add TASKS/task-${normalizedId}-*.md && git commit -m "docs(TASKS): task-${normalizedId} - atualiza status para done [skip-ci]"`
+        `  - Commit status: git add TASKS/task-${normalizedId}-*.md && git commit -m "${statusCommitMessage}"`
       )
     );
     console.log(
@@ -4741,13 +4941,10 @@ async function finishTask(taskId, options, gitService) {
     error("Task is already done");
     process.exit(1);
   }
-  const configManager = new ConfigManager(monorepoRoot);
-  const behavior = configManager.getAutomationBehavior();
-  const autoSyncActive = behavior.autoSync && !!behavior.defaultBranch;
   if (behavior.autoSync && !behavior.defaultBranch) {
     warning("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
   }
-  const git = gitService ?? new GitService(process.cwd());
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
   if (!options.skipUpdate) {
     info("Marking task as done...");
     const updatedTask = await taskManager.finishTask(task.id);
@@ -4764,7 +4961,8 @@ async function finishTask(taskId, options, gitService) {
         const squashed = await squashTaskFileOnDone(git, {
           taskId: normalizedId,
           defaultBranch: behavior.defaultBranch,
-          originBranch: behavior.originBranch
+          originBranch: behavior.originBranch,
+          ciSkipTag: behavior.ciSkipTag
         });
         if (squashed) {
           success(`\u2713 Squash commit pushed to ${behavior.originBranch}`);
@@ -4798,7 +4996,7 @@ async function finishTask(taskId, options, gitService) {
     if (!options.skipUpdate) {
       if (!behavior.autoCommitStatusChange) {
         steps.push(
-          `Commit the status change: git add TASKS/task-${normalizedId}-*.md && git commit -m "docs(TASKS): task-${normalizedId} - atualiza status para done [skip-ci]"`
+          `Commit the status change: git add TASKS/task-${normalizedId}-*.md && git commit -m "${statusCommitMessage}"`
         );
       }
       steps.push("Review your changes");
@@ -4839,6 +5037,7 @@ async function finishTask(taskId, options, gitService) {
 
 // src/commands/init.ts
 init_esm_shims();
+init_src();
 import { existsSync as existsSync5, readdirSync, writeFileSync as writeFileSync2 } from "fs";
 import inquirer2 from "inquirer";
 import { join as join3 } from "path";
@@ -4929,6 +5128,7 @@ async function ensureProviderInstalled(provider) {
 init_esm_shims();
 
 // src/commands/init.ts
+var NO_CI_SKIP_TAG_KEYWORD2 = "none";
 var initCommand = defineCommand({
   name: "init",
   alias: "setup",
@@ -4941,6 +5141,10 @@ var initCommand = defineCommand({
     {
       flags: "-p, --provider <provider>",
       description: "Provider to use (fs, redmine, jira, github) - skips interactive prompt"
+    },
+    {
+      flags: "--ci-skip-tag <tag>",
+      description: `Tag appended to Taskin's own commits so they skip CI (default "${DEFAULT_CI_SKIP_TAG}"; "none" to run CI) - skips interactive prompt`
     }
   ],
   handler: async (options) => {
@@ -4999,8 +5203,14 @@ async function initializeTaskin(options) {
     await ensureProviderInstalled(selectedProvider);
   }
   const providerConfig = await setupProviderConfig(selectedProvider, cwd);
+  const ciSkipTag = await resolveCiSkipTag(options.ciSkipTag);
   const config = {
     version: "1.0.3",
+    automation: {
+      level: "assisted",
+      autoSync: true,
+      ciSkipTag
+    },
     provider: {
       type: selectedProvider.id,
       config: providerConfig
@@ -5027,6 +5237,51 @@ async function initializeTaskin(options) {
   info("For more information, run: taskin --help");
   console.log();
 }
+async function resolveCiSkipTag(fromFlag) {
+  if (fromFlag !== void 0) {
+    return normalizeCiSkipTag(fromFlag);
+  }
+  if (process.env.CI === "true") {
+    return DEFAULT_CI_SKIP_TAG;
+  }
+  console.log();
+  info("Taskin appends a tag to the commits it writes itself \u2014 status changes and");
+  info("task files \u2014 so they do not trigger your pipeline.");
+  console.log();
+  const { choice } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "Tag for Taskin commits:",
+      default: DEFAULT_CI_SKIP_TAG,
+      choices: [
+        { name: `${CI_SKIP_TAGS[0]} \u2014 GitHub, GitLab and Bitbucket (recommended)`, value: CI_SKIP_TAGS[0] },
+        { name: `${CI_SKIP_TAGS[1]} \u2014 GitHub, GitLab and Bitbucket`, value: CI_SKIP_TAGS[1] },
+        { name: `${CI_SKIP_TAGS[2]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[2] },
+        { name: `${CI_SKIP_TAGS[3]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[3] },
+        { name: `${CI_SKIP_TAGS[4]} \u2014 GitHub Actions only`, value: CI_SKIP_TAGS[4] },
+        { name: "none \u2014 do not mark the commits, let CI run", value: NO_CI_SKIP_TAG_KEYWORD2 },
+        { name: "custom\u2026 \u2014 another CI (Azure DevOps uses ***NO_CI***)", value: "custom" }
+      ]
+    }
+  ]);
+  if (choice !== "custom") {
+    return normalizeCiSkipTag(choice);
+  }
+  const { customTag } = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "customTag",
+      message: "Tag to append:",
+      default: DEFAULT_CI_SKIP_TAG
+    }
+  ]);
+  return normalizeCiSkipTag(customTag);
+}
+function normalizeCiSkipTag(input) {
+  const trimmed = input.trim();
+  return trimmed.toLowerCase() === NO_CI_SKIP_TAG_KEYWORD2 ? "" : trimmed;
+}
 async function setupProviderConfig(provider, cwd) {
   if (provider.id === "fs") {
     return setupFileSystemProvider(cwd);
@@ -5051,7 +5306,7 @@ async function setupProviderConfig(provider, cwd) {
 }
 async function setupFileSystemProvider(cwd) {
   const tasksDir = join3(cwd, "TASKS");
-  const { DEFAULT_METADATA_STYLE_ID: DEFAULT_METADATA_STYLE_ID2, FileSystemTaskProvider: FileSystemTaskProvider2, getMetadataStyle: getMetadataStyle2, UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+  const { DEFAULT_METADATA_STYLE_ID: DEFAULT_METADATA_STYLE_ID2, FileSystemTaskProvider: FileSystemTaskProvider2, getMetadataStyle: getMetadataStyle2, UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
   const userRegistry = new UserRegistry2({ taskinDir: join3(cwd, ".taskin") });
   const fileSystemProvider = new FileSystemTaskProvider2(tasksDir, userRegistry);
   await fileSystemProvider.initialize();
@@ -5096,7 +5351,7 @@ You can edit or delete this file. Use \`taskin list\` to see all tasks.
   };
 }
 async function promptCreateFirstUser(cwd) {
-  const { UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+  const { UserRegistry: UserRegistry2 } = await Promise.resolve().then(() => (init_src3(), src_exports));
   const taskinDir = join3(cwd, ".taskin");
   const userRegistry = new UserRegistry2({ taskinDir });
   const { createFirstUser } = await inquirer2.prompt([
@@ -5862,7 +6117,8 @@ async function startMCPServer(options) {
 
 // src/commands/new.ts
 init_esm_shims();
-init_src2();
+init_src3();
+init_src();
 import { TASK_TYPES as TASK_TYPES2 } from "@opentask/taskin-types";
 import inquirer3 from "inquirer";
 var createCommand = defineCommand({
@@ -5964,7 +6220,7 @@ async function createTask(options, gitService) {
   if (behavior.autoSync && !behavior.defaultBranch) {
     warning("autoSync is enabled but no defaultBranch is configured. Nothing will be synced.");
   }
-  const git = gitService ?? new GitService(process.cwd());
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
   if (autoSyncActive) {
     try {
       await syncBeforeCreate(git, {
@@ -5996,7 +6252,8 @@ async function createTask(options, gitService) {
       await pushAfterCreate(git, {
         taskId,
         title: options.title,
-        defaultBranch: behavior.defaultBranch
+        defaultBranch: behavior.defaultBranch,
+        ciSkipTag: behavior.ciSkipTag
       });
     } catch (pushError) {
       error(
@@ -6216,6 +6473,7 @@ async function pauseTask(taskId, options) {
 
 // src/commands/review.ts
 init_esm_shims();
+init_src();
 import { execSync as execSync9 } from "child_process";
 
 // src/lib/hook-runner.ts
@@ -6441,10 +6699,14 @@ async function reviewTask(taskId, options) {
   success(`\u2713 Task ${updatedTask.id} status changed to: ${updatedTask.status}`);
   if (behavior.autoCommitStatusChange) {
     try {
-      execSync9(
-        `git add TASKS/task-${normalizedId}-*.md && git commit -m "docs(TASKS): task-${normalizedId} - mark as ready for review [skip-ci]"`,
-        { cwd: monorepoRoot, stdio: "ignore" }
+      const message = appendCiSkipTag(
+        `docs(TASKS): task-${normalizedId} - mark as ready for review`,
+        behavior.ciSkipTag
       );
+      execSync9(`git add TASKS/task-${normalizedId}-*.md && git commit -m "${message}"`, {
+        cwd: monorepoRoot,
+        stdio: "ignore"
+      });
       success("\u2713 Auto-committed status change");
     } catch {
     }
@@ -6492,6 +6754,7 @@ async function reviewTask(taskId, options) {
 
 // src/commands/start.ts
 init_esm_shims();
+init_src();
 var startCommand = defineCommand({
   name: "start <task-id>",
   description: "\u{1F680} Start working on a task",
@@ -6536,6 +6799,13 @@ async function startTask(taskId, _options, gitService) {
   }
   info(`Found task: ${task.title}`);
   info(`Current status: ${task.status}`);
+  const configManager = new ConfigManager(monorepoRoot);
+  const behavior = configManager.getAutomationBehavior();
+  const statusCommitMessage = buildTaskStatusCommitMessage({
+    taskId: normalizedId,
+    status: "in-progress",
+    ciSkipTag: behavior.ciSkipTag
+  });
   if (_options.dryRun) {
     console.log();
     info("\u{1F50D} Dry run mode - showing what would be executed:");
@@ -6547,7 +6817,7 @@ async function startTask(taskId, _options, gitService) {
     console.log(colors.secondary(`  - Create branch: git checkout -b feat/task-${normalizedId}`));
     console.log(
       colors.secondary(
-        `  - Commit status: git add TASKS/task-${normalizedId}-*.md && git commit -m "docs(TASKS): task-${normalizedId} - atualiza status para in-progress [skip-ci]"`
+        `  - Commit status: git add TASKS/task-${normalizedId}-*.md && git commit -m "${statusCommitMessage}"`
       )
     );
     console.log();
@@ -6566,9 +6836,7 @@ async function startTask(taskId, _options, gitService) {
   const updatedTask = await taskManager.startTask(task.id);
   success(`Task ${updatedTask.id} started successfully!`);
   success(`Status changed to: ${updatedTask.status}`);
-  const configManager = new ConfigManager(monorepoRoot);
-  const behavior = configManager.getAutomationBehavior();
-  const git = gitService ?? new GitService(process.cwd());
+  const git = gitService ?? new GitService(process.cwd(), { ciSkipTag: behavior.ciSkipTag });
   if (behavior.autoCommitStatusChange) {
     const committed = await git.commitTaskStatusChangeOnBranch(normalizedId, "in-progress", behavior.defaultBranch);
     if (committed) {
@@ -6580,7 +6848,7 @@ async function startTask(taskId, _options, gitService) {
     info("Next steps (suggestions):");
     console.log(
       colors.secondary(
-        `  1. Commit the status change: git add TASKS/task-${normalizedId}-*.md && git commit -m "docs(TASKS): task-${normalizedId} - atualiza status para in-progress [skip ci]"`
+        `  1. Commit the status change: git add TASKS/task-${normalizedId}-*.md && git commit -m "${statusCommitMessage}"`
       )
     );
     console.log(colors.secondary(`  2. Create a branch: git checkout -b feat/task-${normalizedId}`));
@@ -6601,7 +6869,8 @@ async function startTask(taskId, _options, gitService) {
 
 // src/commands/stats.ts
 init_esm_shims();
-init_src2();
+init_src3();
+init_src();
 import chalk7 from "chalk";
 import path11 from "path";
 var statsCommand = defineCommand({
@@ -6943,7 +7212,7 @@ init_esm_shims();
 
 // src/lib/file-system-task-linter/file-system-task-linter.ts
 init_esm_shims();
-init_src2();
+init_src3();
 import { TASK_STATUSES as TASK_STATUSES3, TASK_TYPES as TASK_TYPES3 } from "@opentask/taskin-types";
 import chalk8 from "chalk";
 import { readdir, readFile as readFile2 } from "fs/promises";