@link-assistant/hive-mind 1.56.8 → 1.56.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.56.10
+
+### Patch Changes
+
+- e2f9a37: Fix duplicated yargs choice values in Telegram validation errors.
+
+## 1.56.9
+
+### Patch Changes
+
+- 94448c3: Fix screen-isolated work-session Telegram updates so executing messages stay compact and completion messages use `$ --status` start/end timestamps and exit codes.
+
 ## 1.56.8
 
 ### Patch Changes

package/package.json

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

package/src/hive.mjs

@@ -19,7 +19,8 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
     const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
     globalThis.use = use;
     const yargsModule = await use('yargs@17.7.2');
-    const yargs = yargsModule.default || yargsModule;
+    const { resolveYargsFactory } = await import('./yargs-factory.lib.mjs');
+    const yargs = resolveYargsFactory(yargsModule);
     const helpersModuleHelp = await use('yargs@17.7.2/helpers');
     const _helpersHelp = helpersModuleHelp.default || helpersModuleHelp;
     const hideBinHelp = _helpersHelp.hideBin || (argv => argv.slice(2));
@@ -71,7 +72,8 @@ if (isRunningDirectly) {
       'loading command-stream'
     );
     const yargsModule = await withTimeout(use('yargs@17.7.2'), 30000, 'loading yargs');
-    const yargs = yargsModule.default || yargsModule;
+    const { resolveYargsFactory } = await import('./yargs-factory.lib.mjs');
+    const yargs = resolveYargsFactory(yargsModule);
     const helpersModuleMain = await withTimeout(use('yargs@17.7.2/helpers'), 30000, 'loading yargs helpers');
     const _helpersMain = helpersModuleMain.default || helpersModuleMain;
     const hideBin = _helpersMain.hideBin || (argv => argv.slice(2));

package/src/memory-check.mjs

@@ -6,6 +6,7 @@ if (typeof globalThis.use === 'undefined') {
   globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
 }
 const use = globalThis.use;
+const { resolveYargsFactory } = await import('./yargs-factory.lib.mjs');
 
 // Temporarily unset CI to avoid command-stream trace logs
 const originalCI = process.env.CI;
@@ -18,7 +19,7 @@ const { $ } = await use('command-stream');
 const $silent = $({ mirror: false, capture: true });
 
 const yargsModule = await use('yargs@17.7.2');
-const yargs = yargsModule.default || yargsModule;
+const yargs = resolveYargsFactory(yargsModule);
 const helpersModule = await use('yargs@17.7.2/helpers');
 // Node 24 CJS/ESM interop may return the whole module object instead of named exports directly
 const _helpers = helpersModule.default || helpersModule;

package/src/session-monitor.lib.mjs

