agentpacks 0.3.0 → 0.4.0

package/dist/node/index.js

@@ -1,52 +1,86 @@
 #!/usr/bin/env node
 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);
@@ -92,81 +126,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 {
@@ -175,10 +134,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.";
@@ -219,7 +178,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync2(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {
@@ -545,10 +504,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;
@@ -581,10 +708,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,
@@ -595,23 +722,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:"))
@@ -622,24 +751,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);
   }
 }
 
@@ -660,7 +793,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 };
   }
@@ -747,16 +881,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: {} };
   }
@@ -764,7 +906,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) + `
 `);
 }
@@ -783,15 +925,119 @@ function isLockfileFrozenValid(lockfile, sourceKeys) {
   return { valid: missing.length === 0, missing };
 }
 
+// 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/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;
@@ -823,9 +1069,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 || ""
   };
@@ -894,9 +1145,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 = {
@@ -949,11 +1230,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);
     }
   }
 }
@@ -974,7 +1255,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,
@@ -986,21 +1267,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);
       }
     }
   }
@@ -1008,15 +1289,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);
         }
       }
     }
@@ -1026,8 +1307,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) {
@@ -1051,18 +1332,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,
@@ -1076,20 +1354,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",
@@ -1097,7 +1380,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);
     }
@@ -1107,10 +1390,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 {
@@ -1163,7 +1445,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 {
@@ -1177,32 +1459,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);
@@ -1210,15 +1508,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);
@@ -1226,19 +1524,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);
@@ -1247,7 +1545,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
           });
@@ -1255,28 +1553,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);
         }
@@ -1285,7 +1614,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) {
@@ -1305,10 +1634,7 @@ function buildOpenCodeMcp(servers) {
       };
     }
   }
-  return {
-    $schema: "https://opencode.ai/config.json",
-    mcp
-  };
+  return mcp;
 }
 function generateOpenCodeHookPlugin(packName, events) {
   const identifier = packNameToIdentifier(packName);
@@ -1355,7 +1681,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 {
@@ -1368,18 +1694,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);
@@ -1396,33 +1723,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);
@@ -1430,20 +1764,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);
@@ -1451,7 +1785,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);
       }
@@ -1460,14 +1794,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(`
 `) + `
 `;
@@ -1475,6 +1809,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);
   }
 }
@@ -1493,9 +1838,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 resolve10, join as join11 } from "path";
+import { resolve as resolve9, join as join12 } from "path";
 var TARGET_ID3 = "claudecode";
 
 class ClaudeCodeTarget extends BaseTarget {
@@ -1508,18 +1979,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);
@@ -1532,32 +2004,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);
@@ -1565,15 +2046,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);
@@ -1581,15 +2062,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 });
@@ -1646,7 +2138,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 {
@@ -1655,14 +2147,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);
@@ -1670,13 +2162,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);
@@ -1684,9 +2176,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);
       }
@@ -1696,7 +2188,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 {
@@ -1712,12 +2204,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);
@@ -1726,26 +2218,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);
@@ -1754,7 +2246,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);
       }
@@ -1763,14 +2255,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(`
 `) + `
 `;
@@ -1809,7 +2301,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 {
@@ -1821,16 +2313,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) {
@@ -1839,15 +2332,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);
@@ -1855,14 +2348,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);
@@ -1870,16 +2363,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);
@@ -1887,25 +2380,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);
@@ -1917,7 +2421,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);
@@ -1925,7 +2429,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);
 }
@@ -1944,16 +2448,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);
@@ -1961,13 +2465,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);
@@ -1975,7 +2479,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);
       }
@@ -1984,7 +2488,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
         });
@@ -1993,13 +2497,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);
   }
 }
@@ -2139,11 +2653,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,
@@ -2157,7 +2671,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) {
@@ -2170,14 +2684,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) {
@@ -2186,61 +2700,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)) {
@@ -2251,79 +2765,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",
@@ -2335,20 +2849,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"];
@@ -2356,7 +2870,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],
@@ -2373,10 +2887,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)) {
@@ -2387,11 +2901,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) {
@@ -2407,64 +2921,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 };
@@ -2493,20 +3007,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 {
@@ -2516,12 +3030,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",
@@ -2531,21 +3045,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");
@@ -2553,8 +3067,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);
         }
@@ -2573,20 +3087,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: "",
@@ -2595,45 +3109,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 = [
@@ -2645,19 +3159,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);
       }
@@ -2665,10 +3179,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",
@@ -2680,8 +3194,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 };
@@ -2692,15 +3206,14 @@ 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/cli/export-cmd.ts
-init_config();
-import { resolve as resolve21 } from "path";
+import { resolve as resolve20 } from "path";
 import chalk from "chalk";
 function runExport(projectRoot, options) {
   const config = loadWorkspaceConfig(projectRoot);
@@ -2719,7 +3232,7 @@ function runExport(projectRoot, options) {
     console.log(chalk.red(`Pack "${options.pack}" not found.`));
     return;
   }
-  const outputDir = resolve21(projectRoot, options.output ?? "dist/cursor-plugins");
+  const outputDir = resolve20(projectRoot, options.output ?? "dist/cursor-plugins");
   switch (options.format) {
     case "cursor-plugin": {
       let totalFiles = 0;
@@ -2796,14 +3309,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++;
     }
   }
@@ -2832,8 +3360,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++;
           }
@@ -2853,7 +3382,6 @@ function findHunks(oldLines, newLines) {
 }
 
 // src/cli/generate.ts
