zames_pro 1.1.1 → 1.2.0

package/README.md

@@ -29,6 +29,11 @@ zames
 
 The agent works inside the directory it was started in and cannot leave it (sandbox).
 
+While the agent is working you can keep typing: press Enter to queue a message
+(it is sent right after the current task, in the same chat), or Esc / Ctrl+C to
+abort the current generation. This mirrors typing during generation on the
+DeepSeek website.
+
 ### Options
 
 ```

package/package.json

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

package/src/agent-loop.js

@@ -1,5 +1,6 @@
 import { buildSystemPrompt } from './system-prompt.js'
 import { getGitContext, formatGitContext } from './gitTools.js'
+import { parseXmlToolCalls } from './xml-toolcall.js'
 
 export async function runAgentLoop({
   browser,
@@ -47,6 +48,12 @@ export async function runAgentLoop({
   let message = task
   transcript?.log('task', { task })
 
+  // Счётчик «ответ похож на tool-call, но не распознан». Чтобы модель,
+  // написавшая битый JSON/XML, не останавливала агента молча, мы просим
+  // её переотправить вызов. Ограничиваем число таких попыток.
+  let malformedRetries = 0
+  const MAX_MALFORMED_RETRIES = 3
+
   for (let i = 0; i < maxIterations; i++) {
     onThinking()
     const rawResponse = await browser.ask(message)
@@ -69,6 +76,23 @@ export async function runAgentLoop({
     }
 
     if (!parsed) {
+      // Ответ не распознан как tool-call. Если он ПОХОЖ на попытку вызова
+      // (есть tool/invoke/parameter, но JSON/XML битый) — это почти всегда
+      // ошибка формата. Не считаем её финальным ответом (иначе агент молча
+      // остановится), а просим модель переотправить вызов корректно.
+      const looksLikeToolCall = /("tool"\s*:|\binvoke\b|\bparameter\b)/i.test(rawResponse)
+      if (looksLikeToolCall && malformedRetries < MAX_MALFORMED_RETRIES) {
+        malformedRetries++
+        transcript?.log("malformed_toolcall", { attempt: malformedRetries, response: rawResponse })
+        if (debugLog) {
+          console.error("внимание: ответ похож на tool-call, но не распознан (попытка " + malformedRetries + "/" + MAX_MALFORMED_RETRIES + ")")
+        }
+        message = "Твой предыдущий ответ не распознан как вызов инструмента. " +
+          "Ответь РОВНО одним JSON-объектом вызова инструмента, без текста до и после. " +
+          "Например: " + String.fromCharCode(39) + "tool" + String.fromCharCode(39) + ": ..., args: {...}"
+        continue
+      }
+
       onAssistantMessage(rawResponse)
       transcript?.log('assistant_final', { message: rawResponse })
       return rawResponse
@@ -531,6 +555,10 @@ function parseToolCall(text) {
     if (tailPermissive) return { ...tailPermissive, _permissive: true }
   }
 
+  // Последний fallback: модель ответила XML/DSML-блоком вместо JSON.
+  const xmlCalls = parseXmlToolCalls(cleaned)
+  if (xmlCalls) return Array.isArray(xmlCalls) ? xmlCalls : [xmlCalls]
+
   return null
 }
 

package/src/browser.js

@@ -3,6 +3,7 @@ import path from 'path'
 import os from 'os'
 import fs from 'fs/promises'
 import { execSync } from 'child_process'
+import { theme } from './theme.js'
 
 const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile')
 const CHAT_URL = 'https://chat.deepseek.com/'
@@ -78,6 +79,7 @@ export class DeepSeekBrowser {
     askRetries = 3,
     stabilityChecks = 3,
     stabilityDelayMs = 1000,
+    minSendIntervalMs = 25000,
   } = {}) {
     this.headless = headless
     this.debug = debug
@@ -86,6 +88,10 @@ export class DeepSeekBrowser {
     this.askRetries = askRetries
     this.stabilityChecks = stabilityChecks
     this.stabilityDelayMs = stabilityDelayMs
+    // Минимальный интервал между отправками в чат: DeepSeek ограничивает
+    // частоту («Messages too frequent. Try again later.»).
+    this.minSendIntervalMs = minSendIntervalMs
+    this._lastSentAt = 0
     this.context = null
     this.page = null
   }
@@ -418,6 +424,20 @@ export class DeepSeekBrowser {
     }
   }
 
+  // Ждём, пока с прошлой отправки пройдёт minSendIntervalMs. Защита от
+  // «Messages too frequent. Try again later.» на [chat.deepseek.com](https://chat.deepseek.com/).
+  async _waitForSendSlot() {
+    if (!this._lastSentAt) return // первая отправка — пауза не нужна
+    const gap = this.minSendIntervalMs - (Date.now() - this._lastSentAt)
+    if (gap <= 0) return
+    console.error(
+      theme.warn(
+        `⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой (лимит частоты DeepSeek)...`,
+      ),
+    )
+    await this.page.waitForTimeout(gap)
+  }
+
   async _askOnce(prompt, { timeout }) {
     const input = await this._findVisible(INPUT_SELECTORS, 10_000)
     if (!input) {
@@ -428,6 +448,7 @@ export class DeepSeekBrowser {
 
     const beforeText = await this._readLastAnswerTextClean().catch(() => '')
 
+    await this._waitForSendSlot()
     await this._setInputText(input, prompt)
     await this.page.waitForTimeout(200)
 
@@ -440,6 +461,7 @@ export class DeepSeekBrowser {
     } catch {
       await this.page.keyboard.press('Enter')
     }
+    this._lastSentAt = Date.now()
 
     const startDeadline = Date.now() + 15_000
     let started = false

package/src/config.js

@@ -43,6 +43,7 @@ const DEFAULTS = {
     askRetries: 3,
     stabilityChecks: 3,
     stabilityDelayMs: 1000,
+    minSendIntervalMs: 25000,
   },
 }
 

package/src/index.js

@@ -8,6 +8,7 @@ import { DeepSeekBrowser } from './browser.js'
 import { createTools } from './tools.js'
 import { runAgentLoop } from './agent-loop.js'
 import { createSpinner } from './spinner.js'
+import { LineEditor } from './input.js'
 import { loadConfig, CONFIG_PATHS, ZAMES_HOME } from './config.js'
 import { Transcript } from './transcript.js'
 import { UndoStore } from './undo.js'
@@ -200,6 +201,10 @@ ${theme.bold('Опции CLI:')}
   --version, -v      показать версию
   --help, -h         эта справка
 
+${theme.bold('Пока агент работает:')}
+  печать + Enter           поставить сообщение в очередь (уйдёт после текущей задачи)
+  Esc, Ctrl+C              прервать текущую генерацию
+
 ${theme.bold('Обычные команды:')}
   /new, /clear             новый чат (сброс контекста)
   /chats                   список последних чатов DeepSeek
@@ -464,29 +469,143 @@ async function promptOnce(question) {
 }
 
 // Слежение за клавиатурой во время работы агента.
-// Esc — прервать текущую генерацию (клик Stop в браузере).
-function watchEscape(onEscape) {
+//
+// Терминал остаётся живым, пока агент думает:
+//   - Esc (или Ctrl+C) — прервать текущую генерацию (клик Stop в браузере);
+//   - набор текста + Enter — поставить сообщение в очередь; оно уйдёт
+//     агенту сразу после того, как текущая задача завершится
+//     (как «отправить во время генерации» в веб-версии DeepSeek).
+//
+// Ввод буферизуется без построчного редактора: набранный текст отображается
+// в строке спиннера через onChange -> ui.setPending(). Enter отправляет буфер
+// в onQueue, пустой Enter игнорируется. Поддержаны Backspace, Ctrl+U, Esc-
+// последовательности (стрелки/Home/End/Delete игнорируются) и bracketed paste.
+function watchInput({ onEscape, onChange, onQueue } = {}) {
   const stdin = process.stdin
-  if (!stdin.isTTY) return () => {}
+  if (!stdin.isTTY || !stdin.setRawMode) return () => {}
+
+  // Управляющие символы собираем из кодов: в этом файле нельзя писать
+  // «сырые» ESC/CR/LF в строковых литералах (см. AGENTS.md).
+  const ESC = String.fromCharCode(27)
+  const CSI = String.fromCharCode(91)
+  const CR = String.fromCharCode(13)
+  const LF = String.fromCharCode(10)
+
   const wasRaw = stdin.isRaw
-  if (stdin.setRawMode) stdin.setRawMode(true)
+  stdin.setRawMode(true)
   stdin.resume()
-  const handler = (buf) => {
-    if (buf.length === 1 && buf[0] === 27) {
-      onEscape()
+  process.stdout.write(ESC + '[?2004h')
+
+  let buf = ''
+  let inPaste = false
+  const PASTE_START = ESC + '[200~'
+  const PASTE_END = ESC + '[201~'
+  const CSI_RE = new RegExp('^' + CSI + '[0-9;]*[A-Za-z~]')
+
+  const emitChange = () => {
+    if (onChange) onChange(buf)
+  }
+
+  // Вставленный текст: переводы строк внутри многострочной вставки
+  // трактуем как пробелы — сообщение уходит одной строкой.
+  const insert = (text) => {
+    buf += text
+      .split(CR + LF).join(' ')
+      .split(CR).join(' ')
+      .split(LF).join(' ')
+  }
+
+  function onData(data) {
+    let s = data.toString('utf-8')
+
+    // Одиночный Esc — прервать генерацию. Стрелки приходят целым чанком
+    // и сюда не попадают.
+    if (!inPaste && s === ESC) {
+      if (onEscape) onEscape()
+      return
+    }
+
+    while (s.length) {
+      if (inPaste) {
+        const end = s.indexOf(PASTE_END)
+        if (end === -1) {
+          insert(s)
+          s = ''
+        } else {
+          insert(s.slice(0, end))
+          s = s.slice(end + PASTE_END.length)
+          inPaste = false
+        }
+        emitChange()
+        continue
+      }
+
+      const start = s.indexOf(PASTE_START)
+      if (start !== -1) {
+        const before = s.slice(0, start)
+        s = s.slice(start + PASTE_START.length)
+        inPaste = true
+        if (before) {
+          insert(before)
+          emitChange()
+        }
+        continue
+      }
+
+      const ch = s[0]
+      const code = s.charCodeAt(0)
+      s = s.slice(1)
+
+      if (ch === CR || ch === LF) {
+        const text = buf.trim()
+        buf = ''
+        emitChange()
+        if (text && onQueue) onQueue(text)
+        continue
+      }
+      if (code === 3) {
+        // Ctrl+C — как Esc: прервать генерацию.
+        if (onEscape) onEscape()
+        continue
+      }
+      if (code === 21) {
+        // Ctrl+U — очистить набранное.
+        buf = ''
+        emitChange()
+        continue
+      }
+      if (code === 127 || code === 8) {
+        // Backspace.
+        if (buf) {
+          buf = buf.slice(0, -1)
+          emitChange()
+        }
+        continue
+      }
+      if (ch === ESC) {
+        // Escape-последовательность (стрелки, Home/End, Delete) — пропускаем.
+        const m = s.match(CSI_RE)
+        if (m) s = s.slice(m[0].length)
+        continue
+      }
+      if (code < 32) continue // прочие управляющие — игнорируем
+
+      buf += ch
+      emitChange()
     }
   }
+
+  const handler = (data) => onData(data)
   stdin.on('data', handler)
   return () => {
     stdin.removeListener('data', handler)
+    process.stdout.write(ESC + '[?2004l')
     if (stdin.setRawMode) stdin.setRawMode(wasRaw || false)
   }
 }
 
 // ---------- workdir resolution ----------
 
-// ---------- workdir resolution ----------
-
 // Агент работает в директории, из которой его запустили (process.cwd()).
 // Это корень sandbox: инструменты не могут выходить выше него.
 async function resolveWorkdir() {
@@ -502,47 +621,75 @@ async function resolveWorkdir() {
 // ---------- task runner ----------
 
 async function runTask(browser, tools, taskText, workdir, opts) {
-  const { transcript, freshChat, sendSystemPrompt } = opts
-
-  const ui = mod.createSpinner()
-  ui.thinking()
-
-  // Esc во время работы — прервать генерацию.
-  const stopWatching = watchEscape(() => {
-    ui.stop()
-    console.error(theme.warn('⏹ Esc — прерываю генерацию...'))
-    browser.stopGeneration().catch(() => {})
-  })
-
-  let finished = false
+  const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor } = opts
+
+  // В TTY-режиме UI — это LineEditor: он владеет вводом (очередь, Esc,
+  // Ctrl+C) и рисует статус НАД постоянной строкой ввода. В не-TTY режиме
+  // (пайпы) — обычный спиннер + watchInput.
+  const ui = editor || mod.createSpinner()
+  const stopWatching = editor
+    ? () => {}
+    : watchInput({
+        onEscape: () => {
+          ui.stop()
+          console.error(theme.warn('⏹ Esc — прерываю генерацию...'))
+          browser.stopGeneration().catch(() => {})
+        },
+        onChange: (text) => ui.setPending(text),
+        onQueue: (text) => {
+          queue.push(text)
+          ui.setPending(null)
+          ui.stop()
+          console.log(
+            theme.user('📨 В очередь (' + queue.length + '): ') + theme.assistant(text),
+          )
+          ui.thinking()
+        },
+      })
 
   try {
-    await mod.runAgentLoop({
-      browser,
-      tools,
-      task: taskText,
-      workdir,
-      maxIterations: maxIter,
-      freshChat,
-      sendSystemPrompt,
-      transcript,
-      onThinking: () => ui.thinking(),
-      onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
-      onToolResult: (result) => ui.toolResult(result),
-      onAssistantMessage: (msg) => {
-        ui.assistant(msg)
-        finished = true
-      },
-      debugLog: debug,
-    })
+    let next = { task: taskText, freshChat, sendSystemPrompt }
+
+    // Выполняем задачу, затем — всё, что пользователь успел напечатать за
+    // время работы. Очередь может пополняться прямо во время дренажа.
+    while (true) {
+      ui.thinking()
+      await mod.runAgentLoop({
+        browser,
+        tools,
+        task: next.task,
+        workdir,
+        maxIterations: maxIter,
+        freshChat: next.freshChat,
+        sendSystemPrompt: next.sendSystemPrompt,
+        transcript,
+        onThinking: () => ui.thinking(),
+        onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
+        onToolResult: (result) => ui.toolResult(result),
+        onAssistantMessage: (msg) => ui.assistant(msg),
+        debugLog: debug,
+      })
+
+      if (!queue.length) break
+
+      const queued = queue.shift()
+      ui.stop()
+      if (editor) {
+        editor.printAbove(theme.user('▶ Из очереди: ') + theme.assistant(queued))
+      } else {
+        console.log(theme.user('▶ Из очереди: ') + theme.assistant(queued))
+      }
+      transcript?.log('queued_task', { task: queued })
+      next = { task: queued, freshChat: false, sendSystemPrompt: false }
+    }
   } catch (e) {
     ui.stop()
-    console.error(theme.error('\n✖ Ошибка агента:'), e.message)
+    console.error(theme.error(String.fromCharCode(10) + '✖ Ошибка агента:'), e.message)
     if (debug) console.error(e.stack)
     transcript?.log('agent_error', { error: e.message })
   } finally {
     stopWatching()
-    if (!finished) ui.stop()
+    ui.stop()
   }
 }
 
@@ -659,7 +806,12 @@ async function main() {
 
   console.log(
     theme.system(
-      'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.\n',
+      'Интерактивный режим. Введите задачу. Команды — /help. Выход — /exit.',
+    ),
+  )
+  console.log(
+    theme.system(
+      'Пока агент работает, можно печатать следующее сообщение — оно уйдёт в очередь (Enter — отправить, Esc — прервать).',
     ),
   )
 
@@ -669,6 +821,10 @@ async function main() {
   let currentChatId = null
   let running = true
 
+  // Сообщения, набранные пользователем, пока агент работал. runTask
+  // забирает их по одному после завершения текущей задачи.
+  const pendingQueue = []
+
   // ---------- review mode state ----------
   // null — обычный режим.
   // { snapDir, snapName, originalWorkdir } — мы внутри снапшота, чат уже
@@ -709,18 +865,98 @@ async function main() {
     }
   }
 
+  // ---------- ввод: постоянная строка внизу + статус сверху ----------
+  // В TTY используем LineEditor: он владеет вводом всё время, показывает
+  // статус над строкой ввода и печатает ответы агента ВЫШЕ неё, поэтому
+  // набранный текст никогда не затирается выводом. В не-TTY (пайп) —
+  // старый promptOnce.
+  let editor = null
+  let waiter = null
+  const takeInput = () => {
+    if (pendingQueue.length) return Promise.resolve(pendingQueue.shift())
+    return new Promise((resolve) => {
+      waiter = resolve
+    })
+  }
+
+  const buildPrompt = () => {
+    let tail
+    if (reviewMode) {
+      tail = theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+    } else {
+      tail = theme.dir(dirLabel(currentWorkdir))
+    }
+    return theme.prompt('❯ ') + tail + theme.dim(' › ')
+  }
+
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    editor = new LineEditor({ prompt: buildPrompt() })
+    editor.onSubmit = (text) => {
+      pendingQueue.push(text)
+      if (waiter) {
+        const r = waiter
+        waiter = null
+        r(pendingQueue.shift())
+      }
+    }
+    editor.onEscape = () => {
+      if (editor.busy) {
+        editor.printAbove(theme.warn('⏹ Esc — прерываю генерацию...'))
+        browser.stopGeneration().catch(() => {})
+      }
+    }
+    editor.onCtrlC = () => {
+      if (editor.busy) {
+        editor.printAbove(theme.warn('⏹ Ctrl+C — прерываю генерацию...'))
+        browser.stopGeneration().catch(() => {})
+      } else {
+        // Не заняты — выходим. Будим takeInput(), чтобы цикл завершился.
+        running = false
+        if (waiter) {
+          const r = waiter
+          waiter = null
+          r(null)
+        }
+      }
+    }
+    editor.start()
+
+    // Весь вывод команд (console.log/error) должен идти ВЫШЕ строки ввода,
+    // иначе он затирает набираемый текст. Пока редактор активен, заворачиваем
+    // оба потока в editor.printAbove.
+    const origLog = console.log.bind(console)
+    const origErr = console.error.bind(console)
+    const fmt = (a) =>
+      typeof a === 'string' ? a : (() => {
+        try {
+          return JSON.stringify(a)
+        } catch {
+          return String(a)
+        }
+      })()
+    console.log = (...a) => editor.printAbove(a.map(fmt).join(' '))
+    console.error = (...a) => editor.printAbove(a.map(fmt).join(' '))
+    // Сохраняем на случай отладки.
+    editor._origLog = origLog
+    editor._origErr = origErr
+  }
+
   while (running) {
     let input
     try {
-      // Компактное приглашение: золотая стрелка + светло-голубая директория.
-      let tail
-      if (reviewMode) {
-        tail =
-          theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+      if (editor) {
+        editor.setPrompt(buildPrompt())
+        input = await takeInput()
       } else {
-        tail = theme.dir(dirLabel(currentWorkdir))
+        let tail
+        if (reviewMode) {
+          tail =
+            theme.warn('REVIEW') + theme.dim(':') + theme.dir(reviewMode.snapName)
+        } else {
+          tail = theme.dir(dirLabel(currentWorkdir))
+        }
+        input = await promptOnce(theme.prompt('❯ ') + tail + theme.dim(' › '))
       }
-      input = await promptOnce(theme.prompt('❯ ') + tail + theme.dim(' › '))
     } catch {
       break
     }
@@ -852,10 +1088,6 @@ async function main() {
             sendSystemPrompt: false,
             transcript,
             onThinking: () => ui.thinking(),
-            onAssistantThought: (text) => {
-              ui.stop()
-              console.log(theme.system('\n💭 ' + text.slice(0, 1200) + '\n'))
-            },
             onToolCall: (name, toolArgs) => ui.toolCall(name, toolArgs),
             onToolResult: (r) => ui.toolResult(r),
             onAssistantMessage: (m) => {
@@ -943,7 +1175,7 @@ async function main() {
     // ---------- Обычные команды ----------
 
     if (lower === '/chats') {
-      const spin = mod.createSpinner()
+      const spin = editor || mod.createSpinner()
       spin.thinking()
       try {
         lastChats = await browser.listChats(30)
@@ -1195,11 +1427,18 @@ async function main() {
     transcript.log('user_task', { task: trimmed, workdir: currentWorkdir })
 
     const tools = mod.createTools(currentWorkdir, { undo })
-    await runTask(browser, tools, trimmed, currentWorkdir, {
-      transcript,
-      freshChat: freshChatNext,
-      sendSystemPrompt: sendSystemPromptNext,
-    })
+    if (editor) editor.busy = true
+    try {
+      await runTask(browser, tools, trimmed, currentWorkdir, {
+        transcript,
+        freshChat: freshChatNext,
+        sendSystemPrompt: sendSystemPromptNext,
+        queue: pendingQueue,
+        ui: editor || null,
+      })
+    } finally {
+      if (editor) editor.busy = false
+    }
 
     freshChatNext = false
     sendSystemPromptNext = false
@@ -1209,6 +1448,7 @@ async function main() {
     await saveLastChat(currentChatId)
   }
 
+  if (editor) editor.dispose()
   await browser.close().catch(() => {})
   await mod.closeWeb().catch(() => {})
   transcript.close()

package/src/input.js

@@ -0,0 +1,447 @@
+import { theme } from './theme.js'
+import { renderMarkdown } from './markdown.js'
+import { randomThinkingPhrase, stripEllipsis } from './spinner.js'
+
+// Постоянная строка ввода внизу терминала + область статуса/вывода над ней.
+//
+// Зачем свой редактор:
+//   * строка ввода видна ВСЕГДА и не затирается выводом агента;
+//   * спиннер/статус и ответы печатаются ВЫШЕ строки ввода (printAbove);
+//   * перерисовка учитывает перенос по ширине терминала, поэтому нет
+//     дублирования строк при многострочном вводе;
+//   * многострочный ввод: Enter отправляет, Ctrl+J (и Shift+Enter в
+//     терминалах с расширенным протоколом) вставляют перевод строки.
+//
+// Все управляющие символы собираются из кодов, чтобы в файле не было
+// «сырых» ESC/CR/LF в строковых литералах (см. AGENTS.md).
+
+const NL = String.fromCharCode(10)
+const CR = String.fromCharCode(13)
+const ESC = String.fromCharCode(27)
+const PASTE_START = ESC + '[200~'
+const PASTE_END = ESC + '[201~'
+
+const DOTS = ['.', '..', '...']
+const HINT = theme.dim('  ·  Enter — отправить, Ctrl+J — новая строка, Esc — стоп')
+
+function safeJson(v) {
+  try {
+    return JSON.stringify(v)
+  } catch {
+    return String(v)
+  }
+}
+
+// Видимая длина строки без ANSI-последовательностей.
+export function visLen(s) {
+  s = String(s)
+  let n = 0
+  let i = 0
+  while (i < s.length) {
+    if (s.charCodeAt(i) === 27) {
+      i++
+      if (s[i] === '[') {
+        i++
+        while (i < s.length && !/[A-Za-z]/.test(s[i])) i++
+        i++
+      }
+      continue
+    }
+    n++
+    i++
+  }
+  return n
+}
+
+// Раскладка ввода на визуальные строки с учётом ширины терминала.
+// Возвращает строки (с префиксом) и позицию курсора в визуальных координатах.
+export function layoutInput(promptStr, buf, cursor, cols) {
+  const width = Math.max(20, Number(cols) || 80)
+  const promptW = visLen(promptStr)
+  const pad = ' '.repeat(promptW)
+  const chars = Array.from(String(buf))
+  const cur = Math.max(0, Math.min(Number(cursor) || 0, chars.length))
+  const rows = []
+  let i = 0
+  while (true) {
+    const first = rows.length === 0
+    const prefix = first ? promptStr : pad
+    const avail = Math.max(1, width - promptW)
+    let text = ''
+    let count = 0
+    const start = i
+    while (i < chars.length && chars[i] !== NL && count < avail) {
+      text += chars[i]
+      i++
+      count++
+    }
+    if (i < chars.length && chars[i] === NL) {
+      i++
+      rows.push({ prefix, text, start })
+      continue
+    }
+    rows.push({ prefix, text, start })
+    if (i >= chars.length) break
+  }
+
+  let cursorRow = 0
+  let cursorCol = promptW
+  for (let r = 0; r < rows.length; r++) {
+    const row = rows[r]
+    const len = Array.from(row.text).length
+    const from = row.start
+    const to = row.start + len
+    if (cur >= from && cur <= to) {
+      const next = rows[r + 1]
+      if (cur === to && next && next.start === to) continue
+      cursorRow = r
+      cursorCol = promptW + (cur - from)
+      break
+    }
+  }
+  return { rows, cursorRow, cursorCol }
+}
+
+export class LineEditor {
+  constructor({ prompt = '> ' } = {}) {
+    this.promptStr = prompt
+    this.buf = ''
+    this.cursor = 0
+    this.statusText = ''
+    this.pendingText = null
+    this.rendered = false
+    this.cursorRowFromTop = 0
+    this.busy = false
+    this.onSubmit = null
+    this.onEscape = null
+    this.onCtrlC = null
+    this._inPaste = false
+    this._dotTimer = null
+    this._dotPhase = 0
+    this._thinkBase = ''
+    this._wasRaw = false
+    this._onData = (b) => this._handle(b)
+  }
+
+  start() {
+    const stdin = process.stdin
+    if (!stdin.isTTY || !stdin.setRawMode) return false
+    this._wasRaw = stdin.isRaw
+    stdin.setRawMode(true)
+    stdin.resume()
+    process.stdout.write(ESC + '[?2004h')
+    stdin.on('data', this._onData)
+    this._writeBlock()
+    return true
+  }
+
+  dispose() {
+    const stdin = process.stdin
+    stdin.removeListener('data', this._onData)
+    process.stdout.write(ESC + '[?2004l')
+    this._stopDots()
+    if (this.rendered) this._eraseBlock()
+    if (stdin.setRawMode) stdin.setRawMode(this._wasRaw || false)
+  }
+
+  setPrompt(str) {
+    this.promptStr = str
+    this._render()
+  }
+
+  clear() {
+    this.buf = ''
+    this.cursor = 0
+    this._render()
+  }
+
+  // ---------- отрисовка ----------
+
+  _eraseBlock() {
+    if (!this.rendered) return
+    if (this.cursorRowFromTop > 0) {
+      process.stdout.write(ESC + '[' + this.cursorRowFromTop + 'A')
+    }
+    process.stdout.write(CR + ESC + '[J')
+    this.rendered = false
+  }
+
+  _writeBlock() {
+    const cols = process.stdout.columns || 80
+    let out = ''
+    let top = 0
+    if (this.statusText) {
+      out += this.statusText + NL
+      top = 1
+    }
+    const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols)
+    out += lay.rows.map((r) => r.prefix + r.text).join(NL)
+    process.stdout.write(out)
+    const lastRow = lay.rows.length - 1
+    const up = lastRow - lay.cursorRow
+    if (up > 0) process.stdout.write(ESC + '[' + up + 'A')
+    process.stdout.write(CR)
+    if (lay.cursorCol > 0) process.stdout.write(ESC + '[' + lay.cursorCol + 'C')
+    this.rendered = true
+    this.cursorRowFromTop = top + lay.cursorRow
+  }
+
+  _render() {
+    this._eraseBlock()
+    this._writeBlock()
+  }
+
+  // Напечатать блок ВЫШЕ строки ввода и вернуть строку ввода на место.
+  printAbove(text) {
+    this._eraseBlock()
+    process.stdout.write(String(text) + NL)
+    this._writeBlock()
+  }
+
+  // ---------- интерфейс, совместимый со спиннером ----------
+
+  setStatus(text) {
+    this.statusText = text || ''
+    this._render()
+  }
+
+  _stopDots() {
+    if (this._dotTimer) {
+      clearInterval(this._dotTimer)
+      this._dotTimer = null
+    }
+  }
+
+  _startThinking() {
+    if (this.pendingText) {
+      this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT)
+      return
+    }
+    this._thinkBase = theme.brown(stripEllipsis(randomThinkingPhrase()))
+    this._dotPhase = 0
+    this.setStatus(this._thinkBase + DOTS[0] + HINT)
+    this._stopDots()
+    this._dotTimer = setInterval(() => {
+      this._dotPhase = (this._dotPhase + 1) % DOTS.length
+      this.setStatus(this._thinkBase + DOTS[this._dotPhase] + HINT)
+    }, 400)
+    if (this._dotTimer.unref) this._dotTimer.unref()
+  }
+
+  thinking() {
+    this._startThinking()
+  }
+
+  setPending(text) {
+    this.pendingText = text && String(text).length ? String(text) : null
+    if (this.pendingText) {
+      this._stopDots()
+      this.setStatus(theme.prompt('✎ ') + this.pendingText + HINT)
+    } else {
+      this._startThinking()
+    }
+  }
+
+  stop() {
+    this._stopDots()
+    this.setStatus('')
+  }
+
+  toolCall(name, args) {
+    const preview = safeJson(args).slice(0, 120)
+    this.printAbove(theme.tool('🔧 ' + name) + ' ' + theme.dim(preview))
+  }
+
+  toolResult(result) {
+    const text = typeof result === 'string' ? result : safeJson(result)
+    const preview = text.slice(0, 200).split(NL).join(' ↵ ')
+    this.printAbove(theme.toolResult('   → ' + preview))
+  }
+
+  assistant(msg) {
+    this.stop()
+    const rendered = renderMarkdown(msg)
+    this.printAbove(
+      NL + theme.assistant('● Ответ') + NL + rendered + NL + theme.dim('─'.repeat(60)),
+    )
+  }
+
+  // ---------- ввод ----------
+
+  _submit() {
+    const text = this.buf
+    if (!text.trim()) {
+      this._render()
+      return
+    }
+    this.buf = ''
+    this.cursor = 0
+    this.pendingText = null
+    this._stopDots()
+    this.statusText = ''
+    this.printAbove(theme.user('❯ ') + text)
+    if (this.onSubmit) this.onSubmit(text)
+  }
+
+  _insert(text) {
+    const chars = Array.from(this.buf)
+    const ins = Array.from(String(text))
+    const next = chars.slice(0, this.cursor).concat(ins, chars.slice(this.cursor))
+    this.buf = next.join('')
+    this.cursor += ins.length
+  }
+
+  _backspace() {
+    if (this.cursor <= 0) return
+    const chars = Array.from(this.buf)
+    chars.splice(this.cursor - 1, 1)
+    this.buf = chars.join('')
+    this.cursor--
+  }
+
+  _delete() {
+    const chars = Array.from(this.buf)
+    if (this.cursor >= chars.length) return
+    chars.splice(this.cursor, 1)
+    this.buf = chars.join('')
+  }
+
+  _left() {
+    if (this.cursor > 0) this.cursor--
+  }
+
+  _right() {
+    if (this.cursor < Array.from(this.buf).length) this.cursor++
+  }
+
+  _home() {
+    const chars = Array.from(this.buf)
+    let i = this.cursor
+    while (i > 0 && chars[i - 1] !== NL) i--
+    this.cursor = i
+  }
+
+  _end() {
+    const chars = Array.from(this.buf)
+    let i = this.cursor
+    while (i < chars.length && chars[i] !== NL) i++
+    this.cursor = i
+  }
+
+  _up() {
+    const chars = Array.from(this.buf)
+    let start = this.cursor
+    while (start > 0 && chars[start - 1] !== NL) start--
+    if (start === 0) return
+    const col = this.cursor - start
+    const prevEnd = start - 1
+    let prevStart = prevEnd
+    while (prevStart > 0 && chars[prevStart - 1] !== NL) prevStart--
+    this.cursor = prevStart + Math.min(col, prevEnd - prevStart)
+  }
+
+  _down() {
+    const chars = Array.from(this.buf)
+    let end = this.cursor
+    while (end < chars.length && chars[end] !== NL) end++
+    if (end >= chars.length) return
+    let lineStart = this.cursor
+    while (lineStart > 0 && chars[lineStart - 1] !== NL) lineStart--
+    const col = this.cursor - lineStart
+    const nextStart = end + 1
+    let nextEnd = nextStart
+    while (nextEnd < chars.length && chars[nextEnd] !== NL) nextEnd++
+    this.cursor = nextStart + Math.min(col, nextEnd - nextStart)
+  }
+
+  _handle(data) {
+    let s = data.toString('utf-8')
+
+    if (!this._inPaste && s === ESC) {
+      if (this.onEscape) this.onEscape()
+      return
+    }
+
+    while (s.length) {
+      if (this._inPaste) {
+        const end = s.indexOf(PASTE_END)
+        if (end === -1) {
+          this._insert(s)
+          s = ''
+        } else {
+          this._insert(s.slice(0, end))
+          s = s.slice(end + PASTE_END.length)
+          this._inPaste = false
+        }
+        this._render()
+        continue
+      }
+
+      const pasteAt = s.indexOf(PASTE_START)
+      if (pasteAt !== -1) {
+        const before = s.slice(0, pasteAt)
+        s = s.slice(pasteAt + PASTE_START.length)
+        this._inPaste = true
+        if (before) {
+          this._insert(before)
+          this._render()
+        }
+        continue
+      }
+
+      // Shift+Enter в терминалах с расширенным протоколом и Alt+Enter.
+      if (s.startsWith(ESC + '[13;2u')) { this._insert(NL); s = s.slice(7); this._render(); continue }
+      if (s.startsWith(ESC + '[27;2;13~')) { this._insert(NL); s = s.slice(10); this._render(); continue }
+      if (s.startsWith(ESC + NL)) { this._insert(NL); s = s.slice(2); this._render(); continue }
+
+      const ch = s[0]
+      const code = s.charCodeAt(0)
+      s = s.slice(1)
+
+      if (ch === CR) { this._submit(); continue }
+      if (code === 10) { this._insert(NL); this._render(); continue }
+      if (code === 3) { if (this.onCtrlC) this.onCtrlC(); continue }
+      if (code === 4) { if (!this.buf && this.onCtrlC) this.onCtrlC(); continue }
+      if (code === 1) { this._home(); this._render(); continue }
+      if (code === 5) { this._end(); this._render(); continue }
+      if (code === 21) { this.buf = ''; this.cursor = 0; this._render(); continue }
+      if (code === 127 || code === 8) { this._backspace(); this._render(); continue }
+
+      if (code === 27) {
+        if (s.startsWith('[D')) { this._left(); s = s.slice(2); this._render(); continue }
+        if (s.startsWith('[C')) { this._right(); s = s.slice(2); this._render(); continue }
+        if (s.startsWith('[A')) { this._up(); s = s.slice(2); this._render(); continue }
+        if (s.startsWith('[B')) { this._down(); s = s.slice(2); this._render(); continue }
+        if (s.startsWith('[H') || s.startsWith('[1~')) { this._home(); s = s.slice(s.startsWith('[1~') ? 3 : 2); this._render(); continue }
+        if (s.startsWith('[F') || s.startsWith('[4~')) { this._end(); s = s.slice(s.startsWith('[4~') ? 3 : 2); this._render(); continue }
+        if (s.startsWith('[3~')) { this._delete(); s = s.slice(3); this._render(); continue }
+        let j = 0
+        while (j < s.length && !/[A-Za-z~]/.test(s[j])) j++
+        s = s.slice(j + 1)
+        continue
+      }
+
+      if (code < 32) continue
+      this._insert(ch)
+      this._render()
+    }
+  }
+}
+
+// Проверка раскладки: node src/input.js --selftest
+export function selftest() {
+  const cases = [
+    { p: '> ', b: 'hello', c: 5, w: 80 },
+    { p: '> ', b: 'a' + NL + 'b', c: 3, w: 80 },
+    { p: '> ', b: 'x'.repeat(200), c: 200, w: 40 },
+    { p: '> ', b: '', c: 0, w: 40 },
+  ]
+  for (const t of cases) {
+    const r = layoutInput(t.p, t.b, t.c, t.w)
+    console.log(JSON.stringify({ rows: r.rows.length, row: r.cursorRow, col: r.cursorCol }))
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith('input.js') && process.argv.includes('--selftest')) {
+  selftest()
+}

package/src/spinner.js

@@ -36,12 +36,22 @@ const THINKING_PHRASES = [
   'Замешиваю кал из всего подряд…',
 ]
 
-function randomThinkingPhrase() {
+export function randomThinkingPhrase() {
   return THINKING_PHRASES[Math.floor(Math.random() * THINKING_PHRASES.length)]
 }
 
+// Убираем завершающее многоточие из фразы — точки анимируем отдельно.
+export function stripEllipsis(phrase) {
+  return phrase.replace(/[.…]+\s*$/, '')
+}
+
 export function createSpinner() {
   let spinner = null
+  let dotTimer = null
+  let dotPhase = 0
+  let pending = null
+
+  const DOTS = ['.', '..', '...']
 
   const start = (text) => {
     if (!spinner) spinner = ora(text).start()
@@ -49,11 +59,59 @@ export function createSpinner() {
   }
 
   const stop = () => {
+    if (dotTimer) {
+      clearInterval(dotTimer)
+      dotTimer = null
+    }
     if (spinner) spinner.stop()
   }
 
+  // Подсказка в строке статуса: во время работы агента терминал живой,
+  // можно печатать следующее сообщение. Без неё это неочевидно.
+  const HINT = theme.dim('  ·  печатай — Enter в очередь, Esc стоп')
+
+  // Запуск анимированного статуса: коричневый текст + «бегущие» точки.
+  const startThinking = () => {
+    const base = theme.brown(stripEllipsis(randomThinkingPhrase()))
+    start(base + DOTS[0] + HINT)
+    dotPhase = 0
+    if (dotTimer) clearInterval(dotTimer)
+    dotTimer = setInterval(() => {
+      if (!spinner) return
+      dotPhase = (dotPhase + 1) % DOTS.length
+      spinner.text = base + DOTS[dotPhase] + HINT
+    }, 400)
+    if (dotTimer.unref) dotTimer.unref()
+  }
+
+  // Показать набранный, но ещё не отправленный текст вместо спиннера.
+  // Позволяет печатать сообщение прямо во время работы агента.
+  const showPending = () => {
+    if (dotTimer) {
+      clearInterval(dotTimer)
+      dotTimer = null
+    }
+    if (!spinner) spinner = ora('')
+    spinner.start()
+    spinner.text = theme.prompt('✎ ') + pending + HINT
+  }
+
   return {
-    thinking: () => start(theme.system(randomThinkingPhrase())),
+    thinking: () => {
+      if (pending) {
+        showPending()
+        return
+      }
+      startThinking()
+    },
+
+    // Текст, который пользователь набирает во время работы агента.
+    // Пустая строка / null — вернуть обычный спиннер.
+    setPending: (text) => {
+      pending = text && String(text).length ? String(text) : null
+      if (pending) showPending()
+      else startThinking()
+    },
 
     toolCall: (name, args) => {
       stop()

package/src/system-prompt.js

@@ -14,6 +14,34 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null }) {
 
 You work in the directory: ${workdir}
 
+## SILENT OPERATION (most important rule)
+
+Work silently. While you are still solving the task you must output ONLY
+tool calls — nothing else. Do NOT narrate what you are about to do, do NOT
+summarize what you just did, do NOT think out loud, do NOT print progress
+like "Now I will read the file...". Every extra sentence pollutes the chat
+and the context, so keep it to zero.
+
+The operator does NOT read free text in the chat. Anything written outside a
+tool call is lost: the operator only sees tool calls and their results. In
+particular, the operator reads EXACTLY ONE thing from you — the message of the
+LAST respond tool call before you stop. Everything else is ignored.
+
+Therefore the only way to talk to the operator is the respond tool, and it
+must be your LAST action. Call respond in exactly two situations:
+  1. The task is done — report the result.
+  2. You cannot continue and must ask the operator a question or a decision.
+
+Never call respond in the middle, and never split a report across several
+messages: put the complete operator-facing text into that single final
+respond. Do NOT end a turn with plain text, and do NOT rely on plain text to
+ask or answer anything — if you have something to say, say it via respond and
+stop. If you are still working, emit a tool call instead.
+
+So the pattern is: tool call, tool call, tool call, ..., then a single final
+respond. A bare text message without a tool call ends the task and the
+operator will not read it, so never use plain text.\n\nNO PROSE AROUND TOOL CALLS. Each turn must contain ONLY the JSON of the tool\ncall(s) — not a single word before or after, not even a short lead-in like\n"Let me check..." or "Now I'll fix it.". The JSON must be the entire response.\n\nWRONG: "Let me read the file first." then a Read call.\nWRONG: a Read call then "I'll analyze the result next."\nRIGHT: only the JSON of the tool call, nothing else.\n\nIf you feel the urge to explain, do not: put it in the final respond when the\ntask is done (or when you must ask the operator), not between tool calls.
+
 You have access to the following tools:
 
 ${toolDescriptions}
@@ -28,7 +56,9 @@ To call MULTIPLE tools at once (only if they are independent — e.g. reading se
 
 [{"tool": "Read", "args": {"path": "a.js"}}, {"tool": "Read", "args": {"path": "b.js"}}]
 
-After the tool result(s) come back, decide the next action.
+After the tool result(s) come back, decide the next action and immediately
+emit the next tool call as bare JSON. Do NOT write a sentence about what
+you learned or what you will do next — no commentary between tool calls.
 
 To give a final answer to the user, respond with:
 
@@ -68,9 +98,9 @@ Inside that string:
 - Do NOT write any text before or after the JSON. No explanations, no greetings, no plans.
 - Do NOT wrap JSON in markdown fences.
 - Do NOT use XML-like tags such as tool_calls, invoke, parameter, or their DSML variants.
-- If you want to tell the user something, call the respond tool with a message.
-- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use 
- for newlines.
+- The ONLY way to reach the operator is the respond tool, as your LAST action.
+  Any other text is not read by the operator.
+- If JSON parsing fails, the tool call will NOT run and the user will see raw text. Keep JSON valid: escape every double quote inside strings, escape backslashes, use \n for newlines.
 
 ## Rules
 
@@ -82,7 +112,11 @@ Inside that string:
 - Never output anything except JSON when you want to call a tool.
 - Your ENTIRE response must be exactly one JSON object (or array of objects).
 
-REMINDER: respond with exactly one JSON object or array. No text, no markdown, no explanations.
+REMINDER: every intermediate response is exactly one JSON object or array —
+no text, no markdown, no explanations, no progress narration. Keep working
+with tool calls only. Talk to the operator with a single final respond call:
+when the task is done, or when you are blocked and must ask the operator.
+Anything you write outside that one respond is not read by the operator.
 ## Web access
 
 - You have WebSearch and WebFetch. Use them when the answer requires current information (versions, changelogs, recent bugs, docs).

package/src/theme.js

@@ -28,6 +28,7 @@ export const theme = {
   warn: chalk.hex('#c9a86a'), // спокойный охра
   error: chalk.hex('#c98a80'), // приглушённый терракот
   success: chalk.hex('#a9c08c'), // мягкий шалфейный
+  brown: chalk.hex('#a1723f'), // коричневый (статус/спиннер)
   bold: chalk.bold,
 }
 

package/src/xml-toolcall.js

@@ -0,0 +1,69 @@
+function unescapeXml(s) {
+  const A = String.fromCharCode(38) // ampersand
+  return String(s)
+    .split(A + "lt;").join(String.fromCharCode(60))
+    .split(A + "gt;").join(String.fromCharCode(62))
+    .split(A + "quot;").join(String.fromCharCode(34))
+    .split(A + "apos;").join(String.fromCharCode(39))
+    .split(A + "amp;").join(A)
+}
+
+function readAttr(attrs, name) {
+  const Q = String.fromCharCode(34)
+  const re = new RegExp(name + "[ ]*=[ ]*([" + Q + "]([^" + Q + "]*)[" + Q + "])")
+  const m = attrs.match(re)
+  return m ? m[2] : null
+}
+
+export function parseXmlToolCalls(text) {
+  if (!text || typeof text !== "string") return null
+  if (!/<[^>]*invoke/i.test(text)) return null
+
+  const invokeRe = /<[^>]*?invoke([^>]*)>/gi
+  const calls = []
+  let m
+  while ((m = invokeRe.exec(text)) !== null) {
+    const attrs = m[1] || ""
+    const name = readAttr(attrs, "name")
+    if (!name) continue
+
+    const rest = text.slice(invokeRe.lastIndex)
+    const closeRe = /<\/[^>]*?invoke[^>]*>/i
+    const closeMatch = closeRe.exec(rest)
+    const body = closeMatch ? rest.slice(0, closeMatch.index) : rest
+
+    const args = {}
+    const paramRe = /<[^>]*?parameter([^>]*)>([\s\S]*?)<\/[^>]*?parameter[^>]*>/gi
+    let p
+    while ((p = paramRe.exec(body)) !== null) {
+      const pname = readAttr(p[1] || "", "name")
+      if (!pname) continue
+      const isString = /string[ ]*=[ ]*"?true"?/i.test(p[1] || "")
+      let value = unescapeXml(p[2])
+      if (!isString) {
+        try { value = JSON.parse(value) } catch (e) {}
+      }
+      args[pname] = value
+    }
+
+    // Некоторые модели кладут весь JSON-объект аргументов в один
+    // parameter с именем args. Разворачиваем, чтобы не было
+    // {args: {args: {...}}}.
+    let finalArgs = args
+    const keys = Object.keys(args)
+    if (
+      keys.length === 1 &&
+      keys[0] === 'args' &&
+      args.args &&
+      typeof args.args === 'object' &&
+      !Array.isArray(args.args)
+    ) {
+      finalArgs = args.args
+    }
+
+    calls.push({ tool: name, args: finalArgs })
+  }
+
+  if (!calls.length) return null
+  return calls.length === 1 ? calls[0] : calls
+}