@uniqbit/mate-core 0.18.4 → 1.0.0-canary.0

package/src/tools/setup/contribution-ledger.ts

@@ -1,207 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { FRAMEWORK_NAME } from "../../framework";
-import { writeAtomic } from "../../runtime/write-atomic";
-import { instructionBlockKey } from "./context-services";
-import type { CapabilityContributionInput, RuntimeContributions } from "./plugin";
-
-/**
- * Contribution Ledger: which plugin owns each contribution a persisted pass
- * applied to the companion, per Agent Runtime. Committed with the companion,
- * because it describes committed files: a clone that never loaded a plugin
- * must still be able to remove what another clone committed. It records
- * identities only (names, block keys, markers, entries), never a value, so it
- * carries no secret.
- */
-
-export const CONTRIBUTION_LEDGER_VERSION = 1;
-
-/** The identities one owner applied on one runtime. Absent kinds are none. */
-export interface LedgerIdentities {
-  mcpServers?: string[];
-  guidanceKeys?: string[];
-  skillTrees?: string[];
-  agentDefinitions?: string[];
-  hookMarkers?: string[];
-  permissionEntries?: string[];
-  pluginReferences?: string[];
-}
-
-export interface ContributionLedger {
-  version: number;
-  /** Runtime id → owning plugin id → identities. */
-  runtimes: Record<string, Record<string, LedgerIdentities>>;
-  /** Audience plugin packages the upgrade sweep could not load; retried by every pass. */
-  unswept?: string[];
-}
-
-export function contributionLedgerPath(companionPath: string): string {
-  return path.join(companionPath, `.${FRAMEWORK_NAME}`, "config", "contribution-ledger.json");
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function stringList(value: unknown): string[] {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
-}
-
-const IDENTITY_KINDS = [
-  "agentDefinitions",
-  "guidanceKeys",
-  "hookMarkers",
-  "mcpServers",
-  "permissionEntries",
-  "pluginReferences",
-  "skillTrees",
-] as const satisfies readonly (keyof LedgerIdentities)[];
-
-function sortedUnique(values: Iterable<string>): string[] {
-  return [...new Set(values)].toSorted();
-}
-
-/** Sorted kinds and values, empty kinds dropped; `null` when nothing is left. */
-function normalizeIdentities(identities: LedgerIdentities): LedgerIdentities | null {
-  const normalized: LedgerIdentities = {};
-  for (const kind of IDENTITY_KINDS) {
-    const values = sortedUnique(identities[kind] ?? []);
-    if (values.length > 0) normalized[kind] = values;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : null;
-}
-
-/** Sorted runtimes and owners; empty owners and runtimes dropped. */
-function normalizeLedger(ledger: ContributionLedger): ContributionLedger {
-  const runtimes: ContributionLedger["runtimes"] = {};
-  for (const runtimeId of Object.keys(ledger.runtimes).toSorted()) {
-    const owners: Record<string, LedgerIdentities> = {};
-    for (const owner of Object.keys(ledger.runtimes[runtimeId] ?? {}).toSorted()) {
-      const identities = normalizeIdentities(ledger.runtimes[runtimeId]![owner]!);
-      if (identities) owners[owner] = identities;
-    }
-    if (Object.keys(owners).length > 0) runtimes[runtimeId] = owners;
-  }
-  const unswept = sortedUnique(ledger.unswept ?? []);
-  return {
-    version: CONTRIBUTION_LEDGER_VERSION,
-    runtimes,
-    ...(unswept.length > 0 ? { unswept } : {}),
-  };
-}
-
-/** The companion's ledger; `null` when absent or unreadable, which a pass treats as never recorded. */
-export async function readContributionLedger(
-  companionPath: string,
-): Promise<ContributionLedger | null> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(await fs.readFile(contributionLedgerPath(companionPath), "utf8"));
-  } catch {
-    return null;
-  }
-  if (!isRecord(parsed) || !isRecord(parsed.runtimes)) return null;
-  const runtimes: ContributionLedger["runtimes"] = {};
-  for (const [runtimeId, owners] of Object.entries(parsed.runtimes)) {
-    if (!isRecord(owners)) continue;
-    runtimes[runtimeId] = {};
-    for (const [owner, identities] of Object.entries(owners)) {
-      if (!isRecord(identities)) continue;
-      const read: LedgerIdentities = {};
-      for (const kind of IDENTITY_KINDS) read[kind] = stringList(identities[kind]);
-      runtimes[runtimeId][owner] = read;
-    }
-  }
-  return normalizeLedger({
-    version: CONTRIBUTION_LEDGER_VERSION,
-    runtimes,
-    unswept: stringList(parsed.unswept),
-  });
-}
-
-/** Writes the ledger in its stable form; an unchanged ledger leaves the file untouched. */
-export async function writeContributionLedger(
-  companionPath: string,
-  ledger: ContributionLedger,
-): Promise<void> {
-  const target = contributionLedgerPath(companionPath);
-  const text = `${JSON.stringify(normalizeLedger(ledger), null, 2)}\n`;
-  const existing = await fs.readFile(target, "utf8").catch(() => null);
-  if (existing === text) return;
-  await fs.mkdir(path.dirname(target), { recursive: true });
-  await writeAtomic(target, text);
-}
-
-/** The identities a contribution set applies for `pluginId`. */
-export function identitiesOf(
-  pluginId: string,
-  contributions: RuntimeContributions,
-): LedgerIdentities {
-  return {
-    mcpServers: (contributions.mcpServers ?? []).map((server) => server.name),
-    guidanceKeys: (contributions.guidanceSections ?? []).map((section) =>
-      instructionBlockKey(pluginId, section.content),
-    ),
-    skillTrees: (contributions.skillTrees ?? []).map((tree) => tree.name),
-    agentDefinitions: (contributions.agentDefinitions ?? []).map((agent) => agent.name),
-    hookMarkers: (contributions.hookGroups ?? []).map((hook) => hook.marker),
-    permissionEntries: [...(contributions.permissionEntries ?? [])],
-    pluginReferences: (contributions.pluginReferences ?? []).map((entry) => entry.reference),
-  };
-}
-
-/** The ledger a pass leaves: what its enabled inputs applied, per runtime and owner. */
-export function ledgerFromInputs(
-  inputsByRuntime: ReadonlyMap<string, readonly CapabilityContributionInput[]>,
-  unswept: readonly string[] = [],
-): ContributionLedger {
-  const runtimes: ContributionLedger["runtimes"] = {};
-  for (const [runtimeId, inputs] of inputsByRuntime) {
-    const owners: Record<string, LedgerIdentities> = {};
-    for (const input of inputs) {
-      if (!input.enabled) continue;
-      const identities = identitiesOf(input.pluginId, input.contributions);
-      const merged = owners[input.pluginId] ?? {};
-      for (const kind of IDENTITY_KINDS) {
-        merged[kind] = [...(merged[kind] ?? []), ...(identities[kind] ?? [])];
-      }
-      owners[input.pluginId] = merged;
-    }
-    runtimes[runtimeId] = owners;
-  }
-  return normalizeLedger({ version: CONTRIBUTION_LEDGER_VERSION, runtimes, unswept: [...unswept] });
-}
-
-/**
- * A disabled input naming every recorded identity of `owner`, so each Runtime
- * Surface removes them through its existing disabled-input path. Removal keys
- * on identity only, so no value is needed: guidance is stripped by owner, a
- * hook group by its marker, a plugin reference by its exact entry.
- */
-export function ledgerTeardownInput(
-  owner: string,
-  identities: LedgerIdentities,
-): CapabilityContributionInput {
-  return {
-    pluginId: owner,
-    enabled: false,
-    capabilityEnabled: false,
-    contributions: {
-      mcpServers: (identities.mcpServers ?? []).map((name) => ({ name })),
-      guidanceSections: (identities.guidanceKeys ?? []).length > 0 ? [{ content: "" }] : [],
-      skillTrees: (identities.skillTrees ?? []).map((name) => ({ name, sourceDir: "" })),
-      agentDefinitions: (identities.agentDefinitions ?? []).map((name) => ({ name, content: "" })),
-      hookGroups: (identities.hookMarkers ?? []).map((marker) => ({
-        event: "",
-        marker,
-        group: {},
-      })),
-      permissionEntries: [...(identities.permissionEntries ?? [])],
-      pluginReferences: (identities.pluginReferences ?? []).map((reference) => ({
-        reference,
-        isManagedReference: (entry: unknown) => entry === reference,
-      })),
-    },
-  };
-}

