@link-assistant/hive-mind 2.11.13 → 2.12.1

package/src/telegram-task-command.lib.mjs

@@ -1,6 +1,7 @@
 import { buildUserMention } from './buildUserMention.lib.mjs';
 import { validateModelName } from './models/index.mjs';
 import { getLinoYargsFactory } from './cli-arguments.lib.mjs';
+import { getModelFromArgs } from './model-args.lib.mjs';
 import { createYargsConfig as createTaskYargsConfig } from './task.config.lib.mjs';
 import { createCiCdIssue } from './fix.ci-cd-issue.lib.mjs';
 import { parseFixRepository } from './fix.ci-cd.lib.mjs';
@@ -47,14 +48,6 @@ export function getTaskToolFromArgs(args) {
   return 'claude';
 }
 
-function getModelFromArgs(args) {
-  for (let i = 0; i < args.length; i++) {
-    if ((args[i] === '--model' || args[i] === '-m') && i + 1 < args.length) return args[i + 1];
-    if (args[i].startsWith('--model=')) return args[i].substring('--model='.length);
-  }
-  return null;
-}
-
 function validateTaskModel(args) {
   const model = getModelFromArgs(args);
   if (!model) return null;

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

@@ -3,9 +3,10 @@
 import { wrapUseWithRetry } from './use-with-retry.lib.mjs';
 import { wrapUseWithSingleFlight } from './use-m-single-flight.lib.mjs';
 
-export const USE_M_BOOTSTRAP_URL = 'https://unpkg.com/use-m/use.js';
-// Issue #2113: the fallback is only reached when unpkg cannot serve the `latest`
-// bundle, but until now it pinned 8.13.8 — the last release *without* any
+// Both URLs are immutable and use independent CDNs. A mutable `latest` URL
+// allowed an upstream publication to change unchanged CI runs (issue #2150).
+export const USE_M_BOOTSTRAP_URL = 'https://unpkg.com/use-m@8.15.0/use.js';
+// Issue #2113: the fallback previously pinned 8.13.8 — the last release *without* any
 // corrupt-alias self-healing. A CDN hiccup therefore silently downgraded every
 // dependency import to the least resilient loader available. 8.14.4 is the first
 // release that both repairs corrupt aliases (8.14.3, use-m #66/#67) and removes
@@ -13,10 +14,10 @@ export const USE_M_BOOTSTRAP_URL = 'https://unpkg.com/use-m/use.js';
 // upstream recovery instead of losing it. 8.15.0 (use-m #70, the report filed
 // from this issue) additionally serialises installs of one alias across
 // processes with its own `.use-m/<alias>.lock` plus a post-install marker, so
-// the pinned fallback now carries upstream prevention too — verified with the
+// the pinned bootstraps now carry upstream prevention too — verified with the
 // standalone reproduction: 8.14.4 fails 22/24 concurrent loads, 8.15.0 fails
 // 0/24 (docs/case-studies/issue-2113/raw/experiment-upstream-use-m-8.15.0-fixed.log).
-export const USE_M_BOOTSTRAP_FALLBACK_URL = 'https://unpkg.com/use-m@8.15.0/use.js';
+export const USE_M_BOOTSTRAP_FALLBACK_URL = 'https://cdn.jsdelivr.net/npm/use-m@8.15.0/use.js';
 
 const isMissingUseMBundle = code => /^Not found: \/use-m@[^/]+\/use\.js\s*$/.test(code.trim());
 

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

@@ -31,6 +31,49 @@
 const ALIAS_CLEANUP_ERROR = /^Failed to remove (?:corrupt|incomplete) npm alias '([^']+)'\.$/;
 const RETRYABLE_RM_CODES = new Set(['EBUSY', 'EMFILE', 'ENFILE', 'ENOTEMPTY', 'EPERM']);
 
