agentpacks 0.3.0 → 0.4.0

package/dist/node/cli/generate.js

@@ -1,51 +1,85 @@
 import { createRequire } from "node:module";
-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 = /* @__PURE__ */ createRequire(import.meta.url);
 
 // 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,6 +880,118 @@ 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/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(" → ")}`);
+  }
+  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/targets/base-target.ts
@@ -792,7 +1038,7 @@ ${content}`;
 }
 
 // src/targets/opencode.ts
-import { resolve as resolve4, join as join7 } from "path";
+import { resolve as resolve3, join as join8 } from "path";
 var TARGET_ID = "opencode";
 
 class OpenCodeTarget extends BaseTarget {
@@ -806,32 +1052,48 @@ class OpenCodeTarget extends BaseTarget {
     "hooks",
     "plugins",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve4(projectRoot, baseDir);
+    const root = resolve3(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const opencodeDir = resolve4(root, ".opencode");
+    const opencodeDir = resolve3(root, ".opencode");
     if (effective.includes("agents")) {
-      const agentDir = resolve4(opencodeDir, "agent");
+      const agentDir = resolve3(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 = join7(agentDir, `${agent.name}.md`);
-        writeGeneratedFile(filepath, agent.content);
+        const filepath = join8(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 = resolve4(opencodeDir, "skill");
+      const skillDir = resolve3(opencodeDir, "skill");
       if (deleteExisting) {
         removeIfExists(skillDir);
         filesDeleted.push(skillDir);
@@ -839,15 +1101,15 @@ class OpenCodeTarget extends BaseTarget {
       ensureDir(skillDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID));
       for (const skill of skills) {
-        const skillSubDir = join7(skillDir, skill.name);
+        const skillSubDir = join8(skillDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join7(skillSubDir, "SKILL.md");
+        const filepath = join8(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const cmdDir = resolve4(opencodeDir, "command");
+      const cmdDir = resolve3(opencodeDir, "command");
       if (deleteExisting) {
         removeIfExists(cmdDir);
         filesDeleted.push(cmdDir);
@@ -855,19 +1117,19 @@ class OpenCodeTarget extends BaseTarget {
       ensureDir(cmdDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID));
       for (const cmd of commands) {
-        const filepath = join7(cmdDir, `${cmd.name}.md`);
+        const filepath = join8(cmdDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("hooks") || effective.includes("plugins")) {
-      const pluginsDir = resolve4(opencodeDir, "plugins");
+      const pluginsDir = resolve3(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 = join7(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
+            const filepath = join8(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
             const content = generateOpenCodeHookPlugin(hookSet.packName, events);
             writeGeneratedFile(filepath, content, { type: "ts" });
             filesWritten.push(filepath);
@@ -876,7 +1138,7 @@ class OpenCodeTarget extends BaseTarget {
       }
       if (effective.includes("plugins")) {
         for (const plugin of features.plugins) {
-          const filepath = join7(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
+          const filepath = join8(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
           writeGeneratedFile(filepath, plugin.content, {
             type: plugin.extension
           });
@@ -884,28 +1146,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 = resolve4(root, "opencode.json");
+    if (effective.includes("mcp") || effective.includes("models")) {
+      const filepath = resolve3(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 = resolve4(opencodeDir, "memories");
+        const memoriesDir = resolve3(opencodeDir, "memories");
         if (deleteExisting) {
           removeIfExists(memoriesDir);
           filesDeleted.push(memoriesDir);
         }
         ensureDir(memoriesDir);
         for (const rule of detailRules) {
-          const filepath = join7(memoriesDir, `${rule.name}.md`);
+          const filepath = join8(memoriesDir, `${rule.name}.md`);
           writeGeneratedFile(filepath, rule.content);
           filesWritten.push(filepath);
         }
@@ -914,7 +1207,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) {
@@ -934,10 +1227,7 @@ function buildOpenCodeMcp(servers) {
       };
     }
   }
-  return {
-    $schema: "https://opencode.ai/config.json",
-    mcp
-  };
+  return mcp;
 }
 function generateOpenCodeHookPlugin(packName, events) {
   const identifier = packNameToIdentifier(packName);
@@ -984,7 +1274,7 @@ function mapHookEvents(events) {
 }
 
 // src/targets/cursor.ts
-import { resolve as resolve5, join as join8 } from "path";
+import { resolve as resolve4, join as join9 } from "path";
 var TARGET_ID2 = "cursor";
 
 class CursorTarget extends BaseTarget {
@@ -997,18 +1287,19 @@ class CursorTarget extends BaseTarget {
     "skills",
     "hooks",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve5(projectRoot, baseDir);
+    const root = resolve4(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const cursorDir = resolve5(root, ".cursor");
+    const cursorDir = resolve4(root, ".cursor");
     if (effective.includes("rules")) {
-      const rulesDir = resolve5(cursorDir, "rules");
+      const rulesDir = resolve4(cursorDir, "rules");
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -1025,33 +1316,40 @@ class CursorTarget extends BaseTarget {
         if (globs) {
           frontmatter.globs = globs;
         }
-        const filepath = join8(rulesDir, `${rule.name}.mdc`);
+        const filepath = join9(rulesDir, `${rule.name}.mdc`);
         const content = serializeFrontmatter(frontmatter, rule.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const agentsDir = resolve5(cursorDir, "agents");
+      const agentsDir = resolve4(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 = join8(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 = join9(agentsDir, `${agent.name}.md`);
         const content = serializeFrontmatter(frontmatter, agent.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillsDir = resolve5(cursorDir, "skills");
+      const skillsDir = resolve4(cursorDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1059,20 +1357,20 @@ class CursorTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID2));
       for (const skill of skills) {
-        const skillSubDir = join8(skillsDir, skill.name);
+        const skillSubDir = join9(skillsDir, skill.name);
         ensureDir(skillSubDir);
         const frontmatter = {
           name: skill.name,
           description: skill.meta.description ?? ""
         };
-        const filepath = join8(skillSubDir, "SKILL.md");
+        const filepath = join9(skillSubDir, "SKILL.md");
         const content = serializeFrontmatter(frontmatter, skill.content);
         writeGeneratedFile(filepath, content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve5(cursorDir, "commands");
+      const commandsDir = resolve4(cursorDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1080,7 +1378,7 @@ class CursorTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID2));
       for (const cmd of commands) {
-        const filepath = join8(commandsDir, `${cmd.name}.md`);
+        const filepath = join9(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
@@ -1089,14 +1387,14 @@ class CursorTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const mcpConfig = buildCursorMcp(features.mcpServers);
-        const filepath = resolve5(cursorDir, "mcp.json");
+        const filepath = resolve4(cursorDir, "mcp.json");
         writeGeneratedJson(filepath, mcpConfig, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve5(root, ".cursorignore");
+        const filepath = resolve4(root, ".cursorignore");
         const content = features.ignorePatterns.join(`
 `) + `
 `;
@@ -1104,6 +1402,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 = resolve4(cursorDir, "rules");
+        ensureDir(rulesDir);
+        const filepath = join9(rulesDir, "model-config.mdc");
+        writeGeneratedFile(filepath, guidanceContent, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
@@ -1122,9 +1431,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) : "—";
+      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 ?? "—"} | ${profile.default ?? "—"} |`);
+    }
+    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) : "—";
+      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 ?? "—"} | ${profile.default ?? "—"} |`);
+    }
+    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 ?? "—";
+      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 resolve6, join as join9 } from "path";
+import { resolve as resolve5, join as join10 } from "path";
 var TARGET_ID3 = "claudecode";
 
 class ClaudeCodeTarget extends BaseTarget {
@@ -1137,18 +1572,19 @@ class ClaudeCodeTarget extends BaseTarget {
     "skills",
     "hooks",
     "mcp",
-    "ignore"
+    "ignore",
+    "models"
   ];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve6(projectRoot, baseDir);
+    const root = resolve5(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const claudeDir = resolve6(root, ".claude");
+    const claudeDir = resolve5(root, ".claude");
     if (effective.includes("rules")) {
-      const rulesDir = resolve6(claudeDir, "rules");
+      const rulesDir = resolve5(claudeDir, "rules");
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -1161,32 +1597,41 @@ class ClaudeCodeTarget extends BaseTarget {
         const claudeMd = rootRules.map((r) => r.content).join(`
 
 `);
-        const filepath = resolve6(claudeDir, "CLAUDE.md");
+        const filepath = resolve5(claudeDir, "CLAUDE.md");
         writeGeneratedFile(filepath, claudeMd);
         filesWritten.push(filepath);
       }
       for (const rule of detailRules) {
-        const filepath = join9(rulesDir, `${rule.name}.md`);
+        const filepath = join10(rulesDir, `${rule.name}.md`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const agentsDir = resolve6(claudeDir, "agents");
+      const agentsDir = resolve5(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 = join9(agentsDir, `${agent.name}.md`);
-        writeGeneratedFile(filepath, agent.content);
+        const filepath = join10(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 = resolve6(claudeDir, "skills");
+      const skillsDir = resolve5(claudeDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1194,15 +1639,15 @@ class ClaudeCodeTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID3));
       for (const skill of skills) {
-        const skillSubDir = join9(skillsDir, skill.name);
+        const skillSubDir = join10(skillsDir, 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 commandsDir = resolve6(claudeDir, "commands");
+      const commandsDir = resolve5(claudeDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1210,15 +1655,26 @@ class ClaudeCodeTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID3));
       for (const cmd of commands) {
-        const filepath = join9(commandsDir, `${cmd.name}.md`);
+        const filepath = join10(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 = resolve5(claudeDir, "rules");
+        ensureDir(rulesDir);
+        const filepath = join10(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 = resolve6(claudeDir, "settings.json");
+        const filepath = resolve5(claudeDir, "settings.json");
         const existing = readJsonOrNull(filepath) ?? {};
         const merged = { ...existing, ...settings };
         writeGeneratedJson(filepath, merged, { header: false });
@@ -1275,7 +1731,7 @@ function toPascalCase(str) {
 }
 
 // src/targets/codex-cli.ts
-import { resolve as resolve7, join as join10 } from "path";
+import { resolve as resolve6, join as join11 } from "path";
 var TARGET_ID4 = "codexcli";
 
 class CodexCliTarget extends BaseTarget {
@@ -1284,14 +1740,14 @@ class CodexCliTarget extends BaseTarget {
   supportedFeatures = ["rules", "skills", "mcp", "hooks"];
   generate(options) {
     const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
-    const root = resolve7(projectRoot, baseDir);
+    const root = resolve6(projectRoot, baseDir);
     const effective = this.getEffectiveFeatures(enabledFeatures);
     const filesWritten = [];
     const filesDeleted = [];
     const warnings = [];
-    const codexDir = resolve7(root, ".codex");
+    const codexDir = resolve6(root, ".codex");
     if (effective.includes("rules")) {
-      const memoriesDir = resolve7(codexDir, "memories");
+      const memoriesDir = resolve6(codexDir, "memories");
       if (deleteExisting) {
         removeIfExists(memoriesDir);
         filesDeleted.push(memoriesDir);
@@ -1299,13 +1755,13 @@ class CodexCliTarget extends BaseTarget {
       ensureDir(memoriesDir);
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID4));
       for (const rule of rules) {
-        const filepath = join10(memoriesDir, `${rule.name}.md`);
+        const filepath = join11(memoriesDir, `${rule.name}.md`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const skillsDir = resolve7(codexDir, "skills");
+      const skillsDir = resolve6(codexDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1313,9 +1769,9 @@ class CodexCliTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID4));
       for (const skill of skills) {
-        const skillSubDir = join10(skillsDir, skill.name);
+        const skillSubDir = join11(skillsDir, skill.name);
         ensureDir(skillSubDir);
-        const filepath = join10(skillSubDir, "SKILL.md");
+        const filepath = join11(skillSubDir, "SKILL.md");
         writeGeneratedFile(filepath, skill.content);
         filesWritten.push(filepath);
       }
@@ -1325,7 +1781,7 @@ class CodexCliTarget extends BaseTarget {
 }
 
 // src/targets/gemini-cli.ts
-import { resolve as resolve8, join as join11 } from "path";
+import { resolve as resolve7, join as join12 } from "path";
 var TARGET_ID5 = "geminicli";
 
 class GeminiCliTarget extends BaseTarget {
@@ -1341,12 +1797,12 @@ class GeminiCliTarget extends BaseTarget {
   ];
   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 geminiDir = resolve8(root, ".gemini");
+    const geminiDir = resolve7(root, ".gemini");
     if (effective.includes("rules")) {
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID5));
       const rootRules = getRootRules(rules);
@@ -1355,26 +1811,26 @@ class GeminiCliTarget extends BaseTarget {
         const geminiMd = rootRules.map((r) => r.content).join(`
 
 `);
-        const filepath = resolve8(root, "GEMINI.md");
+        const filepath = resolve7(root, "GEMINI.md");
         writeGeneratedFile(filepath, geminiMd);
         filesWritten.push(filepath);
       }
       if (detailRules.length > 0) {
-        const memoriesDir = resolve8(geminiDir, "memories");
+        const memoriesDir = resolve7(geminiDir, "memories");
         if (deleteExisting) {
           removeIfExists(memoriesDir);
           filesDeleted.push(memoriesDir);
         }
         ensureDir(memoriesDir);
         for (const rule of detailRules) {
-          const filepath = join11(memoriesDir, `${rule.name}.md`);
+          const filepath = join12(memoriesDir, `${rule.name}.md`);
           writeGeneratedFile(filepath, rule.content);
           filesWritten.push(filepath);
         }
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve8(geminiDir, "commands");
+      const commandsDir = resolve7(geminiDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1383,7 +1839,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 = join11(commandsDir, `${cmd.name}.toml`);
+        const filepath = join12(commandsDir, `${cmd.name}.toml`);
         writeGeneratedFile(filepath, toml, { type: "md" });
         filesWritten.push(filepath);
       }
@@ -1392,14 +1848,14 @@ class GeminiCliTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const settings = buildGeminiSettings(features.mcpServers);
-        const filepath = resolve8(geminiDir, "settings.json");
+        const filepath = resolve7(geminiDir, "settings.json");
         writeGeneratedJson(filepath, settings, { header: false });
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("ignore")) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve8(root, ".geminiignore");
+        const filepath = resolve7(root, ".geminiignore");
         const content = features.ignorePatterns.join(`
 `) + `
 `;
@@ -1438,7 +1894,7 @@ function buildGeminiSettings(servers) {
 }
 
 // src/targets/copilot.ts
-import { resolve as resolve9, join as join12 } from "path";
+import { resolve as resolve8, join as join13 } from "path";
 var TARGET_ID6 = "copilot";
 
 class CopilotTarget extends BaseTarget {
@@ -1450,16 +1906,17 @@ class CopilotTarget extends BaseTarget {
     "agents",
     "skills",
     "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 githubDir = resolve9(root, ".github");
+    const githubDir = resolve8(root, ".github");
     if (effective.includes("rules")) {
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID6));
       if (rules.length > 0) {
@@ -1468,15 +1925,15 @@ class CopilotTarget extends BaseTarget {
 ---
 
 `);
