@uniqbit/mate-core 0.18.4 → 0.18.5

package/opencode-plugin/src/add-dir.ts

@@ -1,8 +1,15 @@
+import fs from "node:fs/promises";
 import path from "node:path";
 
 import type { Context } from "@opencode/plugin/promise/plugin";
 
-import { loadSkillInfos } from "../../src/runtime/opencode-audience-layer";
+type CompanionSkill = {
+  id: string;
+  name: string;
+  description?: string;
+  path: string;
+  content: string;
+};
 
 function companionSkillPaths(companionPath: string): string[] {
   return [
@@ -16,28 +23,87 @@ function isWithin(root: string, candidate: string): boolean {
   return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }
 
+function parseFrontmatter(content: string): { name?: string; description?: string } {
+  const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) return {};
+
+  const scalar = (key: string) => {
+    const value = match[1].match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim();
+    return value?.replace(
+      /^(?:"([\s\S]*)"|'([\s\S]*)')$/,
+      (_all, doubleQuoted, singleQuoted) => doubleQuoted ?? singleQuoted,
+    );
+  };
+
+  return { name: scalar("name"), description: scalar("description") };
+}
+
+async function findSkillFiles(directory: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files: string[] = [];
+    const subdirectories: Promise<string[]>[] = [];
+    for (const entry of entries) {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isFile() && entry.name === "SKILL.md") files.push(entryPath);
+      else if (entry.isDirectory()) subdirectories.push(findSkillFiles(entryPath));
+    }
+    const nested = await Promise.all(subdirectories);
+    return [...files, ...nested.flat()];
+  } catch {
+    return [];
+  }
+}
+
+function skillID(name: string): string {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9_-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "mate-skill"
+  );
+}
+
+async function loadCompanionSkills(companionPath: string): Promise<CompanionSkill[]> {
+  const files = (await Promise.all(companionSkillPaths(companionPath).map(findSkillFiles))).flat();
+  const skills = await Promise.all(
+    files.map(async (filePath): Promise<CompanionSkill | null> => {
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        const metadata = parseFrontmatter(content);
+        const name = metadata.name || path.basename(path.dirname(filePath));
+        return {
+          id: skillID(name),
+          name,
+          ...(metadata.description ? { description: metadata.description } : {}),
+          path: filePath,
+          content,
+        };
+      } catch {
+        /** An unreadable companion skill must not prevent the session from loading. */
+        return null;
+      }
+    }),
+  );
+  return skills.filter((skill) => skill !== null);
+}
+
 /**
  * Grants the session access to the companion and registers its skills. The
  * permission hook only widens access for companion resources; every other
  * evaluation keeps OpenCode's own verdict.
  */
-export async function registerCompanionAccess(
-  api: Context,
-  companionPath: string,
-  extraRoots: readonly string[] = [],
-): Promise<void> {
+export async function registerCompanionAccess(api: Context, companionPath: string): Promise<void> {
   const permissionRoot = path.resolve(companionPath);
-  /** An audience layer's files are as readable as the companion's, for this launch only. */
-  const allowedRoots = [permissionRoot, ...extraRoots.map((root) => path.resolve(root))];
 
   await api.permission.hook("evaluate", (event) => {
-    if (event.resources.some((resource) => allowedRoots.some((root) => isWithin(root, resource)))) {
+    if (event.resources.some((resource) => isWithin(permissionRoot, resource))) {
       event.effect = "allow";
       delete event.message;
     }
   });
 
-  const skills = await loadSkillInfos(companionSkillPaths(permissionRoot));
+  const skills = await loadCompanionSkills(permissionRoot);
   if (skills.length === 0) return;
 
   await api.skill.transform((editor) => {

package/opencode-plugin/src/companion.ts

@@ -77,7 +77,6 @@ function buildSystemPrompt(
   context: CompanionContext,
   guidance: MateGuidanceFile,
   wrapperBinPath: string,
-  layerGuidance: string,
 ): string[] {
   const lines = [materializeCompanionGuidance(guidance.companionGuidance, context, wrapperBinPath)];
 
@@ -89,11 +88,6 @@ function buildSystemPrompt(
     lines.push("", `<agents.md>${context.agentsMd.trim()}</agents.md>`);
   }
 
-  /** The audience's guidance follows the companion's, never replaces it. */
-  if (layerGuidance.trim()) {
-    lines.push("", layerGuidance.trim());
-  }
-
   return lines;
 }
 
@@ -188,7 +182,6 @@ export async function registerCompanion(
   api: Context,
   context: CompanionContext,
   env: LaunchEnvironment = process.env,
-  layerGuidance = "",
 ): Promise<void> {
   const guidance = loadGuidance(env, api.location.directory);
   if (!guidance) return;
@@ -199,7 +192,7 @@ export async function registerCompanion(
     return;
   }
 
-  const companion = buildSystemPrompt(context, guidance, wrapperBinPath, layerGuidance).join("\n");
+  const companion = buildSystemPrompt(context, guidance, wrapperBinPath).join("\n");
 
   await api.session.hook("context", (event) => {
     const merged = mergeCompanionSystem(event.system, companion);

package/opencode-plugin/src/server.ts

@@ -11,11 +11,6 @@ import { spawnPrepareRunner } from "../../src/runtime/session-prepare-runner";
 import { readWrapStateSync } from "../../src/runtime/wrap-state";
 
 import { registerCompanionAccess } from "./add-dir";
-import {
-  readTrustedAudienceLayer,
-  readWrappedAudienceLayer,
-  registerAudienceLayer,
-} from "./audience-layer";
 import { missingRuntimeDirectoryMessage, registerCompanion, resolveMateBin } from "./companion";
 import { pluginLaunchEnvironment, type LaunchEnvironment } from "./launch-environment";
 
@@ -56,17 +51,9 @@ export const MateOpenCodePlugin = Plugin.define({
     const context = readContext(env, api.location.directory);
     if (!context.companionPath) return;
 
-    /**
-     * A layer comes from a payload this launch trusts, else from the wrap of
-     * the session's checkout; an inherited environment never names one.
-     */
-    const layer =
-      (await readTrustedAudienceLayer(env)) ??
-      (await readWrappedAudienceLayer(api.location.directory, context.companionPath));
-    await registerCompanionAccess(api, context.companionPath, layer ? [layer.root] : []);
+    await registerCompanionAccess(api, context.companionPath);
     await registerCompanionHooks(api, context, env);
-    await registerCompanion(api, context, env, layer?.contents.guidance);
-    if (layer) await registerAudienceLayer(api, layer.contents);
+    await registerCompanion(api, context, env);
     /** Last: the guardrails above are live while the local phase holds `setup`. */
     const prepareCleanup = await registerPrepare(api, context.companionPath, env);
     return async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniqbit/mate-core",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "description": "Core framework and plugin APIs for Mate.",
   "license": "MIT",
   "repository": {

package/src/cli/commands/artifact/finish/openspec.ts

@@ -73,9 +73,12 @@ type ProjectionResult =
   | { ok: true; repository: string; areas: string[] }
   | { ok: false; reason: string };
 
+/** A leading `---` block; group 1 is its YAML, the match ends after the closing line. */
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+
 function parseDeltaScopes(source: string): ScopePair[] {
   const text = source.startsWith(BOM) ? source.slice(BOM.length) : source;
-  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+  const match = FRONTMATTER_PATTERN.exec(text);
   if (!match) return [];
 
   try {
@@ -95,6 +98,26 @@ function parseDeltaScopes(source: string): ScopePair[] {
   }
 }
 
+const DELTA_TAGS = new Set(["openspec/change", "openspec/delta"]);
+
+/**
+ * A header an agent copied from a delta: it declares `type: delta-spec`, carries a
+ * `change` key, or a delta tag. A nested `scopes` key alone does not count, since
+ * legacy canonical specs carry one.
+ */
+function isDeltaShapedFrontmatter(yamlSource: string): boolean {
+  try {
+    const parsed = parse(yamlSource) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+    const header = parsed as Record<string, unknown>;
+    if (header.type === "delta-spec" || "change" in header) return true;
+    const tags = Array.isArray(header.tags) ? header.tags : [header.tags];
+    return tags.some((tag) => typeof tag === "string" && DELTA_TAGS.has(tag));
+  } catch {
+    return false;
+  }
+}
+
 function projectDeltaScopes(scopes: ScopePair[]): ProjectionResult {
   if (scopes.length === 0) return { ok: false, reason: "delta declares no scopes entries" };
   const repositories = [...new Set(scopes.map((entry) => entry.repository))];
@@ -133,7 +156,10 @@ async function archivedChangeUsesMateSchema(
   }
 }
 
-/** Scope keys are omitted when the delta had none — a partial block beats no frontmatter. */
+/**
+ * The block through its closing line. Scope keys are omitted when the delta had
+ * none — a partial block beats no frontmatter.
+ */
 function renderCanonicalFrontmatter(
   capability: string,
   scope: { repository: string; areas: string[] } | null,
@@ -146,14 +172,14 @@ function renderCanonicalFrontmatter(
     "tags: [openspec/spec]",
     "---",
     "",
-    "",
   ].join("\n");
 }
 
 /**
  * Repairs `openspec archive` output: prepends canonical frontmatter to main specs the
- * archive run created bare. Publish does not archive, so this runs the first time publish
- * resolves that archive, however the archive was made.
+ * archive run created bare, and replaces a delta-shaped header an agent copied onto one.
+ * Publish does not archive, so this runs the first time publish resolves that archive,
+ * however the archive was made.
  *
  * `openspec archive` rebuilds a brand-new main spec from a skeleton with no frontmatter slot,
  * so scope metadata dies exactly once, at spec birth; existing specs keep theirs because only
@@ -197,8 +223,14 @@ async function reconcileMainSpecFrontmatter(
       const canonicalPath = path.join(companionPath, canonicalRelative);
 
       try {
-        const canonical = await fs.readFile(canonicalPath, "utf8");
-        if (canonical.replace(BOM, "").startsWith("---")) continue;
+        const canonical = (await fs.readFile(canonicalPath, "utf8")).replace(BOM, "");
+        /** The body that follows the written block: the whole file, or what trails a delta-shaped header. */
+        let body = `\n${canonical}`;
+        if (canonical.startsWith("---")) {
+          const header = FRONTMATTER_PATTERN.exec(canonical);
+          if (!header || !isDeltaShapedFrontmatter(header[1])) continue;
+          body = canonical.slice(header[0].length);
+        }
 
         const deltaSource = await fs.readFile(path.join(directory, entry.name), "utf8");
         const scopes = parseDeltaScopes(deltaSource);
@@ -215,7 +247,7 @@ async function reconcileMainSpecFrontmatter(
           capability,
           projected.ok ? { repository: projected.repository, areas: projected.areas } : null,
         );
-        await fs.writeFile(canonicalPath, head + canonical.replace(BOM, ""), "utf8");
+        await fs.writeFile(canonicalPath, head + body, "utf8");
         reconciled.push(canonicalRelative);
       } catch (error) {
         process.stderr.write(

package/src/cli/commands/doctor.ts

@@ -1,10 +1,13 @@
 import { execFileSync } from "node:child_process";
+import fs from "node:fs/promises";
 import path from "node:path";
 
+import { parse as parseYaml } from "yaml";
+
 import { FRAMEWORK_NAME } from "../../framework";
 import { gitEnvironment } from "../../runtime/companion-git";
-import { readWrapStateSync } from "../../runtime/wrap-state";
 import { getActiveDistribution } from "../../distribution";
+import { hasOpenspecCapability } from "../../lib/orchestrator/capabilities";
 import { checkEngineRequirement } from "../../lib/orchestrator/engine-guard";
 import type { GlobalConfigStore } from "../../lib/orchestrator/global-config-store";
 import { pathIsDirectory } from "../../lib/fs-utils";
@@ -20,12 +23,7 @@ import {
   type PluginInspection,
   type PluginVerificationFailure,
 } from "../../tools/setup/dynamic-plugins/verify";
-import {
-  inspectAudienceIsolation,
-  type AudienceIsolationReport,
-} from "../../tools/setup/isolation-diagnostics";
 import { getRequiredPluginDrift } from "../../tools/setup/policy";
-import type { PluginRegistry } from "../../tools/setup/registry";
 import { resolveCommandOnPath } from "../../tools/setup/utils";
 import { writeJsonStdout } from "../write-json-stdout";
 import { printSection, renderKeyValueTable, renderTable } from "./status";
@@ -39,8 +37,6 @@ interface DoctorDeps {
   inspectPlugins?: (companionPath: string) => Promise<PluginInspection>;
   /** Environment `MATE_AUDIENCE` is read from; defaults to the process environment. */
   env?: Record<string, string | undefined>;
-  /** The hydrated registry; the active distribution's when absent. */
-  registry?: PluginRegistry;
 }
 
 export type DoctorKind = "core" | "working" | "companion" | "hub";
@@ -74,18 +70,15 @@ export interface DoctorReport {
   toolInstallations?: DoctorToolInstallation[];
   requiredPluginDrift?: Array<{ pluginId: string; kind: string; reason: string }>;
   pluginFailures?: PluginVerificationFailure[];
-  /**
-   * Present for a companion that declares audiences or has one selected.
-   * `wrapped` is the audience the working repository is wrapped for, when any.
-   */
-  audiences?: { declared: string[]; active: string | null; wrapped?: string };
+  /** Present for a companion that declares audiences or has one selected. */
+  audiences?: { declared: string[]; active: string | null };
   /** Set when `MATE_AUDIENCE` names an audience the companion does not declare. */
   audienceError?: string;
-  /** Present when an audience's contributions reached a persisted surface, or a launch layer cannot deliver part of one. */
-  audienceIsolation?: AudienceIsolationReport;
   /** IDs of the capabilities the verified plugins provide. */
   pluginCapabilities?: string[];
   engineRequirement?: { range: string; ok: boolean; detail: string };
+  /** Present when the companion's `openspec/config.yaml` has `rules` keys OpenSpec ignores. */
+  openspecRuleWarnings?: Array<{ key: string; message: string }>;
   hub?: { members: DoctorHubMember[] };
   resolutionFailures: Array<{ companionPath: string; message: string }>;
 }
@@ -243,21 +236,79 @@ function collectAudiences(
   report: DoctorReport,
   config: FrameworkConfig,
   env: Record<string, string | undefined>,
-  repositoryPath: string | null,
 ): void {
   const declared = Object.keys(config.audiences ?? {});
   const requested = readAudienceSelection(env);
   if (declared.length === 0 && requested === null) return;
   const resolution = resolveAudience(config, requested);
-  const wrapped = repositoryPath ? readWrapStateSync(repositoryPath).audience : null;
-  report.audiences = {
-    declared,
-    active: resolution.ok ? resolution.active : null,
-    ...(wrapped ? { wrapped } : {}),
-  };
+  report.audiences = { declared, active: resolution.ok ? resolution.active : null };
   if (!resolution.ok) report.audienceError = describeUnknownAudience(resolution);
 }
 
+/** Artifact IDs of OpenSpec's built-in `spec-driven` schema. */
+const BUILT_IN_OPENSPEC_ARTIFACTS = ["proposal", "specs", "design", "tasks"];
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/** Built-in IDs plus every `artifacts[].id` from a `schema.yaml` under the companion's `openspec/schemas/`. */
+async function knownOpenSpecArtifactIds(companionPath: string): Promise<Set<string>> {
+  const schemasDir = path.join(companionPath, "openspec", "schemas");
+  let schemaNames: string[] = [];
+  try {
+    schemaNames = await fs.readdir(schemasDir);
+  } catch {
+    /* no companion schemas */
+  }
+  const schemaIds = await Promise.all(
+    schemaNames.map(async (name) => {
+      try {
+        const schema = asRecord(
+          parseYaml(await fs.readFile(path.join(schemasDir, name, "schema.yaml"), "utf8")),
+        );
+        const artifacts: unknown[] = Array.isArray(schema?.artifacts) ? schema.artifacts : [];
+        return artifacts.flatMap((artifact) => {
+          const id = asRecord(artifact)?.id;
+          return typeof id === "string" ? [id] : [];
+        });
+      } catch {
+        return []; // not a readable schema
+      }
+    }),
+  );
+  return new Set([...BUILT_IN_OPENSPEC_ARTIFACTS, ...schemaIds.flat()]);
+}
+
+/**
+ * OpenSpec ignores a `rules` key that names no artifact, warning only on stderr
+ * of the command that reads it. Read-only; a missing or unparseable config is silent.
+ */
+async function collectOpenSpecRuleWarnings(
+  companionPath: string,
+): Promise<NonNullable<DoctorReport["openspecRuleWarnings"]>> {
+  let rules: Record<string, unknown> | undefined;
+  try {
+    const config = parseYaml(
+      await fs.readFile(path.join(companionPath, "openspec", "config.yaml"), "utf8"),
+    );
+    rules = asRecord(asRecord(config)?.rules);
+  } catch {
+    return [];
+  }
+  if (!rules) return [];
+
+  const known = await knownOpenSpecArtifactIds(companionPath);
+  return Object.keys(rules)
+    .filter((key) => !known.has(key))
+    .map((key) => ({
+      key,
+      message: `rules.${key} matches no OpenSpec artifact and is ignored; put workflow guidance in operations.apply.guidance or operations.archive.guidance`,
+    }));
+}
+
 export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<DoctorReport> {
   const cwd = path.resolve(deps.cwd ?? process.cwd());
   const pathValue = deps.pathValue ?? process.env.PATH ?? "";
@@ -293,16 +344,16 @@ export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<Doctor
 
   const env = deps.env ?? process.env;
   if (root.rootPath && root.config && kind !== "hub") {
-    collectAudiences(report, root.config, env, root.linkedRepository?.path ?? null);
-    const isolation = await inspectAudienceIsolation(
-      root.rootPath,
-      root.config,
-      deps.registry ?? getActiveDistribution().registry,
-      report.audiences?.active ?? null,
-    );
-    if (isolation.leaked.length + isolation.unswept.length + isolation.undelivered.length > 0) {
-      report.audienceIsolation = isolation;
-    }
+    collectAudiences(report, root.config, env);
+  }
+
+  if (
+    root.rootPath &&
+    (kind === "working" || kind === "companion") &&
+    hasOpenspecCapability(root.config?.capabilities)
+  ) {
+    const warnings = await collectOpenSpecRuleWarnings(root.rootPath);
+    if (warnings.length > 0) report.openspecRuleWarnings = warnings;
   }
 
   if (root.rootPath && root.config) {
@@ -353,49 +404,6 @@ function renderHubMembers(members: DoctorHubMember[]): string {
   );
 }
 
-function renderAudienceIsolation(isolation: AudienceIsolationReport): string {
-  const parts: string[] = [];
-  if (isolation.leaked.length > 0) {
-    parts.push(
-      "Contributions on persisted surfaces that no base plugin owns; the next sync removes them:",
-      renderTable(
-        ["Surface", "Kind", "Entry", "Owner"],
-        isolation.leaked.map((entry) => [
-          entry.surface,
-          entry.kind,
-          entry.identity ?? "",
-          entry.owner,
-        ]),
-      ),
-    );
-  }
-  if (isolation.unswept.length > 0) {
-    parts.push(
-      `Audience plugins not swept (could not be loaded); run \`MATE_AUDIENCE=<audience> ${FRAMEWORK_NAME} install --yes\` with their credentials:`,
-      renderList(isolation.unswept, ""),
-    );
-  }
-  if (isolation.undelivered.length > 0) {
-    parts.push(
-      "Active audience plugins contribute declaratively only; these parts are not delivered:",
-      renderList(
-        isolation.undelivered.map(
-          (entry) =>
-            `${entry.pluginId}: ${entry.parts
-              .map((part) =>
-                part === "pluginReferences"
-                  ? "OpenCode plugin references are not delivered"
-                  : `${part} is not run`,
-              )
-              .join("; ")}`,
-        ),
-        "",
-      ),
-    );
-  }
-  return parts.join("\n\n");
-}
-
 function renderHumanReport(report: DoctorReport): void {
   console.log("Mate Doctor");
   console.log("");
@@ -442,20 +450,9 @@ function renderHumanReport(report: DoctorReport): void {
       renderKeyValueTable([
         ["Declared", report.audiences.declared.join(", ") || "none"],
         ["Active", report.audiences.active ?? "none"],
-        ...(report.audiences.wrapped
-          ? [
-              ["Wrapped", `${report.audiences.wrapped} (bare sessions of this checkout)`] as [
-                string,
-                string,
-              ],
-            ]
-          : []),
       ]),
     );
   }
-  if (report.audienceIsolation) {
-    printSection("Audience Isolation", renderAudienceIsolation(report.audienceIsolation));
-  }
   if (report.hub) printSection("Hub Members", renderHubMembers(report.hub.members));
   // Companions with no drift produce no section at all: required plugins are
   // silent when healthy.
@@ -480,6 +477,15 @@ function renderHumanReport(report: DoctorReport): void {
   if (report.engineRequirement) {
     printSection("Version Requirement", report.engineRequirement.detail);
   }
+  if (report.openspecRuleWarnings) {
+    printSection(
+      "OpenSpec Config",
+      renderList(
+        report.openspecRuleWarnings.map((warning) => warning.message),
+        "",
+      ),
+    );
+  }
 
   printSection(
     "Resolution Failures",

package/src/cli/commands/install.ts

@@ -1,8 +1,5 @@
-import path from "node:path";
-
 import { confirm } from "../confirm";
 import { FRAMEWORK_NAME } from "../../framework";
-import { ConfigStore } from "../../lib/orchestrator/config-store";
 import {
   buildInstallPlan,
   inspectInstallPlan,
@@ -179,11 +176,6 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
   }
 
   try {
-    if (!frozen && context.kind === "companion" && context.companionPath) {
-      await new ConfigStore(
-        path.join(context.companionPath, `.${FRAMEWORK_NAME}`, "config", "framework.yaml"),
-      ).save(context.config);
-    }
     await reconcileInstalledCompanion(plan);
     await saveCompleteInstallState(plan, execution.results);
   } catch (error) {

package/src/cli/commands/studio/terminal-launch.ts

@@ -3,11 +3,9 @@ import path from "node:path";
 
 import { FRAMEWORK_NAME } from "../../../framework";
 import { ConfigStore, mergeWithDefaults } from "../../../lib/orchestrator/config-store";
-import { currentAudienceLayer } from "../../../runtime/audience-layer";
 import {
   effectiveStudioAgent,
   readAudienceSelection,
-  resolveAudience,
 } from "../../../tools/setup/dynamic-plugins/audiences";
 import type { StudioInventory, StudioInventoryCompanion } from "./inventory";
 import { findAction, promptArgs, skillInstalledFor, SUBJECT_PATTERN } from "./actions";
@@ -53,8 +51,7 @@ export interface DefaultAgentOutcome {
 /**
  * The companion's effective default agent for one provider: the active
  * audience's `studio.terminal.agent` (Studio's own `MATE_AUDIENCE`, never the
- * browser's), else the base one. Its definition may come from the companion
- * or from the active audience's rendered layer. Never throws and never echoes the configured
+ * browser's), else the base one. Never throws and never echoes the configured
  * value into the notice.
  */
 export async function defaultAgentFor(
@@ -65,13 +62,11 @@ export async function defaultAgentFor(
   const configPath = path.join(companionPath, `.${FRAMEWORK_NAME}`, "config", "framework.yaml");
   if (!fs.existsSync(configPath)) return {};
   let name: unknown;
-  let layer: string | null = null;
   try {
-    const config = await new ConfigStore(configPath).load();
-    const audience = resolveAudience(config, readAudienceSelection(env));
-    const active = audience.ok ? audience.active : null;
-    name = effectiveStudioAgent(config, active);
-    if (active) layer = currentAudienceLayer(companionPath, active);
+    name = effectiveStudioAgent(
+      await new ConfigStore(configPath).load(),
+      readAudienceSelection(env),
+    );
   } catch {
     return {};
   }
@@ -81,12 +76,8 @@ export async function defaultAgentFor(
       notice: "Default agent not applied: studio.terminal.agent is not a valid agent name.",
     };
   }
-  /** The audience's own agents live in its launch layer, which the terminal's launch attaches. */
-  const roots = layer ? [companionPath, layer] : [companionPath];
-  const defined = roots.some((root) =>
-    fs.existsSync(path.join(root, AGENT_DEFINITION_DIRS[agent], `${name}.md`)),
-  );
-  if (!defined) {
+  const definition = path.join(companionPath, AGENT_DEFINITION_DIRS[agent], `${name}.md`);
+  if (!fs.existsSync(definition)) {
     return {
       notice: `Default agent "${name}" not applied: this companion has no ${agent} definition for it.`,
     };