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

package/src/lib/install.ts

@@ -3,10 +3,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { defaultConfig, ConfigStore, mergeWithDefaults } from "./orchestrator/config-store";
-import { CompanionResolver } from "./orchestrator/companion-resolver";
+import { defaultConfig } from "./orchestrator/config-store";
 import { checkEngineRequirement } from "./orchestrator/engine-guard";
-import { GlobalConfigStore } from "./orchestrator/global-config-store";
+import type { GlobalConfigStore } from "./orchestrator/global-config-store";
+import { resolveRootContext } from "./orchestrator/root-context";
 import { YamlFileStore } from "./orchestrator/yaml-file-store";
 import { FRAMEWORK_NAME } from "../framework";
 import type { FrameworkConfig } from "./orchestrator/types";
@@ -18,7 +18,7 @@ import type { Plugin } from "../tools/setup/plugin";
 export const INSTALL_CONTRACT_REVISION = 1;
 
 export interface InstallContext {
-  kind: "core" | "companion" | "ambiguous";
+  kind: "core" | "working" | "companion" | "hub" | "ambiguous";
   companionPath?: string;
   config: FrameworkConfig;
   fingerprint: string;
@@ -66,8 +66,8 @@ export function getInstallStatePath(
     throw new Error("cannot resolve install state for an ambiguous companion context");
   }
   const key =
-    scope.kind === "companion" && scope.companionPath
-      ? fingerprint({ kind: "companion", companionPath: path.resolve(scope.companionPath) })
+    (scope.kind === "companion" || scope.kind === "hub") && scope.companionPath
+      ? fingerprint({ kind: scope.kind, companionPath: path.resolve(scope.companionPath) })
       : "core";
   return path.join(stateRoot, `${key}.yaml`);
 }
@@ -106,50 +106,40 @@ function coreContext(): InstallContext {
   };
 }
 
