zames_pro 2.75.6 → 2.77.0

package/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.77.0] - 2026-10-17
+
+### Added
+
+- **scheduler:** start the first /loop tick immediately
+
+### Fixed
+
+- **diff:** show no-changes text instead of the git runner sentinel
+- **config:** refuse prototype-polluting segments in setByPath
+- **net:** read the context counter from history_messages and OpenAI usage
+- **agent-loop:** do not flag a report that explains the work as unfinished
+- **agent-loop:** stop treating prose that mentions invoke/parameter as a tool call
+- **backlog:** ignore headings inside fenced code blocks
+- **subagent:** keep the SubagentStop hook output when the run fails
+- **goal:** parse a markdown-formatted evaluator verdict
+- **qwen:** skip the thinking phase when restoring a chat from content_list
+- **changelog:** keep drafted group headings on their own line
+- **tui:** decode modified and release wheel reports correctly
+- **shell:** normalize an invalid Bash timeout instead of crashing the tool
+- **cost:** keep per-tool stats safe for __proto__/constructor tool names
+- **tui:** mark blocked/aborted tool calls as errors in the result icon
+- **mcp:** do not split a surrogate pair when truncating an MCP result
+- **context:** discover skills at the documented 3 levels deep
+- **commands:** /diffstat accepts --staged like /diff
+- **commands:** /add-dir expands a leading ~ to the home directory
+- **scheduler:** accept the N/step cron form
+- **scheduler:** reject a /loop interval that overflows the 32-bit timer
+- **diagnostics:** never cut the check output inside a surrogate pair
+- **web:** close two SSRF-guard bypasses in WebFetch
+- **scheduler:** flag a job whose next fire could not be computed
+- **subagent:** cap a report without splitting a surrogate pair
+- **qwen:** a retry wait cut short by Esc must stop the retry chain
+- **tui:** a bracketed paste split across reads must not leak its end marker
+- **agent-loop:** do not cut a tool result inside a surrogate pair
+- **web:** a broken numeric HTML entity must not fail the whole WebFetch
+- **scheduler:** keep a scheduled message's jobId through the queue merge; explain an unrecognized /loop interval
+- **tui:** localize the Ink dialog key-hint bars
+- **i18n:** drop the dead /resume <n> hint from /sessions and the docs
+
+## [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

package/README.md

@@ -374,8 +374,8 @@ Codex CLI:
   runtime.
 - /add-dir <path> — validate an extra directory (the sandbox is fixed at
   startup; relaunch with --dir to write there).
-- /resume <n> (after /chats) and /resume-id <id> — open a chat and PRINT its
-  dialogue into the terminal, so the restored context is visible. Only the
+- /resume-id <id> (or picking a chat in the /chats list) — open a chat and
+  PRINT its dialogue into the terminal, so the restored context is visible. Only the
   last 20 messages are shown (`RESTORED_HISTORY_LIMIT`). /last reopens the last
   chat of the current directory with no lookup step; /sessions shows the saved
   sessions with their relative age.
@@ -400,7 +400,9 @@ Codex CLI:
 tests`). /cron "<min> <hour> <dom> <month> <dow>" <task> — run on a schedule.
   /jobs [rm <id>|clear] lists and stops them. A fired job is put into the same
   message queue you type into, so it runs when the agent is free (never mid-
-  generation) and still respects the send throttle.
+  generation) and still respects the send throttle. The FIRST run of a `/loop`
+  is due at once (and runs as soon as the agent is idle); a `/cron` job waits
+  for its schedule.
 - /thinking [on|off] and /web [on|off] — toggle the reasoning / web-search
   behaviour. On **DeepSeek** these are the "Deep thinking" / "Smart search"
   toggles; on **Qwen** they drive its thinking MODE (Thinking / Fast) and the
@@ -959,8 +961,8 @@ zames --task "..." --output-format jsonl \
   модель Qwen на лету.
 - /add-dir <path> — проверить дополнительную директорию (песочница
   фиксируется при старте; для записи туда перезапустите с --dir).
-- /resume <n> (после /chats) и /resume-id <id> — открыть чат и НАПЕЧАТАТЬ его
-  диалог в терминал, чтобы восстановленный контекст был виден. Показываются
+- /resume-id <id> (или выбор чата в списке /chats) — открыть чат и
+  НАПЕЧАТАТЬ его диалог в терминал, чтобы восстановленный контекст был виден. Показываются
   только последние 20 сообщений (`RESTORED_HISTORY_LIMIT`). /last открывает
   последний чат текущей директории без поиска; /sessions показывает сохранённые
   сессии с их относительным возрастом.
@@ -987,7 +989,8 @@ zames --task "..." --output-format jsonl \
   запуск по расписанию. /jobs [rm <id>|clear] перечисляет и останавливает их.
   Сработавшая задача попадает в ту же очередь сообщений, что и ваш ввод, так
   что выполняется, когда агент свободен (никогда посреди генерации), и всё
-  равно соблюдает троттлинг отправки.
+  равно соблюдает троттлинг отправки. ПЕРВЫЙ запуск `/loop` — сразу же (как
+  только агент свободен); задача `/cron` ждёт своего расписания.
 - /thinking [on|off] и /web [on|off] — переключить режим размышления /
   веб-поиска. В **DeepSeek** это тумблеры «Deep thinking» / «Smart search»;
   в **Qwen** — это режим размышления (Thinking / Fast) и пункт «Web search»

package/dist/answer-parse.js

@@ -25,6 +25,14 @@ export function truncateToolResult(text, limit) {
     // lines — a cut that EXCLUDED the newline left a half line before the marker.
     if (nl >= searchFrom)
         cut = nl + 1;
+    // Never split a surrogate PAIR (an emoji / astral CJK char): the high half
+    // alone is a lone surrogate — a broken code point some channels replace with
+    // '?' or truncate at. Step back one unit so the pair is dropped WHOLE.
+    else {
+        const c = text.charCodeAt(cut - 1);
+        if (c >= 0xd800 && c <= 0xdbff)
+            cut--;
+    }
     const omitted = text.length - cut;
     return text.slice(0, cut) + NL + `[...truncated ${omitted} chars]`;
 }
@@ -37,8 +45,13 @@ export function responseLooksLikeToolCall(rawResponse) {
     const raw = rawResponse || '';
     return (
     // Explicit tool-call format markers: the JSON key "tool", XML/DSML tags,
-    // function_call, etc.
-    /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(raw) ||
+    // function_call, etc. The BARE words `invoke`/`parameter` are deliberately
+    // NOT markers on their own: an ordinary final report can use them as
+    // English words ("a timeout parameter: …", "the invoke helper …"), and a
+    // false positive rejected a perfectly good answer and re-asked the model
+    // until the retry budget ended the task with an error. A real XML/DSML
+    // call is still caught by the tag pattern below.
+    /("tool"\s*:|\btool_calls?\b|DSML|function_call)/i.test(raw) ||
         // "tool" without an opening quote/bracket, with a junk prefix
         // (`<｜tool":`, `**tool**:`, `- tool:`): a call key, not prose.
         /(^|[^A-Za-z0-9_])(?:\*\*)?tool(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/.test(raw) ||
@@ -98,7 +111,10 @@ export function looksLikeUnfinishedWork(text) {
     if (/\b(done|finished|completed|готово|выполнено|завершено)\b/i.test(t)) {
         return false;
     }
-    const en = /\b(now|next|then|let me|let's|i will|i'll|i am going to|i'm going to|going to|about to|will now|time to)\b[^.!?\n]{0,120}\b(update|write|edit|read|run|check|add|fix|create|remove|delete|apply|test|commit|push|install|open|search|look|verify|change|modify|implement|review)\b/i;
+    // `update`/`summarize`/`explain` are REPORT verbs (`I will update you on the
+    // results: …`) — they do not promise a tool call. A colon anywhere in the
+    // gap also means the sentence is explaining a fact, not about to act.
+    const en = /\b(now|next|then|let me|let's|i will|i'll|i am going to|i'm going to|going to|about to|will now|time to)\b[^.!?\n:]{0,120}\b(write|edit|read|run|check|add|fix|create|remove|delete|apply|test|commit|push|install|open|search|look|verify|change|modify|implement|review)\b/i;
     const ru = /(^|[^а-яё])(проверю|обновлю|исправлю|добавлю|запущу|выполню|посмотрю|прочитаю|изменю|попробую|сделаю)([^а-яё]|$)/i;
     return en.test(t) || ru.test(t);
 }

package/dist/changelog.js

@@ -99,6 +99,12 @@ export function syncUnreleased(changelog, body) {
     const tail = next < 0 ? '' : rest.slice(next);
     const cleanBody = String(body || '')
         .replace(/^## \[Unreleased\]\s*/m, '')
+        // A drafted group heading must START a line of its own. When the draft
+        // carries several groups (`## Added` … `## Fixed`) without a blank line
+        // between them, the next group used to stay glued to the last bullet
+        // (`- a### Fixed`) — it was not a heading at all, so the item vanished
+        // from the rendered changelog.
+        .replace(/([^\n])\n?(?=## )/g, '$1' + nl + nl)
         .trim()
         // The draft renders groups as `## Added` (top-level), but INSIDE the file
         // a version's groups are `### Added` (a subsection of the version heading).

package/dist/commands.js

@@ -1,5 +1,6 @@
 import { providerLabel } from './providers.js';
 import path from 'path';
+import os from 'os';
 import { isImageName } from './attachments.js';
 import { translate } from './i18n.js';
 // Helpers for the extra slash commands (/diff, /cost, /export, /doctor,
@@ -14,8 +15,11 @@ export function formatDiff(diffText, opts = {}, t = translate('en')) {
         .split(CR + NL)
         .join(NL)
         .trimEnd();
-    if (!trimmed)
+    // The shared git runner reports an EMPTY result as this sentinel, so a clean
+    // tree must not print it to the operator (formatDiffStat already handles it).
+    if (!trimmed || trimmed.trim() === '(command produced no output)') {
         return t('diff.no_changes');
+    }
     const lines = trimmed.split(NL);
     if (lines.length <= maxLines)
         return trimmed;
@@ -28,6 +32,12 @@ export function formatDiff(diffText, opts = {}, t = translate('en')) {
 export function diffGitArgs(staged = false) {
     return staged ? ['diff', '--staged'] : ['diff'];
 }
+// Git arguments for `/diffstat`. Same shape as diffGitArgs() so the two
+// commands stay symmetric: `/diffstat --staged` used to be impossible (the
+// command hardcoded `git diff --stat`), even though `/diff --staged` worked.
+export function diffStatGitArgs(staged = false) {
+    return staged ? ['diff', '--staged', '--stat'] : ['diff', '--stat'];
+}
 // ---------- /diffstat ----------
 /** Render `git diff --stat` output (a compact change summary) for display. */
 export function formatDiffStat(statText, opts = {}, t = translate('en')) {
@@ -84,9 +94,15 @@ export function summarizeTranscript(entries) {
     const stats = {
         turns: 0,
         toolCalls: 0,
-        toolCounts: {},
+        // Null-prototype maps: a tool NAME is arbitrary text (an MCP server can
+        // advertise anything, the model may emit any name). With a plain {} a name
+        // like '__proto__' assigns the PROTOTYPE (the tool vanishes from the count
+        // and Object.prototype gets mutated), and 'constructor'/'toString' read an
+        // inherited function instead of a number — /cost then printed
+        // "constructor: function Object() { [native code] }1".
+        toolCounts: Object.create(null),
         toolMs: 0,
-        toolTime: {},
+        toolTime: Object.create(null),
         durationMs: 0,
         startedAt: null,
         autoCompacts: 0,
@@ -332,9 +348,18 @@ export function renderDoctor(d, t = translate('en')) {
 }
 // ---------- /add-dir ----------
 export function resolveExtraDir(input, workdir, t = translate('en')) {
-    const raw = String(input ?? '').trim();
+    let raw = String(input ?? '').trim();
     if (!raw)
         return { error: t('adddir.usage') };
+    // A leading `~` means the home directory (a shell convention the operator
+    // expects). Without expansion resolve() treated it as a literal directory
+    // named `~` under the working dir, so /add-dir ~ reported "No such
+    // directory: /w/~". Only a LEADING `~` / `~/` expands; a `~` elsewhere is
+    // an ordinary character.
+    if (raw === '~')
+        raw = os.homedir();
+    else if (raw.startsWith('~/') || raw.startsWith('~' + path.sep))
+        raw = path.join(os.homedir(), raw.slice(2));
     const abs = path.resolve(workdir, raw);
     if (abs === path.resolve(workdir)) {
         return { error: t('adddir.same') };
@@ -828,6 +853,7 @@ export function mergeMessages(msgs) {
         return {
             text: list[0].text,
             attachments: (list[0].attachments || []).slice(),
+            jobId: list[0].jobId,
         };
     }
     let imgOffset = 0;
@@ -861,7 +887,10 @@ export function mergeMessages(msgs) {
         ' messages while you were working. They are listed below in order — ' +
         'treat them as one instruction.';
     const text = header + NL + NL + parts.join(NL + NL + '---' + NL + NL);
-    return { text, attachments };
+    // Keep the FIRST scheduled job id in the batch so the ticker still knows a
+    // copy of that job is in flight (see MergedMessage.jobId).
+    const jobId = list.find((m) => m.jobId !== undefined)?.jobId;
+    return { text, attachments, jobId };
 }
 // Parse BACKLOG.md into actionable items. Recognizes headings of the form
 // `### A1. ...`, `### D7. ...` and marks an item done when its heading carries
@@ -870,8 +899,24 @@ export function mergeMessages(msgs) {
 export function parseBacklogItems(text) {
     const out = [];
     let priority = '';
+    // A fenced code block in an item's body may contain a line that LOOKS like a
+    // heading (an example of the format, a pasted log). Those are not headings:
+    // counting them invented a phantom P0 item that `/improve` picked over the
+    // real backlog. Track the fence (``` or ~~~, at least three) and skip.
+    let fence = '';
     for (const raw of String(text ?? '').split(NL)) {
         const line = raw.trimEnd();
+        const fenceMatch = /^\s*(`{3,}|~{3,})/.exec(line);
+        if (fenceMatch) {
+            const mark = fenceMatch[1][0];
+            if (!fence)
+                fence = mark;
+            else if (mark === fence)
+                fence = '';
+            continue;
+        }
+        if (fence)
+            continue;
         const p = /^##\s+(P[0-3])\b/.exec(line);
         if (p) {
             priority = p[1];

package/dist/config.js

@@ -498,8 +498,15 @@ export function getByPath(obj, path) {
     }
     return cur;
 }
+// Object keys that must NEVER be walked/assigned by a dotted path: they reach
+// the PROTOTYPE chain. deepMerge() already skips them; setByPath did not, so a
+// `__proto__.x` segment polluted Object.prototype for the whole process (and
+// wrote the injected keys into the config file).
+const UNSAFE_PATH_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 export function setByPath(obj, path, value) {
     const parts = path.split('.');
+    if (parts.some((p) => UNSAFE_PATH_KEYS.has(p)))
+        return;
     let cur = obj;
     for (let i = 0; i < parts.length - 1; i++) {
         const p = parts[i];

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
@@ -241,7 +340,11 @@ async function findSkillFiles(root, depth = 3) {
                 await walk(full, level + 1);
         }
     };
-    await walk(root, 1);
+    // Start at level 0 so `level < depth` admits exactly `depth` levels of
+    // subdirectories: with walk(root, 1) the FIRST level counted as 1 and the
+    // walk stopped one level early, so a skill at the documented "3 levels
+    // deep" (`.zames/skills/<a>/<b>/<skill>/SKILL.md`) was never discovered.
+    await walk(root, 0);
     return out;
 }
 export async function loadSkills(workdir) {

package/dist/diagnostics.js

@@ -35,7 +35,14 @@ export function summarizeDiagnostics(raw, maxChars) {
     const chosen = errLines.length ? errLines : lines;
     let out = chosen.join('\n');
     if (out.length > maxChars) {
-        out = out.slice(0, maxChars) + '\n… [diagnostics truncated]';
+        // Never split a surrogate PAIR (emoji / astral CJK): the high half alone
+        // is a lone surrogate in the model's context. Same rule as
+        // truncateToolResult (agent-loop) and capReport (subagent).
+        let cut = maxChars;
+        const c = out.charCodeAt(cut - 1);
+        if (c >= 0xd800 && c <= 0xdbff)
+            cut--;
+        out = out.slice(0, cut) + '\n… [diagnostics truncated]';
     }
     return out;
 }

package/dist/goal.js

@@ -70,12 +70,21 @@ function argumentReason(reason) {
 // "continue", never as "done").
 export function parseGoalVerdict(text) {
     const t = String(text ?? '');
-    const m = /VERDICT:\s*(`{0,3})?\s*(MET|NOT_MET|IMPOSSIBLE)/i.exec(t);
+    // The label may be bolded/italicised and the colon may carry surrounding
+    // spaces (`**VERDICT:** MET`) — a markdown-model answer did exactly that and
+    // the strict `VERDICT:` matcher returned null, so the goal never parsed and
+    // the loop auto-continued until the turn budget.
+    const m = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(MET|NOT_MET|IMPOSSIBLE)/i.exec(t);
     if (!m)
         return null;
-    const raw = m[2].toUpperCase();
+    const raw = m[1].toUpperCase();
     const status = raw === 'MET' ? 'met' : raw === 'IMPOSSIBLE' ? 'impossible' : 'not_met';
-    const rm = /REASON:\s*(.+)/i.exec(t);
-    const reason = rm ? rm[1].replace(/`{2,}/g, '').trim() : '';
+    const rm = /REASON\s*[*_`]*\s*:\s*(.+)/i.exec(t);
+    const reason = rm
+        ? rm[1]
+            .replace(/`{1,3}/g, '')
+            .replace(/\*{1,2}/g, '')
+            .trim()
+        : '';
     return { status, reason };
 }

package/dist/i18n/deepseek.js

@@ -114,6 +114,19 @@ export const deepseekMessages = {
     'auth.form.hint_field': { ru: 'поле', en: 'field' },
     'auth.form.hint_submit': { ru: 'войти', en: 'sign in' },
     'auth.form.hint_cancel': { ru: 'отмена', en: 'cancel' },
+    // Key-hint labels of the Ink dialogs (SelectList / ConfigMenu /
+    // ConfirmDialog). They used to be hardcoded Russian, so an English UI
+    // still showed a Russian hint bar.
+    'tui.hint.select': { ru: 'выбор', en: 'select' },
+    'tui.hint.edit': { ru: 'правка', en: 'edit' },
+    'tui.hint.ok': { ru: 'ок', en: 'ok' },
+    'tui.hint.cancel': { ru: 'отмена', en: 'cancel' },
+    'tui.hint.search': { ru: 'поиск', en: 'search' },
+    'tui.hint.reset': { ru: 'сброс', en: 'reset' },
+    'tui.hint.quit': { ru: 'выход', en: 'quit' },
+    'tui.hint.change': { ru: 'изменить', en: 'change' },
+    // Marks the CURRENT entry in a list menu (e.g. the active Qwen model).
+    'tui.list.current': { ru: '← текущая', en: '← current' },
     'auth.form.note_saved': {
         ru: 'Enter — использовать сохранённые логин и пароль.',
         en: 'Enter — use the saved login and password.',

package/dist/i18n/help.js

@@ -330,6 +330,10 @@ export const helpMessages = {
         ru: 'Использование: /cron "<мин> <час> <день> <мес> <день недели>" <задача>',
         en: 'Usage: /cron "<min> <hour> <dom> <month> <dow>" <task>',
     },
+    'sched.interval_typo': {
+        ru: 'Интервал «{v}» не распознан — задача НЕ добавлена. Единицы: s/sec, m/min, h (например, /loop 10m проверь тесты). Без единицы — СЕКУНДЫ (120 = 120с), для минут нужен суффикс m.',
+        en: 'Interval "{v}" was not recognized — NO job was added. Units: s/sec, m/min, h (e.g. /loop 10m run the tests). Without a unit it means SECONDS (120 = 120s); use the m suffix for minutes.',
+    },
     'sched.loop_too_short': {
         ru: 'Слишком часто: минимум {min} (троттлинг отправок 15с).',
         en: 'Too frequent: minimum {min} (the send throttle is 15s).',
@@ -338,6 +342,10 @@ export const helpMessages = {
         ru: '⏰ Задача #{id} добавлена ({when}): {task}',
         en: '⏰ Job #{id} added ({when}): {task}',
     },
+    'sched.added_hint': {
+        ru: 'Если агент свободен — запуск сразу, иначе сразу после текущей задачи; дальше — по расписанию. Список — /jobs, удалить — /jobs rm <id>.',
+        en: 'Runs at once if the agent is idle, otherwise right after the current task; then on schedule. List: /jobs, remove: /jobs rm <id>.',
+    },
     'sched.title': { ru: 'Запланированные задачи:', en: 'Scheduled jobs:' },
     'sched.none': { ru: 'Запланированных задач нет.', en: 'No scheduled jobs.' },
     'sched.fired': {
@@ -574,4 +582,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/self-review.js

@@ -171,8 +171,8 @@ export const selfReviewMessages = {
         en: 'No saved sessions. They appear after the first task/chat.',
     },
     'sessions.restore_hint': {
-        ru: 'Восстановить: /resume-id <id>  (полный id) или /resume <n> после /chats.',
-        en: 'Restore: /resume-id <id> (full id) or /resume <n> after /chats.',
+        ru: 'Восстановить: /resume-id <id> (полный id) или выбери сессию в списке /sessions.',
+        en: 'Restore: /resume-id <id> (full id) or pick a session from the /sessions list.',
     },
     'sessions.pick_title': {
         ru: 'Выберите сессию (↑/↓, Enter — открыть, Esc — отмена)',