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

package/src/lib/orchestrator/adapters/claude-args.ts

@@ -0,0 +1,50 @@
+/** Reads the operator's `claude` arguments as tokens, for where Mate's appended prompt goes. */
+
+export const APPEND_PROMPT_FLAG = "--append-system-prompt";
+
+function flagArgs(args: readonly string[]): readonly string[] {
+  const terminator = args.indexOf("--");
+  return terminator === -1 ? args : args.slice(0, terminator);
+}
+
+/**
+ * The operator's own `--append-system-prompt` values, lifted out of `args`:
+ * Claude keeps only the last such flag, so each would replace Mate's Agent
+ * Guidance instead of following it. A trailing flag without a value
+ * stays, for Claude to reject. `boundary` is where a lifted flag stood before
+ * an argument that is no flag: a variadic option such as `--add-dir` before
+ * it would otherwise read that argument as its own value, so Mate's flag goes
+ * there. Only the first such place is kept: Claude reads one prompt.
+ */
+export function liftAppendedPrompts(args: readonly string[]): {
+  args: string[];
+  prompts: string[];
+  boundary?: number;
+} {
+  const flags = flagArgs(args);
+  const kept: string[] = [];
+  const prompts: string[] = [];
+  const liftedAt: number[] = [];
+  for (let index = 0; index < flags.length; index += 1) {
+    const arg = flags[index]!;
+    if (arg === APPEND_PROMPT_FLAG && index + 1 < flags.length) {
+      prompts.push(flags[index + 1]!);
+      liftedAt.push(kept.length);
+      index += 1;
+    } else if (arg.startsWith(`${APPEND_PROMPT_FLAG}=`)) {
+      prompts.push(arg.slice(APPEND_PROMPT_FLAG.length + 1));
+      liftedAt.push(kept.length);
+    } else {
+      kept.push(arg);
+    }
+  }
+  const passthrough = [...kept, ...args.slice(flags.length)];
+  const boundary = liftedAt.find(
+    (at) => at > 0 && at < passthrough.length && !passthrough[at]!.startsWith("-"),
+  );
+  return {
+    args: passthrough,
+    prompts,
+    ...(boundary === undefined ? {} : { boundary }),
+  };
+}

package/src/lib/orchestrator/adapters/claude.ts

@@ -5,126 +5,75 @@ import path from "node:path";
 import { FRAMEWORK_NAME } from "../../../framework";
 import { buildCompanionGuidance } from "../../../playbooks/companion-guidance";
 import {
+  launchPluginFolders,
   planClaudeDelivery,
   type ClaudeDeliveryPlan,
-  type SessionKind,
 } from "../../../runtime/claude-delivery-plan";
-import {
-  audienceLayerDir,
-  currentAudienceLayer,
-  readLayerGuidanceSync,
-} from "../../../runtime/audience-layer";
 import { hookGroupKey, type ClaudeHookGroup } from "../../../runtime/claude-hook-group";
+import { resolveSecretPolicy } from "../../../runtime/policy";
+import { managedSessionKind } from "../../../runtime/session-kind";
 import { NOT_WRAPPED } from "../../../runtime/wrap-state";
 import { writeAtomic } from "../../../runtime/write-atomic";
 import {
   getCompanionClaudeMcpConfigPath,
   getCompanionClaudeSettingsPath,
 } from "../../../tools/setup/providers/claude";
+import { definesUserClaudeAttribution } from "../../../tools/setup/providers/claude-attribution";
 import type { ClaudeSettings } from "../../../tools/setup/providers/claude-format";
-import { getContextModePackageRoot, validateContextModePackage } from "../../context-mode-package";
 import { getClaudePluginRoot, validateClaudePluginAssets } from "../../package-paths";
-import type { RenderedAudienceLayer } from "../../../tools/setup/audience-layer";
 import type { PrepareResult } from "../session-prepare";
 import { LaunchPreflightError } from "../types";
 import { type AdapterContext, LaunchAdapter } from "./base";
