zames_pro 2.10.8 → 2.11.0

package/README.md

@@ -76,6 +76,35 @@ zames --version
 zames --help
 ```
 
+## Project context, skills and memory
+
+Like Codex / Claude Code, zames reads project instructions and reusable
+workflows from your repository and from `~/.zames`.
+
+- **AGENTS.md** — project instructions. Put one in the repo root (or in any
+  parent folder of the working directory). Global instructions live in
+  `~/.zames/AGENTS.md` (and `~/.claude/CLAUDE.md`). Create a starter file with
+  `/init`.
+- **MEMORY.md** — durable notes that persist between sessions. The agent
+  appends useful facts here; you can edit it by hand.
+- **Skills** — a folder with a `SKILL.md` file (YAML frontmatter: `name`,
+  `description`, optional `allowed-tools`, `user-invokable`) plus any helper
+  files. Discovered under `.zames/skills/`, `.claude/skills/`,
+  `.agents/skills/`, `skills/`, and `~/.zames/skills/`. The agent reads the
+  body only when a task matches the description. List them with `/skills`;
+  invoke one with `/<skill-name>`.
+- **Custom commands** — `.md` files under `.zames/commands/` (or
+  `.claude/commands/`). They support `$ARGUMENTS` / `{{args}}` placeholders and
+  are invoked with `/<command-name>`.
+
+Skills and custom commands show up in the «/» completion list and in `/help`.
+
+```
+/skills                       list discovered skills
+/memory                       show AGENTS.md / MEMORY.md in effect
+/init                         create a starter AGENTS.md
+```
+
 ## Configuration
 
 Global config: `~/.zames/config.json`

package/dist/agent-loop.js

@@ -1,9 +1,10 @@
 import { buildSystemPrompt } from './system-prompt.js';
+import { loadProjectContext } from './context.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
 import { normText } from './browser.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 200, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
     // UI callbacks must NEVER break the agent loop. A rendering error (a huge
     // tool result, a broken markdown frame, a closed terminal) used to throw
     // out of the loop right after a tool call — the session looked "stopped
@@ -20,6 +21,11 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         };
     };
     const safeThinking = safe(onThinking);
+    // Start the "working" indicator ONLY when a message is really sent (after
+    // the send-pause), not while the loop is still preparing the request.
+    // Previously safeThinking() fired before browser.ask(), so the spinner ran
+    // through the whole throttle pause / chat-open phase with nothing in flight.
+    browser.onSendStart = safeThinking;
     const safeAssistantThought = safe(onAssistantThought);
     const safeToolCall = safe(onToolCall);
     const safeToolResult = safe(onToolResult);
@@ -54,15 +60,27 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         catch (e) {
             gitText = `(git context error: ${e.message})`;
         }
+        let context = null;
+        try {
+            context = await loadProjectContext(workdir);
+        }
+        catch {
+            context = null;
+        }
         const systemPrompt = buildSystemPrompt({
             workdir,
             tools,
             gitContext: gitText,
             locale,
+            context,
         });
         transcript?.log('system_prompt', {
             length: systemPrompt.length,
             gitContext: gitText,
+            agents: context?.agents.map((f) => f.path) ?? [],
+            memory: context?.memory.map((f) => f.path) ?? [],
+            skills: context?.skills.map((s) => s.name) ?? [],
+            commands: context?.commands.map((c) => c.name) ?? [],
         });
         safeThinking();
         // system-prompt is an agent send: throttled (agent: true).
@@ -134,7 +152,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     let afterToolRetries = 0;
     const MAX_AFTER_TOOL_RETRIES = 6;
     for (let i = 0; i < maxIterations; i++) {
-        safeThinking();
+        // NOTE: the spinner is NOT started here. browser.onSendStart fires it
+        // right when the message is actually typed/sent (after the send-pause),
+        // so no spinner runs during the pre-send phase.
         // The first message (task) is user input: no throttle.
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.

package/dist/browser.js

@@ -139,6 +139,11 @@ export class DeepSeekBrowser {
     _netSniff;
     _netSniffLimit;
     _netHookInstalled;
+    // Fired right when a message is actually typed/sent (AFTER the send-pause
+    // and attachments). Used to start the "agent is working" spinner only when
+    // a generation really begins, not during the pre-send phase (chat open,
+    // throttle wait), which used to show a spinner with no work in flight.
+    onSendStart;
     constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 3, stabilityDelayMs = 1000, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, } = {}) {
         this.headless = headless;
         this.debug = debug;
@@ -161,6 +166,7 @@ export class DeepSeekBrowser {
         this._netSniff = [];
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
+        this.onSendStart = null;
     }
     async launch() {
         await killStaleChrome();
@@ -670,6 +676,16 @@ export class DeepSeekBrowser {
         // Esc/Ctrl+C pressed during the pause — do not send anything.
         if (this._abort)
             return '(прервано пользователем)';
+        // The pause is over and we are really about to type/send: only NOW start
+        // the "working" indicator. The spinner used to be started by the caller
+        // BEFORE ask(), so it ran for the whole throttle pause and chat-opening
+        // phase with no generation in flight.
+        if (this.onSendStart) {
+            try {
+                this.onSendStart();
+            }
+            catch { }
+        }
         this._netCapture = '';
         this._netCaptureAt = 0;
         // Attach files/images FIRST (before the text): the DeepSeek upload widget

package/dist/config.js

@@ -6,7 +6,7 @@ const ZAMES_HOME = path.join(os.homedir(), '.zames');
 const HOME_CONFIG = path.join(ZAMES_HOME, 'config.json');
 const PROJECT_CONFIG = path.join(process.cwd(), '.zamesrc.json');
 export const DEFAULTS = {
-    maxIterations: 40,
+    maxIterations: 200,
     headless: false,
     debug: false,
     browserChannel: null,
@@ -77,7 +77,7 @@ function deepMerge(target, source) {
 }
 export const CONFIG_SCHEMA = [
     { path: 'ui.locale', type: 'enum', values: ['ru', 'en'], labelKey: 'cfg.f.ui_locale', groupKey: 'cfg.group.ui' },
-    { path: 'maxIterations', type: 'number', min: 1, max: 1000, labelKey: 'cfg.f.maxIterations', groupKey: 'cfg.group.agent' },
+    { path: 'maxIterations', type: 'number', min: 1, max: 100000, labelKey: 'cfg.f.maxIterations', groupKey: 'cfg.group.agent' },
     { path: 'headless', type: 'boolean', labelKey: 'cfg.f.headless', groupKey: 'cfg.group.agent' },
     { path: 'debug', type: 'boolean', labelKey: 'cfg.f.debug', groupKey: 'cfg.group.agent' },
     { path: 'hotReload', type: 'boolean', labelKey: 'cfg.f.hotReload', groupKey: 'cfg.group.agent' },

package/dist/context.js

@@ -0,0 +1,270 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const MAX_FILE_BASE = 60000;
+const MAX_TOTAL = 240000;
+const CRLF_RE = /\r\n/g;
+const NL = String.fromCharCode(10);
+function clipIf(name, content, budget) {
+    const cleaned = content.replace(CRLF_RE, NL).trim();
+    if (cleaned.length <= budget)
+        return cleaned;
+    const keep = Math.max(0, budget - 120);
+    return cleaned.slice(0, keep) + NL + NL + '[... ' + name + ' truncated (' + (cleaned.length - keep) + ' chars omitted) ...]';
+}
+async function readIfFile(p, budget) {
+    try {
+        const st = await fs.stat(p);
+        if (!st.isFile())
+            return null;
+        const raw = await fs.readFile(p, 'utf-8');
+        const content = clipIf(path.basename(p), raw, budget);
+        if (!content)
+            return null;
+        return { path: p, content };
+    }
+    catch {
+        return null;
+    }
+}
+const AGENT_NAMES = ['AGENTS.md', 'agents.md', 'Agents.md'];
+const MEMORY_NAMES = ['MEMORY.md', 'memory.md', 'Memory.md'];
+async function findNamedFile(dir, names) {
+    for (const n of names) {
+        const p = path.join(dir, n);
+        const st = await fs.stat(p).catch(() => null);
+        if (st && st.isFile())
+            return p;
+    }
+    return null;
+}
+function dirChainFromRoot(from) {
+    const out = [];
+    let cur = path.resolve(from);
+    const root = path.parse(cur).root;
+    while (true) {
+        out.unshift(cur);
+        if (cur === root)
+            break;
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return out;
+}
+const PROJECT_SKILL_DIRS = ['.zames/skills', '.claude/skills', '.agents/skills', 'skills'];
+function parseFrontmatter(raw) {
+    const norm = raw.replace(CRLF_RE, NL);
+    if (!norm.startsWith('---'))
+        return {};
+    const end = norm.indexOf(NL + '---', 3);
+    if (end === -1)
+        return {};
+    const block = norm.slice(3, end);
+    const out = {};
+    let lastKey = null;
+    for (const rawLine of block.split(NL)) {
+        const line = rawLine.replace(/\s+$/, '');
+        if (!line || /^\s*#/.test(line))
+            continue;
+        const m = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (m && !/^\s/.test(line)) {
+            const key = m[1];
+            let val = (m[2] || '').trim();
+            if (val === '|' || val === '>') {
+                out[key] = '';
+                lastKey = key;
+                continue;
+            }
+            if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                val = val.slice(1, -1);
+            }
+            out[key] = val;
+            lastKey = key;
+        }
+        else if (lastKey && /^\s+/.test(line)) {
+            out[lastKey] = ((out[lastKey] || '') + ' ' + line.trim()).trim();
+        }
+    }
+    const allowedTools = typeof out['allowed-tools'] === 'string'
+        ? out['allowed-tools'].split(/,/).map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    const userInvokable = typeof out['user-invokable'] === 'string'
+        ? out['user-invokable'].toLowerCase() !== 'false'
+        : undefined;
+    return { name: out.name, description: out.description, allowedTools, userInvokable };
+}
+export function skillBody(raw) {
+    const norm = raw.replace(CRLF_RE, NL);
+    if (!norm.startsWith('---'))
+        return norm.trim();
+    const end = norm.indexOf(NL + '---', 3);
+    if (end === -1)
+        return norm.trim();
+    return norm.slice(norm.indexOf(NL, end + 1) + 1).trim();
+}
+async function findSkillFiles(root, depth = 3) {
+    const out = [];
+    const walk = async (dir, level) => {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isFile() && e.name === 'SKILL.md')
+                out.push(full);
+            else if (e.isDirectory() && level < depth)
+                await walk(full, level + 1);
+        }
+    };
+    await walk(root, 1);
+    return out;
+}
+export async function loadSkills(workdir) {
+    const found = [];
+    const seen = new Set();
+    const roots = [];
+    for (const rel of PROJECT_SKILL_DIRS) {
+        roots.push({ dir: path.join(workdir, rel), source: 'project' });
+    }
+    roots.push({ dir: path.join(os.homedir(), '.zames', 'skills'), source: 'global' });
+    roots.push({ dir: path.join(os.homedir(), '.claude', 'skills'), source: 'global' });
+    for (const root of roots) {
+        const files = await findSkillFiles(root.dir);
+        for (const f of files) {
+            const raw = await fs.readFile(f, 'utf-8').catch(() => null);
+            if (raw === null)
+                continue;
+            const fm = parseFrontmatter(raw);
+            const dir = path.dirname(f);
+            const name = (fm.name || path.basename(dir)).trim();
+            if (!name)
+                continue;
+            const key = name.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const description = (fm.description || '').replace(/\s+/g, ' ').trim();
+            found.push({ name, description, path: f, dir, allowedTools: fm.allowedTools, source: root.source, userInvokable: fm.userInvokable !== false });
+        }
+    }
+    found.sort((a, b) => a.name.localeCompare(b.name));
+    return found;
+}
+const PROJECT_COMMAND_DIRS = ['.zames/commands', '.claude/commands', '.agents/commands'];
+async function loadCommandsFromDir(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (!/\.md$/i.test(e))
+            continue;
+        const full = path.join(dir, e);
+        const st = await fs.stat(full).catch(() => null);
+        if (!st || !st.isFile())
+            continue;
+        const raw = await fs.readFile(full, 'utf-8').catch(() => null);
+        if (raw === null)
+            continue;
+        const fm = parseFrontmatter(raw);
+        const name = path.basename(e, '.md').trim();
+        if (!name)
+            continue;
+        out.push({ name, description: (fm.description || '').replace(/\s+/g, ' ').trim(), path: full, body: skillBody(raw) });
+    }
+    return out;
+}
+export async function loadCommands(workdir) {
+    const out = [];
+    const seen = new Set();
+    const dirs = PROJECT_COMMAND_DIRS.map((d) => path.join(workdir, d));
+    dirs.push(path.join(os.homedir(), '.zames', 'commands'));
+    dirs.push(path.join(os.homedir(), '.claude', 'commands'));
+    for (const dir of dirs) {
+        for (const c of await loadCommandsFromDir(dir)) {
+            const key = c.name.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(c);
+        }
+    }
+    out.sort((a, b) => a.name.localeCompare(b.name));
+    return out;
+}
+async function loadAgentsChain(workdir) {
+    const out = [];
+    const seen = new Set();
+    for (const p of [path.join(os.homedir(), '.zames', 'AGENTS.md'), path.join(os.homedir(), '.claude', 'CLAUDE.md')]) {
+        const f = await readIfFile(p, MAX_FILE_BASE);
+        if (f && !seen.has(f.path)) {
+            seen.add(f.path);
+            out.push(f);
+        }
+    }
+    const chain = dirChainFromRoot(workdir);
+    for (const dir of chain) {
+        const p = await findNamedFile(dir, AGENT_NAMES);
+        if (!p || seen.has(p))
+            continue;
+        const f = await readIfFile(p, MAX_FILE_BASE);
+        if (f) {
+            seen.add(p);
+            out.push(f);
+        }
+    }
+    return out;
+}
+async function loadMemoryChain(workdir) {
+    const out = [];
+    const seen = new Set();
+    for (const p of [path.join(os.homedir(), '.zames', 'MEMORY.md'), path.join(os.homedir(), '.claude', 'MEMORY.md')]) {
+        const f = await readIfFile(p, MAX_FILE_BASE);
+        if (f && !seen.has(f.path)) {
+            seen.add(f.path);
+            out.push(f);
+        }
+    }
+    const chain = dirChainFromRoot(workdir);
+    for (const dir of chain) {
+        const p = await findNamedFile(dir, MEMORY_NAMES);
+        if (!p || seen.has(p))
+            continue;
+        const f = await readIfFile(p, MAX_FILE_BASE);
+        if (f) {
+            seen.add(p);
+            out.push(f);
+        }
+    }
+    return out;
+}
+export async function loadProjectContext(workdir) {
+    const [agents, memory, skills, commands] = await Promise.all([
+        loadAgentsChain(workdir).catch(() => []),
+        loadMemoryChain(workdir).catch(() => []),
+        loadSkills(workdir).catch(() => []),
+        loadCommands(workdir).catch(() => []),
+    ]);
+    let used = 0;
+    const withinBudget = (files) => {
+        const kept = [];
+        for (const f of files) {
+            if (used + f.content.length > MAX_TOTAL)
+                break;
+            used += f.content.length;
+            kept.push(f);
+        }
+        return kept;
+    };
+    return { agents: withinBudget(agents), memory: withinBudget(memory), skills, commands };
+}

package/dist/i18n.js

@@ -83,6 +83,18 @@ const CATALOG = {
     'help.cmd.debug_dom': { ru: '/debug-dom               сохранить HTML страницы (для отладки)', en: '/debug-dom               dump page HTML (debug)' },
     'help.cmd.help': { ru: '/help, help              справка', en: '/help, help              this help' },
     'help.cmd.exit': { ru: '/exit, /quit, exit       выход', en: '/exit, /quit, exit       exit' },
+    'skills.none': { ru: 'Навыки не найдены. Добавьте SKILL.md в .zames/skills/<имя>/ или ~/.zames/skills/.', en: 'No skills found. Add SKILL.md under .zames/skills/<name>/ or ~/.zames/skills/.' },
+    'skills.title': { ru: 'Найдено навыков: {n}', en: 'Skills found: {n}' },
+    'memory.agents': { ru: 'Инструкции (AGENTS.md):', en: 'Instructions (AGENTS.md):' },
+    'memory.memory': { ru: 'Память (MEMORY.md):', en: 'Memory (MEMORY.md):' },
+    'init.exists': { ru: 'AGENTS.md уже существует: {v}', en: 'AGENTS.md already exists: {v}' },
+    'init.created': { ru: 'Создан {v}', en: 'Created {v}' },
+    'help.cmd.skill': { ru: 'навык (SKILL.md)', en: 'skill (SKILL.md)' },
+    'help.cmd.custom': { ru: 'пользовательская команда', en: 'custom command' },
+    'help.cmd.skills': { ru: '/skills                  список найденных навыков', en: '/skills                  list discovered skills' },
+    'help.cmd.memory': { ru: '/memory                  показать MEMORY.md и AGENTS.md', en: '/memory                  show MEMORY.md and AGENTS.md' },
+    'help.cmd.init': { ru: '/init                    создать AGENTS.md для проекта', en: '/init                    create AGENTS.md for the project' },
+    'help.skills': { ru: 'Навыки и свои команды:', en: 'Skills and custom commands:' },
     'help.self_review': { ru: 'Самообзор (отладка агента):', en: 'Self-review (agent debugging):' },
     'help.self.review': { ru: '/self-review [фокус]     снять снапшот src/ и запустить ревью', en: '/self-review [focus]     snapshot src/ and run review' },
     'help.self.fix': { ru: '/self-fix <name> [фокус] вернуться в существующий снапшот и продолжить', en: '/self-fix <name> [focus] enter an existing snapshot and continue' },
@@ -128,6 +140,7 @@ const CATALOG = {
     'msg.new_chat': { ru: 'Создаю новый чат...', en: 'Creating a new chat...' },
     'msg.new_chat_ok': { ru: 'Новый чат.', en: 'New chat.' },
     'msg.resuming': { ru: 'Восстанавливаю сессию {id}...', en: 'Restoring session {id}...' },
+    'msg.input_locked': { ru: 'Идёт операция, ввод временно заблокирован…', en: 'Operation in progress, input is temporarily locked…' },
     'msg.opening_chat': { ru: 'Открываю чат {id}...', en: 'Opening chat {id}...' },
     'msg.chat_opened': { ru: 'Чат открыт.', en: 'Chat opened.' },
     'msg.interactive': { ru: 'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.', en: 'Interactive mode. Enter a task. Commands — /help. Exit — /exit.' },

package/dist/index.js

@@ -226,6 +226,7 @@ ${theme.bold(t('help.self_review'))}
   ${t('help.self.list')}
   ${t('help.self.diff')}
   ${t('help.self.apply')}
+${dynamicCommands.length ? '\n' + theme.bold(t('help.skills')) + '\n' + dynamicCommands.map((d) => '  ' + d.name.padEnd(24) + ' ' + d.description).join('\n') : ''}
 
 ${theme.bold(t('help.files'))}
   ${t('help.files.logs')}        ${config.transcript.dir}
@@ -261,6 +262,9 @@ const SLASH_COMMANDS = [
     { name: '/undo-list', key: 'help.cmd.undo_list' },
     { name: '/transcript', key: 'help.cmd.transcript' },
     { name: '/config', key: 'help.cmd.config' },
+    { name: '/skills', key: 'help.cmd.skills' },
+    { name: '/memory', key: 'help.cmd.memory' },
+    { name: '/init', key: 'help.cmd.init' },
     { name: '/debug-dom', key: 'help.cmd.debug_dom' },
     { name: '/self-review', key: 'help.self.review' },
     { name: '/self-fix', key: 'help.self.fix' },
@@ -271,12 +275,82 @@ const SLASH_COMMANDS = [
     { name: '/exit', key: 'help.cmd.exit' },
     { name: '/quit', key: 'help.cmd.exit' },
 ];
+// Dynamically discovered skills and custom commands for the current workdir.
+// Filled in by refreshDynamicCommands() and shown in the «/» hint list and
+// help. Skills are surfaced as /skill-name entries (user-invokable only).
+let dynamicCommands = [];
+async function refreshDynamicCommands(workdir) {
+    const out = [];
+    try {
+        const { loadSkills, loadCommands } = await import('./context.js');
+        const skills = await loadSkills(workdir);
+        for (const s of skills) {
+            if (!s.userInvokable)
+                continue;
+            out.push({
+                name: '/' + s.name,
+                description: s.description || t('help.cmd.skill'),
+            });
+        }
+        const cmds = await loadCommands(workdir);
+        for (const c of cmds) {
+            out.push({
+                name: '/' + c.name,
+                description: c.description || t('help.cmd.custom'),
+            });
+        }
+    }
+    catch {
+        // best-effort: a broken skill/command must not break the CLI
+    }
+    dynamicCommands = out;
+}
+// Expand a slash target (skill or custom command) into a task string.
+// Returns null when the name is neither a skill nor a custom command.
+async function expandSlashTarget(workdir, name, rest) {
+    try {
+        const { loadSkills, loadCommands, skillBody } = await import('./context.js');
+        const commands = await loadCommands(workdir);
+        const cmd = commands.find((c) => c.name.toLowerCase() === name.toLowerCase());
+        if (cmd) {
+            let body = cmd.body.replace(/\{\{args\}\}/g, rest);
+            body = body.replace(/\$ARGUMENTS/g, rest);
+            return body.trim() || rest;
+        }
+        const skills = await loadSkills(workdir);
+        const skill = skills.find((s) => s.name.toLowerCase() === name.toLowerCase() && s.userInvokable);
+        if (skill) {
+            let body = '';
+            try {
+                const raw = await fs.readFile(skill.path, 'utf-8');
+                body = skillBody(raw);
+            }
+            catch {
+                body = '';
+            }
+            const header = 'Follow the skill "' + skill.name + '" (from ' + skill.path + ').';
+            const extra = rest ? '\n\nAdditional instructions from the operator: ' + rest : '';
+            return header + '\n\n' + body + extra;
+        }
+    }
+    catch {
+        // fall through: treated as an unknown command
+    }
+    return null;
+}
 // Slash-command descriptions in the current language (for LineEditor hints).
 function buildSlashCommands() {
-    return SLASH_COMMANDS.map((c) => ({
+    const base = SLASH_COMMANDS.map((c) => ({
         name: c.name,
         description: t(c.key),
     }));
+    const known = new Set(base.map((c) => c.name.toLowerCase()));
+    for (const d of dynamicCommands) {
+        if (known.has(d.name.toLowerCase()))
+            continue;
+        base.push(d);
+    }
+    return base;
 }
 // We put the agent's temporary files (one-off scripts, etc.) in
 // <project>/tmp — this folder is in .gitignore and is cleaned on every launch.
@@ -714,9 +788,15 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
         };
         // Execute the task, then everything the user managed to type while it
         // ran. The queue may be replenished right during draining.
+        //
+        // NOTE: we do NOT call ui.thinking() here. runAgentLoop() fires
+        // onThinking() right before the actual browser send (after the send
+        // pause, system-prompt, etc.), so the spinner only appears when a
+        // generation really starts. Calling it here made the spinner run for
+        // the whole pre-send phase (chat creation, throttle wait) with no
+        // generation in flight.
         while (true) {
-            ui.thinking();
-            await mod.runAgentLoop({
+            const outcome = await mod.runAgentLoop({
                 browser,
                 tools,
                 task: next.text,
@@ -735,6 +815,16 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 debugLog: debug,
                 locale: currentLocale,
             });
+            // The loop may end WITHOUT a model answer: an exhausted iteration
+            // limit or an ask() watchdog (the model stopped responding). In that
+            // case no assistant message was shown, and the operator saw the run
+            // just "stop" after a tool call with no explanation. Surface it.
+            if (outcome &&
+                (outcome.startsWith('Достигнут лимит итераций') ||
+                    outcome.startsWith('ask() watchdog'))) {
+                ui.warning(outcome);
+                transcript?.log('agent_no_answer', { outcome });
+            }
             // Aborted (Esc/Ctrl+C) — we don't start the next tasks from the queue
             // and clear it, so "stop" really stops everything.
             if (browser._stopped) {
@@ -770,6 +860,9 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     finally {
         stopWatching();
         ui.stop();
+        // Detach the send hook so a later browser.ask() outside this task cannot
+        // start a stale spinner.
+        browser.onSendStart = null;
     }
 }
 // ---------- main ----------
@@ -954,6 +1047,7 @@ async function main() {
         }
         return theme.prompt('❯ ') + tail + theme.dim(' › ');
     };
+    await refreshDynamicCommands(currentWorkdir);
     if (process.stdin.isTTY && process.stdout.isTTY) {
         const ed = new LineEditor({
             prompt: buildPrompt(),
@@ -1339,6 +1433,8 @@ async function main() {
         }
         if (['/new', '/clear', 'new'].includes(lower)) {
             console.log(theme.system(t('msg.new_chat')));
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 await browser.newChat();
                 freshChatNext = false;
@@ -1351,6 +1447,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.new_chat_error', { v: e.message })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         // ---------- Self-review ----------
@@ -1360,6 +1460,8 @@ async function main() {
             const originalWorkdir = reviewMode
                 ? reviewMode.originalWorkdir
                 : currentWorkdir;
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 const result = await mod.selfReview({
                     browser,
@@ -1388,6 +1490,10 @@ async function main() {
                 if (debug)
                     console.error(e.stack);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/self-fix' || lower.startsWith('/self-fix ')) {
@@ -1513,6 +1619,8 @@ async function main() {
         // ---------- Regular commands ----------
         if (lower === '/chats') {
             const spin = editor || mod.createSpinner(currentLocale);
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             spin.thinking();
             try {
                 lastChats = await browser.listChats(30);
@@ -1533,6 +1641,10 @@ async function main() {
                 spin.stop();
                 console.error(theme.error(t('chats.fetch_error')), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/resume' || lower.startsWith('/resume ')) {
@@ -1556,6 +1668,8 @@ async function main() {
                 continue;
             }
             console.log(theme.system(t('chats.opening', { v: pick.title })));
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 await browser.openChat(pick.id);
                 currentChatId = pick.id;
@@ -1571,6 +1685,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/chat') {
@@ -1608,6 +1726,8 @@ async function main() {
                 console.error(theme.error(t('sessions.resume_id_usage')));
                 continue;
             }
+            if (editor)
+                editor.lock(t('msg.input_locked'));
             try {
                 console.log(theme.system(t('msg.opening_chat', { id })));
                 await browser.openChat(id);
@@ -1622,12 +1742,70 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.open_chat_error', { v: '' })), e.message);
             }
+            finally {
+                if (editor)
+                    editor.unlock();
+            }
             continue;
         }
         if (lower === '/pwd') {
             console.log(theme.system(currentWorkdir));
             continue;
         }
+        if (lower === '/skills') {
+            const { loadSkills } = await import('./context.js');
+            const skills = await loadSkills(currentWorkdir);
+            if (!skills.length) {
+                console.log(theme.dim(t('skills.none')));
+            }
+            else {
+                console.log(theme.system(t('skills.title', { n: String(skills.length) })));
+                for (const s of skills) {
+                    console.log('  ' +
+                        theme.user('/' + s.name) +
+                        theme.dim(' [' + s.source + '] ') +
+                        (s.description || theme.dim(t('common.none'))));
+                    console.log(theme.dim('      ' + s.path));
+                }
+            }
+            continue;
+        }
+        if (lower === '/memory') {
+            const { loadProjectContext } = await import('./context.js');
+            const ctx = await loadProjectContext(currentWorkdir);
+            const show = (title, files) => {
+                console.log(theme.system(title));
+                if (!files.length) {
+                    console.log(theme.dim('  ' + t('common.none')));
+                    return;
+                }
+                for (const f of files)
+                    console.log('  ' + f.path);
+            };
+            show(t('memory.agents'), ctx.agents);
+            show(t('memory.memory'), ctx.memory);
+            continue;
+        }
+        if (lower === '/init') {
+            const target = path.join(currentWorkdir, 'AGENTS.md');
+            const exists = await fs.stat(target).catch(() => null);
+            if (exists) {
+                console.log(theme.warn(t('init.exists', { v: target })));
+                continue;
+            }
+            const stub = '# AGENTS.md\n\n' +
+                'Project instructions for the coding agent. Describe the build/test commands, ' +
+                'conventions, and any rules the agent must follow in this repository.\n\n' +
+                '## Commands\n\n' +
+                '- build: `...`\n' +
+                '- test: `...`\n' +
+                '- lint: `...`\n\n' +
+                '## Conventions\n\n' +
+                '- ...\n';
+            await fs.writeFile(target, stub, 'utf-8');
+            console.log(theme.assistant(t('init.created', { v: target })));
+            continue;
+        }
         if (lower === '/reload') {
             console.log(theme.system(t('msg.reload_start')));
             try {
@@ -1644,6 +1822,10 @@ async function main() {
             catch (e) {
                 console.error(theme.error(t('msg.reload_error')), e.message);
             }
+            await autoReload();
+            await refreshDynamicCommands(currentWorkdir);
+            if (editor)
+                editor.setCommands(buildSlashCommands());
             continue;
         }
         if (lower === '/status') {
@@ -1754,6 +1936,9 @@ async function main() {
                 currentWorkdir = newDir;
                 freshChatNext = true;
                 sendSystemPromptNext = true;
+                await refreshDynamicCommands(currentWorkdir);
+                if (editor)
+                    editor.setCommands(buildSlashCommands());
                 console.log(theme.system(t('cd.changed', { v: newDir })));
             }
             catch (e) {
@@ -1761,19 +1946,29 @@ async function main() {
             }
             continue;
         }
+        // Custom command or skill invoked as a slash command? Expand it into a
+        // task. Skills are instructions the agent follows; custom commands are
+        // prompt templates with $ARGUMENTS / {{args}} placeholders.
+        let expandedTask = null;
         if (lower.startsWith('/')) {
+            const name = trimmed.slice(1).split(/\s+/)[0];
+            const rest = trimmed.slice(1 + name.length).trim();
+            expandedTask = await expandSlashTarget(currentWorkdir, name, rest);
+        }
+        if (lower.startsWith('/') && expandedTask === null) {
             console.error(theme.error(t('msg.unknown_cmd', { v: trimmed })));
             continue;
         }
         // ---- Regular task (including in review mode) ----
+        const taskText = expandedTask !== null ? expandedTask : trimmed;
         // Dev mode: pick up fresh logic modules before the task.
         await autoReload();
-        transcript.log('user_task', { task: trimmed, workdir: currentWorkdir });
+        transcript.log('user_task', { task: taskText, workdir: currentWorkdir });
         const tools = mod.createTools(currentWorkdir, { undo });
         if (editor)
             editor.busy = true;
         try {
-            await runTask(browser, tools, trimmed, currentWorkdir, {
+            await runTask(browser, tools, taskText, currentWorkdir, {
                 transcript,
                 freshChat: freshChatNext,
                 sendSystemPrompt: sendSystemPromptNext,

package/dist/input.js

@@ -207,6 +207,11 @@ export class LineEditor {
     // Clipboard callback: tries to read an image from the OS clipboard when the
     // terminal itself sends no usable data (Ctrl+V, right-click, empty paste).
     onClipboard;
+    // When locked, the editor ignores text input and Enter (submit). Used while
+    // a long operation runs (chat resume/open, /new, self-review): otherwise the
+    // user could type and send a message mid-operation, and it would be queued
+    // and sent right after the operation, breaking the restored session.
+    locked;
     constructor({ prompt = '> ', commands = [] } = {}) {
         this.promptStr = prompt;
         this.buf = '';
@@ -236,6 +241,7 @@ export class LineEditor {
         this._tmpDir = '';
         this.onAttach = null;
         this.onClipboard = null;
+        this.locked = false;
     }
     // Read the OS clipboard for an image and insert its marker. Used when the
     // terminal sends no usable paste data (Ctrl+V / right-click / empty paste).
@@ -333,6 +339,19 @@ export class LineEditor {
         this._writeBlock();
         this._render();
     }
+    // Lock input while a long operation runs (chat resume/open, /new,
+    // self-review). The line stays visible but text input and Enter are ignored,
+    // so a message typed mid-operation is not queued and sent afterwards,
+    // breaking the restored session. Ctrl+C/Ctrl+D still work so the user can
+    // abort.
+    lock(status) {
+        this.locked = true;
+        if (status)
+            this.setStatus(theme.dim(status));
+    }
+    unlock() {
+        this.locked = false;
+    }
     setPrompt(str) {
         this.promptStr = str;
         this._render();
@@ -481,6 +500,10 @@ export class LineEditor {
     }
     // ---------- input ----------
     _submit() {
+        if (this.locked) {
+            this._render();
+            return;
+        }
         const display = this.buf;
         if (!display.trim()) {
             this._render();
@@ -716,6 +739,25 @@ export class LineEditor {
     }
     _handle(data) {
         let s = data.toString('utf-8');
+        // While locked (a long operation is running), swallow all input except
+        // Ctrl+C / Ctrl+D — so the user can still abort, but cannot type a message
+        // that would be queued and sent after the operation.
+        if (this.locked) {
+            if (s.length === 1) {
+                const c = s.charCodeAt(0);
+                if (c === 3) {
+                    if (this.onCtrlC)
+                        this.onCtrlC();
+                    return;
+                }
+                if (c === 4) {
+                    if (this.onCtrlC)
+                        this.onCtrlC();
+                    return;
+                }
+            }
+            return;
+        }
         if (!this._inPaste && s === ESC) {
             if (this.onEscape)
                 this.onEscape();

package/dist/system-prompt.js

@@ -1,5 +1,53 @@
 import { translate } from './i18n.js';
-export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], }) {
+/** Render the AGENTS.md / MEMORY / skills / commands blocks of the prompt. */
+export function renderContextSection(context) {
+    if (!context)
+        return '';
+    let out = '';
+    for (const f of context.agents) {
+        out +=
+            '\n## Project instructions (' + f.path + ')\n\n' +
+                'The following come from ' + f.path + '. Follow them for this project unless the operator explicitly overrides them.\n\n' +
+                f.content +
+                '\n';
+    }
+    for (const f of context.memory) {
+        out +=
+            '\n## Memory (' + f.path + ')\n\n' +
+                'Durable notes accumulated across sessions. Treat as background knowledge; update this file when you learn something worth remembering.\n\n' +
+                f.content +
+                '\n';
+    }
+    if (context.memory.length) {
+        out +=
+            '\nWhen you learn a durable fact about this project or the operator preferences (build quirks, ' +
+                'conventions, gotchas), append a short bullet to ' + context.memory[0].path + ' via Edit/Write so it survives ' +
+                'into future sessions. Keep entries concise.\n';
+    }
+    if (context.skills.length) {
+        const lines = context.skills.map((s) => {
+            const tools = s.allowedTools && s.allowedTools.length
+                ? ' [tools: ' + s.allowedTools.join(', ') + ']'
+                : '';
+            return '- ' + s.name + tools + ': ' + (s.description || '(no description)') + '\n  file: ' + s.path;
+        });
+        out +=
+            '\n## Skills\n\n' +
+                'Specialized workflows available as SKILL.md files. When a task matches a skill description, read its file and follow its instructions. Skills are progressive disclosure: only read the body when the skill applies.\n\n' +
+                lines.join('\n') +
+                '\n';
+    }
+    if (context.commands.length) {
+        const lines = context.commands.map((c) => '- /' + c.name + ': ' + (c.description || '(no description)'));
+        out +=
+            '\n## Custom commands\n\n' +
+                'Reusable prompts the operator can invoke with a slash command. If the operator runs one, its body arrives as the task text.\n\n' +
+                lines.join('\n') +
+                '\n';
+    }
+    return out;
+}
+export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, }) {
     const t = translate(locale);
     const toolDescriptions = tools
         .map((t2) => `### ${t2.name}\n${t2.description}\nПараметры: ${JSON.stringify(t2.parameters)}`)
@@ -11,6 +59,7 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null, locale =
         ? `\n## Attachments\n\nThe user attached files to this task: ${attachments.join(', ')}.\n` +
             `Each [image#N] / [file#N] marker corresponds to a file the user pasted into the terminal; the file was uploaded to the chat and also saved under <project>/tmp. Look at the images in the chat; for files, read the copy in tmp if you need the contents.\n`
         : '';
+    const contextSection = renderContextSection(context);
     return `You are a coding agent running in a terminal. You help the user with software engineering tasks by reading files, writing code, running commands, and iterating until the task is done.
 
 You work in the directory: ${workdir}
@@ -63,7 +112,7 @@ task is done (or when you must ask the operator), not between tool calls.
 You have access to the following tools:
 
 ${toolDescriptions}
-${gitSection}${attachSection}
+${gitSection}${attachSection}${contextSection}
 ## How to use tools
 
 To call ONE tool, respond with ONLY a JSON object (no markdown fences, no extra text):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.10.8",
+  "version": "2.11.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {