zames_pro 2.10.9 → 2.12.0

package/README.md

@@ -76,6 +76,36 @@ 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`). Run `/init` and the agent
+  will explore the project and write an AGENTS.md based on the real build/test
+  commands and conventions (use `/init --force` to overwrite an existing file).
+- **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 [--force]               analyze the project and create 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
@@ -59,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).
@@ -919,6 +932,26 @@ function parseToolCallPermissive(text) {
     if (!toolMatch)
         return null;
     const tool = toolMatch[1];
+    // The model occasionally puts the argument keys INLINE with "tool" —
+    // {"tool": "Bash", "command": "..."} — with no "args" wrapper at all.
+    // The strict parser rejects it (no obj.args), and the permissive parser
+    // used to bail out too (indexOf('"args"') === -1). Such a call was
+    // reported as malformed and re-asked up to MAX_MALFORMED_RETRIES times;
+    // after the budget ran out the run stopped with the model's text as the
+    // final answer. Flatten the inline keys into args when "args" is absent.
+    if (text.indexOf('"args"') === -1) {
+        const braceIdx = text.indexOf('{');
+        if (braceIdx === -1)
+            return null;
+        const endBrace = findMatching(text, braceIdx, '{', '}');
+        const objText = endBrace === -1 ? text.slice(braceIdx) : text.slice(braceIdx, endBrace + 1);
+        const inlineArgs = parseArgsPermissive(objText) || parseArgsGreedy(objText);
+        if (!inlineArgs)
+            return null;
+        delete inlineArgs.tool;
+        // The value may be a string ("command": "...") or a number/bool.
+        return { tool, args: inlineArgs };
+    }
     const argsIdx = text.indexOf('"args"');
     if (argsIdx === -1)
         return null;

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,22 @@ 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}' },
+    'init.analyzing': { ru: 'Изучаю проект и готовлю AGENTS.md...', en: 'Analyzing the project and preparing AGENTS.md...' },
+    'init.done': { ru: 'AGENTS.md создан агентом: {v}', en: 'AGENTS.md created by the agent: {v}' },
+    'init.failed': { ru: 'Не удалось создать AGENTS.md автоматически, записан базовый шаблон.', en: 'Could not create AGENTS.md automatically, wrote a basic template.' },
+    'init.overwrite': { ru: 'AGENTS.md уже существует: {v} (используйте /init --force для перезаписи)', en: 'AGENTS.md already exists: {v} (use /init --force to overwrite)' },
+    '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 [--force]          изучить проект и создать AGENTS.md', en: '/init [--force]          analyze the project and create AGENTS.md' },
+    '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' },

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.
@@ -973,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(),
@@ -1677,6 +1752,127 @@ async function main() {
             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' || lower.startsWith('/init ')) {
+            const force = lower.includes('--force');
+            const target = path.join(currentWorkdir, 'AGENTS.md');
+            const exists = await fs.stat(target).catch(() => null);
+            if (exists && !force) {
+                console.log(theme.warn(t('init.overwrite', { v: target })));
+                continue;
+            }
+            // Like Codex: let the agent explore the project and write AGENTS.md via
+            // the Write tool, so the file reflects the real build/test commands and
+            // conventions instead of a static template.
+            const initTask = 'The user ran /init. Analyze this repository and create an AGENTS.md ' +
+                'file at the project root that onboards future coding agents. Explore ' +
+                'the project first (read the README, package.json and other manifests, ' +
+                'configs, CI, and a sample of source files). Then write AGENTS.md with: ' +
+                'an overview of what the project is; build/typecheck/test/lint commands ' +
+                '(use the real scripts you find); code style and conventions; the repo ' +
+                'layout; and any gotchas or rules an agent must follow. Keep it concise ' +
+                'and factual, based only on what you find. Write the file with the Write ' +
+                'tool, then reply via respond with a one-line summary.';
+            const initTools = mod.createTools(currentWorkdir, { undo });
+            if (editor)
+                editor.busy = true;
+            console.log(theme.system(t('init.analyzing')));
+            try {
+                await mod.runAgentLoop({
+                    browser,
+                    tools: initTools,
+                    task: initTask,
+                    workdir: currentWorkdir,
+                    maxIterations: maxIter,
+                    freshChat: freshChatNext,
+                    sendSystemPrompt: sendSystemPromptNext,
+                    transcript,
+                    onThinking: () => { },
+                    onToolCall: (name, toolArgs) => {
+                        if (editor)
+                            editor.toolCall(name, toolArgs);
+                    },
+                    onToolResult: (r) => {
+                        if (editor)
+                            editor.toolResult(r);
+                    },
+                    onAssistantMessage: (m) => {
+                        if (editor)
+                            editor.assistant(m);
+                    },
+                    onWarning: (m) => {
+                        if (editor)
+                            editor.warning(m);
+                    },
+                    locale: currentLocale,
+                });
+            }
+            catch (e) {
+                console.error(theme.error(t('init.failed')), e.message);
+            }
+            finally {
+                if (editor)
+                    editor.busy = false;
+            }
+            freshChatNext = false;
+            sendSystemPromptNext = false;
+            if (!currentChatId) {
+                currentChatId = await browser.getCurrentChatId();
+            }
+            saveLastChat(currentChatId, currentWorkdir);
+            const created = await fs.stat(target).catch(() => null);
+            if (created) {
+                console.log(theme.assistant(t('init.done', { v: target })));
+            }
+            else {
+                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.warn(t('init.failed')));
+                console.log(theme.assistant(t('init.created', { v: target })));
+            }
+            continue;
+        }
         if (lower === '/reload') {
             console.log(theme.system(t('msg.reload_start')));
             try {
@@ -1693,6 +1889,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') {
@@ -1803,6 +2003,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) {
@@ -1810,19 +2013,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

@@ -351,6 +351,12 @@ export class LineEditor {
     }
     unlock() {
         this.locked = false;
+        // A lock may have set the status hint ("operation in progress, input is
+        // temporarily locked"). If nothing else replaced it (no spinner, no
+        // pending text), clear it here — otherwise the hint stays on screen
+        // forever after a fast operation like /new.
+        if (this.statusText)
+            this.setStatus('');
     }
     setPrompt(str) {
         this.promptStr = str;

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.9",
+  "version": "2.12.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {