@uniqbit/mate-core 0.18.4 → 0.18.5

package/src/tools/setup/registry.ts

@@ -3,22 +3,13 @@ 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,
-      audience: entry.audience ?? null,
-      ...(entry.packageName ? { packageName: entry.packageName } : {}),
-    };
+    return { plugin: entry.plugin, policy: entry.policy };
   }
-  return { plugin: entry, policy: entry.defaultSelected ? "default" : "optional", audience: null };
+  return { plugin: entry, policy: entry.defaultSelected ? "default" : "optional" };
 }
 
 export class PluginRegistry {
@@ -41,19 +32,6 @@ 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/surface-target.ts

@@ -1,6 +1,5 @@
 import path from "node:path";
 
-import { audienceLayerDir } from "../../runtime/audience-layer";
 import type { ProjectionTarget, SetupContext } from "./plugin";
 
 /**
@@ -15,9 +14,6 @@ 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;
 }
 
@@ -42,18 +38,13 @@ export function projectionRepoRoot(ctx: SetupContext): string {
 }
 
 /**
- * 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.
+ * 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.
  */
 export function surfaceRoot(ctx: SetupContext): string {
-  const target = projectionTarget(ctx);
-  if (target === "working") {
+  if (projectionTarget(ctx) === "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.ts

@@ -61,7 +61,7 @@ export async function applySetupCompatibilities(
   companionPath: string,
   config: FrameworkConfig,
   mode: "setup" | "sync",
-  plugins: PluginRegistration[] = getActiveDistribution().registry.baseRegistrations(),
+  plugins: PluginRegistration[] = getActiveDistribution().registry.getEntries(),
   repoPath?: string,
   scope: SetupScope = config.type === "hub" ? "hub" : "companion",
 ): Promise<SetupInstallationOutcome> {
@@ -73,15 +73,14 @@ export async function applySetupCompatibilities(
 
 /**
  * The active Agent Runtimes' documents for a Working Repository, rendered
- * without a write: base, plus the audience the checkout is wrapped for. Runs no plugin phase: the working target reconciles
+ * without a write. Runs no plugin phase: the working target reconciles
  * declarations only, so nothing is written to the companion on its behalf.
  */
 export async function renderWorkingRuntimeDocuments(
   companionPath: string,
   config: FrameworkConfig,
   repoPath: string,
-  plugins: PluginRegistration[] = getActiveDistribution().registry.baseRegistrations(),
-  wrapped?: { audience: string; registrations: PluginRegistration[] },
+  plugins: PluginRegistration[] = getActiveDistribution().registry.getAll(),
 ): Promise<RenderedRuntimeDocuments> {
   const plan = buildSetupInstallationPlan(config, plugins);
   const ctx: SetupContext = {
@@ -92,7 +91,7 @@ export async function renderWorkingRuntimeDocuments(
     repoPath,
     target: "working",
   };
-  return renderRuntimeDocuments(ctx, plugins, plan, wrapped);
+  return renderRuntimeDocuments(ctx, plugins, plan);
 }
 
 export async function updateProjectGitignore(
@@ -100,9 +99,7 @@ export async function updateProjectGitignore(
   config: FrameworkConfig,
 ): Promise<void> {
   const ctx: SetupContext = { companionPath, config, mode: "sync", activeProviders: [] };
-  const plugins = getActiveDistribution()
-    .registry.baseRegistrations()
-    .map((entry) => entry.plugin);
+  const plugins = getActiveDistribution().registry.getAll();
   const entries = collectManagedGitignoreEntries(ctx, plugins);
   await writeManagedGitignoreBlock(path.join(companionPath, ".gitignore"), FRAMEWORK_NAME, entries);
 }
@@ -116,7 +113,7 @@ export async function syncCompanionFiles(
     companionPath,
     config,
     "sync",
-    getActiveDistribution().registry.baseRegistrations(),
+    getActiveDistribution().registry.getAll(),
     repoPath,
   );
 }

package/opencode-plugin/src/audience-layer.ts

@@ -1,91 +0,0 @@
-import type { Context } from "@opencode/plugin/promise/plugin";
-
-import { repositoryWrappedForOpenCode } from "../../src/opencode/companion-hooks";
-import { currentAudienceLayer } from "../../src/runtime/audience-layer";
-import { MATE_ENV } from "../../src/runtime/env";
-import { parseGuidanceContent } from "../../src/runtime/guidance";
-import {
-  readOpenCodeAudienceLayer,
-  type OpenCodeLayerContents,
-} from "../../src/runtime/opencode-audience-layer";
-import { readWrapStateSync } from "../../src/runtime/wrap-state";
-import type { LaunchEnvironment } from "./launch-environment";
-
-export interface TrustedAudienceLayer {
-  root: string;
-  contents: OpenCodeLayerContents;
-}
-
-/**
- * The audience layer named by a payload the plugin trusts. `env` is the
- * launch environment `pluginLaunchEnvironment` decided on, so a masked
- * payload, a bare session and the shared service all read as `{}` here and
- * never apply a layer.
- */
-export async function readTrustedAudienceLayer(
-  env: LaunchEnvironment,
-): Promise<TrustedAudienceLayer | null> {
-  const payload = env[MATE_ENV.guidanceJson];
-  if (!payload?.trim()) return null;
-  const root = parseGuidanceContent(payload).guidance.audienceLayer;
-  if (!root) return null;
-  return { root, contents: await readOpenCodeAudienceLayer(root) };
-}
-
-/**
- * The layer of the audience the session's checkout is wrapped for. The wrap is
- * resolved from the session's own directory, so the shared service serves each
- * checkout its own audience; the environment never selects one.
- */
-export async function readWrappedAudienceLayer(
-  directory: string,
-  companionPath: string,
-): Promise<TrustedAudienceLayer | null> {
-  const repoRoot = repositoryWrappedForOpenCode(directory);
-  if (!repoRoot) return null;
-  const audience = readWrapStateSync(repoRoot).audience;
-  if (!audience) return null;
-  const root = currentAudienceLayer(companionPath, audience);
-  return root ? { root, contents: await readOpenCodeAudienceLayer(root) } : null;
-}
-
-/**
- * Applies a layer's MCP servers, skills and agents through the plugin API. A
- * new agent id is created by updating it; its prompt goes in `system`.
- */
-export async function registerAudienceLayer(
-  api: Context,
-  layer: OpenCodeLayerContents,
-): Promise<void> {
-  if (layer.mcpServers.length > 0) {
-    await api.mcp.transform((editor) => {
-      for (const server of layer.mcpServers) editor.set(server.name, server.config as never);
-    });
-  }
-
-  if (layer.skills.length > 0) {
-    await api.skill.transform((editor) => {
-      for (const skill of layer.skills) {
-        if (editor.get(skill.id)) {
-          editor.update(skill.id, (current) => Object.assign(current, skill));
-        } else {
-          editor.add(skill as never);
-        }
-      }
-    });
-  }
-
-  if (layer.agents.length > 0) {
-    await api.agent.transform((editor) => {
-      for (const agent of layer.agents) {
-        editor.update(agent.id, (current) => {
-          const target = current as Record<string, unknown>;
-          target.name ??= agent.id;
-          if (agent.description) target.description = agent.description;
-          target.mode = agent.mode;
-          target.system = agent.system;
-        });
-      }
-    });
-  }
-}

package/src/runtime/audience-layer.ts

@@ -1,84 +0,0 @@
-import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-
-import { FRAMEWORK_NAME } from "./framework";
-import { mateHome } from "./runtime-directory";
-
-/**
- * Audience Layer locations. A layer holds one audience's plugin contributions
- * for one companion, rendered for managed launches only. It lives under Mate's
- * machine-local state, never inside a repository: a layer inside the companion
- * would be readable by every session with companion access, and could carry
- * values resolved from plugin configuration.
- *
- *   <state>/audience-layers/<companion-key>/<audience>/
- *     <fingerprint>/   one complete render; never changed once renamed into place
- *     current          symlink to the newest complete render
- *
- * A launch attaches the fingerprint directory itself, so a later re-render
- * never changes what a running session reads.
- */
-
-/** Mirrors `AUDIENCE_NAME_PATTERN`; repeated here because `runtime/` imports nothing from core. */
-const SAFE_AUDIENCE = /^[a-z][a-z0-9-]{0,63}$/;
-
-export const CURRENT_LAYER_LINK = "current";
-
-export function audienceLayersRoot(homeDir?: string): string {
-  return path.join(mateHome(homeDir), "state", "audience-layers");
-}
-
-/** A short, stable key for one companion checkout: a hash of its resolved path. */
-export function companionLayerKey(companionPath: string): string {
-  return crypto.createHash("sha256").update(path.resolve(companionPath)).digest("hex").slice(0, 16);
-}
-
-/** The directory holding one audience's layers for one companion. */
-export function audienceLayerDir(
-  companionPath: string,
-  audience: string,
-  homeDir?: string,
-): string {
-  if (!SAFE_AUDIENCE.test(audience)) {
-    throw new Error(`"${audience}" is not a valid audience name for a layer directory`);
-  }
-  return path.join(audienceLayersRoot(homeDir), companionLayerKey(companionPath), audience);
-}
-
-/** The newest complete layer of `audience`, or `null` when none was rendered on this machine. */
-export function currentAudienceLayer(
-  companionPath: string,
-  audience: string,
-  homeDir?: string,
-): string | null {
-  try {
-    const dir = audienceLayerDir(companionPath, audience, homeDir);
-    const layer = path.join(dir, fs.readlinkSync(path.join(dir, CURRENT_LAYER_LINK)));
-    return fs.existsSync(layer) ? layer : null;
-  } catch {
-    return null;
-  }
-}
-
-const MANAGED_MARKER = new RegExp(
-  `^<!-- ${FRAMEWORK_NAME}:managed:[^\\n]* (?:start|end) -->$`,
-  "gm",
-);
-
-/** A layer guidance document's text, managed-block markers removed; empty when absent. */
-export function layerGuidanceText(text: string): string {
-  return text
-    .replace(MANAGED_MARKER, "")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-/** `file` (`CLAUDE.md`, `AGENTS.md`) of the layer at `root`, markers removed; empty when absent. */
-export function readLayerGuidanceSync(root: string, file: string): string {
-  try {
-    return layerGuidanceText(fs.readFileSync(path.join(root, file), "utf8"));
-  } catch {
-    return "";
-  }
-}

package/src/runtime/opencode-audience-layer.ts

@@ -1,176 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { layerGuidanceText } from "./audience-layer";
-import { OPENCODE_MCP_SERVERS_AT } from "./runtime-document-manifest";
-
-/**
- * Reads an audience layer the OpenCode Runtime Surface wrote, as what the Mate
- * OpenCode plugin applies through the plugin API. The surface re-exports it as
- * its own reader; it lives under `runtime/` only so the import-isolated plugin
- * can reach it. The plugin parses no OpenCode document itself.
- */
-
-export interface LayerMcpServer {
-  name: string;
-  /** The entry exactly as the surface wrote it under `mcp.servers`. */
-  config: Record<string, unknown>;
-}
-
-export interface LayerSkill {
-  id: string;
-  name: string;
-  description?: string;
-  /** The skill's `SKILL.md`. */
-  path: string;
-  content: string;
-}
-
-export type LayerAgentMode = "subagent" | "primary" | "all";
-
-export interface LayerAgent {
-  id: string;
-  description?: string;
-  mode: LayerAgentMode;
-  /** The agent's prompt: the definition's body. */
-  system: string;
-}
-
-export interface OpenCodeLayerContents {
-  mcpServers: LayerMcpServer[];
-  skills: LayerSkill[];
-  agents: LayerAgent[];
-  /** The layer's guidance sections, managed-block markers removed. */
-  guidance: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function splitFrontmatter(content: string): { fields: string; body: string } {
-  const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-  return match
-    ? { fields: match[1]!, body: content.slice(match[0].length) }
-    : { fields: "", body: content };
-}
-
-function frontmatterScalarFromFields(fields: string, key: string): string | undefined {
-  const value = fields.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim();
-  return value?.replace(
-    /^(?:"([\s\S]*)"|'([\s\S]*)')$/,
-    (_all, doubleQuoted?: string, singleQuoted?: string) => doubleQuoted ?? singleQuoted ?? "",
-  );
-}
-
-/** One scalar of a simple YAML frontmatter, quotes removed. */
-export function frontmatterScalar(content: string, key: string): string | undefined {
-  return frontmatterScalarFromFields(splitFrontmatter(content).fields, key);
-}
-
-/** An id OpenCode accepts for a skill or agent name. */
-export function contributionId(name: string, fallback: string): string {
-  return (
-    name
-      .toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/^-+|-+$/g, "") || fallback
-  );
-}
-
-async function findSkillFiles(directory: string): Promise<string[]> {
-  try {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const nested = await Promise.all(
-      entries.map((entry) => {
-        const entryPath = path.join(directory, entry.name);
-        if (entry.isFile() && entry.name === "SKILL.md") return Promise.resolve([entryPath]);
-        return entry.isDirectory() ? findSkillFiles(entryPath) : Promise.resolve([]);
-      }),
-    );
-    return nested.flat().toSorted();
-  } catch {
-    return [];
-  }
-}
-
-/** Every `SKILL.md` under `roots`; an unreadable skill is skipped, never fatal. */
-export async function loadSkillInfos(roots: readonly string[]): Promise<LayerSkill[]> {
-  const files = (await Promise.all(roots.map(findSkillFiles))).flat();
-  const skills = await Promise.all(
-    files.map(async (filePath): Promise<LayerSkill | null> => {
-      try {
-        const content = await fs.readFile(filePath, "utf8");
-        const { fields } = splitFrontmatter(content);
-        const name =
-          frontmatterScalarFromFields(fields, "name") || path.basename(path.dirname(filePath));
-        const description = frontmatterScalarFromFields(fields, "description");
-        return {
-          id: contributionId(name, "mate-skill"),
-          name,
-          ...(description ? { description } : {}),
-          path: filePath,
-          content,
-        };
-      } catch {
-        return null;
-      }
-    }),
-  );
-  return skills.filter((skill) => skill !== null);
-}
-
-async function readMcpServers(root: string): Promise<LayerMcpServer[]> {
-  const parsed = await fs
-    .readFile(path.join(root, ".opencode", "opencode.json"), "utf8")
-    .then((text) => JSON.parse(text) as unknown)
-    .catch(() => null);
-  let servers: unknown = parsed;
-  for (const key of OPENCODE_MCP_SERVERS_AT) servers = isRecord(servers) ? servers[key] : undefined;
-  if (!isRecord(servers)) return [];
-  return Object.entries(servers)
-    .filter((entry): entry is [string, Record<string, unknown>] => isRecord(entry[1]))
-    .map(([name, config]) => ({ name, config }))
-    .toSorted((left, right) => left.name.localeCompare(right.name));
-}
-
-function agentMode(value: string | undefined): LayerAgentMode {
-  return value === "subagent" || value === "primary" ? value : "all";
-}
-
-async function readAgents(root: string): Promise<LayerAgent[]> {
-  const dir = path.join(root, ".opencode", "agents");
-  const names = await fs.readdir(dir).catch(() => [] as string[]);
-  const agents = await Promise.all(
-    names
-      .filter((name) => name.endsWith(".md"))
-      .toSorted()
-      .map(async (name): Promise<LayerAgent | null> => {
-        const content = await fs.readFile(path.join(dir, name), "utf8").catch(() => null);
-        if (content === null) return null;
-        const { fields, body } = splitFrontmatter(content);
-        const description = frontmatterScalarFromFields(fields, "description");
-        return {
-          id: contributionId(path.basename(name, ".md"), "mate-agent"),
-          ...(description ? { description } : {}),
-          mode: agentMode(frontmatterScalarFromFields(fields, "mode")),
-          system: body.trim(),
-        };
-      }),
-  );
-  return agents.filter((agent) => agent !== null);
-}
-
-async function readGuidance(root: string): Promise<string> {
-  return layerGuidanceText(await fs.readFile(path.join(root, "AGENTS.md"), "utf8").catch(() => ""));
-}
-
-export async function readOpenCodeAudienceLayer(root: string): Promise<OpenCodeLayerContents> {
-  const [mcpServers, skills, agents, guidance] = await Promise.all([
-    readMcpServers(root),
-    loadSkillInfos([path.join(root, ".agents", "skills")]),
-    readAgents(root),
-    readGuidance(root),
-  ]);
-  return { mcpServers, skills, agents, guidance };
-}