package/src/tools/setup/isolation-diagnostics.ts

@@ -1,139 +0,0 @@
-// oxlint-disable no-await-in-loop
-import path from "node:path";
-
-import type { FrameworkConfig } from "../../lib/orchestrator/types";
-import {
-  readContributionLedger,
-  type ContributionLedger,
-  type LedgerIdentities,
-} from "./contribution-ledger";
-import type { CapabilityPlugin, SetupContext } from "./plugin";
-import type { PluginRegistry } from "./registry";
-import { managedGuidanceOwners } from "./upgrade-sweep";
-
-/**
- * What `mate doctor` reports about audience isolation: contributions on the
- * companion's persisted surfaces that no base plugin owns, audience plugins
- * the upgrade sweep could not load, and the active audience's plugins whose
- * imperative parts a launch layer cannot deliver.
- */
-
-export interface LeakedContribution {
-  /** Companion-relative file or directory. */
-  surface: string;
-  kind: string;
-  /** The entry's name; absent where the surface entry is the owner's block. */
-  identity?: string;
-  owner: string;
-}
-
-export interface UndeliveredAudiencePlugin {
-  pluginId: string;
-  /** `apply`, `teardown`, `forProvider` or `pluginReferences`. */
-  parts: string[];
-}
-
-export interface AudienceIsolationReport {
-  leaked: LeakedContribution[];
-  unswept: string[];
-  undelivered: UndeliveredAudiencePlugin[];
-}
-
-/** Ledger kinds by where each runtime keeps them; guidance is read from the files themselves. */
-const LEDGER_SURFACES: Record<string, Partial<Record<keyof LedgerIdentities, string>>> = {
-  claude: {
-    mcpServers: ".mcp.json",
-    skillTrees: path.join(".claude", "skills"),
-    agentDefinitions: path.join(".claude", "agents"),
-    hookMarkers: path.join(".claude", "settings.local.json"),
-    permissionEntries: path.join(".claude", "settings.local.json"),
-  },
-  opencode: {
-    mcpServers: path.join(".opencode", "opencode.json"),
-    pluginReferences: path.join(".opencode", "opencode.json"),
-    skillTrees: path.join(".agents", "skills"),
-    agentDefinitions: path.join(".opencode", "agents"),
-  },
-};
-
-function leakedLedgerContributions(
-  ledger: ContributionLedger | null,
-  baseIds: ReadonlySet<string>,
-): LeakedContribution[] {
-  const leaked: LeakedContribution[] = [];
-  for (const [runtimeId, owners] of Object.entries(ledger?.runtimes ?? {})) {
-    for (const [owner, identities] of Object.entries(owners)) {
-      if (baseIds.has(owner)) continue;
-      for (const [kind, surface] of Object.entries(LEDGER_SURFACES[runtimeId] ?? {})) {
-        for (const identity of identities[kind as keyof LedgerIdentities] ?? []) {
-          leaked.push({ surface: surface!, kind, identity, owner });
-        }
-      }
-    }
-  }
-  return leaked;
-}
-
-/**
- * Whether a lifecycle hook does anything. `apply` and `teardown` are required
- * members, so a declarative plugin carries empty ones; only a body counts.
- */
-function hasBody(hook: unknown): boolean {
-  if (typeof hook !== "function") return false;
-  const source = Function.prototype.toString.call(hook);
-  const open = source.indexOf("{");
-  const close = source.lastIndexOf("}");
-  if (open === -1 || close <= open) return true;
-  const body = source
-    .slice(open + 1, close)
-    .replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, "")
-    .trim();
-  return body.length > 0;
-}
-
-async function undeliveredParts(plugin: CapabilityPlugin, ctx: SetupContext): Promise<string[]> {
-  const parts: string[] = [];
-  if (hasBody(plugin.apply)) parts.push("apply");
-  if (hasBody(plugin.teardown)) parts.push("teardown");
-  if (plugin.forProvider && Object.keys(plugin.forProvider).length > 0) parts.push("forProvider");
-  try {
-    const byRuntime = (await plugin.getRuntimeContributions?.(ctx)) ?? {};
-    if (Object.values(byRuntime).some((runtime) => (runtime?.pluginReferences ?? []).length > 0)) {
-      parts.push("pluginReferences");
-    }
-  } catch {
-    /** A plugin whose declarations fail is the plugin checks' finding, not this one. */
-  }
-  return parts;
-}
-
-export async function inspectAudienceIsolation(
-  companionPath: string,
-  config: FrameworkConfig,
-  registry: PluginRegistry,
-  activeAudience: string | null,
-): Promise<AudienceIsolationReport> {
-  const baseIds = new Set(registry.baseRegistrations().map((entry) => entry.plugin.id));
-  const leaked: LeakedContribution[] = [];
-
-  for (const [surface, owners] of await managedGuidanceOwners(companionPath)) {
-    for (const owner of owners) {
-      if (!baseIds.has(owner)) leaked.push({ surface, kind: "guidance", owner });
-    }
-  }
-
-  const ledger = await readContributionLedger(companionPath);
-  leaked.push(...leakedLedgerContributions(ledger, baseIds));
-
-  const undelivered: UndeliveredAudiencePlugin[] = [];
-  if (activeAudience) {
-    const ctx: SetupContext = { companionPath, config, mode: "sync", activeProviders: [] };
-    for (const { plugin } of registry.audienceRegistrations(activeAudience)) {
-      if (plugin.kind !== "capability") continue;
-      const parts = await undeliveredParts(plugin as CapabilityPlugin, ctx);
-      if (parts.length > 0) undelivered.push({ pluginId: plugin.id, parts });
-    }
-  }
-
-  return { leaked, unswept: ledger?.unswept ?? [], undelivered };
-}

