dsh-edt-projects 0.12.0 → 0.12.1

package/README.md

@@ -14,8 +14,14 @@ SonarQube/GitLab.
 В **linked git worktree** плагин поднимает отдельное окружение EDT
 (`<worktree>/build/ws`, свой порт и логи), импортирует проекты и монтирует
 `mcp__edt__*` туда; включённость и настройки наследуются от основного checkout.
+Работает совместно с [dsh-git-worktree](https://github.com/LaoYueHanNi/dsh-git-worktree)
+(`<repo>/.dsh/gitworktree/<branch>/`), `build/` не требует ручной настройки.
 Управление — инструмент `edt_workspace`.
 
+В workspace включаются plain text mode (DSH не рендерит embedded resource) и
+`get_form_screenshot` с JVM-флагом `-DnativeFormBufferedLayoutRender=true`;
+выключаются настройками `workspace.plainText` и `workspace.formScreenshots`.
+
 ## Установка
 
 ```text

package/lib/index.js

@@ -44,7 +44,7 @@ import { normalizeTestTooling } from './tests.mjs';
 import { initFile, upgradeFile } from './config-file.mjs';
 import { stringifyConfig, validateConfig } from './schema.mjs';
 import { createSkillsProvider } from './skills.mjs';
-import { repositoriesUnder } from './repo.mjs';
+import { repositoriesUnder, repositoryAt, resolveContextCwd } from './repo.mjs';
 import {
   BUILD_DIR,
   detectEdtHome,
@@ -54,16 +54,20 @@ import {
   pickFreePort,
   pidAlive,
   prepareWorkspaceSnapshot,
+  prefValue,
   probeHealth,
   readPort,
+  readPrefs,
   removeStamp,
+  requiredJava,
+  resolveEdtVm,
   resolveWorkspaceTarget,
   stateOf as workspaceState,
+  tailFile,
   writePort,
   writeStamp,
-  writeWorkspaceSnapshot,
 } from './workspace.mjs';
-import { cmdStop as stopWorkspaceNow } from './workspace-run.mjs';
+import { cmdInit, cmdStop as stopWorkspaceNow, lockState } from './workspace-run.mjs';
 
 const HEADER = `## Работа с 1С через MCP
 
@@ -393,7 +397,20 @@ export async function apply(ctx, config) {
   const loggedErrors = new Set();
   let skillsControl;
 
-  const cwdOf = (agent) => sessionCwd(agent, ctx.workingDirectory);
+  const originCwdOf = (agent) => sessionCwd(agent, ctx.workingDirectory);
+  const workCwdOf = (agent) => {
+    const session = agent?.session;
+    if (session === undefined) return originCwdOf(agent);
+    try {
+      const dir = ctx.workingDirectory?.get?.(session);
+      return typeof dir === 'string' && dir !== '' ? dir : originCwdOf(agent);
+    } catch {
+      return originCwdOf(agent);
+    }
+  };
+  // Контекст сессии — эффективный каталог, если это worktree того же проекта.
+  const cwdOf = (agent) =>
+    resolveContextCwd({ origin: originCwdOf(agent), work: workCwdOf(agent) });
 
   /** Уникальные пути в порядке появления (для слоёв настроек и allowlist). */
   const uniquePaths = (values) => {
@@ -448,7 +465,24 @@ export async function apply(ctx, config) {
     return { cwd, repositories, enabledRepositories, paths, effective, activation, workspace };
   };
 
-  const contextFor = (agent) => projectContextForCwd(cwdOf(agent));
+  const contextFor = (agent) => {
+    const base = projectContextForCwd(cwdOf(agent));
+    const override = agent === undefined ? undefined : agentStates.get(agent)?.workspaceRoot;
+    if (override === undefined) return base;
+
+    const repo = repositoryAt(override);
+    const repositories =
+      repo === undefined
+        ? [{ root: override, mainRoot: base.workspace?.mainRoot ?? override, isWorktree: true }]
+        : [{ ...repo, isWorktree: true }];
+    const workspace = resolveWorkspaceTarget({
+      cwd: override,
+      config: base.effective.config,
+      repositories,
+      env: process.env,
+    });
+    return { ...base, cwd: override, repositories, workspace, workspaceOverride: true };
+  };
   const effectiveFor = (agent) => contextFor(agent).effective;
 
   /** Каталог, от которого считается корень BSL и относительный workspace.root. */
@@ -485,6 +519,7 @@ export async function apply(ctx, config) {
       phase: phase?.phase,
       since: phase?.since,
       detail: phase?.detail,
+      warning: phase?.warning,
       imported: current.imported?.projects?.length,
       settings: plan.settings,
       warnings: plan.warnings ?? [],
@@ -559,6 +594,11 @@ export async function apply(ctx, config) {
       if (entry.unavailable) value = 'unavailable';
       if (item?.fiber && !item.error) value = 'mounted';
       if (item?.error) value = 'failed';
+      // Пока EDT-окружение не готово, mounted с нулём инструментов выглядит
+      // как поломка: показываем фазу подъёма.
+      if (entry.name === 'edt' && item?.fiber && !item.error && workspace.state === 'worktree' && workspace.status !== 'ready') {
+        value = workspace.status === 'failed' || workspace.status === 'stale' ? 'failed' : 'starting';
+      }
       return {
         name: entry.name,
         state: value,
@@ -777,6 +817,25 @@ export async function apply(ctx, config) {
     return Date.now() - updated < budget;
   };
 
+  /** Убеждается, что фоновый run действительно начал работу (а не упал на lock). */
+  const launchStarted = async (buildDir, settings = {}, timeoutMs = 5000) => {
+    // Тот же срок устаревания, что в cmdInit/cmdRun: иначе lock, который они
+    // уже считают осиротевшим, здесь выглядел бы как живой запуск.
+    const maxAgeMs = (Math.max(settings.startTimeout ?? 1800, settings.importTimeout ?? 3600) + 600) * 1000;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const current = workspaceState(buildDir, { alive: cheapAlive });
+      const phase = current.progress?.edt?.phase;
+      if (current.label === 'starting' || current.label === 'ready' || current.label === 'failed') return true;
+      if (phase !== undefined && phase !== 'ready' && phase !== 'failed') return true;
+      // run мог только взяться за lock, ещё не записав ни progress, ни pid.
+      const runLock = lockState(join(buildDir, 'init-run.lock'), { maxAgeMs });
+      if (runLock.exists === true && runLock.stale === false) return true;
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return false;
+  };
+
   /**
    * Гарантирует подъём окружения: занимает порт, пишет снимок и запускает
    * фоновый init. Готовое/стартующее окружение только принимается.
@@ -835,9 +894,23 @@ export async function apply(ctx, config) {
           settings: plan.settings,
         });
         if (options.import === true) workspaceSnapshot.forceImport = true;
-        writeWorkspaceSnapshot(key, workspaceSnapshot);
+        const initLog = join(key, 'logs', 'init.log');
+        const code = await cmdInit(plan.root, {}, { snapshot: workspaceSnapshot });
+        if (code !== 0) {
+          const tail = tailFile(initLog);
+          return {
+            ...workspaceState(key, { alive: cheapAlive }),
+            launchError: `init завершился с кодом ${code}${tail === null ? '' : `: ${tail}`}`,
+          };
+        }
         record.startedByUs = true;
-        spawnInitializer(plan.root, 'init');
+        if (!(await launchStarted(key, plan.settings))) {
+          const tail = tailFile(initLog);
+          return {
+            ...workspaceState(key, { alive: cheapAlive }),
+            launchError: `run не стартовал${tail === null ? '' : `: ${tail}`}`,
+          };
+        }
         return workspaceState(key, { alive: cheapAlive });
       } catch (error) {
         ctx.logger?.warn?.(`mcp-hub: окружение EDT не поднялось: ${error instanceof Error ? error.message : String(error)}`);
@@ -874,7 +947,8 @@ export async function apply(ctx, config) {
     // Окружение поднимается до монтирования edt: нужен порт для адреса.
     if (context.workspace.state === 'ok') {
       try {
-        await ensureWorkspace(agent, context);
+        const launched = await ensureWorkspace(agent, context);
+        if (launched?.launchError !== undefined) ctx.logger?.warn?.(`mcp-hub: ${launched.launchError}`);
       } catch (error) {
         ctx.logger?.warn?.(`mcp-hub: окружение EDT не поднялось: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -894,6 +968,7 @@ export async function apply(ctx, config) {
     const state = agentStates.get(agent);
     if (state === undefined || !state.active) return;
     state.active = false;
+    state.workspaceRoot = undefined;
     for (const dispose of state.disposers.splice(0)) {
       try {
         dispose();
@@ -924,7 +999,8 @@ export async function apply(ctx, config) {
     }
 
     if (context.workspace.state === 'ok') {
-      await ensureWorkspace(agent, context);
+      const launched = await ensureWorkspace(agent, context);
+      if (launched?.launchError !== undefined) ctx.logger?.warn?.(`mcp-hub: ${launched.launchError}`);
       // Порт появился после init — адрес edt изменился, перемонтируем.
       try {
         await reload(agent, 'edt');
@@ -1084,13 +1160,35 @@ export async function apply(ctx, config) {
     }
     if (info.imported !== undefined) lines.push(`Импортировано проектов: ${info.imported}`);
     const home = detectEdtHome(info.settings, { platform: process.platform, env: process.env });
-    lines.push(
-      `EDT: ${home.home ?? 'не найден'}${home.error === undefined ? '' : ` — ${home.error}`}${home.mcpBundle === false ? ' (бандл EDT-MCP не найден в plugins/features)' : ''}`,
-    );
+    const required = requiredJava(home.home, { platform: process.platform });
+    const vm = resolveEdtVm(info.settings, home.home, { platform: process.platform, env: process.env });
+    lines.push(`EDT: ${home.home ?? 'не найден'}${home.error === undefined ? '' : ` — ${home.error}`}`);
+    lines.push(`Java: ${vm ?? 'авто'}${required.major === undefined ? '' : ` (EDT требует ${required.major})`}`);
+    if (info.status !== 'ready') {
+      if (home.mcpBundle === false) {
+        lines.push('EDT-MCP: по файлам не подтверждён; готовность проверит /health');
+      } else if (Array.isArray(home.mcpEvidence) && home.mcpEvidence.length > 0) {
+        lines.push(`EDT-MCP: ${home.mcpEvidence[0]}`);
+      }
+    }
     const importMode = info.settings.import;
     lines.push(`Импорт проектов: ${importMode === true ? 'да' : importMode === false ? 'нет' : 'авто (если workspace пуст)'}`);
+    lines.push(`Plain text: ${info.settings.plainText === false ? 'нет' : 'да'}; скриншоты форм: ${info.settings.formScreenshots === false ? 'нет' : 'да'}`);
+    const prefsText = readPrefs(info.buildDir);
+    const plainPref = prefsText === undefined ? undefined : prefValue(prefsText, 'mcpPlainTextMode');
+    lines.push(
+      `Plain text в prefs: ${prefsText === undefined ? 'файла ещё нет' : plainPref === undefined ? 'ключа нет' : plainPref === 'true' ? 'да' : 'нет'}`,
+    );
+    if (prefsText !== undefined && info.settings.plainText !== false && plainPref !== 'true') {
+      lines.push('! prefs не содержат mcpPlainTextMode=true — выполните restart окружения');
+    }
+    if (info.warning !== undefined) {
+      const warning = info.warning;
+      const memory = warning.used === undefined ? '' : ` (${warning.used}/${warning.total} MB)`;
+      lines.push(`! импорт шёл на пределе памяти${memory} — поднимите workspace.xmxImport`);
+    }
     for (const warning of info.warnings) lines.push(`! ${warning}`);
-    lines.push(`Логи: ${join(info.buildDir, 'logs')}`);
+    lines.push(`Логи: ${join(info.buildDir, 'logs')}; импорт: ${join(info.wsDir, '.metadata', '.log')}`);
     return lines.join('\n');
   };
 
@@ -1115,6 +1213,9 @@ export async function apply(ctx, config) {
         if (plan === undefined || plan.state !== 'ok') {
           throw new Error(`EDT-окружение недоступно: ${plan?.message ?? workspaceText(plan)}`);
         }
+        // root=… не только поднимает окружение, но и становится контекстом
+        // сессии: entriesFor подменит URL edt на порт этого workspace.
+        if (args.root !== undefined && args.root !== '') stateOf(exec?.agent).workspaceRoot = plan.root;
         const record = registerWorkspaceSession(plan.buildDir, exec?.agent, plan.settings);
 
         if (action === 'stop') {
@@ -1137,6 +1238,16 @@ export async function apply(ctx, config) {
         const forceImport = args.import === true || action === 'import';
         const result = await ensureWorkspace(exec?.agent, { ...context, workspace: plan }, { force: true, import: forceImport });
         if (result === undefined) throw new Error('Не удалось запустить подъём окружения: смотрите логи build/logs.');
+        if (result.launchError !== undefined) throw new Error(`${result.launchError}\n\n${workspaceText(plan)}`);
+        if (result.label === 'failed') {
+          const info = describeWorkspace(plan, { alive: cheapAlive });
+          const warning = info.warning;
+          const memory =
+            warning === undefined
+              ? ''
+              : `\n! импорт шёл на пределе памяти${warning.used === undefined ? '' : ` (${warning.used}/${warning.total} MB)`} — поднимите workspace.xmxImport`;
+          throw new Error(`EDT-окружение не поднялось: ${info.detail ?? 'см. build/logs/edt.log'}${memory}`);
+        }
         if (result.label === 'ready') {
           return { text: `EDT уже готов (порт ${result.port ?? '-'}).\n\n${workspaceText(plan)}` };
         }
@@ -1181,6 +1292,11 @@ export async function apply(ctx, config) {
           const { errors, warnings } = validateConfig(effective.config);
           const activation = context.activation;
           const workspace = describeWorkspace(context.workspace, { alive: cheapAlive });
+          const origin = originCwdOf(exec?.agent);
+          const dirsLine =
+            origin === context.cwd
+              ? `Каталог: ${context.cwd}`
+              : `Каталог: исходный ${origin}, рабочий ${context.cwd}${context.workspaceOverride === true ? ' (через edt_workspace root)' : ''}`;
           const workspaceLine =
             workspace.state === 'worktree'
               ? `EDT-окружение worktree: ${workspace.status}, порт ${workspace.port ?? '-'}, ${workspace.root}`
@@ -1189,6 +1305,7 @@ export async function apply(ctx, config) {
                 : 'EDT-окружение worktree: выключено (поднимается только в git worktree)';
           const head = [
             `Проект: ${activation.enabled ? 'включён' : 'выключен'} — ${activationReason(activation)}`,
+            dirsLine,
             `Источники: ${effective.sources.length > 0 ? effective.sources.join(', ') : 'только cordis.patch.yml'}`,
             workspaceLine,
             `Действующие настройки:\n${stringifyConfig(effective.config)}`,

package/lib/repo.mjs

@@ -11,7 +11,7 @@
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 
-import { normalizeProjectPath } from './enable.mjs';
+import { normalizeProjectPath, matchesProject } from './enable.mjs';
 
 /** Сколько родителей просматривать в поисках `.git`. */
 const MAX_UP = 8;
@@ -151,3 +151,35 @@ export function uniqueRepositories(repositories, { platform = process.platform }
   }
   return out;
 }
+
+/**
+ * Каталог, от которого плагин считает проект.
+ *
+ * `origin` — неизменяемый `session.header.cwd`, `work` — эффективный каталог
+ * сессии (`ctx.workingDirectory`). Переключаемся на work только если это
+ * linked worktree, связанный с исходным репозиторием: `cd` в подкаталог или в
+ * чужой репозиторий проект не переключает, а worktree того же репозитория —
+ * переключает. Возвращается корень worktree, а не подкаталог, чтобы настройки
+ * и окружение не зависели от `cd` внутри него.
+ * @returns {string} абсолютный каталог проекта.
+ */
+export function resolveContextCwd({ origin, work, platform = process.platform } = {}) {
+  if (typeof origin !== 'string' || origin === '') {
+    return typeof work === 'string' && work !== '' ? work : process.cwd();
+  }
+  if (typeof work !== 'string' || work === '' || isSamePath(work, origin, { platform })) return origin;
+
+  const workRepo = repositoryAt(work, { platform });
+  if (workRepo === undefined || workRepo.isWorktree !== true) return origin;
+
+  const originRepo = repositoryAt(origin, { platform });
+  if (originRepo === undefined) return origin;
+
+  const related =
+    isSamePath(workRepo.mainRoot, originRepo.root, { platform }) ||
+    isSamePath(workRepo.mainRoot, origin, { platform }) ||
+    matchesProject(originRepo.root, workRepo.mainRoot, { platform }) ||
+    matchesProject(origin, workRepo.mainRoot, { platform });
+
+  return related ? workRepo.root : origin;
+}

package/lib/schema.mjs

@@ -33,6 +33,10 @@ export const DEFAULTS = {
     projects: [],
     ports: { min: 20000, max: 39999 },
     stopOnSessionEnd: true,
+    // MCP-инструменты EDT-MCP, которые нам нужны в worktree: plain text
+    // вместо embedded resource (DSH их не рендерит) и скриншоты форм.
+    plainText: true,
+    formScreenshots: true,
   },
   tests: {
     yaxunit: { enabled: false, path: '', project: '' },
@@ -53,12 +57,24 @@ export const KNOWN = {
   'servers.*.url': { type: 'string', description: 'Адрес MCP-сервера (streamable-http).' },
   'servers.*.headers': { type: 'object', description: 'Заголовки запросов, например Authorization.' },
   'servers.*.root': { type: 'string', description: 'Корень рабочего пространства (для bsl).' },
+  'servers.*.transport': { type: 'string', description: 'Транспорт: stdio или streamable-http.' },
+  'servers.*.disabled': { type: 'boolean', description: 'Не монтировать сервер.' },
+  'servers.*.unavailable': { type: 'boolean', description: 'Сервер описан, но не настроен (нет переменных окружения).' },
+  'servers.*.command': { type: 'string', description: 'Команда запуска для stdio-сервера.' },
+  'servers.*.args': { type: 'array', description: 'Аргументы команды stdio-сервера.' },
+  'servers.*.env': { type: 'object', description: 'Переменные окружения stdio-сервера.' },
+  'servers.*.cwd': { type: 'string', description: 'Рабочий каталог stdio-сервера.' },
+  'servers.*.maxInstructionBytes': { type: 'number', description: 'Предел текста инструкций сервера.' },
   'servers.*.lazy': { type: 'boolean', description: 'Не подключать на старте, только по edt_pin.' },
   'servers.*.shared': { type: 'boolean', description: 'Устарело: серверы всегда монтируются в скоупе сессии.' },
   'servers.*.provision': { type: 'boolean', description: 'Параметры запуска добираются на edt_pin.' },
   'servers.*.toolCallTimeoutMs': { type: 'number', description: 'Таймаут вызова инструмента.' },
   'servers.*.failOnStartupError': { type: 'boolean', description: 'Падать, если стартовое подключение не удалось.' },
   'servers.*.reconnect': { type: 'object', description: 'Политика переподключения.' },
+  'servers.*.reconnect.enabled': { type: 'boolean', description: 'Включено ли переподключение.' },
+  'servers.*.reconnect.initialDelayMs': { type: 'number', description: 'Начальная задержка переподключения, мс.' },
+  'servers.*.reconnect.maxDelayMs': { type: 'number', description: 'Максимальная задержка переподключения, мс.' },
+  'servers.*.reconnect.maxAttempts': { type: 'number', description: 'Максимум попыток переподключения.' },
   'servers.bsl.jar': { type: 'string', description: 'Готовый jar BSL Language Server.' },
   'servers.bsl.url': { type: 'string', description: 'Прямой URL на jar вместо GitHub.' },
   'servers.bsl.version': { type: 'string', description: 'Тег релиза BSL LS, например v1.0.7.' },
@@ -86,6 +102,8 @@ export const KNOWN = {
   'workspace.ports.min': { type: 'number', description: 'Нижняя граница диапазона портов.' },
   'workspace.ports.max': { type: 'number', description: 'Верхняя граница диапазона портов.' },
   'workspace.stopOnSessionEnd': { type: 'boolean', description: 'Останавливать EDT, когда закрылась последняя сессия на этом worktree.' },
+  'workspace.plainText': { type: 'boolean', description: 'Plain text mode EDT-MCP вместо embedded resource (DSH их не рендерит).' },
+  'workspace.formScreenshots': { type: 'boolean', description: 'Включить get_form_screenshot и JVM-флаг nativeFormBufferedLayoutRender.' },
   'tests.yaxunit.enabled': { type: 'boolean', description: 'Включить правила тестируемости YAxUnit.' },
   'tests.yaxunit.path': { type: 'string', description: 'Каталог тестов как образец стиля.' },
   'tests.yaxunit.project': { type: 'string', description: 'EDT-проект, в который писать тесты.' },
@@ -217,6 +235,15 @@ export function validateConfig(config) {
     errors.push('projects: ожидался массив строк');
   }
 
+  if (isPlainObject(config.servers)) {
+    for (const [name, server] of Object.entries(config.servers)) {
+      if (!isPlainObject(server)) continue;
+      if (Array.isArray(server.args) && !server.args.every((item) => typeof item === 'string')) {
+        errors.push(`servers.${name}.args: ожидался массив строк`);
+      }
+    }
+  }
+
   if (isPlainObject(config.workspace)) {
     const workspace = config.workspace;
     if (workspace.import !== undefined && ![true, false, 'auto'].includes(workspace.import)) {

package/lib/workspace-run.mjs

@@ -14,12 +14,13 @@
 // Все зависимости, которые трогают процессы и время, передаются через `deps` —
 // так сценарии проверяются без запуска настоящего EDT.
 import { execFile, execFileSync, spawn } from 'node:child_process';
-import { closeSync, mkdirSync, openSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { closeSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { promisify } from 'node:util';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import {
+  appendImportDigest,
   buildWorkspaceSnapshot,
   clearProgress,
   detectEdtHome,
@@ -28,6 +29,8 @@ import {
   formatElapsed,
   guiArgs,
   importArgs,
+  importDigest,
+  importMemoryWarning,
   importScriptText,
   isPortFree,
   killTree,
@@ -40,6 +43,7 @@ import {
   readPort,
   readWorkspaceSnapshot,
   registeredProjectsDir,
+  requiredJava,
   resolveEdtVm,
   stateOf,
   tailFile,
@@ -134,25 +138,70 @@ function lockInfo(file) {
   }
 }
 
-/** Захватывает lock; чужой живой lock — сигнал «уже идёт». */
+/** Сколько живёт lock без обновления, если владелец не отвечает. */
+const LOCK_MAX_AGE_MS = 6 * 60 * 60_000;
+
+/** Состояние lock для диагностики: живой ли pid, возраст, просрочен ли. */
+export function lockState(file, deps = {}) {
+  const info = lockInfo(file);
+  if (info === null) return { exists: false };
+  const pid = Number.parseInt(info.pid, 10);
+  const at = Date.parse(info.at ?? '');
+  const ageMs = Number.isNaN(at) ? undefined : Math.max(0, Date.now() - at);
+  const maxAgeMs = deps.maxAgeMs ?? LOCK_MAX_AGE_MS;
+  const alive = deps.alive ?? ((value) => pidAlive(value));
+  const live = Number.isInteger(pid) && pid > 0 && alive(pid);
+  return {
+    exists: true,
+    pid: Number.isInteger(pid) ? pid : undefined,
+    at: Number.isNaN(at) ? undefined : new Date(at).toISOString(),
+    ageMs,
+    stale: !live || (ageMs !== undefined && ageMs > maxAgeMs),
+  };
+}
+
+/**
+ * Захватывает lock. Чужой lock считается stale, если pid не жив, образ не
+ * совпадает (`image`) или возраст больше `maxAgeMs`; stale перехватывается.
+ */
 export function acquireLock(file, deps = {}) {
   mkdirSync(path.dirname(file), { recursive: true });
   const alive = deps.alive ?? ((pid) => pidAlive(pid));
-  const existing = lockInfo(file);
-  if (existing?.pid !== undefined) {
-    if (alive(existing.pid)) return false;
+  const image = deps.image;
+  const maxAgeMs = deps.maxAgeMs ?? LOCK_MAX_AGE_MS;
+  const now = deps.now?.() ?? new Date();
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const existing = lockInfo(file);
+    if (existing !== null) {
+      const pid = Number.parseInt(existing.pid, 10);
+      const at = Date.parse(existing.at ?? '');
+      const tooOld = !Number.isNaN(at) && now.getTime() - at > maxAgeMs;
+      const live = Number.isInteger(pid) && pid > 0 && alive(pid);
+      const sameImage = live && (image === undefined || pidAlive(pid, [image]));
+      if (live && sameImage && !tooOld) return false;
+      try {
+        unlinkSync(file);
+      } catch {
+        // lock мог исчезнуть между чтением и удалением
+      }
+    }
     try {
-      unlinkSync(file);
+      writeFileSync(
+        file,
+        JSON.stringify({
+          pid: process.pid,
+          at: now.toISOString(),
+          image: path.basename(process.execPath),
+        }),
+        { flag: 'wx' },
+      );
+      return true;
     } catch {
-      // lock мог уже исчезнуть
+      // кто-то успел создать lock — повторим проверку
     }
   }
-  try {
-    writeFileSync(file, JSON.stringify({ pid: process.pid, at: new Date().toISOString() }), { flag: 'wx' });
-    return true;
-  } catch {
-    return false;
-  }
+  return false;
 }
 
 export function releaseLock(file) {
@@ -233,25 +282,54 @@ export async function cmdInit(root, args = {}, deps = {}) {
   mkdirSync(buildDir, { recursive: true });
   writeWorkspaceSnapshot(buildDir, snapshot);
 
-  const state = stateOf(buildDir, { alive: deps.alive });
-  if (state.label === 'ready' || state.label === 'starting') {
-    logTo(buildDir, `init: окружение уже ${state.label === 'ready' ? 'готово' : 'поднимается'}, делать нечего`);
-    return 0;
-  }
-
   const lock = filePath(buildDir, 'lock');
   if (!acquireLock(lock, deps)) {
     logTo(buildDir, 'init: другой процесс уже занимает порт, выходим');
     return 0;
   }
   try {
+    // Осиротевший run-lock не должен блокировать повторный init.
+    const runLock = filePath(buildDir, 'runLock');
+    const maxAgeMs = (Math.max(snapshot.settings.startTimeout, snapshot.settings.importTimeout) + 600) * 1000;
+    const running = lockState(runLock, { ...deps, maxAgeMs });
+    if (running.exists && running.stale !== true) {
+      logTo(buildDir, `init: run уже идёт (pid ${running.pid ?? '?'}, возраст ${running.ageMs === undefined ? '?' : formatElapsed(new Date(Date.now() - running.ageMs).toISOString())})`);
+      return 4;
+    }
+    if (running.exists) {
+      try {
+        unlinkSync(runLock);
+      } catch {
+        // lock уже исчез
+      }
+      logTo(buildDir, 'init: снят осиротевший run-lock');
+    }
+
+    const state = stateOf(buildDir, { alive: deps.alive });
+    if (state.label === 'ready') {
+      logTo(buildDir, 'init: окружение уже готово, делать нечего');
+      return 0;
+    }
+    const alive = deps.alive ?? ((pid) => pidAlive(pid, ['1cedt']));
+    if (state.label === 'starting' && state.pid !== null && alive(state.pid.pid)) {
+      logTo(buildDir, 'init: окружение уже поднимается, делать нечего');
+      return 0;
+    }
+    if (state.label === 'starting') {
+      // Осталась только запись прогресса от упавшего run: начинаем заново.
+      clearProgress(buildDir);
+    }
+
     let port = readPort(buildDir);
     const free = deps.isPortFree ?? isPortFree;
     if (port === null || !(await free(port))) {
       port = await (deps.pickFreePort ?? pickFreePort)(snapshot.settings.ports, { isFree: free });
       writePort(buildDir, port);
     }
-    const prefs = writePrefs(buildDir, port);
+    const prefs = writePrefs(buildDir, port, {
+      plainText: snapshot.settings.plainText,
+      formScreenshots: snapshot.settings.formScreenshots,
+    });
     logTo(buildDir, `init: порт ${port}, prefs ${path.relative(root, prefs)}, запускаю run в фоне`);
     const logPath = path.join(buildDir, 'logs', 'init.log');
     (deps.spawnDetached ?? spawnDetached)(process.execPath, [SELF, 'run', '--root', root], logPath, root, deps);
@@ -277,9 +355,11 @@ export async function cmdRun(root, args = {}, deps = {}) {
   mkdirSync(path.join(buildDir, 'logs'), { recursive: true });
 
   const lock = filePath(buildDir, 'runLock');
-  if (!acquireLock(lock, deps)) {
-    log('run: другой запуск уже идёт, выходим');
-    return 0;
+  const maxAgeMs = (Math.max(settings.startTimeout, settings.importTimeout) + 600) * 1000;
+  if (!acquireLock(lock, { ...deps, maxAgeMs, image: path.basename(process.execPath) })) {
+    const holder = lockState(lock, { ...deps, maxAgeMs });
+    log(`run: другой запуск уже идёт (pid ${holder.pid ?? '?'}, возраст ${holder.ageMs === undefined ? '?' : `${Math.round(holder.ageMs / 1000)}s`}), выходим`);
+    return 2;
   }
 
   try {
@@ -297,7 +377,11 @@ export async function cmdRun(root, args = {}, deps = {}) {
       return 1;
     }
     if (detected.mcpBundle !== true) {
-      log('edt: предупреждение — в установке не найден бандл EDT-MCP (проверьте plugins/features)');
+      // Это только файловая эвристика: бандл может стоять в пользовательской
+      // configuration area, а готовность подтверждает /health.
+      log('edt: EDT-MCP не подтверждён по файлам; готовность проверит /health');
+    } else if (Array.isArray(detected.mcpEvidence) && detected.mcpEvidence.length > 0) {
+      log(`edt: EDT-MCP найден: ${detected.mcpEvidence[0]}`);
     }
 
     const port = readPort(buildDir);
@@ -315,14 +399,37 @@ export async function cmdRun(root, args = {}, deps = {}) {
       log('edt: FAILED: в установке нет 1cedtcli, импорт проектов невозможен');
       return 1;
     }
+
+    let importWarning;
+    let lastImportDetail;
     if (importNeeded) {
+      const metadataLog = path.join(snapshot.wsDir, '.metadata', '.log');
+      let offset = 0;
+      try {
+        offset = statSync(metadataLog).size;
+      } catch {
+        offset = 0;
+      }
+      const total = snapshot.projects.length;
       const scriptPath = writeImportScript(buildDir, snapshot.projects);
-      writeProgress(buildDir, 'edt', 'importing', tailFile(path.join(buildDir, 'logs', 'edt-import.log')));
-      log(`edt: импорт ${snapshot.projects.length} проект(ов) в ${path.relative(root, snapshot.wsDir)} (xmx ${settings.xmxImport}, timeout ${settings.importTimeout}s)`);
-      const ticker = setInterval(() => {
-        const detail = tailFile(path.join(buildDir, 'logs', 'edt-import.log'));
-        if (detail) writeProgress(buildDir, 'edt', 'importing', detail);
-      }, 10_000);
+      const seenProjects = new Set();
+      let lastProject;
+      const tick = () => {
+        const digest = (deps.importDigest ?? importDigest)(buildDir, offset, total, deps);
+        offset = digest.offset;
+        (deps.appendImportDigest ?? appendImportDigest)(buildDir, digest.lines);
+        const memory = importMemoryWarning(digest.text);
+        if (memory !== undefined) importWarning = memory;
+        for (const name of digest.started ?? []) seenProjects.add(name);
+        if (digest.current !== undefined) lastProject = digest.current;
+        const count = total > 0 ? Math.min(seenProjects.size, total) : seenProjects.size;
+        lastImportDetail = `${count}/${total}${lastProject === undefined ? '' : ` — ${lastProject}`}`;
+        writeProgress(buildDir, 'edt', 'importing', lastImportDetail, deps.now?.(), memory === undefined ? undefined : { warning: memory });
+      };
+      lastImportDetail = `0/${total}`;
+      writeProgress(buildDir, 'edt', 'importing', lastImportDetail, deps.now?.());
+      log(`edt: импорт ${total} проект(ов) в ${path.relative(root, snapshot.wsDir)} (xmx ${settings.xmxImport}, timeout ${settings.importTimeout}s)`);
+      const ticker = setInterval(tick, deps.importPollMs ?? 5000);
       ticker.unref?.();
       try {
         await (deps.runCapture ?? runCapture)(
@@ -333,15 +440,20 @@ export async function cmdRun(root, args = {}, deps = {}) {
         );
       } catch (error) {
         clearInterval(ticker);
-        const tail = tailFile(path.join(buildDir, 'logs', 'edt-import.log'));
-        writeProgress(buildDir, 'edt', 'import-failed', `${tail ?? error?.message ?? error}; см. build/logs/edt-import.log`);
+        tick();
+        const detail = `импорт не удался (${lastImportDetail}): ${error?.message ?? error}; см. build/ws/.metadata/.log`;
+        writeProgress(buildDir, 'edt', 'import-failed', detail, deps.now?.(), importWarning === undefined ? undefined : { warning: importWarning });
         writeStamp(buildDir, 'failed', deps.now?.());
-        log(`edt: FAILED: импорт не удался — ${error?.message ?? error}; лог build/logs/edt-import.log`);
+        log(`edt: FAILED: ${detail}`);
         return 1;
       }
       clearInterval(ticker);
+      tick();
       writeImported(buildDir, snapshot.projects, deps.now?.());
-      log('edt: импорт завершён');
+      log(`edt: импорт завершён (${lastImportDetail})`);
+      if (importWarning !== undefined) {
+        log(`edt: импорт шёл на пределе памяти (${importWarning.used ?? '?'}/${importWarning.total ?? '?'} MB) — поднимите workspace.xmxImport`);
+      }
       if (snapshot.forceImport === true) {
         const { forceImport, ...rest } = snapshot;
         writeWorkspaceSnapshot(buildDir, rest);
@@ -350,16 +462,26 @@ export async function cmdRun(root, args = {}, deps = {}) {
       log('edt: импорт не требуется');
     }
 
-    writePrefs(buildDir, port);
+    writePrefs(buildDir, port, {
+      plainText: settings.plainText,
+      formScreenshots: settings.formScreenshots,
+    });
     const runningPid = readPid(buildDir)?.pid;
     if (runningPid !== undefined && (deps.alive ?? ((pid) => pidAlive(pid, ['1cedt'])))(runningPid)) {
       log(`edt: уже запущен (pid ${runningPid})`);
     } else {
       const vm = (deps.resolveEdtVm ?? resolveEdtVm)(settings, detected.home, deps);
+      const required = (deps.requiredJava ?? requiredJava)(detected.home, { platform: process.platform });
+      log(`edt: Java ${vm ?? 'авто'}${required.major === undefined ? '' : ` (EDT требует ${required.major})`}`);
       writeProgress(buildDir, 'edt', 'gui');
       const gui = (deps.spawnDetached ?? spawnDetached)(
         detected.bin,
-        guiArgs({ wsDir: snapshot.wsDir, xmx: settings.xmxIde, vm }),
+        guiArgs({
+          wsDir: snapshot.wsDir,
+          xmx: settings.xmxIde,
+          vm,
+          nativeFormBufferedLayoutRender: settings.formScreenshots,
+        }),
         path.join(buildDir, 'logs', 'edt.log'),
         root,
         deps,
@@ -377,17 +499,30 @@ export async function cmdRun(root, args = {}, deps = {}) {
     removeStamp(buildDir, 'ready');
     writeProgress(buildDir, 'edt', 'health');
     log(`edt: жду /health на порту ${port} (до ${Math.round(settings.startTimeout / 60)} мин)`);
-    const ready = await (deps.waitHealth ?? waitHealth)(port, settings.startTimeout * 1000, deps);
-    if (ready) {
-      writeProgress(buildDir, 'edt', 'ready');
+    const ready = await (deps.waitReady ?? waitReady)(
+      {
+        port,
+        pid: readPid(buildDir)?.pid,
+        alive: (value) => (deps.alive ?? ((pid) => pidAlive(pid, ['1cedt'])))(value),
+        logPath: path.join(buildDir, 'logs', 'edt.log'),
+        timeoutMs: settings.startTimeout * 1000,
+      },
+      deps,
+    );
+    if (ready.ok === true) {
+      writeProgress(buildDir, 'edt', 'ready', undefined, deps.now?.(), importWarning === undefined ? undefined : { warning: importWarning });
       writeStamp(buildDir, 'ready', deps.now?.());
       removeStamp(buildDir, 'failed');
       log('edt: READY');
       return 0;
     }
-    writeProgress(buildDir, 'edt', 'failed', 'health timeout');
+    const detail =
+      ready.reason === 'process-exited'
+        ? `процесс EDT завершился${ready.detail === undefined ? '' : `: ${ready.detail}`}`
+        : `health timeout${ready.detail === undefined ? '' : `: ${ready.detail}`}`;
+    writeProgress(buildDir, 'edt', 'failed', detail, deps.now?.(), importWarning === undefined ? undefined : { warning: importWarning });
     writeStamp(buildDir, 'failed', deps.now?.());
-    log('edt: FAILED: health timeout');
+    log(`edt: FAILED: ${detail}`);
     return 1;
   } finally {
     releaseLock(lock);
@@ -413,6 +548,33 @@ export async function waitHealth(port, timeoutMs, deps = {}) {
   return false;
 }
 
+/**
+ * Ждёт готовности EDT и замечает смерть процесса: если pid умер, а /health
+ * молчит grace-период, возвращает причину сразу, не выжидая весь startTimeout.
+ * @returns {Promise<{ ok: boolean, reason?: 'process-exited'|'timeout', detail?: string }>}
+ */
+export async function waitReady({ port, pid, alive, logPath, timeoutMs }, deps = {}) {
+  const probe = deps.probeHealth ?? probeHealth;
+  const delay = deps.sleep ?? sleep;
+  const pollMs = deps.pollMs ?? HEALTH_POLL_MS;
+  const graceMs = deps.processGraceMs ?? 15_000;
+  const deadline = Date.now() + timeoutMs;
+  let deadSince;
+  const detail = () => (typeof logPath === 'string' ? tailFile(logPath, 300) ?? undefined : undefined);
+
+  while (Date.now() < deadline) {
+    if (await probe(port, deps)) return { ok: true };
+    if (pid !== undefined && typeof alive === 'function' && !alive(pid)) {
+      deadSince ??= Date.now();
+      if (Date.now() - deadSince >= graceMs) return { ok: false, reason: 'process-exited', detail: detail() };
+    } else {
+      deadSince = undefined;
+    }
+    await delay(pollMs);
+  }
+  return { ok: false, reason: 'timeout', detail: detail() };
+}
+
 /** Останавливает EDT этого worktree. */
 export async function cmdStop(root, deps = {}) {
   const buildDir = path.join(root, 'build');
@@ -471,6 +633,13 @@ export function statusReport(root, deps = {}) {
     `workspace: ${snapshot?.wsDir ?? path.join(buildDir, 'ws')}`,
     `порт: ${state.port ?? '-'}  pid: ${state.pid?.pid ?? '-'}`,
   ];
+  const settings = snapshot?.settings ?? normalizeWorkspaceSettings({});
+  const home = detectEdtHome(settings, { platform: process.platform, env: process.env });
+  const required = requiredJava(home.home, { platform: process.platform });
+  const vm = resolveEdtVm(settings, home.home, { platform: process.platform, env: process.env });
+  lines.push(`EDT: ${home.home ?? 'не найден'}`);
+  lines.push(`Java: ${vm ?? 'авто'}${required.major === undefined ? '' : ` (EDT требует ${required.major})`}`);
+  lines.push(`Plain text: ${settings.plainText === false ? 'нет' : 'да'}; скриншоты форм: ${settings.formScreenshots === false ? 'нет' : 'да'}`);
   if (progress?.phase) {
     lines.push(`фаза: ${progress.phase}${progress.since ? ` (${formatElapsed(progress.since)})` : ''}${progress.detail ? ` — ${progress.detail}` : ''}`);
   }

package/lib/workspace.mjs

@@ -10,17 +10,22 @@
 // поднятое opencode в том же worktree, плагин принимает как готовое.
 import { execFileSync } from 'node:child_process';
 import {
+  appendFileSync,
+  closeSync,
   existsSync,
   mkdirSync,
+  openSync,
   readFileSync,
   readdirSync,
   readlinkSync,
+  readSync,
   renameSync,
   rmSync,
   statSync,
   writeFileSync,
 } from 'node:fs';
 import { createServer, connect } from 'node:net';
+import { homedir } from 'node:os';
 import path from 'node:path';
 
 import { DEFAULTS } from './schema.mjs';
@@ -115,6 +120,8 @@ export function normalizeWorkspaceSettings(raw = {}, env = process.env) {
     projects: Array.isArray(value.projects) ? value.projects.filter((item) => text(item) !== undefined).map((item) => item.trim()) : [],
     ports: min <= max ? { min, max } : { min: Math.min(min, max), max: Math.max(min, max) },
     stopOnSessionEnd: pick('stopOnSessionEnd', defaults.stopOnSessionEnd) !== false,
+    plainText: pick('plainText', defaults.plainText) !== false,
+    formScreenshots: pick('formScreenshots', defaults.formScreenshots) !== false,
   };
 }
 
@@ -318,12 +325,60 @@ export function mergePrefsText(current, values = {}) {
   return out;
 }
 
+/** Значения инструментов, отключённых в EDT-MCP по умолчанию. */
+export const DEFAULT_DISABLED_TOOLS = ['git', 'ask_workmate', 'get_form_screenshot'];
+
+/** Значение ключа prefs (первое вхождение). */
+export function prefValue(text, key) {
+  for (const line of String(text ?? '').split(/\r?\n/)) {
+    const index = line.indexOf('=');
+    if (index > 0 && line.slice(0, index) === key) return line.slice(index + 1);
+  }
+  return undefined;
+}
+
+/** Список отключённых инструментов из prefs (или дефолт EDT-MCP). */
+function disabledToolsList(current) {
+  const raw = prefValue(current, 'mcpDisabledTools');
+  return (raw === undefined ? DEFAULT_DISABLED_TOOLS : raw.split(','))
+    .map((item) => item.trim())
+    .filter((item) => item !== '');
+}
+
+function disabledToolsWithout(current, tool) {
+  return [...new Set(disabledToolsList(current).filter((item) => item !== tool))].join(',');
+}
+
+function disabledToolsWith(current, tool) {
+  return [...new Set([...disabledToolsList(current), tool])].join(',');
+}
+
+/** Содержимое prefs EDT-MCP этого workspace (undefined — файла нет). */
+export function readPrefs(buildDir) {
+  return readText(prefsPath(buildDir));
+}
+
 /** prefs, включающие MCP-сервер EDT на нужном порту при старте. */
-export function writePrefs(buildDir, port) {
+export function writePrefs(buildDir, port, options = {}) {
   const file = prefsPath(buildDir);
   mkdirSync(path.dirname(file), { recursive: true });
   const current = existsSync(file) ? readFileSync(file, 'utf8') : '';
-  const next = mergePrefsText(current, { mcpServerAutoStart: 'true', mcpServerPort: port });
+  const values = {
+    mcpServerHttpEnabled: 'true',
+    mcpServerAutoStart: 'true',
+    mcpServerPort: port,
+    // DSH не рендерит embedded resource: markdown-инструменты EDT-MCP должны
+    // отдавать текст (Plain text mode).
+    mcpPlainTextMode: String(options.plainText !== false),
+  };
+  // get_form_screenshot выключен в EDT-MCP по умолчанию. Список всегда
+  // приводим к настройке: при true убираем инструмент, при false — возвращаем,
+  // иначе prefs от прошлого запуска оставят его включённым.
+  values.mcpDisabledTools =
+    options.formScreenshots !== false
+      ? disabledToolsWithout(current, 'get_form_screenshot')
+      : disabledToolsWith(current, 'get_form_screenshot');
+  const next = mergePrefsText(current, values);
   atomicWrite(file, next);
   return file;
 }
@@ -472,12 +527,17 @@ export function readProgress(buildDir) {
   return readJson(filePath(buildDir, 'progress')) ?? null;
 }
 
-export function writeProgress(buildDir, kind, phase, detail) {
-  const prev = readProgress(buildDir) ?? { startedAt: new Date().toISOString() };
-  const now = new Date().toISOString();
+/**
+ * @param now момент записи (для тестов передаётся явно: `since` не должен
+ *   зависеть от разрешения часов).
+ */
+export function writeProgress(buildDir, kind, phase, detail, now = new Date(), extra = undefined) {
+  const prev = readProgress(buildDir) ?? { startedAt: now.toISOString() };
+  const stamp = now.toISOString();
   const was = prev[kind];
-  prev[kind] = { phase, since: was?.phase === phase && was.since ? was.since : now, updated: now };
+  prev[kind] = { phase, since: was?.phase === phase && was.since ? was.since : stamp, updated: stamp };
   if (detail !== undefined) prev[kind].detail = detail;
+  if (extra !== undefined && typeof extra === 'object') Object.assign(prev[kind], extra);
   atomicWrite(filePath(buildDir, 'progress'), `${JSON.stringify(prev, null, 2)}\n`);
 }
 
@@ -499,6 +559,111 @@ export function tailFile(file, maxLen = 200) {
   return lines.length === 0 ? null : lines[lines.length - 1].slice(0, maxLen);
 }
 
+/** Длина буфера без обрезанной многобайтовой UTF-8 последовательности. */
+function completeUtf8Length(buffer) {
+  let index = buffer.length - 1;
+  let continuation = 0;
+  while (index >= 0 && (buffer[index] & 0xc0) === 0x80 && continuation < 3) {
+    index -= 1;
+    continuation += 1;
+  }
+  if (index < 0) return buffer.length;
+  const lead = buffer[index];
+  let needed;
+  if ((lead & 0x80) === 0) needed = 1;
+  else if ((lead & 0xe0) === 0xc0) needed = 2;
+  else if ((lead & 0xf0) === 0xe0) needed = 3;
+  else if ((lead & 0xf8) === 0xf0) needed = 4;
+  else return buffer.length;
+  const have = buffer.length - index;
+  return have >= needed ? buffer.length : index;
+}
+
+/** Читает файл с байтового смещения (для растущего workspace `.metadata/.log`). */
+export function readFromOffset(file, offset, { maxBytes = 512 * 1024 } = {}) {
+  let fd;
+  try {
+    fd = openSync(file, 'r');
+    const size = statSync(file).size;
+    const start = Math.max(0, Math.min(offset ?? 0, size));
+    const length = Math.min(Math.max(0, size - start), maxBytes);
+    if (length === 0) return { text: '', offset: size };
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, start);
+    const complete = completeUtf8Length(buffer);
+    return {
+      text: buffer.subarray(0, complete).toString('utf8'),
+      // Следующий вызов дочитает остаток, а не пропустит его.
+      offset: start + complete,
+    };
+  } catch {
+    return { text: '', offset: offset ?? 0 };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+const PROJECT_STARTED = /Project context is started:\s*(.+?)\s*$/;
+const PROJECT_STARTING = /Project context is being started:\s*(.+?)(?:\s+\([A-Z_]+\))?\s*$/;
+
+/**
+ * Прогресс импорта по `build/ws/.metadata/.log`: сколько проектов стартовало
+ * и какой проект сейчас в работе. Счётчик ограничен `total`.
+ */
+export function parseImportProgress(text, total = 0) {
+  const started = new Set();
+  let lastStarted;
+  let lastStarting;
+  for (const line of String(text ?? '').split(/\r?\n/)) {
+    const startedMatch = PROJECT_STARTED.exec(line);
+    if (startedMatch !== null) {
+      lastStarted = startedMatch[1].trim();
+      started.add(lastStarted);
+      continue;
+    }
+    const startingMatch = PROJECT_STARTING.exec(line);
+    if (startingMatch !== null) lastStarting = startingMatch[1].trim();
+  }
+  const count = total > 0 ? Math.min(started.size, total) : started.size;
+  const current = lastStarting !== undefined && !started.has(lastStarting) ? lastStarting : lastStarted;
+  return { started: [...started], startedCount: count, total, current };
+}
+
+/** Свежий кусок metadata-лога, прогресс импорта и полезные строки. */
+export function importDigest(buildDir, offset, total, deps = {}) {
+  const file = path.join(buildDir, 'ws', '.metadata', '.log');
+  const { text, offset: next } = (deps.readFromOffset ?? readFromOffset)(file, offset);
+  const progress = parseImportProgress(text, total);
+  const lines = text
+    .split(/\r?\n/)
+    .filter((line) => /Project context|CPU overload|Memory \d+ MB|!ERROR|Exception/.test(line));
+  return { ...progress, offset: next, lines, text };
+}
+
+/** Копирует значимые строки импорта в build/logs/edt-import.log. */
+export function appendImportDigest(buildDir, lines) {
+  if (!Array.isArray(lines) || lines.length === 0) return;
+  const file = path.join(buildDir, 'logs', 'edt-import.log');
+  mkdirSync(path.dirname(file), { recursive: true });
+  appendFileSync(file, `${lines.join('\n')}\n`, 'utf8');
+}
+
+/**
+ * Признак нехватки памяти при импорте: `CPU overload. Memory X MB used of Y MB`
+ * или явный `CPU overload`. Возвращает последнее измерение, если загрузка ≥85 %.
+ */
+export function importMemoryWarning(text) {
+  const matches = [...String(text ?? '').matchAll(/Memory\s+(\d+)\s+MB\s+used\s+of\s+(\d+)\s+MB/gi)];
+  const last = matches.at(-1);
+  const cpuOverload = /CPU overload/i.test(String(text ?? ''));
+  if (last === undefined) return cpuOverload ? { cpuOverload: true } : undefined;
+  const used = Number.parseInt(last[1], 10);
+  const total = Number.parseInt(last[2], 10);
+  if (!Number.isFinite(used) || !Number.isFinite(total) || total <= 0) return undefined;
+  const ratio = used / total;
+  return ratio >= 0.85 || cpuOverload ? { used, total, ratio, cpuOverload } : undefined;
+}
+
 /** Снимок настроек окружения — для диагностики и фонового процесса. */
 export function buildWorkspaceSnapshot({ root, buildDir, wsDir, mainRoot, settings, projects, now = new Date() }) {
   return {
@@ -598,18 +763,97 @@ export function killTree(pid, { force = false, platform = process.platform, run
 
 // --- установка EDT ----------------------------------------------------------
 
-/** Установлен ли в этой EDT плагин EDT-MCP (эвристика по именам бандлов). */
-export function hasMcpBundle(home) {
-  for (const dir of ['plugins', 'features']) {
+const MCP_BUNDLE = /com\.ditrix\.edt\.mcp\.server|ditrix/i;
+
+function bundleNames(dir) {
+  try {
+    return readdirSync(dir).filter((name) => MCP_BUNDLE.test(name));
+  } catch {
+    return [];
+  }
+}
+
+/** Значение ключа Eclipse `config.ini` (без разбора секций). */
+function iniValue(text, key) {
+  const match = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=\\s*(.+)$`, 'm').exec(String(text ?? ''));
+  return match === null ? undefined : match[1].trim();
+}
+
+/** `file\:configuration/` -> абсолютный путь. */
+function resolveEclipsePath(value, baseDir) {
+  if (typeof value !== 'string' || value === '') return undefined;
+  const raw = value.replace(/\\:/g, ':').replace(/^file:/i, '');
+  if (raw === '') return undefined;
+  return path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(baseDir, raw);
+}
+
+/** Области конфигурации, в которых Eclipse ищет бандлы. */
+function configurationAreas(home, { platform = process.platform, eclipseRoots } = {}) {
+  const areas = [];
+  if (typeof home === 'string' && home !== '') {
+    // Сам каталог установки: <home>/plugins и <home>/features.
+    areas.push(home);
+    const configDir = path.join(home, 'configuration');
+    areas.push(configDir);
+    try {
+      const shared = iniValue(readFileSync(path.join(configDir, 'config.ini'), 'utf8'), 'osgi.sharedConfiguration.area');
+      const resolved = resolveEclipsePath(shared, configDir);
+      if (resolved !== undefined && resolved !== configDir) areas.push(resolved);
+    } catch {
+      // config.ini может отсутствовать — не мешает проверке установки
+    }
+    try {
+      const ini = readFileSync(path.join(home, platform === 'win32' ? '1cedt.ini' : '1cedt.ini'), 'utf8');
+      const line = /^-configuration\s+(.+)$/m.exec(ini)?.[1]?.trim();
+      const resolved = resolveEclipsePath(line, home);
+      if (resolved !== undefined) areas.push(resolved);
+    } catch {
+      // 1cedt.ini может отсутствовать
+    }
+  }
+
+  const homeDir = platform === 'win32' ? homedir() : (process.env.HOME ?? homedir());
+  for (const root of eclipseRoots ?? [path.join(homeDir, '.eclipse')]) {
     let entries;
     try {
-      entries = readdirSync(path.join(home, dir));
+      entries = readdirSync(root, { withFileTypes: true });
     } catch {
       continue;
     }
-    if (entries.some((name) => /mcp/i.test(name) || /ditrix/i.test(name))) return true;
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !/^org\.eclipse\.platform_/.test(entry.name)) continue;
+      areas.push(path.join(root, entry.name, 'configuration'));
+    }
   }
-  return false;
+  return [...new Set(areas)];
+}
+
+/**
+ * Где реально лежит EDT-MCP: установка, shared area или пользовательская
+ * configuration area (`~/.eclipse/org.eclipse.platform_*`). Это подсказка для
+ * диагностики, а не критерий выбора установки.
+ * @returns {{ found: boolean, evidence: string[] }}
+ */
+export function mcpEvidence(home, options = {}) {
+  const evidence = [];
+  for (const area of configurationAreas(home, options)) {
+    for (const sub of ['plugins', 'features']) {
+      const hits = bundleNames(path.join(area, sub));
+      if (hits.length > 0) evidence.push(`${path.join(area, sub)}: ${hits[0]}`);
+    }
+    const bundles = path.join(area, 'org.eclipse.equinox.simpleconfigurator', 'bundles.info');
+    try {
+      if (MCP_BUNDLE.test(readFileSync(bundles, 'utf8'))) evidence.push(bundles);
+    } catch {
+      // bundles.info может отсутствовать
+    }
+  }
+  return { found: evidence.length > 0, evidence };
+}
+
+/** Установлен ли в этой EDT плагин EDT-MCP (обёртка над mcpEvidence). */
+export function hasMcpBundle(home, options = {}) {
+  return mcpEvidence(home, options).found;
 }
 
 const VERSION_PATTERN = /^1c-edt-(\d{4})\.(\d+)\.(\d+)\+(\d+)-/;
@@ -631,9 +875,13 @@ const compareVersion = (left, right) => {
 
 /**
  * Установка EDT: явная из настроек/`DSH_1C_EDT_HOME` либо старшая найденная.
- * @returns {{ home?: string, bin?: string, cli?: string, mcpBundle?: boolean, source?: string, error?: string }}
+ * Наличие EDT-MCP в файлах — только диагностическая подсказка: бандл может
+ * стоять в пользовательской configuration area, а окончательно готовность
+ * подтверждает `/health`.
+ * @returns {{ home?: string, bin?: string, cli?: string, mcpBundle?: boolean,
+ *             mcpEvidence?: string[], source?: string, error?: string }}
  */
-export function detectEdtHome(settings, { platform = process.platform, env = process.env, roots } = {}) {
+export function detectEdtHome(settings, { platform = process.platform, env = process.env, roots, eclipseRoots } = {}) {
   const binary = platform === 'win32' ? '1cedt.exe' : '1cedt';
   const cli = platform === 'win32' ? '1cedtcli.exe' : '1cedtcli';
   const explicit = text(env?.DSH_1C_EDT_HOME) ?? text(settings?.home?.[platform]);
@@ -642,11 +890,13 @@ export function detectEdtHome(settings, { platform = process.platform, env = pro
     const bin = path.join(home, binary);
     if (!existsSync(bin)) return { error: `в ${home} нет ${binary}`, home };
     const cliPath = path.join(home, cli);
+    const evidence = mcpEvidence(home, { platform, env, eclipseRoots });
     return {
       home,
       bin,
       cli: existsSync(cliPath) ? cliPath : undefined,
-      mcpBundle: hasMcpBundle(home),
+      mcpBundle: evidence.found,
+      mcpEvidence: evidence.evidence,
       source: text(env?.DSH_1C_EDT_HOME) ? 'env' : 'config',
     };
   }
@@ -666,48 +916,111 @@ export function detectEdtHome(settings, { platform = process.platform, env = pro
       if (version === null) continue;
       const home = path.join(root, entry.name);
       if (!existsSync(path.join(home, binary))) continue;
-      candidates.push({ home, version, mcpBundle: hasMcpBundle(home) });
+      candidates.push({ home, version });
     }
   }
   if (candidates.length === 0) {
     return { error: `1C:EDT не найден; задайте workspace.home или DSH_1C_EDT_HOME (искали в ${searchRoots.join(', ')})` };
   }
+  // Выбор только по версии: наличие бандла не должно решать, какую установку
+  // запускать (бандл может лежать в пользовательской configuration area).
   candidates.sort((left, right) => compareVersion(right.version, left.version));
-  const chosen = candidates.find((candidate) => candidate.mcpBundle) ?? candidates[0];
+  const chosen = candidates[0];
   const cliPath = path.join(chosen.home, cli);
+  const evidence = mcpEvidence(chosen.home, { platform, env, eclipseRoots });
   return {
     home: chosen.home,
     bin: path.join(chosen.home, binary),
     cli: existsSync(cliPath) ? cliPath : undefined,
-    mcpBundle: chosen.mcpBundle,
+    mcpBundle: evidence.found,
+    mcpEvidence: evidence.evidence,
     source: 'autodetect',
   };
 }
 
-/** Java для EDT: явная настройка, env либо jdk-full-17 рядом с установкой. */
+/**
+ * Требования EDT к Java из `1cedt.ini`: major из
+ * `-Dosgi.requiredJavaVersion` и явный `-vm` (до `-vmargs`), если задан.
+ */
+export function requiredJava(home, { platform = process.platform } = {}) {
+  const result = { major: undefined, vm: undefined };
+  if (typeof home !== 'string' || home === '') return result;
+  let ini;
+  try {
+    ini = readFileSync(path.join(home, '1cedt.ini'), 'utf8');
+  } catch {
+    return result;
+  }
+  const major = /-Dosgi\.requiredJavaVersion=(\d+)/.exec(ini)?.[1];
+  if (major !== undefined) result.major = Number.parseInt(major, 10);
+
+  const lines = ini.split(/\r?\n/);
+  const vmargsAt = lines.findIndex((line) => line.trim() === '-vmargs');
+  const launchLines = vmargsAt === -1 ? lines : lines.slice(0, vmargsAt);
+  const vmAt = launchLines.findIndex((line) => line.trim() === '-vm');
+  let vm;
+  if (vmAt !== -1) {
+    vm = launchLines.slice(vmAt + 1).find((line) => line.trim() !== '')?.trim();
+  } else {
+    vm = /^\s*-vm\s+(.+)$/m.exec(launchLines.join('\n'))?.[1]?.trim();
+  }
+  if (vm !== undefined && vm !== '') {
+    result.vm = path.isAbsolute(vm) ? path.normalize(vm) : path.resolve(home, vm);
+  }
+  return result;
+}
+
+/** JDK рядом с установкой EDT: `{ major, path }`, по убыванию major. */
+function jdkCandidates(components, javaBinary) {
+  let entries;
+  try {
+    entries = readdirSync(components, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const major = /jdk-(?:full-)?(\d+)/i.exec(entry.name)?.[1];
+    if (major === undefined) continue;
+    const bin = path.join(components, entry.name, 'bin', javaBinary);
+    if (!existsSync(bin)) continue;
+    candidates.push({ major: Number.parseInt(major, 10), path: bin });
+  }
+  return candidates.sort((left, right) => right.major - left.major);
+}
+
+/**
+ * Java для EDT: явная настройка → `-vm` из ini → JDK рядом с установкой по
+ * требуемой major (точная, затем ближайшая старшая, затем старшая доступная).
+ */
 export function resolveEdtVm(settings, home, { platform = process.platform, env = process.env } = {}) {
   const explicit = text(env?.DSH_1C_EDT_VM) ?? text(settings?.vm);
   if (explicit !== undefined) return explicit;
   if (typeof home !== 'string' || home === '') return undefined;
+
+  const required = requiredJava(home, { platform });
+  if (required.vm !== undefined && existsSync(required.vm)) return required.vm;
+
   const javaBinary = platform === 'win32' ? 'javaw.exe' : 'java';
-  try {
-    const components = path.dirname(home);
-    const jdk = readdirSync(components, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory() && /jdk-full-17/.test(entry.name))
-      .map((entry) => path.join(components, entry.name, 'bin', javaBinary))
-      .filter((candidate) => existsSync(candidate))
-      .sort();
-    return jdk[0];
-  } catch {
-    return undefined;
-  }
+  const candidates = jdkCandidates(path.dirname(home), javaBinary);
+  if (candidates.length === 0) return undefined;
+  if (required.major === undefined) return candidates[0].path;
+
+  const exact = candidates.find((candidate) => candidate.major === required.major);
+  if (exact !== undefined) return exact.path;
+  const newer = [...candidates].reverse().find((candidate) => candidate.major >= required.major);
+  return (newer ?? candidates[0]).path;
 }
 
 /** Аргументы запуска EDT GUI с отдельным workspace. */
-export function guiArgs({ wsDir, xmx, vm }) {
+export function guiArgs({ wsDir, xmx, vm, nativeFormBufferedLayoutRender = false }) {
   const args = ['-nosplash', '-data', wsDir, '--launcher.appendVmargs'];
   if (typeof vm === 'string' && vm !== '') args.push('-vm', vm);
   args.push('-vmargs', `-Xmx${xmx}`);
+  // Требование EDT-MCP для get_form_screenshot: свойство должно идти после
+  // -vmargs. На Windows включает буферизованный рендер форм на всю сессию.
+  if (nativeFormBufferedLayoutRender) args.push('-DnativeFormBufferedLayoutRender=true');
   return args;
 }
 

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "1C:EDT + BSL MCP",
-    "description": "MCP hub for 1C development: active only in selected projects (.dsh-1c.json or the projects list). There EDT is connected up front, while BSL Language Server (diagnostics, types, navigation), standards and a task tracker are mounted on demand via edt_pin; in a git worktree the plugin raises its own EDT workspace under build/ws. 1C rules enter the prompt only there."
+    "description": "MCP hub for 1C development: active only in selected projects (.dsh-1c.json or the projects list). There EDT is connected up front, while BSL Language Server (diagnostics, types, navigation), standards and a task tracker are mounted on demand via edt_pin; in a git worktree (including dsh-git-worktree) the plugin raises its own EDT workspace under build/ws with plain text and form screenshots. 1C rules enter the prompt only there."
   }
 }

package/locale/ru.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "1C:EDT + BSL MCP",
-    "description": "Хаб MCP-серверов для разработки на 1С: включается только в выбранных проектах (файл .dsh-1c.json или список projects). В них EDT подключён сразу, BSL Language Server (диагностика, типы, навигация), стандарты и система задач — по требованию через edt_pin; в git worktree плагин поднимает отдельный EDT workspace в build/ws. Правила 1С появляются в промпте только там."
+    "description": "Хаб MCP-серверов для разработки на 1С: включается только в выбранных проектах (файл .dsh-1c.json или список projects). В них EDT подключён сразу, BSL Language Server (диагностика, типы, навигация), стандарты и система задач — по требованию через edt_pin; в git worktree (в т.ч. dsh-git-worktree) плагин поднимает отдельный EDT workspace в build/ws с plain text и скриншотами форм. Правила 1С появляются в промпте только там."
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edt-projects",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "type": "module",
   "description": "Project-scoped MCP hub for 1C development: active only in selected projects, EDT connected up front there, a per-worktree EDT workspace under build/ws, BSL Language Server, a task tracker and the v8std standards MCP mounted on demand, bundled SonarQube and GitLab skills, with model-facing usage rules",
   "license": "MIT",