mister-wolf 2.20.0 → 2.21.0

package/dist/adapters/platforms/opencode-adapter.js

@@ -2,14 +2,22 @@ import * as fs from 'fs/promises';
 import { existsSync } from 'fs';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { basename, join } from 'path';
+import { basename, join, relative } from 'path';
 import { parseJsonc } from './jsonc.js';
 import { writeFileAtomic } from '../fs/markdown-memory-store.js';
 import { UserFacingError } from '../../domain/errors.js';
-/** Дефолтный агент Wolf в opencode (§6.1). */
-export const DEFAULT_AGENT = 'mr-wolf';
-/** Глубина субагентов: executor-lead спавнит worker-* (трёхуровневая схема). */
-export const SUBAGENT_DEPTH = 2;
+import { parseStamp } from '../render/stamp.js';
+import yaml from 'js-yaml';
+import { CONFIG_LOCATIONS, DEFAULT_AGENT, DEFAULT_AGENT_KEY, MCP_KEY, MCP_ROOT, MCP_SERVERS, SUBAGENT_DEPTH, SUBAGENT_DEPTH_KEY, WOLF_MCP_COMMAND, WRITE_LOCATION, WRITE_LOCATION_ID, deletePath, getPath, getRecordAt, isWolfMcpEntry, legacyPathOf, blockedSegment, locatePath, mcpEntryNative, mergeSurface, pathWritable, relPathOf, setPath, } from './opencode-config-keys.js';
+export { DEFAULT_AGENT, SUBAGENT_DEPTH };
+/** Каноническая команда wolf: removeWolf/configIssues не получают cmd, ownership проверяем ею. */
+const WOLF_CMD = WOLF_MCP_COMMAND;
+/** Значение глубины в действующем месте — наше или совместимое (>= SUBAGENT_DEPTH). */
+function depthIsOurs(value) {
+    return typeof value === 'number' && value >= SUBAGENT_DEPTH;
+}
+const dotted = (key) => key.writePath.join('.');
+const leaf = (key) => key.writePath[key.writePath.length - 1];
 const execFileAsync = promisify(execFile);
 /** Минимальная поддержанная v1 (порог диапазона). */
 const V1_MIN_MINOR = 18;
@@ -17,6 +25,9 @@ const V1_MIN_PATCH = 29;
 /**
  * Чистый парсер `opencode --version`. Эмпирика форматов: v1 печатает `1.18.35`,
  * v2 — `opencode v2.0.24`; regex вытаскивает M.m.p из обоих.
+ *
+ * Нативная форма `mcp.servers.<name>` принимается opencode >= 1.18.29 (v2-compat hoist),
+ * а порог v1 в коде — ровно 1.18.29: ветвление по версии для выбора формы не нужно.
  */
 export function parseOpencodeVersion(raw) {
     const trimmed = raw.trim();
@@ -50,126 +61,560 @@ export class OpencodeAdapter {
             return { status: 'absent', message: err instanceof Error ? err.message : String(err) };
         }
     }
