@uniqbit/mate-core 0.18.4 → 1.0.0-canary.0

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

@@ -28,6 +28,7 @@ export type ProjectionEntryId =
   | "openspec-store-exclude"
   | "openspec-store-pointer"
   | "claude-skill-links"
+  | "claude-command-links"
   | "workspace-document"
   | "capability-excludes"
   | "claude-working-settings"
@@ -41,6 +42,8 @@ export type ProjectionEntryId =
 export interface ProjectionInput {
   repoPath: string;
   companionPath?: string;
+  /** Every companion folder the workspace document lists, in order; `[companionPath]` when absent. */
+  workspaceCompanionPaths?: string[];
   repository?: LinkedRepository;
   source?: CompanionSource;
   config?: FrameworkConfig;
@@ -50,8 +53,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/refresh-working-claude-links.ts

@@ -0,0 +1,87 @@
+import { readWrapState } from "../../runtime/wrap-state";
+import { GlobalConfigStore } from "./global-config-store";
+import { reconcileWorkingRepoClaudeCommandLinks } from "./projection-claude-commands";
+import { reconcileWorkingRepoClaudeSkillLinks } from "./projection-claude-skills";
+import { readCompanionRegistry } from "./repository-link";
+import type { FrameworkConfig, LinkedRepository } from "./types";
+import { errorMessage } from "../../runtime/error-message";
+
+export interface LinkRefreshResult {
+  /** Null when the companion's list of linked repositories could not be read. */
+  repository: LinkedRepository | null;
+  outcome: "written" | "current" | "failed";
+  error?: string;
+}
+
+export interface LinkRefreshDeps {
+  readRegistry: (companionPath: string) => Promise<LinkedRepository[]>;
+  isWrappedForClaude: (repoPath: string) => Promise<boolean>;
+  registeredCompanionPaths: () => Promise<string[]>;
+  reconcileSkillLinks: typeof reconcileWorkingRepoClaudeSkillLinks;
+  reconcileCommandLinks: typeof reconcileWorkingRepoClaudeCommandLinks;
+}
+
+const linkRefreshDeps: LinkRefreshDeps = {
+  readRegistry: async (companionPath) => {
+    try {
+      return (await readCompanionRegistry(companionPath)).repos;
+    } catch (error) {
+      // No registry file means no linked repositories.
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+      throw error;
+    }
+  },
+  isWrappedForClaude: async (repoPath) => (await readWrapState(repoPath)).runtimes.has("claude"),
+  registeredCompanionPaths: () => new GlobalConfigStore().list(),
+  reconcileSkillLinks: reconcileWorkingRepoClaudeSkillLinks,
+  reconcileCommandLinks: reconcileWorkingRepoClaudeCommandLinks,
+};
+
+/**
+ * Re-links the companion's Claude skills and commands into every linked Claude-wrapped
+ * Working Repository. Links only; runtime documents wait for the wrap pass. Failures
+ * are reported per repository, never thrown.
+ */
+export async function refreshWorkingClaudeLinks(
+  companionPath: string,
+  config: FrameworkConfig,
+  deps: LinkRefreshDeps = linkRefreshDeps,
+): Promise<LinkRefreshResult[]> {
+  const enabled = config.allowedAgents?.includes("claude") ?? false;
+  const results: LinkRefreshResult[] = [];
+  let registered: string[] | undefined;
+  let repositories: LinkedRepository[];
+  try {
+    repositories = await deps.readRegistry(companionPath);
+  } catch (error) {
+    return [{ repository: null, outcome: "failed", error: errorMessage(error) }];
+  }
+
+  for (const repository of repositories) {
+    try {
+      if (!(await deps.isWrappedForClaude(repository.path))) continue;
+      registered ??= await deps.registeredCompanionPaths();
+      const skills = await deps.reconcileSkillLinks(
+        repository.path,
+        companionPath,
+        enabled,
+        registered,
+      );
+      const commands = await deps.reconcileCommandLinks(
+        repository.path,
+        companionPath,
+        enabled,
+        registered,
+      );
+      const written = skills === "written" || commands === "written";
+      results.push({ repository, outcome: written ? "written" : "current" });
+    } catch (error) {
+      results.push({
+        repository,
+        outcome: "failed",
+        error: errorMessage(error),
+      });
+    }
+  }
+  return results;
+}

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

@@ -1,5 +1,6 @@
 import { getActiveDistribution } from "../../distribution";
 import { FRAMEWORK_NAME } from "../../framework";
+import { launchPassesClaudePluginFolders } from "../../runtime/claude-delivery-plan";
 import { recordCompanionSyncUnfinished } from "../../runtime/companion-git-state";
 import { withCompanionLock, type CompanionLockOptions } from "../../runtime/companion-lock";
 import {
@@ -7,15 +8,11 @@ import {
   syncCompanionUnattended,
   type UnattendedSyncOutcome,
 } from "../../runtime/companion-sync";
-import { readWrapStateSync, type WrapState } from "../../runtime/wrap-state";
+import { managedSessionKind, type SessionKind } from "../../runtime/session-kind";
+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 type { ClaudePluginFolders } from "../../tools/setup/providers/claude-plugin-folders";
 import { attendedLockOptions, syncCompanionGit } from "./companion-git-sync";
 import { readCompanionConfig } from "./config-store";
 import { entryFailureMessage, firstFailure, type ProjectionChangedPaths } from "./projection-types";
@@ -40,8 +37,7 @@ export type PrepareStepName =
   | "file-sync"
   | "launch-projection"
   | "working-target"
-  | "preflight"
-  | "audience-layer";
+  | "preflight";
 
 export interface PrepareStep {
   step: PrepareStepName;
@@ -68,8 +64,8 @@ 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;
+  /** The Claude plugin folders the `file-sync` step gathered; a launch gathers none itself. */
+  claudePluginDirectories?: string[];
 }
 
 export interface PrepareSessionInput {
@@ -98,10 +94,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;
@@ -133,7 +128,8 @@ export const sessionPrepareDeps = {
   syncCompanionGit,
   syncCompanionUnattended,
   recordCompanionSyncUnfinished,
-  syncCompanionFiles,
+  syncCompanionFiles: async (...args: Parameters<typeof syncCompanionFiles>) =>
+    (await syncCompanionFiles(...args)).claudePluginFolders,
   projectLaunch: (input: Parameters<typeof project>[1]) => project("launch", input),
   /**
    * The Projection Root a Claude launch guarantees for itself. Companion
@@ -147,11 +143,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 +155,7 @@ class StepLog {
   readonly warnings: string[] = [];
   failure: unknown;
   wrapState: WrapState | undefined;
-  audienceLayer: RenderedAudienceLayer | undefined;
+  claudePluginDirectories: string[] | undefined;
   stopped = false;
   companionChanged = false;
 
@@ -192,10 +183,18 @@ async function runFileSync(
 ): Promise<void> {
   const deps = sessionPrepareDeps;
   try {
-    if (input.repository) {
-      await deps.syncCompanionFiles(input.companionPath, config, input.repository.path);
-    } else {
-      await deps.syncCompanionFiles(input.companionPath, config);
+    const folders = input.repository
+      ? await deps.syncCompanionFiles(input.companionPath, config, input.repository.path)
+      : await deps.syncCompanionFiles(input.companionPath, config);
+    run.claudePluginDirectories = [...folders.launch];
+    /**
+     * The Claude plan speaks for Claude sessions only; OpenCode loads no plugin
+     * folder. With a Working Repository the wrap pass reports publication;
+     * without one no wrap pass runs, so this step does.
+     */
+    if (reportsClaudePluginFolders(input)) {
+      run.warnings.push(...folders.loadWarnings);
+      if (!input.repository) run.warnings.push(...publicationWarnings(folders));
     }
     run.push({ step: "file-sync", outcome: "ok" });
   } catch (error) {
@@ -215,6 +214,24 @@ function wrapDetail(wrapped: {
   return parts.length > 0 ? `updated (${parts.join("; ")})` : "updated";
 }
 
+/** A managed Claude launch; plain sessions' prepares and OpenCode report no plugin-folder problem. */
+function reportsClaudePluginFolders(input: PrepareSessionInput): boolean {
+  return input.runtime === "claude" && launchPassesClaudePluginFolders(sessionKindOf(input));
+}
+
+/** What a publication left undone, one sentence per folder. */
+function publicationWarnings(folders: ClaudePluginFolders | undefined): string[] {
+  const publication = folders?.publication;
+  if (!publication) return [];
+  return [...publication.unpublished.map((entry) => entry.warning), ...publication.warnings];
+}
+
+/** Attended is a managed launch, with or without a Working Repository; the rest serve plain sessions. */
+function sessionKindOf(input: PrepareSessionInput): SessionKind {
+  if (input.mode !== "attended") return "unmanaged";
+  return managedSessionKind(Boolean(input.repository));
+}
+
 function runtimesOf(input: PrepareSessionInput): PrepareRuntime[] {
   return input.mode !== "attended" && input.runtimes?.length
     ? [...input.runtimes]
@@ -241,6 +258,9 @@ async function reconcileWrap(
     return;
   }
   run.warnings.push(...wrapped.warnings);
+  if (reportsClaudePluginFolders(input)) {
+    run.warnings.push(...publicationWarnings(wrapped.claudePluginFolders));
+  }
   run.wrapState = wrapped.wrapState;
   run.push({
     step: "working-target",
@@ -324,6 +344,7 @@ async function runLocal(
         config,
         repository: input.repository,
         providerId: runtime,
+        sessionKind: sessionKindOf(input),
       }),
     ),
   );
@@ -337,71 +358,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 +384,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 +438,9 @@ 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 } : {}),
+    ...(run.claudePluginDirectories
+      ? { claudePluginDirectories: run.claudePluginDirectories }
+      : {}),
   });
 
   const locked = await deps.withCompanionLock(input.companionPath, lockOptions(input), async () => {

package/src/lib/orchestrator/setup-compatibilities.ts

@@ -1,23 +1,8 @@
-import type {
-  CapabilityConfig,
-  CliToolConfig,
-  FrameworkConfig,
-  GitModeProfile,
-  OpenSpecSchemaProfile,
-} from "./types";
+import type { CapabilityConfig, CliToolConfig, FrameworkConfig, GitModeProfile } from "./types";
 
-export type OpenSpecSchemaSelection = OpenSpecSchemaProfile | "default";
 export type GitModeSelection = GitModeProfile | "default";
-const DEFAULT_OPENSPEC_SCHEMA_SELECTION: OpenSpecSchemaSelection = "default";
 export const DEFAULT_GIT_MODE_SELECTION: GitModeSelection = "default";
 
-export interface OpenSpecSchemaCompatibility {
-  id: OpenSpecSchemaSelection;
-  label: string;
-  description: string;
-  defaultSelected: boolean;
-}
-
 export interface GitModeCompatibility {
   id: GitModeSelection;
   label: string;
@@ -25,21 +10,6 @@ export interface GitModeCompatibility {
   defaultSelected: boolean;
 }
 
-const BUILTIN_OPENSPEC_SCHEMA_COMPATIBILITIES: OpenSpecSchemaCompatibility[] = [
-  {
-    id: "default",
-    label: "Default (vanilla OpenSpec)",
-    description: "Use OpenSpec's built-in spec-driven workflow.",
-    defaultSelected: true,
-  },
-  {
-    id: "mate-v1",
-    label: "Mate v1",
-    description: "Use Mate's schema with proposal, design, spec, and task artifacts.",
-    defaultSelected: false,
-  },
-];
-
 const BUILTIN_GIT_MODE_COMPATIBILITIES: GitModeCompatibility[] = [
   {
     id: "default",
@@ -59,33 +29,9 @@ export interface SetupSelections {
   allowedAgents: string[];
   packageManagers: string[];
   capabilities: CapabilityConfig[];
-  selectedOpenSpecSchema: OpenSpecSchemaSelection;
   selectedGitMode: GitModeSelection;
 }
 
-export function getOpenSpecSchemaSelection(
-  capabilities: CapabilityConfig[],
-): OpenSpecSchemaSelection {
-  const openspec = capabilities.find((capability) => capability.name === "openspec");
-  return openspec?.schemaProfile ?? DEFAULT_OPENSPEC_SCHEMA_SELECTION;
-}
-
-export function applyOpenSpecSchemaSelection(
-  capabilities: CapabilityConfig[],
-  schemaSelection: OpenSpecSchemaSelection | undefined,
-): CapabilityConfig[] {
-  if (schemaSelection === undefined) return capabilities;
-
-  return capabilities.map((capability) => {
-    if (capability.name !== "openspec") return capability;
-    if (schemaSelection === "default") {
-      const { schemaProfile: _schemaProfile, ...rest } = capability;
-      return rest;
-    }
-    return { ...capability, schemaProfile: schemaSelection };
-  });
-}
-
 interface SetupCompatibilityBase {
   id: string;
   label: string;
@@ -222,24 +168,6 @@ export function listSetupPackageManagerCompatibilities(): SetupPackageManagerCom
   );
 }
 
-export function listSetupOpenSpecSchemaCompatibilities(
-  activeSchemaProfile?: OpenSpecSchemaSelection,
-): OpenSpecSchemaCompatibility[] {
-  const compatibilities = [...BUILTIN_OPENSPEC_SCHEMA_COMPATIBILITIES];
-  if (
-    activeSchemaProfile !== undefined &&
-    !BUILTIN_OPENSPEC_SCHEMA_COMPATIBILITIES.some((entry) => entry.id === activeSchemaProfile)
-  ) {
-    compatibilities.push({
-      id: activeSchemaProfile,
-      label: "Custom",
-      description: `Keep the project's current custom schema profile ("${activeSchemaProfile}"). Selecting Default or Mate v1 replaces it.`,
-      defaultSelected: false,
-    });
-  }
-  return compatibilities;
-}
-
 export function listSetupGitModeCompatibilities(): GitModeCompatibility[] {
   return [...BUILTIN_GIT_MODE_COMPATIBILITIES];
 }
@@ -272,7 +200,6 @@ export function getDefaultSetupSelections(): SetupSelections {
     allowedAgents,
     packageManagers,
     capabilities,
-    selectedOpenSpecSchema: DEFAULT_OPENSPEC_SCHEMA_SELECTION,
     selectedGitMode: DEFAULT_GIT_MODE_SELECTION,
   };
 }
@@ -284,11 +211,27 @@ export function getSetupSelectionsFromConfig(config: FrameworkConfig): SetupSele
       ...new Set([...getLockedPackageManagers(), ...(config.packageManagers ?? [])]),
     ],
     capabilities: dedupeCapabilities(config.capabilities ?? []),
-    selectedOpenSpecSchema: getOpenSpecSchemaSelection(config.capabilities ?? []),
     selectedGitMode: config.git ?? DEFAULT_GIT_MODE_SELECTION,
   };
 }
 
+/**
+ * Re-selected capabilities keep their saved settings (such as openspec's
+ * `protectedBranches`); pickers and flags only name the capabilities.
+ */
+export function keepCapabilitySettings(
+  selected: CapabilityConfig[],
+  saved: CapabilityConfig[],
+): CapabilityConfig[] {
+  const byName = new Map(saved.map((capability) => [capability.name, capability]));
+  return selected.map((capability) => {
+    // `schemaProfile` is a removed setting; a re-save drops it.
+    const { schemaProfile: _removed, ...settings } = (byName.get(capability.name) ??
+      {}) as CapabilityConfig & { schemaProfile?: unknown };
+    return { ...capability, ...settings };
+  });
+}
+
 export function dedupeCapabilities(capabilities: CapabilityConfig[]): CapabilityConfig[] {
   const seen = new Set<string>();
   const result: CapabilityConfig[] = [];

package/src/lib/orchestrator/types.ts

@@ -58,12 +58,12 @@ export interface CliToolConfig {
   redirectCwd: "companionRoot" | false;
 }
 
-export type OpenSpecSchemaProfile = "mate-v1" | (string & {});
 export type GitModeProfile = "auto";
 
 export interface CapabilityConfig {
   name: string;
-  schemaProfile?: OpenSpecSchemaProfile;
+  /** openspec only: branch glob patterns (`release/*`) treated as protected besides the default branch. */
+  protectedBranches?: string[];
 }
 
 export type FrameworkType = "working" | "companion" | "hub";