@link-assistant/hive-mind 1.59.0 → 1.59.2

package/CHANGELOG.md

@@ -1,5 +1,83 @@
 # @link-assistant/hive-mind
 
+## 1.59.2
+
+### Patch Changes
+
+- 9e96635: Fix Telegram `/solve` repo-not-accessible message still suggesting `--auto-accept-invite` even when that flag is already active (issue #1714). After issue #1694 flipped `--auto-accept-invite` to default-on, `src/telegram-bot.mjs` was passing `autoAcceptInvite: args.some(a => a === '--auto-accept-invite')` to `validateGitHubEntityExistence()` — but the literal flag is no longer present in the typical default-on invocation, so the suppression added by issue #1692 silently regressed. The call now reads `parsedSolveArgs?.autoAcceptInvite` (matching the auto-accept pre-check two lines above), so the hint is suppressed when the flag is active and only shown when the user explicitly opts out with `--no-auto-accept-invite`. Adds `tests/test-issue-1714-auto-accept-invite-hint.mjs` covering the parsed-argv contract and a source-level guard against the `args.some(...)` form returning, plus a case study under `docs/case-studies/issue-1714/`.
+
+## 1.59.1
+
+### Patch Changes
+
+- 65d7b99: Fix misleading `/merge` verbose logs that read as "no CI configured" when CI was actually
+  running — addresses issue [#1712](https://github.com/link-assistant/hive-mind/issues/1712)
+  where a user mistakenly Ctrl+C'd the auto-restart-until-mergeable watcher after seeing:
+
+  ```
+  [VERBOSE] /merge: PR #83 has no CI checks yet - treating as no_checks
+  [VERBOSE] /merge: PR #83 has no CI check-runs yet, but 1 workflow run(s) were triggered ...
+    ⏳ Waiting for CI:         Build and Release Docker Image
+  ```
+
+  The classification logic was correct — `/merge` was waiting on the legitimate 30-120s gap
+  between GitHub registering a `workflow_run` and publishing the corresponding `check_runs`.
+  The wording was the bug: "no CI checks yet" is parseable as "this repo has no CI", and the
+  listing showed run IDs without URLs, so the user couldn't quickly verify what `/merge` was
+  watching.
+
+  Changes:
+  - **`src/github-merge.lib.mjs`** — `getDetailedCIStatus` and `checkPRCIStatus` reword the
+    `no_checks` verbose lines to "has no check-runs or commit statuses registered yet",
+    including the short SHA. `getWorkflowRunsForSha` now appends `run.html_url` to every
+    entry. Normalized check-run / commit-status entries carry an `html_url` field
+    (falling back to `details_url` / `target_url`).
+  - **`src/solve.auto-merge-helpers.lib.mjs::getMergeBlockers`** — the `no_checks`,
+    `pending`, and `cancelled` branches now produce blocker `details` strings of the form
+    `"<name> [<status>] — <html_url>"`. The user-facing `⏳ Waiting for CI: …` line in
+    `solve.auto-merge.lib.mjs` (which joins `details` with commas) automatically picks up
+    the URLs, so the user can click through to the run.
+  - **`tests/test-misleading-merge-logs-1712.mjs`** — 13 unit tests covering the wording
+    guard, blocker enrichment for the no_checks / pending / cancelled paths, regression
+    guard for #1466, and the joined user-facing line format.
+  - **`docs/case-studies/issue-1712/README.md`** — full case study with raw logs, timeline,
+    root cause, fix description, and verification on the original PR
+    [link-foundation/box#83](https://github.com/link-foundation/box/pull/83) (which CI
+    passed for, after the user killed the watcher prematurely).
+
+  Also extends the `useWithRetry` helper (originally added in #1710 to recover from corrupt
+  hosted-CI npm-install state) with a third failure mode: `ERR_INVALID_PACKAGE_CONFIG` —
+  seen in this branch's own CI run when Node refused to parse a truncated
+  `getenv-v-latest/package.json`. `src/queue-config.lib.mjs` now loads `getenv` and
+  `links-notation` through the retry wrapper, matching `config.lib.mjs` and `lino.lib.mjs`.
+  Three new unit tests in `tests/test-use-with-retry.mjs` cover the new mode.
+
+  No upstream issue is needed — the bug was entirely in `link-assistant/hive-mind`. The
+  external workflow finished successfully (`check-runs-dfc4c14.json` shows `total_count: 22`).
+
+  **Follow-up round** (after review feedback in
+  [PR #1713 comment](https://github.com/link-assistant/hive-mind/pull/1713#issuecomment-4342387674)):
+  - **List active runs across ALL PR commits, not just HEAD.** New
+    `getActivePRWorkflowRuns()` in `src/github-merge-repo-actions.lib.mjs` walks every
+    commit on the PR (`/repos/.../pulls/N/commits`), dedupes by `run.id`, returns groups
+    marked `head` / `older`. The verbose log now lists active runs on older commits under
+    per-commit URL headers, so the GitHub Actions tab (which shows yellow dots for older
+    commits) reconciles with the log.
+  - **Eliminate duplicate logging.** `getWorkflowRunsForSha(verbose=true)` already prints
+    every run; the no_checks branch no longer re-iterates `workflowRuns`, just emits a
+    single explanatory summary line.
+  - **Commit URLs instead of short SHAs.** Verbose lines that referenced
+    `${sha.substring(0, 7)}` now use `https://github.com/${owner}/${repo}/commit/${sha}`
+    (or `/pull/N/commits/${sha}` where the PR context matters).
+  - **Inline plain-English explanations.** New `STATUS_HINTS` / `CONCLUSION_HINTS`
+    dictionaries plus `explainStatus()` helper — verbose lines read
+    `[in_progress] (currently executing)` instead of bare `in_progress`.
+  - **Multi-line user-facing waiting message.** The `⏳ Waiting for CI:` line is now
+    rendered by `renderBlocker()` — single-line for the common case (one run), but each
+    detail on its own indented line when there are multiple.
+  - 8 new tests added to `tests/test-misleading-merge-logs-1712.mjs` (Groups 5–8); 21
+    total. #1480 (31/31) and #1466 (14/14) regression suites still pass.
+
 ## 1.59.0
 
 ### Minor Changes

package/package.json

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

package/src/github-merge-repo-actions.lib.mjs

@@ -91,6 +91,60 @@ export async function getPRCommitShas(owner, repo, prNumber, verbose = false) {
   }
 }
 
+/**
+ * Issue #1712: Collect every active (in_progress / pending / queued / waiting / requested)
+ * workflow run on the PR branch — across ALL commits, not only the head SHA.
+ *
+ * Why this exists: when the user watches `/merge`, the GitHub Actions tab shows yellow
+ * dots for every commit that ever had a run, including older commits whose runs were
+ * automatically cancelled by GitHub's concurrency group. The verbose log used to list
+ * only the head-SHA runs, so a user comparing the log to the GitHub UI would see
+ * "1 workflow run" in the log but two yellow dots on screen — looking like a bug.
+ *
+ * Returns runs grouped by SHA, deduplicated by run.id (a single run can be associated
+ * with one SHA, but the same workflow file can produce runs on multiple SHAs).
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {string} headSha - The PR head SHA (used to mark which group is "current")
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Function} getWorkflowRunsForSha - Function to get workflow runs for a SHA
+ * @returns {Promise<{groups: Array<{sha: string, isHead: boolean, runs: Array}>, totalActive: number, headActive: number, otherActive: number}>}
+ */
+export async function getActivePRWorkflowRuns(owner, repo, prNumber, headSha, verbose, getWorkflowRunsForSha) {
+  const shas = await getPRCommitShas(owner, repo, prNumber, false);
+  if (shas.length === 0) {
+    return { groups: [], totalActive: 0, headActive: 0, otherActive: 0 };
+  }
+
+  const ACTIVE_STATUSES = new Set(['in_progress', 'pending', 'queued', 'waiting', 'requested']);
+  const groups = [];
+  const seenRunIds = new Set();
+  let totalActive = 0;
+  let headActive = 0;
+  let otherActive = 0;
+
+  for (const sha of shas) {
+    const runs = await getWorkflowRunsForSha(owner, repo, sha, false);
+    const activeRuns = runs.filter(r => ACTIVE_STATUSES.has(r.status) && !seenRunIds.has(r.id));
+    for (const r of activeRuns) seenRunIds.add(r.id);
+    if (activeRuns.length === 0) continue;
+
+    const isHead = sha === headSha;
+    groups.push({ sha, isHead, runs: activeRuns });
+    totalActive += activeRuns.length;
+    if (isHead) headActive += activeRuns.length;
+    else otherActive += activeRuns.length;
+  }
+
+  if (verbose && totalActive > 0) {
+    console.log(`[VERBOSE] pr-commits: ${totalActive} active workflow run(s) across ${groups.length} commit(s) on PR #${prNumber} (${headActive} on HEAD, ${otherActive} on older commits)`);
+  }
+
+  return { groups, totalActive, headActive, otherActive };
+}
+
 /**
  * Check that workflow runs for ALL commits on the PR branch have completed.
  * @param {string} owner - Repository owner

package/src/github-merge.lib.mjs

@@ -342,7 +342,9 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
     // ([].every(fn) returns true for any fn).
     if (allChecks.length === 0) {
       if (verbose) {
-        console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks yet - treating as pending`);
+        // Issue #1712: Reword for clarity — empty check-runs API response, not "no CI configured".
+        const commitUrl = `https://github.com/${owner}/${repo}/commit/${sha}`;
+        console.log(`[VERBOSE] /merge: PR #${prNumber} HEAD ${commitUrl} has no check-runs/statuses registered yet — treating as pending`);
       }
       return {
         status: 'pending',
@@ -1070,6 +1072,8 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
     const statuses = JSON.parse(statusJson.trim() || '[]');
 
     // Build detailed checks list
+    // Issue #1712: Include html_url so the user-facing waiting message can include
+    // a clickable link for each pending/failing check.
     const allChecks = [
       ...checkRuns.map(check => ({
         name: check.name,
@@ -1077,6 +1081,7 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
         conclusion: check.conclusion, // success, failure, cancelled, timed_out, skipped, neutral, action_required, stale, null
         type: 'check_run',
         id: check.id,
+        html_url: check.html_url || check.details_url || null,
       })),
       ...statuses.map(status => ({
         name: status.context,
@@ -1084,13 +1089,20 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
         conclusion: status.state === 'pending' ? null : status.state === 'success' ? 'success' : status.state === 'failure' ? 'failure' : status.state,
         type: 'status',
         id: null,
+        html_url: status.target_url || null,
       })),
     ];
 
     // No checks yet
     if (allChecks.length === 0) {
       if (verbose) {
-        console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks yet - treating as no_checks`);
+        // Issue #1712: Reword to avoid "no CI checks" sounding like "no CI configured".
+        // We are inspecting the GitHub `/commits/{sha}/check-runs` and `/commits/{sha}/status` endpoints;
+        // an empty result means no check-runs/statuses are registered yet for this commit, NOT that the
+        // repository has no CI/CD workflows. The caller (`getMergeBlockers`) decides between race
+        // condition vs. "no CI configured" based on additional API calls.
+        const commitUrl = `https://github.com/${owner}/${repo}/commit/${sha}`;
+        console.log(`[VERBOSE] /merge: PR #${prNumber} HEAD ${commitUrl} has no check-runs or commit statuses registered yet (status=no_checks; race vs. no-CI distinction is decided downstream)`);
       }
       return {
         status: 'no_checks',
@@ -1213,9 +1225,14 @@ export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
       .map(run => ({ id: run.id, status: run.status, conclusion: run.conclusion, name: run.name, html_url: run.html_url, path: run.path }));
 
     if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${runs.length} workflow runs for SHA ${sha.substring(0, 7)}`);
+      // Issue #1712: Include the commit URL (not just SHA) and the workflow run html_url
+      // so the user can click through to GitHub instead of pasting IDs into a URL by hand.
+      // The run html_url already encodes the run ID, so we don't repeat it as a separate field.
+      const commitUrl = `https://github.com/${owner}/${repo}/commit/${sha}`;
+      console.log(`[VERBOSE] /merge: Found ${runs.length} workflow run(s) for ${commitUrl}`);
       for (const run of runs) {
-        console.log(`[VERBOSE] /merge:   - ${run.name} (${run.id}): status=${run.status}, conclusion=${run.conclusion}`);
+        const concPart = run.conclusion ? `/${run.conclusion}` : '';
+        console.log(`[VERBOSE] /merge:   - ${run.name} [${run.status}${concPart}]: ${run.html_url}`);
       }
     }
 
@@ -1333,8 +1350,8 @@ export { getCommitDate, checkPreviousPRCommitsHadCI, checkWorkflowsHavePRTrigger
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
 export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
 
-import { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas } from './github-merge-repo-actions.lib.mjs'; // Issue #1503
-export { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas };
+import { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas, getActivePRWorkflowRuns } from './github-merge-repo-actions.lib.mjs'; // Issue #1503, #1712
+export { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas, getActivePRWorkflowRuns };
 
 export default {
   READY_LABEL,
@@ -1376,4 +1393,5 @@ export default {
   getAllActiveRepoRuns,
   waitForAllRepoActions,
   checkCIConsensus, // Issue #1503
+  getActivePRWorkflowRuns, // Issue #1712: list active runs across ALL PR commits
 };

package/src/queue-config.lib.mjs

@@ -36,10 +36,15 @@ if (typeof globalThis.use === 'undefined') {
   }
 }
 
-const getenvModule = await use('getenv');
+// Issue #1710 / #1712: use-m occasionally hands back a truncated/corrupt global
+// package on hosted CI (npm install -g flake — manifests as ERR_INVALID_PACKAGE_CONFIG,
+// "Failed to resolve the path", or SyntaxError mid-import). useWithRetry deletes
+// the broken install dir and re-fetches.
+const { useWithRetry } = await import('./use-with-retry.lib.mjs');
+const getenvModule = await useWithRetry(globalThis.use, 'getenv');
 // Node 24 CJS/ESM interop may return the whole module object instead of the function directly
 const getenv = typeof getenvModule === 'function' ? getenvModule : getenvModule.default || getenvModule;
-const linoModule = await use('links-notation');
+const linoModule = await useWithRetry(globalThis.use, 'links-notation');
 const LinoParser = linoModule.Parser || linoModule.default?.Parser;
 
 /**

package/src/solve.auto-merge-helpers.lib.mjs

@@ -33,7 +33,43 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkForBillingLimitError, getDetailedCIStatus, getWorkflowRunsForSha, getWorkflowRunJobsCount, getActiveRepoWorkflows, getCommitDate, checkWorkflowsHavePRTriggers, checkPreviousPRCommitsHadCI } = githubMergeLib;
+const { checkPRMergeable, checkForBillingLimitError, getDetailedCIStatus, getWorkflowRunsForSha, getWorkflowRunJobsCount, getActiveRepoWorkflows, getCommitDate, checkWorkflowsHavePRTriggers, checkPreviousPRCommitsHadCI, getActivePRWorkflowRuns } = githubMergeLib;
+
+/**
+ * Issue #1712: Plain-English meaning of GitHub Actions / check-run statuses, so the
+ * verbose log explains itself instead of forcing the user to look up GitHub docs.
+ * Returns the same status string suffixed with a parenthetical hint, e.g.
+ * "in_progress (currently executing)". Unknown statuses are returned unchanged.
+ */
+const STATUS_HINTS = {
+  in_progress: 'currently executing',
+  queued: 'waiting for a runner',
+  pending: 'waiting to start',
+  waiting: 'blocked on a deployment / approval gate',
+  requested: 'requested but not yet picked up',
+  completed: 'finished',
+};
+const CONCLUSION_HINTS = {
+  success: 'passed',
+  failure: 'failed',
+  cancelled: 'cancelled (will be re-triggered if applicable)',
+  timed_out: 'timed out',
+  skipped: 'skipped (e.g. paths-ignore matched)',
+  neutral: 'neutral / informational',
+  action_required: 'manual approval required',
+  stale: 'stale — superseded by a newer run',
+  startup_failure: 'workflow failed to start (likely invalid YAML)',
+};
+const explainStatus = (status, conclusion) => {
+  const statusPart = status ? `${status}${STATUS_HINTS[status] ? ` (${STATUS_HINTS[status]})` : ''}` : 'unknown';
+  if (!conclusion) return statusPart;
+  const concPart = `${conclusion}${CONCLUSION_HINTS[conclusion] ? ` (${CONCLUSION_HINTS[conclusion]})` : ''}`;
+  return `${statusPart} → ${concPart}`;
+};
+const formatRunLine = run => {
+  const status = run.conclusion ? `${run.status}/${run.conclusion}` : run.status;
+  return `${run.name} [${status}] — ${run.html_url}`;
+};
 
 // Issue #1625: Import centralized session-ending markers so the duplicate-
 // search scope for checkForExistingComment() stays in lock-step with the
@@ -343,13 +379,38 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
           }
 
           // Some workflow runs are still in progress or produced results — genuine race condition
+          // Issue #1712: User-facing blocker `details` carry the run URL + status so the
+          // top-level "⏳ Waiting for CI:" line is self-explanatory. Verbose listing is
+          // produced by `getWorkflowRunsForSha(..., verbose=true)` above — do NOT print the
+          // same run list twice. Here we only emit the one-line summary that explains
+          // *why* we're still waiting (race vs. real run).
+          const commitUrl = `https://github.com/${owner}/${repo}/pull/${prNumber}/commits/${ciStatus.sha}`;
           if (verbose) {
-            await log(`[VERBOSE] /merge: PR #${prNumber} has no CI check-runs yet, but ${workflowRuns.length} workflow run(s) were triggered for SHA ${ciStatus.sha.substring(0, 7)} - genuine race condition (waiting for check-runs to appear)`);
+            await log(`[VERBOSE] /merge: ${workflowRuns.length} workflow run(s) registered for PR #${prNumber} HEAD ${commitUrl} — waiting for them to publish check-runs (race condition between workflow_run and check_runs APIs, typically ~30–120 s)`);
           }
+
+          // Also surface any active workflow runs on OLDER PR commits, so the user's view of
+          // the GitHub Actions tab (which shows yellow dots for every commit) reconciles
+          // with the log. These are NOT blockers — GitHub's concurrency group cancels them
+          // when a new commit is pushed — but listing them stops the user from worrying that
+          // the watcher is missing them.
+          const activeAcrossCommits = await getActivePRWorkflowRuns(owner, repo, prNumber, ciStatus.sha, verbose, getWorkflowRunsForSha);
+          if (verbose && activeAcrossCommits.otherActive > 0) {
+            await log(`[VERBOSE] /merge: ${activeAcrossCommits.otherActive} additional active workflow run(s) on older commits of PR #${prNumber} (these are not blockers — GitHub's concurrency group will cancel them):`);
+            for (const group of activeAcrossCommits.groups) {
+              if (group.isHead) continue;
+              const olderCommitUrl = `https://github.com/${owner}/${repo}/pull/${prNumber}/commits/${group.sha}`;
+              await log(`[VERBOSE] /merge:   on ${olderCommitUrl}:`);
+              for (const run of group.runs) {
+                await log(`[VERBOSE] /merge:     - ${formatRunLine(run)} — ${explainStatus(run.status, run.conclusion)}`);
+              }
+            }
+          }
+
           blockers.push({
             type: 'ci_pending',
-            message: `CI/CD checks have not started yet (${workflowRuns.length} workflow run(s) triggered, waiting for check-runs to appear)`,
-            details: workflowRuns.map(r => r.name),
+            message: `Waiting for ${workflowRuns.length} workflow run(s) on HEAD ${commitUrl} to publish check-runs`,
+            details: workflowRuns.map(formatRunLine),
           });
         } else {
           // No workflow runs for this SHA — but this could be a race condition!
@@ -519,11 +580,27 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
     }
   } else if (ciStatus.status === 'pending') {
     // CI is still running or queued - wait for completion
-    const pendingNames = [...ciStatus.pendingChecks, ...ciStatus.queuedChecks].map(c => c.name);
+    const pendingChecks = [...ciStatus.pendingChecks, ...ciStatus.queuedChecks];
+    const pendingDetails = pendingChecks.map(c => {
+      const statusPart = c.status ? ` [${c.status}]` : '';
+      const urlPart = c.html_url ? ` — ${c.html_url}` : '';
+      return `${c.name}${statusPart}${urlPart}`;
+    });
+    if (verbose) {
+      // Issue #1712: One concise line + a per-check entry that includes a plain-English
+      // explanation of the status. We do NOT also call getWorkflowRunsForSha here — the
+      // detailed CI status already covers the same data via check-runs.
+      const commitUrl = `https://github.com/${owner}/${repo}/pull/${prNumber}/commits/${ciStatus.sha}`;
+      await log(`[VERBOSE] /merge: ${pendingChecks.length} check-run(s) still running/queued on PR #${prNumber} HEAD ${commitUrl}:`);
+      for (const c of pendingChecks) {
+        const url = c.html_url ? ` — ${c.html_url}` : '';
+        await log(`[VERBOSE] /merge:   - ${c.name}: ${explainStatus(c.status, c.conclusion)}${url}`);
+      }
+    }
     blockers.push({
       type: 'ci_pending',
       message: 'CI/CD checks are still running or queued',
-      details: pendingNames,
+      details: pendingDetails,
     });
   } else if (ciStatus.status === 'cancelled') {
     // All non-passed checks are cancelled or stale (no genuine failures)
@@ -540,10 +617,15 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
     } else {
       // These need to be re-triggered, NOT treated as AI-fixable failures
       const cancelledOrStaleChecks = [...ciStatus.cancelledChecks, ...(ciStatus.staleChecks || [])];
+      const cancelledDetails = cancelledOrStaleChecks.map(c => {
+        const concPart = c.conclusion ? ` [${c.conclusion}]` : '';
+        const urlPart = c.html_url ? ` — ${c.html_url}` : '';
+        return `${c.name}${concPart}${urlPart}`;
+      });
       blockers.push({
         type: 'ci_cancelled',
         message: 'CI/CD checks were cancelled or became stale',
-        details: cancelledOrStaleChecks.map(c => c.name),
+        details: cancelledDetails,
         sha: ciStatus.sha,
       });
     }

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

