zames_pro 2.72.9 → 2.73.0

package/dist/qwen-chats.js

@@ -0,0 +1,183 @@
+// PURE scraping/parsing helpers for the Qwen provider (chat.qwen.ai).
+//
+// WHY a separate module (mirroring browser-chats.ts for DeepSeek): the chat
+// list and the restored dialogue are read from a page we do not control, so
+// the scraping policy must have ONE home that can be unit-tested WITHOUT
+// Playwright. These functions run INSIDE page.evaluate, so they must not close
+// over module scope — they use only their arguments and DOM globals.
+//
+// Values verified against a live guest session:
+//   chat links  -> a[href*="/c/"] (a guest chat is /c/guest, skipped)
+//   messages    -> markdown/answer blocks inside message containers
+// Pull the chat id out of a Qwen chat link. A guest chat (/c/guest) is not a
+// real, resumable chat and is filtered by the caller.
+const CHAT_HREF_RE = /\/c\/([A-Za-z0-9_-]+)/;
+/**
+ * In-page scraper for the sidebar chat list. Returns the links' ids/titles in
+ * document order, de-duplicated, capped at `limit`. A guest session has no
+ * sidebar history, so the result is legitimately empty.
+ */
+export function scrapeQwenChatList(limit) {
+    const out = [];
+    const seen = new Set();
+    const anchors = document.querySelectorAll('a[href*="/c/"], a[href*="/chat"]');
+    for (const a of Array.from(anchors)) {
+        const href = a.getAttribute('href') || '';
+        const m = href.match(CHAT_HREF_RE);
+        if (!m)
+            continue;
+        if (m[1] === 'guest')
+            continue;
+        if (seen.has(m[1]))
+            continue;
+        seen.add(m[1]);
+        const titleEl = a.querySelector('[class*="title"], [class*="name"]');
+        const title = ((titleEl ? titleEl.textContent : a.textContent) || '')
+            .trim()
+            .replace(/\s+/g, ' ');
+        out.push({ id: m[1], title });
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+/**
+ * In-page scraper for the WHOLE visible dialogue of the open chat. Nested
+ * duplicate containers are collapsed to the OUTERMOST one: the broad
+ * `[class*="message"]` chain matched both an outer wrapper and an inner block,
+ * which printed every turn TWICE (observed live: 'assistant:teal' twice).
+ * Reasoning blocks (think class, on the node or an ancestor) are skipped.
+ */
+export function scrapeQwenChatMessages(opts) {
+    const thinkRe = new RegExp(opts.thinkRe, 'i');
+    const assistantRe = new RegExp(opts.assistantRe, 'i');
+    const inThink = (e) => {
+        let n = e;
+        while (n) {
+            if (thinkRe.test((n.className || '').toString()))
+                return true;
+            n = n.parentElement;
+        }
+        return false;
+    };
+    let containers = [];
+    for (const sel of opts.containerSels) {
+        const found = Array.from(document.querySelectorAll(sel)).filter((e) => !inThink(e) && (e.textContent || '').trim().length > 0);
+        if (found.length) {
+            containers = found;
+            break;
+        }
+    }
+    const uniq = Array.from(new Set(containers));
+    // Keep only the OUTERMOST block of a nested pair.
+    const blocks = uniq.filter((b) => !uniq.some((o) => o !== b && o.contains(b)));
+    const out = [];
+    for (const c of blocks) {
+        let node = c.querySelector('[class*="markdown"], [class*="answer"]');
+        const isAssistant = assistantRe.test(c.className || '') || !!node;
+        if (!node)
+            node = c;
+        const text = (node.textContent || '').trim();
+        if (!text)
+            continue;
+        out.push({ role: isAssistant ? 'assistant' : 'user', text });
+    }
+    return out;
+}
+// ---------- API payload parsers (pure, unit-tested) ----------
+/**
+ * Parse the chat list from `GET /api/v2/chats/?page=1&exclude_project=true`.
+ * The shape has drifted between builds, so accept several:
+ *   { data: [ {id,title} ] }, { data: { chats: [...] } }, { data: { list: [...] } }.
+ * Returns [] for anything unrecognizable (never throws).
+ */
+export function parseQwenChatList(json) {
+    const root = json;
+    const data = root && typeof root === 'object' ? root.data : null;
+    const arr = Array.isArray(data)
+        ? data
+        : data && typeof data === 'object'
+            ? (data.chats ??
+                data.list ??
+                data.items)
+            : null;
+    if (!Array.isArray(arr))
+        return [];
+    const out = [];
+    for (const c of arr) {
+        if (!c || typeof c !== 'object')
+            continue;
+        const m = c;
+        const id = typeof m.id === 'string'
+            ? m.id
+            : typeof m.chat_id === 'string'
+                ? m.chat_id
+                : '';
+        if (!id)
+            continue;
+        const title = (typeof m.title === 'string' && m.title) ||
+            (typeof m.name === 'string' && m.name) ||
+            '';
+        out.push({ id, title: title.trim() });
+    }
+    return out;
+}
+/**
+ * Parse one chat's history from `GET /api/v2/chats/<id>?direction=up&limit=N`.
+ * Accepts the plausible shapes:
+ *   { data: { messages: [...] } }, { data: { chat: { messages } } }, { data: [...] }.
+ * A message's text is taken from `content` (string) or from `fragments[]`
+ * (a DeepSeek-style payload: keep REQUEST for user, RESPONSE for assistant).
+ */
+export function parseQwenHistory(json) {
+    const root = json;
+    const data = root && typeof root === 'object' ? root.data : null;
+    let arr = null;
+    if (Array.isArray(data))
+        arr = data;
+    else if (data && typeof data === 'object') {
+        const d = data;
+        if (Array.isArray(d.messages))
+            arr = d.messages;
+        else if (d.chat && typeof d.chat === 'object') {
+            const chat = d.chat;
+            if (Array.isArray(chat.messages))
+                arr = chat.messages;
+        }
+    }
+    if (!Array.isArray(arr))
+        return [];
+    const out = [];
+    for (const raw of arr) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const m = raw;
+        // Role detection is DEFENSIVE: the field has been `role` (string,
+        // case-insensitive), a numeric flag, or `is_user`. Anything that is not
+        // clearly the user is treated as the assistant (the restored dialogue
+        // cares about the distinction, not the exact enum).
+        const roleStr = String(m.role ?? '').toLowerCase();
+        const isUser = roleStr === 'user' ||
+            roleStr === '0' ||
+            m.is_user === true ||
+            m.from === 'user';
+        const role = isUser ? 'user' : 'assistant';
+        let text = '';
+        if (typeof m.content === 'string')
+            text = m.content;
+        else if (typeof m.text === 'string')
+            text = m.text;
+        else if (Array.isArray(m.fragments)) {
+            const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+            for (const fr of m.fragments) {
+                if (fr && fr.type === want && typeof fr.content === 'string') {
+                    text += fr.content;
+                }
+            }
+        }
+        text = text.trim();
+        if (text)
+            out.push({ role, text });
+    }
+    return out;
+}

package/dist/qwen-net-capture.js

@@ -0,0 +1,221 @@
+// Extraction of the RAW model answer from Qwen Chat's (chat.qwen.ai) network
+// data. The DOM distorts the answer (markdown/LaTeX/link auto-detection), so
+// — exactly like the DeepSeek path (net-capture.ts) — the answer the agent
+// consumes is parsed from the intercepted SSE stream instead of the rendered
+// page.
+//
+// Qwen's completions stream (POST /api/v2/chat/completions?chat_id=...):
+//   data: {"response.created": {chat_id, response_id, ...}}
+//   data: {"response.info": {"action": "keep_alive", ...}}
+//   data: {"choices":[{"delta":{"role":"assistant","content":"",
+//                            "phase":"thinking_summary","extra":{...}},
+//                       "status":"typing"}], "usage":{...}}
+//   data: {"choices":[{"delta":{"role":"assistant","content":"PONG",
+//                            "phase":"answer","status":"typing"}}], ...}
+//   data: {"choices":[{"delta":{"content":"","role":"assistant",
+//                            "status":"finished","phase":"answer"}}]}
+//
+// The answer text is the concatenation of delta.content chunks whose
+// `phase` is NOT the reasoning phase (`thinking_summary`). Reasoning must
+// never leak into the answer (same rule as DeepSeek's THINK fragments).
+//
+// `usage` carries input_tokens/output_tokens/total_tokens — the closest thing
+// Qwen exposes to "used context" (there is no accumulated_token_usage).
+const NL = String.fromCharCode(10);
+function parseDataLines(body) {
+    const out = [];
+    for (const line of String(body || '').split(NL)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:'))
+            continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === '[DONE]')
+            continue;
+        try {
+            const obj = JSON.parse(payload);
+            if (obj && typeof obj === 'object')
+                out.push(obj);
+        }
+        catch { }
+    }
+    return out;
+}
+// True when a delta chunk is part of the reasoning (thinking) phase, which is
+// NOT the answer.
+function isThinkingPhase(delta) {
+    const phase = delta.phase;
+    return typeof phase === 'string' && /think/i.test(phase);
+}
+// Assembles the answer text from the Qwen SSE stream. Also accepts an
+// OpenAI-compatible shape (choices[].delta.content) as a safety net, and
+// ignores reasoning_content there as well.
+export function extractFromSse(body) {
+    let out = '';
+    for (const obj of parseDataLines(body)) {
+        const choices = obj.choices;
+        if (!Array.isArray(choices))
+            continue;
+        for (const ch of choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta && typeof c.delta === 'object'
+                ? c.delta
+                : c.message && typeof c.message === 'object'
+                    ? c.message
+                    : null;
+            if (!delta)
+                continue;
+            if (isThinkingPhase(delta))
+                continue;
+            const content = delta.content;
+            if (typeof content === 'string' && content)
+                out += content;
+        }
+    }
+    return out;
+}
+// A plain JSON body (a non-streamed response) — pick the first string content
+// that is not reasoning. Best-effort; the live stream is SSE.
+export function extractFromJson(body) {
+    let obj;
+    try {
+        obj = JSON.parse(body);
+    }
+    catch {
+        return '';
+    }
+    return pickAnswer(obj);
+}
+function pickAnswer(node) {
+    if (node == null)
+        return '';
+    if (typeof node === 'string')
+        return node;
+    if (Array.isArray(node))
+        return node.map(pickAnswer).join('');
+    if (typeof node !== 'object')
+        return '';
+    const obj = node;
+    if (Array.isArray(obj.choices)) {
+        let out = '';
+        for (const ch of obj.choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta && typeof c.delta === 'object'
+                ? c.delta
+                : c.message && typeof c.message === 'object'
+                    ? c.message
+                    : c;
+            if (isThinkingPhase(delta))
+                continue;
+            const content = delta.content;
+            if (typeof content === 'string')
+                out += content;
+        }
+        if (out)
+            return out;
+    }
+    for (const key of ['content', 'text', 'answer']) {
+        const v = obj[key];
+        if (typeof v === 'string' && v)
+            return v;
+    }
+    return '';
+}
+// A universal attempt: first SSE, then regular JSON.
+export function extractAnswer(body) {
+    const sse = extractFromSse(body);
+    if (sse)
+        return sse;
+    return extractFromJson(body);
+}
+// The CONTEXT size (in tokens) Qwen reports in the `usage` object of the SSE
+// stream. `input_tokens` is the PROMPT size for the turn — the best match for
+// "how much context is used", the same idea as DeepSeek's
+// accumulated_token_usage. (`total_tokens` = prompt + answer, so it inflates
+// the number by the answer length; it is only the fallback when input_tokens
+// is absent.) Null when the body carries no usage.
+export function extractTokenUsage(body) {
+    let lastInput = null;
+    let lastTotal = null;
+    for (const obj of parseDataLines(body)) {
+        const usage = obj.usage;
+        if (!usage || typeof usage !== 'object')
+            continue;
+        const u = usage;
+        if (typeof u.input_tokens === 'number' && Number.isFinite(u.input_tokens))
+            lastInput = u.input_tokens;
+        if (typeof u.total_tokens === 'number' && Number.isFinite(u.total_tokens))
+            lastTotal = u.total_tokens;
+    }
+    if (lastInput !== null)
+        return lastInput;
+    if (lastTotal !== null)
+        return lastTotal;
+    // Plain JSON fallback (a non-streamed body).
+    try {
+        const obj = JSON.parse(body);
+        const usage = obj?.usage;
+        if (usage) {
+            if (typeof usage.input_tokens === 'number')
+                return usage.input_tokens;
+            if (typeof usage.total_tokens === 'number')
+                return usage.total_tokens;
+        }
+    }
+    catch { }
+    return null;
+}
+// True when the stream ENDED (a chunk with status "finished") but produced NO
+// answer content — the model finished with only a reasoning summary. The
+// caller then retries instead of waiting out the whole timeout. Mirrors
+// DeepSeek's isFinishedWithoutAnswer.
+export function isFinishedWithoutAnswer(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    let finished = false;
+    for (const obj of parseDataLines(b)) {
+        const choices = obj.choices;
+        if (!Array.isArray(choices))
+            continue;
+        for (const ch of choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const delta = ch.delta;
+            if (delta && delta.status === 'finished')
+                finished = true;
+        }
+    }
+    if (!finished)
+        return false;
+    return extractFromSse(b) === '';
+}
+// True when the body carries Qwen's rate-limit / busy notice, so ask() can
+// back off instead of waiting out the deadline. Matched against the RAW body.
+export function isRateLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    return /too many requests|rate limit|too frequent|please try again later|слишком часто/i.test(b);
+}
+// The GUEST daily limit is a DIFFERENT failure from a transient rate limit:
+// Qwen answers `RateLimited` with "You've reached the guest chat limit for
+// today's usage. Log in to continue." Retrying after `rateLimitWaitMs` cannot
+// help (it resets the next day); the operator must sign in. Detected from the
+// raw body so ask() can fail fast with a clear "log in" message instead of
+// burning the whole retry budget.
+export function isGuestLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    return /guest chat limit|guest.*limit|log in to continue|гостевой лимит/i.test(b);
+}
+export function isServerBusyText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    return /server is busy|service unavailable|try again later/i.test(b);
+}

