zames_pro 2.75.5 → 2.76.0

package/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.76.0] - 2026-10-16
+
+### Added
+
+- bake methodology skills in, localize skill hints, fix Ctrl+Del and scroll-to-bottom
+
+## [2.75.6] - 2026-10-16
+
+### Added
+
+- **tools:** AskUser — a modal question with options (and a free-text escape)
+- **skills:** tell the model to check and read a matching skill before a non-trivial task
+
+### Fixed
+
+- **deepseek:** retry a FINISHED turn with only a truncated RESPONSE head
+- **tui:** default ui.mouseScroll back to true (wheel scrolls the log)
+- **tui:** default ui.mouseScroll back to false so native selection works
+
+### Changed
+
+- prune dead code, untrack one-off TUI probes, ship only postinstall
+- **tui:** drop the unused onCopy/hint affordance from CodeBlock
+- **tui:** drop the code-block copy feature (Ctrl+Y / /copy-code)
+
 ## [2.75.5] - 2026-10-15
 
 ### Fixed

package/README.md

@@ -258,8 +258,11 @@ The prompt is a small line editor with persistent history:
 Full-screen mode adds dialog navigation, so a long answer can be read and
 selected without leaving the terminal:
 
-- mouse wheel — scroll the dialog (never the input history; history is arrow
-  keys only). Selecting text needs `Shift`+click, the standard TUI convention.
+- `ui.mouseScroll=false` (default) — the terminal owns the mouse: normal text
+  selection works and the wheel is inert (it never scrolls the input history —
+  history is arrow keys only).
+- `ui.mouseScroll=true` — the app consumes the wheel and scrolls the dialog;
+  selecting text then needs `Shift`+click (the TUI convention).
 - `PgUp` / `PgDn` — move up/down the dialog half a screen.
 - `Home` / `End` — jump to the very top / bottom of the dialog (only while the
   input line is empty; with text typed they move the caret as usual).
@@ -838,8 +841,11 @@ zames
 В полноэкранном режиме добавляется навигация по диалогу, чтобы длинный ответ
 можно было прочитать и выделить не покидая терминал:
 
-- колесо мыши — скролл диалога (историю ввода колесо НЕ листает; история —
-  только стрелки). Выделение текста — `Shift`+клик, стандарт TUI.
+- `ui.mouseScroll=false` (по умолчанию) — терминал владеет мышью: обычное
+  выделение текста работает, колесо инертно (и никогда не листает историю
+  ввода — история только стрелками).
+- `ui.mouseScroll=true` — приложение перехватывает колесо и скроллит диалог;
+  выделение текста тогда — `Shift`+клик (стандарт TUI).
 - `PgUp` / `PgDn` — вверх/вниз по диалогу на пол-экрана.
 - `Home` / `End` — прыжок в самый верх / низ диалога (только когда строка ввода
   пуста; при набранном тексте они двигают курсор, как обычно).

package/dist/agent-loop.js

@@ -7,7 +7,7 @@ import { substituteAttachmentMarkers } from './commands.js';
 import { loadHooks, runPreToolUse, runPostToolUse, runLifecycleHooks, } from './hooks.js';
 import { loadPermissions, decidePermission, } from './permissions.js';
 import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, onAskUser = null, }) {
     // Resolve the hook config ONCE per task: a read per tool call would be
     // wasteful, and a mid-task edit of hooks.json is not something to chase.
     // `undefined` means "read .zames/hooks.json"; an explicit null disables
@@ -884,6 +884,66 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     }
                     continue;
                 }