-
-/** The active audience's layer, attached to this launch only. */
-interface ClaudeLayerDelivery {
-  audience: string;
-  root: string;
-  /** The layer's MCP configuration, when the layer holds one. */
-  mcpConfigPath?: string;
-}
+import { APPEND_PROMPT_FLAG, liftAppendedPrompts } from "./claude-args";
 
 /** The paths are present only where the plan names that channel and the file exists. */
 interface ClaudeDelivery {
   plan: ClaudeDeliveryPlan;
   settingsPath?: string;
   mcpConfigPath?: string;
-  layer?: ClaudeLayerDelivery;
-  /**
-   * The guidance of the audience the checkout is wrapped for. The wrap carries
-   * the rest of that audience; its guidance hook stays silent in a managed
-   * session, so the launch's own system prompt carries this.
-   */
-  wrappedGuidance?: string;
 }
 
 /** A Claude launch's context: the delivery its plan chose, and the files it chose or wrote. */
 interface ClaudeLaunchContext extends AdapterContext {
   delivery: ClaudeDelivery;
+  /** The Capability plugin folders this launch's own prepare gathered, in order. */
+  pluginDirectories: readonly string[];
 }
 
-function safeName(value: string): string {
-  return value.replace(/[^A-Za-z0-9._-]/g, "_");
-}
-
-/**
- * Where a launch writes its derived `--settings`. Per Working Repository and
- * audience, so concurrent launches never race; a companion-scoped launch
- * derives one only for an audience. Without an audience it is git-ignored
- * under the companion. With one it carries that audience's hooks and
- * permission entries, so it lives beside the audience's layer, outside the
- * companion, where no other audience's session can read it.
- */
-export function launchSettingsPath(
-  companionPath: string,
-  repositoryId: string | null,
-  audience?: string,
-): string {
-  const scope = repositoryId === null ? "companion-scope" : `settings.${safeName(repositoryId)}`;
-  if (audience) {
-    return path.join(audienceLayerDir(companionPath, audience), `launch-${scope}.json`);
-  }
-  return path.join(companionPath, ".claude", "state", `launch-${scope}.json`);
-}
-
-async function readSettings(settingsPath: string): Promise<ClaudeSettings> {
-  if (!existsSync(settingsPath)) return {};
-  return JSON.parse(await fs.readFile(settingsPath, "utf8")) as ClaudeSettings;
+/** Where a launch with a Working Repository writes its derived `--settings`; git-ignored. */
+export function launchSettingsPath(companionPath: string, repositoryId: string): string {
+  const safeId = repositoryId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return path.join(companionPath, ".claude", "state", `launch-settings.${safeId}.json`);
 }
 
 /**
- * Companion settings minus `exclude`, so each wrap-carried group runs once,
- * plus the layer's hook groups and permission entries. A file, not inline JSON
- * (platform arg limits). Claude reads one `--settings` file only — a second
- * one replaces the first — so the layer is merged here, never passed beside.
+ * Companion settings minus `exclude`, so each wrap-carried group runs once. A
+ * file, not inline JSON (platform arg limits); per repository, so concurrent
+ * launches never race. `--settings` outranks every file scope, so `attribution`
+ * is dropped when the user or the repository sets its own, even one added
+ * after the companion's last sync.
  */
 async function writeLaunchSettings(
   companionSettingsPath: string,
   target: string,
   exclude: readonly ClaudeHookGroup[],
-  layerSettingsPath?: string,
+  repoRoot: string,
 ): Promise<void> {
-  const settings = await readSettings(companionSettingsPath);
-  const layer = layerSettingsPath ? await readSettings(layerSettingsPath) : {};
+  const settings = JSON.parse(await fs.readFile(companionSettingsPath, "utf8")) as ClaudeSettings;
   const excluded = new Set(exclude.map(hookGroupKey));
   const hooks: Record<string, ClaudeHookGroup[]> = {};
   for (const [event, groups] of Object.entries(settings.hooks ?? {})) {
     const kept = (groups ?? []).filter((group) => !excluded.has(hookGroupKey(group)));
     if (kept.length > 0) hooks[event] = kept;
   }
-  for (const [event, groups] of Object.entries(layer.hooks ?? {})) {
-    hooks[event] = [...(hooks[event] ?? []), ...(groups ?? [])];
-  }
   const derived: ClaudeSettings = { ...settings, hooks };
   if (Object.keys(hooks).length === 0) delete derived.hooks;
-  const layerAllow = layer.permissions?.allow ?? [];
-  if (layerAllow.length > 0) {
-    const allow = [...new Set([...(settings.permissions?.allow ?? []), ...layerAllow])];
-    derived.permissions = { ...settings.permissions, allow };
+  if (definesUserClaudeAttribution({ repoRoot })) {
+    delete derived.attribution;
   }
 
-  const text = `${JSON.stringify(derived, null, 2)}\n`;
-  if (layerSettingsPath) {
-    /** Beside the audience's layer: as private as the layer itself. */
-    await fs.mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
-    await writeAtomic(target, text, 0o600);
-  } else {
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await writeAtomic(target, text);
-  }
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await writeAtomic(target, `${JSON.stringify(derived, null, 2)}\n`);
 }
 
 /** The `--settings` file the plan's hook owner calls for, writing it when derived. */
@@ -132,38 +81,21 @@ async function settingsPathFor(
   plan: ClaudeDeliveryPlan,
   companionPath: string,
   repository: AdapterContext["repository"],
-  layer: RenderedAudienceLayer | undefined,
 ): Promise<string | undefined> {
   const companionSettingsPath = getCompanionClaudeSettingsPath(companionPath);
-  if (plan.hooks.owner === "none") return undefined;
-  if (!layer && !existsSync(companionSettingsPath)) return undefined;
-  if (plan.hooks.owner === "settings" && !layer) return companionSettingsPath;
+  if (plan.hooks.owner === "none" || !existsSync(companionSettingsPath)) return undefined;
+  if (plan.hooks.owner === "settings") return companionSettingsPath;
   /** Owner `wrap` is planned only for `managed-repo`, which has a repository. */
-  const settingsPath = launchSettingsPath(
-    companionPath,
-    plan.hooks.owner === "wrap" ? repository!.id : null,
-    layer?.audience,
-  );
+  const settingsPath = launchSettingsPath(companionPath, repository!.id);
   await writeLaunchSettings(
     companionSettingsPath,
     settingsPath,
     plan.hooks.launchSettingsExclude,
-    layer ? getCompanionClaudeSettingsPath(layer.root) : undefined,
+    repository!.path,
   );
   return settingsPath;
 }
 
-/** The layer as this launch attaches it: the directory, and its MCP configuration when present. */
-function layerDelivery(layer: RenderedAudienceLayer | undefined): ClaudeLayerDelivery | undefined {
-  if (!layer) return undefined;
-  const mcpConfigPath = getCompanionClaudeMcpConfigPath(layer.root);
-  return {
-    audience: layer.audience,
-    root: layer.root,
-    ...(existsSync(mcpConfigPath) ? { mcpConfigPath } : {}),
-  };
-}
-
 export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
   readonly toolName = "claude";
   readonly interactive = true;
@@ -175,7 +107,7 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
    */
   async planLaunch(context: AdapterContext, prepared: PrepareResult): Promise<ClaudeLaunchContext> {
     const { repository, companionPath } = context;
-    const kind: SessionKind = repository ? "managed-repo" : "managed-companion";
+    const kind = managedSessionKind(Boolean(repository));
     const wrap = prepared.wrapState ?? NOT_WRAPPED;
     if (repository && !wrap.runtimes.has("claude")) {
       throw new LaunchPreflightError(
@@ -184,24 +116,13 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
     }
     const plan = planClaudeDelivery(kind, wrap);
     const mcpConfigPath = getCompanionClaudeMcpConfigPath(companionPath);
-    const settingsPath = await settingsPathFor(
-      plan,
-      companionPath,
-      repository,
-      prepared.audienceLayer,
-    );
-    const layer = layerDelivery(prepared.audienceLayer);
-    const wrappedLayer =
-      !layer && wrap.audience ? currentAudienceLayer(companionPath, wrap.audience) : null;
-    const wrappedGuidance = wrappedLayer ? readLayerGuidanceSync(wrappedLayer, "CLAUDE.md") : "";
+    const settingsPath = await settingsPathFor(plan, companionPath, repository);
     const delivery: ClaudeDelivery = {
       plan,
       ...(plan.mcp === "mcp-config" && existsSync(mcpConfigPath) ? { mcpConfigPath } : {}),
       ...(settingsPath ? { settingsPath } : {}),
-      ...(layer ? { layer } : {}),
-      ...(wrappedGuidance ? { wrappedGuidance } : {}),
     };
-    return { ...context, delivery };
+    return { ...context, delivery, pluginDirectories: prepared.claudePluginDirectories ?? [] };
   }
 
   /** A failed Claude wrap pass names the entry that failed. */
@@ -216,7 +137,7 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
     return super.launchFailure(prepared);
   }
 
-  async validateLaunch(context: ClaudeLaunchContext): Promise<void> {
+  async validateLaunch(_context: ClaudeLaunchContext): Promise<void> {
     /** The bundled plugin carries the artifact-path guard; never launch without it. */
     try {
       validateClaudePluginAssets();
@@ -226,71 +147,48 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
         { cause: error },
       );
     }
-
-    if (context.capabilities.some((capability) => capability.name === "context-mode")) {
-      try {
-        await validateContextModePackage(context.companionPath);
-      } catch (error) {
-        throw new Error(
-          `Claude context-mode plugin is unavailable: ${(error as Error).message} Repair it with \`mate companion setup\`.`,
-          { cause: error },
-        );
-      }
-    }
   }
 
   /**
-   * Plan in, flags out; decides nothing. `--append-system-prompt`, `--plugin-dir`
-   * and context-mode are unconditional: no settings document can carry them.
+   * Plan in, flags out; decides nothing. `--append-system-prompt` is
+   * unconditional: no settings document can carry it. It holds the Agent
+   * Guidance alone; the Companion Instructions come from the wrap's session hook.
+   * `--plugin-dir` passes the folders `launchPluginFolders` names, from the
+   * running install's bundled plugin.
    */
   buildArgs(context: ClaudeLaunchContext, args: string[]): string[] {
-    const { plan, settingsPath, mcpConfigPath, layer, wrappedGuidance } = context.delivery;
-    const companionGuidance = buildCompanionGuidance(context);
-    const systemPrompt = wrappedGuidance
-      ? `${companionGuidance}\n\n${wrappedGuidance}`
-      : companionGuidance;
+    const { plan, settingsPath, mcpConfigPath } = context.delivery;
     /** Layered on the user's own sources so global skills and plugins still load. */
     const settingsArgs =
       plan.hooks.owner !== "none" && settingsPath
         ? ["--setting-sources", "user,project,local", "--settings", settingsPath]
         : [];
-    /**
-     * The layer adds its skills, commands, agents and `CLAUDE.md` as one more
-     * directory, and its MCP servers as one more configuration beside every
-     * server the launch delivered before. Both flags are variadic, so each is
-     * followed by another flag, never by the operator's arguments.
-     */
-    const addDirArgs = [
-      ...(plan.dirAccess === "add-dir" ? ["--add-dir", context.companionPath] : []),
-      ...(layer ? ["--add-dir", layer.root] : []),
-    ];
-    const mcpConfigArgs = [
-      ...(plan.mcp === "mcp-config" && mcpConfigPath ? ["--mcp-config", mcpConfigPath] : []),
-      ...(layer?.mcpConfigPath ? ["--mcp-config", layer.mcpConfigPath] : []),
-    ];
-    const contextModeArgs = context.capabilities.some(
-      (capability) => capability.name === "context-mode",
-    )
-      ? ["--plugin-dir", getContextModePackageRoot(context.companionPath)]
-      : [];
-
+    const addDirArgs = plan.dirAccess === "add-dir" ? ["--add-dir", context.companionPath] : [];
+    const pluginDirArgs = launchPluginFolders(
+      plan,
+      context.pluginDirectories,
+      getClaudePluginRoot(),
+    ).flatMap((dir) => ["--plugin-dir", dir]);
+    const mcpConfigArgs =
+      plan.mcp === "mcp-config" && mcpConfigPath ? ["--mcp-config", mcpConfigPath] : [];
+
+    const guidance = buildCompanionGuidance({
+      ...context,
+      secretGuardrails: resolveSecretPolicy(context.companionPath).guardrails,
+    });
+    const { args: passthrough, prompts, boundary } = liftAppendedPrompts(args);
+    const promptArgs = [APPEND_PROMPT_FLAG, [guidance, ...prompts].filter(Boolean).join("\n\n")];
+    const launchArgs = [...settingsArgs, ...mcpConfigArgs, ...pluginDirArgs];
+
+    if (boundary === undefined) {
+      return [...addDirArgs, ...promptArgs, ...launchArgs, ...passthrough];
+    }
     return [
       ...addDirArgs,
-      "--append-system-prompt",
-      systemPrompt,
-      ...settingsArgs,
-      ...mcpConfigArgs,
-      /** The bundled plugin from the running install, beside context-mode's. */
-      "--plugin-dir",
-      getClaudePluginRoot(),
-      ...contextModeArgs,
-      ...args,
+      ...launchArgs,
+      ...passthrough.slice(0, boundary),
+      ...promptArgs,
+      ...passthrough.slice(boundary),
     ];
   }
-
-  extendEnvironment(_context: ClaudeLaunchContext): NodeJS.ProcessEnv {
-    return {
-      CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1",
-    };
-  }
 }

package/src/lib/orchestrator/adapters/opencode.ts

@@ -6,6 +6,7 @@ const path = await import("node:path");
 
 import { MATE_ENV } from "../../../runtime/env";
 import { validateGuidanceData, type MateGuidanceFile } from "../../../runtime/guidance";
+import { resolveSecretPolicy } from "../../../runtime/policy";
 
 import { validateOpenCodePluginAssets } from "../../package-paths";
 import { readOpenCodeConfig } from "../../../tools/setup/providers/opencode-format";
@@ -56,12 +57,7 @@ function readInvocation(launchWorkingDirectory: string, args: string[]): OpenCod
   return { command, rest, hostsPrivateServer: Boolean(hostsServer) && !choosesRemoteServer };
 }
 