package/dist/qwen-ui.js

@@ -0,0 +1,160 @@
+// Qwen Chat (chat.qwen.ai) UI constants — the SINGLE place where the Qwen
+// web app's specifics live.
+//
+// WHY this mirrors deepseek-ui.ts: zames drives the site through Playwright,
+// so every selector and protocol marker is a hardcoded assumption about a
+// page we do not control. Concentrating them here turns "Qwen redesigned the
+// UI" into ONE file to audit and lets probeUiHealth report the exact broken
+// capability BEFORE a task hangs on it.
+//
+// Values verified against a live guest session (headless Chromium):
+//   input  -> textarea.message-input-textarea (placeholder "Ask Qwen")
+//   send   -> button.send-button (aria-label "Send")
+//   model  -> .wms-trigger (aria-label "Select Model")
+//   new    -> .new-chat (aria-label "New Chat")
+// The API is a two-step v2 flow: POST /api/v2/chats/new -> { id }, then
+// POST /api/v2/chat/completions?chat_id=<id> (SSE, see qwen-net-capture.ts).
+// ---------- endpoints ----------
+export const CHAT_URL = 'https://chat.qwen.ai/';
+// A logged-in chat lives at /c/<id>; a guest chat is /c/guest.
+export const CHAT_ID_RE = /\/c\/([A-Za-z0-9_-]+)/;
+export function chatUrl(id) {
+    return CHAT_URL + 'c/' + id;
+}
+// The two-step API. `NEW_CHAT_URL` creates a chat and returns its id;
+// `COMPLETIONS_URL(id)` streams the answer.
+export const NEW_CHAT_URL = 'https://chat.qwen.ai/api/v2/chats/new';
+export const MODELS_URL = 'https://chat.qwen.ai/api/v2/models/';
+// The chat list, newest first, EXCLUDING project chats (verified live on a
+// signed-in session). Used by listChats() instead of scraping the sidebar.
+export const CHAT_LIST_URL = 'https://chat.qwen.ai/api/v2/chats/?page=1&exclude_project=true';
+// One chat's messages: GET /api/v2/chats/<id>?direction=up&limit=N. Verified
+// live while switching chats. Used by fetchChatMessages().
+export function chatHistoryUrl(chatId, limit = 50) {
+    return ('https://chat.qwen.ai/api/v2/chats/' +
+        encodeURIComponent(chatId) +
+        '?direction=up&limit=' +
+        String(limit));
+}
+export function completionsUrl(chatId) {
+    return ('https://chat.qwen.ai/api/v2/chat/completions?chat_id=' +
+        encodeURIComponent(chatId));
+}
+// The completions SSE endpoint carries the real answer; used to gate the
+// network capture so an unrelated JSON endpoint never clobbers it.
+export const ANSWER_URL_RE = /\/api\/v2\/chat\/completions/i;
+// ---------- input ----------
+export const INPUT_SELECTORS = [
+    'textarea.message-input-textarea',
+    'textarea[placeholder="Ask Qwen"]',
+    'textarea',
+    'div[contenteditable="true"]',
+    '[role="textbox"]',
+];
+// ---------- send ----------
+// The send control is a <button class="send-button"> with aria-label "Send".
+// A generic primary button is deliberately NOT matched: it could be the Stop
+// control, which would make _isGenerating() always true.
+export const SEND_SELECTORS = [
+    'button.send-button',
+    'button[aria-label="Send" i]',
+    '.message-input-right-button-send button',
+    'button[type="submit"]',
+];
+// ---------- stop ----------
+export const STOP_SELECTORS = [
+    'button[aria-label*="stop" i]',
+    'button[aria-label*="останов" i]',
+    'button.stop-button',
+    'button:has-text("Stop")',
+];
+export const STOP_NAME_RE = /^(?:stop|остановить)(?:\s+\S{0,20})?\s*[.!…]?$/i;
+// ---------- new chat ----------
+export const NEW_CHAT_SELECTOR = '.new-chat, button[aria-label="New Chat" i]';
+// ---------- model selector ----------
+// The current model label sits in the header. It is read-only for the UI; the
+// 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';
+// ---------- 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.
+export const AGE_GATE_MODAL = '.age-confirmation-modal';
+export const AGE_GATE_CONTINUE = '.age-confirmation-modal .qwen-chat-v2-btn-black';
+// The cookie banner's accept button (matched by its visible label).
+export const COOKIE_ACCEPT_RE = /^accept all cookies$/i;
+// ---------- messages / answers ----------
+// Assistant answers render as markdown blocks. The class names drift between
+// builds, so a content wrapper is tried first, then the generic markdown.
+export const ANSWER_SELECTORS = [
+    '[class*="markdown-content"]',
+    '[class*="markdown"]',
+    '[class*="answer"]',
+];
+// Reasoning / thinking summaries are NOT the answer and must never be picked
+// up as one (the terminal would show the model's long reasoning).
+export const THINK_CLASS_RE = /thinking|think-content|think_summary/i;
+// Message-level containers for the restored dialogue (broad first).
+export const MESSAGE_CONTAINER_SELECTORS = [
+    '[class*="chat-message"]',
+    '[class*="message-item"]',
+    '[data-message-id]',
+    '[class*="message"]',
+];
+export const ASSISTANT_CLASS_RE = /assistant|answer|markdown/i;
+// A cheap "did the page grow?" signal: count message nodes and measure the
+// last answer node's text length (no full-body innerText walk).
+export const CHAT_SIGNAL_NODES_SELECTOR = '[class*="markdown"], [class*="chat-message"], [class*="message-item"]';
+export const MARKDOWN_SELECTOR = '[class*="markdown"]';
+// ---------- attachments ----------
+// The attach flow on Qwen: click the "+" (`.mode-select-open`) to open the
+// mode menu, then the "Upload attachment" item — that click fires a real
+// filechooser. The hidden <input id="filesUpload"> is the fallback (setting
+// files on it directly).
+export const ATTACH_MENU_TRIGGER = '.mode-select-open';
+export const ATTACH_MENU_ITEM_RE = /upload attachment/i;
+export const ATTACH_SELECTORS = ['input#filesUpload', 'input[type="file"]'];
+// ---------- login ----------
+// Qwen's sign-in is a SEPARATE origin (auth.qwen.ai) opened from the header
+// "Log in" button. Email / Google / GitHub are accepted; no phone required.
+export const LOGIN_BUTTON_RE = /^\s*(log ?in|sign ?in|войти)\s*$/i;
+export const PASSWORD_SELECTORS = [
+    'input[type="password"]',
+    'input[autocomplete="current-password"]',
+];
+export const LOGIN_SELECTORS = [
+    'input[type="email"]',
+    'input[name="email"]',
+    'input[placeholder*="email" i]',
+    'input[autocomplete="email"]',
+    'input[autocomplete="username"]',
+];
+// ---------- service statuses / errors ----------
+// A generic "generating" label that must never be taken for an answer.
+export const STATUS_RE = /^(thinking|searching|generating|thinking completed|остановить|stop)[\s.…]*$/i;
+// Qwen's rate-limit / busy notices (best-effort; the toast may be short-lived).
+export const RATE_LIMIT_RE = /too many requests|rate limit|too frequent|please try again later|слишком часто/i;
+export const SERVER_BUSY_RE = /server is busy|service unavailable|try again later/i;
+// ---------- toggles ----------
+// The "Auto" thinking/search toggle and the mode selector. Read-only probing
+// support; the model's thinking mode is set via config when supported.
+// ---------- toggles (thinking mode / web search) ----------
+// Qwen exposes thinking as a MODE dropdown (`.qwen-thinking-selector`, label
+// "Auto" by default) with options Auto / Thinking / Fast — NOT a boolean
+// toggle like DeepSeek. Web search is an item in the "+" (mode) menu. Both
+// are applied best-effort before a send.
+export const THINKING_SELECTOR = '.qwen-thinking-selector';
+// Menu options that select a thinking mode (matched by normalized label).
+export const THINKING_MODE_RE = /thinking|размышл/i;
+export const FAST_MODE_RE = /fast|quick|быстр/i;
+// The "+" (mode) menu item that enables web search.
+export const WEB_SEARCH_MENU_RE = /web search|поиск в интернет|веб-поиск/i;
+// Advisory probe selectors (the mode button is always present).
+export const TOGGLE_SELECTORS = [
+    THINKING_SELECTOR,
+    '.mode-select-open',
+    '[role="switch"]',
+    'div[role="button"][aria-pressed]',
+];
+export const DEEP_THINKING_RE = /think|reason|размышл/i;
+export const WEB_SEARCH_RE = /search|поиск/i;

