@link-assistant/hive-mind 1.69.4 → 1.69.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.69.6
+
+### Patch Changes
+
+- c2c51fa: Allow Telegram `/terminal_watch` and `/watch` to be used by the user who started a tracked session while preserving chat-owner access and private-repository DM routing.
+
+## 1.69.5
+
+### Patch Changes
+
+- 31b0f7e: Add issue language auto-detection for solve work prompts and localize limits output.
+
 ## 1.69.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.69.4",
+  "version": "1.69.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -78,7 +78,8 @@
     "lino-arguments": "^0.3.0",
     "lino-objects-codec": "^0.3.6",
     "secretlint": "^11.2.5",
-    "semver": "^7.7.3"
+    "semver": "^7.7.3",
+    "tinyld": "^1.3.4"
   },
   "lint-staged": {
     "*.{js,mjs,json,md}": [

package/src/auto-language.lib.mjs

@@ -0,0 +1,94 @@
+import { detect as detectLanguage } from 'tinyld';
+
+const WORD_PATTERN = /\p{L}[\p{L}\p{M}'-]*/gu;
+const TARGET_LANGUAGES = new Set(['en', 'ru']);
+const DEFAULT_THRESHOLD = 0.51;
+
+export function extractLanguageWords(text) {
+  if (!text || typeof text !== 'string') return [];
+  return text.match(WORD_PATTERN) || [];
+}
+
+function detectByScript(word) {
+  const hasCyrillic = /\p{Script=Cyrillic}/u.test(word);
+  const hasLatin = /\p{Script=Latin}/u.test(word);
+  if (hasCyrillic && !hasLatin) return 'ru';
+  if (hasLatin && !hasCyrillic) return 'en';
+  return null;
+}
+
+export function detectWordLanguage(word, detector = detectLanguage) {
+  if (!word || typeof word !== 'string') return null;
+  let detected = null;
+  try {
+    detected = detector(word);
+  } catch {
+    detected = null;
+  }
+  if (TARGET_LANGUAGES.has(detected)) return detected;
+  return detectByScript(word);
+}
+
+export function detectIssueLanguageFromText(text, { detector = detectLanguage, threshold = DEFAULT_THRESHOLD, fallbackLanguage = 'en' } = {}) {
+  const words = extractLanguageWords(text);
+  const counts = { en: 0, ru: 0, detected: 0, ignored: 0, total: words.length };
+
+  for (const word of words) {
+    const language = detectWordLanguage(word, detector);
+    if (language === 'en' || language === 'ru') {
+      counts[language] += 1;
+      counts.detected += 1;
+    } else {
+      counts.ignored += 1;
+    }
+  }
+
+  const ratios = {
+    en: counts.total > 0 ? counts.en / counts.total : 0,
+    ru: counts.total > 0 ? counts.ru / counts.total : 0,
+  };
+
+  let language = fallbackLanguage;
+  if (ratios.ru > threshold) {
+    language = 'ru';
+  } else if (ratios.en > threshold) {
+    language = 'en';
+  }
+
+  return { language, counts, ratios, threshold };
+}
+
+export async function fetchTargetTextForAutoLanguage({ githubLib, owner, repo, number, isIssueUrl, isPrUrl }) {
+  const jsonFields = 'number,title,body';
+  let result = null;
+  if (isIssueUrl) {
+    result = await githubLib.ghIssueView({ issueNumber: number, owner, repo, jsonFields });
+  } else if (isPrUrl) {
+    result = await githubLib.ghPrView({ prNumber: number, owner, repo, jsonFields });
+  }
+
+  if (!result || result.code !== 0 || !result.data) return null;
+  return [result.data.title, result.data.body].filter(Boolean).join('\n\n');
+}
+
+export async function applyAutoLanguageToArgv({ argv, githubLib, owner, repo, number, isIssueUrl, isPrUrl, log = async () => {} }) {
+  if (!argv?.autoLanguage || argv._workLanguageExplicit) return null;
+
+  try {
+    const text = await fetchTargetTextForAutoLanguage({ githubLib, owner, repo, number, isIssueUrl, isPrUrl });
+    if (!text) {
+      argv.workLanguage = argv.workLanguage || 'en';
+      await log('Auto language detection could not fetch target text; using English work language.', { verbose: true });
+      return null;
+    }
+
+    const result = detectIssueLanguageFromText(text);
+    argv.workLanguage = result.language;
+    await log(`Auto language detection selected work language: ${result.language} (en=${result.counts.en}, ru=${result.counts.ru}, detected=${result.counts.detected})`, { verbose: true });
+    return result;
+  } catch (error) {
+    argv.workLanguage = argv.workLanguage || 'en';
+    await log(`Auto language detection failed: ${error?.message || error}; using English work language.`, { verbose: true });
+    return null;
+  }
+}

package/src/limits-i18n.lib.mjs

@@ -0,0 +1,71 @@
+import { t } from './i18n.lib.mjs';
+
+const ENGLISH_LIMITS = {
+  additional_codex_limits: 'Additional Codex limits',
+  balance: 'balance',
+  claude_5_hour_session: 'Claude 5 hour session',
+  claude_limits: 'Claude limits',
+  codex_5_hour_session: 'Codex 5 hour session',
+  codex_credits: 'Codex credits',
+  codex_limits: 'Codex limits',
+  cpu: 'CPU',
+  cpu_cores_used: 'CPU cores used',
+  current_time: 'Current time',
+  current_week_all_models: 'Current week (all models)',
+  current_week_sonnet_only: 'Current week (Sonnet only)',
+  disabled_by_admin: '`--show-limits` is disabled by the bot administrator.',
+  disk_space: 'Disk space',
+  end: 'End',
+  five_hour_session: '5h session',
+  five_min_load_avg: '5m load avg',
+  github_api: 'GitHub API',
+  limits_at_end: 'Limits at end',
+  limits_at_start: 'Limits at start',
+  limits_change: 'Limits change',
+  na: 'N/A',
+  note_delta_approx: 'Note: delta is approximate (parallel sessions share the same budget).',
+  passed: 'passed',
+  plan: 'Plan',
+  ram: 'RAM',
+  requests: 'requests',
+  resets_at: 'Resets {{time}}',
+  resets_in: 'Resets in {{duration}}',
+  seven_day_all_models: '7d all models',
+  seven_day_sonnet_only: '7d Sonnet only',
+  session: 'session',
+  start: 'Start',
+  unavailable: 'unavailable',
+  unlimited: 'unlimited',
+  used: 'used',
+  week: 'week',
+  weekly: 'Weekly',
+};
+
+function applyParams(text, params = {}) {
+  let out = text;
+  for (const [key, value] of Object.entries(params)) {
+    out = out.replace(new RegExp(`{{${key}}}`, 'g'), String(value));
+  }
+  return out;
+}
+
+export function resolveLimitLocale(options = {}) {
+  if (typeof options === 'string') return options;
+  return options?.locale || null;
+}
+
+export function lt(key, params = {}, options = {}) {
+  const fullKey = `limits.${key}`;
+  const locale = resolveLimitLocale(options);
+  const translated = t(fullKey, params, locale ? { locale } : {});
+  if (translated !== fullKey) return translated;
+  return applyParams(ENGLISH_LIMITS[key] || key, params);
+}
+
+export function formatLimitResetsIn(duration, resetTime, options = {}) {
+  return `${lt('resets_in', { duration }, options)} (${resetTime})`;
+}
+
+export function formatLimitResetsAt(resetTime, options = {}) {
+  return lt('resets_at', { time: resetTime }, options);
+}

package/src/limits.lib.mjs

@@ -13,6 +13,7 @@ import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
+import { formatLimitResetsAt, formatLimitResetsIn, lt, resolveLimitLocale } from './limits-i18n.lib.mjs';
 // Initialize dayjs plugins
 dayjs.extend(utc);
 
@@ -280,13 +281,14 @@ function formatBytes(bytes) {
 }
 
 /**
- * Format two byte values into a combined "used/total UNIT used" format
  * @param {number} usedBytes - Used size in bytes
  * @param {number} totalBytes - Total size in bytes
+ * @param {Object|string} options - Optional locale options
  * @returns {string} Formatted string (e.g., "2.8/11.7 GB used")
  */
-function formatBytesRange(usedBytes, totalBytes) {
-  if (totalBytes === 0) return '0/0 B used';
+function formatBytesRange(usedBytes, totalBytes, options = {}) {
+  const usedLabel = lt('used', {}, options);
+  if (totalBytes === 0) return `0/0 B ${usedLabel}`;
   const k = 1024;
   const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
   // Determine unit based on total (larger value)
@@ -295,7 +297,7 @@ function formatBytesRange(usedBytes, totalBytes) {
   const totalValue = totalBytes / Math.pow(k, i);
   // Use 1 decimal place for GB and above, none for smaller units
   const decimals = i >= 3 ? 1 : 0;
-  return `${usedValue.toFixed(decimals)}/${totalValue.toFixed(decimals)} ${sizes[i]} used`;
+  return `${usedValue.toFixed(decimals)}/${totalValue.toFixed(decimals)} ${sizes[i]} ${usedLabel}`;
 }
 
 function formatRoundedNumber(value, decimals = 2) {
@@ -307,6 +309,10 @@ function getDisplayCpuCoresUsed(loadAvg5, cpuCount) {
   return formatRoundedNumber(boundedLoad);
 }
 
+function hasLimitPercentage(window) {
+  return window?.percentage !== null && window?.percentage !== undefined;
+}
+
 /**
  * Get GitHub API rate limits by calling gh api rate_limit
  * Returns rate limit info for core, search, graphql, and other resources
@@ -1019,74 +1025,68 @@ export function calculateTimePassedPercentage(resetsAt, periodHours) {
  * @param {Object} memory - Optional memory info from getMemoryInfo
  * @param {string|null} claudeError - Optional error message to show in Claude sections (e.g., auth expired)
  * @param {string[]} extraSections - Optional extra sections to append inside the code block (e.g. queue status)
+ * @param {Object|string} options - Optional locale options
  * @returns {string} Formatted message wrapped in a single code block
  * @see https://github.com/link-assistant/hive-mind/issues/1242
  */
-export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = null, cpuLoad = null, memory = null, claudeError = null, extraSections = []) {
-  // Build sections as individual text blocks; they will all be joined and wrapped in a
-  // single code block at the end. This avoids fragile string-searching to inject content.
-
+export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = null, cpuLoad = null, memory = null, claudeError = null, extraSections = [], options = {}) {
+  if (!Array.isArray(extraSections) && extraSections && typeof extraSections === 'object') {
+    options = extraSections;
+    extraSections = [];
+  }
+  const locale = resolveLimitLocale(options);
   const sections = [];
 
-  // Show current time
-  sections.push(`Current time: ${formatCurrentTime()}\n`);
+  sections.push(`${lt('current_time', {}, { locale })}: ${formatCurrentTime()}\n`);
 
-  // CPU load section (if provided)
-  // Threshold: Blocks new commands when usage >= 65%
   if (cpuLoad) {
-    let section = 'CPU\n';
+    let section = `${lt('cpu', {}, { locale })}\n`;
     const usedBar = getProgressBar(cpuLoad.usagePercentage, DISPLAY_THRESHOLDS.CPU);
     // Show 'used' label when below threshold, warning emoji when at/above threshold
     // See: https://github.com/link-assistant/hive-mind/issues/1267
-    const suffix = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : ' used';
+    const suffix = cpuLoad.usagePercentage >= DISPLAY_THRESHOLDS.CPU ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     section += `${usedBar} ${cpuLoad.usagePercentage}%${suffix}\n`;
     // Linux load average is demand, not bounded CPU time. Keep the cores-used
     // display within CPU capacity and show raw load average only when saturated.
     const usedCpuCores = cpuLoad.usedCpuCores ?? getDisplayCpuCoresUsed(cpuLoad.loadAvg5, cpuLoad.cpuCount);
-    let cpuCoresLine = `${formatRoundedNumber(usedCpuCores)}/${cpuLoad.cpuCount} CPU cores used`;
+    let cpuCoresLine = `${formatRoundedNumber(usedCpuCores)}/${cpuLoad.cpuCount} ${lt('cpu_cores_used', {}, { locale })}`;
     if (cpuLoad.loadAvg5 > cpuLoad.cpuCount) {
-      cpuCoresLine += ` (5m load avg ${formatRoundedNumber(cpuLoad.loadAvg5)})`;
+      cpuCoresLine += ` (${lt('five_min_load_avg', {}, { locale })} ${formatRoundedNumber(cpuLoad.loadAvg5)})`;
     }
     section += `${cpuCoresLine}\n`;
     sections.push(section);
   }
 
-  // Memory section (if provided)
-  // Threshold: Blocks new commands when usage >= 65%
   if (memory) {
-    let section = 'RAM\n';
+    let section = `${lt('ram', {}, { locale })}\n`;
     const usedBar = getProgressBar(memory.usedPercentage, DISPLAY_THRESHOLDS.RAM);
-    const suffix = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : ' used';
+    const suffix = memory.usedPercentage >= DISPLAY_THRESHOLDS.RAM ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     section += `${usedBar} ${memory.usedPercentage}%${suffix}\n`;
-    section += `${formatBytesRange(memory.usedBytes, memory.totalBytes)}\n`;
+    section += `${formatBytesRange(memory.usedBytes, memory.totalBytes, { locale })}\n`;
     sections.push(section);
   }
 
-  // Disk space section (if provided)
-  // Threshold: One-at-a-time mode when usage >= 90%
   if (diskSpace) {
-    let section = 'Disk space\n';
-    // Show used percentage with progress bar and threshold marker
+    let section = `${lt('disk_space', {}, { locale })}\n`;
     const usedBar = getProgressBar(diskSpace.usedPercentage, DISPLAY_THRESHOLDS.DISK);
-    const suffix = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : ' used';
+    const suffix = diskSpace.usedPercentage >= DISPLAY_THRESHOLDS.DISK ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     section += `${usedBar} ${diskSpace.usedPercentage}%${suffix}\n`;
-    section += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes)}\n`;
+    section += `${formatBytesRange(diskSpace.usedBytes, diskSpace.totalBytes, { locale })}\n`;
     sections.push(section);
   }
 
   // GitHub API rate limits section (if provided)
   // Threshold: Blocks parallel claude commands when >= 75%
   if (githubRateLimit) {
-    let section = 'GitHub API\n';
-    // Show used percentage with progress bar and threshold marker
+    let section = `${lt('github_api', {}, { locale })}\n`;
     const usedBar = getProgressBar(githubRateLimit.usedPercentage, DISPLAY_THRESHOLDS.GITHUB_API);
-    const suffix = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : ' used';
+    const suffix = githubRateLimit.usedPercentage >= DISPLAY_THRESHOLDS.GITHUB_API ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     section += `${usedBar} ${githubRateLimit.usedPercentage}%${suffix}\n`;
-    section += `${githubRateLimit.used}/${githubRateLimit.limit} requests\n`;
+    section += `${githubRateLimit.used}/${githubRateLimit.limit} ${lt('requests', {}, { locale })}\n`;
     if (githubRateLimit.relativeReset) {
-      section += `Resets in ${githubRateLimit.relativeReset} (${githubRateLimit.resetTime})\n`;
+      section += `${formatLimitResetsIn(githubRateLimit.relativeReset, githubRateLimit.resetTime, { locale })}\n`;
     } else if (githubRateLimit.resetTime) {
-      section += `Resets ${githubRateLimit.resetTime}\n`;
+      section += `${formatLimitResetsAt(githubRateLimit.resetTime, { locale })}\n`;
     }
     sections.push(section);
   }
@@ -1094,81 +1094,77 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
   // Claude limits section
   // When there's an error (e.g., auth expired), show it once and skip empty subsections
   if (claudeError) {
-    sections.push(`Claude limits\n${claudeError}\n`);
+    sections.push(`${lt('claude_limits', {}, { locale })}\n${claudeError}\n`);
   } else {
     // Claude 5 hour session (five_hour)
     // Threshold: One-at-a-time mode when usage >= 65%
-    let sessionSection = 'Claude 5 hour session\n';
-    if (usage && usage.currentSession.percentage !== null) {
-      // Add time passed progress bar first (no threshold marker for time)
+    let sessionSection = `${lt('claude_5_hour_session', {}, { locale })}\n`;
+    if (hasLimitPercentage(usage?.currentSession)) {
       const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
       if (timePassed !== null) {
         const timeBar = getProgressBar(timePassed);
-        sessionSection += `${timeBar} ${timePassed}% passed\n`;
+        sessionSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
       }
 
-      // Add usage progress bar second with threshold marker
       // Use Math.floor so 100% only appears when usage is exactly 100%
       // See: https://github.com/link-assistant/hive-mind/issues/1133
       const pct = Math.floor(usage.currentSession.percentage);
       const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ' used';
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_5_HOUR_SESSION ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
       sessionSection += `${bar} ${pct}%${suffix}\n`;
 
       if (usage.currentSession.resetTime) {
         const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
         if (relativeTime) {
-          sessionSection += `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n`;
+          sessionSection += `${formatLimitResetsIn(relativeTime, usage.currentSession.resetTime, { locale })}\n`;
         } else {
-          sessionSection += `Resets ${usage.currentSession.resetTime}\n`;
+          sessionSection += `${formatLimitResetsAt(usage.currentSession.resetTime, { locale })}\n`;
         }
       }
     } else {
-      sessionSection += 'N/A\n';
+      sessionSection += `${lt('na', {}, { locale })}\n`;
     }
     sections.push(sessionSection);
 
     // Current week (all models / seven_day)
     // Threshold: One-at-a-time mode when usage >= 97%
-    let allModelsSection = 'Current week (all models)\n';
-    if (usage && usage.allModels.percentage !== null) {
-      // Add time passed progress bar first (no threshold marker for time)
+    let allModelsSection = `${lt('current_week_all_models', {}, { locale })}\n`;
+    if (hasLimitPercentage(usage?.allModels)) {
       const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
       if (timePassed !== null) {
         const timeBar = getProgressBar(timePassed);
-        allModelsSection += `${timeBar} ${timePassed}% passed\n`;
+        allModelsSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
       }
 
-      // Add usage progress bar second with threshold marker
       // Use Math.floor so 100% only appears when usage is exactly 100%
       // See: https://github.com/link-assistant/hive-mind/issues/1133
       const pct = Math.floor(usage.allModels.percentage);
       const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
       allModelsSection += `${bar} ${pct}%${suffix}\n`;
 
       if (usage.allModels.resetTime) {
         const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
         if (relativeTime) {
-          allModelsSection += `Resets in ${relativeTime} (${usage.allModels.resetTime})\n`;
+          allModelsSection += `${formatLimitResetsIn(relativeTime, usage.allModels.resetTime, { locale })}\n`;
         } else {
-          allModelsSection += `Resets ${usage.allModels.resetTime}\n`;
+          allModelsSection += `${formatLimitResetsAt(usage.allModels.resetTime, { locale })}\n`;
         }
       }
     } else {
-      allModelsSection += 'N/A\n';
+      allModelsSection += `${lt('na', {}, { locale })}\n`;
     }
     sections.push(allModelsSection);
 
     // Current week (Sonnet only / seven_day_sonnet)
     // Threshold: One-at-a-time mode when usage >= 97% (same as all models)
-    let sonnetSection = 'Current week (Sonnet only)\n';
-    if (usage && usage.sonnetOnly.percentage !== null) {
+    let sonnetSection = `${lt('current_week_sonnet_only', {}, { locale })}\n`;
+    if (hasLimitPercentage(usage?.sonnetOnly)) {
       // Add time passed progress bar first (no threshold marker for time)
       const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
       if (timePassed !== null) {
         const timeBar = getProgressBar(timePassed);
-        sonnetSection += `${timeBar} ${timePassed}% passed\n`;
+        sonnetSection += `${timeBar} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
       }
 
       // Add usage progress bar second with threshold marker
@@ -1176,19 +1172,19 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
       // See: https://github.com/link-assistant/hive-mind/issues/1133
       const pct = Math.floor(usage.sonnetOnly.percentage);
       const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CLAUDE_WEEKLY);
-      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ' used';
+      const suffix = pct >= DISPLAY_THRESHOLDS.CLAUDE_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
       sonnetSection += `${bar} ${pct}%${suffix}\n`;
 
       if (usage.sonnetOnly.resetTime) {
         const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);
         if (relativeTime) {
-          sonnetSection += `Resets in ${relativeTime} (${usage.sonnetOnly.resetTime})\n`;
+          sonnetSection += `${formatLimitResetsIn(relativeTime, usage.sonnetOnly.resetTime, { locale })}\n`;
         } else {
-          sonnetSection += `Resets ${usage.sonnetOnly.resetTime}\n`;
+          sonnetSection += `${formatLimitResetsAt(usage.sonnetOnly.resetTime, { locale })}\n`;
         }
       }
     } else {
-      sonnetSection += 'N/A\n';
+      sonnetSection += `${lt('na', {}, { locale })}\n`;
     }
     sections.push(sonnetSection);
   }
@@ -1208,11 +1204,13 @@ export function formatUsageMessage(usage, diskSpace = null, githubRateLimit = nu
  *
  * @param {Object|null} codexLimits - Result object from getCodexUsageLimits, or null
  * @param {string|null} codexError - Optional error message
+ * @param {Object|string} options - Optional locale options
  * @returns {string} Formatted section text
  */
-export function formatCodexLimitsSection(codexLimits, codexError = null) {
+export function formatCodexLimitsSection(codexLimits, codexError = null, options = {}) {
+  const locale = resolveLimitLocale(options);
   if (codexError) {
-    return `Codex limits\n${codexError}\n`;
+    return `${lt('codex_limits', {}, { locale })}\n${codexError}\n`;
   }
 
   const usage = codexLimits?.usage || null;
@@ -1220,63 +1218,63 @@ export function formatCodexLimitsSection(codexLimits, codexError = null) {
   const credits = codexLimits?.credits || null;
   const planType = codexLimits?.planType || null;
 
-  let section = 'Codex limits\n';
+  let section = `${lt('codex_limits', {}, { locale })}\n`;
   if (planType) {
-    section += `Plan: ${planType}\n`;
+    section += `${lt('plan', {}, { locale })}: ${planType}\n`;
   }
 
-  let sessionSection = 'Codex 5 hour session\n';
-  if (usage?.currentSession?.percentage !== null) {
+  let sessionSection = `${lt('codex_5_hour_session', {}, { locale })}\n`;
+  if (hasLimitPercentage(usage?.currentSession)) {
     const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
     if (timePassed !== null) {
-      sessionSection += `${getProgressBar(timePassed)} ${timePassed}% passed\n`;
+      sessionSection += `${getProgressBar(timePassed)} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
     }
     const pct = Math.floor(usage.currentSession.percentage);
     const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION ? ' ⚠️' : ' used';
+    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_5_HOUR_SESSION ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     sessionSection += `${bar} ${pct}%${suffix}\n`;
     if (usage.currentSession.resetTime) {
       const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
-      sessionSection += relativeTime ? `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n` : `Resets ${usage.currentSession.resetTime}\n`;
+      sessionSection += relativeTime ? `${formatLimitResetsIn(relativeTime, usage.currentSession.resetTime, { locale })}\n` : `${formatLimitResetsAt(usage.currentSession.resetTime, { locale })}\n`;
     }
   } else {
-    sessionSection += 'N/A\n';
+    sessionSection += `${lt('na', {}, { locale })}\n`;
   }
 
-  let weeklySection = 'Current week (all models)\n';
-  if (usage?.allModels?.percentage !== null) {
+  let weeklySection = `${lt('current_week_all_models', {}, { locale })}\n`;
+  if (hasLimitPercentage(usage?.allModels)) {
     const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
     if (timePassed !== null) {
-      weeklySection += `${getProgressBar(timePassed)} ${timePassed}% passed\n`;
+      weeklySection += `${getProgressBar(timePassed)} ${timePassed}% ${lt('passed', {}, { locale })}\n`;
     }
     const pct = Math.floor(usage.allModels.percentage);
     const bar = getProgressBar(pct, DISPLAY_THRESHOLDS.CODEX_WEEKLY);
-    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_WEEKLY ? ' ⚠️' : ' used';
+    const suffix = pct >= DISPLAY_THRESHOLDS.CODEX_WEEKLY ? ' ⚠️' : ` ${lt('used', {}, { locale })}`;
     weeklySection += `${bar} ${pct}%${suffix}\n`;
     if (usage.allModels.resetTime) {
       const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
-      weeklySection += relativeTime ? `Resets in ${relativeTime} (${usage.allModels.resetTime})\n` : `Resets ${usage.allModels.resetTime}\n`;
+      weeklySection += relativeTime ? `${formatLimitResetsIn(relativeTime, usage.allModels.resetTime, { locale })}\n` : `${formatLimitResetsAt(usage.allModels.resetTime, { locale })}\n`;
     }
   } else {
-    weeklySection += 'N/A\n';
+    weeklySection += `${lt('na', {}, { locale })}\n`;
   }
 
   section += `${sessionSection}\n${weeklySection}`;
 
   if (additionalRateLimits.length > 0) {
-    section += '\nAdditional Codex limits\n';
+    section += `\n${lt('additional_codex_limits', {}, { locale })}\n`;
     for (const limit of additionalRateLimits) {
       const sessionPct = limit.currentSession?.percentage;
       const weeklyPct = limit.allModels?.percentage;
-      const sessionText = sessionPct === null ? 'session N/A' : `session ${Math.floor(sessionPct)}%`;
-      const weeklyText = weeklyPct === null ? 'week N/A' : `week ${Math.floor(weeklyPct)}%`;
+      const sessionText = sessionPct === null || sessionPct === undefined ? `${lt('session', {}, { locale })} ${lt('na', {}, { locale })}` : `${lt('session', {}, { locale })} ${Math.floor(sessionPct)}%`;
+      const weeklyText = weeklyPct === null || weeklyPct === undefined ? `${lt('week', {}, { locale })} ${lt('na', {}, { locale })}` : `${lt('week', {}, { locale })} ${Math.floor(weeklyPct)}%`;
       section += `${limit.limitName}: ${sessionText}, ${weeklyText}\n`;
     }
   }
 
   if (credits) {
-    const creditSummary = credits.unlimited ? 'unlimited' : `${credits.balance ?? '0'} balance`;
-    section += `\nCodex credits\n${creditSummary}\n`;
+    const creditSummary = credits.unlimited ? lt('unlimited', {}, { locale }) : `${credits.balance ?? '0'} ${lt('balance', {}, { locale })}`;
+    section += `\n${lt('codex_credits', {}, { locale })}\n${creditSummary}\n`;
   }
 
   return section;