team-chat 0.0.0-stage → 0.3.0

package/host/knowledge/stack.js

@@ -0,0 +1,229 @@
+// С каким стеком работал агент — по манифестам проекта: языки, фреймворки, базы, тесты,
+// с версиями. Только названия и версии: содержимое проекта сюда не попадает.
+//
+// Каталог проекта может держать несколько репозиториев (у QBazar их три) — тогда стек
+// берётся у тех, чьи файлы агент трогал: задача про витрину не про бэкенд.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const MANIFESTS = ['package.json', 'composer.json', 'pyproject.toml', 'requirements.txt', 'go.mod', 'Cargo.toml', 'Gemfile',
+  'docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml', 'Dockerfile'];
+
+const JS_FRAMEWORKS = {
+  next: 'Next.js', react: 'React', vue: 'Vue', nuxt: 'Nuxt', '@angular/core': 'Angular', svelte: 'Svelte', '@sveltejs/kit': 'SvelteKit',
+  express: 'Express', fastify: 'Fastify', hono: 'Hono', '@nestjs/core': 'NestJS', koa: 'Koa', 'react-native': 'React Native', expo: 'Expo',
+  electron: 'Electron', '@refinedev/core': 'Refine', vite: 'Vite', tailwindcss: 'Tailwind CSS', 'drizzle-orm': 'Drizzle',
+  prisma: 'Prisma', '@prisma/client': 'Prisma', typeorm: 'TypeORM', sequelize: 'Sequelize', mongoose: 'Mongoose',
+  '@modelcontextprotocol/sdk': 'MCP SDK',
+};
+const JS_DATABASES = {
+  pg: 'PostgreSQL', postgres: 'PostgreSQL', '@electric-sql/pglite': 'PostgreSQL (PGlite)', mysql2: 'MySQL', mysql: 'MySQL',
+  mongodb: 'MongoDB', mongoose: 'MongoDB', redis: 'Redis', ioredis: 'Redis', 'better-sqlite3': 'SQLite', sqlite3: 'SQLite',
+};
+const JS_TESTS = { jest: 'Jest', vitest: 'Vitest', mocha: 'Mocha', '@playwright/test': 'Playwright', cypress: 'Cypress' };
+
+const PHP_PACKAGES = {
+  'laravel/framework': ['frameworks', 'Laravel'], 'symfony/framework-bundle': ['frameworks', 'Symfony'],
+  'filament/filament': ['frameworks', 'Filament'], 'livewire/livewire': ['frameworks', 'Livewire'],
+  'inertiajs/inertia-laravel': ['frameworks', 'Inertia'], 'phpunit/phpunit': ['tests', 'PHPUnit'], 'pestphp/pest': ['tests', 'Pest'],
+};
+const PY_PACKAGES = {
+  django: ['frameworks', 'Django'], fastapi: ['frameworks', 'FastAPI'], flask: ['frameworks', 'Flask'],
+  sqlalchemy: ['frameworks', 'SQLAlchemy'], pytest: ['tests', 'pytest'], 'psycopg2': ['databases', 'PostgreSQL'], 'psycopg': ['databases', 'PostgreSQL'],
+};
+
+/** Образы контейнеров → что это. */
+const IMAGES = [
+  [/^(?:library\/)?mysql$/, 'databases', 'MySQL'], [/^(?:library\/)?mariadb$/, 'databases', 'MariaDB'],
+  [/^(?:library\/)?postgres$|^postgis\/postgis$|^pgvector\/pgvector$/, 'databases', 'PostgreSQL'],
+  [/^(?:library\/)?mongo$/, 'databases', 'MongoDB'], [/^(?:library\/)?redis$|^valkey\/valkey$/, 'databases', 'Redis'],
+  [/elasticsearch$/, 'databases', 'Elasticsearch'], [/opensearch$/, 'databases', 'OpenSearch'], [/clickhouse/, 'databases', 'ClickHouse'],
+  [/kafka$/, 'infra', 'Kafka'], [/^(?:library\/)?rabbitmq$/, 'infra', 'RabbitMQ'], [/^(?:library\/)?nginx$/, 'infra', 'Nginx'],
+  [/^(?:library\/)?(?:php)$/, 'languages', 'PHP'], [/^(?:library\/)?node$/, 'languages', 'Node.js'], [/^(?:library\/)?python$/, 'languages', 'Python'],
+];
+
+/**
+ * @param {string} workdir каталог проекта
+ * @param {string[]} touched файлы, которые агент читал или менял
+ */
+export function detectStack(workdir, touched = []) {
+  const stack = new Stack();
+  for (const root of projectRoots(workdir, touched)) {
+    const read = name => readText(path.join(root, name));
+    readPackageJson(stack, read);
+    readComposer(stack, read);
+    readPython(stack, read);
+    readGo(stack, read);
+    readRust(stack, read);
+    readRuby(stack, read);
+    readContainers(stack, read);
+  }
+  stack.os = osName();
+  return stack.result();
+}
+
+class Stack {
+  groups = { languages: new Map(), frameworks: new Map(), databases: new Map(), tests: new Map() };
+  infra = new Set();
+  os = null;
+
+  /** Одно название — одна запись; версия — первая известная. */
+  add(group, name, version = null) {
+    if (group === 'infra') return void this.infra.add(name);
+    const known = this.groups[group].get(name);
+    if (!known || (!known.version && version)) this.groups[group].set(name, { name, version: shortVersion(version) });
+  }
+
+  result() {
+    const list = group => [...this.groups[group].values()];
+    return {
+      languages: list('languages'), frameworks: list('frameworks'), databases: list('databases'),
+      infra: [...this.infra], tests: list('tests').map(t => t.name), os: this.os,
+    };
+  }
+}
+
+// ------------------------------------------------------------- какие репозитории смотреть
+
+/** Корни проектов: сам каталог, если в нём манифест; иначе — репозитории внутри, которых касался агент. */
+function projectRoots(workdir, touched) {
+  if (!workdir || !isDir(workdir)) return [];
+  if (hasManifest(workdir)) return [workdir];
+  const repos = fs.readdirSync(workdir, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== 'node_modules')
+    .map(d => path.join(workdir, d.name))
+    .filter(dir => hasManifest(dir) || isDir(path.join(dir, '.git')));
+  const used = repos.filter(repo => touched.some(file => path.resolve(workdir, file).startsWith(repo + path.sep)));
+  return used.length ? used : repos;
+}
+
+function hasManifest(dir) {
+  return MANIFESTS.some(name => fs.existsSync(path.join(dir, name)));
+}
+
+// ------------------------------------------------------------- манифесты
+
+function readPackageJson(stack, read) {
+  const pkg = json(read('package.json'));
+  if (!pkg) return;
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const lock = json(read('package-lock.json'))?.packages ?? {};
+  const version = name => lock[`node_modules/${name}`]?.version ?? deps[name];
+
+  stack.add('languages', deps.typescript ? 'TypeScript' : 'JavaScript', deps.typescript ? version('typescript') : null);
+  stack.add('languages', 'Node.js', pkg.engines?.node ?? read('.nvmrc')?.trim() ?? null);
+  for (const [name, title] of Object.entries(JS_FRAMEWORKS)) if (deps[name]) stack.add('frameworks', title, version(name));
+  for (const [name, title] of Object.entries(JS_DATABASES)) if (deps[name]) stack.add('databases', title);
+  for (const [name, title] of Object.entries(JS_TESTS)) if (deps[name]) stack.add('tests', title);
+  if (/\bnode\s+--test\b/.test(Object.values(pkg.scripts ?? {}).join(' '))) stack.add('tests', 'node:test');
+}
+
+function readComposer(stack, read) {
+  const composer = json(read('composer.json'));
+  if (!composer) return;
+  const lock = json(read('composer.lock'));
+  const locked = new Map([...(lock?.packages ?? []), ...(lock?.['packages-dev'] ?? [])].map(p => [p.name, p.version]));
+  const required = { ...composer.require, ...composer['require-dev'] };
+
+  stack.add('languages', 'PHP', required.php ?? null);
+  for (const [name, [group, title]] of Object.entries(PHP_PACKAGES)) {
+    if (required[name] || locked.has(name)) stack.add(group, title, locked.get(name) ?? required[name]);
+  }
+}
+
+function readPython(stack, read) {
+  const pyproject = read('pyproject.toml');
+  const requirements = read('requirements.txt');
+  if (!pyproject && !requirements) return;
+  const pythonVersion = /requires-python\s*=\s*["']([^"']+)/.exec(pyproject ?? '')?.[1] ?? null;
+  stack.add('languages', 'Python', pythonVersion);
+  const text = `${pyproject ?? ''}\n${requirements ?? ''}`.toLowerCase();
+  for (const [name, [group, title]] of Object.entries(PY_PACKAGES)) {
+    const match = new RegExp(`(?:^|["'\\s])${name}\\s*(?:[=<>~!]=?\\s*([\\d.]+))?`, 'm').exec(text);
+    if (match) stack.add(group, title, match[1] ?? null);
+  }
+}
+
+function readGo(stack, read) {
+  const mod = read('go.mod');
+  if (!mod) return;
+  stack.add('languages', 'Go', /^go\s+([\d.]+)/m.exec(mod)?.[1] ?? null);
+  for (const [module, title] of [['gin-gonic/gin', 'Gin'], ['labstack/echo', 'Echo'], ['gofiber/fiber', 'Fiber']]) {
+    const match = new RegExp(`${module}(?:/v\\d+)?\\s+v([\\d.]+)`).exec(mod);
+    if (match) stack.add('frameworks', title, match[1]);
+  }
+}
+
+function readRust(stack, read) {
+  const cargo = read('Cargo.toml');
+  if (!cargo) return;
+  stack.add('languages', 'Rust', /rust-version\s*=\s*"([^"]+)"/.exec(cargo)?.[1] ?? null);
+  for (const [crate, title] of [['actix-web', 'Actix Web'], ['axum', 'Axum'], ['tokio', 'Tokio'], ['rocket', 'Rocket']]) {
+    const match = new RegExp(`^${crate}\\s*=\\s*(?:"([^"]+)"|\\{[^}]*version\\s*=\\s*"([^"]+)")`, 'm').exec(cargo);
+    if (match) stack.add('frameworks', title, match[1] ?? match[2]);
+  }
+}
+
+function readRuby(stack, read) {
+  const gemfile = read('Gemfile');
+  if (!gemfile) return;
+  stack.add('languages', 'Ruby', /^ruby\s+["']([^"']+)/m.exec(gemfile)?.[1] ?? null);
+  const rails = /^gem\s+["']rails["'](?:\s*,\s*["']([^"']+))?/m.exec(gemfile);
+  if (rails) stack.add('frameworks', 'Rails', rails[1] ?? null);
+  if (/^gem\s+["']rspec/m.test(gemfile)) stack.add('tests', 'RSpec');
+}
+
+/** docker-compose и Dockerfile: образы баз и инфраструктуры с версиями из тегов. */
+function readContainers(stack, read) {
+  const compose = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'].map(read).filter(Boolean).join('\n');
+  const dockerfile = read('Dockerfile') ?? '';
+  if (!compose && !dockerfile) return;
+  stack.add('infra', 'Docker');
+  const images = [
+    ...compose.matchAll(/^\s*image:\s*["']?([\w./-]+?)(?::([\w.-]+))?["']?\s*$/gm),
+    ...dockerfile.matchAll(/^FROM\s+(?:--platform=\S+\s+)?([\w./-]+?)(?::([\w.-]+))?(?:\s|$)/gim),
+  ];
+  for (const [, image, tag] of images) {
+    const known = IMAGES.find(([pattern]) => pattern.test(image));
+    if (known) stack.add(known[1], known[2], tag && /^\d/.test(tag) ? tag : null);
+  }
+}
+
+// ------------------------------------------------------------- мелочи
+
+/** «^11.9.3», «>=8.2», «v20.11.0», «8.0-fpm» → «11.9», «8.2», «20.11», «8.0». */
+function shortVersion(version) {
+  const match = /(\d+)(?:\.(\d+))?/.exec(String(version ?? ''));
+  return match ? (match[2] !== undefined ? `${match[1]}.${match[2]}` : match[1]) : null;
+}
+
+function osName() {
+  if (process.platform === 'linux') return /microsoft/i.test(os.release()) ? 'Linux (WSL)' : 'Linux';
+  return { darwin: 'macOS', win32: 'Windows' }[process.platform] ?? process.platform;
+}
+
+function readText(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function json(text) {
+  try {
+    return text ? JSON.parse(text) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isDir(dir) {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/host/knowledge/transcript.js

@@ -0,0 +1,82 @@
+// Сжатая запись работы агента — то, что читает нейросеть, когда пишет урок. Шаги, ошибки
+// и итог; длинные выводы урезаны: урок пишется по ходу работы, а не по содержимому файлов.
+// Запись уходит модели того же поставщика, что уже видел эту работу целиком.
+
+import path from 'node:path';
+import { scrub } from './scrub.js';
+
+const MAX_TOTAL = 24_000;
+const MAX_COMMAND = 240;
+const MAX_OUTPUT = 400;
+const MAX_TEXT = 800;
+
+/**
+ * @param {string} engine движок
+ * @param {string} output построчный вывод агента
+ * @param {string[]} questions тексты обращений — с чего началась работа
+ */
+export function compactTranscript(engine, output, questions) {
+  const lines = [`Задача (сообщения в чате):\n${questions.map(q => `— ${clip(q, MAX_TEXT)}`).join('\n')}`, '', 'Ход работы:'];
+  const writer = WRITERS[engine];
+  if (writer) for (const event of events(output)) writer(event, line => lines.push(line));
+
+  let text = scrub(lines.join('\n'));
+  if (text.length > MAX_TOTAL) {
+    // Начало (задача, первые шаги) и конец (исправление, проверка, итог) важнее середины.
+    text = `${text.slice(0, MAX_TOTAL * 0.4)}\n…[пропущено]…\n${text.slice(-MAX_TOTAL * 0.6)}`;
+  }
+  return text;
+}
+
+const WRITERS = {
+  claude(event, write) {
+    for (const part of event.message?.content ?? []) {
+      if (part.type === 'text' && part.text?.trim()) write(`агент: ${clip(part.text, MAX_TEXT)}`);
+      if (part.type === 'tool_use' && part.name !== 'ToolSearch') write(`→ ${describeClaudeTool(part)}`);
+      if (part.type === 'tool_result') {
+        const out = typeof part.content === 'string' ? part.content
+          : (part.content ?? []).map(c => c?.text ?? '').join('\n');
+        write(`  ${part.is_error ? 'ошибка' : 'результат'}: ${clip(out, MAX_OUTPUT)}`);
+      }
+    }
+    if (event.type === 'result' && event.result) write(`итог: ${clip(event.result, MAX_TEXT)}`);
+  },
+
+  codex(event, write) {
+    if (event.type !== 'item.completed') return;
+    const item = event.item ?? {};
+    if (item.type === 'agent_message') write(`агент: ${clip(item.text, MAX_TEXT)}`);
+    if (item.type === 'command_execution') {
+      write(`→ команда: ${clip(item.command, MAX_COMMAND)}`);
+      write(`  код выхода ${item.exit_code}: ${clip(item.aggregated_output, MAX_OUTPUT)}`);
+    }
+    if (item.type === 'file_change') {
+      write(`→ правка файлов: ${(item.changes ?? []).map(c => `${path.basename(c.path ?? '')} (${c.kind})`).join(', ')}`);
+    }
+    if (item.type === 'mcp_tool_call') write(`→ инструмент чата: ${item.tool}`);
+  },
+};
+
+function describeClaudeTool(part) {
+  const input = part.input ?? {};
+  if (part.name === 'Bash') return `команда: ${clip(input.command, MAX_COMMAND)}`;
+  const file = input.file_path ?? input.path ?? input.notebook_path;
+  if (file) return `${part.name}: ${path.basename(file)}`;
+  if (input.pattern) return `${part.name}: ${clip(input.pattern, MAX_COMMAND)}`;
+  return part.name;
+}
+
+function clip(text, max) {
+  const flat = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return flat.length > max ? `${flat.slice(0, max)}…` : flat;
+}
+
+function* events(output) {
+  for (const line of String(output ?? '').split('\n')) {
+    try {
+      if (line.trim()) yield JSON.parse(line);
+    } catch {
+      // служебная строка движка
+    }
+  }
+}

package/host/lib/chat-api.js

@@ -0,0 +1,120 @@
+// Шлюз к HTTP API чата. Мост и раннер ходят в чат только через него: адреса, заголовки
+// и разбор ошибок — в одном месте.
+
+/** Чат не ответил: сеть, таймаут. Не сбой прохода, а повод подождать и повторить. */
+export class ChatUnavailableError extends Error {
+  constructor(reason, options) {
+    super(`чат недоступен (${reason})`, options);
+    this.reason = reason;
+  }
+}
+
+/** Чат ответил отказом. */
+export class ChatHttpError extends Error {
+  constructor(status, method, path, body) {
+    super(`чат ответил ${status} на ${method} ${path}`);
+    this.status = status;
+    this.body = body;
+  }
+}
+
+export class ChatApi {
+  #url;
+  #token;
+  #timeoutMs;
+
+  /** @param {{url: string, token: string, timeoutMs?: number}} options url — с /api на конце */
+  constructor({ url, token, timeoutMs = 30_000 }) {
+    this.#url = url.replace(/\/+$/, '');
+    this.#token = token;
+    this.#timeoutMs = timeoutMs;
+  }
+
+  // --- обращения: по всем чатам сразу, мост у агента один ---
+
+  async mentions() {
+    return (await this.#request('GET', '/mentions')).mentions;
+  }
+
+  /** Подтвердить обращение: гасит его. Чтение обращение не гасит — только это. */
+  async acknowledge(mentionId) {
+    await this.#request('POST', `/mentions/${mentionId}/handled`);
+  }
+
+  // --- лента и настройки чатов ---
+
+  /**
+   * Страница ленты чата: после afterId по возрастанию id, иначе последние limit.
+   * @param {string|null} chat slug; null — чат по умолчанию (сервер старше нескольких чатов)
+   */
+  async messages(chat, { afterId, limit } = {}) {
+    const query = new URLSearchParams();
+    if (afterId !== undefined) query.set('after_id', String(afterId));
+    if (limit !== undefined) query.set('limit', String(limit));
+    return (await this.#request('GET', `${scope(chat)}/messages?${query}`)).messages;
+  }
+
+  async chats() {
+    return (await this.#request('GET', '/chats')).chats;
+  }
+
+  // --- опыт агентов ---
+
+  /** Уроки, похожие на запрос: по всем чатам, уроки этого чата выше. */
+  async knowledge(chat, query, { limit = 3 } = {}) {
+    const params = new URLSearchParams({ q: query, limit: String(limit) });
+    return (await this.#request('GET', `${scope(chat)}/knowledge?${params}`)).lessons;
+  }
+
+  /** Карточка опыта запуска; та же запись запуска (key) обновляет ту же карточку. */
+  async saveCard(chat, key, card) {
+    await this.#request('POST', `${scope(chat)}/knowledge`, { key, card });
+  }
+
+  /** Ход обработки обращений: working | done | failed | deferred | paused. */
+  async report({ state, mentions, note, ttl }) {
+    const body = { state, mentions };
+    if (note) body.note = note.slice(0, 200);
+    if (ttl) body.ttl = ttl;
+    await this.#request('POST', '/activity', body);
+  }
+
+  // --- раннер: только для участника host ---
+
+  /** Агенты, которых раннер должен держать, с учётом движков этой машины. */
+  async runnerAgents(runtimes) {
+    return (await this.#request('GET', `/runner/agents?runtimes=${runtimes.map(encodeURIComponent).join(',')}`)).agents;
+  }
+
+  /** Токен агента для его моста. Постоянный токен агента при этом не меняется. */
+  async agentToken(handle) {
+    return (await this.#request('POST', `/runner/agents/${encodeURIComponent(handle)}/token`)).token;
+  }
+
+  async #request(method, path, body) {
+    let response;
+    try {
+      response = await fetch(this.#url + path, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.#token}`,
+          Accept: 'application/json',
+          ...(body ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(this.#timeoutMs),
+      });
+    } catch (e) {
+      throw new ChatUnavailableError(e.cause?.code ?? e.cause?.message ?? e.message, { cause: e });
+    }
+
+    const text = await response.text();
+    if (!response.ok) throw new ChatHttpError(response.status, method, path, text);
+    return text ? JSON.parse(text) : {};
+  }
+}
+
+/** Префикс API чата. Без чата пути ведут в чат по умолчанию — так было, пока чат был один. */
+function scope(chat) {
+  return chat ? `/chats/${encodeURIComponent(chat)}` : '';
+}

package/host/lib/log.js

@@ -0,0 +1,6 @@
+// Журнал процесса: время и сообщение в stderr. В файл его направляет тот, кто запустил
+// процесс, — юнит systemd или раннер.
+
+export function log(...parts) {
+  console.error(new Date().toTimeString().slice(0, 8), ...parts);
+}

package/host/lib/pid-lock.js

@@ -0,0 +1,65 @@
+// Замок «один процесс на файл»: файл с pid держателя.
+//
+// Мосту он нужен, чтобы на одного агента был один мост: два моста видят одно и то же
+// открытое обращение и оба запускают агента (так 27.09 на #95 Codex запустился дважды).
+//
+// flock в Node нет, поэтому замок сам не снимается со смертью процесса: занятый файл
+// с pid мёртвого процесса считается брошенным и забирается. Окно гонки остаётся только
+// между двумя процессами, которые в одну и ту же миллисекунду забирают один брошенный
+// замок, — для мостов, которые запускает раннер или systemd, такого не бывает.
+
+import fs from 'node:fs';
+
+export class LockBusyError extends Error {
+  constructor(file, pid) {
+    super(`${file} занят процессом ${pid}`);
+    this.pid = pid;
+  }
+}
+
+export class PidLock {
+  #file;
+
+  constructor(file) {
+    this.#file = file;
+  }
+
+  /** @throws {LockBusyError} если держатель жив */
+  static acquire(file) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        fs.writeFileSync(file, String(process.pid), { flag: 'wx' });
+        return new PidLock(file);
+      } catch (e) {
+        if (e.code !== 'EEXIST') throw e;
+      }
+      const holder = readPid(file);
+      if (holder !== null && isAlive(holder)) throw new LockBusyError(file, holder);
+      fs.rmSync(file, { force: true });
+    }
+    throw new LockBusyError(file, readPid(file));
+  }
+
+  /** Отпустить, если замок всё ещё наш. */
+  release() {
+    if (readPid(this.#file) === process.pid) fs.rmSync(this.#file, { force: true });
+  }
+}
+
+function readPid(file) {
+  try {
+    const pid = Number.parseInt(fs.readFileSync(file, 'utf8').trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM'; // процесс есть, но чужой
+  }
+}

package/host/lib/shell-words.js

@@ -0,0 +1,45 @@
+// Командная строка агента из runner.json → слова для spawn. Оболочку не зовём: кавычки
+// и обратная косая работают как в POSIX-оболочке, а подстановки ($, `, *) — нет.
+// Те же правила, что у shlex.split в Python, которым это делал мост раньше.
+
+export class ShellWordsError extends Error {}
+
+/** @returns {string[]} */
+export function splitWords(line) {
+  const words = [];
+  let word = null; // null — слова ещё нет; '' — есть, но пустое ("")
+  let quote = null;
+
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+
+    if (quote === "'") {
+      if (c === "'") quote = null;
+      else word += c;
+    } else if (quote === '"') {
+      if (c === '"') quote = null;
+      // Внутри двойных кавычек косая экранирует только кавычку и саму себя.
+      else if (c === '\\' && (line[i + 1] === '"' || line[i + 1] === '\\')) word += line[++i];
+      else word += c;
+    } else if (/\s/.test(c)) {
+      if (word !== null) words.push(word);
+      word = null;
+    } else {
+      word ??= '';
+      if (c === "'" || c === '"') quote = c;
+      else if (c === '\\') {
+        if (i + 1 === line.length) throw new ShellWordsError(`команда кончается обратной косой: ${line}`);
+        word += line[++i];
+      } else word += c;
+    }
+  }
+
+  if (quote) throw new ShellWordsError(`незакрытая кавычка ${quote} в команде: ${line}`);
+  if (word !== null) words.push(word);
+  return words;
+}
+
+/** Слово в одинарных кавычках — обратное к splitWords. */
+export function quoteWord(word) {
+  return /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+}

package/host/runner/bridge-process.js

@@ -0,0 +1,82 @@
+// Мост одного агента — дочерний процесс раннера со своей группой процессов. Агент,
+// которого запускает мост, живёт в той же группе, поэтому остановка моста гасит и его:
+// иначе агент остался бы сиротой и дописал бы ответ от имени остановленного моста.
+
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+
+/** Сколько ждать мост после SIGTERM, прежде чем убить. */
+const GRACE_MS = 20_000;
+
+export class BridgeProcess {
+  #child;
+  #exit;
+  #exitCode = null;
+
+  /**
+   * @param {object} p
+   * @param {string} p.handle
+   * @param {string} p.runtime движок, на котором запущен агент
+   * @param {string[]} p.command
+   * @param {NodeJS.ProcessEnv} p.env
+   * @param {string} p.logFile вывод моста дописывается сюда
+   * @param {number} p.startedAt
+   */
+  constructor({ handle, runtime, command, env, logFile, startedAt }) {
+    this.handle = handle;
+    this.runtime = runtime;
+    this.startedAt = startedAt;
+
+    const out = fs.openSync(logFile, 'a');
+    try {
+      const [cmd, ...args] = command;
+      this.#child = spawn(cmd, args, { env, stdio: ['ignore', out, out], detached: true });
+    } finally {
+      fs.closeSync(out);
+    }
+    this.#exit = new Promise(resolve => {
+      // Не запустился (error) или завершился (exit) — для раннера одно: моста нет.
+      const done = code => {
+        this.#exitCode ??= code;
+        resolve();
+      };
+      this.#child.once('error', () => done(127));
+      this.#child.once('exit', (code, signal) => done(code ?? signal));
+    });
+  }
+
+  get pid() {
+    return this.#child.pid;
+  }
+
+  /** Код выхода или сигнал, пока мост жив — null. */
+  get exitCode() {
+    return this.#exitCode;
+  }
+
+  alive() {
+    return this.#exitCode === null;
+  }
+
+  async stop() {
+    if (!this.alive()) return;
+    this.#signal('SIGTERM');
+    const timer = setTimeout(() => this.#signal('SIGKILL'), GRACE_MS);
+    await this.#exit;
+    clearTimeout(timer);
+  }
+
+  #signal(signal) {
+    // На Windows групп процессов нет: дерево моста гасит taskkill, сразу и насмерть.
+    if (process.platform === 'win32') {
+      spawnSync('taskkill', ['/pid', String(this.#child.pid), '/T', '/F'], { stdio: 'ignore' });
+      return;
+    }
+    try {
+      // Минус — вся группа: мост и его агент.
+      process.kill(-this.#child.pid, signal);
+    } catch {
+      // уже нет
+    }
+  }
+}