package/dist/run-task.js

@@ -1,6 +1,7 @@
 import { theme } from './theme.js';
 import { withGoal, mergeMessages, isSlashCommand, formatDuration, } from './commands.js';
 import { formatCompactTokens, pasteReplacement, expandPastes } from './input.js';
+import { providerAskDeadlineMs } from './config.js';
 // Ask the operator to approve a tool call flagged by an `ask` permission rule
 // (C1). While the LineEditor owns the terminal it must be paused first, or the
 // confirmation prompt and the input line fight for the same keys. A non-TTY run
@@ -349,7 +350,7 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
                 onChatReady,
                 debugLog: debug,
                 locale,
-                askDeadlineMs: config.browser.askDeadlineMs,
+                askDeadlineMs: providerAskDeadlineMs(config),
                 maxAfterToolRetries: config.browser.maxAfterToolRetries,
                 // Auto-compact between tool calls when the context nears the window
                 // limit. The callback is provided by the caller so it can refresh the

package/dist/sessions.js

@@ -51,7 +51,7 @@ function safeName(id) {
 }
 // Save/update a session. workdir is needed so that when launched from the same
 // project we restore exactly its last chat.
-export function saveSession({ id, title = '', workdir = '', todos, }) {
+export function saveSession({ id, title = '', workdir = '', todos, provider, }) {
     if (!id)
         return null;
     try {
@@ -70,6 +70,7 @@ export function saveSession({ id, title = '', workdir = '', todos, }) {
             createdAt: prev.createdAt || now,
             updatedAt: now,
             version: SESSIONS_FORMAT_VERSION,
+            provider: provider || prev.provider || 'deepseek',
         };
         // Keep the previous checklist unless a new one is explicitly passed —
         // saveLastChat() calls this for title/workdir only and must not wipe it.
@@ -107,7 +108,12 @@ function writeIndex({ id, workdir }) {
 }
 // The last session for the working directory. If there is none —
 // we return the last session overall (useful when launched from a new place).
-export function loadLastSession(workdir = '') {
+// The last session for the working directory, restricted to `provider` when
+// given. A chat id only exists on ITS backend, so restoring a DeepSeek chat
+// while the active provider is Qwen (or vice versa) would fail to open — the
+// filter makes auto-restore and /last pick the right one (and fall back to the
+// global last only within the same provider).
+export function loadLastSession(workdir = '', provider) {
     try {
         const index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8'));
         const byWorkdir = index && index.byWorkdir ? index.byWorkdir : {};
@@ -119,8 +125,13 @@ export function loadLastSession(workdir = '') {
             if (internal.has(id))
                 continue;
             const s = readSession(id);
-            if (s)
-                return s;
+            if (!s)
+                continue;
+            // Older files have no provider: treat them as deepseek (the only backend
+            // that existed when they were written).
+            if (provider && (s.provider || 'deepseek') !== provider)
+                continue;
+            return s;
         }
         return null;
     }