diff --git a/bin/publish-latest-branch-build.php b/bin/publish-latest-branch-build.php
index 29763fb..61ceb4d 100755
--- a/bin/publish-latest-branch-build.php
+++ b/bin/publish-latest-branch-build.php
@@ -1,225 +1,232 @@
 #!/usr/bin/env php
 <?php
 ################################################################
 # This script is supposed to be executed by Phorge's Harbormaster,
 # from the directory of the leased working copy, on top of the
 # desired commit.
 #
 # Algorithm:
 #   - read the secret environment variables
 #   - for each APK:
 #     - make fingerprint
 #     - sign APK
 #     - move to the HTTP area
 #   - finally, if we are on a patch page:
 #     - publish a nice comment on Phorge on the patch page
 ################################################################
 
 // Die violently in case of any errors.
 require __DIR__ . '/../include/autoload.php';
 
 // Get environment variables.
 // These environment variables are very secret and passed to this script
 // using traditional Unix variable export.
 // These variables SHOULD be stored in a file that has very hardened permissions like
 // chmod 600, or similar.
 // Note that this PHP script does not know the .env filename. We just receive the env vars.
 // We die violently if a env variable does not exist (or if it's empty).
 // These are parsed earlier so to crash at startup.
 $KEYSTORE_PATH       = require_env('KEYSTORE_PATH');       // to sign the APK files
 $KEYSTORE_PASSPHRASE = require_env('KEYSTORE_PASSPHRASE'); // to sign the APK files
 $ARTIFACTS_PATH      = require_env('ARTIFACTS_PATH');      // to expose APK files on the web
 $ARTIFACTS_URL       = require_env('ARTIFACTS_URL');       // to download APK files from the web
 
 // Set he pathname to the repository built apk file(s).
 $APK_PATH_GENERIC = './app/build/outputs/apk/gitpull/*.apk';
 
 // Set the expected base URL for the published APK files and its webroot path on the filesystem.
 
 // The first argument of the script is the Differential ID number,
 // or empty if we are a generic commit.
 $phorge_differential_id = $argv[1] ?? null;
 
 // Show the current directory.
 // This is supposed to be a /var/drydock/repo/something and it's automatically
 // created by Harbormaster during the repository leasing.
 print_log_info(sprintf(
 	"Current directory: %s",
 	getcwd()
 ));
 
 // Get the branch name, and the Phorge document id of the page to be commented.
 $phorge_document_id = '';
 $branch_name = null;
 if ($phorge_differential_id) {
 	// We are coming from a Differential revision page.
 	// The first argument is "123", that is, the "D123" revision page.
 	// We assume that as branch name, to create nice APK names.
 	$branch_name = 'D' . $phorge_differential_id;
 	$phorge_document_id = $branch_name;
 } else {
 	// We are coming from a generic commit, not created from Differential.
 	// Get the git ref name (probably "HEAD").
 	$remote_shit = shell_line('git', [
 		'name-rev',
 		'--name-only',
 		'HEAD',
 	]);
 	$branch_name = basename($remote_shit);
 }
 
 // Get the git commit hash and title.
 // TODO: get also the author name.
 $git_commit = shell_line('git', [
 	'rev-parse',
 	'HEAD',
 ]);
 $git_commit_title = shell_line('git', [
 	'show',
 	'--pretty=format:%s',
 	'-s',
 	'HEAD',
 ]);
 
 // Find every single APK and generate core info.
 $generated_apks = [];
 
 // No APK, no party.
 $apk_founds = glob($APK_PATH_GENERIC);
 if (!$apk_founds) {
 	print_log_error("No APK Founds. WTF!?");
 	exit(1);
 }
 
 // Process every single APK.
 foreach (glob($APK_PATH_GENERIC) as $apk_path) {
 
 	// Build a "branch-apk-amd64.apk" filename.
 	$apk_filename = basename($apk_path);
 	$apk_realpath = realpath($apk_path);
 	$apk_destination_name = "$branch_name-$apk_filename";
 
 	// Set destination APK URL and path.
 	$apk_destination_file = $ARTIFACTS_PATH . '/' . $apk_destination_name;
 	$apk_destination_url  = $ARTIFACTS_URL  .       $apk_destination_name;
 
 	// Calculate the signature. This may take some time.
 	print_log_info("APK {$apk_filename}: calculating sha256sum...");
 	$apk_sha256 = hash_file('sha256', $apk_path);
 
 	// Show some internal info for the log.
 	print_log_info("APK {$apk_filename}: calculating sha256sum... completed. Info:");
 	echo "  APK original:         ${apk_path}\n";
 	echo "  APK sha256:           ${apk_sha256}\n";
 	echo "  APK destination name: ${apk_destination_name}\n";
 	echo "  APK destination path: ${apk_destination_file}\n";
 	echo "  APK destination URL:  ${apk_destination_url}\n";
 
 	// Expose in the web directory.
 	// Note that this overwrites the destination.
 	print_log_info("APK {$apk_filename}: copying to HTTP deploy destination");
 	copy($apk_path, $apk_destination_file);
 	print_log_info("APK {$apk_filename}: published in $apk_destination_url");
 
 	$apk_signed_aligned = add_file_suffix($apk_destination_file, '-signed');
 	$apk_aligned        = add_file_suffix($apk_destination_file, '-aligned');
 
 	// Run Android "ZIP align".
 	print_log_info("APK {$apk_filename}: running zipalign");
 	passthru(sprintf(
 		'~/bin/zipalign -p -f -v 4 %s %s',
 		escapeshellarg($apk_destination_file),
 		escapeshellarg($apk_aligned)
 	));
 
 	// Signing APK.
 	print_log_info("APK {$apk_filename}: signing creating {$apk_signed_aligned}...");
 	passthru(sprintf(
 		'~/bin/apksigner sign --ks %s --out %s --ks-pass pass:%s %s',
 		escapeshellarg($KEYSTORE_PATH),
 		escapeshellarg($apk_signed_aligned),
 		escapeshellarg($KEYSTORE_PASSPHRASE),
 		escapeshellarg($apk_aligned)
 	));
 	print_log_info("APK {$apk_filename}: signing creating {$apk_signed_aligned}... signed!");
 
 	// Clean old APK in the repository to never re-use it by mistake
 	// as it happened when we moved everything to the /app directory...
 	unlink($apk_path);
 
 	// Remember this APK later and its signature.
 	$generated_apks[] = new APK($apk_destination_name, $apk_destination_url, $apk_sha256);
 }
 
 // Overwrite the latest git show for this branch name (force date update).
 $BUILD_GIT_SHOW_FILE = $ARTIFACTS_PATH . '/' . $branch_name . '-git-show.txt';
 file_put_contents($BUILD_GIT_SHOW_FILE, shell_exec('git show'));
 
 // Build Phorge comment.
 // There is a fixed header, and multiple lines about each APK.
