@uniqbit/mate-core 0.18.4 → 0.18.5

package/src/cli/commands/wrap.ts

@@ -33,29 +33,12 @@ function reportChangedPaths(changed: ProjectionChangedPaths): void {
 
 /**
  * `--companion` is consumed by the dispatch gate before the command runs, so it
- * is parsed there too. `--audience` names the audience the checkout's bare
- * sessions get beside base.
+ * is parsed there too; this only rejects anything else.
  */
-export function parseWrapArgs(
-  argv: string[],
-): { companion?: string; audience?: string } | { error: string } {
+export function parseWrapArgs(argv: string[]): { companion?: string } | { error: string } {
   let companion: string | undefined;
-  let audience: string | undefined;
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index]!;
-    if (arg === "--audience") {
-      const value = argv[index + 1];
-      if (!value || value.startsWith("--")) return { error: "--audience requires a name" };
-      audience = value;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--audience=")) {
-      const value = arg.slice("--audience=".length);
-      if (!value) return { error: "--audience requires a name" };
-      audience = value;
-      continue;
-    }
     if (arg === "--companion") {
       const value = argv[index + 1];
       if (!value || value.startsWith("--")) return { error: "--companion requires a path" };
@@ -71,10 +54,7 @@ export function parseWrapArgs(
     }
     return { error: `unknown wrap option: ${arg}` };
   }
-  return {
-    ...(companion === undefined ? {} : { companion }),
-    ...(audience === undefined ? {} : { audience }),
-  };
+  return companion === undefined ? {} : { companion };
 }
 
 /**
@@ -128,12 +108,8 @@ export async function runWrapCommand(
   }
 
   /** Serialized with Session Prepare and every sync, which rewrite the same manifest. */
-  /**
-   * The flag is the only way to give a checkout's bare sessions an audience;
-   * without it the wrap is base and any recorded audience is withdrawn.
-   */
   const locked = await withCompanionLock(companionPath, attendedLockOptions(companionPath), () =>
-    wrap(companionPath, repository, { audience: parsed.audience ?? null }),
+    wrap(companionPath, repository),
   );
   const result: WrapPassResult = locked.acquired
     ? locked.value
@@ -150,7 +126,6 @@ export async function runWrapCommand(
       : `Already wrapped: ${result.projectionRoot}`,
   );
   console.log(`  Companion: ${result.companionPath}`);
-  if (result.audience) console.log(`  Audience:  ${result.audience}`);
   for (const document of result.documents) {
     console.log(`  Runtime:   ${document}`);
   }

package/src/cli/usage.ts

@@ -21,7 +21,7 @@ export function usage(): string {
     ` ${n} companion open`,
     ` ${n} companion tui`,
     ` ${n} working cleanup`,
-    ` ${n} wrap [--companion PATH] [--audience NAME]`,
+    ` ${n} wrap [--companion PATH]`,
     ` ${n} unwrap`,
     ` ${n} session prepare --repo <dir> [--json] [--sync]`,
     ` ${n} hub init [folder]`,
@@ -54,7 +54,6 @@ export function usage(): string {
     "",
     "Wrapped repositories:",
     ` ${n} wrap configures the repository so sessions you start yourself load the companion`,
-    ` ${n} wrap --audience NAME gives those sessions one audience beside base; plain wrap returns to base`,
     ` ${n} claude does not run while a repository is wrapped for Claude`,
     ` ${n} opencode wraps the repository for OpenCode itself, then starts plain \`opencode\``,
     ` ${n} unwrap withdraws the wrap and restores managed launches; the link is kept`,

package/src/hooks/session-guidance.ts

@@ -1,8 +1,5 @@
 // Deliver the companion guidance to a Claude session Mate did not launch.
-import { currentAudienceLayer, readLayerGuidanceSync } from "../runtime/audience-layer";
-import { resolveProjection } from "../runtime/projection";
 import { buildProjectedGuidance } from "../runtime/projected-guidance";
-import { readWrapStateSync } from "../runtime/wrap-state";
 import type { HookEnv } from "./validate-artifact-path";
 
 export interface GuidanceOutcome {
@@ -10,19 +7,6 @@ export interface GuidanceOutcome {
   stdout: string;
 }
 
-/**
- * The guidance of the audience this checkout is wrapped for, from its layer.
- * The wrap is the only source: an inherited `MATE_AUDIENCE` selects nothing.
- */
-function wrappedAudienceGuidance(cwd: string): string {
-  const projection = resolveProjection(cwd);
-  if (!projection) return "";
-  const audience = readWrapStateSync(projection.repoRoot).audience;
-  if (!audience) return "";
-  const layer = currentAudienceLayer(projection.companionPath, audience);
-  return layer ? readLayerGuidanceSync(layer, "CLAUDE.md") : "";
-}
-
 /**
  * `SessionStart.additionalContext` is the file-based form of the managed
  * launch's `--append-system-prompt`: a settings document can declare a hook,
@@ -34,10 +18,8 @@ function wrappedAudienceGuidance(cwd: string): string {
  * repository must read exactly as it did before the hook existed.
  */
 export function buildSessionGuidance(env: HookEnv, cwd: string = process.cwd()): GuidanceOutcome {
-  const companionGuidance = buildProjectedGuidance(env, cwd);
-  if (!companionGuidance) return { exitCode: 0, stdout: "" };
-  const layer = wrappedAudienceGuidance(cwd);
-  const guidance = layer ? `${companionGuidance}\n\n${layer}` : companionGuidance;
+  const guidance = buildProjectedGuidance(env, cwd);
+  if (!guidance) return { exitCode: 0, stdout: "" };
 
   return {
     exitCode: 0,

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

@@ -9,11 +9,6 @@ import {
   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 { NOT_WRAPPED } from "../../../runtime/wrap-state";
 import { writeAtomic } from "../../../runtime/write-atomic";
@@ -24,31 +19,15 @@ import {
 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;
-}
-
 /** 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. */
@@ -56,75 +35,34 @@ interface ClaudeLaunchContext extends AdapterContext {
   delivery: ClaudeDelivery;
 }
 
-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.
  */
 async function writeLaunchSettings(
   companionSettingsPath: string,
   target: string,
   exclude: readonly ClaudeHookGroup[],
-  layerSettingsPath?: 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 };
-  }
 
-  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 +70,16 @@ 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,
-  );
-  await writeLaunchSettings(
-    companionSettingsPath,
-    settingsPath,
-    plan.hooks.launchSettingsExclude,
-    layer ? getCompanionClaudeSettingsPath(layer.root) : undefined,
-  );
+  const settingsPath = launchSettingsPath(companionPath, repository!.id);
+  await writeLaunchSettings(companionSettingsPath, settingsPath, plan.hooks.launchSettingsExclude);
   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;
@@ -184,22 +100,11 @@ 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 };
   }
@@ -244,30 +149,15 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
    * and context-mode are unconditional: no settings document can carry them.
    */
   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 addDirArgs = plan.dirAccess === "add-dir" ? ["--add-dir", context.companionPath] : [];
+    const mcpConfigArgs =
+      plan.mcp === "mcp-config" && mcpConfigPath ? ["--mcp-config", mcpConfigPath] : [];
     const contextModeArgs = context.capabilities.some(
       (capability) => capability.name === "context-mode",
     )
@@ -277,7 +167,7 @@ export class ClaudeAdapter extends LaunchAdapter<ClaudeLaunchContext> {
     return [
       ...addDirArgs,
       "--append-system-prompt",
-      systemPrompt,
+      buildCompanionGuidance(context),
       ...settingsArgs,
       ...mcpConfigArgs,
       /** The bundled plugin from the running install, beside context-mode's. */

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

@@ -56,12 +56,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 +79,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 +102,26 @@ 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,
     });
-    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 +185,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);