-/** An OpenCode launch's context: the audience layer its prepare rendered, if any. */
-interface OpenCodeLaunchContext extends AdapterContext {
-  audienceLayer?: string;
-}
-
-export class OpenCodeAdapter extends LaunchAdapter<OpenCodeLaunchContext> {
+export class OpenCodeAdapter extends LaunchAdapter {
   readonly toolName = "opencode";
   readonly interactive = true;
   private readonly requiredRuntimeAssets = [path.join(".opencode", "opencode.json")] as const;
@@ -84,15 +80,6 @@ export class OpenCodeAdapter extends LaunchAdapter<OpenCodeLaunchContext> {
     );
   }
 
-  async planLaunch(
-    context: AdapterContext,
-    prepared: PrepareResult,
-  ): Promise<OpenCodeLaunchContext> {
-    return prepared.audienceLayer
-      ? { ...context, audienceLayer: prepared.audienceLayer.root }
-      : context;
-  }
-
   /** A prepared repository reports its failure as one summary, as it always has. */
   launchFailure(prepared: PrepareResult): unknown {
     return prepared.repositoryId
@@ -116,29 +103,27 @@ export class OpenCodeAdapter extends LaunchAdapter<OpenCodeLaunchContext> {
    * overlay carried now lives in the wrapped `.opencode/opencode.json`. An
    * inherited `OPENCODE_CONFIG_DIR` or `OPENCODE_CONFIG_CONTENT` passes through.
    */
-  extendEnvironment(context: OpenCodeLaunchContext, args: string[] = []): NodeJS.ProcessEnv {
+  extendEnvironment(context: AdapterContext, args: string[] = []): NodeJS.ProcessEnv {
     const { hostsPrivateServer } = readInvocation(context.launchWorkingDirectory, args);
     return {
       // Built fresh per launch from the live capability config; always set so
       // a stale value inherited from an outer Mate session can never leak in.
       // Masked unless the launch hosts its own server: a payload that reached
-      // the shared service would apply this session's guidance — and its
-      // audience layer — to every other.
+      // the shared service would apply this session's guidance to every other.
       [MATE_ENV.guidanceJson]: hostsPrivateServer
         ? JSON.stringify(this.buildGuidance(context))
         : "",
     };
   }
 
-  /** The audience layer travels as a path; the plugin reads it through the surface's reader. */
-  private buildGuidance(context: OpenCodeLaunchContext): MateGuidanceFile {
-    const guidance = buildOpenCodeGuidance(context.capabilities, {
+  private buildGuidance(context: AdapterContext): MateGuidanceFile {
+    return buildOpenCodeGuidance(context.capabilities, {
       companionScoped: !context.repository,
+      secretGuardrails: resolveSecretPolicy(context.companionPath).guardrails,
     });
-    return context.audienceLayer ? { ...guidance, audienceLayer: context.audienceLayer } : guidance;
   }
 
-  async validateLaunch(context: OpenCodeLaunchContext): Promise<void> {
+  async validateLaunch(context: AdapterContext): Promise<void> {
     this.validateOpenCodeVersion();
 
     const missingAssets = await Promise.all(
@@ -202,7 +187,7 @@ export class OpenCodeAdapter extends LaunchAdapter<OpenCodeLaunchContext> {
 
   // Self-check the guidance payload this launch is about to inject so a
   // broken playbook template fails preflight instead of inside OpenCode.
-  private validateGuidance(context: OpenCodeLaunchContext): string[] {
+  private validateGuidance(context: AdapterContext): string[] {
     const built = this.buildGuidance(context);
     const { guidance, errors } = validateGuidanceData(built);
 

package/src/lib/orchestrator/config-store.ts

@@ -1,14 +1,7 @@
 import path from "node:path";
 
-import semver from "semver";
+import { normalizeBaseAudience } from "../../tools/setup/dynamic-plugins/audiences";
 
-import {
-  BASE_AUDIENCE,
-  BASE_AUDIENCE_KEYS,
-  normalizeBaseAudience,
-} from "../../tools/setup/dynamic-plugins/audiences";
-
-import { getActiveDistribution } from "../../distribution";
 import { FRAMEWORK_NAME } from "../../framework";
 import {
   getDefaultSetupSelections,
@@ -300,69 +293,12 @@ function validateAudiences(config: FrameworkConfig): void {
   }
 }
 
-/**
- * The release that introduces the `audiences.base` shape. An older Mate would
- * read a saved file as an empty base plus an audience called `base`, so every
- * save in the new shape raises the companion's `engines` floor to it — capped
- * at the running release, so a pre-release build never locks itself out.
- */
-export const BASE_AUDIENCE_MIN_VERSION = "0.19.0";
-
-/** The floor version a save writes: the introducing release, or the running one when older. */
-export function baseAudienceFloorVersion(
-  runningVersion: string = getActiveDistribution().config.version,
-): string {
-  const running = semver.coerce(runningVersion)?.version;
-  return running && semver.lt(running, BASE_AUDIENCE_MIN_VERSION)
-    ? running
-    : BASE_AUDIENCE_MIN_VERSION;
-}
-
-/** Only companions carry audiences; a hub or a working repository keeps the root shape. */
-function usesAudiences(config: FrameworkConfig): boolean {
-  return config.type === undefined || config.type === "companion";
-}
-
-/** The floor that admits the base audience shape, keeping a higher one. */
-function raisedEngineFloor(range: string | undefined): string {
-  const version = baseAudienceFloorVersion();
-  const floor = `>=${version}`;
-  if (!range || semver.validRange(range) === null) return range ?? floor;
-  const minimum = semver.minVersion(range);
-  return minimum && semver.gte(minimum, version) ? range : floor;
-}
-
-/**
- * The file shape of a companion config: the base set's audience-scoped keys
- * under `audiences.base`, first among the audiences. The in-memory config
- * keeps them at the root, so its readers never see the difference.
- */
-function toFileShape(config: FrameworkConfig): FrameworkConfig {
-  if (!usesAudiences(config)) return config;
-  const base: Record<string, unknown> = {};
-  const rest: Record<string, unknown> = { ...config };
-  for (const key of BASE_AUDIENCE_KEYS) {
-    if (rest[key] === undefined) continue;
-    base[key] = rest[key];
-    delete rest[key];
-  }
-  if (Object.keys(base).length === 0) return config;
-  return {
-    ...(rest as unknown as FrameworkConfig),
-    audiences: { [BASE_AUDIENCE]: base, ...config.audiences } as FrameworkConfig["audiences"],
-    engines: {
-      ...config.engines,
-      [FRAMEWORK_NAME]: raisedEngineFloor(config.engines?.[FRAMEWORK_NAME]),
-    },
-  };
-}
-
 export class ConfigStore extends YamlFileStore<FrameworkConfig> {
   constructor(configPath = process.env.MATE_CONFIG ?? defaultConfigPath()) {
     super(path.resolve(configPath));
   }
 
-  /** Either file shape loads as the base set at the root; the new shape persists on the next save. */
+  /** Either file shape loads as the base set at the root; the next save writes the root shape. */
   override async load(): Promise<FrameworkConfig> {
     const merged = mergeWithDefaults(
       migrateProfilesToAllowedAgents(normalizeBaseAudience(await super.load())),
@@ -373,10 +309,6 @@ export class ConfigStore extends YamlFileStore<FrameworkConfig> {
     return merged;
   }
 
-  override async save(config: FrameworkConfig): Promise<void> {
-    await super.save(toFileShape(config));
-  }
-
   protected async onMissing(): Promise<FrameworkConfig> {
     const config = defaultConfig();
     await this.save(config);

package/src/lib/orchestrator/editor.ts

@@ -74,28 +74,28 @@ export const editorWorkspacePath = workspaceDocumentPath;
 
 interface WorkspaceDocument {
   workspacePath: string;
-  folders: [string, string];
+  folders: string[];
 }
 
 /**
  * Writes the generated `.mate/workspace.code-workspace` file (working
- * repository first, companion second) and returns its path and folder
- * order. Called by editor-launching `injectEditorFolder`, which backs
- * `mate companion open`.
+ * repository first, then each companion in the given order) and returns its
+ * path and folder order. Called by editor-launching `injectEditorFolder`,
+ * which backs `mate companion open`.
  */
 async function writeWorkspaceDocument(
-  companionPath: string,
+  companionPaths: string[],
   repoPath: string,
 ): Promise<WorkspaceDocument> {
-  await project("workspace", { repoPath, companionPath });
+  await project("workspace", { repoPath, workspaceCompanionPaths: companionPaths });
   return {
     workspacePath: workspaceDocumentPath(repoPath),
-    folders: [path.resolve(repoPath), path.resolve(companionPath)],
+    folders: [repoPath, ...companionPaths].map((folder) => path.resolve(folder)),
   };
 }
 
 export async function injectEditorFolder(
-  companionPath: string,
+  companionPaths: string[],
   repoPath: string,
   cli = "code",
   spawnProcess: SpawnLike = spawn,
@@ -113,7 +113,7 @@ export async function injectEditorFolder(
 
   const { binary } = resolved;
 
-  const { folders: workspaceFolders } = await writeWorkspaceDocument(companionPath, repoPath);
+  const { folders: workspaceFolders } = await writeWorkspaceDocument(companionPaths, repoPath);
 
   const child = spawnProcess(binary, ["--add", ...workspaceFolders], {
     stdio: "ignore",