-$phorge_apk_lines = [];
+$telegram_apk_lines = [];
+$phorge_apk_lines   = [];
 foreach ($generated_apks as $generated_apk) {
+	foreach ($generated_apk->getTelegramCommentLines() as $apk_line) {
+		$telegram_apk_lines[] = $apk_line;
+		$telegram_apk_lines[] = "";
+	}
 	foreach ($generated_apk->getPhorgeCommentLines() as $apk_line) {
 		$phorge_apk_lines[] = $apk_line;
 		$phorge_apk_lines[] = "";
 	}
 }
-$phorge_apk_lines_str = implode("\n", $phorge_apk_lines);
+$telegram_apk_lines_str = implode("\n", $telegram_apk_lines);
+$phorge_apk_lines_str   = implode("\n", $phorge_apk_lines);
 
 // add a comment to the build URL
 if (!empty($phorge_document_id) && empty(getenv('NO_COMMENT'))) {
 	// We have a Differentials revision under review!
 	$telegram_chat_content = implode("\n", [
-		"⚙ Dear Android hackers, please review this promising patch:",
-		"https://gitpull.it/$phorge_document_id",
+		// In Telegram, normal text must be escaped. Link destinations must not be escaped.
+		TelegramStupidSDK::escapeMarkdownV2("⚙ Dear Android hackers, please review this promising patch:"),
+		TelegramStupidSDK::escapeMarkdownV2("https://gitpull.it/$phorge_document_id"),
 		"",
-		"Here the related fresh test builds:",
+		TelegramStupidSDK::escapeMarkdownV2("Here the related fresh test builds:"),
 		"",
-		$phorge_apk_lines_str,
+		// The texts in these links are already escaped.
+		$telegram_apk_lines_str,
 	]);
 
 	// Send message to Telegram groups.
 	echo "DEBUG TELEGRAM CONTENT\n";
 	echo "$telegram_chat_content\n";
 
 	// Send message to your default Telegram group.
 	// See the TELEGRAM_* environment variables.
 	(new TelegramStupidSDK())->sendMessage($telegram_chat_content);
 
 	// Send message to Phorge.
 	echo "Adding bipbop Comment to $phorge_document_id\n";
 	shell_exec(sprintf(
 		"~/bin/phab-comment.php %s %s %s",
 		escapeshellarg($phorge_document_id),
 		escapeshellarg($apk_destination_url),
 		escapeshellarg($apk_sha256)
 	));
 } else {
 	// We have NOT a Differentials revision under review!
 	// So this is an atomic commit.
 	$telegram_chat_content = implode("\n", [
 		"🌚 New commit: *$git_commit_title*",
 		"https://gitpull.it/R4:$git_commit",
 		"",
-		$phorge_apk_lines_str,
+		"Here the related fresh test builds:",
 		"",
-		"APK fingerprint sha256:",
-		"`$apk_sha256`"
+		$telegram_apk_lines_str,
 	]);
 
 	echo "DEBUG TELEGRAM CONTENT\n";
 	echo "$telegram_chat_content\n";
 
 	// Send message to your default Telegram group.
 	// See the TELEGRAM_* environment variables.
 	(new TelegramStupidSDK())->sendMessage($telegram_chat_content);
 }
 
 // delete very old files
 print_log_info("Cleaning old artifacts");
 shell_exec(sprintf(
 	"find %s -type f -mtime +120 -delete",
 	escapeshellarg($ARTIFACTS_PATH)
 ));
 
 print_log_info("Done");
