kingkont 0.13.1 → 0.14.1

package/index.html

@@ -130,7 +130,7 @@
     </div>
     <button id="charSettingsBtn" style="display:none;" title="Настройки персонажа">⚙</button>
     <button id="timelineBtn" title="Показать/скрыть таймлайн">🎬 Таймлайн</button>
-    <button id="chatBtn" title="Чат с Claude (Cmd+J)" onclick="window.kingChat?.toggle?.()">💬 Чат</button>
+    <button id="chatBtn" title="Открыть/скрыть чат с KingKont (⌘J / Ctrl+J)" onclick="window.kingChat?.toggle?.()">💬 Чат <span style="opacity:0.6; font-size:10px;">⌘J</span></button>
     <!-- скрытые, но используемые элементы (logic ссылается по id) -->
     <span id="hint" class="path" style="display:none;"></span>
     <span id="boardBadge" class="badge" style="display:none;"></span>

package/lib/chatSession.js

@@ -0,0 +1,310 @@
+// lib/chatSession.js — Server-side chat sessions для KingKont.
+//
+// Каждая сессия привязана к проекту (sessionKey = projectKey клиента,
+// например "cloud:abc123" или "folder:Сериал-вживую"). Хранит:
+//   - history: [{role, content, tools?}]
+//   - busy:    true пока крутится LLM-loop
+//   - pendingToolCalls: [{name, args, id}] — то что Claude хочет запустить;
+//                        клиент исполняет → posts results → loop продолжается
+//   - lastError: строка ошибки если loop упал
+//
+// Lifecycle:
+//   1. Клиент: POST /api/chat/send {sessionKey, text, system, context}
+//      → серверный send() пушит user-msg, стартует LLM-loop в фоне.
+//   2. Loop ждёт ответ от LLM. Парсит <tool>JSON</tool> блоки.
+//      Если есть → выставляет pendingToolCalls + ставит ожидание results.
+//   3. Клиент поллит GET /api/chat/state?sessionKey=...
+//      Видит pendingToolCalls → исполняет локально (с FSAH доступом!) →
+//      POST /api/chat/tool-results {sessionKey, results}.
+//   4. Loop резюмирует с tool-results, идёт следующая итерация.
+//   5. Когда нет tools → loop останавливается, busy=false.
+//
+// Persistence: на каждое изменение пишем в `<userDataDir>/chats/<key>.json`
+// (debounced). Загружается на первый запрос session'а. Это позволяет
+// чату пережить рестарт Electron.
+//
+// Tools НЕ исполняются на сервере — только пробрасываются клиенту.
+// Это потому что тулы работают с FSAH-handle'ами проекта (renderer-only).
+
+'use strict';
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const MAX_TOOL_ITERATIONS = 12;
+const PERSIST_DEBOUNCE_MS = 800;
+
+// ============== STORAGE ==============
+let _userDataDir = null;   // выставляется через init() из main.js
+function init({ userDataDir }) {
+  _userDataDir = userDataDir;
+  if (_userDataDir) {
+    const dir = path.join(_userDataDir, 'chats');
+    try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  }
+}
+function _sessionFilePath(key) {
+  if (!_userDataDir) return null;
+  // sessionKey может содержать /, : и т.п. — encode через URI.
+  const safe = encodeURIComponent(key);
+  return path.join(_userDataDir, 'chats', safe + '.json');
+}
+async function _persist(session) {
+  if (!_userDataDir) return;
+  const p = _sessionFilePath(session.key);
+  if (!p) return;
+  // Не сохраняем pending state — на restart loop стартанётся заново
+  // (или останется незавершённым — клиент увидит busy=false и предложит
+  //  повторить).
+  const persistable = {
+    key: session.key,
+    history: session.history.filter(m =>
+      m.role !== 'system' &&
+      !(m.role === 'user' && typeof m.content === 'string' && m.content.startsWith('<tool_result>')),
+    ),
+    savedAt: Date.now(),
+  };
+  try {
+    await fsp.writeFile(p, JSON.stringify(persistable, null, 2), 'utf-8');
+  } catch (e) {
+    console.warn('[chatSession] persist failed for', session.key, e?.message);
+  }
+}
+async function _load(key) {
+  if (!_userDataDir) return null;
+  const p = _sessionFilePath(key);
+  if (!p) return null;
+  try {
+    const text = await fsp.readFile(p, 'utf-8');
+    return JSON.parse(text);
+  } catch { return null; }
+}
+
+// ============== SESSIONS ==============
+const SESSIONS = new Map();   // key → Session
+
+function _emptySession(key) {
+  return {
+    key,
+    history: [],          // [{role, content, tools?}]
+    busy: false,
+    pendingToolCalls: null,    // null | [{id, name, args}]
+    pendingResolve: null,      // function(results) — used by loop awaiting
+    lastError: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    _persistTimer: null,
+  };
+}
+
+async function getSession(key, { create = true } = {}) {
+  let s = SESSIONS.get(key);
+  if (s) return s;
+  // Try load from disk.
+  const saved = await _load(key);
+  if (saved) {
+    s = _emptySession(key);
+    s.history = Array.isArray(saved.history) ? saved.history : [];
+    SESSIONS.set(key, s);
+    return s;
+  }
+  if (!create) return null;
+  s = _emptySession(key);
+  SESSIONS.set(key, s);
+  return s;
+}
+
+function schedulePersist(session) {
+  clearTimeout(session._persistTimer);
+  session._persistTimer = setTimeout(() => _persist(session), PERSIST_DEBOUNCE_MS);
+}
+
+// ============== TOOL-CALL PARSER ==============
+function parseToolCalls(text) {
+  if (typeof text !== 'string' || !text) return [];
+  const out = [];
+  const re = /<tool>\s*([\s\S]*?)\s*<\/tool>/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    try {
+      const obj = JSON.parse(m[1]);
+      if (obj && typeof obj.name === 'string') {
+        out.push({ id: crypto.randomUUID(), name: obj.name, args: obj.args || {} });
+      }
+    } catch (e) {
+      out.push({ id: crypto.randomUUID(), _parseError: e.message, raw: m[1] });
+    }
+  }
+  return out;
+}
+function stripToolCalls(text) {
+  if (typeof text !== 'string') return '';
+  return text
+    .replace(/<tool>[\s\S]*?<\/tool>/g, '')
+    .replace(/<tool_result>[\s\S]*?<\/tool_result>/g, '')
+    .replace(/[ \t]{2,}/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+// ============== LLM CALL ==============
+// Использует ту же providers.generateText (single-prompt с transcript), что и
+// клиентский код раньше. Передаём messages как готовый transcript-prompt.
+function _historyToPrompt(history) {
+  const lines = [];
+  for (const m of history) {
+    if (m.role === 'system') continue;
+    const role = m.role === 'assistant' ? 'ASSISTANT' : m.role === 'user' ? 'USER' : m.role.toUpperCase();
+    const content = typeof m.content === 'string' ? m.content : '';
+    lines.push(`${role}: ${content}`);
+  }
+  lines.push('ASSISTANT:');
+  return lines.join('\n\n');
+}
+
+async function _callLLM(history, system, settings) {
+  const providers = require('./providers');
+  const prompt = _historyToPrompt(history);
+  const r = await providers.generateText({
+    prompt, system,
+    model: 'anthropic/claude-sonnet-4.6',
+    settings,
+  });
+  return r.text || '';
+}
+
+// ============== LOOP ==============
+// Запускается в фоне после send() / submitToolResults(). Делает один-два
+// (или больше) round-trips к LLM, между ними ждёт tool-results от клиента.
+async function _runLoop(session, system, settingsGetter) {
+  if (session.busy) return;     // уже идёт
+  session.busy = true;
+  session.lastError = null;
+  schedulePersist(session);
+  let iter = 0;
+  try {
+    while (iter < MAX_TOOL_ITERATIONS) {
+      iter++;
+      const text = await _callLLM(session.history, system, settingsGetter());
+      const toolCalls = parseToolCalls(text);
+      const cleanText = stripToolCalls(text);
+      const assistantMsg = { role: 'assistant', content: cleanText, tools: [] };
+      session.history.push(assistantMsg);
+      schedulePersist(session);
+      if (!toolCalls.length) break;     // финальный ответ
+      // Выставляем pendingToolCalls и ЖДЁМ что клиент пришлёт results.
+      // _waitForToolResults возвращает массив {id, ok, result, error}.
+      const results = await _waitForToolResults(session, toolCalls);
+      // Записываем info про tool-вызовы в assistantMsg для UI.
+      for (let i = 0; i < toolCalls.length; i++) {
+        const tc = toolCalls[i];
+        const r = results.find(x => x.id === tc.id) || {};
+        assistantMsg.tools.push({
+          name: tc.name, args: tc.args,
+          _ok: !!r.ok, _error: r.error || tc._parseError, result: r.result,
+        });
+      }
+      schedulePersist(session);
+      // Шлём результаты в LLM как user-msg (Claude видит их в transcript).
+      const resultsMsg = results.map(r => `<tool_result>${JSON.stringify({
+        name: r.name, ok: !!r.ok, result: r.result, error: r.error,
+      })}</tool_result>`).join('\n');
+      session.history.push({ role: 'user', content: resultsMsg });
+    }
+    if (iter >= MAX_TOOL_ITERATIONS) {
+      session.history.push({ role: 'assistant', content: `⚠ Остановлен после ${MAX_TOOL_ITERATIONS} итераций.`, tools: [] });
+    }
+  } catch (e) {
+    console.error('[chatSession] loop error:', e?.stack || e?.message || e);
+    session.lastError = e?.message || String(e);
+    session.history.push({ role: 'assistant', content: `⚠ Ошибка: ${session.lastError}`, tools: [] });
+  } finally {
+    session.busy = false;
+    session.pendingToolCalls = null;
+    session.pendingResolve = null;
+    schedulePersist(session);
+  }
+}
+
+function _waitForToolResults(session, toolCalls) {
+  // Выставляем pending — клиент через GET state увидит, исполнит локально,
+  // вызовет submitToolResults. Тот резолвит promise.
+  return new Promise(resolve => {
+    session.pendingToolCalls = toolCalls;
+    session.pendingResolve = resolve;
+  });
+}
+
+// ============== PUBLIC API ==============
+
+// Снимок состояния для клиента (без internal-полей).
+function snapshot(session) {
+  return {
+    key: session.key,
+    history: session.history,
+    busy: session.busy,
+    pendingToolCalls: session.pendingToolCalls,
+    lastError: session.lastError,
+    updatedAt: session.updatedAt,
+  };
+}
+
+// Push user-msg + start loop. Если loop уже бежит — отказ.
+async function send(key, { text, system, settingsGetter }) {
+  if (!text) throw new Error('text обязателен');
+  const session = await getSession(key);
+  if (session.busy) throw new Error('сессия занята — дождитесь окончания текущего turn');
+  session.history.push({ role: 'user', content: text });
+  session.updatedAt = Date.now();
+  schedulePersist(session);
+  // Запускаем loop в фоне (не await'им).
+  _runLoop(session, system, settingsGetter).catch(e => {
+    console.error('[chatSession] _runLoop unhandled:', e);
+  });
+  return snapshot(session);
+}
+
+// Клиент исполнил pendingToolCalls и шлёт results. Резолвим promise →
+// loop продолжается.
+function submitToolResults(key, results) {
+  const session = SESSIONS.get(key);
+  if (!session) throw new Error('сессия не найдена');
+  if (!session.pendingResolve) throw new Error('нет ожидающих tool-вызовов');
+  const resolve = session.pendingResolve;
+  session.pendingResolve = null;
+  session.pendingToolCalls = null;
+  // Привязываем results к pending-toolCall id'ам — клиент должен прислать
+  // тот же id что мы дали в pendingToolCalls.
+  resolve(results || []);
+  return snapshot(session);
+}
+
+async function clear(key) {
+  const session = SESSIONS.get(key);
+  if (session) {
+    session.history = [];
+    session.lastError = null;
+    schedulePersist(session);
+    return snapshot(session);
+  }
+  // Нет в памяти — создадим пустую и сохраним.
+  const fresh = await getSession(key);
+  fresh.history = [];
+  schedulePersist(fresh);
+  return snapshot(fresh);
+}
+
+async function getState(key) {
+  const session = await getSession(key);
+  return snapshot(session);
+}
+
+module.exports = {
+  init,
+  getState,
+  send,
+  submitToolResults,
+  clear,
+};

package/main.js

@@ -974,7 +974,10 @@ app.whenReady().then(async () => {
   // падаем на random и теряем handle. 8×500мс = 4 сек обычно хватает.
   // server.js на каждый запрос читает live-настройки через getSettings —
   // settings.json на диске единственный источник правды.
-  const startOpts = { getSettings: () => readSettings() };
+  const startOpts = {
+    getSettings: () => readSettings(),
+    userDataDir: app.getPath('userData'),
+  };
   const PRIMARY_PORT = 17893;
   const RETRIES = 8;
   let lastErr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kingkont",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "KingKont · Chatium — нод-редактор сцен с AI-генерацией (картинки/видео/голос/SFX/музыка/текст)",
   "main": "main.js",
   "bin": {
@@ -19,7 +19,8 @@
     "scripts/**/*",
     "skill/**/*",
     "README.md",
-    "updates.html"
+    "updates.html",
+    "web.html"
   ],
   "engines": {
     "node": ">=18"

package/renderer/chat.js

@@ -99,19 +99,49 @@
     },
 
     add_node: {
-      description: 'Добавить ноду на текущую доску. Для image/video/audio promptа можно задать prompt — нода будет в draft-состоянии (юзер запустит generation отдельно или используй generate_node).',
-      params: '{"type":"image|video|audio|text","name":"<optional>","prompt":"<optional>","x":<optional>,"y":<optional>,"text":"<for-type=text>","modelKey":"<optional>"}',
-      async handler({ type, name, prompt, x, y, text, modelKey }) {
+      description: 'Добавить ноду на текущую доску. Для image/video/audio promptа можно задать prompt — нода будет в draft-состоянии (юзер запустит generation отдельно или используй generate_node). Для audio укажи subKind="music"|"sfx"|"voice" — иначе по умолчанию voice (TTS).',
+      params: '{"type":"image|video|audio|text","subKind":"music|sfx|voice (only for audio)","name":"<optional>","prompt":"<optional>","x":<optional>,"y":<optional>,"text":"<for-type=text>","modelKey":"<optional>","durationMs":<for-music-or-sfx>}',
+      async handler({ type, subKind, name, prompt, x, y, text, modelKey, durationMs }) {
         if (!state.currentBoard) throw new Error('доска не выбрана');
         if (!['image','video','audio','text','label'].includes(type)) throw new Error(`unknown type: ${type}`);
-        // Авто-координаты — справа от последней ноды. Clamp к >= 50, чтобы
-        // нода не ушла в отрицательные координаты (canvas начинается с 0,0,
-        // негативные позиции невидимы без скролла).
+        // Поиск незанятого места: пытаемся справа от последней ноды,
+        // потом проверяем что не перекрывает существующие. Если
+        // перекрывает — сдвигаем вправо/вниз пошагово (по сетке 32px).
         const last = state.currentBoard.metadata.nodes[state.currentBoard.metadata.nodes.length - 1];
         let nx = typeof x === 'number' ? x : (last ? last.x + 320 : 100);
         let ny = typeof y === 'number' ? y : (last ? last.y : 100);
         if (nx < 50) nx = 50;
         if (ny < 50) ny = 50;
+        // Дефолтные размеры для overlap-detection. Реальные node.width/height
+        // выставляются renderCanvas'ом по типу — но 280×220 — типичная
+        // прикидка для image/video, 200×120 — text/label/audio.
+        const w = (type === 'text' || type === 'label' || type === 'audio') ? 200 : 280;
+        const h = (type === 'text' || type === 'label' || type === 'audio') ? 120 : 220;
+        function overlaps(ax, ay) {
+          for (const n of state.currentBoard.metadata.nodes) {
+            const nw = n.width || ((n.type === 'text' || n.type === 'label' || n.type === 'audio') ? 200 : 280);
+            const nh = n.height || ((n.type === 'text' || n.type === 'label' || n.type === 'audio') ? 120 : 220);
+            // Считаем overlap'ом если центр новой ноды попадает В существующую.
+            // Это позволяет частично пересекаться (выглядит как «сдвиг»),
+            // но юзер увидит обе ноды.
+            const cx = ax + w / 2, cy = ay + h / 2;
+            if (cx >= n.x && cx <= n.x + nw && cy >= n.y && cy <= n.y + nh) return true;
+          }
+          return false;
+        }
+        // Если первое место занято — двигаем по сетке. Пытаемся вправо до
+        // 6 шагов, потом строкой ниже.
+        if (overlaps(nx, ny)) {
+          const step = 40;
+          let found = false;
+          for (let row = 0; row < 8 && !found; row++) {
+            for (let col = 0; col < 8 && !found; col++) {
+              const tx = nx + col * step;
+              const ty = ny + row * step;
+              if (!overlaps(tx, ty)) { nx = tx; ny = ty; found = true; }
+            }
+          }
+        }
         const id = (crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2));
         const node = { id, type, x: nx, y: ny };
         if (name) node.name = name;
@@ -122,6 +152,14 @@
         if (prompt && type !== 'text' && type !== 'label') {
           node.status = 'draft';
           node.generated = { rawPrompt: prompt, prompt, modelKey: modelKey || undefined };
+          // Audio имеет 3 sub-kind'а: voice (TTS — дефолт), music, sfx.
+          // generate_node роутит в нужный job по этому полю.
+          if (type === 'audio') {
+            node.generated.kind = 'audio';
+            node.generated.subKind = (subKind === 'music' || subKind === 'sfx') ? subKind : 'voice';
+            if (typeof durationMs === 'number') node.generated.durationMs = durationMs;
+            if (subKind === 'music') node.generated.model = 'eleven-music';
+          }
         }
         state.currentBoard.metadata.nodes.push(node);
         scheduleSave();
@@ -322,11 +360,21 @@
         node.generated = { ...(node.generated || {}), kind, prompt, rawPrompt: node.generated?.rawPrompt || prompt };
         scheduleSave();
         if (typeof renderCanvas === 'function') await renderCanvas();
-        // Маршрутизация по kind — копия логики из resumeJob/«Повторить», чтобы
-        // запустить job напрямую без gen-modal'а.
+        // Маршрутизация по kind/subKind — копия логики из resumeJob/«Повторить»,
+        // чтобы запустить job напрямую без gen-modal'а.
         if (kind === 'audio') {
-          if (typeof runTTSJob !== 'function') throw new Error('runTTSJob недоступен');
-          runTTSJob(node, prompt, boardHandle, bKey, node.generated?.voiceId).catch(e => console.error('TTS job failed:', e));
+          const subKind = node.generated?.subKind || 'voice';
+          if (subKind === 'music') {
+            if (typeof runMusicJob !== 'function') throw new Error('runMusicJob недоступен');
+            runMusicJob(node, prompt, node.generated?.durationMs || null, boardHandle, bKey).catch(e => console.error('music job failed:', e));
+          } else if (subKind === 'sfx') {
+            if (typeof runSfxJob !== 'function') throw new Error('runSfxJob недоступен');
+            runSfxJob(node, prompt, node.generated?.durationMs ? node.generated.durationMs / 1000 : null, boardHandle, bKey).catch(e => console.error('sfx job failed:', e));
+          } else {
+            // voice (TTS) — дефолт.
+            if (typeof runTTSJob !== 'function') throw new Error('runTTSJob недоступен');
+            runTTSJob(node, prompt, boardHandle, bKey, node.generated?.voiceId).catch(e => console.error('TTS job failed:', e));
+          }
         } else if (kind === 'text') {
           if (typeof runTextJob !== 'function') throw new Error('runTextJob недоступен');
           const imageRefs = refs.filter(r => r.type === 'image' && r.file);
@@ -485,7 +533,21 @@
       await persistNow();
     }
   }
+  // Забираем историю с сервера (server-side state — source of truth).
+  // Если на сервере есть pending tool-loop — сразу стартуем polling.
   async function loadHistoryFromCurrentProject() {
+    const key = sessionKey();
+    if (!key) { history = []; renderHistory(); return; }
+    try {
+      const r = await fetch('/api/chat/state?key=' + encodeURIComponent(key));
+      if (r.ok) {
+        const snap = await r.json();
+        applyServerState(snap);
+        if (snap.busy) startPolling(key);
+        return;
+      }
+    } catch (e) { console.warn('[chat] load from server failed:', e?.message); }
+    // Fallback на legacy disk-loaded — если сервер недоступен (старая версия).
     if (!state.filmHandle) { history = []; renderHistory(); return; }
     try {
       const fh = await state.filmHandle.getFileHandle(CHAT_FILE);
@@ -700,6 +762,21 @@
     return ctx;
   }
 
+  // Декл-форма множественного: «1 картинка», «2 картинки», «5 картинок».
+  function _ru_plural(n, forms) {
+    const n10 = n % 10, n100 = n % 100;
+    if (n100 >= 11 && n100 <= 14) return forms[2];
+    if (n10 === 1) return forms[0];
+    if (n10 >= 2 && n10 <= 4) return forms[1];
+    return forms[2];
+  }
+  const _typeForms = {
+    image: ['картинка','картинки','картинок'],
+    video: ['видео','видео','видео'],
+    audio: ['аудио','аудио','аудио'],
+    text:  ['текст','текста','текстов'],
+    label: ['подпись','подписи','подписей'],
+  };
   function renderContextRow() {
     const row = document.getElementById('chatContextRow');
     if (!row) return;
@@ -707,8 +784,21 @@
     const ctx = buildContextSnapshot();
     const parts = [];
     if (ctx.scene) parts.push({ key: 'scene', label: `🎬 ${ctx.scene.name}`, removable: false });
+    // Группируем выделенные ноды по type. Если 1 — показываем имя/id;
+    // если 2+ — «N картинок» с локализацией.
+    const byType = {};
     for (const sel of ctx.selected) {
-      parts.push({ key: 'sel:' + sel.id, label: `◉ ${sel.type === 'image' ? '🖼' : sel.type === 'video' ? '🎬' : sel.type === 'audio' ? '🎙' : '📝'} ${sel.name || sel.id.slice(0, 6)}`, removable: false });
+      (byType[sel.type] = byType[sel.type] || []).push(sel);
+    }
+    for (const [type, items] of Object.entries(byType)) {
+      const icon = type === 'image' ? '🖼' : type === 'video' ? '🎬' : type === 'audio' ? '🎙' : type === 'text' ? '📝' : '◉';
+      if (items.length === 1) {
+        const s = items[0];
+        parts.push({ key: 'sel:' + s.id, label: `${icon} ${s.name || s.id.slice(0, 6)}`, removable: false });
+      } else {
+        const noun = _typeForms[type] || ['нода','ноды','нод'];
+        parts.push({ key: 'sel-grp:' + type, label: `${icon} ${items.length} ${_ru_plural(items.length, noun)}`, removable: false });
+      }
     }
     for (const a of ctx.attachments) {
       parts.push({ key: 'att:' + a.relPath, label: `📎 ${a.name}`, removable: true, onRemove: () => { manualAttachments = manualAttachments.filter(x => x.relPath !== a.relPath); renderContextRow(); } });
@@ -818,7 +908,8 @@
     list.scrollTop = list.scrollHeight;
   }
 
-  function appendStatus(msg) {
+  // (старый appendStatus — заменён на нижний с поддержкой isError)
+  function _appendStatusOld(msg) {
     const list = $('chatList');
     if (!list) return;
     const div = document.createElement('div');
@@ -894,85 +985,137 @@
     return await def.handler(args || {});
   }
 
+  // Идентификатор сессии чата = projectKey клиента. Передаётся серверу.
+  function sessionKey() {
+    if (state.cloudProjectId) return 'cloud:' + state.cloudProjectId;
+    if (state.filmHandle?.name) return 'folder:' + state.filmHandle.name;
+    return null;
+  }
+
+  // Длинный pollin цикл. Стартует после send(). Опрашивает GET /api/chat/state
+  // каждые 800ms, пока сервер busy=true. Если сервер вернул pendingToolCalls
+  // — исполняет их локально (тут есть FSAH-доступ) и шлёт results через
+  // POST /api/chat/tool-results, после чего сервер продолжает loop.
+  let pollTimer = null;
+  let pollKey = null;
+  async function startPolling(key) {
+    if (pollKey === key && pollTimer) return;
+    stopPolling();
+    pollKey = key;
+    const tick = async () => {
+      if (pollKey !== key) return;
+      try {
+        const r = await fetch('/api/chat/state?key=' + encodeURIComponent(key));
+        if (!r.ok) throw new Error('HTTP ' + r.status);
+        const snap = await r.json();
+        // Применяем снимок только если сессия всё ещё активна на клиенте.
+        if (sessionKey() === key) applyServerState(snap);
+        // Если есть pending-tools — исполняем и шлём results (продолжаем
+        // poll сразу, не ждём next tick).
+        if (snap.pendingToolCalls && snap.pendingToolCalls.length) {
+          const results = [];
+          for (const tc of snap.pendingToolCalls) {
+            if (tc._parseError) {
+              results.push({ id: tc.id, name: 'parse_error', ok: false, error: tc._parseError });
+              continue;
+            }
+            try {
+              const r2 = await runTool(tc.name, tc.args);
+              results.push({ id: tc.id, name: tc.name, ok: true, result: r2 });
+            } catch (e) {
+              results.push({ id: tc.id, name: tc.name, ok: false, error: e?.message || String(e) });
+            }
+          }
+          await fetch('/api/chat/tool-results', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key, results }),
+          }).catch(() => {});
+          // Сразу продолжаем polling без задержки (loop уже резюмирован сервером).
+          if (pollKey === key) pollTimer = setTimeout(tick, 50);
+          return;
+        }
+        if (snap.busy) {
+          if (pollKey === key) pollTimer = setTimeout(tick, 800);
+        } else {
+          // Loop завершён — последняя статус-строка может быть info'й.
+          if (snap.lastError) appendStatus('⚠ ' + snap.lastError, true);
+          stopPolling();
+        }
+      } catch (e) {
+        console.warn('[chat] poll failed:', e?.message);
+        if (pollKey === key) pollTimer = setTimeout(tick, 2000);   // backoff
+      }
+    };
+    tick();
+  }
+  function stopPolling() {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+    pollKey = null;
+  }
+
+  // Сервер прислал snapshot — применяем history к UI.
+  function applyServerState(snap) {
+    if (!snap) return;
+    history = snap.history || [];
+    busy = !!snap.busy;
+    renderHistory();
+    // Statusbar: если сервер думает — поддерживаем placeholder.
+    let statusEl = document.querySelector('#chatList .chat-status:last-child');
+    if (busy) {
+      const txt = (snap.pendingToolCalls?.length)
+        ? `Выполняю ${snap.pendingToolCalls.length} tool(s)…`
+        : 'KingKont думает…';
+      if (!statusEl || !statusEl.classList.contains('chat-status') || statusEl.classList.contains('error')) {
+        statusEl = appendStatus(txt);
+      } else {
+        statusEl.textContent = txt;
+      }
+    } else if (statusEl && !statusEl.classList.contains('error')) {
+      statusEl.remove();
+    }
+  }
+
   async function send(userText) {
-    if (busy) return;
     if (!userText.trim()) return;
-    busy = true;
-    // Snapshot ДО мутации — чтобы юзер мог откатить «всё что чат сделал
-    // в ответ на это сообщение». Шортнем label первыми 60 символами user-msg.
+    const key = sessionKey();
+    if (!key) { alert('Сначала открой проект'); return; }
+    // Snapshot ДО мутации — клиентский (для отката чат-действий).
     try {
       await takeSnapshot(userText.length > 60 ? userText.slice(0, 60) + '…' : userText);
     } catch (e) { console.warn('snapshot failed:', e?.message); }
-    history.push({ role: 'user', content: userText });
-    renderHistory();
-    persistDebounced();
-    const status = appendStatus('KingKont думает…');
-    // Привязываем context-snapshot НА МОМЕНТ send: текущая сцена,
-    // выделенные ноды, прикреплённые файлы. Передаётся в system-prompt
-    // дополнительным блоком — модель видит что у юзера сейчас в фокусе.
+    // Контекст + system-prompt: формируем тут (на клиенте) и отдаём серверу.
     const ctxSnap = buildContextSnapshot();
     const system = buildSystemPrompt() + '\n\n' + buildContextBlock(ctxSnap);
+    appendStatus('KingKont думает…');
     try {
-      let iter = 0;
-      while (iter < MAX_TOOL_ITERATIONS) {
-        iter++;
-        const text = await callLLM(historyToMessages(), system);
-        const toolCalls = parseToolCalls(text);
-        const cleanText = stripToolCalls(text);
-        const assistantMsg = {
-          role: 'assistant',
-          content: cleanText,
-          tools: [],
-        };
-        history.push(assistantMsg);
-
-        if (!toolCalls.length) {
-          // Финальный ответ — больше нечего исполнять.
-          status.remove();
-          renderHistory();
-          persistDebounced();
-          break;
-        }
-
-        // Исполняем tools, собираем результаты.
-        status.textContent = `Выполняю ${toolCalls.length} tool(s)…`;
-        const results = [];
-        for (const tc of toolCalls) {
-          if (tc._parseError) {
-            results.push({ name: 'parse_error', error: tc._parseError, raw: tc.raw });
-            assistantMsg.tools.push({ name: 'parse_error', _error: tc._parseError });
-            continue;
-          }
-          try {
-            const r = await runTool(tc.name, tc.args);
-            results.push({ name: tc.name, ok: true, result: r });
-            assistantMsg.tools.push({ name: tc.name, args: tc.args, result: r, _ok: true });
-          } catch (e) {
-            results.push({ name: tc.name, ok: false, error: e?.message || String(e) });
-            assistantMsg.tools.push({ name: tc.name, args: tc.args, _error: e?.message || String(e) });
-          }
-        }
-        renderHistory();
-        persistDebounced();   // assistant-турн с tool-вызовами уже частично готов
-
-        // Шлём результаты обратно как user-message (чтобы Claude увидел и продолжил).
-        const resultsMsg = results.map(r => `<tool_result>${JSON.stringify(r)}</tool_result>`).join('\n');
-        history.push({ role: 'user', content: resultsMsg });
-        // Не рендерим этот системный turn (renderHistory его отфильтровывает) —
-        // на самом деле он role='user', придётся скрыть руками. Делаем простую
-        // эвристику: если content начинается с <tool_result>, не показываем.
-        // Тут же — это можно сделать через флаг.
-      }
-      if (iter >= MAX_TOOL_ITERATIONS) {
-        appendStatus(`⚠ остановился после ${MAX_TOOL_ITERATIONS} итераций`);
+      const r = await fetch('/api/chat/send', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ key, text: userText, system }),
+      });
+      if (!r.ok) {
+        const err = await r.json().catch(() => ({}));
+        throw new Error(err.error || 'HTTP ' + r.status);
       }
+      const snap = await r.json();
+      applyServerState(snap);
+      startPolling(key);
     } catch (e) {
-      status.textContent = '⚠ ' + (e?.message || e);
-      status.classList.add('error');
-    } finally {
-      busy = false;
+      appendStatus('⚠ ' + (e?.message || e), true);
     }
   }
+  function appendStatus(text, isError) {
+    const list = $('chatList');
+    if (!list) return null;
+    const div = document.createElement('div');
+    div.className = 'chat-status' + (isError ? ' error' : '');
+    div.textContent = text;
+    list.appendChild(div);
+    list.scrollTop = list.scrollHeight;
+    return div;
+  }
 
   // Скрываем tool_result-сообщения из UI (они нужны только модели).
   // renderHistory вызывает renderHistory — оставлю как есть, плюс добавлю
@@ -1016,27 +1159,30 @@
         div.appendChild(body);
       }
       if (hasTools) {
-        for (const tc of m.tools) {
-          const t = document.createElement('details');
-          t.className = 'chat-tool';
-          const sum = document.createElement('summary');
-          // Компактный summary: имя tool + ключевой arg (если короткий) + статус.
+        // Все tools в ОДНУ строку (separated " · "), без emoji-icons —
+        // компактнее. Раскрываются click'ом одной общей <details>.
+        const t = document.createElement('details');
+        t.className = 'chat-tool';
+        const sum = document.createElement('summary');
+        const parts = m.tools.map(tc => {
+          const status = tc._error ? '⚠' : (tc._ok ? '✓' : '·');
           const argHint = _argHint(tc.args);
-          const status = tc._error ? '  ⚠' : tc._ok ? '  ✓' : '';
-          sum.textContent = `🔧 ${tc.name}${argHint}${status}`;
-          t.appendChild(sum);
-          // pre добавляем только если есть что показать (args/result/error не пусты).
-          const dump = {};
-          if (tc.args && Object.keys(tc.args).length) dump.args = tc.args;
-          if (tc.result !== undefined) dump.result = tc.result;
-          if (tc._error) dump.error = tc._error;
-          if (Object.keys(dump).length) {
-            const pre = document.createElement('pre');
-            pre.textContent = JSON.stringify(dump, null, 2);
-            t.appendChild(pre);
-          }
-          div.appendChild(t);
-        }
+          return `${tc.name}${argHint} ${status}`;
+        });
+        sum.textContent = parts.join(' · ');
+        t.appendChild(sum);
+        // pre с полным JSON всех вызовов (для debug/details).
+        const dumpAll = m.tools.map(tc => {
+          const d = { tool: tc.name };
+          if (tc.args && Object.keys(tc.args).length) d.args = tc.args;
+          if (tc.result !== undefined) d.result = tc.result;
+          if (tc._error) d.error = tc._error;
+          return d;
+        });
+        const pre = document.createElement('pre');
+        pre.textContent = JSON.stringify(dumpAll, null, 2);
+        t.appendChild(pre);
+        div.appendChild(t);
       }
       list.appendChild(div);
     }
@@ -1148,6 +1294,9 @@
     const panel = $('chatPanel');
     panel.classList.toggle('hidden');
     if (!panel.classList.contains('hidden')) {
+      // Сворачиваем preview-панель — иначе она перекрывает чат справа
+      // (preview z-index 40 > chat z-index 30 by design).
+      if (typeof setPreviewCollapsed === 'function') setPreviewCollapsed(true);
       // Отрисовываем сохранённую историю при показе (на случай если она
       // была подгружена в фоне через loadFromCurrentProject до первого toggle).
       renderHistory();
@@ -1180,13 +1329,25 @@
     open: () => { ensureUI(); $('chatPanel').classList.remove('hidden'); setTimeout(() => $('chatInput')?.focus(), 50); },
     close: () => $('chatPanel')?.classList.add('hidden'),
     send,
-    // User-clear: чистит И на диске тоже (юзер явно нажал ⌫).
-    clear: () => { history = []; snapshots = []; renderHistory(); renderSnapshotBar(); persistNow().catch(() => {}); },
-    // Reset-on-close: ФЛАШИМ pending-дебаунс В ТЕКУЩИЙ filmHandle (чтобы
-    // история не утекла в следующий проект), потом чистим in-memory.
-    // На диске история того проекта остаётся — re-open подгрузит.
+    // User-clear: стираем И на сервере (юзер явно нажал ⌫).
+    clear: async () => {
+      const key = sessionKey();
+      if (key) {
+        try {
+          await fetch('/api/chat/clear', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key }),
+          });
+        } catch {}
+      }
+      history = []; snapshots = [];
+      renderHistory(); renderSnapshotBar();
+    },
+    // Reset-on-close: останавливаем polling, чистим UI. История на сервере
+    // остаётся (server-side persistence). re-open того же проекта подгрузит.
     resetInMemory: async () => {
-      try { await flushPersist(); } catch {}
+      stopPolling();
       history = []; snapshots = [];
       renderHistory(); renderSnapshotBar();
     },