-init_config();
 import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
 import chalk2 from "chalk";
 function runGenerate(projectRoot, options) {
@@ -2924,9 +3452,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);
@@ -3055,19 +3583,246 @@ Next steps:`), `
   2. Run`, chalk3.bold("agentpacks generate"), "to generate tool configs");
 }
 
-// src/cli/init.ts
-import { existsSync as existsSync16, copyFileSync as copyFileSync5, writeFileSync as writeFileSync10 } from "fs";
-import { resolve as resolve22, join as join21 } from "path";
+// src/utils/registry-client.ts
+var DEFAULT_REGISTRY_URL = "https://registry.agentpacks.dev";
+function createRegistryClient(config) {
+  return new RegistryClient({
+    registryUrl: config?.registryUrl ?? DEFAULT_REGISTRY_URL,
+    authToken: config?.authToken,
+    timeout: config?.timeout ?? 30000
+  });
+}
+
+class RegistryClient {
+  config;
+  constructor(config) {
+    this.config = {
+      registryUrl: config.registryUrl.replace(/\/+$/, ""),
+      authToken: config.authToken,
+      timeout: config.timeout ?? 30000
+    };
+  }
+  async search(params) {
+    const searchParams = new URLSearchParams;
+    if (params.query)
+      searchParams.set("q", params.query);
+    if (params.tags?.length)
+      searchParams.set("tags", params.tags.join(","));
+    if (params.targets?.length)
+      searchParams.set("targets", params.targets.join(","));
+    if (params.features?.length)
+      searchParams.set("features", params.features.join(","));
+    if (params.author)
+      searchParams.set("author", params.author);
+    if (params.sort)
+      searchParams.set("sort", params.sort);
+    if (params.limit)
+      searchParams.set("limit", String(params.limit));
+    if (params.offset)
+      searchParams.set("offset", String(params.offset));
+    const url = `${this.config.registryUrl}/packs?${searchParams.toString()}`;
+    const res = await this.fetch(url);
+    return res;
+  }
+  async info(packName) {
+    const url = `${this.config.registryUrl}/packs/${encodeURIComponent(packName)}`;
+    const res = await this.fetch(url);
+    return res;
+  }
+  async download(packName, version = "latest") {
+    const url = `${this.config.registryUrl}/packs/${encodeURIComponent(packName)}/versions/${encodeURIComponent(version)}/download`;
+    const response = await fetch(url, {
+      headers: this.headers(),
+      signal: AbortSignal.timeout(this.config.timeout)
+    });
+    if (!response.ok) {
+      throw new RegistryApiError(response.status, `Failed to download ${packName}@${version}: ${response.statusText}`);
+    }
+    const integrity = response.headers.get("x-integrity") ?? "";
+    const data = await response.arrayBuffer();
+    return { data, integrity };
+  }
+  async publish(tarball, metadata) {
+    if (!this.config.authToken) {
+      throw new Error("Authentication required. Run `agentpacks login` first.");
+    }
+    const formData = new FormData;
+    formData.append("tarball", new Blob([tarball], { type: "application/gzip" }), `${metadata.name}-${metadata.version}.tgz`);
+    formData.append("metadata", JSON.stringify(metadata));
+    const url = `${this.config.registryUrl}/packs`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.authToken}`
+      },
+      body: formData,
+      signal: AbortSignal.timeout(this.config.timeout)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new RegistryApiError(response.status, `Publish failed: ${body || response.statusText}`);
+    }
+    return await response.json();
+  }
+  async featured(limit) {
+    const url = limit ? `${this.config.registryUrl}/featured?limit=${limit}` : `${this.config.registryUrl}/featured`;
+    const res = await this.fetch(url);
+    return res.packs;
+  }
+  async tags() {
+    const url = `${this.config.registryUrl}/tags`;
+    const res = await this.fetch(url);
+    return res.tags;
+  }
+  async stats() {
+    const url = `${this.config.registryUrl}/stats`;
+    return await this.fetch(url);
+  }
+  async health() {
+    try {
+      const url = `${this.config.registryUrl}/health`;
+      await this.fetch(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async fetch(url) {
+    const response = await fetch(url, {
+      headers: this.headers(),
+      signal: AbortSignal.timeout(this.config.timeout)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new RegistryApiError(response.status, body || response.statusText);
+    }
+    return response.json();
+  }
+  headers() {
+    const h = {
+      Accept: "application/json"
+    };
+    if (this.config.authToken) {
+      h["Authorization"] = `Bearer ${this.config.authToken}`;
+    }
+    return h;
+  }
+}
+
+class RegistryApiError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "RegistryApiError";
+    this.status = status;
+  }
+}
+
+// src/utils/credentials.ts
+import { existsSync as existsSync16, readFileSync as readFileSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync5 } from "fs";
+import { join as join22, dirname as dirname2 } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join22(homedir(), ".config", "agentpacks");
+var CREDENTIALS_FILE = join22(CONFIG_DIR, "credentials.json");
+function loadCredentials() {
+  if (!existsSync16(CREDENTIALS_FILE)) {
+    return { registryUrl: "https://registry.agentpacks.dev" };
+  }
+  try {
+    const raw = readFileSync16(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { registryUrl: "https://registry.agentpacks.dev" };
+  }
+}
+function saveCredentials(credentials) {
+  mkdirSync5(dirname2(CREDENTIALS_FILE), { recursive: true });
+  writeFileSync9(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2) + `
+`, {
+    mode: 384
+  });
+}
+function clearCredentials() {
+  if (existsSync16(CREDENTIALS_FILE)) {
+    writeFileSync9(CREDENTIALS_FILE, JSON.stringify({ registryUrl: "https://registry.agentpacks.dev" }) + `
+`);
+  }
+}
+
+// src/cli/info.ts
 import chalk4 from "chalk";
+async function runInfo(packName) {
+  const credentials = loadCredentials();
+  const client = createRegistryClient({
+    registryUrl: credentials.registryUrl,
+    authToken: credentials.token
+  });
+  try {
+    const pack = await client.info(packName);
+    console.log(chalk4.bold(`
+${pack.displayName}`));
+    console.log(chalk4.dim(`  ${pack.name}`));
+    console.log(`  ${pack.description}`);
+    console.log();
+    console.log(`  ${chalk4.dim("Author:")} ${pack.author}`);
+    console.log(`  ${chalk4.dim("License:")} ${pack.license}`);
+    console.log(`  ${chalk4.dim("Downloads:")} ${pack.downloads}`);
+    if (pack.homepage) {
+      console.log(`  ${chalk4.dim("Homepage:")} ${pack.homepage}`);
+    }
+    if (pack.repository) {
+      console.log(`  ${chalk4.dim("Repository:")} ${pack.repository}`);
+    }
+    console.log();
+    if (pack.tags.length > 0) {
+      console.log(`  ${chalk4.dim("Tags:")} ${pack.tags.join(", ")}`);
+    }
+    if (pack.targets.length > 0) {
+      console.log(`  ${chalk4.dim("Targets:")} ${pack.targets.join(", ")}`);
+    }
+    if (pack.features.length > 0) {
+      console.log(`  ${chalk4.dim("Features:")} ${pack.features.join(", ")}`);
+    }
+    console.log();
+    if (pack.versions.length > 0) {
+      console.log(chalk4.bold("  Versions:"));
+      for (const v of pack.versions.slice(0, 10)) {
+        console.log(`    ${v.version} — ${v.createdAt} (${v.fileCount} files, ${formatBytes(v.tarballSize)})`);
+      }
+      if (pack.versions.length > 10) {
+        console.log(chalk4.dim(`    ... and ${pack.versions.length - 10} more`));
+      }
+    }
+    console.log();
+    console.log(chalk4.bold("  Install:"));
+    console.log(`    registry:${pack.name}`);
+    console.log();
+  } catch (err) {
+    console.log(chalk4.red(`Failed to get pack info: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/cli/init.ts
+import { existsSync as existsSync17, copyFileSync as copyFileSync5, writeFileSync as writeFileSync10 } from "fs";
+import { resolve as resolve21, join as join23 } from "path";
+import chalk5 from "chalk";
 function runInit(projectRoot) {
-  const configPath = resolve22(projectRoot, "agentpacks.jsonc");
-  const packsDir = resolve22(projectRoot, "packs", "default");
-  if (existsSync16(configPath)) {
-    console.log(chalk4.yellow("agentpacks.jsonc already exists. Skipping config creation."));
+  const configPath = resolve21(projectRoot, "agentpacks.jsonc");
+  const packsDir = resolve21(projectRoot, "packs", "default");
+  if (existsSync17(configPath)) {
+    console.log(chalk5.yellow("agentpacks.jsonc already exists. Skipping config creation."));
   } else {
-    const templateDir = resolve22(import.meta.dirname, "..", "..", "templates");
-    const templateConfig = resolve22(templateDir, "workspace", "agentpacks.jsonc");
-    if (existsSync16(templateConfig)) {
+    const templateDir = resolve21(import.meta.dirname, "..", "..", "templates");
+    const templateConfig = resolve21(templateDir, "workspace", "agentpacks.jsonc");
+    if (existsSync17(templateConfig)) {
       copyFileSync5(templateConfig, configPath);
     } else {
       const config = {
@@ -3091,16 +3846,16 @@ function runInit(projectRoot) {
       writeFileSync10(configPath, JSON.stringify(config, null, 2) + `
 `);
     }
-    console.log(chalk4.green("Created agentpacks.jsonc"));
+    console.log(chalk5.green("Created agentpacks.jsonc"));
   }
-  if (existsSync16(packsDir)) {
-    console.log(chalk4.yellow("packs/default/ already exists. Skipping pack scaffold."));
+  if (existsSync17(packsDir)) {
+    console.log(chalk5.yellow("packs/default/ already exists. Skipping pack scaffold."));
   } else {
     ensureDir(packsDir);
-    ensureDir(join21(packsDir, "rules"));
-    ensureDir(join21(packsDir, "commands"));
-    ensureDir(join21(packsDir, "agents"));
-    ensureDir(join21(packsDir, "skills"));
+    ensureDir(join23(packsDir, "rules"));
+    ensureDir(join23(packsDir, "commands"));
+    ensureDir(join23(packsDir, "agents"));
+    ensureDir(join23(packsDir, "skills"));
     const packJson = {
       name: "default",
       version: "1.0.0",
@@ -3111,43 +3866,162 @@ function runInit(projectRoot) {
       targets: "*",
       features: "*"
     };
-    writeFileSync10(join21(packsDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+    writeFileSync10(join23(packsDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-    const templateRule = resolve22(import.meta.dirname, "..", "..", "templates", "pack", "rules", "overview.md");
-    if (existsSync16(templateRule)) {
-      copyFileSync5(templateRule, join21(packsDir, "rules", "overview.md"));
+    const templateRule = resolve21(import.meta.dirname, "..", "..", "templates", "pack", "rules", "overview.md");
+    if (existsSync17(templateRule)) {
+      copyFileSync5(templateRule, join23(packsDir, "rules", "overview.md"));
     }
-    console.log(chalk4.green("Created packs/default/ with scaffold"));
+    console.log(chalk5.green("Created packs/default/ with scaffold"));
   }
-  console.log(chalk4.cyan(`
+  console.log(chalk5.cyan(`
 Next steps:`), `
   1. Edit packs/default/rules/overview.md with your project guidelines`, `
-  2. Run`, chalk4.bold("agentpacks generate"), "to generate tool configs", `
-  3. Or run`, chalk4.bold("agentpacks import --from rulesync"), "to migrate from rulesync");
+  2. Run`, chalk5.bold("agentpacks generate"), "to generate tool configs", `
+  3. Or run`, chalk5.bold("agentpacks import --from rulesync"), "to migrate from rulesync");
+}
+
+// src/utils/tarball.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync17, existsSync as existsSync18, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
+import { join as join24, resolve as resolve22 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { tmpdir } from "os";
+async function createTarball(packDir) {
+  const absDir = resolve22(packDir);
+  const tmpFile = join24(tmpdir(), `agentpacks-${Date.now()}.tgz`);
+  try {
+    execSync2(`tar -czf "${tmpFile}" -C "${absDir}" .`, {
+      stdio: "pipe"
+    });
+    const buffer = readFileSync17(tmpFile);
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  } finally {
+    if (existsSync18(tmpFile)) {
+      rmSync2(tmpFile);
+    }
+  }
+}
+async function extractTarball(data, targetDir) {
+  mkdirSync6(targetDir, { recursive: true });
+  const tmpFile = join24(tmpdir(), `agentpacks-${Date.now()}.tgz`);
+  try {
+    const buffer = Buffer.from(data);
+    const { writeFileSync: writeFileSync11 } = await import("fs");
+    writeFileSync11(tmpFile, buffer);
+    execSync2(`tar -xzf "${tmpFile}" -C "${targetDir}"`, {
+      stdio: "pipe"
+    });
+  } finally {
+    if (existsSync18(tmpFile)) {
+      rmSync2(tmpFile);
+    }
+  }
+}
+function computeTarballIntegrity(data) {
+  const hash = createHash2("sha256").update(Buffer.from(data)).digest("hex");
+  return `sha256-${hash}`;
+}
+
+// src/sources/registry.ts
+import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync3, rmSync as rmSync3 } from "fs";
+import { resolve as resolve23, join as join25 } from "path";
+async function installRegistrySource(projectRoot, source, lockfile, options = {}) {
+  const parsed = parseRegistrySourceRef(source);
+  const sourceKey = registrySourceKey(parsed);
+  const installed = [];
+  const warnings = [];
+  const locked = getLockedSource(lockfile, sourceKey);
+  if (options.frozen && !locked) {
+    throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
+  }
+  let targetVersion = parsed.version;
+  if (locked && !options.update) {
+    targetVersion = locked.resolvedRef;
+  } else if (targetVersion === "latest") {
+    const clientCfg2 = buildClientConfig(options.registryUrl);
+    const client2 = createRegistryClient(clientCfg2);
+    const info = await client2.info(parsed.packName);
+    targetVersion = info.latestVersion;
+  }
+  const clientCfg = buildClientConfig(options.registryUrl);
+  const client = createRegistryClient(clientCfg);
+  const { data } = await client.download(parsed.packName, targetVersion);
+  const localIntegrity = computeTarballIntegrity(data);
+  if (locked && !options.update && locked.skills?.["__integrity"]) {
+    const expectedIntegrity = locked.skills["__integrity"].integrity;
+    if (expectedIntegrity && localIntegrity !== expectedIntegrity) {
+      throw new Error(`Integrity mismatch for ${parsed.packName}@${targetVersion}. ` + `Expected ${expectedIntegrity}, got ${localIntegrity}.`);
+    }
+  }
+  const curatedDir = resolve23(projectRoot, ".agentpacks", ".curated");
+  const packOutDir = resolve23(curatedDir, parsed.packName);
+  if (existsSync19(packOutDir)) {
+    rmSync3(packOutDir, { recursive: true, force: true });
+  }
+  mkdirSync7(packOutDir, { recursive: true });
+  await extractTarball(data, packOutDir);
+  collectFiles2(packOutDir, installed);
+  const newEntry = {
+    requestedRef: parsed.version,
+    resolvedRef: targetVersion,
+    resolvedAt: new Date().toISOString(),
+    skills: {
+      __integrity: { integrity: localIntegrity }
+    },
+    packs: {
+      [parsed.packName]: { integrity: localIntegrity }
+    }
+  };
+  setLockedSource(lockfile, sourceKey, newEntry);
+  return { installed, warnings };
+}
+function buildClientConfig(registryUrl) {
+  const cfg = {};
+  if (registryUrl) {
+    cfg.registryUrl = registryUrl;
+  }
+  try {
+    const creds = loadCredentials();
+    if (creds?.token) {
+      cfg.authToken = creds.token;
+    }
+  } catch {}
+  return cfg;
+}
+function collectFiles2(dir, out) {
+  const entries = readdirSync3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join25(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles2(full, out);
+    } else {
+      out.push(full);
+    }
+  }
 }
 
 // src/cli/install.ts
-init_config();
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 async function runInstall(projectRoot, options) {
   const config = loadWorkspaceConfig(projectRoot);
   const lockfile = loadLockfile(projectRoot);
   const verbose = options.verbose ?? config.verbose;
-  const remotePacks = config.packs.filter((ref) => isGitPackRef(ref) || isNpmPackRef(ref));
+  const remotePacks = config.packs.filter((ref) => isGitPackRef(ref) || isNpmPackRef(ref) || isRegistryPackRef(ref));
   const localPacks = config.packs.filter((ref) => isLocalPackRef(ref));
   if (remotePacks.length === 0) {
-    console.log(chalk5.dim("No remote packs to install. All packs are local."));
+    console.log(chalk6.dim("No remote packs to install. All packs are local."));
     return;
   }
   if (verbose) {
-    console.log(chalk5.dim(`Found ${remotePacks.length} remote pack(s) to install`));
-    console.log(chalk5.dim(`  (${localPacks.length} local pack(s) skipped)`));
+    console.log(chalk6.dim(`Found ${remotePacks.length} remote pack(s) to install`));
+    console.log(chalk6.dim(`  (${localPacks.length} local pack(s) skipped)`));
   }
   if (options.frozen) {
     const sourceKeys = remotePacks.map((ref) => ref);
     const frozenCheck = isLockfileFrozenValid(lockfile, sourceKeys);
     if (!frozenCheck.valid) {
-      console.log(chalk5.red(`Frozen install failed. Missing lockfile entries: ${frozenCheck.missing.join(", ")}`));
+      console.log(chalk6.red(`Frozen install failed. Missing lockfile entries: ${frozenCheck.missing.join(", ")}`));
       process.exit(1);
     }
   }
@@ -3155,11 +4029,16 @@ async function runInstall(projectRoot, options) {
   const allWarnings = [];
   for (const packRef of remotePacks) {
     if (verbose) {
-      console.log(chalk5.dim(`  Installing ${packRef}...`));
+      console.log(chalk6.dim(`  Installing ${packRef}...`));
     }
     try {
       let result;
-      if (isGitPackRef(packRef)) {
+      if (isRegistryPackRef(packRef)) {
+        result = await installRegistrySource(projectRoot, packRef, lockfile, {
+          update: options.update,
+          frozen: options.frozen
+        });
+      } else if (isGitPackRef(packRef)) {
         const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? undefined;
         result = await installGitSource(projectRoot, packRef, lockfile, {
           update: options.update,
@@ -3177,39 +4056,204 @@ async function runInstall(projectRoot, options) {
       totalInstalled += result.installed.length;
       allWarnings.push(...result.warnings);
       if (verbose && result.installed.length > 0) {
-        console.log(chalk5.dim(`    ${result.installed.length} file(s) installed`));
+        console.log(chalk6.dim(`    ${result.installed.length} file(s) installed`));
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.log(chalk5.red(`  error [${packRef}]: ${msg}`));
+      console.log(chalk6.red(`  error [${packRef}]: ${msg}`));
       allWarnings.push(`Failed to install ${packRef}: ${msg}`);
     }
   }
   for (const w of allWarnings) {
-    console.log(chalk5.yellow(`  warn: ${w}`));
+    console.log(chalk6.yellow(`  warn: ${w}`));
   }
   saveLockfile(projectRoot, lockfile);
-  console.log(chalk5.green(`Installed ${totalInstalled} file(s) from ${remotePacks.length} source(s)`));
+  console.log(chalk6.green(`Installed ${totalInstalled} file(s) from ${remotePacks.length} source(s)`));
   if (verbose) {
-    console.log(chalk5.dim("Lockfile updated: agentpacks.lock"));
+    console.log(chalk6.dim("Lockfile updated: agentpacks.lock"));
+  }
+}
+
+// src/cli/login.ts
+import chalk7 from "chalk";
+async function runLogin(options) {
+  const registryUrl = options.registry ?? "https://registry.agentpacks.dev";
+  if (!options.token) {
+    console.log(chalk7.bold(`agentpacks login
+`));
+    console.log("To authenticate, you need an API token.");
+    console.log(`Get one at: ${chalk7.cyan(`${registryUrl}/account/tokens`)}
+`);
+    console.log("Then run:");
+    console.log(chalk7.dim(`  agentpacks login --token <your-token>
+`));
+    return;
+  }
+  const client = createRegistryClient({
+    registryUrl,
+    authToken: options.token
+  });
+  const healthy = await client.health();
+  if (!healthy) {
+    console.log(chalk7.yellow(`Warning: Could not reach registry at ${registryUrl}`));
   }
+  saveCredentials({
+    registryUrl,
+    token: options.token
+  });
+  console.log(chalk7.green(`Authenticated with ${registryUrl}`));
+  console.log(chalk7.dim("Credentials saved to ~/.config/agentpacks/credentials.json"));
+}
+
+// src/cli/models-explain.ts
+import chalk8 from "chalk";
+import { resolve as resolve24 } from "path";
+function runModelsExplain(options) {
+  const projectRoot = resolve24(options.config ?? ".");
+  const config = loadWorkspaceConfig(projectRoot);
+  const loader = new PackLoader(projectRoot, config);
+  const { packs } = loader.loadAll();
+  if (packs.length === 0) {
+    console.log(chalk8.red("No packs loaded. Run `agentpacks init` first."));
+    process.exit(1);
+  }
+  const merger = new FeatureMerger(packs);
+  const { features: merged } = merger.merge();
+  if (!merged.models) {
+    console.log(chalk8.dim("No model configuration found in your packs."));
+    return;
+  }
+  const profile = options.profile;
+  const target = options.target;
+  const resolved = resolveModels(merged.models, profile, target);
+  console.log(chalk8.bold(`
+\uD83D\uDCCB Model Configuration Summary
+`));
+  if (resolved.default) {
+    console.log(`  ${chalk8.dim("Default model:")}  ${chalk8.cyan(resolved.default)}`);
+  }
+  if (resolved.small) {
+    console.log(`  ${chalk8.dim("Small model:")}    ${chalk8.cyan(resolved.small)}`);
+  }
+  if (resolved.activeProfile) {
+    console.log(`  ${chalk8.dim("Active profile:")} ${chalk8.green(resolved.activeProfile)}`);
+  }
+  if (target) {
+    console.log(`  ${chalk8.dim("Target:")}         ${chalk8.yellow(target)}`);
+  }
+  const agentEntries = Object.entries(resolved.agents);
+  if (agentEntries.length > 0) {
+    console.log(chalk8.bold(`
+  Agent Assignments:`));
+    for (const [name, config2] of agentEntries) {
+      const temp = config2.temperature !== undefined ? ` (temp: ${config2.temperature})` : "";
+      console.log(`    ${chalk8.dim("•")} ${name}: ${chalk8.cyan(config2.model)}${chalk8.dim(temp)}`);
+    }
+  }
+  if (resolved.profileNames.length > 0) {
+    console.log(chalk8.bold(`
+  Available Profiles:`));
+    for (const name of resolved.profileNames) {
+      const profileData = resolved.profiles[name];
+      const desc = profileData?.description ?? "";
+      const active = name === resolved.activeProfile ? chalk8.green(" ← active") : "";
+      console.log(`    ${chalk8.dim("•")} ${name}${active}${desc ? chalk8.dim(` — ${desc}`) : ""}`);
+    }
+  }
+  if (resolved.routing.length > 0) {
+    console.log(chalk8.bold(`
+  Routing Rules:`));
+    for (const rule of resolved.routing) {
+      const conditions = Object.entries(rule.when).map(([k, v]) => `${chalk8.yellow(k)}=${chalk8.cyan(v)}`).join(", ");
+      const desc = rule.description;
+      console.log(`    ${chalk8.dim("•")} When ${conditions} → use ${chalk8.green(rule.use)}${desc ? chalk8.dim(` (${desc})`) : ""}`);
+    }
+    if (options.task) {
+      console.log(chalk8.bold(`
+  Task Analysis:`));
+      console.log(`    ${chalk8.dim("Task:")} "${options.task}"`);
+      const matched = matchTaskToRouting(options.task, resolved.routing);
+      if (matched) {
+        console.log(`    ${chalk8.green("✓")} Matched rule: ${chalk8.green(matched.use)}`);
+        const conditions = Object.entries(matched.when).map(([k, v]) => `${k}=${v}`).join(", ");
+        console.log(`    ${chalk8.dim("  Conditions:")} ${conditions}`);
+      } else {
+        console.log(`    ${chalk8.yellow("○")} No routing rule matched — using default profile`);
+      }
+    }
+  }
+  const guidance = generateModelGuidanceMarkdown(resolved);
+  if (guidance) {
+    console.log(chalk8.bold(`
+  Generated Guidance Preview:`));
+    console.log(chalk8.dim("  " + "─".repeat(50)));
+    for (const line of guidance.split(`
+`).slice(0, 20)) {
+      console.log(`  ${chalk8.dim(line)}`);
+    }
+    if (guidance.split(`
+`).length > 20) {
+      console.log(chalk8.dim(`  ... (${guidance.split(`
+`).length - 20} more lines)`));
+    }
+  }
+  console.log("");
+}
+function matchTaskToRouting(task, routing) {
+  const lowerTask = task.toLowerCase();
+  const complexityKeywords = {
+    critical: ["critical", "security", "production", "hotfix"],
+    high: ["refactor", "architecture", "complex", "rewrite", "migrate"],
+    medium: ["feature", "implement", "update", "modify"],
+    low: ["fix", "typo", "comment", "rename", "format"]
+  };
+  const urgencyKeywords = {
+    high: ["urgent", "asap", "emergency", "hotfix", "critical"],
+    normal: ["feature", "implement", "add"],
+    low: ["cleanup", "refactor", "docs", "todo"]
+  };
+  const inferred = {};
+  for (const [level, keywords] of Object.entries(complexityKeywords)) {
+    if (keywords.some((kw) => lowerTask.includes(kw))) {
+      inferred["complexity"] = level;
+      break;
+    }
+  }
+  for (const [level, keywords] of Object.entries(urgencyKeywords)) {
+    if (keywords.some((kw) => lowerTask.includes(kw))) {
+      inferred["urgency"] = level;
+      break;
+    }
+  }
+  for (const rule of routing) {
+    const matches = Object.entries(rule.when).every(([key, value]) => {
+      if (inferred[key] === value)
+        return true;
+      if (lowerTask.includes(value.toLowerCase()))
+        return true;
+      return false;
+    });
+    if (matches)
+      return rule;
+  }
+  return null;
 }
 
 // src/cli/pack/create.ts
-import { existsSync as existsSync17, writeFileSync as writeFileSync11 } from "fs";
-import { resolve as resolve23, join as join22 } from "path";
-import chalk6 from "chalk";
+import { existsSync as existsSync20, writeFileSync as writeFileSync11 } from "fs";
+import { resolve as resolve25, join as join26 } from "path";
+import chalk9 from "chalk";
 function runPackCreate(projectRoot, name) {
-  const packDir = resolve23(projectRoot, "packs", name);
-  if (existsSync17(packDir)) {
-    console.log(chalk6.red(`Pack "${name}" already exists at packs/${name}/`));
+  const packDir = resolve25(projectRoot, "packs", name);
+  if (existsSync20(packDir)) {
+    console.log(chalk9.red(`Pack "${name}" already exists at packs/${name}/`));
     return;
   }
   ensureDir(packDir);
-  ensureDir(join22(packDir, "rules"));
-  ensureDir(join22(packDir, "commands"));
-  ensureDir(join22(packDir, "agents"));
-  ensureDir(join22(packDir, "skills"));
+  ensureDir(join26(packDir, "rules"));
+  ensureDir(join26(packDir, "commands"));
+  ensureDir(join26(packDir, "agents"));
+  ensureDir(join26(packDir, "skills"));
   const packJson = {
     name,
     version: "1.0.0",
@@ -3220,31 +4264,31 @@ function runPackCreate(projectRoot, name) {
     targets: "*",
     features: "*"
   };
-  writeFileSync11(join22(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+  writeFileSync11(join26(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-  console.log(chalk6.green(`Created pack "${name}" at packs/${name}/`));
-  console.log(chalk6.dim("  Add rules, commands, agents, skills, hooks, plugins, mcp.json, or ignore files."));
-  console.log(chalk6.dim(`  Then add "${join22("./packs", name)}" to packs[] in agentpacks.jsonc.`));
+  console.log(chalk9.green(`Created pack "${name}" at packs/${name}/`));
+  console.log(chalk9.dim("  Add rules, commands, agents, skills, hooks, plugins, mcp.json, or ignore files."));
+  console.log(chalk9.dim(`  Then add "${join26("./packs", name)}" to packs[] in agentpacks.jsonc.`));
 }
 
 // src/cli/pack/enable.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync18 } from "fs";
-import { resolve as resolve24 } from "path";
-import chalk7 from "chalk";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync21 } from "fs";
+import { resolve as resolve26 } from "path";
+import chalk10 from "chalk";
 var CONFIG_FILENAME = "agentpacks.jsonc";
 function readConfigRaw(projectRoot) {
-  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
-  if (!existsSync18(filepath)) {
+  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
+  if (!existsSync21(filepath)) {
     throw new Error(`No ${CONFIG_FILENAME} found. Run 'agentpacks init' first.`);
   }
-  return readFileSync16(filepath, "utf-8");
+  return readFileSync18(filepath, "utf-8");
 }
 function parseDisabledFromRaw(raw) {
   const regex = /"disabled"\s*:\s*\[([^\]]*)\]/;
   const match = regex.exec(raw);
   if (!match)
     return { list: [], match: null };
-  const inner = match[1].trim();
+  const inner = (match[1] ?? "").trim();
   if (!inner)
     return { list: [], match };
   const list = inner.split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
@@ -3264,47 +4308,46 @@ function runPackDisable(projectRoot, packName) {
   const raw = readConfigRaw(projectRoot);
   const { list, match } = parseDisabledFromRaw(raw);
   if (list.includes(packName)) {
-    console.log(chalk7.dim(`Pack "${packName}" is already disabled.`));
+    console.log(chalk10.dim(`Pack "${packName}" is already disabled.`));
     return;
   }
   list.push(packName);
   const updated = writeDisabled(raw, list, match);
-  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
+  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
   writeFileSync12(filepath, updated);
-  console.log(chalk7.green(`Disabled pack "${packName}".`));
-  console.log(chalk7.dim("Run 'agentpacks generate' to regenerate configs."));
+  console.log(chalk10.green(`Disabled pack "${packName}".`));
+  console.log(chalk10.dim("Run 'agentpacks generate' to regenerate configs."));
 }
 function runPackEnable(projectRoot, packName) {
   const raw = readConfigRaw(projectRoot);
   const { list, match } = parseDisabledFromRaw(raw);
   if (!list.includes(packName)) {
-    console.log(chalk7.dim(`Pack "${packName}" is not disabled.`));
+    console.log(chalk10.dim(`Pack "${packName}" is not disabled.`));
     return;
   }
   const newList = list.filter((n) => n !== packName);
   const updated = writeDisabled(raw, newList, match);
-  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
+  const filepath = resolve26(projectRoot, CONFIG_FILENAME);
   writeFileSync12(filepath, updated);
-  console.log(chalk7.green(`Enabled pack "${packName}".`));
-  console.log(chalk7.dim("Run 'agentpacks generate' to regenerate configs."));
+  console.log(chalk10.green(`Enabled pack "${packName}".`));
+  console.log(chalk10.dim("Run 'agentpacks generate' to regenerate configs."));
 }
 
 // src/cli/pack/list.ts
-init_config();
-import chalk8 from "chalk";
+import chalk11 from "chalk";
 function runPackList(projectRoot) {
   const config = loadWorkspaceConfig(projectRoot);
   const loader = new PackLoader(projectRoot, config);
   const { packs, warnings } = loader.loadAll();
   const disabledSet = new Set(config.disabled);
   for (const w of warnings) {
-    console.log(chalk8.yellow(`  warn: ${w}`));
+    console.log(chalk11.yellow(`  warn: ${w}`));
   }
   if (packs.length === 0 && config.packs.length === 0) {
-    console.log(chalk8.dim("No packs configured. Run 'agentpacks init' to get started."));
+    console.log(chalk11.dim("No packs configured. Run 'agentpacks init' to get started."));
     return;
   }
-  console.log(chalk8.bold(`Active packs:
+  console.log(chalk11.bold(`Active packs:
 `));
   for (const pack of packs) {
     const m = pack.manifest;
@@ -3325,140 +4368,269 @@ function runPackList(projectRoot) {
       features.push(`${Object.keys(pack.mcp.servers).length} MCP servers`);
     if (pack.ignore)
       features.push("ignore");
-    const status = disabledSet.has(m.name) ? chalk8.red("[disabled]") : chalk8.green("[active]");
-    console.log(`  ${status} ${chalk8.bold(m.name)} v${m.version}`);
+    const status = disabledSet.has(m.name) ? chalk11.red("[disabled]") : chalk11.green("[active]");
+    console.log(`  ${status} ${chalk11.bold(m.name)} v${m.version}`);
     if (m.description) {
-      console.log(`    ${chalk8.dim(m.description)}`);
+      console.log(`    ${chalk11.dim(m.description)}`);
     }
     if (features.length > 0) {
-      console.log(`    ${chalk8.dim(features.join(", "))}`);
+      console.log(`    ${chalk11.dim(features.join(", "))}`);
     }
     console.log();
   }
   for (const ref of config.disabled) {
     if (!packs.some((p) => p.manifest.name === ref)) {
-      console.log(`  ${chalk8.red("[disabled]")} ${chalk8.dim(ref)}`);
+      console.log(`  ${chalk11.red("[disabled]")} ${chalk11.dim(ref)}`);
     }
   }
 }
 
 // src/cli/pack/validate.ts
-init_config();
-import { existsSync as existsSync19 } from "fs";
-import { resolve as resolve25, join as join23 } from "path";
-import chalk9 from "chalk";
+import { existsSync as existsSync22 } from "fs";
+import { resolve as resolve27, join as join27 } from "path";
+import chalk12 from "chalk";
 function runPackValidate(projectRoot) {
   const config = loadWorkspaceConfig(projectRoot);
   let hasErrors = false;
   for (const packRef of config.packs) {
     const packDir = resolvePackDir(projectRoot, packRef);
-    console.log(chalk9.bold(`
+    console.log(chalk12.bold(`
 Validating pack: ${packRef}`));
-    if (!packDir || !existsSync19(packDir)) {
-      console.log(chalk9.red(`  ERROR: Pack directory not found: ${packRef}`));
+    if (!packDir || !existsSync22(packDir)) {
+      console.log(chalk12.red(`  ERROR: Pack directory not found: ${packRef}`));
       hasErrors = true;
       continue;
     }
-    const packJsonPath = resolve25(packDir, "pack.json");
-    if (!existsSync19(packJsonPath)) {
-      console.log(chalk9.yellow("  warn: No pack.json found. Name will be inferred from directory."));
+    const packJsonPath = resolve27(packDir, "pack.json");
+    if (!existsSync22(packJsonPath)) {
+      console.log(chalk12.yellow("  warn: No pack.json found. Name will be inferred from directory."));
     } else {
       try {
         loadPackManifest(packDir);
-        console.log(chalk9.green("  pack.json: valid"));
+        console.log(chalk12.green("  pack.json: valid"));
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.log(chalk9.red(`  ERROR pack.json: ${message}`));
+        console.log(chalk12.red(`  ERROR pack.json: ${message}`));
         hasErrors = true;
       }
     }
     const subdirs = ["rules", "commands", "agents", "skills"];
     for (const sub of subdirs) {
-      const subDir = join23(packDir, sub);
-      if (existsSync19(subDir)) {
+      const subDir = join27(packDir, sub);
+      if (existsSync22(subDir)) {
         if (sub === "skills") {
           const skillDirs = listDirs(subDir);
           for (const skillDir of skillDirs) {
-            const skillMd = join23(skillDir, "SKILL.md");
-            if (!existsSync19(skillMd)) {
-              console.log(chalk9.yellow(`  warn: skills/${skillDir.split("/").pop()} missing SKILL.md`));
+            const skillMd = join27(skillDir, "SKILL.md");
+            if (!existsSync22(skillMd)) {
+              console.log(chalk12.yellow(`  warn: skills/${skillDir.split("/").pop()} missing SKILL.md`));
             }
           }
-          console.log(chalk9.green(`  ${sub}/: ${skillDirs.length} skill(s)`));
+          console.log(chalk12.green(`  ${sub}/: ${skillDirs.length} skill(s)`));
         } else {
           const files = listFiles(subDir, { extension: ".md" });
-          console.log(chalk9.green(`  ${sub}/: ${files.length} file(s)`));
+          console.log(chalk12.green(`  ${sub}/: ${files.length} file(s)`));
         }
       }
     }
     const optionalFiles = ["mcp.json", "ignore", ".aiignore"];
     for (const file of optionalFiles) {
-      if (existsSync19(join23(packDir, file))) {
-        console.log(chalk9.green(`  ${file}: present`));
+      if (existsSync22(join27(packDir, file))) {
+        console.log(chalk12.green(`  ${file}: present`));
       }
     }
-    const hooksJson = join23(packDir, "hooks", "hooks.json");
-    if (existsSync19(hooksJson)) {
-      console.log(chalk9.green("  hooks/hooks.json: present"));
+    const hooksJson = join27(packDir, "hooks", "hooks.json");
+    if (existsSync22(hooksJson)) {
+      console.log(chalk12.green("  hooks/hooks.json: present"));
     }
-    const pluginsDir = join23(packDir, "plugins");
-    if (existsSync19(pluginsDir)) {
+    const pluginsDir = join27(packDir, "plugins");
+    if (existsSync22(pluginsDir)) {
       const pluginFiles = [
         ...listFiles(pluginsDir, { extension: ".ts" }),
         ...listFiles(pluginsDir, { extension: ".js" })
       ];
-      console.log(chalk9.green(`  plugins/: ${pluginFiles.length} file(s)`));
+      console.log(chalk12.green(`  plugins/: ${pluginFiles.length} file(s)`));
+    }
+    const modelsJsonPath = join27(packDir, "models.json");
+    if (existsSync22(modelsJsonPath)) {
+      try {
+        const parsed = parseModels(packDir, "validate");
+        if (parsed) {
+          console.log(chalk12.green("  models.json: valid"));
+          const secretWarnings = scanModelsForSecrets(parsed.config);
+          if (secretWarnings.length > 0) {
+            for (const w of secretWarnings) {
+              console.log(chalk12.red(`  ERROR models.json: ${w}`));
+            }
+            hasErrors = true;
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk12.red(`  ERROR models.json: ${message}`));
+        hasErrors = true;
+      }
     }
   }
   console.log();
   if (hasErrors) {
-    console.log(chalk9.red("Validation failed with errors."));
+    console.log(chalk12.red("Validation failed with errors."));
     process.exit(1);
   } else {
-    console.log(chalk9.green("All packs valid."));
+    console.log(chalk12.green("All packs valid."));
   }
 }
 function resolvePackDir(projectRoot, packRef) {
   if (packRef.startsWith("./") || packRef.startsWith("../")) {
-    return resolve25(projectRoot, packRef);
+    return resolve27(projectRoot, packRef);
+  }
+  return resolve27(projectRoot, packRef);
+}
+
+// src/cli/publish.ts
+import { resolve as resolve28 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import chalk13 from "chalk";
+async function runPublish(projectRoot, options) {
+  const credentials = loadCredentials();
+  if (!credentials.token) {
+    console.log(chalk13.red("Not authenticated. Run `agentpacks login` first."));
+    process.exit(1);
+  }
+  const packDir = resolve28(projectRoot);
+  const packJsonPath = resolve28(packDir, "pack.json");
+  if (!existsSync23(packJsonPath)) {
+    console.log(chalk13.red("No pack.json found. Are you in a pack directory?"));
+    process.exit(1);
+  }
+  const manifest = loadPackManifest(packDir);
+  console.log(chalk13.bold(`Publishing ${manifest.name}@${manifest.version}...`));
+  const models = parseModels(packDir, manifest.name);
+  if (models) {
+    const secretWarnings = scanModelsForSecrets(models.config);
+    if (secretWarnings.length > 0) {
+      console.log(chalk13.red(`
+Blocked: secrets detected in models.json:`));
+      for (const w of secretWarnings) {
+        console.log(chalk13.red(`  - ${w}`));
+      }
+      process.exit(1);
+    }
+  }
+  if (options.verbose)
+    console.log(chalk13.dim("  Creating tarball..."));
+  const tarball = await createTarball(packDir);
+  if (options.verbose)
+    console.log(chalk13.dim("  Uploading..."));
+  const client = createRegistryClient({
+    registryUrl: credentials.registryUrl,
+    authToken: credentials.token
+  });
+  try {
+    const result = await client.publish(tarball, {
+      name: manifest.name,
+      version: manifest.version,
+      manifest
+    });
+    console.log(chalk13.green(`
+Published ${result.name}@${result.version}`));
+    console.log(chalk13.dim(`  integrity: ${result.integrity}`));
+  } catch (err) {
+    console.log(chalk13.red(`
+Publish failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+}
+
+// src/cli/search.ts
+import chalk14 from "chalk";
+async function runSearch(query, options) {
+  const credentials = loadCredentials();
+  const client = createRegistryClient({
+    registryUrl: credentials.registryUrl,
+    authToken: credentials.token
+  });
+  try {
+    const { packs, total } = await client.search({
+      query,
+      tags: options.tags?.split(","),
+      targets: options.targets?.split(","),
+      sort: options.sort,
+      limit: options.limit ? Number(options.limit) : 20
+    });
+    if (packs.length === 0) {
+      console.log(chalk14.dim("No packs found."));
+      return;
+    }
+    console.log(chalk14.bold(`Found ${total} pack(s)${query ? ` matching "${query}"` : ""}:
+`));
+    for (const pack of packs) {
+      const verified = pack.verified ? chalk14.green(" [verified]") : "";
+      const featured = pack.featured ? chalk14.yellow(" [featured]") : "";
+      console.log(`  ${chalk14.bold(pack.name)}${verified}${featured}`);
+      console.log(`    ${pack.description}`);
+      console.log(chalk14.dim(`    v${pack.latestVersion} | ${pack.downloads} downloads | by ${pack.author}`));
+      if (options.verbose && pack.tags.length > 0) {
+        console.log(chalk14.dim(`    tags: ${pack.tags.join(", ")}`));
+      }
+      console.log();
+    }
+  } catch (err) {
+    console.log(chalk14.red(`Search failed: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
   }
-  return resolve25(projectRoot, packRef);
 }
 
 // src/index.ts
 import { Command } from "commander";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve29 } from "path";
 var program = new Command;
 program.name("agentpacks").description("Composable AI agent configuration manager. Pack-based rules, commands, skills, hooks, and MCP sync across OpenCode, Cursor, Claude Code, Codex, Gemini, Copilot, and more.").version("0.1.0");
 program.command("init").description("Initialize agentpacks in the current project").action(() => {
-  runInit(resolve26("."));
+  runInit(resolve29("."));
 });
 program.command("generate").description("Generate tool configs from active packs").option("-t, --targets <targets>", "Comma-separated target IDs or '*' for all").option("-f, --features <features>", "Comma-separated feature IDs or '*' for all").option("--dry-run", "Preview changes without writing files").option("--diff", "Show diff of what would change").option("-v, --verbose", "Enable verbose logging").action((options) => {
-  runGenerate(resolve26("."), options);
+  runGenerate(resolve29("."), options);
 });
 program.command("install").description("Install remote packs (git, npm) into local cache").option("--update", "Re-resolve all refs (ignore lockfile)").option("--frozen", "Fail if lockfile is missing or incomplete").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
-  await runInstall(resolve26("."), options);
+  await runInstall(resolve29("."), options);
 });
 program.command("export").description("Export packs to target-native format (e.g. Cursor plugin)").requiredOption("--format <format>", "Export format (cursor-plugin)").option("-o, --output <dir>", "Output directory").option("--pack <name>", "Export a specific pack only").option("-v, --verbose", "Enable verbose logging").action((options) => {
-  runExport(resolve26("."), options);
+  runExport(resolve29("."), options);
 });
 program.command("import").description("Import from existing tool configurations").requiredOption("--from <source>", "Import source (rulesync)").option("-o, --output <dir>", "Output pack directory").action((options) => {
-  runImport(resolve26("."), options);
+  runImport(resolve29("."), options);
+});
+program.command("search [query]").description("Search for packs in the registry").option("--tags <tags>", "Filter by tags (comma-separated)").option("--targets <targets>", "Filter by targets (comma-separated)").option("--sort <sort>", "Sort by: downloads, updated, name, weekly").option("-l, --limit <limit>", "Max results to show").option("-v, --verbose", "Show additional details").action(async (query, options) => {
+  await runSearch(query ?? "", options);
+});
+program.command("info <pack>").description("Show detailed pack information from the registry").action(async (packName) => {
+  await runInfo(packName);
+});
+program.command("publish").description("Publish a pack to the registry").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+  await runPublish(resolve29("."), options);
+});
+program.command("login").description("Authenticate with the agentpacks registry").option("--token <token>", "API token").option("--registry <url>", "Registry URL").action(async (options) => {
+  await runLogin(options);
+});
+var modelsCmd = program.command("models").description("Model configuration and routing");
+modelsCmd.command("explain").description("Explain model profile and routing resolution").option("-c, --config <path>", "Path to agentpacks.yaml").option("-p, --profile <name>", "Profile to activate").option("-t, --target <id>", "Target to resolve for").option("--task <description>", "Task description for routing match").action((options) => {
+  runModelsExplain(options);
 });
 var packCmd = program.command("pack").description("Manage packs");
 packCmd.command("create <name>").description("Create a new pack scaffold").action((name) => {
-  runPackCreate(resolve26("."), name);
+  runPackCreate(resolve29("."), name);
 });
 packCmd.command("list").description("List all configured packs and their status").action(() => {
-  runPackList(resolve26("."));
+  runPackList(resolve29("."));
 });
 packCmd.command("validate").description("Validate all configured packs").action(() => {
-  runPackValidate(resolve26("."));
+  runPackValidate(resolve29("."));
 });
 packCmd.command("enable <name>").description("Enable a previously disabled pack").action((name) => {
-  runPackEnable(resolve26("."), name);
+  runPackEnable(resolve29("."), name);
 });
 packCmd.command("disable <name>").description("Disable a pack without removing it").action((name) => {
-  runPackDisable(resolve26("."), name);
+  runPackDisable(resolve29("."), name);
 });
 program.parse();