diff --git a/include/APK.php b/include/APK.php
index 0ced1f5..7566293 100644
--- a/include/APK.php
+++ b/include/APK.php
@@ -1,53 +1,78 @@
 <?php
 /**
  * Stupid class describing a single APK.
  */
 class APK {
 	private $name;
 	private $url;
 	private $sha256;
 
 	/**
 	 * Constructor
 	 */
 	public function __construct($name, $url, $sha256) {
 		$this->name   = $name;
 		$this->url    = $url;
 		$this->sha256 = $sha256;
 	}
 
 	/**
 	 * @return array
 	 */
 	public function getPhorgeCommentLines() {
 		return [
 			$this->getPhorgeDownloadLink(),
-			//'', // No Empty newline between download link and signature
 			$this->getPhorgeAPKSignatureLine()
 		];
 	}
 
+	/**
+	 * @return array
+	 */
+	public function getTelegramCommentLines() {
+		return [
+			$this->getTelegramDownloadLink(),
+			$this->getPhorgeAPKSignatureLine()
+		];
+	}
+
+	/**
+	 * Get a very generic download link for Phorge.
+	 * @return string
+	 */
+	private function getPhorgeDownloadLink(): string {
+		return sprintf(
+			"[%s](%s)",
+			"Download {$this->name}",
+			$this->url
+		);
+	}
+
 	/**
 	 * Get a very generic download link for Phorge.
 	 * @return string
 	 */
-	private function getPhorgeDownloadLink() {
+	private function getTelegramDownloadLink(): string {
+		// In Telegram it seems we must escape the link text from special characters.
+		// The link, instead, can be returned as-is.
+		// So the Text from: "Download asd.apk"
+		//               to: "Download asd\\.apk"
 		return sprintf(
-			"[Download %s](%s)",
-			$this->name,
+			"[%s](%s)",
+			TelegramStupidSDK::escapeMarkdownV2("Download {$this->name}"),
 			$this->url
 		);
 	}
 
 	/**
 	 * Get a very generic line about the sha256sum of this APK.
 	 * @return string
 	 */
 	private function getPhorgeAPKSignatureLine() {
+		// NOTE: if you write a ":" here, Telegram will crash. Sanitize it for Telegram asd.
 		return sprintf(
-			"APK sha256: `%s`",
+			"APK sha256 `%s`",
 			$this->sha256
 		);
 	}
 }
-
diff --git a/include/TelegramStupidSDK.php b/include/TelegramStupidSDK.php
index 97ba96d..61ca06c 100644
--- a/include/TelegramStupidSDK.php
+++ b/include/TelegramStupidSDK.php
@@ -1,103 +1,106 @@
 <?php
 /**
  * Yet another stupid Telegram SDK.
  */
 class TelegramStupidSDK {
 
 	private $botToken;
 
 	/**
 	 * Constructor from the bot token.
 	 */
 	public function __construct(string $bot_token = null) {
 		// Have a sane default from the environment.
 		if ($bot_token === null) {
 			$bot_token = require_env('TELEGRAM_BOT_TOKEN');
 		}
 
 		$this->botToken = $bot_token;
 	}
 
 	/**
 	 * Get an action URL.
 	 */
 	private function getActionURL(string $action): string {
 		return "https://api.telegram.org/bot{$this->botToken}/{$action}";
 	}
 
 	/**
 	 * Get the default chat ID from the environment variable.
 	 */
 	private function getDefaultChatID(): int {
 		return require_env('TELEGRAM_CHAT_ID');
 	}
 
 	/**
 	 * Send a Telegram message to a Chat ID.
 	 */
 	public function sendMessage(string $message, int $chatId = null) {
 		// Assume a sane default.
 		if ($chatId === null) {
 			$chatId = $this->getDefaultChatID();
 		}
 
 		// Prepare the URL for the Telegram API.
 		// Initialize cURL.
 		$url = $this->getActionURL('sendMessage');
 		$ch = curl_init($url);
 
 		// Prepare the data to be sent.
-		// LOOOOL it's absolutely not clear what we should escape here.
-		$message_safe = $message;
-//		$message_safe = $this->escapeMarkdownV2($message);
+		// Note that you should escape some things by yourself, e.g. the text in the links, like:
+		//      [Download asd\\.apk](https://duck.ai/asd.apk/)
 		$data = [
 			'parse_mode' => 'MarkdownV2',
 			'chat_id' => $chatId,
-			'text' => $message_safe,
+			'text' => $message,
 		];
 
 		// Set cURL options
 		curl_setopt($ch, CURLOPT_POST, true);
 		curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
 		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 
 		// Execute the request
 		$response = curl_exec($ch);
 
 		// Check for errors
 		if (curl_errno($ch)) {
 			throw new Exception(sprintf(
 				"Error running cURL: %s",
 				curl_error($ch)
 			));
 		}
 
 		// Close cURL session
 		curl_close($ch);
 
+		// TODO: crash on server error asd.
+		print_r($response);
+
 		// Return the response
 		return $response;
 	}
 
 	/**
 	 * Escape a Telegram message body for MarkdownV2.
 	 * In MarkdownV2, these characters must be escaped: _*[]()~`>#+-=|{}.!
+	 * but only if these are parts of a "normal" text body (not in links, etc.)
 	 * https://core.telegram.org/bots/api#markdownv2-style
 	 */
-	private function escapeMarkdownV2(string $input): string {
+	public static function escapeMarkdownV2(string $input): string {
 		// Characters that need to be escaped in MarkdownV2
 		$specialChars = ['_', '*', '[', ']', '(', ')', '~', '`', '>', '#', '+', '-', '=', '|', '{', '}', '.', '!'];
 
 		// Create a search and replace array
 		$search = [];
 		$replace = [];
 
 		foreach ($specialChars as $char) {
 			$search[] = $char;
 			$replace[] = '\\' . $char;
 		}
 
 		// Replace all special characters with their escaped versions
 		return str_replace($search, $replace, $input);
 	}
 }