+// `use-m` otherwise resolves every bare specifier through npm's mutable
+// `latest` tag at runtime. command-stream@0.19.0 changing its CommonJS entry
+// point broke unchanged Hive Mind commits in issue #2150. Keep every runtime
+// dependency reproducible; explicit versions and subpaths remain untouched.
+export const USE_M_PACKAGE_VERSIONS = Object.freeze({
+  '@dotenvx/dotenvx': '2.21.0',
+  'command-stream': '0.18.0',
+  getenv: '2.0.0',
+  'links-notation': '0.13.0',
+  'lino-arguments': '0.3.0',
+  telegraf: '4.16.3',
+  yargs: '17.7.2',
+  zx: '8.8.5',
+});
+
+export const pinUseMSpecifier = specifier => {
+  const version = USE_M_PACKAGE_VERSIONS[specifier];
+  return version ? `${specifier}@${version}` : specifier;
+};
+
+/**
+ * Undo Node 24's CommonJS namespace wrapper when `use-m` returns it verbatim.
+ *
+ * Node 23+ exposes `module.exports` as a synthetic named export alongside the
+ * default export. use-m@8.15.0 does not classify that key as namespace
+ * metadata, so a CommonJS package with no real named exports is returned as an
+ * object instead of its `module.exports` value. Requiring object identity keeps
+ * real ESM namespaces and unusual hybrid modules intact.
+ *
+ * @param {unknown} loaded
+ * @param {object} [options]
+ * @param {string} [options.specifier]
+ * @param {(message: string) => void} [options.log]
+ * @returns {unknown}
+ */
+export const normalizeCommonJsNamespace = (loaded, options = {}) => {
+  if (loaded && typeof loaded === 'object' && Object.hasOwn(loaded, 'default') && Object.hasOwn(loaded, 'module.exports') && loaded.default === loaded['module.exports']) {
+    options.log?.(`use('${options.specifier ?? 'unknown'}') normalized Node's CommonJS namespace marker`);
+    return loaded.default;
+  }
+  return loaded;
+};
+
 /**
  * @param {(specifier: string) => Promise<unknown>} use - the use-m loader.
  * @param {string} specifier - the npm specifier to load (e.g. `'getenv'`).
@@ -46,18 +89,23 @@ const RETRYABLE_RM_CODES = new Set(['EBUSY', 'EMFILE', 'ENFILE', 'ENOTEMPTY', 'E
  * @returns {Promise<unknown>} the module returned by use-m.
  */
 export const useWithRetry = async (use, specifier, options = {}) => {
+  const requestedSpecifier = specifier;
+  specifier = pinUseMSpecifier(specifier);
   const attempts = options.attempts ?? 3;
   const cleanup = options.cleanup ?? defaultCleanup;
   const sleep = options.sleep ?? defaultSleep;
   const backoffMs = options.backoffMs ?? 1000;
   const log = options.log ?? defaultLog;
   const importModule = options.importModule ?? defaultImport;
+  const installWithoutBinLinks = options.installWithoutBinLinks ?? defaultInstallWithoutBinLinks;
   const extraArgs = options.args ?? [];
+  if (requestedSpecifier !== specifier) log(`use('${requestedSpecifier}') pinned to '${specifier}'`);
   let lastError;
   let cleanedImportPath = null;
   for (let attempt = 1; attempt <= attempts; attempt++) {
     try {
-      return await use(specifier, ...extraArgs);
+      const loaded = await use(specifier, ...extraArgs);
+      return normalizeCommonJsNamespace(loaded, { specifier, log });
     } catch (error) {
       lastError = error;
       // Node's ESM loader caches *failed* module evaluations by resolved URL.
@@ -71,7 +119,7 @@ export const useWithRetry = async (use, specifier, options = {}) => {
         try {
           const recovered = await importModule(cleanedImportPath, attempt);
           log(`use('${specifier}') recovered via a cache-busted import of ${cleanedImportPath}`);
-          return recovered;
+          return normalizeCommonJsNamespace(recovered, { specifier, log });
         } catch (reimportError) {
           log(`cache-busted import of ${cleanedImportPath} also failed: ${reimportError?.message}`);
         }
@@ -82,6 +130,21 @@ export const useWithRetry = async (use, specifier, options = {}) => {
         throw error;
       }
       log(`use('${specifier}') failed on attempt ${attempt}/${attempts}: ${error?.message} — retrying`);
+      // npm gives every global alias the package's original executable names.
+      // When a pinned alias replaces use-m's former `-v-latest` alias, packages
+      // such as zx collide on `/bin/zx` even though both module directories can
+      // coexist. use-m only imports the package and does not need its CLI link,
+      // so finish the pinned install without bin links and retry the import.
+      if (requestedSpecifier !== specifier && isBinLinkInstallConflict(error)) {
+        const details = extractFailedInstallDetails(error);
+        try {
+          await installWithoutBinLinks({ specifier, globalRoot: details?.globalRoot, error });
+          log(`use('${specifier}') repaired npm's alias bin-link collision`);
+          continue;
+        } catch (repairError) {
+          log(`use('${specifier}') could not repair npm's alias bin-link collision: ${repairError?.message}`);
+        }
+      }
       // Mode 4 (issue #2092): `npm install -g` itself failed (network blip,
       // registry 5xx, DinD DNS not up yet). There is nothing to delete; just
       // back off and let npm try again.
@@ -127,6 +190,69 @@ export const isTransientInstallError = error => {
   return /^Failed to install .+ globally into /.test(message);
 };
 
+export const extractFailedInstallDetails = error => {
+  const message = typeof error?.message === 'string' ? error.message : '';
+  const match = message.match(/^Failed to install (.+?) globally into '([^']+)'(?:\.| after\b)/);
+  return match ? { specifier: match[1], globalRoot: match[2] } : null;
+};
+
+export const isBinLinkInstallConflict = error => {
+  if (!extractFailedInstallDetails(error)) return false;
+  // use-m may aggregate all npm attempts into the outer message instead of
+  // preserving stderr on the final cause, so inspect both levels.
+  const causeText = [error?.message, error?.cause?.message, error?.cause?.stderr, error?.cause?.stdout, error?.cause?.cause?.message, error?.cause?.cause?.stderr].filter(Boolean).join('\n');
+  return /\bEEXIST\b/.test(causeText) && /(?:File exists|file already exists|\/bin\/|\\bin\\)/i.test(causeText);
+};
+
+const installErrorText = error => [error?.message, error?.stderr, error?.stdout, error?.cause?.message, error?.cause?.stderr, error?.cause?.stdout, error?.cause?.cause?.message, error?.cause?.cause?.stderr].filter(Boolean).join('\n');
+
+export const extractConflictingBinPath = error => {
+  const match = installErrorText(error).match(/(?:^|\n)npm error path ([^\r\n]+)/);
+  return match?.[1]?.trim() ?? null;
+};
+
+export const aliasForUseMSpecifier = specifier => {
+  const match = specifier.match(/^(@[^/]+\/[^@/]+|[^@/]+)@(.+)$/);
+  if (!match) throw new Error(`Expected an exact npm package specifier, got '${specifier}'`);
+  const [, packageName, version] = match;
+  return `${packageName.replace('@', '').replace('/', '-')}-v-${version}`;
+};
+
+export const npmPrefixForGlobalRoot = globalRoot => {
+  if (!globalRoot) return null;
+  const normalized = globalRoot.replaceAll('\\', '/').replace(/\/$/, '');
+  if (normalized.endsWith('/lib/node_modules')) return normalized.slice(0, -'/lib/node_modules'.length);
+  if (normalized.endsWith('/node_modules')) return normalized.slice(0, -'/node_modules'.length);
+  return null;
+};
+
+export const installAliasWithoutBinLinks = async ({ specifier, globalRoot, error, runner, readlink } = {}) => {
+  const alias = aliasForUseMSpecifier(specifier);
+  const prefix = npmPrefixForGlobalRoot(globalRoot);
+  const binPath = extractConflictingBinPath(error);
+  if (!prefix || !binPath) throw new Error('Cannot safely identify the conflicting use-m package binary');
+  const { dirname, resolve, sep } = await import('node:path');
+  const readSymbolicLink = readlink ?? (await import('node:fs/promises')).readlink;
+  const target = resolve(dirname(binPath), await readSymbolicLink(binPath));
+  const [packageName] = specifier.match(/^(@[^/]+\/[^@/]+|[^@/]+)@(.+)$/)?.slice(1) ?? [];
+  const aliasPrefix = `${packageName?.replace('@', '').replace('/', '-')}-v-`;
+  const normalizedRoot = resolve(globalRoot);
+  if (!packageName || !target.startsWith(`${normalizedRoot}${sep}${aliasPrefix}`)) {
+    throw new Error(`Refusing to replace ${binPath}; it is not owned by a use-m alias for ${packageName ?? specifier}`);
+  }
+  // npm 11 still checks an existing global executable even with
+  // --no-bin-links. --force is safe here only because the symlink target was
+  // verified above as another version alias managed by use-m for this package.
+  const args = ['install', '-g', '--force', '--no-bin-links', `${alias}@npm:${specifier}`];
+  if (prefix) args.push('--prefix', prefix);
+  if (runner) return runner('npm', args);
+  const { execFile } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  return promisify(execFile)('npm', args);
+};
+
+const defaultInstallWithoutBinLinks = installAliasWithoutBinLinks;
+
 export const isCorruptInstallError = error => {
   const cause = error?.cause;
   if (cause instanceof SyntaxError) return true;

package/src/working-session-summary.lib.mjs

@@ -49,6 +49,52 @@ export const redactWorkspacePaths = text => {
   return text.replace(WORKSPACE_PATH_PATTERN, WORKSPACE_PATH_PLACEHOLDER);
 };
 
+/**
+ * Fence structured text emitted after a Markdown lead-in ending in `:`.
+ * Formal AI plan events use a root record followed by space/tab-indented Lino;
+ * GitHub otherwise collapses that layout into ordinary prose. Existing fences
+ * and ordinary Markdown are preserved, making this safe to apply at the final
+ * GitHub-comment boundary.
+ */
+export const formatWorkingSessionSummaryMarkdown = text => {
+  if (typeof text !== 'string' || !text) return text;
+
+  const lines = text.split('\n');
+  const output = [];
+  let inFence = false;
+  let previousNonEmpty = '';
+
+  for (let index = 0; index < lines.length; ) {
+    const line = lines[index];
+    if (/^\s*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      output.push(line);
+      if (line.trim()) previousNonEmpty = line;
+      index += 1;
+      continue;
+    }
+
+    if (!inFence && line.trim() && previousNonEmpty.trimEnd().endsWith(':')) {
+      let end = index;
+      while (end < lines.length && lines[end].trim()) end += 1;
+      const block = lines.slice(index, end);
+      const looksStructured = block.length >= 2 && block.some(blockLine => /^(?:\t| {2,})/.test(blockLine));
+      if (looksStructured) {
+        output.push('```text', ...block, '```');
+        previousNonEmpty = '```';
+        index = end;
+        continue;
+      }
+    }
+
+    output.push(line);
+    if (line.trim()) previousNonEmpty = line;
+    index += 1;
+  }
+
+  return output.join('\n');
+};
+
 /**
  * The line appended when the pull request still has an empty diff.
  *
@@ -62,4 +108,4 @@ export const buildNoChangesNotice = changeStats => {
   return '> ⚠️ This pull request still contains no changes - nothing was implemented yet.';
 };
 
-export default { buildNoChangesNotice, redactWorkspacePaths, WORKSPACE_PATH_PLACEHOLDER };
+export default { buildNoChangesNotice, formatWorkingSessionSummaryMarkdown, redactWorkspacePaths, WORKSPACE_PATH_PLACEHOLDER };