@uniqbit/mate-core 0.18.3-canary.1 → 0.18.4

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

@@ -11,7 +11,7 @@ import {
   upsertManagedBlock,
 } from "../context-services";
 import type { CapabilityContributionInput, ProviderPlugin, SetupContext } from "../plugin";
-import { surfaceRoot } from "../surface-target";
+import { projectionTarget, surfaceRoot } from "../surface-target";
 import { mergeDir, pruneEmptyAncestors } from "../utils";
 import { stripSectionFromFile, type RemoveHeadingSectionOptions } from "./agent-file-sections";
 import { patchSkillTreeMarkdownFiles } from "./skill-tree";
@@ -89,6 +89,10 @@ function getBaseManagedPermissionEntries(companionPath: string): string[] {
 const LEGACY_MANAGED_PERMISSION_ENTRIES = [
   "Bash($MATE_COMPANION_BIN_PATH/openspec:*)",
   "Bash($MATE_COMPANION_BIN_PATH/graphify:*)",
+  // React Doctor's pre-seeds before it moved to the pinned mate-react-doctor skill.
+  "Skill(react-doctor)",
+  "Bash(npx react-doctor:*)",
+  "Bash(npx react-doctor@latest *)",
 ];
 
 function getAllManagedPermissionEntries(companionPath: string): Set<string> {
@@ -102,16 +106,12 @@ function getAllManagedPermissionEntries(companionPath: string): Set<string> {
   ]);
 }
 
-// Resolved path of the companion-owned Claude settings document. This is the
-// single source of truth for Mate-managed Claude hooks, permissions, and MCP
-// servers; it is loaded at launch via `claude --settings`.
+/** Companion-owned Claude settings: sole source of Mate-managed hooks, permissions and MCP servers. */
 export function getCompanionClaudeSettingsPath(companionPath: string): string {
   return path.join(companionPath, ".claude", "settings.local.json");
 }
 
-// Resolved path of the companion-owned `.mcp.json`. Mate writes Mate-managed
-// MCP servers here and loads it at launch via `claude --mcp-config`, keeping
-// the MCP surface out of the working repo and out of settings.local.json.
+/** Companion-owned `.mcp.json`; loaded via `--mcp-config` only by a companion-scoped launch. */
 export function getCompanionClaudeMcpConfigPath(companionPath: string): string {
   return path.join(companionPath, ".mcp.json");
 }
@@ -147,6 +147,40 @@ export function renderManagedClaudeMcpServers(
   return servers;
 }
 
