@uniqbit/mate-core 0.18.4 → 0.18.5

package/src/tools/setup/capabilities/openspec.ts

@@ -3,6 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 
+import { Document, isMap, isScalar, isSeq, parseDocument, type YAMLMap, type YAMLSeq } from "yaml";
+
 import { getOpenSpecSchemaSelection } from "../../../lib/orchestrator/setup-compatibilities";
 import { getWrapperBinPath } from "../../../lib/package-paths";
 import { fetchPublicPackageVersion } from "../../../lib/public-npm";
@@ -55,6 +57,25 @@ const MATE_SCHEMA_SOURCE_ROOT = path.join(
 );
 const MATE_CONVENTIONS_SOURCE = path.join(MATE_SCHEMA_SOURCE_ROOT, "openspec-conventions.yaml");
 
+/**
+ * Identifies Mate's own `rules.specs` entry, so a later release can replace its
+ * text instead of adding a second entry.
+ */
+export const MATE_SPECS_RULE_MARKER = "[mate] ";
+
+/**
+ * Delivered through `rules.specs`, the one config hook OpenSpec's archive and
+ * sync workflows read when writing main specs. Propose reads it for delta specs
+ * too, so the text binds main specs only.
+ */
+export const MATE_SPECS_RULE = `${MATE_SPECS_RULE_MARKER}A main spec at openspec/specs/<capability>/spec.md MUST begin with flat frontmatter: type: spec, capability: <capability>, repository: <org/repository> (one scalar), areas: [<area>, ...] (a flat list in the delta's scope order), and tags: [openspec/spec]. Project repository and areas from the delta's paired scopes; never copy scopes, change, or delta tags onto a main spec. Delta specs under openspec/changes/<name>/specs/ keep their delta frontmatter. Full rules: openspec/mate-conventions.yaml.`;
+
+/** What Mate writes besides its entry; anything beyond the two is user content. */
+const MANAGED_CONFIG_SCHEMA_ONLY = "schema: mate-v1";
+
+/** Unfolded output keeps the Mate entry on one line and user scalars unwrapped. */
+const CONFIG_TO_STRING = { lineWidth: 0 } as const;
+
 /**
  * Runtime → OpenSpec CLI tools. OpenCode reads workflow skills from the shared
  * `agents` root; its own tool only contributes the `/opsx-*` commands.
@@ -293,20 +314,131 @@ async function ensureOpenSpecInstalled(
   return true;
 }
 
-/** Only the config Mate itself wrote is removed; a user-edited config.yaml is left alone. */
+function isMateSpecsRule(item: unknown): boolean {
+  return (
+    isScalar(item) &&
+    typeof item.value === "string" &&
+    item.value.startsWith(MATE_SPECS_RULE_MARKER)
+  );
+}
+
+/** The config's `rules.specs` sequence, `null` when absent, or `undefined` when a shape is foreign. */
+function readSpecsRules(doc: Document): YAMLSeq | null | undefined {
+  if (doc.contents !== null && !isMap(doc.contents)) return undefined;
+  const rules = doc.get("rules", true);
+  if (rules === undefined || rules === null) return null;
+  if (!isMap(rules)) return undefined;
+  const specs = rules.get("specs", true);
+  if (specs === undefined || specs === null) return null;
+  return isSeq(specs) ? specs : undefined;
+}
+
+/**
+ * Removes Mate's `rules.specs` entry and any `rules.specs` list or `rules` map
+ * that leaves empty. Returns whether the document changed.
+ */
+function removeMateSpecsRule(doc: Document): boolean {
+  const specs = readSpecsRules(doc);
+  if (!specs) return false;
+  const before = specs.items.length;
+  specs.items = specs.items.filter((item) => !isMateSpecsRule(item));
+  if (specs.items.length === before) return false;
+  if (specs.items.length === 0) doc.deleteIn(["rules", "specs"]);
+  const rules = doc.get("rules", true);
+  if (isMap(rules) && rules.items.length === 0) doc.delete("rules");
+  return true;
+}
+
+/**
+ * Ensures exactly one current Mate entry in `rules.specs`: appended when
+ * missing, replaced in place when outdated. Returns whether the document changed.
+ */
+function upsertMateSpecsRule(doc: Document): boolean {
+  if (doc.contents === null) doc.contents = doc.createNode({}) as YAMLMap;
+  const specs = readSpecsRules(doc);
+  if (specs === null) {
+    doc.setIn(["rules", "specs"], doc.createNode([MATE_SPECS_RULE]));
+    return true;
+  }
+  if (!specs) return false;
+
+  const index = specs.items.findIndex(isMateSpecsRule);
+  if (index === -1) {
+    specs.add(doc.createNode(MATE_SPECS_RULE));
+    return true;
+  }
+  let changed = false;
+  const current = specs.items[index];
+  if (isScalar(current) && current.value !== MATE_SPECS_RULE) {
+    current.value = MATE_SPECS_RULE;
+    changed = true;
+  }
+  const deduplicated = specs.items.filter((item, i) => i === index || !isMateSpecsRule(item));
+  if (deduplicated.length !== specs.items.length) {
+    specs.items = deduplicated;
+    changed = true;
+  }
+  return changed;
+}
+
+/**
+ * Removes Mate's own config content: its `rules.specs` entry always, and the
+ * file only when what remains is exactly what Mate writes. User content stays.
+ */
 async function removeManagedOpenSpecConfig(companionPath: string): Promise<void> {
   const configPath = getOpenSpecConfigPath(companionPath);
+  let content: string;
   try {
-    const content = await fs.readFile(configPath, "utf8");
-    if (content.trim() === "schema: mate-v1") {
-      await fs.rm(configPath, { force: true });
-      await pruneEmptyAncestors(path.dirname(configPath), companionPath);
-    }
+    content = await fs.readFile(configPath, "utf8");
   } catch {
-    /* no managed config present */
+    return;
+  }
+
+  let remaining = content;
+  if (content.trim() !== MANAGED_CONFIG_SCHEMA_ONLY) {
+    const doc = parseDocument(content);
+    if (doc.errors.length > 0 || !removeMateSpecsRule(doc)) return;
+    remaining = doc.toString(CONFIG_TO_STRING);
+  }
+
+  if (remaining.trim() === MANAGED_CONFIG_SCHEMA_ONLY) {
+    await fs.rm(configPath, { force: true });
+    await pruneEmptyAncestors(path.dirname(configPath), companionPath);
+  } else {
+    await fs.writeFile(configPath, remaining, "utf8");
   }
 }
 
