@link-assistant/hive-mind 2.17.0 → 2.18.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 2.18.0
+
+### Minor Changes
+
+- 3fc12ef: Recover broken GitHub URLs instead of rejecting them, and say what was repaired (issue #2194).
+
+  A user sent `/Claude https://github.com/G-Ivan-A/aether-orbis/pulls/30`. Telegram drew a healthy GitHub preview card under it, because github.com really does answer `/owner/repo/pulls/30` with **HTTP 200** and a full set of Open Graph tags — a genuinely wrong path like `/pullz/30` 404s and gets no card. The bot then refused the command and told the user to "1. Open the repository: https://github.com/G-Ivan-A/aether-orbis/**pulls/30**" — the same broken link that had just failed. Meanwhile `parseGitHubUrl` had already extracted the number: the pre-fix `case 'pulls'` stored `'30'` in `result.subpath` and nothing ever read it. The data to restore the URL from was sitting in the result object.
+
+  - **`src/github-url-recovery.lib.mjs`** repairs a URL before it is parsed: strips invisible characters (`\p{Cf}`/`\p{Cc}`/`\p{Zl}`/`\p{Zp}`, U+034F, variation selectors), unwraps `[title](url)` / `<url>` / `(url).`, folds full-width and fraction punctuation and full-width digits to ASCII, lower-cases scheme and host, reads `git@github.com:owner/repo.git` and `api.github.com/repos/...` as their web addresses, and reads `/pulls/30` as `/pull/30`, `/issue/123` as `/issues/123`, `/pull/30/files` as the pull request itself.
+  - **Recovery is on by default inside `parseGitHubUrl`**, so all 48 call sites across 14 files get it without changing any of them. `{ recover: false }` reproduces the old code path exactly, which is what makes the before/after evidence reproducible.
+  - **It never invents a GitHub URL.** `gitlab.com`, `bitbucket.org`, `gist.github.com`, `raw.githubusercontent.com`, `github.com.evil.example` and `evil.example/github.com/...` are all still rejected — and so is over-reach in the other direction: `support@github.com` is an email address rather than a repository (`git@github.com:owner/repo.git` still works), and `[the PR](aether-orbis)` stays rejected because unwrapping prose is only worth doing when what comes out already names github.com.
+  - **It never repairs silently.** Every result carries `original`, `repairs[]` and `recovered`, plus `hidden`/`revealed` when something invisible was removed. The Telegram bot (new `telegram.url_recovered` string in `en`/`ru`/`hi`/`zh`), `solve` and `hive` each print what they understood before acting on it.
+  - **Two silent-corruption bugs went with it.** A zero-width space in a repository name used to produce `valid: true` for `aether-orbis%E2%80%8B` — a repository that does not exist. `HTTPS://GITHUB.COM/...` used to parse as a _relative path_ with `HTTPS:` as the owner; the bot's own `url.includes('github.com')` gate had the same flaw and rejected the URL before the parser saw it — that gate now asks the recovery layer whether the text names github.com as its _host_, so `evil.example/github.com/...` no longer passes it either.
+  - **The log could not have proved an invisible character even if there had been one** — it never recorded the message text. `/solve` and its aliases now log raw text through `revealHiddenCharacters()` (a zero-width space appears as `[U+200B]`), and `traceUrlRecovery()` reports each repair stage under `--verbose`.
+
+  `normalize-url@9` and `confusables@1` were installed and measured against these exact inputs rather than assumed: `normalize-url` percent-encodes the zero-width space instead of removing it and **throws** on a full-width colon, and `confusables` turns `github.com/Ćwikła/...` into `github.com/Cwikla/...` — it would silently retarget a real owner. Neither knows that `/pulls/30` means pull request 30.
+
+  77 assertions in `tests/test-issue-2194-broken-url-recovery.mjs`. Timeline, evidence and the full analysis are in `docs/case-studies/issue-2194/README.md`, with reproduction scripts in `experiments/issue-2194/` and `examples/github-url-recovery-demo.mjs`.
+
 ## 2.17.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/github-url-parser.lib.mjs

@@ -1,8 +1,37 @@
 import { reportError } from './sentry.lib.mjs';
+import { describeHiddenCharacters, repairGitHubPathParts, repairGitHubUrlText, revealHiddenCharacters, traceUrlRecovery } from './github-url-recovery.lib.mjs';
+
+/**
+ * Attach the issue #2194 recovery diagnostics to a parse result.
+ *
+ * `original` is always present so a caller can show the user what they actually
+ * sent; `hidden`/`revealed` only appear when there was something invisible to
+ * reveal, keeping the common result small.
+ *
+ * @param {Object} result - The result object to annotate (mutated and returned).
+ * @param {string} original - The URL exactly as it was passed in.
+ * @param {Array<{code: string, message: string, notable: boolean}>} repairs
+ * @param {Array<{escape: string, name: string}>} hidden
+ * @returns {Object} The same result object.
+ */
+function withRecoveryDiagnostics(result, original, repairs, hidden) {
+  result.original = original;
+  result.repairs = repairs;
+  result.recovered = repairs.length > 0;
+  if (hidden.length > 0) {
+    result.hidden = hidden;
+    result.revealed = revealHiddenCharacters(original);
+  }
+  return result;
+}
 
 /**
  * Universal GitHub URL parser that handles various formats
  * @param {string} url - The GitHub URL to parse
+ * @param {Object} [options] - Parsing options
+ * @param {boolean} [options.recover=true] - Repair recoverable damage (invisible
+ *   Unicode, wrappers, look-alike punctuation, `/pulls/30` for `/pull/30`, …)
+ *   before parsing. Pass `false` to see the URL exactly as it was typed.
  * @returns {Object} Parsed URL information including:
  *   - valid: boolean indicating if the URL is valid
  *   - normalized: the normalized URL (https://github.com/...), query/fragment kept
@@ -13,22 +42,41 @@ import { reportError } from './sentry.lib.mjs';
  *   - number: issue/PR number (if applicable)
  *   - path: additional path components
  *   - error: error message if invalid
+ *   - original: the URL exactly as it was passed in
+ *   - repairs: the list of repairs recovery had to apply (issue #2194)
+ *   - recovered: true when at least one repair was applied
+ *   - hidden/revealed: codepoint diagnostics, present only when the input carried
+ *     invisible or look-alike characters
  */
-export function parseGitHubUrl(url) {
+export function parseGitHubUrl(url, options = {}) {
   if (!url || typeof url !== 'string') {
     return {
       valid: false,
       error: 'Invalid input: URL must be a non-empty string',
     };
   }
+  const { recover = true } = options;
+  // Issue #2194: a URL that renders correctly on screen can still be broken —
+  // `…/pulls/30` previews as a healthy page, a zero-width space is unprintable by
+  // definition. Repair what can be repaired first, and keep a record of it, so the
+  // user is told what was interpreted instead of being told "invalid URL".
+  const hidden = describeHiddenCharacters(url);
+  let repairs = [];
   // Trim whitespace and remove trailing slashes
   let normalizedUrl = url.trim().replace(/\/+$/, '');
+  if (recover) {
+    const repaired = repairGitHubUrlText(normalizedUrl);
+    repairs = repaired.repairs;
+    if (repaired.rejection) {
+      traceUrlRecovery('rejected', { original: url, error: repaired.rejection, repairs, hidden });
+      return withRecoveryDiagnostics({ valid: false, error: repaired.rejection }, url, repairs, hidden);
+    }
+    normalizedUrl = repaired.text.replace(/\/+$/, '');
+    if (repairs.length > 0) traceUrlRecovery('repaired-text', { original: url, repaired: normalizedUrl, repairs, hidden });
+  }
   // Check if this looks like a valid GitHub-related input Reject clearly invalid inputs (spaces in the URL, special chars at the start, etc.)
   if (/\s/.test(normalizedUrl) || /^[!@#$%^&*()[\]{}|\\:;"'<>,?`~]/.test(normalizedUrl)) {
-    return {
-      valid: false,
-      error: 'Invalid GitHub URL format',
-    };
+    return withRecoveryDiagnostics({ valid: false, error: 'Invalid GitHub URL format' }, url, repairs, hidden);
   }
   // Handle protocol normalization
   if (!normalizedUrl.startsWith('http://') && !normalizedUrl.startsWith('https://')) {
@@ -40,10 +88,7 @@ export function parseGitHubUrl(url) {
       normalizedUrl = 'https://github.com/' + normalizedUrl;
     } else {
       // Has github.com somewhere but not at the start - likely malformed
-      return {
-        valid: false,
-        error: 'Invalid GitHub URL format',
-      };
+      return withRecoveryDiagnostics({ valid: false, error: 'Invalid GitHub URL format' }, url, repairs, hidden);
     }
   }
   // Convert http to https
@@ -56,11 +101,16 @@ export function parseGitHubUrl(url) {
     // Generate suggested URL by replacing backslashes with forward slashes
     const suggestedUrl = urlBeforeQueryAndHash.replace(/\\/g, '/');
     const urlAfterPath = normalizedUrl.substring(urlBeforeQueryAndHash.length);
-    return {
-      valid: false,
-      error: 'Invalid character in URL: backslash (\\) is not allowed in URL paths',
-      suggestion: suggestedUrl + urlAfterPath,
-    };
+    return withRecoveryDiagnostics(
+      {
+        valid: false,
+        error: 'Invalid character in URL: backslash (\\) is not allowed in URL paths',
+        suggestion: suggestedUrl + urlAfterPath,
+      },
+      url,
+      repairs,
+      hidden
+    );
   }
   // Parse the URL
   let urlObj;
@@ -74,17 +124,11 @@ export function parseGitHubUrl(url) {
         url: normalizedUrl,
       });
     }
-    return {
-      valid: false,
-      error: 'Invalid URL format',
-    };
+    return withRecoveryDiagnostics({ valid: false, error: 'Invalid URL format' }, url, repairs, hidden);
   }
   // Ensure it's a GitHub URL
   if (urlObj.hostname !== 'github.com' && urlObj.hostname !== 'www.github.com') {
-    return {
-      valid: false,
-      error: 'Not a GitHub URL',
-    };
+    return withRecoveryDiagnostics({ valid: false, error: 'Not a GitHub URL' }, url, repairs, hidden);
   }
   // Normalize hostname
   if (urlObj.hostname === 'www.github.com') {
@@ -92,7 +136,19 @@ export function parseGitHubUrl(url) {
     urlObj = new globalThis.URL(normalizedUrl);
   }
   // Parse the pathname
-  const pathParts = urlObj.pathname.split('/').filter(p => p);
+  let pathParts = urlObj.pathname.split('/').filter(p => p);
+  // Issue #2194: `/owner/repo/pulls/30` carries every byte needed to address pull
+  // request 30 — restore it rather than reporting the pull request list page.
+  if (recover) {
+    const pathRepair = repairGitHubPathParts(pathParts);
+    if (pathRepair.repairs.length > 0) {
+      repairs = repairs.concat(pathRepair.repairs);
+      pathParts = pathRepair.parts;
+      urlObj.pathname = `/${pathParts.join('/')}`;
+      normalizedUrl = urlObj.toString().replace(/\/+$/, '');
+      traceUrlRecovery('repaired-path', { original: url, repaired: normalizedUrl, repairs, hidden });
+    }
+  }
   // Handle different GitHub URL patterns
   const result = {
     valid: true,
@@ -108,6 +164,7 @@ export function parseGitHubUrl(url) {
     protocol: 'https',
     path: urlObj.pathname,
   };
+  withRecoveryDiagnostics(result, url, repairs, hidden);
   // No path - just github.com
   if (pathParts.length === 0) {
     result.type = 'home';

package/src/github-url-recovery.lib.mjs

@@ -0,0 +1,514 @@
+/**
+ * Recovery layer for GitHub URLs that "look valid" but are not.
+ *
+ * A URL pasted into a chat client rarely arrives byte-for-byte as it left the
+ * address bar: messengers wrap it in punctuation, IMEs substitute full-width
+ * punctuation, bidi and zero-width characters ride along invisibly, and users type
+ * `/pulls/30` where they meant `/pull/30` — which github.com answers with HTTP 200
+ * (the pull request *list* page), so the link preview looks perfectly healthy while
+ * the number the user cared about is silently dropped.
+ *
+ * Every function here is pure. Repairs are conservative enough to be no-ops on a
+ * well-formed URL, and each one is reported back to the caller, so the bot can say
+ * what it actually interpreted instead of failing with "invalid URL".
+ *
+ * Scope note: the confusable-punctuation folding below is applied to the scheme and
+ * host, and to path *separators* only. A `tree`/`blob` file path therefore keeps its
+ * original bytes apart from its slashes — those URL types address no task in this
+ * codebase, and corrupting a file name would be worse than failing to normalize one.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2194
+ * @module github-url-recovery
+ */
+
+/** Canonical GitHub web host. */
+const GITHUB_HOST = 'github.com';
+
+/**
+ * Characters that must never survive into a URL:
+ *   - `\p{Cf}` — zero-width space/joiner, BOM, soft hyphen, bidi marks and embeddings
+ *   - `\p{Cc}` — C0/C1 control characters (including tab, CR and LF)
+ *   - `\p{Zl}`/`\p{Zp}` — line and paragraph separators
+ *   - U+034F COMBINING GRAPHEME JOINER and U+FE00–U+FE0F variation selectors
+ * They are removable rather than replaceable: they carry no addressing information.
+ */
+const INVISIBLE_CHARACTERS = /[\p{Cf}\p{Cc}\p{Zl}\p{Zp}\u034F\uFE00-\uFE0F]/gu;
+
+/**
+ * Unicode space separators other than U+0020. A URL can never contain one, so a
+ * space that is not the plain ASCII space is always paste damage. The ASCII space
+ * is deliberately left in place: it is how the caller still detects "this is two
+ * words, not a URL".
+ */
+const EXOTIC_SPACES = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
+
+/** Names for the characters we most often have to strip, for the diagnostics. */
+const CHARACTER_NAMES = {
+  0x0009: 'TAB',
+  0x000a: 'LINE FEED',
+  0x000d: 'CARRIAGE RETURN',
+  0x00ad: 'SOFT HYPHEN',
+  0x00a0: 'NO-BREAK SPACE',
+  0x034f: 'COMBINING GRAPHEME JOINER',
+  0x200b: 'ZERO WIDTH SPACE',
+  0x200c: 'ZERO WIDTH NON-JOINER',
+  0x200d: 'ZERO WIDTH JOINER',
+  0x200e: 'LEFT-TO-RIGHT MARK',
+  0x200f: 'RIGHT-TO-LEFT MARK',
+  0x202a: 'LEFT-TO-RIGHT EMBEDDING',
+  0x202b: 'RIGHT-TO-LEFT EMBEDDING',
+  0x202c: 'POP DIRECTIONAL FORMATTING',
+  0x202d: 'LEFT-TO-RIGHT OVERRIDE',
+  0x202e: 'RIGHT-TO-LEFT OVERRIDE',
+  0x202f: 'NARROW NO-BREAK SPACE',
+  0x2060: 'WORD JOINER',
+  0x2066: 'LEFT-TO-RIGHT ISOLATE',
+  0x2067: 'RIGHT-TO-LEFT ISOLATE',
+  0x2068: 'FIRST STRONG ISOLATE',
+  0x2069: 'POP DIRECTIONAL ISOLATE',
+  0x3000: 'IDEOGRAPHIC SPACE',
+  0xfe0f: 'VARIATION SELECTOR-16',
+  0xfeff: 'ZERO WIDTH NO-BREAK SPACE (BOM)',
+  0xff0e: 'FULLWIDTH FULL STOP',
+  0xff0f: 'FULLWIDTH SOLIDUS',
+  0xff1a: 'FULLWIDTH COLON',
+  0x2044: 'FRACTION SLASH',
+  0x2215: 'DIVISION SLASH',
+};
+
+/** Look-alike separators, mapped to the ASCII character they impersonate. */
+const SEPARATOR_CONFUSABLES = new Map([
+  ['／', '/'], // FULLWIDTH SOLIDUS
+  ['⁄', '/'], // FRACTION SLASH
+  ['∕', '/'], // DIVISION SLASH
+  ['⧸', '/'], // BIG SOLIDUS
+  ['：', ':'], // FULLWIDTH COLON
+  ['﹕', ':'], // SMALL COLON
+  ['︓', ':'], // PRESENTATION FORM FOR VERTICAL COLON
+  ['∶', ':'], // RATIO
+]);
+
+/** Everything above, plus host punctuation that only makes sense before the path. */
+const PREFIX_CONFUSABLES = new Map([
+  ...SEPARATOR_CONFUSABLES,
+  ['．', '.'], // FULLWIDTH FULL STOP
+  ['＠', '@'], // FULLWIDTH COMMERCIAL AT
+  ['－', '-'], // FULLWIDTH HYPHEN-MINUS
+]);
+
+/** Paired delimiters a messenger or a prose sentence may wrap a URL in. */
+const WRAPPERS = new Map([
+  ['<', '>'],
+  ['(', ')'],
+  ['[', ']'],
+  ['{', '}'],
+  ['"', '"'],
+  ["'", "'"],
+  ['`', '`'],
+  ['«', '»'], // « »
+  ['“', '”'], // “ ”
+  ['‘', '’'], // ‘ ’
+]);
+
+/** Sentence punctuation that can only be prose, never the end of a GitHub URL. */
+const TRAILING_PUNCTUATION = new Set(['.', ',', ';', ':', '!', '?', '…']);
+
+/** Closing delimiters that are stripped when the matching opener is absent. */
+const UNBALANCED_CLOSERS = new Map([
+  [')', '('],
+  [']', '['],
+  ['}', '{'],
+  ['>', '<'],
+  ['»', '«'],
+  ['”', '“'],
+  ['’', '‘'],
+]);
+
+/**
+ * What may legally stand in front of `github.com`: an optional scheme (with the
+ * colon, or without it when at least two slashes follow — the `https//github.com`
+ * typo), optional SSH user info, and one of the few host aliases that serve the
+ * same site. Anything else — `gist.`, `raw.`, `evil.com/`, `notgithub.com` — must
+ * NOT be rewritten into a github.com address.
+ */
+const HOST_PREFIX = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/{0,3}|[A-Za-z][A-Za-z0-9+.-]*\/{2,3}|\/{0,3})(?:[^/\s@]*@)?(www\.|m\.|api\.)?$/;
+
+/** Repairs that mean the token was wrapped in prose punctuation rather than typed as a URL. */
+const WRAPPER_REPAIR_CODES = new Set(['markdown-link-unwrapped', 'wrapper-stripped']);
+
+/** The first path segment must be able to be a GitHub login for the shorthand form. */
+const GITHUB_LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\/|$)/;
+
+/** Any explicit `scheme://`, which means the input names its own host. */
+const EXPLICIT_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+
+/** Alternate spellings of the two entity kinds we can act on. */
+const ENTITY_KIND_ALIASES = new Map([
+  ['issue', 'issues'],
+  ['issues', 'issues'],
+  ['pull', 'pull'],
+  ['pulls', 'pulls'],
+  ['pullrequest', 'pull'],
+  ['pullrequests', 'pulls'],
+  ['pull-request', 'pull'],
+  ['pull-requests', 'pulls'],
+  ['pull_request', 'pull'],
+  ['pull_requests', 'pulls'],
+  ['merge_requests', 'pulls'],
+]);
+
+/**
+ * Repairs a user cannot see for themselves. These change *which* entity the URL
+ * addresses, or undo damage that is invisible on screen, so the bot has to say out
+ * loud what it did. The rest (a stripped bracket, an added `https://`) are obvious
+ * from the URL itself and would only be noise.
+ */
+const NOTABLE_REPAIR_CODES = new Set(['invisible-characters-removed', 'confusables-normalized', 'entity-kind-corrected', 'entity-subpath-dropped', 'fullwidth-digits-normalized', 'duplicate-slashes-collapsed', 'api-url-converted']);
+
+/** Rejection reasons, worded exactly as `parseGitHubUrl` has always worded them. */
+export const REJECT_NOT_GITHUB = 'Not a GitHub URL';
+export const REJECT_MALFORMED = 'Invalid GitHub URL format';
+
+/** Single-character probes need their own non-global copies of the /g regexes. */
+const INVISIBLE_CHARACTER = new RegExp(INVISIBLE_CHARACTERS.source, 'u');
+const EXOTIC_SPACE = new RegExp(EXOTIC_SPACES.source, 'u');
+
+/**
+ * Describe every character in `text` that is invisible, exotic whitespace, or a
+ * punctuation look-alike, so a log line or an error message can show the user *why*
+ * a URL that looks correct on screen was not.
+ *
+ * @param {string} text
+ * @returns {Array<{index: number, codePoint: number, escape: string, name: string}>}
+ */
+export function describeHiddenCharacters(text) {
+  if (!text || typeof text !== 'string') return [];
+  const found = [];
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (!INVISIBLE_CHARACTER.test(character) && !EXOTIC_SPACE.test(character) && !PREFIX_CONFUSABLES.has(character)) continue;
+    const codePoint = character.codePointAt(0);
+    const escape = `U+${codePoint.toString(16).toUpperCase().padStart(4, '0')}`;
+    found.push({ index, codePoint, escape, name: CHARACTER_NAMES[codePoint] || escape });
+  }
+  return found;
+}
+
+/**
+ * Render `text` with every hidden character replaced by its `U+XXXX` escape, so the
+ * damage survives a copy/paste into an issue report. Visible characters are kept.
+ *
+ * @param {string} text
+ * @param {{maxLength?: number}} [options]
+ * @returns {string}
+ */
+export function revealHiddenCharacters(text, { maxLength = 300 } = {}) {
+  if (!text || typeof text !== 'string') return '';
+  const hidden = new Map(describeHiddenCharacters(text).map(entry => [entry.index, entry.escape]));
+  let revealed = '';
+  for (let index = 0; index < text.length; index++) {
+    revealed += hidden.has(index) ? `[${hidden.get(index)}]` : text[index];
+  }
+  return revealed.length > maxLength ? `${revealed.slice(0, maxLength)}… (truncated)` : revealed;
+}
+
+/** Replace look-alike punctuation with ASCII, preserving string length. */
+function fold(text, table) {
+  let folded = '';
+  for (const character of text) folded += table.get(character) ?? character;
+  return folded;
+}
+
+/** Record a repair once; a repeated code keeps its first (most specific) message. */
+function addRepair(repairs, code, message) {
+  if (repairs.some(repair => repair.code === code)) return;
+  repairs.push({ code, message, notable: NOTABLE_REPAIR_CODES.has(code) });
+}
+
+/** Strip paired wrappers and prose punctuation that a messenger glued to the URL. */
+function stripDecoration(text, repairs) {
+  let current = text;
+  let changed = true;
+  while (changed && current.length > 1) {
+    changed = false;
+    // [label](url) — a Markdown link pasted whole.
+    const markdownLink = current.match(/^\[[^\]]*\]\((.+)\)$/);
+    if (markdownLink) {
+      current = markdownLink[1].trim();
+      addRepair(repairs, 'markdown-link-unwrapped', 'unwrapped a Markdown link');
+      changed = true;
+      continue;
+    }
+    if (WRAPPERS.get(current[0]) === current[current.length - 1]) {
+      current = current.slice(1, -1).trim();
+      addRepair(repairs, 'wrapper-stripped', 'removed the surrounding brackets or quotes');
+      changed = true;
+      continue;
+    }
+    const last = current[current.length - 1];
+    if (TRAILING_PUNCTUATION.has(last)) {
+      current = current.slice(0, -1);
+      addRepair(repairs, 'trailing-punctuation-stripped', `removed the trailing "${last}"`);
+      changed = true;
+      continue;
+    }
+    const opener = UNBALANCED_CLOSERS.get(last);
+    if (opener && !current.includes(opener)) {
+      current = current.slice(0, -1);
+      addRepair(repairs, 'trailing-punctuation-stripped', `removed the unmatched "${last}"`);
+      changed = true;
+    }
+  }
+  return current;
+}
+
+/** Remove invisible characters and exotic spaces, reporting what was dropped. */
+function stripHiddenCharacters(text, repairs) {
+  const cleaned = text.replace(INVISIBLE_CHARACTERS, '').replace(EXOTIC_SPACES, ' ');
+  if (cleaned === text) return text;
+  const names = [...new Set(describeHiddenCharacters(text).map(entry => entry.name))].slice(0, 4).join(', ');
+  addRepair(repairs, 'invisible-characters-removed', `removed invisible character(s)${names ? `: ${names}` : ''}`);
+  return cleaned;
+}
+
+/**
+ * Rewrite the scheme/host prefix to the canonical `https://github.com`.
+ *
+ * @returns {{text: string}|{rejection: string}|null} `null` when the input carries
+ *   no `github.com` at all, leaving the caller to consider the shorthand form.
+ */
+function normalizeHost(text, repairs) {
+  const folded = fold(text, PREFIX_CONFUSABLES);
+  const hostIndex = folded.toLowerCase().indexOf(GITHUB_HOST);
+  if (hostIndex === -1) return null;
+
+  const hostEnd = hostIndex + GITHUB_HOST.length;
+  const prefix = folded.slice(0, hostIndex);
+  const prefixMatch = prefix.match(HOST_PREFIX);
+  if (!prefixMatch) return { rejection: REJECT_NOT_GITHUB };
+
+  // Only the separators of the remainder are folded — see the module note.
+  let after = fold(text.slice(hostEnd, hostEnd + 1), SEPARATOR_CONFUSABLES) + text.slice(hostEnd + 1);
+  if (after !== '' && !/^[/:?#]/.test(after)) return { rejection: REJECT_NOT_GITHUB };
+
+  // `git@github.com:owner/repo.git` is an SSH remote; `support@github.com` on its
+  // own is an email address and must never become a GitHub URL (issue #2194).
+  if (prefix.includes('@') && !/^[:/]./.test(after)) return { rejection: REJECT_NOT_GITHUB };
+
+  const port = after.match(/^:(\d+)(.*)$/s);
+  if (port) after = port[2];
+  const rest = after.replace(/^:+/, '/');
+
+  const alias = (prefixMatch[1] || '').toLowerCase();
+  let path = rest;
+  if (alias === 'api.') {
+    // https://api.github.com/repos/{owner}/{repo}/{issues|pulls}/{number}
+    const apiPath = rest.match(/^\/repos\/([^/\s]+\/[^/\s]+(?:\/.*)?)$/s);
+    if (!apiPath) return { rejection: REJECT_NOT_GITHUB };
+    path = `/${apiPath[1]}`;
+    addRepair(repairs, 'api-url-converted', 'read the api.github.com address as its web address');
+  } else if (alias) {
+    addRepair(repairs, 'host-normalized', `normalized the "${alias}${GITHUB_HOST}" host to ${GITHUB_HOST}`);
+  }
+  if (prefix.includes('@')) addRepair(repairs, 'ssh-url-converted', 'read the SSH/git remote address as its web address');
+  if (folded.slice(0, hostEnd) !== text.slice(0, hostEnd)) addRepair(repairs, 'confusables-normalized', 'replaced look-alike punctuation with ASCII');
+  if (!/^https:\/\/github\.com(?:[/?#]|$)/.test(text)) addRepair(repairs, 'scheme-normalized', 'normalized the address to https://github.com');
+
+  return { text: `https://${GITHUB_HOST}${path === '' || /^[/?#]/.test(path) ? path : `/${path}`}` };
+}
+
+/** Convert full-width digits (`３０`) to ASCII; returns null when not all digits. */
+function toAsciiDigits(segment) {
+  if (!/^[０-９]+$/.test(segment)) return null;
+  return segment.replace(/[０-９]/g, digit => String.fromCharCode(digit.charCodeAt(0) - 0xff10 + 0x30));
+}
+
+/** Collapse repeated slashes in the path and drop a `.git` suffix on the repo. */
+function normalizePathShape(text, repairs) {
+  const match = text.match(/^(https:\/\/github\.com)([\s\S]*)$/);
+  if (!match) return text;
+  const pathAndRest = match[2];
+  const boundary = pathAndRest.search(/[?#]/);
+  const path = boundary === -1 ? pathAndRest : pathAndRest.slice(0, boundary);
+  const suffix = boundary === -1 ? '' : pathAndRest.slice(boundary);
+
+  let repaired = path.replace(/\/{2,}/g, '/');
+  if (repaired !== path) addRepair(repairs, 'duplicate-slashes-collapsed', 'collapsed repeated slashes');
+
+  const segments = repaired.split('/').filter(Boolean);
+  let rebuild = false;
+  if (segments.length >= 2 && /\.git$/i.test(segments[1])) {
+    segments[1] = segments[1].replace(/\.git$/i, '');
+    rebuild = true;
+    addRepair(repairs, 'git-suffix-removed', 'removed the ".git" suffix from the repository name');
+  }
+  // Full-width digits have to be folded here, before `new URL()` percent-encodes
+  // them out of recognition. Only the entity number is touched, never a file name.
+  if (segments.length >= 4 && ENTITY_KIND_ALIASES.has(segments[2].toLowerCase())) {
+    const asciiNumber = toAsciiDigits(segments[3]);
+    if (asciiNumber) {
+      segments[3] = asciiNumber;
+      rebuild = true;
+      addRepair(repairs, 'fullwidth-digits-normalized', 'converted full-width digits to ASCII');
+    }
+  }
+  if (rebuild) repaired = `/${segments.join('/')}`;
+  return `https://${GITHUB_HOST}${repaired}${suffix}`;
+}
+
+/**
+ * Does `text` address github.com *as its host*?
+ *
+ * A substring test cannot answer this. `https://evil.example/github.com/o/r` and
+ * `https://github.com.evil.example/o/r` both contain "github.com" and neither one is
+ * a GitHub URL, while `HTTPS://GITHUB.COM/o/r` and `https：//github．com/o/r` are
+ * GitHub URLs that contain no ASCII lowercase "github.com" at all. So the question
+ * is answered by the same host normalizer the repair path uses, and by nothing else.
+ *
+ * The shorthand form (`owner/repo`) names no host and is deliberately not a match:
+ * this is the check a caller makes *before* deciding the input was meant to be a URL
+ * at all, so a bare word must stay distinguishable from a mistyped address.
+ *
+ * @param {string} text - The URL exactly as the user supplied it.
+ * @returns {boolean}
+ */
+export function namesGitHubHost(text) {
+  if (!text || typeof text !== 'string') return false;
+  const repairs = [];
+  const stripped = stripDecoration(stripHiddenCharacters(text.trim(), repairs).trim(), repairs);
+  if (stripped === '') return false;
+  const host = normalizeHost(stripped, repairs);
+  return Boolean(host) && !host.rejection;
+}
+
+/**
+ * Repair the textual form of a GitHub URL before it is parsed.
+ *
+ * @param {string} raw - The URL exactly as the user supplied it.
+ * @returns {{text: string, repairs: Array<{code: string, message: string, notable: boolean}>, rejection?: string}}
+ *   `text` is the repaired URL (identical to the trimmed input when nothing needed
+ *   fixing), `repairs` lists what changed, and `rejection` is set when the input
+ *   names a host that must not be rewritten.
+ */
+export function repairGitHubUrlText(raw) {
+  const repairs = [];
+  if (!raw || typeof raw !== 'string') return { text: '', repairs };
+
+  let text = stripHiddenCharacters(raw.trim(), repairs).trim();
+  text = stripDecoration(text, repairs);
+  if (text === '') return { text, repairs, rejection: REJECT_MALFORMED };
+  const wasWrapped = repairs.some(repair => WRAPPER_REPAIR_CODES.has(repair.code));
+
+  const host = normalizeHost(text, repairs);
+  if (host?.rejection) return { text, repairs, rejection: host.rejection };
+  if (host) return { text: normalizePathShape(host.text, repairs), repairs };
+
+  // No github.com anywhere. An input that names its own scheme names its own host
+  // too, so it is handed to the parser untouched and rejected there — this is what
+  // keeps `https://gitlab.com/owner/repo` from being rewritten into a GitHub URL.
+  if (EXPLICIT_SCHEME.test(text)) return { text, repairs };
+  // `[label](target)` and `"word"` in the middle of a sentence are prose. Unwrapping
+  // them is only worth doing when what comes out already names github.com, so a bare
+  // token that was wrapped must not be promoted to a GitHub profile (issue #2194).
+  if (wasWrapped) return { text, repairs, rejection: REJECT_MALFORMED };
+  if (!GITHUB_LOGIN.test(text)) return { text, repairs, rejection: REJECT_MALFORMED };
+  addRepair(repairs, 'scheme-normalized', `read the shorthand as a ${GITHUB_HOST} path`);
+  return { text: normalizePathShape(`https://${GITHUB_HOST}/${text.replace(/^\/+/, '')}`, repairs), repairs };
+}
+
+/**
+ * Repair the `owner/repo/kind/number` shape of an already-split path.
+ *
+ * This is where the reported failure is fixed: `/owner/repo/pulls/30` carries every
+ * byte needed to address pull request 30, so it is restored to `/owner/repo/pull/30`
+ * instead of being reported as "the pull requests list page".
+ *
+ * @param {string[]} parts - Path segments, with the empty ones already removed.
+ * @returns {{parts: string[], repairs: Array<{code: string, message: string, notable: boolean}>}}
+ */
+export function repairGitHubPathParts(parts) {
+  const repairs = [];
+  if (!Array.isArray(parts) || parts.length < 3) return { parts, repairs };
+
+  const repaired = [...parts];
+  const rawKind = repaired[2];
+  const kind = ENTITY_KIND_ALIASES.get(rawKind.toLowerCase());
+  if (!kind) return { parts: repaired, repairs };
+
+  const asciiNumber = repaired.length > 3 ? toAsciiDigits(repaired[3]) : null;
+  if (asciiNumber) {
+    repaired[3] = asciiNumber;
+    addRepair(repairs, 'fullwidth-digits-normalized', 'converted full-width digits to ASCII');
+  }
+  const hasNumber = repaired.length > 3 && /^\d+$/.test(repaired[3]);
+
+  // `/pulls/30` addresses pull request 30; a bare `/pull` addresses the list. Any
+  // other `/pull/<something>` (`/pull/new/branch`) is left exactly as it was.
+  let canonicalKind = kind;
+  if (kind === 'pulls' && hasNumber) canonicalKind = 'pull';
+  if (kind === 'pull' && repaired.length === 3) canonicalKind = 'pulls';
+
+  if (canonicalKind !== rawKind) {
+    repaired[2] = canonicalKind;
+    const isReportedCase = canonicalKind === 'pull' && rawKind.toLowerCase() === 'pulls';
+    addRepair(repairs, 'entity-kind-corrected', isReportedCase ? `"/${rawKind}/${repaired[3]}" is the pull request list page — read it as "/pull/${repaired[3]}"` : `corrected the path segment "${rawKind}" to "${canonicalKind}"`);
+  }
+
+  // A tab suffix (`/files`, `/commits`, `/checks`, …) still addresses the same entity.
+  if (hasNumber && repaired.length > 4 && (canonicalKind === 'pull' || canonicalKind === 'issues')) {
+    const dropped = repaired.slice(4).join('/');
+    repaired.length = 4;
+    addRepair(repairs, 'entity-subpath-dropped', `ignored the "/${dropped}" tab and used the ${canonicalKind === 'pull' ? 'pull request' : 'issue'} itself`);
+  }
+  return { parts: repaired, repairs };
+}
+
+/**
+ * Render a repair list as one human-readable sentence fragment.
+ *
+ * @param {Array<{message: string}>} repairs
+ * @param {{notableOnly?: boolean}} [options]
+ * @returns {string} Empty string when there is nothing worth saying.
+ */
+export function formatUrlRepairs(repairs, { notableOnly = false } = {}) {
+  if (!Array.isArray(repairs) || repairs.length === 0) return '';
+  const selected = notableOnly ? repairs.filter(repair => repair.notable) : repairs;
+  return selected.map(repair => repair.message).join('; ');
+}
+
+/** True when at least one repair changed something the user could not see. */
+export function hasNotableRepair(repairs) {
+  return Array.isArray(repairs) && repairs.some(repair => repair.notable);
+}
+
+/**
+ * Verbose-only trace of one recovery step.
+ *
+ * `parseGitHubUrl` is synchronous and cannot await the project logger, but the
+ * stdio interceptor in `lib.mjs` mirrors console output into the session log, so a
+ * `--verbose` run still ends up with the codepoint-level record that issue #2194
+ * asked for ("add debug output and verbose mode … that will allow us to find root
+ * cause on next iteration").
+ *
+ * @param {string} stage
+ * @param {Object} details
+ */
+export function traceUrlRecovery(stage, details) {
+  if (!globalThis.verboseMode) return;
+  try {
+    console.error(`[url-recovery] ${stage} ${JSON.stringify(details)}`);
+  } catch {
+    console.error(`[url-recovery] ${stage} (details could not be serialized)`);
+  }
+}
+
+export default {
+  describeHiddenCharacters,
+  formatUrlRepairs,
+  hasNotableRepair,
+  namesGitHubHost,
+  repairGitHubPathParts,
+  repairGitHubUrlText,
+  revealHiddenCharacters,
+  traceUrlRecovery,
+};

package/src/hive.mjs

@@ -86,6 +86,8 @@ if (isRunningDirectly) {
     const { validateYouTrackConfig, testYouTrackConnection, createYouTrackConfigFromEnv } = youTrackLib;
     const youTrackSync = await import('./youtrack/youtrack-sync.mjs');
     const { syncYouTrackToGitHub, formatIssuesForHive } = youTrackSync;
+    // Issue #2194: recovery diagnostics for URLs that had to be repaired before parsing.
+    const { formatUrlRepairs, hasNotableRepair, revealHiddenCharacters } = await import('./github-url-recovery.lib.mjs');
     const memCheck = await import('./memory-check.mjs');
     const { checkSystem } = memCheck;
     const exitHandler = await import('./exit-handler.lib.mjs');
@@ -185,6 +187,14 @@ if (isRunningDirectly) {
         console.error('  - owner/repo (will be converted to https://github.com/owner/repo)');
         await safeExit(1, 'Error occurred');
       }
+      // Issue #2194: report a repaired URL before monitoring starts, so the user
+      // can catch a wrong guess instead of watching the wrong repository.
+      if (hasNotableRepair(parsedUrl.repairs)) {
+        console.error('ℹ️  Repaired the GitHub URL before monitoring:');
+        console.error(`     You typed: ${revealHiddenCharacters(githubUrl)}`);
+        console.error(`     Using:     ${parsedUrl.canonical || parsedUrl.normalized}`);
+        console.error(`     Repaired:  ${formatUrlRepairs(parsedUrl.repairs, { notableOnly: true })}`);
+      }
       // Check if it's a valid type for hive (user or repo)
       if (parsedUrl.type !== 'user' && parsedUrl.type !== 'repo') {
         console.error('Error: Invalid GitHub URL for monitoring');

package/src/locales/en.lino

@@ -508,6 +508,13 @@ en
       must
         be
           type "URL must be a GitHub {{allowedTypes}} (not {{type}})"
+      recovered """
+        ℹ️ I repaired the link before starting.
+
+        You sent: {{original}}
+        Using: {{used}}
+        Repaired: {{repairs}}
+      """
     language
       invalid """
         ❌ Invalid language. Supported: {{supported}}.

package/src/locales/hi.lino

@@ -508,6 +508,13 @@ hi
       must
         be
           type "URL GitHub {{allowedTypes}} होना चाहिए ({{type}} नहीं)"
+      recovered """
+        ℹ️ शुरू करने से पहले लिंक ठीक की गई।
+
+        आपने भेजा: {{original}}
+        उपयोग किया जा रहा है: {{used}}
+        ठीक किया गया: {{repairs}}
+      """
     language
       invalid """
         ❌ अमान्य भाषा। समर्थित: {{supported}}।

package/src/locales/ru.lino

@@ -508,6 +508,13 @@ ru
       must
         be
           type "URL должен быть GitHub {{allowedTypes}} (не {{type}})"
+      recovered """
+        ℹ️ Ссылка была исправлена перед запуском.
+
+        Вы отправили: {{original}}
+        Используется: {{used}}
+        Исправлено: {{repairs}}
+      """
     language
       invalid """
         ❌ Неверный язык. Поддерживаются: {{supported}}.

package/src/locales/zh.lino

@@ -508,6 +508,13 @@ zh
       must
         be
           type "URL 必须是 GitHub {{allowedTypes}}（不是 {{type}}）"
+      recovered """
+        ℹ️ 开始前已修复链接。
+
+        您发送的：{{original}}
+        实际使用：{{used}}
+        修复内容：{{repairs}}
+      """
     language
       invalid """
         ❌ 语言无效。支持的语言：{{supported}}。

package/src/solve.validation.lib.mjs

@@ -35,6 +35,9 @@ const {
 } = githubLib;
 
 // Import git-related functions for identity validation and repair
+// Issue #2194: recovery diagnostics for URLs that had to be repaired before parsing.
+const { formatUrlRepairs, hasNotableRepair, revealHiddenCharacters } = await import('./github-url-recovery.lib.mjs');
+
 const gitLib = await import('./git.lib.mjs');
 const { checkGitIdentity, repairGitIdentity } = gitLib;
 
@@ -83,6 +86,16 @@ export const validateGitHubUrl = issueUrl => {
     return { isValid: false, isIssueUrl: null, isPrUrl: null };
   }
 
+  // Issue #2194: the URL needed repair before it could be understood. Say so up
+  // front, so a wrong guess is visible before a whole session runs against the
+  // wrong entity.
+  if (hasNotableRepair(parsedUrl.repairs)) {
+    console.error('ℹ️  Repaired the GitHub URL before solving:');
+    console.error(`     You typed: ${revealHiddenCharacters(issueUrl)}`);
+    console.error(`     Using:     ${parsedUrl.canonical || parsedUrl.normalized}`);
+    console.error(`     Repaired:  ${formatUrlRepairs(parsedUrl.repairs, { notableOnly: true })}`);
+  }
+
   // Check if it's an issue or pull request
   const isIssueUrl = parsedUrl.type === 'issue';
   const isPrUrl = parsedUrl.type === 'pull';
@@ -102,9 +115,12 @@ export const validateGitHubUrl = issueUrl => {
     isIssueUrl,
     isPrUrl,
     normalizedUrl: parsedUrl.normalized,
+    canonicalUrl: parsedUrl.canonical || parsedUrl.normalized,
     owner: parsedUrl.owner,
     repo: parsedUrl.repo,
     number: parsedUrl.number,
+    repairs: parsedUrl.repairs || [],
+    recovered: Boolean(parsedUrl.recovered),
   };
 };
 

package/src/telegram-bot.mjs

@@ -169,6 +169,8 @@ const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = lim
 const { handleShowLimitsFlag, captureStartSnapshotAndAppend } = await import('./telegram-show-limits.lib.mjs'); // #594
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
+const { formatUrlRepairs, hasNotableRepair, namesGitHubHost, revealHiddenCharacters } = await import('./github-url-recovery.lib.mjs'); // #2194
+
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
 const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
 const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
@@ -315,22 +317,28 @@ async function validateGitHubUrl(args, options = {}) {
   if (!rawUrl) return { valid: false, error: t('telegram.missing_github_url', { commandName }, { locale }) };
   // Issue #1102: Clean non-printable chars (Zero-Width Space, BOM, etc.) from URLs
   const url = cleanNonPrintableChars(rawUrl);
-  if (!url.includes('github.com')) return { valid: false, error: t('telegram.first_arg_must_be_github_url', {}, { locale }) };
+  // Issue #2194: the host may be typed in any case (GITHUB.COM) or hidden behind
+  // look-alike punctuation, and "github.com" in the path of another host is not a
+  // GitHub URL at all — so the recovery layer's host check makes the call, not a
+  // substring test that both misses the first case and accepts the second.
+  if (!namesGitHubHost(url)) return { valid: false, error: t('telegram.first_arg_must_be_github_url', {}, { locale }) };
   const parsed = parseGitHubUrl(url);
   if (!parsed.valid) return { valid: false, error: parsed.error || 'Invalid GitHub URL', suggestion: parsed.suggestion };
+  // Issue #2194: tell the user which URL we actually understood when we had to repair theirs.
+  const recoveryNotice = hasNotableRepair(parsed.repairs) ? t('telegram.url_recovered', { original: escapeMarkdown(makeSpecialCharsVisible(rawUrl)), used: escapeMarkdown(parsed.canonical), repairs: escapeMarkdown(formatUrlRepairs(parsed.repairs, { notableOnly: true })) }, { locale }) : null;
   if (!allowedTypes.includes(parsed.type)) {
     const allowedTypesStr = allowedTypes.map(t => (t === 'pull' ? 'pull request' : t)).join(', ');
     const baseUrl = `https://github.com/${parsed.owner}/${parsed.repo}`;
     const escapedUrl = escapeMarkdown(url),
       escapedBaseUrl = escapeMarkdown(baseUrl); // Issue #1102: escape for Markdown
     let error;
-    if (parsed.type === 'issues_list') error = t('telegram.url_issues_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
-    else if (parsed.type === 'pulls_list') error = t('telegram.url_pulls_list_error', { url: escapedUrl, example: `${escapedBaseUrl}/pull/1` }, { locale });
+    if (parsed.type === 'issues_list') error = t('telegram.url_issues_list_error', { url: escapedBaseUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
+    else if (parsed.type === 'pulls_list') error = t('telegram.url_pulls_list_error', { url: escapedBaseUrl, example: `${escapedBaseUrl}/pull/1` }, { locale });
     else if (parsed.type === 'repo') error = t('telegram.url_repo_error', { allowedTypes: allowedTypesStr, url: escapedUrl, example: `${escapedBaseUrl}/issues/1` }, { locale });
     else error = t('telegram.url_must_be_type', { allowedTypes: allowedTypesStr, type: parsed.type.replace('_', ' ') }, { locale });
     return { valid: false, error };
   }
-  return { valid: true, parsed, normalizedUrl: url };
+  return { valid: true, parsed, normalizedUrl: url, recoveryNotice };
 }
 
 const executeAndUpdateMessage = buildExecuteAndUpdateMessage({ resolveIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE, executeStartScreen, trackSession, untrackSession, AUTO_WATCH_MESSAGE, startAutoTerminalWatchForSession, bot, formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage });
@@ -539,6 +547,10 @@ async function handleSolveCommand(ctx) {
   }
 
   VERBOSE && console.log(`[VERBOSE] ${solveCommandDisplay} passed all checks, executing...`);
+  // Issue #2194: the incoming text is the only record of what the user actually
+  // typed, and the log for that issue did not contain it — so an invisible
+  // character in the URL was invisible in the log too. Reveal it here.
+  VERBOSE && console.log(`[VERBOSE] ${solveCommandDisplay} raw text: ${revealHiddenCharacters(ctx.message.text)}`);
   const solveToolAlias = getSolveToolAliasFromText(ctx.message.text);
   let userArgs = parseCommandArgs(ctx.message.text);
 
@@ -607,6 +619,8 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  // Issue #2194: the link needed repair, so show what we understood before we act on it.
+  if (validation.recoveryNotice) await safeReply(ctx, validation.recoveryNotice, { reply_to_message_id: ctx.message.message_id });
   userArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   // Issue #2166: hand the spawned session the same canonical URL that is shown
   // in the chat, so the echo and the actual work can never disagree.
@@ -826,6 +840,8 @@ async function handleHiveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  // Issue #2194: the link needed repair, so show what we understood before we act on it.
+  if (validation.recoveryNotice) await safeReply(ctx, validation.recoveryNotice, { reply_to_message_id: ctx.message.message_id });
   // Normalize issues_list/pulls_list to base repo URL, or use cleaned URL
   let normalizedArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const p = validation.parsed;