@@ -903,10 +903,30 @@ No further AI sessions will be started automatically for this run. Please review
         const cancelledOnly = blockers.every(b => b.type === 'ci_cancelled' || b.type === 'ci_pending');
         const cancelledBlocker = blockers.find(b => b.type === 'ci_cancelled');
 
+        // Issue #1712: When `details` contain URLs (which they now always do for ci_pending /
+        // ci_cancelled blockers), comma-joining them produces an unreadable single-line wall
+        // of text. Render the first detail inline (with the message as the header) and any
+        // additional details on their own indented lines. Each detail is already
+        // self-explanatory: "<name> [<status>] — <url>".
+        const renderBlocker = (icon, header, blocker) => {
+          if (!blocker.details || blocker.details.length === 0) {
+            return log(formatAligned(icon, header, blocker.message, 2));
+          }
+          if (blocker.details.length === 1) {
+            return log(formatAligned(icon, header, blocker.details[0], 2));
+          }
+          return (async () => {
+            await log(formatAligned(icon, header, blocker.message, 2));
+            for (const detail of blocker.details) {
+              await log(formatAligned('', '', detail, 4));
+            }
+          })();
+        };
+
         if (cancelledOnly && cancelledBlocker) {
-          await log(formatAligned('🔄', 'Waiting for re-triggered CI:', cancelledBlocker.details.join(', '), 2));
+          await renderBlocker('🔄', 'Waiting for re-triggered CI:', cancelledBlocker);
         } else if (pendingBlocker) {
-          await log(formatAligned('⏳', 'Waiting for CI:', pendingBlocker.details.length > 0 ? pendingBlocker.details.join(', ') : pendingBlocker.message, 2));
+          await renderBlocker('⏳', 'Waiting for CI:', pendingBlocker);
         } else {
           await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
         }

