@link-assistant/hive-mind 1.77.1 → 1.78.1

package/src/telegram-safe-reply.lib.mjs

@@ -61,27 +61,129 @@ function findTelegramSplitIndex(text, limit) {
   return limit;
 }
 
+// A Markdown fenced code block opens/closes with ``` or ~~~ (optionally indented
+// and, on the opening fence, followed by a language/info string). We track these
+// so a split that lands inside a code block can close the fence on the current
+// chunk and reopen it — repeating the language — on the next one (issue #1891).
+const CODE_FENCE_RE = /^(\s*)(```+|~~~+)(.*)$/;
+
+/**
+ * Parse a single line as a Markdown code-fence delimiter.
+ *
+ * @param {string} line
+ * @returns {{indent: string, marker: string, info: string}|null}
+ *   The fence parts, or `null` when the line is not a fence.
+ */
+export function parseCodeFence(line) {
+  const match = CODE_FENCE_RE.exec(line);
+  if (!match) return null;
+  return { indent: match[1], marker: match[2], info: match[3].trim() };
+}
+
+/**
+ * Hard-split a single physical line that is itself longer than `limit` into
+ * pieces that each fit, preferring a break at a natural separator near the end
+ * and falling back to a hard character cut. Used only for pathologically long
+ * lines (normal queue/help lines are short).
+ *
+ * @param {string} line
+ * @param {number} limit
+ * @returns {string[]}
+ */
+function splitLongLine(line, limit) {
+  const pieces = [];
+  let remaining = line;
+  while (remaining.length > limit) {
+    let splitAt = findTelegramSplitIndex(remaining, limit);
+    if (splitAt <= 0 || splitAt > limit) splitAt = limit;
+    let piece = remaining.slice(0, splitAt);
+    if (!piece.trim()) {
+      splitAt = limit;
+      piece = remaining.slice(0, splitAt);
+    }
+    pieces.push(piece);
+    remaining = remaining.slice(splitAt);
+  }
+  if (remaining) pieces.push(remaining);
+  return pieces;
+}
+
+/**
+ * Split a (possibly oversized) Telegram message into chunks that each stay
+ * within `limit` characters.
+ *
+ * Splitting happens on line boundaries so inline Markdown entities (bold,
+ * italic, links — none of which may span a newline in Telegram's legacy
+ * Markdown) are never cut in half. Fenced code blocks, which *do* span lines,
+ * are kept valid across the split: when a break lands inside a code block the
+ * current chunk gets a closing fence appended and the next chunk re-opens the
+ * fence with the same marker and language (issue #1891).
+ *
+ * @param {string} text
+ * @param {number} [limit=TELEGRAM_TEXT_LIMIT]
+ * @returns {string[]} One or more chunks; always at least one element.
+ */
 export function splitTelegramMessageText(text, limit = TELEGRAM_TEXT_LIMIT) {
   const source = String(text ?? '');
   if (source.length <= limit) return [source];
 
+  // Reserve headroom on each physical line for a possible fence reopen/close
+  // pair so re-wrapping a code block never pushes a chunk past the limit.
+  const FENCE_HEADROOM = 16;
+  const lineLimit = Math.max(1, limit - FENCE_HEADROOM);
+
+  // Expand into physical lines, pre-splitting any line that alone exceeds the
+  // budget so the chunker below only ever deals with lines that fit.
+  const lines = [];
+  for (const raw of source.split('\n')) {
+    if (raw.length <= lineLimit) lines.push(raw);
+    else lines.push(...splitLongLine(raw, lineLimit));
+  }
+
   const chunks = [];
-  let remaining = source;
+  let current = '';
+  let openFence = null; // { indent, marker, info } while inside a code block
 
-  while (remaining.length > limit) {
-    let splitAt = findTelegramSplitIndex(remaining, limit);
-    let chunk = remaining.slice(0, splitAt).trimEnd();
+  const closeFenceLine = () => `${openFence.indent}${openFence.marker}`;
+  const reopenFenceLine = () => `${openFence.indent}${openFence.marker}${openFence.info}`;
 
-    if (!chunk) {
-      splitAt = limit;
-      chunk = remaining.slice(0, splitAt);
+  const flush = () => {
+    let chunk = current;
+    if (openFence) {
+      // Close the still-open code block at the end of this chunk.
+      chunk = chunk.length ? `${chunk}\n${closeFenceLine()}` : closeFenceLine();
     }
-
     chunks.push(chunk);
-    remaining = remaining.slice(splitAt).trimStart();
+    // Re-open the fence at the start of the next chunk so the code block (and
+    // its language) continues seamlessly.
+    current = openFence ? reopenFenceLine() : '';
+  };
+
+  for (const line of lines) {
+    const separatorLength = current.length ? 1 : 0;
+    const closeReserve = openFence ? closeFenceLine().length + 1 : 0;
+    const projected = current.length + separatorLength + line.length + closeReserve;
+
+    if (current.length > 0 && projected > limit) {
+      flush();
+    }
+
+    current = current.length ? `${current}\n${line}` : line;
+
+    const fence = parseCodeFence(line);
+    if (fence) {
+      // A fence line toggles code-block state: open when outside, close when
+      // already inside.
+      openFence = openFence ? null : fence;
+    }
+  }
+
+  // Defensive: close any fence left open by unbalanced input.
+  if (openFence && current.length) {
+    current = `${current}\n${closeFenceLine()}`;
   }
+  if (current.length || chunks.length === 0) chunks.push(current);
 
-  if (remaining) chunks.push(remaining);
   return chunks;
 }
 

package/src/telegram-solve-queue.helpers.lib.mjs

@@ -50,18 +50,18 @@ export function formatQueueItemLink(url) {
  * @param {boolean} [opts.withError] - Append `— error` when the item failed.
  * @returns {string} The formatted section (empty string when no items).
  */
-export function formatQueueHistorySection({ items, emoji, label, max, locale, withError = false }) {
+export function formatQueueHistorySection({ items, emoji, label, max, locale, withError = false, indent = '' }) {
   if (!items || items.length === 0) return '';
-  let section = `*${label}* (${items.length}):\n`;
+  let section = `${indent}*${label}* (${items.length}):\n`;
   for (const item of [...items].reverse().slice(0, max)) {
-    section += `  ${emoji} ${formatQueueItemLink(item.url)}`;
+    section += `${indent}  ${emoji} ${formatQueueItemLink(item.url)}`;
     if (withError && item.error) section += ` — ${item.error}`;
     section += '\n';
   }
   if (items.length > max) {
-    section += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+    section += `${indent}    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
   }
