@link-assistant/hive-mind 1.65.2 → 1.67.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.67.0
+
+### Minor Changes
+
+- d88aa94: Add `--ui-language` and `--work-language` flags for two-track i18n (issue #378). The existing `--language LOCALE` continues to set both tracks at once; `--ui-language LOCALE` overrides only UI/log strings, and `--work-language LOCALE` overrides only the language the AI uses for free-form output (PR/issue comments, commit messages, chat replies). Code, identifiers, and CLI strings stay in their original form. Supported locales: `en` (default), `ru`, `zh`, `hi`. The Telegram bot now resolves the user's effective locale and propagates it as `--language` to spawned solve/hive/task processes when no language flag is already present.
+
+## 1.66.0
+
+### Minor Changes
+
+- f744d5a: Add internationalisation (i18n) for user-facing terminal output and the Telegram bot. Translations are stored in `links-notation` files under `src/locales/` (`en`, `ru`, `zh`, `hi`) and loaded via `lino-objects-codec`. Adds a `--language <en|ru|zh|hi>` option to `solve`, `hive`, `task`, and `review` (defaults to detected system locale). The Telegram bot picks each user's language from `ctx.from.language_code` with a per-user override settable through a new `/language <code|default>` command (in-memory, resets on bot restart). Built-in commands `/limits`, `/version`, `/solve`, `/hive`, and `/language` now reply in the user's selected language. AI prompts are intentionally untouched - only human-facing strings are translated.
+
 ## 1.65.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.65.2",
+  "version": "1.67.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -76,6 +76,7 @@
     "dayjs": "^1.11.19",
     "decimal.js-light": "^2.5.1",
     "lino-arguments": "^0.3.0",
+    "lino-objects-codec": "^0.3.6",
     "secretlint": "^11.2.5",
     "semver": "^7.7.3"
   },

package/src/agent.prompts.lib.mjs

@@ -6,6 +6,7 @@
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Agent
@@ -257,7 +258,7 @@ Visual UI work and screenshots.
    - When the fix is visual, include side-by-side or sequential comparison of before/after states in the PR description.
    - When possible, create automated visual regression tests to prevent the UI bug from recurring.`
        : ''
-   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}${buildWorkLanguageDirective()}`;
 };
 
 // Export all functions as default object too

package/src/claude-quiet-config.lib.mjs

