@tuned-tensor/cli 0.13.1-beta.4 → 0.13.1-beta.6

package/dist/{chunk-7VIUHQBI.js → chunk-W7MOBPCO.js}

@@ -477,37 +477,37 @@ async function verifyTarGzipArchive(path) {
       if (sizeText && !/^[0-7]+$/.test(sizeText)) throw new Error(`Invalid tar member size in ${path}.`);
       const size = sizeText ? Number.parseInt(sizeText, 8) : 0;
       if (!Number.isSafeInteger(size) || size < 0) throw new Error(`Invalid tar member size in ${path}.`);
-      const type = String.fromCharCode(header[156] ?? 0);
-      if (type !== "\0" && type !== "0" && type !== "5" && type !== "x" && type !== "g") {
-        throw new Error(`Unsafe or unsupported tar member type ${JSON.stringify(type)} in ${path}.`);
+      const type2 = String.fromCharCode(header[156] ?? 0);
+      if (type2 !== "\0" && type2 !== "0" && type2 !== "5" && type2 !== "x" && type2 !== "g") {
+        throw new Error(`Unsafe or unsupported tar member type ${JSON.stringify(type2)} in ${path}.`);
       }
       const shortName = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
       const prefix = header.subarray(345, 500).toString("utf8").replace(/\0.*$/, "");
       const headerPath = safeMemberPath(prefix ? `${prefix}/${shortName}` : shortName);
-      const memberPath = type === "x" || type === "g" ? headerPath : safeMemberPath(pendingPaxPath ?? headerPath);
-      if (type !== "x" && type !== "g") pendingPaxPath = void 0;
+      const memberPath = type2 === "x" || type2 === "g" ? headerPath : safeMemberPath(pendingPaxPath ?? headerPath);
+      if (type2 !== "x" && type2 !== "g") pendingPaxPath = void 0;
       const segments = memberPath.split("/").filter(Boolean);
       const name = segments.at(-1)?.toLowerCase();
       const metadataOnly = name === "training-metrics.json" || name === "trainer_state.json" || name === "training_args.bin" || name === "config.json" || name === "generation_config.json" || name === "adapter_config.json" || name === "readme.md" || name?.startsWith("tokenizer") || name?.startsWith("special_tokens") || name?.startsWith("added_tokens") || name === "vocab.json" || name === "merges.txt";
       const recognizedPayload = Boolean(name) && name !== "training_args.bin" && (name.endsWith(".safetensors") || name.endsWith(".bin"));
       const adapterWeight = name === "adapter_model.safetensors" || name === "adapter_model.bin";
       const fullModelWeight = Boolean(name) && (name.endsWith(".safetensors") && !name.startsWith("adapter_") || /^pytorch_model.*\.bin$/.test(name));
-      if (size > 0 && name === "adapter_config.json" && (type === "\0" || type === "0")) {
+      if (size > 0 && name === "adapter_config.json" && (type2 === "\0" || type2 === "0")) {
         adapterConfigEntries += 1;
       }
-      if ((type === "x" || type === "g") && size > maxPaxBytes) {
+      if ((type2 === "x" || type2 === "g") && size > maxPaxBytes) {
         throw new Error(`PAX metadata exceeds 1 MiB in ${path}.`);
       }
-      if (size > 0 && !metadataOnly && (type === "\0" || type === "0")) payloadEntries += 1;
-      if (size > 0 && recognizedPayload && (type === "\0" || type === "0")) {
+      if (size > 0 && !metadataOnly && (type2 === "\0" || type2 === "0")) payloadEntries += 1;
+      if (size > 0 && recognizedPayload && (type2 === "\0" || type2 === "0")) {
         recognizedPayloadEntries += 1;
         recognizedPayloadBytes += size;
       }
-      if (size > 0 && adapterWeight && (type === "\0" || type === "0")) {
+      if (size > 0 && adapterWeight && (type2 === "\0" || type2 === "0")) {
         adapterWeightEntries += 1;
         adapterWeightBytes += size;
       }
-      if (size > 0 && fullModelWeight && (type === "\0" || type === "0")) {
+      if (size > 0 && fullModelWeight && (type2 === "\0" || type2 === "0")) {
         fullModelWeightEntries += 1;
         fullModelWeightBytes += size;
       }
@@ -515,7 +515,7 @@ async function verifyTarGzipArchive(path) {
       if (expandedBytes > maxExpandedBytes) throw new Error(`Tar archive exceeds 20 GiB expanded size: ${path}.`);
       payloadBytes = size;
       paddingBytes = (512 - size % 512) % 512;
-      paxType = type === "x" || type === "g" ? type : null;
+      paxType = type2 === "x" || type2 === "g" ? type2 : null;
       paxChunks = [];
       entries += 1;
       if (entries > maxEntries) throw new Error(`Tar archive exceeds ${maxEntries} members: ${path}.`);
@@ -834,28 +834,371 @@ async function assertUsableModelArtifact(uri) {
   return inspection;
 }
 
-// src/local-runtime/store.ts
-import { appendFile, chmod, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir2, readdir as readdir3, readFile as readFile2, rename as rename2, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve4, sep as sep2 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+// src/local-runtime/run-reporter.ts
+function reportInBackground(action) {
+  try {
+    void Promise.resolve(action()).catch(() => void 0);
+  } catch {
+  }
+}
+function sanitizeLogLine(line) {
+  return line.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|secret|password)=)[^\s]+/gi, "$1[redacted]");
+}
+function forwardStreamLines(stream, onLine) {
+  let buffered = "";
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk) => {
+    buffered += chunk;
+    const lines = buffered.split(/\r\n|\n|\r/);
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim()) onLine(sanitizeLogLine(line));
+    }
+  });
+  stream.on("end", () => {
+    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
+  });
+}
 
-// src/paths.ts
+// src/local-runtime/package-root.ts
 import { existsSync } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function localRuntimePackageRoot(moduleUrl) {
+  const moduleDirectory = dirname2(fileURLToPath2(moduleUrl));
+  const candidates = [
+    dirname2(moduleDirectory),
+    dirname2(dirname2(moduleDirectory))
+  ];
+  const root = candidates.find(
+    (candidate) => existsSync(resolve3(candidate, "package.json")) && existsSync(resolve3(candidate, "training/adapter"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  }
+  return root;
+}
+
+// src/local-runtime/capability-profiles.ts
+var GIB = 1024 ** 3;
+function gib(n) {
+  return Math.round(n * GIB);
+}
+var FOUNDATION_DEFAULT_DEPTH = 2;
+var FOUNDATION_MAX_DEPTH = 64;
+var FOUNDATION_DEFAULT_VOCAB = 256;
+var FOUNDATION_DEFAULT_SEQUENCE = 64;
+var FOUNDATION_DEFAULT_BATCH = 2;
+var ADAPTER_MEMORY_PROFILES = [
+  {
+    id: "Qwen/Qwen3.5-2B",
+    diskBytes: gib(8),
+    inferenceBytes: gib(8),
+    trainBytes: gib(16),
+    sparkClass: false
+  },
+  {
+    id: "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16",
+    diskBytes: gib(80),
+    inferenceBytes: gib(80),
+    trainBytes: gib(96),
+    sparkClass: true
+  },
+  {
+    id: "meta-models/Muse-Glimmer-30B",
+    diskBytes: gib(80),
+    inferenceBytes: gib(80),
+    trainBytes: gib(96),
+    sparkClass: true
+  }
+];
+function adapterMemoryProfile(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  return ADAPTER_MEMORY_PROFILES.find((profile) => profile.id.toLowerCase() === normalized);
+}
+function foundationWidth(depth) {
+  return 32 * depth;
+}
+function foundationParamCount(depth, vocabSize = FOUNDATION_DEFAULT_VOCAB, sequenceLength = FOUNDATION_DEFAULT_SEQUENCE) {
+  const width = foundationWidth(depth);
+  return 12 * depth * width * width + vocabSize * width + sequenceLength * width;
+}
+function foundationTrainBytes(depth, options = {}) {
+  const vocabSize = options.vocabSize ?? FOUNDATION_DEFAULT_VOCAB;
+  const sequenceLength = options.sequenceLength ?? FOUNDATION_DEFAULT_SEQUENCE;
+  const batchSize = options.batchSize ?? FOUNDATION_DEFAULT_BATCH;
+  const params = foundationParamCount(depth, vocabSize, sequenceLength);
+  const width = foundationWidth(depth);
+  const activationSlack = batchSize * sequenceLength * width * depth * 64;
+  return 16 * params + activationSlack;
+}
+function foundationInferenceBytes(depth, options = {}) {
+  const params = foundationParamCount(
+    depth,
+    options.vocabSize ?? FOUNDATION_DEFAULT_VOCAB,
+    options.sequenceLength ?? FOUNDATION_DEFAULT_SEQUENCE
+  );
+  return 4 * params + gib(0.25);
+}
+function isUnifiedGpuName(name) {
+  if (!name) return false;
+  return /spark|gb10/i.test(name);
+}
+
+// src/local-runtime/capability.ts
+var HEADROOM = 1.2;
+var FIT_RATIO = 0.7;
+function formatGiB(bytes) {
+  const amount = bytes / 1024 ** 3;
+  const precision = amount >= 10 ? 0 : 1;
+  return `${amount.toFixed(precision)} GiB`;
+}
+function compareFit(available, required, missing) {
+  if (available === void 0) {
+    return { status: "not_possible", reason: missing, required_bytes: required };
+  }
+  if (available < required) {
+    return {
+      status: "not_possible",
+      reason: `needs ~${formatGiB(required)}; ${formatGiB(available)} available`,
+      required_bytes: required,
+      available_bytes: available
+    };
+  }
+  if (available < required * HEADROOM) {
+    return {
+      status: "tight",
+      reason: `fits in ${formatGiB(available)} with little headroom (needs ~${formatGiB(required)})`,
+      required_bytes: required,
+      available_bytes: available
+    };
+  }
+  return {
+    status: "ready",
+    reason: `${formatGiB(available)} available (needs ~${formatGiB(required)})`,
+    required_bytes: required,
+    available_bytes: available
+  };
+}
+function trainingBlockers(inventory) {
+  const blockers = [];
+  if (!inventory.node.ok) blockers.push(`Node ${inventory.node.version} is below 22`);
+  if (inventory.uv && !inventory.uv.ok) blockers.push(inventory.uv.message);
+  if (inventory.python && !inventory.python.ok) blockers.push(inventory.python.message);
+  return blockers;
+}
+function cudaAvailable(inventory) {
+  if (inventory.python?.ok && inventory.python.cuda_available !== void 0) {
+    return inventory.python.cuda_available;
+  }
+  return inventory.nvidia_smi.ok && inventory.gpus.length > 0;
+}
+function trainingGpu(inventory) {
+  const listed = inventory.gpus.find((gpu) => gpu.index === 0) ?? inventory.gpus[0];
+  if (listed) {
+    if (!listed.memory_total_bytes && inventory.python?.total_memory_bytes) {
+      return { ...listed, memory_total_bytes: inventory.python.total_memory_bytes };
+    }
+    return listed;
+  }
+  if (inventory.python?.cuda_device) {
+    return {
+      index: 0,
+      name: inventory.python.cuda_device,
+      memory_total_bytes: inventory.python.total_memory_bytes,
+      unified_memory: isUnifiedGpuName(inventory.python.cuda_device)
+    };
+  }
+  return void 0;
+}
+function gpuMemory(gpu) {
+  return gpu?.memory_total_bytes;
+}
+function diskForCache(inventory) {
+  return inventory.disks.find((disk) => disk.name === "model-cache")?.free_bytes;
+}
+function worse(left, right) {
+  const rank = { not_possible: 2, tight: 1, ready: 0 };
+  return rank[left.status] >= rank[right.status] ? left : right;
+}
+function withBlockers(verdict, blockers) {
+  if (blockers.length === 0) return verdict;
+  return {
+    status: "not_possible",
+    reason: blockers.join("; "),
+    required_bytes: verdict.required_bytes,
+    available_bytes: verdict.available_bytes
+  };
+}
+function adapterVerdicts(profile, inventory, gpu, hasCuda) {
+  const blockers = trainingBlockers(inventory);
+  const gpuBytes = gpuMemory(gpu);
+  const ram = inventory.os.total_memory_bytes;
+  const disk = diskForCache(inventory);
+  let train;
+  if (!hasCuda) {
+    train = {
+      status: "not_possible",
+      reason: "LoRA training requires CUDA",
+      required_bytes: profile.trainBytes
+    };
+  } else {
+    train = compareFit(gpuBytes, profile.trainBytes, "GPU memory is unknown");
+  }
+  train = withBlockers(train, blockers);
+  if (disk !== void 0 && disk < profile.diskBytes && train.status !== "not_possible") {
+    train = worse(train, compareFit(disk, profile.diskBytes, "model cache disk is unknown"));
+  }
+  const finetune = train;
+  let inference;
+  if (hasCuda) {
+    inference = compareFit(gpuBytes, profile.inferenceBytes, "GPU memory is unknown");
+  } else {
+    inference = compareFit(ram, profile.inferenceBytes, "system RAM is unknown");
+    if (inference.status !== "not_possible") {
+      inference = {
+        ...inference,
+        reason: `CPU inference: ${inference.reason}`
+      };
+    }
+  }
+  return {
+    id: profile.id,
+    spark_class: profile.sparkClass,
+    train,
+    finetune,
+    inference
+  };
+}
+function suggestedFoundationDepth(availableBytes) {
+  if (availableBytes === void 0) return FOUNDATION_DEFAULT_DEPTH;
+  const budget = availableBytes * FIT_RATIO;
+  let suggested = FOUNDATION_DEFAULT_DEPTH;
+  for (let depth = FOUNDATION_DEFAULT_DEPTH; depth <= FOUNDATION_MAX_DEPTH; depth += 1) {
+    if (foundationTrainBytes(depth) <= budget) suggested = depth;
+    else break;
+  }
+  return suggested;
+}
+function evaluateCapabilities(inventory) {
+  const hasCuda = cudaAvailable(inventory);
+  const gpu = trainingGpu(inventory);
+  const notes = [];
+  if (gpu?.unified_memory || isUnifiedGpuName(gpu?.name)) {
+    notes.push("GPU memory is a unified pool shared with system RAM (Spark-class).");
+  }
+  if (inventory.quick) {
+    notes.push("Quick probe skipped the bundled torch/uv runtime.");
+  }
+  if (!inventory.node.ok) {
+    notes.push(`Node ${inventory.node.version} is below the 22.x required by the local runner.`);
+  }
+  const adapters = ADAPTER_MEMORY_PROFILES.map(
+    (profile) => adapterVerdicts(profile, inventory, gpu, hasCuda)
+  );
+  const blockers = trainingBlockers(inventory);
+  const gpuBytes = gpuMemory(gpu);
+  const ram = inventory.os.total_memory_bytes;
+  const trainBudget = hasCuda ? gpuBytes : void 0;
+  const suggested = suggestedFoundationDepth(trainBudget);
+  const defaultTrain = foundationTrainBytes(FOUNDATION_DEFAULT_DEPTH);
+  const inferBudget = hasCuda ? gpuBytes : ram;
+  let train;
+  if (!hasCuda) {
+    train = {
+      status: "not_possible",
+      reason: "Foundation pretrain, SFT, and RL require CUDA",
+      required_bytes: defaultTrain
+    };
+  } else {
+    train = compareFit(gpuBytes, defaultTrain, "GPU memory is unknown");
+  }
+  train = withBlockers(train, blockers);
+  const inference = compareFit(
+    inferBudget,
+    foundationInferenceBytes(FOUNDATION_DEFAULT_DEPTH),
+    hasCuda ? "GPU memory is unknown" : "system RAM is unknown"
+  );
+  const foundation = {
+    default_depth: FOUNDATION_DEFAULT_DEPTH,
+    suggested_max_depth: hasCuda && blockers.length === 0 ? suggested : FOUNDATION_DEFAULT_DEPTH,
+    train,
+    finetune: train,
+    inference: hasCuda ? inference : { ...inference, reason: `CPU eval: ${inference.reason}` },
+    serve: {
+      status: "not_possible",
+      reason: "tt serve cannot host foundation checkpoints yet"
+    }
+  };
+  return { cuda_available: hasCuda, gpu, adapters, foundation, notes };
+}
+function formatCapabilitySummary(report) {
+  const gpu = report.gpu;
+  const gpuLabel = gpu ? `${gpu.name}${gpu.memory_total_bytes ? `, ${formatGiB(gpu.memory_total_bytes)}` : ""}${gpu.unified_memory ? " unified" : ""}` : "no NVIDIA GPU";
+  const adapterBits = report.adapters.map((adapter) => {
+    const short = adapter.id.split("/").at(-1) ?? adapter.id;
+    return `${short} train ${adapter.train.status}`;
+  });
+  return [
+    `GPU ${gpuLabel}, CUDA ${report.cuda_available ? "yes" : "no"}`,
+    `Adapter: ${adapterBits.join("; ")}`,
+    `Foundation: train ${report.foundation.train.status}, suggested max depth ${report.foundation.suggested_max_depth}; serve not supported`
+  ].join(". ");
+}
+function warningsFromSnapshot(report, target) {
+  const warnings = [];
+  if (target.engine === "foundation") {
+    for (const kind of ["train", "finetune"]) {
+      const verdict = report.foundation[kind];
+      if (verdict.status === "not_possible" || verdict.status === "tight") {
+        warnings.push(`Foundation ${kind} is ${verdict.status}: ${verdict.reason}`);
+      }
+    }
+    return warnings;
+  }
+  const modelId = target.baseModel;
+  const adapter = modelId ? report.adapters.find((item) => item.id.toLowerCase() === modelId.trim().toLowerCase()) : void 0;
+  if (!adapter) {
+    if (modelId && !adapterMemoryProfile(modelId)) return warnings;
+    const blocked = report.adapters.filter((item) => item.train.status === "not_possible");
+    if (blocked.length === report.adapters.length) {
+      warnings.push(`Adapter train is not_possible: ${report.adapters[0]?.train.reason ?? "CUDA required"}`);
+    }
+    return warnings;
+  }
+  for (const kind of ["train", "finetune", "inference"]) {
+    const verdict = adapter[kind];
+    if (verdict.status === "not_possible" || verdict.status === "tight") {
+      warnings.push(`${adapter.id} ${kind} is ${verdict.status}: ${verdict.reason}`);
+    }
+  }
+  return warnings;
+}
+
+// src/local-runtime/host-inventory.ts
+import { constants as constants2 } from "fs";
+import { access, statfs } from "fs/promises";
+import { cpus, freemem, homedir as homedir3, totalmem, type } from "os";
+import { dirname as dirname5, join as join5, resolve as resolve7 } from "path";
+import { spawn as spawn2 } from "child_process";
+
+// src/paths.ts
+import { existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
-import { isAbsolute as isAbsolute2, join as join2, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve4 } from "path";
 var TUNED_TENSOR_DIR = ".tuned-tensor";
 var DEFAULT_ARTIFACT_ROOT = `${TUNED_TENSOR_DIR}/artifacts`;
 var DEFAULT_PROJECT_STORE_ROOT = `${TUNED_TENSOR_DIR}/store`;
 var DEFAULT_FOUNDATION_RUNS_DIR = `${TUNED_TENSOR_DIR}/foundation-runs`;
 function envHome(env = process.env) {
   const home = env.HOME?.trim();
-  return home ? resolve3(home) : homedir();
+  return home ? resolve4(home) : homedir();
 }
 function expandUserPath(value, env = process.env, baseDirectory = process.cwd()) {
   const trimmed = value.trim();
   if (trimmed === "~") return envHome(env);
-  if (trimmed.startsWith("~/")) return resolve3(envHome(env), trimmed.slice(2));
-  return isAbsolute2(trimmed) ? resolve3(trimmed) : resolve3(baseDirectory, trimmed);
+  if (trimmed.startsWith("~/")) return resolve4(envHome(env), trimmed.slice(2));
+  return isAbsolute2(trimmed) ? resolve4(trimmed) : resolve4(baseDirectory, trimmed);
 }
 function getTunedTensorHome(env = process.env) {
   const override = env.TUNED_TENSOR_HOME?.trim();
@@ -863,14 +1206,14 @@ function getTunedTensorHome(env = process.env) {
   return join2(envHome(env), TUNED_TENSOR_DIR);
 }
 function legacyConfigDir(env) {
-  const configHome = env.XDG_CONFIG_HOME?.trim() ? resolve3(env.XDG_CONFIG_HOME) : join2(envHome(env), ".config");
+  const configHome = env.XDG_CONFIG_HOME?.trim() ? resolve4(env.XDG_CONFIG_HOME) : join2(envHome(env), ".config");
   return join2(configHome, "tuned-tensor");
 }
 function getConfigDir(env = process.env) {
   const next = getTunedTensorHome(env);
   if (env.TUNED_TENSOR_HOME?.trim()) return next;
   const legacy = legacyConfigDir(env);
-  if (!existsSync(join2(next, "config.json")) && existsSync(join2(legacy, "config.json"))) {
+  if (!existsSync2(join2(next, "config.json")) && existsSync2(join2(legacy, "config.json"))) {
     return legacy;
   }
   return next;
@@ -879,7 +1222,7 @@ function getAgentConfigDir(env = process.env) {
   const next = join2(getTunedTensorHome(env), "agent");
   if (env.TUNED_TENSOR_HOME?.trim()) return next;
   const legacy = join2(legacyConfigDir(env), "agent");
-  if (!existsSync(next) && existsSync(legacy)) return legacy;
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
   return next;
 }
 function defaultStoreRoot(env = process.env) {
@@ -888,7 +1231,7 @@ function defaultStoreRoot(env = process.env) {
   const next = join2(getTunedTensorHome(env), "store");
   if (env.TUNED_TENSOR_HOME?.trim()) return next;
   const legacy = join2(envHome(env), ".tuned-tensor-local");
-  if (!existsSync(next) && existsSync(legacy)) return legacy;
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
   return next;
 }
 function defaultCacheRoot(env = process.env) {
@@ -897,179 +1240,878 @@ function defaultCacheRoot(env = process.env) {
 function pythonEnvironmentPath(kind, hash, env = process.env) {
   const next = join2(defaultCacheRoot(env), kind, hash);
   if (env.TUNED_TENSOR_HOME?.trim()) return next;
-  const cacheHome = env.XDG_CACHE_HOME?.trim() ? resolve3(env.XDG_CACHE_HOME) : join2(envHome(env), ".cache");
+  const cacheHome = env.XDG_CACHE_HOME?.trim() ? resolve4(env.XDG_CACHE_HOME) : join2(envHome(env), ".cache");
   const legacy = join2(cacheHome, "tuned-tensor-local", kind, hash);
-  if (!existsSync(next) && existsSync(legacy)) return legacy;
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
   return next;
 }
 
-// src/local-runtime/store.ts
-function isTerminalRunState(state) {
-  return state.status === "stage_completed" || state.status === "completed" || state.status === "failed" || state.status === "cancelled" && state.current_stage === "cancelled" && Boolean(state.completed_at);
-}
-function defaultLocalHome() {
-  return defaultStoreRoot();
+// src/local-runtime/huggingface-cache.ts
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve5 } from "path";
+function minimalMachineLearningEnvironment(env) {
+  const exact = /* @__PURE__ */ new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "LANG",
+    "LANGUAGE",
+    "LD_LIBRARY_PATH",
+    "DYLD_LIBRARY_PATH",
+    "XDG_CACHE_HOME",
+    "SSL_CERT_FILE",
+    "REQUESTS_CA_BUNDLE",
+    "CURL_CA_BUNDLE",
+    "NO_PROXY",
+    "no_proxy",
+    "UV_CACHE_DIR",
+    "UV_PYTHON",
+    "HF_HOME",
+    "HF_HUB_CACHE",
+    "HUGGINGFACE_HUB_CACHE",
+    "HF_ENDPOINT",
+    "HF_TOKEN",
+    "HF_HUB_OFFLINE",
+    "HF_HUB_DISABLE_TELEMETRY",
+    "TRANSFORMERS_OFFLINE",
+    "HF_HUB_ENABLE_HF_TRANSFER",
+    "PYTHONUTF8",
+    "PYTHONIOENCODING"
+  ]);
+  const prefixes = [
+    "LC_",
+    "CUDA_",
+    "NVIDIA_",
+    "NCCL_",
+    "OMP_",
+    "MKL_",
+    "TORCH_",
+    "PYTORCH_",
+    "TOKENIZERS_",
+    "HF_XET_"
+  ];
+  const result = Object.fromEntries(Object.entries(env).filter(
+    ([key]) => exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix))
+  ));
+  result.TORCH_DISABLE_NATIVE_JIT ??= "1";
+  return result;
 }
-function localStorePaths(root) {
+function resolveHuggingFaceCacheLayout(modelCache) {
+  const hfHome = resolve5(modelCache);
   return {
-    root,
-    specsDir: join3(root, "specs"),
-    runsDir: join3(root, "runs"),
-    modelsDir: join3(root, "models"),
-    datasetsDir: join3(root, "datasets")
+    hfHome,
+    hubCache: join3(hfHome, "hub")
   };
 }
-async function exists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensurePrivateDirectory(path) {
-  await mkdir2(path, { recursive: true, mode: 448 });
-  const metadata = await lstat3(path);
-  if (metadata.isSymbolicLink()) {
-    throw new Error(`Refusing symbolic link in local store: ${path}`);
-  }
-  if (!metadata.isDirectory()) {
-    throw new Error(`Expected local store directory: ${path}`);
-  }
-  await chmod(path, 448);
+function withHuggingFaceCacheEnvironment(env, modelCache) {
+  const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
+  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname3(resolve5(inheritedHub)) : join3(homedir2(), ".cache", "huggingface"));
+  const layout = resolveHuggingFaceCacheLayout(canonicalHome);
+  const result = {
+    ...env,
+    HF_HOME: layout.hfHome,
+    HF_HUB_CACHE: layout.hubCache,
+    HUGGINGFACE_HUB_CACHE: layout.hubCache
+  };
+  delete result.TRANSFORMERS_CACHE;
+  delete result.PYTORCH_TRANSFORMERS_CACHE;
+  delete result.PYTORCH_PRETRAINED_BERT_CACHE;
+  return result;
 }
-async function hardenPrivateTree(path) {
-  const metadata = await lstat3(path);
-  if (metadata.isSymbolicLink()) {
-    throw new Error(`Refusing symbolic link in local store: ${path}`);
-  }
-  if (metadata.isDirectory()) {
-    await chmod(path, 448);
-    for (const entry of await readdir3(path)) {
-      await hardenPrivateTree(join3(path, entry));
-    }
-    return;
-  }
-  if (metadata.isFile()) {
-    await chmod(path, 384);
-    return;
-  }
-  throw new Error(`Refusing unsupported filesystem entry in local store: ${path}`);
+function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
+  return {
+    ...withHuggingFaceCacheEnvironment(env, modelCache),
+    HF_HUB_OFFLINE: "1",
+    TRANSFORMERS_OFFLINE: "1"
+  };
 }
-async function hardenExistingLocalStore(root) {
-  const resolvedRoot = resolve4(root);
-  let metadata;
-  try {
-    metadata = await lstat3(resolvedRoot);
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-  if (metadata.isSymbolicLink()) {
-    throw new Error(`Refusing symbolic link in local store: ${resolvedRoot}`);
+
+// src/local-runtime/process-runner.ts
+import { createHash as createHash2 } from "crypto";
+import { spawn } from "child_process";
+import { constants, readFileSync } from "fs";
+import { mkdir as mkdir2, open as open2 } from "fs/promises";
+import { dirname as dirname4, join as join4, resolve as resolve6 } from "path";
+var packageRoot = localRuntimePackageRoot(import.meta.url);
+var bundledProject = join4(packageRoot, "training/adapter");
+var bundledRuntimeHash = (() => {
+  const hash = createHash2("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join4(bundledProject, name)));
   }
-  if (!metadata.isDirectory()) {
-    throw new Error(`Expected local store directory: ${resolvedRoot}`);
+  return hash.digest("hex").slice(0, 20);
+})();
+var BUNDLED_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv", bundledRuntimeHash);
+var foundationProject = join4(packageRoot, "training/foundation");
+var foundationRuntimeHash = (() => {
+  const hash = createHash2("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join4(foundationProject, name)));
   }
-  await hardenPrivateTree(resolvedRoot);
-  return true;
-}
-async function writePrivateJsonAtomic(path, value) {
-  await ensurePrivateDirectory(dirname2(path));
-  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
-  await writeFile2(tmp, `${JSON.stringify(value, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-  await rename2(tmp, path);
-  await chmod(path, 384);
-}
-async function readJson2(path) {
-  return JSON.parse(await readFile2(path, "utf8"));
-}
-async function appendJsonl(path, value) {
-  await ensurePrivateDirectory(dirname2(path));
-  await appendFile(path, `${JSON.stringify(value)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-  await chmod(path, 384);
+  return hash.digest("hex").slice(0, 20);
+})();
+var FOUNDATION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-foundation", foundationRuntimeHash);
+function buildBundledPythonCommand(entrypoint, args = []) {
+  const target = entrypoint === "-c" ? entrypoint : join4(bundledProject, "src", entrypoint);
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--quiet",
+    "--project",
+    bundledProject,
+    "python",
+    target,
+    ...args
+  ];
+  return {
+    command: "uv",
+    commandArgs,
+    displayCommand: ["uv", ...commandArgs]
+  };
 }
-async function writePrivateText(path, value) {
-  await ensurePrivateDirectory(dirname2(path));
-  await writeFile2(path, value, { encoding: "utf8", mode: 384 });
-  await chmod(path, 384);
+function withBundledPythonEnvironment(env) {
+  return {
+    ...env,
+    UV_PROJECT_ENVIRONMENT: BUNDLED_PYTHON_ENVIRONMENT
+  };
 }
-async function readJsonl(path) {
-  if (!await exists(path)) return [];
-  return (await readFile2(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+function buildFoundationPythonCommand(entrypoint, args = []) {
+  const target = entrypoint === "-c" ? entrypoint : join4(foundationProject, "src", entrypoint);
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--quiet",
+    "--project",
+    foundationProject,
+    "python",
+    target,
+    ...args
+  ];
+  return {
+    command: "uv",
+    commandArgs,
+    displayCommand: ["uv", ...commandArgs]
+  };
 }
-async function copyIfExists(from, to) {
-  if (!await exists(from)) return;
-  await ensurePrivateDirectory(dirname2(to));
-  await copyFile2(from, to);
-  await chmod(to, 384);
+function withFoundationPythonEnvironment(env) {
+  return {
+    ...env,
+    UV_PROJECT_ENVIRONMENT: FOUNDATION_PYTHON_ENVIRONMENT
+  };
 }
-async function childDirectoryNames(path) {
+var ProcessCancelledError = class extends Error {
+  constructor(message = "Process cancelled.") {
+    super(message);
+    this.name = "ProcessCancelledError";
+  }
+};
+async function openProcessLog(path, exclusive, append) {
+  const flags = constants.O_WRONLY | constants.O_CREAT | (exclusive ? constants.O_EXCL : append ? constants.O_APPEND : constants.O_TRUNC) | (process.platform === "win32" ? 0 : constants.O_NOFOLLOW);
+  const handle = await open2(path, flags, 384);
   try {
-    const entries = await readdir3(path, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return handle.createWriteStream({ autoClose: true });
   } catch (error) {
-    if (error.code === "ENOENT") return [];
+    await handle.close();
     throw error;
   }
 }
-function compareIds(left, right) {
-  if (left.id === right.id) return 0;
-  return left.id < right.id ? -1 : 1;
+async function runLoggedProcess(args) {
+  if (args.logPath) await mkdir2(dirname4(args.logPath), { recursive: true });
+  const logStream = args.logPath ? await openProcessLog(args.logPath, args.exclusiveLog ?? false, args.appendLog ?? false) : null;
+  let stderr = "";
+  try {
+    const exitCode = await new Promise((resolvePromise, reject) => {
+      const child = spawn(args.command, args.commandArgs, {
+        cwd: args.cwd ? resolve6(args.cwd) : process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"],
+        env: args.env ?? process.env,
+        detached: process.platform !== "win32"
+      });
+      let timedOut = false;
+      let cancelled = false;
+      let cancellationError;
+      let cancellationCheckRunning = false;
+      let forceKillTimer = null;
+      const killProcessGroup = (signal) => {
+        if (child.pid && process.platform !== "win32") {
+          try {
+            process.kill(-child.pid, signal);
+            return;
+          } catch {
+          }
+        }
+        child.kill(signal);
+      };
+      const requestStop = (signal = "SIGTERM") => {
+        killProcessGroup(signal);
+        if (!forceKillTimer) {
+          forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), args.shutdownGraceMs ?? 5e3);
+          forceKillTimer.unref();
+        }
+      };
+      const onSigint = () => {
+        cancelled = true;
+        requestStop("SIGINT");
+      };
+      const onSigterm = () => {
+        cancelled = true;
+        requestStop("SIGTERM");
+      };
+      process.once("SIGINT", onSigint);
+      process.once("SIGTERM", onSigterm);
+      const timer = args.timeoutMs ? setTimeout(() => {
+        timedOut = true;
+        requestStop();
+      }, args.timeoutMs) : null;
+      const cancellationTimer = args.shouldCancel ? setInterval(() => {
+        if (cancellationCheckRunning || cancelled) return;
+        cancellationCheckRunning = true;
+        Promise.resolve(args.shouldCancel?.()).then((requested) => {
+          if (!requested || cancelled) return;
+          cancelled = true;
+          requestStop();
+        }).catch((error) => {
+          cancellationError = error;
+          requestStop();
+        }).finally(() => {
+          cancellationCheckRunning = false;
+        });
+      }, args.cancelPollMs ?? 250) : null;
+      cancellationTimer?.unref();
+      const clearProcessTimers = () => {
+        if (timer) clearTimeout(timer);
+        if (cancellationTimer) clearInterval(cancellationTimer);
+        if (forceKillTimer) clearTimeout(forceKillTimer);
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+      };
+      if (logStream) {
+        child.stdout.pipe(logStream, { end: false });
+        child.stderr.pipe(logStream, { end: false });
+      }
+      forwardStreamLines(child.stdout, (line) => {
+        args.onLine?.(line, "stdout");
+        if (args.reporter?.verbose) {
+          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stdout", message: line }));
+        }
+      });
+      forwardStreamLines(child.stderr, (line) => {
+        stderr += `${line}
+`;
+        args.onLine?.(line, "stderr");
+        if (args.reporter?.verbose) {
+          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stderr", message: line }));
+        }
+      });
+      child.on("error", (error) => {
+        clearProcessTimers();
+        reject(timedOut ? new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`) : error);
+      });
+      child.on("close", (code) => {
+        if (timedOut || cancelled || cancellationError || args.terminateProcessGroupOnExit) {
+          killProcessGroup("SIGKILL");
+        }
+        clearProcessTimers();
+        if (timedOut) {
+          reject(new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`));
+          return;
+        }
+        if (cancellationError) {
+          reject(cancellationError);
+          return;
+        }
+        if (cancelled) {
+          reject(new ProcessCancelledError(`${args.stage} was cancelled.`));
+          return;
+        }
+        resolvePromise(code ?? 1);
+      });
+    });
+    return { exitCode, stderr };
+  } finally {
+    if (logStream) {
+      await new Promise((resolveEnd) => {
+        logStream.end(resolveEnd);
+      });
+    }
+  }
 }
-function compareUpdatedAt(left, right) {
-  if (left.updated_at !== right.updated_at) return left.updated_at > right.updated_at ? -1 : 1;
-  return compareIds(left, right);
+
+// src/local-runtime/host-inventory.ts
+async function runCommand(command, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  let interrupted;
+  const result = await new Promise((resolveResult) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    let stopError;
+    let forceKillTimer = null;
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const killProcessGroup = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const requestStop = (signal = "SIGTERM") => {
+      killProcessGroup(signal);
+      if (!forceKillTimer) {
+        forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), 5e3);
+        forceKillTimer.unref();
+      }
+    };
+    const onSigint = () => {
+      interrupted = "interrupted by SIGINT";
+      stopError = interrupted;
+      requestStop("SIGINT");
+    };
+    const onSigterm = () => {
+      interrupted = "interrupted by SIGTERM";
+      stopError = interrupted;
+      requestStop("SIGTERM");
+    };
+    const finish = (result2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      resolveResult(result2);
+    };
+    const timer = setTimeout(() => {
+      stopError = `timed out after ${timeoutMs}ms`;
+      requestStop();
+    }, timeoutMs);
+    timer.unref();
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      finish({ code: null, stdout, stderr, error: error.message });
+    });
+    child.on("close", (code) => {
+      finish({ code: stopError ? null : code, stdout, stderr, error: stopError });
+    });
+  });
+  if (interrupted) throw new Error(interrupted);
+  return result;
 }
-function compareCreatedAt(left, right) {
-  if (left.created_at !== right.created_at) return left.created_at > right.created_at ? -1 : 1;
-  return compareIds(left, right);
+function firstLine(value) {
+  return value.trim().split(/\r?\n/)[0] ?? "";
 }
-function findByIdOrPrefix(records, id) {
-  return records.find((record) => record.id === id) ?? records.find((record) => record.id.startsWith(id));
+function parseMiB(value) {
+  if (!value) return void 0;
+  const parsed = Number(value.replace(/[^\d.]/g, ""));
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  return Math.round(parsed * 1024 * 1024);
 }
-function isPathInside(root, candidate) {
-  const resolvedRoot = resolve4(root);
-  const resolvedCandidate = resolve4(candidate);
-  return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
+function isNvidiaSmiDecorativeLine(line) {
+  return /^(?:mon|tue|wed|thu|fri|sat|sun)\b/i.test(line) || line.startsWith("+---") || line.startsWith("|");
 }
-function createLocalStore(root = defaultLocalHome()) {
-  const resolvedRoot = resolve4(root);
-  const paths = localStorePaths(resolvedRoot);
-  const runDir = (id) => join3(paths.runsDir, id);
-  const runStatePath = (id) => join3(runDir(id), "state.json");
-  const runEventsPath = (id) => join3(runDir(id), "progress.jsonl");
-  const runRequestPath = (id) => join3(runDir(id), "request.json");
-  const runReportPath = (id) => join3(runDir(id), "run-report.json");
-  const cancellationPath = (id) => join3(runDir(id), "cancel.requested");
-  const specDir = (id) => join3(paths.specsDir, id);
-  const specPath = (id) => join3(specDir(id), "spec.json");
-  const modelPath = (id) => join3(paths.modelsDir, id, "model.json");
-  let ensurePromise;
-  async function ensureOnce() {
-    await ensurePrivateDirectory(paths.root);
-    await Promise.all([
-      ensurePrivateDirectory(paths.specsDir),
-      ensurePrivateDirectory(paths.runsDir),
-      ensurePrivateDirectory(paths.modelsDir),
-      ensurePrivateDirectory(paths.datasetsDir)
-    ]);
-    await hardenExistingLocalStore(paths.root);
+function gpuFromName(name, index, extras = {}) {
+  return {
+    index,
+    name,
+    unified_memory: /spark|gb10/i.test(name),
+    ...extras
+  };
+}
+function parseNvidiaGpus(stdout) {
+  const gpus = [];
+  for (const line of stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+    if (isNvidiaSmiDecorativeLine(line)) continue;
+    const parts = line.split(",").map((part) => part.trim());
+    if (parts[0] && /^\d+$/.test(parts[0]) && parts.length >= 2) {
+      const name = parts[1] || "NVIDIA GPU";
+      gpus.push(gpuFromName(name, Number(parts[0]), {
+        driver_version: parts[2] || void 0,
+        memory_total_bytes: parseMiB(parts[3]),
+        memory_free_bytes: parseMiB(parts[4]),
+        compute_cap: parts[5] || void 0
+      }));
+      continue;
+    }
+    if (parts.length >= 2 && parts[0] && !/^(?:NVIDIA-SMI|Fail|Error)/i.test(parts[0])) {
+      const name = parts[0];
+      gpus.push(gpuFromName(name, gpus.length, {
+        driver_version: parts[1] || void 0,
+        memory_total_bytes: parseMiB(parts[2]),
+        memory_free_bytes: parseMiB(parts[3])
+      }));
+    }
   }
-  async function ensure() {
-    ensurePromise ??= ensureOnce().catch((error) => {
-      ensurePromise = void 0;
-      throw error;
-    });
-    await ensurePromise;
+  return gpus;
+}
+function parseNvidiaTableGpus(stdout) {
+  const gpus = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const match = line.match(/^\|\s+(\d+)\s+(.+?)\s+(?:On|Off|N\/A)\s+\|/);
+    if (!match) continue;
+    const name = (match[2] ?? "").trim();
+    if (!name || /^NVIDIA-SMI/i.test(name)) continue;
+    gpus.push(gpuFromName(name, Number(match[1])));
+  }
+  return gpus;
+}
+var NVIDIA_CSV_QUERIES = [
+  ["--query-gpu=index,name,driver_version,memory.total,memory.free", "--format=csv,noheader,nounits"],
+  ["--query-gpu=name,driver_version,memory.total,memory.free", "--format=csv,noheader,nounits"],
+  ["--query-gpu=name,driver_version", "--format=csv,noheader"]
+];
+async function queryNvidiaGpus(env) {
+  let last;
+  for (const args of NVIDIA_CSV_QUERIES) {
+    const result = await runCommand("nvidia-smi", args, { env, timeoutMs: 1e4 });
+    last = result;
+    if (result.code !== 0) continue;
+    const gpus2 = parseNvidiaGpus(result.stdout);
+    if (gpus2.length > 0) return { result, gpus: gpus2 };
+  }
+  const table = await runCommand("nvidia-smi", [], { env, timeoutMs: 1e4 });
+  const gpus = table.code === 0 ? parseNvidiaTableGpus(table.stdout) : [];
+  return { result: table.code === 0 || !last ? table : last, gpus };
+}
+async function diskCheck(name, path) {
+  const resolvedPath = resolve7(path);
+  try {
+    await access(resolvedPath, constants2.R_OK);
+    const fs = await statfs(resolvedPath);
+    const freeBytes = Number(fs.bavail) * Number(fs.bsize);
+    return {
+      name,
+      path: resolvedPath,
+      free_bytes: freeBytes,
+      ok: true,
+      message: `${resolvedPath} (${Math.round(freeBytes / 1024 ** 3 * 10) / 10} GiB available)`
+    };
+  } catch (error) {
+    let probe = resolvedPath;
+    for (let i = 0; i < 6; i += 1) {
+      const parent = dirname5(probe);
+      if (parent === probe) break;
+      probe = parent;
+      try {
+        const fs = await statfs(probe);
+        const freeBytes = Number(fs.bavail) * Number(fs.bsize);
+        return {
+          name,
+          path: resolvedPath,
+          free_bytes: freeBytes,
+          ok: true,
+          message: `${resolvedPath} not created yet; ${probe} has ${Math.round(freeBytes / 1024 ** 3 * 10) / 10} GiB available`
+        };
+      } catch {
+        continue;
+      }
+    }
+    return {
+      name,
+      path: resolvedPath,
+      ok: false,
+      message: `${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function pythonProbeSource() {
+  return [
+    "import json",
+    "import torch, transformers, peft, huggingface_hub",
+    "payload = {'python_ok': True, 'torch': torch.__version__, 'transformers': transformers.__version__, 'peft': getattr(peft, '__version__', None), 'cuda_available': bool(torch.cuda.is_available())}",
+    "cuda = torch.cuda.is_available()",
+    "payload.update({'cuda_device': torch.cuda.get_device_name(0), 'compute_capability': list(torch.cuda.get_device_capability(0)), 'total_memory_bytes': torch.cuda.get_device_properties(0).total_memory, 'bf16_supported': bool(torch.cuda.is_bf16_supported())} if cuda else {})",
+    "print(json.dumps(payload))"
+  ].join("; ");
+}
+function parsePythonProbeJson(text) {
+  const line = [...text.split(/\r?\n/)].reverse().find((item) => item.trim().startsWith("{"));
+  if (!line) return void 0;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.python_ok !== true) return void 0;
+    return {
+      ok: true,
+      message: line.trim(),
+      torch: typeof parsed.torch === "string" ? parsed.torch : void 0,
+      transformers: typeof parsed.transformers === "string" ? parsed.transformers : void 0,
+      peft: typeof parsed.peft === "string" ? parsed.peft : void 0,
+      cuda_available: parsed.cuda_available === true,
+      cuda_device: typeof parsed.cuda_device === "string" ? parsed.cuda_device : void 0,
+      compute_capability: Array.isArray(parsed.compute_capability) ? parsed.compute_capability.filter((value) => typeof value === "number") : void 0,
+      total_memory_bytes: typeof parsed.total_memory_bytes === "number" ? parsed.total_memory_bytes : void 0,
+      bf16_supported: parsed.bf16_supported === true
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function collectPythonRuntime(config, env) {
+  const entrypoint = buildBundledPythonCommand("-c", [pythonProbeSource()]);
+  const childEnv = withBundledPythonEnvironment(
+    withHuggingFaceCacheEnvironment(
+      minimalMachineLearningEnvironment(env),
+      config?.paths.modelCache
+    )
+  );
+  const result = await runCommand(entrypoint.command, entrypoint.commandArgs, {
+    env: childEnv,
+    timeoutMs: 18e5
+  });
+  if (result.code === 0) {
+    return parsePythonProbeJson(result.stdout) ?? {
+      ok: true,
+      message: firstLine(result.stdout) || "Python runtime probe succeeded"
+    };
+  }
+  return {
+    ok: false,
+    message: result.error ?? (firstLine(result.stderr) || `uv exited ${result.code}`)
+  };
+}
+async function collectHostInventory(options = {}) {
+  const env = options.env ?? process.env;
+  const config = options.config;
+  const cwd = options.cwd ?? process.cwd();
+  const nodeVersion = process.versions.node;
+  const nodeMajor = Number(nodeVersion.split(".")[0]);
+  const artifactRoot = resolve7(cwd, config?.artifactRoot ?? join5(cwd, DEFAULT_ARTIFACT_ROOT));
+  const storeRoot = resolve7(config?.storeRoot ?? defaultStoreRoot(env));
+  const modelCache = resolve7(
+    config?.paths.modelCache ?? env.HF_HOME ?? join5(homedir3(), ".cache", "huggingface")
+  );
+  const [artifactDisk, storeDisk, cacheDisk, uvVersion, nvidiaQueried] = await Promise.all([
+    diskCheck("artifact-root", artifactRoot),
+    diskCheck("store-root", storeRoot),
+    diskCheck("model-cache", modelCache),
+    runCommand("uv", ["--version"], { env, timeoutMs: 1e4 }),
+    queryNvidiaGpus(env)
+  ]);
+  const nvidia = nvidiaQueried.result;
+  const gpus = nvidiaQueried.gpus;
+  const inventory = {
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    quick: options.quick === true,
+    node: {
+      version: nodeVersion,
+      major: nodeMajor,
+      ok: nodeMajor >= 22
+    },
+    os: {
+      platform: process.platform,
+      arch: process.arch,
+      type: type(),
+      cpu_count: cpus().length,
+      total_memory_bytes: totalmem(),
+      free_memory_bytes: freemem()
+    },
+    uv: {
+      ok: uvVersion.code === 0,
+      version: uvVersion.code === 0 ? firstLine(uvVersion.stdout) : void 0,
+      message: uvVersion.code === 0 ? firstLine(uvVersion.stdout) : uvVersion.error ?? (firstLine(uvVersion.stderr) || "uv is not available")
+    },
+    gpus,
+    nvidia_smi: {
+      ok: nvidia.code === 0,
+      message: nvidia.code === 0 ? gpus[0] ? `${gpus[0].name}${gpus[0].memory_total_bytes ? ` (${Math.round(gpus[0].memory_total_bytes / 1024 ** 3)} GiB)` : ""}` : firstLine(nvidia.stdout) || "nvidia-smi reported a GPU" : nvidia.error ?? (firstLine(nvidia.stderr) || "nvidia-smi not available")
+    },
+    disks: [artifactDisk, storeDisk, cacheDisk]
+  };
+  if (options.quick !== true) {
+    inventory.python = uvVersion.code === 0 ? await collectPythonRuntime(config, env) : { ok: false, message: "Python probe skipped because uv is not available" };
+  }
+  return inventory;
+}
+
+// src/local-runtime/hardware-snapshot.ts
+import { chmod, mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname6, join as join6 } from "path";
+var HARDWARE_SNAPSHOT_VERSION = 1;
+var HARDWARE_SNAPSHOT_TTL_MS = 24 * 60 * 60 * 1e3;
+function hardwareSnapshotPath(env = process.env) {
+  return join6(getTunedTensorHome(env), "hardware.json");
+}
+async function readHardwareSnapshot(env = process.env) {
+  const path = hardwareSnapshotPath(env);
+  try {
+    const parsed = JSON.parse(await readFile2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const snapshot = parsed;
+    if (snapshot.version !== HARDWARE_SNAPSHOT_VERSION) return void 0;
+    if (typeof snapshot.collected_at !== "string" || !snapshot.capabilities || !snapshot.inventory) {
+      return void 0;
+    }
+    const age = Date.now() - Date.parse(snapshot.collected_at);
+    const stale = !Number.isFinite(age) || age > HARDWARE_SNAPSHOT_TTL_MS || age < 0;
+    return { ...snapshot, stale, path };
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    return void 0;
+  }
+}
+async function writeHardwareSnapshot(snapshot, env = process.env) {
+  const path = hardwareSnapshotPath(env);
+  await mkdir3(dirname6(path), { recursive: true, mode: 448 });
+  const gpu = snapshot.capabilities.gpu;
+  const record = {
+    version: HARDWARE_SNAPSHOT_VERSION,
+    collected_at: snapshot.collected_at,
+    quick: snapshot.quick,
+    gpu_fingerprint: gpu ? { name: gpu.name, total_memory_bytes: gpu.memory_total_bytes } : void 0,
+    inventory: snapshot.inventory,
+    capabilities: snapshot.capabilities,
+    summary: snapshot.summary ?? formatCapabilitySummary(snapshot.capabilities)
+  };
+  await writeFile2(path, `${JSON.stringify(record, null, 2)}
+`, { mode: 384 });
+  await chmod(path, 384);
+  return record;
+}
+function formatHostStatusLine(snapshot) {
+  if (!snapshot) return "not inventoried (run tt hardware)";
+  const stale = snapshot.stale ? `; stale \u2014 run tt hardware` : "";
+  return `${snapshot.summary}${stale}`;
+}
+function formatAgentHostBlock(snapshot) {
+  if (!snapshot) {
+    return [
+      "Host capability is not inventoried yet.",
+      "When the user asks to examine this machine, GPU, VRAM, CUDA, or what can train, fine-tune, or infer here, call examine_hardware before recommending a base model, engine, or pipeline."
+    ].join(" ");
+  }
+  const stale = snapshot.stale ? " (stale \u2014 call examine_hardware to refresh)" : "";
+  return [
+    `Host capability (cached ${snapshot.collected_at}${stale}):`,
+    snapshot.summary,
+    "When the user wants to examine this host, GPU, or decide what can train/fine-tune/infer here, call examine_hardware before recommending a base model, engine, or pipeline.",
+    "Recommend only workloads marked ready; mention tight as a caution. Never invent generic 7B/70B sizing."
+  ].join("\n");
+}
+
+// src/local-runtime/hardware.ts
+async function assessHardware(options = {}) {
+  const env = options.env ?? process.env;
+  if (options.quick === true) {
+    const existing = await readHardwareSnapshot(env);
+    if (existing && !existing.quick && !existing.stale) {
+      return {
+        version: existing.version,
+        collected_at: existing.collected_at,
+        quick: existing.quick,
+        gpu_fingerprint: existing.gpu_fingerprint,
+        inventory: existing.inventory,
+        capabilities: existing.capabilities,
+        summary: existing.summary
+      };
+    }
+  }
+  const inventory = await collectHostInventory({
+    config: options.config,
+    quick: options.quick === true,
+    env,
+    cwd: options.cwd
+  });
+  const capabilities = evaluateCapabilities(inventory);
+  return await writeHardwareSnapshot({
+    collected_at: inventory.collected_at,
+    quick: inventory.quick,
+    inventory,
+    capabilities,
+    summary: formatCapabilitySummary(capabilities)
+  }, env);
+}
+
+// src/local-runtime/store.ts
+import { appendFile, chmod as chmod2, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir4, readdir as readdir3, readFile as readFile3, rename as rename2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname7, join as join7, resolve as resolve8, sep as sep2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function isTerminalRunState(state) {
+  return state.status === "stage_completed" || state.status === "completed" || state.status === "failed" || state.status === "cancelled" && state.current_stage === "cancelled" && Boolean(state.completed_at);
+}
+function defaultLocalHome() {
+  return defaultStoreRoot();
+}
+function localStorePaths(root) {
+  return {
+    root,
+    specsDir: join7(root, "specs"),
+    runsDir: join7(root, "runs"),
+    modelsDir: join7(root, "models"),
+    datasetsDir: join7(root, "datasets")
+  };
+}
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensurePrivateDirectory(path) {
+  await mkdir4(path, { recursive: true, mode: 448 });
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${path}`);
+  }
+  await chmod2(path, 448);
+}
+async function hardenPrivateTree(path) {
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (metadata.isDirectory()) {
+    await chmod2(path, 448);
+    for (const entry of await readdir3(path)) {
+      await hardenPrivateTree(join7(path, entry));
+    }
+    return;
+  }
+  if (metadata.isFile()) {
+    await chmod2(path, 384);
+    return;
+  }
+  throw new Error(`Refusing unsupported filesystem entry in local store: ${path}`);
+}
+async function hardenExistingLocalStore(root) {
+  const resolvedRoot = resolve8(root);
+  let metadata;
+  try {
+    metadata = await lstat3(resolvedRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${resolvedRoot}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${resolvedRoot}`);
+  }
+  await hardenPrivateTree(resolvedRoot);
+  return true;
+}
+async function writePrivateJsonAtomic(path, value) {
+  await ensurePrivateDirectory(dirname7(path));
+  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+  await writeFile3(tmp, `${JSON.stringify(value, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename2(tmp, path);
+  await chmod2(path, 384);
+}
+async function readJson2(path) {
+  return JSON.parse(await readFile3(path, "utf8"));
+}
+async function appendJsonl(path, value) {
+  await ensurePrivateDirectory(dirname7(path));
+  await appendFile(path, `${JSON.stringify(value)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod2(path, 384);
+}
+async function writePrivateText(path, value) {
+  await ensurePrivateDirectory(dirname7(path));
+  await writeFile3(path, value, { encoding: "utf8", mode: 384 });
+  await chmod2(path, 384);
+}
+async function readJsonl(path) {
+  if (!await exists(path)) return [];
+  return (await readFile3(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function copyIfExists(from, to) {
+  if (!await exists(from)) return;
+  await ensurePrivateDirectory(dirname7(to));
+  await copyFile2(from, to);
+  await chmod2(to, 384);
+}
+async function childDirectoryNames(path) {
+  try {
+    const entries = await readdir3(path, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function compareIds(left, right) {
+  if (left.id === right.id) return 0;
+  return left.id < right.id ? -1 : 1;
+}
+function compareUpdatedAt(left, right) {
+  if (left.updated_at !== right.updated_at) return left.updated_at > right.updated_at ? -1 : 1;
+  return compareIds(left, right);
+}
+function compareCreatedAt(left, right) {
+  if (left.created_at !== right.created_at) return left.created_at > right.created_at ? -1 : 1;
+  return compareIds(left, right);
+}
+function findByIdOrPrefix(records, id) {
+  return records.find((record) => record.id === id) ?? records.find((record) => record.id.startsWith(id));
+}
+function isPathInside(root, candidate) {
+  const resolvedRoot = resolve8(root);
+  const resolvedCandidate = resolve8(candidate);
+  return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
+}
+function createLocalStore(root = defaultLocalHome()) {
+  const resolvedRoot = resolve8(root);
+  const paths = localStorePaths(resolvedRoot);
+  const runDir = (id) => join7(paths.runsDir, id);
+  const runStatePath = (id) => join7(runDir(id), "state.json");
+  const runEventsPath = (id) => join7(runDir(id), "progress.jsonl");
+  const runRequestPath = (id) => join7(runDir(id), "request.json");
+  const runReportPath = (id) => join7(runDir(id), "run-report.json");
+  const cancellationPath = (id) => join7(runDir(id), "cancel.requested");
+  const specDir = (id) => join7(paths.specsDir, id);
+  const specPath = (id) => join7(specDir(id), "spec.json");
+  const modelPath = (id) => join7(paths.modelsDir, id, "model.json");
+  let ensurePromise;
+  async function ensureOnce() {
+    await ensurePrivateDirectory(paths.root);
+    await Promise.all([
+      ensurePrivateDirectory(paths.specsDir),
+      ensurePrivateDirectory(paths.runsDir),
+      ensurePrivateDirectory(paths.modelsDir),
+      ensurePrivateDirectory(paths.datasetsDir)
+    ]);
+    await hardenExistingLocalStore(paths.root);
+  }
+  async function ensure() {
+    ensurePromise ??= ensureOnce().catch((error) => {
+      ensurePromise = void 0;
+      throw error;
+    });
+    await ensurePromise;
   }
   async function writeRunState(state) {
     await writePrivateJsonAtomic(runStatePath(state.id), state);
@@ -1136,7 +2178,7 @@ function createLocalStore(root = defaultLocalHome()) {
       ...event
     };
     await appendJsonl(runEventsPath(state.id), row);
-    await appendJsonl(join3(state.artifact_dir, "progress.jsonl"), {
+    await appendJsonl(join7(state.artifact_dir, "progress.jsonl"), {
       at: row.occurred_at,
       stage: row.stage,
       status: row.status,
@@ -1167,7 +2209,7 @@ function createLocalStore(root = defaultLocalHome()) {
     const previous = await getRun(runId);
     if (isTerminalRunState(previous)) return previous;
     await Promise.all([
-      rm(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
+      rm(join7(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
       rm(runReportPath(previous.id), { force: true })
     ]);
     if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
@@ -1320,6 +2362,13 @@ function createLocalStore(root = defaultLocalHome()) {
       }
       const request = await readJson2(runRequestPath(report.run_id));
       const completedAt = report.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+      if (!await exists(reportPath)) {
+        throw new Error(`Run report not found: ${reportPath}`);
+      }
+      await copyIfExists(reportPath, runReportPath(report.run_id));
+      if (await exists(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
       const model = await registerModelRecord({
         request,
         training: report.training,
@@ -1327,7 +2376,7 @@ function createLocalStore(root = defaultLocalHome()) {
         createdAt: completedAt
       });
       if (!model) {
-        await rm(join3(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+        await rm(join7(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
       }
       const previous = await getRun(report.run_id);
       const state = {
@@ -1341,10 +2390,6 @@ function createLocalStore(root = defaultLocalHome()) {
         completed_at: completedAt,
         updated_at: completedAt
       };
-      if (!await exists(reportPath)) {
-        throw new Error(`Run report not found: ${reportPath}`);
-      }
-      await copyIfExists(reportPath, runReportPath(report.run_id));
       if (await exists(cancellationPath(report.run_id))) {
         return preserveCancellationRequestState(report.run_id);
       }
@@ -1365,7 +2410,7 @@ function createLocalStore(root = defaultLocalHome()) {
       const previous = await getRun(runId);
       if (options.report) await rm(runReportPath(previous.id), { force: true });
       if (options.model) {
-        await rm(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
+        await rm(join7(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
       }
       const state = {
         ...previous,
@@ -1442,9 +2487,9 @@ function createLocalStore(root = defaultLocalHome()) {
       const state = await getRun(id);
       const candidates = [];
       if (state.report_path) {
-        const reportPath = resolve4(state.report_path);
+        const reportPath = resolve8(state.report_path);
         const allowedRoots = [resolvedRoot];
-        if (state.artifact_dir) allowedRoots.push(resolve4(state.artifact_dir));
+        if (state.artifact_dir) allowedRoots.push(resolve8(state.artifact_dir));
         if (allowedRoots.some((allowed) => isPathInside(allowed, reportPath))) {
           candidates.push(reportPath);
         }
@@ -1485,14 +2530,30 @@ var specSnapshotSchema = z.object({
 }).strict();
 var foundationHyperparametersSchema = z.object({
   vocab_size: z.number().int().min(64).max(65536).default(256),
-  max_chars: z.number().int().min(1e3).max(2e9).default(2e4),
+  max_chars: z.number().int().min(1e3).max(1e12).default(2e4),
   depth: z.number().int().min(1).max(64).default(2),
   pretrain_steps: z.number().int().min(1).max(1e7).default(2),
   finetune_steps: z.number().int().min(1).max(1e7).default(2),
   rl_steps: z.number().int().min(0).max(1e7).default(0),
   batch_size: z.number().int().min(1).max(1024).default(2),
   sequence_length: z.number().int().min(16).max(8192).default(64),
-  nproc_per_node: z.number().int().min(1).max(16).default(1)
+  nproc_per_node: z.number().int().min(1).max(16).default(1),
+  corpus_path: z.string().min(1).optional(),
+  tokenizer_max_chars: z.number().int().min(1e3).max(1e12).optional(),
+  validation_path: z.string().min(1).optional(),
+  checkpoint_backup_dir: z.string().min(1).optional(),
+  seed: z.number().int().min(0).max(2147483647).optional(),
+  learning_rate: z.number().positive().max(1).optional(),
+  weight_decay: z.number().min(0).max(10).optional(),
+  warmup_steps: z.number().int().min(0).max(1e7).optional(),
+  min_lr_ratio: z.number().min(0).max(1).optional(),
+  gradient_accumulation_steps: z.number().int().min(1).max(1024).optional(),
+  gradient_clip: z.number().positive().max(1e3).optional(),
+  bf16: z.boolean().optional(),
+  checkpoint_interval_steps: z.number().int().min(1).max(1e7).optional(),
+  checkpoint_interval_seconds: z.number().int().min(1).max(86400).optional(),
+  keep_checkpoints: z.number().int().min(1).max(100).optional(),
+  log_interval_steps: z.number().int().min(1).max(1e6).optional()
 }).strict();
 var localFoundationSpecFileSchema = z.object({
   engine: z.literal("foundation"),
@@ -1744,23 +2805,30 @@ function isFoundationSpecFile(spec) {
 }
 
 // src/local-runtime/local-project.ts
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile3, stat as stat3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
-import { homedir as homedir2 } from "os";
-import { mkdir as mkdir3 } from "fs/promises";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve9, sep as sep3 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdir as mkdir5 } from "fs/promises";
 var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
 function resolveLocalReference(value, baseDirectory) {
   if (typeof value !== "string" || !value || isAbsolute3(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
     return value;
   }
-  if (value === "~") return homedir2();
-  if (value.startsWith("~/")) return resolve5(homedir2(), value.slice(2));
-  return resolve5(baseDirectory, value);
+  if (value === "~") return homedir4();
+  if (value.startsWith("~/")) return resolve9(homedir4(), value.slice(2));
+  return resolve9(baseDirectory, value);
+}
+function localPathsOverlap(left, right) {
+  const contains = (parent, candidate) => {
+    const relation = relative2(resolve9(parent), resolve9(candidate));
+    return relation === "" || !isAbsolute3(relation) && relation !== ".." && !relation.startsWith(`..${sep3}`);
+  };
+  return contains(left, right) || contains(right, left);
 }
 function resolveLocalRunInputPaths(raw, inputPath) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
-  const baseDirectory = dirname3(resolve5(inputPath));
+  const baseDirectory = dirname8(resolve9(inputPath));
   const value = structuredClone(raw);
   const dataset = value.dataset_prebuilt;
   if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
@@ -1769,6 +2837,13 @@ function resolveLocalRunInputPaths(raw, inputPath) {
       if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
     }
   }
+  const foundation = value.foundation;
+  if (foundation && typeof foundation === "object" && !Array.isArray(foundation)) {
+    const fields = foundation;
+    for (const key of ["corpus_path", "validation_path", "checkpoint_backup_dir"]) {
+      if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
+    }
+  }
   return value;
 }
 async function exists2(path) {
@@ -1816,8 +2891,8 @@ async function initLocalSpecFile(args) {
         nproc_per_node: 1
       }
     });
-    await mkdir3(dirname3(args.outputPath), { recursive: true });
-    await writeFile3(args.outputPath, `${JSON.stringify(spec2, null, 2)}
+    await mkdir5(dirname8(args.outputPath), { recursive: true });
+    await writeFile4(args.outputPath, `${JSON.stringify(spec2, null, 2)}
 `, "utf8");
     return spec2;
   }
@@ -1848,8 +2923,8 @@ async function initLocalSpecFile(args) {
       n_epochs: 1
     }
   });
-  await mkdir3(dirname3(args.outputPath), { recursive: true });
-  await writeFile3(args.outputPath, `${JSON.stringify(spec, null, 2)}
+  await mkdir5(dirname8(args.outputPath), { recursive: true });
+  await writeFile4(args.outputPath, `${JSON.stringify(spec, null, 2)}
 `, "utf8");
   return spec;
 }
@@ -1870,8 +2945,8 @@ async function initLocalRunnerConfigFile(args) {
       timeoutMs: 18e5
     }
   };
-  await mkdir3(dirname3(args.outputPath), { recursive: true });
-  await writeFile3(args.outputPath, `${JSON.stringify(config, null, 2)}
+  await mkdir5(dirname8(args.outputPath), { recursive: true });
+  await writeFile4(args.outputPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return config;
 }
@@ -1907,536 +2982,185 @@ function assertFoundationSpecReady(spec) {
 }
 function runRequestFromLocalSpec(spec, options = {}) {
   if (isFoundationSpecFile(spec)) {
-    throw new Error(
-      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
-    );
-  }
-  const {
-    id,
-    engine: _engine,
-    hyperparameters,
-    dataset_prebuilt: datasetPrebuilt,
-    ...specSnapshot
-  } = spec;
-  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
-  return fineTuneRunRequestSchema.parse({
-    run_id: options.runId ?? randomUUID3(),
-    user_id: "local-user",
-    behavior_spec_id: behaviorSpecId,
-    run_number: 1,
-    spec_snapshot: specSnapshot,
-    hyperparameters,
-    dataset_prebuilt: datasetPrebuilt
-  });
-}
-function deterministicBehaviorSpecId(spec) {
-  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
-  const digest = createHash2("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
-  digest[6] = digest[6] & 15 | 80;
-  digest[8] = digest[8] & 63 | 128;
-  const hex = digest.toString("hex");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20)
-  ].join("-");
-}
-async function loadLocalRunInput(path, options = {}) {
-  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile3(path, "utf8")), path);
-  const request = fineTuneRunRequestSchema.safeParse(raw);
-  if (request.success) {
-    return { kind: "request", path, request: request.data };
-  }
-  const spec = localBehaviorSpecFileSchema.parse(raw);
-  if (isFoundationSpecFile(spec)) {
-    return { kind: "foundation-spec", path, spec };
-  }
-  return {
-    kind: "spec",
-    path,
-    spec,
-    request: runRequestFromLocalSpec(spec, options)
-  };
-}
-
-// src/local-runtime/dataset.ts
-import { readFile as readFile4 } from "fs/promises";
-async function loadNormalizedChatJsonl(path) {
-  const text = await readFile4(path, "utf8");
-  const rows = [];
-  const jsonLines = [];
-  for (const [index, line] of text.split(/\r?\n/).entries()) {
-    if (!line.trim()) continue;
-    let value;
-    try {
-      value = JSON.parse(line);
-    } catch (error) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
-    }
-    const messages = value.messages;
-    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
-      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
-    )) {
-      throw new Error(
-        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
-      );
-    }
-    const row = { messages };
-    const offset = row.messages.length === 3 ? 1 : 0;
-    if (offset === 1 && row.messages[0]?.role !== "system" || row.messages[offset]?.role !== "user" || !row.messages[offset]?.content.trim() || row.messages[offset + 1]?.role !== "assistant" || !row.messages[offset + 1]?.content.trim()) {
-      throw new Error(
-        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one non-empty user message, and one non-empty assistant answer`
-      );
-    }
-    rows.push(row);
-    jsonLines.push(JSON.stringify(row));
-  }
-  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
-  return {
-    rows,
-    jsonl: jsonLines.join("\n")
-  };
-}
-async function normalizeChatJsonlForRelocation(path) {
-  return (await loadNormalizedChatJsonl(path)).jsonl;
-}
-function buildSystemMessage(spec) {
-  const parts = [];
-  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
-  if (spec.guidelines.length > 0) {
-    parts.push(`Guidelines:
-${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
-  }
-  if (spec.constraints.length > 0) {
-    parts.push(`Constraints:
-${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
-  }
-  return parts.join("\n\n") || "Follow the demonstrated behavior.";
-}
-function exampleToChatRow(spec, example) {
-  const system = buildSystemMessage(spec);
-  return {
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: example.input },
-      { role: "assistant", content: example.output }
-    ]
-  };
-}
-function compileSpecToJsonl(spec) {
-  return spec.examples.map((example) => JSON.stringify(exampleToChatRow(spec, example))).join("\n");
-}
-function examplesFromSpec(spec) {
-  return spec.examples;
-}
-async function examplesFromChatJsonl(path) {
-  const normalized = await loadNormalizedChatJsonl(path);
-  const examples = [];
-  for (const [index, row] of normalized.rows.entries()) {
-    const user = row.messages.at(-2);
-    const assistant = row.messages.at(-1);
-    examples.push({
-      input: user.content,
-      output: assistant.content
-    });
-  }
-  return examples;
-}
-async function evaluationSuiteFromChatJsonl(path, configuredSystem) {
-  const normalized = await loadNormalizedChatJsonl(path);
-  const inputIdentities = /* @__PURE__ */ new Set();
-  for (const row of normalized.rows) {
-    const input = row.messages.at(-2).content;
-    const identity = input.trim().replace(/\s+/g, " ").toLowerCase();
-    if (inputIdentities.has(identity)) {
-      throw new Error(
-        "General regression data contains duplicate inputs; evaluation prompts must be unique."
-      );
-    }
-    inputIdentities.add(identity);
-  }
-  const systems = new Set(
-    normalized.rows.map((row) => row.messages.find((message) => message.role === "system")?.content).filter((value) => value !== void 0)
-  );
-  if (systems.size > 1) {
-    throw new Error("General regression rows must use one consistent system message.");
-  }
-  const embeddedSystem = [...systems][0];
-  if (configuredSystem !== void 0 && embeddedSystem !== void 0 && configuredSystem !== embeddedSystem) {
-    throw new Error(
-      "evaluation.generalRegression.systemPrompt must match the system message embedded in the dataset."
-    );
-  }
-  return {
-    examples: normalized.rows.map((row) => ({
-      input: row.messages.at(-2).content,
-      output: row.messages.at(-1).content
-    })),
-    system: configuredSystem ?? embeddedSystem ?? "You are a helpful assistant."
-  };
-}
-
-// src/local-runtime/run-reporter.ts
-function reportInBackground(action) {
-  try {
-    void Promise.resolve(action()).catch(() => void 0);
-  } catch {
-  }
-}
-function sanitizeLogLine(line) {
-  return line.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|secret|password)=)[^\s]+/gi, "$1[redacted]");
-}
-function forwardStreamLines(stream, onLine) {
-  let buffered = "";
-  stream.setEncoding("utf8");
-  stream.on("data", (chunk) => {
-    buffered += chunk;
-    const lines = buffered.split(/\r\n|\n|\r/);
-    buffered = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.trim()) onLine(sanitizeLogLine(line));
-    }
-  });
-  stream.on("end", () => {
-    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
-  });
-}
-
-// src/local-runtime/package-root.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname4, resolve as resolve6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function localRuntimePackageRoot(moduleUrl) {
-  const moduleDirectory = dirname4(fileURLToPath2(moduleUrl));
-  const candidates = [
-    dirname4(moduleDirectory),
-    dirname4(dirname4(moduleDirectory))
-  ];
-  const root = candidates.find(
-    (candidate) => existsSync2(resolve6(candidate, "package.json")) && existsSync2(resolve6(candidate, "training/adapter"))
-  );
-  if (!root) {
-    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
-  }
-  return root;
-}
-
-// src/local-runtime/prefetch.ts
-import { createHash as createHash4 } from "crypto";
-import { createReadStream as createReadStream2 } from "fs";
-import { lstat as lstat4, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join6, relative as relative2, resolve as resolve9, sep as sep3 } from "path";
-
-// src/local-runtime/process-runner.ts
-import { createHash as createHash3 } from "crypto";
-import { spawn } from "child_process";
-import { createWriteStream, readFileSync } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve7 } from "path";
-var packageRoot = localRuntimePackageRoot(import.meta.url);
-var bundledProject = join4(packageRoot, "training/adapter");
-var bundledRuntimeHash = (() => {
-  const hash = createHash3("sha256");
-  for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join4(bundledProject, name)));
-  }
-  return hash.digest("hex").slice(0, 20);
-})();
-var BUNDLED_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv", bundledRuntimeHash);
-var foundationProject = join4(packageRoot, "training/foundation");
-var foundationRuntimeHash = (() => {
-  const hash = createHash3("sha256");
-  for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join4(foundationProject, name)));
-  }
-  return hash.digest("hex").slice(0, 20);
-})();
-var FOUNDATION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-foundation", foundationRuntimeHash);
-function buildBundledPythonCommand(entrypoint, args = []) {
-  const target = entrypoint === "-c" ? entrypoint : join4(bundledProject, "src", entrypoint);
-  const commandArgs = [
-    "run",
-    "--frozen",
-    "--quiet",
-    "--project",
-    bundledProject,
-    "python",
-    target,
-    ...args
-  ];
-  return {
-    command: "uv",
-    commandArgs,
-    displayCommand: ["uv", ...commandArgs]
-  };
-}
-function withBundledPythonEnvironment(env) {
-  return {
-    ...env,
-    UV_PROJECT_ENVIRONMENT: BUNDLED_PYTHON_ENVIRONMENT
-  };
-}
-function buildFoundationPythonCommand(entrypoint, args = []) {
-  const commandArgs = [
-    "run",
-    "--frozen",
-    "--quiet",
-    "--project",
-    foundationProject,
-    "python",
-    join4(foundationProject, "src", entrypoint),
-    ...args
-  ];
-  return {
-    command: "uv",
-    commandArgs,
-    displayCommand: ["uv", ...commandArgs]
-  };
-}
-function withFoundationPythonEnvironment(env) {
-  return {
-    ...env,
-    UV_PROJECT_ENVIRONMENT: FOUNDATION_PYTHON_ENVIRONMENT
-  };
-}
-var ProcessCancelledError = class extends Error {
-  constructor(message = "Process cancelled.") {
-    super(message);
-    this.name = "ProcessCancelledError";
-  }
-};
-async function openProcessLog(path, exclusive) {
-  const stream = createWriteStream(path, {
-    flags: exclusive ? "wx" : "w",
-    mode: 384
-  });
-  await new Promise((resolveOpen, reject) => {
-    const onOpen = () => {
-      stream.off("error", onError);
-      resolveOpen();
-    };
-    const onError = (error) => {
-      stream.off("open", onOpen);
-      reject(error);
-    };
-    stream.once("open", onOpen);
-    stream.once("error", onError);
-  });
-  return stream;
-}
-async function runLoggedProcess(args) {
-  if (args.logPath) await mkdir4(dirname5(args.logPath), { recursive: true });
-  const logStream = args.logPath ? await openProcessLog(args.logPath, args.exclusiveLog ?? false) : null;
-  let stderr = "";
-  try {
-    const exitCode = await new Promise((resolvePromise, reject) => {
-      const child = spawn(args.command, args.commandArgs, {
-        cwd: args.cwd ? resolve7(args.cwd) : process.cwd(),
-        stdio: ["ignore", "pipe", "pipe"],
-        env: args.env ?? process.env,
-        detached: process.platform !== "win32"
-      });
-      let timedOut = false;
-      let cancelled = false;
-      let cancellationError;
-      let cancellationCheckRunning = false;
-      let forceKillTimer = null;
-      const killProcessGroup = (signal) => {
-        if (child.pid && process.platform !== "win32") {
-          try {
-            process.kill(-child.pid, signal);
-            return;
-          } catch {
-          }
-        }
-        child.kill(signal);
-      };
-      const requestStop = (signal = "SIGTERM") => {
-        killProcessGroup(signal);
-        if (!forceKillTimer) {
-          forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), 5e3);
-          forceKillTimer.unref();
-        }
-      };
-      const onSigint = () => {
-        cancelled = true;
-        requestStop("SIGINT");
-      };
-      const onSigterm = () => {
-        cancelled = true;
-        requestStop("SIGTERM");
-      };
-      process.once("SIGINT", onSigint);
-      process.once("SIGTERM", onSigterm);
-      const timer = args.timeoutMs ? setTimeout(() => {
-        timedOut = true;
-        requestStop();
-      }, args.timeoutMs) : null;
-      const cancellationTimer = args.shouldCancel ? setInterval(() => {
-        if (cancellationCheckRunning || cancelled) return;
-        cancellationCheckRunning = true;
-        Promise.resolve(args.shouldCancel?.()).then((requested) => {
-          if (!requested || cancelled) return;
-          cancelled = true;
-          requestStop();
-        }).catch((error) => {
-          cancellationError = error;
-          requestStop();
-        }).finally(() => {
-          cancellationCheckRunning = false;
-        });
-      }, args.cancelPollMs ?? 250) : null;
-      cancellationTimer?.unref();
-      const clearProcessTimers = () => {
-        if (timer) clearTimeout(timer);
-        if (cancellationTimer) clearInterval(cancellationTimer);
-        if (forceKillTimer) clearTimeout(forceKillTimer);
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-      };
-      if (logStream) {
-        child.stdout.pipe(logStream, { end: false });
-        child.stderr.pipe(logStream, { end: false });
-      }
-      forwardStreamLines(child.stdout, (line) => {
-        args.onLine?.(line, "stdout");
-        if (args.reporter?.verbose) {
-          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stdout", message: line }));
-        }
-      });
-      forwardStreamLines(child.stderr, (line) => {
-        stderr += `${line}
-`;
-        args.onLine?.(line, "stderr");
-        if (args.reporter?.verbose) {
-          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stderr", message: line }));
-        }
-      });
-      child.on("error", (error) => {
-        clearProcessTimers();
-        reject(timedOut ? new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`) : error);
-      });
-      child.on("close", (code) => {
-        if (timedOut || cancelled || cancellationError || args.terminateProcessGroupOnExit) {
-          killProcessGroup("SIGKILL");
-        }
-        clearProcessTimers();
-        if (timedOut) {
-          reject(new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`));
-          return;
-        }
-        if (cancellationError) {
-          reject(cancellationError);
-          return;
-        }
-        if (cancelled) {
-          reject(new ProcessCancelledError(`${args.stage} was cancelled.`));
-          return;
-        }
-        resolvePromise(code ?? 1);
-      });
-    });
-    return { exitCode, stderr };
-  } finally {
-    if (logStream) {
-      await new Promise((resolveEnd) => {
-        logStream.end(resolveEnd);
-      });
-    }
+    throw new Error(
+      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
+    );
   }
+  const {
+    id,
+    engine: _engine,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt,
+    ...specSnapshot
+  } = spec;
+  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
+  return fineTuneRunRequestSchema.parse({
+    run_id: options.runId ?? randomUUID3(),
+    user_id: "local-user",
+    behavior_spec_id: behaviorSpecId,
+    run_number: 1,
+    spec_snapshot: specSnapshot,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt
+  });
 }
-
-// src/local-runtime/huggingface-cache.ts
-import { homedir as homedir3 } from "os";
-import { dirname as dirname6, join as join5, resolve as resolve8 } from "path";
-function minimalMachineLearningEnvironment(env) {
-  const exact = /* @__PURE__ */ new Set([
-    "PATH",
-    "HOME",
-    "USER",
-    "LOGNAME",
-    "SHELL",
-    "TMPDIR",
-    "TEMP",
-    "TMP",
-    "LANG",
-    "LANGUAGE",
-    "LD_LIBRARY_PATH",
-    "DYLD_LIBRARY_PATH",
-    "XDG_CACHE_HOME",
-    "SSL_CERT_FILE",
-    "REQUESTS_CA_BUNDLE",
-    "CURL_CA_BUNDLE",
-    "NO_PROXY",
-    "no_proxy",
-    "UV_CACHE_DIR",
-    "UV_PYTHON",
-    "HF_HOME",
-    "HF_HUB_CACHE",
-    "HUGGINGFACE_HUB_CACHE",
-    "HF_ENDPOINT",
-    "HF_TOKEN",
-    "HF_HUB_OFFLINE",
-    "HF_HUB_DISABLE_TELEMETRY",
-    "TRANSFORMERS_OFFLINE",
-    "HF_HUB_ENABLE_HF_TRANSFER",
-    "PYTHONUTF8",
-    "PYTHONIOENCODING"
-  ]);
-  const prefixes = [
-    "LC_",
-    "CUDA_",
-    "NVIDIA_",
-    "NCCL_",
-    "OMP_",
-    "MKL_",
-    "TORCH_",
-    "PYTORCH_",
-    "TOKENIZERS_",
-    "HF_XET_"
-  ];
-  const result = Object.fromEntries(Object.entries(env).filter(
-    ([key]) => exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix))
-  ));
-  result.TORCH_DISABLE_NATIVE_JIT ??= "1";
-  return result;
+function deterministicBehaviorSpecId(spec) {
+  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
+  const digest = createHash3("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
+  digest[6] = digest[6] & 15 | 80;
+  digest[8] = digest[8] & 63 | 128;
+  const hex = digest.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
 }
-function resolveHuggingFaceCacheLayout(modelCache) {
-  const hfHome = resolve8(modelCache);
+async function loadLocalRunInput(path, options = {}) {
+  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile4(path, "utf8")), path);
+  const request = fineTuneRunRequestSchema.safeParse(raw);
+  if (request.success) {
+    return { kind: "request", path, request: request.data };
+  }
+  const spec = localBehaviorSpecFileSchema.parse(raw);
+  if (isFoundationSpecFile(spec)) {
+    return { kind: "foundation-spec", path, spec };
+  }
   return {
-    hfHome,
-    hubCache: join5(hfHome, "hub")
+    kind: "spec",
+    path,
+    spec,
+    request: runRequestFromLocalSpec(spec, options)
   };
 }
-function withHuggingFaceCacheEnvironment(env, modelCache) {
-  const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
-  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve8(inheritedHub)) : join5(homedir3(), ".cache", "huggingface"));
-  const layout = resolveHuggingFaceCacheLayout(canonicalHome);
-  const result = {
-    ...env,
-    HF_HOME: layout.hfHome,
-    HF_HUB_CACHE: layout.hubCache,
-    HUGGINGFACE_HUB_CACHE: layout.hubCache
+
+// src/local-runtime/dataset.ts
+import { readFile as readFile5 } from "fs/promises";
+async function loadNormalizedChatJsonl(path) {
+  const text = await readFile5(path, "utf8");
+  const rows = [];
+  const jsonLines = [];
+  for (const [index, line] of text.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (error) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
+    }
+    const messages = value.messages;
+    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
+      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
+    )) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
+      );
+    }
+    const row = { messages };
+    const offset = row.messages.length === 3 ? 1 : 0;
+    if (offset === 1 && row.messages[0]?.role !== "system" || row.messages[offset]?.role !== "user" || !row.messages[offset]?.content.trim() || row.messages[offset + 1]?.role !== "assistant" || !row.messages[offset + 1]?.content.trim()) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one non-empty user message, and one non-empty assistant answer`
+      );
+    }
+    rows.push(row);
+    jsonLines.push(JSON.stringify(row));
+  }
+  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
+  return {
+    rows,
+    jsonl: jsonLines.join("\n")
   };
-  delete result.TRANSFORMERS_CACHE;
-  delete result.PYTORCH_TRANSFORMERS_CACHE;
-  delete result.PYTORCH_PRETRAINED_BERT_CACHE;
-  return result;
 }
-function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
+async function normalizeChatJsonlForRelocation(path) {
+  return (await loadNormalizedChatJsonl(path)).jsonl;
+}
+function buildSystemMessage(spec) {
+  const parts = [];
+  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
+  if (spec.guidelines.length > 0) {
+    parts.push(`Guidelines:
+${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
+  }
+  if (spec.constraints.length > 0) {
+    parts.push(`Constraints:
+${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
+  }
+  return parts.join("\n\n") || "Follow the demonstrated behavior.";
+}
+function exampleToChatRow(spec, example) {
+  const system = buildSystemMessage(spec);
   return {
-    ...withHuggingFaceCacheEnvironment(env, modelCache),
-    HF_HUB_OFFLINE: "1",
-    TRANSFORMERS_OFFLINE: "1"
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: example.input },
+      { role: "assistant", content: example.output }
+    ]
+  };
+}
+function compileSpecToJsonl(spec) {
+  return spec.examples.map((example) => JSON.stringify(exampleToChatRow(spec, example))).join("\n");
+}
+function examplesFromSpec(spec) {
+  return spec.examples;
+}
+async function examplesFromChatJsonl(path) {
+  const normalized = await loadNormalizedChatJsonl(path);
+  const examples = [];
+  for (const [index, row] of normalized.rows.entries()) {
+    const user = row.messages.at(-2);
+    const assistant = row.messages.at(-1);
+    examples.push({
+      input: user.content,
+      output: assistant.content
+    });
+  }
+  return examples;
+}
+async function evaluationSuiteFromChatJsonl(path, configuredSystem) {
+  const normalized = await loadNormalizedChatJsonl(path);
+  const inputIdentities = /* @__PURE__ */ new Set();
+  for (const row of normalized.rows) {
+    const input = row.messages.at(-2).content;
+    const identity = input.trim().replace(/\s+/g, " ").toLowerCase();
+    if (inputIdentities.has(identity)) {
+      throw new Error(
+        "General regression data contains duplicate inputs; evaluation prompts must be unique."
+      );
+    }
+    inputIdentities.add(identity);
+  }
+  const systems = new Set(
+    normalized.rows.map((row) => row.messages.find((message) => message.role === "system")?.content).filter((value) => value !== void 0)
+  );
+  if (systems.size > 1) {
+    throw new Error("General regression rows must use one consistent system message.");
+  }
+  const embeddedSystem = [...systems][0];
+  if (configuredSystem !== void 0 && embeddedSystem !== void 0 && configuredSystem !== embeddedSystem) {
+    throw new Error(
+      "evaluation.generalRegression.systemPrompt must match the system message embedded in the dataset."
+    );
+  }
+  return {
+    examples: normalized.rows.map((row) => ({
+      input: row.messages.at(-2).content,
+      output: row.messages.at(-1).content
+    })),
+    system: configuredSystem ?? embeddedSystem ?? "You are a helpful assistant."
   };
 }
 
 // src/local-runtime/prefetch.ts
+import { createHash as createHash4 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { lstat as lstat4, mkdir as mkdir6, readFile as readFile6, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join8, relative as relative3, resolve as resolve10, sep as sep4 } from "path";
 var NEMOTRON_BF16_FILE_DIGESTS = {
   ".gitattributes": { algorithm: "sha1", digest: "fe3f694ce14b577c9833fca6e83c5e26a7119127" },
   "LICENSE": { algorithm: "sha1", digest: "4d76cc87c9edb280753e3bee3b499ae461113835" },
@@ -2502,14 +3226,14 @@ async function certifiedFileDigest(path, expected) {
   return digest.digest("hex");
 }
 function isStrictPhysicalDescendant(parent, child) {
-  const candidate = relative2(parent, child);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute4(candidate);
+  const candidate = relative3(parent, child);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep4}`) && !isAbsolute4(candidate);
 }
 async function verifySnapshotCacheLocation(path, modelId, revision, modelCache) {
   const repository = `models--${modelId.replaceAll("/", "--")}`;
   const layout = resolveHuggingFaceCacheLayout(modelCache);
-  const repositoryRoot = join6(layout.hubCache, repository);
-  const expectedPath = join6(repositoryRoot, "snapshots", revision);
+  const repositoryRoot = join8(layout.hubCache, repository);
+  const expectedPath = join8(repositoryRoot, "snapshots", revision);
   const [
     physicalCacheRoot,
     physicalHubRoot,
@@ -2521,7 +3245,7 @@ async function verifySnapshotCacheLocation(path, modelId, revision, modelCache)
     realpath2(layout.hfHome).catch(() => null),
     realpath2(layout.hubCache).catch(() => null),
     realpath2(repositoryRoot).catch(() => null),
-    realpath2(join6(repositoryRoot, "blobs")).catch(() => null),
+    realpath2(join8(repositoryRoot, "blobs")).catch(() => null),
     realpath2(path).catch(() => null),
     realpath2(expectedPath).catch(() => null)
   ]);
@@ -2537,7 +3261,7 @@ async function verifySnapshotCacheLocation(path, modelId, revision, modelCache)
     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: ${join6(repositoryRoot, "blobs")}`);
+    throw new Error(`Hugging Face blob store escapes its repository: ${join8(repositoryRoot, "blobs")}`);
   }
   if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalExpectedPath)) {
     throw new Error(`Hugging Face snapshot escapes its configured repository: ${expectedPath}`);
@@ -2595,17 +3319,17 @@ async function verifyCertifiedLocalSnapshot(path, modelId, snapshotFiles, modelC
     }
     physicalFiles.set(file, target);
   }
-  const actualFiles = new Set(snapshotFiles.map((file) => relative2(path, file).split("\\").join("/")));
+  const actualFiles = new Set(snapshotFiles.map((file) => relative3(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: ${join6(path, unexpected[0])}`);
+    throw new Error(`Certified snapshot contains unexpected file: ${join8(path, unexpected[0])}`);
   }
   for (const [name, expected] of Object.entries(digests)) {
     if (!actualFiles.has(name)) {
-      throw new Error(`Certified snapshot file is missing: ${join6(path, name)}`);
+      throw new Error(`Certified snapshot file is missing: ${join8(path, name)}`);
     }
-    const file = join6(path, name);
+    const file = join8(path, name);
     const physicalFile = physicalFiles.get(file);
     if (await certifiedFileDigest(physicalFile, expected) !== expected.digest) {
       throw new Error(`Certified snapshot file checksum mismatch: ${file}`);
@@ -2624,7 +3348,7 @@ function buildModelPrefetchPayload(request, config) {
   return {
     base_model: model.id,
     ...revision ? { revision } : {},
-    ...config.paths.modelCache ? { model_cache: resolve9(config.paths.modelCache) } : {}
+    ...config.paths.modelCache ? { model_cache: resolve10(config.paths.modelCache) } : {}
   };
 }
 function safeName(value) {
@@ -2648,7 +3372,7 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
-      const child = join6(directory, entry.name);
+      const child = join8(directory, entry.name);
       if (entry.isSymbolicLink()) {
         const metadata2 = await stat4(child);
         if (!metadata2.isFile()) {
@@ -2672,15 +3396,15 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
     throw new Error(`Local base-model directory contains no non-empty Transformers model weights: ${path}`);
   }
   const required = async (name) => {
-    const metadata = await stat4(join6(path, name)).catch(() => null);
+    const metadata = await stat4(join8(path, name)).catch(() => null);
     return Boolean(metadata?.isFile() && metadata.size > 0);
   };
   if (!await required("config.json")) throw new Error(`Local base-model directory is missing config.json: ${path}`);
   try {
-    const config = JSON.parse(await readFile5(join6(path, "config.json"), "utf8"));
+    const config = JSON.parse(await readFile6(join8(path, "config.json"), "utf8"));
     assertCertifiedBaseModelConfig(
       config,
-      `Local base-model config ${join6(path, "config.json")}`,
+      `Local base-model config ${join8(path, "config.json")}`,
       expectedModelId
     );
   } catch (error) {
@@ -2710,7 +3434,7 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
     throw new Error(`Local base-model directory is missing tokenizer metadata or vocabulary: ${path}`);
   }
   for (const file of files.filter((candidate) => candidate.path.endsWith(".index.json"))) {
-    const parsed = JSON.parse(await readFile5(file.path, "utf8"));
+    const parsed = JSON.parse(await readFile6(file.path, "utf8"));
     if (!parsed.weight_map || typeof parsed.weight_map !== "object" || Array.isArray(parsed.weight_map)) {
       throw new Error(`Local base-model weight index is invalid: ${file.path}`);
     }
@@ -2730,14 +3454,14 @@ async function prefetchBaseModel(args) {
     ...buildModelPrefetchPayload(args.request, args.config),
     ...args.localOnly ? { local_files_only: true } : {}
   };
-  const artifactDir = resolve9(
+  const artifactDir = resolve10(
     args.config.artifactRoot,
     args.localOnly ? "verify-base" : "prefetch",
     `${safeName(args.request.spec_snapshot.base_model)}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`
   );
-  await mkdir5(artifactDir, { recursive: true });
+  await mkdir6(artifactDir, { recursive: true });
   if (args.config.paths.baseModel) {
-    const localPath = resolve9(args.config.paths.baseModel);
+    const localPath = resolve10(args.config.paths.baseModel);
     const verified = await verifyLocalBaseModel(
       localPath,
       args.request.spec_snapshot.base_model,
@@ -2754,9 +3478,9 @@ 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 inputPath = join6(artifactDir, "prefetch-input.json");
-  const outputPath = join6(artifactDir, "prefetch-output.json");
-  const logPath = join6(artifactDir, "prefetch.log");
+  const inputPath = join8(artifactDir, "prefetch-input.json");
+  const outputPath = join8(artifactDir, "prefetch-output.json");
+  const logPath = join8(artifactDir, "prefetch.log");
   await writeJson(inputPath, payload);
   const entrypoint = buildBundledPythonCommand(
     "prefetch.py",
@@ -2793,7 +3517,7 @@ async function prefetchBaseModel(args) {
   if (exitCode !== 0) {
     throw new Error(`Model prefetch exited with code ${exitCode}. See ${logPath}.`);
   }
-  const output = JSON.parse(await readFile5(outputPath, "utf8"));
+  const output = JSON.parse(await readFile6(outputPath, "utf8"));
   const snapshotRevision = baseModelRevisionSchema.safeParse(output.snapshot_revision);
   if (!snapshotRevision.success) {
     throw new Error(
@@ -2876,17 +3600,17 @@ function evaluateGeneralRegressionGate(comparison, policy) {
 }
 
 // src/local-runtime/orchestrator.ts
-import { lstat as lstat5, 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 { lstat as lstat5, mkdir as mkdir9, open as open3, readFile as readFile9, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
 import { createReadStream as createReadStream3 } from "fs";
 import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import { performance } from "perf_hooks";
-import { homedir as homedir4 } from "os";
-import { basename, dirname as dirname8, join as join9, relative as relative3, resolve as resolve12 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename, dirname as dirname10, join as join11, relative as relative4, resolve as resolve13 } from "path";
 
 // src/local-runtime/evaluation.ts
 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 join7, resolve as resolve10 } from "path";
+import { mkdir as mkdir7, readFile as readFile7, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname9, join as join9, resolve as resolve11 } from "path";
 function normalize(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -3106,8 +3830,8 @@ async function runTransformersInference(args) {
   const inputPath = `${args.outputPath}.inference-input.json`;
   const outputPath = `${args.outputPath}.inference-output.json`;
   const logPath = `${args.outputPath}.inference.log`;
-  await mkdir6(dirname7(inputPath), { recursive: true });
-  await writeFile4(inputPath, `${JSON.stringify({
+  await mkdir7(dirname9(inputPath), { recursive: true });
+  await writeFile5(inputPath, `${JSON.stringify({
     protocol_version: INFERENCE_PROTOCOL_VERSION,
     kind: args.kind,
     model_id: args.modelId,
@@ -3121,7 +3845,7 @@ async function runTransformersInference(args) {
       id: String(index),
       input: example.input
     })),
-    model_cache: args.config.paths.modelCache ? resolve10(args.config.paths.modelCache) : void 0,
+    model_cache: args.config.paths.modelCache ? resolve11(args.config.paths.modelCache) : void 0,
     trust_remote_code: false,
     device: args.config.evaluation.inference.device,
     generation: {
@@ -3170,7 +3894,7 @@ async function runTransformersInference(args) {
   }
   let output;
   try {
-    output = JSON.parse(await readFile6(outputPath, "utf8"));
+    output = JSON.parse(await readFile7(outputPath, "utf8"));
   } catch (error) {
     throw new Error(
       `Transformers inference did not write valid JSON: ${error instanceof Error ? error.message : String(error)}`
@@ -3207,15 +3931,15 @@ function baselineInputsAreStable(args) {
   return args.config.paths.baseModel ? Boolean(args.sourceFingerprint) : Boolean(args.baseModelRevision);
 }
 function baselineStoreRoot(config) {
-  return config.storeRoot ? resolve10(config.storeRoot) : defaultLocalHome();
+  return config.storeRoot ? resolve11(config.storeRoot) : defaultLocalHome();
 }
 function baselineCachePath(config, key) {
-  return join7(baselineStoreRoot(config), "cache", "baseline-evals", `${key}.json`);
+  return join9(baselineStoreRoot(config), "cache", "baseline-evals", `${key}.json`);
 }
 async function readBaselineCache(config, path) {
   await hardenExistingLocalStore(baselineStoreRoot(config));
   try {
-    return evalReportSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+    return evalReportSchema.parse(JSON.parse(await readFile7(path, "utf8")));
   } catch {
     return null;
   }
@@ -3224,7 +3948,7 @@ var cachedPackageVersion = null;
 async function packageVersion() {
   if (cachedPackageVersion !== null) return cachedPackageVersion;
   try {
-    const raw = await readFile6(resolve10(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
+    const raw = await readFile7(resolve11(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
     cachedPackageVersion = String(
       JSON.parse(raw).version ?? "unknown"
     );
@@ -3293,7 +4017,7 @@ async function evaluateExamples(args) {
     baseModelId,
     args.baseModelRevision
   );
-  const localModelSource = args.modelSource ? resolve10(args.modelSource) !== resolve10(baseModelId) : false;
+  const localModelSource = args.modelSource ? resolve11(args.modelSource) !== resolve11(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;
@@ -3409,8 +4133,8 @@ function compareEvalReports(baseline, candidate) {
 }
 
 // src/local-runtime/process-training.ts
-import { access, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import { join as join8, resolve as resolve11 } from "path";
+import { access as access2, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { join as join10, resolve as resolve12 } from "path";
 function buildTrainingHyperparameters(request, options = {}) {
   const model = resolveTrainingModel(request.spec_snapshot.base_model);
   const hyper = request.hyperparameters;
@@ -3434,7 +4158,7 @@ function buildTrainingHyperparameters(request, options = {}) {
 }
 async function pathExists(path) {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -3501,15 +4225,15 @@ function createTrainingProgressForwarder(reporter) {
 async function launchProcessTraining(args) {
   const { request, artifacts, config } = args;
   const jobName = `tt-local-${request.run_id}`;
-  await mkdir7(artifacts.trainingDir, { recursive: true });
+  await mkdir8(artifacts.trainingDir, { recursive: true });
   await copyDatasetToTrainingChannel(artifacts);
   const hyperparameters = buildTrainingHyperparameters(request, {
     baseModelRevision: args.baseModelRevision
   });
-  await writeJson(join8(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
+  await writeJson(join10(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
   const entrypoint = buildBundledPythonCommand("train.py");
   if (config.dryRun) {
-    await writeFile5(
+    await writeFile6(
       artifacts.trainingLog,
       "Dry run enabled. Training process was not launched.\n",
       "utf8"
@@ -3531,20 +4255,20 @@ async function launchProcessTraining(args) {
     withOfflineHuggingFaceCacheEnvironment({
       ...inheritedEnv,
       BACKEND: "local",
-      SM_CHANNEL_TRAINING: resolve11(artifacts.trainingInputDir),
-      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve11(config.paths.baseModel) : void 0,
-      SM_MODEL_DIR: resolve11(artifacts.trainingModelDir),
-      SM_OUTPUT_DIR: resolve11(artifacts.trainingOutputDir),
-      TT_HYPERPARAMETERS_PATH: resolve11(artifacts.trainingConfigDir, "hyperparameters.json")
+      SM_CHANNEL_TRAINING: resolve12(artifacts.trainingInputDir),
+      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve12(config.paths.baseModel) : void 0,
+      SM_MODEL_DIR: resolve12(artifacts.trainingModelDir),
+      SM_OUTPUT_DIR: resolve12(artifacts.trainingOutputDir),
+      TT_HYPERPARAMETERS_PATH: resolve12(artifacts.trainingConfigDir, "hyperparameters.json")
     }, config.paths.modelCache)
   );
   for (const [key, value] of Object.entries(childEnv)) {
     if (value === void 0) delete childEnv[key];
   }
-  if (config.paths.modelCache) await mkdir7(resolve11(config.paths.modelCache), { recursive: true });
+  if (config.paths.modelCache) await mkdir8(resolve12(config.paths.modelCache), { recursive: true });
   if (config.paths.baseModel) {
     await verifyLocalBaseModel(
-      resolve11(config.paths.baseModel),
+      resolve12(config.paths.baseModel),
       request.spec_snapshot.base_model,
       config.paths.modelCache
     );
@@ -3571,12 +4295,12 @@ async function launchProcessTraining(args) {
     onLine: (line) => forwardTrainingProgress(line),
     shouldCancel: args.shouldCancel
   });
-  const metricsPath = join8(artifacts.trainingModelDir, "training-metrics.json");
-  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile7(metricsPath, "utf8")) : null;
+  const metricsPath = join10(artifacts.trainingModelDir, "training-metrics.json");
+  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile8(metricsPath, "utf8")) : null;
   if (exitCode !== 0) {
     throw new Error(`Training process exited with code ${exitCode}. See ${artifacts.trainingLog}.`);
   }
-  const modelTarPath = join8(artifacts.trainingOutputDir, "model.tar.gz");
+  const modelTarPath = join10(artifacts.trainingOutputDir, "model.tar.gz");
   const modelUri = await pathExists(modelTarPath) ? fileUri(modelTarPath) : fileUri(artifacts.trainingModelDir);
   await args.reporter?.onEvent?.({
     stage: "training",
@@ -3671,21 +4395,21 @@ function validateLocalPipeline(pipeline) {
   return pipeline;
 }
 async function loadJsonFile(path) {
-  return JSON.parse(await readFile8(path, "utf8"));
+  return JSON.parse(await readFile9(path, "utf8"));
 }
 async function loadRunRequest(path) {
   return fineTuneRunRequestSchema.parse(await loadJsonFile(path));
 }
 async function loadLocalRunnerConfig(path) {
   if (!path) return localRunnerConfigSchema.parse({});
-  const configPath = resolve12(path);
-  const base = dirname8(configPath);
+  const configPath = resolve13(path);
+  const base = dirname10(configPath);
   const config = localRunnerConfigSchema.parse(await loadJsonFile(configPath));
   const configPathValue = (value) => {
     if (!value) return void 0;
-    if (value === "~") return homedir4();
-    if (value.startsWith("~/")) return resolve12(homedir4(), value.slice(2));
-    return resolve12(base, value);
+    if (value === "~") return homedir5();
+    if (value.startsWith("~/")) return resolve13(homedir5(), value.slice(2));
+    return resolve13(base, value);
   };
   return {
     ...config,
@@ -3883,21 +4607,21 @@ async function hashFileIfPresent(path) {
 }
 async function packageVersion2() {
   try {
-    const parsed = JSON.parse(await readFile8(resolve12(packageRoot2, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile9(resolve13(packageRoot2, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
   }
 }
 async function runtimeFingerprint() {
-  const bundledProject2 = resolve12(packageRoot2, "training/adapter");
+  const bundledProject2 = resolve13(packageRoot2, "training/adapter");
   return hashJson({
     tt_local_version: await packageVersion2(),
     node_version: process.version,
     platform: process.platform,
     architecture: process.arch,
-    runner_pyproject: await hashFileIfPresent(resolve12(bundledProject2, "pyproject.toml")),
-    runner_uv_lock: await hashFileIfPresent(resolve12(bundledProject2, "uv.lock"))
+    runner_pyproject: await hashFileIfPresent(resolve13(bundledProject2, "pyproject.toml")),
+    runner_uv_lock: await hashFileIfPresent(resolve13(bundledProject2, "uv.lock"))
   });
 }
 function preparedSourceFingerprint(args) {
@@ -3944,9 +4668,9 @@ async function resolveBaseModelRevision(request, config) {
   }
   const repository = `models--${request.spec_snapshot.base_model.replaceAll("/", "--")}`;
   const cacheEnvironment = withHuggingFaceCacheEnvironment(process.env, config.paths.modelCache);
-  const refPath = resolve12(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
+  const refPath = resolve13(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
   try {
-    const revision = (await readFile8(refPath, "utf8")).trim();
+    const revision = (await readFile9(refPath, "utf8")).trim();
     if (revision) return revision;
   } catch {
   }
@@ -3965,7 +4689,7 @@ async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir5(directory, { withFileTypes: true })) {
-      const child = resolve12(directory, entry.name);
+      const child = resolve13(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(child);
         continue;
@@ -3976,7 +4700,7 @@ async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
       }
       if (!childMetadata.isFile()) continue;
       files.push({
-        path: relative3(root, child).split("\\").join("/"),
+        path: relative4(root, child).split("\\").join("/"),
         size_bytes: childMetadata.size,
         sha256: await hashFile(child)
       });
@@ -4004,12 +4728,12 @@ async function readStageMetadata(path) {
   }
 }
 async function removePrefixedArtifacts(path) {
-  const directory = dirname8(path);
+  const directory = dirname10(path);
   const prefix = `${basename(path)}.`;
   const names = await readdir5(directory).catch(() => []);
   await Promise.all([
     rm3(path, { force: true }),
-    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm3(resolve12(directory, name), { recursive: true, force: true }))
+    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm3(resolve13(directory, name), { recursive: true, force: true }))
   ]);
 }
 async function cleanupStageArtifacts(artifacts, stage) {
@@ -4022,7 +4746,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       rm3(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm3(resolve12(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm3(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
       removeReport(),
       rm3(artifacts.artifactManifestJson, { force: true })
     ]);
@@ -4040,7 +4764,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
     await Promise.all([
       rm3(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm3(resolve12(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm3(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
       removePrefixedArtifacts(artifacts.candidateEvalJson),
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       removeReport()
@@ -4059,7 +4783,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
   await removeReport();
 }
 function manifestRelativePath(artifacts, path) {
-  return relative3(artifacts.runDir, path).split("\\").join("/");
+  return relative4(artifacts.runDir, path).split("\\").join("/");
 }
 async function verifyReusableArtifacts(artifacts, paths, options = {}) {
   if (!await pathExists2(artifacts.artifactManifestJson)) return false;
@@ -4076,11 +4800,11 @@ async function throwIfCancelled(store, request) {
   }
 }
 async function acquireWorkflowLock(lockPath, description) {
-  await mkdir8(dirname8(lockPath), { recursive: true });
+  await mkdir9(dirname10(lockPath), { recursive: true });
   const token = randomUUID4();
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      const handle = await open2(lockPath, "wx", 384);
+      const handle = await open3(lockPath, "wx", 384);
       try {
         await handle.writeFile(`${JSON.stringify({ token, pid: process.pid, created_at: (/* @__PURE__ */ new Date()).toISOString() })}
 `);
@@ -4089,7 +4813,7 @@ async function acquireWorkflowLock(lockPath, description) {
       }
       return async () => {
         try {
-          const owner = JSON.parse(await readFile8(lockPath, "utf8"));
+          const owner = JSON.parse(await readFile9(lockPath, "utf8"));
           if (owner.token === token) await rm3(lockPath, { force: true });
         } catch {
         }
@@ -4099,7 +4823,7 @@ async function acquireWorkflowLock(lockPath, description) {
       const metadata = await stat5(lockPath).catch(() => null);
       let owner = null;
       try {
-        owner = JSON.parse(await readFile8(lockPath, "utf8"));
+        owner = JSON.parse(await readFile9(lockPath, "utf8"));
       } catch {
         owner = null;
       }
@@ -4131,11 +4855,11 @@ async function acquireWorkflowLock(lockPath, description) {
 }
 async function acquireRunLock(store, runId) {
   await store.ensure();
-  return acquireWorkflowLock(resolve12(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
+  return acquireWorkflowLock(resolve13(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
 }
 async function acquireArtifactLock(artifacts) {
   return acquireWorkflowLock(
-    join9(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
+    join11(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
     `Artifact directory ${artifacts.runDir}`
   );
 }
@@ -4182,13 +4906,13 @@ function stageFingerprintPath(prepared, stage) {
   return `${stageOutputPath(prepared, stage)}.stage.json`;
 }
 async function runnerFileFingerprints() {
-  const project = resolve12(packageRoot2, "training/adapter");
-  const bundledSource = resolve12(packageRoot2, "training/adapter/src");
-  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve12(bundledSource, entry.name));
+  const project = resolve13(packageRoot2, "training/adapter");
+  const bundledSource = resolve13(packageRoot2, "training/adapter/src");
+  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve13(bundledSource, entry.name));
   const candidates = [.../* @__PURE__ */ new Set([
     ...pythonSources,
-    resolve12(project, "pyproject.toml"),
-    resolve12(project, "uv.lock")
+    resolve13(project, "pyproject.toml"),
+    resolve13(project, "uv.lock")
   ])];
   const fingerprints = {};
   for (const path of candidates.sort()) fingerprints[path] = await hashFileIfPresent(path);
@@ -4302,7 +5026,7 @@ async function ensureRunRecord(args) {
         `Run ${args.request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
       );
     }
-    if (resolve12(existing.artifact_dir) !== resolve12(args.artifacts.runDir)) {
+    if (resolve13(existing.artifact_dir) !== resolve13(args.artifacts.runDir)) {
       throw new Error(
         `Run ${args.request.run_id} is already bound to artifact directory ${existing.artifact_dir}; it cannot be resumed with ${args.artifacts.runDir}.`
       );
@@ -4409,7 +5133,7 @@ async function prepareStage(args) {
   const preparedExists = await pathExists2(args.artifacts.stageMetadataJson) && await pathExists2(args.artifacts.trainingJsonl);
   const prepared = await computePreparedRun({ ...args, writeArtifacts: false });
   await args.store.syncRunRequest(args.request, args.artifacts.runDir);
-  await writeJsonAtomic(resolve12(args.artifacts.runDir, "request.json"), args.request);
+  await writeJsonAtomic(resolve13(args.artifacts.runDir, "request.json"), args.request);
   const existingMetadata = preparedExists ? await readStageMetadata(args.artifacts.stageMetadataJson) : null;
   let canReuse = preparedExists && existingMetadata?.source_fingerprint === prepared.metadata.source_fingerprint;
   if (canReuse) {
@@ -4938,7 +5662,7 @@ async function runLocalPipeline(input) {
         if (step.uses === "evaluate") {
           const isBase = step.with.model === "base";
           const report = isBase ? await runBaselineStage({ prepared, config: input.config, store, reporter: input.reporter, runReporter }) : await runCandidateStage({ prepared, config: input.config, store, reporter: input.reporter, runReporter });
-          const reportPath = join9(artifacts.runDir, "evaluations", `${step.id}.json`);
+          const reportPath = join11(artifacts.runDir, "evaluations", `${step.id}.json`);
           await writeJsonAtomic(reportPath, { ...report, artifact_uri: fileUri(reportPath) });
           outputs[step.id] = { report: { ...report, artifact_uri: fileUri(reportPath) }, reportPath };
           await refreshArtifactManifest(prepared);
@@ -5027,6 +5751,23 @@ export {
   getConfigDir,
   getAgentConfigDir,
   defaultStoreRoot,
+  warningsFromSnapshot,
+  minimalMachineLearningEnvironment,
+  withHuggingFaceCacheEnvironment,
+  withOfflineHuggingFaceCacheEnvironment,
+  reportInBackground,
+  sanitizeLogLine,
+  forwardStreamLines,
+  localRuntimePackageRoot,
+  buildBundledPythonCommand,
+  withBundledPythonEnvironment,
+  buildFoundationPythonCommand,
+  withFoundationPythonEnvironment,
+  runLoggedProcess,
+  readHardwareSnapshot,
+  formatHostStatusLine,
+  formatAgentHostBlock,
+  assessHardware,
   isTerminalRunState,
   defaultLocalHome,
   localStorePaths,
@@ -5054,6 +5795,7 @@ export {
   localRunnerConfigSchema,
   isFoundationSpecFile,
   DEFAULT_LOCAL_SPEC_PATH,
+  localPathsOverlap,
   resolveLocalRunInputPaths,
   initLocalSpecFile,
   initLocalRunnerConfigFile,
@@ -5070,18 +5812,6 @@ export {
   examplesFromSpec,
   examplesFromChatJsonl,
   evaluationSuiteFromChatJsonl,
-  reportInBackground,
-  sanitizeLogLine,
-  forwardStreamLines,
-  localRuntimePackageRoot,
-  buildBundledPythonCommand,
-  withBundledPythonEnvironment,
-  buildFoundationPythonCommand,
-  withFoundationPythonEnvironment,
-  runLoggedProcess,
-  minimalMachineLearningEnvironment,
-  withHuggingFaceCacheEnvironment,
-  withOfflineHuggingFaceCacheEnvironment,
   tokenF1,
   verifyModelPrefetchCacheReport,
   buildModelPrefetchPayload,
@@ -5098,4 +5828,4 @@ export {
   runLocalPipeline,
   runLocalFineTune
 };
-//# sourceMappingURL=chunk-7VIUHQBI.js.map
+//# sourceMappingURL=chunk-W7MOBPCO.js.map