package/src/tools/setup/runtime-documents.ts

@@ -1,291 +0,0 @@
-import path from "node:path";
-
-import { runtimeOpenCodePluginRoot } from "../../runtime/runtime-directory";
-import {
-  CLAUDE_LOCAL_CONFIG_DOCUMENT,
-  CLAUDE_SETTINGS_DOCUMENT,
-  OPENCODE_CONFIG_DOCUMENT,
-  OPENCODE_MCP_SERVERS_AT,
-  type ManagedRegion,
-  type RenderedRuntimeDocument,
-} from "../../runtime/runtime-document-manifest";
-import type { CapabilityContributionInput, SetupContext } from "./plugin";
-import {
-  mateBannerHookGroups,
-  mateGuardHookGroups,
-  mateGuidanceHookGroups,
-  mateSessionPrepareHookGroups,
-} from "./providers/claude-plugin-hooks";
-import {
-  renderManagedClaudeHookGroups,
-  renderManagedClaudeMcpServers,
-  renderManagedClaudePermissionEntries,
-} from "./providers/claude";
-import {
-  renderCompanionExternalDirectoryPermissions,
-  renderManagedOpenCodeMcpServers,
-} from "./providers/opencode";
-import { isRecord, readOpenCodeConfig } from "./providers/opencode-format";
-import { projectionRepoRoot } from "./surface-target";
-
-/**
- * The working target's documents, rendered as values. Each is a document the
- * runtime finds by walking up from the current directory, and every path inside
- * one still names the Companion Repository — only where the document is placed
- * differs from the companion target.
- */
-
-export { CLAUDE_LOCAL_CONFIG_DOCUMENT };
-
-function nonEmpty(region: ManagedRegion): boolean {
-  if (region.kind === "list") return region.values.length > 0;
-  if (region.kind === "map") return Object.keys(region.entries).length > 0;
-  return true;
-}
-
-function document(documentPath: string, regions: ManagedRegion[]): RenderedRuntimeDocument[] {
-  const kept = regions.filter(nonEmpty);
-  return kept.length > 0 ? [{ path: documentPath, regions: kept }] : [];
-}
-
-/**
- * The Mate plugin root is what makes an Unmanaged OpenCode session load the
- * companion guidance at all: OpenCode has no config channel for a generated
- * system prompt, so the plugin is the only injection point. It is named through
- * the runtime directory, so a reinstall does not strand a wrapped repository.
- * The managed launch carries no overlay of its own, so this document is the one
- * place every OpenCode session in the repository loads it from.
- */
-
-/**
- * Loaded by a managed session beside the launch's plugin. Mate hooks here run
- * twice there, inertly: guard is input-pure, guidance/prepare yield under a
- * launch env, banner is `--projected`. Capability groups run once: the launch
- * omits them from `--settings`. A launch passes no `--add-dir`; it relies on
- * `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` for companion `CLAUDE.md`.
- */
-function claudeSettingsRegions(
-  ctx: SetupContext,
-  inputs: CapabilityContributionInput[],
-): ManagedRegion[] {
-  const capabilityHooks = renderManagedClaudeHookGroups(inputs);
-  const mateHooks: Record<string, unknown[]> = {
-    PreToolUse: mateGuardHookGroups(),
-    SessionStart: [
-      ...mateBannerHookGroups(),
-      ...mateGuidanceHookGroups(),
-      ...mateSessionPrepareHookGroups(),
-    ],
-  };
-  const events = [...new Set([...Object.keys(mateHooks), ...Object.keys(capabilityHooks)])];
-  return [
-    ...events.map((event): ManagedRegion => ({
-      at: ["hooks", event],
-      kind: "list",
-      values: [...(mateHooks[event] ?? []), ...(capabilityHooks[event] ?? [])],
-    })),
-    /**
-     * `stripPrefix` heals a repository an older Mate wrapped. That version wrote
-     * the whole launch environment here, and Claude Code applies `env` to the
-     * session, so every hook in a bare session inherited `MATE_*` and read the
-     * repository as a Managed Session — silently, since looking managed is
-     * exactly what makes the guidance hook emit nothing. Guidance must be the
-     * projection's to give in an Unmanaged Session, so no `MATE_*` key may
-     * survive here.
-     */
-    {
-      at: ["env"],
-      kind: "map",
-      entries: { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" },
-      stripPrefix: "MATE_",
-    },
-    {
-      at: ["permissions", "allow"],
-      kind: "list",
-      values: renderManagedClaudePermissionEntries(ctx.companionPath, inputs),
-    },
-  ];
-}
-
-export function renderDocumentsForTarget(
-  ctx: SetupContext,
-  inputsByRuntime: Map<string, CapabilityContributionInput[]>,
-): RenderedRuntimeDocument[] {
-  const repoRoot = projectionRepoRoot(ctx);
-
-  const documents: RenderedRuntimeDocument[] = [];
-  if (ctx.activeProviders.includes("claude")) {
-    const inputs = inputsByRuntime.get("claude") ?? [];
-    documents.push(...document(CLAUDE_SETTINGS_DOCUMENT, claudeSettingsRegions(ctx, inputs)));
-    /**
-     * Local scope, not `.mcp.json`: a project-scoped server is inert until a
-     * human approves it in a session, which an Unmanaged Session is exactly the
-     * case that cannot rely on. The repo path is the key Claude Code files a
-     * project under, resolved so a symlinked working directory still matches.
-     *
-     * Confirmed against a real `~/.claude.json`: the keys there are the
-     * directories sessions started in, not repository roots — sibling
-     * directories of one checkout each hold their own entry, as do temporary
-     * directories. So this reaches exactly one session: the one started at the
-     * repository root. A session started in a subdirectory of a wrapped
-     * repository has its own key, finds no `mcpServers` under it, and sees none
-     * of these servers — the Unmanaged Session case this document exists for,
-     * missed. That limit is deliberate. The directories a session might start
-     * in are unbounded, and every one of them would be a fresh entry in the
-     * user's global configuration that nothing later reclaims; keying the
-     * repository root only keeps the projection's footprint there to a single
-     * key. A subdirectory session still gets the rest of the projection — the
-     * documents inside the repository are found by the runtime's own upward
-     * walk — it loses only the MCP servers.
-     */
-    documents.push(
-      ...document(CLAUDE_LOCAL_CONFIG_DOCUMENT, [
-        {
-          at: ["projects", repoRoot, "mcpServers"],
-          kind: "map",
-          entries: renderManagedClaudeMcpServers(inputs),
-        },
-      ]),
-    );
-  }
-  if (ctx.activeProviders.includes("opencode")) {
-    const inputs = inputsByRuntime.get("opencode") ?? [];
-    documents.push(
-      ...document(OPENCODE_CONFIG_DOCUMENT, [
-        {
-          at: ["plugins"],
-          kind: "list",
-          values: [runtimeOpenCodePluginRoot()],
-        },
-        {
-          at: [...OPENCODE_MCP_SERVERS_AT],
-          kind: "map",
-          entries: renderManagedOpenCodeMcpServers(inputs),
-        },
-        {
-          at: ["permissions"],
-          kind: "list",
-          values: renderCompanionExternalDirectoryPermissions(ctx.companionPath),
-        },
-        {
-          at: ["skills"],
-          kind: "list",
-          values: [path.join(ctx.companionPath, ".agents", "skills")],
-        },
-        { at: ["references"], kind: "map", entries: { mate: ctx.companionPath } },
-      ]),
-    );
-  }
-  return documents;
-}
-
-/** Keys Mate renders its own regions for; the companion's values join those regions. */
-const MATE_OPENCODE_KEYS = new Set(["plugins", "permissions", "skills", "mcp", "references"]);
-
-function relativePathValues(value: unknown, at: string[]): string[] {
-  if (typeof value === "string") {
-    return value.startsWith("./") || value.startsWith("../") ? [at.join(".")] : [];
-  }
-  if (Array.isArray(value)) {
-    return value.flatMap((entry, index) => relativePathValues(entry, [...at, String(index)]));
-  }
-  if (isRecord(value)) {
-    return Object.entries(value).flatMap(([key, entry]) => relativePathValues(entry, [...at, key]));
-  }
-  return [];
-}
-
-/** Replaces the region at `at` with what `merge` builds from it, or appends one. */
-function upsertRegion(
-  regions: ManagedRegion[],
-  at: string[],
-  merge: (found: ManagedRegion | undefined) => ManagedRegion,
-): void {
-  const key = JSON.stringify(at);
-  const index = regions.findIndex((region) => JSON.stringify(region.at) === key);
-  if (index === -1) regions.push(merge(undefined));
-  else regions[index] = merge(regions[index]);
-}
-
-/** Mate's own values stay; companion values it does not already list go first. */
-function mergeListRegion(regions: ManagedRegion[], at: string[], extra: unknown[]): void {
-  upsertRegion(regions, at, (found) => {
-    const own = found?.kind === "list" ? found.values : [];
-    const seen = new Set(own.map((value) => JSON.stringify(value)));
-    const values = [...extra.filter((value) => !seen.has(JSON.stringify(value))), ...own];
-    return { at, kind: "list", values };
-  });
-}
-
-/** Mate's own entries win over companion entries of the same name. */
-function mergeMapRegion(
-  regions: ManagedRegion[],
-  at: string[],
-  extra: Record<string, unknown>,
-): void {
-  upsertRegion(regions, at, (found) => {
-    const own = found?.kind === "map" ? found.entries : {};
-    return { at, kind: "map", entries: { ...extra, ...own } };
-  });
-}
-
-/** Relative reference paths resolved against the companion's `.opencode/`. */
-function resolveReferences(
-  references: Record<string, unknown>,
-  companionDir: string,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(references).map(([name, reference]) => [
-      name,
-      typeof reference === "string" && !path.isAbsolute(reference)
-        ? path.resolve(companionDir, reference)
-        : reference,
-    ]),
-  );
-}
-
-/**
- * Folds the companion's `.opencode/opencode.json` into the wrapped document.
- * Mate's regions beat companion values; other top-level keys yield to the
- * repository's. `references` resolve against the companion's `.opencode/`;
- * other relative paths are reported, not rewritten.
- */
-export async function mergeCompanionOpenCodeConfig(
-  companionPath: string,
-  documents: RenderedRuntimeDocument[],
-): Promise<{ documents: RenderedRuntimeDocument[]; warnings: string[] }> {
-  const index = documents.findIndex((document) => document.path === OPENCODE_CONFIG_DOCUMENT);
-  const companionConfigPath = path.join(companionPath, ".opencode", "opencode.json");
-  const companion = index === -1 ? null : await readOpenCodeConfig(companionConfigPath);
-  if (!companion?.present) return { documents, warnings: [] };
-
-  const regions = [...documents[index]!.regions] as ManagedRegion[];
-  const warnings: string[] = [];
-
-  const companionDir = path.dirname(companionConfigPath);
-  for (const [key, value] of Object.entries(companion.config)) {
-    if (key === "$schema") continue;
-    if (key === "references" && isRecord(value)) {
-      mergeMapRegion(regions, ["references"], resolveReferences(value, companionDir));
-      continue;
-    }
-    for (const at of relativePathValues(value, [key])) {
-      warnings.push(
-        `${companionConfigPath}: ${at} is a relative path, which resolves against the working repository once merged into ${OPENCODE_CONFIG_DOCUMENT}; use an absolute path.`,
-      );
-    }
-    if (MATE_OPENCODE_KEYS.has(key)) {
-      if (key === "mcp" && isRecord(value) && isRecord(value.servers)) {
-        mergeMapRegion(regions, [...OPENCODE_MCP_SERVERS_AT], value.servers);
-      } else if (Array.isArray(value)) {
-        mergeListRegion(regions, [key], value);
-      }
-      continue;
-    }
-    regions.push({ at: [key], kind: "value", value, yields: true });
-  }
-
-  const next = [...documents];
-  next[index] = { path: OPENCODE_CONFIG_DOCUMENT, regions };
-  return { documents: next, warnings };
-}