@@ -60,7 +60,22 @@ export const formatClaudeQuietConfigSummary = () => {
 
 const isPlainObject = value => value && typeof value === 'object' && !Array.isArray(value);
 
-export const ensureClaudeQuietConfig = async ({ settingsPath, log } = {}) => {
+// Map our 2-letter locale to the BCP-47-like language string Claude Code accepts.
+// See https://code.claude.com/docs/en/settings#available-settings for the
+// supported `language` values.
+const LOCALE_TO_CLAUDE_LANGUAGE = Object.freeze({
+  en: 'English',
+  ru: 'Russian',
+  zh: 'Chinese (Simplified)',
+  hi: 'Hindi',
+});
+
+export function resolveClaudeLanguageSetting(locale) {
+  if (!locale) return null;
+  return LOCALE_TO_CLAUDE_LANGUAGE[locale] || null;
+}
+
+export const ensureClaudeQuietConfig = async ({ settingsPath, log, workLanguage = null } = {}) => {
   const resolvedPath = settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
   let settings = {};
   try {
@@ -118,7 +133,18 @@ export const ensureClaudeQuietConfig = async ({ settingsPath, log } = {}) => {
   }
   settings.env = existingEnv;
 
-  const changed = updatedSettingsKeys.length > 0 || updatedEnvKeys.length > 0;
+  // Issue #378: write Claude Code's `language` setting from --work-language.
+  // When workLanguage is null, we deliberately leave any existing value alone
+  // so the user's manual override stays intact between solve invocations.
+  const desiredLanguage = resolveClaudeLanguageSetting(workLanguage);
+  let updatedLanguage = false;
+  if (desiredLanguage && settings.language !== desiredLanguage) {
+    settings.language = desiredLanguage;
+    updatedSettingsKeys.push('language');
+    updatedLanguage = true;
+  }
+
+  const changed = updatedSettingsKeys.length > 0 || updatedEnvKeys.length > 0 || updatedLanguage;
   try {
     if (changed) {
       await fs.mkdir(path.dirname(resolvedPath), { recursive: true });

package/src/claude.lib.mjs

@@ -719,7 +719,13 @@ export const executeClaudeCommand = async params => {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
     }
-    await ensureClaudeQuietConfig({ log });
+    let claudeWorkLanguage = null;
+    try {
+      claudeWorkLanguage = (await import('./i18n.lib.mjs')).getWorkLocale?.() ?? null;
+    } catch {
+      /* ignore */
+    }
+    await ensureClaudeQuietConfig({ log, workLanguage: claudeWorkLanguage });
     const { mcpConfigPath, disallowedToolsList } = await resolveClaudeSessionToolFlags({ argv, log, fallbackBuildMcpConfigWithoutPlaywright: buildMcpConfigWithoutPlaywright });
     if (mcpConfigPath) claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
     if (disallowedToolsList.length) claudeArgs += ` --disallowedTools ${disallowedToolsList.join(' ')}`;

package/src/claude.prompts.lib.mjs

@@ -7,6 +7,7 @@ import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mj
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { primaryModelNames } from './models/index.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Claude
@@ -328,7 +329,7 @@ Visual UI work and screenshots.
    - When the fix is visual, include side-by-side or sequential comparison of before/after states in the PR description.
    - When possible, create automated visual regression tests to prevent the UI bug from recurring.`
        : ''
-   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}${buildWorkLanguageDirective()}`;
 };
 
 // Export all functions as default object too

package/src/codex.prompts.lib.mjs

@@ -6,6 +6,7 @@
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Codex
@@ -305,7 +306,7 @@ Visual UI work and screenshots.
    - When the fix is visual, include side-by-side or sequential comparison of before/after states in the PR description.
    - When possible, create automated visual regression tests to prevent the UI bug from recurring.`
        : ''
-   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}${buildWorkLanguageDirective()}`;
 };
 
 // Export all functions as default object too

package/src/gemini.prompts.lib.mjs

@@ -6,6 +6,7 @@
 import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
 import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
 import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+import { buildWorkLanguageDirective } from './work-language.prompts.lib.mjs';
 
 /**
  * Build the user prompt for Gemini
@@ -227,7 +228,7 @@ Visual UI work and screenshots.
    - When you work on visual UI changes, include a render or screenshot of the final result in the pull request description.
    - When you save screenshots to the repository, use permanent links in the PR description such as https://github.com/${screenshotRepoPath}/blob/${branchName}/docs/screenshots/result.png?raw=true.`
        : ''
-   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}${buildWorkLanguageDirective()}`;
 };
 
 export default {

package/src/hive.mjs

@@ -292,6 +292,9 @@ if (isRunningDirectly) {
     // Set global verbose mode
     global.verboseMode = argv.verbose;
 
+    const { initI18n } = await import('./i18n.lib.mjs');
+    await initI18n({ language: argv.language, uiLanguage: argv.uiLanguage, workLanguage: argv.workLanguage });
+
     setupVerboseLogInterceptor(); // Issue #1466: capture [VERBOSE] output in log files
     setupStdioLogInterceptor(); // Issue #1549: capture ALL terminal output in log file
 

package/src/i18n.lib.mjs

@@ -0,0 +1,239 @@
+// i18n module for hive-mind.
+// - Translation files live in src/locales/<locale>.lino and are stored
+//   in Links Notation, parsed via lino-objects-codec.
+// - Supported locales: en (default fallback), ru, zh, hi.
+// - Two locale tracks: ui (user-facing strings) and work (AI prompts /
+//   tool preferred language). Both default to the value of --language.
+// - Public API: initI18n, t, getCurrentLocale, getUiLocale, getWorkLocale,
+//   setLocale, setUiLocale, setWorkLocale, getSupportedLocales,
+//   normalizeLocale, getUserLocale, setUserLocale, clearUserLocale,
+//   resolveLocaleFromTelegramCtx.
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parseIndented } from 'lino-objects-codec';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const DEFAULT_LOCALE = 'en';
+const SUPPORTED_LOCALES = ['en', 'ru', 'zh', 'hi'];
+
+const localeCache = new Map(); // locale -> { key: string }
+const userLocales = new Map(); // userId/chatId -> locale (in-memory)
+
+let currentUiLocale = DEFAULT_LOCALE;
+let currentWorkLocale = DEFAULT_LOCALE;
+let fallbackLoaded = false;
+
+export function getSupportedLocales() {
+  return [...SUPPORTED_LOCALES];
+}
+
+export function normalizeLocale(input) {
+  if (!input || typeof input !== 'string') return null;
+  const lower = input.toLowerCase();
+  // Take only the language part (before "_" or "-")
+  const lang = lower.split(/[_\-.]/)[0];
+  if (SUPPORTED_LOCALES.includes(lang)) return lang;
+  return null;
+}
+
+export function detectLocale() {
+  const envLocale = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || process.env.LC_MESSAGES || '';
+  return normalizeLocale(envLocale) || DEFAULT_LOCALE;
+}
+
+async function readLocaleFile(locale) {
+  const localesDir = path.join(__dirname, 'locales');
+  const linoFile = path.join(localesDir, `${locale}.lino`);
+  const data = await fs.readFile(linoFile, 'utf-8');
+  return parseIndentedToFlatMap(data);
+}
+
+// parseIndented returns { id, obj } where obj is the key->value map.
+// Some keys contain dots (e.g., error.invalid_github_url). The parser
+// supports them when the key is a plain reference (no spaces/quotes).
+function unescapeString(s) {
+  // Convert literal escape sequences (e.g., "\n" inside a quoted string in
+  // Links Notation) into the corresponding JS characters. This keeps the
+  // .lino files single-line and human-friendly.
+  return s.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r').replace(/\\\\/g, '\\');
+}
+
+function parseIndentedToFlatMap(text) {
+  const parsed = parseIndented({ text });
+  // parsed: { id: <localeName>, obj: { key: value, ... } }
+  if (!parsed || !parsed.obj) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(parsed.obj)) {
+    out[k] = typeof v === 'string' ? unescapeString(v) : String(v);
+  }
+  return out;
+}
+
+export async function loadTranslations(locale) {
+  if (localeCache.has(locale)) return localeCache.get(locale);
+
+  let translations = {};
+  try {
+    translations = await readLocaleFile(locale);
+  } catch {
+    translations = {};
+  }
+  localeCache.set(locale, translations);
+
+  // Always have the fallback (English) ready
+  if (!fallbackLoaded && locale !== DEFAULT_LOCALE) {
+    try {
+      const fb = await readLocaleFile(DEFAULT_LOCALE);
+      localeCache.set(DEFAULT_LOCALE, fb);
+    } catch {
+      localeCache.set(DEFAULT_LOCALE, {});
+    }
+    fallbackLoaded = true;
+  } else if (locale === DEFAULT_LOCALE) {
+    fallbackLoaded = true;
+  }
+
+  return translations;
+}
+
+// initI18n accepts either a single locale string (legacy) that sets both
+// ui and work locales, or an object { language, uiLanguage, workLanguage }.
+// Resolution rules:
+//   - If uiLanguage given, use it for UI; else use language; else detect.
+//   - If workLanguage given, use it for work; else use language; else detect.
+export async function initI18n(input = null) {
+  let language = null;
+  let uiLanguage = null;
+  let workLanguage = null;
+
+  if (input && typeof input === 'object') {
+    language = input.language ?? null;
+    uiLanguage = input.uiLanguage ?? null;
+    workLanguage = input.workLanguage ?? null;
+  } else if (typeof input === 'string') {
+    language = input;
+  }
+
+  const baseLocale = (language ? normalizeLocale(language) : null) || detectLocale();
+  const uiLocale = (uiLanguage ? normalizeLocale(uiLanguage) : null) || baseLocale;
+  const workLocale = (workLanguage ? normalizeLocale(workLanguage) : null) || baseLocale;
+
+  currentUiLocale = uiLocale;
+  currentWorkLocale = workLocale;
+
+  await loadTranslations(uiLocale);
+  if (workLocale !== uiLocale) {
+    await loadTranslations(workLocale);
+  }
+  if (uiLocale !== DEFAULT_LOCALE && workLocale !== DEFAULT_LOCALE) {
+    await loadTranslations(DEFAULT_LOCALE);
+  }
+
+  return { uiLocale, workLocale };
+}
+
+function applyParams(text, params) {
+  if (!params) return text;
+  let out = text;
+  for (const [k, v] of Object.entries(params)) {
+    out = out.replace(new RegExp(`{{${k}}}`, 'g'), String(v));
+  }
+  return out;
+}
+
+// t() returns a translated string. By default uses the UI locale.
+// Pass options.locale to override; pass options.track = 'work' to use the
+// work locale (for AI prompts).
+export function t(key, params = {}, options = {}) {
+  let locale;
+  if (options.locale) {
+    locale = normalizeLocale(options.locale) || currentUiLocale;
+  } else if (options.track === 'work') {
+    locale = currentWorkLocale;
+  } else {
+    locale = currentUiLocale;
+  }
+  const main = localeCache.get(locale) || {};
+  const fallback = localeCache.get(DEFAULT_LOCALE) || {};
+  const value = main[key] ?? fallback[key] ?? key;
+  return applyParams(value, params);
+}
+
+// Convenience helper for work-language strings (AI prompts).
+export function tWork(key, params = {}) {
+  return t(key, params, { track: 'work' });
+}
+
+export function getCurrentLocale() {
+  return currentUiLocale;
+}
+
+export function getUiLocale() {
+  return currentUiLocale;
+}
+
+export function getWorkLocale() {
+  return currentWorkLocale;
+}
+
+export function setLocale(locale) {
+  const normalized = normalizeLocale(locale);
+  if (normalized) {
+    currentUiLocale = normalized;
+    currentWorkLocale = normalized;
+  }
+}
+
+export function setUiLocale(locale) {
+  const normalized = normalizeLocale(locale);
+  if (normalized) currentUiLocale = normalized;
+}
+
+export function setWorkLocale(locale) {
+  const normalized = normalizeLocale(locale);
+  if (normalized) currentWorkLocale = normalized;
+}
+
+// In-memory per-user locale store (used by the Telegram bot).
+export function getUserLocale(userId) {
+  if (userId === undefined || userId === null) return null;
+  return userLocales.get(String(userId)) || null;
+}
+
+export function setUserLocale(userId, locale) {
+  const normalized = normalizeLocale(locale);
+  if (!normalized || userId === undefined || userId === null) return false;
+  userLocales.set(String(userId), normalized);
+  return true;
+}
+
+export function clearUserLocale(userId) {
+  if (userId === undefined || userId === null) return false;
+  return userLocales.delete(String(userId));
+}
+
+// Resolve the best locale for a Telegram update context.
+// Priority: per-user override -> ctx.from.language_code -> current default.
+export function resolveLocaleFromTelegramCtx(ctx) {
+  const userId = ctx?.from?.id;
+  const userOverride = getUserLocale(userId);
+  if (userOverride) return userOverride;
+  const fromTelegram = normalizeLocale(ctx?.from?.language_code);
+  if (fromTelegram) return fromTelegram;
+  return currentUiLocale;
+}
+
+// Pre-load every supported locale (handy for the Telegram bot at startup).
+export async function preloadAllLocales() {
+  for (const loc of SUPPORTED_LOCALES) {
+    try {
+      await loadTranslations(loc);
+    } catch {
+      // ignore - missing files fall back to English
+    }
+  }
+}

package/src/locales/en.lino

@@ -0,0 +1,131 @@
+en
+  error "Error"
+  success "Success"
+  warning "Warning"
+  failed "Failed"
+  info "Info"
+  error.invalid_github_url "Error: Invalid GitHub URL format"
+  error.invalid_github_url_monitoring "Error: Invalid GitHub URL for monitoring"
+  error.missing_required_url "Error: Missing required github issue or pull request URL"
+  error.unable_determine_version "Error: Unable to determine version"
+  error.invalid_url_type "Error: Invalid GitHub URL format"
+  error.url_type_not_supported "URL type '{{type}}' is not supported"
+  error.failed_to_get_current_user "Error: Failed to get current user"
+  error.failed_to_initialize_repository "Error: Failed to initialize repository"
+  error.failed_to_create_fork "Failed to create fork after all retries"
+  error.fork_not_accessible "Fork exists but not accessible after multiple retries"
+  error.failed_to_add_upstream_remote "Failed to add upstream remote"
+  error.failed_to_checkout "Failed to checkout {{branch}}"
+  error.failed_to_sync "Failed to sync {{branch}} with upstream"
+  error.failed_to_get_default_branch "Failed to get default branch name"
+  error.failed_to_get_current_branch "Failed to get current branch"
+  error.failed_to_fetch_upstream "Failed to fetch upstream"
+  error.failed_to_add_pr_fork_remote "Failed to add pr-fork remote"
+  error.failed_to_fetch_from_pr_fork "Failed to fetch from pr-fork"
+  error.pr_does_not_exist "Error: PR #{{prNumber}} does not exist in {{owner}}/{{repo}}"
+  error.youtrack_url_detected_no_config "Error: YouTrack URL detected but YouTrack configuration not found"
+  error.telegram_bot_token_not_set "Error: TELEGRAM_BOT_TOKEN environment variable or --token option is not set"
+  error.invalid_github_url_solve "Error: Invalid GitHub URL for solve command"
+  error.invalid_language "Invalid language '{{value}}'. Supported: {{supported}}"
+  success.readme_created "README.md created successfully"
+  success.process_completed "Process completed"
+  success.error_reported_to_sentry "Error reported to Sentry successfully"
+  success.language_set "Language set to {{language}}"
+  warning.session_log_not_found "Warning: Session log for {{session}} not found, but continuing with resume attempt"
+  warning.failed_to_create_readme "Failed: Could not create README.md"
+  warning.could_not_determine_root_repository "Could not determine root repository"
+  warning.could_not_check_fork_status "Warning: Could not check fork status: {{message}}"
+  warning.no_linked_issue_found "Warning: No linked issue found in PR body"
+  warning.could_not_search_for_existing_prs "Warning: Could not search for existing PRs: {{message}}"
+  warning.could_not_get_current_user "Warning: Could not get current GitHub user"
+  warning.could_not_check_github_permissions "Warning: Could not check GitHub permissions: {{message}}"
+  warning.could_not_determine_token_scopes "Warning: Could not determine token scopes from auth status"
+  warning.failed_to_fetch_branches "Warning: Failed to fetch branches from remote"
+  warning.error_during_auto_pr_creation "Warning: Error during auto PR creation: {{message}}"
+  warning.could_not_convert_pr_to_draft "Warning: Could not convert PR to draft"
+  warning.could_not_check_convert_pr_draft_status "Warning: Could not check/convert PR draft status"
+  warning.could_not_post_work_start_comment "Warning: Could not post work start comment"
+  warning.could_not_post_work_end_comment "Warning: Could not post work end comment"
+  warning.could_not_convert_pr_to_ready "Warning: Could not convert PR to ready"
+  warning.could_not_convert_pr_to_ready_status "Warning: Could not convert PR to ready status"
+  warning.pr_created_but_no_url "Warning: PR created but no URL returned"
+  warning.could_not_assign_user "Could not assign user"
+  info.expected_github_url_format "Expected: https://github.com/owner or https://github.com/owner/repo"
+  info.you_can_use_formats "You can use any of these formats:"
+  info.format_https_owner "- https://github.com/owner"
+  info.format_https_owner_repo "- https://github.com/owner/repo"
+  info.format_http_owner "- http://github.com/owner (will be converted to https)"
+  info.format_github_owner "- github.com/owner (will add https://)"
+  info.format_owner "- owner (will be converted to https://github.com/owner)"
+  info.format_owner_repo "- owner/repo (will be converted to https://github.com/owner/repo)"
+  info.full_log_file "Full log file: {{path}}"
+  info.process_exited_with_code "Process exited with code {{code}}"
+  info.current_configuration "Current Configuration:"
+  process.using_repository_fallback "Using repository-by-repository fallback for {{scope}}: {{owner}}"
+  process.fetching_repository_list "Fetching repository list..."
+  process.command "Command: {{command}}"
+  check.number "Check #{{iteration}}:"
+  time.current "Current time: {{time}}"
+  telegram.fetching_limits "🔄 Fetching usage limits..."
+  telegram.gathering_version "🔄 Gathering version information..."
+  telegram.usage_limits_title "📊 *Usage Limits*"
+  telegram.version_information_title "🤖 *Version Information*"
+  telegram.limits_only_in_groups "❌ The /limits command only works in group chats. Please add this bot to a group and make it an admin."
+  telegram.version_only_in_groups "❌ The /version command only works in group chats. Please add this bot to a group and make it an admin."
+  telegram.solve_only_in_groups "❌ The {{commandDisplay}} command only works in group chats. Please add this bot to a group and make it an admin."
+  telegram.hive_only_in_groups "❌ The /hive command only works in group chats. Please add this bot to a group and make it an admin."
+  telegram.solve_disabled "❌ The solve command is disabled on this bot instance."
+  telegram.hive_disabled "❌ The /hive command is disabled on this bot instance."
+  telegram.no_github_link_in_reply "❌ No GitHub issue/PR link found in the replied message.\n\nExample: Reply to a message containing a GitHub issue link with `/solve`\n\nOr with options: `/solve --model opus`"
+  telegram.invalid_options "❌ Invalid options: {{message}}\n\nUse /help to see available options"
+  telegram.invalid_isolation "❌ Invalid --isolation value '{{value}}'. Must be: screen, tmux, or docker"
+  telegram.invalid_locked_isolation "❌ Invalid locked --isolation value '{{value}}'. Must be: screen, tmux, or docker"
+  telegram.option_syntax_check "Please check your option syntax."
+  telegram.url_status_active "❌ This URL is {{statusText}}.\n\nURL: {{url}}\nStatus: {{status}}\n\n💡 Use /solve_queue to check the queue status."
+  telegram.url_session_running "❌ A working session is already running for this URL.\n\nURL: {{url}}\nSession: `{{session}}`\n\n💡 Wait for the current session to complete, or use /solve\\_stop to cancel it."
+  telegram.solve_rejected "❌ Solve command rejected.\n\n{{infoBlock}}\n\n🚫 Reason: {{reason}}"
+  telegram.language_invalid "❌ Invalid language. Supported: {{supported}}.\nUsage: /language <code>"
+  telegram.language_set "✅ Language set to *{{language}}*."
+  telegram.language_current "🌐 Current language: *{{language}}*.\nSupported: {{supported}}.\nUsage: /language <code>"
+  language.en "English"
+  language.ru "Russian"
+  language.zh "Chinese"
+  language.hi "Hindi"
+  prompt.user.issue_to_solve "Issue to solve: {{issueUrl}}"
+  prompt.user.issue_linked_to_pr "Issue to solve: Issue linked to PR #{{prNumber}}"
+  prompt.user.prepared_branch "Your prepared branch: {{branchName}}"
+  prompt.user.prepared_working_directory "Your prepared working directory: {{tempDir}}"
+  prompt.user.prepared_tmp_directory "Your prepared tmp directory for logs and downloads: {{workspaceTmpDir}}"
+  prompt.user.prepared_pull_request "Your prepared Pull Request: {{prUrl}}"
+  prompt.user.forked_repository "Your forked repository: {{forkedRepo}}"
+  prompt.user.original_repository "Original repository (upstream): {{owner}}/{{repo}}"
+  prompt.user.fork_actions_url "GitHub Actions on your fork: {{forkActionsUrl}}"
+  prompt.user.continue "Continue."
+  prompt.user.proceed "Proceed."
+  prompt.system.intro 'You are an AI issue solver. When you investigate issues, prefer root-cause analysis. When you communicate, prefer facts you have checked yourself or cite sources that provide evidence, such as quoted code or references to documents or web pages. When you are unsure or working from assumptions, test them yourself or ask clarifying questions.'
+  prompt.system.workspace_instructions 'Workspace tmp directory.\n   - Use {{workspaceTmpDir}} for all temporary files, logs, and downloads.\n   - When saving command output to files, save to {{workspaceTmpDir}}/command-output.log.\n   - When downloading CI logs, save to {{workspaceTmpDir}}/ci-logs/.\n   - When saving diffs for review, save to {{workspaceTmpDir}}/diffs/.\n   - When creating debug files, save to {{workspaceTmpDir}}/debug/.'
+  prompt.system.general_guidelines_header 'General guidelines.'
+  prompt.system.general_guidelines_body '   - When you execute commands and the output becomes large, save the logs to files for easier review.\n   - When running commands, avoid setting a timeout yourself. Let them run as long as needed. The default timeout of 2 minutes is usually enough, and once commands finish, review the logs in the file.\n   - When running sudo commands, especially package installations like apt-get, yum, or npm install, run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.'
+  prompt.system.issue_reporting '   - When you spot errors, bugs, or minor issues during the working session that are unrelated to the main task requirements, create issues to track them when they do not already exist. The issue should include reproducible examples, ideally a minimum reproducible example, workarounds, and suggestions for fixing the issue in code. For issues in the current repository, use gh issue create --repo {{owner}}/{{repo}} --title "Issue title" --body "Issue description". For issues in third-party GitHub repositories used by the working repository, use gh issue create --repo owner/repo --title "Issue title" --body "Issue description". When similar issues may already exist, check first with gh issue list --repo owner/repo --search "keywords" to avoid duplicates. If a similar issue already exists, add a comment with gh issue comment <issue-number> --repo owner/repo --body "Comment text" describing your specific case, including anonymized logs with personal or sensitive data redacted, reproduction steps, a minimum reproducible example when practical, workarounds, and suggestions for a fix.'
+  prompt.system.ci_investigation '   - When CI is failing or user reports failures, consider adding a detailed investigation protocol to your todo list with these steps:\n      Step 1: List recent runs with timestamps using: gh run list --repo {{owner}}/{{repo}} --branch {{branchName}} --limit 5 --json databaseId,conclusion,createdAt,headSha\n      Step 2: Verify runs are after the latest commit by checking timestamps and SHA\n      Step 3: For each non-passing run, download logs to preserve them: gh run view {run-id} --repo {{owner}}/{{repo}} --log > ci-logs/{workflow}-{run-id}.log\n      Step 4: Read each downloaded log file with the Read tool to understand the actual failures\n      Step 5: Report findings with specific errors and line numbers from logs\n      This detailed investigation is especially helpful when user mentions CI failures, asks to investigate logs, you see non-passing status, or when finalizing a PR.\n      Note: If user says failing but tools show passing, this might indicate stale data - consider downloading fresh logs and checking timestamps to resolve the discrepancy.'
+  prompt.system.large_files "   - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines."
+  prompt.system.complex_problems "   - When facing a complex problem, do as much tracing as possible and turn on all verbose modes."
+  prompt.system.divide_and_conquer "   - When you face something extremely hard, use divide and conquer."
+  prompt.system.initial_research_header "Initial research."
+  prompt.system.initial_research_body '   - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.\n   - When the user mentions CI failures or asks to investigate logs, consider adding these todos to track the investigation: (1) list recent CI runs with timestamps, (2) download logs from failed runs to the ci-logs/ directory, (3) analyze error messages and identify the root cause, (4) implement a fix, (5) verify that the fix resolves the specific errors found in the logs.\n   - When you read the issue, read all details and comments thoroughly.\n   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the file command. When corrupted or non-image files, such as GitHub Not Found pages saved as .png, are read, they can cause Could not process image errors and crash the AI solver process. When the file command shows HTML, text, or ASCII text, the download failed, so do not call Read on that file. Instead: (1) when images are from GitHub issues or PRs, such as URLs containing github.com/user-attachments, retry with: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>" (2) when the retry still fails, skip the image and note that it was unavailable.\n   - When you need issue details, use gh issue view https://github.com/{{owner}}/{{repo}}/issues/{{issueNumber}}.\n   - When you need related code, use gh search code --owner {{owner}} [keywords].\n   - When you need repo context, read files in your working directory.'
+  prompt.system.explore_subagent "   - When you need to learn something about the codebase structure, patterns, or how things work, use the Task tool with subagent_type=Explore to thoroughly explore the codebase."
+  prompt.system.check_sibling_prs "   - When you study related work, study the most recent related pull requests."
+  prompt.system.initial_research_tail '   - When the issue is not defined clearly enough, write a comment with clarifying questions.\n   - When accessing GitHub Gists (especially private ones), use gh gist view command instead of direct URL fetching to ensure proper authentication.\n   - When you are fixing a bug, find the actual root cause first and run as many experiments as needed.\n   - When you are fixing a bug and the code does not have enough tracing or logs, add them and keep them in the code with the default state switched off.\n   - When you need comments on a pull request, note that GitHub has three different comment types with different API endpoints:\n      1. PR review comments (inline code comments): gh api repos/{{owner}}/{{repo}}/pulls/{{prNumber}}/comments --paginate\n      2. PR conversation comments (general discussion): gh api repos/{{owner}}/{{repo}}/issues/{{prNumber}}/comments --paginate\n      3. PR reviews (approve/request changes): gh api repos/{{owner}}/{{repo}}/pulls/{{prNumber}}/reviews --paginate\n      Note: The command "gh pr view --json comments" only returns conversation comments and misses review comments.\n   - When you need the latest comments on the issue, use gh api repos/{{owner}}/{{repo}}/issues/{{issueNumber}}/comments --paginate.'
+  prompt.system.general_purpose_subagent "   - When the task is large and requires processing many files or folders, use `general-purpose` sub-agents to delegate work. Each separate file or folder can be delegated to a sub-agent for more efficient processing."
+  prompt.system.case_studies "   - When working on this issue, create a comprehensive case study in the ./docs/case-studies/issue-{{issueNumber}}/ directory. Download all logs and data related to the issue to the repository. Perform deep case study analysis by searching online for additional facts and data, reconstructing the timeline/sequence of events, identifying root causes of the problem, and proposing possible solutions. Include files like README.md (executive summary, problem statement, timeline, root cause), TECHNICAL_SUMMARY.md (deep technical analysis), ANALYSIS.md (detailed investigation findings), improvements.md (proposed solutions), and supporting logs/data files."
+  prompt.system.solution_development 'Solution development and testing.\n   - When issue is solvable, first create a test that reproduces the problem, then implement the fix.\n   - When implementing features, search for similar existing implementations in the codebase and use them as examples instead of implementing everything from scratch.\n   - When coding, commit each atomic step that is useful on its own to the pull request branch so interrupted work remains preserved in the pull request.\n   - When you test:\n      start from testing of small functions using separate scripts;\n      write unit tests with mocks for easy and quick start.\n   - When you test integrations, use existing framework.\n   - When you test solution draft, include automated checks in pr.\n   - When you write or modify tests, consider setting reasonable timeouts at test, suite, and CI job levels so failures surface quickly instead of hanging.\n   - When you see repeated test timeout patterns in CI, investigate the root cause rather than increasing timeouts.\n   - When the issue is unclear, write a comment on the issue with questions.\n   - When you encounter problems that you cannot solve yourself and need human help, write a comment on the pull request asking for help.\n   - When you need human help, use gh pr comment {{prNumber}} --body "your message" to comment on existing PR.'
+  prompt.system.reproducible_testing "Reproducible testing.\n   - When fixing a bug, create a test that reproduces the problem before implementing the fix. When you cannot reproduce the problem, you cannot verify the fix.\n   - When encountering logic bugs, write an automated test that fails due to the bug, then implement the fix to make it pass.\n   - When encountering UI bugs, capture a screenshot showing the problem state, then create a visual regression test or manual verification screenshot after the fix.\n   - When creating tests, prefer minimum reproducible examples, meaning the simplest test case that demonstrates the issue.\n   - When submitting a fix, include in the PR description: (1) how to reproduce the issue, (2) the automated test that verifies the fix, (3) before/after screenshots for UI issues.\n   - When a bug fix does not have a reproducing test, treat the fix as incomplete because regressions can occur later without notice."
+  prompt.system.preparing_pr 'Preparing pull request.\n   - When you code, follow contributing guidelines.\n   - When you commit, write clear message.\n   - When you need examples of style, use gh pr list --repo {{owner}}/{{repo}} --state merged --search [keywords].\n   - When you open pr, describe solution draft and include tests.\n   - When there is a package with version and GitHub Actions workflows for automatic release, update the version (or other necessary release trigger) in your pull request to prepare for next release.\n   - When you update existing pr {{prNumber}}, use gh pr edit to modify title and description.\n   - When you are about to commit or push code, run local CI checks first if they are available in contributing guidelines (like ruff check, mypy, eslint, etc.) to catch errors before pushing.\n   - When you finalize the pull request:\n      follow style from merged prs for code, title, and description,\n      check that no uncommitted changes corresponding to the original requirements are left behind,\n      check that the default branch is merged into the pull request branch,\n      check that all CI checks are passing if they exist before you finish,\n      check for latest comments on the issue and pull request to ensure no recent feedback was missed,\n      double-check that all changes in the pull request address the original requirements of the issue,\n      check for newly introduced bugs in the pull request by carefully reading gh pr diff,\n      check that no previously existing features were removed without an explicit request in the issue description, issue comments, or pull request comments.\n   - When you finish implementation, use gh pr ready {{prNumber}}.'
+  prompt.system.workflow "Workflow and collaboration.\n   - When you check branch, verify with git branch --show-current.\n   - When you push, push only to branch {{branchName}}.\n   - When you finish, create a pull request from branch {{branchName}}. (Note: PR {{prNumber}} already exists, update it instead)\n   - When you organize workflow, use pull requests instead of direct merges to default branch (main or master).\n   - When you manage commits, preserve commit history for later analysis.\n   - When you contribute, keep repository history forward-moving with regular commits, pushes, and reverts if needed.\n   - When you face conflict that you cannot resolve yourself, ask for help.\n   - When you collaborate, respect branch protections by working only on {{branchName}}.\n   - When you mention a result, include the pull request URL or comment URL.\n   - When you need to create pr, remember pr {{prNumber}} already exists for this branch."
+  prompt.system.self_review_header "Self review.\n   - When you check your solution draft, run all tests locally.\n   - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.\n   - When you compare with repo style, use gh pr diff [number].\n   - When you finalize, confirm code, tests, and description are consistent."
+  prompt.system.ensure_all_requirements "   - When no explicit feedback or requirements are provided, ensure all changes are correct, consistent, validated, tested, logged, and aligned with all discussed requirements by checking the issue description and all comments on the issue and pull request. Check that all CI or CD checks are passing."
+  prompt.system.github_cli_patterns 'GitHub CLI command patterns.\n   - When fetching lists from GitHub API, use the --paginate flag to ensure all results are returned (GitHub returns max 30 per page by default).\n   - When listing PR review comments (inline code comments), use gh api repos/OWNER/REPO/pulls/NUMBER/comments --paginate.\n   - When listing PR conversation comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.\n   - When listing PR reviews, use gh api repos/OWNER/REPO/pulls/NUMBER/reviews --paginate.\n   - When listing issue comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.\n   - When adding PR comment, use gh pr comment NUMBER --body "text" --repo OWNER/REPO.\n   - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.\n   - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.\n   - When filtering with jq, use gh api repos/{{owner}}/{{repo}}/pulls/{{prNumber}}/comments --paginate --jq reverse-then-slice-first-five.'
+  prompt.system.playwright_mcp "Playwright MCP usage (browser automation via mcp__playwright__* tools).\n   - When you develop frontend web applications (HTML, CSS, JavaScript, React, Vue, Angular, etc.), use Playwright MCP tools to test the UI in a real browser.\n   - When WebFetch tool fails to retrieve expected content (e.g., returns empty content, JavaScript-rendered pages, or login-protected pages), use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for web browsing.\n   - When WebSearch tool fails or returns insufficient results, use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for internet search.\n   - When you need to interact with dynamic web pages that require JavaScript execution, use Playwright MCP tools.\n   - When you need to visually verify how a web page looks or take screenshots, use browser_take_screenshot from Playwright MCP.\n   - When you need to fill forms, click buttons, or perform user interactions on web pages, use Playwright MCP tools (browser_click, browser_type, browser_fill_form).\n   - When you need to test responsive design or different viewport sizes, use browser_resize from Playwright MCP.\n   - When you finish using the browser, close it with browser_close to free resources.\n   - When reproducing UI bugs, use browser_take_screenshot to capture the problem state before implementing any fix.\n   - When fixing UI bugs, take before/after screenshots to provide visual evidence of the fix for human verification.\n   - When creating UI tests, save baseline screenshots to the repository for visual regression testing.\n   - When verifying UI fixes, compare screenshots to ensure the fix does not introduce unintended visual changes."
+  prompt.system.plan_subagent 'Plan sub-agent usage.\n   - When you start working on a task, consider using the Plan sub-agent to research the codebase and create an implementation plan.\n   - When using the Plan sub-agent, you can add it as the first item in your todo list.\n   - When you delegate planning, use the Task tool with subagent_type="Plan" before starting implementation work.'
+  prompt.system.visual_ui 'Visual UI work and screenshots.\n   - When you work on visual UI changes (frontend, CSS, HTML, design), include a render or screenshot of the final result in the pull request description.\n   - When you need to show visual results, take a screenshot and save it to the repository (e.g., in a docs/screenshots/ or assets/ folder).\n   - When you save screenshots to the repository, use permanent links in the pull request description markdown (e.g., https://github.com/{{screenshotRepoPath}}/blob/{{branchName}}/docs/screenshots/result.png?raw=true).\n   - When uploading images, commit them to the branch first, then reference them using the GitHub blob URL format with ?raw=true suffix (works for both public and private repositories).\n   - When the visual result is important for review, mention it explicitly in the pull request description with the embedded image.\n   - When fixing UI bugs, capture both the "before" (problem) and "after" (fixed) screenshots as evidence for human verification.\n   - When reporting UI bugs, include a screenshot of the problem state to enable visual verification of the fix.\n   - When the fix is visual, include side-by-side or sequential comparison of before/after states in the PR description.\n   - When possible, create automated visual regression tests to prevent the UI bug from recurring.'
+  prompt.system.ci_examples "CI investigation with workspace tmp directory.\n   - When downloading CI run logs:\n      gh run view RUN_ID --repo {{owner}}/{{repo}} --log > {{workspaceTmpDir}}/ci-logs/run-RUN_ID.log\n   - When downloading failed job logs:\n      gh run view RUN_ID --repo {{owner}}/{{repo}} --log-failed > {{workspaceTmpDir}}/ci-logs/run-RUN_ID-failed.log\n   - When listing CI runs with details:\n      gh run list --repo {{owner}}/{{repo}} --branch {{branchName}} --limit 5 --json databaseId,conclusion,createdAt,headSha > {{workspaceTmpDir}}/ci-logs/recent-runs.json\n   - When saving PR diff for review:\n      gh pr diff {{prNumber}} --repo {{owner}}/{{repo}} > {{workspaceTmpDir}}/diffs/pr-{{prNumber}}.diff\n   - When saving command output with stderr:\n      npm test 2>&1 | tee {{workspaceTmpDir}}/test-output.log\n   - When investigating issue details:\n      gh issue view {{issueNumber}} --repo {{owner}}/{{repo}} --json body,comments > {{workspaceTmpDir}}/issue-{{issueNumber}}.json"