-    /** Существующий конфиг (jsonc — только если нет json); для новой установки — opencode.json. */
-    configFile(projectRoot) {
-        if (existsSync(join(projectRoot, 'opencode.jsonc')) && !existsSync(join(projectRoot, 'opencode.json'))) {
-            return join(projectRoot, 'opencode.jsonc');
+    /**
+     * Файл локации: jsonc — только если json отсутствует (правило прежнее),
+     * иначе json. Если файла нет — возвращается дефолтный путь (цель записи).
+     */
+    locationFile(projectRoot, location) {
+        const dir = location.dir === '' ? projectRoot : join(projectRoot, location.dir);
+        const jsonc = join(dir, `${location.fileBase}.jsonc`);
+        const json = join(dir, `${location.fileBase}.json`);
+        return existsSync(jsonc) && !existsSync(json) ? jsonc : json;
+    }
+    /** Корневой конфиг — единственное место, куда wolf пишет свои ключи. */
+    rootFile(projectRoot) {
+        return this.locationFile(projectRoot, WRITE_LOCATION);
+    }
+    /**
+     * Поверхность конфига (6.7): обе локации + эффективный (слейдженный) вид.
+     * Битый/нечитаемый файл ИЗОЛИРУЕТСЯ: он попадает в `errors`, а остальные локации
+     * читаются как обычно (прежнее поведение «всё или ничего» чинило в обратную сторону).
+     */
+    async loadSurface(projectRoot) {
+        const files = [];
+        const errors = [];
+        for (const location of CONFIG_LOCATIONS) {
+            const file = this.locationFile(projectRoot, location);
+            if (!existsSync(file))
+                continue;
+            const rel = relative(projectRoot, file);
+            let raw;
+            try {
+                raw = await fs.readFile(file, 'utf-8');
+            }
+            catch (err) {
+                errors.push({
+                    location: location.id,
+                    file,
+                    rel,
+                    kind: 'not readable',
+                    message: `${file} is not readable: ${err instanceof Error ? err.message : err}`,
+                });
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = parseJsonc(raw);
+            }
+            catch (err) {
+                // паритет с ClaudeAdapter: ошибки парсинга — UserFacingError, не сырой SyntaxError
+                errors.push({
+                    location: location.id,
+                    file,
+                    rel,
+                    kind: 'not valid JSONC',
+                    message: `${file} is not valid JSONC: ${err instanceof Error ? err.message : err}`,
+                });
+                continue;
+            }
+            const cfg = asRecord(parsed);
+            if (cfg === undefined) {
+                errors.push({
+                    location: location.id,
+                    file,
+                    rel,
+                    kind: 'not a JSON object',
+                    message: `${file} is not a JSON object — refusing to touch it`,
+                });
+                continue;
+            }
+            files.push({ location: location.id, file, rel, cfg });
         }
-        return join(projectRoot, 'opencode.json');
+        return { files, errors, effective: mergeSurface(files) };
+    }
+    /** Битая/нечитаемая корневая локация (та, куда wolf пишет) — прежний контракт: ошибка наружу. */
+    static rootError(surface) {
+        return surface.errors.find((error) => error.location === WRITE_LOCATION_ID);
     }
+    /**
+     * Эффективный конфиг обеих локаций; null — конфиг-файлов нет ни в одной локации.
+     * Битый корневой файл — UserFacingError (прежний контракт для корня);
+     * битый `.opencode` — не мешает: возвращаем вид читаемых файлов.
+     */
     async readConfig(projectRoot) {
-        const file = this.configFile(projectRoot);
-        let raw = null;
-        try {
-            raw = await fs.readFile(file, 'utf-8');
-        }
-        catch {
+        const surface = await this.loadSurface(projectRoot);
+        const rootError = OpencodeAdapter.rootError(surface);
+        if (rootError !== undefined)
+            throw new UserFacingError(rootError.message);
+        if (surface.files.length === 0)
             return null;
+        return surface.effective;
+    }
+    /**
+     * Запись wolf-ключей (6.7): решения принимаются по эффективному виду обеих
+     * локаций, запись — только в корневой конфиг (в .opencode wolf не пишет).
+     *
+     * opts.createFile=false — режим repair-only: файл конфига не создаётся, если его нет
+     * (минимальный init чинит существующий конфиг и никогда не создаёт платформенный).
+     */
+    async writeConfig(projectRoot, cmd, opts) {
+        const surface = await this.loadSurface(projectRoot);
+        // битый/нечитаемый корень — прежнее поведение: файл не трогаем, ошибка наружу
+        const rootError = OpencodeAdapter.rootError(surface);
+        if (rootError !== undefined)
+            throw new UserFacingError(rootError.message);
+        const file = this.rootFile(projectRoot);
+        const rootExists = surface.files.some((f) => f.location === WRITE_LOCATION_ID);
+        if (!rootExists && opts?.createFile === false) {
+            // минимальный init: конфига нет — не создаём (документированное обещание)
+            const other = surface.files.find((f) => f.location !== WRITE_LOCATION_ID);
+            const reason = other !== undefined
+                ? `no root ${relPathOf(WRITE_LOCATION)} to repair — the project config is ${other.rel}; a minimal init never creates a platform config (use wolf init --platform ${this.id})`
+                : `no root ${relPathOf(WRITE_LOCATION)} to repair — a minimal init never creates a platform config (use wolf init --platform ${this.id})`;
+            return { action: 'skipped', reason };
         }
-        let parsed;
-        try {
-            parsed = parseJsonc(raw);
+        const rootCfg = rootConfigOf(surface);
+        // 6.3: пишем нативную форму mcp.servers.wolf, легаси mcp.wolf снимаем только если он наш
+        const desired = mcpEntryNative(cmd);
+        const legacyMcpPath = legacyPathOf(MCP_KEY);
+        const nativeAt = locatePath(surface.files, MCP_KEY.writePath);
+        const legacyAt = locatePath(surface.files, legacyMcpPath);
+        const legacyMcpOurs = legacyAt !== undefined && isWolfMcpEntry(legacyAt.value, cmd);
+        const mcpWritable = pathWritable(rootCfg, MCP_KEY.writePath);
+        const blockedReasons = [];
+        const agentReasons = [];
+        const depthReasons = [];
+        const mcpBlocked = blockedSegment(rootCfg, MCP_KEY.writePath);
+        if (mcpBlocked !== undefined) {
+            blockedReasons.push(`${mcpBlocked} is not an object; ${MCP_KEY.label} is not written — fix the conflicting key manually`);
         }
-        catch (err) {
-            // паритет с ClaudeAdapter: ошибки парсинга — UserFacingError, не сырой SyntaxError
-            throw new UserFacingError(`${file} is not valid JSONC: ${err instanceof Error ? err.message : err}`);
-        }
-        return asConfig(parsed, file);
-    }
-    async writeConfig(projectRoot, cmd) {
-        const file = this.configFile(projectRoot);
-        const cfg = (await this.readConfig(projectRoot)) ?? {};
-        const mcp = asRecord(cfg.mcp) ?? {};
-        // каноническая проекция McpCommand в формат opencode: command — массив
-        const desired = { type: 'local', command: [cmd.command, ...cmd.args], enabled: true };
-        const mcpOk = JSON.stringify(mcp.wolf) === JSON.stringify(desired);
-        // §6.1: default_agent и subagent_depth мерджатся рядом с mcp.wolf
-        const da = cfg.default_agent;
-        const sd = cfg.subagent_depth;
-        const reasons = [];
+        // §6.1: default_agent — по эффективному виду (корень + .opencode)
+        const da = locatePath(surface.files, DEFAULT_AGENT_KEY.writePath)?.value;
         if (da !== undefined && da !== DEFAULT_AGENT) {
-            reasons.push(`default_agent=${da} is taken; mr-wolf not assigned`);
+            agentReasons.push(`${DEFAULT_AGENT_KEY.label}=${da} is taken; ${DEFAULT_AGENT} not assigned`);
+        }
+        // 6.7: объявленное в .opencode не перекрываем вторым ключом в корне
+        let writeMcp = false;
+        let replaceMcp = false;
+        let mcpNativeReason;
+        if (nativeAt !== undefined) {
+            if (JSON.stringify(nativeAt.value) === JSON.stringify(desired)) {
+                // уже канонично — писать нечего
+            }
+            else if (nativeAt.location === WRITE_LOCATION_ID) {
+                if (mcpWritable) {
+                    writeMcp = true;
+                    replaceMcp = true;
+                    mcpNativeReason = `replaced non-canonical ${MCP_KEY.label} entry with the canonical Wolf entry`;
+                }
+            }
+            else {
+                mcpNativeReason = `${MCP_KEY.label} is declared in ${relOf(surface, nativeAt.location)} — the .opencode value overrides the root one, so a root entry would have no effect; wolf leaves it untouched (wolf writes the root config)`;
+            }
+        }
+        else if (legacyAt === undefined || !legacyMcpOurs || legacyAt.location === WRITE_LOCATION_ID) {
+            writeMcp = mcpWritable;
+        }
+        // легаси-форма: снимаем только свою и только в корне (писать можно лишь туда)
+        let dropLegacyMcp = false;
+        let mcpLegacyReason;
+        if (legacyAt !== undefined) {
+            if (!legacyMcpOurs) {
+                mcpLegacyReason = `top-level ${legacyMcpPath.join('.')} is deprecated and foreign (command differs); ${MCP_KEY.label} is used`;
+            }
+            else if (legacyAt.location === WRITE_LOCATION_ID) {
+                dropLegacyMcp = true;
+                mcpLegacyReason = `removed deprecated top-level ${legacyMcpPath.join('.')} (migrated to ${MCP_KEY.label})`;
+            }
+            else if (nativeAt === undefined) {
+                mcpLegacyReason = `wolf entry is in the deprecated top-level ${legacyMcpPath.join('.')} form in ${relOf(surface, legacyAt.location)} — the .opencode value overrides the root one, so a root entry would have no effect; migrate it to ${MCP_KEY.label} manually`;
+            }
+            else {
+                mcpLegacyReason = `deprecated top-level ${legacyMcpPath.join('.')} in ${relOf(surface, legacyAt.location)} is ignored by opencode v2 — the .opencode value overrides the root one; remove it manually`;
+            }
+        }
+        // opencode v2: действует только experimental.subagent_depth. Верхнеуровневый ключ —
+        // deprecated: наше точное значение мигрируем, чужое не трогаем и сообщаем.
+        const depthPath = SUBAGENT_DEPTH_KEY.writePath;
+        const depthLeaf = leaf(SUBAGENT_DEPTH_KEY);
+        const depthLabel = dotted(SUBAGENT_DEPTH_KEY);
+        const legacyDepthPath = legacyPathOf(SUBAGENT_DEPTH_KEY);
+        const depthAt = locatePath(surface.files, depthPath);
+        const legacyDepthAt = locatePath(surface.files, legacyDepthPath);
+        const depth = depthAt?.value;
+        const legacyDepth = legacyDepthAt?.value;
+        const depthOk = depthIsOurs(depth);
+        const legacyOurs = legacyDepth === SUBAGENT_DEPTH;
+        let setDepth = false;
+        let dropLegacy = false;
+        const depthWritable = pathWritable(rootCfg, depthPath);
+        if (!depthWritable) {
+            depthReasons.push(`experimental is not an object; ${depthLeaf} is not written — set ${depthLabel}: ${SUBAGENT_DEPTH} manually`);
+        }
+        else if (depthOk) {
+            if (legacyOurs) {
+                if (legacyDepthAt.location === WRITE_LOCATION_ID) {
+                    dropLegacy = true; // оба ключа наши: легаси — только шум, убираем
+                    depthReasons.push(`removed deprecated top-level ${depthLeaf}=${SUBAGENT_DEPTH} (ignored by opencode v2)`);
+                }
+                else {
+                    depthReasons.push(`top-level ${depthLeaf}=${SUBAGENT_DEPTH} in ${relOf(surface, legacyDepthAt.location)} is deprecated and ignored by opencode v2 — the .opencode value overrides the root one; remove it manually`);
+                }
+            }
+            else if (legacyDepth !== undefined) {
+                depthReasons.push(`top-level ${depthLeaf}=${legacyDepth} is deprecated and ignored by opencode v2; ${depthLabel} is used`);
+            }
+        }
+        else if (depth !== undefined) {
+            depthReasons.push(`${depthLabel}=${depth} is taken; the three-level scheme will not work, set >=2`);
+        }
+        else if (legacyOurs) {
+            setDepth = true;
+            if (legacyDepthAt.location === WRITE_LOCATION_ID) {
+                dropLegacy = true;
+                depthReasons.push(`migrated ${depthLeaf} to ${depthLabel}`);
+            }
+            else {
+                // легаси в .opencode удалить не можем (wolf пишет только в корень) — но и второй
+                // ключ не нужен: каноническую форму wolf записывает в корневой конфиг сам.
+                depthReasons.push(`top-level ${depthLeaf}=${SUBAGENT_DEPTH} in ${relOf(surface, legacyDepthAt.location)} is deprecated and ignored by opencode v2 — wolf wrote ${depthLabel}=${SUBAGENT_DEPTH} in the root config; remove the deprecated key manually`);
+            }
         }
-        if (sd !== undefined && !(typeof sd === 'number' && sd >= SUBAGENT_DEPTH)) {
-            reasons.push(`subagent_depth=${sd} is taken; the three-level scheme will not work, set >=2`);
+        else if (legacyDepth !== undefined) {
+            depthReasons.push(`top-level ${depthLeaf}=${legacyDepth} is taken; the key is deprecated and ignored by opencode v2 — set ${depthLabel} >=${SUBAGENT_DEPTH}`);
         }
+        else {
+            setDepth = true;
+        }
+        const reasons = [
+            ...blockedReasons,
+            ...agentReasons,
+            ...(mcpLegacyReason !== undefined ? [mcpLegacyReason] : []),
+            ...(mcpNativeReason !== undefined ? [mcpNativeReason] : []),
+            ...depthReasons,
+            // битая/нечитаемая локация не мешает починке корня — но называем её
+            ...surface.errors.map((error) => `skipped: ${error.rel} is ${error.kind}`),
+        ];
         const reason = reasons.length > 0 ? reasons.join('; ') : undefined;
-        // F6 (спека 2.1.0 §2.4): фактические wolf-ключи после ensured — только наши
-        // (mcp.wolf в обоих ветках ниже каноничен; default_agent/subagent_depth — если ключ наш, не занят чужим значением)
+        // F6 (спека 2.1.0 §2.4): фактические wolf-ключи после ensured — по эффективному виду
+        // (mcp.servers.wolf каноничен; default_agent/subagent_depth — если ключ наш, не занят чужим значением)
         const ours = () => {
-            const keys = ['mcp.wolf'];
-            if (cfg.default_agent === DEFAULT_AGENT)
-                keys.push(`default_agent=${DEFAULT_AGENT}`);
-            if (typeof cfg.subagent_depth === 'number' && cfg.subagent_depth >= SUBAGENT_DEPTH)
-                keys.push(`subagent_depth=${cfg.subagent_depth}`);
+            const effective = effectiveAfter(surface, rootCfg);
+            const keys = [];
+            if (isWolfMcpEntry(getPath(effective, MCP_KEY.writePath), cmd))
+                keys.push(MCP_KEY.label);
+            if (getPath(effective, DEFAULT_AGENT_KEY.writePath) === DEFAULT_AGENT)
+                keys.push(`${DEFAULT_AGENT_KEY.label}=${DEFAULT_AGENT}`);
+            const sd = getPath(effective, depthPath);
+            if (depthIsOurs(sd))
+                keys.push(`${depthLeaf}=${sd}`);
             return keys;
         };
-        // unchanged — по ВСЕМ ключам: корректный mcp.wolf не маскирует отсутствие default_agent/subagent_depth
-        if (mcpOk && da !== undefined && sd !== undefined)
-            return { action: 'unchanged', reason, configFile: basename(file), keys: ours() };
-        const replaced = mcp.wolf !== undefined && !mcpOk;
-        mcp.wolf = desired;
-        cfg.mcp = mcp;
-        if (da === undefined)
-            cfg.default_agent = DEFAULT_AGENT; // конфликтный ключ не трогаем
-        if (sd === undefined)
-            cfg.subagent_depth = SUBAGENT_DEPTH; // конфликтный ключ не трогаем
-        await writeFileAtomic(file, JSON.stringify(cfg, null, 2) + '\n');
-        return { action: replaced ? 'replaced' : 'written', reason, configFile: basename(file), keys: ours() };
+        // F-10: отчёт init называет файл, где реально лежат wolf-ключи (при отсутствии
+        // записи — файл, где объявлен эффективный wolf-ключ; иначе — файл записи).
+        const wolfKeyFile = () => {
+            const mcp = locatePath(surface.files, MCP_KEY.writePath);
+            if (mcp !== undefined)
+                return relOf(surface, mcp.location);
+            const agent = locatePath(surface.files, DEFAULT_AGENT_KEY.writePath);
+            if (agent !== undefined)
+                return relOf(surface, agent.location);
+            const depth = locatePath(surface.files, SUBAGENT_DEPTH_KEY.writePath);
+            if (depth !== undefined)
+                return relOf(surface, depth.location);
+            return undefined;
+        };
+        // unchanged — по ВСЕМ ключам: корректный mcp.servers.wolf не маскирует отсутствие default_agent/subagent_depth;
+        // занятое чужим значением место depth тоже settled (не перезаписываем — только reason);
+        // наш легаси mcp.wolf — не settled: его надо снять записью.
+        const setAgent = da === undefined;
+        if (!writeMcp && !dropLegacyMcp && !setAgent && !setDepth && !dropLegacy)
+            return { action: 'unchanged', reason, configFile: wolfKeyFile() ?? basename(file), keys: ours() };
+        if (writeMcp)
+            setPath(rootCfg, MCP_KEY.writePath, desired);
+        if (dropLegacyMcp)
+            deletePath(rootCfg, legacyMcpPath);
+        if (setAgent)
+            setPath(rootCfg, DEFAULT_AGENT_KEY.writePath, DEFAULT_AGENT); // конфликтный ключ не трогаем
+        if (setDepth)
+            setPath(rootCfg, depthPath, SUBAGENT_DEPTH);
+        if (dropLegacy)
+            deletePath(rootCfg, legacyDepthPath);
+        await writeFileAtomic(file, JSON.stringify(rootCfg, null, 2) + '\n');
+        return { action: replaceMcp ? 'replaced' : 'written', reason, configFile: basename(file), keys: ours() };
     }
+    /**
+     * 6.7: wolf-запись MCP (нативная и легаси, только если она наша) удаляется
+     * из ВСЕХ локаций, где она реально объявлена.
+     */
     async removeWolf(projectRoot) {
-        const file = this.configFile(projectRoot);
-        const cfg = await this.readConfig(projectRoot);
-        if (cfg === null)
+        const surface = await this.loadSurface(projectRoot);
+        if (surface.files.length === 0)
             return false;
-        const mcp = asRecord(cfg.mcp);
-        if (mcp === undefined || mcp.wolf === undefined)
-            return false;
-        delete mcp.wolf;
-        if (Object.keys(mcp).length === 0)
-            delete cfg.mcp;
-        else
-            cfg.mcp = mcp;
-        await writeFileAtomic(file, JSON.stringify(cfg, null, 2) + '\n');
-        return true;
+        const legacyMcpPath = legacyPathOf(MCP_KEY);
+        let removed = false;
+        for (const file of surface.files) {
+            let changed = false;
+            const nativeEntry = getPath(file.cfg, MCP_KEY.writePath);
+            const legacyEntry = getPath(file.cfg, legacyMcpPath);
+            if (nativeEntry !== undefined && isWolfMcpEntry(nativeEntry, WOLF_CMD)) {
+                deletePath(file.cfg, MCP_KEY.writePath);
+                changed = true;
+            }
+            if (legacyEntry !== undefined && isWolfMcpEntry(legacyEntry, WOLF_CMD)) {
+                deletePath(file.cfg, legacyMcpPath);
+                changed = true;
+            }
+            if (!changed)
+                continue;
+            removed = true;
+            await writeFileAtomic(file.file, JSON.stringify(file.cfg, null, 2) + '\n');
+        }
+        return removed;
     }
     /**
      * 2.16.2 (uninstall, F-07): только wolf-ключи с точным нашим значением.
      * Пользовательские default_agent/subagent_depth (не наши точные значения) не трогаем.
+     * Глубина: `experimental.subagent_depth === 2` (действующий путь) + легаси верхнеуровневый.
+     * 6.3: удаляем обе формы MCP (нативную и легаси) — только если запись наша.
+     * 6.7: снимаем ключи из ВСЕХ локаций, где они объявлены; битый файл — в причину.
      */
     async removeWolfKeys(projectRoot) {
-        const file = this.configFile(projectRoot);
-        const cfg = await this.readConfig(projectRoot).catch(() => null);
-        if (cfg === null)
-            return { action: 'skipped', reason: `no ${basename(file)}`, configFile: basename(file) };
-        const removed = [];
-        const mcp = asRecord(cfg.mcp);
-        if (mcp !== undefined && mcp.wolf !== undefined) {
-            delete mcp.wolf;
-            if (Object.keys(mcp).length === 0)
-                delete cfg.mcp;
-            else
-                cfg.mcp = mcp;
-            removed.push('mcp.wolf');
-        }
-        if (cfg.default_agent === DEFAULT_AGENT) {
-            delete cfg.default_agent;
-            removed.push(`default_agent=${DEFAULT_AGENT}`);
-        }
-        if (cfg.subagent_depth === SUBAGENT_DEPTH) {
-            delete cfg.subagent_depth;
-            removed.push(`subagent_depth=${SUBAGENT_DEPTH}`);
+        const file = this.rootFile(projectRoot);
+        const surface = await this.loadSurface(projectRoot);
+        const broken = surface.errors.map((error) => `skipped: ${error.rel} is ${error.kind}`);
+        if (surface.files.length === 0) {
+            // «no opencode.json» — только когда конфиг-файлов нет НИ В ОДНОЙ локации
+            return {
+                action: 'skipped',
+                reason: broken.length > 0 ? broken.join('; ') : `no ${basename(file)}`,
+                configFile: basename(file),
+            };
         }
+        let mcpRemoved = false;
+        let agentRemoved = false;
+        let depthRemoved = false;
+        const changed = [];
+        const legacyMcpPath = legacyPathOf(MCP_KEY);
+        const depthLeaf = leaf(SUBAGENT_DEPTH_KEY);
+        const legacyDepthPath = legacyPathOf(SUBAGENT_DEPTH_KEY);
+        // корень первым — так же, как в configFile списке результата
+        for (const file of [...surface.files].reverse()) {
+            let touched = false;
+            const nativeEntry = getPath(file.cfg, MCP_KEY.writePath);
+            const legacyEntry = getPath(file.cfg, legacyMcpPath);
+            if (nativeEntry !== undefined && isWolfMcpEntry(nativeEntry, WOLF_CMD)) {
+                deletePath(file.cfg, MCP_KEY.writePath);
+                mcpRemoved = true;
+                touched = true;
+            }
+            if (legacyEntry !== undefined && isWolfMcpEntry(legacyEntry, WOLF_CMD)) {
+                deletePath(file.cfg, legacyMcpPath);
+                mcpRemoved = true;
+                touched = true;
+            }
+            if (getPath(file.cfg, DEFAULT_AGENT_KEY.writePath) === DEFAULT_AGENT) {
+                deletePath(file.cfg, DEFAULT_AGENT_KEY.writePath);
+                agentRemoved = true;
+                touched = true;
+            }
+            if (getPath(file.cfg, SUBAGENT_DEPTH_KEY.writePath) === SUBAGENT_DEPTH) {
+                deletePath(file.cfg, SUBAGENT_DEPTH_KEY.writePath);
+                depthRemoved = true;
+                touched = true;
+            }
+            if (getPath(file.cfg, legacyDepthPath) === SUBAGENT_DEPTH) {
+                // легаси верхнеуровневый ключ (deprecated в opencode v2) — тоже наш
+                deletePath(file.cfg, legacyDepthPath);
+                depthRemoved = true;
+                touched = true;
+            }
+            if (!touched)
+                continue; // перезаписываем только файлы, из которых сняты наши ключи
+            changed.push(file.rel);
+            await writeFileAtomic(file.file, JSON.stringify(file.cfg, null, 2) + '\n');
+        }
+        const removed = [
+            ...(mcpRemoved ? [MCP_KEY.label] : []),
+            ...(agentRemoved ? [`${DEFAULT_AGENT_KEY.label}=${DEFAULT_AGENT}`] : []),
+            ...(depthRemoved ? [`${depthLeaf}=${SUBAGENT_DEPTH}`] : []),
+        ];
         if (removed.length === 0) {
             return {
                 action: 'unchanged',
-                reason: 'no wolf keys with our exact values',
+                reason: ['no wolf keys with our exact values', ...broken].join('; '),
                 configFile: basename(file),
                 keys: [],
             };
         }
-        await writeFileAtomic(file, JSON.stringify(cfg, null, 2) + '\n');
-        return { action: 'removed', configFile: basename(file), keys: removed };
+        return {
+            action: 'removed',
+            ...(broken.length > 0 ? { reason: broken.join('; ') } : {}),
+            configFile: changed.join(', '),
+            keys: removed,
+        };
+    }
+    /**
+     * 6.1/6.3/6.4: doctor-проверки, которые знает только opencode-адаптер —
+     * все ключи, которые Wolf пишет, + смешанный frontmatter managed-агентов.
+     * Строки идут в общий `issues` проекта и маскируются doctor'ом как обычно.
+     * 6.7: проверки — по эффективному виду обеих локаций; битый файл — свой issue с именем.
+     */
+    async configIssues(projectRoot) {
+        const surface = await this.loadSurface(projectRoot);
+        const issues = surface.errors.map((error) => `${this.id}: ${error.rel} is ${error.kind} — fix it or remove the file, then run wolf init`);
+        if (surface.files.length === 0) {
+            // «missing» советовал бы init, который честно скипает битый конфиг
+            if (issues.length === 0)
+                return [`${this.id}: wolf entry missing — run wolf init`];
+            return issues;
+        }
+        return [
+            ...issues,
+            ...mcpIssues(surface),
+            ...defaultAgentIssues(surface.effective),
+            ...depthIssues(surface),
+            ...(await mixedFrontmatterIssues(projectRoot, this.id)),
+        ];
+    }
+}
+/** Собственный конфиг корневой локации (не слейдженный): в него wolf пишет. */
+function rootConfigOf(surface) {
+    return surface.files.find((f) => f.location === WRITE_LOCATION_ID)?.cfg ?? {};
+}
+/** Путь файла локации относительно корня проекта (для сообщений). */
+function relOf(surface, location) {
+    return surface.files.find((f) => f.location === location)?.rel ?? '';
+}
+/** Эффективный вид после записи: обновлённый корень + .opencode (порядок — в mergeSurface). */
+function effectiveAfter(surface, rootCfg) {
+    return mergeSurface(surface.files, { location: WRITE_LOCATION_ID, cfg: rootCfg });
+}
+/** 6.3/6.7: wolf-сервер отсутствует в обеих формах / легаси-форма подлежит миграции. */
+function mcpIssues(surface) {
+    const cfg = surface.effective;
+    // запись невозможна: init не вылечит такой конфиг — не советуем его
+    const blocked = blockedSegment(cfg, MCP_KEY.writePath);
+    if (blocked !== undefined)
+        return [`opencode: ${blocked} is not an object — ${MCP_KEY.label} is not written; fix it manually`];
+    const legacyPath = legacyPathOf(MCP_KEY);
+    const nativeAt = locatePath(surface.files, MCP_KEY.writePath);
+    const legacyAt = locatePath(surface.files, legacyPath);
+    // сервер не объявлен НИ В ОДНОЙ локации — только тогда «wolf entry missing»
+    if (nativeAt === undefined && legacyAt === undefined)
+        return [`opencode: wolf entry missing — run wolf init`];
+    if (legacyAt === undefined)
+        return [];
+    const ours = isWolfMcpEntry(legacyAt.value, WOLF_CMD);
+    // легаси в .opencode: init туда не пишет — советуем ручную миграцию с именем файла
+    if (legacyAt.location === WRITE_LOCATION_ID) {
+        return [
+            ours
+                ? `opencode: wolf entry is in the deprecated top-level ${legacyPath.join('.')} form — run wolf init to migrate it to ${MCP_KEY.label}`
+                : `opencode: top-level ${legacyPath.join('.')} is foreign and deprecated (opencode v2 reads ${MCP_ROOT}.${MCP_SERVERS}) — wolf leaves it untouched`,
+        ];
+    }
+    const rel = relOf(surface, legacyAt.location);
+    return [
+        ours
+            ? `opencode: wolf entry is in the deprecated top-level ${legacyPath.join('.')} form in ${rel} — migrate it to ${MCP_KEY.label} manually`
+            : `opencode: top-level ${legacyPath.join('.')} in ${rel} is foreign and deprecated (opencode v2 reads ${MCP_ROOT}.${MCP_SERVERS}) — wolf leaves it untouched`,
+    ];
+}
+/** 6.1: default_agent === mr-wolf, иначе L0 стартует не тем агентом. */
+function defaultAgentIssues(cfg) {
+    const da = getPath(cfg, DEFAULT_AGENT_KEY.writePath);
+    if (da === undefined)
+        return [
+            `opencode: ${DEFAULT_AGENT_KEY.label} is not set — ${DEFAULT_AGENT} is not the default agent; run wolf init`,
+        ];
+    if (da !== DEFAULT_AGENT)
+        return [
+            `opencode: ${DEFAULT_AGENT_KEY.label}=${String(da)} is taken; ${DEFAULT_AGENT} is not assigned (foreign value is never overwritten)`,
+        ];
+    return [];
+}
+/** 6.1/6.7: experimental.subagent_depth >= 2 + deprecated верхнеуровневый ключ (по эффективному виду). */
+function depthIssues(surface) {
+    const cfg = surface.effective;
+    const out = [];
+    const depthPath = SUBAGENT_DEPTH_KEY.writePath;
+    const parentPath = depthPath.slice(0, -1);
+    const depthLabel = depthPath.join('.');
+    const depthLeaf = depthPath[depthPath.length - 1];
+    const parentRaw = getPath(cfg, parentPath);
+    const experimental = getRecordAt(cfg, parentPath);
+    const depth = experimental?.[depthLeaf];
+    if (parentRaw !== undefined && experimental === undefined) {
+        out.push(`opencode: ${parentPath.join('.')} is not an object — ${depthLabel} is not set; set it to ${SUBAGENT_DEPTH} manually`);
+    }
+    else if (depth === undefined) {
+        out.push(`opencode: ${depthLabel} is not set — the three-level scheme needs >=${SUBAGENT_DEPTH}; run wolf init`);
+    }
+    else if (typeof depth !== 'number' || depth < SUBAGENT_DEPTH) {
+        out.push(`opencode: ${depthLabel}=${String(depth)} — the three-level scheme needs >=${SUBAGENT_DEPTH}; foreign value is never overwritten`);
+    }
+    const legacyPath = legacyPathOf(SUBAGENT_DEPTH_KEY);
+    const legacyAt = locatePath(surface.files, legacyPath);
+    if (legacyAt !== undefined) {
+        const legacy = legacyAt.value;
+        // легаси в .opencode: init туда не пишет — миграция ручная, с именем файла
+        if (legacyAt.location === WRITE_LOCATION_ID) {
+            out.push(legacy === SUBAGENT_DEPTH
+                ? `opencode: top-level ${legacyPath.join('.')}=${SUBAGENT_DEPTH} is deprecated and ignored by opencode v2 — run wolf init to migrate it to ${depthLabel}`
+                : `opencode: top-level ${legacyPath.join('.')}=${String(legacy)} is deprecated and ignored by opencode v2 — foreign value, set ${depthLabel} >=${SUBAGENT_DEPTH} manually`);
+        }
+        else {
+            const rel = relOf(surface, legacyAt.location);
+            out.push(legacy === SUBAGENT_DEPTH
+                ? `opencode: top-level ${legacyPath.join('.')}=${SUBAGENT_DEPTH} in ${rel} is deprecated and ignored by opencode v2 — migrate it to ${depthLabel} manually`
+                : `opencode: top-level ${legacyPath.join('.')}=${String(legacy)} in ${rel} is deprecated and ignored by opencode v2 — foreign value, set ${depthLabel} >=${SUBAGENT_DEPTH} manually`);
+        }
+    }
+    return out;
+}
+/** v2-поля агента: их появление включает чтение файла по схеме V2. */
+const V2_AGENT_FIELDS = ['permissions', 'request', 'system', 'disabled'];
+/** v1-поля агента: в V2-режиме молча игнорируются (6.4). */
+const V1_AGENT_FIELDS = ['permission', 'temperature', 'mode'];
+/**
+ * 6.4: managed-агент (есть штамп Wolf) со смешанным frontmatter читается как V2,
+ * и v1-правила (`permission.task: deny`) исчезают — предупреждаем, не правим файл.
+ */
+async function mixedFrontmatterIssues(projectRoot, platformId) {
+    const dir = join(projectRoot, '.opencode', 'agents');
+    const names = await fs.readdir(dir).catch(() => []);
+    const out = [];
+    for (const name of names) {
+        if (!name.endsWith('.md'))
+            continue;
+        const raw = await fs.readFile(join(dir, name), 'utf-8').catch(() => null);
+        if (raw === null || parseStamp(raw) === null)
+            continue; // чужой файл — не наш scope
+        const front = frontmatterOf(raw);
+        if (front === undefined)
+            continue;
+        const v2 = V2_AGENT_FIELDS.filter((field) => front[field] !== undefined);
+        const v1 = V1_AGENT_FIELDS.filter((field) => front[field] !== undefined);
+        if (v2.length === 0 || v1.length === 0)
+            continue;
+        out.push(`${platformId}: ${join('.opencode', 'agents', name)} mixes v2 (${v2.join(', ')}) and v1 (${v1.join(', ')}) frontmatter — the file is read as V2 and v1 fields are ignored; do not mix formats in one file`);
+    }
+    return out;
+}
+/** YAML-frontmatter файла агента; нет блока/битый YAML — undefined. */
+function frontmatterOf(raw) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+    if (match === null)
+        return undefined;
+    try {
+        const parsed = yaml.load(match[1]);
+        return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
     }
 }
 function asRecord(value) {
@@ -177,11 +622,4 @@ function asRecord(value) {
         ? value
         : undefined;
 }
-function asConfig(value, file) {
-    const cfg = asRecord(value);
-    if (cfg === undefined) {
-        throw new UserFacingError(`${file} is not a JSON object — refusing to touch it`);
-    }
-    return cfg;
-}
 //# sourceMappingURL=opencode-adapter.js.map