+                // `AskUser` is a SEAM like `Task`: the CALLER owns the modal UI, the
+                // loop only relays the question and folds the answer back as the tool
+                // result. Intercepted BEFORE the unknown-tool branch so the tool can be
+                // handled even though its `fn` is a stub.
+                if (call.tool === 'AskUser') {
+                    const rawQ = typeof call.args.question === 'string'
+                        ? call.args.question.trim()
+                        : '';
+                    const opts = Array.isArray(call.args.options)
+                        ? call.args.options
+                            .map((o) => String(o ?? '').trim())
+                            .filter(Boolean)
+                            .slice(0, 6)
+                        : [];
+                    const recRaw = Number(call.args.recommended);
+                    const recommended = Number.isInteger(recRaw) && recRaw >= 0 && recRaw < opts.length
+                        ? recRaw
+                        : null;
+                    const allowText = call.args.allow_text !== false;
+                    if (!onAskUser || !rawQ || opts.length < 2) {
+                        const err = !onAskUser
+                            ? 'AskUser is not available in this run. Choose a sensible default, proceed, and state the assumption in your final answer.'
+                            : 'AskUser requires a non-empty `question` and at least two `options`. Proceed with your best judgement instead.';
+                        safeToolResult(err);
+                        transcript?.log('tool_error', { tool: 'AskUser', error: err });
+                        results.push({ tool: 'AskUser', result: err });
+                        continue;
+                    }
+                    syncToolAbort();
+                    safeToolCall('AskUser', call.args);
+                    transcript?.log('ask_user', {
+                        question: rawQ,
+                        options: opts,
+                        recommended,
+                        allowText,
+                    });
+                    let answer;
+                    try {
+                        answer = await onAskUser({
+                            question: rawQ,
+                            options: opts,
+                            recommended,
+                            allowText,
+                        });
+                    }
+                    catch (e) {
+                        answer = `AskUser error: ${e.message}`;
+                    }
+                    const out = answer === null || answer === ''
+                        ? '(the operator dismissed the question — choose a sensible default, proceed, and state the assumption)'
+                        : 'The operator answered: ' + answer;
+                    safeToolResult(out);
+                    transcript?.log('ask_user_result', { answer: out });
+                    results.push({ tool: 'AskUser', result: out });
+                    if (browser._abort || browser._stopped) {
+                        transcript?.log('user_aborted');
+                        return '(прервано пользователем)';
+                    }
+                    continue;
+                }
                 const tool = tools.find((t) => t.name === call.tool);
                 if (!tool) {
                     const err = `Unknown tool: ${call.tool}`;

package/dist/browser.js

@@ -459,15 +459,20 @@ export class DeepSeekBrowser {
                 const cid = url.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
                 if (cid)
                     this._netChatId = cid[0];
+                // A live hang: the turn ENDED (`quasi_status: FINISHED`) with no real
+                // answer — only reasoning, or a RESPONSE fragment truncated to a lone
+                // `{`. The extractor yields '' or the fragment, so the OLD
+                // `!extracted` guard skipped the check and the finish loop waited out
+                // the whole askDeadlineMs. Run the check on the RAW body regardless of
+                // whether a (bogus) fragment was extracted.
+                if (isFinishedWithoutAnswer(body)) {
+                    // The UI shows Stopped + Continue. Record it with a fresh timestamp
+                    // so the ask() loops do not wait out the timeout — they click
+                    // Continue / resend.
+                    this._netNoAnswer = true;
+                    this._netCapture = '';
+                }
                 if (!extracted) {
-                    if (isFinishedWithoutAnswer(body)) {
-                        // A FINISHED turn with NO RESPONSE fragment (only reasoning): the
-                        // UI shows Stopped + Continue. Record it with a fresh timestamp
-                        // so the ask() loops do not wait out the timeout — they click
-                        // Continue / resend.
-                        this._netNoAnswer = true;
-                        this._netCapture = '';
-                    }
                     // A truncated turn (generation_err / INCOMPLETE) also has no
                     // RESPONSE; make the body visible to the incomplete check by
                     // refreshing the timestamp.
@@ -2044,6 +2049,12 @@ export class DeepSeekBrowser {
         // Ticks since the SSE body reported FINISHED-with-answer while the DOM
         // heuristics kept the loop waiting (see the safety net below).
         let netFinishedTicks = 0;
+        // Ticks since the SSE body reported FINISHED but produced NO real answer
+        // (only reasoning / a truncated head) while no Continue button was found.
+        // Waiting out the full answerTimeoutMs (up to 15 min) on a turn the server
+        // already ENDED with nothing is pointless — after a short grace period the
+        // loop gives up so ask() resends the prompt instead of a 4-minute spinner.
+        let deadTicks = 0;
         while (Date.now() < deadline) {
             if (this._abort || this._askCancelled) {
                 return last || '(прервано пользователем)';
@@ -2160,6 +2171,27 @@ export class DeepSeekBrowser {
             else {
                 netFinishedTicks = 0;
             }
+            // DEAD-TURN SAFETY NET. The server ENDED the turn (`quasi_status:
+            // FINISHED`) but produced no real answer (only reasoning, or a truncated
+            // RESPONSE head) AND there is no Continue button to resume it. The
+            // `truncated`/`noAnswer` branches above throw at once when the raw body
+            // says so; this is the belt-and-braces variant that also covers a body
+            // whose flags were cleared by an earlier Continue click. Waiting out the
+            // full answerTimeoutMs (up to 15 min) is pointless — after a short grace
+            // period give up so ask() resends the prompt instead of a long spinner.
+            if (this._netCaptureAt >= this._lastSentAt &&
+                isFinishedWithAnswer(this._netBody) === false &&
+                isGenerationIncompleteText(this._netBody) === false &&
+                (this._netNoAnswer || isFinishedWithoutAnswer(this._netBody))) {
+                deadTicks++;
+                if (deadTicks >= 6 && !(await this._continueButtonVisible())) {
+                    this._askDebug('THROW dead-turn (finished without answer)');
+                    throw new GenerationIncompleteError('finished without answer');
+                }
+            }
+            else {
+                deadTicks = 0;
+            }
             if (isNew && cur === last) {
                 stable++;
                 // `stabilityChecks` / `stabilityDelayMs` are the real knobs here.

package/dist/commands.js

@@ -987,7 +987,6 @@ export const SLASH_COMMANDS = [
     { name: '/rename', key: 'help.cmd.rename' },
     { name: '/context', key: 'help.cmd.context' },
     { name: '/copy', key: 'help.cmd.copy' },
-    { name: '/copy-code', key: 'help.cmd.copy_code' },
     { name: '/chat', key: 'help.cmd.chat' },
     { name: '/cd', key: 'help.cmd.cd' },
     { name: '/pwd', key: 'help.cmd.pwd' },

package/dist/config.js

@@ -71,7 +71,11 @@ export const DEFAULTS = {
         incompleteWaitMs: 2000,
         autoContinue: true,
         continueMinGapMs: 1500,
-        askDeadlineMs: 240000,
+        // The agent-loop watchdog for ONE ask(). It only bounds a SILENT send:
+        // a turn the server already ENDED with no answer (FINISHED + truncated
+        // RESPONSE) is detected by the network detectors and retried in seconds,
+        // not waited out. 240s used to mean a 4-minute spinner per dead turn.
+        askDeadlineMs: 120000,
         maxAfterToolRetries: 6,
         autoCompact: false,
         autoCompactPct: 95,
@@ -113,8 +117,9 @@ export const DEFAULTS = {
         // REPORTING (1000/1006) plus alternate-scroll OFF (1007l), so the wheel
         // arrives as SGR events we consume and never as Up/Down arrows. The
         // trade-off is that the terminal no longer does its own drag-select, so
-        // selecting text needs SHIFT+DRAG (the standard TUI convention). Set to
-        // false to give the terminal the mouse back (native select, wheel inert).
+        // selecting text needs SHIFT+DRAG (the standard TUI convention: Claude
+        // Code / Codex / opencode do the same). Set to false to give the terminal
+        // the mouse back (native select, wheel inert).
         mouseScroll: true,
     },
     // Off by default: a full tsc/eslint run after every edit is slow; opt in.

package/dist/context.js

@@ -57,6 +57,105 @@ const BUILTIN_SKILLS = [
             'couplings, and any WHY-comments that matter.\n' +
             '4. Do NOT change code. Answer in the operator language.',
     },
+    // Methodology skills, ported from superpowers (github.com/obra/superpowers)
+    // as plain prompt bodies — the zames equivalent of its SessionStart
+    // bootstrap, without a hook. The model is nudged to read the matching one
+    // before a non-trivial task by SKILLS_DISCIPLINE (src/system-prompt.ts).
+    // Baked in (not a file on disk) so a user who installed the npm package has
+    // them out of the box; a project skill of the same name overrides them.
+    {
+        name: 'brainstorming',
+        description: 'Use when the request is a GOAL, not a spec — "add X", "make it better", "integrate Y" — and it is unclear what "done" means.',
+        body: 'When a request is a goal ("make scrolling feel right"), building ' +
+            'immediately produces the wrong thing fast. First make the intent concrete.\n' +
+            'Pin down: (a) the REAL outcome — what should be TRUE after that is not ' +
+            'true now; (b) the acceptance check — how the operator will know it works; ' +
+            '(c) scope edges — what is explicitly NOT part of this; (d) the ' +
+            'alternatives considered and why you chose one.\n' +
+            'zames has NO conversational turn: the operator sees only your final ' +
+            'respond. So do the brainstorming YOURSELF and return a SHORT, concrete ' +
+            'proposal in ONE respond — the goal as you understood it, your ' +
+            'assumptions and defaults, what you will NOT do — then either proceed if ' +
+            'the request was clearly actionable, or stop and ask the ONE decision you ' +
+            'genuinely cannot make alone. For an already-precise request ("read X", ' +
+            '"rename Y") skip this entirely.',
+    },
+    {
+        name: 'writing-plans',
+        description: 'Use when a task needs more than one or two tool calls — a multi-file change, a new feature, a refactor. Breaks it into small ordered steps with exact paths and a verification for each.',
+        body: 'A plan is a sequence of steps a careful engineer with NO project ' +
+            'context could follow. Each step (2-5 minutes) names: the EXACT file ' +
+            'path(s); the concrete edit; how to verify it (command, test name, ' +
+            'expected output). Order matters: put the step that DE-RISKS the task ' +
+            'first (a spike, a failing test, a proof the API works) — do not build ' +
+            'three layers on an unverified assumption.\n' +
+            'Rules: one concern per step ("add the flag AND refactor the caller" is ' +
+            'two); prefer a step that FAILS LOUDLY over one that silently ' +
+            'half-works; every behavioural change gets a test step (see ' +
+            'test-driven-development); if a step turns out wrong, STOP and revise the ' +
+            'plan instead of improvising; a 30-step plan means the task should be ' +
+            'split. In zames the plan lives in your reasoning and, for a long task, ' +
+            'in a TodoWrite list — one entry per step. Do not narrate it between tool ' +
+            'calls; the todo list IS the visible plan.',
+    },
+    {
+        name: 'test-driven-development',
+        description: 'Use when writing or changing testable behaviour — a bug fix, a new function, a parser, a formatter. Write the failing test first, watch it fail, then make it pass.',
+        body: 'RED -> GREEN -> REFACTOR. The order is the point, not a formality.\n' +
+            '1. RED — write the smallest test that expresses the new behaviour and ' +
+            'RUN it. It must FAIL for the RIGHT reason ("not implemented", not a ' +
+            'typo). A test you never saw fail proves nothing.\n' +
+            '2. GREEN — write the MINIMUM code that makes it pass; do not add the ' +
+            'next feature "while you are there".\n' +
+            '3. REFACTOR — clean up with the test green, then re-run.\n' +
+            'A good test asserts BEHAVIOUR (input -> output), is deterministic (no ' +
+            'sleeps, no network, no wall-clock or test-order dependence) and fails ' +
+            'for ONE reason with a message that says what broke. In this project a ' +
+            'bug fix ALWAYS gets a regression test reproducing the original bug. ' +
+            'When a test needs fixing, ask whether the TEST or the CODE was wrong; ' +
+            'if the code was written before its test, rewrite it driven by the test.',
+    },
+    {
+        name: 'systematic-debugging',
+        description: 'Use when something is broken and the cause is not obvious — a failing test, a wrong result, a hang, a crash. Four phases: reproduce, isolate, hypothesize, fix.',
+        body: 'Do NOT start by editing code. Work the four phases in order; each ' +
+            'produces an artifact you can point at.\n' +
+            '1. REPRODUCE — get a command that FAILS the way the operator describes; ' +
+            'copy the exact error. If it passes you do not have the bug yet: narrow ' +
+            'the input until it fails.\n' +
+            '2. ISOLATE — shrink to the smallest failing unit (bisect, stub, ' +
+            'binary-search). Read the code the failing path ACTUALLY executes. Check ' +
+            'the obvious first: wrong file, stale build, cached state, different ' +
+            'config, an error swallowed by a catch.\n' +
+            '3. HYPOTHESIZE — state it in one sentence and predict what you should ' +
+            'see if it is right; test exactly that. One change at a time; prefer an ' +
+            'observation (log, test assertion) over an edit. If the prediction is ' +
+            'wrong, DISCARD the hypothesis.\n' +
+            '4. FIX AND VERIFY — fix the CAUSE, not the symptom; add a regression ' +
+            'test that fails WITHOUT the fix; re-run the phase-1 reproduction ' +
+            'verbatim; look for the same bug elsewhere.\n' +
+            'Anti-patterns: editing before reproducing; "it works now" without ' +
+            'knowing what changed; silencing an error you do not understand with a ' +
+            'try/catch; trusting a green test never seen red.',
+    },
+    {
+        name: 'verification-before-completion',
+        description: 'Use BEFORE declaring a task done — a feature, a bug fix, a generated file. Forces you to run the verification you promised instead of trusting the code looks right.',
+        body: '"It should work" is not done. Before reporting success, produce ' +
+            'EVIDENCE from the real artifact, not from your intent.\n' +
+            '1. Re-read the original request; tick every requirement (including the ' +
+            'ones in a parenthetical) against something you can show.\n' +
+            '2. Run the thing: build/typecheck/tests for code; run a script; for a ' +
+            'generated file, open/parse it and confirm it is COMPLETE, not ' +
+            'truncated; for a UI, the real screen, not the diff.\n' +
+            '3. Re-read your own diff as a reviewer: leftover debug output, dead ' +
+            'code, a wrong path, a test that asserts nothing.\n' +
+            '4. State the evidence in the final report — the exact command and its ' +
+            'result — so the operator can reproduce it. "Tests pass" without the ' +
+            'command is not evidence.\n' +
+            'If you cannot run the verification, SAY SO explicitly and describe what ' +
+            'you did instead; never report "done" implying a check you did not run.',
+    },
 ];
 // Per-file budgets. AGENTS.md/MEMORY.md are hand-maintained and grow over
 // time, so the caps are generous: an AGENTS.md of a real project (this repo's

package/dist/deepseek-ui.js

@@ -18,7 +18,7 @@ export const CHAT_URL = 'https://chat.deepseek.com/';
 export const CHAT_ID_RE = /\/chat\/s\/([a-zA-Z0-9_-]+)/;
 // DeepSeek's chat URL shape. A direct navigation always yields the requested
 // chat (the sidebar link click is tried first, this is the fallback).
-export const CHAT_PATH_PREFIX = 'a/chat/s/';
+const CHAT_PATH_PREFIX = 'a/chat/s/';
 export function chatUrl(id) {
     return CHAT_URL + CHAT_PATH_PREFIX + id;
 }
@@ -177,7 +177,6 @@ export const MFA_CODE_SELECTORS = [
     '.ds-mfa-verification-modal input[type="tel"]',
     'input[inputmode="numeric"][maxlength="6"]',
 ];
-export const MFA_MODAL_SELECTOR = '.ds-mfa-verification-modal, [role="dialog"]';
 export const MFA_SUBMIT_SELECTORS = [
     'div[role="button"].ds-mfa-verification-submit',
     '.ds-mfa-verification-modal div[role="button"].ds-button--primary',
@@ -264,7 +263,6 @@ export const INCOMPLETE_STATUS_RE = /"quasi_status"(?::|,"v":)"INCOMPLETE"/i;
 // fragment. The UI shows Stopped + Continue. Matches both the JSON-property
 // and the BATCH shape (see INCOMPLETE_STATUS_RE).
 export const FINISHED_STATUS_RE = /"quasi_status"(?::|,"v":)"FINISHED"/i;
-export const RESPONSE_CONTENT_RE = /"type":"RESPONSE","content":"[^"]/;
 // Only a completion/continue turn carries a real answer. Gating the capture
 // assignment to these URLs keeps a future endpoint (which happens to return a
 // `content`/`text` field) from clobbering the answer and looking fresh.

package/dist/i18n/common.js

@@ -117,6 +117,19 @@ export const commonMessages = {
         en: 'Allow this call?',
     },
     'perm.title': { ru: 'Подтверждение', en: 'Confirmation' },
+    // The AskUser modal (the model asks the operator a question with options).
+    'askuser.title': { ru: 'Вопрос от агента', en: 'Question from the agent' },
+    'askuser.other': {
+        ru: 'Свой вариант — введу текстом',
+        en: 'Other — I will type my own answer',
+    },
+    'askuser.recommended': { ru: 'рекомендую', en: 'recommended' },
+    'askuser.your_answer': { ru: 'Ваш ответ:', en: 'Your answer:' },
+    'askuser.hint_select': { ru: 'выбор', en: 'select' },
+    'askuser.hint_ok': { ru: 'ок', en: 'ok' },
+    'askuser.hint_dismiss': { ru: 'закрыть', en: 'dismiss' },
+    'askuser.hint_send': { ru: 'отправить', en: 'send' },
+    'askuser.hint_cancel': { ru: 'отмена', en: 'cancel' },
     'confirm.yes': { ru: 'Да', en: 'Yes' },
     'confirm.no': { ru: 'Нет', en: 'No' },
     'perm.ask_sub': {
@@ -246,22 +259,6 @@ export const commonMessages = {
         ru: 'Не удалось скопировать (нет {tool} или он недоступен).',
         en: 'Could not copy ({tool} missing or unavailable).',
     },
-    'copy.no_code': {
-        ru: 'В последнем ответе нет блоков кода.',
-        en: 'The last answer has no code blocks.',
-    },
-    'copy.bad_index': {
-        ru: 'Нет блока кода #{n}.',
-        en: 'No code block #{n}.',
-    },
-    'copy_code.list': {
-        ru: 'Блоки кода последнего ответа:',
-        en: 'Code blocks in the last answer:',
-    },
-    'copy_code.item': {
-        ru: '  #{n} {lang} — {lines} стр.',
-        en: '  #{n} {lang} — {lines} lines',
-    },
     'retry.running': { ru: 'Повторяю задачу…', en: 'Retrying the task...' },
     'rename.usage': {
         ru: 'Использование: /rename <title>',

package/dist/i18n/config.js

@@ -44,8 +44,8 @@ export const configMessages = {
         en: 'Full-screen TUI mode (alternate screen)',
     },
     'cfg.f.ui_mouseScroll': {
-        ru: 'Прокрутка лога колесом мыши (выделение текста — Shift+клик)',
-        en: 'Mouse-wheel log scrolling (select text with Shift+click)',
+        ru: 'Колесо: лог или терминал (выкл = выделение без Shift)',
+        en: 'Wheel: log or terminal (off = select without Shift)',
     },
     'cfg.f.maxIterations': {
         ru: 'Лимит итераций на задачу',

package/dist/i18n/help.js

@@ -102,8 +102,8 @@ export const helpMessages = {
         en: 'PgUp / PgDn               up/down the dialog (Home/End — top/bottom) [full-screen]',
     },
     'help.key.wheel': {
-        ru: 'колесо мыши               скролл диалога; выделение — Shift+клик',
-        en: 'mouse wheel               scroll the dialog; select text with Shift+click',
+        ru: 'ui.mouseScroll            on (умолч.) — колесо скроллит диалог (выделение Shift); off — выделение мышью',
+        en: 'ui.mouseScroll            on (default) — wheel scrolls the dialog (select: Shift); off — select with the mouse',
     },
     'help.key.bang': {
         ru: '!команда                  выполнить shell-команду напрямую (мимо модели)',
@@ -201,10 +201,6 @@ export const helpMessages = {
         ru: '/copy скопировать последний ответ в буфер обмена',
         en: '/copy copy the last answer to the clipboard',
     },
-    'help.cmd.copy_code': {
-        ru: '/copy-code [номер] копировать блок кода из последнего ответа (Ctrl+Y)',
-        en: '/copy-code [n] copy a code block from the last answer (Ctrl+Y)',
-    },
     'help.cmd.cost': { ru: '/cost статистика сессии', en: '/cost session stats' },
     'help.cmd.export': {
         ru: '/export [file] выгрузить сессию в Markdown',
@@ -578,4 +574,50 @@ export const helpMessages = {
         ru: 'Индикаторы в статус-строке: 🧠 — глубокое размышление, 🌐 — поиск в интернете (видны, когда включены).',
         en: 'Status-line icons: 🧠 — Deep thinking, 🌐 — web search (shown when enabled).',
     },
+    // Localized descriptions for the WELL-KNOWN skills (built-in + bundled
+    // methodology). A skill's SKILL.md frontmatter is agent-facing English, so
+    // showing it verbatim in the «/» hints would leave an English line in a
+    // Russian UI. Keyed by skill NAME, applied regardless of source, so a local
+    // `.zames/skills/` copy of a bundled skill still shows the translated text.
+    // An unknown (user-authored) skill has no key and keeps its own description.
+    'skill.desc.commit': {
+        ru: 'подготовить аккуратный git-коммит из текущих изменений',
+        en: 'prepare a clean git commit from the current changes',
+    },
+    'skill.desc.review': {
+        ru: 'ревью текущего диффа на баги и риски (без правок)',
+        en: 'review the current diff for bugs and risks (no changes)',
+    },
+    'skill.desc.test': {
+        ru: 'прогнать тесты проекта и чинить падения до зелёного',
+        en: 'run the project tests and fix failures until green',
+    },
+    'skill.desc.debug': {
+        ru: 'системно диагностировать и починить баг',
+        en: 'systematically diagnose and fix a bug',
+    },
+    'skill.desc.explain': {
+        ru: 'объяснить, как работает файл/модуль/фича',
+        en: 'explain how a file/module/feature works',
+    },
+    'skill.desc.brainstorming': {
+        ru: 'когда запрос — это цель, а не спека: сначала прояснить замысел',
+        en: 'when the request is a goal, not a spec: pin down the intent first',
+    },
+    'skill.desc.writing-plans': {
+        ru: 'разбить многошаговую задачу на маленькие шаги с проверкой каждого',
+        en: 'break a multi-step task into small steps, each with a check',
+    },
+    'skill.desc.test-driven-development': {
+        ru: 'сначала падающий тест, потом код (RED → GREEN → REFACTOR)',
+        en: 'write the failing test first, then the code (RED → GREEN → REFACTOR)',
+    },
+    'skill.desc.systematic-debugging': {
+        ru: 'четыре фазы отладки: воспроизвести, изолировать, гипотеза, фикс',
+        en: 'four debugging phases: reproduce, isolate, hypothesize, fix',
+    },
+    'skill.desc.verification-before-completion': {
+        ru: 'прогнать проверку ПЕРЕД тем, как объявить задачу готовой',
+        en: 'run the verification BEFORE declaring the task done',
+    },
 };

package/dist/i18n/spinner.js

@@ -35,11 +35,17 @@ export const spinnerMessages = {
         ru: 'Напишите задачу и нажмите Enter. /help — команды, Ctrl+J — новая строка.',
         en: 'Type a task and press Enter. /help for commands, Ctrl+J for a new line.',
     },
-    // One-line key hint UNDER the input box (full-screen mode).
+    // One-line key hint UNDER the input box (full-screen mode). Two variants:
+    // with in-app wheel scroll the mouse belongs to the app, so selection needs
+    // Shift; without it the terminal keeps the mouse and the wheel is inert.
     'editor.keys_hint': {
         ru: 'выделение — Shift+клик · колесо — скролл · PgUp/PgDn — вверх/вниз · Home/End — в начало/конец',
         en: 'select — Shift+click · wheel — scroll · PgUp/PgDn — up/down · Home/End — top/bottom',
     },
+    'editor.keys_hint_select': {
+        ru: 'выделение — мышью · PgUp/PgDn — вверх/вниз · Home/End — в начало/конец',
+        en: 'select — drag · PgUp/PgDn — up/down · Home/End — top/bottom',
+    },
     // Reverse search (Ctrl+R) status line. The query may be empty.
     'editor.search_prompt': {
         ru: '(обратный поиск) `{q}` — Ctrl+R дальше, Enter принять, Esc отмена',

package/dist/index.js

@@ -35,7 +35,6 @@ import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } f
 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';
 import { renderStartupBanner } from './banner.js';
 import { runStatusLineCommand } from './statusline.js';
@@ -531,9 +530,18 @@ async function refreshDynamicCommands(workdir) {
         for (const s of skills) {
             if (!s.userInvokable)
                 continue;
+            // A well-known skill (built-in or bundled methodology) has a localized
+            // description keyed by NAME — its SKILL.md frontmatter is agent-facing
+            // English, which must not leak into a Russian UI. `t` returns the key
+            // itself when it is missing, so an unknown (user-authored) skill falls
+            // back to its own description.
+            const descKey = 'skill.desc.' + s.name;
+            const localized = t(descKey);
             out.push({
                 name: '/' + s.name,
-                description: s.description || t('help.cmd.skill'),
+                description: localized !== descKey
+                    ? localized
+                    : s.description || t('help.cmd.skill'),
             });
         }
         const cmds = await loadCommands(workdir);
@@ -1528,7 +1536,6 @@ async function main() {
             }) + theme.dim('  (' + res.via + ')')));
             return att;
         };
-        ed.onCopyText = (text) => writeClipboardText(text);
         ed.onSubmit = (text, items) => {
             // While the agent is busy the main command loop is blocked on
             // `await runTask()`, so ONLY commands that make sense without the main
@@ -3239,53 +3246,6 @@ async function main() {
             }
             continue;
         }
-        if (lower === '/copy-code' || lower.startsWith('/copy-code ')) {
-            const arg = trimmed.slice('/copy-code'.length).trim();
-            const blocks = extractCodeBlocks(lastAssistantMessage ?? '');
-            if (!blocks.length) {
-                console.log(theme.dim(t('copy.no_code')));
-                continue;
-            }
-            if (arg === 'list') {
-                console.log(theme.system(t('copy_code.list')));
-                for (const b of blocks) {
-                    console.log(theme.assistant(t('copy_code.item', {
-                        n: String(b.index),
-                        lang: b.lang || 'text',
-                        lines: String(b.text.split(String.fromCharCode(10)).length),
-                    })));
-                }
-                continue;
-            }
-            // Prefer the TUI copy path (it reports into the log); fall back to a
-            // direct clipboard write for the legacy editor / non-TTY.
-            const n = arg ? Number(arg) : undefined;
-            if (n !== undefined && (!Number.isInteger(n) || n < 1)) {
-                console.log(theme.warn(t('copy.bad_index', { n: arg })));
-                continue;
-            }
-            if (editor &&
-                'copyCode' in editor &&
-                typeof editor.copyCode === 'function') {
-                editor.copyCode(n);
-                continue;
-            }
-            const pick = n !== undefined
-                ? blocks.find((b) => b.index === n)
-                : blocks[blocks.length - 1];
-            if (!pick) {
-                console.log(theme.warn(t('copy.bad_index', { n: String(n) })));
-                continue;
-            }
-            const res2 = writeClipboardText(pick.text);
-            if (res2.ok) {
-                console.log(theme.assistant(t('copy.done', { tool: res2.via })));
-            }
-            else {
-                console.error(theme.warn(t('copy.failed', { tool: res2.via })));
-            }
-            continue;
-        }
         if (lower === '/retry') {
             if (!lastTaskText) {
                 console.log(theme.dim(t('retry.none')));