package/renderer/styles.css

@@ -253,7 +253,10 @@
     position: fixed; right: 0; top: 0; bottom: 0; width: 420px;
     background: #1a1a1a; border-left: 1px solid #333;
     display: flex; flex-direction: column;
-    z-index: 80;
+    /* z-index 30 — НИЖЕ preview-panel (z-index 40). Preview перекрывает чат
+       визуально; при открытии чата preview сворачивается автоматически
+       (см. toggle() в chat.js → setPreviewCollapsed(true)). */
+    z-index: 30;
     box-shadow: -8px 0 32px rgba(0,0,0,0.4);
     /* --chat-font задаётся inline в chat.js (Cmd+/Cmd-). Дефолт 13px. */
     font-size: var(--chat-font, 13px);

package/server.js

@@ -13,6 +13,7 @@ const { readFileSync, existsSync } = require('node:fs');
 const { extname, join, normalize, resolve } = require('node:path');
 
 const providers = require('./lib/providers');
+const chatSession = require('./lib/chatSession');
 
 // ---------- .env loader (без зависимостей) ----------
 function loadEnv() {
@@ -299,6 +300,51 @@ async function handleProjectDelete(res, id) {
   } catch (e) { sendError(res, e, 502); }
 }
 
+// =============================================================================
+// Chat sessions: server-side LLM-loop с tool-pump pattern.
+// Клиент:  POST /api/chat/send {key, text, system}  → starts loop
+//          GET  /api/chat/state?key=...             → poll for state/pendingTools
+//          POST /api/chat/tool-results {key, results} → continue loop
+//          POST /api/chat/clear {key}
+// Tools исполняются НА КЛИЕНТЕ (FSAH-доступ), сервер только пробрасывает.
+// =============================================================================
+async function handleChatSend(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key, text, system } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    if (!text) return send(res, 400, { error: 'text обязателен' });
+    const snap = await chatSession.send(key, { text, system, settingsGetter: getSettings });
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatState(res, url) {
+  try {
+    const key = url.searchParams.get('key');
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = await chatSession.getState(key);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatToolResults(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key, results } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = chatSession.submitToolResults(key, results);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+async function handleChatClear(req, res) {
+  try {
+    const body = await readJson(req);
+    const { key } = body || {};
+    if (!key) return send(res, 400, { error: 'key обязателен' });
+    const snap = await chatSession.clear(key);
+    send(res, 200, snap);
+  } catch (e) { sendError(res, e, 500); }
+}
+
 // =============================================================================
 // Static files (renderer assets).
 // =============================================================================
@@ -348,6 +394,11 @@ const server = createServer(async (req, res) => {
         if (req.method === 'DELETE') return handleTemplateDelete(res, decodeURIComponent(m[1]));
       }
     }
+    // Chat routes (server-side LLM loop, tools исполняются на клиенте).
+    if (req.method === 'POST' && url.pathname === '/api/chat/send')         return handleChatSend(req, res);
+    if (req.method === 'GET'  && url.pathname === '/api/chat/state')        return handleChatState(res, url);
+    if (req.method === 'POST' && url.pathname === '/api/chat/tool-results') return handleChatToolResults(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/chat/clear')        return handleChatClear(req, res);
     // Cloud-projects routes — зеркало templates, но для редактируемых проектов.
     if (req.method === 'GET'  && url.pathname === '/api/projects')     return handleProjectsList(res);
     if (req.method === 'POST' && url.pathname === '/api/projects')     return handleProjectCreate(req, res);
@@ -372,6 +423,9 @@ process.on('uncaughtException',  (err) => console.error('[uncaughtException]', e
 
 function start(port = PORT, opts = {}) {
   if (typeof opts.getSettings === 'function') getSettings = opts.getSettings;
+  // Init chatSession с userDataDir для персистентности историй.
+  // Без opts.userDataDir чат живёт только in-memory (CLI-режим).
+  chatSession.init({ userDataDir: opts.userDataDir || null });
   return new Promise((resolveOk, reject) => {
     server.once('error', reject);
     server.listen(port, () => {

package/web.html

@@ -0,0 +1,105 @@
+<!DOCTYPE html>
+<!--
+  KingKont — web-shell (без FS Access API).
+  =========================================
+
+  Это вход для веб-версии. Отличается от index.html только тем что:
+    1. Вначале выставляет window.__KINGKONT_WEB__ = true.
+    2. После загрузки index.html-разметки прячет кнопки которые требуют
+       реальной FS-Access (#pickRoot и любые «Открыть папку…»).
+    3. В renderer/cloudFs.js fallback на in-memory backend срабатывает
+       автоматически — preload не подгружен, window.cloudFs undefined.
+
+  Способы попасть сюда:
+    - локально: `node server.js` → http://localhost:8000/web.html
+    - чуть позже задеплоится отдельно как иной endpoint (когда будет готов).
+
+  ВАЖНО: всю работу с проектом веб-версия ведёт через cloud-projects.
+  Папочные проекты (через showDirectoryPicker) в вебе не поддерживаются.
+-->
+<html lang="ru">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>KingKont (web)</title>
+<link rel="stylesheet" href="renderer/styles.css">
+<style>
+  /* Web-mode: прячем кнопки которые завязаны на FS Access API. */
+  body.web-mode #pickRoot,
+  body.web-mode #welcomeOpen,
+  body.web-mode .web-hide { display: none !important; }
+  /* Подсказку добавляем в шапку — что это web-вариант. */
+  body.web-mode .brand-version::after {
+    content: ' · web';
+    color: #ff9d6e;
+    margin-left: 4px;
+  }
+</style>
+<script>
+  // Маркер до загрузки прочих скриптов: cloudFs.js / cloudProjects.js
+  // могут проверить window.__KINGKONT_WEB__ для развилок.
+  window.__KINGKONT_WEB__ = true;
+</script>
+</head>
+<body class="web-mode">
+<!--
+  ВНИМАНИЕ: разметка ниже скопирована из index.html. Чтобы не плодить дубликат
+  при изменениях, держи их синхронизированными ИЛИ вынеси разметку в общий
+  partial. Сейчас минимальный shell — без копирования всех модалок: их можно
+  включить позже когда веб-режим будет покрывать больше сценариев.
+
+  TODO для следующих итераций:
+    - вынести `<aside class="sidebar">` и `<main class="canvas">` в common partial
+    - проверить что generate.js работает без window.appSettings (он делает
+      `window.appSettings.get()` для useChatium-флагов; на вебе нужно либо
+      mock'ать через server.js endpoint, либо хранить в localStorage).
+    - аудио/видео-плейбек таймлайна должен работать с blob-URL'ами от
+      in-memory cloud-handle'ов (cloudFs.js делает Blob через .getFile()).
+-->
+<div style="padding:60px; text-align:center; max-width:600px; margin:auto; color:#bbb; font-family:sans-serif;">
+  <h1 style="color:#fff; margin-bottom:16px;">KingKont · web</h1>
+  <p style="margin-bottom:24px;">Веб-версия в разработке. Сейчас доступно:</p>
+  <ul style="text-align:left; max-width:400px; margin:0 auto 24px; line-height:1.8;">
+    <li>создание облачного проекта (server-side)</li>
+    <li>редактирование в браузере (in-memory)</li>
+    <li>сохранение на сервер по кнопке</li>
+  </ul>
+  <p style="font-size:13px; opacity:0.7;">
+    Для полноценной работы открой Electron-приложение:<br>
+    <code style="background:#222; padding:2px 6px; border-radius:3px;">npx kingkont</code>
+  </p>
+  <hr style="margin:32px 0; border:none; border-top:1px solid #333;">
+  <p style="font-size:12px; opacity:0.6;">
+    Чтобы открыть полную web-версию (с canvas), <a href="/index.html" style="color:#7ab;">перейди на /index.html</a>
+    — там работает FS Access API в Chrome (можно открыть папку проекта).<br>
+    Эта страница (web.html) — заготовка для будущего билда без FS-API.
+  </p>
+</div>
+
+<script>
+  // Заглушки для главных API окружения, которых нет в web (приходят из
+  // preload в Electron). Renderer-модули проверяют наличие через optional
+  // chaining (window.appSettings?.get etc) — undefined → они просто не
+  // дёргают эти ручки.
+  if (!window.appSettings) {
+    window.appSettings = {
+      // На вебе settings храним в localStorage (минимально нужны useChatium
+      // и chatium.token — иначе cloud-projects кнопки не покажутся).
+      // Token придётся ввести вручную пока не сделан web-OAuth.
+      get: async () => {
+        try { return JSON.parse(localStorage.getItem('webSettings') || '{}'); }
+        catch { return {}; }
+      },
+      save: async (partial) => {
+        const cur = JSON.parse(localStorage.getItem('webSettings') || '{}');
+        const next = { ...cur, ...partial };
+        localStorage.setItem('webSettings', JSON.stringify(next));
+        return next;
+      },
+    };
+  }
+  if (!window.appProject) window.appProject = { notifyState: () => {} };
+  if (!window.appInfo)    window.appInfo    = { version: async () => 'web' };
+</script>
+</body>
+</html>