zames_pro 2.75.2 → 2.75.4

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.75.4] - 2026-10-15
+
+### Added
+
+- **qwen:** per-model context window for the status bar and auto-compact
+
+### Changed
+
+- **test:** format qwen-context test with prettier
+
+## [2.75.3] - 2026-10-15
+
+### Fixed
+
+- **markdown:** always apply the theme in rendered answers; rename logo-small.jpg to logo.jpg
+
 ## [2.75.2] - 2026-10-15
 
 ### Changed

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/Viqto0r/zames_pro/master/logo-small.jpg" alt="zames logo" width="430">
+  <img src="https://raw.githubusercontent.com/Viqto0r/zames_pro/master/logo.jpg" alt="zames logo" width="430">
 </p>
 
 <h1 align="center">zames_pro</h1>

package/dist/config.js

@@ -21,6 +21,13 @@ export const DEFAULTS = {
     qwen: {
         model: '',
         enabled: false,
+        // Qwen's context window is PER-MODEL, not a site constant: Qwen3-Max is
+        // 258K while the 3.7/3.8-Max and Coder builds are 1M. The default assumes
+        // the common Qwen3-Max; `/model` re-derives it from the picked id (see
+        // qwenContextWindow in src/qwen-ui.ts) and `/config set qwen.contextLimit`
+        // overrides it. Kept SEPARATE from ui.contextLimit (DeepSeek's 1M) so one
+        // backend's window never becomes the other's denominator.
+        contextLimit: 258_048,
         // Qwen DOES rate-limit a rapid burst: measured live, the 5th back-to-back
         // send at 0 ms gap hit "too frequent" and needed a 5-min back-off. A 1 s
         // gap was too small for a real editing session, so the default is now 4 s
@@ -237,6 +244,14 @@ export const CONFIG_SCHEMA = [
         labelKey: 'cfg.f.qwen_model',
         groupKey: 'cfg.group.browser',
     },
+    {
+        path: 'qwen.contextLimit',
+        type: 'number',
+        min: 10_000,
+        max: 10_000_000,
+        labelKey: 'cfg.f.qwen_contextLimit',
+        groupKey: 'cfg.group.browser',
+    },
     {
         path: 'qwen.minSendIntervalMs',
         type: 'number',

package/dist/i18n/config.js

@@ -11,6 +11,10 @@ export const configMessages = {
         ru: 'Модель Qwen (id)',
         en: 'Qwen model (id)',
     },
+    'cfg.f.qwen_contextLimit': {
+        ru: 'Qwen: размер контекста, токены (258K у Qwen3-Max, 1M у 3.7/3.8/Coder)',
+        en: 'Qwen: context window, tokens (258K on Qwen3-Max, 1M on 3.7/3.8/Coder)',
+    },
     'cfg.f.qwen_minSendIntervalMs': {
         ru: 'Qwen: пауза между отправками (мс)',
         en: 'Qwen: pause between sends (ms)',

package/dist/index.js

@@ -33,6 +33,7 @@ import { applyBrowserLiveConfig, applyStoreLiveConfig } from './config-live.js';
 import { buildHandoffText, saveProviderHandoff, readProviderHandoff, clearProviderHandoff, } from './provider-handoff.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { createCliArgs } from './cli-args.js';
+import { qwenContextWindow } from './qwen-ui.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
 import { extractCodeBlocks } from './code-blocks.js';
 import { contentWidth } from './width.js';
@@ -660,6 +661,42 @@ function providerAnswerTimeoutMs() {
 function browserProviderUrl() {
     return providerChatUrlPrefix(config.provider);
 }
+/**
+ * The context window (tokens) for the ACTIVE provider. The two backends
+ * advertise different windows and Qwen's is PER-MODEL, so a single global
+ * number would either overstate Qwen's (258K models) or understate the 1M
+ * builds — and the number is the denominator of the auto-compact threshold,
+ * so an error directly delays (or prematurely fires) compaction.
+ *
+ * `config.qwen.contextLimit` / `ui.contextLimit` are the operator-tunable
+ * values; `/model` rewrites the Qwen one from the picked model id.
+ */
+function effectiveContextLimit() {
+    if (config.provider === 'qwen') {
+        return config.qwen.contextLimit > 0
+            ? config.qwen.contextLimit
+            : config.ui.contextLimit;
+    }
+    return config.ui.contextLimit;
+}
+/**
+ * Re-derive `qwen.contextLimit` from a picked model id and persist it. Called
+ * by `/model` on an explicit pick (never on startup), so a manual
+ * `/config set qwen.contextLimit` survives until the operator switches model
+ * again. An UNKNOWN model id leaves the limit alone: guessing would either
+ * fire auto-compact too early or too late. The live editor is repainted by
+ * the caller (it owns the `editor` reference); this only touches config.
+ */
+function applyModelContextLimit(model) {
+    const window = qwenContextWindow(model);
+    if (window === null)
+        return;
+    config.qwen.contextLimit = window;
+    try {
+        writeConfigValue('home', 'qwen.contextLimit', String(window));
+    }
+    catch { }
+}
 /**
  * Build the browser for a provider. Called at startup AND on a live
  * `/provider` switch, so both paths construct the class the same way. The
@@ -756,8 +793,9 @@ async function printRestoredHistory(browser, ui, chatId = null) {
         out(theme.dim(t('chats.history_tokens', { v: String(restoredTokens) })));
         // Warn when the restored chat is near the context limit, and suggest
         // /compact. The threshold mirrors the auto-compact one so the operator
-        // sees the same signal whether or not auto-compact is enabled.
-        const limit = config.ui.contextLimit;
+        // sees the same signal whether or not auto-compact is enabled. The limit
+        // is the ACTIVE provider's window (Qwen's is per-model).
+        const limit = effectiveContextLimit();
         if (limit > 0) {
             const pct = (restoredTokens / limit) * 100;
             if (pct >= 80) {
@@ -1292,8 +1330,10 @@ async function main() {
         // Task-list summary ("tasks: 2/5") before the context counter. Pulled on
         // every render, like the queue badge.
         ed.onTasksQuery = () => todosSummary();
-        // Use the configured context window for the fill percentage/color.
-        ed.setContextLimit(config.ui.contextLimit);
+        // Use the configured context window for the fill percentage/color. The
+        // window is PROVIDER-dependent: Qwen's is per-model (258K/1M, see
+        // qwenContextWindow), DeepSeek's is the ui.contextLimit.
+        ed.setContextLimit(effectiveContextLimit());
         // Toggle icons (🧠 deep thinking, 🌐 web search) before the context
         // counter. The editor pulls the live state on every render.
         ed.onToggleQuery = () => browser.getToggleStatesSync();
@@ -1380,7 +1420,7 @@ async function main() {
                 chatId: currentChatId,
                 queueLength: pendingQueue.length,
                 tokens: browser.getLastTokenUsage(),
-                contextLimit: config.ui.contextLimit,
+                contextLimit: effectiveContextLimit(),
                 tasks: todosSummary(),
                 locale: currentLocale,
             });
@@ -1690,10 +1730,13 @@ async function main() {
         }
         // The context window size feeds the status-bar percentage and its color.
         // Apply it to the live editor immediately (the value is a plain number,
-        // no restart needed).
-        if (path === 'ui.contextLimit' && typeof value === 'number') {
+        // no restart needed). A change to EITHER provider's limit matters: the
+        // Qwen one is what a /model pick rewrites, and the active provider is
+        // what decides which value the editor shows.
+        if ((path === 'ui.contextLimit' || path === 'qwen.contextLimit') &&
+            typeof value === 'number') {
             if (editor) {
-                editor.setContextLimit(value);
+                editor.setContextLimit(effectiveContextLimit());
                 editor.refreshStatus();
             }
         }
@@ -2556,6 +2599,16 @@ async function main() {
                         config.qwen.model = picked;
                         if (typeof qb.model === 'string')
                             qb.model = picked;
+                        // Derive the context window from the picked model: Qwen windows
+                        // are per-model (258K vs 1M), and this number is the denominator
+                        // of the auto-compact threshold. The operator's manual
+                        // `/config set qwen.contextLimit` still wins afterwards (this
+                        // only runs on an explicit pick).
+                        applyModelContextLimit(picked);
+                        if (editor) {
+                            editor.setContextLimit(effectiveContextLimit());
+                            editor.refreshStatus();
+                        }
                         try {
                             writeConfigValue('home', 'qwen.model', picked);
                         }
@@ -2571,6 +2624,11 @@ async function main() {
             config.qwen.model = arg;
             if (typeof qb.model === 'string')
                 qb.model = arg;
+            applyModelContextLimit(arg);
+            if (editor) {
+                editor.setContextLimit(effectiveContextLimit());
+                editor.refreshStatus();
+            }
             try {
                 writeConfigValue('home', 'qwen.model', arg);
             }
@@ -3257,7 +3315,7 @@ async function main() {
                             saveLastChat(chatId, currentWorkdir);
                         }
                     },
-                    contextLimit: config.ui.contextLimit,
+                    contextLimit: effectiveContextLimit(),
                     getTokenUsage: () => browser.getLastTokenUsage(),
                     goal: sessionGoal,
                 });
@@ -3372,7 +3430,7 @@ async function main() {
                 mcpTools: mcpStatus.toolCount,
                 transcriptOk: !!transcript.file,
                 authSaved: authMarkerExists(),
-                contextLimit: config.ui.contextLimit,
+                contextLimit: effectiveContextLimit(),
                 hasOrigin: gitOk
                     ? (await runGitArgs(['remote'], currentWorkdir, 5000)).includes('origin')
                     : undefined,
@@ -3890,7 +3948,7 @@ async function main() {
                     }
                     : null,
                 autoCompactPct: config.browser.autoCompactPct,
-                contextLimit: config.ui.contextLimit,
+                contextLimit: effectiveContextLimit(),
                 getTokenUsage: () => browser.getLastTokenUsage(),
                 goal: sessionGoal,
                 // Completion-goal mode (Claude Code parity): the goal is a CONDITION,

package/dist/markdown.js

@@ -1,5 +1,6 @@
 import { render } from 'markdansi';
 import { highlight } from 'cli-highlight';
+import supportsHyperlinks from 'supports-hyperlinks';
 const theme = {
     heading: { color: '#9fb8d8', bold: true },
     strong: { color: '#e6e0cc', bold: true },
@@ -37,16 +38,31 @@ export function setAnswerWidth(width) {
 export function renderMarkdown(text) {
     if (!text)
         return '';
+    // NO_COLOR (https://no-color.org) is the ONE color opt-out. markdansi
+    // builds its OWN Chalk instance, so the `chalk.level = 0` that theme.ts
+    // sets for NO_COLOR never reaches it; without this guard the answers would
+    // stay colored while everything else went plain.
+    if (process.env.NO_COLOR)
+        return String(text);
     try {
         const width = contentWidth();
         return render(String(text), {
             width,
+            // markdansi infers color support itself (`process.stdout.isTTY`), so
+            // under a non-TTY stdout — a piped answer, `--json`, a test — it emitted
+            // PLAIN text and the whole theme below was silently unused (answers
+            // looked unformatted). `color: true` makes it always emit SGR; the ONE
+            // opt-out is NO_COLOR, handled above.
+            color: true,
             theme: theme,
             highlighter,
             codeBox: true,
             tableBorder: 'unicode',
             listIndent: 2,
-            hyperlinks: false,
+            // OSC-8 hyperlinks: the URL disappears into a clickable label. Only
+            // when the terminal advertises support — otherwise the raw URL is
+            // printed, which is the safer default for a log that may be piped.
+            hyperlinks: supportsHyperlinks.stdout,
         });
     }
     catch {

package/dist/qwen-ui.js

@@ -76,6 +76,47 @@ export const NEW_CHAT_SELECTOR = '.new-chat, button[aria-label="New Chat" i]';
 // model itself is chosen via the config (sent with each completion request)
 // unless a per-session override is set.
 export const MODEL_TRIGGER_SELECTOR = '.wms-trigger';
+// ---------- context windows ----------
+// Qwen's per-model context window (tokens). The window is a property of the
+// MODEL, not the site: Qwen3-Max is 258K while the 3.7/3.8-Max and Coder
+// builds are 1M. zames uses the number ONLY as the denominator for the
+// status-bar fill percentage and the auto-compact threshold, so a wrong value
+// either fires compaction far too late (window overstated) or too early.
+//
+// Matching is done on a NORMALIZED id: lowercased, non-alphanumerics dropped,
+// so `qwen3-max`, `Qwen3-Max` and `qwen3_max` all hit the same row. The list is
+// ordered MOST SPECIFIC first: a `qwen3-coder-plus` id must not stop at a
+// generic `qwen3` rule. Values verified against the public model cards
+// (contextwindows.dev / haimaker.ai) in October 2026.
+const CONTEXT_WINDOWS = [
+    // The 1M builds MUST be checked before the 258K `qwen3-max` family, or
+    // `qwen3.7-max` would match the shorter `max` rule first.
+    [/qwen3\.?7.?max/, 1_000_000],
+    [/qwen3\.?8.?max/, 1_000_000],
+    [/qwen3coder/, 1_000_000],
+    [/qwenlong/, 10_000_000],
+    [/qwen3max/, 258_048],
+    // Generic fallback: the OTHER qwen3 builds (Plus/Turbo/Flash) advertised 1M
+    // on their model cards, so an unknown qwen3 id gets 1M rather than the min.
+    [/qwen3/, 1_000_000],
+];
+/** Lowercase and drop every non-alphanumeric so `qwen3.7-max` -> `qwen37max`. */
+export function normalizeModelId(model) {
+    return String(model || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '');
+}
+/** The context window (tokens) for a Qwen model id, or null when unknown. */
+export function qwenContextWindow(model) {
+    const id = normalizeModelId(model);
+    if (!id)
+        return null;
+    for (const [re, window] of CONTEXT_WINDOWS) {
+        if (re.test(id))
+            return window;
+    }
+    return null;
+}
 // ---------- age gate / cookies ----------
 // A first-time visitor must confirm their birth year before chatting. The
 // dialog is an ant-modal; the Continue button is the black footer button.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.75.2",
+  "version": "2.75.4",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
-    "logo-small.jpg"
+    "logo.jpg"
   ],
   "scripts": {
     "start": "node ./dist/index.js",