@link-assistant/hive-mind 1.2.3 → 1.2.5

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # @link-assistant/hive-mind
 
+## 1.2.5
+
+### Patch Changes
+
+- 65ee214: fix: Detect malformed flag patterns like "-- model" (Issue #1092)
+
+  Added `detectMalformedFlags()` function that catches malformed command-line options and provides helpful error messages:
+  - Detects "-- option" (space after --) and suggests "--option"
+  - Detects "-option" (single dash for long option) and suggests "--option"
+  - Detects "---option" (triple dash) and suggests "--option"
+  - Integrated into both Telegram bot and CLI argument parsing
+  - Added 23 comprehensive unit tests
+
+- af950c8: fix(hive): require closing keywords for PR detection
+
+  The `/hive` command was incorrectly skipping issues by reporting they had
+  PRs when those PRs only mentioned the issues without actually solving them.
+
+  **Root cause**: The `batchCheckPullRequestsForIssues` function used GitHub's
+  `CROSS_REFERENCED_EVENT` timeline items, which are created whenever a PR
+  body/title/commit mentions an issue number - regardless of whether the PR
+  actually solves the issue.
+
+  **Example**: PR #369 in VisageDvachevsky/StoryGraph is an audit PR that
+  created 28 new issues (#370-#397) and listed them in a table. This caused
+  GitHub to create cross-reference events linking that PR to all 28 issues,
+  but PR #369 only actually fixes #368.
+
+  **Solution**:
+  - Add `prClosesIssue()` function to detect GitHub closing keywords
+    (fixes, closes, resolves - case-insensitive)
+  - Update GraphQL query to include PR body text
+  - Only count PRs that contain "fixes #N", "closes #N", or "resolves #N"
+    for the specific issue number
+  - Add verbose logging when PRs are skipped for only mentioning issues
+
+  This aligns with GitHub's own auto-close behavior where only specific
+  keywords trigger issue closure when a PR is merged.
+
+  Fixes #1094
+
+- 0d997ac: fix(telegram-bot): stop solve queue on SIGINT/SIGTERM for clean exit
+
+  The telegram bot was hanging after pressing Ctrl+C because the SolveQueue
+  consumer loop kept running with active timers that prevented the Node.js
+  event loop from emptying.
+  - **Root cause identified**: The SIGINT/SIGTERM handlers only called
+    `bot.stop()` (Telegraf) but did not stop the SolveQueue, whose `sleep()`
+    timers kept the event loop alive.
+  - **Solution**: Added `solveQueue.stop()` call in both SIGINT and SIGTERM
+    handlers to stop the consumer loop before calling `bot.stop()`.
+  - **Added verbose logging**: When running with `--verbose`, the bot now
+    logs "Solve queue stopped" during shutdown.
+  - **Case study documentation**: Added detailed analysis in
+    `docs/case-studies/issue-1083/` with timeline, root cause investigation,
+    and evidence collection.
+
+  Fixes #1083
+
+## 1.2.4
+
+### Patch Changes
+
+- 14ea4b6: Add validation for LINO configuration to detect invalid input
+  - Add validation in `lenv-reader.lib.mjs` to reject multiple values on the same line (e.g., `--option1  --option2`)
+  - Add validation to reject unrecognized characters in command-line options (e.g., `?`, `@`, `!`)
+  - Errors include clear messages showing the problematic value and instructions for correction
+  - Valid option characters: letters, numbers, hyphens, underscores, equals signs
+  - Add comprehensive unit tests for LINO parsing logic (`test-lino.mjs`)
+  - Add validation tests to lenv-reader test suite (`test-lenv-reader.mjs`)
+  - Add lino tests to CI/CD workflow
+
+  This approach helps users identify and correct configuration errors early, rather than silently dropping invalid options.
+
+  Fixes #1086
+
 ## 1.2.3
 
 ### Patch Changes

package/analyze-issue.md

@@ -0,0 +1,72 @@
+# Issue #1092 Analysis: Silent Ignoring of "-- model" (with space)
+
+## The Problem
+
+When a user types `-- model` (with a space between the dashes) instead of `--model`,
+the system silently ignores it and uses the default model instead of producing an error.
+
+## Why This Happens
+
+### Argument Parsing in Shell
+
+When a shell receives the command:
+
+```bash
+solve https://github.com/owner/repo/issues/1 -- model sonnet
+```
+
+It parses this as:
+
+- `https://github.com/owner/repo/issues/1` (positional arg)
+- `-- model` (single string, NOT a flag)
+- `sonnet` (positional arg)
+
+The `"-- model"` string has a space in it, so it's not recognized as a flag by yargs.
+
+### Yargs Behavior with .strict()
+
+Yargs `.strict()` mode only rejects:
+
+1. Unknown OPTIONS (flags that start with `-` or `--`)
+2. Unknown ARGUMENTS that look like flags
+
+It does NOT reject:
+
+- Positional arguments that look similar to flag names
+- Strings like `"-- model"` (which are treated as regular positional arguments)
+
+So when yargs sees `"-- model"` as a positional argument, it:
+
+1. Doesn't match it to `--model` option
+2. Doesn't throw an error because it's not in strict "option" format
+3. Silently ignores it
+4. Uses the default model value
+
+## The Flow
+
+1. User types: `solve <url> -- model sonnet`
+2. Shell parses as: `['<url>', '-- model', 'sonnet']`
+3. Yargs receives: `{ _: ['<url>', '-- model', 'sonnet'] }`
+4. Yargs strict mode checks: Is this an unknown OPTION? No.
+5. Yargs silently accepts the positional arguments
+6. Model defaults to 'sonnet'
+7. User sees no error, but their `--model` flag was ignored
+
+## Solution Approaches
+
+1. **Detect spaced flag patterns**: Check if any positional arguments match the pattern
+   `-- <option-name>` where option-name is a known flag
+
+2. **Validate positional arguments**: After parsing, check if the remaining positional
+   arguments look like mistyped flags (start with -- or -)
+
+3. **Improve error message**: When detecting such patterns, suggest the correct format
+
+## Key Code References
+
+- `/src/solve.config.lib.mjs`: Contains yargs configuration and argument parsing
+- `/src/option-suggestions.lib.mjs`: Already has logic for suggesting similar options
+- `/src/model-validation.lib.mjs`: Validates model names
+
+The current `.strict()` mode in solve.config.lib.mjs (line 316) only catches malformed
+OPTIONS, not these kinds of subtle positional argument errors.

package/package.json

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

package/src/github.batch.lib.mjs

@@ -11,6 +11,53 @@ if (typeof globalThis.use === 'undefined') {
 import { log, cleanErrorMessage } from './lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 
+/**
+ * Check if a PR body/title indicates it fixes/closes/resolves a specific issue number
+ * GitHub auto-closes issues when PR body contains keywords like "fixes #123", "closes #123", "resolves #123"
+ * See: https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue
+ * @param {string} text - PR body or title text
+ * @param {number} issueNumber - Issue number to check for
+ * @returns {boolean} True if the text contains a closing keyword for this issue
+ */
+export function prClosesIssue(text, issueNumber) {
+  if (!text || typeof text !== 'string') {
+    return false;
+  }
+
+  // GitHub closing keywords (case-insensitive)
+  // Supports: fix, fixes, fixed, close, closes, closed, resolve, resolves, resolved
+  // Also supports variations with repository prefix like "fixes owner/repo#123"
+  const closingKeywords = ['fix', 'fixes', 'fixed', 'close', 'closes', 'closed', 'resolve', 'resolves', 'resolved'];
+
+  // Build regex pattern that matches any of the keywords followed by #N or repo#N
+  // Examples matched:
+  //   - "fixes #123"
+  //   - "Closes #123"
+  //   - "RESOLVED #123"
+  //   - "fixes owner/repo#123"
+  //   - "fix: #123" (common commit style)
+  const issueNum = issueNumber.toString();
+
+  for (const keyword of closingKeywords) {
+    // Pattern: keyword + optional colon/space + optional repo prefix + # + issue number
+    // Must be followed by word boundary (not part of larger number)
+    const patterns = [
+      // Standard format: "fixes #123"
+      new RegExp(`\\b${keyword}\\s*:?\\s*#${issueNum}\\b`, 'i'),
+      // With repo prefix: "fixes owner/repo#123"
+      new RegExp(`\\b${keyword}\\s*:?\\s*[\\w.-]+/[\\w.-]+#${issueNum}\\b`, 'i'),
+    ];
+
+    for (const pattern of patterns) {
+      if (pattern.test(text)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 /**
  * Batch fetch pull request information for multiple issues using GraphQL
  * @param {string} owner - Repository owner
@@ -34,6 +81,8 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
       const batch = issueNumbers.slice(i, i + BATCH_SIZE);
 
       // Build GraphQL query for this batch
+      // Issue #1094: Include PR body to check for "fixes/closes/resolves #N" keywords
+      // This prevents false positives from PRs that only mention issues without solving them
       const query = `
         query GetPullRequestsForIssues {
           repository(owner: "${owner}", name: "${repo}") {
@@ -51,6 +100,7 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
                       ... on PullRequest {
                         number
                         title
+                        body
                         state
                         isDraft
                         url
@@ -92,14 +142,26 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
             const linkedPRs = [];
 
             // Extract linked PRs from timeline items
+            // Issue #1094: Only count PRs that explicitly fix/close/resolve this issue
+            // This prevents false positives from PRs that only mention issues without solving them
             for (const item of issueData.timelineItems?.nodes || []) {
               if (item?.source && item.source.state === 'OPEN' && !item.source.isDraft) {
-                linkedPRs.push({
-                  number: item.source.number,
-                  title: item.source.title,
-                  state: item.source.state,
-                  url: item.source.url,
-                });
+                // Check if PR actually closes this issue (has "fixes #N", "closes #N", or "resolves #N")
+                const prBody = item.source.body || '';
+                const prTitle = item.source.title || '';
+                const closesThisIssue = prClosesIssue(prBody, issueNum) || prClosesIssue(prTitle, issueNum);
+
+                if (closesThisIssue) {
+                  linkedPRs.push({
+                    number: item.source.number,
+                    title: item.source.title,
+                    state: item.source.state,
+                    url: item.source.url,
+                  });
+                } else {
+                  // Log that we're skipping a PR that only mentions the issue
+                  await log(`      ℹ️  PR #${item.source.number} mentions issue #${issueNum} but doesn't close it (no fixes/closes/resolves keyword)`, { verbose: true });
+                }
               }
             }
 
@@ -271,6 +333,7 @@ export async function batchCheckArchivedRepositories(repositories) {
 
 // Export all functions as default object too
 export default {
+  prClosesIssue,
   batchCheckPullRequestsForIssues,
   batchCheckArchivedRepositories,
 };

package/src/lenv-reader.lib.mjs

@@ -77,6 +77,47 @@ export class LenvReader {
 
         // The values are the variable value
         if (link.values && link.values.length > 0) {
+          // Check for nested structures (multiple items on same line) - reject with error
+          // A nested tuple with id=null that appears amongst other direct values indicates
+          // same-line grouping (e.g., "--option1  --option2" on same line)
+          // However, if the entire list is a SINGLE nested tuple (e.g., "VAR: (\n  1\n  2\n)"),
+          // that's valid parenthesized syntax
+          const hasDirectValues = link.values.some(v => v && typeof v === 'object' && v.id !== null);
+          const hasNestedTuples = link.values.some(v => v && typeof v === 'object' && v.id === null && v.values && v.values.length > 0);
+
+          if (hasDirectValues && hasNestedTuples) {
+            // Mixed direct values and nested tuples indicates same-line grouping
+            for (const v of link.values) {
+              if (v && typeof v === 'object' && v.id === null && v.values && v.values.length > 0) {
+                const nestedItems = v.values.map(nested => nested.id || nested).join(' ');
+                throw new Error(`Invalid LINO format in "${varName}": Multiple values on the same line are not supported.\n` + `Found: "${nestedItems}"\n` + `Each value must be on its own line with proper indentation.`);
+              }
+            }
+          }
+
+          // Determine which values to validate for invalid characters
+          // If it's a single nested tuple (parenthesized list), unwrap it for validation
+          let valuesToValidate = link.values;
+          if (link.values.length === 1 && link.values[0] && typeof link.values[0] === 'object' && link.values[0].id === null && link.values[0].values) {
+            // Single parenthesized list - use inner values
+            valuesToValidate = link.values[0].values;
+          }
+
+          // Check for invalid characters in option-like values
+          for (const v of valuesToValidate) {
+            // Options should match pattern: --option-name or -o (with optional =value)
+            const valueStr = v.id || v;
+            if (typeof valueStr === 'string' && valueStr.startsWith('-')) {
+              // This looks like a command-line option, validate it
+              // Valid option pattern: -x, --option-name, --option-name=value
+              // Invalid characters: ?, !, @, #, $, %, ^, &, *, etc.
+              const invalidCharMatch = valueStr.match(/[^a-zA-Z0-9=_.-]/);
+              if (invalidCharMatch) {
+                throw new Error(`Invalid LINO format in "${varName}": Unrecognized character "${invalidCharMatch[0]}" in option.\n` + `Found: "${valueStr}"\n` + `Options should only contain letters, numbers, hyphens, underscores, and equals signs.`);
+              }
+            }
+          }
+
           // If there are multiple values, format them as LINO notation
           const values = link.values.map(v => v.id || v);
 
@@ -98,6 +139,11 @@ export class LenvReader {
 
       return result;
     } catch (error) {
+      // Re-throw validation errors so users can correct their configuration
+      if (error.message.includes('Invalid LINO format')) {
+        throw error;
+      }
+      // For other parsing errors, log and return empty
       console.error(`Error parsing LINO configuration: ${error.message}`);
       return {};
     }

package/src/option-suggestions.lib.mjs

@@ -146,6 +146,126 @@ export function formatSuggestions(suggestions) {
   return `\n\nDid you mean one of these?\n${formattedOptions.map(opt => `  • ${opt}`).join('\n')}`;
 }
 
+/**
+ * Known valid option names that we use for detecting "-- optionname" typos.
+ * These are common options that users might accidentally type with a space after --.
+ */
+const KNOWN_OPTION_NAMES = [
+  'model',
+  'verbose',
+  'help',
+  'version',
+  'resume',
+  'fork',
+  'dry-run',
+  'tool',
+  'think',
+  'watch',
+  'sentry',
+  'attach-logs',
+  'auto-continue',
+  'auto-fork',
+  'auto-cleanup',
+  'base-branch',
+  'log-dir',
+  'skip-tool-check',
+  'skip-tool-connection-check',
+  'auto-resume-on-limit-reset',
+  'auto-resume-on-errors',
+  'auto-close-pull-request-on-fail',
+  'auto-pull-request-creation',
+  'auto-commit-uncommitted-changes',
+  'auto-restart-on-uncommitted-changes',
+  'continue-only-on-feedback',
+  'claude-file',
+  'gitkeep-file',
+  'interactive-mode',
+  'prompt-plan-sub-agent',
+  'prompt-explore-sub-agent',
+  'prompt-general-purpose-sub-agent',
+  'prompt-issue-reporting',
+  'prompt-architecture-care',
+  'prompt-case-studies',
+  'prompt-playwright-mcp',
+  'prompt-check-sibling-pull-requests',
+  'enable-workspaces',
+  'execute-tool-with-bun',
+  'tokens-budget-stats',
+  'min-disk-space',
+  'watch-interval',
+  'only-prepare-command',
+  'auto-merge-default-branch-to-pull-request-branch',
+  'allow-fork-divergence-resolution-using-force-push-with-lease',
+  'allow-to-push-to-contributors-pull-requests-as-maintainer',
+  'prefix-fork-name-with-owner-name',
+  'auto-restart-max-iterations',
+  'auto-continue-only-on-new-comments',
+];
+
+/**
+ * Detect malformed flag patterns in command line arguments.
+ * These are arguments that look like they were intended to be flags
+ * but have incorrect formatting (e.g., "-- model" instead of "--model").
+ *
+ * Issue #1092: When user types "-- model" (with space), yargs silently ignores it
+ * as a positional argument instead of producing an error.
+ *
+ * @param {string[]} args - Array of command line arguments
+ * @returns {{ malformed: string[], errors: string[] }} - Detected malformed arguments and error messages
+ */
+export function detectMalformedFlags(args) {
+  const malformed = [];
+  const errors = [];
+
+  // Patterns that suggest user intended to type a flag but made a mistake
+  const malformedPatterns = [
+    // "-- option" - space between dashes and option name (Issue #1092)
+    { regex: /^-- +\w/, description: 'Space after "--"', suggestion: arg => `--${arg.replace(/^-- +/, '')}` },
+    // "- -option" - space between dashes
+    { regex: /^- +-/, description: 'Space between dashes', suggestion: arg => arg.replace(/^- +/, '') },
+    // "-option" for what looks like a long option (more than 1 char after single dash)
+    // Only flag this for known-looking patterns to avoid false positives
+    {
+      regex: /^-[a-z][a-z]+-?[a-z]*$/i,
+      description: 'Single dash for long option',
+      suggestion: arg => `-${arg}`,
+    },
+    // "---option" - triple dash or more
+    { regex: /^---+\w/, description: 'Too many dashes', suggestion: arg => arg.replace(/^-+/, '--') },
+  ];
+
+  for (const arg of args) {
+    for (const pattern of malformedPatterns) {
+      if (pattern.regex.test(arg)) {
+        malformed.push(arg);
+        const suggestion = pattern.suggestion(arg);
+        errors.push(`Malformed option "${arg}": ${pattern.description}. Did you mean "${suggestion}"?`);
+        break; // Don't double-report the same argument
+      }
+    }
+  }
+
+  // Issue #1092: Detect "-- optionname" pattern where the space caused
+  // the argument to be split into ['--', 'optionname'] by the tokenizer.
+  // Look for standalone '--' followed by a known option name.
+  for (let i = 0; i < args.length - 1; i++) {
+    if (args[i] === '--') {
+      const nextArg = args[i + 1];
+      // Check if next argument looks like an option name (not a URL or path)
+      // and is a known option name
+      if (nextArg && !nextArg.startsWith('-') && !nextArg.includes('/') && !nextArg.includes(':')) {
+        const lowerNextArg = nextArg.toLowerCase();
+        if (KNOWN_OPTION_NAMES.includes(lowerNextArg)) {
+          malformed.push(`-- ${nextArg}`);
+          errors.push(`Malformed option "-- ${nextArg}": Space after "--". Did you mean "--${nextArg}"?`);
+        }
+      }
+    }
+  }
+
+  return { malformed, errors };
+}
+
 /**
  * Create an enhanced error message with suggestions for unknown arguments
  *

package/src/solve.config.lib.mjs

@@ -7,7 +7,10 @@
 // Note: Strict options validation is now handled by yargs built-in .strict() mode (see below)
 // This approach was adopted per issue #482 feedback to minimize custom code maintenance
 
-import { enhanceErrorMessage } from './option-suggestions.lib.mjs';
+import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.lib.mjs';
+
+// Re-export for use by telegram-bot.mjs (avoids extra import lines there)
+export { detectMalformedFlags };
 
 // Export an initialization function that accepts 'use'
 export const initializeConfig = async use => {
@@ -322,6 +325,16 @@ export const createYargsConfig = yargsInstance => {
 // Parse command line arguments - now needs yargs and hideBin passed in
 export const parseArguments = async (yargs, hideBin) => {
   const rawArgs = hideBin(process.argv);
+
+  // Issue #1092: Detect malformed flag patterns BEFORE yargs parsing
+  // This catches cases like "-- model" which yargs silently treats as positional arguments
+  const malformedResult = detectMalformedFlags(rawArgs);
+  if (malformedResult.malformed.length > 0) {
+    const error = new Error(malformedResult.errors.join('\n'));
+    error.name = 'MalformedArgumentError';
+    throw error;
+  }
+
   // Use .parse() instead of .argv to ensure .strict() mode works correctly
   // When you call yargs(args) and use .argv, strict mode doesn't trigger
   // See: https://github.com/yargs/yargs/issues - .strict() only works with .parse()

package/src/telegram-bot.mjs

@@ -32,18 +32,12 @@ const yargs = yargsModule.default || yargsModule;
 const { hideBin } = await use('yargs@17.7.2/helpers');
 
 // Import solve and hive yargs configurations for validation
-const solveConfigLib = await import('./solve.config.lib.mjs');
-const { createYargsConfig: createSolveYargsConfig } = solveConfigLib;
-
-const hiveConfigLib = await import('./hive.config.lib.mjs');
-const { createYargsConfig: createHiveYargsConfig } = hiveConfigLib;
-
+const { createYargsConfig: createSolveYargsConfig, detectMalformedFlags } = await import('./solve.config.lib.mjs');
+const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config.lib.mjs');
 // Import GitHub URL parser for extracting URLs from messages
 const { parseGitHubUrl } = await import('./github.lib.mjs');
-
 // Import model validation for early validation with helpful error messages
 const { validateModelName } = await import('./model-validation.lib.mjs');
-
 // Import libraries for /limits, /version, and markdown escaping
 const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mjs');
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
@@ -1066,7 +1060,12 @@ bot.command(/^solve$/i, async ctx => {
     await ctx.reply(`❌ ${modelError}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
     return;
   }
-
+  // Issue #1092: Detect malformed flag patterns like "-- model" (space after --)
+  const { malformed, errors: malformedErrors } = detectMalformedFlags(args);
+  if (malformed.length > 0) {
+    await ctx.reply(`❌ ${malformedErrors.join('\n')}\n\nPlease check your option syntax.`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    return;
+  }
   // Validate merged arguments using solve's yargs config
   try {
     // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
@@ -1465,36 +1464,31 @@ bot.telegram
     process.exit(1);
   });
 
+// Helper to stop solve queue gracefully on shutdown
+// See: https://github.com/link-assistant/hive-mind/issues/1083
+const stopSolveQueue = () => {
+  try {
+    getSolveQueue({ verbose: VERBOSE }).stop();
+    if (VERBOSE) console.log('[VERBOSE] Solve queue stopped');
+  } catch (err) {
+    if (VERBOSE) console.log('[VERBOSE] Could not stop solve queue:', err.message);
+  }
+};
+
 process.once('SIGINT', () => {
   isShuttingDown = true;
   console.log('\n🛑 Received SIGINT (Ctrl+C), stopping bot...');
-  if (VERBOSE) {
-    console.log('[VERBOSE] Signal: SIGINT');
-    console.log('[VERBOSE] Process ID:', process.pid);
-    console.log('[VERBOSE] Parent Process ID:', process.ppid);
-  }
+  if (VERBOSE) console.log(`[VERBOSE] Signal: SIGINT, PID: ${process.pid}, PPID: ${process.ppid}`);
+  stopSolveQueue();
   bot.stop('SIGINT');
 });
 
 process.once('SIGTERM', () => {
   isShuttingDown = true;
   console.log('\n🛑 Received SIGTERM, stopping bot...');
-  if (VERBOSE) {
-    console.log('[VERBOSE] Signal: SIGTERM');
-    console.log('[VERBOSE] Process ID:', process.pid);
-    console.log('[VERBOSE] Parent Process ID:', process.ppid);
-    console.log('[VERBOSE] Possible causes:');
-    console.log('[VERBOSE]   - System shutdown/restart');
-    console.log('[VERBOSE]   - Process manager (systemd, pm2, etc.) stopping the service');
-    console.log('[VERBOSE]   - Manual kill command: kill <pid>');
-    console.log('[VERBOSE]   - Container orchestration (Docker, Kubernetes) stopping container');
-    console.log('[VERBOSE]   - Out of memory (OOM) killer');
-  }
-  console.log('ℹ️  SIGTERM is typically sent by:');
-  console.log('   - System shutdown/restart');
-  console.log('   - Process manager stopping the service');
-  console.log('   - Manual termination (kill command)');
-  console.log('   - Container/orchestration platform');
-  console.log('💡 Check system logs for more details: journalctl -u <service> or dmesg');
+  if (VERBOSE) console.log(`[VERBOSE] Signal: SIGTERM, PID: ${process.pid}, PPID: ${process.ppid}`);
+  console.log('ℹ️  SIGTERM is typically sent by: system shutdown, process manager, kill command, or container orchestration');
+  console.log('💡 Check system logs for details: journalctl -u <service> or dmesg');
+  stopSolveQueue();
   bot.stop('SIGTERM');
 });