@tuned-tensor/cli 0.11.0 → 0.12.0-beta.0

package/dist/{chunk-DAP2Z7EZ.js → chunk-HDGBDHOB.js}

@@ -558,17 +558,59 @@ async function assertArtifactManifest(manifestPath, options = {}) {
 import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
 import { resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+var NEMOTRON_BF16_REVISION = "ce38b6ab8b252b4b8ee7165b4605e93191cafd73";
+var MUSE_GLIMMER_BF16_REVISION = "a4e59da52a7bc87ae7251dd5545c0dd437c44b68";
 var TRAINING_MODELS = [
   {
     id: "Qwen/Qwen3.5-2B",
     family: "qwen3_5",
+    modelLoader: "causal_lm",
     defaultLearningRate: 1e-5,
     defaultPerDeviceBatchSize: 1,
     defaultGradientAccumulationSteps: 8,
     defaultLoraRank: 16,
     defaultLoraAlpha: 32,
     defaultLoraDropout: 0.05,
-    defaultMaxSeqLength: 2048
+    defaultMaxSeqLength: 2048,
+    loraTargetModules: "all-linear",
+    gradientCheckpointing: false
+  },
+  {
+    id: "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16",
+    family: "nemotron_h",
+    defaultRevision: NEMOTRON_BF16_REVISION,
+    modelLoader: "causal_lm",
+    defaultLearningRate: 1e-5,
+    defaultPerDeviceBatchSize: 1,
+    defaultGradientAccumulationSteps: 8,
+    defaultLoraRank: 16,
+    defaultLoraAlpha: 32,
+    defaultLoraDropout: 0.05,
+    defaultMaxSeqLength: 1024,
+    // Avoid one LoRA pair for every routed expert matrix. Adapt the shared
+    // attention (q/k/v/o) and Mamba input projections instead, keeping the
+    // adapter bounded. out_proj/conv1d are rejected by PEFT for Mamba models.
+    loraTargetModules: ["q_proj", "k_proj", "v_proj", "o_proj", "in_proj"],
+    gradientCheckpointing: true
+  },
+  {
+    id: "meta-models/Muse-Glimmer-30B",
+    family: "muse_glimmer",
+    defaultRevision: MUSE_GLIMMER_BF16_REVISION,
+    // Muse Glimmer is a vision-language model whose text tower is not exposed
+    // through the causal-LM auto mapping, so the bundled runtime loads the full
+    // conditional-generation checkpoint (vision tower frozen and unused) via
+    // AutoModelForImageTextToText for text-only SFT.
+    modelLoader: "image_text_to_text",
+    defaultLearningRate: 1e-5,
+    defaultPerDeviceBatchSize: 1,
+    defaultGradientAccumulationSteps: 8,
+    defaultLoraRank: 16,
+    defaultLoraAlpha: 32,
+    defaultLoraDropout: 0.05,
+    defaultMaxSeqLength: 2048,
+    loraTargetModules: "all-linear",
+    gradientCheckpointing: true
   }
 ];
 function resolveTrainingModel(modelId) {
@@ -578,7 +620,7 @@ function resolveTrainingModel(modelId) {
   );
   if (!model) {
     throw new Error(
-      `Unsupported base model "${modelId}". Supported model: ${TRAINING_MODELS[0].id}`
+      `Unsupported base model "${modelId}". Supported models: ${TRAINING_MODELS.map((item) => item.id).join(", ")}`
     );
   }
   return model;
@@ -586,7 +628,22 @@ function resolveTrainingModel(modelId) {
 function canonicalizeTrainingModel(modelId) {
   return resolveTrainingModel(modelId).id;
 }
-var CERTIFIED_TEXT_CONFIG = {
+function resolveRequestedBaseModelRevision(modelId, requestedRevision) {
+  const model = resolveTrainingModel(modelId);
+  if (model.defaultRevision && requestedRevision && requestedRevision !== model.defaultRevision) {
+    throw new Error(
+      `${model.id} must use certified revision ${model.defaultRevision}; got ${requestedRevision}.`
+    );
+  }
+  return requestedRevision ?? model.defaultRevision;
+}
+function defaultBaseModelRevision(modelId) {
+  return resolveRequestedBaseModelRevision(modelId);
+}
+function resolveModelLoader(modelId) {
+  return resolveTrainingModel(modelId).modelLoader;
+}
+var CERTIFIED_QWEN_TEXT_CONFIG = {
   model_type: "qwen3_5_text",
   hidden_size: 2048,
   num_hidden_layers: 24,
@@ -595,27 +652,99 @@ var CERTIFIED_TEXT_CONFIG = {
   intermediate_size: 6144,
   vocab_size: 248320
 };
-function assertCertifiedBaseModelConfig(value, label = "base-model config.json") {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${label} must contain a JSON object.`);
-  }
-  const config = value;
+var CERTIFIED_MUSE_GLIMMER_TEXT_CONFIG = {
+  model_type: "muse_glimmer_text",
+  hidden_size: 6656,
+  num_hidden_layers: 52,
+  num_attention_heads: 32,
+  num_key_value_heads: 2,
+  intermediate_size: 19968,
+  vocab_size: 202048
+};
+var CERTIFIED_NEMOTRON_CONFIG = {
+  hidden_size: 2688,
+  num_hidden_layers: 52,
+  num_attention_heads: 32,
+  num_key_value_heads: 2,
+  intermediate_size: 1856,
+  vocab_size: 131072,
+  n_routed_experts: 128,
+  num_experts_per_tok: 6,
+  num_nextn_predict_layers: 1,
+  max_position_embeddings: 262144
+};
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasArchitecture(config, architecture) {
   const architectures = config.architectures;
+  return Array.isArray(architectures) && architectures.includes(architecture);
+}
+function assertCertifiedTextTowerConfig(config, label, certifiedModelId, architecture, certifiedTextConfig) {
+  if (!hasArchitecture(config, architecture)) {
+    throw new Error(`${label} is not the certified ${certifiedModelId} architecture.`);
+  }
   const textConfig = config.text_config;
-  if (config.model_type !== "qwen3_5" || !Array.isArray(architectures) || !architectures.includes("Qwen3_5ForConditionalGeneration") || !textConfig || typeof textConfig !== "object" || Array.isArray(textConfig)) {
-    throw new Error(
-      `${label} is not the certified Qwen/Qwen3.5-2B architecture.`
-    );
+  if (!isRecord(textConfig)) {
+    throw new Error(`${label} is not the certified ${certifiedModelId} architecture.`);
   }
-  const text = textConfig;
-  for (const [key, expected] of Object.entries(CERTIFIED_TEXT_CONFIG)) {
-    if (text[key] !== expected) {
+  for (const [key, expected] of Object.entries(certifiedTextConfig)) {
+    if (textConfig[key] !== expected) {
       throw new Error(
-        `${label} is not the certified Qwen/Qwen3.5-2B architecture: text_config.${key} must be ${JSON.stringify(expected)}.`
+        `${label} is not the certified ${certifiedModelId} architecture: text_config.${key} must be ${JSON.stringify(expected)}.`
       );
     }
   }
 }
+function assertCertifiedBaseModelConfig(value, label = "base-model config.json", expectedModelId) {
+  if (!isRecord(value)) {
+    throw new Error(`${label} must contain a JSON object.`);
+  }
+  const config = value;
+  const expectedFamily = expectedModelId ? resolveTrainingModel(expectedModelId).family : void 0;
+  if (config.model_type === "qwen3_5") {
+    if (expectedFamily && expectedFamily !== "qwen3_5") {
+      throw new Error(`${label} does not match requested base model ${expectedModelId}.`);
+    }
+    assertCertifiedTextTowerConfig(
+      config,
+      label,
+      "Qwen/Qwen3.5-2B",
+      "Qwen3_5ForConditionalGeneration",
+      CERTIFIED_QWEN_TEXT_CONFIG
+    );
+    return;
+  }
+  if (config.model_type === "muse_glimmer") {
+    if (expectedFamily && expectedFamily !== "muse_glimmer") {
+      throw new Error(`${label} does not match requested base model ${expectedModelId}.`);
+    }
+    assertCertifiedTextTowerConfig(
+      config,
+      label,
+      "meta-models/Muse-Glimmer-30B",
+      "MuseGlimmerForConditionalGeneration",
+      CERTIFIED_MUSE_GLIMMER_TEXT_CONFIG
+    );
+    return;
+  }
+  if (config.model_type === "nemotron_h" && hasArchitecture(config, "NemotronHForCausalLM")) {
+    if (expectedFamily && expectedFamily !== "nemotron_h") {
+      throw new Error(`${label} does not match requested base model ${expectedModelId}.`);
+    }
+    for (const [key, expected] of Object.entries(CERTIFIED_NEMOTRON_CONFIG)) {
+      if (config[key] !== expected) {
+        throw new Error(
+          `${label} is not the certified nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16 architecture: ${key} must be ${JSON.stringify(expected)}.`
+        );
+      }
+    }
+    return;
+  }
+  throw new Error(
+    `${label} is not a certified TT Local base-model architecture.`
+  );
+}
 function localModelArtifactPath(uri) {
   if (uri.startsWith("file://")) return fileURLToPath(new URL(uri));
   if (/^[a-z][a-z0-9+.-]*:/i.test(uri)) {
@@ -1743,8 +1872,10 @@ function createLocalStore(root = defaultLocalHome()) {
 }
 
 // src/local-runtime/prefetch.ts
-import { lstat as lstat3, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, stat as stat4 } from "fs/promises";
-import { join as join5, resolve as resolve8 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { lstat as lstat3, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve as resolve8, sep as sep2 } from "path";
 
 // src/local-runtime/process-runner.ts
 import { createHash as createHash3 } from "crypto";
@@ -2024,11 +2155,195 @@ function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
 }
 
 // src/local-runtime/prefetch.ts
+var NEMOTRON_BF16_FILE_DIGESTS = {
+  ".gitattributes": { algorithm: "sha1", digest: "fe3f694ce14b577c9833fca6e83c5e26a7119127" },
+  "LICENSE": { algorithm: "sha1", digest: "4d76cc87c9edb280753e3bee3b499ae461113835" },
+  "README.md": { algorithm: "sha1", digest: "8ec43ee9f3ee345202e4a6ef752c51b2619f7425" },
+  "accuracy_plot.png": { algorithm: "sha256", digest: "1397995f8a5d34d819a069d86c02914990e9ecfc2fce101e233924da9cf5ddcf" },
+  "agentic_coding_benchmarks.png": { algorithm: "sha256", digest: "06cf5486ae94ecd7cc6f91ae3b4bae21c7435253a294cb89f54f7ec42eda8847" },
+  "bias.md": { algorithm: "sha1", digest: "cdcc8055f965222fabddabcabf22885d3a8bacc1" },
+  "chat_template.jinja": { algorithm: "sha1", digest: "d85b0c772f8fe585063847c5f6bf5ec48eb210be" },
+  "config.json": { algorithm: "sha1", digest: "993b612989e6aa67da45f908ea5983cb777e7678" },
+  "explainability.md": { algorithm: "sha1", digest: "2435f23c865e7daba6a6eceef2f214b86df75d24" },
+  "generation_config.json": { algorithm: "sha1", digest: "a41201df53f9d0769947989353b5d02e70491c56" },
+  "model.safetensors.index.json": { algorithm: "sha1", digest: "3cd409443b1896d9adc5c3981af301841f85329a" },
+  "special_tokens_map.json": { algorithm: "sha1", digest: "0451f37912edb7f8a4bf04d77eef13f6130f0515" },
+  "tokenizer.json": { algorithm: "sha256", digest: "623c34567aebb18582765289fbe23d901c62704d6518d71866e0e58db892b5b7" },
+  "tokenizer_config.json": { algorithm: "sha1", digest: "c96e5ad00986bfa0b666d4bc425666f1c51d6d1b" },
+  "model-00001-of-00014.safetensors": { algorithm: "sha256", digest: "7a3e74d24969eac6657cb9b6422091fd062b7d30fd4bc90ecee6c3d7f692626a" },
+  "model-00002-of-00014.safetensors": { algorithm: "sha256", digest: "a80c3846e959f6dda34aa031cbb668b766643691ac7e5c9f43f62e6fb1221059" },
+  "model-00003-of-00014.safetensors": { algorithm: "sha256", digest: "996bf3a46668e14075cb82259390267c2b1f71446caeb3a5f1f9e0bd7a079ae7" },
+  "model-00004-of-00014.safetensors": { algorithm: "sha256", digest: "cce1d79e7ff2e2b746b9d97166156aa1dcec796116675cc7fd1aa70a8d73ccb2" },
+  "model-00005-of-00014.safetensors": { algorithm: "sha256", digest: "9338f59d3fd5f074288c71a9559452d5b5c581da00e9ccb9fe7aa2ce9b04d2ad" },
+  "model-00006-of-00014.safetensors": { algorithm: "sha256", digest: "e947fa4097c68263ba3d097fceb32a300a22cebd9d909fb5198af7d18a4022fe" },
+  "model-00007-of-00014.safetensors": { algorithm: "sha256", digest: "c7362630bf4256275ca58354ed8f31506cec67ffab30573e753703fd5ae48795" },
+  "model-00008-of-00014.safetensors": { algorithm: "sha256", digest: "1b33a5a6b5505b25b57c90ddda19e9cd1598176468917df0c56116fa6f6072cb" },
+  "model-00009-of-00014.safetensors": { algorithm: "sha256", digest: "fcc9b48caff427beaf1f87b78cf4ab42bc2a3c43b3c487bccb013ba22d7468b2" },
+  "model-00010-of-00014.safetensors": { algorithm: "sha256", digest: "d1924fd54d1b77a15aff8df591a317e8a82a58e46d6f5742fa21e90e0be3cfa6" },
+  "model-00011-of-00014.safetensors": { algorithm: "sha256", digest: "e9d0b83bcf04bd4d5758b94e6495a3f1595d121d82faffaa27ce6a884e2c8757" },
+  "model-00012-of-00014.safetensors": { algorithm: "sha256", digest: "fce184f112cb0b97024cadc60f993f6f660e365d04e21c240fb3c75747bd3a01" },
+  "model-00013-of-00014.safetensors": { algorithm: "sha256", digest: "f427d037d2a3e4d44323325aa38571e3551e8ad702f469c3dacc4e59ea2e50d1" },
+  "model-00014-of-00014.safetensors": { algorithm: "sha256", digest: "64577b275ca4e7e5266eae0903674f7f46ec2a8cbf4f4f1a3207f80d503cd1d0" },
+  "privacy.md": { algorithm: "sha1", digest: "e3bf30aa1c42a488298ef37383647dc99e1cd39e" },
+  "safety.md": { algorithm: "sha1", digest: "f53bf94a4635862eed5cf3e0bc799b93f81d20ac" }
+};
+var MUSE_GLIMMER_FILE_DIGESTS = {
+  ".gitattributes": { algorithm: "sha1", digest: "52373fe24473b1aa44333d318f578ae6bf04b49b" },
+  "LICENSE": { algorithm: "sha1", digest: "d645695673349e3947e8e5ae42332d0ac3164cd7" },
+  "README.md": { algorithm: "sha1", digest: "a25f87c1c1fbd88f367a552fd14427baa8cb947e" },
+  "USAGE_POLICY.md": { algorithm: "sha1", digest: "1a9ed6cffc54585daf9cc904c07cb6e436a9444b" },
+  "chat_template.jinja": { algorithm: "sha1", digest: "7507f3c9f38809152732c045df3977848f3916a6" },
+  "config.json": { algorithm: "sha1", digest: "190826dc834c13c86b8dc68e775a888a852d7c34" },
+  "generation_config.json": { algorithm: "sha1", digest: "b69a50a4239f42707d54a479e0143b8ee56c8bcc" },
+  "model.safetensors.index.json": { algorithm: "sha1", digest: "00b257ef0c8bce1b001a6266f6b1f66f4fe16a6b" },
+  "processor_config.json": { algorithm: "sha1", digest: "ec9a07be13ea1dadf7395131871753b13f406c26" },
+  "tokenizer_config.json": { algorithm: "sha1", digest: "fe7f0bb90fb0d0288e3a505974ae0e4baf1d3e61" },
+  "tokenizer.json": { algorithm: "sha256", digest: "c9dbee66967b58f31a7c27f723c3760da3526ccd0427578e8905b0abb0031c4d" },
+  "model-00001-of-00002.safetensors": { algorithm: "sha256", digest: "8eef61530e1283642c77ce2e6721feb5c6f348fa055c00e90f2844a136372694" },
+  "model-00002-of-00002.safetensors": { algorithm: "sha256", digest: "b58cc2144ba1ba1af4420f67f4ca3ced7f09298510b80464cc75018a0be14381" }
+};
+function certifiedFileDigests(modelId) {
+  switch (modelId) {
+    case "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16":
+      return NEMOTRON_BF16_FILE_DIGESTS;
+    case "meta-models/Muse-Glimmer-30B":
+      return MUSE_GLIMMER_FILE_DIGESTS;
+    default:
+      return void 0;
+  }
+}
+async function certifiedFileDigest(path, expected) {
+  const metadata = await stat4(path);
+  const digest = createHash4(expected.algorithm);
+  if (expected.algorithm === "sha1") digest.update(`blob ${metadata.size}\0`);
+  for await (const chunk of createReadStream2(path)) digest.update(chunk);
+  return digest.digest("hex");
+}
+function isStrictPhysicalDescendant(parent, child) {
+  const candidate = relative2(parent, child);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep2}`) && !isAbsolute3(candidate);
+}
+async function verifySnapshotCacheLocation(path, modelId, revision, modelCache) {
+  const repository = `models--${modelId.replaceAll("/", "--")}`;
+  const layout = resolveHuggingFaceCacheLayout(modelCache);
+  const repositoryRoot = join5(layout.hubCache, repository);
+  const expectedPath = join5(repositoryRoot, "snapshots", revision);
+  const [
+    physicalCacheRoot,
+    physicalHubRoot,
+    physicalRepositoryRoot,
+    physicalBlobRoot,
+    physicalPath,
+    physicalExpectedPath
+  ] = await Promise.all([
+    realpath2(layout.hfHome).catch(() => null),
+    realpath2(layout.hubCache).catch(() => null),
+    realpath2(repositoryRoot).catch(() => null),
+    realpath2(join5(repositoryRoot, "blobs")).catch(() => null),
+    realpath2(path).catch(() => null),
+    realpath2(expectedPath).catch(() => null)
+  ]);
+  if (!physicalCacheRoot || !physicalHubRoot || !physicalRepositoryRoot || !physicalBlobRoot || !physicalPath || !physicalExpectedPath || physicalPath !== physicalExpectedPath) {
+    throw new Error(
+      `${modelId} must use the certified Hugging Face cache snapshot ${expectedPath}; got ${path}.`
+    );
+  }
+  if (!isStrictPhysicalDescendant(physicalCacheRoot, physicalHubRoot)) {
+    throw new Error(`Hugging Face hub cache escapes its configured cache root: ${layout.hubCache}`);
+  }
+  if (!isStrictPhysicalDescendant(physicalHubRoot, physicalRepositoryRoot)) {
+    throw new Error(`Hugging Face repository escapes its configured hub cache: ${repositoryRoot}`);
+  }
+  if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalBlobRoot)) {
+    throw new Error(`Hugging Face blob store escapes its repository: ${join5(repositoryRoot, "blobs")}`);
+  }
+  if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalExpectedPath)) {
+    throw new Error(`Hugging Face snapshot escapes its configured repository: ${expectedPath}`);
+  }
+  return { repositoryRoot, physicalBlobRoot };
+}
+async function requireReportedCachePath(label, reported, expected) {
+  const [physicalReported, physicalExpected] = await Promise.all([
+    reported ? realpath2(reported).catch(() => null) : null,
+    realpath2(expected).catch(() => null)
+  ]);
+  if (!physicalReported || !physicalExpected || physicalReported !== physicalExpected) {
+    throw new Error(`Model prefetch returned an unexpected ${label}: ${String(reported)}.`);
+  }
+}
+async function verifyModelPrefetchCacheReport(args) {
+  if (!args.output.snapshot_path) {
+    throw new Error("Model prefetch did not return a snapshot path.");
+  }
+  const effectiveHubCache = resolveHuggingFaceCacheLayout(args.modelCache).hubCache;
+  await Promise.all([
+    requireReportedCachePath("model cache", args.output.model_cache, args.modelCache),
+    requireReportedCachePath("HF home", args.output.hf_home, args.modelCache),
+    requireReportedCachePath("hub cache", args.output.hub_cache, effectiveHubCache)
+  ]);
+  await verifySnapshotCacheLocation(
+    args.output.snapshot_path,
+    args.modelId,
+    args.revision,
+    args.modelCache
+  );
+}
+async function verifyCertifiedLocalSnapshot(path, modelId, snapshotFiles, modelCache) {
+  const revision = defaultBaseModelRevision(modelId);
+  if (!revision) return;
+  const digests = certifiedFileDigests(modelId);
+  if (!digests) {
+    throw new Error(`No certified file digests are registered for pinned model ${modelId}.`);
+  }
+  if (!modelCache) {
+    throw new Error(`A certified local snapshot for ${modelId} requires paths.modelCache.`);
+  }
+  const { physicalBlobRoot } = await verifySnapshotCacheLocation(
+    path,
+    modelId,
+    revision,
+    modelCache
+  );
+  const physicalFiles = /* @__PURE__ */ new Map();
+  for (const file of snapshotFiles) {
+    const metadata = await lstat3(file);
+    const target = await realpath2(file);
+    if (metadata.isSymbolicLink()) {
+      if (!isStrictPhysicalDescendant(physicalBlobRoot, target)) {
+        throw new Error(`Certified snapshot symbolic link escapes its Hugging Face blob store: ${file}`);
+      }
+    }
+    physicalFiles.set(file, target);
+  }
+  const actualFiles = new Set(snapshotFiles.map((file) => relative2(path, file).split("\\").join("/")));
+  const expectedFiles = new Set(Object.keys(digests));
+  const unexpected = [...actualFiles].filter((name) => !expectedFiles.has(name)).sort();
+  if (unexpected.length > 0) {
+    throw new Error(`Certified snapshot contains unexpected file: ${join5(path, unexpected[0])}`);
+  }
+  for (const [name, expected] of Object.entries(digests)) {
+    if (!actualFiles.has(name)) {
+      throw new Error(`Certified snapshot file is missing: ${join5(path, name)}`);
+    }
+    const file = join5(path, name);
+    const physicalFile = physicalFiles.get(file);
+    if (await certifiedFileDigest(physicalFile, expected) !== expected.digest) {
+      throw new Error(`Certified snapshot file checksum mismatch: ${file}`);
+    }
+    if (await realpath2(file) !== physicalFile) {
+      throw new Error(`Certified snapshot file changed during verification: ${file}`);
+    }
+  }
+}
 function buildModelPrefetchPayload(request, config) {
   const model = resolveTrainingModel(request.spec_snapshot.base_model);
+  const revision = resolveRequestedBaseModelRevision(
+    model.id,
+    request.hyperparameters.base_model_revision
+  );
   return {
     base_model: model.id,
-    ...request.hyperparameters.base_model_revision ? { revision: request.hyperparameters.base_model_revision } : {},
+    ...revision ? { revision } : {},
     ...config.paths.modelCache ? { model_cache: resolve8(config.paths.modelCache) } : {}
   };
 }
@@ -2039,7 +2354,7 @@ function transformersWeightName(name) {
   const lower = name.split(/[\\/]/).at(-1)?.toLowerCase() ?? "";
   return lower.endsWith(".safetensors") && !lower.startsWith("adapter_") || /^pytorch_model.*\.bin$/.test(lower);
 }
-async function verifyLocalBaseModel(path) {
+async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
   const root = await lstat3(path).catch(() => null);
   if (!root) throw new Error(`paths.baseModel is set to ${path}, but that path does not exist.`);
   if (root.isSymbolicLink()) {
@@ -2054,14 +2369,19 @@ async function verifyLocalBaseModel(path) {
   const visit = async (directory) => {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
       const child = join5(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        const metadata2 = await stat4(child);
+        if (!metadata2.isFile()) {
+          throw new Error(`Local base model contains a non-file symbolic link: ${child}`);
+        }
+        files.push({ path: child, size: metadata2.size });
+        continue;
+      }
       if (entry.isDirectory()) {
         await visit(child);
         continue;
       }
       const metadata = await stat4(child);
-      if (entry.isSymbolicLink() && !metadata.isFile()) {
-        throw new Error(`Local base model contains a non-file symbolic link: ${child}`);
-      }
       if (metadata.isFile()) files.push({ path: child, size: metadata.size });
     }
   };
@@ -2078,9 +2398,25 @@ async function verifyLocalBaseModel(path) {
   if (!await required("config.json")) throw new Error(`Local base-model directory is missing config.json: ${path}`);
   try {
     const config = JSON.parse(await readFile5(join5(path, "config.json"), "utf8"));
-    assertCertifiedBaseModelConfig(config, `Local base-model config ${join5(path, "config.json")}`);
+    assertCertifiedBaseModelConfig(
+      config,
+      `Local base-model config ${join5(path, "config.json")}`,
+      expectedModelId
+    );
   } catch (error) {
-    throw new Error(`Local base-model directory has an invalid or unsupported config.json: ${path}`, { cause: error });
+    const detail = error instanceof Error ? `: ${error.message}` : "";
+    throw new Error(
+      `Local base-model directory has an invalid or unsupported config.json: ${path}${detail}`,
+      { cause: error }
+    );
+  }
+  if (expectedModelId) {
+    await verifyCertifiedLocalSnapshot(
+      path,
+      expectedModelId,
+      files.map((file) => file.path),
+      modelCache
+    );
   }
   const vocabNames = [
     "tokenizer.json",
@@ -2110,6 +2446,10 @@ async function verifyLocalBaseModel(path) {
   };
 }
 async function prefetchBaseModel(args) {
+  const payload = {
+    ...buildModelPrefetchPayload(args.request, args.config),
+    ...args.localOnly ? { local_files_only: true } : {}
+  };
   const artifactDir = resolve8(
     args.config.artifactRoot,
     args.localOnly ? "verify-base" : "prefetch",
@@ -2118,7 +2458,11 @@ async function prefetchBaseModel(args) {
   await mkdir5(artifactDir, { recursive: true });
   if (args.config.paths.baseModel) {
     const localPath = resolve8(args.config.paths.baseModel);
-    const verified = await verifyLocalBaseModel(localPath);
+    const verified = await verifyLocalBaseModel(
+      localPath,
+      args.request.spec_snapshot.base_model,
+      args.config.paths.modelCache
+    );
     return {
       ok: true,
       status: args.localOnly ? "completed" : "skipped",
@@ -2130,10 +2474,6 @@ async function prefetchBaseModel(args) {
       reason: args.localOnly ? "Verified the configured local base-model artifact; no network access was used." : "paths.baseModel points at a verified local base-model artifact; no Hugging Face download is needed."
     };
   }
-  const payload = {
-    ...buildModelPrefetchPayload(args.request, args.config),
-    ...args.localOnly ? { local_files_only: true } : {}
-  };
   const inputPath = join5(artifactDir, "prefetch-input.json");
   const outputPath = join5(artifactDir, "prefetch-output.json");
   const logPath = join5(artifactDir, "prefetch.log");
@@ -2153,12 +2493,13 @@ async function prefetchBaseModel(args) {
       log_path: logPath
     }
   });
-  const env = withBundledPythonEnvironment(
-    withHuggingFaceCacheEnvironment(
-      minimalMachineLearningEnvironment(process.env),
-      payload.model_cache
-    )
+  const cacheEnvironment = withHuggingFaceCacheEnvironment(
+    minimalMachineLearningEnvironment(process.env),
+    payload.model_cache
   );
+  const effectiveModelCache = cacheEnvironment.HF_HOME;
+  const effectiveHubCache = resolveHuggingFaceCacheLayout(effectiveModelCache).hubCache;
+  const env = withBundledPythonEnvironment(cacheEnvironment);
   const { exitCode } = await runLoggedProcess({
     command: entrypoint.command,
     commandArgs: entrypoint.commandArgs,
@@ -2179,14 +2520,35 @@ async function prefetchBaseModel(args) {
       "Model prefetch did not resolve the base model to a 40-character immutable commit SHA."
     );
   }
+  if (output.base_model !== payload.base_model) {
+    throw new Error(`Model prefetch returned ${String(output.base_model)} for requested model ${payload.base_model}.`);
+  }
+  if (payload.revision && snapshotRevision.data !== payload.revision.toLowerCase()) {
+    throw new Error(
+      `Model prefetch resolved a different revision (${snapshotRevision.data}) than requested (${payload.revision}).`
+    );
+  }
+  await verifyModelPrefetchCacheReport({
+    modelId: payload.base_model,
+    revision: snapshotRevision.data,
+    modelCache: effectiveModelCache,
+    output
+  });
+  if (defaultBaseModelRevision(payload.base_model)) {
+    await verifyLocalBaseModel(
+      output.snapshot_path,
+      payload.base_model,
+      effectiveModelCache
+    );
+  }
   await args.reporter?.onEvent?.({
     stage: "model_prefetch",
     status: "completed",
     message: "Base model is available in the local Hugging Face cache.",
     details: {
       base_model: output.base_model ?? payload.base_model,
-      hf_home: output.hf_home ?? output.model_cache ?? payload.model_cache ?? null,
-      hub_cache: output.hub_cache ?? null,
+      hf_home: effectiveModelCache,
+      hub_cache: effectiveHubCache,
       snapshot_path: output.snapshot_path ?? null,
       snapshot_revision: snapshotRevision.data,
       file_count: output.file_count ?? null,
@@ -2198,9 +2560,9 @@ async function prefetchBaseModel(args) {
     ok: true,
     status: "completed",
     base_model: output.base_model ?? payload.base_model,
-    model_cache: output.model_cache ?? payload.model_cache,
-    hf_home: output.hf_home ?? output.model_cache ?? payload.model_cache,
-    hub_cache: output.hub_cache,
+    model_cache: effectiveModelCache,
+    hf_home: effectiveModelCache,
+    hub_cache: effectiveHubCache,
     snapshot_path: output.snapshot_path,
     snapshot_revision: snapshotRevision.data,
     file_count: output.file_count,
@@ -2235,14 +2597,14 @@ function evaluateGeneralRegressionGate(comparison, policy) {
 
 // src/local-runtime/orchestrator.ts
 import { lstat as lstat4, mkdir as mkdir8, open as open2, readFile as readFile8, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
-import { createReadStream as createReadStream2 } from "fs";
-import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
+import { createReadStream as createReadStream3 } from "fs";
+import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import { performance } from "perf_hooks";
 import { homedir as homedir5 } from "os";
-import { basename, dirname as dirname8, join as join8, relative as relative2, resolve as resolve11 } from "path";
+import { basename, dirname as dirname8, join as join8, relative as relative3, resolve as resolve11 } from "path";
 
 // src/local-runtime/evaluation.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "fs/promises";
 import { dirname as dirname7, join as join6, resolve as resolve9 } from "path";
 function normalize(value) {
@@ -2470,8 +2832,9 @@ async function runTransformersInference(args) {
     kind: args.kind,
     model_id: args.modelId,
     base_model: args.baseModelId,
+    model_source: args.modelSource,
     base_model_revision: args.baseModelRevision,
-    model_loader: "causal_lm",
+    model_loader: resolveModelLoader(args.baseModelId),
     adapter_path: fileUriToPath(args.adapterPath),
     system: args.system,
     examples: args.examples.map((example, index) => ({
@@ -2544,7 +2907,7 @@ function assertEvaluationScoringReady(config) {
   }
 }
 function baselineCacheKey(args) {
-  return createHash4("sha256").update(JSON.stringify({
+  return createHash5("sha256").update(JSON.stringify({
     v: 6,
     inference_protocol_version: INFERENCE_PROTOCOL_VERSION,
     package_version: args.packageVersion,
@@ -2642,19 +3005,26 @@ async function scoreGenerated(args) {
 }
 async function evaluateExamples(args) {
   assertEvaluationScoringReady(args.config);
+  const baseModelId = args.baseModelId ?? args.modelId;
+  const requestedBaseModelRevision = resolveRequestedBaseModelRevision(
+    baseModelId,
+    args.baseModelRevision
+  );
+  const localModelSource = args.modelSource ? resolve9(args.modelSource) !== resolve9(baseModelId) : false;
+  const baseModelRevision = localModelSource ? defaultBaseModelRevision(baseModelId) : requestedBaseModelRevision;
   const maxExamples = args.config.evaluation.maxExamples ?? args.maxExamples ?? args.examples.length;
   const truncated = args.examples.length > maxExamples;
   const seed = args.config.evaluation.sampleSeed ?? args.sampleSeed ?? 0;
   const examples = truncated ? sampleExamples(args.examples, maxExamples, seed) : args.examples;
   const evalSampleSeed = truncated || args.evalSplit === "spec_holdout" ? seed : null;
   const cacheEligible = args.kind === "baseline" && args.config.evaluation.baselineCache && !args.config.dryRun && baselineInputsAreStable({
-    baseModelRevision: args.baseModelRevision,
+    baseModelRevision,
     sourceFingerprint: args.sourceFingerprint,
     config: args.config
   });
   const cacheKey = cacheEligible ? baselineCacheKey({
     modelId: args.modelId,
-    baseModelRevision: args.baseModelRevision,
+    baseModelRevision,
     sourceFingerprint: args.sourceFingerprint,
     system: args.system,
     examples,
@@ -2685,8 +3055,9 @@ async function evaluateExamples(args) {
   const inference = args.config.dryRun ? null : await runTransformersInference({
     kind: args.kind,
     modelId: args.modelId,
-    baseModelId: args.baseModelId ?? args.modelId,
-    baseModelRevision: args.baseModelRevision,
+    baseModelId,
+    modelSource: args.modelSource ?? args.modelId,
+    baseModelRevision,
     adapterPath: args.adapterPath,
     examples,
     system: args.system,
@@ -2761,6 +3132,7 @@ function buildTrainingHyperparameters(request, options = {}) {
   const hyper = request.hyperparameters;
   return {
     base_model: model.id,
+    model_loader: model.modelLoader,
     ...options.baseModelRevision ? { base_model_revision: options.baseModelRevision } : {},
     n_epochs: String(hyper.n_epochs),
     learning_rate: String(hyper.learning_rate ?? model.defaultLearningRate),
@@ -2771,7 +3143,9 @@ function buildTrainingHyperparameters(request, options = {}) {
     lora_rank: String(hyper.lora_rank ?? model.defaultLoraRank),
     lora_alpha: String(hyper.lora_alpha ?? model.defaultLoraAlpha),
     lora_dropout: String(hyper.lora_dropout ?? model.defaultLoraDropout),
-    max_seq_length: String(hyper.max_seq_length ?? model.defaultMaxSeqLength)
+    max_seq_length: String(hyper.max_seq_length ?? model.defaultMaxSeqLength),
+    lora_target_modules: Array.isArray(model.loraTargetModules) ? model.loraTargetModules.join(",") : model.loraTargetModules,
+    gradient_checkpointing: String(model.gradientCheckpointing)
   };
 }
 async function pathExists(path) {
@@ -2884,6 +3258,13 @@ async function launchProcessTraining(args) {
     if (value === void 0) delete childEnv[key];
   }
   if (config.paths.modelCache) await mkdir7(resolve10(config.paths.modelCache), { recursive: true });
+  if (config.paths.baseModel) {
+    await verifyLocalBaseModel(
+      resolve10(config.paths.baseModel),
+      request.spec_snapshot.base_model,
+      config.paths.modelCache
+    );
+  }
   await args.reporter?.onEvent?.({
     stage: "training",
     status: "running",
@@ -3206,7 +3587,7 @@ function canonicalJson2(value) {
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(object[key])}`).join(",")}}`;
 }
 function hashJson(value) {
-  return createHash5("sha256").update(canonicalJson2(value)).digest("hex");
+  return createHash6("sha256").update(canonicalJson2(value)).digest("hex");
 }
 var packageRoot2 = localRuntimePackageRoot(import.meta.url);
 async function hashFileIfPresent(path) {
@@ -3246,8 +3627,8 @@ function preparedSourceFingerprint(args) {
   });
 }
 async function hashFile(path) {
-  const hash = createHash5("sha256");
-  for await (const chunk of createReadStream2(path)) hash.update(chunk);
+  const hash = createHash6("sha256");
+  for await (const chunk of createReadStream3(path)) hash.update(chunk);
   return hash.digest("hex");
 }
 async function datasetFingerprints(request) {
@@ -3266,24 +3647,28 @@ async function datasetFingerprints(request) {
   return fingerprints;
 }
 async function resolveBaseModelRevision(request, config) {
-  const explicit = request.hyperparameters.base_model_revision;
-  if (explicit) return explicit;
+  const requested = resolveRequestedBaseModelRevision(
+    request.spec_snapshot.base_model,
+    request.hyperparameters.base_model_revision
+  );
   if (config.paths.baseModel) {
-    const match = resolve11(config.paths.baseModel).match(/[\\/]snapshots[\\/]([^\\/]+)(?:[\\/]|$)/);
-    if (match?.[1]) return match[1];
+    return defaultBaseModelRevision(request.spec_snapshot.base_model);
+  }
+  if (requested) return requested;
+  if (!request.spec_snapshot.base_model.includes("/")) {
+    return defaultBaseModelRevision(request.spec_snapshot.base_model);
   }
-  if (!request.spec_snapshot.base_model.includes("/")) return void 0;
   const repository = `models--${request.spec_snapshot.base_model.replaceAll("/", "--")}`;
   const cacheEnvironment = withHuggingFaceCacheEnvironment(process.env, config.paths.modelCache);
   const refPath = resolve11(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
   try {
     const revision = (await readFile8(refPath, "utf8")).trim();
-    return revision || void 0;
+    if (revision) return revision;
   } catch {
-    return void 0;
   }
+  return defaultBaseModelRevision(request.spec_snapshot.base_model);
 }
-async function fingerprintLocalBaseModel(uri) {
+async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
   const root = localModelArtifactPath(uri);
   const rootMetadata = await lstat4(root);
   if (rootMetadata.isSymbolicLink()) {
@@ -3292,7 +3677,7 @@ async function fingerprintLocalBaseModel(uri) {
   if (!rootMetadata.isDirectory()) {
     throw new Error(`Local base model must be a Hugging Face snapshot directory: ${root}`);
   }
-  await verifyLocalBaseModel(root);
+  await verifyLocalBaseModel(root, expectedModelId, modelCache);
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir5(directory, { withFileTypes: true })) {
@@ -3307,7 +3692,7 @@ async function fingerprintLocalBaseModel(uri) {
       }
       if (!childMetadata.isFile()) continue;
       files.push({
-        path: relative2(root, child).split("\\").join("/"),
+        path: relative3(root, child).split("\\").join("/"),
         size_bytes: childMetadata.size,
         sha256: await hashFile(child)
       });
@@ -3390,7 +3775,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
   await removeReport();
 }
 function manifestRelativePath(artifacts, path) {
-  return relative2(artifacts.runDir, path).split("\\").join("/");
+  return relative3(artifacts.runDir, path).split("\\").join("/");
 }
 async function verifyReusableArtifacts(artifacts, paths, options = {}) {
   if (!await pathExists2(artifacts.artifactManifestJson)) return false;
@@ -3487,7 +3872,7 @@ async function modelManifestContract(prepared, training) {
     format,
     framework: "transformers-peft",
     base_model: prepared.request.spec_snapshot.base_model,
-    base_model_revision: prepared.metadata.base_model_revision ?? prepared.request.hyperparameters.base_model_revision,
+    base_model_revision: prepared.metadata.base_model_revision ?? void 0,
     base_model_artifact_uri: training.base_model_artifact_uri,
     base_model_fingerprint: prepared.metadata.base_model_fingerprint ?? void 0,
     artifact_uri: training.model_artifact_uri,
@@ -3673,7 +4058,11 @@ async function computePreparedRun(args) {
   const requestFingerprint = hashJson(request);
   const runtimeFingerprintValue = await runtimeFingerprint();
   const baseModelRevision = await resolveBaseModelRevision(request, config);
-  const baseModelFingerprint = config.paths.baseModel ? await fingerprintLocalBaseModel(config.paths.baseModel) : void 0;
+  const baseModelFingerprint = config.paths.baseModel ? await fingerprintLocalBaseModel(
+    config.paths.baseModel,
+    request.spec_snapshot.base_model,
+    config.paths.modelCache
+  ) : void 0;
   const metadata = {
     run_id: request.run_id,
     behavior_spec_id: request.behavior_spec_id,
@@ -3706,7 +4095,7 @@ async function computePreparedRun(args) {
     base_model_for_evaluation: baseModelForEvaluation,
     base_model_revision: baseModelRevision ?? null,
     base_model_fingerprint: baseModelFingerprint ?? null,
-    system_prompt_sha256: createHash5("sha256").update(system).digest("hex"),
+    system_prompt_sha256: createHash6("sha256").update(system).digest("hex"),
     prepared_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (args.writeArtifacts) await writeJsonAtomic(artifacts.stageMetadataJson, metadata);
@@ -3810,7 +4199,8 @@ async function runBaselineStage(args) {
   const report = await evaluateExamples({
     kind: "baseline",
     modelId: args.prepared.baseModelForEvaluation,
-    baseModelId: args.prepared.baseModelForEvaluation,
+    baseModelId: args.prepared.request.spec_snapshot.base_model,
+    modelSource: args.prepared.baseModelForEvaluation,
     baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
     sourceFingerprint: args.prepared.metadata.base_model_fingerprint ?? void 0,
     examples: args.prepared.examples,
@@ -3839,7 +4229,8 @@ async function runBaselineStage(args) {
     await evaluateExamples({
       kind: "baseline",
       modelId: args.prepared.baseModelForEvaluation,
-      baseModelId: args.prepared.baseModelForEvaluation,
+      baseModelId: args.prepared.request.spec_snapshot.base_model,
+      modelSource: args.prepared.baseModelForEvaluation,
       baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
       sourceFingerprint: args.prepared.metadata.base_model_fingerprint ?? void 0,
       examples: args.prepared.generalRegression.examples,
@@ -3901,7 +4292,9 @@ async function runTrainStage(args) {
     request: args.prepared.request,
     artifacts: args.prepared.artifacts,
     config: args.config,
-    baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+    // Python loads a configured snapshot by local path, but still needs this
+    // certified revision to enforce registry-pinned model provenance.
+    baseModelRevision: args.prepared.metadata.base_model_revision ?? void 0,
     reporter: args.runReporter,
     shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
   });
@@ -4005,7 +4398,8 @@ async function runCandidateStage(args) {
   const report = await evaluateExamples({
     kind: "candidate",
     modelId: modelArtifact,
-    baseModelId: args.prepared.baseModelForEvaluation,
+    baseModelId: args.prepared.request.spec_snapshot.base_model,
+    modelSource: args.prepared.baseModelForEvaluation,
     baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
     adapterPath: modelArtifact,
     examples: args.prepared.examples,
@@ -4034,7 +4428,8 @@ async function runCandidateStage(args) {
     await evaluateExamples({
       kind: "candidate",
       modelId: modelArtifact,
-      baseModelId: args.prepared.baseModelForEvaluation,
+      baseModelId: args.prepared.request.spec_snapshot.base_model,
+      modelSource: args.prepared.baseModelForEvaluation,
       baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
       adapterPath: modelArtifact,
       examples: args.prepared.generalRegression.examples,
@@ -4336,7 +4731,11 @@ async function runLocalFineTune(input) {
 export {
   writeJsonAtomic,
   assertArtifactManifest,
+  TRAINING_MODELS,
   resolveTrainingModel,
+  resolveRequestedBaseModelRevision,
+  defaultBaseModelRevision,
+  resolveModelLoader,
   assertUsableModelArtifact,
   datasetFormatSchema,
   baseModelRevisionSchema,
@@ -4383,6 +4782,7 @@ export {
   withHuggingFaceCacheEnvironment,
   withOfflineHuggingFaceCacheEnvironment,
   tokenF1,
+  verifyModelPrefetchCacheReport,
   buildModelPrefetchPayload,
   verifyLocalBaseModel,
   prefetchBaseModel,
@@ -4397,4 +4797,4 @@ export {
   runLocalPipeline,
   runLocalFineTune
 };
-//# sourceMappingURL=chunk-DAP2Z7EZ.js.map
+//# sourceMappingURL=chunk-HDGBDHOB.js.map