@uniqbit/mate-core 0.15.3 → 0.15.4-canary.10

package/src/lib/orchestrator/framework-context.ts

@@ -1,14 +1,17 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
-import { FRAMEWORK_NAME, frameworkConfig } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
+import { parse } from "yaml";
 import { CompanionResolver } from "./companion-resolver";
 import { ConfigStore } from "./config-store";
 import { GlobalConfigStore } from "./global-config-store";
-import { migrateConfigDir } from "./migration";
 import { findRepoLocalLinkedRepository } from "./repo-local-registry";
 import {
   AmbiguousCompanionError,
+  ConfigError,
+  type FrameworkConfig,
+  type HubConfig,
   type LinkedRepository,
   RepositoryNotFoundError,
   WorkingRepoRequiredError,
@@ -20,7 +23,8 @@ export interface FrameworkContext {
   workingRepoStore: WorkingRepoStore;
   companionPath: string;
   repository?: LinkedRepository;
-  contextKind: "env" | "working-repo" | "companion-root";
+  contextKind: "env" | "working-repo" | "companion-root" | "hub";
+  hub?: HubConfig;
 }
 
 export interface LaunchContext extends FrameworkContext {
@@ -34,7 +38,6 @@ function repositoryFromEnvironment(): LinkedRepository | undefined {
   return {
     id: process.env.MATE_REPO_ID ?? path.basename(path.resolve(repositoryPath)),
     path: path.resolve(repositoryPath),
-    profile: process.env.MATE_REPO_PROFILE ?? "default",
   };
 }
 
@@ -44,6 +47,7 @@ function makeContext(
   companionPath: string,
   contextKind: FrameworkContext["contextKind"],
   repository?: LinkedRepository,
+  hub?: HubConfig,
 ): FrameworkContext {
   const configDir = path.join(companionPath, `.${FRAMEWORK_NAME}`, "config");
   return {
@@ -52,9 +56,90 @@ function makeContext(
     companionPath,
     repository,
     contextKind,
+    hub,
   };
 }
 
+function isStrictChildPath(parentPath: string, candidatePath: string): boolean {
+  const relative = path.relative(parentPath, candidatePath);
+  return relative !== "" && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+}
+
+async function validateHubMember(
+  resolvedRoot: string,
+  realRoot: string,
+  member: HubConfig["companions"][number],
+): Promise<ConfigError | null> {
+  const memberPath = path.resolve(resolvedRoot, member.path);
+  if (!isStrictChildPath(resolvedRoot, memberPath)) {
+    return new ConfigError(
+      `Hub member "${member.id}" path resolves outside the hub root: ${member.path}`,
+    );
+  }
+
+  const stats = await fs.stat(memberPath).catch(() => null);
+  if (!stats?.isDirectory()) {
+    return new ConfigError(`Hub member "${member.id}" directory is missing: ${memberPath}`);
+  }
+
+  const realMemberPath = await fs.realpath(memberPath).catch(() => memberPath);
+  if (!isStrictChildPath(realRoot, realMemberPath)) {
+    return new ConfigError(
+      `Hub member "${member.id}" path resolves outside the hub root: ${member.path}`,
+    );
+  }
+
+  const childConfigPath = path.join(memberPath, `.${FRAMEWORK_NAME}`, "config", "framework.yaml");
+  let childConfig: Partial<FrameworkConfig> | null;
+  try {
+    childConfig = parse(
+      await fs.readFile(childConfigPath, "utf8"),
+    ) as Partial<FrameworkConfig> | null;
+  } catch {
+    return new ConfigError(
+      `Hub member "${member.id}" must contain a framework.yaml declaring type "companion".`,
+    );
+  }
+
+  if (childConfig?.type !== "companion") {
+    return new ConfigError(
+      `Hub member "${member.id}" must declare type "companion" in ${childConfigPath}.`,
+    );
+  }
+
+  return null;
+}
+
+async function validateHubMembers(hubRoot: string, hub: HubConfig): Promise<void> {
+  const resolvedRoot = path.resolve(hubRoot);
+  const realRoot = await fs.realpath(resolvedRoot).catch(() => resolvedRoot);
+  const errors = await Promise.all(
+    hub.companions.map((member) => validateHubMember(resolvedRoot, realRoot, member)),
+  );
+  const firstError = errors.find((error): error is ConfigError => error !== null);
+  if (firstError) throw firstError;
+}
+
+async function withResolvedHub(context: FrameworkContext): Promise<FrameworkContext> {
+  let rawConfig: Partial<FrameworkConfig> | null;
+  try {
+    rawConfig = parse(
+      await fs.readFile(context.configStore.configPath, "utf8"),
+    ) as Partial<FrameworkConfig> | null;
+  } catch {
+    return context;
+  }
+
+  if (rawConfig?.type !== "hub") return context;
+
+  const config = await context.configStore.load();
+  if (!config.hub) {
+    throw new ConfigError('A "hub" framework requires a hub.companions array.');
+  }
+  await validateHubMembers(context.companionPath, config.hub);
+  return { ...context, contextKind: "hub", hub: config.hub };
+}
+
 // Resolves the companion framework context without a repositoryId. Used by commands
 // that only need companion config (e.g. `mate doctor`, `mate config`, `mate report`). Resolution order:
 // 1. MATE_ARTIFACT_PATH env var (agent-launched sessions)
@@ -67,31 +152,32 @@ export async function resolveFrameworkContext(
   const envCompanionPath = process.env.MATE_ARTIFACT_PATH;
   if (envCompanionPath) {
     const repository = repositoryFromEnvironment() ?? (await findRepoLocalLinkedRepository(cwd));
-    return makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined);
+    return withResolvedHub(
+      makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined),
+    );
   }
 
   const match = await new CompanionResolver(globalConfigStore).resolve(cwd);
   if (match) {
-    return makeContext(
-      match.companionPath,
-      "working-repo",
-      (await findRepoLocalLinkedRepository(cwd)) ?? undefined,
+    return withResolvedHub(
+      makeContext(
+        match.companionPath,
+        "working-repo",
+        (await findRepoLocalLinkedRepository(cwd)) ?? undefined,
+      ),
     );
   }
 
   const localDir = path.join(cwd, `.${FRAMEWORK_NAME}`);
-  const localLegacyDirs = frameworkConfig.legacyNames.map((n) => path.join(cwd, `.${n}`));
-  await migrateConfigDir(localDir, localLegacyDirs);
 
   const localConfigPath = path.join(localDir, "config", "framework.yaml");
   try {
     await fs.access(localConfigPath);
-    return makeContext(cwd, "companion-root");
   } catch {
     // no local config
+    throw new RepositoryNotFoundError(`No companion found for current directory: ${cwd}`);
   }
-
-  throw new RepositoryNotFoundError(`No companion found for current directory: ${cwd}`);
+  return withResolvedHub(makeContext(cwd, "companion-root"));
 }
 
 // Resolves context for agent-launch commands. Returns a LaunchContext with repositoryId.
@@ -108,8 +194,11 @@ export async function resolveForLaunch(
   if (envCompanionPath) {
     const repository = repositoryFromEnvironment() ?? (await findRepoLocalLinkedRepository(cwd));
     const repositoryId = process.env.MATE_REPO_ID ?? repository?.id ?? "";
+    const context = await withResolvedHub(
+      makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined),
+    );
     return {
-      ...makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined),
+      ...context,
       repositoryId,
     };
   }
@@ -123,8 +212,11 @@ export async function resolveForLaunch(
 
   if (resolution.match) {
     const repository = (await findRepoLocalLinkedRepository(cwd)) ?? undefined;
+    const context = await withResolvedHub(
+      makeContext(resolution.match.companionPath, "working-repo", repository),
+    );
     return {
-      ...makeContext(resolution.match.companionPath, "working-repo", repository),
+      ...context,
       repositoryId: resolution.match.repositoryId,
     };
   }
@@ -143,7 +235,9 @@ export async function resolveForCapability(
   const envCompanionPath = process.env.MATE_ARTIFACT_PATH;
   if (envCompanionPath) {
     const repository = repositoryFromEnvironment() ?? (await findRepoLocalLinkedRepository(cwd));
-    const ctx = makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined);
+    const ctx = await withResolvedHub(
+      makeContext(path.resolve(envCompanionPath), "env", repository ?? undefined),
+    );
     const repositoryId = process.env.MATE_REPO_ID;
     if (repositoryId) {
       return { ...ctx, repositoryId };
@@ -158,12 +252,15 @@ export async function resolveForCapability(
 
   const match = await new CompanionResolver(globalConfigStore).resolve(cwd);
   if (match) {
-    return {
-      ...makeContext(
+    const context = await withResolvedHub(
+      makeContext(
         match.companionPath,
         "working-repo",
         (await findRepoLocalLinkedRepository(cwd)) ?? undefined,
       ),
+    );
+    return {
+      ...context,
       repositoryId: match.repositoryId,
     };
   }
@@ -171,16 +268,14 @@ export async function resolveForCapability(
   // Fallback: cwd is the companion directory — resolve from its local config.
   // This is specific to mate cap; resolveForLaunch does NOT get this fallback.
   const localDir = path.join(cwd, `.${FRAMEWORK_NAME}`);
-  const localLegacyDirs = frameworkConfig.legacyNames.map((n) => path.join(cwd, `.${n}`));
-  await migrateConfigDir(localDir, localLegacyDirs);
 
   const localConfigPath = path.join(localDir, "config", "framework.yaml");
   try {
     await fs.access(localConfigPath);
-    return { ...makeContext(cwd, "companion-root"), repositoryId: process.env.MATE_REPO_ID ?? "" };
   } catch {
     // no local config
+    throw new WorkingRepoRequiredError("cap");
   }
-
-  throw new WorkingRepoRequiredError("cap");
+  const context = await withResolvedHub(makeContext(cwd, "companion-root"));
+  return { ...context, repositoryId: process.env.MATE_REPO_ID ?? "" };
 }

package/src/lib/orchestrator/global-config-store.ts

@@ -1,9 +1,8 @@
 import os from "node:os";
 import path from "node:path";
 
-import { FRAMEWORK_NAME, frameworkConfig } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
 import { YamlFileStore } from "./yaml-file-store";
-import { migrateConfigDir } from "./migration";
 
 interface CompanionEntry {
   path: string;
@@ -35,9 +34,6 @@ export class GlobalConfigStore extends YamlFileStore<GlobalConfig> {
   }
 
   override async load(): Promise<GlobalConfig> {
-    const currentDir = path.dirname(this.configPath);
-    const legacyDirs = frameworkConfig.legacyNames.map((n) => path.join(os.homedir(), `.${n}`));
-    await migrateConfigDir(currentDir, legacyDirs);
     return normalizeGlobalConfig(await super.load());
   }
 

package/src/lib/orchestrator/launcher.ts

@@ -5,7 +5,7 @@ import type { CapabilityPlugin, LaunchPreflightContext } from "../../tools/setup
 import type { LaunchAdapter, AdapterContext } from "./adapters/base";
 import { ClaudeAdapter } from "./adapters/claude";
 import { OpenCodeAdapter } from "./adapters/opencode";
-import { CompanionStore, resolvePolicyFromConfig } from "./companion-store";
+import { CompanionStore } from "./companion-store";
 import { syncCompanionGit } from "./companion-git-sync";
 import { resolveForLaunch, type LaunchContext } from "./framework-context";
 import {
@@ -16,7 +16,6 @@ import {
   type LaunchRequest,
   type LaunchResult,
   type LinkedRepository,
-  type PolicySettings,
 } from "./types";
 
 export interface LaunchPreview {
@@ -34,7 +33,6 @@ interface ResolvedLaunchState {
   adapter: LaunchAdapter;
   companionPath: string;
   config: FrameworkConfig;
-  policy: PolicySettings;
   repository: LinkedRepository;
 }
 
@@ -100,10 +98,7 @@ export class FrameworkLauncher {
     }
 
     const config = await configStore.load();
-    const policy = localRepository
-      ? resolvePolicyFromConfig(config, [repository], repository.id)
-      : await store.resolvePolicy(repository.id);
-    if (!policy.allowedAgents.includes(request.tool)) {
+    if (!config.allowedAgents.includes(request.tool)) {
       throw new ToolNotAllowedError(`Tool is disallowed by policy: ${request.tool}`);
     }
 
@@ -116,7 +111,6 @@ export class FrameworkLauncher {
       adapter,
       companionPath,
       config,
-      policy,
       repository,
     };
   }
@@ -124,7 +118,7 @@ export class FrameworkLauncher {
   private makeAdapterContext(state: ResolvedLaunchState): AdapterContext {
     return {
       repository: state.repository,
-      policy: state.policy,
+      allowedAgents: state.config.allowedAgents,
       companionPath: state.companionPath,
       capabilities: state.config.capabilities ?? [],
       git: state.config.git,

package/src/lib/orchestrator/migration.ts

@@ -1,6 +1,4 @@
-// oxlint-disable no-await-in-loop
 import fs from "node:fs/promises";
-import path from "node:path";
 
 import { parse, stringify } from "yaml";
 
@@ -18,24 +16,3 @@ export async function migrateRegistryData(filePath: string): Promise<void> {
     await fs.writeFile(filePath, stringify(rest), "utf8");
   }
 }
-
-export async function migrateConfigDir(currentDir: string, legacyDirs: string[]): Promise<void> {
-  try {
-    await fs.access(currentDir);
-    return;
-  } catch {
-    // current dir missing — check legacy locations
-  }
-
-  for (const legacyDir of legacyDirs) {
-    try {
-      await fs.access(legacyDir);
-      await fs.mkdir(path.dirname(currentDir), { recursive: true });
-      await fs.rename(legacyDir, currentDir);
-      process.stderr.write(`[migration] ${legacyDir} → ${currentDir}\n`);
-      return;
-    } catch {
-      // this legacy dir also absent, try next
-    }
-  }
-}

package/src/lib/orchestrator/opencode-guidance.ts

@@ -25,9 +25,8 @@ export function buildOpenCodeGuidance(capabilities: CapabilityConfig[]): MateGui
       repository: {
         id: "$MATE_REPO_ID",
         path: "$MATE_REPO_PATH",
-        profile: "$MATE_REPO_PROFILE",
       },
-      policy: { allowedAgents: [] },
+      allowedAgents: [],
       capabilities,
     },
     { wrapperBinPath: "$MATE_WRAPPER_BIN_PATH" },

package/src/lib/orchestrator/repo-local-registry.ts

@@ -105,9 +105,11 @@ async function saveRepoLocalRegistry(repoPath: string, registry: RepoLocalRegist
   await store.save(registry);
 }
 
+// Field-explicit on purpose: also strips legacy per-repo policy fields
+// (profile/overrides) from entries read from or written to disk.
 function normalizeLinkedRepository(repository: LinkedRepository): LinkedRepository {
   return {
-    ...repository,
+    id: repository.id,
     path: path.resolve(repository.path),
   };
 }

package/src/lib/orchestrator/root-context.ts

@@ -0,0 +1,117 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { FRAMEWORK_NAME } from "../../framework";
+import { CompanionResolver, type CompanionResolutionResult } from "./companion-resolver";
+import { ConfigStore, mergeWithDefaults } from "./config-store";
+import { GlobalConfigStore } from "./global-config-store";
+import { findRepoLocalLinkedRepository } from "./repo-local-registry";
+import type { FrameworkConfig, LinkedRepository } from "./types";
+
+/** Root classification shared by install and doctor. `core` = no configured root. */
+export type RootKind = "core" | "working" | "companion" | "hub";
+
+/** How the configured root was found. */
+export type RootOrigin = "env" | "registry" | "local" | "none";
+
+export interface RootContext {
+  /** Kind of the resolved configured root (from `config.type`), or `core`. */
+  kind: RootKind;
+  origin: RootOrigin;
+  rootPath?: string;
+  /** Merged config of the resolved root; absent for `core`. */
+  config?: FrameworkConfig;
+  repositoryId?: string;
+  /** Repo-local `registry.yaml` repository entry for cwd, when present. */
+  linkedRepository: LinkedRepository | null;
+  resolution: CompanionResolutionResult;
+}
+
+export interface RootContextDeps {
+  globalConfigStore?: GlobalConfigStore;
+}
+
+const emptyResolution = (): CompanionResolutionResult => ({
+  match: null,
+  ambiguousMatches: [],
+  failures: [],
+});
+
+function kindForConfig(config: FrameworkConfig): Exclude<RootKind, "core"> {
+  return config.type === "hub" ? "hub" : config.type === "working" ? "working" : "companion";
+}
+
+async function loadRootConfig(rootPath: string): Promise<FrameworkConfig> {
+  const configPath = path.join(rootPath, `.${FRAMEWORK_NAME}`, "config", "framework.yaml");
+  return mergeWithDefaults(await new ConfigStore(configPath).load());
+}
+
+export async function resolveRootContext(
+  cwd = process.cwd(),
+  deps: RootContextDeps = {},
+): Promise<RootContext> {
+  const resolvedCwd = path.resolve(cwd);
+  const linkedRepository = await findRepoLocalLinkedRepository(resolvedCwd);
+
+  const envRootPath = process.env.MATE_ARTIFACT_PATH;
+  if (envRootPath) {
+    const rootPath = path.resolve(envRootPath);
+    const config = await loadRootConfig(rootPath);
+    return {
+      kind: kindForConfig(config),
+      origin: "env",
+      rootPath,
+      config,
+      repositoryId: process.env.MATE_REPO_ID ?? linkedRepository?.id,
+      linkedRepository,
+      resolution: emptyResolution(),
+    };
+  }
+
+  const resolver = new CompanionResolver(deps.globalConfigStore ?? new GlobalConfigStore());
+  const resolution = await resolver.resolveWithDiagnostics(resolvedCwd);
+  if (resolution.match) {
+    const rootPath = resolution.match.companionPath;
+    const config = await loadRootConfig(rootPath);
+    return {
+      kind: kindForConfig(config),
+      origin: "registry",
+      rootPath,
+      config,
+      repositoryId: linkedRepository?.id ?? resolution.match.repositoryId,
+      linkedRepository,
+      resolution,
+    };
+  }
+
+  const localRoot = await findConfiguredRoot(resolvedCwd);
+  if (localRoot) {
+    const config = await loadRootConfig(localRoot);
+    return {
+      kind: kindForConfig(config),
+      origin: "local",
+      rootPath: localRoot,
+      config,
+      linkedRepository,
+      resolution,
+    };
+  }
+
+  return { kind: "core", origin: "none", linkedRepository, resolution };
+}
+
+/** Nearest ancestor of `cwd` (inclusive) holding `.<framework>/config/framework.yaml`. */
+export async function findConfiguredRoot(cwd: string): Promise<string | null> {
+  let dir = path.resolve(cwd);
+  for (;;) {
+    try {
+      await fs.access(path.join(dir, `.${FRAMEWORK_NAME}`, "config", "framework.yaml"));
+      return dir;
+    } catch {
+      // keep walking up
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}

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

@@ -287,7 +287,7 @@ export function getDefaultSetupSelections(): SetupSelections {
 
 export function getSetupSelectionsFromConfig(config: FrameworkConfig): SetupSelections {
   return {
-    allowedAgents: [...new Set(config.profiles.default?.allowedAgents ?? [])],
+    allowedAgents: [...new Set(config.allowedAgents ?? [])],
     packageManagers: [
       ...new Set([...getLockedPackageManagers(), ...(config.packageManagers ?? [])]),
     ],

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

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { parse } from "yaml";
 
-import { FRAMEWORK_NAME, frameworkCommandName, frameworkConfig } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
 import { fileExists } from "../fs-utils";
 import { GlobalConfigStore } from "./global-config-store";
 import { CompanionResolver, type CompanionMatch } from "./companion-resolver";
@@ -126,20 +126,7 @@ export async function looksLikeWorkingRepo(cwd: string): Promise<boolean> {
 
 export async function hasLocalCompanionConfig(cwd: string): Promise<boolean> {
   const resolvedCwd = path.resolve(cwd);
-  const candidatePaths = [
-    path.join(resolvedCwd, `.${FRAMEWORK_NAME}`, "config", "framework.yaml"),
-    ...frameworkConfig.legacyNames.map((name) =>
-      path.join(resolvedCwd, `.${name}`, "config", "framework.yaml"),
-    ),
-  ];
-
-  for (const candidatePath of candidatePaths) {
-    if (await fileExists(candidatePath)) {
-      return true;
-    }
-  }
-
-  return false;
+  return fileExists(path.join(resolvedCwd, `.${FRAMEWORK_NAME}`, "config", "framework.yaml"));
 }
 
 async function hasWorkingRepoConfig(cwd: string): Promise<boolean> {
@@ -167,7 +154,7 @@ export async function inspectSetupPreflight(
   // linked working repo, even if it sits inside another repo's working tree.
   // A stale registration of a working repo is the exception: its local type
   // marker is authoritative and must not make setup load working-repo config
-  // as a companion profile config.
+  // as a companion framework config.
   if (isRegisteredCompanion && !(await hasWorkingRepoConfig(resolvedCwd))) {
     return { kind: "existing-companion" };
   }
@@ -190,7 +177,7 @@ export async function inspectSetupPreflight(
 
 export function formatSetupGuardrailError(cwd: string, match: CompanionMatch): string {
   return [
-    `\`${frameworkCommandName()} setup\` cannot run here: ${path.resolve(cwd)} is inside linked working repo \`${match.repositoryId}\`.`,
-    `Run \`${frameworkCommandName()} setup\` from the companion repo instead: ${match.companionPath}`,
+    `\`${FRAMEWORK_NAME} setup\` cannot run here: ${path.resolve(cwd)} is inside linked working repo \`${match.repositoryId}\`.`,
+    `Run \`${FRAMEWORK_NAME} setup\` from the companion repo instead: ${match.companionPath}`,
   ].join("\n");
 }

package/src/lib/orchestrator/types.ts

@@ -42,23 +42,9 @@ export class WorkingRepoRequiredError extends MateError {
 
 export type CompanionSource = "git" | "existing" | "local";
 
-export interface PolicySettings {
-  allowedAgents: string[];
-}
-
-export interface PolicyOverride {
-  allowedAgents?: string[];
-}
-
-export interface PolicyProfile extends PolicySettings {
-  name: string;
-}
-
 export interface LinkedRepository {
   id: string;
   path: string;
-  profile: string;
-  overrides?: PolicyOverride;
 }
 
 export interface CliToolConfig {
@@ -74,6 +60,26 @@ export interface CapabilityConfig {
   schemaProfile?: OpenSpecSchemaProfile;
 }
 
+export type FrameworkType = "working" | "companion" | "hub";
+
+export interface HubMemberSource {
+  kind: "git" | "local";
+  url?: string;
+  ref?: string;
+  path?: string;
+}
+
+export interface HubMember {
+  id: string;
+  path: string;
+  source: HubMemberSource;
+  materializedCommit?: string;
+}
+
+export interface HubConfig {
+  companions: HubMember[];
+}
+
 /**
  * Distribution-name-keyed semver ranges (e.g. `{ mate: ">=0.15.0" }` or
  * `{ "acme-mate": ">=1.2.0" }`). A running CLI only checks the key matching
@@ -88,9 +94,10 @@ export type EngineConstraints = Record<string, string>;
 export type PluginDeclarationPolicy = "default" | "optional";
 
 /**
- * A companion-declared npm plugin: installed by setup/install into
- * `.mate/dependencies/plugins/` and loaded on every invocation. Declaration
- * registers the plugin; enablement stays in the `capabilities` list.
+ * A companion-declared npm plugin: installed by setup/install into the
+ * companion's own shared plugin workspace (`.mate/plugins/`) and loaded
+ * from there on every invocation. Declaration registers the plugin;
+ * enablement stays in the `capabilities` list.
  */
 export interface PluginDeclaration {
   /** npm package name (e.g. `@acme/custom-plugin`). */
@@ -104,9 +111,10 @@ export interface PluginDeclaration {
 }
 
 export interface FrameworkConfig {
-  type?: "working" | "companion";
+  type?: FrameworkType;
   git?: GitModeProfile;
-  profiles: Record<string, PolicyProfile>;
+  hub?: HubConfig;
+  allowedAgents: string[];
   capabilities?: CapabilityConfig[];
   plugins?: PluginDeclaration[];
   migrations?: string[];

package/src/lib/orchestrator/working-repo-store.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 
-import { FRAMEWORK_NAME, frameworkCommandName } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
 import { migrateRegistryData } from "./migration";
 import { YamlFileStore } from "./yaml-file-store";
 import { ConfigError, type WorkingRepoConfig } from "./types";
@@ -16,12 +16,18 @@ export class WorkingRepoStore extends YamlFileStore<WorkingRepoConfig> {
 
   override async load(): Promise<WorkingRepoConfig> {
     await migrateRegistryData(this.configPath);
-    return super.load();
+    const config = await super.load();
+    // Silently drop legacy per-repo policy fields (profile/overrides); the
+    // clean shape persists on the next save.
+    return {
+      ...config,
+      repos: (config.repos ?? []).map(({ id, path: repoPath }) => ({ id, path: repoPath })),
+    };
   }
 
   protected async onMissing(): Promise<WorkingRepoConfig> {
     throw new ConfigError(
-      `Working repo config not found. Please run \`${frameworkCommandName()} companion setup\` to initialize the framework.`,
+      `Working repo config not found. Please run \`${FRAMEWORK_NAME} companion setup\` to initialize the framework.`,
     );
   }