+/** Writes a fresh Mate config, or merges Mate's entry into an existing one; writes only on change. */
+async function ensureManagedOpenSpecConfig(companionPath: string): Promise<void> {
+  const configPath = getOpenSpecConfigPath(companionPath);
+  let content: string | undefined;
+  try {
+    content = await fs.readFile(configPath, "utf8");
+  } catch {
+    /* no config yet */
+  }
+
+  if (content === undefined) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    const fresh = new Document({ schema: "mate-v1", rules: { specs: [MATE_SPECS_RULE] } });
+    await fs.writeFile(configPath, fresh.toString(CONFIG_TO_STRING), "utf8");
+    return;
+  }
+
+  // config.yaml is user-editable once created; only Mate's own entry is touched.
+  const doc = parseDocument(content);
+  if (doc.errors.length > 0) {
+    process.stderr.write(
+      `openspec: left openspec/config.yaml unchanged, it is not valid YAML: ${doc.errors[0].message.split("\n")[0]}\n`,
+    );
+    return;
+  }
+  if (!upsertMateSpecsRule(doc)) return;
+  const merged = doc.toString(CONFIG_TO_STRING);
+  if (merged !== content) await fs.writeFile(configPath, merged, "utf8");
+}
+
 async function teardownOpenSpecSchema(companionPath: string): Promise<void> {
   for (const schemaName of MATE_SCHEMA_NAMES) {
     const schemaDir = getMateSchemaDir(companionPath, schemaName);
@@ -340,17 +472,7 @@ async function reconcileOpenSpecSchema(ctx: SetupContext): Promise<void> {
     return;
   }
 
-  const configPath = getOpenSpecConfigPath(ctx.companionPath);
-  await fs.mkdir(path.dirname(configPath), { recursive: true });
-
-  // config.yaml is user-editable once created; never overwrite it on re-sync.
-  const configExists = await fs
-    .access(configPath)
-    .then(() => true)
-    .catch(() => false);
-  if (configExists) return;
-
-  await fs.writeFile(configPath, "schema: mate-v1\n", "utf8");
+  await ensureManagedOpenSpecConfig(ctx.companionPath);
 }
 
 export function createOpenspecPlugin(deps: OpenSpecPluginDeps = {}): CapabilityPlugin {

package/src/tools/setup/dynamic-plugins/audiences.ts

@@ -8,10 +8,13 @@ import { ConfigError, type PluginDeclaration } from "../../../lib/orchestrator/t
 
 export const AUDIENCE_ENV = "MATE_AUDIENCE";
 
-/** The reserved audience holding the base set: always applied, never selected or listed. */
+/**
+ * Mate 0.18.4 saved the base set under `audiences.base`. That shape is read
+ * back for compatibility, never written: the next save uses the root shape.
+ */
 export const BASE_AUDIENCE = "base";
 
-/** The base set's audience-scoped keys; companion-wide keys stay at the root. */
+/** The keys 0.18.4 moved under `audiences.base`; companion-wide keys stayed at the root. */
 export const BASE_AUDIENCE_KEYS = ["capabilities", "plugins", "studio"] as const;
 
 export type AudienceResolution =
@@ -23,13 +26,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function pluginList(value: unknown): unknown[] {
-  if (
-    isRecord(value) &&
-    isRecord(value.audiences) &&
-    Object.hasOwn(value.audiences, BASE_AUDIENCE)
-  ) {
-    return pluginList(normalizeBaseAudience(value));
-  }
   return isRecord(value) && Array.isArray(value.plugins) ? value.plugins : [];
 }
 
@@ -91,7 +87,6 @@ export function declaredAudiences(raw: unknown): string[] {
     : [];
 }
 
-/** `MATE_AUDIENCE=base` selects the base set alone, the same as no audience. */
 export function resolveAudience(raw: unknown, audience: string | null): AudienceResolution {
   if (audience === null || audience === BASE_AUDIENCE) return { ok: true, active: null };
   const declared = declaredAudiences(raw);
@@ -104,34 +99,7 @@ export function resolveAudience(raw: unknown, audience: string | null): Audience
  * its own `policy` and `config`. An unknown audience contributes nothing.
  */
 export function effectivePluginDeclarations(raw: unknown, audience: string | null): unknown[] {
-  return [...pluginList(raw), ...pluginList(audienceEntry(raw, audience))];
-}
-
-/** One effective declaration and its source: `null` for base, else the audience name. */
-export interface SourcedDeclaration {
-  entry: unknown;
-  audience: string | null;
-}
-
-/** `effectivePluginDeclarations`, each entry marked with the source that declared it. */
-export function effectivePluginDeclarationSources(
-  raw: unknown,
-  audience: string | null,
-): SourcedDeclaration[] {
-  return [
-    ...pluginList(raw).map((entry) => ({ entry, audience: null })),
-    ...pluginList(audienceEntry(raw, audience)).map((entry) => ({ entry, audience })),
-  ];
-}
-
-/** The declarations of one audience only, without base. */
-export function audiencePluginDeclarations(raw: unknown, audience: string): unknown[] {
-  return pluginList(audienceEntry(raw, audience));
-}
-
-/** The raw `audiences.<name>` entry, for fingerprinting what a layer depends on. */
-export function audienceDeclarationEntry(raw: unknown, audience: string): unknown {
-  return audienceEntry(raw, audience);
+  return [...pluginList(normalizeBaseAudience(raw)), ...pluginList(audienceEntry(raw, audience))];
 }
 
 /**
@@ -140,7 +108,7 @@ export function audienceDeclarationEntry(raw: unknown, audience: string): unknow
  * version. Runtime declarations must come from `effectivePluginDeclarations`.
  */
 export function allPluginDeclarations(raw: unknown): unknown[] {
-  const all = [...pluginList(raw)];
+  const all = [...pluginList(normalizeBaseAudience(raw))];
   for (const name of declaredAudiences(raw)) {
     all.push(...pluginList(audienceEntry(raw, name)));
   }

package/src/tools/setup/dynamic-plugins/declarations.ts

@@ -13,7 +13,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 /**
- * Raw read of the companion's base `plugins:` list, from either shape. Deliberately avoids
+ * Raw read of the companion's `plugins:` list. Deliberately avoids
  * `ConfigStore.load()` — hydration runs on every invocation and must never
  * create or migrate config files as a side effect.
  */

package/src/tools/setup/dynamic-plugins/hydrate.ts

@@ -9,7 +9,7 @@ import type { Plugin } from "../plugin";
 import type { PluginRegistry } from "../registry";
 import {
   describeUnknownAudience,
-  effectivePluginDeclarationSources,
+  effectivePluginDeclarations,
   readAudienceSelection,
   readFrameworkRaw,
   resolveAudience,
@@ -71,8 +71,7 @@ function activateDeclaredPlugin(plugin: Plugin): Plugin {
 /**
  * Registers the companion's effective plugins (base plus the active
  * `MATE_AUDIENCE`) into the active registry — compiled-in plugins first
- * (they are already registered), declared order after. Each registration is
- * marked with its source, so persisted passes can keep to base. Runs before cap-command detection on every invocation. No-op
+ * (they are already registered), declared order after. Runs before cap-command detection on every invocation. No-op
  * without a companion or `plugins:` entries; all diagnostics go to stderr;
  * never throws.
  */
@@ -90,12 +89,12 @@ export async function hydrateDynamicPlugins(deps: HydrateDynamicPluginsDeps = {}
     if (!audience.ok) {
       warn(`${describeUnknownAudience(audience)}; applying the base configuration only`);
     }
-    const entries = effectivePluginDeclarationSources(raw, audience.ok ? audience.active : null);
+    const entries = effectivePluginDeclarations(raw, audience.ok ? audience.active : null);
     if (entries.length === 0) return;
 
     const registry = deps.registry ?? getActiveDistribution().registry;
 
-    for (const { entry, audience: source } of entries) {
+    for (const entry of entries) {
       const { declaration, error } = validateDeclaration(entry);
       if (!declaration) {
         if (error) warn(error);
@@ -123,8 +122,6 @@ export async function hydrateDynamicPlugins(deps: HydrateDynamicPluginsDeps = {}
       registry.register({
         plugin: activateDeclaredPlugin(result.plugin),
         policy: declaration.policy ?? "optional",
-        audience: source,
-        packageName: declaration.package,
       });
       hydratedPackages.add(declaration.package);
     }

package/src/tools/setup/engine.ts

@@ -4,13 +4,6 @@ import { FRAMEWORK_NAME } from "../../framework";
 import type { FrameworkConfig } from "../../lib/orchestrator/types";
 import type { RenderedRuntimeDocument } from "../../runtime/runtime-document-manifest";
 import { collectHostingProviders, ContextServiceMediator } from "./context-services";
-import {
-  ledgerFromInputs,
-  ledgerTeardownInput,
-  readContributionLedger,
-  writeContributionLedger,
-  type ContributionLedger,
-} from "./contribution-ledger";
 import type {
   CapabilityContributionInput,
   CapabilityPlugin,
@@ -22,8 +15,6 @@ import { reconcileClaudeContributions } from "./providers/claude";
 import { reconcileOpenCodeContributions } from "./providers/opencode";
 import { mergeCompanionOpenCodeConfig, renderDocumentsForTarget } from "./runtime-documents";
 import { normalizeRegistration, type NormalizedRegistration } from "./registry";
-import { surfaceRoot } from "./surface-target";
-import { removeForeignGuidanceBlocks, sweepAudienceDeclarations } from "./upgrade-sweep";
 
 export interface SetupInstallationPlanAction {
   phase: Plugin["kind"];
@@ -44,23 +35,11 @@ export interface SetupInstallationOutcome {
   warnings: string[];
 }
 
-/**
- * The registrations a pass that writes a persisted surface may reconcile:
- * base only. An audience registration takes part in no such pass — neither
- * its lifecycle hooks nor its declared contributions — whatever audience is
- * active; its contributions reach sessions only through the launch layer.
- */
-export function persistedRegistrations(
-  registrations: PluginRegistration[],
-): NormalizedRegistration[] {
-  return registrations.map(normalizeRegistration).filter((entry) => entry.audience === null);
-}
-
 export function buildSetupInstallationPlan(
   config: FrameworkConfig,
   registrations: PluginRegistration[],
 ): SetupInstallationPlan {
-  const entries = persistedRegistrations(registrations);
+  const entries = registrations.map(normalizeRegistration);
   // Required plugins are always treated as enabled: saved selections cannot
   // deselect them and deselection never produces a teardown action.
   const isEntryEnabled = (entry: NormalizedRegistration) =>
@@ -130,7 +109,7 @@ export async function executeSetupInstallationPlan(
   registrations: PluginRegistration[],
   plan: SetupInstallationPlan,
 ): Promise<SetupInstallationOutcome> {
-  const plugins = persistedRegistrations(registrations).map((entry) => entry.plugin);
+  const plugins = registrations.map((entry) => normalizeRegistration(entry).plugin);
   const pluginById = new Map(plugins.map((plugin) => [plugin.id, plugin]));
   const executedActions: SetupInstallationPlanAction[] = [];
   const skippedActions: SetupInstallationPlanAction[] = [];
@@ -197,22 +176,13 @@ export async function executeSetupInstallationPlan(
 
   await mediator.finalize();
 
-  const reconcileWarnings = await reconcileCapabilityContributions(
-    ctx,
-    plugins,
-    plan,
-    registrations.map(normalizeRegistration),
-  );
-  for (const warning of reconcileWarnings) {
-    warnings.push(warning);
-    process.stderr.write(`${warning}\n`);
-  }
+  await reconcileCapabilityContributions(ctx, plugins, plan);
 
   return { executedActions, skippedActions, warnings };
 }
 
 // The Runtime Surface of each active Agent Runtime, by runtime id.
-export const RUNTIME_SURFACE_RECONCILERS: Record<
+const RUNTIME_SURFACE_RECONCILERS: Record<
   string,
   (ctx: SetupContext, inputs: CapabilityContributionInput[]) => Promise<void>
 > = {
@@ -273,104 +243,13 @@ async function reconcileCapabilityContributions(
   ctx: SetupContext,
   plugins: Plugin[],
   plan: SetupInstallationPlan,
-  registrations: NormalizedRegistration[],
-): Promise<string[]> {
+): Promise<void> {
   const inputsByRuntime = await collectContributionInputs(ctx, plugins, plan);
-  const ledgerRoot = surfaceRoot(ctx);
-  const ledger = await readContributionLedger(ledgerRoot);
-  const warnings: string[] = [];
-  let unswept = ledger?.unswept ?? [];
-  if (!ledger || unswept.length > 0) {
-    if (!ledger) {
-      await removeForeignGuidanceBlocks(ledgerRoot, new Set(plugins.map((plugin) => plugin.id)));
-    }
-    const sweep = await sweepAudienceDeclarations(ctx, {
-      registrations,
-      ...(ledger ? { packages: new Set(unswept) } : {}),
-    });
-    prependTeardown(inputsByRuntime, sweep.teardown);
-    unswept = sweep.unswept;
-    warnings.push(...sweep.warnings);
-  }
-  prependLedgerTeardown(inputsByRuntime, ledger);
   for (const [runtimeId, inputs] of inputsByRuntime) {
     const reconcile = RUNTIME_SURFACE_RECONCILERS[runtimeId];
     if (!reconcile || inputs.length === 0) continue;
     await reconcile(ctx, inputs);
   }
-  await writeContributionLedger(ledgerRoot, ledgerFromInputs(inputsByRuntime, unswept));
-  return warnings;
-}
-
-/**
- * Disabled inputs placed first, skipping any owner that is an enabled input
- * of the pass on that runtime: removal runs before enabled inputs apply.
- */
-function prependTeardown(
-  inputsByRuntime: Map<string, CapabilityContributionInput[]>,
-  teardownByRuntime: ReadonlyMap<string, readonly CapabilityContributionInput[]>,
-): void {
-  for (const [runtimeId, teardown] of teardownByRuntime) {
-    const inputs = inputsByRuntime.get(runtimeId) ?? [];
-    const enabled = new Set(inputs.filter((input) => input.enabled).map((input) => input.pluginId));
-    const kept = teardown.filter((input) => !enabled.has(input.pluginId));
-    if (kept.length > 0) inputsByRuntime.set(runtimeId, [...kept, ...inputs]);
-  }
-}
-
-/**
- * Every recorded owner that is not an enabled input of this pass, as a
- * disabled input placed first: its entries are removed before enabled inputs
- * apply, so an identity another plugin still declares is re-applied after.
- * Entries the ledger does not record are never named, so they survive.
- */
-function prependLedgerTeardown(
-  inputsByRuntime: Map<string, CapabilityContributionInput[]>,
-  ledger: ContributionLedger | null,
-): void {
-  prependTeardown(
-    inputsByRuntime,
-    new Map(
-      Object.entries(ledger?.runtimes ?? {}).map(([runtimeId, owners]) => [
-        runtimeId,
-        Object.entries(owners).map(([owner, identities]) => ledgerTeardownInput(owner, identities)),
-      ]),
-    ),
-  );
-}
-
-/**
- * The declared contributions of one audience's plugins, as enabled inputs per
- * active runtime. No plugin phase and no lifecycle hook runs: an audience
- * plugin contributes declaratively only. OpenCode plugin references are
- * dropped — the Mate plugin has no way to load another plugin.
- */
-export async function collectAudienceInputs(
-  ctx: SetupContext,
-  registrations: PluginRegistration[],
-  audience: string,
-): Promise<Map<string, CapabilityContributionInput[]>> {
-  const inputsByRuntime = new Map<string, CapabilityContributionInput[]>();
-  for (const entry of registrations.map(normalizeRegistration)) {
-    if (entry.audience !== audience || entry.plugin.kind !== "capability") continue;
-    const capability = entry.plugin as CapabilityPlugin;
-    if (!capability.getRuntimeContributions) continue;
-    if (entry.policy !== "required" && !capability.isEnabled(ctx.config)) continue;
-    const byRuntime = await capability.getRuntimeContributions(ctx);
-    for (const [runtimeId, contributions] of Object.entries(byRuntime)) {
-      if (!contributions || !ctx.activeProviders.includes(runtimeId)) continue;
-      const { pluginReferences: _dropped, ...declarative } = contributions;
-      const inputs = inputsByRuntime.get(runtimeId) ?? [];
-      inputs.push({
-        pluginId: capability.id,
-        enabled: true,
-        capabilityEnabled: true,
-        contributions: declarative,
-      });
-      inputsByRuntime.set(runtimeId, inputs);
-    }
-  }
-  return inputsByRuntime;
 }
 
 /** What a render returns: its warnings are data for the caller, never printed here. */
@@ -388,22 +267,12 @@ export async function renderRuntimeDocuments(
   ctx: SetupContext,
   registrations: PluginRegistration[],
   plan: SetupInstallationPlan,
-  wrapped?: { audience: string; registrations: PluginRegistration[] },
 ): Promise<RenderedRuntimeDocuments> {
-  const plugins = persistedRegistrations(registrations).map((entry) => entry.plugin);
-  const inputsByRuntime = await collectContributionInputs(ctx, plugins, plan);
-  /** A checkout wrapped for an audience carries it beside base; no other audience ever. */
-  if (wrapped) {
-    const audienceInputs = await collectAudienceInputs(
-      ctx,
-      wrapped.registrations,
-      wrapped.audience,
-    );
-    for (const [runtimeId, inputs] of audienceInputs) {
-      inputsByRuntime.set(runtimeId, [...(inputsByRuntime.get(runtimeId) ?? []), ...inputs]);
-    }
-  }
-  const documents = renderDocumentsForTarget(ctx, inputsByRuntime);
+  const plugins = registrations.map((entry) => normalizeRegistration(entry).plugin);
+  const documents = renderDocumentsForTarget(
+    ctx,
+    await collectContributionInputs(ctx, plugins, plan),
+  );
   if (ctx.target !== "working") return { documents, warnings: [] };
   return mergeCompanionOpenCodeConfig(ctx.companionPath, documents);
 }

package/src/tools/setup/plugin.ts

@@ -7,10 +7,9 @@ export type SetupScope = "companion" | "hub";
 /**
  * Where a reconcile pass lands its documents. `companion` writes the material's
  * own repository; `working` renders the documents an Agent Runtime discovers by
- * its own upward walk and leaves the placing to the Projection Root;
- * `audience-layer` writes one audience's launch layer, outside every repository.
+ * its own upward walk and leaves the placing to the Projection Root.
  */
-export type ProjectionTarget = "companion" | "working" | "audience-layer";
+export type ProjectionTarget = "companion" | "working";
 
 export interface SetupContext {
   companionPath: string;
@@ -23,14 +22,6 @@ export interface SetupContext {
   repoPath?: string;
   /** Defaults to `companion`, so a caller that names no target is unchanged. */
   target?: ProjectionTarget;
-  /** The audience an `audience-layer` pass renders; required by that target only. */
-  audience?: string;
-  /**
-   * Where an `audience-layer` pass writes: the staging directory a render is
-   * built in before it is renamed into place. The audience's layer directory
-   * when absent.
-   */
-  layerRoot?: string;
   /**
    * Provider-mediated context services. Always populated when the engine
    * executes a plugin; optional so hand-built contexts (tests, direct calls)
@@ -131,15 +122,9 @@ export type PluginPolicy = "required" | "default" | "optional";
 
 /**
  * A plugin registration entry. Bare plugins derive their policy from
- * `defaultSelected` (`true` → "default", `false` → "optional"). `audience` is
- * the source of a declared plugin: `null` (or absent) for compiled-in plugins
- * and top-level `plugins` declarations, the audience name for a declaration
- * under `audiences.<name>.plugins`. `packageName` names the declared package a
- * dynamic plugin was loaded from.
+ * `defaultSelected` (`true` → "default", `false` → "optional").
  */
-export type PluginRegistration =
-  | Plugin
-  | { plugin: Plugin; policy: PluginPolicy; audience?: string | null; packageName?: string };
+export type PluginRegistration = Plugin | { plugin: Plugin; policy: PluginPolicy };
 
 /**
  * A hook group a Capability contributes to a runtime's settings. `marker` is

package/src/tools/setup/plugins/gitignore.ts

@@ -97,13 +97,7 @@ export function createGitignorePlugin(
 ): Plugin {
   // Resolve lazily so plugin sets can be built before a distribution is active.
   const resolveName = typeof frameworkName === "function" ? frameworkName : () => frameworkName;
-  /** Base only: an audience plugin's entries would reach the committed `.gitignore`. */
-  const resolvePlugins =
-    allPlugins ??
-    (() =>
-      getActiveDistribution()
-        .registry.baseRegistrations()
-        .map((entry) => entry.plugin));
+  const resolvePlugins = allPlugins ?? (() => getActiveDistribution().registry.getAll());
   return {
     id: "gitignore",
     kind: "root",

package/src/tools/setup/providers/claude.ts

@@ -11,7 +11,7 @@ import {
   upsertManagedBlock,
 } from "../context-services";
 import type { CapabilityContributionInput, ProviderPlugin, SetupContext } from "../plugin";
-import { projectionTarget, surfaceRoot } from "../surface-target";
+import { surfaceRoot } from "../surface-target";
 import { mergeDir, pruneEmptyAncestors } from "../utils";
 import { stripSectionFromFile, type RemoveHeadingSectionOptions } from "./agent-file-sections";
 import { patchSkillTreeMarkdownFiles } from "./skill-tree";
@@ -164,23 +164,6 @@ export function renderManagedClaudeHookGroups(
   return hooks;
 }
 
-/**
- * A layer's Claude settings: the enabled inputs' hook groups and permission
- * entries, nothing of Mate's own. The launch merges them over its base settings.
- */
-export function renderLayerClaudeSettings(
-  contributions: CapabilityContributionInput[] = [],
-): ClaudeSettings {
-  const hooks = renderManagedClaudeHookGroups(contributions);
-  const allow = contributions
-    .filter((input) => input.enabled)
-    .flatMap((input) => input.contributions.permissionEntries ?? []);
-  return {
-    ...(Object.keys(hooks).length > 0 ? { hooks } : {}),
-    ...(allow.length > 0 ? { permissions: { allow } } : {}),
-  };
-}
-
 // Reconcile the Mate-managed Claude settings shape (hooks, permissions, MCP
 // servers) on top of whatever already exists in the settings document. Managed
 // groups/entries always lead their arrays so the emitted shape stays stable
@@ -304,15 +287,7 @@ export async function reconcileClaudeContributions(
   // The settings sync (re)creates the managed settings document, so it only
   // runs while the Claude runtime is active; a deactivated runtime's pass is
   // teardown-only and must not resurrect files the provider teardown removed.
-  // A layer carries its plugins' hooks and permission entries only, for the
-  // launch to merge into its one `--settings` file.
-  if (projectionTarget(ctx) === "audience-layer") {
-    await writeClaudeSettings(
-      getCompanionClaudeSettingsPath(root),
-      renderLayerClaudeSettings(inputs),
-    );
-    await syncCompanionClaudeMcpConfig(root);
-  } else if (ctx.activeProviders.includes("claude")) {
+  if (ctx.activeProviders.includes("claude")) {
     await syncCompanionClaudeSettings(root, config, inputs);
   }
 

package/src/tools/setup/providers/opencode.ts

@@ -416,16 +416,6 @@ export async function removeOpenCodeForeignPluginReferences(
 
 const OPENCODE_CONTRIBUTION_CONFIG_FILES = ["opencode.json"];
 
-/**
- * The surface's reader for an audience layer it wrote: what the Mate OpenCode
- * plugin applies. Defined under `runtime/` so the import-isolated plugin can
- * reach it; this surface owns the format it reads.
- */
-export {
-  readOpenCodeAudienceLayer,
-  type OpenCodeLayerContents,
-} from "../../../runtime/opencode-audience-layer";
-
 export async function reconcileOpenCodeContributions(
   ctx: SetupContext,
   inputs: CapabilityContributionInput[],