esedre 0.1.11 → 1.0.0

package/dist/esedre.mjs

@@ -7,9 +7,19 @@ import path9 from "node:path";
 // src/storage/filesystem.ts
 import fs3 from "node:fs";
 import path3 from "node:path";
+import os2 from "node:os";
 
 // src/types.ts
-var CURRENT_ESEDRE_VERSION = "0.1.11";
+var CURRENT_ESEDRE_VERSION = "1.0.0";
+var INVERSE_RELATIONS = {
+  "relates-to": "relates-to",
+  "blocks": "blocked-by",
+  "blocked-by": "blocks",
+  "parent-of": "child-of",
+  "child-of": "parent-of",
+  "duplicates": "duplicated-by",
+  "duplicated-by": "duplicates"
+};
 var EsedreConflictError = class extends Error {
   constructor(ticketId, currentHash, lastHash) {
     super(
@@ -446,9 +456,13 @@ function computeTicketHash(ticket) {
     title: (ticket.meta.title || "").trim(),
     category: ticket.meta.category,
     status: ticket.meta.status,
+    priority: ticket.meta.priority || "",
     complexity: ticket.meta.complexity || "",
     effort: ticket.meta.estimatedEffort || "",
     project: ticket.meta.project || "",
+    milestone: ticket.meta.milestone || "",
+    featureFlag: ticket.meta.featureFlag || "",
+    links: ticket.meta.links || [],
     revision: ticket.meta.revision || 1,
     completedAt: ticket.meta.completedAt || "",
     detailRaw: (ticket.detail?.raw || "").trim(),
@@ -495,11 +509,17 @@ async function generateProjectSnapshot(storage, projectCode, outputDir) {
       title: ticketObj.meta.title,
       type: ticketObj.meta.type || ticketObj.meta.category || "Feature",
       category: ticketObj.meta.type || ticketObj.meta.category || "Feature",
+      priority: ticketObj.meta.priority,
       status: ticketObj.meta.status,
       complexity: ticketObj.meta.complexity,
       estimatedEffort: ticketObj.meta.estimatedEffort,
       project: pCode,
       summary: ticketObj.detail?.summary,
+      milestone: ticketObj.meta.milestone,
+      featureFlag: ticketObj.meta.featureFlag,
+      inheritedFeatureFlag: ticketObj.meta.inheritedFeatureFlag,
+      links: ticketObj.meta.links || [],
+      isBlocked: ticketObj.isBlocked || false,
       hasPlan: Boolean(plan && plan.trim().length > 0),
       planMarkdown: plan && plan.trim().length > 0 ? plan : void 0,
       createdAt,
@@ -510,12 +530,38 @@ async function generateProjectSnapshot(storage, projectCode, outputDir) {
       sha1
     });
   }
+  let milestoneSnapshots;
+  try {
+    const rawMilestones = await storage.listMilestones(projectCode);
+    milestoneSnapshots = rawMilestones.map((m) => {
+      const mTickets = entries.filter(
+        (t) => t.milestone && (t.milestone.toLowerCase() === String(m.id).toLowerCase() || t.milestone.toLowerCase() === m.title.toLowerCase())
+      );
+      const completed = mTickets.filter((t) => t.status === "Completed").length;
+      const total = mTickets.length;
+      const progressPercent = total > 0 ? Math.round(completed / total * 100) : 0;
+      return {
+        id: m.id,
+        project: m.project,
+        title: m.title,
+        description: m.description,
+        status: m.status,
+        featureFlag: m.featureFlag,
+        targetDate: m.targetDate,
+        totalTickets: total,
+        completedTickets: completed,
+        progressPercent
+      };
+    });
+  } catch {
+  }
   const snapshot = {
     version: CURRENT_ESEDRE_VERSION,
     projectCode,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     totalTickets: entries.length,
-    tickets: entries
+    tickets: entries,
+    ...milestoneSnapshots && milestoneSnapshots.length > 0 ? { milestones: milestoneSnapshots } : {}
   };
   const esedreDir = path2.join(outputDir, ".esedre");
   if (!fs2.existsSync(esedreDir)) {
@@ -538,6 +584,289 @@ async function generateProjectSnapshot(storage, projectCode, outputDir) {
   return snapshot;
 }
 
+// src/utils/formatter.ts
+var isColorSupported = !process.env.NO_COLOR && (process.stdout.isTTY || process.env.FORCE_COLOR);
+var colors = {
+  reset: isColorSupported ? "\x1B[0m" : "",
+  bold: isColorSupported ? "\x1B[1m" : "",
+  dim: isColorSupported ? "\x1B[2m" : "",
+  cyan: isColorSupported ? "\x1B[36m" : "",
+  green: isColorSupported ? "\x1B[32m" : "",
+  yellow: isColorSupported ? "\x1B[33m" : "",
+  magenta: isColorSupported ? "\x1B[35m" : "",
+  red: isColorSupported ? "\x1B[31m" : "",
+  blue: isColorSupported ? "\x1B[34m" : ""
+};
+function normalizePriority(val) {
+  if (!val) return void 0;
+  const lower = String(val).trim().toLowerCase();
+  if (lower === "critical") return "Critical";
+  if (lower === "high") return "High";
+  if (lower === "medium") return "Medium";
+  if (lower === "low") return "Low";
+  return void 0;
+}
+function normalizeDashesAndMojibake(val) {
+  if (typeof val !== "string") return val;
+  return val.replace(/–|‗/g, "-").replace(/â€[˜™]/g, "'").replace(/â€[Å“Â ]/g, '"').replace(/\u00e2\u20ac\u201c|\u00e2\u0080\u0093|–/g, "-").replace(/\u00e2\u20ac\u201d|\u00e2\u0080\u0094|—/g, "-").replace(/\u00e2\u20ac\u02dc|\u00e2\u20ac\u2122|‘|’/g, "'").replace(/\u00e2\u20ac\u0153|\u00e2\u20ac\u009d|\u00e2\u0080\u009d|“|â€\u009d|†/g, '"').replace(/\u00e2\u20ac\u00a6|…/g, "...").replace(/[\u2012\u2013\u2014\u2015\u2212]/g, "-");
+}
+function normalizeTicketFields(ticket) {
+  if (!ticket) return ticket;
+  if (ticket.meta) {
+    if (ticket.meta.title) ticket.meta.title = normalizeDashesAndMojibake(ticket.meta.title);
+    if (ticket.meta.estimatedEffort) ticket.meta.estimatedEffort = normalizeDashesAndMojibake(ticket.meta.estimatedEffort);
+    if (ticket.meta.complexity) ticket.meta.complexity = normalizeDashesAndMojibake(ticket.meta.complexity);
+    if (ticket.meta.milestone) ticket.meta.milestone = normalizeDashesAndMojibake(ticket.meta.milestone);
+    if (ticket.meta.featureFlag) ticket.meta.featureFlag = normalizeDashesAndMojibake(ticket.meta.featureFlag);
+    if (ticket.meta.inheritedFeatureFlag) ticket.meta.inheritedFeatureFlag = normalizeDashesAndMojibake(ticket.meta.inheritedFeatureFlag);
+    if (ticket.meta.priority) {
+      const norm = normalizePriority(ticket.meta.priority);
+      if (norm) {
+        ticket.meta.priority = norm;
+      } else {
+        delete ticket.meta.priority;
+      }
+    }
+  }
+  if (ticket.detail) {
+    if (ticket.detail.title) ticket.detail.title = normalizeDashesAndMojibake(ticket.detail.title);
+    if (ticket.detail.estimatedEffort) ticket.detail.estimatedEffort = normalizeDashesAndMojibake(ticket.detail.estimatedEffort);
+    if (ticket.detail.summary) ticket.detail.summary = normalizeDashesAndMojibake(ticket.detail.summary);
+    if (ticket.detail.milestone) ticket.detail.milestone = normalizeDashesAndMojibake(ticket.detail.milestone);
+    if (ticket.detail.priority) {
+      const norm = normalizePriority(ticket.detail.priority);
+      if (norm) {
+        ticket.detail.priority = norm;
+      } else {
+        delete ticket.detail.priority;
+      }
+    }
+    if (ticket.detail.breakdown) ticket.detail.breakdown = ticket.detail.breakdown.map((b) => normalizeDashesAndMojibake(b));
+    if (ticket.detail.technicalDetails) ticket.detail.technicalDetails = ticket.detail.technicalDetails.map((t) => normalizeDashesAndMojibake(t));
+    if (ticket.detail.openQuestions) ticket.detail.openQuestions = ticket.detail.openQuestions.map((q) => normalizeDashesAndMojibake(q));
+    if (ticket.detail.raw) ticket.detail.raw = normalizeDashesAndMojibake(ticket.detail.raw);
+  }
+  if (ticket.planMarkdown) {
+    ticket.planMarkdown = normalizeDashesAndMojibake(ticket.planMarkdown);
+  }
+  if (ticket.comments) {
+    for (const c of ticket.comments) {
+      if (c.text) c.text = normalizeDashesAndMojibake(c.text);
+      if (c.author) c.author = normalizeDashesAndMojibake(c.author);
+    }
+  }
+  return ticket;
+}
+function formatTicketListTable(tickets) {
+  if (tickets.length === 0) {
+    return `${colors.dim}No tickets found matching criteria.${colors.reset}`;
+  }
+  const showPriority = tickets.some((t) => Boolean(t.meta.priority));
+  const rows = tickets.map((t) => {
+    const id = t.projectDescriptor?.code ? `${t.projectDescriptor.code}-${t.meta.id}` : `#${t.meta.id}`;
+    const project = t.projectDescriptor?.code || "CORE";
+    const type = t.meta.type || t.meta.category || "Feature";
+    const priority = t.meta.priority || "-";
+    const status = t.meta.status;
+    const title = normalizeDashesAndMojibake(t.meta.title) + (t.isBlocked ? ` ${colors.red}[BLOCKED]${colors.reset}` : "");
+    return { id, project, type, priority, status, title };
+  });
+  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
+  const projWidth = Math.max(7, ...rows.map((r) => r.project.length));
+  const typeWidth = Math.max(8, ...rows.map((r) => r.type.length));
+  const prioWidth = showPriority ? Math.max(8, ...rows.map((r) => r.priority.length)) : 0;
+  const statusWidth = Math.max(14, ...rows.map((r) => r.status.length));
+  const headerParts = [
+    pad("ID", idWidth),
+    pad("Project", projWidth),
+    pad("Type", typeWidth)
+  ];
+  if (showPriority) headerParts.push(pad("Priority", prioWidth));
+  headerParts.push(pad("Status", statusWidth), "Title");
+  const header = `${colors.bold}${headerParts.join("  ")}${colors.reset}`;
+  const dividerParts = [
+    "-".repeat(idWidth),
+    "-".repeat(projWidth),
+    "-".repeat(typeWidth)
+  ];
+  if (showPriority) dividerParts.push("-".repeat(prioWidth));
+  dividerParts.push("-".repeat(statusWidth), "-".repeat(40));
+  const divider = `${colors.dim}${dividerParts.join("  ")}${colors.reset}`;
+  const formattedRows = rows.map((r) => {
+    const statusColored = colorStatus(r.status);
+    const typeColored = colorType(r.type);
+    const projColored = `${colors.magenta}${r.project}${colors.reset}`;
+    const rowParts = [
+      `${colors.bold}${pad(r.id, idWidth)}${colors.reset}`,
+      pad(projColored, projWidth + (isColorSupported ? colors.magenta.length + colors.reset.length : 0)),
+      pad(typeColored, typeWidth + (isColorSupported ? 9 : 0))
+    ];
+    if (showPriority) {
+      const prioColored = r.priority === "-" ? `${colors.dim}-${colors.reset}` : colorPriority(r.priority);
+      rowParts.push(pad(prioColored, prioWidth + (isColorSupported && r.priority !== "-" ? 9 : isColorSupported ? colors.dim.length + colors.reset.length : 0)));
+    }
+    rowParts.push(
+      pad(statusColored, statusWidth + (isColorSupported ? 9 : 0)),
+      r.title
+    );
+    return rowParts.join("  ");
+  });
+  return [header, divider, ...formattedRows].join("\n");
+}
+function formatTicketDetail(ticket) {
+  const { meta, detail, comments, planMarkdown, projectDescriptor } = ticket;
+  const lines = [];
+  lines.push(`${colors.bold}${colors.cyan}Ticket #${meta.project ? `${meta.project}-${meta.id}` : meta.id}: ${normalizeDashesAndMojibake(meta.title)}${colors.reset}`);
+  lines.push(`${colors.dim}${"=".repeat(60)}${colors.reset}`);
+  lines.push(`${colors.bold}Project:${colors.reset}     ${projectDescriptor ? `${projectDescriptor.code} - ${projectDescriptor.name}` : "Default"}`);
+  lines.push(`${colors.bold}Type:${colors.reset}        ${colorType(meta.type || meta.category || "Feature")}`);
+  if (meta.priority) {
+    lines.push(`${colors.bold}Priority:${colors.reset}    ${colorPriority(meta.priority)}`);
+  }
+  lines.push(`${colors.bold}Status:${colors.reset}      ${colorStatus(meta.status)}`);
+  lines.push(`${colors.bold}Complexity:${colors.reset}  ${normalizeDashesAndMojibake(meta.complexity || "Medium")}`);
+  lines.push(`${colors.bold}Effort:${colors.reset}      ${normalizeDashesAndMojibake(meta.estimatedEffort || "N/A")}`);
+  lines.push(`${colors.bold}Submitted By:${colors.reset} ${meta.submittedBy || "Unknown"}`);
+  if (meta.milestone) {
+    lines.push(`${colors.bold}Milestone:${colors.reset}   ${colors.magenta}${meta.milestone}${colors.reset}`);
+  }
+  if (meta.featureFlag) {
+    const isInherited = meta.inheritedFeatureFlag && meta.inheritedFeatureFlag === meta.featureFlag;
+    lines.push(`${colors.bold}Feature Flag:${colors.reset} ${colors.yellow}${meta.featureFlag}${colors.reset}${isInherited ? ` ${colors.dim}(inherited from Milestone)${colors.reset}` : ""}`);
+  }
+  if (ticket.isBlocked) {
+    lines.push(`${colors.bold}Dependency:${colors.reset}   ${colors.red}${colors.bold}Blocked by uncompleted ticket${colors.reset}`);
+  }
+  if (detail?.summary) {
+    lines.push("");
+    lines.push(`${colors.bold}Summary:${colors.reset}`);
+    lines.push(normalizeDashesAndMojibake(detail.summary));
+  }
+  if (detail?.breakdown && detail.breakdown.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Feature Breakdown:${colors.reset}`);
+    for (const b of detail.breakdown) {
+      lines.push(`  \u2022 ${normalizeDashesAndMojibake(b)}`);
+    }
+  }
+  if (detail?.technicalDetails && detail.technicalDetails.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Technical Details:${colors.reset}`);
+    for (const t of detail.technicalDetails) {
+      lines.push(`  \u2022 ${normalizeDashesAndMojibake(t)}`);
+    }
+  }
+  if (detail?.openQuestions && detail.openQuestions.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Open Decisions & Questions:${colors.reset}`);
+    for (const q of detail.openQuestions) {
+      lines.push(`  \u2022 ${normalizeDashesAndMojibake(q)}`);
+    }
+  }
+  if (ticket.links && ticket.links.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Linked Tickets (${ticket.links.length}):${colors.reset}`);
+    for (const l of ticket.links) {
+      const relFormatted = l.relation === "blocks" ? `${colors.red}Blocks${colors.reset}` : l.relation === "blocked-by" ? `${colors.red}Blocked by${colors.reset}` : l.relation === "parent-of" ? `${colors.magenta}Parent of${colors.reset}` : l.relation === "child-of" ? `${colors.magenta}Child of${colors.reset}` : l.relation === "duplicates" ? `${colors.yellow}Duplicates${colors.reset}` : l.relation === "duplicated-by" ? `${colors.yellow}Duplicated by${colors.reset}` : `${colors.cyan}Relates to${colors.reset}`;
+      const blockedTag = l.isBlockedByUncompleted ? ` ${colors.red}[BLOCKED]${colors.reset}` : "";
+      const titleSnippet = l.targetTitle ? ` : ${normalizeDashesAndMojibake(l.targetTitle)}` : "";
+      const statusSnippet = l.targetStatus ? ` [${l.targetStatus}]` : "";
+      lines.push(`  \u2022 ${relFormatted} ${colors.bold}${l.targetKey}${colors.reset}${statusSnippet}${titleSnippet}${blockedTag}`);
+    }
+  }
+  if (planMarkdown) {
+    lines.push("");
+    lines.push(`${colors.bold}Implementation Plan:${colors.reset}`);
+    lines.push(normalizeDashesAndMojibake(planMarkdown.trim()));
+  }
+  if (comments && comments.length > 0) {
+    lines.push("");
+    lines.push(`${colors.bold}Comments (${comments.length}):${colors.reset}`);
+    for (const c of comments) {
+      lines.push(`  ${colors.dim}[${c.timestamp.slice(0, 10)}]${colors.reset} ${colors.bold}${normalizeDashesAndMojibake(c.author)}:${colors.reset} ${normalizeDashesAndMojibake(c.text)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function pad(str, width) {
+  return str.padEnd(width, " ");
+}
+function colorStatus(status) {
+  switch (status) {
+    case "Completed":
+      return `${colors.green}${status}${colors.reset}`;
+    case "In Development":
+      return `${colors.green}${status}${colors.reset}`;
+    case "Rejected":
+      return `${colors.red}${status}${colors.reset}`;
+    default:
+      return `${colors.cyan}${status}${colors.reset}`;
+  }
+}
+function colorType(type) {
+  switch (type) {
+    case "Feature":
+      return `${colors.blue}${type}${colors.reset}`;
+    case "Platform":
+      return `${colors.magenta}${type}${colors.reset}`;
+    case "Tools":
+      return `${colors.yellow}${type}${colors.reset}`;
+    case "Bug":
+      return `${colors.red}${type}${colors.reset}`;
+    case "Idea":
+      return `${colors.green}${type}${colors.reset}`;
+    default:
+      return type;
+  }
+}
+function colorPriority(priority) {
+  if (!priority) return "";
+  switch (priority.toLowerCase()) {
+    case "critical":
+      return `${colors.red}${colors.bold}Critical${colors.reset}`;
+    case "high":
+      return `${colors.yellow}${colors.bold}High${colors.reset}`;
+    case "medium":
+      return `${colors.blue}Medium${colors.reset}`;
+    case "low":
+      return `${colors.dim}Low${colors.reset}`;
+    default:
+      return priority;
+  }
+}
+function formatMilestoneListTable(milestones, tickets) {
+  if (milestones.length === 0) {
+    return `${colors.dim}No milestones found.${colors.reset}`;
+  }
+  const rows = milestones.map((m) => {
+    const id = String(m.id);
+    const project = m.project;
+    const title = m.title;
+    const status = m.status;
+    const flag = m.featureFlag || "-";
+    let progress = "-";
+    if (tickets) {
+      const mTickets = tickets.filter(
+        (t) => t.meta.milestone && (t.meta.milestone.toLowerCase() === String(m.id).toLowerCase() || t.meta.milestone.toLowerCase() === m.title.toLowerCase())
+      );
+      const completed = mTickets.filter((t) => t.meta.status === "Completed").length;
+      progress = `${completed}/${mTickets.length}`;
+    }
+    return { id, project, status, flag, progress, title };
+  });
+  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
+  const projWidth = Math.max(7, ...rows.map((r) => r.project.length));
+  const statusWidth = Math.max(10, ...rows.map((r) => r.status.length));
+  const flagWidth = Math.max(14, ...rows.map((r) => r.flag.length));
+  const progWidth = Math.max(8, ...rows.map((r) => r.progress.length));
+  const header = `${colors.bold}${pad("ID", idWidth)}  ${pad("Project", projWidth)}  ${pad("Status", statusWidth)}  ${pad("Umbrella Flag", flagWidth)}  ${pad("Progress", progWidth)}  Title${colors.reset}`;
+  const divider = `${colors.dim}${"-".repeat(idWidth)}  ${"-".repeat(projWidth)}  ${"-".repeat(statusWidth)}  ${"-".repeat(flagWidth)}  ${"-".repeat(progWidth)}  ${"-".repeat(30)}${colors.reset}`;
+  const formattedRows = rows.map((r) => {
+    return `${colors.bold}${pad(r.id, idWidth)}${colors.reset}  ${pad(r.project, projWidth)}  ${pad(r.status, statusWidth)}  ${pad(r.flag, flagWidth)}  ${pad(r.progress, progWidth)}  ${r.title}`;
+  });
+  return [header, divider, ...formattedRows].join("\n");
+}
+
 // src/storage/filesystem.ts
 function isProjectMatch(code, filter) {
   if (!code || !filter) return false;
@@ -592,6 +921,20 @@ var FilesystemStorageAdapter = class {
     }
   }
   refreshConfig() {
+    if (this.isConfigExplicit) {
+      try {
+        const discovered = findEsedreConfig(this.workspaceRoot);
+        if (discovered.config && Object.keys(discovered.config).length > 0) {
+          this.config = {
+            ...this.config,
+            ...discovered.config
+          };
+        }
+      } catch {
+      }
+      this.lastConfigCheck = Date.now();
+      return;
+    }
     try {
       const discovered = findEsedreConfig(this.workspaceRoot);
       this.config = discovered.config || {};
@@ -1104,86 +1447,647 @@ ${formattedList}`
     }
     return projectDesc;
   }
-  findTicketLocation(id) {
+  async updateProject(input) {
+    const cleanCode = input.code.trim();
+    const cleanLower = cleanCode.toLowerCase();
+    if (input.name !== void 0) {
+      const nameVal = validateProjectName(input.name);
+      if (!nameVal.valid) {
+        throw new Error(nameVal.error);
+      }
+    }
     const locations = this.resolveProjectLocations();
-    if (locations.length === 0) return null;
-    const strId = String(id).trim();
-    const prefixMatch = strId.match(/^([a-zA-Z0-9]{1,8})[-_:](\d+)$/i);
-    if (prefixMatch) {
-      const code = prefixMatch[1].toLowerCase();
-      const num2 = parseInt(prefixMatch[2], 10);
-      const loc = locations.find((l) => isProjectMatch(l.project.code, code));
-      if (!loc) return null;
-      const ticketDir = path3.join(loc.ticketsDir, String(num2));
-      const metaPath = path3.join(ticketDir, "meta.json");
-      if (fs3.existsSync(metaPath)) {
-        if (loc.isSharedDir) {
+    const loc = locations.find((l) => l.project.code.toLowerCase() === cleanLower);
+    if (!loc) {
+      throw new Error(`Project "${cleanCode}" not found`);
+    }
+    const updatedDesc = {
+      ...loc.project,
+      ...input.name !== void 0 ? { name: input.name.trim() } : {},
+      ...input.description !== void 0 ? { description: input.description.trim() } : {},
+      ...input.colors !== void 0 ? { colors: input.colors } : {},
+      ...input.techStack !== void 0 ? { techStack: input.techStack } : {},
+      ...input.groundingRules !== void 0 ? { groundingRules: input.groundingRules } : {},
+      ...input.guidelinesRef !== void 0 ? { guidelinesRef: input.guidelinesRef } : {}
+    };
+    if (loc.sourceType === "hub" && loc.hubDir) {
+      const projectDir = path3.dirname(loc.ticketsDir);
+      const pJsonPath = path3.join(projectDir, "project.json");
+      let existingPJson = {};
+      if (fs3.existsSync(pJsonPath)) {
+        try {
+          existingPJson = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+        } catch {
+        }
+      }
+      const mergedPJson = { ...existingPJson, ...updatedDesc };
+      writeSafeFile(pJsonPath, JSON.stringify(mergedPJson, null, 2) + "\n");
+      const hubProjectsFile = path3.join(loc.hubDir, "projects.json");
+      const subHubProjectsFile = path3.join(loc.hubDir, "projects", "projects.json");
+      for (const f of [hubProjectsFile, subHubProjectsFile]) {
+        if (fs3.existsSync(f)) {
           try {
-            const metaRaw = fs3.readFileSync(metaPath, "utf-8");
-            const meta = JSON.parse(metaRaw);
-            meta.type = meta.type || meta.category || "Feature";
-            meta.category = meta.type;
-            const mProj = (meta.project || "").toLowerCase();
-            if (mProj && mProj !== code && mProj !== loc.project.code.toLowerCase()) {
-              return null;
+            const arr = JSON.parse(fs3.readFileSync(f, "utf-8"));
+            const idx = arr.findIndex((p) => p.code.toLowerCase() === cleanLower);
+            if (idx >= 0) {
+              arr[idx] = { ...arr[idx], ...updatedDesc };
+              writeSafeFile(f, JSON.stringify(arr, null, 2) + "\n");
             }
           } catch {
           }
         }
-        return { loc, ticketDir, id: num2 };
       }
-      return null;
-    }
-    const num = typeof id === "number" ? id : parseInt(strId, 10);
-    if (isNaN(num)) return null;
-    const matches = [];
-    const checkedDirs = /* @__PURE__ */ new Set();
-    for (const loc of locations) {
-      const ticketDir = path3.join(loc.ticketsDir, String(num));
-      const metaPath = path3.join(ticketDir, "meta.json");
-      if (!fs3.existsSync(metaPath)) continue;
-      if (loc.isSharedDir) {
-        if (checkedDirs.has(ticketDir)) continue;
-        checkedDirs.add(ticketDir);
-        try {
-          const metaRaw = fs3.readFileSync(metaPath, "utf-8");
-          const meta = JSON.parse(metaRaw);
-          const matchedLoc = locations.find(
-            (l) => meta.projectId !== void 0 && l.project.id === meta.projectId || meta.project && l.project.code.toLowerCase() === meta.project.toLowerCase()
-          ) || loc;
-          matches.push({ loc: matchedLoc, ticketDir, id: num });
-        } catch {
-          matches.push({ loc, ticketDir, id: num });
+    } else {
+      const projectDir = loc.sourceType === "federated" ? path3.dirname(loc.ticketsDir) : path3.join(this.workspaceRoot, ".esedre");
+      const candidates = [
+        path3.join(projectDir, "project.json"),
+        path3.join(this.workspaceRoot, ".esedre", "project.json"),
+        path3.join(this.workspaceRoot, "project.json")
+      ];
+      for (const pJsonPath of candidates) {
+        if (fs3.existsSync(pJsonPath)) {
+          try {
+            const existing = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+            const merged = { ...existing, ...updatedDesc };
+            writeSafeFile(pJsonPath, JSON.stringify(merged, null, 2) + "\n");
+          } catch {
+          }
+        }
+      }
+      const pJsonListCandidates = [
+        path3.join(projectDir, "projects.json"),
+        path3.join(this.workspaceRoot, ".esedre", "projects.json"),
+        path3.join(this.workspaceRoot, "projects.json")
+      ];
+      for (const projectsJsonPath of pJsonListCandidates) {
+        if (fs3.existsSync(projectsJsonPath)) {
+          try {
+            const arr = JSON.parse(fs3.readFileSync(projectsJsonPath, "utf-8"));
+            const idx = arr.findIndex((p) => p.code.toLowerCase() === cleanLower);
+            if (idx >= 0) {
+              arr[idx] = { ...arr[idx], ...updatedDesc };
+              writeSafeFile(projectsJsonPath, JSON.stringify(arr, null, 2) + "\n");
+            }
+          } catch {
+          }
         }
-      } else {
-        matches.push({ loc, ticketDir, id: num });
       }
     }
-    if (this.config.projectCode) {
-      const prefLower = this.config.projectCode.toLowerCase();
-      const preferredMatch = matches.find(
-        (m) => m.loc.project.code.toLowerCase() === prefLower
-      );
-      if (preferredMatch) return preferredMatch;
-    }
-    if (matches.length === 1) {
-      return matches[0];
-    }
-    if (matches.length > 1) {
-      const codes = matches.map((m) => m.loc.project.code);
-      throw new Error(
-        `Ambiguous ticket #${num}: exists in multiple projects (${codes.join(", ")}). Please specify as <ProjectCode>-${num} (e.g. ${codes[0]}-${num}).`
-      );
+    this.refreshConfig();
+    return updatedDesc;
+  }
+  async renameProjectCode(input) {
+    const cleanOld = input.oldCode.trim();
+    const cleanNew = input.newCode.trim();
+    const oldLower = cleanOld.toLowerCase();
+    const newLower = cleanNew.toLowerCase();
+    const codeVal = validateProjectCode(cleanNew);
+    if (!codeVal.valid) {
+      throw new Error(codeVal.error);
+    }
+    if (input.newName !== void 0) {
+      const nameVal = validateProjectName(input.newName);
+      if (!nameVal.valid) {
+        throw new Error(nameVal.error);
+      }
     }
-    return null;
-  }
-  async listTickets(filter) {
     const locations = this.resolveProjectLocations();
-    const tickets = [];
-    const processedSharedTickets = /* @__PURE__ */ new Set();
-    for (const loc of locations) {
-      if (filter?.project && filter.project !== "all") {
-        const pLower = filter.project.toLowerCase();
+    const loc = locations.find((l) => l.project.code.toLowerCase() === oldLower);
+    if (!loc) {
+      throw new Error(`Project "${cleanOld}" not found`);
+    }
+    if (oldLower !== newLower) {
+      const collision = locations.find((l) => l.project.code.toLowerCase() === newLower);
+      if (collision) {
+        throw new Error(`Project code "${cleanNew}" collides with existing project "${collision.project.code}".`);
+      }
+    }
+    let migratedTicketsCount = 0;
+    const updatedHubs = [];
+    const updatedConfigs = [];
+    const updatedDesc = {
+      ...loc.project,
+      code: cleanNew,
+      ...input.newName ? { name: input.newName.trim() } : {}
+    };
+    if (loc.sourceType === "hub" && loc.hubDir) {
+      const hubDir = loc.hubDir;
+      const oldProjectDir = path3.dirname(loc.ticketsDir);
+      const hubProjectsDir = path3.dirname(oldProjectDir);
+      const newProjectDir = path3.join(hubProjectsDir, cleanNew);
+      if (oldProjectDir.toLowerCase() === newProjectDir.toLowerCase()) {
+        if (path3.basename(oldProjectDir) !== cleanNew) {
+          const tempHop = `${oldProjectDir}__rename_hop_${Date.now()}`;
+          fs3.renameSync(oldProjectDir, tempHop);
+          fs3.renameSync(tempHop, newProjectDir);
+        }
+      } else {
+        if (fs3.existsSync(newProjectDir)) {
+          throw new Error(`Target directory "${newProjectDir}" already exists.`);
+        }
+        fs3.renameSync(oldProjectDir, newProjectDir);
+      }
+      const pJsonPath = path3.join(newProjectDir, "project.json");
+      let existingPJson = {};
+      if (fs3.existsSync(pJsonPath)) {
+        try {
+          existingPJson = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+        } catch {
+        }
+      }
+      const mergedPJson = { ...existingPJson, ...updatedDesc, code: cleanNew };
+      writeSafeFile(pJsonPath, JSON.stringify(mergedPJson, null, 2) + "\n");
+      const hubProjectsFile = path3.join(hubDir, "projects.json");
+      const subHubProjectsFile = path3.join(hubDir, "projects", "projects.json");
+      for (const f of [hubProjectsFile, subHubProjectsFile]) {
+        if (fs3.existsSync(f)) {
+          try {
+            const arr = JSON.parse(fs3.readFileSync(f, "utf-8"));
+            const idx = arr.findIndex((p) => p.code.toLowerCase() === oldLower);
+            if (idx >= 0) {
+              arr[idx] = { ...arr[idx], ...updatedDesc, code: cleanNew };
+              writeSafeFile(f, JSON.stringify(arr, null, 2) + "\n");
+              if (!updatedHubs.includes(f)) updatedHubs.push(f);
+            }
+          } catch {
+          }
+        }
+      }
+      const newTicketsDir = path3.join(newProjectDir, "tickets");
+      if (fs3.existsSync(newTicketsDir)) {
+        try {
+          const entries = fs3.readdirSync(newTicketsDir, { withFileTypes: true });
+          for (const ent of entries) {
+            if (!ent.isDirectory()) continue;
+            const tMetaPath = path3.join(newTicketsDir, ent.name, "meta.json");
+            if (fs3.existsSync(tMetaPath)) {
+              try {
+                const meta = JSON.parse(fs3.readFileSync(tMetaPath, "utf-8"));
+                meta.project = cleanNew;
+                if (Array.isArray(meta.links)) {
+                  for (const l of meta.links) {
+                    if (l.targetProject && l.targetProject.toLowerCase() === oldLower) {
+                      l.targetProject = cleanNew;
+                      l.targetKey = `${cleanNew}-${l.targetId}`;
+                    }
+                  }
+                }
+                writeSafeFile(tMetaPath, JSON.stringify(meta, null, 2) + "\n");
+                migratedTicketsCount++;
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      for (const otherLoc of locations) {
+        if (otherLoc.project.code.toLowerCase() === oldLower) continue;
+        if (fs3.existsSync(otherLoc.ticketsDir)) {
+          try {
+            const entries = fs3.readdirSync(otherLoc.ticketsDir, { withFileTypes: true });
+            for (const ent of entries) {
+              if (!ent.isDirectory()) continue;
+              const tMetaPath = path3.join(otherLoc.ticketsDir, ent.name, "meta.json");
+              if (fs3.existsSync(tMetaPath)) {
+                try {
+                  const meta = JSON.parse(fs3.readFileSync(tMetaPath, "utf-8"));
+                  if (Array.isArray(meta.links)) {
+                    let changed = false;
+                    for (const l of meta.links) {
+                      if (l.targetProject && l.targetProject.toLowerCase() === oldLower) {
+                        l.targetProject = cleanNew;
+                        l.targetKey = `${cleanNew}-${l.targetId}`;
+                        changed = true;
+                      }
+                    }
+                    if (changed) {
+                      writeSafeFile(tMetaPath, JSON.stringify(meta, null, 2) + "\n");
+                    }
+                  }
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      const newMilestonesPath = path3.join(newProjectDir, "milestones.json");
+      if (fs3.existsSync(newMilestonesPath)) {
+        try {
+          const arr = JSON.parse(fs3.readFileSync(newMilestonesPath, "utf-8"));
+          for (const m of arr) {
+            m.project = cleanNew;
+          }
+          writeSafeFile(newMilestonesPath, JSON.stringify(arr, null, 2) + "\n");
+        } catch {
+        }
+      }
+    } else {
+      const esedreDir = path3.join(this.workspaceRoot, ".esedre");
+      const pJsonPath = path3.join(esedreDir, "project.json");
+      if (fs3.existsSync(pJsonPath)) {
+        try {
+          const existing = JSON.parse(fs3.readFileSync(pJsonPath, "utf-8"));
+          writeSafeFile(pJsonPath, JSON.stringify({ ...existing, ...updatedDesc, code: cleanNew }, null, 2) + "\n");
+        } catch {
+        }
+      }
+      const projectsJsonPath = path3.join(esedreDir, "projects.json");
+      if (fs3.existsSync(projectsJsonPath)) {
+        try {
+          const arr = JSON.parse(fs3.readFileSync(projectsJsonPath, "utf-8"));
+          const idx = arr.findIndex((p) => p.code.toLowerCase() === oldLower);
+          if (idx >= 0) {
+            arr[idx] = { ...arr[idx], ...updatedDesc, code: cleanNew };
+            writeSafeFile(projectsJsonPath, JSON.stringify(arr, null, 2) + "\n");
+          }
+        } catch {
+        }
+      }
+      if (fs3.existsSync(loc.ticketsDir)) {
+        try {
+          const entries = fs3.readdirSync(loc.ticketsDir, { withFileTypes: true });
+          for (const ent of entries) {
+            if (!ent.isDirectory()) continue;
+            const tMetaPath = path3.join(loc.ticketsDir, ent.name, "meta.json");
+            if (fs3.existsSync(tMetaPath)) {
+              try {
+                const meta = JSON.parse(fs3.readFileSync(tMetaPath, "utf-8"));
+                meta.project = cleanNew;
+                if (Array.isArray(meta.links)) {
+                  for (const l of meta.links) {
+                    if (l.targetProject && l.targetProject.toLowerCase() === oldLower) {
+                      l.targetProject = cleanNew;
+                      l.targetKey = `${cleanNew}-${l.targetId}`;
+                    }
+                  }
+                }
+                writeSafeFile(tMetaPath, JSON.stringify(meta, null, 2) + "\n");
+                migratedTicketsCount++;
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      const milestonesJsonPath = path3.join(esedreDir, "milestones.json");
+      if (fs3.existsSync(milestonesJsonPath)) {
+        try {
+          const arr = JSON.parse(fs3.readFileSync(milestonesJsonPath, "utf-8"));
+          for (const m of arr) {
+            if (m.project.toLowerCase() === oldLower) {
+              m.project = cleanNew;
+            }
+          }
+          writeSafeFile(milestonesJsonPath, JSON.stringify(arr, null, 2) + "\n");
+        } catch {
+        }
+      }
+    }
+    const workspaceConfigFile = path3.join(this.workspaceRoot, ".esedre", "esedre.json");
+    if (fs3.existsSync(workspaceConfigFile)) {
+      try {
+        const wsCfg = JSON.parse(fs3.readFileSync(workspaceConfigFile, "utf-8"));
+        let modified = false;
+        if (wsCfg.projectCode && wsCfg.projectCode.toLowerCase() === oldLower) {
+          wsCfg.projectCode = cleanNew;
+          if (input.newName) wsCfg.projectName = input.newName.trim();
+          modified = true;
+        }
+        if (Array.isArray(wsCfg.allowedProjects)) {
+          const idx = wsCfg.allowedProjects.findIndex((p) => p.toLowerCase() === oldLower);
+          if (idx >= 0) {
+            wsCfg.allowedProjects[idx] = cleanNew;
+            modified = true;
+          }
+        }
+        if (modified) {
+          writeSafeFile(workspaceConfigFile, JSON.stringify(wsCfg, null, 2) + "\n");
+          updatedConfigs.push(workspaceConfigFile);
+        }
+      } catch {
+      }
+    }
+    const globalConfigFile = path3.join(os2.homedir(), ".esedre", "config.json");
+    if (fs3.existsSync(globalConfigFile)) {
+      try {
+        const gCfg = JSON.parse(fs3.readFileSync(globalConfigFile, "utf-8"));
+        let modified = false;
+        if (gCfg.projects && typeof gCfg.projects === "object") {
+          for (const [key, val] of Object.entries(gCfg.projects)) {
+            if (key.toLowerCase() === oldLower) {
+              delete gCfg.projects[key];
+              gCfg.projects[cleanNew] = val;
+              modified = true;
+              break;
+            }
+          }
+        }
+        if (modified) {
+          writeSafeFile(globalConfigFile, JSON.stringify(gCfg, null, 2) + "\n");
+          updatedConfigs.push(globalConfigFile);
+        }
+      } catch {
+      }
+    }
+    if (this.config.projectCode && this.config.projectCode.toLowerCase() === oldLower) {
+      this.config.projectCode = cleanNew;
+      if (input.newName) this.config.projectName = input.newName.trim();
+    }
+    if (Array.isArray(this.config.allowedProjects)) {
+      const idx = this.config.allowedProjects.findIndex((p) => p.toLowerCase() === oldLower);
+      if (idx >= 0) {
+        this.config.allowedProjects[idx] = cleanNew;
+      }
+    }
+    this.refreshConfig();
+    return {
+      success: true,
+      oldCode: cleanOld,
+      newCode: cleanNew,
+      project: updatedDesc,
+      migratedTicketsCount,
+      updatedHubs,
+      updatedConfigs
+    };
+  }
+  getMilestonesPath(loc) {
+    const parent = path3.dirname(loc.ticketsDir);
+    return path3.join(parent, "milestones.json");
+  }
+  readProjectMilestones(loc) {
+    const mPath = this.getMilestonesPath(loc);
+    if (!fs3.existsSync(mPath)) return [];
+    try {
+      const raw = fs3.readFileSync(mPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  writeProjectMilestones(loc, milestones) {
+    const mPath = this.getMilestonesPath(loc);
+    writeSafeFile(mPath, JSON.stringify(milestones, null, 2) + "\n");
+  }
+  resolveMilestone(milestoneRef, localLoc) {
+    const cleanRef = normalizeDashesAndMojibake(milestoneRef).trim();
+    if (!cleanRef) return null;
+    const locations = this.resolveProjectLocations();
+    const colonIdx = cleanRef.indexOf(":");
+    if (colonIdx > 0) {
+      const projPrefix = cleanRef.substring(0, colonIdx).trim();
+      const targetRef = cleanRef.substring(colonIdx + 1).trim();
+      const targetLoc = locations.find((l) => isProjectMatch(l.project.code, projPrefix));
+      if (targetLoc) {
+        const pMilestones = this.readProjectMilestones(targetLoc);
+        const match = pMilestones.find(
+          (m) => String(m.id).toLowerCase() === targetRef.toLowerCase() || m.title.toLowerCase() === targetRef.toLowerCase()
+        );
+        if (match) return { ...match, project: targetLoc.project.code };
+      }
+    }
+    if (localLoc) {
+      const localMilestones = this.readProjectMilestones(localLoc);
+      const match = localMilestones.find(
+        (m) => String(m.id).toLowerCase() === cleanRef.toLowerCase() || m.title.toLowerCase() === cleanRef.toLowerCase()
+      );
+      if (match) return { ...match, project: localLoc.project.code };
+    }
+    for (const loc of locations) {
+      if (localLoc && isProjectMatch(loc.project.code, localLoc.project.code)) continue;
+      const list = this.readProjectMilestones(loc);
+      const match = list.find(
+        (m) => String(m.id).toLowerCase() === cleanRef.toLowerCase() || m.title.toLowerCase() === cleanRef.toLowerCase()
+      );
+      if (match) return { ...match, project: loc.project.code };
+    }
+    return null;
+  }
+  async listMilestones(projectCode) {
+    const locations = this.resolveProjectLocations();
+    const milestones = [];
+    for (const loc of locations) {
+      if (projectCode && projectCode !== "all") {
+        if (!isProjectMatch(loc.project.code, projectCode)) continue;
+      }
+      const list = this.readProjectMilestones(loc);
+      for (const m of list) {
+        milestones.push({
+          ...m,
+          project: loc.project.code
+        });
+      }
+    }
+    return milestones.sort((a, b) => {
+      if (a.project !== b.project) return a.project.localeCompare(b.project);
+      return (Number(a.id) || 0) - (Number(b.id) || 0);
+    });
+  }
+  async getMilestone(id, projectCode) {
+    const target = String(id).trim();
+    const colonIdx = target.indexOf(":");
+    let effectiveProject = projectCode;
+    let effectiveId = target;
+    if (colonIdx > 0 && (!projectCode || projectCode === "all")) {
+      effectiveProject = target.substring(0, colonIdx).trim();
+      effectiveId = target.substring(colonIdx + 1).trim();
+    }
+    const all = await this.listMilestones(effectiveProject);
+    const targetLower = effectiveId.toLowerCase();
+    const found = all.find(
+      (m) => String(m.id).toLowerCase() === targetLower || m.title.toLowerCase() === targetLower
+    );
+    return found || null;
+  }
+  async createMilestone(input) {
+    const locations = this.resolveProjectLocations();
+    const projectCode = input.projectCode || this.config.projectCode;
+    let targetLoc;
+    if (projectCode) {
+      targetLoc = locations.find((l) => isProjectMatch(l.project.code, projectCode));
+    } else if (locations.length === 1) {
+      targetLoc = locations[0];
+    }
+    if (!targetLoc) {
+      throw new Error("Project is required to create a milestone.");
+    }
+    const existing = this.readProjectMilestones(targetLoc);
+    const existingIds = existing.map((m) => typeof m.id === "number" ? m.id : parseInt(String(m.id), 10)).filter((n) => !isNaN(n));
+    const nextId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 1;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const title = normalizeDashesAndMojibake(input.title).trim();
+    if (!title) {
+      throw new Error("Milestone title is required.");
+    }
+    const milestone = {
+      id: nextId,
+      project: targetLoc.project.code,
+      title,
+      description: input.description ? normalizeDashesAndMojibake(input.description).trim() : void 0,
+      status: input.status || "Planned",
+      featureFlag: input.featureFlag ? normalizeDashesAndMojibake(input.featureFlag).trim() : void 0,
+      targetDate: input.targetDate ? normalizeDashesAndMojibake(input.targetDate).trim() : void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    existing.push(milestone);
+    this.writeProjectMilestones(targetLoc, existing);
+    return milestone;
+  }
+  async updateMilestone(id, input, projectCode) {
+    const locations = this.resolveProjectLocations();
+    const targetId = String(id).trim().toLowerCase();
+    let foundLoc;
+    let foundIndex = -1;
+    for (const loc of locations) {
+      if (projectCode && projectCode !== "all" && !isProjectMatch(loc.project.code, projectCode)) continue;
+      const list2 = this.readProjectMilestones(loc);
+      const idx = list2.findIndex(
+        (m2) => String(m2.id).toLowerCase() === targetId || m2.title.toLowerCase() === targetId
+      );
+      if (idx >= 0) {
+        foundLoc = loc;
+        foundIndex = idx;
+        break;
+      }
+    }
+    if (!foundLoc || foundIndex < 0) {
+      throw new Error(`Milestone '${id}' not found.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const list = this.readProjectMilestones(foundLoc);
+    const m = list[foundIndex];
+    if (input.title !== void 0) m.title = normalizeDashesAndMojibake(input.title).trim();
+    if (input.description !== void 0) {
+      m.description = input.description ? normalizeDashesAndMojibake(input.description).trim() : void 0;
+    }
+    if (input.status !== void 0) {
+      m.status = input.status;
+      if (input.status === "Completed" && !m.completedAt) {
+        m.completedAt = now;
+      } else if (input.status !== "Completed") {
+        delete m.completedAt;
+      }
+    }
+    if (input.featureFlag !== void 0) {
+      if (input.featureFlag === null || input.featureFlag === "" || input.featureFlag.toLowerCase() === "none") {
+        delete m.featureFlag;
+      } else {
+        m.featureFlag = normalizeDashesAndMojibake(input.featureFlag).trim();
+      }
+    }
+    if (input.targetDate !== void 0) {
+      if (input.targetDate === null || input.targetDate === "" || input.targetDate.toLowerCase() === "none") {
+        delete m.targetDate;
+      } else {
+        m.targetDate = normalizeDashesAndMojibake(input.targetDate).trim();
+      }
+    }
+    m.updatedAt = now;
+    m.project = foundLoc.project.code;
+    this.writeProjectMilestones(foundLoc, list);
+    return m;
+  }
+  async deleteMilestone(id, projectCode) {
+    const locations = this.resolveProjectLocations();
+    const targetId = String(id).trim().toLowerCase();
+    for (const loc of locations) {
+      if (projectCode && projectCode !== "all" && !isProjectMatch(loc.project.code, projectCode)) continue;
+      const list = this.readProjectMilestones(loc);
+      const filtered = list.filter(
+        (m) => String(m.id).toLowerCase() !== targetId && m.title.toLowerCase() !== targetId
+      );
+      if (filtered.length !== list.length) {
+        this.writeProjectMilestones(loc, filtered);
+        return true;
+      }
+    }
+    return false;
+  }
+  findTicketLocation(id) {
+    const locations = this.resolveProjectLocations();
+    if (locations.length === 0) return null;
+    const strId = String(id).trim();
+    const prefixMatch = strId.match(/^([a-zA-Z0-9]{1,8})[-_:](\d+)$/i);
+    if (prefixMatch) {
+      const code = prefixMatch[1].toLowerCase();
+      const num2 = parseInt(prefixMatch[2], 10);
+      const loc = locations.find((l) => isProjectMatch(l.project.code, code));
+      if (!loc) return null;
+      const ticketDir = path3.join(loc.ticketsDir, String(num2));
+      const metaPath = path3.join(ticketDir, "meta.json");
+      if (fs3.existsSync(metaPath)) {
+        if (loc.isSharedDir) {
+          try {
+            const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+            const meta = JSON.parse(metaRaw);
+            meta.type = meta.type || meta.category || "Feature";
+            meta.category = meta.type;
+            const mProj = (meta.project || "").toLowerCase();
+            if (mProj && mProj !== code && mProj !== loc.project.code.toLowerCase()) {
+              return null;
+            }
+          } catch {
+          }
+        }
+        return { loc, ticketDir, id: num2 };
+      }
+      return null;
+    }
+    const num = typeof id === "number" ? id : parseInt(strId, 10);
+    if (isNaN(num)) return null;
+    const matches = [];
+    const checkedDirs = /* @__PURE__ */ new Set();
+    for (const loc of locations) {
+      const ticketDir = path3.join(loc.ticketsDir, String(num));
+      const metaPath = path3.join(ticketDir, "meta.json");
+      if (!fs3.existsSync(metaPath)) continue;
+      if (loc.isSharedDir) {
+        if (checkedDirs.has(ticketDir)) continue;
+        checkedDirs.add(ticketDir);
+        try {
+          const metaRaw = fs3.readFileSync(metaPath, "utf-8");
+          const meta = JSON.parse(metaRaw);
+          const matchedLoc = locations.find(
+            (l) => meta.projectId !== void 0 && l.project.id === meta.projectId || meta.project && l.project.code.toLowerCase() === meta.project.toLowerCase()
+          ) || loc;
+          matches.push({ loc: matchedLoc, ticketDir, id: num });
+        } catch {
+          matches.push({ loc, ticketDir, id: num });
+        }
+      } else {
+        matches.push({ loc, ticketDir, id: num });
+      }
+    }
+    if (this.config.projectCode) {
+      const prefLower = this.config.projectCode.toLowerCase();
+      const preferredMatch = matches.find(
+        (m) => m.loc.project.code.toLowerCase() === prefLower
+      );
+      if (preferredMatch) return preferredMatch;
+    }
+    if (matches.length === 1) {
+      return matches[0];
+    }
+    if (matches.length > 1) {
+      const codes = matches.map((m) => m.loc.project.code);
+      throw new Error(
+        `Ambiguous ticket #${num}: exists in multiple projects (${codes.join(", ")}). Please specify as <ProjectCode>-${num} (e.g. ${codes[0]}-${num}).`
+      );
+    }
+    return null;
+  }
+  async listTickets(filter) {
+    const locations = this.resolveProjectLocations();
+    const tickets = [];
+    const processedSharedTickets = /* @__PURE__ */ new Set();
+    for (const loc of locations) {
+      if (filter?.project && filter.project !== "all") {
+        const pLower = filter.project.toLowerCase();
         if (!isProjectMatch(loc.project.code, filter.project)) {
           continue;
         }
@@ -1213,6 +2117,9 @@ ${formattedList}`
           meta.id = meta.id ?? num;
           meta.type = meta.type || meta.category || "Feature";
           meta.category = meta.type;
+          if (meta.priority) {
+            meta.priority = normalizePriority(meta.priority);
+          }
           let effectiveLoc = loc;
           if (loc.isSharedDir) {
             const found = locations.find(
@@ -1222,18 +2129,61 @@ ${formattedList}`
           }
           meta.project = effectiveLoc.project.code;
           meta.projectId = effectiveLoc.project.id;
+          let mMatch = null;
+          if (meta.milestone) {
+            meta.milestone = normalizeDashesAndMojibake(meta.milestone);
+            mMatch = this.resolveMilestone(meta.milestone, effectiveLoc);
+            if (mMatch?.featureFlag) {
+              meta.inheritedFeatureFlag = mMatch.featureFlag;
+              if (!meta.featureFlag) {
+                meta.featureFlag = mMatch.featureFlag;
+              }
+            }
+          }
           if (filter?.project && filter.project !== "all") {
             const pLower = filter.project.toLowerCase();
             if (!isProjectMatch(meta.project, filter.project)) {
               continue;
             }
           }
+          if (filter?.milestone) {
+            const mFilter = filter.milestone.trim().toLowerCase();
+            const resolvedFilterMilestone = this.resolveMilestone(filter.milestone, effectiveLoc);
+            const matchesDirect = Boolean(meta.milestone && meta.milestone.toLowerCase() === mFilter);
+            const matchesResolvedTitle = Boolean(
+              resolvedFilterMilestone && meta.milestone && meta.milestone.toLowerCase() === resolvedFilterMilestone.title.toLowerCase()
+            );
+            const matchesResolvedId = Boolean(
+              resolvedFilterMilestone && meta.milestone && String(resolvedFilterMilestone.id).toLowerCase() === meta.milestone.toLowerCase()
+            );
+            const matchesCompound = Boolean(
+              resolvedFilterMilestone && meta.milestone && `${resolvedFilterMilestone.project}:${resolvedFilterMilestone.title}`.toLowerCase() === meta.milestone.toLowerCase()
+            );
+            const matchesResolvedSelf = Boolean(
+              mMatch && (mMatch.title.toLowerCase() === mFilter || String(mMatch.id).toLowerCase() === mFilter || `${mMatch.project}:${mMatch.title}`.toLowerCase() === mFilter || `${mMatch.project}:${mMatch.id}`.toLowerCase() === mFilter)
+            );
+            if (!matchesDirect && !matchesResolvedTitle && !matchesResolvedId && !matchesCompound && !matchesResolvedSelf) {
+              continue;
+            }
+          }
           if (filter?.status && meta.status !== filter.status) {
             continue;
           }
           if (filter?.category && meta.category !== filter.category) {
             continue;
           }
+          if (filter?.priority !== void 0) {
+            const fPrio = String(filter.priority).trim().toLowerCase();
+            if (fPrio === "none" || fPrio === "null") {
+              if (meta.priority) {
+                continue;
+              }
+            } else {
+              if (!meta.priority || meta.priority.toLowerCase() !== fPrio) {
+                continue;
+              }
+            }
+          }
           if (filter?.search) {
             const term = filter.search.toLowerCase();
             const matchesTitle = meta.title.toLowerCase().includes(term);
@@ -1268,8 +2218,24 @@ ${formattedList}`
             comments,
             projectDescriptor: effectiveLoc.project
           };
+          normalizeTicketFields(ticketObj);
+          this.enrichTicketLinks(ticketObj);
           ticketObj.sha1 = computeTicketHash(ticketObj);
           ticketObj.lastHash = ticketObj.sha1;
+          if (filter?.isBlocked !== void 0 && Boolean(ticketObj.isBlocked) !== Boolean(filter.isBlocked)) {
+            continue;
+          }
+          if (filter?.linkedTo) {
+            const target = filter.linkedTo.trim().toLowerCase();
+            const hasLink = ticketObj.meta.links?.some((l) => {
+              const tk = l.targetKey.toLowerCase();
+              const idStr = String(l.targetId);
+              return tk === target || idStr === target;
+            });
+            if (!hasLink) {
+              continue;
+            }
+          }
           tickets.push(ticketObj);
         } catch {
         }
@@ -1293,6 +2259,19 @@ ${formattedList}`
       meta.id = meta.id ?? locInfo.id;
       meta.project = locInfo.loc.project.code;
       meta.projectId = locInfo.loc.project.id;
+      if (meta.priority) {
+        meta.priority = normalizePriority(meta.priority);
+      }
+      if (meta.milestone) {
+        meta.milestone = normalizeDashesAndMojibake(meta.milestone);
+        const mMatch = this.resolveMilestone(meta.milestone, locInfo.loc);
+        if (mMatch?.featureFlag) {
+          meta.inheritedFeatureFlag = mMatch.featureFlag;
+          if (!meta.featureFlag) {
+            meta.featureFlag = mMatch.featureFlag;
+          }
+        }
+      }
       let detail;
       const detailPath = path3.join(locInfo.ticketDir, "detail.md");
       if (fs3.existsSync(detailPath)) {
@@ -1319,6 +2298,8 @@ ${formattedList}`
         comments,
         projectDescriptor: locInfo.loc.project
       };
+      normalizeTicketFields(ticket);
+      this.enrichTicketLinks(ticket);
       ticket.sha1 = computeTicketHash(ticket);
       ticket.lastHash = ticket.sha1;
       return ticket;
@@ -1368,10 +2349,13 @@ ${formattedList}`
         if (itemMatch) openQuestions.push(itemMatch[1].trim());
       }
     }
+    const priorityMatch = raw.match(/\*\*Priority\*\*:\s*([^\n]+)/i);
+    const priority = priorityMatch ? normalizePriority(priorityMatch[1].trim()) : void 0;
     return {
       title,
       type,
       category,
+      priority,
       complexity,
       estimatedEffort,
       summary,
@@ -1411,13 +2395,40 @@ ${formattedList}`
     fs3.mkdirSync(ticketDir, { recursive: true });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const effectiveType = input.type || input.category || "Feature";
+    const cleanTitle = normalizeDashesAndMojibake(input.title).slice(0, 48).trim();
+    const cleanEffort = normalizeDashesAndMojibake(input.estimatedEffort || input.effort || "2.0 - 4.0 hours");
+    const cleanComplexity = normalizeDashesAndMojibake(input.complexity || "Medium");
+    const cleanPriority = normalizePriority(input.priority);
+    let cleanMilestone = input.milestone ? normalizeDashesAndMojibake(String(input.milestone)).trim() : void 0;
+    let inheritedFlag;
+    let initialFlag;
+    if (cleanMilestone) {
+      const pMilestones = this.readProjectMilestones(targetLoc);
+      const mMatch = pMilestones.find(
+        (m) => String(m.id).toLowerCase() === cleanMilestone?.toLowerCase() || m.title.toLowerCase() === cleanMilestone?.toLowerCase()
+      );
+      if (mMatch?.featureFlag) {
+        inheritedFlag = mMatch.featureFlag;
+        initialFlag = mMatch.featureFlag;
+      }
+    }
+    let cleanFeatureFlag = input.featureFlag ? normalizeDashesAndMojibake(input.featureFlag).trim() : void 0;
+    if (!cleanFeatureFlag && initialFlag) {
+      cleanFeatureFlag = initialFlag;
+    }
+    const cleanSummary = input.summary ? normalizeDashesAndMojibake(input.summary) : void 0;
+    const cleanDetailRaw = input.detailMarkdown || input.detail ? normalizeDashesAndMojibake(input.detailMarkdown || input.detail) : void 0;
     const meta = {
       id: nextId,
-      title: input.title.slice(0, 48).trim(),
+      title: cleanTitle,
       type: effectiveType,
       category: effectiveType,
-      complexity: input.complexity || "Medium",
-      estimatedEffort: input.estimatedEffort || input.effort || "2.0 - 4.0 hours",
+      ...cleanPriority ? { priority: cleanPriority } : {},
+      ...cleanMilestone ? { milestone: cleanMilestone } : {},
+      ...cleanFeatureFlag ? { featureFlag: cleanFeatureFlag } : {},
+      ...inheritedFlag ? { inheritedFeatureFlag: inheritedFlag } : {},
+      complexity: cleanComplexity,
+      estimatedEffort: cleanEffort,
       submittedBy: input.submittedBy || "Developer",
       timestamp: now,
       createdAt: now,
@@ -1428,7 +2439,11 @@ ${formattedList}`
       projectId: targetLoc.project.id,
       project: targetLoc.project.code
     };
-    const rawDetail = (input.detailMarkdown || input.detail)?.trim();
+    const rawDetail = cleanDetailRaw?.trim();
+    const priorityLine = meta.priority ? `**Priority**: ${meta.priority}  
+` : "";
+    const milestoneLine = meta.milestone ? `**Milestone**: ${meta.milestone}  
+` : "";
     let detailMd;
     if (rawDetail) {
       if (/^#\s+[^\n]+/m.test(rawDetail)) {
@@ -1436,7 +2451,7 @@ ${formattedList}`
         if (!/\*\*(?:Type|Category)\*\*:/i.test(processed)) {
           const metaBlock = `
 **Category**: ${meta.category}  
-**Complexity**: ${meta.complexity}  
+${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
 **Estimated Effort**: ${meta.estimatedEffort}  
 `;
           processed = processed.replace(/^(# Ticket[^\n]+\n)/m, `$1${metaBlock}`);
@@ -1476,7 +2491,7 @@ ${rawDetail}
         }
         detailMd = `# Ticket #${nextId}: ${meta.title}
 **Category**: ${meta.category}  
-**Complexity**: ${meta.complexity}  
+${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
 **Estimated Effort**: ${meta.estimatedEffort}  
 
 ${body.trim()}
@@ -1485,7 +2500,7 @@ ${body.trim()}
     } else {
       detailMd = `# Ticket #${nextId}: ${meta.title}
 **Category**: ${meta.category}  
-**Complexity**: ${meta.complexity}  
+${priorityLine}${milestoneLine}**Complexity**: ${meta.complexity}  
 **Estimated Effort**: ${meta.estimatedEffort}  
 
 ### Summary
@@ -1527,22 +2542,61 @@ ${input.summary || "Summary to be defined."}
     const isNowCompleted = updates.status === "Completed";
     const completedAt = isNowCompleted ? existing.meta.completedAt || now : updates.status && updates.status !== "Completed" ? void 0 : existing.meta.completedAt;
     const revision = (existing.meta.revision || 1) + 1;
+    const sanitizedUpdates = { ...updates };
+    if (sanitizedUpdates.title) sanitizedUpdates.title = normalizeDashesAndMojibake(sanitizedUpdates.title);
+    if (sanitizedUpdates.estimatedEffort) sanitizedUpdates.estimatedEffort = normalizeDashesAndMojibake(sanitizedUpdates.estimatedEffort);
+    if (sanitizedUpdates.complexity) sanitizedUpdates.complexity = normalizeDashesAndMojibake(sanitizedUpdates.complexity);
     const updatedMeta = {
       ...existing.meta,
-      ...updates,
+      ...sanitizedUpdates,
       id: locInfo.id,
       project: locInfo.loc.project.code,
       updatedAt: now,
       completedAt,
       revision
     };
+    if ("priority" in updates || updates.priority !== void 0) {
+      const rawPrio = updates.priority;
+      if (rawPrio === null || rawPrio === "none" || rawPrio === "null" || rawPrio === "") {
+        delete updatedMeta.priority;
+      } else {
+        const norm = normalizePriority(rawPrio);
+        if (norm) {
+          updatedMeta.priority = norm;
+        } else {
+          delete updatedMeta.priority;
+        }
+      }
+    }
+    if ("milestone" in updates || updates.milestone !== void 0) {
+      const rawMilestone = updates.milestone;
+      if (rawMilestone === null || rawMilestone === "none" || rawMilestone === "null" || rawMilestone === "") {
+        delete updatedMeta.milestone;
+        if (updatedMeta.inheritedFeatureFlag && updatedMeta.featureFlag === updatedMeta.inheritedFeatureFlag) {
+          delete updatedMeta.featureFlag;
+        }
+        delete updatedMeta.inheritedFeatureFlag;
+      } else {
+        updatedMeta.milestone = normalizeDashesAndMojibake(String(rawMilestone)).trim();
+        const pMilestones = this.readProjectMilestones(locInfo.loc);
+        const mMatch = pMilestones.find(
+          (m) => String(m.id).toLowerCase() === updatedMeta.milestone?.toLowerCase() || m.title.toLowerCase() === updatedMeta.milestone?.toLowerCase()
+        );
+        if (mMatch?.featureFlag) {
+          updatedMeta.inheritedFeatureFlag = mMatch.featureFlag;
+          if (!updatedMeta.featureFlag) {
+            updatedMeta.featureFlag = mMatch.featureFlag;
+          }
+        }
+      }
+    }
     writeSafeFile(metaPath, JSON.stringify(updatedMeta, null, 2) + "\n");
     const newType = updates.type || updates.category;
     if (newType) {
       updatedMeta.type = newType;
       updatedMeta.category = newType;
     }
-    if (existing.detail && (updates.title || updates.type || updates.category || updates.complexity || updates.estimatedEffort)) {
+    if (existing.detail && ("priority" in updates || "milestone" in updates || updates.title || updates.type || updates.category || updates.complexity || updates.estimatedEffort)) {
       let content = existing.detail.raw;
       if (updates.title) {
         content = content.replace(/^#\s*(?:Ticket\s*#?\d+\s*:\s*|\d+\s*:\s*)?[^\n]+/im, `# Ticket #${locInfo.id}: ${updatedMeta.title}`);
@@ -1550,77 +2604,321 @@ ${input.summary || "Summary to be defined."}
       if (updates.type || updates.category) {
         content = content.replace(/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i, `**Type**: ${updatedMeta.type}`);
       }
+      if ("priority" in updates) {
+        if (updatedMeta.priority) {
+          if (/\*\*Priority\*\*:\s*[^\n]+/i.test(content)) {
+            content = content.replace(/\*\*Priority\*\*:\s*[^\n]+/i, `**Priority**: ${updatedMeta.priority}`);
+          } else if (/\*\*(?:Type|Category)\*\*:\s*[^\n]+/i.test(content)) {
+            content = content.replace(/(\*\*(?:Type|Category)\*\*:\s*[^\n]+)/i, `$1  
+**Priority**: ${updatedMeta.priority}`);
+          }
+        } else {
+          content = content.replace(/\*\*Priority\*\*:\s*[^\n]+\n?/i, "");
+        }
+      }
+      if ("milestone" in updates) {
+        if (updatedMeta.milestone) {
+          if (/\*\*Milestone\*\*:\s*[^\n]+/i.test(content)) {
+            content = content.replace(/\*\*Milestone\*\*:\s*[^\n]+/i, `**Milestone**: ${updatedMeta.milestone}`);
+          } else if (/\*\*(?:Priority|Type|Category)\*\*:\s*[^\n]+/i.test(content)) {
+            content = content.replace(/(\*\*(?:Priority|Type|Category)\*\*:\s*[^\n]+)/i, `$1  
+**Milestone**: ${updatedMeta.milestone}`);
+          }
+        } else {
+          content = content.replace(/\*\*Milestone\*\*:\s*[^\n]+\n?/i, "");
+        }
+      }
       if (updates.complexity) {
         content = content.replace(/\*\*Complexity\*\*:\s*[^\n]+/i, `**Complexity**: ${updatedMeta.complexity}`);
       }
       if (updates.estimatedEffort) {
         content = content.replace(/\*\*Estimated Effort\*\*:\s*[^\n]+/i, `**Estimated Effort**: ${updatedMeta.estimatedEffort}`);
       }
-      writeSafeFile(path3.join(locInfo.ticketDir, "detail.md"), content);
+      writeSafeFile(path3.join(locInfo.ticketDir, "detail.md"), content);
+    }
+    return await this.getTicket(`${locInfo.loc.project.code}-${locInfo.id}`);
+  }
+  async getPlan(id) {
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) return null;
+    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+    if (!fs3.existsSync(planPath)) return null;
+    return normalizeDashesAndMojibake(fs3.readFileSync(planPath, "utf-8"));
+  }
+  async savePlan(id, planMarkdown, lastHash) {
+    const ticket = await this.getTicket(id);
+    if (!ticket) {
+      throw new Error(`Ticket #${id} does not exist`);
+    }
+    if (lastHash !== void 0) {
+      const currentHash = ticket.sha1 || computeTicketHash(ticket);
+      if (!verifyTicketHash(currentHash, lastHash)) {
+        throw new EsedreConflictError(id, currentHash, lastHash);
+      }
+    }
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
+    writeSafeFile(planPath, normalizeDashesAndMojibake(planMarkdown));
+    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
+    if (fs3.existsSync(metaPath)) {
+      try {
+        const meta = JSON.parse(fs3.readFileSync(metaPath, "utf-8"));
+        meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        meta.revision = (meta.revision || 1) + 1;
+        writeSafeFile(metaPath, JSON.stringify(meta, null, 2) + "\n");
+      } catch {
+      }
+    }
+  }
+  async addComment(id, comment) {
+    const ticket = await this.getTicket(id);
+    if (!ticket) {
+      throw new Error(`Ticket #${id} does not exist`);
+    }
+    const locInfo = this.findTicketLocation(id);
+    if (!locInfo) {
+      throw new Error(`Ticket #${id} could not be located on disk`);
+    }
+    const commentsPath = path3.join(locInfo.ticketDir, "comments.json");
+    let comments = [];
+    if (fs3.existsSync(commentsPath)) {
+      try {
+        comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+      } catch {
+      }
+    }
+    const newComment = {
+      id: `${locInfo.id}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      author: normalizeDashesAndMojibake(comment.author || "User"),
+      text: normalizeDashesAndMojibake(comment.text.trim())
+    };
+    comments.push(newComment);
+    writeSafeFile(commentsPath, JSON.stringify(comments, null, 2) + "\n");
+    return newComment;
+  }
+  resolveTicketIdentifier(id, defaultProject) {
+    const str = String(id).trim();
+    if (!/^([a-zA-Z0-9]{1,8})[-_:](\d+)$/i.test(str) && defaultProject && defaultProject !== "all") {
+      const candidate = this.findTicketLocation(`${defaultProject}-${str}`);
+      if (candidate) {
+        return {
+          ...candidate,
+          key: `${candidate.loc.project.code}-${candidate.id}`,
+          project: candidate.loc.project.code
+        };
+      }
+    }
+    const loc = this.findTicketLocation(id);
+    if (!loc) return null;
+    return {
+      ...loc,
+      key: `${loc.loc.project.code}-${loc.id}`,
+      project: loc.loc.project.code
+    };
+  }
+  wouldCreateCycle(sourceKey, targetKey, relation) {
+    if (relation !== "blocks" && relation !== "parent-of") {
+      return false;
+    }
+    const sLower = sourceKey.toLowerCase();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [targetKey.toLowerCase()];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === sLower) {
+        return true;
+      }
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const loc = this.findTicketLocation(current);
+      if (!loc) continue;
+      const metaPath = path3.join(loc.ticketDir, "meta.json");
+      if (!fs3.existsSync(metaPath)) continue;
+      try {
+        const meta = JSON.parse(fs3.readFileSync(metaPath, "utf-8"));
+        if (Array.isArray(meta.links)) {
+          for (const l of meta.links) {
+            if (l.relation === relation) {
+              queue.push(l.targetKey.toLowerCase());
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  enrichTicketLinks(ticket) {
+    if (!ticket.meta.links || ticket.meta.links.length === 0) {
+      ticket.links = [];
+      ticket.isBlocked = false;
+      return;
+    }
+    const enriched = [];
+    let isBlocked = false;
+    for (const link of ticket.meta.links) {
+      const enrichedLink = { ...link, isResolved: false };
+      const targetLoc = this.findTicketLocation(link.targetKey);
+      if (targetLoc) {
+        const targetMetaPath = path3.join(targetLoc.ticketDir, "meta.json");
+        if (fs3.existsSync(targetMetaPath)) {
+          try {
+            const targetMeta = JSON.parse(fs3.readFileSync(targetMetaPath, "utf-8"));
+            enrichedLink.targetTitle = targetMeta.title;
+            enrichedLink.targetType = targetMeta.type || targetMeta.category || "Feature";
+            enrichedLink.targetStatus = targetMeta.status || "Planned";
+            enrichedLink.isTargetCompleted = targetMeta.status === "Completed";
+            if (targetMeta.priority) {
+              enrichedLink.targetPriority = normalizePriority(targetMeta.priority);
+            }
+            enrichedLink.isResolved = true;
+            if (link.relation === "blocked-by" && targetMeta.status !== "Completed") {
+              enrichedLink.isBlockedByUncompleted = true;
+              isBlocked = true;
+            }
+          } catch {
+          }
+        }
+      }
+      enriched.push(enrichedLink);
     }
-    return await this.getTicket(`${locInfo.loc.project.code}-${locInfo.id}`);
-  }
-  async getPlan(id) {
-    const locInfo = this.findTicketLocation(id);
-    if (!locInfo) return null;
-    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
-    if (!fs3.existsSync(planPath)) return null;
-    return fs3.readFileSync(planPath, "utf-8");
+    ticket.links = enriched;
+    ticket.isBlocked = isBlocked;
   }
-  async savePlan(id, planMarkdown, lastHash) {
-    const ticket = await this.getTicket(id);
-    if (!ticket) {
-      throw new Error(`Ticket #${id} does not exist`);
+  async addTicketLink(sourceId, relation, targetId, options) {
+    if (!INVERSE_RELATIONS[relation]) {
+      throw new Error(
+        `Invalid link relation: "${relation}". Valid relations: ${Object.keys(INVERSE_RELATIONS).join(", ")}`
+      );
     }
-    if (lastHash !== void 0) {
-      const currentHash = ticket.sha1 || computeTicketHash(ticket);
-      if (!verifyTicketHash(currentHash, lastHash)) {
-        throw new EsedreConflictError(id, currentHash, lastHash);
-      }
+    const sourceInfo = this.resolveTicketIdentifier(sourceId, options?.project);
+    if (!sourceInfo) {
+      throw new Error(`Source ticket #${sourceId} could not be located.`);
     }
-    const locInfo = this.findTicketLocation(id);
-    if (!locInfo) {
-      throw new Error(`Ticket #${id} could not be located on disk`);
+    const targetInfo = this.resolveTicketIdentifier(targetId, options?.project || sourceInfo.project);
+    if (!targetInfo) {
+      throw new Error(`Target ticket #${targetId} could not be located.`);
     }
-    const planPath = path3.join(locInfo.ticketDir, "implementation_plan.md");
-    writeSafeFile(planPath, planMarkdown);
-    const metaPath = path3.join(locInfo.ticketDir, "meta.json");
-    if (fs3.existsSync(metaPath)) {
+    if (sourceInfo.key.toLowerCase() === targetInfo.key.toLowerCase()) {
+      throw new Error(`Cannot link ticket ${sourceInfo.key} to itself.`);
+    }
+    if (this.wouldCreateCycle(sourceInfo.key, targetInfo.key, relation)) {
+      throw new Error(
+        `Circular dependency detected: linking ${sourceInfo.key} -> ${targetInfo.key} with "${relation}" forms a cycle.`
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sourceMetaPath = path3.join(sourceInfo.ticketDir, "meta.json");
+    const sourceMeta = JSON.parse(fs3.readFileSync(sourceMetaPath, "utf-8"));
+    sourceMeta.links = sourceMeta.links || [];
+    const existingSourceLink = sourceMeta.links.find(
+      (l) => l.targetKey.toLowerCase() === targetInfo.key.toLowerCase()
+    );
+    if (existingSourceLink) {
+      existingSourceLink.relation = relation;
+      existingSourceLink.targetProject = targetInfo.project;
+      existingSourceLink.targetId = targetInfo.id;
+    } else {
+      sourceMeta.links.push({
+        relation,
+        targetKey: targetInfo.key,
+        targetProject: targetInfo.project,
+        targetId: targetInfo.id,
+        createdAt: now,
+        createdBy: options?.author ? normalizeDashesAndMojibake(options.author) : void 0
+      });
+    }
+    sourceMeta.updatedAt = now;
+    sourceMeta.revision = (sourceMeta.revision || 1) + 1;
+    writeSafeFile(sourceMetaPath, JSON.stringify(sourceMeta, null, 2) + "\n");
+    let updatedTarget;
+    const targetMetaPath = path3.join(targetInfo.ticketDir, "meta.json");
+    if (fs3.existsSync(targetMetaPath)) {
       try {
-        const meta = JSON.parse(fs3.readFileSync(metaPath, "utf-8"));
-        meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        meta.revision = (meta.revision || 1) + 1;
-        writeSafeFile(metaPath, JSON.stringify(meta, null, 2) + "\n");
+        const targetMeta = JSON.parse(fs3.readFileSync(targetMetaPath, "utf-8"));
+        targetMeta.links = targetMeta.links || [];
+        const inverseRel = INVERSE_RELATIONS[relation];
+        const existingTargetLink = targetMeta.links.find(
+          (l) => l.targetKey.toLowerCase() === sourceInfo.key.toLowerCase()
+        );
+        if (existingTargetLink) {
+          existingTargetLink.relation = inverseRel;
+          existingTargetLink.targetProject = sourceInfo.project;
+          existingTargetLink.targetId = sourceInfo.id;
+        } else {
+          targetMeta.links.push({
+            relation: inverseRel,
+            targetKey: sourceInfo.key,
+            targetProject: sourceInfo.project,
+            targetId: sourceInfo.id,
+            createdAt: now,
+            createdBy: options?.author ? normalizeDashesAndMojibake(options.author) : void 0
+          });
+        }
+        targetMeta.updatedAt = now;
+        targetMeta.revision = (targetMeta.revision || 1) + 1;
+        writeSafeFile(targetMetaPath, JSON.stringify(targetMeta, null, 2) + "\n");
+        updatedTarget = await this.getTicket(targetInfo.key) || void 0;
       } catch {
       }
     }
+    const updatedSource = await this.getTicket(sourceInfo.key);
+    return { source: updatedSource, target: updatedTarget };
   }
-  async addComment(id, comment) {
-    const ticket = await this.getTicket(id);
-    if (!ticket) {
-      throw new Error(`Ticket #${id} does not exist`);
-    }
-    const locInfo = this.findTicketLocation(id);
-    if (!locInfo) {
-      throw new Error(`Ticket #${id} could not be located on disk`);
+  async removeTicketLink(sourceId, targetId, options) {
+    const sourceInfo = this.resolveTicketIdentifier(sourceId, options?.project);
+    if (!sourceInfo) {
+      throw new Error(`Source ticket #${sourceId} could not be located.`);
     }
-    const commentsPath = path3.join(locInfo.ticketDir, "comments.json");
-    let comments = [];
-    if (fs3.existsSync(commentsPath)) {
+    const targetInfo = this.resolveTicketIdentifier(targetId, options?.project || sourceInfo.project);
+    const targetKey = targetInfo ? targetInfo.key : String(targetId).trim();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sourceMetaPath = path3.join(sourceInfo.ticketDir, "meta.json");
+    if (fs3.existsSync(sourceMetaPath)) {
       try {
-        comments = JSON.parse(fs3.readFileSync(commentsPath, "utf-8"));
+        const sourceMeta = JSON.parse(fs3.readFileSync(sourceMetaPath, "utf-8"));
+        if (Array.isArray(sourceMeta.links)) {
+          const originalLen = sourceMeta.links.length;
+          sourceMeta.links = sourceMeta.links.filter(
+            (l) => !(l.targetKey.toLowerCase() === targetKey.toLowerCase() && (!options?.relation || l.relation === options.relation))
+          );
+          if (sourceMeta.links.length !== originalLen) {
+            sourceMeta.updatedAt = now;
+            sourceMeta.revision = (sourceMeta.revision || 1) + 1;
+            writeSafeFile(sourceMetaPath, JSON.stringify(sourceMeta, null, 2) + "\n");
+          }
+        }
       } catch {
       }
     }
-    const newComment = {
-      id: `${locInfo.id}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      author: comment.author || "User",
-      text: comment.text.trim()
-    };
-    comments.push(newComment);
-    writeSafeFile(commentsPath, JSON.stringify(comments, null, 2) + "\n");
-    return newComment;
+    let updatedTarget;
+    if (targetInfo) {
+      const targetMetaPath = path3.join(targetInfo.ticketDir, "meta.json");
+      if (fs3.existsSync(targetMetaPath)) {
+        try {
+          const targetMeta = JSON.parse(fs3.readFileSync(targetMetaPath, "utf-8"));
+          if (Array.isArray(targetMeta.links)) {
+            const originalLen = targetMeta.links.length;
+            targetMeta.links = targetMeta.links.filter(
+              (l) => !(l.targetKey.toLowerCase() === sourceInfo.key.toLowerCase() && (!options?.relation || l.relation === INVERSE_RELATIONS[options.relation]))
+            );
+            if (targetMeta.links.length !== originalLen) {
+              targetMeta.updatedAt = now;
+              targetMeta.revision = (targetMeta.revision || 1) + 1;
+              writeSafeFile(targetMetaPath, JSON.stringify(targetMeta, null, 2) + "\n");
+              updatedTarget = await this.getTicket(targetInfo.key) || void 0;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    const updatedSource = await this.getTicket(sourceInfo.key);
+    return { source: updatedSource, target: updatedTarget };
   }
 };
 
@@ -1652,19 +2950,56 @@ var SecurityFilter = class {
     }
     return proj;
   }
+  async updateProject(input) {
+    if (!isProjectAuthorized(input.code, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(input.code);
+    }
+    return this.target.updateProject(input);
+  }
+  async renameProjectCode(input) {
+    if (!isProjectAuthorized(input.oldCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(input.oldCode);
+    }
+    const result = await this.target.renameProjectCode(input);
+    if (this.config.allowedProjects && !this.config.allowedProjects.includes("*")) {
+      const oldUpper = input.oldCode.toUpperCase();
+      const idx = this.config.allowedProjects.findIndex((p) => p.toUpperCase() === oldUpper);
+      if (idx >= 0) {
+        this.config.allowedProjects[idx] = result.newCode;
+      }
+    }
+    return result;
+  }
+  redactLinks(ticket) {
+    if (!ticket.links || ticket.links.length === 0) return ticket;
+    if (!this.config.allowedProjects || this.config.allowedProjects.includes("*")) {
+      return ticket;
+    }
+    for (const link of ticket.links) {
+      if (link.targetProject && !isProjectAuthorized(link.targetProject, this.config.allowedProjects)) {
+        link.targetTitle = "[Restricted Project]";
+        delete link.targetType;
+        delete link.targetStatus;
+        delete link.targetPriority;
+        delete link.isBlockedByUncompleted;
+        link.isResolved = false;
+      }
+    }
+    return ticket;
+  }
   async listTickets(filter) {
     if (filter?.project && !isProjectAuthorized(filter.project, this.config.allowedProjects)) {
       throw new EsedreAuthorizationError(filter.project);
     }
     const tickets = await this.target.listTickets(filter);
     if (!this.config.allowedProjects || this.config.allowedProjects.length === 0) {
-      return tickets;
+      return tickets.map((t) => this.redactLinks(t));
     }
     return tickets.filter((t) => {
       const code = t.projectDescriptor?.code || t.meta.project;
       if (!code) return true;
       return isProjectAuthorized(code, this.config.allowedProjects);
-    });
+    }).map((t) => this.redactLinks(t));
   }
   async getTicket(id) {
     const ticket = await this.target.getTicket(id);
@@ -1673,7 +3008,7 @@ var SecurityFilter = class {
     if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
       throw new EsedreAuthorizationError(code);
     }
-    return ticket;
+    return this.redactLinks(ticket);
   }
   async createTicket(input) {
     const targetCode = input.projectCode || this.config.projectCode;
@@ -1725,132 +3060,88 @@ var SecurityFilter = class {
     }
     return this.target.addComment(id, comment);
   }
-};
-
-// src/utils/formatter.ts
-var isColorSupported = !process.env.NO_COLOR && (process.stdout.isTTY || process.env.FORCE_COLOR);
-var colors = {
-  reset: isColorSupported ? "\x1B[0m" : "",
-  bold: isColorSupported ? "\x1B[1m" : "",
-  dim: isColorSupported ? "\x1B[2m" : "",
-  cyan: isColorSupported ? "\x1B[36m" : "",
-  green: isColorSupported ? "\x1B[32m" : "",
-  yellow: isColorSupported ? "\x1B[33m" : "",
-  magenta: isColorSupported ? "\x1B[35m" : "",
-  red: isColorSupported ? "\x1B[31m" : "",
-  blue: isColorSupported ? "\x1B[34m" : ""
-};
-function formatTicketListTable(tickets) {
-  if (tickets.length === 0) {
-    return `${colors.dim}No tickets found matching criteria.${colors.reset}`;
-  }
-  const rows = tickets.map((t) => {
-    const id = t.projectDescriptor?.code ? `${t.projectDescriptor.code}-${t.meta.id}` : `#${t.meta.id}`;
-    const project = t.projectDescriptor?.code || "CORE";
-    const type = t.meta.type || t.meta.category || "Feature";
-    const status = t.meta.status;
-    const title = t.meta.title;
-    return { id, project, type, status, title };
-  });
-  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
-  const projWidth = Math.max(7, ...rows.map((r) => r.project.length));
-  const typeWidth = Math.max(8, ...rows.map((r) => r.type.length));
-  const statusWidth = Math.max(14, ...rows.map((r) => r.status.length));
-  const header = `${colors.bold}${pad("ID", idWidth)}  ${pad("Project", projWidth)}  ${pad("Type", typeWidth)}  ${pad("Status", statusWidth)}  Title${colors.reset}`;
-  const divider = `${colors.dim}${"-".repeat(idWidth)}  ${"-".repeat(projWidth)}  ${"-".repeat(typeWidth)}  ${"-".repeat(statusWidth)}  ${"-".repeat(40)}${colors.reset}`;
-  const formattedRows = rows.map((r) => {
-    const statusColored = colorStatus(r.status);
-    const typeColored = colorType(r.type);
-    const projColored = `${colors.magenta}${r.project}${colors.reset}`;
-    return `${colors.bold}${pad(r.id, idWidth)}${colors.reset}  ${pad(projColored, projWidth + (isColorSupported ? colors.magenta.length + colors.reset.length : 0))}  ${pad(typeColored, typeWidth + (isColorSupported ? 9 : 0))}  ${pad(statusColored, statusWidth + (isColorSupported ? 9 : 0))}  ${r.title}`;
-  });
-  return [header, divider, ...formattedRows].join("\n");
-}
-function formatTicketDetail(ticket) {
-  const { meta, detail, comments, planMarkdown, projectDescriptor } = ticket;
-  const lines = [];
-  lines.push(`${colors.bold}${colors.cyan}Ticket #${meta.project ? `${meta.project}-${meta.id}` : meta.id}: ${meta.title}${colors.reset}`);
-  lines.push(`${colors.dim}${"=".repeat(60)}${colors.reset}`);
-  lines.push(`${colors.bold}Project:${colors.reset}     ${projectDescriptor ? `${projectDescriptor.code} - ${projectDescriptor.name}` : "Default"}`);
-  lines.push(`${colors.bold}Type:${colors.reset}        ${colorType(meta.type || meta.category || "Feature")}`);
-  lines.push(`${colors.bold}Status:${colors.reset}      ${colorStatus(meta.status)}`);
-  lines.push(`${colors.bold}Complexity:${colors.reset}  ${meta.complexity || "Medium"}`);
-  lines.push(`${colors.bold}Effort:${colors.reset}      ${meta.estimatedEffort || "N/A"}`);
-  lines.push(`${colors.bold}Submitted By:${colors.reset} ${meta.submittedBy || "Unknown"}`);
-  if (meta.featureFlag) {
-    lines.push(`${colors.bold}Feature Flag:${colors.reset} ${colors.yellow}${meta.featureFlag}${colors.reset}`);
-  }
-  if (detail?.summary) {
-    lines.push("");
-    lines.push(`${colors.bold}Summary:${colors.reset}`);
-    lines.push(detail.summary);
-  }
-  if (detail?.breakdown && detail.breakdown.length > 0) {
-    lines.push("");
-    lines.push(`${colors.bold}Feature Breakdown:${colors.reset}`);
-    for (const b of detail.breakdown) {
-      lines.push(`  \u2022 ${b}`);
+  async listMilestones(projectCode) {
+    if (projectCode && projectCode !== "all" && !isProjectAuthorized(projectCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(projectCode);
+    }
+    const all = await this.target.listMilestones(projectCode);
+    if (!this.config.allowedProjects || this.config.allowedProjects.length === 0) {
+      return all;
     }
+    if (this.config.allowedProjects.includes("*")) {
+      return all;
+    }
+    return all.filter((m) => isProjectAuthorized(m.project, this.config.allowedProjects));
   }
-  if (detail?.technicalDetails && detail.technicalDetails.length > 0) {
-    lines.push("");
-    lines.push(`${colors.bold}Technical Details:${colors.reset}`);
-    for (const t of detail.technicalDetails) {
-      lines.push(`  \u2022 ${t}`);
+  async getMilestone(id, projectCode) {
+    if (projectCode && projectCode !== "all" && !isProjectAuthorized(projectCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(projectCode);
+    }
+    const milestone = await this.target.getMilestone(id, projectCode);
+    if (!milestone) return null;
+    if (milestone.project && !isProjectAuthorized(milestone.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(milestone.project);
     }
+    return milestone;
   }
-  if (detail?.openQuestions && detail.openQuestions.length > 0) {
-    lines.push("");
-    lines.push(`${colors.bold}Open Decisions & Questions:${colors.reset}`);
-    for (const q of detail.openQuestions) {
-      lines.push(`  \u2022 ${q}`);
+  async createMilestone(input) {
+    const targetCode = input.projectCode || this.config.projectCode;
+    if (targetCode && !isProjectAuthorized(targetCode, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(targetCode);
     }
+    return this.target.createMilestone(input);
   }
-  if (planMarkdown) {
-    lines.push("");
-    lines.push(`${colors.bold}Implementation Plan:${colors.reset}`);
-    lines.push(planMarkdown.trim());
+  async updateMilestone(id, input, projectCode) {
+    const existing = await this.target.getMilestone(id, projectCode);
+    if (existing) {
+      if (existing.project && !isProjectAuthorized(existing.project, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(existing.project);
+      }
+    }
+    return this.target.updateMilestone(id, input, projectCode);
   }
-  if (comments && comments.length > 0) {
-    lines.push("");
-    lines.push(`${colors.bold}Comments (${comments.length}):${colors.reset}`);
-    for (const c of comments) {
-      lines.push(`  ${colors.dim}[${c.timestamp.slice(0, 10)}]${colors.reset} ${colors.bold}${c.author}:${colors.reset} ${c.text}`);
+  async deleteMilestone(id, projectCode) {
+    const existing = await this.target.getMilestone(id, projectCode);
+    if (existing) {
+      if (existing.project && !isProjectAuthorized(existing.project, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(existing.project);
+      }
     }
+    return this.target.deleteMilestone(id, projectCode);
   }
-  return lines.join("\n");
-}
-function pad(str, width) {
-  return str.padEnd(width, " ");
-}
-function colorStatus(status) {
-  switch (status) {
-    case "Completed":
-      return `${colors.green}${status}${colors.reset}`;
-    case "In Development":
-      return `${colors.green}${status}${colors.reset}`;
-    case "Rejected":
-      return `${colors.red}${status}${colors.reset}`;
-    default:
-      return `${colors.cyan}${status}${colors.reset}`;
+  async addTicketLink(sourceId, relation, targetId, options) {
+    const sourceTicket = await this.target.getTicket(sourceId);
+    if (sourceTicket) {
+      const code = sourceTicket.projectDescriptor?.code || sourceTicket.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    } else if (options?.project && !isProjectAuthorized(options.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(options.project);
+    }
+    const result = await this.target.addTicketLink(sourceId, relation, targetId, options);
+    return {
+      source: this.redactLinks(result.source),
+      target: result.target ? this.redactLinks(result.target) : void 0
+    };
   }
-}
-function colorType(type) {
-  switch (type) {
-    case "Feature":
-      return `${colors.blue}${type}${colors.reset}`;
-    case "Platform":
-      return `${colors.magenta}${type}${colors.reset}`;
-    case "Tools":
-      return `${colors.yellow}${type}${colors.reset}`;
-    case "Bug":
-      return `${colors.red}${type}${colors.reset}`;
-    case "Idea":
-      return `${colors.green}${type}${colors.reset}`;
-    default:
-      return type;
+  async removeTicketLink(sourceId, targetId, options) {
+    const sourceTicket = await this.target.getTicket(sourceId);
+    if (sourceTicket) {
+      const code = sourceTicket.projectDescriptor?.code || sourceTicket.meta.project;
+      if (code && !isProjectAuthorized(code, this.config.allowedProjects)) {
+        throw new EsedreAuthorizationError(code);
+      }
+    } else if (options?.project && !isProjectAuthorized(options.project, this.config.allowedProjects)) {
+      throw new EsedreAuthorizationError(options.project);
+    }
+    const result = await this.target.removeTicketLink(sourceId, targetId, options);
+    return {
+      source: this.redactLinks(result.source),
+      target: result.target ? this.redactLinks(result.target) : void 0
+    };
   }
-}
+};
 
 // src/mcp/server.ts
 import readline from "node:readline";
@@ -1906,7 +3197,7 @@ var EsedreMcpServer = class {
             },
             serverInfo: {
               name: "esedre",
-              version: "0.1.0"
+              version: CURRENT_ESEDRE_VERSION
             }
           }
         };
@@ -2070,7 +3361,11 @@ Status: ${ticket.meta.status}`;
             status: { type: "string", enum: ["Planned", "In Development", "Completed", "Rejected"], description: "Ticket status" },
             type: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket type" },
             category: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket category (legacy alias for type)" },
-            search: { type: "string", description: "Search keywords in title or ID" }
+            priority: { type: "string", enum: ["Critical", "High", "Medium", "Low", "none"], description: "Ticket priority filter" },
+            milestone: { type: "string", description: "Filter tickets by milestone name or ID" },
+            search: { type: "string", description: "Search keywords in title or ID" },
+            isBlocked: { type: "boolean", description: "Filter tickets blocked by uncompleted tickets" },
+            linkedTo: { type: "string", description: "Filter tickets linked to a specific ticket ID or key" }
           }
         }
       },
@@ -2119,10 +3414,12 @@ Status: ${ticket.meta.status}`;
             project: { type: "string", description: "Target project code (e.g. CORE, WEB, DOCS)" },
             type: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket type" },
             category: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"], description: "Ticket category" },
+            priority: { type: "string", enum: ["Critical", "High", "Medium", "Low"], description: "Ticket priority" },
             complexity: { type: "string", description: "Complexity (e.g. Low, Medium, High)" },
             effort: { type: "string", description: "Estimated effort (e.g. 2.0 - 4.0 hours)" },
             summary: { type: "string", description: "Initial feature summary" },
             detail: { type: "string", description: "Initial specification, feature breakdown, or technical detail markdown" },
+            milestone: { type: "string", description: "Assign ticket to milestone" },
             author: { type: "string", description: "Submitting author name" }
           },
           required: ["title"]
@@ -2138,11 +3435,13 @@ Status: ${ticket.meta.status}`;
             status: { type: "string", enum: ["Planned", "In Development", "Completed", "Rejected"] },
             type: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"] },
             category: { type: "string", enum: ["Feature", "Platform", "Tools", "Idea", "Bug"] },
+            priority: { type: "string", enum: ["Critical", "High", "Medium", "Low", "none"], description: "Ticket priority (pass none or null to clear)" },
             title: { type: "string", description: "New title (max 48 characters)" },
             complexity: { type: "string", description: "Complexity (e.g. Low, Medium, High)" },
             effort: { type: "string", description: "Estimated effort (e.g. 2.0 - 4.0 hours)" },
             inDevelopment: { type: "boolean", description: "Active development toggle" },
             featureFlag: { type: "string", description: "Feature flag name" },
+            milestone: { type: "string", description: 'Update ticket milestone ("none" to clear)' },
             lastHash: { type: "string", description: "Optimistic concurrency control: last known sha1 hash of the ticket" }
           },
           required: ["ticketId"]
@@ -2158,7 +3457,94 @@ Status: ${ticket.meta.status}`;
             text: { type: "string", description: "Comment message" },
             author: { type: "string", description: "Author name (e.g. Antigravity, Developer)" }
           },
-          required: ["ticketId", "text"]
+          required: ["ticketId", "text"]
+        }
+      },
+      {
+        name: "esedre_list_milestones",
+        description: "List roadmap milestones with optional project filter.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Project code (e.g. Esedre, Alce)" }
+          }
+        }
+      },
+      {
+        name: "esedre_get_milestone",
+        description: "Retrieve milestone details by ID or title.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: ["integer", "string"], description: "Milestone ID or title" },
+            project: { type: "string", description: "Project code" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "esedre_create_milestone",
+        description: "Create a new milestone with optional umbrella feature flag.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Milestone title" },
+            project: { type: "string", description: "Target project code" },
+            description: { type: "string", description: "Milestone goal and description" },
+            featureFlag: { type: "string", description: "Optional umbrella feature flag inherited by member tickets" },
+            targetDate: { type: "string", description: "Optional target completion date" },
+            status: { type: "string", enum: ["Planned", "Active", "Completed", "Closed"], description: "Milestone status" }
+          },
+          required: ["title"]
+        }
+      },
+      {
+        name: "esedre_update_milestone",
+        description: "Update milestone state, umbrella feature flag, status, or target date.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: ["integer", "string"], description: "Milestone ID or title" },
+            project: { type: "string", description: "Project code" },
+            title: { type: "string", description: "New milestone title" },
+            description: { type: "string", description: "Milestone goal and description" },
+            featureFlag: { type: "string", description: 'Umbrella feature flag ("none" to clear)' },
+            targetDate: { type: "string", description: 'Target date ("none" to clear)' },
+            status: { type: "string", enum: ["Planned", "Active", "Completed", "Closed"], description: "Milestone status" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "esedre_link_ticket",
+        description: "Establish a bi-directional link between two tickets (within or across projects) with cycle detection.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceTicketId: { type: ["integer", "string"], description: "Source ticket ID or compound key" },
+            relation: {
+              type: "string",
+              enum: ["relates-to", "blocks", "blocked-by", "parent-of", "child-of", "duplicates", "duplicated-by"],
+              description: "Link relation type"
+            },
+            targetTicketId: { type: ["integer", "string"], description: "Target ticket ID or compound key" },
+            author: { type: "string", description: "Author creating the link" },
+            project: { type: "string", description: "Project code context for unqualified source ticket ID" }
+          },
+          required: ["sourceTicketId", "relation", "targetTicketId"]
+        }
+      },
+      {
+        name: "esedre_unlink_ticket",
+        description: "Remove a link between two tickets and its reciprocal link.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceTicketId: { type: ["integer", "string"], description: "Source ticket ID or compound key" },
+            targetTicketId: { type: ["integer", "string"], description: "Target ticket ID or compound key" },
+            project: { type: "string", description: "Project code context for unqualified source ticket ID" }
+          },
+          required: ["sourceTicketId", "targetTicketId"]
         }
       }
     ];
@@ -2173,7 +3559,11 @@ Status: ${ticket.meta.status}`;
           status: args.status,
           type,
           category: type,
-          search: args.search
+          priority: args.priority,
+          milestone: args.milestone,
+          search: args.search,
+          isBlocked: args.isBlocked !== void 0 ? Boolean(args.isBlocked) : void 0,
+          linkedTo: args.linkedTo
         });
         return tickets.map((t) => ({
           id: t.meta.id,
@@ -2181,10 +3571,16 @@ Status: ${ticket.meta.status}`;
           type: t.meta.type || t.meta.category,
           category: t.meta.type || t.meta.category,
           status: t.meta.status,
+          priority: t.meta.priority,
           complexity: t.meta.complexity,
           effort: t.meta.estimatedEffort,
+          milestone: t.meta.milestone,
+          featureFlag: t.meta.featureFlag,
+          inheritedFeatureFlag: t.meta.inheritedFeatureFlag,
           project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
-          sha1: t.sha1 || t.meta.sha1
+          sha1: t.sha1 || t.meta.sha1,
+          isBlocked: t.isBlocked,
+          links: t.links
         }));
       }
       case "get_ticket": {
@@ -2209,12 +3605,14 @@ Status: ${ticket.meta.status}`;
           title: args.title,
           type,
           category: type,
+          priority: args.priority,
           projectCode: args.project,
           complexity: args.complexity,
           estimatedEffort: args.effort,
           summary: args.summary,
           detail: args.detail || args.detailMarkdown,
           detailMarkdown: args.detailMarkdown || args.detail,
+          milestone: args.milestone,
           submittedBy: args.author || "Agent"
         });
         return created;
@@ -2228,11 +3626,13 @@ Status: ${ticket.meta.status}`;
           updates.category = type;
         }
         if (args.status) updates.status = args.status;
+        if (args.priority !== void 0) updates.priority = args.priority;
         if (args.title) updates.title = args.title;
         if (args.complexity) updates.complexity = args.complexity;
         if (args.effort) updates.estimatedEffort = args.effort;
         if (args.inDevelopment !== void 0) updates.isActivePlanning = Boolean(args.inDevelopment);
         if (args.featureFlag) updates.featureFlag = args.featureFlag;
+        if (args.milestone !== void 0) updates.milestone = args.milestone;
         const updated = await this.storage.updateTicket(id, updates, args.lastHash);
         return updated;
       }
@@ -2244,6 +3644,63 @@ Status: ${ticket.meta.status}`;
         });
         return comment;
       }
+      case "list_milestones": {
+        return this.storage.listMilestones(args.project);
+      }
+      case "get_milestone": {
+        const m = await this.storage.getMilestone(args.id, args.project);
+        if (!m) throw new Error(`Milestone '${args.id}' not found`);
+        const tickets = await this.storage.listTickets({ project: args.project || m.project, milestone: String(m.id) });
+        return {
+          ...m,
+          tickets
+        };
+      }
+      case "create_milestone": {
+        return this.storage.createMilestone({
+          title: args.title,
+          projectCode: args.project,
+          description: args.description,
+          featureFlag: args.featureFlag,
+          targetDate: args.targetDate,
+          status: args.status
+        });
+      }
+      case "update_milestone": {
+        return this.storage.updateMilestone(args.id, {
+          title: args.title,
+          description: args.description,
+          featureFlag: args.featureFlag,
+          targetDate: args.targetDate,
+          status: args.status
+        }, args.project);
+      }
+      case "link_ticket": {
+        const sourceId = this.parseTicketId(args.sourceTicketId);
+        const targetId = this.parseTicketId(args.targetTicketId);
+        const relation = String(args.relation).toLowerCase().replace(/_/g, "-");
+        const result = await this.storage.addTicketLink(sourceId, relation, targetId, {
+          author: args.author || "Agent",
+          project: args.project
+        });
+        return {
+          success: true,
+          source: result.source,
+          target: result.target
+        };
+      }
+      case "unlink_ticket": {
+        const sourceId = this.parseTicketId(args.sourceTicketId);
+        const targetId = this.parseTicketId(args.targetTicketId);
+        const result = await this.storage.removeTicketLink(sourceId, targetId, {
+          project: args.project
+        });
+        return {
+          success: true,
+          source: result.source,
+          target: result.target
+        };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -2443,7 +3900,7 @@ import path6 from "node:path";
 // src/server/daemon.ts
 import fs5 from "node:fs";
 import path5 from "node:path";
-import os2 from "node:os";
+import os3 from "node:os";
 import http from "node:http";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -2453,7 +3910,7 @@ function getGlobalEsedreDir() {
   if (process.env.ESEDRE_GLOBAL_DIR) {
     return process.env.ESEDRE_GLOBAL_DIR;
   }
-  return path5.join(os2.homedir(), ".esedre");
+  return path5.join(os3.homedir(), ".esedre");
 }
 function ensureGlobalEsedreStore() {
   const globalDir = getGlobalEsedreDir();
@@ -2721,6 +4178,27 @@ async function stopDaemon(options = {}) {
       }
       return false;
     }
+    try {
+      if (process.platform === "win32") {
+        const out = spawnSync("netstat", ["-ano", "-p", "tcp"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).stdout || "";
+        const lines = out.split("\n");
+        for (const line of lines) {
+          if (line.includes(`:${port}`) && line.includes("LISTENING")) {
+            const parts = line.trim().split(/\s+/);
+            const foundPid = parseInt(parts[parts.length - 1], 10);
+            if (!isNaN(foundPid) && foundPid > 0) {
+              pid = foundPid;
+              break;
+            }
+          }
+        }
+      } else {
+        const out = spawnSync("lsof", ["-ti", `tcp:${port}`], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).stdout || "";
+        const foundPid = parseInt(out.trim().split("\n")[0], 10);
+        if (!isNaN(foundPid) && foundPid > 0) pid = foundPid;
+      }
+    } catch {
+    }
   }
   if (pid && isProcessAlive(pid)) {
     try {
@@ -2828,49 +4306,49 @@ function classifyContent(currentContent, latestTemplate, historicHashes) {
 }
 var WRAPPER_CMD = `@echo off
 REM Esedre Autonomous Ticketing & Project Planning Engine Wrapper (Windows CMD)
-setlocal
+call :run %*
+exit /b %ERRORLEVEL%
+
+:run
+if exist "%~dp0..\\dist\\esedre.mjs" (
+  node "%~dp0..\\dist\\esedre.mjs" %*
+  goto :eof
+)
+if exist "%~dp0..\\..\\esedre\\dist\\esedre.mjs" (
+  node "%~dp0..\\..\\esedre\\dist\\esedre.mjs" %*
+  goto :eof
+)
+if exist "%~dp0..\\esedre\\dist\\esedre.mjs" (
+  node "%~dp0..\\esedre\\dist\\esedre.mjs" %*
+  goto :eof
+)
+if exist "%~dp0..\\node_modules\\esedre\\dist\\esedre.mjs" (
+  node "%~dp0..\\node_modules\\esedre\\dist\\esedre.mjs" %*
+  goto :eof
+)
+if exist "%~dp0..\\node_modules\\.bin\\ese.cmd" (
+  call "%~dp0..\\node_modules\\.bin\\ese.cmd" %*
+  goto :eof
+)
+if exist "%~dp0..\\node_modules\\.bin\\esedre.cmd" (
+  call "%~dp0..\\node_modules\\.bin\\esedre.cmd" %*
+  goto :eof
+)
 
 where ese >nul 2>nul
-if %ERRORLEVEL% equ 0 goto use_ese
+if %ERRORLEVEL% equ 0 (
+  call ese %*
+  goto :eof
+)
 
 where esedre >nul 2>nul
-if %ERRORLEVEL% equ 0 goto use_esedre
-
-if exist "%~dp0..\\..\\esedre\\dist\\esedre.mjs" goto use_sibling_dist
-if exist "%~dp0..\\esedre\\dist\\esedre.mjs" goto use_local_dist
-if exist "%~dp0..\\node_modules\\.bin\\ese.cmd" goto use_node_modules_ese
-if exist "%~dp0..\\node_modules\\.bin\\esedre.cmd" goto use_node_modules_esedre
+if %ERRORLEVEL% equ 0 (
+  call esedre %*
+  goto :eof
+)
 
 call npx --yes esedre %*
-goto done
-
-:use_ese
-call ese %*
-goto done
-
-:use_esedre
-call esedre %*
-goto done
-
-:use_sibling_dist
-node "%~dp0..\\..\\esedre\\dist\\esedre.mjs" %*
-goto done
-
-:use_local_dist
-node "%~dp0..\\esedre\\dist\\esedre.mjs" %*
-goto done
-
-:use_node_modules_ese
-call "%~dp0..\\node_modules\\.bin\\ese.cmd" %*
-goto done
-
-:use_node_modules_esedre
-call "%~dp0..\\node_modules\\.bin\\esedre.cmd" %*
-goto done
-
-:done
-endlocal
-exit /b %ERRORLEVEL%
+goto :eof
 `;
 var WRAPPER_PS1 = `# Esedre Autonomous Ticketing & Project Planning Engine Wrapper (PowerShell)
 $ErrorActionPreference = "Stop"
@@ -2884,12 +4362,9 @@ try {
 
 $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 
-if (Get-Command "ese" -ErrorAction SilentlyContinue) {
-    & ese @args
-    exit $LASTEXITCODE
-}
-if (Get-Command "esedre" -ErrorAction SilentlyContinue) {
-    & esedre @args
+$inRepoEsedre = Join-Path $scriptDir "..\\dist\\esedre.mjs"
+if (Test-Path $inRepoEsedre) {
+    & node $inRepoEsedre @args
     exit $LASTEXITCODE
 }
 $siblingEsedre = Join-Path $scriptDir "..\\..\\esedre\\dist\\esedre.mjs"
@@ -2902,6 +4377,11 @@ if (Test-Path $distEsedre) {
     & node $distEsedre @args
     exit $LASTEXITCODE
 }
+$nodeModulesEsedre = Join-Path $scriptDir "..\\node_modules\\esedre\\dist\\esedre.mjs"
+if (Test-Path $nodeModulesEsedre) {
+    & node $nodeModulesEsedre @args
+    exit $LASTEXITCODE
+}
 $localBin = Join-Path $scriptDir "..\\node_modules\\.bin\\ese.cmd"
 if (Test-Path $localBin) {
     & $localBin @args
@@ -2912,6 +4392,14 @@ if (Test-Path $localEsedreBin) {
     & $localEsedreBin @args
     exit $LASTEXITCODE
 }
+if (Get-Command "ese" -ErrorAction SilentlyContinue) {
+    & ese @args
+    exit $LASTEXITCODE
+}
+if (Get-Command "esedre" -ErrorAction SilentlyContinue) {
+    & esedre @args
+    exit $LASTEXITCODE
+}
 & npx --yes esedre @args
 exit $LASTEXITCODE
 `;
@@ -2920,11 +4408,8 @@ var WRAPPER_BASH = `#!/usr/bin/env bash
 set -e
 DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
 
-if command -v ese >/dev/null 2>&1; then
-  exec ese "$@"
-fi
-if command -v esedre >/dev/null 2>&1; then
-  exec esedre "$@"
+if [ -f "$DIR/../dist/esedre.mjs" ]; then
+  exec node "$DIR/../dist/esedre.mjs" "$@"
 fi
 if [ -f "$DIR/../../esedre/dist/esedre.mjs" ]; then
   exec node "$DIR/../../esedre/dist/esedre.mjs" "$@"
@@ -2932,12 +4417,21 @@ fi
 if [ -f "$DIR/../esedre/dist/esedre.mjs" ]; then
   exec node "$DIR/../esedre/dist/esedre.mjs" "$@"
 fi
+if [ -f "$DIR/../node_modules/esedre/dist/esedre.mjs" ]; then
+  exec node "$DIR/../node_modules/esedre/dist/esedre.mjs" "$@"
+fi
 if [ -f "$DIR/../node_modules/.bin/ese" ]; then
   exec "$DIR/../node_modules/.bin/ese" "$@"
 fi
 if [ -f "$DIR/../node_modules/.bin/esedre" ]; then
   exec "$DIR/../node_modules/.bin/esedre" "$@"
 fi
+if command -v ese >/dev/null 2>&1; then
+  exec ese "$@"
+fi
+if command -v esedre >/dev/null 2>&1; then
+  exec esedre "$@"
+fi
 exec npx --yes esedre "$@"
 `;
 var ESE_WRAPPER_CMD = `@echo off
@@ -3514,10 +5008,17 @@ function startUiServer(port, webDir) {
 
 // src/server/apiServer.ts
 import http3 from "node:http";
+var MAX_JSON_BODY_BYTES = 10 * 1024 * 1024;
 function readJsonBody(req) {
   return new Promise((resolve, reject) => {
     let body = "";
+    let bytesRead = 0;
     req.on("data", (chunk) => {
+      bytesRead += chunk.length;
+      if (bytesRead > MAX_JSON_BODY_BYTES) {
+        req.destroy(new Error("Payload Too Large: JSON body exceeds 10MB limit"));
+        return;
+      }
       body += chunk;
     });
     req.on("end", () => {
@@ -3570,7 +5071,7 @@ function createApiHandler(storage, workspaceRoot) {
         res.writeHead(204, {
           "Access-Control-Allow-Origin": "*",
           "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type, Authorization"
+          "Access-Control-Allow-Headers": "Content-Type, Authorization, x-esedre-allowed-projects"
         });
         res.end();
         return true;
@@ -3602,12 +5103,14 @@ function createApiHandler(storage, workspaceRoot) {
           const status = url.searchParams.get("status") || void 0;
           const type = url.searchParams.get("type") || url.searchParams.get("category") || void 0;
           const category = type;
+          const priority = url.searchParams.get("priority") || void 0;
           const search = url.searchParams.get("search") || void 0;
           const tickets = await reqStorage.listTickets({
             project: project === "all" ? void 0 : project,
             status,
             type,
             category,
+            priority,
             search
           });
           sendJson(res, 200, tickets);
@@ -3643,9 +5146,10 @@ function createApiHandler(storage, workspaceRoot) {
             const numKey = String(t.meta.id);
             const code = t.projectDescriptor?.code || t.meta.project || "Profe";
             const prefixedKey = `${code}-${t.meta.id}`;
-            metasMap[prefixedKey] = t.meta;
+            const metaWithLinks = { ...t.meta, links: t.links || t.meta.links || [], isBlocked: t.isBlocked };
+            metasMap[prefixedKey] = metaWithLinks;
             if (!metasMap[numKey] || code.toUpperCase() === "PROF") {
-              metasMap[numKey] = t.meta;
+              metasMap[numKey] = metaWithLinks;
             }
             commentsMap[prefixedKey] = t.comments || [];
             if (!commentsMap[numKey] || code.toUpperCase() === "PROF") {
@@ -3747,6 +5251,12 @@ function createApiHandler(storage, workspaceRoot) {
           sendJson(res, 200, snapshot);
           return true;
         }
+        if (pathname === "/api/planning/milestones") {
+          const project = url.searchParams.get("project") || void 0;
+          const milestones = await reqStorage.listMilestones(project);
+          sendJson(res, 200, { milestones });
+          return true;
+        }
       }
       if (req.method === "POST") {
         const body = await readJsonBody(req);
@@ -3783,6 +5293,59 @@ function createApiHandler(storage, workspaceRoot) {
           sendJson(res, 201, project);
           return true;
         }
+        if (pathname === "/api/planning/update-project") {
+          const { code, name, description, colors: colors2, techStack, groundingRules, guidelinesRef } = body;
+          if (!code) {
+            sendJson(res, 400, { error: "Project code is required." });
+            return true;
+          }
+          if (name !== void 0) {
+            const nameVal = validateProjectName(name);
+            if (!nameVal.valid) {
+              sendJson(res, 400, { error: nameVal.error });
+              return true;
+            }
+          }
+          invalidateApiCache();
+          const updated = await reqStorage.updateProject({
+            code,
+            name,
+            description,
+            colors: colors2,
+            techStack,
+            groundingRules,
+            guidelinesRef
+          });
+          sendJson(res, 200, updated);
+          return true;
+        }
+        if (pathname === "/api/planning/rename-project") {
+          const { oldCode, newCode, newName } = body;
+          if (!oldCode || !newCode) {
+            sendJson(res, 400, { error: "Both oldCode and newCode are required to rename a project." });
+            return true;
+          }
+          const codeVal = validateProjectCode(newCode);
+          if (!codeVal.valid) {
+            sendJson(res, 400, { error: codeVal.error });
+            return true;
+          }
+          if (newName !== void 0) {
+            const nameVal = validateProjectName(newName);
+            if (!nameVal.valid) {
+              sendJson(res, 400, { error: nameVal.error });
+              return true;
+            }
+          }
+          invalidateApiCache();
+          const result = await reqStorage.renameProjectCode({
+            oldCode,
+            newCode,
+            newName
+          });
+          sendJson(res, 200, result);
+          return true;
+        }
         if (pathname === "/api/planning/plans") {
           const { ticketId, planMarkdown, lastHash } = body;
           invalidateApiCache();
@@ -3820,6 +5383,48 @@ function createApiHandler(storage, workspaceRoot) {
           sendJson(res, 200, { success: true, detail: detailMarkdown });
           return true;
         }
+        if (pathname === "/api/planning/milestones") {
+          invalidateApiCache();
+          const created = await reqStorage.createMilestone(body);
+          sendJson(res, 201, { milestone: created });
+          return true;
+        }
+        if (pathname === "/api/planning/update-milestone") {
+          invalidateApiCache();
+          const { id, projectCode, ...updates } = body;
+          const updated = await reqStorage.updateMilestone(id, updates, projectCode);
+          sendJson(res, 200, { milestone: updated });
+          return true;
+        }
+        if (pathname === "/api/planning/delete-milestone") {
+          invalidateApiCache();
+          const { id, projectCode } = body;
+          const success = await reqStorage.deleteMilestone(id, projectCode);
+          sendJson(res, 200, { success });
+          return true;
+        }
+        if (pathname === "/api/planning/link") {
+          invalidateApiCache();
+          const { sourceId, relation, targetId, author, project } = body;
+          if (!sourceId || !relation || !targetId) {
+            sendJson(res, 400, { error: "sourceId, relation, and targetId are required." });
+            return true;
+          }
+          const result = await reqStorage.addTicketLink(sourceId, relation, targetId, { author, project });
+          sendJson(res, 200, { success: true, source: result.source, target: result.target });
+          return true;
+        }
+        if (pathname === "/api/planning/unlink") {
+          invalidateApiCache();
+          const { sourceId, targetId, relation, project } = body;
+          if (!sourceId || !targetId) {
+            sendJson(res, 400, { error: "sourceId and targetId are required." });
+            return true;
+          }
+          const result = await reqStorage.removeTicketLink(sourceId, targetId, { relation, project });
+          sendJson(res, 200, { success: true, source: result.source, target: result.target });
+          return true;
+        }
       }
       sendJson(res, 404, { error: `Endpoint not found: ${pathname}` });
       return true;
@@ -4001,18 +5606,33 @@ ${colors.bold}ROADMAP COMMANDS (Pair Programming & LLM Agents):${colors.reset}
   ${colors.bold}plan${colors.reset}        <id> [--file <path> | --set "<markdown>"] [--last-hash <sha1>] [--json]
                View or update implementation plan with optimistic concurrency control.
 
-  ${colors.bold}create${colors.reset}      --title "..." [-p|--project <code>] [-t|--type <type>] [--complexity <c>] [--effort "<e>"] [--summary "<s>"] [--detail "<md>"] [--file <path>] [--json]
+  ${colors.bold}create${colors.reset}      --title "..." [-p|--project <code>] [-t|--type <type>] [-P|--priority <prio>] [--complexity <c>] [--effort "<e>"] [--summary "<s>"] [--detail "<md>"] [--file <path>] [--json]
                Mint a new roadmap ticket with sequential numeric ID.
 
-  ${colors.bold}update${colors.reset}      <id> [-s|--status <status>] [-t|--type <type>] [--title "..."] [--complexity <c>] [--effort "<e>"] [--in-dev] [--flag <name>] [--last-hash <sha1>] [--force] [--json]
-               Mutate ticket status, type, title, complexity, effort, active state, or feature flag with OCC protection.
+  ${colors.bold}update${colors.reset}      <id> [-s|--status <status>] [-t|--type <type>] [-P|--priority <prio>] [--title "..."] [--complexity <c>] [--effort "<e>"] [--in-dev] [--flag <name>] [--last-hash <sha1>] [--force] [--json]
+               Mutate ticket status, type, priority, title, complexity, effort, active state, or feature flag with OCC protection.
 
   ${colors.bold}comment${colors.reset}     <id> ["<text>"] [--text "..."] [--author "..."] [--json]
                Append a research finding, test verification, or note to ticket history.
 
+  ${colors.bold}link${colors.reset}        <sourceId> <relation> <targetId> [--author "..."] [--json]
+               Establish a bi-directional link between two tickets (within or across projects).
+               \u2022 Relations: 'relates-to', 'blocks', 'blocked-by', 'parent-of', 'child-of', 'duplicates', 'duplicated-by'
+
+  ${colors.bold}unlink${colors.reset}      <sourceId> <targetId> [--json]
+               Remove a link between two tickets and its reciprocal link.
+
   ${colors.bold}snapshot, refresh${colors.reset} [--project <code>] [--json]
                Generate lean read-only projection snapshot (.esedre/snapshot.json) for zero-latency agent context.
 
+  ${colors.bold}milestone${colors.reset}   [list | get <id> | create | update <id> | delete <id>] [options] [--json]
+               Manage project milestones with optional umbrella feature flags.
+               \u2022 list:   ese milestone list [-p <project>]
+               \u2022 get:    ese milestone get <id> [-p <project>]
+               \u2022 create: ese milestone create --title "..." [-p <project>] [--flag <name>] [--status <status>] [--target-date <date>] [--desc "..."]
+               \u2022 update: ese milestone update <id> [--title "..."] [--flag <name>] [--status <status>] [--target-date <date>] [--desc "..."]
+               \u2022 delete: ese milestone delete <id> [-p <project>]
+
 ${colors.bold}SERVICE DAEMON COMMANDS:${colors.reset}
   ${colors.bold}start${colors.reset}       [--port <n>] [--foreground | -f] [--quiet] [--json]
                Start the Esedre background server and web UI daemon (default port ${DEFAULT_ESEDRE_PORT}).
@@ -4048,12 +5668,24 @@ ${colors.bold}DEVELOPER ADMINISTRATION (Human Setup & Configuration):${colors.re
   ${colors.bold}projects${colors.reset}    [--json]
                List registered workspace projects, project codes (e.g. 'CORE', 'WEB', 'DOCS'), and descriptions.
 
+  ${colors.bold}project${colors.reset}     [set <code> [-n|--name <name>] [-d|--desc <text>] | rename <old> <new>] [--json]
+               Inspect, update metadata, or rename workspace projects.
+
+  ${colors.bold}rename-project${colors.reset} <oldCode> <newCode> [-n|--name <name>] [--json]
+               Safely rename a project code on disk, updating hub folders, manifests, ticket references, and workspace configs.
+
 ${colors.bold}OPTIONS:${colors.reset}
   -p, --project <code> Project code (e.g. CORE, ALCE, DOCS).
   -n, --name <name>    Project display name (e.g. "Alce Web Reader").
   -t, --type <type>    Ticket type ('Feature', 'Platform', 'Tools', 'Idea', 'Bug').
+  -P, --priority <prio> Ticket priority ('Critical', 'High', 'Medium', 'Low', 'none').
+  -m, --milestone <name|id> Ticket milestone association.
   -s, --status <stat>  Ticket status ('Planned', 'In Development', 'Completed', 'Rejected').
   -q, --search <query> Case-insensitive substring search query.
+  -r, --relation <rel> Link relation type ('relates-to', 'blocks', 'blocked-by', etc.).
+  --to <targetId>      Target ticket ID for link/unlink commands.
+  --blocked            Filter tickets that are blocked by uncompleted tickets.
+  --linked-to <key>    Filter tickets that are linked to a specific ticket.
   --detail "<md>"      Specification markdown for ticket detail during create.
   --file <path>        Path to markdown file for detail (create) or implementation plan (plan).
   --json              Output raw machine-readable JSON (strongly recommended for autonomous LLM coding agents).
@@ -4092,7 +5724,7 @@ function parseArgs(rawArgs) {
         flags["help"] = true;
       } else if (key === "y") {
         flags["yes"] = true;
-      } else if (key === "t" || key === "p" || key === "s" || key === "q" || key === "n") {
+      } else if (key === "t" || key === "p" || key === "s" || key === "q" || key === "n" || key === "P" || key === "m" || key === "r") {
         const next = rawArgs[i + 1];
         if (next !== void 0 && !next.startsWith("-")) {
           flags[key] = next;
@@ -4113,9 +5745,12 @@ function parseArgs(rawArgs) {
   }
   if (flags["t"] && !flags["type"]) flags["type"] = flags["t"];
   if (flags["p"] && !flags["project"]) flags["project"] = flags["p"];
+  if (flags["P"] && !flags["priority"]) flags["priority"] = flags["P"];
+  if (flags["m"] && !flags["milestone"]) flags["milestone"] = flags["m"];
   if (flags["n"] && !flags["name"]) flags["name"] = flags["n"];
   if (flags["s"] && !flags["status"]) flags["status"] = flags["s"];
   if (flags["q"] && !flags["search"]) flags["search"] = flags["q"];
+  if (flags["r"] && !flags["relation"]) flags["relation"] = flags["r"];
   if (flags["f"] && !flags["foreground"]) flags["foreground"] = flags["f"];
   return { command, positionals, flags };
 }
@@ -4129,6 +5764,18 @@ function printDuplicateProjectWarnings(storage, isJson) {
   }
 }
 async function main() {
+  if (process.stdout && typeof process.stdout.setDefaultEncoding === "function") {
+    try {
+      process.stdout.setDefaultEncoding("utf-8");
+    } catch {
+    }
+  }
+  if (process.stderr && typeof process.stderr.setDefaultEncoding === "function") {
+    try {
+      process.stderr.setDefaultEncoding("utf-8");
+    } catch {
+    }
+  }
   const rawArgs = process.argv.slice(2);
   const { command, positionals, flags } = parseArgs(rawArgs);
   try {
@@ -4679,6 +6326,80 @@ ${colors.yellow}\u26A0\uFE0F  Warning: Daemon is running v${status.version}, but
         printDaemonLogs({ port, lines, workspaceRoot: discovered.workspaceRoot });
         return;
       }
+      case "rename-project": {
+        const oldCode = positionals[0];
+        const newCode = positionals[1];
+        if (!oldCode || !newCode) {
+          console.error(`${colors.red}Error: Both oldCode and newCode are required (e.g. ese rename-project Profe Lab151)${colors.reset}`);
+          process.exit(1);
+        }
+        const newName = flags["name"] || flags["n"];
+        const result = await storage.renameProjectCode({ oldCode, newCode, newName });
+        if (isJson) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Successfully renamed project "${result.oldCode}" to "${result.newCode}"${colors.reset}`);
+          console.log(`  \u2022 Display Name: ${result.project.name}`);
+          console.log(`  \u2022 Migrated Tickets: ${result.migratedTicketsCount}`);
+          if (result.updatedHubs.length > 0) {
+            console.log(`  \u2022 Updated Data Hubs: ${result.updatedHubs.length}`);
+          }
+          if (result.updatedConfigs.length > 0) {
+            console.log(`  \u2022 Updated Configs: ${result.updatedConfigs.join(", ")}`);
+          }
+        }
+        return;
+      }
+      case "project": {
+        const sub = positionals[0]?.toLowerCase();
+        if (sub === "rename") {
+          const oldCode = positionals[1];
+          const newCode = positionals[2];
+          if (!oldCode || !newCode) {
+            console.error(`${colors.red}Error: Both oldCode and newCode are required (e.g. ese project rename Profe Lab151)${colors.reset}`);
+            process.exit(1);
+          }
+          const newName = flags["name"] || flags["n"];
+          const result = await storage.renameProjectCode({ oldCode, newCode, newName });
+          if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log(`${colors.green}\u2714 Successfully renamed project "${result.oldCode}" to "${result.newCode}"${colors.reset}`);
+            console.log(`  \u2022 Display Name: ${result.project.name}`);
+            console.log(`  \u2022 Migrated Tickets: ${result.migratedTicketsCount}`);
+          }
+          return;
+        }
+        if (sub === "set") {
+          const code = positionals[1] || flags["project"] || flags["p"];
+          if (!code) {
+            console.error(`${colors.red}Error: Project code is required (e.g. ese project set Lab151 --name "Lab 151")${colors.reset}`);
+            process.exit(1);
+          }
+          const name = flags["name"] || flags["n"];
+          const description = flags["description"] || flags["desc"] || flags["d"];
+          const updated = await storage.updateProject({ code, name, description });
+          if (isJson) {
+            console.log(JSON.stringify(updated, null, 2));
+          } else {
+            console.log(`${colors.green}\u2714 Updated project "${updated.code}"${colors.reset}`);
+            console.log(`  \u2022 Name: ${updated.name}`);
+            console.log(`  \u2022 Description: ${updated.description}`);
+          }
+          return;
+        }
+        printDuplicateProjectWarnings(storage, isJson);
+        const projects = await storage.getProjects();
+        if (isJson) {
+          console.log(JSON.stringify(projects, null, 2));
+        } else {
+          console.log(`${colors.bold}Registered Projects:${colors.reset}`);
+          for (const p of projects) {
+            console.log(`  \u2022 ${colors.bold}${p.code}${colors.reset} (#${p.id}): ${p.name}: ${colors.dim}${p.description}${colors.reset}`);
+          }
+        }
+        return;
+      }
       case "projects": {
         printDuplicateProjectWarnings(storage, isJson);
         const projects = await storage.getProjects();
@@ -4699,19 +6420,43 @@ ${colors.yellow}\u26A0\uFE0F  Warning: Daemon is running v${status.version}, but
         const status = flags["status"] || void 0;
         const type = flags["type"] || flags["category"] || void 0;
         const category = type;
+        const rawPriority = flags["priority"];
+        let priority;
+        if (rawPriority) {
+          const lower = rawPriority.trim().toLowerCase();
+          if (lower === "none" || lower === "null") {
+            priority = "none";
+          } else {
+            const norm = normalizePriority(rawPriority);
+            if (!norm) {
+              console.error(`${colors.red}Error: Invalid priority filter '${rawPriority}'. Valid options: Critical, High, Medium, Low, none${colors.reset}`);
+              process.exit(1);
+            }
+            priority = norm;
+          }
+        }
         const search = flags["search"] || void 0;
-        const tickets = await storage.listTickets({ project, status, type, category, search });
+        const milestone = flags["milestone"] || flags["m"] || void 0;
+        const isBlocked = flags["blocked"] ? true : void 0;
+        const linkedTo = flags["linked-to"] || flags["linkedTo"] || void 0;
+        const tickets = await storage.listTickets({ project, status, type, category, priority, milestone, search, isBlocked, linkedTo });
         if (isJson) {
           console.log(JSON.stringify(tickets.map((t) => ({
             id: t.meta.id,
-            title: t.meta.title,
+            title: normalizeDashesAndMojibake(t.meta.title),
             type: t.meta.type || t.meta.category,
             category: t.meta.type || t.meta.category,
             status: t.meta.status,
-            complexity: t.meta.complexity,
-            effort: t.meta.estimatedEffort,
+            priority: t.meta.priority,
+            complexity: normalizeDashesAndMojibake(t.meta.complexity),
+            effort: normalizeDashesAndMojibake(t.meta.estimatedEffort),
+            milestone: t.meta.milestone,
+            featureFlag: t.meta.featureFlag,
+            inheritedFeatureFlag: t.meta.inheritedFeatureFlag,
             project: t.projectDescriptor?.code || t.meta.project || "UNASSIGNED",
-            sha1: t.sha1 || t.meta.sha1
+            sha1: t.sha1 || t.meta.sha1,
+            isBlocked: t.isBlocked,
+            links: t.links
           })), null, 2));
         } else {
           if (tickets.length === 0) {
@@ -4806,22 +6551,33 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         return;
       }
       case "create": {
-        const title = flags["title"];
-        if (!title) {
+        const rawTitle = flags["title"];
+        if (!rawTitle) {
           console.error(`${colors.red}Error: --title is required${colors.reset}`);
           process.exit(1);
         }
+        const title = normalizeDashesAndMojibake(rawTitle);
         const type = flags["type"] || flags["category"] || "Feature";
         const category = type;
+        const rawPriority = flags["priority"];
+        let priority;
+        if (rawPriority) {
+          const norm = normalizePriority(rawPriority);
+          if (!norm) {
+            console.error(`${colors.red}Error: Invalid priority '${rawPriority}'. Valid options: Critical, High, Medium, Low${colors.reset}`);
+            process.exit(1);
+          }
+          priority = norm;
+        }
         const projectCode = flags["project"] || discovered.config?.projectCode;
         if (!projectCode) {
           console.error(`${colors.red}Error: Project is required to create a ticket (--project <code> or configure projectCode in esedre.json).${colors.reset}`);
           console.error(`${colors.dim}Tip: Run 'ese init' to initialize this repository.${colors.reset}`);
           process.exit(1);
         }
-        const complexity = flags["complexity"] || "Medium";
-        const estimatedEffort = flags["effort"] || "2.0 - 4.0 hours";
-        const summary = flags["summary"] || void 0;
+        const complexity = normalizeDashesAndMojibake(flags["complexity"] || "Medium");
+        const estimatedEffort = normalizeDashesAndMojibake(flags["effort"] || "2.0 - 4.0 hours");
+        const summary = flags["summary"] ? normalizeDashesAndMojibake(flags["summary"]) : void 0;
         const submittedBy = flags["author"] || "Developer";
         const val = validateProjectCode(projectCode);
         if (!val.valid) {
@@ -4830,6 +6586,7 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         }
         const detailArg = flags["detail"];
         const fileArg = flags["file"];
+        const milestone = flags["milestone"] || flags["m"] || void 0;
         let detailMarkdown = detailArg;
         if (fileArg) {
           const filePath = path9.resolve(fileArg);
@@ -4847,18 +6604,20 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
           title,
           type,
           category,
+          priority,
           projectCode,
           complexity,
           estimatedEffort,
           summary,
           submittedBy,
           detail: detailMarkdown,
-          detailMarkdown
+          detailMarkdown,
+          milestone
         });
         if (isJson) {
           console.log(JSON.stringify(created, null, 2));
         } else {
-          console.log(`${colors.green}\u2714 Created Ticket #${created.meta.id}: ${created.meta.title}${colors.reset} [${created.projectDescriptor?.code || created.meta.project || "UNASSIGNED"}] (SHA-1: ${created.sha1?.slice(0, 8)})`);
+          console.log(`${colors.green}\u2714 Created Ticket #${created.meta.id}: ${created.meta.title}${colors.reset} [${created.projectDescriptor?.code || created.meta.project || "UNASSIGNED"}]${created.meta.priority ? ` [${created.meta.priority}]` : ""} (SHA-1: ${created.sha1?.slice(0, 8)})`);
         }
         return;
       }
@@ -4871,11 +6630,12 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         const projectFlag = flags["project"];
         const lookupKey = projectFlag && /^\d+$/.test(idStr) ? `${projectFlag}-${idStr}` : idStr;
         const status = flags["status"];
-        const title = flags["title"];
-        const complexity = flags["complexity"];
-        const effort = flags["effort"];
+        const title = flags["title"] ? normalizeDashesAndMojibake(flags["title"]) : void 0;
+        const complexity = flags["complexity"] ? normalizeDashesAndMojibake(flags["complexity"]) : void 0;
+        const effort = flags["effort"] ? normalizeDashesAndMojibake(flags["effort"]) : void 0;
         const inDev = flags["in-dev"] !== void 0 ? Boolean(flags["in-dev"]) : void 0;
         const flag = flags["flag"];
+        const rawMilestone = flags["milestone"] !== void 0 ? flags["milestone"] : flags["m"];
         const isForce = Boolean(flags["force"]);
         const lastHash = isForce ? void 0 : flags["last-hash"];
         const updates = {};
@@ -4885,19 +6645,172 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
           updates.category = type;
         }
         if (status) updates.status = status;
+        if (flags["priority"] !== void 0) {
+          const raw = String(flags["priority"]).trim();
+          if (raw.toLowerCase() === "none" || raw.toLowerCase() === "clear" || raw.toLowerCase() === "null") {
+            updates.priority = "none";
+          } else {
+            const norm = normalizePriority(raw);
+            if (!norm) {
+              console.error(`${colors.red}Error: Invalid priority '${raw}'. Valid options: Critical, High, Medium, Low, none${colors.reset}`);
+              process.exit(1);
+            }
+            updates.priority = norm;
+          }
+        }
         if (title) updates.title = title;
         if (complexity) updates.complexity = complexity;
         if (effort) updates.estimatedEffort = effort;
         if (inDev !== void 0) updates.isActivePlanning = inDev;
         if (flag) updates.featureFlag = flag;
+        if (rawMilestone !== void 0) updates.milestone = rawMilestone;
         const updated = await storage.updateTicket(lookupKey, updates, lastHash);
         if (isJson) {
           console.log(JSON.stringify(updated, null, 2));
         } else {
-          console.log(`${colors.green}\u2714 Updated Ticket #${lookupKey}: ${updated.meta.title} (Status: ${updated.meta.status}, SHA-1: ${updated.sha1?.slice(0, 8)})${colors.reset}`);
+          console.log(`${colors.green}\u2714 Updated Ticket #${lookupKey}: ${updated.meta.title} (Status: ${updated.meta.status}${updated.meta.priority ? `, Priority: ${updated.meta.priority}` : ""}${updated.meta.milestone ? `, Milestone: ${updated.meta.milestone}` : ""}, SHA-1: ${updated.sha1?.slice(0, 8)})${colors.reset}`);
         }
         return;
       }
+      case "milestone":
+      case "milestones": {
+        const subAction = positionals[0] || "list";
+        const project = flags["project"] || flags["p"] || discovered.config?.projectCode;
+        if (subAction === "list") {
+          const milestones = await storage.listMilestones(project);
+          const allTickets = await storage.listTickets({ project });
+          if (isJson) {
+            console.log(JSON.stringify(milestones, null, 2));
+          } else {
+            console.log(formatMilestoneListTable(milestones, allTickets));
+            if (milestones.length > 0) {
+              console.log(`
+${colors.dim}Total: ${milestones.length} milestones${colors.reset}`);
+            }
+          }
+          return;
+        }
+        if (subAction === "get") {
+          const idStr = positionals[1];
+          if (!idStr) {
+            console.error(`${colors.red}Error: Milestone ID or title is required (e.g. ese milestone get 1 or ese milestone get "v0.2.0")${colors.reset}`);
+            process.exit(1);
+          }
+          const milestone = await storage.getMilestone(idStr, project);
+          if (!milestone) {
+            console.error(`${colors.red}Error: Milestone "${idStr}" not found.${colors.reset}`);
+            process.exit(1);
+          }
+          const tickets = await storage.listTickets({ project, milestone: String(milestone.id) });
+          if (isJson) {
+            console.log(JSON.stringify({ ...milestone, tickets }, null, 2));
+          } else {
+            console.log(`${colors.bold}${colors.cyan}Milestone #${milestone.id}: ${milestone.title}${colors.reset}`);
+            console.log(`${colors.dim}${"=".repeat(60)}${colors.reset}`);
+            console.log(`${colors.bold}Project:${colors.reset}       ${milestone.project}`);
+            console.log(`${colors.bold}Status:${colors.reset}        ${milestone.status}`);
+            if (milestone.featureFlag) {
+              console.log(`${colors.bold}Umbrella Flag:${colors.reset} ${colors.yellow}${milestone.featureFlag}${colors.reset} ${colors.dim}(inherited by all tickets in milestone)${colors.reset}`);
+            }
+            if (milestone.targetDate) {
+              console.log(`${colors.bold}Target Date:${colors.reset}   ${milestone.targetDate}`);
+            }
+            if (milestone.description) {
+              console.log(`
+${colors.bold}Description:${colors.reset}
+${milestone.description}`);
+            }
+            const completedCount = tickets.filter((t) => t.meta.status === "Completed").length;
+            const progress = tickets.length > 0 ? Math.round(completedCount / tickets.length * 100) : 0;
+            console.log(`
+${colors.bold}Progress:${colors.reset}      ${completedCount} / ${tickets.length} completed (${progress}%)`);
+            if (tickets.length > 0) {
+              console.log(`
+${colors.bold}Tickets:${colors.reset}`);
+              for (const t of tickets) {
+                console.log(`  \u2022 #${t.meta.id} [${t.meta.status}] [${t.meta.type}]: ${t.meta.title}${t.meta.priority ? ` (${t.meta.priority})` : ""}`);
+              }
+            }
+          }
+          return;
+        }
+        if (subAction === "create") {
+          const rawTitle = flags["title"] || positionals.slice(1).join(" ").trim();
+          if (!rawTitle) {
+            console.error(`${colors.red}Error: --title is required to create a milestone (e.g. ese milestone create --title "v0.2.0")${colors.reset}`);
+            process.exit(1);
+          }
+          const title = normalizeDashesAndMojibake(rawTitle);
+          const projectCode = project;
+          if (!projectCode) {
+            console.error(`${colors.red}Error: Project is required to create a milestone (--project <code> or configure projectCode in esedre.json).${colors.reset}`);
+            process.exit(1);
+          }
+          const description = flags["desc"] || flags["description"];
+          const featureFlag = flags["flag"] || flags["feature-flag"];
+          const targetDate = flags["target-date"] || flags["date"];
+          const status = flags["status"] || "Planned";
+          const created = await storage.createMilestone({
+            projectCode,
+            title,
+            description,
+            featureFlag,
+            targetDate,
+            status
+          });
+          if (isJson) {
+            console.log(JSON.stringify(created, null, 2));
+          } else {
+            console.log(`${colors.green}\u2714 Created Milestone #${created.id}: ${created.title} [${created.project}]${created.featureFlag ? ` (Umbrella Flag: ${created.featureFlag})` : ""}${colors.reset}`);
+          }
+          return;
+        }
+        if (subAction === "update") {
+          const idStr = positionals[1];
+          if (!idStr) {
+            console.error(`${colors.red}Error: Milestone ID is required (e.g. ese milestone update 1 --status Active)${colors.reset}`);
+            process.exit(1);
+          }
+          const updates = {};
+          if (flags["title"]) updates.title = flags["title"];
+          if (flags["desc"] || flags["description"]) updates.description = flags["desc"] || flags["description"];
+          if (flags["status"]) updates.status = flags["status"];
+          if (flags["flag"] !== void 0 || flags["feature-flag"] !== void 0) {
+            updates.featureFlag = flags["flag"] !== void 0 ? flags["flag"] : flags["feature-flag"];
+          }
+          if (flags["target-date"] !== void 0 || flags["date"] !== void 0) {
+            updates.targetDate = flags["target-date"] !== void 0 ? flags["target-date"] : flags["date"];
+          }
+          const updated = await storage.updateMilestone(idStr, updates, project);
+          if (isJson) {
+            console.log(JSON.stringify(updated, null, 2));
+          } else {
+            console.log(`${colors.green}\u2714 Updated Milestone #${updated.id}: ${updated.title} (Status: ${updated.status}${updated.featureFlag ? `, Flag: ${updated.featureFlag}` : ""})${colors.reset}`);
+          }
+          return;
+        }
+        if (subAction === "delete") {
+          const idStr = positionals[1];
+          if (!idStr) {
+            console.error(`${colors.red}Error: Milestone ID is required (e.g. ese milestone delete 1)${colors.reset}`);
+            process.exit(1);
+          }
+          const success = await storage.deleteMilestone(idStr, project);
+          if (isJson) {
+            console.log(JSON.stringify({ success, id: idStr }, null, 2));
+          } else {
+            if (success) {
+              console.log(`${colors.green}\u2714 Deleted Milestone #${idStr}${colors.reset}`);
+            } else {
+              console.error(`${colors.red}Error: Milestone "${idStr}" not found.${colors.reset}`);
+              process.exit(1);
+            }
+          }
+          return;
+        }
+        console.error(`${colors.red}Error: Unknown milestone action "${subAction}". Valid actions: list, get, create, update, delete${colors.reset}`);
+        process.exit(1);
+      }
       case "comment": {
         const idStr = positionals[0];
         if (!idStr) {
@@ -4921,6 +6834,58 @@ ${colors.dim}Total: ${tickets.length} tickets${colors.reset}`);
         }
         return;
       }
+      case "link": {
+        let sourceId = positionals[0];
+        let relationArg = flags["relation"];
+        let targetId = flags["to"] || positionals[1];
+        if (positionals.length >= 3) {
+          sourceId = positionals[0];
+          relationArg = positionals[1];
+          targetId = positionals[2];
+        } else if (positionals.length === 2 && !flags["relation"]) {
+          const normRel = positionals[1].toLowerCase().replace(/_/g, "-");
+          if (["blocks", "blocked-by", "relates-to", "parent-of", "child-of", "duplicates", "duplicated-by"].includes(normRel)) {
+            relationArg = normRel;
+            targetId = flags["to"] || positionals[2];
+          } else {
+            targetId = positionals[1];
+            relationArg = "relates-to";
+          }
+        }
+        if (!sourceId || !targetId) {
+          console.error(`${colors.red}Error: Both source and target ticket IDs are required.${colors.reset}`);
+          console.error(`${colors.dim}Usage: ese link <sourceId> <relation> <targetId> [options]${colors.reset}`);
+          console.error(`${colors.dim}Relations: blocks, blocked-by, relates-to, parent-of, child-of, duplicates, duplicated-by${colors.reset}`);
+          process.exit(1);
+        }
+        const relation = (relationArg || "relates-to").toLowerCase().replace(/_/g, "-");
+        const project = flags["project"] || discovered.config?.projectCode;
+        const author = flags["author"] || "User";
+        const result = await storage.addTicketLink(sourceId, relation, targetId, { author, project });
+        if (isJson) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Linked #${result.source.meta.id} (${result.source.meta.project || "Project"}) -> ${relation} -> #${targetId}${colors.reset}`);
+        }
+        return;
+      }
+      case "unlink": {
+        const sourceId = positionals[0];
+        const targetId = flags["to"] || positionals[1];
+        if (!sourceId || !targetId) {
+          console.error(`${colors.red}Error: Both source and target ticket IDs are required.${colors.reset}`);
+          console.error(`${colors.dim}Usage: ese unlink <sourceId> <targetId> [options]${colors.reset}`);
+          process.exit(1);
+        }
+        const project = flags["project"] || discovered.config?.projectCode;
+        const result = await storage.removeTicketLink(sourceId, targetId, { project });
+        if (isJson) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`${colors.green}\u2714 Unlinked #${result.source.meta.id} from #${targetId}${colors.reset}`);
+        }
+        return;
+      }
       default: {
         console.error(`${colors.red}Error: Unknown command "${command}"${colors.reset}`);
         printHelp();