-        const filepath = resolve9(githubDir, "copilot-instructions.md");
+        const filepath = resolve8(githubDir, "copilot-instructions.md");
         ensureDir(githubDir);
         writeGeneratedFile(filepath, combinedContent);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("agents")) {
-      const copilotDir = resolve9(githubDir, "copilot");
-      const agentsDir = resolve9(copilotDir, "agents");
+      const copilotDir = resolve8(githubDir, "copilot");
+      const agentsDir = resolve8(copilotDir, "agents");
       if (deleteExisting) {
         removeIfExists(agentsDir);
         filesDeleted.push(agentsDir);
@@ -1484,14 +1941,14 @@ class CopilotTarget extends BaseTarget {
       ensureDir(agentsDir);
       const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID6));
       for (const agent of agents) {
-        const filepath = join12(agentsDir, `${agent.name}.md`);
+        const filepath = join13(agentsDir, `${agent.name}.md`);
         writeGeneratedFile(filepath, agent.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("skills")) {
-      const copilotDir = resolve9(githubDir, "copilot");
-      const skillsDir = resolve9(copilotDir, "skills");
+      const copilotDir = resolve8(githubDir, "copilot");
+      const skillsDir = resolve8(copilotDir, "skills");
       if (deleteExisting) {
         removeIfExists(skillsDir);
         filesDeleted.push(skillsDir);
@@ -1499,16 +1956,16 @@ class CopilotTarget extends BaseTarget {
       ensureDir(skillsDir);
       const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID6));
       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);
       }
     }
     if (effective.includes("commands")) {
-      const copilotDir = resolve9(githubDir, "copilot");
-      const commandsDir = resolve9(copilotDir, "commands");
+      const copilotDir = resolve8(githubDir, "copilot");
+      const commandsDir = resolve8(copilotDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1516,25 +1973,36 @@ class CopilotTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID6));
       for (const cmd of commands) {
-        const filepath = join12(commandsDir, `${cmd.name}.md`);
+        const filepath = join13(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 = resolve8(githubDir, "copilot");
+        ensureDir(copilotDir);
+        const filepath = join13(copilotDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
 
 // src/targets/agents-md.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve9 } from "path";
 class AgentsMdTarget extends BaseTarget {
   id = "agentsmd";
   name = "AGENTS.md";
   supportedFeatures = ["rules"];
   generate(options) {
     const { projectRoot, baseDir, features } = options;
-    const root = resolve10(projectRoot, baseDir);
+    const root = resolve9(projectRoot, baseDir);
     const filesWritten = [];
     const warnings = [];
     const rootRules = getRootRules(features.rules);
@@ -1546,7 +2014,7 @@ class AgentsMdTarget extends BaseTarget {
     const content = sections.join(`
 
 `);
-    const filepath = resolve10(root, "AGENTS.md");
+    const filepath = resolve9(root, "AGENTS.md");
     writeGeneratedFile(filepath, content);
     filesWritten.push(filepath);
     return this.createResult(filesWritten, [], warnings);
@@ -1554,7 +2022,7 @@ class AgentsMdTarget extends BaseTarget {
 }
 
 // src/targets/generic-md-target.ts
-import { resolve as resolve11, join as join13 } from "path";
+import { resolve as resolve10, join as join14 } from "path";
 function createGenericMdTarget(config) {
   return new GenericMdTarget(config);
 }
@@ -1573,16 +2041,16 @@ class GenericMdTarget extends BaseTarget {
   }
   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 configDir = resolve11(root, this.config.configDir);
+    const configDir = resolve10(root, this.config.configDir);
     const rulesSubDir = this.config.rulesDir ?? "rules";
     const ext = this.config.ruleExtension ?? ".md";
     if (effective.includes("rules")) {
-      const rulesDir = resolve11(configDir, rulesSubDir);
+      const rulesDir = resolve10(configDir, rulesSubDir);
       if (deleteExisting) {
         removeIfExists(rulesDir);
         filesDeleted.push(rulesDir);
@@ -1590,13 +2058,13 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(rulesDir);
       const rules = features.rules.filter((r) => ruleMatchesTarget(r, this.id));
       for (const rule of rules) {
-        const filepath = join13(rulesDir, `${rule.name}${ext}`);
+        const filepath = join14(rulesDir, `${rule.name}${ext}`);
         writeGeneratedFile(filepath, rule.content);
         filesWritten.push(filepath);
       }
     }
     if (effective.includes("commands")) {
-      const commandsDir = resolve11(configDir, "commands");
+      const commandsDir = resolve10(configDir, "commands");
       if (deleteExisting) {
         removeIfExists(commandsDir);
         filesDeleted.push(commandsDir);
@@ -1604,7 +2072,7 @@ class GenericMdTarget extends BaseTarget {
       ensureDir(commandsDir);
       const commands = features.commands.filter((c) => commandMatchesTarget(c, this.id));
       for (const cmd of commands) {
-        const filepath = join13(commandsDir, `${cmd.name}.md`);
+        const filepath = join14(commandsDir, `${cmd.name}.md`);
         writeGeneratedFile(filepath, cmd.content);
         filesWritten.push(filepath);
       }
@@ -1613,7 +2081,7 @@ class GenericMdTarget extends BaseTarget {
       const mcpEntries = Object.entries(features.mcpServers);
       if (mcpEntries.length > 0) {
         const mcpDir = this.config.mcpInConfigDir ? configDir : root;
-        const filepath = resolve11(mcpDir, "mcp.json");
+        const filepath = resolve10(mcpDir, "mcp.json");
         writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
           header: false
         });
@@ -1622,13 +2090,23 @@ class GenericMdTarget extends BaseTarget {
     }
     if (effective.includes("ignore") && this.config.ignoreFile) {
       if (features.ignorePatterns.length > 0) {
-        const filepath = resolve11(root, this.config.ignoreFile);
+        const filepath = resolve10(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 = join14(configDir, "model-config.md");
+        writeGeneratedFile(filepath, guidance);
+        filesWritten.push(filepath);
+      }
+    }
     return this.createResult(filesWritten, filesDeleted, warnings);
   }
 }
@@ -1822,14 +2300,29 @@ function findHunks(oldLines, newLines) {
   let ni = 0;
   while (oi < oldLines.length || ni < newLines.length) {
     if (oi < oldLines.length && ni < newLines.length && oldLines[oi] === newLines[ni]) {
-      changes.push({ type: " ", line: oldLines[oi], oldIdx: oi, newIdx: ni });
+      changes.push({
+        type: " ",
+        line: oldLines[oi] ?? "",
+        oldIdx: oi,
+        newIdx: ni
+      });
       oi++;
       ni++;
-    } else if (ni < newLines.length && (oi >= oldLines.length || !newLines.slice(ni).includes(oldLines[oi]))) {
-      changes.push({ type: "+", line: newLines[ni], oldIdx: oi, newIdx: ni });
+    } else if (ni < newLines.length && (oi >= oldLines.length || !newLines.slice(ni).includes(oldLines[oi] ?? ""))) {
+      changes.push({
+        type: "+",
+        line: newLines[ni] ?? "",
+        oldIdx: oi,
+        newIdx: ni
+      });
       ni++;
     } else {
-      changes.push({ type: "-", line: oldLines[oi], oldIdx: oi, newIdx: oi });
+      changes.push({
+        type: "-",
+        line: oldLines[oi] ?? "",
+        oldIdx: oi,
+        newIdx: oi
+      });
       oi++;
     }
   }
@@ -1858,8 +2351,9 @@ function findHunks(oldLines, newLines) {
           lines: []
         };
         for (let i = contextStart;i < changes.indexOf(change); i++) {
-          if (changes[i].type === " ") {
-            currentHunk.lines.push(` ${changes[i].line}`);
+          const entry = changes[i];
+          if (entry?.type === " ") {
+            currentHunk.lines.push(` ${entry.line}`);
             currentHunk.oldCount++;
             currentHunk.newCount++;
           }
@@ -1879,7 +2373,6 @@ function findHunks(oldLines, newLines) {
 }
 
 // src/cli/generate.ts
-init_config();
 import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
 import chalk from "chalk";
 function runGenerate(projectRoot, options) {
@@ -1950,9 +2443,9 @@ function runGenerate(projectRoot, options) {
         enabledFeatures,
         deleteExisting: options.diff ? false : config.delete,
         global: config.global,
-        verbose: config.verbose
+        verbose: config.verbose,
+        modelProfile: config.modelProfile
       };
-      const preSnapshot = new Map;
       try {
         const result = target.generate(generateOptions);
         allResults.push(result);