@@ -17,6 +17,9 @@
 
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
+import { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
+
+export { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
 
 const exec = promisify(execCallback);
 
@@ -201,6 +204,7 @@ export async function monitorSessions(bot, verbose = false) {
   for (const { sessionName, sessionInfo } of sessions) {
     let stillRunning;
     let exitCode = null;
+    let statusResult = null;
 
     if (sessionInfo.isolationBackend && sessionInfo.sessionId) {
       // Isolation mode: use $ --status, with screen -ls only as a fallback
@@ -209,6 +213,7 @@ export async function monitorSessions(bot, verbose = false) {
       const state = await getIsolationSessionState(sessionName, sessionInfo, { verbose });
       stillRunning = state.running;
       exitCode = state.exitCode;
+      statusResult = state.statusResult;
     } else {
       // Issue #1586: Non-isolation screen sessions cannot reliably detect
       // completion because start-screen keeps the screen alive via `exec bash`.
@@ -233,21 +238,14 @@ export async function monitorSessions(bot, verbose = false) {
       console.log(`Session ${sessionName} has finished. Sending notification to chat ${sessionInfo.chatId}`);
 
       try {
-        const endTime = new Date();
-        const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
-        const duration = Math.round((endTime - startTime) / 1000);
-        const minutes = Math.floor(duration / 60);
-        const seconds = duration % 60;
-
-        const statusEmoji = exitCode === null || exitCode === 0 ? '✅' : '❌';
-        const statusText = exitCode === null || exitCode === 0 ? 'Completed' : `Failed (exit code: ${exitCode})`;
-        const isolationInfo = sessionInfo.isolationBackend ? `\n🔒 Isolation: ${sessionInfo.isolationBackend}` : '';
-
-        let message = `${statusEmoji} *Work Session ${statusText}*\n\n`;
-        message += `📊 Session: \`${sessionName}\`\n`;
-        message += `⏱️ Duration: ${minutes}m ${seconds}s\n`;
-        message += `🔗 URL: ${sessionInfo.url}${isolationInfo}\n\n`;
-        message += `The work session has finished. You can now review the results.`;
+        const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+        const message = formatSessionCompletionMessage({
+          sessionName,
+          sessionInfo,
+          statusResult,
+          observedEndTime: new Date(),
+          exitCode: finalExitCode,
+        });
 
         // Update the original reply message if messageId is available, otherwise send new message
         if (sessionInfo.messageId) {
@@ -256,7 +254,7 @@ export async function monitorSessions(bot, verbose = false) {
           await bot.telegram.sendMessage(sessionInfo.chatId, message, { parse_mode: 'Markdown' });
         }
 
-        completeSession(sessionName, exitCode || 0, verbose);
+        completeSession(sessionName, finalExitCode || 0, verbose);
       } catch (error) {
         console.error(`Failed to send completion notification for ${sessionName}:`, error);
         completeSession(sessionName, 1, verbose);

package/src/solve.config.lib.mjs

@@ -10,6 +10,7 @@
 import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.lib.mjs';
 import { defaultModels, buildModelOptionDescription, resolveDefaultFallbackModel, resolveRuntimeDefaultModel } from './models/index.mjs';
 import { validateBranchName } from './solve.branch.lib.mjs';
+import { resolveYargsFactory } from './yargs-factory.lib.mjs';
 
 // Re-export for use by telegram-bot.mjs (avoids extra import lines there)
 export { detectMalformedFlags };
@@ -18,7 +19,7 @@ export { detectMalformedFlags };
 export const initializeConfig = async use => {
   // Import yargs with specific version for hideBin support
   const yargsModule = await use('yargs@17.7.2');
-  const yargs = yargsModule.default || yargsModule;
+  const yargs = resolveYargsFactory(yargsModule);
   const helpersModule = await use('yargs@17.7.2/helpers');
   // Node 24 CJS/ESM interop may return the whole module object instead of named exports directly
   const helpers = helpersModule.default || helpersModule;

package/src/telegram-bot.mjs

@@ -25,13 +25,14 @@ const dotenvxModule = await use('@dotenvx/dotenvx');
 const dotenvx = dotenvxModule.default || dotenvxModule;
 const getenvModule = await use('getenv');
 const getenv = typeof getenvModule === 'function' ? getenvModule : getenvModule.default || getenvModule;
+const { resolveYargsFactory } = await import('./yargs-factory.lib.mjs');
 
 // Load .env/.lenv configuration (issue #1318)
 dotenvx.config({ quiet: true, ignore: ['MISSING_ENV_FILE'] });
 await loadLenvConfig({ override: true, quiet: true });
 
 const yargsModule = await use('yargs@17.7.2');
-const yargs = yargsModule.default || yargsModule;
+const yargs = resolveYargsFactory(yargsModule);
 const helpersModuleBot = await use('yargs@17.7.2/helpers');
 const _helpersBot = helpersModuleBot.default || helpersModuleBot;
 const hideBin = _helpersBot.hideBin || (argv => argv.slice(2));
@@ -50,6 +51,7 @@ const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STO
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
 const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
+const { formatExecutingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 
 const config = yargs(hideBin(process.argv))
   .usage('Usage: hive-telegram-bot [options]')
@@ -559,14 +561,11 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
     }
   };
   const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
-  let result,
-    session,
-    extraInfo = '';
+  let result, session;
   if (iso) {
     session = iso.runner.generateSessionId();
     VERBOSE && console.log(`[VERBOSE] Using isolation (${iso.backend}), session: ${session}`);
     result = await iso.runner.executeWithIsolation(commandName, args, { backend: iso.backend, sessionId: session, verbose: VERBOSE });
-    extraInfo = `\n🔒 Isolation: \`${iso.backend}\``;
     if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session, tool }, VERBOSE);
   } else {
     result = await executeStartScreen(commandName, args);
@@ -579,8 +578,16 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
     if (result.success && session !== 'unknown') trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool }, VERBOSE);
   }
   if (result.warning) return safeEdit(`⚠️  ${result.warning}`);
-  if (result.success) await safeEdit(`🔄 ${commandName.charAt(0).toUpperCase() + commandName.slice(1)} command executing...\n\nStatus: \`Executing...\`\n📊 Session: \`${session}\`${extraInfo}\n\n${infoBlock}\n\n🔔 This message will update when the session finishes.`);
-  else await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``);
+  if (result.success) {
+    await safeEdit(
+      formatExecutingWorkSessionMessage({
+        commandName,
+        sessionName: session,
+        isolationBackend: iso?.backend || null,
+        infoBlock,
+      })
+    );
+  } else await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``);
 }
 
 bot.command('help', async ctx => {

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

@@ -20,6 +20,7 @@ export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, ge
 import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningProcesses } 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 } from './work-session-formatting.lib.mjs';
 
 export const QueueItemStatus = {
   QUEUED: 'queued',
@@ -1145,8 +1146,12 @@ export class SolveQueue {
               if (result.warning) {
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, `⚠️ ${result.warning}`, { parse_mode: 'Markdown' });
               } else if (result.success) {
-                const isolationInfo = result.isolationBackend ? `\n🔒 Isolation: \`${result.isolationBackend}\`` : '';
-                const response = `🔄 Solve command executing...\n\nStatus: \`Executing...\`\n📊 Session: \`${sessionName}\`${isolationInfo}\n\n${item.infoBlock}\n\n🔔 This message will update when the session finishes.`;
+                const response = formatExecutingWorkSessionMessage({
+                  commandName: item.command || 'solve',
+                  sessionName,
+                  isolationBackend: result.isolationBackend,
+                  infoBlock: item.infoBlock,
+                });
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               } else {
                 const response = `❌ Error executing solve command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``;

package/src/work-session-formatting.lib.mjs

@@ -0,0 +1,72 @@
+const FAILURE_STATUSES = new Set(['failed', 'cancelled', 'canceled', 'error']);
+
+function capitalizeCommandName(commandName) {
+  const normalized = commandName || 'solve';
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+
+function parseDateValue(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function normalizeExitCode(value) {
+  if (value === null || value === undefined) return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+export function getSessionCompletionExitCode({ exitCode = null, statusResult = null } = {}) {
+  const explicitExitCode = normalizeExitCode(exitCode);
+  if (explicitExitCode !== null) return explicitExitCode;
+
+  const statusExitCode = normalizeExitCode(statusResult?.exitCode);
+  if (statusExitCode !== null) return statusExitCode;
+
+  const status = String(statusResult?.status || '').toLowerCase();
+  if (FAILURE_STATUSES.has(status)) return 1;
+
+  return null;
+}
+
+export function formatSessionDurationSeconds(seconds) {
+  const totalSeconds = Math.max(0, Math.round(Number(seconds) || 0));
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const remainingSeconds = totalSeconds % 60;
+  const parts = [];
+
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (remainingSeconds > 0 || parts.length === 0) parts.push(`${remainingSeconds}s`);
+
+  return parts.join(' ');
+}
+
+export function formatExecutingWorkSessionMessage({ commandName = 'solve', sessionName = 'unknown', isolationBackend = null, infoBlock = '' } = {}) {
+  const isolationInfo = isolationBackend ? `\n🔒 Isolation: \`${isolationBackend}\`` : '';
+  const details = infoBlock ? `\n\n${infoBlock}` : '';
+  return `⏳ ${capitalizeCommandName(commandName)} command executing...\n\n📊 Session: \`${sessionName}\`${isolationInfo}${details}`;
+}
+
+export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null } = {}) {
+  const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+  const failed = finalExitCode !== null && finalExitCode !== 0;
+  const statusEmoji = failed ? '❌' : '✅';
+  const statusText = failed ? `Failed (exit code: ${finalExitCode})` : 'Completed';
+  const isolationInfo = sessionInfo?.isolationBackend ? `\n🔒 Isolation: ${sessionInfo.isolationBackend}` : '';
+  const startTime = parseDateValue(statusResult?.startTime) || parseDateValue(sessionInfo?.startTime) || observedEndTime;
+  const endTime = parseDateValue(statusResult?.endTime) || observedEndTime;
+  const durationSeconds = Math.max(0, (endTime.getTime() - startTime.getTime()) / 1000);
+
+  let message = `${statusEmoji} *Work Session ${statusText}*\n\n`;
+  message += `📊 Session: \`${sessionName || 'unknown'}\`\n`;
+  message += `⏱️ Duration: ${formatSessionDurationSeconds(durationSeconds)}\n`;
+  message += `🔗 URL: ${sessionInfo?.url || 'unknown'}${isolationInfo}\n\n`;
+  message += 'The work session has finished. You can now review the results.';
+
+  return message;
+}

package/src/yargs-factory.lib.mjs

@@ -0,0 +1,17 @@
+// Resolve use-m's yargs import to the fresh parser factory.
+//
+// In the use-m yargs@17.7.2 shape, the module object is the factory that
+// creates independent parser instances, while module.default is a singleton
+// wrapper. Reusing the singleton accumulates options and duplicates choice
+// values in validation errors.
+export function resolveYargsFactory(yargsModule) {
+  if (typeof yargsModule === 'function' && typeof yargsModule.getInternalMethods === 'function') {
+    return yargsModule;
+  }
+
+  const candidate = yargsModule?.default || yargsModule;
+  if (typeof candidate !== 'function') {
+    throw new TypeError('Unable to resolve yargs factory from imported module');
+  }
+  return candidate;
+}