+/**
+ * Enabled Capabilities' Claude hook groups per event, in declared order, as a
+ * value: what a Claude wrap carries into the Working Repository.
+ */
+export function renderManagedClaudeHookGroups(
+  contributions: CapabilityContributionInput[] = [],
+): Record<string, ClaudeHookGroup[]> {
+  const hooks: Record<string, ClaudeHookGroup[]> = {};
+  for (const input of contributions) {
+    if (!input.enabled) continue;
+    for (const hook of input.contributions.hookGroups ?? []) {
+      (hooks[hook.event] ??= []).push(hook.group);
+    }
+  }
+  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
@@ -270,7 +304,15 @@ 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.
-  if (ctx.activeProviders.includes("claude")) {
+  // 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")) {
     await syncCompanionClaudeSettings(root, config, inputs);
   }
 

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

@@ -416,6 +416,16 @@ 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[],

package/src/tools/setup/registry.ts

@@ -3,13 +3,22 @@ import type { Plugin, PluginPolicy, PluginRegistration } from "./plugin";
 export interface NormalizedRegistration {
   plugin: Plugin;
   policy: PluginPolicy;
+  /** The audience that declared the plugin; `null` for base. */
+  audience: string | null;
+  /** The declared package a dynamic plugin was loaded from; absent for compiled-in plugins. */
+  packageName?: string;
 }
 
 export function normalizeRegistration(entry: PluginRegistration): NormalizedRegistration {
   if ("plugin" in entry && "policy" in entry) {
-    return { plugin: entry.plugin, policy: entry.policy };
+    return {
+      plugin: entry.plugin,
+      policy: entry.policy,
+      audience: entry.audience ?? null,
+      ...(entry.packageName ? { packageName: entry.packageName } : {}),
+    };
   }
-  return { plugin: entry, policy: entry.defaultSelected ? "default" : "optional" };
+  return { plugin: entry, policy: entry.defaultSelected ? "default" : "optional", audience: null };
 }
 
 export class PluginRegistry {
@@ -32,6 +41,19 @@ export class PluginRegistry {
     return this.entries.map((entry) => ({ ...entry }));
   }
 
+  /**
+   * Compiled-in plugins and top-level declarations: the only registrations a
+   * pass that writes a persisted surface may reconcile.
+   */
+  baseRegistrations(): NormalizedRegistration[] {
+    return this.getEntries().filter((entry) => entry.audience === null);
+  }
+
+  /** The registrations one audience declared; only its launch layer renders them. */
+  audienceRegistrations(audience: string): NormalizedRegistration[] {
+    return this.getEntries().filter((entry) => entry.audience === audience);
+  }
+
   getPolicy(pluginId: string): PluginPolicy | undefined {
     return this.entries.find((entry) => entry.plugin.id === pluginId)?.policy;
   }

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

@@ -1,20 +1,23 @@
+import path from "node:path";
+
+import { runtimeOpenCodePluginRoot } from "../../runtime/runtime-directory";
 import {
   CLAUDE_LOCAL_CONFIG_DOCUMENT,
   CLAUDE_SETTINGS_DOCUMENT,
   OPENCODE_CONFIG_DOCUMENT,
-} from "../../lib/orchestrator/projection-runtime-documents";
-import type {
-  ManagedRegion,
-  RenderedRuntimeDocument,
-} from "../../lib/orchestrator/projection-types";
-import { getOpenCodePluginRoot } from "../../lib/package-paths";
+  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";
@@ -22,6 +25,7 @@ import {
   renderCompanionExternalDirectoryPermissions,
   renderManagedOpenCodeMcpServers,
 } from "./providers/opencode";
+import { isRecord, readOpenCodeConfig } from "./providers/opencode-format";
 import { projectionRepoRoot } from "./surface-target";
 
 /**
@@ -47,40 +51,39 @@ function document(documentPath: string, regions: ManagedRegion[]): RenderedRunti
 /**
  * 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, and a bare session
- * has no launch overlay to find it in. The root is machine-local, which this
- * git-excluded document tolerates and a committed config would not.
- *
- * A managed launch lists the same root in its `OPENCODE_CONFIG_CONTENT`
- * overlay; OpenCode dedupes identical plugin paths across config sources.
+ * 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.
  */
 
 /**
- * Capability hook groups stay companion-only. A managed session loads this
- * document as its `local` source *alongside* the companion's, so anything here
- * that the launch also delivers runs twice; the guard, the guidance hook and
- * the banner are the contributions whose absence is a correctness hole and
- * whose double run is inert — the guard because its verdict depends only on the
- * tool input, the guidance hook because it yields nothing under a launch
- * environment, and the banner because the copy carried here is flagged
- * `--projected` and defers to the one the launch's own plugin prints.
- *
- * `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` is what a managed launch sets
- * beside `--add-dir`. Without it the companion directories this document
- * already permits are reachable but their `CLAUDE.md` is not loaded, so the
- * permission alone delivers no guidance.
+ * 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 [
-    { at: ["hooks", "PreToolUse"], kind: "list", values: mateGuardHookGroups() },
-    {
-      at: ["hooks", "SessionStart"],
+    ...events.map((event): ManagedRegion => ({
+      at: ["hooks", event],
       kind: "list",
-      values: [...mateBannerHookGroups(), ...mateGuidanceHookGroups()],
-    },
+      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
@@ -152,10 +155,10 @@ export function renderDocumentsForTarget(
         {
           at: ["plugins"],
           kind: "list",
-          values: [getOpenCodePluginRoot()],
+          values: [runtimeOpenCodePluginRoot()],
         },
         {
-          at: ["mcp", "servers"],
+          at: [...OPENCODE_MCP_SERVERS_AT],
           kind: "map",
           entries: renderManagedOpenCodeMcpServers(inputs),
         },
@@ -164,8 +167,125 @@ export function renderDocumentsForTarget(
           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 };
+}

package/src/tools/setup/surface-target.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 
+import { audienceLayerDir } from "../../runtime/audience-layer";
 import type { ProjectionTarget, SetupContext } from "./plugin";
 
 /**
@@ -14,6 +15,9 @@ export function projectionTarget(ctx: SetupContext): ProjectionTarget {
       "a working-target reconcile needs a Working Repository in scope; none was supplied",
     );
   }
+  if (target === "audience-layer" && !ctx.audience) {
+    throw new Error("an audience-layer reconcile needs an audience; none was supplied");
+  }
   return target;
 }
 
@@ -38,13 +42,18 @@ export function projectionRepoRoot(ctx: SetupContext): string {
 }
 
 /**
- * The root a Runtime Surface writes into. Defined for the companion target
- * only: a working-target pass renders its documents for the Projection Root to
- * place, so no Runtime Surface ever computes a path inside a Working Repository.
+ * The root a Runtime Surface writes into: the companion, or one audience's
+ * layer outside every repository. Never a Working Repository: a working-target
+ * pass renders its documents for the Projection Root to place, so no Runtime
+ * Surface ever computes a path inside one.
  */
 export function surfaceRoot(ctx: SetupContext): string {
-  if (projectionTarget(ctx) === "working") {
+  const target = projectionTarget(ctx);
+  if (target === "working") {
     throw new Error("a working-target reconcile renders its documents; it writes no surface root");
   }
+  if (target === "audience-layer") {
+    return ctx.layerRoot ?? audienceLayerDir(ctx.companionPath, ctx.audience!);
+  }
   return ctx.companionPath;
 }

package/src/tools/setup/upgrade-sweep.ts

@@ -0,0 +1,153 @@
+// oxlint-disable no-await-in-loop
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { FRAMEWORK_NAME } from "../../framework";
+import { removeManagedBlocksForPlugin } from "./context-services";
+import {
+  audiencePluginDeclarations,
+  declaredAudiences,
+  effectivePluginDeclarations,
+  readFrameworkRaw,
+} from "./dynamic-plugins/audiences";
+import { validateDeclaration } from "./dynamic-plugins/declarations";
+import { loadDynamicPlugin, type DynamicPluginLoadDeps } from "./dynamic-plugins/loader";
+import type { CapabilityContributionInput, CapabilityPlugin, Plugin, SetupContext } from "./plugin";
+import type { NormalizedRegistration } from "./registry";
+
+/**
+ * Upgrade Sweep: removes what audience plugins leaked into a companion before
+ * the contribution ledger existed. Runs once, when a persisted pass finds no
+ * ledger, and again only for the packages it could not load then.
+ */
+
+/** The companion files Mate's managed guidance blocks live in. */
+const GUIDANCE_FILES = ["CLAUDE.md", "AGENTS.md", path.join(".opencode", "AGENTS.md")];
+
+const MANAGED_BLOCK_START = new RegExp(
+  `<!-- ${FRAMEWORK_NAME}:managed:([^\\n]+):[0-9a-f]+ start -->`,
+  "g",
+);
+
+/** Plugin ids owning a managed guidance block in `text`. */
+export function managedBlockOwners(text: string): string[] {
+  return [...new Set([...text.matchAll(MANAGED_BLOCK_START)].map((match) => match[1]!))];
+}
+
+/** `relative path → owners` for every managed guidance block under `root`. */
+export async function managedGuidanceOwners(root: string): Promise<Map<string, string[]>> {
+  const owners = new Map<string, string[]>();
+  for (const file of GUIDANCE_FILES) {
+    const text = await fs.readFile(path.join(root, file), "utf8").catch(() => null);
+    if (text === null) continue;
+    const found = managedBlockOwners(text);
+    if (found.length > 0) owners.set(file, found);
+  }
+  return owners;
+}
+
+/**
+ * Guidance blocks name their owner, so this needs no plugin loaded: every
+ * block whose owner is not a base registration goes.
+ */
+export async function removeForeignGuidanceBlocks(
+  root: string,
+  baseIds: ReadonlySet<string>,
+): Promise<void> {
+  for (const [file, owners] of await managedGuidanceOwners(root)) {
+    for (const owner of owners) {
+      if (baseIds.has(owner)) continue;
+      await removeManagedBlocksForPlugin(path.join(root, file), FRAMEWORK_NAME, owner);
+    }
+  }
+}
+
+export interface AudienceSweep {
+  /** Disabled inputs for every swept plugin, per runtime. */
+  teardown: Map<string, CapabilityContributionInput[]>;
+  /** Packages that could not be loaded; their non-guidance entries stay until a retry. */
+  unswept: string[];
+  warnings: string[];
+}
+
+export interface AudienceSweepOptions {
+  /** Every registration of the process; an audience plugin already loaded is reused, not reloaded. */
+  registrations: readonly NormalizedRegistration[];
+  /** Restrict the sweep to these packages; every audience declaration when absent. */
+  packages?: ReadonlySet<string>;
+  deps?: DynamicPluginLoadDeps;
+}
+
+/** One distinct package per audience declaration, base packages excluded. */
+function audiencePackages(raw: unknown): Map<string, ReturnType<typeof validateDeclaration>> {
+  const basePackages = new Set(
+    effectivePluginDeclarations(raw, null).flatMap((entry) => {
+      const { declaration } = validateDeclaration(entry);
+      return declaration ? [declaration.package] : [];
+    }),
+  );
+  const found = new Map<string, ReturnType<typeof validateDeclaration>>();
+  for (const audience of declaredAudiences(raw)) {
+    for (const entry of audiencePluginDeclarations(raw, audience)) {
+      const validated = validateDeclaration(entry);
+      const name = validated.declaration?.package;
+      if (!name || basePackages.has(name) || found.has(name)) continue;
+      found.set(name, validated);
+    }
+  }
+  return found;
+}
+
+/**
+ * Collects the declarations of every audience plugin as disabled inputs:
+ * loaded for its declarations only — never activated, no lifecycle hook run.
+ * An unloadable plugin is reported, never fatal.
+ */
+export async function sweepAudienceDeclarations(
+  ctx: SetupContext,
+  options: AudienceSweepOptions,
+): Promise<AudienceSweep> {
+  const sweep: AudienceSweep = { teardown: new Map(), unswept: [], warnings: [] };
+  const raw = await readFrameworkRaw(ctx.companionPath);
+
+  for (const [name, { declaration }] of audiencePackages(raw)) {
+    if (options.packages && !options.packages.has(name)) continue;
+    let plugin: Plugin | undefined = options.registrations.find(
+      (entry) => entry.packageName === name,
+    )?.plugin;
+    if (!plugin) {
+      const loaded = await loadDynamicPlugin(ctx.companionPath, declaration!, options.deps);
+      if (!loaded.ok) {
+        sweep.unswept.push(name);
+        sweep.warnings.push(
+          `audience plugin "${name}" was not swept from the companion: ${loaded.warning} Its entries stay until a pass can load it.`,
+        );
+        continue;
+      }
+      plugin = loaded.plugin;
+    }
+
+    const capability = plugin as CapabilityPlugin;
+    if (plugin.kind !== "capability" || !capability.getRuntimeContributions) continue;
+    try {
+      const byRuntime = await capability.getRuntimeContributions(ctx);
+      for (const [runtimeId, contributions] of Object.entries(byRuntime)) {
+        if (!contributions) continue;
+        const inputs = sweep.teardown.get(runtimeId) ?? [];
+        inputs.push({
+          pluginId: plugin.id,
+          enabled: false,
+          capabilityEnabled: false,
+          contributions,
+        });
+        sweep.teardown.set(runtimeId, inputs);
+      }
+    } catch (error) {
+      sweep.unswept.push(name);
+      sweep.warnings.push(
+        `audience plugin "${name}" was not swept from the companion: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+  return sweep;
+}

package/src/tools/setup/working-repo-cleanup.ts

@@ -18,6 +18,7 @@ const REPORTED_AS: Partial<
 > = {
   "projection-root": { as: "removed", label: ".mate" },
   "git-excludes": { as: "removed", label: "git-excludes" },
+  "openspec-store-pointer": { as: "removed", label: "openspec/config.yaml" },
   "claude-working-settings": { as: "updated", label: "claude-settings" },
   "legacy-tokensave-claude-md": { as: "updated", label: "claude-settings" },
 };
@@ -36,6 +37,7 @@ export async function cleanupWorkingRepository(
       retained.push(entry.id);
       continue;
     }
+    if (entry.retains && !retained.includes(entry.retains)) retained.push(entry.retains);
     if (entry.state !== "removed") continue;
     const reported = REPORTED_AS[entry.id];
     if (!reported) continue;