@uniqbit/mate-core 0.18.4 → 0.18.5

package/src/lib/orchestrator/projection-claude-skills.ts

@@ -1,8 +1,6 @@
-// oxlint-disable no-await-in-loop
 import fs from "node:fs/promises";
 import path from "node:path";
 
-import { CURRENT_LAYER_LINK } from "../../runtime/audience-layer";
 import { readProjectionFile } from "../../runtime/projection";
 import { realLinkTarget, realOrResolved } from "../fs-utils";
 import {
@@ -66,114 +64,63 @@ async function createSkillLink(target: string, link: string): Promise<void> {
   await fs.symlink(target, link, process.platform === "win32" ? "junction" : "dir");
 }
 
-const CLAUDE_AGENTS_PATH = path.join(".claude", "agents");
-
-/** The manifest key of an agent link: repo-relative, POSIX separators. */
-function agentKey(file: string): string {
-  return `.claude/agents/${file}`;
-}
-
-async function agentFiles(root: string): Promise<string[]> {
-  const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
-  return entries
-    .filter((entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".md"))
-    .map((entry) => entry.name);
-}
-
-/**
- * Every link the wrap wants, by manifest key: the companion's skills, then the
- * wrapped audience's skills and agents. An audience link targets the layer
- * through its `current` link, so a re-rendered layer never strands it. A
- * companion skill wins a name both provide.
- */
-async function wantedLinks(
-  currentRoot: string | null,
-  layerRoot: string | null,
-): Promise<Map<string, string>> {
-  const wanted = new Map<string, string>();
-  if (currentRoot) {
-    for (const name of await skillNames(currentRoot)) {
-      wanted.set(recordKey(name), path.join(currentRoot, name));
-    }
-  }
-  if (layerRoot) {
-    const layerSkills = path.join(layerRoot, "skills");
-    for (const name of await skillNames(layerSkills)) {
-      if (!wanted.has(recordKey(name))) wanted.set(recordKey(name), path.join(layerSkills, name));
-    }
-    const layerAgents = path.join(layerRoot, "agents");
-    for (const file of await agentFiles(layerAgents)) {
-      wanted.set(agentKey(file), path.join(layerAgents, file));
-    }
-  }
-  return wanted;
-}
-
 /**
  * Recorded link: Mate's while it resolves to its recorded target. Unrecorded:
- * a skill link is adopted only when it resolves into a registered, current or
- * projected companion; an agent link never is. Records follow the filesystem,
- * so a partial failure re-adopts.
+ * adopted only when it resolves into a registered, current or projected
+ * companion. Records follow the filesystem, so a partial failure re-adopts.
  */
 export async function reconcileWorkingRepoClaudeSkillLinks(
   repoPath: string,
   companionPath: string | null,
   enabled: boolean,
   registeredCompanionPaths: string[] = [],
-  audienceLayerDir: string | null = null,
 ): Promise<"written" | "current"> {
-  const repoRoot = path.resolve(repoPath);
   const currentRoot = companionPath ? path.resolve(companionPath, CLAUDE_SKILLS_PATH) : null;
-  const layerRoot =
-    audienceLayerDir && enabled ? path.join(audienceLayerDir, CURRENT_LAYER_LINK, ".claude") : null;
   const roots = await registeredSkillRoots(repoPath, companionPath, registeredCompanionPaths);
+  const targetRoot = path.join(path.resolve(repoPath), CLAUDE_SKILLS_PATH);
   const recorded = links(await readManifest(repoPath), "claude");
-  const wanted = await wantedLinks(enabled ? currentRoot : null, layerRoot);
+  const existing = await fs.readdir(targetRoot, { withFileTypes: true }).catch(() => []);
+  const sourceNames: Set<string> =
+    currentRoot && enabled ? new Set(await skillNames(currentRoot)) : new Set<string>();
   const records: Record<string, LinkRecord> = {};
   let changed = false;
 
-  const linkDirs = [
-    { dir: path.join(repoRoot, CLAUDE_SKILLS_PATH), keyOf: recordKey, adoptable: true },
-    { dir: path.join(repoRoot, CLAUDE_AGENTS_PATH), keyOf: agentKey, adoptable: false },
-  ];
-  for (const { dir, keyOf, adoptable } of linkDirs) {
-    const existing = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const entry of existing) {
-      if (!entry.isSymbolicLink()) continue;
-      const link = path.join(dir, entry.name);
-      const target = await linkTarget(link);
-      if (target === null) continue;
-      const key = keyOf(entry.name);
-      const record = recorded[key];
-      const owned = record
-        ? (await realOrResolved(record.target)) === target
-        : adoptable && roots.some((root) => path.dirname(target) === root);
-      if (!owned) continue;
+  for (const entry of existing) {
+    if (!entry.isSymbolicLink()) continue;
+    const link = path.join(targetRoot, entry.name);
+    const target = await linkTarget(link);
+    if (target === null) continue;
+    const record = recorded[recordKey(entry.name)];
+    const owned = record
+      ? (await realOrResolved(record.target)) === target
+      : roots.some((root) => path.dirname(target) === root);
+    if (!owned) continue;
+
+    const wanted = currentRoot ? path.join(currentRoot, entry.name) : null;
+    if (wanted && sourceNames.has(entry.name) && (await realOrResolved(wanted)) === target) {
+      records[recordKey(entry.name)] = { runtime: "claude", target: wanted };
+      continue;
+    }
 
-      const want = wanted.get(key);
-      if (want && (await realOrResolved(want)) === target) {
-        records[key] = { runtime: "claude", target: want };
-        continue;
-      }
+    await fs.unlink(link);
+    changed = true;
+  }
 
-      await fs.unlink(link);
+  if (currentRoot && sourceNames.size > 0) {
+    await fs.mkdir(targetRoot, { recursive: true });
+    for (const name of sourceNames) {
+      const link = path.join(targetRoot, name);
+      const existingLink = await fs.lstat(link).catch(() => null);
+      if (existingLink) continue;
+      const target = path.join(currentRoot, name);
+      await createSkillLink(target, link);
+      records[recordKey(name)] = { runtime: "claude", target };
       changed = true;
     }
   }
 
-  for (const [key, target] of wanted) {
-    const link = path.join(repoRoot, ...key.split("/"));
-    const existingLink = await fs.lstat(link).catch(() => null);
-    if (existingLink) continue;
-    await fs.mkdir(path.dirname(link), { recursive: true });
-    if (key.startsWith(".claude/agents/")) await fs.symlink(target, link, "file");
-    else await createSkillLink(target, link);
-    records[key] = { runtime: "claude", target };
-    changed = true;
-  }
-
   if (changed || !enabled) {
-    for (const { dir } of linkDirs) await pruneEmptyAncestors(dir, repoRoot);
+    await pruneEmptyAncestors(targetRoot, path.resolve(repoPath));
   }
   if (JSON.stringify(sortedEntries(records)) !== JSON.stringify(sortedEntries(recorded))) {
     await updateManifest(repoPath, (manifest) => withLinks(manifest, "claude", records));

package/src/lib/orchestrator/projection-entries.ts

@@ -307,7 +307,6 @@ function buildEntries(): readonly ProjectionEntry[] {
           input.companionPath ?? null,
           input.config.allowedAgents?.includes("claude") ?? false,
           registeredCompanionPaths,
-          input.audienceLayerDir ?? null,
         );
       },
       removal: {

package/src/lib/orchestrator/projection-types.ts

@@ -50,8 +50,6 @@ export interface ProjectionInput {
   runtimeDocuments?: readonly RenderedRuntimeDocument[];
   /** Restricts runtime-tagged entries to these runtimes; every runtime when absent. */
   runtimes?: readonly WrapRuntime[];
-  /** The layer directory of the audience the checkout is wrapped for; `null` or absent for base only. */
-  audienceLayerDir?: string | null;
 }
 
 export interface ProjectionRemovalInput {

package/src/lib/orchestrator/session-prepare.ts

@@ -7,14 +7,8 @@ import {
   syncCompanionUnattended,
   type UnattendedSyncOutcome,
 } from "../../runtime/companion-sync";
-import { readWrapStateSync, type WrapState } from "../../runtime/wrap-state";
+import type { WrapState } from "../../runtime/wrap-state";
 import { syncCompanionFiles } from "../../tools/setup";
-import { renderAudienceLayer, type RenderedAudienceLayer } from "../../tools/setup/audience-layer";
-import {
-  readAudienceSelection,
-  resolveAudience,
-} from "../../tools/setup/dynamic-plugins/audiences";
-import { buildSetupInstallationPlan } from "../../tools/setup/engine";
 import type { CapabilityPlugin, LaunchPreflightContext } from "../../tools/setup/plugin";
 import { attendedLockOptions, syncCompanionGit } from "./companion-git-sync";
 import { readCompanionConfig } from "./config-store";
@@ -40,8 +34,7 @@ export type PrepareStepName =
   | "file-sync"
   | "launch-projection"
   | "working-target"
-  | "preflight"
-  | "audience-layer";
+  | "preflight";
 
 export interface PrepareStep {
   step: PrepareStepName;
@@ -68,8 +61,6 @@ export interface PrepareResult {
   failure?: unknown;
   /** The wrap state the `working-target` step's pass left; a launch reads no manifest itself. */
   wrapState?: WrapState;
-  /** The active audience's layer, rendered for an attended prepare only. */
-  audienceLayer?: RenderedAudienceLayer;
 }
 
 export interface PrepareSessionInput {
@@ -98,10 +89,9 @@ const SYNC_LOCK_TIMEOUT_MS = 5 * 60_000;
  */
 async function runCapabilityPreflight(context: LaunchPreflightContext): Promise<void> {
   const { config, providerId } = context;
-  /** Base only: an audience plugin's `forProvider` hooks never run. */
   const preflights = getActiveDistribution()
-    .registry.baseRegistrations()
-    .flatMap(({ plugin }) => {
+    .registry.getAll()
+    .flatMap((plugin) => {
       if (plugin.kind !== "capability" || !plugin.isEnabled(config)) return [];
       const capability = plugin as CapabilityPlugin;
       const preflight = capability.forProvider?.[providerId]?.preflight;
@@ -147,11 +137,6 @@ export const sessionPrepareDeps = {
   withCompanionLock,
   /** As the launch decides it: Git may prompt only with a terminal on both ends. */
   isInteractiveTerminal: () => !!(process.stdin.isTTY && process.stdout.isTTY),
-  /** The launch's `MATE_AUDIENCE`; read by an attended prepare only. */
-  audienceSelection: () => readAudienceSelection(process.env),
-  /** The audience a checkout is wrapped for, from its manifest; `null` for base. */
-  wrappedAudience: (repoPath: string) => readWrapStateSync(repoPath).audience,
-  renderAudienceLayer,
 };
 
 function message(error: unknown): string {
@@ -164,7 +149,6 @@ class StepLog {
   readonly warnings: string[] = [];
   failure: unknown;
   wrapState: WrapState | undefined;
-  audienceLayer: RenderedAudienceLayer | undefined;
   stopped = false;
   companionChanged = false;
 
@@ -337,71 +321,12 @@ async function runLocal(
   });
 }
 
-/**
- * The active audience's launch layer, after the base prepare. Only a managed
- * launch reaches here: a bare session's prepare never renders one, whatever
- * `MATE_AUDIENCE` its environment carries. An audience the companion does not
- * declare renders nothing; hydration already warned about it.
- */
-async function renderLayer(
-  input: PrepareSessionInput,
-  config: FrameworkConfig,
-  run: StepLog,
-): Promise<void> {
-  const deps = sessionPrepareDeps;
-  /** Adopted from the wrap: the wrap delivers it, so the launch renders no layer of its own. */
-  const wrapped = input.repository ? deps.wrappedAudience(input.repository.path) : null;
-  if (wrapped) {
-    run.push({ step: "audience-layer", outcome: "ok", detail: `${wrapped}: from the wrap` });
-    return;
-  }
-  const audience = resolveAudience(config, deps.audienceSelection());
-  if (!audience.ok || audience.active === null) return;
-  try {
-    const registry = getActiveDistribution().registry;
-    const layer = await deps.renderAudienceLayer({
-      companionPath: input.companionPath,
-      config,
-      audience: audience.active,
-      activeProviders: buildSetupInstallationPlan(config, registry.baseRegistrations())
-        .activeProviders,
-      registrations: registry.audienceRegistrations(audience.active),
-    });
-    run.audienceLayer = layer;
-    run.push({
-      step: "audience-layer",
-      outcome: "ok",
-      detail: `${layer.audience}: ${layer.rendered ? "rendered" : "current"}`,
-    });
-  } catch (error) {
-    run.fail("audience-layer", error);
-  }
-}
-
-/**
- * A checkout wrapped for one audience refuses a launch for another before
- * anything runs: the wrap's on-disk content would reach that session.
- */
-function audienceConflict(input: PrepareSessionInput, config: FrameworkConfig): string | null {
-  if (!input.repository) return null;
-  const wrapped = sessionPrepareDeps.wrappedAudience(input.repository.path);
-  if (!wrapped) return null;
-  const selected = resolveAudience(config, sessionPrepareDeps.audienceSelection());
-  if (!selected.ok || selected.active === null || selected.active === wrapped) return null;
-  return `${FRAMEWORK_NAME}: ${input.repository.id} is wrapped for audience "${wrapped}", but MATE_AUDIENCE selects "${selected.active}". Run \`${FRAMEWORK_NAME} wrap --audience ${selected.active}\` in ${input.repository.path}, or launch from another worktree wrapped for "${selected.active}".`;
-}
-
 async function runAttended(
   input: PrepareSessionInput,
   config: FrameworkConfig,
   run: StepLog,
 ): Promise<void> {
   const deps = sessionPrepareDeps;
-  const conflict = audienceConflict(input, config);
-  if (conflict) {
-    run.fail("audience-layer", new LaunchPreflightError(conflict));
-    return;
-  }
   if (input.skipGit) {
     run.push({ step: "git-sync", outcome: "skipped", detail: "--no-git" });
   } else if (config.git !== "auto") {
@@ -422,8 +347,6 @@ async function runAttended(
     }
   }
   await runLocal(input, config, run);
-  if (run.stopped) return;
-  await renderLayer(input, config, run);
 }
 
 /** The sync's own config read: only a fast-forward can have changed it. */
@@ -478,7 +401,6 @@ export async function prepareSession(input: PrepareSessionInput): Promise<Prepar
     ...(run.companionChanged ? { companionChanged: true as const } : {}),
     ...(run.failure === undefined ? {} : { failure: run.failure }),
     ...(run.wrapState ? { wrapState: run.wrapState } : {}),
-    ...(run.audienceLayer ? { audienceLayer: run.audienceLayer } : {}),
   });
 
   const locked = await deps.withCompanionLock(input.companionPath, lockOptions(input), async () => {

package/src/lib/orchestrator/wrap-pass.ts

@@ -1,24 +1,11 @@
 import path from "node:path";
 
 import { renderWorkingRuntimeDocuments } from "../../tools/setup";
-import { renderAudienceLayer } from "../../tools/setup/audience-layer";
-import { loadAudienceRegistrations } from "../../tools/setup/audience-registrations";
-import { declaredAudiences } from "../../tools/setup/dynamic-plugins/audiences";
-import { buildSetupInstallationPlan } from "../../tools/setup/engine";
-import { getActiveDistribution } from "../../distribution";
-import { audienceLayerDir } from "../../runtime/audience-layer";
-import {
-  readManifest,
-  recordedAudience,
-  updateManifest,
-  withAudience,
-} from "../../runtime/runtime-document-manifest";
 import { readCompanionConfig } from "./config-store";
 import { GlobalConfigStore } from "./global-config-store";
 import { entryFailureMessage, firstFailure, type ProjectionChangedPaths } from "./projection-types";
 import type { WrapRuntime } from "../../runtime/runtime-document-manifest";
 import { readWrapState, type WrapState } from "../../runtime/wrap-state";
-import type { NormalizedRegistration } from "../../tools/setup/registry";
 import type { FrameworkConfig, LinkedRepository } from "./types";
 import { project } from "./working-repo-projection";
 
@@ -26,8 +13,6 @@ export interface WrapPassDependencies {
   renderWorkingRuntimeDocuments: typeof renderWorkingRuntimeDocuments;
   readCompanionConfig: typeof readCompanionConfig;
   project: typeof project;
-  loadAudienceRegistrations: typeof loadAudienceRegistrations;
-  renderAudienceLayer: typeof renderAudienceLayer;
   /** The registered companions, whose stale skill links a re-pin withdraws; the user's registry when absent. */
   globalConfigStore?: GlobalConfigStore;
 }
@@ -36,8 +21,6 @@ export const wrapPassDeps: WrapPassDependencies = {
   renderWorkingRuntimeDocuments,
   readCompanionConfig,
   project,
-  loadAudienceRegistrations,
-  renderAudienceLayer,
 };
 
 export interface WrapPassOptions {
@@ -45,12 +28,6 @@ export interface WrapPassOptions {
   runtimes?: readonly WrapRuntime[];
   /** The companion config the caller already read; read from files otherwise. */
   config?: FrameworkConfig;
-  /**
-   * The audience to wrap the checkout for: a name records it, `null` withdraws
-   * it, absent keeps the one the manifest records. Never read from the
-   * environment: it is the only source of a bare session's audience.
-   */
-  audience?: string | null;
 }
 
 export type WrapPassResult =
@@ -70,21 +47,9 @@ export type WrapPassResult =
       runtimes: ReadonlySet<WrapRuntime>;
       /** The wrap state as this pass left it. */
       wrapState: WrapState;
-      /** The audience the checkout is wrapped for after this pass. */
-      audience: string | null;
     }
   | { kind: "failed"; message: string };
 
-/** An audience a checkout may be wrapped for: declared by the companion, never the reserved base. */
-function wrappableAudience(config: FrameworkConfig, audience: string): boolean {
-  return audience !== "base" && declaredAudiences(config).includes(audience);
-}
-
-function describeUnwrappable(config: FrameworkConfig, audience: string): string {
-  const declared = declaredAudiences(config).filter((name) => name !== "base");
-  return `audience "${audience}" cannot be wrapped: the companion declares ${declared.length > 0 ? declared.join(", ") : "no audiences"}.`;
-}
-
 /**
  * One pass of the `wrap` scope, restricted to the requested runtimes by each
  * entry's runtime tag. Best-effort per entry like every projection: a failed
@@ -98,50 +63,10 @@ export async function runWrapPass(
 ): Promise<WrapPassResult> {
   const resolvedCompanionPath = path.resolve(companionPath);
   const config = options.config ?? (await deps.readCompanionConfig(resolvedCompanionPath));
-
-  const audienceWarnings: string[] = [];
-  let audience: string | null;
-  if (options.audience === undefined) {
-    const recorded = recordedAudience(await readManifest(repository.path));
-    /** A recorded audience the companion no longer declares falls back to base, never fails a prepare. */
-    if (recorded && !wrappableAudience(config, recorded)) {
-      audienceWarnings.push(
-        `${describeUnwrappable(config, recorded)} ${repository.id} is wrapped for base only.`,
-      );
-      audience = null;
-    } else {
-      audience = recorded;
-    }
-  } else {
-    audience = options.audience;
-    if (audience && !wrappableAudience(config, audience)) {
-      return { kind: "failed", message: describeUnwrappable(config, audience) };
-    }
-  }
-
-  let wrapped: { audience: string; registrations: NormalizedRegistration[] } | undefined;
-  if (audience) {
-    const loaded = await deps.loadAudienceRegistrations(resolvedCompanionPath, config, audience);
-    audienceWarnings.push(...loaded.warnings);
-    await deps.renderAudienceLayer({
-      companionPath: resolvedCompanionPath,
-      config,
-      audience,
-      activeProviders: buildSetupInstallationPlan(
-        config,
-        getActiveDistribution().registry.baseRegistrations(),
-      ).activeProviders,
-      registrations: loaded.registrations,
-    });
-    wrapped = { audience, registrations: loaded.registrations };
-  }
-
   const rendered = await deps.renderWorkingRuntimeDocuments(
     resolvedCompanionPath,
     config,
     repository.path,
-    undefined,
-    wrapped,
   );
   const result = await deps.project("wrap", {
     repoPath: repository.path,
@@ -149,7 +74,6 @@ export async function runWrapPass(
     repository,
     config,
     runtimeDocuments: rendered.documents,
-    audienceLayerDir: audience ? audienceLayerDir(resolvedCompanionPath, audience) : null,
     globalConfigStore: deps.globalConfigStore ?? new GlobalConfigStore(),
     ...(options.runtimes ? { runtimes: options.runtimes } : {}),
   });
@@ -157,12 +81,6 @@ export async function runWrapPass(
   const failure = firstFailure(result.outcomes);
   if (failure) return { kind: "failed", message: entryFailureMessage(failure, repository.id) };
 
-  const before = recordedAudience(await readManifest(repository.path));
-  const audienceChanged = before !== audience;
-  if (audienceChanged) {
-    await updateManifest(repository.path, (manifest) => withAudience(manifest, audience));
-  }
-
   /** Read once under the caller's lock, so it is exactly what the pass recorded. */
   let wrapState: WrapState;
   try {
@@ -194,10 +112,7 @@ export async function runWrapPass(
     .map((outcome) => outcome.path);
 
   return {
-    kind:
-      audienceChanged || result.outcomes.some((outcome) => outcome.state === "written")
-        ? "written"
-        : "current",
+    kind: result.outcomes.some((outcome) => outcome.state === "written") ? "written" : "current",
     projectionRoot: result.root,
     companionPath: resolvedCompanionPath,
     documents: [...new Set(documents)],
@@ -207,7 +122,6 @@ export async function runWrapPass(
       removed: result.outcomes.flatMap((outcome) => outcome.changed?.removed ?? []),
     },
     warnings: [
-      ...audienceWarnings,
       ...rendered.warnings,
       ...result.outcomes.flatMap((outcome) => outcome.warnings ?? []),
       /** A degradable failure does not fail the pass, but it is never silent. */
@@ -217,6 +131,5 @@ export async function runWrapPass(
     ],
     runtimes,
     wrapState,
-    audience,
   };
 }

package/src/runtime/guidance.ts

@@ -1,5 +1,3 @@
-import path from "node:path";
-
 /**
  * Versioned companion guidance contract. The CLI builds the guidance data
  * from its playbooks at launch time and delivers it through the
@@ -18,12 +16,6 @@ export type MateGuidanceFile = {
   companionGuidance: string;
   codebaseExplorationGuidance: string;
   errors: string[];
-  /**
-   * The active audience's layer, for a launch that hosts its own server only.
-   * The plugin applies it only from a payload it trusts; a masked payload
-   * carries none, so the shared service and bare sessions never see one.
-   */
-  audienceLayer?: string;
 };
 
 export type GuidanceValidation = {
@@ -84,21 +76,12 @@ export function validateGuidanceData(value: unknown): GuidanceValidation {
     errors.push("injected codebase exploration guidance is malformed");
   }
 
-  const audienceLayer =
-    typeof value.audienceLayer === "string" && path.isAbsolute(value.audienceLayer)
-      ? value.audienceLayer
-      : undefined;
-  if (value.audienceLayer !== undefined && audienceLayer === undefined) {
-    errors.push("injected audience layer is not an absolute path");
-  }
-
   return {
     guidance: {
       version: GUIDANCE_FILE_VERSION,
       companionGuidance,
       codebaseExplorationGuidance,
       errors,
-      ...(audienceLayer ? { audienceLayer } : {}),
     },
     errors,
   };

package/src/runtime/policy.ts

@@ -40,17 +40,6 @@ function capabilityNames(value: unknown): string[] {
     .filter((name): name is string => typeof name === "string");
 }
 
-/**
- * A base-set key from `audiences.base`, the shape a companion is saved in. The
- * lenient twin of the setup normalizer, which `runtime/` cannot import.
- */
-function baseAudienceKey(config: Record<string, unknown>, key: string): unknown {
-  const audiences = config.audiences;
-  if (!audiences || typeof audiences !== "object") return undefined;
-  const base = (audiences as Record<string, unknown>).base;
-  return base && typeof base === "object" ? (base as Record<string, unknown>)[key] : undefined;
-}
-
 /**
  * Synchronous so it composes into `readCompanionRuntimeContext`. A missing or
  * unparseable companion config yields an inert policy rather than throwing.
@@ -67,9 +56,7 @@ export function readCompanionPolicy(companionPath: string): CompanionPolicy {
   const config = parsed as Record<string, unknown>;
   return {
     allowedAgents: stringList(config.allowedAgents),
-    enabledCapabilities: capabilityNames(
-      config.capabilities ?? baseAudienceKey(config, "capabilities"),
-    ),
+    enabledCapabilities: capabilityNames(config.capabilities),
     gitAutoMode: config.git === "auto",
   };
 }

package/src/runtime/runtime-document-manifest.ts

@@ -80,8 +80,6 @@ export interface Manifest {
   readonly runtimes: Readonly<Record<string, WrapRuntime>>;
   readonly copies: Readonly<Record<string, CopyRecord>>;
   readonly links: Readonly<Record<string, LinkRecord>>;
-  /** The audience `mate wrap --audience` recorded; the only source of a bare session's audience. */
-  readonly audience?: string;
 }
 
 export const EMPTY_MANIFEST: Manifest = Object.freeze({
@@ -126,23 +124,9 @@ function manifestOf(parsed: Record<string, unknown>): Manifest {
     runtimes: isRecord(parsed.runtimes) ? (parsed.runtimes as Manifest["runtimes"]) : {},
     copies: isRecord(parsed.copies) ? (parsed.copies as Manifest["copies"]) : {},
     links: isRecord(parsed.links) ? (parsed.links as Manifest["links"]) : {},
-    ...(typeof parsed.audience === "string" && parsed.audience
-      ? { audience: parsed.audience }
-      : {}),
   };
 }
 
-/** The audience the checkout is wrapped for; `null` for base only. */
-export function recordedAudience(manifest: Manifest): string | null {
-  return manifest.audience ?? null;
-}
-
-/** Records the checkout's audience, or none with `null`. */
-export function withAudience(manifest: Manifest, audience: string | null): Manifest {
-  const { audience: _previous, ...rest } = manifest;
-  return audience ? { ...rest, audience } : rest;
-}
-
 function recordedRuntime(manifest: Manifest, documentPath: string): WrapRuntime {
   return manifest.runtimes[documentPath] ?? documentRuntime(documentPath);
 }
@@ -166,7 +150,6 @@ export function serializeManifest(manifest: Manifest): string | null {
       ...(recorded.length > 0 ? { runtimes } : {}),
       ...(copied.length > 0 ? { copies: manifest.copies } : {}),
       ...(linked.length > 0 ? { links: manifest.links } : {}),
-      ...(manifest.audience ? { audience: manifest.audience } : {}),
     },
     null,
     2,

package/src/runtime/wrap-state.ts

@@ -14,7 +14,6 @@ import {
   parseManifestStrict,
   readManifestText,
   recordedListValues,
-  recordedAudience,
   recordedMapKeys,
   type Manifest,
   type WrapRuntime,
@@ -31,8 +30,6 @@ export interface WrapState {
   carriesClaudeHookGroup(group: ClaudeHookGroup): boolean;
   /** MCP server names the wrap declared in `.opencode/opencode.json`; user servers are not listed. */
   readonly openCodeMcpServers: readonly string[];
-  /** The audience the checkout is wrapped for; `null` for base only. */
-  readonly audience: string | null;
 }
 
 export const WRAP_RUNTIMES: readonly WrapRuntime[] = ["claude", "opencode"];
@@ -64,7 +61,6 @@ export function wrapStateOf(manifest: Manifest): WrapState {
       OPENCODE_CONFIG_DOCUMENT,
       OPENCODE_MCP_SERVERS_AT,
     ),
-    audience: recordedAudience(manifest),
   };
 }