-async function contextForCompanion(companionPath: string): Promise<InstallContext> {
-  const configPath = path.join(companionPath, `.${FRAMEWORK_NAME}`, "config", "framework.yaml");
-  const config = mergeWithDefaults(await new ConfigStore(configPath).load());
-  return {
-    kind: "companion",
-    companionPath,
-    config,
-    fingerprint: fingerprint({ kind: "companion", companionPath, config }),
-  };
-}
-
-async function hasLocalConfig(cwd: string): Promise<boolean> {
-  try {
-    await fs.access(path.join(cwd, `.${FRAMEWORK_NAME}`, "config", "framework.yaml"));
-    return true;
-  } catch {
-    return false;
-  }
+function workingContext(): InstallContext {
+  const context = coreContext();
+  return { ...context, kind: "working" };
 }
 
 export async function resolveInstallContext(
   cwd = process.cwd(),
   deps: InstallContextDeps = {},
 ): Promise<InstallContext> {
-  const resolvedCwd = path.resolve(cwd);
-  const envCompanionPath = process.env.MATE_ARTIFACT_PATH;
-  if (envCompanionPath) return contextForCompanion(path.resolve(envCompanionPath));
-
-  const resolver = new CompanionResolver(deps.globalConfigStore ?? new GlobalConfigStore());
-  const resolution = await resolver.resolveWithDiagnostics(resolvedCwd);
-  if (resolution.ambiguousMatches.length > 1) {
+  const root = await resolveRootContext(cwd, deps);
+  if (root.resolution.ambiguousMatches.length > 1) {
     return {
       ...coreContext(),
       kind: "ambiguous",
       message: [
         "multiple companions match the current working repository.",
-        ...resolution.ambiguousMatches.map((match) => `  - ${match.companionPath}`),
+        ...root.resolution.ambiguousMatches.map((match) => `  - ${match.companionPath}`),
         "Run `mate install` from an explicit companion context or set MATE_ARTIFACT_PATH.",
       ].join("\n"),
     };
   }
-  if (resolution.match) return contextForCompanion(resolution.match.companionPath);
-  if (await hasLocalConfig(resolvedCwd)) return contextForCompanion(resolvedCwd);
-  return coreContext();
+  if (root.kind === "working") return workingContext();
+  if (root.kind === "core" || !root.rootPath || !root.config) return coreContext();
+
+  return {
+    kind: root.kind,
+    companionPath: root.rootPath,
+    config: root.config,
+    fingerprint: fingerprint({
+      kind: root.kind,
+      companionPath: root.rootPath,
+      config: root.config,
+    }),
+  };
 }
 
 export function buildInstallPlan(
@@ -292,11 +282,7 @@ export async function inspectInstallPreflight(
 ): Promise<InstallPreflightResult> {
   const context = await resolveInstallContext(cwd, deps);
   const distribution = getActiveDistribution().config;
-  const engineCheck = checkEngineRequirement(
-    context.config,
-    distribution.name,
-    distribution.version,
-  );
+  const engineCheck = checkEngineRequirement(context.config, FRAMEWORK_NAME, distribution.version);
   if (!engineCheck.ok) return { ok: false, reason: engineCheck.reason };
   const plan = await inspectInstallPlan(buildInstallPlan(context));
   if (context.kind === "ambiguous") return { ok: false, reason: context.message, plan };
@@ -333,8 +319,10 @@ export async function inspectInstallPreflight(
 }
 
 export async function reconcileInstalledCompanion(plan: InstallPlan): Promise<void> {
-  if (plan.context.kind === "companion" && plan.context.companionPath) {
-    const { syncCompanionFiles } = await import("../tools/setup");
-    await syncCompanionFiles(plan.context.companionPath, plan.context.config);
+  if (plan.context.kind !== "companion" || !plan.context.companionPath) {
+    return;
   }
+
+  const { syncCompanionFiles } = await import("../tools/setup");
+  await syncCompanionFiles(plan.context.companionPath, plan.context.config);
 }

package/src/lib/orchestrator/adapters/base.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { version } from "../../../../package.json";
 import { isCommandOnPath } from "../../fs-utils";
-import { FRAMEWORK_NAME, frameworkCommandName } from "../../../framework";
+import { FRAMEWORK_NAME } from "../../../framework";
 import { getReactDoctorBinPath, getWrapperBinPath } from "../../package-paths";
 import {
   GRAPHIFY_OUTPUT_SUBDIR,
@@ -17,11 +17,11 @@ import {
   spawnProxyBackground as defaultSpawnProxyBackground,
   waitForProxyReachable as defaultWaitForProxyReachable,
 } from "../headroom/proxy";
-import type { CapabilityConfig, GitModeProfile, LinkedRepository, PolicySettings } from "../types";
+import type { CapabilityConfig, GitModeProfile, LinkedRepository } from "../types";
 
 export interface AdapterContext {
   repository: LinkedRepository;
-  policy: PolicySettings;
+  allowedAgents: string[];
   companionPath: string;
   capabilities: CapabilityConfig[];
   git?: GitModeProfile;
@@ -78,18 +78,17 @@ export abstract class LaunchAdapter {
     const env: NodeJS.ProcessEnv = {
       ...process.env,
       MATE_NAME: FRAMEWORK_NAME,
-      MATE_COMMAND: frameworkCommandName(),
       MATE_VERSION: version,
       MATE_ARTIFACT_PATH: context.companionPath,
       MATE_WRAPPER_BIN_PATH: wrapperBinPath,
       PATH: prependPathEntry(process.env.PATH, wrapperBinPath),
       MATE_GRAPHIFY_ENABLED: context.capabilities.some((c) => c.name === "graphify") ? "1" : "0",
+      MATE_OPENSPEC_ENABLED: context.capabilities.some((c) => c.name === "openspec") ? "1" : "0",
       MATE_REACT_DOCTOR_ENABLED: reactDoctorEnabled ? "1" : "0",
       MATE_GIT_AUTO_MODE: context.git === "auto" ? "1" : "0",
       MATE_REPO_ID: context.repository.id,
       MATE_REPO_PATH: context.repository.path,
-      MATE_REPO_PROFILE: context.repository.profile,
-      MATE_POLICY_JSON: JSON.stringify(context.policy),
+      MATE_POLICY_JSON: JSON.stringify({ allowedAgents: context.allowedAgents }),
     };
 
     if (reactDoctorEnabled) {
@@ -149,7 +148,7 @@ export abstract class LaunchAdapter {
         command: this.toolName,
         args: builtArgs,
         env,
-        warning: `${frameworkCommandName()}: headroom capability enabled but \`headroom\` was not found on PATH; install with \`uv tool install "headroom-ai[all]"\`; launching ${this.toolName} directly\n`,
+        warning: `${FRAMEWORK_NAME}: headroom capability enabled but \`headroom\` was not found on PATH; install with \`uv tool install "headroom-ai[all]"\`; launching ${this.toolName} directly\n`,
       };
     }
 
@@ -183,7 +182,7 @@ export abstract class LaunchAdapter {
           command: this.toolName,
           args: builtArgs,
           env,
-          warning: `${frameworkCommandName()}: headroom proxy failed to become ready on port ${port} after ${maxProxyStartAttempts} attempts; launching ${this.toolName} directly${errorDetail}\n`,
+          warning: `${FRAMEWORK_NAME}: headroom proxy failed to become ready on port ${port} after ${maxProxyStartAttempts} attempts; launching ${this.toolName} directly${errorDetail}\n`,
         };
       }
     }

package/src/lib/orchestrator/adapters/claude.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 
 import { buildCompanionGuidance } from "../../../playbooks/companion-guidance";
 import { getContextModePackageRoot, validateContextModePackage } from "../../context-mode-package";
+import { getClaudePluginRoot, validateClaudePluginAssets } from "../../package-paths";
 import {
   getCompanionClaudeMcpConfigPath,
   getCompanionClaudeSettingsPath,
@@ -13,6 +14,17 @@ export class ClaudeAdapter extends LaunchAdapter {
   readonly interactive = true;
 
   async validateLaunch(context: AdapterContext): Promise<void> {
+    // The bundled mate plugin carries the artifact-path guard; never launch a
+    // managed session without it.
+    try {
+      validateClaudePluginAssets();
+    } catch (error) {
+      throw new Error(
+        `Mate Claude plugin is unavailable: ${(error as Error).message}. Reinstall mate to repair it.`,
+        { cause: error },
+      );
+    }
+
     if (context.capabilities.some((capability) => capability.name === "context-mode")) {
       try {
         await validateContextModePackage(context.companionPath);
@@ -56,6 +68,10 @@ export class ClaudeAdapter extends LaunchAdapter {
       buildCompanionGuidance(context),
       ...settingsArgs,
       ...mcpConfigArgs,
+      // Bundled mate plugin (hooks) resolved from the running mate-core
+      // installation, coexisting with the context-mode plugin dir.
+      "--plugin-dir",
+      getClaudePluginRoot(),
       ...contextModeArgs,
       ...args,
     ];

package/src/lib/orchestrator/adapters/opencode.ts

@@ -9,61 +9,15 @@ import {
   getOpenCodePluginPackageReference,
   isMateOpenCodePluginReference,
 } from "../../opencode-plugin-package";
+import {
+  getOpenCodePluginReferences,
+  mergeOpenCodeConfigContent,
+  readOpenCodeConfig,
+} from "../../../tools/setup/providers/opencode-format";
 import { buildOpenCodeGuidance } from "../opencode-guidance";
 import { LaunchPreflightError } from "../types";
 import { type AdapterContext, LaunchAdapter } from "./base";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function mergeConfig(target: Record<string, unknown>, source: Record<string, unknown>): void {
-  for (const [key, sourceValue] of Object.entries(source)) {
-    const targetValue = target[key];
-    if (isRecord(targetValue) && isRecord(sourceValue)) {
-      mergeConfig(targetValue, sourceValue);
-      continue;
-    }
-
-    target[key] = sourceValue;
-  }
-}
-
-function mergeOpenCodeConfigContent(
-  overlay: Record<string, unknown>,
-  env: NodeJS.ProcessEnv = process.env,
-  options: { appendSkillPaths?: string[] } = {},
-): string {
-  let config: Record<string, unknown> = {};
-  const existing = env.OPENCODE_CONFIG_CONTENT;
-
-  if (existing) {
-    try {
-      const parsed = JSON.parse(existing) as unknown;
-      if (isRecord(parsed)) {
-        config = parsed;
-      }
-    } catch {
-      // Ignore invalid inherited config content rather than breaking launch.
-    }
-  }
-
-  mergeConfig(config, overlay);
-
-  if (options.appendSkillPaths && options.appendSkillPaths.length > 0) {
-    const skills = isRecord(config.skills) ? config.skills : {};
-    const paths = Array.isArray(skills.paths) ? skills.paths : [];
-    const existingPaths = new Set(paths);
-    skills.paths = [
-      ...paths,
-      ...options.appendSkillPaths.filter((skillPath) => !existingPaths.has(skillPath)),
-    ];
-    config.skills = skills;
-  }
-
-  return JSON.stringify(config);
-}
-
 export class OpenCodeAdapter extends LaunchAdapter {
   readonly toolName = "opencode";
   readonly interactive = true;
@@ -190,18 +144,14 @@ export class OpenCodeAdapter extends LaunchAdapter {
   ): Promise<string[]> {
     const configPath = path.join(context.companionPath, configFile);
 
-    let config: unknown;
-    try {
-      config = JSON.parse(await fs.readFile(configPath, "utf8"));
-    } catch {
-      return [`Unreadable OpenCode configuration: ${configPath}`];
-    }
-    if (!isRecord(config)) {
+    const { present, config } = await readOpenCodeConfig(configPath);
+    if (!present) {
       return [`Unreadable OpenCode configuration: ${configPath}`];
     }
 
-    const plugins = Array.isArray(config.plugin) ? (config.plugin as unknown[]) : [];
-    const mateReferences = plugins.filter(isMateOpenCodePluginReference) as string[];
+    const mateReferences = getOpenCodePluginReferences(config).filter(
+      isMateOpenCodePluginReference,
+    ) as string[];
 
     if (mateReferences.includes(expectedPluginReference)) {
       return [];