@link-assistant/hive-mind 1.72.3 → 1.72.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.72.5
+
+### Patch Changes
+
+- c3a89a3: Recover auto-PR creation when a rejected push leaves the remote branch matching local HEAD, and improve push rejection diagnostics with exact branch and compare links.
+
+## 1.72.4
+
+### Patch Changes
+
+- 82d440c: Fix fork creation verification for dotted repository names such as GitHub Pages forks.
+
 ## 1.72.3
 
 ### Patch Changes

package/package.json

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

package/src/github-repository-names.lib.mjs

@@ -0,0 +1,63 @@
+const OWNER_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+const REPOSITORY_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+const FULL_NAME_IN_TEXT_PATTERN = /(?:^|\s)([A-Za-z0-9_-]+\/[A-Za-z0-9._-]+)(?=$|\s|[),.;:])/;
+
+function trimOutputToken(token) {
+  return token.replace(/^[<([{'"`]+/, '').replace(/[>\])}'"`.,;]+$/, '');
+}
+
+function stripGitSuffix(repositoryName) {
+  return repositoryName.endsWith('.git') ? repositoryName.slice(0, -4) : repositoryName;
+}
+
+function normalizeRepositoryFullName(owner, repositoryName) {
+  if (!owner || !repositoryName) return null;
+  if (!OWNER_NAME_PATTERN.test(owner)) return null;
+  if (!REPOSITORY_NAME_PATTERN.test(repositoryName)) return null;
+  return `${owner}/${repositoryName}`;
+}
+
+function parseGitHubRepositoryUrlToken(token) {
+  const cleaned = trimOutputToken(token);
+  let pathName = null;
+
+  if (cleaned.startsWith('git@github.com:')) {
+    pathName = cleaned.slice('git@github.com:'.length);
+  } else if (cleaned.startsWith('github.com/')) {
+    pathName = cleaned.slice('github.com/'.length);
+  } else {
+    try {
+      const parsed = new URL(cleaned);
+      if (parsed.hostname !== 'github.com') return null;
+      pathName = parsed.pathname.replace(/^\/+/, '');
+    } catch {
+      return null;
+    }
+  }
+
+  const [owner, repositoryName] = pathName.split('/');
+  return normalizeRepositoryFullName(owner, stripGitSuffix(repositoryName || ''));
+}
+
+/**
+ * Parse the repository full name returned by `gh repo fork`.
+ *
+ * GitHub repository names can contain dots, notably GitHub Pages names like
+ * `parking.github.io`. The previous inline regex only accepted letters,
+ * digits, underscores, and dashes, so it truncated dotted fork names and
+ * verified the wrong repository.
+ *
+ * @param {string} output
+ * @returns {string|null}
+ */
+export function parseForkFullNameFromGhOutput(output) {
+  const text = String(output || '');
+
+  for (const token of text.match(/\S+/g) || []) {
+    const parsed = parseGitHubRepositoryUrlToken(token);
+    if (parsed) return parsed;
+  }
+
+  const fullNameMatch = text.match(FULL_NAME_IN_TEXT_PATTERN);
+  return fullNameMatch ? fullNameMatch[1] : null;
+}

package/src/solve.auto-pr.lib.mjs

@@ -4,7 +4,7 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
-import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
+import { handleRejectedPushForAutoPr, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. Issue #1756: execGhWithRetry retries on transient 5xx (504) too.
@@ -409,6 +409,9 @@ Proceed.
         }
       }
 
+      let branchReadyForPrCreation = pushResult.code === 0;
+      let recoveredFromPushRejection = false;
+
       if (pushResult.code !== 0) {
         const errorOutput = pushResult.stderr ? pushResult.stderr.toString() : pushResult.stdout ? pushResult.stdout.toString() : 'Unknown error';
 
@@ -539,48 +542,41 @@ Proceed.
           }
           await log('');
           throw new Error('Permission denied - need fork or collaborator access');
-        } else if (errorOutput.includes('non-fast-forward') || errorOutput.includes('rejected') || errorOutput.includes('! [rejected]')) {
-          const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
-          // Push rejected due to conflicts or diverged history
-          await log('');
-          await log(formatAligned('❌', 'PUSH REJECTED:', 'Branch has diverged from remote'), { level: 'error' });
-          await log('');
-          await log('  🔍 What happened:');
-          await log('     The remote branch has changes that conflict with your local changes.');
-          await log('     This typically means someone else has pushed to this branch.');
-          for (const line of buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence })) {
-            await log(line);
+        } else {
+          const rejectedPush = await handleRejectedPushForAutoPr({
+            errorOutput,
+            $,
+            tempDir,
+            log,
+            formatAligned,
+            branchName,
+            isContinueMode,
+            prNumber,
+            owner,
+            repo,
+            defaultBranch,
+            forkedRepo,
+          });
+
+          if (rejectedPush.handled) {
+            branchReadyForPrCreation = rejectedPush.branchReadyForPrCreation;
+            recoveredFromPushRejection = rejectedPush.recoveredFromPushRejection;
+          } else {
+            // Other push errors
+            await log(`${formatAligned('❌', 'Failed to push:', 'See error below')}`, { level: 'error' });
+            await log(`   Error: ${errorOutput}`, { level: 'error' });
+            throw new Error('Failed to push branch');
           }
-          await log('');
-          await log('  💡 Why we cannot fix this automatically:');
-          await log('     • We never use force push to preserve history');
-          await log('     • We never use rebase or reset to avoid altering git history');
-          await log('     • Manual conflict resolution is required');
-          await log('');
-          await log('  🔧 How to fix:');
-          await log('     1. Clone the repository and checkout the branch:');
-          await log(`        git clone https://github.com/${owner}/${repo}.git`);
-          await log(`        cd ${repo}`);
-          await log(`        git checkout ${branchName}`);
-          await log('');
-          await log('     2. Pull and merge the remote changes:');
-          await log(`        git pull origin ${branchName}`);
-          await log('');
-          await log('     3. Resolve any conflicts manually, then:');
-          await log(`        git push origin ${branchName}`);
-          await log('');
-          await log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-          await log('');
-          throw new Error('Push rejected - branch has diverged, manual resolution required');
+        }
+      }
+
+      if (branchReadyForPrCreation) {
+        if (recoveredFromPushRejection) {
+          await log(`${formatAligned('✅', 'Branch available:', 'Remote branch matches local HEAD')}`);
         } else {
-          // Other push errors
-          await log(`${formatAligned('❌', 'Failed to push:', 'See error below')}`, { level: 'error' });
-          await log(`   Error: ${errorOutput}`, { level: 'error' });
-          throw new Error('Failed to push branch');
+          await log(`${formatAligned('✅', 'Branch pushed:', 'Successfully to remote')}`);
         }
-      } else {
-        await log(`${formatAligned('✅', 'Branch pushed:', 'Successfully to remote')}`);
-        if (argv.verbose) {
+        if (argv.verbose && pushResult.code === 0) {
           await log(`   Push output: ${pushResult.stdout.toString().trim()}`, { verbose: true });
         }
 
@@ -1454,6 +1450,10 @@ ${prBody}`,
       operation: 'handle_auto_pr',
     });
 
+    if (prError?.hiveMindUserFacingLogged) {
+      throw prError;
+    }
+
     // Issue #1462: Single consolidated error message for PR creation failure.
     // Previously this was the third of three error blocks, causing confusing output.
     // Now this is the ONLY error block shown for PR creation failures.

package/src/solve.branch-divergence.lib.mjs

@@ -9,18 +9,117 @@ const outputOf = result => {
   return stdout || stderr;
 };
 
-export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null }) {
+const shortSha = sha => (sha ? String(sha).slice(0, 12) : null);
+
+const encodeRefForGitHubUrl = ref =>
+  encodeURI(String(ref || ''))
+    .replaceAll('#', '%23')
+    .replaceAll('?', '%3F');
+
+export function classifyPushRejection(errorOutput = '') {
+  const normalized = String(errorOutput || '').toLowerCase();
+
+  if (normalized.includes('cannot lock ref') && normalized.includes('reference already exists')) {
+    return 'remote-ref-already-exists';
+  }
+
+  if (normalized.includes('non-fast-forward') || normalized.includes('not fast-forward') || normalized.includes('fetch first') || normalized.includes('stale info') || normalized.includes('tip of your current branch is behind') || normalized.includes('updates were rejected')) {
+    return 'non-fast-forward';
+  }
+
+  if (normalized.includes('remote rejected') || normalized.includes('[remote rejected]')) {
+    return 'remote-rejected';
+  }
+
+  if (normalized.includes('rejected') || normalized.includes('failed to push some refs')) {
+    return 'rejected';
+  }
+
+  return 'unknown';
+}
+
+export function shouldTreatPushRejectionAsRemoteSynchronized(divergence = null) {
+  if (!divergence?.remoteExists || divergence.ahead !== 0 || divergence.behind !== 0) {
+    return false;
+  }
+
+  if (divergence.localSha && divergence.remoteSha) {
+    return divergence.localSha === divergence.remoteSha;
+  }
+
+  return true;
+}
+
+export function buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo = null }) {
+  const repository = `${owner}/${repo}`;
+  const headRepository = forkedRepo || repository;
+  const headOwner = headRepository.split('/')[0];
+  const baseBranch = defaultBranch || 'main';
+  const compareHead = forkedRepo ? `${headOwner}:${branchName}` : branchName;
+
+  return {
+    repository,
+    headRepository,
+    baseBranchRef: `${repository}:${baseBranch}`,
+    headBranchRef: `${headRepository}:${branchName}`,
+    remoteBranchRef: `origin/${branchName}`,
+    repositoryUrl: `https://github.com/${repository}`,
+    branchUrl: `https://github.com/${headRepository}/tree/${encodeRefForGitHubUrl(branchName)}`,
+    compareUrl: `https://github.com/${repository}/compare/${encodeRefForGitHubUrl(baseBranch)}...${encodeRefForGitHubUrl(compareHead)}`,
+  };
+}
+
+export function buildPushRejectionFailureActionSection({ owner, repo, branchName, defaultBranch, forkedRepo = null }) {
+  if (!owner || !repo || !branchName) {
+    return `### What you can do
+- Inspect the remote branch and compare it with the local branch before retrying.
+- If the remote branch already contains the intended commit, rerun the solver.
+- If the histories differ, merge or resolve the branch manually, then rerun the solver.`;
+  }
+
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+
+  return `### What you can do
+- Inspect the remote branch: ${links.branchUrl}
+- Compare the base and head branches: ${links.compareUrl}
+- If the remote branch already contains the intended commit, rerun the solver. Matching remote branches are treated as usable after this fix.
+- If the histories differ, merge or resolve \`${links.headBranchRef}\` against \`${links.baseBranchRef}\`, then rerun the solver.
+
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+}
+
+export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null, owner = null, repo = null, defaultBranch = null, forkedRepo = null, classification = 'unknown' }) {
   const lines = [];
 
   if (isContinueMode && !prNumber) {
     lines.push('     This run reused an existing issue branch because auto-continue found a matching branch with no PR.');
     lines.push('     It is not a fresh branch created by this run, even though auto-PR creation is running now.');
+  } else if (classification === 'remote-ref-already-exists') {
+    lines.push('     GitHub rejected the push while creating or updating the remote ref because that ref already exists.');
   } else {
     lines.push('     The remote branch changed after the local branch state used for this push.');
   }
 
+  if (owner && repo) {
+    const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+    lines.push(`     Repository: ${links.repositoryUrl}`);
+    lines.push(`     Base branch: ${links.baseBranchRef}`);
+    lines.push(`     Remote branch: ${links.headBranchRef}`);
+    lines.push(`     Branch URL: ${links.branchUrl}`);
+    lines.push(`     Compare URL: ${links.compareUrl}`);
+  }
+
   if (divergence?.remoteExists && divergence.ahead !== null && divergence.behind !== null) {
     lines.push(`     Current branch state for ${branchName}: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}.`);
+    if (divergence.localSha) {
+      lines.push(`     Local HEAD: ${shortSha(divergence.localSha)}`);
+    }
+    if (divergence.remoteSha) {
+      lines.push(`     Remote HEAD: ${shortSha(divergence.remoteSha)}`);
+    }
+    if (shouldTreatPushRejectionAsRemoteSynchronized(divergence)) {
+      lines.push('     The remote branch currently matches local HEAD, so this is not a branch divergence.');
+    }
   } else if (divergence?.fetchError) {
     lines.push(`     Could not inspect origin/${branchName}: ${divergence.fetchError}`);
   }
@@ -28,6 +127,142 @@ export function buildPushRejectionExplanation({ branchName, isContinueMode, prNu
   return lines;
 }
 
+export async function logRecoverablePushRejection({ log, formatAligned, branchName, isContinueMode, prNumber, divergence, owner, repo, defaultBranch, forkedRepo, classification }) {
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+
+  await log('');
+  await log(formatAligned('⚠️', 'PUSH REPORTED FAILURE:', 'Remote branch already matches local HEAD'), { level: 'warning' });
+  await log('');
+  await log('  🔍 What happened:');
+  for (const line of buildPushRejectionExplanation({
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  })) {
+    await log(line);
+  }
+  await log('');
+  await log('  ✅ Recovery:');
+  await log(`     The branch is available at ${links.branchUrl}.`);
+  await log('     Continuing with PR creation because no local commit would be lost.');
+  await log('');
+
+  return links;
+}
+
+export async function logBlockingPushRejection({ log, formatAligned, branchName, isContinueMode, prNumber, divergence, owner, repo, defaultBranch, forkedRepo, classification }) {
+  const links = buildBranchSubjectLinks({ owner, repo, branchName, defaultBranch, forkedRepo });
+  const isRefCollision = classification === 'remote-ref-already-exists';
+
+  await log('');
+  await log(formatAligned('❌', isRefCollision ? 'REMOTE BRANCH COLLISION:' : 'PUSH REJECTED:', isRefCollision ? 'Remote ref already exists and differs from local branch' : 'Local and remote branch histories differ'), { level: 'error' });
+  await log('');
+  await log('  🔍 What happened:');
+  if (isRefCollision) {
+    await log(`     GitHub rejected creation or update of ${links.headBranchRef} because that remote ref already exists.`);
+    await log('     The existing remote branch does not match this local branch, so hive-mind cannot assume it is safe to continue.');
+  } else {
+    await log(`     Git rejected updating ${links.headBranchRef} from this local branch.`);
+    await log('     The local and remote histories are not in a state that a normal push can update safely.');
+  }
+  for (const line of buildPushRejectionExplanation({
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  })) {
+    await log(line);
+  }
+  await log('');
+  await log('  💡 Why we cannot fix this automatically:');
+  await log('     • We never use force push to preserve history');
+  await log('     • We never use rebase or reset to avoid altering git history');
+  await log(`     • Manual review is required before changing ${links.headBranchRef}`);
+  await log('');
+  await log('  🔧 How to fix:');
+  await log(`     1. Inspect the remote branch: ${links.branchUrl}`);
+  await log(`     2. Compare base and head: ${links.compareUrl}`);
+  await log('     3. Clone the repository and checkout the branch:');
+  await log(`        git clone https://github.com/${links.headRepository}.git`);
+  await log(`        cd ${links.headRepository.split('/')[1]}`);
+  await log(`        git checkout ${branchName}`);
+  await log('');
+  await log('     4. Merge the remote branch state, resolve conflicts if any, then push:');
+  await log(`        git pull origin ${branchName}`);
+  await log(`        git push origin ${branchName}`);
+  await log('');
+  await log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  await log('');
+
+  return {
+    links,
+    failureActionSection: buildPushRejectionFailureActionSection({ owner, repo, branchName, defaultBranch, forkedRepo }),
+  };
+}
+
+export async function handleRejectedPushForAutoPr({ errorOutput, $, tempDir, log, formatAligned, branchName, isContinueMode, prNumber, owner, repo, defaultBranch, forkedRepo }) {
+  const classification = classifyPushRejection(errorOutput);
+  if (classification === 'unknown') {
+    return {
+      handled: false,
+      branchReadyForPrCreation: false,
+      recoveredFromPushRejection: false,
+    };
+  }
+
+  const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+
+  if (shouldTreatPushRejectionAsRemoteSynchronized(divergence)) {
+    await logRecoverablePushRejection({
+      log,
+      formatAligned,
+      branchName,
+      isContinueMode,
+      prNumber,
+      divergence,
+      owner,
+      repo,
+      defaultBranch,
+      forkedRepo,
+      classification,
+    });
+    return {
+      handled: true,
+      branchReadyForPrCreation: true,
+      recoveredFromPushRejection: true,
+    };
+  }
+
+  const { links, failureActionSection } = await logBlockingPushRejection({
+    log,
+    formatAligned,
+    branchName,
+    isContinueMode,
+    prNumber,
+    divergence,
+    owner,
+    repo,
+    defaultBranch,
+    forkedRepo,
+    classification,
+  });
+  const error = new Error(`Push rejected for ${links.headBranchRef}; compare ${links.compareUrl} and inspect ${links.branchUrl}`);
+  error.hiveMindUserFacingLogged = true;
+  error.failureActionSection = failureActionSection;
+  throw error;
+}
+
 export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName }) {
   const fetchResult = await $({ cwd: tempDir, silent: true })`git fetch origin refs/heads/${branchName}:refs/remotes/origin/${branchName} 2>&1`;
   if (fetchResult.code !== 0) {
@@ -41,11 +276,15 @@ export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName
 
   const aheadResult = await $({ cwd: tempDir, silent: true })`git rev-list --count origin/${branchName}..HEAD 2>&1`;
   const behindResult = await $({ cwd: tempDir, silent: true })`git rev-list --count HEAD..origin/${branchName} 2>&1`;
+  const localShaResult = await $({ cwd: tempDir, silent: true })`git rev-parse HEAD 2>&1`;
+  const remoteShaResult = await $({ cwd: tempDir, silent: true })`git rev-parse origin/${branchName} 2>&1`;
 
   return {
     remoteExists: aheadResult.code === 0 && behindResult.code === 0,
     ahead: aheadResult.code === 0 ? toCount(aheadResult.stdout) : null,
     behind: behindResult.code === 0 ? toCount(behindResult.stdout) : null,
+    localSha: localShaResult.code === 0 ? outputOf(localShaResult) : null,
+    remoteSha: remoteShaResult.code === 0 ? outputOf(remoteShaResult) : null,
     fetchError: aheadResult.code === 0 && behindResult.code === 0 ? null : outputOf(aheadResult) || outputOf(behindResult) || 'could not compare local and remote branch',
   };
 }

package/src/solve.error-handlers.lib.mjs

@@ -68,6 +68,7 @@ export const handleFailure = async options => {
           sanitizeLogContent,
           verbose: argv.verbose,
           errorMessage: cleanErrorMessage(error),
+          failureActionSection: error?.failureActionSection || null,
           // Issue #1225: Pass model and tool info for PR comments
           requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
@@ -236,7 +237,9 @@ export const handleMainExecutionError = async options => {
     return;
   }
 
-  await log('Error executing command:', cleanErrorMessage(error));
+  if (!error?.hiveMindUserFacingLogged) {
+    await log('Error executing command:', cleanErrorMessage(error));
+  }
   await log(`Stack trace: ${error.stack}`, { verbose: true });
   await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
 

package/src/solve.pre-pr-failure-notifier.lib.mjs

@@ -15,6 +15,16 @@ const isForkDivergenceFailure = reason => {
   return normalizedReason.includes('fork divergence') || (normalizedReason.includes('fork') && normalizedReason.includes('non-fast-forward')) || normalizedReason.includes('force-with-lease');
 };
 
+const extractUrlAfter = (reason, label) => {
+  const match = String(reason || '').match(new RegExp(`${label}\\s+(https://github\\.com/[^\\s;]+)`, 'i'));
+  return match ? match[1] : null;
+};
+
+const isPushRejectionFailure = reason => {
+  const normalizedReason = String(reason || '').toLowerCase();
+  return normalizedReason.includes('push rejected for ') || (normalizedReason.includes('failed to push') && normalizedReason.includes('github.com'));
+};
+
 export function buildPrePullRequestFailureActionSection(reason = '') {
   const normalizedReason = String(reason || '').toLowerCase();
   const isForkOrRecoveryFailure = normalizedReason.includes('fork') || normalizedReason.includes('auto-recovery') || normalizedReason.includes('repository setup');
@@ -25,6 +35,18 @@ export function buildPrePullRequestFailureActionSection(reason = '') {
 - If the fork has commits you need to preserve, resolve the divergence manually, then rerun the solver.
 - If this requires elevated Hive Mind access, ask a Hive Mind administrator to handle the affected fork or repository.
 
+Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
+  }
+
+  if (isPushRejectionFailure(reason)) {
+    const branchUrl = extractUrlAfter(reason, 'inspect');
+    const compareUrl = extractUrlAfter(reason, 'compare');
+    return `### What you can do
+- Inspect the remote branch${branchUrl ? `: ${branchUrl}` : ' named in the failure'}.
+- Compare the base and head histories${compareUrl ? `: ${compareUrl}` : ' using the compare link named in the failure'}.
+- If the branch belongs to you, merge the remote branch state or choose a new branch name, then rerun the solver.
+- Do not force-push unless you have manually confirmed that overwriting the remote branch is safe.
+
 Administrator-only CLI details, if any, are printed in the solver terminal log rather than in this GitHub comment.`;
   }
 

package/src/solve.repository.lib.mjs

@@ -28,6 +28,7 @@ const { log, formatAligned } = lib;
 
 // Import exit handler
 import { safeExit } from './exit-handler.lib.mjs';
+import { parseForkFullNameFromGhOutput } from './github-repository-names.lib.mjs';
 
 // Import GitHub utilities for permission checks
 const githubLib = await import('./github.lib.mjs');
@@ -589,11 +590,10 @@ export const setupRepository = async (argv, owner, repo, forkOwner = null, issue
         const forkOutput = (forkResult.stderr ? forkResult.stderr.toString() : '') + (forkResult.stdout ? forkResult.stdout.toString() : '');
         if (argv.verbose) await log(`${formatAligned('🔧', 'Fork output:', forkOutput.split('\n')[0] || '(empty)')}`); // Issue #1518
         // Parse actual fork name from output (e.g., "konard/netkeep80-jsonRVM already exists")
-        // GitHub may create forks with modified names to avoid conflicts
-        // Use regex that won't match domain names like "github.com/user" -> "com/user"
-        const forkNameMatch = forkOutput.match(/(?:github\.com\/|^|\s)([a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+)/);
-        if (forkNameMatch) {
-          actualForkName = forkNameMatch[1];
+        // Issue #1819: repository names can contain dots, such as "*.github.io".
+        const parsedForkName = parseForkFullNameFromGhOutput(forkOutput);
+        if (parsedForkName) {
+          actualForkName = parsedForkName;
         }
 
         if (forkResult.code === 0) {