package/src/telegram-bot.mjs

@@ -967,7 +967,9 @@ async function handleSolveCommand(ctx) {
       VERBOSE && console.log(`[VERBOSE] Auto-accept invite pre-check failed: ${e.message}`);
     }
   }
-  const entityCheck = await validateGitHubEntityExistence({ owner: validation.parsed.owner, repo: validation.parsed.repo, number: validation.parsed.number, type: validation.parsed.type, verbose: VERBOSE, autoAcceptInvite: args.some(a => a === '--auto-accept-invite') });
+  // Issue #1714: read the parsed argv (default-on per #1694) instead of the raw args list,
+  // so the invite hint is suppressed on the default-on path where the literal flag is absent.
+  const entityCheck = await validateGitHubEntityExistence({ owner: validation.parsed.owner, repo: validation.parsed.repo, number: validation.parsed.number, type: validation.parsed.type, verbose: VERBOSE, autoAcceptInvite: !!parsedSolveArgs?.autoAcceptInvite });
   if (!entityCheck.valid) {
     await safeReply(ctx, `❌ ${escapeMarkdown(entityCheck.error)}`, { reply_to_message_id: ctx.message.message_id });
     return;

package/src/use-with-retry.lib.mjs

@@ -4,7 +4,7 @@
  * Retry wrapper for `use-m` package loading.
  *
  * Issue #1710: Hosted CI runners occasionally hand back a truncated or
- * partially-installed global package after `npm install -g <pkg>`. Two
+ * partially-installed global package after `npm install -g <pkg>`. Three
  * surface symptoms have been observed:
  *
  *   1. `import` throws a SyntaxError ("Unexpected end of input") wrapped
@@ -13,8 +13,11 @@
  *   2. use-m throws `Failed to resolve the path to '<pkg>' from '<dir>'`
  *      — the install completed without error but the package tree is
  *      missing files that the `main`/`exports` entry depends on.
+ *   3. Node throws `Invalid package config <dir>/package.json.` with
+ *      `code: 'ERR_INVALID_PACKAGE_CONFIG'` — the package.json itself
+ *      is corrupt/truncated and cannot even be parsed (issue #1712).
  *
- * The recovery is identical for both: delete the broken alias install
+ * The recovery is identical for all three: delete the broken alias install
  * directory and ask use-m to re-fetch. A clean reinstall almost always
  * succeeds. This helper centralises that retry so every call site picks
  * it up.
@@ -68,10 +71,18 @@ export const isCorruptInstallError = error => {
   if (cause instanceof SyntaxError) return true;
   const causeMessage = typeof cause?.message === 'string' ? cause.message : '';
   if (/Unexpected end of input|Unexpected token/.test(causeMessage)) return true;
+  // Mode 3 (issue #1712): package.json itself is corrupt — Node refuses to
+  // even parse it and throws ERR_INVALID_PACKAGE_CONFIG before use-m's own
+  // resolve/import logic gets a chance to run.
+  if (error?.code === 'ERR_INVALID_PACKAGE_CONFIG') return true;
+  if (cause?.code === 'ERR_INVALID_PACKAGE_CONFIG') return true;
   // Mode 2 (also seen on hosted CI): npm install completes but the package
   // tree is incomplete, so use-m can't resolve the entry point.
   const message = typeof error?.message === 'string' ? error.message : '';
-  return /^Failed to resolve the path to /.test(message);
+  if (/^Failed to resolve the path to /.test(message)) return true;
+  // Fallback string match for ERR_INVALID_PACKAGE_CONFIG (in case the error
+  // bubbles through use-m without preserving the `code` property).
+  return /^Invalid package config /.test(message);
 };
 
 export const extractCorruptedFilePath = error => {
@@ -82,7 +93,12 @@ export const extractCorruptedFilePath = error => {
   // is already the alias install directory — return it directly so callers
   // can clean it up (cleanup() handles both files and directories).
   const resolveMatch = message.match(/Failed to resolve the path to '[^']+' from '([^']+)'/);
-  return resolveMatch ? resolveMatch[1] : null;
+  if (resolveMatch) return resolveMatch[1];
+  // Mode 3 (issue #1712): "Invalid package config <dir>/package.json." —
+  // extract the package.json path so the caller's cleanup() walks up to
+  // the alias dir.
+  const invalidConfigMatch = message.match(/Invalid package config (\S+?package\.json)/);
+  return invalidConfigMatch ? invalidConfigMatch[1] : null;
 };
 
 const defaultCleanup = async path => {