-  return `${section}\n`;
+  return section;
 }
 
 /**
@@ -128,25 +128,128 @@ export function collectExecutingItems({ processingItems = [], sessionItems = [],
 }
 
 /**
- * Render the per-tool "executing" lines (`▶️ link (status, elapsed)`) for the
- * detailed queue status, capped at `max` items with a localized "... and N more"
- * line (issue #1837).
+ * Render the per-tool "executing" lines for the detailed queue status as a
+ * compact, de-duplicated list (issue #1891):
+ *
+ *   `• owner/repo#number (▶️ 2h 14m 16s)`
+ *
+ * The ▶️ emoji replaces the repeated literal "processing" status word that
+ * appeared on every line in the old format. Items are listed in full by
+ * default; pass a finite `max` to cap them with a localized "... and N more"
+ * line.
  *
  * @param {object} opts
  * @param {Array} opts.items - Output of {@link collectExecutingItems}.
- * @param {number} opts.max - Maximum items to list before collapsing.
+ * @param {number} [opts.max=Infinity] - Maximum items before collapsing.
+ * @param {string|null} opts.locale - Locale for labels/durations.
+ * @param {string} [opts.label] - Optional sub-list heading (e.g. "Processing").
+ *   When set, a `  *Label* (count):` header is rendered above the items so each
+ *   status gets its own clearly-labeled list (issue #1891 follow-up).
+ * @returns {string} The formatted lines (empty string when no items).
+ */
+export function formatQueueExecutingItems({ items, max = Infinity, locale, label }) {
+  if (!items || items.length === 0) return '';
+  // Items nest one level under their section label when labeled (issue #1891).
+  const itemIndent = label ? '    ' : '  ';
+  let out = label ? `  *${label}* (${items.length}):\n` : '';
+  for (const item of items.slice(0, max)) {
+    out += `${itemIndent}• ${formatQueueItemLink(item.url)} (▶️ ${formatDuration(item.waitMs, { locale })})\n`;
+  }
+  if (items.length > max) {
+    out += `${itemIndent}  ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+  }
+  return out;
+}
+
+/**
+ * Backwards-compatible alias for {@link formatQueueExecutingItems}.
+ * @deprecated Use {@link formatQueueExecutingItems}.
+ */
+export const formatQueueProcessingItems = formatQueueExecutingItems;
+
+/**
+ * Group queue history items (completed/failed) by their `tool` key so each tool
+ * queue can render its own Completed/Failed list (issue #1891 follow-up).
+ *
+ * @param {Array<{tool?: string}>} items
+ * @returns {Object<string, Array>} Map of tool key → items.
+ */
+export function groupQueueItemsByTool(items) {
+  const byTool = {};
+  for (const item of items || []) {
+    const tool = item.tool || 'claude';
+    (byTool[tool] ||= []).push(item);
+  }
+  return byTool;
+}
+
+/**
+ * Render one tool queue's block for the detailed status as a set of *separate,
+ * individually-labeled lists* — Processing, Pending, Completed, Failed — instead
+ * of one merged bullet list (issue #1891 follow-up). Empty lists are omitted.
+ *
+ * @param {object} opts
+ * @param {string} opts.tool - Tool key (header label).
+ * @param {Array} opts.executing - Output of {@link collectExecutingItems}.
+ * @param {Array} opts.pendingItems - `{url, waitMs, waitingReason}` per pending item.
+ * @param {Array} opts.completed - Completed history items for this tool.
+ * @param {Array} opts.failed - Failed history items for this tool.
+ * @param {object} opts.labels - Localized labels (`pendingLower`, `processingLower`,
+ *   `pending`, `processing`, `completed`, `failed`).
+ * @param {number} opts.max - Max history items before the "… and N more" collapse.
+ * @param {string|null} opts.locale - Locale for labels/durations.
+ * @returns {string} The formatted block (with a trailing blank line).
+ */
+export function formatQueueToolSection({ tool, executing, pendingItems, completed, failed, labels, max, locale }) {
+  let block = `*${tool}*\n`;
+
+  // Processing list.
+  block += formatQueueExecutingItems({ items: executing, locale, label: labels.processing });
+
+  // Pending list + the shared waiting reason once (when all items agree on it).
+  block += formatQueuePendingItems({ items: pendingItems, locale, label: labels.pending });
+  const distinctReasons = [...new Set(pendingItems.map(item => item.waitingReason).filter(Boolean))];
+  if (distinctReasons.length === 1) {
+    block += `    ⏳ ${distinctReasons[0].replace(/\n+/g, '; ')}\n`;
+  }
+
+  // Completed / Failed lists for this tool (most-recent-first, capped), indented
+  // so the label sits under the tool header and items under it.
+  block += formatQueueHistorySection({ items: completed, emoji: '✅', label: labels.completed, max, locale, indent: '  ' });
+  block += formatQueueHistorySection({ items: failed, emoji: '❌', label: labels.failed, max, locale, withError: true, indent: '  ' });
+
+  return `${block}\n`;
+}
+
+/**
+ * Render the per-tool "pending/waiting" lines for the detailed queue status as a
+ * compact list (issue #1891):
+ *
+ *   `• owner/repo#number (⏳ 5m 2s)`
+ *
+ * The per-item waiting *reason* is deliberately omitted here — it is almost
+ * always identical across pending items, so the caller shows it once for the
+ * whole tool instead of repeating it on every line.
+ *
+ * @param {object} opts
+ * @param {Array<{url: string, waitMs: number}>} opts.items - Pending items.
+ * @param {number} [opts.max=Infinity] - Maximum items before collapsing.
  * @param {string|null} opts.locale - Locale for labels/durations.
+ * @param {string} [opts.label] - Optional sub-list heading (e.g. "Pending").
+ *   When set, a `  *Label* (count):` header is rendered above the items so each
+ *   status gets its own clearly-labeled list (issue #1891 follow-up).
  * @returns {string} The formatted lines (empty string when no items).
  */
-export function formatQueueProcessingItems({ items, max, locale }) {
+export function formatQueuePendingItems({ items, max = Infinity, locale, label }) {
   if (!items || items.length === 0) return '';
-  let out = '';
+  // Items nest one level under their section label when labeled (issue #1891).
+  const itemIndent = label ? '    ' : '  ';
+  let out = label ? `  *${label}* (${items.length}):\n` : '';
   for (const item of items.slice(0, max)) {
-    const label = item.queueStatus ? lt(`queue_status_${item.queueStatus}`, {}, { locale }) : lt('queue_processing', {}, { locale });
-    out += `  ▶️ ${formatQueueItemLink(item.url)} (${label}, ${formatDuration(item.waitMs, { locale })})\n`;
+    out += `${itemIndent}• ${formatQueueItemLink(item.url)} (⏳ ${formatDuration(item.waitMs, { locale })})\n`;
   }
   if (items.length > max) {
-    out += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+    out += `${itemIndent}  ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
   }
   return out;
 }

package/src/telegram-solve-queue.lib.mjs

@@ -17,7 +17,7 @@
 
 import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
 export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
-import { collectExecutingItems, formatDuration, formatQueueHistorySection, formatQueueItemLink, formatQueueProcessingItems, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems } from './telegram-solve-queue.helpers.lib.mjs';
+import { collectExecutingItems, formatDuration, formatQueueToolSection, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems, groupQueueItemsByTool } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
@@ -46,10 +46,6 @@ function appendRemainingDuration(reason, ms, locale) {
   return `${reason} (${lt('remaining', { duration: formatDuration(ms, { locale }) }, { locale })})`;
 }
 
-function queueStatusLabel(status, locale) {
-  return lt(`queue_status_${status}`, {}, { locale });
-}
-
 /**
  * Queue item representing a /solve command request
  */
@@ -1324,65 +1320,63 @@ export class SolveQueue {
 
   /**
    * Format detailed queue status for Telegram message.
-   * Groups output by tool queue (clickable links per item), then lists the
-   * Completed and Failed history as clickable links, capped per section.
    *
-   * Processing count = max(actual AI CLI processes via pgrep, tracked
-   * `$ --status` executing screen-isolated sessions), not queue state.
+   * Each tool queue renders as a set of *separate, individually-labeled lists* —
+   * Processing, Pending, Completed, Failed — instead of one merged bullet list
+   * (issue #1891). Empty lists (and fully-empty tool queues) are skipped, items
+   * render as compact `• link (emoji dur)` rows, and the shared waiting reason
+   * is shown once per tool.
    *
    * @returns {Promise<string>}
-   * @see https://github.com/link-assistant/hive-mind/issues/1159
    * @see https://github.com/link-assistant/hive-mind/issues/1267
    * @see https://github.com/link-assistant/hive-mind/issues/1837
+   * @see https://github.com/link-assistant/hive-mind/issues/1891
    */
   async formatDetailedStatus(options = {}) {
     const locale = getLocale(options);
     const stats = this.getStats();
-    const externalProcessing = await this.getExternalProcessingSnapshot(Object.keys(this.queues));
     // Currently-executing detached sessions (with issue/PR URLs). These are the
     // real running tasks; the queue's own `processing` Map is emptied once a task
     // is dispatched, so without this the executing items are never listed (#1837).
     const runningSessionItems = await this.getRunningSessionItemsFn(this.verbose);
 
-    // Get actual processing counts for each tool queue.
-    // This combines pgrep with tracked isolation status so users see detached
-    // screen-isolated work even when the direct AI CLI process count is lower.
+    // Section labels: each per-tool sub-list uses a capitalized heading.
+    const cap = s => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
+    const labels = {
+      pending: cap(lt('queue_pending', {}, { locale })),
+      processing: cap(lt('queue_processing', {}, { locale })),
+      completed: cap(lt('queue_completed', {}, { locale })),
+      failed: cap(lt('queue_failed', {}, { locale })),
+    };
+
+    // Group the (globally-capped) completed/failed history by tool so each tool
+    // queue shows its own Completed/Failed list (issue #1891 follow-up).
+    const completedByTool = groupQueueItemsByTool(this.completed);
+    const failedByTool = groupQueueItemsByTool(this.failed);
+
     let message = `📋 *${lt('solve_queue_status', {}, { locale })}*\n\n`;
+    const max = QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE;
 
-    // Show per-tool queue breakdown with items grouped by queue
-    for (const [tool, toolQueue] of Object.entries(this.queues)) {
-      const pending = toolQueue.length;
-      const processing = externalProcessing.byTool[tool] || 0;
-      message += `*${tool}* (${lt('queue_pending', {}, { locale })}: ${pending}, ${lt('queue_processing', {}, { locale })}: ${processing})\n`;
+    // Every tool with *any* activity (queued, processing, or in history) so
+    // per-tool history shows even after a tool's live queue has drained.
+    const tools = [...new Set([...Object.keys(this.queues), ...Object.keys(completedByTool), ...Object.keys(failedByTool)])];
 
-      // List the tasks this tool is actively executing as clickable links. We
-      // merge the queue's in-memory processing Map with the externally-tracked
-      // running sessions (detached screen/isolation work), deduped by URL, so
-      // executing tasks are listed even after dispatch (issue #1837).
+    for (const tool of tools) {
+      const toolQueue = this.queues[tool] || [];
+      const pending = toolQueue.length;
+      // Executing tasks: merge the in-memory processing Map with tracked
+      // detached sessions, deduped by URL, so they list even after dispatch
+      // (issue #1837).
       const executing = collectExecutingItems({ processingItems: this.processing.values(), sessionItems: runningSessionItems, tool });
-      message += formatQueueProcessingItems({ items: executing, max: QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE, locale });
-
-      // Show first queued items for this tool with clickable links
-      const displayItems = toolQueue.slice(0, QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE);
-      for (const item of displayItems) {
-        const waitTime = formatDuration(item.getWaitTime(), { locale });
-        message += `  • ${formatQueueItemLink(item.url)} (${queueStatusLabel(item.status, locale)}, ${waitTime})\n`;
-        if (item.waitingReason) {
-          message += `    └ ${item.waitingReason}\n`;
-        }
-      }
-      if (toolQueue.length > QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE) {
-        message += `    ... ${lt('queue_and_more', { count: toolQueue.length - QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE }, { locale })}\n`;
-      }
+      const completed = completedByTool[tool] || [];
+      const failed = failedByTool[tool] || [];
 
-      message += '\n';
-    }
+      // Skip tools with nothing to show in any list.
+      if (pending === 0 && executing.length === 0 && completed.length === 0 && failed.length === 0) continue;
 
-    // Completed / Failed lists - clickable links to the executed issues/PRs,
-    // most-recent-first so the newest results are easy to find (issue #1837).
-    const max = QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE;
-    message += formatQueueHistorySection({ items: this.completed, emoji: '✅', label: lt('queue_completed', {}, { locale }), max, locale });
-    message += formatQueueHistorySection({ items: this.failed, emoji: '❌', label: lt('queue_failed', {}, { locale }), max, locale, withError: true });
+      const pendingItems = toolQueue.map(item => ({ url: item.url, waitMs: item.getWaitTime(), waitingReason: item.waitingReason }));
+      message += formatQueueToolSection({ tool, executing, pendingItems, completed, failed, labels, max, locale });
+    }
 
     // Summary stats
     message += `${lt('queue_completed', {}, { locale })}: ${stats.completed}, ${lt('queue_failed', {}, { locale })}: ${stats.failed}\n`;

package/src/token-sanitization.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 /**
  * Token sanitization utilities for log content
  * Dual approach: Uses both secretlint AND custom patterns for comprehensive coverage
@@ -240,7 +241,7 @@ export const getGitHubTokensFromFiles = async () => {
  */
 export const getGitHubTokensFromCommand = async () => {
   if (typeof globalThis.use === 'undefined') {
-    globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+    await ensureUseM();
   }
   const { $ } = await globalThis.use('command-stream');
   const tokens = [];

package/src/tool-comments.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 /**
  * Centralized definitions for GitHub comments posted by solve.mjs itself
@@ -290,7 +291,7 @@ export const postTrackedCommentFromFile = async ({ $, owner, repo, targetNumber,
     throw new Error('postTrackedCommentFromFile requires a command-stream $ helper');
   }
   if (typeof globalThis.use === 'undefined') {
-    globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+    await ensureUseM();
   }
   const fs = (await globalThis.use('fs')).promises;
   let body;

package/src/use-m-bootstrap.lib.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { ensureWritableNpmGlobalPrefix } from './npm-global-prefix.lib.mjs';
+
+const defaultFetchUseMCode = async () => (await fetch('https://unpkg.com/use-m/use.js')).text();
+
+/**
+ * Load the use-m bootstrap after npm's global prefix has been made safe for
+ * use-m's Node resolver.
+ *
+ * @param {object} [options]
+ * @param {(message: string) => void} [options.log]
+ * @param {() => Promise<string>} [options.fetchUseMCode]
+ * @returns {Promise<Function>} The global use-m `use` function.
+ */
+export const ensureUseM = async (options = {}) => {
+  const { log = message => console.log(message), fetchUseMCode = defaultFetchUseMCode } = options;
+  await ensureWritableNpmGlobalPrefix({ log });
+  if (typeof globalThis.use === 'undefined') {
+    globalThis.use = (await eval(await fetchUseMCode())).use;
+  }
+  return globalThis.use;
+};

package/src/useless-tools.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 // Useless Claude Code tools and MCP servers for autonomous headless workflows.
 //
 // Hive-mind runs `claude` inside Docker with `--print --dangerously-skip-permissions`
@@ -17,7 +18,7 @@
 // Related issue: https://github.com/link-assistant/hive-mind/issues/1627
 
 if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 const fs = (await use('fs')).promises;
 const os = await use('os');

package/src/youtrack/youtrack.lib.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
+import { ensureUseM } from '../use-m-bootstrap.lib.mjs';
 // YouTrack-related utility functions
 
 // Check if use is already defined (when imported from other modules)
 // If not, fetch it (when running standalone)
 if (typeof use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 
 // Import log and other utilities from general lib