agentpacks 0.3.0 → 0.4.0

package/dist/api.js

@@ -1,51 +1,85 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/core/config.ts
-var exports_config = {};
-__export(exports_config, {
-  resolveTargets: () => resolveTargets,
-  resolveFeatures: () => resolveFeatures,
-  loadWorkspaceConfig: () => loadWorkspaceConfig,
-  loadPackManifest: () => loadPackManifest,
-  WorkspaceConfigSchema: () => WorkspaceConfigSchema,
-  TARGET_IDS: () => TARGET_IDS,
-  REPO_MODES: () => REPO_MODES,
-  PackManifestSchema: () => PackManifestSchema,
-  FEATURE_IDS: () => FEATURE_IDS
-});
 import { z } from "zod";
 import { readFileSync, existsSync } from "fs";
 import { resolve } from "path";
 import { parse as parseJsonc } from "jsonc-parser";
+var TARGET_IDS = [
+  "opencode",
+  "cursor",
+  "claudecode",
+  "codexcli",
+  "geminicli",
+  "copilot",
+  "agentsmd",
+  "cline",
+  "kilo",
+  "roo",
+  "qwencode",
+  "kiro",
+  "factorydroid",
+  "antigravity",
+  "junie",
+  "augmentcode",
+  "windsurf",
+  "warp",
+  "replit",
+  "zed"
+];
+var FEATURE_IDS = [
+  "rules",
+  "commands",
+  "agents",
+  "skills",
+  "hooks",
+  "plugins",
+  "mcp",
+  "ignore",
+  "models"
+];
+var REPO_MODES = ["repo", "monorepo", "metarepo"];
+var PackManifestSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().default("1.0.0"),
+  description: z.string().default(""),
+  author: z.union([
+    z.string(),
+    z.object({ name: z.string(), email: z.string().optional() })
+  ]).optional(),
+  tags: z.array(z.string()).default([]),
+  dependencies: z.array(z.string()).default([]),
+  conflicts: z.array(z.string()).default([]),
+  targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+  features: z.union([z.literal("*"), z.array(z.string())]).default("*")
+});
+var FeaturesSchema = z.union([
+  z.literal("*"),
+  z.array(z.string()),
+  z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
+]);
+var WorkspaceConfigSchema = z.object({
+  $schema: z.string().optional(),
+  packs: z.array(z.string()).default(["./packs/default"]),
+  disabled: z.array(z.string()).default([]),
+  targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+  features: FeaturesSchema.default("*"),
+  mode: z.enum(REPO_MODES).default("repo"),
+  baseDirs: z.array(z.string()).default(["."]),
+  global: z.boolean().default(false),
+  delete: z.boolean().default(true),
+  verbose: z.boolean().default(false),
+  silent: z.boolean().default(false),
+  overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
+  sources: z.array(z.object({
+    source: z.string(),
+    packs: z.array(z.string()).optional(),
+    skills: z.array(z.string()).optional()
+  })).default([]),
+  modelProfile: z.string().optional()
+});
+var CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
 function loadWorkspaceConfig(projectRoot) {
   for (const filename of CONFIG_FILES) {
     const filepath = resolve(projectRoot, filename);
@@ -91,81 +125,6 @@ function resolveTargets(config) {
     return [...TARGET_IDS];
   return config.targets;
 }
-var TARGET_IDS, FEATURE_IDS, REPO_MODES, PackManifestSchema, FeaturesSchema, WorkspaceConfigSchema, CONFIG_FILES;
-var init_config = __esm(() => {
-  TARGET_IDS = [
-    "opencode",
-    "cursor",
-    "claudecode",
-    "codexcli",
-    "geminicli",
-    "copilot",
-    "agentsmd",
-    "cline",
-    "kilo",
-    "roo",
-    "qwencode",
-    "kiro",
-    "factorydroid",
-    "antigravity",
-    "junie",
-    "augmentcode",
-    "windsurf",
-    "warp",
-    "replit",
-    "zed"
-  ];
-  FEATURE_IDS = [
-    "rules",
-    "commands",
-    "agents",
-    "skills",
-    "hooks",
-    "plugins",
-    "mcp",
-    "ignore"
-  ];
-  REPO_MODES = ["repo", "monorepo", "metarepo"];
-  PackManifestSchema = z.object({
-    name: z.string().min(1),
-    version: z.string().default("1.0.0"),
-    description: z.string().default(""),
-    author: z.union([
-      z.string(),
-      z.object({ name: z.string(), email: z.string().optional() })
-    ]).optional(),
-    tags: z.array(z.string()).default([]),
-    dependencies: z.array(z.string()).default([]),
-    conflicts: z.array(z.string()).default([]),
-    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
-    features: z.union([z.literal("*"), z.array(z.string())]).default("*")
-  });
-  FeaturesSchema = z.union([
-    z.literal("*"),
-    z.array(z.string()),
-    z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
-  ]);
-  WorkspaceConfigSchema = z.object({
-    $schema: z.string().optional(),
-    packs: z.array(z.string()).default(["./packs/default"]),
-    disabled: z.array(z.string()).default([]),
-    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
-    features: FeaturesSchema.default("*"),
-    mode: z.enum(REPO_MODES).default("repo"),
-    baseDirs: z.array(z.string()).default(["."]),
-    global: z.boolean().default(false),
-    delete: z.boolean().default(true),
-    verbose: z.boolean().default(false),
-    silent: z.boolean().default(false),
-    overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
-    sources: z.array(z.object({
-      source: z.string(),
-      packs: z.array(z.string()).optional(),
-      skills: z.array(z.string()).optional()
-    })).default([])
-  });
-  CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
-});
 
 // src/utils/filesystem.ts
 import {
@@ -174,10 +133,10 @@ import {
   readFileSync as readFileSync2,
   writeFileSync,
   readdirSync,
+  rmSync,
   statSync
 } from "fs";
 import { dirname, relative, join } from "path";
-import { removeSync } from "fs-extra";
 var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
 var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
 var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
@@ -218,7 +177,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync2(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {
@@ -544,10 +503,178 @@ function mergeIgnorePatterns(configs) {
   return result;
 }
 
+// src/features/models.ts
+import { join as join7 } from "path";
+import { z as z2 } from "zod";
+var SECRET_PATTERNS = [
+  /["']api[_-]?key["']\s*:/i,
+  /["']apiKey["']\s*:/i,
+  /["']secret["']\s*:/i,
+  /["']password["']\s*:/i,
+  /["'](?:auth_token|access_token|bearer_token)["']\s*:/i,
+  /["']private[_-]?key["']\s*:/i,
+  /-----BEGIN\s+(RSA|EC|DSA|OPENSSH|PGP)\s+PRIVATE\s+KEY-----/,
+  /sk-[a-zA-Z0-9]{20,}/,
+  /Bearer\s+[a-zA-Z0-9._-]{20,}/
+];
+var AgentModelSchema = z2.object({
+  model: z2.string(),
+  temperature: z2.number().min(0).max(2).optional(),
+  top_p: z2.number().min(0).max(1).optional()
+});
+var ModelProfileSchema = z2.object({
+  extends: z2.string().optional(),
+  description: z2.string().optional(),
+  default: z2.string().optional(),
+  small: z2.string().optional(),
+  agents: z2.record(z2.string(), AgentModelSchema).optional()
+});
+var RoutingConditionSchema = z2.object({
+  complexity: z2.enum(["low", "medium", "high", "critical"]).optional().describe("Task complexity level"),
+  urgency: z2.enum(["low", "normal", "high"]).optional().describe("Time sensitivity"),
+  budget: z2.enum(["minimal", "standard", "premium"]).optional().describe("Cost/token budget tier"),
+  contextWindowNeed: z2.enum(["small", "medium", "large", "max"]).optional().describe("Required context window size"),
+  toolUseIntensity: z2.enum(["none", "light", "heavy"]).optional().describe("Expected tool/function calling intensity")
+});
+var RoutingRuleSchema = z2.object({
+  when: z2.record(z2.string(), z2.string()),
+  use: z2.string(),
+  description: z2.string().optional(),
+  priority: z2.number().optional()
+});
+var ProviderModelSchema = z2.object({
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  variants: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional()
+});
+var ProviderConfigSchema = z2.object({
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  models: z2.record(z2.string(), ProviderModelSchema).optional()
+});
+var ModelsSchema = z2.object({
+  default: z2.string().optional(),
+  small: z2.string().optional(),
+  agents: z2.record(z2.string(), AgentModelSchema).optional(),
+  profiles: z2.record(z2.string(), ModelProfileSchema).optional(),
+  providers: z2.record(z2.string(), ProviderConfigSchema).optional(),
+  routing: z2.array(RoutingRuleSchema).optional(),
+  overrides: z2.record(z2.string(), z2.object({
+    default: z2.string().optional(),
+    small: z2.string().optional(),
+    agents: z2.record(z2.string(), AgentModelSchema).optional()
+  })).optional()
+});
+function parseModels(packDir, packName) {
+  const modelsPath = join7(packDir, "models.json");
+  const raw = readJsonOrNull(modelsPath);
+  if (!raw)
+    return null;
+  const parsed = ModelsSchema.parse(raw);
+  return {
+    packName,
+    sourcePath: modelsPath,
+    config: parsed
+  };
+}
+function mergeModelsConfigs(configs) {
+  const warnings = [];
+  const result = {};
+  for (const entry of configs) {
+    const { config, packName } = entry;
+    if (config.default !== undefined && result.default === undefined) {
+      result.default = config.default;
+    } else if (config.default !== undefined && result.default !== undefined) {
+      warnings.push(`Models "default" from pack "${packName}" skipped (already defined).`);
+    }
+    if (config.small !== undefined && result.small === undefined) {
+      result.small = config.small;
+    } else if (config.small !== undefined && result.small !== undefined) {
+      warnings.push(`Models "small" from pack "${packName}" skipped (already defined).`);
+    }
+    if (config.agents) {
+      if (!result.agents)
+        result.agents = {};
+      for (const [name, assignment] of Object.entries(config.agents)) {
+        if (name in result.agents) {
+          warnings.push(`Models agent "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.agents[name] = assignment;
+      }
+    }
+    if (config.profiles) {
+      if (!result.profiles)
+        result.profiles = {};
+      for (const [name, profile] of Object.entries(config.profiles)) {
+        if (name in result.profiles) {
+          warnings.push(`Models profile "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.profiles[name] = profile;
+      }
+    }
+    if (config.providers) {
+      if (!result.providers)
+        result.providers = {};
+      for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        if (!(providerName in result.providers)) {
+          result.providers[providerName] = providerConfig;
+        } else {
+          const existing = result.providers[providerName];
+          if (!existing) {
+            result.providers[providerName] = providerConfig;
+            continue;
+          }
+          if (providerConfig.options) {
+            existing.options = {
+              ...providerConfig.options,
+              ...existing.options
+            };
+          }
+          if (providerConfig.models) {
+            if (!existing.models)
+              existing.models = {};
+            for (const [modelName, modelConfig] of Object.entries(providerConfig.models)) {
+              if (!(modelName in existing.models)) {
+                existing.models[modelName] = modelConfig;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (config.routing) {
+      if (!result.routing)
+        result.routing = [];
+      result.routing.push(...config.routing);
+    }
+    if (config.overrides) {
+      if (!result.overrides)
+        result.overrides = {};
+      for (const [targetId, override] of Object.entries(config.overrides)) {
+        if (targetId in result.overrides) {
+          warnings.push(`Models override for target "${targetId}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.overrides[targetId] = override;
+      }
+    }
+  }
+  return { config: result, warnings };
+}
+function scanModelsForSecrets(config) {
+  const warnings = [];
+  const json = JSON.stringify(config);
+  for (const pattern of SECRET_PATTERNS) {
+    if (pattern.test(json)) {
+      warnings.push(`Potential secret detected in models.json matching pattern: ${pattern.source}`);
+    }
+  }
+  return warnings;
+}
+
 // src/core/pack-loader.ts
-init_config();
 import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve3, isAbsolute } from "path";
+import { resolve as resolve2, isAbsolute } from "path";
 class PackLoader {
   projectRoot;
   config;
@@ -580,10 +707,10 @@ class PackLoader {
   }
   loadPack(packDir, manifest) {
     const name = manifest.name;
-    const rulesDir = resolve3(packDir, "rules");
-    const commandsDir = resolve3(packDir, "commands");
-    const agentsDir = resolve3(packDir, "agents");
-    const skillsDir = resolve3(packDir, "skills");
+    const rulesDir = resolve2(packDir, "rules");
+    const commandsDir = resolve2(packDir, "commands");
+    const agentsDir = resolve2(packDir, "agents");
+    const skillsDir = resolve2(packDir, "skills");
     return {
       manifest,
       directory: packDir,
@@ -594,23 +721,25 @@ class PackLoader {
       hooks: parseHooks(packDir, name),
       plugins: parsePlugins(packDir, name),
       mcp: parseMcp(packDir, name),
-      ignore: parseIgnore(packDir, name)
+      ignore: parseIgnore(packDir, name),
+      models: parseModels(packDir, name)
     };
   }
   loadForBaseDir(baseDir) {
-    const baseDirRoot = resolve3(this.projectRoot, baseDir);
-    const localConfigPath = resolve3(baseDirRoot, "agentpacks.jsonc");
+    const baseDirRoot = resolve2(this.projectRoot, baseDir);
+    const localConfigPath = resolve2(baseDirRoot, "agentpacks.jsonc");
     if (!existsSync6(localConfigPath)) {
       return { packs: [], warnings: [] };
     }
-    const { loadWorkspaceConfig: loadWorkspaceConfig2 } = (init_config(), __toCommonJS(exports_config));
-    const localConfig = loadWorkspaceConfig2(baseDirRoot);
+    const localConfig = loadWorkspaceConfig(baseDirRoot);
     const loader = new PackLoader(baseDirRoot, localConfig);
     return loader.loadAll();
   }
   resolveCuratedPack(packRef) {
-    const curatedDir = resolve3(this.projectRoot, ".agentpacks", ".curated");
+    const curatedDir = resolve2(this.projectRoot, ".agentpacks", ".curated");
     let packName = packRef;
+    if (packName.startsWith("registry:"))
+      packName = packName.slice(9);
     if (packName.startsWith("npm:"))
       packName = packName.slice(4);
     if (packName.startsWith("github:"))
@@ -621,24 +750,28 @@ class PackLoader {
       const parts = packName.split("/");
       packName = packName.includes("@") ? parts.join("-") : parts[parts.length - 1] ?? packName;
     }
-    packName = packName.split("@")[0].split(":")[0];
-    const resolved = resolve3(curatedDir, packName);
+    const withoutVersion = packName.split("@")[0] ?? packName;
+    packName = withoutVersion.split(":")[0] ?? withoutVersion;
+    const resolved = resolve2(curatedDir, packName);
     return existsSync6(resolved) ? resolved : null;
   }
   resolvePackPath(packRef) {
     if (packRef.startsWith("./") || packRef.startsWith("../")) {
-      return resolve3(this.projectRoot, packRef);
+      return resolve2(this.projectRoot, packRef);
     }
     if (isAbsolute(packRef)) {
       return packRef;
     }
+    if (packRef.startsWith("registry:")) {
+      return this.resolveCuratedPack(packRef);
+    }
     if (packRef.startsWith("@") || packRef.startsWith("npm:") || !packRef.includes("/")) {
       return this.resolveCuratedPack(packRef);
     }
     if (packRef.startsWith("github:") || packRef.includes("/")) {
       return this.resolveCuratedPack(packRef);
     }
-    return resolve3(this.projectRoot, packRef);
+    return resolve2(this.projectRoot, packRef);
   }
 }
 
@@ -659,7 +792,8 @@ class FeatureMerger {
       hooks: this.mergeHooks(),
       plugins: this.mergePlugins(),
       mcpServers: this.mergeMcp(),
-      ignorePatterns: this.mergeIgnore()
+      ignorePatterns: this.mergeIgnore(),
+      models: this.mergeModels()
     };
     return { features, warnings: this.warnings };
   }
@@ -746,16 +880,24 @@ class FeatureMerger {
     }
     return result;
   }
+  mergeModels() {
+    const configs = this.packs.map((p) => p.models).filter((m) => m != null);
+    if (configs.length === 0)
+      return null;
+    const { config, warnings } = mergeModelsConfigs(configs);
+    this.warnings.push(...warnings);
+    return config;
+  }
 }
 
 // src/core/lockfile.ts
 import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 import { createHash } from "crypto";
 var LOCKFILE_VERSION = 1;
 var LOCKFILE_NAME = "agentpacks.lock";
 function loadLockfile(projectRoot) {
-  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  const filepath = resolve3(projectRoot, LOCKFILE_NAME);
   if (!existsSync7(filepath)) {
     return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
   }
@@ -763,7 +905,7 @@ function loadLockfile(projectRoot) {
   return JSON.parse(raw);
 }
 function saveLockfile(projectRoot, lockfile) {
-  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  const filepath = resolve3(projectRoot, LOCKFILE_NAME);
   writeFileSync2(filepath, JSON.stringify(lockfile, null, 2) + `
 `);
 }
@@ -831,8 +973,12 @@ function topologicalSort(graph) {
   const sorted = [];
   while (queue.length > 0) {
     const current = queue.shift();
+    if (!current)
+      continue;
     sorted.push(current);
     const node = graph.get(current);
+    if (!node)
+      continue;
     for (const dep of node.dependencies) {
       if (!graph.has(dep))
         continue;
@@ -899,15 +1045,119 @@ function detectConflicts(graph) {
   return conflicts;
 }
 
+// src/core/profile-resolver.ts
+function resolveModels(merged, modelProfile, targetId) {
+  let defaultModel = merged.default;
+  let smallModel = merged.small;
+  let agents = { ...merged.agents };
+  if (modelProfile && merged.profiles?.[modelProfile]) {
+    const resolvedProfile = resolveProfileInheritance(modelProfile, merged.profiles);
+    if (resolvedProfile.default)
+      defaultModel = resolvedProfile.default;
+    if (resolvedProfile.small)
+      smallModel = resolvedProfile.small;
+    if (resolvedProfile.agents) {
+      agents = { ...agents, ...resolvedProfile.agents };
+    }
+  }
+  if (targetId) {
+    const targetOverride = merged.overrides?.[targetId];
+    if (targetOverride) {
+      if (targetOverride.default)
+        defaultModel = targetOverride.default;
+      if (targetOverride.small)
+        smallModel = targetOverride.small;
+      if (targetOverride.agents) {
+        agents = { ...agents, ...targetOverride.agents };
+      }
+    }
+  }
+  const providers = {};
+  if (merged.providers) {
+    for (const [name, config] of Object.entries(merged.providers)) {
+      providers[name] = {
+        ...config.options ? { options: config.options } : {},
+        ...config.models ? { models: config.models } : {}
+      };
+    }
+  }
+  const profileNames = Object.keys(merged.profiles ?? {});
+  const profiles = {};
+  if (merged.profiles) {
+    for (const [name, profile] of Object.entries(merged.profiles)) {
+      profiles[name] = {
+        description: profile.description,
+        default: profile.default,
+        small: profile.small
+      };
+    }
+  }
+  return {
+    default: defaultModel,
+    small: smallModel,
+    agents,
+    providers,
+    routing: merged.routing ?? [],
+    profileNames,
+    activeProfile: modelProfile,
+    profiles
+  };
+}
+function resolveAgentModel(resolved, agentName, frontmatterModel) {
+  const fromModels = resolved.agents[agentName];
+  if (fromModels) {
+    return {
+      model: fromModels.model,
+      temperature: fromModels.temperature,
+      top_p: fromModels.top_p
+    };
+  }
+  if (frontmatterModel) {
+    return { model: frontmatterModel };
+  }
+  return {};
+}
+function resolveProfileInheritance(profileName, profiles) {
+  const visited = new Set;
+  return resolveProfileChain(profileName, profiles, visited, 0);
+}
+var MAX_INHERITANCE_DEPTH = 10;
+function resolveProfileChain(name, profiles, visited, depth) {
+  if (depth > MAX_INHERITANCE_DEPTH) {
+    throw new Error(`Profile inheritance too deep (max ${MAX_INHERITANCE_DEPTH}): ${name}`);
+  }
+  if (visited.has(name)) {
+    throw new Error(`Circular profile inheritance detected: ${[...visited, name].join(" \u2192 ")}`);
+  }
+  const profile = profiles[name];
+  if (!profile) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  visited.add(name);
+  if (!profile.extends) {
+    return { ...profile };
+  }
+  const parent = resolveProfileChain(profile.extends, profiles, visited, depth + 1);
+  return {
+    description: profile.description ?? parent.description,
+    default: profile.default ?? parent.default,
+    small: profile.small ?? parent.small,
+    agents: {
+      ...parent.agents,
+      ...profile.agents
+    }
+  };
+}
+
 // src/sources/local.ts
 import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve4, isAbsolute as isAbsolute2 } from "path";
 function resolveLocalPack(packRef, projectRoot) {
   let resolved;
   if (isAbsolute2(packRef)) {
     resolved = packRef;
   } else {
-    resolved = resolve5(projectRoot, packRef);
+    resolved = resolve4(projectRoot, packRef);
   }
   if (!existsSync8(resolved))
     return null;
@@ -939,9 +1189,14 @@ function parseGitSourceRef(source) {
   if (parts.length < 2) {
     throw new Error(`Invalid git source reference: "${source}". Expected owner/repo format.`);
   }
+  const owner = parts[0];
+  const repo = parts[1];
+  if (!owner || !repo) {
+    throw new Error(`Invalid git source reference: "${source}". Expected owner/repo format.`);
+  }
   return {
-    owner: parts[0],
-    repo: parts[1],
+    owner,
+    repo,
     ref,
     path: path || ""
   };
@@ -1010,9 +1265,39 @@ function npmSourceKey(parsed) {
   return `npm:${parsed.packageName}`;
 }
 
+// src/sources/registry-ref.ts
+function parseRegistrySourceRef(source) {
+  let s = source;
+  if (s.startsWith("registry:")) {
+    s = s.slice(9);
+  }
+  if (!s) {
+    throw new Error(`Invalid registry source reference: "${source}". Expected pack name.`);
+  }
+  let version = "latest";
+  const atIdx = s.indexOf("@");
+  if (atIdx > 0) {
+    version = s.slice(atIdx + 1);
+    s = s.slice(0, atIdx);
+  }
+  if (!s) {
+    throw new Error(`Invalid registry source reference: "${source}". Pack name is empty.`);
+  }
+  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(s)) {
+    throw new Error(`Invalid registry pack name: "${s}". Must be lowercase alphanumeric with hyphens.`);
+  }
+  return { packName: s, version };
+}
+function isRegistryPackRef(packRef) {
+  return packRef.startsWith("registry:");
+}
+function registrySourceKey(parsed) {
+  return `registry:${parsed.packName}`;
+}
+
 // src/sources/git.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve6, join as join7 } from "path";
+import { resolve as resolve5, join as join8 } from "path";
 var GITHUB_API = "https://api.github.com";
 function githubHeaders(token) {
   const h = {
@@ -1065,11 +1350,11 @@ async function fetchAndWriteSubdir(parsed, sha, remotePath, localDir, installed,
   for (const entry of entries) {
     if (entry.type === "file" && entry.download_url) {
       const content = await fetchGitFile(entry.download_url, token);
-      const filepath = join7(localDir, entry.name);
+      const filepath = join8(localDir, entry.name);
       writeFileSync3(filepath, content);
       installed.push(filepath);
     } else if (entry.type === "dir") {
-      await fetchAndWriteSubdir(parsed, sha, `${remotePath}/${entry.name}`, join7(localDir, entry.name), installed, token);
+      await fetchAndWriteSubdir(parsed, sha, `${remotePath}/${entry.name}`, join8(localDir, entry.name), installed, token);
     }
   }
 }
@@ -1090,7 +1375,7 @@ async function installGitSource(projectRoot, source, lockfile, options = {}) {
   }
   const basePath = parsed.path || "packs";
   const entries = await fetchGitDirectory(parsed, resolvedSha, basePath, options.token);
-  const curatedDir = resolve6(projectRoot, ".agentpacks", ".curated");
+  const curatedDir = resolve5(projectRoot, ".agentpacks", ".curated");
   mkdirSync2(curatedDir, { recursive: true });
   const newLockEntry = {
     requestedRef: parsed.ref,
@@ -1102,21 +1387,21 @@ async function installGitSource(projectRoot, source, lockfile, options = {}) {
   const packDirs = entries.filter((e) => e.type === "dir");
   for (const packEntry of packDirs) {
     const packName = packEntry.name;
-    const packOutDir = resolve6(curatedDir, packName);
+    const packOutDir = resolve5(curatedDir, packName);
     const packFiles = await fetchGitDirectory(parsed, resolvedSha, `${basePath}/${packName}`, options.token);
     mkdirSync2(packOutDir, { recursive: true });
     for (const file of packFiles) {
       if (file.type === "file" && file.download_url) {
         const content = await fetchGitFile(file.download_url, options.token);
-        writeFileSync3(join7(packOutDir, file.name), content);
-        installed.push(join7(packOutDir, file.name));
+        writeFileSync3(join8(packOutDir, file.name), content);
+        installed.push(join8(packOutDir, file.name));
         if (newLockEntry.packs) {
           newLockEntry.packs[packName] = {
             integrity: computeIntegrity(content)
           };
         }
       } else if (file.type === "dir") {
-        await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${packName}/${file.name}`, join7(packOutDir, file.name), installed, options.token);
+        await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${packName}/${file.name}`, join8(packOutDir, file.name), installed, options.token);
       }
     }
   }
@@ -1124,15 +1409,15 @@ async function installGitSource(projectRoot, source, lockfile, options = {}) {
     const fileEntries = entries.filter((e) => e.type === "file");
     if (fileEntries.length > 0) {
       const packName = parsed.path.split("/").pop() ?? parsed.repo;
-      const packOutDir = resolve6(curatedDir, packName);
+      const packOutDir = resolve5(curatedDir, packName);
       mkdirSync2(packOutDir, { recursive: true });
       for (const file of entries) {
         if (file.type === "file" && file.download_url) {
           const content = await fetchGitFile(file.download_url, options.token);
-          writeFileSync3(join7(packOutDir, file.name), content);
-          installed.push(join7(packOutDir, file.name));
+          writeFileSync3(join8(packOutDir, file.name), content);
+          installed.push(join8(packOutDir, file.name));
         } else if (file.type === "dir") {
-          await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${file.name}`, join7(packOutDir, file.name), installed, options.token);
+          await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${file.name}`, join8(packOutDir, file.name), installed, options.token);
         }
       }
     }
@@ -1142,8 +1427,8 @@ async function installGitSource(projectRoot, source, lockfile, options = {}) {
 }
 
 // src/sources/npm.ts
-import { mkdirSync as mkdirSync3, existsSync as existsSync9 } from "fs";
-import { resolve as resolve7, join as join8 } from "path";
+import { mkdirSync as mkdirSync3, existsSync as existsSync9, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve6, join as join9 } from "path";
 import { execSync } from "child_process";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 async function resolveNpmVersion(parsed) {
@@ -1167,18 +1452,15 @@ async function installNpmSource(projectRoot, source, lockfile, options = {}) {
     throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
   }
   let resolvedVersion;
-  let tarballUrl;
   if (locked && !options.update) {
     resolvedVersion = locked.resolvedRef;
-    tarballUrl = "";
   } else {
     const resolved = await resolveNpmVersion(parsed);
     resolvedVersion = resolved.version;
-    tarballUrl = resolved.tarball;
   }
-  const curatedDir = resolve7(projectRoot, ".agentpacks", ".curated");
+  const curatedDir = resolve6(projectRoot, ".agentpacks", ".curated");
   mkdirSync3(curatedDir, { recursive: true });
-  const packDir = extractNpmPack(parsed, resolvedVersion, curatedDir, installed, warnings);
+  extractNpmPack(parsed, resolvedVersion, curatedDir, installed, warnings);
   const newEntry = {
     requestedRef: parsed.version,
     resolvedRef: resolvedVersion,
@@ -1192,20 +1474,25 @@ async function installNpmSource(projectRoot, source, lockfile, options = {}) {
 function extractNpmPack(parsed, version, curatedDir, installed, warnings) {
   const pkgSpec = `${parsed.packageName}@${version}`;
   const packName = parsed.packageName.replace(/^@/, "").replace(/\//g, "-");
-  const packOutDir = resolve7(curatedDir, packName);
+  const packOutDir = resolve6(curatedDir, packName);
   try {
-    const tmpDir = resolve7(curatedDir, ".tmp-npm");
+    const tmpDir = resolve6(curatedDir, ".tmp-npm");
     mkdirSync3(tmpDir, { recursive: true });
     execSync(`npm pack ${pkgSpec} --pack-destination "${tmpDir}"`, {
       stdio: "pipe",
       timeout: 30000
     });
-    const tgzFiles = __require("fs").readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+    const tgzFiles = readdirSync2(tmpDir).filter((f) => f.endsWith(".tgz"));
     if (tgzFiles.length === 0) {
       warnings.push(`No tarball found for ${pkgSpec}`);
       return packOutDir;
     }
-    const tgzPath = join8(tmpDir, tgzFiles[0]);
+    const firstTgz = tgzFiles[0];
+    if (!firstTgz) {
+      warnings.push(`No tarball found for ${pkgSpec}`);
+      return packOutDir;
+    }
+    const tgzPath = join9(tmpDir, firstTgz);
     mkdirSync3(packOutDir, { recursive: true });
     execSync(`tar xzf "${tgzPath}" -C "${packOutDir}" --strip-components=1`, {
       stdio: "pipe",
@@ -1213,7 +1500,7 @@ function extractNpmPack(parsed, version, curatedDir, installed, warnings) {
     });
     execSync(`rm -rf "${tmpDir}"`, { stdio: "pipe" });
     const subpath = parsed.path || "";
-    const targetDir = subpath ? join8(packOutDir, subpath) : packOutDir;
+    const targetDir = subpath ? join9(packOutDir, subpath) : packOutDir;
     if (existsSync9(targetDir)) {
       collectFiles(targetDir, installed);
     }
@@ -1223,10 +1510,9 @@ function extractNpmPack(parsed, version, curatedDir, installed, warnings) {
   return packOutDir;
 }
 function collectFiles(dir, out) {
-  const fs = __require("fs");
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const entries = readdirSync2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = join8(dir, entry.name);
+    const full = join9(dir, entry.name);
     if (entry.isDirectory()) {
       collectFiles(full, out);
     } else {
@@ -1279,7 +1565,7 @@ ${content}`;
 }
 
 // src/targets/opencode.ts
-import { resolve as resolve8, join as join9 } from "path";
+import { resolve as resolve7, join as join10 } from "path";
 var TARGET_ID = "opencode";
 
 class OpenCodeTarget extends BaseTarget {
@@ -1293,32 +1579,48 @@ class OpenCodeTarget extends BaseTarget {
     "hooks",
     "plugins",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve8(projectRoot, baseDir);
+    const root = resolve7(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const opencodeDir = resolve8(root, ".opencode");
+    const opencodeDir = resolve7(root, ".opencode");
     if (effective.includes("agents")) {
-      const agentDir = resolve8(opencodeDir, "agent");
+      const agentDir = resolve7(opencodeDir, "agent");
       if (deleteExisting) {
         removeIfExists(agentDir);
         filesDeleted.push(agentDir);
       }
       ensureDir(agentDir);
+      const resolvedModels = features.models ? resolveModels(features.models, options.modelProfile, TARGET_ID) : null;
       const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID));
       for (const agent of agents) {
-        const filepath = join9(agentDir, `${agent.name}.md`);
-        writeGeneratedFile(filepath, agent.content);
+        const filepath = join10(agentDir, `${agent.name}.md`);
+        const fm = {};
+        const oc = agent.meta.opencode ?? {};
+        const modelsAgent = resolvedModels?.agents[agent.name];
+        const agentModel = modelsAgent?.model ?? oc.model;
+        const agentTemp = modelsAgent?.temperature ?? oc.temperature;
+        if (agentModel)
+          fm.model = agentModel;
+        if (agentTemp !== undefined)
+          fm.temperature = agentTemp;
+        if (oc.mode)
+          fm.mode = oc.mode;
+        if (oc.top_p !== undefined)
+          fm.top_p = oc.top_p;
+        const content = Object.keys(fm).length > 0 ? serializeFrontmatter(fm, agent.content) : agent.content;
+        writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillDir = resolve8(opencodeDir, "skill");
+      const skillDir = resolve7(opencodeDir, "skill");
       if (deleteExisting) {
         removeIfExists(skillDir);
         filesDeleted.push(skillDir);
@@ -1326,15 +1628,15 @@ class OpenCodeTarget extends BaseTarget {
       ensureDir(skillDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID));
       for (const skill of skills) {
-        const skillSubDir = join9(skillDir, skill.name);
+        const skillSubDir = join10(skillDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join9(skillSubDir, "SKILL.md");
+        const filepath = join10(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const cmdDir = resolve8(opencodeDir, "command");
+      const cmdDir = resolve7(opencodeDir, "command");
       if (deleteExisting) {
         removeIfExists(cmdDir);
         filesDeleted.push(cmdDir);
@@ -1342,19 +1644,19 @@ class OpenCodeTarget extends BaseTarget {
       ensureDir(cmdDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID));
       for (const cmd of commands) {
-        const filepath = join9(cmdDir, `${cmd.name}.md`);
+        const filepath = join10(cmdDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("hooks") || effective.includes("plugins")) {
-      const pluginsDir = resolve8(opencodeDir, "plugins");
+      const pluginsDir = resolve7(opencodeDir, "plugins");
       ensureDir(pluginsDir);
       if (effective.includes("hooks")) {
         for (const hookSet of features.hooks) {
           const events = resolveHooksForTarget(hookSet, TARGET_ID);
           if (Object.keys(events).length > 0) {
-            const filepath = join9(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
+            const filepath = join10(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
             const content = generateOpenCodeHookPlugin(hookSet.packName, events);
             writeGeneratedFile(filepath, content, { type: "ts" });
             filesWritten.push(filepath);
@@ -1363,7 +1665,7 @@ class OpenCodeTarget extends BaseTarget {
       }
       if (effective.includes("plugins")) {
         for (const plugin of features.plugins) {
-          const filepath = join9(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
+          const filepath = join10(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
           writeGeneratedFile(filepath, plugin.content, {
             type: plugin.extension
           });
@@ -1371,28 +1673,59 @@ class OpenCodeTarget extends BaseTarget {
         }
       }
     }
-    if (effective.includes("mcp")) {
-      const mcpEntries = Object.entries(features.mcpServers);
-      if (mcpEntries.length > 0) {
-        const opencodeConfig = buildOpenCodeMcp(features.mcpServers);
-        const filepath = resolve8(root, "opencode.json");
+    if (effective.includes("mcp") || effective.includes("models")) {
+      const filepath = resolve7(root, "opencode.json");
+      const opencodeConfig = {
+        $schema: "https://opencode.ai/config.json"
+      };
+      if (effective.includes("mcp")) {
+        const mcpEntries = Object.entries(features.mcpServers);
+        if (mcpEntries.length > 0) {
+          opencodeConfig.mcp = buildOpenCodeMcpServers(features.mcpServers);
+        }
+      }
+      if (effective.includes("models") && features.models) {
+        const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID);
+        if (resolved.default)
+          opencodeConfig.model = resolved.default;
+        if (resolved.small)
+          opencodeConfig.small_model = resolved.small;
+        if (Object.keys(resolved.providers).length > 0) {
+          opencodeConfig.provider = resolved.providers;
+        }
+        const agentEntries = Object.entries(resolved.agents);
+        if (agentEntries.length > 0) {
+          const agentConfig = {};
+          for (const [name, assignment] of agentEntries) {
+            const config = { model: assignment.model };
+            if (assignment.temperature !== undefined) {
+              config.temperature = assignment.temperature;
+            }
+            if (assignment.top_p !== undefined) {
+              config.top_p = assignment.top_p;
+            }
+            agentConfig[name] = config;
+          }
+          opencodeConfig.agent = agentConfig;
+        }
+      }
+      if (Object.keys(opencodeConfig).length > 1) {
         writeGeneratedJson(filepath, opencodeConfig, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("rules")) {
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID));
-      const rootRules = getRootRules(rules);
       const detailRules = getDetailRules(rules);
       if (detailRules.length > 0) {
-        const memoriesDir = resolve8(opencodeDir, "memories");
+        const memoriesDir = resolve7(opencodeDir, "memories");
         if (deleteExisting) {
           removeIfExists(memoriesDir);
           filesDeleted.push(memoriesDir);
         }
         ensureDir(memoriesDir);
         for (const rule of detailRules) {
-          const filepath = join9(memoriesDir, `${rule.name}.md`);
+          const filepath = join10(memoriesDir, `${rule.name}.md`);
           writeGeneratedFile(filepath, rule.content);
           filesWritten.push(filepath);
         }
@@ -1401,7 +1734,7 @@ class OpenCodeTarget extends BaseTarget {
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
-function buildOpenCodeMcp(servers) {
+function buildOpenCodeMcpServers(servers) {
   const mcp = {};
   for (const [name, entry] of Object.entries(servers)) {
     if (entry.url) {
@@ -1421,10 +1754,7 @@ function buildOpenCodeMcp(servers) {
       };
     }
   }
-  return {
-    $schema: "https://opencode.ai/config.json",
-    mcp
-  };
+  return mcp;
 }
 function generateOpenCodeHookPlugin(packName, events) {
   const identifier = packNameToIdentifier(packName);
@@ -1471,7 +1801,7 @@ function mapHookEvents(events) {
 }
 
 // src/targets/cursor.ts
-import { resolve as resolve9, join as join10 } from "path";
+import { resolve as resolve8, join as join11 } from "path";
 var TARGET_ID2 = "cursor";
 
 class CursorTarget extends BaseTarget {
@@ -1484,18 +1814,19 @@ class CursorTarget extends BaseTarget {
     "skills",
     "hooks",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve9(projectRoot, baseDir);
+    const root = resolve8(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const cursorDir = resolve9(root, ".cursor");
+    const cursorDir = resolve8(root, ".cursor");
     if (effective.includes("rules")) {
-      const rulesDir = resolve9(cursorDir, "rules");
+      const rulesDir = resolve8(cursorDir, "rules");
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -1512,33 +1843,40 @@ class CursorTarget extends BaseTarget {
         if (globs) {
           frontmatter.globs = globs;
         }
-        const filepath = join10(rulesDir, `${rule.name}.mdc`);
+        const filepath = join11(rulesDir, `${rule.name}.mdc`);
         const content = serializeFrontmatter(frontmatter, rule.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const agentsDir = resolve9(cursorDir, "agents");
+      const agentsDir = resolve8(cursorDir, "agents");
       if (deleteExisting) {
         removeIfExists(agentsDir);
         filesDeleted.push(agentsDir);
       }
       ensureDir(agentsDir);
+      const resolvedModels = features.models ? resolveModels(features.models, options.modelProfile, TARGET_ID2) : null;
       const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID2));
       for (const agent of agents) {
         const frontmatter = {
           name: agent.name,
           description: agent.meta.description ?? ""
         };
-        const filepath = join10(agentsDir, `${agent.name}.md`);
+        const cursorMeta = agent.meta.cursor ?? {};
+        const modelsAgent = resolvedModels?.agents[agent.name];
+        const model = modelsAgent?.model ?? cursorMeta.model;
+        if (model) {
+          frontmatter.model = model;
+        }
+        const filepath = join11(agentsDir, `${agent.name}.md`);
         const content = serializeFrontmatter(frontmatter, agent.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillsDir = resolve9(cursorDir, "skills");
+      const skillsDir = resolve8(cursorDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1546,20 +1884,20 @@ class CursorTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID2));
       for (const skill of skills) {
-        const skillSubDir = join10(skillsDir, skill.name);
+        const skillSubDir = join11(skillsDir, skill.name);
         ensureDir(skillSubDir);
         const frontmatter = {
           name: skill.name,
           description: skill.meta.description ?? ""
         };
-        const filepath = join10(skillSubDir, "SKILL.md");
+        const filepath = join11(skillSubDir, "SKILL.md");
         const content = serializeFrontmatter(frontmatter, skill.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve9(cursorDir, "commands");
+      const commandsDir = resolve8(cursorDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1567,7 +1905,7 @@ class CursorTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID2));
       for (const cmd of commands) {
-        const filepath = join10(commandsDir, `${cmd.name}.md`);
+        const filepath = join11(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
@@ -1576,14 +1914,14 @@ class CursorTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const mcpConfig = buildCursorMcp(features.mcpServers);
-        const filepath = resolve9(cursorDir, "mcp.json");
+        const filepath = resolve8(cursorDir, "mcp.json");
         writeGeneratedJson(filepath, mcpConfig, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve9(root, ".cursorignore");
+        const filepath = resolve8(root, ".cursorignore");
         const content = features.ignorePatterns.join(`
 `) + `
 `;
@@ -1591,6 +1929,17 @@ class CursorTarget extends BaseTarget {
         filesWritten.push(filepath);
       }
     }
+    if (effective.includes("models") && features.models) {
+      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID2);
+      const guidanceContent = buildCursorModelGuidance(resolved);
+      if (guidanceContent) {
+        const rulesDir = resolve8(cursorDir, "rules");
+        ensureDir(rulesDir);
+        const filepath = join11(rulesDir, "model-config.mdc");
+        writeGeneratedFile(filepath, guidanceContent, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
@@ -1609,9 +1958,135 @@ function buildCursorMcp(servers) {
   }
   return { mcpServers };
 }
+function buildCursorModelGuidance(resolved) {
+  if (!resolved.default && !resolved.small && Object.keys(resolved.agents).length === 0) {
+    return null;
+  }
+  const frontmatter = {
+    description: "Model configuration and selection guidelines for this workspace",
+    alwaysApply: true
+  };
+  const lines = [];
+  lines.push("# Model Configuration");
+  lines.push("");
+  lines.push("Use the following model preferences when working in this project.");
+  lines.push("");
+  if (resolved.default || resolved.small) {
+    lines.push("## Default Models");
+    lines.push("");
+    if (resolved.default) {
+      lines.push(`- **Primary model**: ${resolved.default}`);
+    }
+    if (resolved.small) {
+      lines.push(`- **Lightweight tasks** (titles, summaries): ${resolved.small}`);
+    }
+    lines.push("");
+  }
+  const agentEntries = Object.entries(resolved.agents);
+  if (agentEntries.length > 0) {
+    lines.push("## Agent Model Assignments");
+    lines.push("");
+    lines.push("| Agent | Model | Temperature |");
+    lines.push("| --- | --- | --- |");
+    for (const [name, assignment] of agentEntries) {
+      const temp = assignment.temperature !== undefined ? String(assignment.temperature) : "\u2014";
+      lines.push(`| ${name} | ${assignment.model} | ${temp} |`);
+    }
+    lines.push("");
+  }
+  if (Object.keys(resolved.profiles).length > 0) {
+    lines.push("## Available Profiles");
+    lines.push("");
+    lines.push("| Profile | Description | Default Model |");
+    lines.push("| --- | --- | --- |");
+    for (const [name, profile] of Object.entries(resolved.profiles)) {
+      lines.push(`| ${name} | ${profile.description ?? "\u2014"} | ${profile.default ?? "\u2014"} |`);
+    }
+    lines.push("");
+  }
+  if (resolved.activeProfile) {
+    lines.push(`**Active profile**: \`${resolved.activeProfile}\``);
+    lines.push("");
+  }
+  return serializeFrontmatter(frontmatter, lines.join(`
+`));
+}
+
+// src/utils/model-guidance.ts
+function generateModelGuidanceMarkdown(resolved) {
+  if (!resolved.default && !resolved.small && Object.keys(resolved.agents).length === 0 && Object.keys(resolved.profiles).length === 0) {
+    return null;
+  }
+  const lines = [];
+  lines.push("# Model Configuration");
+  lines.push("");
+  lines.push("Use the following model preferences when working in this project.");
+  lines.push("");
+  if (resolved.default || resolved.small) {
+    lines.push("## Default Models");
+    lines.push("");
+    if (resolved.default) {
+      lines.push(`- **Primary model**: ${resolved.default}`);
+    }
+    if (resolved.small) {
+      lines.push(`- **Lightweight tasks** (titles, summaries): ${resolved.small}`);
+    }
+    lines.push("");
+  }
+  const agentEntries = Object.entries(resolved.agents);
+  if (agentEntries.length > 0) {
+    lines.push("## Agent Model Assignments");
+    lines.push("");
+    lines.push("| Agent | Model | Temperature |");
+    lines.push("| --- | --- | --- |");
+    for (const [name, assignment] of agentEntries) {
+      const temp = assignment.temperature !== undefined ? String(assignment.temperature) : "\u2014";
+      lines.push(`| ${name} | ${assignment.model} | ${temp} |`);
+    }
+    lines.push("");
+  }
+  if (Object.keys(resolved.profiles).length > 0) {
+    lines.push("## Available Profiles");
+    lines.push("");
+    lines.push("| Profile | Description | Default Model |");
+    lines.push("| --- | --- | --- |");
+    for (const [name, profile] of Object.entries(resolved.profiles)) {
+      lines.push(`| ${name} | ${profile.description ?? "\u2014"} | ${profile.default ?? "\u2014"} |`);
+    }
+    lines.push("");
+  }
+  if (resolved.activeProfile) {
+    lines.push(`**Active profile**: \`${resolved.activeProfile}\``);
+    lines.push("");
+  }
+  if (resolved.routing.length > 0) {
+    lines.push("## Task-Aware Routing");
+    lines.push("");
+    lines.push("Select the appropriate profile based on the task context:");
+    lines.push("");
+    lines.push("| Condition | Profile | Description |");
+    lines.push("| --- | --- | --- |");
+    for (const rule of resolved.routing) {
+      const conditions = Object.entries(rule.when).map(([k, v]) => `${k}=${v}`).join(", ");
+      const desc = rule.description ?? "\u2014";
+      lines.push(`| ${conditions} | ${rule.use} | ${desc} |`);
+    }
+    lines.push("");
+    lines.push("### Condition Reference");
+    lines.push("");
+    lines.push("- **complexity**: low | medium | high | critical");
+    lines.push("- **urgency**: low | normal | high");
+    lines.push("- **budget**: minimal | standard | premium");
+    lines.push("- **contextWindowNeed**: small | medium | large | max");
+    lines.push("- **toolUseIntensity**: none | light | heavy");
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
 
 // src/targets/claude-code.ts
-import { resolve as resolve10, join as join11 } from "path";
+import { resolve as resolve9, join as join12 } from "path";
 var TARGET_ID3 = "claudecode";
 
 class ClaudeCodeTarget extends BaseTarget {
@@ -1624,18 +2099,19 @@ class ClaudeCodeTarget extends BaseTarget {
     "skills",
     "hooks",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve10(projectRoot, baseDir);
+    const root = resolve9(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const claudeDir = resolve10(root, ".claude");
+    const claudeDir = resolve9(root, ".claude");
     if (effective.includes("rules")) {
-      const rulesDir = resolve10(claudeDir, "rules");
+      const rulesDir = resolve9(claudeDir, "rules");
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -1648,32 +2124,41 @@ class ClaudeCodeTarget extends BaseTarget {
         const claudeMd = rootRules.map((r) => r.content).join(`
 
 `);
-        const filepath = resolve10(claudeDir, "CLAUDE.md");
+        const filepath = resolve9(claudeDir, "CLAUDE.md");
         writeGeneratedFile(filepath, claudeMd);
         filesWritten.push(filepath);
       }
       for (const rule of detailRules) {
-        const filepath = join11(rulesDir, `${rule.name}.md`);
+        const filepath = join12(rulesDir, `${rule.name}.md`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const agentsDir = resolve10(claudeDir, "agents");
+      const agentsDir = resolve9(claudeDir, "agents");
       if (deleteExisting) {
         removeIfExists(agentsDir);
         filesDeleted.push(agentsDir);
       }
       ensureDir(agentsDir);
+      const resolvedModels = features.models ? resolveModels(features.models, options.modelProfile, TARGET_ID3) : null;
       const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID3));
       for (const agent of agents) {
-        const filepath = join11(agentsDir, `${agent.name}.md`);
-        writeGeneratedFile(filepath, agent.content);
+        const filepath = join12(agentsDir, `${agent.name}.md`);
+        const cc = agent.meta.claudecode ?? {};
+        const modelsAgent = resolvedModels?.agents[agent.name];
+        const agentModel = modelsAgent?.model ?? cc.model;
+        let content = agent.content;
+        if (agentModel) {
+          content = `<!-- model: ${agentModel} -->
+${content}`;
+        }
+        writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillsDir = resolve10(claudeDir, "skills");
+      const skillsDir = resolve9(claudeDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1681,15 +2166,15 @@ class ClaudeCodeTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID3));
       for (const skill of skills) {
-        const skillSubDir = join11(skillsDir, skill.name);
+        const skillSubDir = join12(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join11(skillSubDir, "SKILL.md");
+        const filepath = join12(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve10(claudeDir, "commands");
+      const commandsDir = resolve9(claudeDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1697,15 +2182,26 @@ class ClaudeCodeTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID3));
       for (const cmd of commands) {
-        const filepath = join11(commandsDir, `${cmd.name}.md`);
+        const filepath = join12(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
     }
+    if (effective.includes("models") && features.models) {
+      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID3);
+      const guidance = generateModelGuidanceMarkdown(resolved);
+      if (guidance) {
+        const rulesDir = resolve9(claudeDir, "rules");
+        ensureDir(rulesDir);
+        const filepath = join12(rulesDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
     if (effective.includes("hooks") || effective.includes("mcp") || effective.includes("ignore")) {
       const settings = buildClaudeSettings(options, effective);
       if (Object.keys(settings).length > 0) {
-        const filepath = resolve10(claudeDir, "settings.json");
+        const filepath = resolve9(claudeDir, "settings.json");
         const existing = readJsonOrNull(filepath) ?? {};
         const merged = { ...existing, ...settings };
         writeGeneratedJson(filepath, merged, { header: false });
@@ -1762,7 +2258,7 @@ function toPascalCase(str) {
 }
 
 // src/targets/codex-cli.ts
-import { resolve as resolve11, join as join12 } from "path";
+import { resolve as resolve10, join as join13 } from "path";
 var TARGET_ID4 = "codexcli";
 
 class CodexCliTarget extends BaseTarget {
@@ -1771,14 +2267,14 @@ class CodexCliTarget extends BaseTarget {
   supportedFeatures = ["rules", "skills", "mcp", "hooks"];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve11(projectRoot, baseDir);
+    const root = resolve10(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const codexDir = resolve11(root, ".codex");
+    const codexDir = resolve10(root, ".codex");
     if (effective.includes("rules")) {
-      const memoriesDir = resolve11(codexDir, "memories");
+      const memoriesDir = resolve10(codexDir, "memories");
       if (deleteExisting) {
         removeIfExists(memoriesDir);
         filesDeleted.push(memoriesDir);
@@ -1786,13 +2282,13 @@ class CodexCliTarget extends BaseTarget {
       ensureDir(memoriesDir);
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID4));
       for (const rule of rules) {
-        const filepath = join12(memoriesDir, `${rule.name}.md`);
+        const filepath = join13(memoriesDir, `${rule.name}.md`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillsDir = resolve11(codexDir, "skills");
+      const skillsDir = resolve10(codexDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1800,9 +2296,9 @@ class CodexCliTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID4));
       for (const skill of skills) {
-        const skillSubDir = join12(skillsDir, skill.name);
+        const skillSubDir = join13(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join12(skillSubDir, "SKILL.md");
+        const filepath = join13(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
@@ -1812,7 +2308,7 @@ class CodexCliTarget extends BaseTarget {
 }
 
 // src/targets/gemini-cli.ts
-import { resolve as resolve12, join as join13 } from "path";
+import { resolve as resolve11, join as join14 } from "path";
 var TARGET_ID5 = "geminicli";
 
 class GeminiCliTarget extends BaseTarget {
@@ -1828,12 +2324,12 @@ class GeminiCliTarget extends BaseTarget {
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve12(projectRoot, baseDir);
+    const root = resolve11(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const geminiDir = resolve12(root, ".gemini");
+    const geminiDir = resolve11(root, ".gemini");
     if (effective.includes("rules")) {
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID5));
       const rootRules = getRootRules(rules);
@@ -1842,26 +2338,26 @@ class GeminiCliTarget extends BaseTarget {
         const geminiMd = rootRules.map((r) => r.content).join(`
 
 `);
-        const filepath = resolve12(root, "GEMINI.md");
+        const filepath = resolve11(root, "GEMINI.md");
         writeGeneratedFile(filepath, geminiMd);
         filesWritten.push(filepath);
       }
       if (detailRules.length > 0) {
-        const memoriesDir = resolve12(geminiDir, "memories");
+        const memoriesDir = resolve11(geminiDir, "memories");
         if (deleteExisting) {
           removeIfExists(memoriesDir);
           filesDeleted.push(memoriesDir);
         }
         ensureDir(memoriesDir);
         for (const rule of detailRules) {
-          const filepath = join13(memoriesDir, `${rule.name}.md`);
+          const filepath = join14(memoriesDir, `${rule.name}.md`);
           writeGeneratedFile(filepath, rule.content);
           filesWritten.push(filepath);
         }
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve12(geminiDir, "commands");
+      const commandsDir = resolve11(geminiDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1870,7 +2366,7 @@ class GeminiCliTarget extends BaseTarget {
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID5));
       for (const cmd of commands) {
         const toml = buildGeminiCommand(cmd.name, cmd.meta.description ?? "", cmd.content);
-        const filepath = join13(commandsDir, `${cmd.name}.toml`);
+        const filepath = join14(commandsDir, `${cmd.name}.toml`);
         writeGeneratedFile(filepath, toml, { type: "md" });
         filesWritten.push(filepath);
       }
@@ -1879,14 +2375,14 @@ class GeminiCliTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const settings = buildGeminiSettings(features.mcpServers);
-        const filepath = resolve12(geminiDir, "settings.json");
+        const filepath = resolve11(geminiDir, "settings.json");
         writeGeneratedJson(filepath, settings, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve12(root, ".geminiignore");
+        const filepath = resolve11(root, ".geminiignore");
         const content = features.ignorePatterns.join(`
 `) + `
 `;
@@ -1925,7 +2421,7 @@ function buildGeminiSettings(servers) {
 }
 
 // src/targets/copilot.ts
-import { resolve as resolve13, join as join14 } from "path";
+import { resolve as resolve12, join as join15 } from "path";
 var TARGET_ID6 = "copilot";
 
 class CopilotTarget extends BaseTarget {
@@ -1937,16 +2433,17 @@ class CopilotTarget extends BaseTarget {
     "agents",
     "skills",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve13(projectRoot, baseDir);
+    const root = resolve12(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const githubDir = resolve13(root, ".github");
+    const githubDir = resolve12(root, ".github");
     if (effective.includes("rules")) {
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID6));
       if (rules.length > 0) {
@@ -1955,15 +2452,15 @@ class CopilotTarget extends BaseTarget {
 ---
 
 `);
-        const filepath = resolve13(githubDir, "copilot-instructions.md");
+        const filepath = resolve12(githubDir, "copilot-instructions.md");
         ensureDir(githubDir);
         writeGeneratedFile(filepath, combinedContent);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const copilotDir = resolve13(githubDir, "copilot");
-      const agentsDir = resolve13(copilotDir, "agents");
+      const copilotDir = resolve12(githubDir, "copilot");
+      const agentsDir = resolve12(copilotDir, "agents");
       if (deleteExisting) {
         removeIfExists(agentsDir);
         filesDeleted.push(agentsDir);
@@ -1971,14 +2468,14 @@ class CopilotTarget extends BaseTarget {
       ensureDir(agentsDir);
       const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID6));
       for (const agent of agents) {
-        const filepath = join14(agentsDir, `${agent.name}.md`);
+        const filepath = join15(agentsDir, `${agent.name}.md`);
         writeGeneratedFile(filepath, agent.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const copilotDir = resolve13(githubDir, "copilot");
-      const skillsDir = resolve13(copilotDir, "skills");
+      const copilotDir = resolve12(githubDir, "copilot");
+      const skillsDir = resolve12(copilotDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1986,16 +2483,16 @@ class CopilotTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID6));
       for (const skill of skills) {
-        const skillSubDir = join14(skillsDir, skill.name);
+        const skillSubDir = join15(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join14(skillSubDir, "SKILL.md");
+        const filepath = join15(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const copilotDir = resolve13(githubDir, "copilot");
-      const commandsDir = resolve13(copilotDir, "commands");
+      const copilotDir = resolve12(githubDir, "copilot");
+      const commandsDir = resolve12(copilotDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -2003,25 +2500,36 @@ class CopilotTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID6));
       for (const cmd of commands) {
-        const filepath = join14(commandsDir, `${cmd.name}.md`);
+        const filepath = join15(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {}
+    if (effective.includes("models") && features.models) {
+      const resolved = resolveModels(features.models, options.modelProfile, TARGET_ID6);
+      const guidance = generateModelGuidanceMarkdown(resolved);
+      if (guidance) {
+        const copilotDir = resolve12(githubDir, "copilot");
+        ensureDir(copilotDir);
+        const filepath = join15(copilotDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
 
 // src/targets/agents-md.ts
-import { resolve as resolve14 } from "path";
+import { resolve as resolve13 } from "path";
 class AgentsMdTarget extends BaseTarget {
   id = "agentsmd";
   name = "AGENTS.md";
   supportedFeatures = ["rules"];
   generate(options) {
     const { projectRoot, baseDir, features } = options;
-    const root = resolve14(projectRoot, baseDir);
+    const root = resolve13(projectRoot, baseDir);
     const filesWritten = [];
     const warnings = [];
     const rootRules = getRootRules(features.rules);
@@ -2033,7 +2541,7 @@ class AgentsMdTarget extends BaseTarget {
     const content = sections.join(`
 
 `);
-    const filepath = resolve14(root, "AGENTS.md");
+    const filepath = resolve13(root, "AGENTS.md");
     writeGeneratedFile(filepath, content);
     filesWritten.push(filepath);
     return this.createResult(filesWritten, [], warnings);
@@ -2041,7 +2549,7 @@ class AgentsMdTarget extends BaseTarget {
 }
 
 // src/targets/generic-md-target.ts
-import { resolve as resolve15, join as join15 } from "path";
+import { resolve as resolve14, join as join16 } from "path";
 function createGenericMdTarget(config) {
   return new GenericMdTarget(config);
 }
@@ -2060,16 +2568,16 @@ class GenericMdTarget extends BaseTarget {
   }
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve15(projectRoot, baseDir);
+    const root = resolve14(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const configDir = resolve15(root, this.config.configDir);
+    const configDir = resolve14(root, this.config.configDir);
     const rulesSubDir = this.config.rulesDir ?? "rules";
     const ext = this.config.ruleExtension ?? ".md";
     if (effective.includes("rules")) {
-      const rulesDir = resolve15(configDir, rulesSubDir);
+      const rulesDir = resolve14(configDir, rulesSubDir);
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -2077,13 +2585,13 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(rulesDir);
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, this.id));
       for (const rule of rules) {
-        const filepath = join15(rulesDir, `${rule.name}${ext}`);
+        const filepath = join16(rulesDir, `${rule.name}${ext}`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve15(configDir, "commands");
+      const commandsDir = resolve14(configDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -2091,7 +2599,7 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, this.id));
       for (const cmd of commands) {
-        const filepath = join15(commandsDir, `${cmd.name}.md`);
+        const filepath = join16(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
@@ -2100,7 +2608,7 @@ class GenericMdTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const mcpDir = this.config.mcpInConfigDir ? configDir : root;
-        const filepath = resolve15(mcpDir, "mcp.json");
+        const filepath = resolve14(mcpDir, "mcp.json");
         writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
           header: false
         });
@@ -2109,13 +2617,23 @@ class GenericMdTarget extends BaseTarget {
     }
     if (effective.includes("ignore") && this.config.ignoreFile) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve15(root, this.config.ignoreFile);
+        const filepath = resolve14(root, this.config.ignoreFile);
         writeGeneratedFile(filepath, features.ignorePatterns.join(`
 `) + `
 `);
         filesWritten.push(filepath);
       }
     }
+    if (effective.includes("models") && features.models) {
+      const resolved = resolveModels(features.models, options.modelProfile, this.id);
+      const guidance = generateModelGuidanceMarkdown(resolved);
+      if (guidance) {
+        ensureDir(configDir);
+        const filepath = join16(configDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
@@ -2255,11 +2773,11 @@ function listTargetIds() {
 }
 
 // src/exporters/cursor-plugin.ts
-import { resolve as resolve16, join as join16 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve15, join as join17 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 function exportCursorPlugin(pack, outputDir) {
   const filesWritten = [];
-  const pluginDir = resolve16(outputDir, pack.manifest.name);
+  const pluginDir = resolve15(outputDir, pack.manifest.name);
   mkdirSync4(pluginDir, { recursive: true });
   const manifest = {
     name: pack.manifest.name,
@@ -2273,7 +2791,7 @@ function exportCursorPlugin(pack, outputDir) {
     manifest.tags = pack.manifest.tags;
   }
   if (pack.rules.length > 0) {
-    const rulesDir = join16(pluginDir, "rules");
+    const rulesDir = join17(pluginDir, "rules");
     ensureDir(rulesDir);
     manifest.rules = [];
     for (const rule of pack.rules) {
@@ -2286,14 +2804,14 @@ function exportCursorPlugin(pack, outputDir) {
       if (globs)
         fm.globs = globs;
       const filename = `${rule.name}.mdc`;
-      const filepath = join16(rulesDir, filename);
-      writeFileSync5(filepath, serializeFrontmatter(fm, rule.content));
+      const filepath = join17(rulesDir, filename);
+      writeFileSync4(filepath, serializeFrontmatter(fm, rule.content));
       filesWritten.push(filepath);
       manifest.rules.push(filename);
     }
   }
   if (pack.agents.length > 0) {
-    const agentsDir = join16(pluginDir, "agents");
+    const agentsDir = join17(pluginDir, "agents");
     ensureDir(agentsDir);
     manifest.agents = [];
     for (const agent of pack.agents) {
@@ -2302,61 +2820,61 @@ function exportCursorPlugin(pack, outputDir) {
         description: agent.meta.description ?? ""
       };
       const filename = `${agent.name}.md`;
-      const filepath = join16(agentsDir, filename);
-      writeFileSync5(filepath, serializeFrontmatter(fm, agent.content));
+      const filepath = join17(agentsDir, filename);
+      writeFileSync4(filepath, serializeFrontmatter(fm, agent.content));
       filesWritten.push(filepath);
       manifest.agents.push(filename);
     }
   }
   if (pack.skills.length > 0) {
-    const skillsDir = join16(pluginDir, "skills");
+    const skillsDir = join17(pluginDir, "skills");
     ensureDir(skillsDir);
     manifest.skills = [];
     for (const skill of pack.skills) {
-      const skillSubDir = join16(skillsDir, skill.name);
+      const skillSubDir = join17(skillsDir, skill.name);
       ensureDir(skillSubDir);
       const fm = {
         name: skill.name,
         description: skill.meta.description ?? ""
       };
-      const filepath = join16(skillSubDir, "SKILL.md");
-      writeFileSync5(filepath, serializeFrontmatter(fm, skill.content));
+      const filepath = join17(skillSubDir, "SKILL.md");
+      writeFileSync4(filepath, serializeFrontmatter(fm, skill.content));
       filesWritten.push(filepath);
       manifest.skills.push(skill.name);
     }
   }
   if (pack.commands.length > 0) {
-    const commandsDir = join16(pluginDir, "commands");
+    const commandsDir = join17(pluginDir, "commands");
     ensureDir(commandsDir);
     manifest.commands = [];
     for (const cmd of pack.commands) {
       const filename = `${cmd.name}.md`;
-      const filepath = join16(commandsDir, filename);
-      writeFileSync5(filepath, cmd.content);
+      const filepath = join17(commandsDir, filename);
+      writeFileSync4(filepath, cmd.content);
       filesWritten.push(filepath);
       manifest.commands.push(filename);
     }
   }
   if (pack.mcp && Object.keys(pack.mcp.servers).length > 0) {
     manifest.mcp = true;
-    const filepath = join16(pluginDir, "mcp.json");
-    writeFileSync5(filepath, JSON.stringify({ mcpServers: pack.mcp.servers }, null, 2) + `
+    const filepath = join17(pluginDir, "mcp.json");
+    writeFileSync4(filepath, JSON.stringify({ mcpServers: pack.mcp.servers }, null, 2) + `
 `);
     filesWritten.push(filepath);
   }
-  const manifestPath = join16(pluginDir, "manifest.json");
-  writeFileSync5(manifestPath, JSON.stringify(manifest, null, 2) + `
+  const manifestPath = join17(pluginDir, "manifest.json");
+  writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2) + `
 `);
   filesWritten.push(manifestPath);
   return { outputDir: pluginDir, filesWritten, manifest };
 }
 
 // src/importers/rulesync.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10, copyFileSync, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve17, join as join17, basename as basename6 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10, copyFileSync, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve16, join as join18, basename as basename6 } from "path";
 import { parse as parseJsonc2 } from "jsonc-parser";
 function importFromRulesync(projectRoot, outputPackDir) {
-  const rulesyncDir = resolve17(projectRoot, ".rulesync");
+  const rulesyncDir = resolve16(projectRoot, ".rulesync");
   const warnings = [];
   const filesImported = [];
   if (!existsSync10(rulesyncDir)) {
@@ -2367,79 +2885,79 @@ function importFromRulesync(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve17(projectRoot, "packs", "default");
+  const packDir = outputPackDir ?? resolve16(projectRoot, "packs", "default");
   ensureDir(packDir);
-  const rulesDir = resolve17(rulesyncDir, "rules");
+  const rulesDir = resolve16(rulesyncDir, "rules");
   if (existsSync10(rulesDir)) {
-    const outRulesDir = resolve17(packDir, "rules");
+    const outRulesDir = resolve16(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join17(outRulesDir, basename6(file));
+      const dest = join18(outRulesDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const commandsDir = resolve17(rulesyncDir, "commands");
+  const commandsDir = resolve16(rulesyncDir, "commands");
   if (existsSync10(commandsDir)) {
-    const outCommandsDir = resolve17(packDir, "commands");
+    const outCommandsDir = resolve16(packDir, "commands");
     ensureDir(outCommandsDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join17(outCommandsDir, basename6(file));
+      const dest = join18(outCommandsDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const subagentsDir = resolve17(rulesyncDir, "subagents");
+  const subagentsDir = resolve16(rulesyncDir, "subagents");
   if (existsSync10(subagentsDir)) {
-    const outAgentsDir = resolve17(packDir, "agents");
+    const outAgentsDir = resolve16(packDir, "agents");
     ensureDir(outAgentsDir);
     const files = listFiles(subagentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join17(outAgentsDir, basename6(file));
+      const dest = join18(outAgentsDir, basename6(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
-  const skillsDir = resolve17(rulesyncDir, "skills");
+  const skillsDir = resolve16(rulesyncDir, "skills");
   if (existsSync10(skillsDir)) {
-    const outSkillsDir = resolve17(packDir, "skills");
+    const outSkillsDir = resolve16(packDir, "skills");
     ensureDir(outSkillsDir);
     const skillDirs = listDirs(skillsDir);
     for (const skillDir of skillDirs) {
       const skillName = basename6(skillDir);
       if (skillName.startsWith("."))
         continue;
-      const skillMd = join17(skillDir, "SKILL.md");
+      const skillMd = join18(skillDir, "SKILL.md");
       if (existsSync10(skillMd)) {
-        const outSkillDir = join17(outSkillsDir, skillName);
+        const outSkillDir = join18(outSkillsDir, skillName);
         ensureDir(outSkillDir);
-        copyFileSync(skillMd, join17(outSkillDir, "SKILL.md"));
-        filesImported.push(join17(outSkillDir, "SKILL.md"));
+        copyFileSync(skillMd, join18(outSkillDir, "SKILL.md"));
+        filesImported.push(join18(outSkillDir, "SKILL.md"));
       }
     }
   }
-  const hooksJson = resolve17(rulesyncDir, "hooks.json");
+  const hooksJson = resolve16(rulesyncDir, "hooks.json");
   if (existsSync10(hooksJson)) {
-    const outHooksDir = resolve17(packDir, "hooks");
+    const outHooksDir = resolve16(packDir, "hooks");
     ensureDir(outHooksDir);
-    copyFileSync(hooksJson, join17(outHooksDir, "hooks.json"));
-    filesImported.push(join17(outHooksDir, "hooks.json"));
+    copyFileSync(hooksJson, join18(outHooksDir, "hooks.json"));
+    filesImported.push(join18(outHooksDir, "hooks.json"));
   }
-  const mcpJson = resolve17(rulesyncDir, "mcp.json");
+  const mcpJson = resolve16(rulesyncDir, "mcp.json");
   if (existsSync10(mcpJson)) {
-    copyFileSync(mcpJson, join17(packDir, "mcp.json"));
-    filesImported.push(join17(packDir, "mcp.json"));
+    copyFileSync(mcpJson, join18(packDir, "mcp.json"));
+    filesImported.push(join18(packDir, "mcp.json"));
   }
-  const aiIgnore = resolve17(rulesyncDir, ".aiignore");
-  const rulesyncIgnore = resolve17(projectRoot, ".rulesyncignore");
+  const aiIgnore = resolve16(rulesyncDir, ".aiignore");
+  const rulesyncIgnore = resolve16(projectRoot, ".rulesyncignore");
   if (existsSync10(aiIgnore)) {
-    copyFileSync(aiIgnore, join17(packDir, "ignore"));
-    filesImported.push(join17(packDir, "ignore"));
+    copyFileSync(aiIgnore, join18(packDir, "ignore"));
+    filesImported.push(join18(packDir, "ignore"));
   } else if (existsSync10(rulesyncIgnore)) {
-    copyFileSync(rulesyncIgnore, join17(packDir, "ignore"));
-    filesImported.push(join17(packDir, "ignore"));
+    copyFileSync(rulesyncIgnore, join18(packDir, "ignore"));
+    filesImported.push(join18(packDir, "ignore"));
   }
   const packJson = {
     name: "default",
@@ -2451,20 +2969,20 @@ function importFromRulesync(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  writeFileSync6(join17(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+  writeFileSync5(join18(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-  filesImported.push(join17(packDir, "pack.json"));
+  filesImported.push(join18(packDir, "pack.json"));
   let configGenerated = false;
-  const rulesyncConfig = resolve17(projectRoot, "rulesync.jsonc");
+  const rulesyncConfig = resolve16(projectRoot, "rulesync.jsonc");
   if (existsSync10(rulesyncConfig)) {
-    const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir, projectRoot);
-    const configPath = resolve17(projectRoot, "agentpacks.jsonc");
-    writeFileSync6(configPath, agentpacksConfig);
+    const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir);
+    const configPath = resolve16(projectRoot, "agentpacks.jsonc");
+    writeFileSync5(configPath, agentpacksConfig);
     configGenerated = true;
   }
   return { packDir, filesImported, warnings, configGenerated };
 }
-function convertRulesyncConfig(rulesyncPath, packDir, projectRoot) {
+function convertRulesyncConfig(rulesyncPath, _packDir) {
   const raw = readFileSync10(rulesyncPath, "utf-8");
   const parsed = parseJsonc2(raw);
   const targets = parsed.targets ?? ["opencode", "cursor", "claudecode"];
@@ -2472,7 +2990,7 @@ function convertRulesyncConfig(rulesyncPath, packDir, projectRoot) {
   const baseDirs = parsed.baseDirs ?? ["."];
   const global = parsed.global ?? false;
   const deleteVal = parsed.delete ?? true;
-  const relPackDir = "./" + join17("packs", "default");
+  const relPackDir = "./" + join18("packs", "default");
   const config = {
     $schema: "https://unpkg.com/agentpacks/schema.json",
     packs: [relPackDir],
@@ -2489,10 +3007,10 @@ function convertRulesyncConfig(rulesyncPath, packDir, projectRoot) {
 }
 
 // src/importers/cursor.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync7, copyFileSync as copyFileSync2 } from "fs";
-import { resolve as resolve18, join as join18, basename as basename7 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync6, copyFileSync as copyFileSync2 } from "fs";
+import { resolve as resolve17, join as join19, basename as basename7 } from "path";
 function importFromCursor(projectRoot, outputPackDir) {
-  const cursorDir = resolve18(projectRoot, ".cursor");
+  const cursorDir = resolve17(projectRoot, ".cursor");
   const warnings = [];
   const filesImported = [];
   if (!existsSync11(cursorDir)) {
@@ -2503,11 +3021,11 @@ function importFromCursor(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve18(projectRoot, "packs", "cursor-import");
+  const packDir = outputPackDir ?? resolve17(projectRoot, "packs", "cursor-import");
   ensureDir(packDir);
-  const rulesDir = resolve18(cursorDir, "rules");
+  const rulesDir = resolve17(cursorDir, "rules");
   if (existsSync11(rulesDir)) {
-    const outRulesDir = resolve18(packDir, "rules");
+    const outRulesDir = resolve17(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".mdc" });
     for (const file of files) {
@@ -2523,64 +3041,64 @@ function importFromCursor(projectRoot, outputPackDir) {
       meta.cursor = { ...data };
       const mdContent = buildAgentpacksRule(meta, content);
       const name = basename7(file, ".mdc");
-      const dest = join18(outRulesDir, `${name}.md`);
-      writeFileSync7(dest, mdContent);
+      const dest = join19(outRulesDir, `${name}.md`);
+      writeFileSync6(dest, mdContent);
       filesImported.push(dest);
     }
     const mdFiles = listFiles(rulesDir, { extension: ".md" });
     for (const file of mdFiles) {
-      const dest = join18(outRulesDir, basename7(file));
+      const dest = join19(outRulesDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const agentsDir = resolve18(cursorDir, "agents");
+  const agentsDir = resolve17(cursorDir, "agents");
   if (existsSync11(agentsDir)) {
-    const outDir = resolve18(packDir, "agents");
+    const outDir = resolve17(packDir, "agents");
     ensureDir(outDir);
     const files = listFiles(agentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join18(outDir, basename7(file));
+      const dest = join19(outDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const skillsDir = resolve18(cursorDir, "skills");
+  const skillsDir = resolve17(cursorDir, "skills");
   if (existsSync11(skillsDir)) {
-    const outDir = resolve18(packDir, "skills");
+    const outDir = resolve17(packDir, "skills");
     ensureDir(outDir);
     const dirs = listDirs(skillsDir);
     for (const dir of dirs) {
       const name = basename7(dir);
-      const skillMd = join18(dir, "SKILL.md");
+      const skillMd = join19(dir, "SKILL.md");
       if (existsSync11(skillMd)) {
-        const outSkillDir = join18(outDir, name);
+        const outSkillDir = join19(outDir, name);
         ensureDir(outSkillDir);
-        copyFileSync2(skillMd, join18(outSkillDir, "SKILL.md"));
-        filesImported.push(join18(outSkillDir, "SKILL.md"));
+        copyFileSync2(skillMd, join19(outSkillDir, "SKILL.md"));
+        filesImported.push(join19(outSkillDir, "SKILL.md"));
       }
     }
   }
-  const commandsDir = resolve18(cursorDir, "commands");
+  const commandsDir = resolve17(cursorDir, "commands");
   if (existsSync11(commandsDir)) {
-    const outDir = resolve18(packDir, "commands");
+    const outDir = resolve17(packDir, "commands");
     ensureDir(outDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join18(outDir, basename7(file));
+      const dest = join19(outDir, basename7(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
-  const mcpJson = resolve18(cursorDir, "mcp.json");
+  const mcpJson = resolve17(cursorDir, "mcp.json");
   if (existsSync11(mcpJson)) {
-    copyFileSync2(mcpJson, join18(packDir, "mcp.json"));
-    filesImported.push(join18(packDir, "mcp.json"));
+    copyFileSync2(mcpJson, join19(packDir, "mcp.json"));
+    filesImported.push(join19(packDir, "mcp.json"));
   }
-  const cursorIgnore = resolve18(projectRoot, ".cursorignore");
+  const cursorIgnore = resolve17(projectRoot, ".cursorignore");
   if (existsSync11(cursorIgnore)) {
-    copyFileSync2(cursorIgnore, join18(packDir, "ignore"));
-    filesImported.push(join18(packDir, "ignore"));
+    copyFileSync2(cursorIgnore, join19(packDir, "ignore"));
+    filesImported.push(join19(packDir, "ignore"));
   }
   writePackJson(packDir, "cursor-import", filesImported);
   return { packDir, filesImported, warnings, configGenerated: false };
@@ -2609,20 +3127,20 @@ function writePackJson(packDir, name, filesImported) {
     targets: "*",
     features: "*"
   };
-  const dest = join18(packDir, "pack.json");
-  writeFileSync7(dest, JSON.stringify(packJson, null, 2) + `
+  const dest = join19(packDir, "pack.json");
+  writeFileSync6(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
 }
 
 // src/importers/claude-code.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync8, copyFileSync as copyFileSync3 } from "fs";
-import { resolve as resolve19, join as join19, basename as basename8 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync7, copyFileSync as copyFileSync3 } from "fs";
+import { resolve as resolve18, join as join20, basename as basename8 } from "path";
 function importFromClaudeCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
-  const claudeDir = resolve19(projectRoot, ".claude");
-  const hasClaudeMd = existsSync12(resolve19(projectRoot, "CLAUDE.md"));
+  const claudeDir = resolve18(projectRoot, ".claude");
+  const hasClaudeMd = existsSync12(resolve18(projectRoot, "CLAUDE.md"));
   const hasClaudeDir = existsSync12(claudeDir);
   if (!hasClaudeMd && !hasClaudeDir) {
     return {
@@ -2632,12 +3150,12 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve19(projectRoot, "packs", "claude-import");
+  const packDir = outputPackDir ?? resolve18(projectRoot, "packs", "claude-import");
   ensureDir(packDir);
-  const rulesDir = resolve19(packDir, "rules");
+  const rulesDir = resolve18(packDir, "rules");
   ensureDir(rulesDir);
   if (hasClaudeMd) {
-    const raw = readFileSync12(resolve19(projectRoot, "CLAUDE.md"), "utf-8");
+    const raw = readFileSync12(resolve18(projectRoot, "CLAUDE.md"), "utf-8");
     const ruleContent = [
       "---",
       "root: true",
@@ -2647,21 +3165,21 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest = join19(rulesDir, "claude-root.md");
-    writeFileSync8(dest, ruleContent);
+    const dest = join20(rulesDir, "claude-root.md");
+    writeFileSync7(dest, ruleContent);
     filesImported.push(dest);
   }
   if (hasClaudeDir) {
-    const claudeRulesDir = resolve19(claudeDir, "rules");
+    const claudeRulesDir = resolve18(claudeDir, "rules");
     if (existsSync12(claudeRulesDir)) {
       const files = listFiles(claudeRulesDir, { extension: ".md" });
       for (const file of files) {
-        const dest = join19(rulesDir, basename8(file));
+        const dest = join20(rulesDir, basename8(file));
         copyFileSync3(file, dest);
         filesImported.push(dest);
       }
     }
-    const settingsPath = resolve19(claudeDir, "settings.json");
+    const settingsPath = resolve18(claudeDir, "settings.json");
     if (existsSync12(settingsPath)) {
       try {
         const raw = readFileSync12(settingsPath, "utf-8");
@@ -2669,8 +3187,8 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
         const mcpServers = settings.mcpServers ?? settings.mcp_servers;
         if (mcpServers && typeof mcpServers === "object") {
           const mcpConfig = { servers: mcpServers };
-          const dest = join19(packDir, "mcp.json");
-          writeFileSync8(dest, JSON.stringify(mcpConfig, null, 2) + `
+          const dest = join20(packDir, "mcp.json");
+          writeFileSync7(dest, JSON.stringify(mcpConfig, null, 2) + `
 `);
           filesImported.push(dest);
         }
@@ -2689,20 +3207,20 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const packJsonPath = join19(packDir, "pack.json");
-  writeFileSync8(packJsonPath, JSON.stringify(packJson, null, 2) + `
+  const packJsonPath = join20(packDir, "pack.json");
+  writeFileSync7(packJsonPath, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(packJsonPath);
   return { packDir, filesImported, warnings, configGenerated: false };
 }
 
 // src/importers/opencode.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync9, copyFileSync as copyFileSync4 } from "fs";
-import { resolve as resolve20, join as join20, basename as basename9 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync8, copyFileSync as copyFileSync4 } from "fs";
+import { resolve as resolve19, join as join21, basename as basename9 } from "path";
 function importFromOpenCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
-  const ocDir = resolve20(projectRoot, ".opencode");
+  const ocDir = resolve19(projectRoot, ".opencode");
   if (!existsSync13(ocDir)) {
     return {
       packDir: "",
@@ -2711,45 +3229,45 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       configGenerated: false
     };
   }
-  const packDir = outputPackDir ?? resolve20(projectRoot, "packs", "opencode-import");
+  const packDir = outputPackDir ?? resolve19(projectRoot, "packs", "opencode-import");
   ensureDir(packDir);
-  importDirMd(resolve20(ocDir, "rules"), resolve20(packDir, "rules"), filesImported);
-  importDirMd(resolve20(ocDir, "commands"), resolve20(packDir, "commands"), filesImported);
-  importDirMd(resolve20(ocDir, "agents"), resolve20(packDir, "agents"), filesImported);
-  const skillDir = resolve20(ocDir, "skill");
+  importDirMd(resolve19(ocDir, "rules"), resolve19(packDir, "rules"), filesImported);
+  importDirMd(resolve19(ocDir, "commands"), resolve19(packDir, "commands"), filesImported);
+  importDirMd(resolve19(ocDir, "agents"), resolve19(packDir, "agents"), filesImported);
+  const skillDir = resolve19(ocDir, "skill");
   if (existsSync13(skillDir)) {
-    const outSkillDir = resolve20(packDir, "skills");
+    const outSkillDir = resolve19(packDir, "skills");
     ensureDir(outSkillDir);
     const dirs = listDirs(skillDir);
     for (const dir of dirs) {
       const name = basename9(dir);
       if (name.startsWith("."))
         continue;
-      const skillMd = join20(dir, "SKILL.md");
+      const skillMd = join21(dir, "SKILL.md");
       if (existsSync13(skillMd)) {
-        const outDir = join20(outSkillDir, name);
+        const outDir = join21(outSkillDir, name);
         ensureDir(outDir);
-        copyFileSync4(skillMd, join20(outDir, "SKILL.md"));
-        filesImported.push(join20(outDir, "SKILL.md"));
+        copyFileSync4(skillMd, join21(outDir, "SKILL.md"));
+        filesImported.push(join21(outDir, "SKILL.md"));
       }
     }
   }
-  const pluginsDir = resolve20(ocDir, "plugins");
+  const pluginsDir = resolve19(ocDir, "plugins");
   if (existsSync13(pluginsDir)) {
-    const outPluginsDir = resolve20(packDir, "plugins");
+    const outPluginsDir = resolve19(packDir, "plugins");
     ensureDir(outPluginsDir);
     const files = listFiles(pluginsDir);
     for (const file of files) {
       if (file.endsWith(".ts") || file.endsWith(".js")) {
-        const dest2 = join20(outPluginsDir, basename9(file));
+        const dest2 = join21(outPluginsDir, basename9(file));
         copyFileSync4(file, dest2);
         filesImported.push(dest2);
       }
     }
   }
-  const agentsMd = resolve20(projectRoot, "AGENTS.md");
+  const agentsMd = resolve19(projectRoot, "AGENTS.md");
   if (existsSync13(agentsMd)) {
-    const outRulesDir = resolve20(packDir, "rules");
+    const outRulesDir = resolve19(packDir, "rules");
     ensureDir(outRulesDir);
     const raw = readFileSync13(agentsMd, "utf-8");
     const ruleContent = [
@@ -2761,19 +3279,19 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest2 = join20(outRulesDir, "agents-md-root.md");
-    writeFileSync9(dest2, ruleContent);
+    const dest2 = join21(outRulesDir, "agents-md-root.md");
+    writeFileSync8(dest2, ruleContent);
     filesImported.push(dest2);
   }
-  const ocJson = resolve20(projectRoot, "opencode.json");
+  const ocJson = resolve19(projectRoot, "opencode.json");
   if (existsSync13(ocJson)) {
     try {
       const raw = readFileSync13(ocJson, "utf-8");
       const config = JSON.parse(raw);
       const mcpObj = config.mcp;
       if (mcpObj) {
-        const dest2 = join20(packDir, "mcp.json");
-        writeFileSync9(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
+        const dest2 = join21(packDir, "mcp.json");
+        writeFileSync8(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
 `);
         filesImported.push(dest2);
       }
@@ -2781,10 +3299,10 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       warnings.push("Failed to parse opencode.json");
     }
   }
-  const ocIgnore = resolve20(projectRoot, ".opencodeignore");
+  const ocIgnore = resolve19(projectRoot, ".opencodeignore");
   if (existsSync13(ocIgnore)) {
-    copyFileSync4(ocIgnore, join20(packDir, "ignore"));
-    filesImported.push(join20(packDir, "ignore"));
+    copyFileSync4(ocIgnore, join21(packDir, "ignore"));
+    filesImported.push(join21(packDir, "ignore"));
   }
   const packJson = {
     name: "opencode-import",
@@ -2796,8 +3314,8 @@ function importFromOpenCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const dest = join20(packDir, "pack.json");
-  writeFileSync9(dest, JSON.stringify(packJson, null, 2) + `
+  const dest = join21(packDir, "pack.json");
+  writeFileSync8(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
   return { packDir, filesImported, warnings, configGenerated: false };
@@ -2808,26 +3326,28 @@ function importDirMd(srcDir, outDir, filesImported) {
   ensureDir(outDir);
   const files = listFiles(srcDir, { extension: ".md" });
   for (const file of files) {
-    const dest = join20(outDir, basename9(file));
+    const dest = join21(outDir, basename9(file));
     copyFileSync4(file, dest);
     filesImported.push(dest);
   }
 }
-
-// src/api.ts
-init_config();
 export {
   saveLockfile,
   resolveTargets,
+  resolveModels,
   resolveLocalPack,
   resolveFeatures,
   resolveDependencies,
+  resolveAgentModel,
+  registrySourceKey,
+  parseRegistrySourceRef,
   parseNpmSourceRef,
   parseGitSourceRef,
   loadWorkspaceConfig,
   loadPackManifest,
   loadLockfile,
   listTargetIds,
+  isRegistryPackRef,
   isNpmPackRef,
   isLocalPackRef,
   isGitPackRef,