@link-assistant/hive-mind 1.78.0 → 1.78.1

package/src/interactive-mode.lib.mjs

@@ -10,6 +10,8 @@
  * - system.task_started: Agent subtask started (Issue #1450)
  * - system.task_progress: Agent subtask progress update (Issue #1450)
  * - system.task_notification: Agent subtask completed/failed (Issue #1450)
+ * - system.thinking_tokens: Accumulated thinking progress (Issue #1900)
+ * - system.status / system.compact_boundary / system.task_updated: Status lifecycle events (Issue #1900)
  * - assistant (text): AI text responses
  * - assistant (tool_use): Tool invocations
  * - user (tool_result): Tool execution results
@@ -32,7 +34,9 @@
  * @experimental
  */
 
-import { CONFIG, createCollapsible, createRawJsonSection, createRedactedRawJsonSection, escapeMarkdown, execFileAsync, formatCost, formatDuration, getToolIcon, redactImageData, safeJsonStringify, sanitizeUnicode, truncateMiddle } from './interactive-mode.shared.lib.mjs';
+import { CONFIG, createCollapsible, createRawJsonSection, createRedactedRawJsonSection, escapeMarkdown, execFileAsync, formatCost, formatDuration, getToolIcon, safeJsonStringify, sanitizeUnicode, truncateMiddle } from './interactive-mode.shared.lib.mjs';
+import { createCodexEventHandlers } from './interactive-codex-events.lib.mjs';
+import { createSystemLifecycleHandlers } from './interactive-system-events.lib.mjs';
 // Issue #1843: turn base64 image tool-results into inline PR-comment images.
 import { createImageRenderer, extractImagePayload, isImageNode } from './interactive-image-render.lib.mjs';
 // Issue #1625: track interactive-mode comment IDs so they're excluded from
@@ -108,6 +112,9 @@ export const createInteractiveHandler = options => {
     // Track active agent tasks for progress update deduplication
     // Map of task_id -> { commentId, toolUseId, description, commentIdPromise, resolveCommentId }
     pendingTasks: new Map(),
+    // Track consecutive thinking-token events so high-frequency model progress
+    // edits one live comment instead of posting hundreds of PR comments.
+    activeThinking: null,
     // Issue #1472: Diagnostic counters for tracking comment posting success/failure
     eventsProcessed: 0,
     commentsAttempted: 0,
@@ -190,10 +197,11 @@ export const createInteractiveHandler = options => {
    * @param {string} body - Comment body
    * @param {string} [toolId] - Optional tool ID for tracking pending tool calls
    * @param {string} [taskId] - Optional task ID for tracking pending agent tasks
+   * @param {Function} [onPosted] - Optional callback invoked with the posted comment ID
    * @returns {Promise<string|null>} Comment ID if successful, null if queued or failed
    * @private
    */
-  const postComment = async (body, toolId = null, taskId = null) => {
+  const postComment = async (body, toolId = null, taskId = null, onPosted = null) => {
     if (!prNumber || !owner || !repo) {
       if (verbose) {
         await log('⚠️ Interactive mode: Cannot post comment - missing PR info', { verbose: true });
@@ -210,7 +218,7 @@ export const createInteractiveHandler = options => {
 
     if (timeSinceLastComment < CONFIG.MIN_COMMENT_INTERVAL) {
       // Queue the comment for later with toolId/taskId for tracking
-      state.commentQueue.push({ body: safeBody, toolId, taskId });
+      state.commentQueue.push({ body: safeBody, toolId, taskId, onPosted });
       if (verbose) {
         await log(`📝 Interactive mode: Comment queued (${state.commentQueue.length} in queue)${toolId ? ` [tool: ${toolId}]` : ''}${taskId ? ` [task: ${taskId}]` : ''}`, { verbose: true });
       }
@@ -247,6 +255,16 @@ export const createInteractiveHandler = options => {
       // AI-authored-comment check. Tracking is a no-op when commentId is null.
       trackToolCommentId(commentId);
 
+      if (commentId && typeof onPosted === 'function') {
+        try {
+          await onPosted(commentId);
+        } catch (error) {
+          if (verbose) {
+            await log(`⚠️ Interactive mode: post-comment callback failed for ${commentId}: ${error.message}`, { verbose: true });
+          }
+        }
+      }
+
       if (verbose) {
         await log(`✅ Interactive mode: Comment posted${commentId ? ` (ID: ${commentId})` : ''} (body: ${safeBody.length} chars)`, { verbose: true });
       }
@@ -325,9 +343,9 @@ export const createInteractiveHandler = options => {
 
       const queueItem = state.commentQueue.shift();
       if (queueItem) {
-        const { body, toolId, taskId } = queueItem;
+        const { body, toolId, taskId, onPosted } = queueItem;
         // Post the comment (don't pass toolId/taskId to avoid re-queueing)
-        const commentId = await postComment(body);
+        const commentId = await postComment(body, null, null, onPosted);
 
         // If this was a tool use comment, update the pending call with the comment ID
         if (toolId && commentId) {
@@ -1092,6 +1110,20 @@ ${createRawJsonSection(data)}`;
     }
   };
 
+  const { handleThinkingTokens, finalizeThinkingGroup, handleSystemStatus, handleCompactBoundary, handleTaskUpdated } = createSystemLifecycleHandlers({
+    state,
+    owner,
+    repo,
+    prNumber,
+    log,
+    verbose,
+    postComment,
+    editComment,
+    processQueue,
+    handleTaskProgress,
+    handleTaskNotification,
+  });
+
   /**
    * Handle rate_limit_event (silently logged, no comment created)
    * @param {Object} data - Event data
@@ -1104,153 +1136,12 @@ ${createRawJsonSection(data)}`;
     }
   };
 
-  const handleCodexThreadStarted = async data => {
-    if (state.sessionId) return;
-
-    state.sessionId = data.thread_id || data.session_id || null;
-    state.startTime = Date.now();
-
-    const comment = `## 🚀 ${INTERACTIVE_SESSION_STARTED_MARKER}
-
-| Property | Value |
-|----------|-------|
-| **Session ID** | \`${state.sessionId || 'unknown'}\` |
-| **Model** | \`${data.model || 'unknown'}\` |
-| **Tool** | \`codex\` |
-
----
-
-${createRawJsonSection(data)}`;
-
-    await postComment(comment);
-  };
-
-  const handleCodexAgentMessage = async data => {
-    const text = data.item?.text;
-    if (typeof text !== 'string' || !text.trim()) return;
-    await handleAssistantText(data, text);
-  };
-
-  const handleCodexTodoList = async data => {
-    const items = Array.isArray(data.item?.items) ? data.item.items : [];
-    const todosPreview = items.length > 0 ? items.map(todo => `- [${todo?.completed ? 'x' : ' '}] ${todo?.text || ''}`).join('\n') : '_No tasks_';
-    const completedCount = items.filter(todo => todo?.completed).length;
-
-    const comment = `## 📋 Codex todo list
-
-${createCollapsible(`📋 Todos (${completedCount}/${items.length} items)`, todosPreview, true)}
-
----
-
-${createRawJsonSection(data)}`;
-
-    await postComment(comment);
-  };
-
-  const handleCodexCommandExecution = async data => {
-    const item = data.item || {};
-    const command = item.command || '';
-    const output = item.aggregated_output || '';
-    const status = item.status || (data.type === 'item.completed' ? 'completed' : data.type === 'item.updated' ? 'updated' : 'started');
-    const body = `## 💻 Codex command execution
-
-**Status:** \`${status}\`
-${command ? '\n' + createCollapsible('📋 Executed command', '```bash\n' + escapeMarkdown(command) + '\n```', true) : ''}
-${output ? '\n\n' + createCollapsible('📤 Output', '```\n' + escapeMarkdown(truncateMiddle(output, { maxLines: 60, keepStart: 25, keepEnd: 25 })) + '\n```', true) : ''}
-
----
-
-${createRawJsonSection(data)}`;
-    await postComment(body);
-  };
-
-  const handleCodexMcpToolCall = async data => {
-    const item = data.item || {};
-    const summary = [`**Server:** \`${item.server || 'unknown'}\``, `**Tool:** \`${item.tool || 'unknown'}\``, `**Status:** \`${item.status || 'unknown'}\``].join('\n');
-    const details = item.arguments != null ? createCollapsible('📥 Arguments', '```json\n' + safeJsonStringify(item.arguments, 2) + '\n```', true) : '';
-    // Issue #1843: render MCP-result images inline; base64 is redacted from JSON below.
-    const imagesSection = await imageRenderer.section([item.result], `${item.tool || 'mcp'} image`);
-    const imagesBlock = imagesSection ? '\n\n' + imagesSection : '';
-    const resultSection = item.result != null ? '\n\n' + createCollapsible('📤 Result', '```json\n' + safeJsonStringify(redactImageData(item.result), 2) + '\n```', false) : '';
-    const errorSection = item.error != null ? '\n\n' + createCollapsible('❌ Error', '```json\n' + safeJsonStringify(item.error, 2) + '\n```', true) : '';
-
-    await postComment(`## 🔌 Codex MCP tool call
-
-${summary}
-${details}${resultSection}${imagesBlock}${errorSection}
-
----
-
-${createRedactedRawJsonSection(data)}`);
-  };
-
-  const handleCodexWebSearch = async data => {
-    const item = data.item || {};
-    await postComment(`## 🌐 Codex web search
-
-**Query:** ${escapeMarkdown(item.query || 'unknown')}
-${item.action ? `\n**Action:** \`${item.action}\`` : ''}
-
----
-
-${createRawJsonSection(data)}`);
-  };
-
-  const handleCodexFileChange = async data => {
-    const item = data.item || {};
-    const changes = Array.isArray(item.changes) ? item.changes.map(change => `- \`${change?.kind || 'change'}\` ${change?.path || ''}`).join('\n') : '_No changes listed_';
-    await postComment(`## 📝 Codex file changes
-
-**Status:** \`${item.status || 'unknown'}\`
-${createCollapsible('📄 Files', changes, true)}
-
----
-
-${createRawJsonSection(data)}`);
-  };
-
-  const handleCodexCollabToolCall = async data => {
-    const item = data.item || {};
-    const prompt = item.prompt || item.description || `${item.tool || 'collab_tool_call'} via codex`;
-    await postComment(`## 🤝 Codex collab/sub-agent call
-
-**Tool:** \`${item.tool || 'unknown'}\`
-**Status:** \`${item.status || 'unknown'}\`
-${createCollapsible('📝 Prompt', escapeMarkdown(truncateMiddle(prompt, { maxLines: 30, keepStart: 12, keepEnd: 12 })), true)}
-
----
-
-${createRawJsonSection(data)}`);
-  };
-
-  const handleCodexTurnCompleted = async data => {
-    const usage = data.usage || {};
-    let usageSection = '| Type | Count |\n|------|-------|\n';
-    usageSection += `| Input | ${(usage.input_tokens || 0).toLocaleString()} |\n`;
-    usageSection += `| Cache Read | ${(usage.cached_input_tokens || 0).toLocaleString()} |\n`;
-    usageSection += `| Output | ${(usage.output_tokens || 0).toLocaleString()} |\n`;
-
-    await postComment(`## ✅ Codex turn completed
-
-### 📊 Token Usage
-
-${usageSection}
-
----
-
-${createRawJsonSection(data)}`);
-  };
-
-  const handleCodexError = async data => {
-    const message = data.message || data.error?.message || 'Unknown Codex error';
-    await postComment(`## ❌ Codex error
-
-${createCollapsible('View error', escapeMarkdown(message), true)}
-
----
-
-${createRawJsonSection(data)}`);
-  };
+  const { handleCodexThreadStarted, handleCodexAgentMessage, handleCodexTodoList, handleCodexCommandExecution, handleCodexMcpToolCall, handleCodexWebSearch, handleCodexFileChange, handleCodexCollabToolCall, handleCodexTurnCompleted, handleCodexError } = createCodexEventHandlers({
+    state,
+    postComment,
+    handleAssistantText,
+    imageRenderer,
+  });
 
   /**
    * Handle unrecognized event types
@@ -1285,6 +1176,11 @@ ${createRawJsonSection(data)}`;
     }
     state.eventsProcessed++;
 
+    const isThinkingTokenEvent = data.type === 'system' && data.subtype === 'thinking_tokens';
+    if (!isThinkingTokenEvent) {
+      await finalizeThinkingGroup();
+    }
+
     // Handle events without type as unrecognized
     if (!data.type) {
       await handleUnrecognized(data);
@@ -1301,6 +1197,14 @@ ${createRawJsonSection(data)}`;
           await handleTaskProgress(data);
         } else if (data.subtype === 'task_notification') {
           await handleTaskNotification(data);
+        } else if (data.subtype === 'thinking_tokens') {
+          await handleThinkingTokens(data);
+        } else if (data.subtype === 'status') {
+          await handleSystemStatus(data);
+        } else if (data.subtype === 'compact_boundary') {
+          await handleCompactBoundary(data);
+        } else if (data.subtype === 'task_updated') {
+          await handleTaskUpdated(data);
         } else {
           // Unknown system subtype
           await handleUnrecognized(data);
@@ -1392,6 +1296,7 @@ ${createRawJsonSection(data)}`;
    * @returns {Promise<void>}
    */
   const flush = async () => {
+    await finalizeThinkingGroup();
     await processQueue();
   };
 
@@ -1417,6 +1322,11 @@ ${createRawJsonSection(data)}`;
       handleTaskStarted,
       handleTaskProgress,
       handleTaskNotification,
+      handleThinkingTokens,
+      finalizeThinkingGroup,
+      handleSystemStatus,
+      handleCompactBoundary,
+      handleTaskUpdated,
       handleRateLimitEvent,
       handleUnrecognized,
       handleCodexThreadStarted,

package/src/interactive-mode.shared.lib.mjs

@@ -7,6 +7,7 @@ export { sanitizeUnicode };
 
 export const CONFIG = {
   MIN_COMMENT_INTERVAL: 5000,
+  MIN_THINKING_COMMENT_UPDATE_INTERVAL: 60000,
   MAX_LINES_BEFORE_TRUNCATION: 50,
   LINES_TO_KEEP_START: 20,
   LINES_TO_KEEP_END: 20,

package/src/interactive-system-events.lib.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+import { CONFIG, createRawJsonSection, formatDuration, safeJsonStringify } from './interactive-mode.shared.lib.mjs';
+
+const isFiniteNumber = value => typeof value === 'number' && Number.isFinite(value);
+
+const formatNumber = value => (isFiniteNumber(value) ? value.toLocaleString() : 'unknown');
+
+const formatSignedNumber = value => {
+  if (!isFiniteNumber(value)) return 'unknown';
+  return `${value > 0 ? '+' : ''}${value.toLocaleString()}`;
+};
+
+const pluralize = (count, singular, plural = `${singular}s`) => `${count} ${count === 1 ? singular : plural}`;
+
+const formatThinkingDuration = ms => {
+  if (!isFiniteNumber(ms) || ms < 1000) return 'a moment';
+
+  const totalSeconds = Math.max(1, Math.round(ms / 1000));
+  if (totalSeconds < 60) return pluralize(totalSeconds, 'second');
+
+  const totalMinutes = Math.max(1, Math.round(totalSeconds / 60));
+  if (totalMinutes < 60) return pluralize(totalMinutes, 'minute');
+
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return [pluralize(hours, 'hour'), minutes > 0 ? pluralize(minutes, 'minute') : ''].filter(Boolean).join(' ');
+};
+
+const getThinkingStats = events => {
+  const latest = events[events.length - 1] || {};
+  const estimatedTokens = isFiniteNumber(latest.estimated_tokens) ? latest.estimated_tokens : null;
+  const totalDelta = events.reduce((sum, event) => (isFiniteNumber(event.estimated_tokens_delta) ? sum + event.estimated_tokens_delta : sum), 0);
+  const latestDelta = isFiniteNumber(latest.estimated_tokens_delta) ? latest.estimated_tokens_delta : null;
+  return { estimatedTokens, totalDelta, latestDelta };
+};
+
+const buildThinkingComment = (thinking, { final = false } = {}) => {
+  const events = thinking.events;
+  const stats = getThinkingStats(events);
+  const elapsedMs = Math.max(0, thinking.lastEventTime - thinking.firstEventTime);
+  const header = final ? `## 🧠 Thought for ${formatThinkingDuration(elapsedMs)}.` : '## 🧠 Thinking...';
+  const summary = [`${formatNumber(stats.estimatedTokens)} estimated thinking tokens`, pluralize(events.length, 'thinking-token event'), `${formatSignedNumber(stats.totalDelta)} total delta`].join(' | ');
+  const latestDelta = stats.latestDelta == null ? 'unknown' : formatSignedNumber(stats.latestDelta);
+
+  return `${header}
+
+${summary}
+
+| Metric | Value |
+|--------|-------|
+| **Estimated tokens** | ${formatNumber(stats.estimatedTokens)} |
+| **Latest delta** | ${latestDelta} |
+| **Events grouped** | ${events.length.toLocaleString()} |
+| **Elapsed** | ${formatDuration(elapsedMs)} |
+
+---
+
+${createRawJsonSection(events)}`;
+};
+
+const waitForCommentId = async commentIdPromise => {
+  let timeoutId;
+  const timeoutPromise = new Promise(resolve => {
+    timeoutId = setTimeout(() => resolve(null), 15000);
+  });
+  const commentId = await Promise.race([commentIdPromise, timeoutPromise]);
+  clearTimeout(timeoutId);
+  return commentId;
+};
+
+export const createSystemLifecycleHandlers = ({ state, owner, repo, prNumber, log, verbose, postComment, editComment, processQueue, handleTaskProgress, handleTaskNotification }) => {
+  const resolveThinkingCommentId = async thinking => {
+    if (thinking.commentId) return thinking.commentId;
+    if (!prNumber || !owner || !repo) return null;
+
+    if (state.commentQueue.length > 0) {
+      const wasProcessing = state.isProcessing;
+      state.isProcessing = false;
+      await processQueue();
+      state.isProcessing = wasProcessing;
+    }
+
+    if (thinking.commentId) return thinking.commentId;
+    if (!thinking.commentIdPromise) return null;
+    return waitForCommentId(thinking.commentIdPromise);
+  };
+
+  const rememberThinkingComment = thinking => commentId => {
+    thinking.commentId = commentId;
+    if (thinking.resolveCommentId) thinking.resolveCommentId(commentId);
+  };
+
+  const handleThinkingTokens = async data => {
+    const now = Date.now();
+    let thinking = state.activeThinking;
+
+    if (!thinking) {
+      let resolveCommentId;
+      const commentIdPromise = new Promise(resolve => {
+        resolveCommentId = resolve;
+      });
+      thinking = {
+        commentId: null,
+        commentIdPromise,
+        resolveCommentId,
+        events: [],
+        firstEventTime: now,
+        lastEventTime: now,
+        lastEditTime: now,
+      };
+      state.activeThinking = thinking;
+    }
+
+    thinking.events.push(data);
+    thinking.lastEventTime = now;
+
+    if (thinking.events.length === 1) {
+      const rememberComment = rememberThinkingComment(thinking);
+      const commentId = await postComment(buildThinkingComment(thinking), null, null, rememberComment);
+      if (commentId) rememberComment(commentId);
+      if (verbose) {
+        await log(`🧠 Interactive mode: Thinking started (${formatNumber(data.estimated_tokens)} estimated tokens)`, { verbose: true });
+      }
+      return;
+    }
+
+    if (now - thinking.lastEditTime >= CONFIG.MIN_THINKING_COMMENT_UPDATE_INTERVAL) {
+      const commentId = await resolveThinkingCommentId(thinking);
+      if (commentId) {
+        await editComment(commentId, buildThinkingComment(thinking));
+        thinking.lastEditTime = now;
+      }
+    }
+  };
+
+  const finalizeThinkingGroup = async () => {
+    const thinking = state.activeThinking;
+    if (!thinking) return;
+
+    state.activeThinking = null;
+    const commentId = await resolveThinkingCommentId(thinking);
+    if (commentId) await editComment(commentId, buildThinkingComment(thinking, { final: true }));
+
+    if (verbose) {
+      await log(`🧠 Interactive mode: Thinking finished after ${formatThinkingDuration(thinking.lastEventTime - thinking.firstEventTime)} (${thinking.events.length} events)`, {
+        verbose: true,
+      });
+    }
+  };
+
+  const handleSystemStatus = async data => {
+    if (verbose) await log(`ℹ️ Interactive mode: System status ${data.status || 'unknown'}`, { verbose: true });
+  };
+
+  const handleCompactBoundary = async data => {
+    const metadata = data.compact_metadata || {};
+    const trigger = metadata.trigger || 'unknown';
+    const preTokens = isFiniteNumber(metadata.pre_tokens) ? metadata.pre_tokens : null;
+    const postTokens = isFiniteNumber(metadata.post_tokens) ? metadata.post_tokens : null;
+    const reduction = preTokens != null && postTokens != null ? preTokens - postTokens : null;
+    const durationText = isFiniteNumber(metadata.duration_ms) ? formatDuration(metadata.duration_ms) : 'unknown';
+
+    await postComment(`## 🧭 Context compacted
+
+| Metric | Value |
+|--------|-------|
+| **Trigger** | \`${trigger}\` |
+| **Before** | ${formatNumber(preTokens)} tokens |
+| **After** | ${formatNumber(postTokens)} tokens |
+| **Reduction** | ${formatNumber(reduction)} tokens |
+| **Duration** | ${durationText} |
+
+---
+
+${createRawJsonSection(data)}`);
+  };
+
+  const handleTaskUpdated = async data => {
+    const taskId = data.task_id;
+    const patch = data.patch && typeof data.patch === 'object' ? data.patch : {};
+    const pendingTask = state.pendingTasks.get(taskId);
+
+    if (!pendingTask) {
+      if (verbose) {
+        await log(`🤖 Interactive mode: Task update for unknown task ${taskId || 'unknown'}: ${safeJsonStringify(patch)}`, { verbose: true });
+      }
+      return;
+    }
+
+    const status = patch.status || data.status;
+    if (status) {
+      await handleTaskNotification({
+        ...data,
+        status,
+        summary: data.summary || data.description || patch.summary || `Task ${status}`,
+        usage: data.usage || patch.usage || {},
+      });
+      return;
+    }
+
+    if (patch.description || data.description || patch.last_tool_name || data.last_tool_name || patch.usage || data.usage) {
+      await handleTaskProgress({
+        ...data,
+        subtype: 'task_progress',
+        description: patch.description || data.description || pendingTask.lastProgressDescription || pendingTask.description,
+        usage: data.usage || patch.usage || {},
+        last_tool_name: patch.last_tool_name || data.last_tool_name || '',
+      });
+      return;
+    }
+
+    pendingTask.allEvents.push(data);
+    if (verbose) await log(`🤖 Interactive mode: Task update recorded for ${taskId}: ${safeJsonStringify(patch)}`, { verbose: true });
+  };
+
+  return {
+    handleThinkingTokens,
+    finalizeThinkingGroup,
+    handleSystemStatus,
+    handleCompactBoundary,
+    handleTaskUpdated,
+  };
+};

package/src/isolation-runner.lib.mjs

@@ -1,3 +1,4 @@
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 /**
  * Isolation Runner for Telegram bot
  *
@@ -19,7 +20,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 if (typeof use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 
 const { $ } = await use('command-stream');

package/src/lenv-reader.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 /**
  * lenv-reader.lib.mjs - LINO-based environment configuration reader
@@ -30,7 +31,7 @@
  */
 
 if (typeof use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 
 const linoModule = await use('links-notation');

package/src/lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 // Shared library functions for hive-mind project
 
@@ -32,7 +33,7 @@ try {
 // Check if use is already defined (when imported from solve.mjs)
 // If not, fetch it (when running standalone)
 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;

package/src/lino.lib.mjs

@@ -1,5 +1,6 @@
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 if (typeof use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 
 // Issue #1710: hosted CI npm-install flake — retry once on a corrupt install.

package/src/local-ci-checks.lib.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 /**
  * Local CI Checks Module
@@ -6,7 +7,7 @@
  */
 
 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 use('command-stream');

package/src/log-upload.lib.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 // Log upload module for hive-mind
 // Uses gh-upload-log for uploading log files to GitHub
 
 // Use use-m to dynamically import modules for cross-runtime compatibility
 if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 const use = globalThis.use;
 

package/src/memory-check.mjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 
 // Check if use is already defined (when imported from solve.mjs)
 // If not, fetch it (when running standalone)
 if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 const use = globalThis.use;
 const { getLinoYargsFactory, hideBin, parseCliArgumentsWithLino } = await import('./cli-arguments.lib.mjs');

package/src/models/index.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ensureUseM } from '../use-m-bootstrap.lib.mjs';
 
 /**
  * Unified models module for hive-mind
@@ -18,7 +19,7 @@ import { promisify } from 'node:util';
 // Check if use is already defined (when imported from solve.mjs)
 // If not, fetch it (when running standalone)
 if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+  await ensureUseM();
 }
 
 import { log } from '../lib.mjs';