@tuned-tensor/cli 0.9.0 → 0.9.1

package/dist/chunk-DAP2Z7EZ.js

@@ -0,0 +1,4400 @@
+#!/usr/bin/env node
+
+// src/local-runtime/artifacts.ts
+import { createHash, randomUUID } from "crypto";
+import { createReadStream } from "fs";
+import { copyFile, lstat, mkdir, open, readFile, readdir, realpath, rename, stat, writeFile } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { createGunzip } from "zlib";
+var RUN_OWNER_FILE = ".tt-local-run-owner.json";
+var ARTIFACT_WORKFLOW_LOCK_FILE = ".tt-local-workflow.lock";
+function fileUri(path) {
+  return `file://${resolve(path)}`;
+}
+function defaultArtifactPrefix(input) {
+  return join("users", input.userId, "specs", input.behaviorSpecId, "runs", input.runId);
+}
+function resolveRunArtifacts(args) {
+  const root = resolve(args.artifactRoot);
+  const safePrefix = args.prefix.replace(/^[/\\]+/, "");
+  const runDir = resolve(root, safePrefix);
+  const containment = relative(root, runDir);
+  if (containment === ".." || containment.startsWith(`..${sep}`) || isAbsolute(containment)) {
+    throw new Error(`Artifact prefix escapes artifactRoot: ${args.prefix}`);
+  }
+  const trainingDir = join(runDir, "training");
+  return {
+    root,
+    prefix: safePrefix,
+    runDir,
+    trainingJsonl: join(runDir, "training.jsonl"),
+    stageMetadataJson: join(runDir, "stage-metadata.json"),
+    trainingReportJson: join(runDir, "training-report.json"),
+    baselineEvalJson: join(runDir, "baseline-eval.json"),
+    candidateEvalJson: join(runDir, "candidate-eval.json"),
+    generalBaselineEvalJson: join(runDir, "general-baseline-eval.json"),
+    generalCandidateEvalJson: join(runDir, "general-candidate-eval.json"),
+    runReportJson: join(runDir, "run-report.json"),
+    artifactManifestJson: join(runDir, "artifact-manifest.json"),
+    progressJsonl: join(runDir, "progress.jsonl"),
+    trainingDir,
+    trainingInputDir: join(trainingDir, "input", "data", "training"),
+    trainingConfigDir: join(trainingDir, "input", "config"),
+    trainingOutputDir: join(trainingDir, "output"),
+    trainingModelDir: join(trainingDir, "model"),
+    trainingLog: join(trainingDir, "training.log")
+  };
+}
+async function ensureSafeRunDirectory(artifacts) {
+  await mkdir(artifacts.root, { recursive: true });
+  const canonicalRoot = await realpath(artifacts.root);
+  const pathFromRoot = relative(artifacts.root, artifacts.runDir);
+  const segments = pathFromRoot ? pathFromRoot.split(sep).filter(Boolean) : [];
+  let current = artifacts.root;
+  for (const segment of segments) {
+    current = join(current, segment);
+    let metadata = await lstat(current).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!metadata) {
+      await mkdir(current).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      metadata = await lstat(current);
+    }
+    if (metadata.isSymbolicLink()) {
+      throw new Error(`Artifact path must not contain symbolic links: ${current}`);
+    }
+    if (!metadata.isDirectory()) {
+      throw new Error(`Artifact path component is not a directory: ${current}`);
+    }
+  }
+  const canonicalRunDir = await realpath(artifacts.runDir);
+  const containment = relative(canonicalRoot, canonicalRunDir);
+  if (containment === ".." || containment.startsWith(`..${sep}`) || isAbsolute(containment)) {
+    throw new Error(`Artifact run directory escapes artifactRoot: ${artifacts.runDir}`);
+  }
+}
+async function claimRunArtifactDirectory(args) {
+  await ensureSafeRunDirectory(args.artifacts);
+  const ownerPath = join(args.artifacts.runDir, RUN_OWNER_FILE);
+  const proposed = {
+    schema_version: 1,
+    run_id: args.runId,
+    user_id: args.userId,
+    behavior_spec_id: args.behaviorSpecId,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    const handle = await open(ownerPath, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(proposed, null, 2)}
+`);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    return proposed;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  let existing;
+  try {
+    existing = JSON.parse(await readFile(ownerPath, "utf8"));
+  } catch (error) {
+    throw new Error(`Artifact run owner claim is unreadable: ${ownerPath}`, { cause: error });
+  }
+  if (existing.schema_version !== 1 || existing.run_id !== args.runId || existing.user_id !== args.userId || existing.behavior_spec_id !== args.behaviorSpecId) {
+    throw new Error(
+      `Artifact directory ${args.artifacts.runDir} is already owned by run ${existing.run_id ?? "unknown"}; run ${args.runId} must use a different artifacts.prefix.`
+    );
+  }
+  return existing;
+}
+async function prepareRunDirectories(artifacts) {
+  await ensureSafeRunDirectory(artifacts);
+  await Promise.all([
+    mkdir(artifacts.runDir, { recursive: true }),
+    mkdir(artifacts.trainingInputDir, { recursive: true }),
+    mkdir(artifacts.trainingConfigDir, { recursive: true }),
+    mkdir(artifacts.trainingOutputDir, { recursive: true }),
+    mkdir(artifacts.trainingModelDir, { recursive: true })
+  ]);
+}
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function writeJsonAtomic(path, value) {
+  await writeFileAtomic(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function writeFileAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+  await writeFile(temporary, value);
+  await rename(temporary, path);
+}
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function copyDatasetToTrainingChannel(artifacts) {
+  const destination = join(artifacts.trainingInputDir, "training.jsonl");
+  await copyFile(artifacts.trainingJsonl, destination);
+  return destination;
+}
+var MANIFEST_IGNORED_PATHS = /* @__PURE__ */ new Set([
+  "artifact-manifest.json",
+  // These are append-only/control-plane files rather than immutable stage
+  // outputs. Including them would invalidate a manifest whenever the store
+  // records the next stage event or refreshes the canonical request copy.
+  "progress.jsonl",
+  "request.json",
+  RUN_OWNER_FILE,
+  ARTIFACT_WORKFLOW_LOCK_FILE
+]);
+function portableRelative(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+function shouldManifest(path) {
+  const atomicTemporary = /\.\d+\.\d+\.[0-9a-f-]{36}\.tmp$/i.test(path);
+  return !MANIFEST_IGNORED_PATHS.has(path) && !atomicTemporary;
+}
+async function listArtifactFiles(root, current = root) {
+  const files = [];
+  for (const entry of await readdir(current, { withFileTypes: true }).catch(() => [])) {
+    const absolute = join(current, entry.name);
+    if (entry.isSymbolicLink()) {
+      throw new Error(`Artifact tree must not contain symbolic links: ${absolute}`);
+    }
+    if (entry.isDirectory()) {
+      files.push(...await listArtifactFiles(root, absolute));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const relativePath = portableRelative(root, absolute);
+    if (!shouldManifest(relativePath)) continue;
+    const metadata = await stat(absolute).catch(() => null);
+    if (metadata?.isFile()) files.push(relativePath);
+  }
+  return files.sort();
+}
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function describeArtifactFile(root, path) {
+  const absolute = join(root, path);
+  const metadata = await stat(absolute);
+  return {
+    path,
+    size_bytes: metadata.size,
+    sha256: await sha256File(absolute)
+  };
+}
+function assertManifestFiles(value, label) {
+  if (!Array.isArray(value)) throw new Error(`Artifact manifest ${label} must be an array.`);
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of value) {
+    if (!file || typeof file.path !== "string" || !Number.isSafeInteger(file.size_bytes) || file.size_bytes < 0 || typeof file.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(file.sha256)) {
+      throw new Error(`Artifact manifest contains an invalid ${label} entry.`);
+    }
+    const manifestPath = file.path;
+    const segments = manifestPath.split("/");
+    if (!manifestPath || manifestPath.includes("\\") || manifestPath.includes("\0") || manifestPath.startsWith("/") || /^[a-z]:/i.test(manifestPath) || segments.some((segment) => !segment || segment === "." || segment === "..")) {
+      throw new Error(`Artifact manifest contains an unsafe ${label} path: ${manifestPath}`);
+    }
+    if (paths.has(manifestPath)) throw new Error(`Artifact manifest contains a duplicate ${label} path: ${manifestPath}`);
+    paths.add(manifestPath);
+  }
+}
+function hasPeftAdapterFiles(files) {
+  const names = new Set(
+    files.filter((file) => file.size_bytes > 0).map((file) => file.path.split("/").at(-1)?.toLowerCase())
+  );
+  return names.has("adapter_config.json") && (names.has("adapter_model.safetensors") || names.has("adapter_model.bin"));
+}
+function parseArtifactManifest(value) {
+  if (!value || typeof value !== "object") throw new Error("Artifact manifest must be an object.");
+  const candidate = value;
+  if (candidate.schema_version !== 1 || !Array.isArray(candidate.files)) {
+    throw new Error("Unsupported or invalid artifact manifest.");
+  }
+  assertManifestFiles(candidate.files, "file");
+  if (candidate.model) {
+    const model = candidate.model;
+    const allowedModelKeys = /* @__PURE__ */ new Set([
+      "artifact_kind",
+      "format",
+      "framework",
+      "base_model",
+      "base_model_revision",
+      "base_model_artifact_uri",
+      "base_model_fingerprint",
+      "artifact_uri",
+      "artifact_root",
+      "servable",
+      "files"
+    ]);
+    const hasBaseArtifact = model.base_model_artifact_uri !== void 0;
+    const hasBaseFingerprint = model.base_model_fingerprint !== void 0;
+    if (Object.keys(model).some((key) => !allowedModelKeys.has(key)) || model.artifact_kind !== "file" && model.artifact_kind !== "directory" || model.format !== "tar.gz" && model.format !== "huggingface-directory" || model.framework !== "transformers-peft" || typeof model.base_model !== "string" || model.base_model_revision !== void 0 && typeof model.base_model_revision !== "string" || model.base_model_artifact_uri !== void 0 && typeof model.base_model_artifact_uri !== "string" || model.base_model_fingerprint !== void 0 && typeof model.base_model_fingerprint !== "string" || hasBaseArtifact !== hasBaseFingerprint || typeof model.artifact_uri !== "string" || typeof model.artifact_root !== "string" || model.servable !== true || !Array.isArray(model.files) || model.files.length === 0 || model.artifact_kind === "file" && model.format !== "tar.gz" || model.artifact_kind === "directory" && model.format !== "huggingface-directory") {
+      throw new Error("Artifact manifest contains invalid model contract metadata.");
+    }
+    assertManifestFiles(model.files, "model file");
+    if (model.artifact_kind === "directory" && !hasPeftAdapterFiles(model.files)) {
+      throw new Error("PEFT model manifest requires adapter weights and adapter_config.json.");
+    }
+  }
+  return candidate;
+}
+async function writeArtifactManifest(artifacts, options = {}) {
+  const paths = await listArtifactFiles(artifacts.runDir);
+  let model;
+  if (options.model) {
+    if (options.model.framework !== "transformers-peft" || options.model.servable !== true || options.model.artifact_kind === "file" && options.model.format !== "tar.gz" || options.model.artifact_kind === "directory" && options.model.format !== "huggingface-directory") {
+      throw new Error("TT Local model artifacts must be verified, servable Transformers PEFT adapters.");
+    }
+    if (options.model.base_model_artifact_uri === void 0 !== (options.model.base_model_fingerprint === void 0)) {
+      throw new Error("Model contracts must record a local base-model URI and fingerprint together.");
+    }
+    const modelRoot = resolve(options.model.artifact_root);
+    const modelPaths = options.model.artifact_kind === "file" ? [portableRelative(dirname(modelRoot), modelRoot)] : await listArtifactFiles(modelRoot);
+    const checksumRoot = options.model.artifact_kind === "file" ? dirname(modelRoot) : modelRoot;
+    if (options.model.artifact_kind === "file") {
+      if (!modelRoot.toLowerCase().endsWith(".tar.gz")) {
+        throw new Error(`PEFT file artifacts must be .tar.gz archives: ${modelRoot}`);
+      }
+      const archive = await verifyTarGzipArchive(modelRoot);
+      if (archive.adapter_weight_entries === 0 || archive.adapter_weight_bytes === 0) {
+        throw new Error(`PEFT model archive contains no adapter_model.safetensors or adapter_model.bin: ${modelRoot}`);
+      }
+      if (archive.adapter_config_entries === 0) {
+        throw new Error(`PEFT model archive contains no adapter_config.json: ${modelRoot}`);
+      }
+    }
+    const modelFiles = await Promise.all(modelPaths.map((path) => describeArtifactFile(checksumRoot, path)));
+    if (options.model.artifact_kind === "directory" && !hasPeftAdapterFiles(modelFiles)) {
+      throw new Error(`PEFT model directory requires adapter weights and adapter_config.json: ${modelRoot}`);
+    }
+    model = {
+      ...options.model,
+      artifact_root: modelRoot,
+      files: modelFiles
+    };
+  }
+  const manifest = {
+    schema_version: 1,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    files: await Promise.all(paths.map((path) => describeArtifactFile(artifacts.runDir, path))),
+    ...model ? { model } : {}
+  };
+  await writeJsonAtomic(artifacts.artifactManifestJson, manifest);
+  return manifest;
+}
+async function verifyArtifactManifest(manifestPath, options = {}) {
+  const root = dirname(resolve(manifestPath));
+  const manifest = parseArtifactManifest(JSON.parse(await readFile(manifestPath, "utf8")));
+  const expected = new Map(manifest.files.map((file) => [file.path, file]));
+  const actualPaths = await listArtifactFiles(root);
+  const actual = new Set(actualPaths);
+  const missing = [];
+  const changed = [];
+  const normalizedRequired = (options.requiredPaths ?? []).map((path) => path.split(sep).join("/").replace(/^\.\//, ""));
+  const checkedEntries = options.scopeToRequired ? normalizedRequired.flatMap((path) => {
+    const entry = expected.get(path);
+    return entry ? [[path, entry]] : [];
+  }) : [...expected.entries()];
+  for (const [path, expectedFile] of checkedEntries) {
+    if (!actual.has(path)) {
+      missing.push(path);
+      continue;
+    }
+    const actualFile = await describeArtifactFile(root, path);
+    if (actualFile.size_bytes !== expectedFile.size_bytes || actualFile.sha256 !== expectedFile.sha256) {
+      changed.push(path);
+    }
+  }
+  for (const normalized of normalizedRequired) {
+    if (!expected.has(normalized) && !missing.includes(normalized)) missing.push(normalized);
+  }
+  const unexpected = options.allowUnexpected || options.scopeToRequired ? [] : actualPaths.filter((path) => !expected.has(path));
+  let modelChecked = 0;
+  if (manifest.model && (options.verifyModel ?? !options.scopeToRequired)) {
+    const modelRoot = resolve(manifest.model.artifact_root);
+    const checksumRoot = manifest.model.artifact_kind === "file" ? dirname(modelRoot) : modelRoot;
+    const modelActualPaths = manifest.model.artifact_kind === "file" ? [portableRelative(checksumRoot, modelRoot)] : await listArtifactFiles(modelRoot);
+    const modelActual = new Set(modelActualPaths);
+    for (const expectedFile of manifest.model.files) {
+      const label = `model:${expectedFile.path}`;
+      if (!modelActual.has(expectedFile.path)) {
+        missing.push(label);
+        continue;
+      }
+      const actualFile = await describeArtifactFile(checksumRoot, expectedFile.path);
+      modelChecked += 1;
+      if (actualFile.size_bytes !== expectedFile.size_bytes || actualFile.sha256 !== expectedFile.sha256) {
+        changed.push(label);
+      }
+    }
+    if (!options.allowUnexpected) {
+      const expectedModelPaths = new Set(manifest.model.files.map((file) => file.path));
+      unexpected.push(...modelActualPaths.filter((path) => !expectedModelPaths.has(path)).map((path) => `model:${path}`));
+    }
+    if (manifest.model.artifact_kind === "file") {
+      try {
+        const archive = await verifyTarGzipArchive(modelRoot);
+        if (archive.adapter_weight_entries === 0 || archive.adapter_weight_bytes === 0) {
+          changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:missing_adapter_weights`);
+        }
+        if (archive.adapter_config_entries === 0) {
+          changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:missing_adapter_config`);
+        }
+      } catch {
+        changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:invalid_archive`);
+      }
+    } else if (!hasPeftAdapterFiles(
+      await Promise.all(modelActualPaths.map((path) => describeArtifactFile(checksumRoot, path)))
+    )) {
+      changed.push("model:missing_peft_adapter");
+    }
+  }
+  return {
+    valid: missing.length === 0 && changed.length === 0 && unexpected.length === 0,
+    checked: checkedEntries.length + modelChecked,
+    missing: [...new Set(missing)].sort(),
+    changed: changed.sort(),
+    unexpected: unexpected.sort()
+  };
+}
+async function verifyTarGzipArchive(path) {
+  const maxEntries = 1e5;
+  const maxExpandedBytes = 20 * 1024 * 1024 * 1024;
+  const maxPaxBytes = 1024 * 1024;
+  const safeMemberPath = (value) => {
+    const normalized = value.replaceAll("\\", "/");
+    const segments = normalized.split("/").filter(Boolean);
+    if (!normalized || normalized.startsWith("/") || /^[a-z]:\//i.test(normalized) || segments.includes("..")) {
+      throw new Error(`Unsafe tar member path ${JSON.stringify(normalized)} in ${path}.`);
+    }
+    return normalized;
+  };
+  const parsePax = (payload, global) => {
+    let offset = 0;
+    let memberPath;
+    const allowedMetadata = /* @__PURE__ */ new Set(["mtime", "atime", "ctime", "uid", "gid", "uname", "gname"]);
+    while (offset < payload.length) {
+      const separator = payload.indexOf(32, offset);
+      if (separator < 0) throw new Error(`Malformed PAX record in ${path}.`);
+      const lengthText = payload.subarray(offset, separator).toString("ascii");
+      if (!/^[1-9][0-9]*$/.test(lengthText)) throw new Error(`Malformed PAX record length in ${path}.`);
+      const length = Number.parseInt(lengthText, 10);
+      const end = offset + length;
+      if (!Number.isSafeInteger(length) || end > payload.length || payload[end - 1] !== 10) {
+        throw new Error(`Truncated PAX record in ${path}.`);
+      }
+      const record = payload.subarray(separator + 1, end - 1).toString("utf8");
+      const equals = record.indexOf("=");
+      if (equals <= 0) throw new Error(`Malformed PAX key/value in ${path}.`);
+      const key = record.slice(0, equals);
+      const value = record.slice(equals + 1);
+      if (key === "path") {
+        if (global) throw new Error(`Global PAX path overrides are unsupported in ${path}.`);
+        memberPath = safeMemberPath(value);
+      } else if (!allowedMetadata.has(key)) {
+        throw new Error(`Unsupported PAX key ${JSON.stringify(key)} in ${path}.`);
+      }
+      offset = end;
+    }
+    return memberPath;
+  };
+  const gunzip = createReadStream(path).pipe(createGunzip());
+  let buffered = Buffer.alloc(0);
+  let payloadBytes = 0;
+  let paddingBytes = 0;
+  let paxType = null;
+  let paxChunks = [];
+  let pendingPaxPath;
+  let entries = 0;
+  let payloadEntries = 0;
+  let recognizedPayloadEntries = 0;
+  let recognizedPayloadBytes = 0;
+  let adapterWeightEntries = 0;
+  let adapterWeightBytes = 0;
+  let fullModelWeightEntries = 0;
+  let fullModelWeightBytes = 0;
+  let adapterConfigEntries = 0;
+  let expandedBytes = 0;
+  let zeroBlocks = 0;
+  let ended = false;
+  for await (const chunk of gunzip) {
+    buffered = Buffer.concat([buffered, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    while (true) {
+      if (payloadBytes > 0) {
+        if (buffered.length === 0) break;
+        const consumed = Math.min(payloadBytes, buffered.length);
+        if (paxType) paxChunks.push(buffered.subarray(0, consumed));
+        buffered = buffered.subarray(consumed);
+        payloadBytes -= consumed;
+        continue;
+      }
+      if (paddingBytes > 0) {
+        if (buffered.length === 0) break;
+        const consumed = Math.min(paddingBytes, buffered.length);
+        buffered = buffered.subarray(consumed);
+        paddingBytes -= consumed;
+        continue;
+      }
+      if (paxType) {
+        const paxPath = parsePax(Buffer.concat(paxChunks), paxType === "g");
+        if (paxType === "x") pendingPaxPath = paxPath;
+        paxType = null;
+        paxChunks = [];
+        continue;
+      }
+      if (buffered.length < 512) break;
+      const header = buffered.subarray(0, 512);
+      buffered = buffered.subarray(512);
+      if (header.every((byte) => byte === 0)) {
+        zeroBlocks += 1;
+        if (zeroBlocks >= 2) ended = true;
+        continue;
+      }
+      if (ended) throw new Error(`Tar archive contains data after its end marker: ${path}.`);
+      zeroBlocks = 0;
+      const checksumText = header.subarray(148, 156).toString("ascii").replace(/\0/g, "").trim();
+      if (!/^[0-7]+$/.test(checksumText)) throw new Error(`Invalid tar checksum field in ${path}.`);
+      const expectedChecksum = Number.parseInt(checksumText, 8);
+      let actualChecksum = 0;
+      for (let index = 0; index < header.length; index += 1) {
+        actualChecksum += index >= 148 && index < 156 ? 32 : header[index];
+      }
+      if (actualChecksum !== expectedChecksum) throw new Error(`Tar member checksum mismatch in ${path}.`);
+      const sizeText = header.subarray(124, 136).toString("ascii").replace(/\0/g, "").trim();
+      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 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 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")) {
+        adapterConfigEntries += 1;
+      }
+      if ((type === "x" || type === "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")) {
+        recognizedPayloadEntries += 1;
+        recognizedPayloadBytes += size;
+      }
+      if (size > 0 && adapterWeight && (type === "\0" || type === "0")) {
+        adapterWeightEntries += 1;
+        adapterWeightBytes += size;
+      }
+      if (size > 0 && fullModelWeight && (type === "\0" || type === "0")) {
+        fullModelWeightEntries += 1;
+        fullModelWeightBytes += size;
+      }
+      expandedBytes += size;
+      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;
+      paxChunks = [];
+      entries += 1;
+      if (entries > maxEntries) throw new Error(`Tar archive exceeds ${maxEntries} members: ${path}.`);
+    }
+  }
+  if (payloadBytes !== 0 || paddingBytes !== 0 || paxType || buffered.some((byte) => byte !== 0)) {
+    throw new Error(`Truncated tar archive: ${path}.`);
+  }
+  if (pendingPaxPath) throw new Error(`PAX path override has no following member in ${path}.`);
+  if (!ended) throw new Error(`Tar archive is missing its end marker: ${path}.`);
+  if (entries === 0) throw new Error(`Empty tar archive: ${path}.`);
+  if (payloadEntries === 0) throw new Error(`Tar archive contains no model payload files: ${path}.`);
+  return {
+    entries,
+    payload_entries: payloadEntries,
+    recognized_payload_entries: recognizedPayloadEntries,
+    recognized_payload_bytes: recognizedPayloadBytes,
+    adapter_weight_entries: adapterWeightEntries,
+    adapter_weight_bytes: adapterWeightBytes,
+    full_model_weight_entries: fullModelWeightEntries,
+    full_model_weight_bytes: fullModelWeightBytes,
+    adapter_config_entries: adapterConfigEntries,
+    expanded_bytes: expandedBytes
+  };
+}
+async function assertArtifactManifest(manifestPath, options = {}) {
+  const result = await verifyArtifactManifest(manifestPath, options);
+  if (!result.valid) {
+    const details = [
+      result.missing.length ? `missing=${result.missing.join(",")}` : "",
+      result.changed.length ? `changed=${result.changed.join(",")}` : "",
+      result.unexpected.length ? `unexpected=${result.unexpected.join(",")}` : ""
+    ].filter(Boolean).join(" ");
+    throw new Error(`Artifact integrity verification failed${details ? `: ${details}` : "."}`);
+  }
+  return result;
+}
+
+// src/local-runtime/model-registry.ts
+import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var TRAINING_MODELS = [
+  {
+    id: "Qwen/Qwen3.5-2B",
+    family: "qwen3_5",
+    defaultLearningRate: 1e-5,
+    defaultPerDeviceBatchSize: 1,
+    defaultGradientAccumulationSteps: 8,
+    defaultLoraRank: 16,
+    defaultLoraAlpha: 32,
+    defaultLoraDropout: 0.05,
+    defaultMaxSeqLength: 2048
+  }
+];
+function resolveTrainingModel(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  const model = TRAINING_MODELS.find(
+    (candidate) => candidate.id.toLowerCase() === normalized
+  );
+  if (!model) {
+    throw new Error(
+      `Unsupported base model "${modelId}". Supported model: ${TRAINING_MODELS[0].id}`
+    );
+  }
+  return model;
+}
+function canonicalizeTrainingModel(modelId) {
+  return resolveTrainingModel(modelId).id;
+}
+var CERTIFIED_TEXT_CONFIG = {
+  model_type: "qwen3_5_text",
+  hidden_size: 2048,
+  num_hidden_layers: 24,
+  num_attention_heads: 8,
+  num_key_value_heads: 2,
+  intermediate_size: 6144,
+  vocab_size: 248320
+};
+function assertCertifiedBaseModelConfig(value, label = "base-model config.json") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must contain a JSON object.`);
+  }
+  const config = value;
+  const architectures = config.architectures;
+  const textConfig = config.text_config;
+  if (config.model_type !== "qwen3_5" || !Array.isArray(architectures) || !architectures.includes("Qwen3_5ForConditionalGeneration") || !textConfig || typeof textConfig !== "object" || Array.isArray(textConfig)) {
+    throw new Error(
+      `${label} is not the certified Qwen/Qwen3.5-2B architecture.`
+    );
+  }
+  const text = textConfig;
+  for (const [key, expected] of Object.entries(CERTIFIED_TEXT_CONFIG)) {
+    if (text[key] !== expected) {
+      throw new Error(
+        `${label} is not the certified Qwen/Qwen3.5-2B architecture: text_config.${key} must be ${JSON.stringify(expected)}.`
+      );
+    }
+  }
+}
+function localModelArtifactPath(uri) {
+  if (uri.startsWith("file://")) return fileURLToPath(new URL(uri));
+  if (/^[a-z][a-z0-9+.-]*:/i.test(uri)) {
+    throw new Error(`Model artifact must be a local path or file URI: ${uri}`);
+  }
+  return resolve2(uri);
+}
+function adapterWeightName(name) {
+  const lower = name.toLowerCase();
+  return lower === "adapter_model.safetensors" || lower === "adapter_model.bin";
+}
+async function inspectAdapterDirectory(path) {
+  let count = 0;
+  let bytes = 0;
+  let hasConfig = false;
+  for (const entry of await readdir2(path, { withFileTypes: true })) {
+    const child = resolve2(path, entry.name);
+    if (entry.isSymbolicLink()) {
+      throw new Error(`Model artifact must not contain symbolic links: ${child}`);
+    }
+    if (entry.isDirectory()) {
+      const nested = await inspectAdapterDirectory(child);
+      count += nested.count;
+      bytes += nested.bytes;
+      hasConfig ||= nested.hasConfig;
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const metadata = await lstat2(child);
+    if (adapterWeightName(entry.name) && metadata.size > 0) {
+      count += 1;
+      bytes += metadata.size;
+    }
+    if (entry.name.toLowerCase() === "adapter_config.json" && metadata.size > 0) {
+      hasConfig = true;
+    }
+  }
+  return { count, bytes, hasConfig };
+}
+async function inspectModelArtifact(uri) {
+  const path = localModelArtifactPath(uri);
+  const metadata = await lstat2(path).catch(() => null);
+  if (!metadata) throw new Error(`Model artifact does not exist: ${path}`);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Model artifact must not be a symbolic link: ${path}`);
+  }
+  if (metadata.isDirectory()) {
+    const adapter = await inspectAdapterDirectory(path);
+    return {
+      uri,
+      path,
+      kind: "directory",
+      adapter_weight_file_count: adapter.count,
+      adapter_weight_bytes: adapter.bytes,
+      has_adapter_config: adapter.hasConfig
+    };
+  }
+  if (!metadata.isFile() || !path.toLowerCase().endsWith(".tar.gz")) {
+    throw new Error(
+      `Model artifact must be a PEFT adapter directory or .tar.gz archive: ${path}`
+    );
+  }
+  const archive = await verifyTarGzipArchive(path);
+  return {
+    uri,
+    path,
+    kind: "file",
+    adapter_weight_file_count: archive.adapter_weight_entries,
+    adapter_weight_bytes: archive.adapter_weight_bytes,
+    has_adapter_config: archive.adapter_config_entries > 0
+  };
+}
+async function assertUsableModelArtifact(uri) {
+  const inspection = await inspectModelArtifact(uri);
+  if (inspection.adapter_weight_file_count === 0 || inspection.adapter_weight_bytes === 0) {
+    throw new Error(
+      `PEFT model artifact ${inspection.path} contains no non-empty adapter_model weights.`
+    );
+  }
+  if (!inspection.has_adapter_config) {
+    throw new Error(
+      `PEFT model artifact ${inspection.path} contains adapter weights but no non-empty adapter_config.json.`
+    );
+  }
+  return inspection;
+}
+
+// src/local-runtime/contracts.ts
+import { z } from "zod";
+var datasetFormatSchema = z.literal("chat_jsonl");
+var baseModelRevisionSchema = z.string().regex(/^[0-9a-f]{40}$/i, "base_model_revision must be a 40-character Hugging Face commit SHA").transform((value) => value.toLowerCase());
+var behaviorSpecExampleSchema = z.object({
+  input: z.string().min(1),
+  output: z.string().min(1)
+}).strict();
+var specSnapshotSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().default(""),
+  system_prompt: z.string().default(""),
+  guidelines: z.array(z.string()).default([]),
+  examples: z.array(behaviorSpecExampleSchema).default([]),
+  constraints: z.array(z.string()).default([]),
+  base_model: z.string().transform((value) => canonicalizeTrainingModel(value))
+}).strict();
+var datasetPrebuiltSchema = z.object({
+  training: z.string().min(1),
+  validation: z.string().min(1).optional(),
+  test: z.string().min(1).optional(),
+  format: datasetFormatSchema.default("chat_jsonl")
+}).strict().superRefine((dataset, context) => {
+  if (!dataset.validation && !dataset.test) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["validation"],
+      message: "Provide a distinct validation or test split for held-out evaluation"
+    });
+  }
+});
+var fineTuneHyperparametersSchema = z.object({
+  n_epochs: z.number().int().min(1).max(20).default(1),
+  learning_rate: z.number().positive().optional(),
+  batch_size: z.number().int().min(1).optional(),
+  lora_rank: z.number().int().min(1).optional(),
+  lora_alpha: z.number().int().min(1).optional(),
+  lora_dropout: z.number().min(0).max(1).optional(),
+  max_seq_length: z.number().int().min(128).max(32768).optional(),
+  gradient_accumulation_steps: z.number().int().min(1).optional(),
+  max_eval_examples: z.number().int().min(1).optional(),
+  /** Immutable Hugging Face commit used by every stage of the run. */
+  base_model_revision: baseModelRevisionSchema.optional()
+}).strict();
+var fineTuneRunRequestSchema = z.object({
+  run_id: z.string().uuid(),
+  user_id: z.string().min(1),
+  behavior_spec_id: z.string().uuid(),
+  run_number: z.number().int().min(1),
+  spec_snapshot: specSnapshotSchema,
+  hyperparameters: fineTuneHyperparametersSchema.default({ n_epochs: 1 }),
+  dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict().superRefine((request, context) => {
+  if (request.spec_snapshot.examples.length === 0 && !request.dataset_prebuilt) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["spec_snapshot", "examples"],
+      message: "Add examples or provide dataset_prebuilt training and validation files"
+    });
+  }
+});
+var localBehaviorSpecFileSchema = specSnapshotSchema.extend({
+  id: z.string().uuid().optional(),
+  hyperparameters: fineTuneHyperparametersSchema.optional(),
+  dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict();
+var evalExampleResultSchema = z.object({
+  prompt: z.string(),
+  expected: z.string(),
+  actual: z.string(),
+  passed: z.boolean(),
+  score: z.number().min(0).max(1),
+  reasoning: z.string().nullable(),
+  latency_ms: z.number().int().nonnegative(),
+  scored_by: z.enum(["exact_match", "json_fields", "heuristic"]).optional()
+}).strict();
+var jsonFieldMetricsSchema = z.object({
+  fields: z.array(z.string()),
+  valid_json_count: z.number().int().nonnegative(),
+  valid_json_rate: z.number().min(0).max(1),
+  schema_match_count: z.number().int().nonnegative(),
+  schema_match_rate: z.number().min(0).max(1),
+  all_fields_match_count: z.number().int().nonnegative(),
+  all_fields_match_rate: z.number().min(0).max(1),
+  field_accuracy: z.record(z.string(), z.object({
+    correct: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+    accuracy: z.number().min(0).max(1)
+  }).strict())
+}).strict();
+var evalSplitSchema = z.enum([
+  "spec_examples",
+  "spec_holdout",
+  "prebuilt_test",
+  "prebuilt_validation",
+  "general_regression"
+]);
+var evalReportSchema = z.object({
+  kind: z.enum(["baseline", "candidate"]),
+  model_id: z.string(),
+  total: z.number().int().nonnegative(),
+  eval_examples_total: z.number().int().nonnegative(),
+  eval_examples_used: z.number().int().nonnegative(),
+  eval_truncated: z.boolean(),
+  eval_split: evalSplitSchema.optional(),
+  eval_sample_seed: z.number().int().nullable().optional(),
+  avg_score: z.number().min(0).max(1),
+  pass_rate: z.number().min(0).max(1),
+  exact_match_rate: z.number().min(0).max(1),
+  avg_token_f1: z.number().min(0).max(1).optional(),
+  avg_latency_ms: z.number().int().nonnegative(),
+  cached: z.boolean().optional(),
+  cache_key: z.string().optional(),
+  results: z.array(evalExampleResultSchema),
+  artifact_uri: z.string(),
+  scoring_method: z.enum(["heuristic", "exact_match", "json_fields"]),
+  inference_provider: z.enum(["none", "transformers"]).optional(),
+  scoring_mode: z.enum(["exact_match", "json_fields"]).optional(),
+  json_field_metrics: jsonFieldMetricsSchema.optional(),
+  generation_config: z.record(z.string(), z.unknown()).optional(),
+  log_uri: z.string().optional()
+}).strict();
+var comparisonReportSchema = z.object({
+  avg_score_delta: z.number(),
+  pass_rate_delta: z.number(),
+  exact_match_rate_delta: z.number(),
+  token_f1_delta: z.number().optional(),
+  regressions: z.number().int().nonnegative(),
+  improvements: z.number().int().nonnegative(),
+  regressed_examples: z.array(z.object({
+    prompt: z.string(),
+    old_score: z.number(),
+    new_score: z.number()
+  }).strict())
+}).strict();
+var trainingReportSchema = z.object({
+  provider: z.literal("local-uv"),
+  training_job_name: z.string(),
+  model_artifact_uri: z.string().optional(),
+  base_model_artifact_uri: z.string().optional(),
+  metrics: z.record(z.string(), z.unknown()).nullable(),
+  exit_code: z.number().int().nullable(),
+  log_uri: z.string(),
+  command: z.array(z.string()).optional()
+}).strict();
+var runReportSchema = z.object({
+  run_id: z.string().uuid(),
+  behavior_spec_id: z.string().uuid(),
+  user_id: z.string(),
+  run_number: z.number().int().min(1),
+  base_model: z.string(),
+  fine_tuned_model_id: z.string(),
+  status: z.enum(["completed", "failed"]),
+  baseline: evalReportSchema,
+  candidate: evalReportSchema,
+  comparison: comparisonReportSchema,
+  general_regression: z.object({
+    dataset_uri: z.string(),
+    dataset_sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    baseline: evalReportSchema,
+    candidate: evalReportSchema,
+    comparison: comparisonReportSchema,
+    policy: z.object({
+      max_score_drop: z.number().min(0).max(1),
+      max_pass_rate_drop: z.number().min(0).max(1)
+    }).strict(),
+    passed: z.boolean(),
+    failures: z.array(z.string())
+  }).strict().optional(),
+  training: trainingReportSchema,
+  artifact_uris: z.object({
+    dataset: z.string(),
+    baseline_eval: z.string(),
+    candidate_eval: z.string(),
+    general_baseline_eval: z.string().optional(),
+    general_candidate_eval: z.string().optional(),
+    report: z.string()
+  }).strict(),
+  run_metadata: z.object({
+    base_model: z.string(),
+    fine_tuned_model_id: z.string(),
+    dataset_prebuilt: z.boolean(),
+    dataset_format: datasetFormatSchema.nullable().optional(),
+    dataset_uri: z.string(),
+    spec_example_count: z.number().int().nonnegative(),
+    training_example_count: z.number().int().nonnegative().nullable(),
+    eval_examples_total: z.number().int().nonnegative(),
+    eval_examples_used: z.number().int().nonnegative(),
+    eval_split: evalSplitSchema.optional(),
+    eval_sample_seed: z.number().int().nullable().optional(),
+    started_at: z.string(),
+    completed_at: z.string(),
+    elapsed_ms: z.number().int().nonnegative(),
+    elapsed_seconds: z.number().nonnegative()
+  }).strict(),
+  created_at: z.string()
+}).strict();
+var inferenceConfigSchema = z.object({
+  maxNewTokens: z.number().int().min(1).default(256),
+  temperature: z.number().min(0).default(0),
+  topP: z.number().min(0).max(1).default(1),
+  device: z.enum(["cuda", "cpu"]).default("cuda")
+}).strict();
+var scoringConfigSchema = z.object({
+  mode: z.enum(["exact_match", "json_fields"]).default("exact_match"),
+  fields: z.array(z.string().min(1)).optional()
+}).strict();
+var evaluationConfigSchema = z.object({
+  inference: inferenceConfigSchema.default({
+    maxNewTokens: 256,
+    temperature: 0,
+    topP: 1,
+    device: "cuda"
+  }),
+  scoring: scoringConfigSchema.default({ mode: "exact_match" }),
+  timeoutMs: z.number().int().min(100).default(18e5),
+  maxExamples: z.number().int().min(1).optional(),
+  sampleSeed: z.number().int().optional(),
+  baselineCache: z.boolean().default(true),
+  generalRegression: z.object({
+    dataset: z.string().min(1),
+    systemPrompt: z.string().optional(),
+    maxScoreDrop: z.number().min(0).max(1).default(0.03),
+    maxPassRateDrop: z.number().min(0).max(1).default(0.05)
+  }).strict().optional()
+}).strict();
+var localRunnerConfigSchema = z.object({
+  storeRoot: z.string().optional(),
+  artifactRoot: z.string().default(".tt-local/artifacts"),
+  dryRun: z.boolean().default(false),
+  paths: z.object({
+    baseModel: z.string().optional(),
+    modelCache: z.string().optional()
+  }).strict().default({}),
+  evaluation: evaluationConfigSchema.default({
+    inference: {
+      maxNewTokens: 256,
+      temperature: 0,
+      topP: 1,
+      device: "cuda"
+    },
+    scoring: { mode: "exact_match" },
+    timeoutMs: 18e5,
+    baselineCache: true
+  })
+}).strict();
+
+// src/local-runtime/local-project.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+import { homedir } from "os";
+import { mkdir as mkdir2 } from "fs/promises";
+var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
+function resolveLocalReference(value, baseDirectory) {
+  if (typeof value !== "string" || !value || isAbsolute2(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
+    return value;
+  }
+  if (value === "~") return homedir();
+  if (value.startsWith("~/")) return resolve3(homedir(), value.slice(2));
+  return resolve3(baseDirectory, value);
+}
+function resolveLocalRunInputPaths(raw, inputPath) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const baseDirectory = dirname2(resolve3(inputPath));
+  const value = structuredClone(raw);
+  const dataset = value.dataset_prebuilt;
+  if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
+    const fields = dataset;
+    for (const key of ["training", "validation", "test"]) {
+      if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
+    }
+  }
+  return value;
+}
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initLocalSpecFile(args) {
+  if (!args.force && await exists(args.outputPath)) {
+    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
+  }
+  const spec = localBehaviorSpecFileSchema.parse({
+    id: randomUUID2(),
+    name: args.name,
+    description: "",
+    system_prompt: "Describe the behavior this local model should learn.",
+    guidelines: [
+      "Return concise, task-specific answers."
+    ],
+    constraints: [],
+    base_model: args.baseModel,
+    examples: [
+      {
+        input: "Replace this with representative training input.",
+        output: "Replace this with the expected training output."
+      },
+      {
+        input: "Replace this with a different validation input.",
+        output: "Replace this with the expected validation output."
+      }
+    ],
+    hyperparameters: {
+      n_epochs: 1
+    }
+  });
+  await mkdir2(dirname2(args.outputPath), { recursive: true });
+  await writeFile2(args.outputPath, `${JSON.stringify(spec, null, 2)}
+`, "utf8");
+  return spec;
+}
+async function initLocalRunnerConfigFile(args) {
+  if (!args.force && await exists(args.outputPath)) {
+    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
+  }
+  const config = {
+    artifactRoot: ".tt-local/artifacts",
+    storeRoot: ".tt-local/store",
+    evaluation: {
+      inference: {
+        device: "cuda"
+      },
+      scoring: {
+        mode: "exact_match"
+      },
+      timeoutMs: 18e5
+    }
+  };
+  await mkdir2(dirname2(args.outputPath), { recursive: true });
+  await writeFile2(args.outputPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return config;
+}
+function generatedPlaceholderIssues(request) {
+  const issues = [];
+  if (/describe the behavior this local model should learn/i.test(request.spec_snapshot.system_prompt)) {
+    issues.push("system_prompt still contains the generated placeholder");
+  }
+  request.spec_snapshot.examples.forEach((example, index) => {
+    if (/replace this with/i.test(example.input) || /replace this with/i.test(example.output)) {
+      issues.push(`examples[${index}] still contains generated placeholder text`);
+    }
+  });
+  return issues;
+}
+function assertLocalRunInputReady(request) {
+  const issues = generatedPlaceholderIssues(request);
+  if (issues.length > 0) {
+    throw new Error(`Edit the generated behavior spec before training: ${issues.join("; ")}.`);
+  }
+}
+function runRequestFromLocalSpec(spec, options = {}) {
+  const {
+    id,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt,
+    ...specSnapshot
+  } = spec;
+  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
+  return fineTuneRunRequestSchema.parse({
+    run_id: options.runId ?? randomUUID2(),
+    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 readFile2(path, "utf8")), path);
+  const request = fineTuneRunRequestSchema.safeParse(raw);
+  if (request.success) {
+    return { kind: "request", path, request: request.data };
+  }
+  const spec = localBehaviorSpecFileSchema.parse(raw);
+  return {
+    kind: "spec",
+    path,
+    spec,
+    request: runRequestFromLocalSpec(spec, options)
+  };
+}
+
+// src/local-runtime/dataset.ts
+import { readFile as readFile3 } from "fs/promises";
+async function loadNormalizedChatJsonl(path) {
+  const text = await readFile3(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 } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function localRuntimePackageRoot(moduleUrl) {
+  const moduleDirectory = dirname3(fileURLToPath2(moduleUrl));
+  const candidates = [
+    dirname3(moduleDirectory),
+    dirname3(dirname3(moduleDirectory))
+  ];
+  const root = candidates.find(
+    (candidate) => existsSync(resolve4(candidate, "package.json")) && existsSync(resolve4(candidate, "training/local-runner"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  }
+  return root;
+}
+
+// src/local-runtime/store.ts
+import { appendFile, copyFile as copyFile2, mkdir as mkdir3, readdir as readdir3, readFile as readFile4, rename as rename2, rm, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join2, resolve as resolve5 } from "path";
+import { randomUUID as randomUUID3 } 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 resolve5(process.env.TT_LOCAL_HOME ?? join2(homedir2(), ".tuned-tensor-local"));
+}
+function localStorePaths(root) {
+  return {
+    root,
+    specsDir: join2(root, "specs"),
+    runsDir: join2(root, "runs"),
+    modelsDir: join2(root, "models"),
+    datasetsDir: join2(root, "datasets")
+  };
+}
+async function exists2(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeJsonAtomic2(path, value) {
+  await mkdir3(dirname4(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID3()}.tmp`;
+  await writeFile3(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename2(tmp, path);
+}
+async function readJson2(path) {
+  return JSON.parse(await readFile4(path, "utf8"));
+}
+async function appendJsonl(path, value) {
+  await mkdir3(dirname4(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(value)}
+`, "utf8");
+}
+async function readJsonl(path) {
+  if (!await exists2(path)) return [];
+  return (await readFile4(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function copyIfExists(from, to) {
+  if (!await exists2(from)) return;
+  await mkdir3(dirname4(to), { recursive: true });
+  await copyFile2(from, to);
+}
+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 createLocalStore(root = defaultLocalHome()) {
+  const resolvedRoot = resolve5(root);
+  const paths = localStorePaths(resolvedRoot);
+  const runDir = (id) => join2(paths.runsDir, id);
+  const runStatePath = (id) => join2(runDir(id), "state.json");
+  const runEventsPath = (id) => join2(runDir(id), "progress.jsonl");
+  const runRequestPath = (id) => join2(runDir(id), "request.json");
+  const runReportPath = (id) => join2(runDir(id), "run-report.json");
+  const cancellationPath = (id) => join2(runDir(id), "cancel.requested");
+  const specDir = (id) => join2(paths.specsDir, id);
+  const specPath = (id) => join2(specDir(id), "spec.json");
+  const modelPath = (id) => join2(paths.modelsDir, id, "model.json");
+  async function ensure() {
+    await Promise.all([
+      mkdir3(paths.specsDir, { recursive: true }),
+      mkdir3(paths.runsDir, { recursive: true }),
+      mkdir3(paths.modelsDir, { recursive: true }),
+      mkdir3(paths.datasetsDir, { recursive: true })
+    ]);
+  }
+  async function writeRunState(state) {
+    await writeJsonAtomic2(runStatePath(state.id), state);
+    return state;
+  }
+  async function readSpecRecord(id) {
+    const path = specPath(id);
+    if (!await exists2(path)) return null;
+    const [spec, fileStats, directoryStats] = await Promise.all([
+      readJson2(path),
+      stat3(path),
+      stat3(specDir(id))
+    ]);
+    const createdAt = directoryStats.birthtimeMs > 0 ? directoryStats.birthtime : directoryStats.ctime;
+    return {
+      id,
+      name: spec.name,
+      base_model: spec.base_model,
+      path,
+      created_at: createdAt.toISOString(),
+      updated_at: fileStats.mtime.toISOString()
+    };
+  }
+  async function listSpecRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.specsDir)) {
+      const record = await readSpecRecord(id);
+      if (record) records.push(record);
+    }
+    return records.sort(compareUpdatedAt);
+  }
+  async function listRunRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.runsDir)) {
+      const path = runStatePath(id);
+      if (await exists2(path)) records.push(await readJson2(path));
+    }
+    return records.sort(compareUpdatedAt);
+  }
+  async function listModelRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.modelsDir)) {
+      const path = modelPath(id);
+      if (await exists2(path)) records.push(await readJson2(path));
+    }
+    return records.sort(compareCreatedAt);
+  }
+  async function importSpecRecord(specId, spec) {
+    await ensure();
+    await mkdir3(specDir(specId), { recursive: true });
+    await writeJsonAtomic2(specPath(specId), spec);
+    const record = await readSpecRecord(specId);
+    if (!record) throw new Error(`Failed to persist spec: ${specId}`);
+    return record;
+  }
+  async function appendRunEvent(state, event) {
+    const row = {
+      id: randomUUID3(),
+      run_id: state.id,
+      occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...event
+    };
+    await appendJsonl(runEventsPath(state.id), row);
+    await appendJsonl(join2(state.artifact_dir, "progress.jsonl"), {
+      at: row.occurred_at,
+      stage: row.stage,
+      status: row.status,
+      message: row.message,
+      ...row.details ? { details: row.details } : {}
+    });
+  }
+  async function finalizeCancellationState(runId) {
+    const previous = await getRun(runId);
+    if (previous.status === "cancelled" && previous.current_stage === "cancelled" && previous.completed_at) {
+      return previous;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const cancelled = {
+      ...previous,
+      status: "cancelled",
+      current_stage: "cancelled",
+      status_message: "Run cancelled.",
+      error: void 0,
+      completed_at: now,
+      updated_at: now
+    };
+    await writeRunState(cancelled);
+    await appendRunEvent(cancelled, { stage: "cancelled", status: "cancelled", message: "Run cancelled." });
+    return cancelled;
+  }
+  async function preserveCancellationRequestState(runId) {
+    const previous = await getRun(runId);
+    if (isTerminalRunState(previous)) return previous;
+    if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
+    const requested = {
+      ...previous,
+      status: "cancelled",
+      current_stage: "cancel_requested",
+      status_message: "Cancellation requested; waiting for the active worker to stop.",
+      error: void 0,
+      completed_at: void 0,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return writeRunState(requested);
+  }
+  async function resolveRunId(id) {
+    await ensure();
+    if (await exists2(runStatePath(id))) return id;
+    const record = findByIdOrPrefix(await listRunRecords(), id);
+    if (!record) throw new Error(`Run not found: ${id}`);
+    return record.id;
+  }
+  async function getRun(id) {
+    return readJson2(runStatePath(await resolveRunId(id)));
+  }
+  async function registerModelRecord(args) {
+    if (!args.training.model_artifact_uri || args.training.metrics?.dry_run === true) return null;
+    const previous = await getRun(args.request.run_id);
+    const modelId = `local-${args.request.run_id}`;
+    const existingModel = await exists2(modelPath(modelId)) ? await readJson2(modelPath(modelId)) : void 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const model = {
+      id: modelId,
+      run_id: args.request.run_id,
+      behavior_spec_id: args.request.behavior_spec_id,
+      name: `${args.request.spec_snapshot.base_model} (${args.request.run_id.slice(0, 8)})`,
+      provider: args.training.provider,
+      base_model: args.request.spec_snapshot.base_model,
+      artifact_uri: args.training.model_artifact_uri,
+      artifact_dir: args.artifactDir,
+      metrics: args.training.metrics,
+      created_at: existingModel?.created_at ?? args.createdAt ?? now
+    };
+    await writeJsonAtomic2(modelPath(model.id), model);
+    const alreadyRegistered = previous.model_id === modelId;
+    const state = {
+      ...previous,
+      model_id: modelId,
+      updated_at: now
+    };
+    await writeRunState(state);
+    if (!alreadyRegistered) {
+      await appendRunEvent(state, {
+        stage: "model_registered",
+        status: "running",
+        message: "Local model artifact registered.",
+        details: { model_id: modelId, artifact_uri: model.artifact_uri }
+      });
+    }
+    return model;
+  }
+  return {
+    root: resolvedRoot,
+    paths,
+    ensure,
+    importSpec: importSpecRecord,
+    async listSpecs() {
+      return listSpecRecords();
+    },
+    async getSpec(id) {
+      const record = findByIdOrPrefix(await listSpecRecords(), id);
+      if (!record) throw new Error(`Spec not found: ${id}`);
+      return { ...record, spec: await readJson2(record.path) };
+    },
+    async startRun({ request, artifactDir }) {
+      await ensure();
+      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const state = {
+        id: request.run_id,
+        behavior_spec_id: request.behavior_spec_id,
+        user_id: request.user_id,
+        run_number: request.run_number,
+        status: "queued",
+        current_stage: "queued",
+        status_message: "Run queued.",
+        artifact_dir: artifactDir,
+        base_model: request.spec_snapshot.base_model,
+        spec_name: request.spec_snapshot.name,
+        created_at: now,
+        updated_at: now,
+        started_at: now
+      };
+      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      await writeRunState(state);
+      await appendRunEvent(state, { stage: "queued", status: "queued", message: "Run queued." });
+      return state;
+    },
+    async syncRunRequest(request, artifactDir) {
+      const previous = await getRun(request.run_id);
+      if (previous.behavior_spec_id !== request.behavior_spec_id || previous.user_id !== request.user_id || previous.run_number !== request.run_number) {
+        throw new Error(
+          `Run ${request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
+        );
+      }
+      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
+      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      const state = {
+        ...previous,
+        artifact_dir: artifactDir ?? previous.artifact_dir,
+        base_model: request.spec_snapshot.base_model,
+        spec_name: request.spec_snapshot.name,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeRunState(state);
+      return state;
+    },
+    async updateRun({ runId, status, stage, message, details }) {
+      const previous = await getRun(runId);
+      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      const active = status !== "stage_completed" && status !== "completed" && status !== "failed" && status !== "cancelled";
+      const successful = status === "stage_completed" || status === "completed";
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const state = {
+        ...previous,
+        status,
+        current_stage: stage,
+        status_message: message,
+        ...active ? { error: void 0, completed_at: void 0 } : successful ? { error: void 0, completed_at: now } : {},
+        updated_at: now
+      };
+      await writeRunState(state);
+      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      await appendRunEvent(state, {
+        stage,
+        status: successful ? "completed" : status === "failed" ? "failed" : "running",
+        message,
+        details
+      });
+      return state;
+    },
+    async completeRun(report, artifactDir, reportPath) {
+      if (await exists2(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
+      const request = await readJson2(runRequestPath(report.run_id));
+      const completedAt = report.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+      const model = await registerModelRecord({
+        request,
+        training: report.training,
+        artifactDir,
+        createdAt: completedAt
+      });
+      if (!model) {
+        await rm(join2(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+      }
+      const previous = await getRun(report.run_id);
+      const state = {
+        ...previous,
+        status: "completed",
+        current_stage: "completed",
+        status_message: "Run completed successfully.",
+        report_path: reportPath,
+        model_id: model?.id,
+        error: void 0,
+        completed_at: completedAt,
+        updated_at: completedAt
+      };
+      await writeRunState(state);
+      if (await exists2(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
+      await copyIfExists(reportPath, runReportPath(report.run_id));
+      await appendRunEvent(state, {
+        stage: "completed",
+        status: "completed",
+        message: "Run completed successfully.",
+        details: { report_path: reportPath, ...model ? { model_id: model.id } : {} }
+      });
+      return state;
+    },
+    registerModel: registerModelRecord,
+    async invalidateRunOutputs(runId, options) {
+      const previous = await getRun(runId);
+      if (options.report) await rm(runReportPath(previous.id), { force: true });
+      if (options.model) {
+        await rm(join2(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
+      }
+      const state = {
+        ...previous,
+        ...options.report ? { report_path: void 0 } : {},
+        ...options.model ? { model_id: void 0 } : {},
+        error: void 0,
+        completed_at: void 0,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return writeRunState(state);
+    },
+    async failRun(runId, error) {
+      const previous = await getRun(runId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      const state = {
+        ...previous,
+        status: "failed",
+        current_stage: "failed",
+        status_message: error,
+        error,
+        completed_at: now,
+        updated_at: now
+      };
+      await writeRunState(state);
+      if (await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      await appendRunEvent(state, { stage: "failed", status: "failed", message: error });
+      return state;
+    },
+    async cancelRun(runId) {
+      const state = await getRun(runId);
+      if (isTerminalRunState(state) || state.status === "cancelled" && state.current_stage === "cancel_requested") {
+        return;
+      }
+      await writeFile3(cancellationPath(state.id), `${(/* @__PURE__ */ new Date()).toISOString()}
+`, "utf8");
+      const latest = await getRun(state.id);
+      if (isTerminalRunState(latest)) {
+        if (latest.status !== "cancelled") await rm(cancellationPath(state.id), { force: true });
+        return;
+      }
+      const updated = {
+        ...latest,
+        status: "cancelled",
+        current_stage: "cancel_requested",
+        status_message: "Cancellation requested; waiting for the active worker to stop.",
+        error: void 0,
+        completed_at: void 0,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeRunState(updated);
+      await appendRunEvent(updated, { stage: "cancel_requested", status: "cancelled", message: "Cancellation requested." });
+    },
+    async finalizeCancellation(runId) {
+      return finalizeCancellationState(runId);
+    },
+    async isCancellationRequested(runId) {
+      const state = await getRun(runId);
+      return state.status === "cancelled" || await exists2(cancellationPath(state.id));
+    },
+    async listRuns() {
+      return listRunRecords();
+    },
+    getRun,
+    async getRunEvents(id) {
+      const state = await getRun(id);
+      return readJsonl(runEventsPath(state.id));
+    },
+    async getRunReport(id) {
+      const state = await getRun(id);
+      if (state.report_path && await exists2(state.report_path)) {
+        return readJson2(state.report_path);
+      }
+      const copiedReportPath = runReportPath(state.id);
+      if (await exists2(copiedReportPath)) return readJson2(copiedReportPath);
+      throw new Error(`Run has no report yet: ${id}`);
+    },
+    async listModels() {
+      return listModelRecords();
+    },
+    async getModel(id) {
+      const record = findByIdOrPrefix(await listModelRecords(), id);
+      if (!record) throw new Error(`Model not found: ${id}`);
+      return record;
+    }
+  };
+}
+
+// src/local-runtime/prefetch.ts
+import { lstat as lstat3, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, stat as stat4 } from "fs/promises";
+import { join as join5, resolve as resolve8 } from "path";
+
+// 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 { homedir as homedir3 } from "os";
+import { dirname as dirname5, join as join3, resolve as resolve6 } from "path";
+var packageRoot = localRuntimePackageRoot(import.meta.url);
+var bundledProject = join3(packageRoot, "training/local-runner");
+var bundledRuntimeHash = (() => {
+  const hash = createHash3("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join3(bundledProject, name)));
+  }
+  return hash.digest("hex").slice(0, 20);
+})();
+var BUNDLED_PYTHON_ENVIRONMENT = join3(
+  resolve6(process.env.XDG_CACHE_HOME ?? join3(homedir3(), ".cache")),
+  "tuned-tensor-local",
+  "uv",
+  bundledRuntimeHash
+);
+function buildBundledPythonCommand(entrypoint, args = []) {
+  const target = entrypoint === "-c" ? entrypoint : join3(bundledProject, "src", entrypoint);
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--project",
+    bundledProject,
+    "python",
+    target,
+    ...args
+  ];
+  return {
+    command: "uv",
+    commandArgs,
+    displayCommand: ["uv", ...commandArgs]
+  };
+}
+function withBundledPythonEnvironment(env) {
+  return {
+    ...env,
+    UV_PROJECT_ENVIRONMENT: BUNDLED_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 ? 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"), 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);
+      });
+    }
+  }
+}
+
+// src/local-runtime/huggingface-cache.ts
+import { homedir as homedir4 } from "os";
+import { dirname as dirname6, join as join4, resolve as resolve7 } 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 resolveHuggingFaceCacheLayout(modelCache) {
+  const hfHome = resolve7(modelCache);
+  return {
+    hfHome,
+    hubCache: join4(hfHome, "hub")
+  };
+}
+function withHuggingFaceCacheEnvironment(env, modelCache) {
+  const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
+  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve7(inheritedHub)) : join4(homedir4(), ".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;
+}
+function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
+  return {
+    ...withHuggingFaceCacheEnvironment(env, modelCache),
+    HF_HUB_OFFLINE: "1",
+    TRANSFORMERS_OFFLINE: "1"
+  };
+}
+
+// src/local-runtime/prefetch.ts
+function buildModelPrefetchPayload(request, config) {
+  const model = resolveTrainingModel(request.spec_snapshot.base_model);
+  return {
+    base_model: model.id,
+    ...request.hyperparameters.base_model_revision ? { revision: request.hyperparameters.base_model_revision } : {},
+    ...config.paths.modelCache ? { model_cache: resolve8(config.paths.modelCache) } : {}
+  };
+}
+function safeName(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "model";
+}
+function transformersWeightName(name) {
+  const lower = name.split(/[\\/]/).at(-1)?.toLowerCase() ?? "";
+  return lower.endsWith(".safetensors") && !lower.startsWith("adapter_") || /^pytorch_model.*\.bin$/.test(lower);
+}
+async function verifyLocalBaseModel(path) {
+  const root = await lstat3(path).catch(() => null);
+  if (!root) throw new Error(`paths.baseModel is set to ${path}, but that path does not exist.`);
+  if (root.isSymbolicLink()) {
+    throw new Error(`paths.baseModel must not itself be a symbolic link: ${path}`);
+  }
+  if (!root.isDirectory()) {
+    throw new Error(
+      `paths.baseModel must be a Hugging Face snapshot directory, not a standalone file or archive: ${path}`
+    );
+  }
+  const files = [];
+  const visit = async (directory) => {
+    for (const entry of await readdir4(directory, { withFileTypes: true })) {
+      const child = join5(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(child);
+        continue;
+      }
+      const metadata = await stat4(child);
+      if (entry.isSymbolicLink() && !metadata.isFile()) {
+        throw new Error(`Local base model contains a non-file symbolic link: ${child}`);
+      }
+      if (metadata.isFile()) files.push({ path: child, size: metadata.size });
+    }
+  };
+  await visit(path);
+  const nonEmpty = files.filter((file) => file.size > 0);
+  const weights = nonEmpty.filter((file) => transformersWeightName(file.path));
+  if (weights.length === 0) {
+    throw new Error(`Local base-model directory contains no non-empty Transformers model weights: ${path}`);
+  }
+  const required = async (name) => {
+    const metadata = await stat4(join5(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(join5(path, "config.json"), "utf8"));
+    assertCertifiedBaseModelConfig(config, `Local base-model config ${join5(path, "config.json")}`);
+  } catch (error) {
+    throw new Error(`Local base-model directory has an invalid or unsupported config.json: ${path}`, { cause: error });
+  }
+  const vocabNames = [
+    "tokenizer.json",
+    "tokenizer.model",
+    "sentencepiece.bpe.model",
+    "spiece.model",
+    "vocab.json",
+    "tokenizer.tiktoken"
+  ];
+  if (!await required("tokenizer_config.json") || !(await Promise.all(vocabNames.map(required))).some(Boolean)) {
+    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"));
+    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}`);
+    }
+    for (const shard of new Set(Object.values(parsed.weight_map))) {
+      if (typeof shard !== "string" || !await required(shard)) {
+        throw new Error(`Local base-model directory is missing indexed weight shard: ${String(shard)}`);
+      }
+    }
+  }
+  return {
+    fileCount: files.length,
+    sizeBytes: files.reduce((total, file) => total + file.size, 0)
+  };
+}
+async function prefetchBaseModel(args) {
+  const artifactDir = resolve8(
+    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 });
+  if (args.config.paths.baseModel) {
+    const localPath = resolve8(args.config.paths.baseModel);
+    const verified = await verifyLocalBaseModel(localPath);
+    return {
+      ok: true,
+      status: args.localOnly ? "completed" : "skipped",
+      base_model: args.request.spec_snapshot.base_model,
+      local_base_model_path: localPath,
+      file_count: verified.fileCount,
+      size_bytes: verified.sizeBytes,
+      artifact_dir: artifactDir,
+      reason: args.localOnly ? "Verified the configured local base-model artifact; no network access was used." : "paths.baseModel points at a verified local base-model artifact; no Hugging Face download is needed."
+    };
+  }
+  const payload = {
+    ...buildModelPrefetchPayload(args.request, args.config),
+    ...args.localOnly ? { local_files_only: true } : {}
+  };
+  const inputPath = join5(artifactDir, "prefetch-input.json");
+  const outputPath = join5(artifactDir, "prefetch-output.json");
+  const logPath = join5(artifactDir, "prefetch.log");
+  await writeJson(inputPath, payload);
+  const entrypoint = buildBundledPythonCommand(
+    "prefetch.py",
+    ["--input", inputPath, "--output", outputPath]
+  );
+  await args.reporter?.onEvent?.({
+    stage: "model_prefetch",
+    status: "running",
+    message: args.localOnly ? "Verifying the Hugging Face base model is available in the local cache." : "Prefetching Hugging Face base model.",
+    details: {
+      base_model: payload.base_model,
+      model_cache: payload.model_cache ?? null,
+      command: entrypoint.displayCommand,
+      log_path: logPath
+    }
+  });
+  const env = withBundledPythonEnvironment(
+    withHuggingFaceCacheEnvironment(
+      minimalMachineLearningEnvironment(process.env),
+      payload.model_cache
+    )
+  );
+  const { exitCode } = await runLoggedProcess({
+    command: entrypoint.command,
+    commandArgs: entrypoint.commandArgs,
+    env,
+    logPath,
+    // A base model can be several gigabytes. Surface the downloader's progress
+    // by default; callers can still opt out by omitting the reporter (`--quiet`).
+    reporter: args.reporter ? { ...args.reporter, verbose: true } : void 0,
+    stage: "model_prefetch"
+  });
+  if (exitCode !== 0) {
+    throw new Error(`Model prefetch exited with code ${exitCode}. See ${logPath}.`);
+  }
+  const output = JSON.parse(await readFile5(outputPath, "utf8"));
+  const snapshotRevision = baseModelRevisionSchema.safeParse(output.snapshot_revision);
+  if (!snapshotRevision.success) {
+    throw new Error(
+      "Model prefetch did not resolve the base model to a 40-character immutable commit SHA."
+    );
+  }
+  await args.reporter?.onEvent?.({
+    stage: "model_prefetch",
+    status: "completed",
+    message: "Base model is available in the local Hugging Face cache.",
+    details: {
+      base_model: output.base_model ?? payload.base_model,
+      hf_home: output.hf_home ?? output.model_cache ?? payload.model_cache ?? null,
+      hub_cache: output.hub_cache ?? null,
+      snapshot_path: output.snapshot_path ?? null,
+      snapshot_revision: snapshotRevision.data,
+      file_count: output.file_count ?? null,
+      size_bytes: output.size_bytes ?? null,
+      verified_blob_count: output.verified_blob_count ?? null
+    }
+  });
+  return {
+    ok: true,
+    status: "completed",
+    base_model: output.base_model ?? payload.base_model,
+    model_cache: output.model_cache ?? payload.model_cache,
+    hf_home: output.hf_home ?? output.model_cache ?? payload.model_cache,
+    hub_cache: output.hub_cache,
+    snapshot_path: output.snapshot_path,
+    snapshot_revision: snapshotRevision.data,
+    file_count: output.file_count,
+    size_bytes: output.size_bytes,
+    verified_blob_count: output.verified_blob_count,
+    artifact_dir: artifactDir,
+    input_path: inputPath,
+    output_path: outputPath,
+    log_uri: fileUri(logPath),
+    command: entrypoint.displayCommand
+  };
+}
+
+// src/local-runtime/general-regression.ts
+function evaluateGeneralRegressionGate(comparison, policy) {
+  const failures = [];
+  const scoreDrop = Math.max(0, -comparison.avg_score_delta);
+  const passRateDrop = Math.max(0, -comparison.pass_rate_delta);
+  const tolerance = 1e-12;
+  if (scoreDrop > policy.maxScoreDrop + tolerance) {
+    failures.push(
+      `Average score dropped ${scoreDrop.toFixed(4)}, exceeding the ${policy.maxScoreDrop.toFixed(4)} budget.`
+    );
+  }
+  if (passRateDrop > policy.maxPassRateDrop + tolerance) {
+    failures.push(
+      `Pass rate dropped ${passRateDrop.toFixed(4)}, exceeding the ${policy.maxPassRateDrop.toFixed(4)} budget.`
+    );
+  }
+  return { passed: failures.length === 0, failures };
+}
+
+// src/local-runtime/orchestrator.ts
+import { lstat as lstat4, mkdir as mkdir8, open as open2, readFile as readFile8, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
+import { createReadStream as createReadStream2 } from "fs";
+import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
+import { performance } from "perf_hooks";
+import { homedir as homedir5 } from "os";
+import { basename, dirname as dirname8, join as join8, relative as relative2, resolve as resolve11 } from "path";
+
+// src/local-runtime/evaluation.ts
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir6, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname7, join as join6, resolve as resolve9 } from "path";
+function normalize(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function exactScore(expected, actual) {
+  return normalize(expected) === normalize(actual) ? 1 : 0;
+}
+function tokenF1(expected, actual) {
+  const tokenize = (value) => normalize(value).match(/[\p{L}\p{N}]+/gu) ?? [];
+  const expectedTokens = tokenize(expected);
+  const actualTokens = tokenize(actual);
+  if (expectedTokens.length === 0 || actualTokens.length === 0) {
+    return expectedTokens.length === actualTokens.length ? 1 : 0;
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of expectedTokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  let overlap = 0;
+  for (const token of actualTokens) {
+    const remaining = counts.get(token) ?? 0;
+    if (remaining > 0) {
+      overlap += 1;
+      counts.set(token, remaining - 1);
+    }
+  }
+  if (overlap === 0) return 0;
+  const precision = overlap / actualTokens.length;
+  const recall = overlap / expectedTokens.length;
+  return 2 * precision * recall / (precision + recall);
+}
+function deriveSampleSeed(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 | 0;
+    let value = Math.imul(state ^ state >>> 15, 1 | state);
+    value = value + Math.imul(value ^ value >>> 7, 61 | value) ^ value;
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+function sampleExamples(examples, count, seed) {
+  if (count >= examples.length) return examples;
+  const indices = examples.map((_, index) => index);
+  const random = mulberry32(seed);
+  for (let index = indices.length - 1; index > 0; index -= 1) {
+    const swap = Math.floor(random() * (index + 1));
+    [indices[index], indices[swap]] = [indices[swap], indices[index]];
+  }
+  return indices.slice(0, count).sort((left, right) => left - right).map((index) => examples[index]);
+}
+function splitSpecExamples(examples, seed, holdoutRatio = 0.2) {
+  if (examples.length < 2) return { train: examples, holdout: [] };
+  const holdoutCount = Math.min(
+    examples.length - 1,
+    Math.max(1, Math.round(examples.length * holdoutRatio))
+  );
+  const indices = examples.map((_, index) => index);
+  const random = mulberry32(seed);
+  for (let index = indices.length - 1; index > 0; index -= 1) {
+    const swap = Math.floor(random() * (index + 1));
+    [indices[index], indices[swap]] = [indices[swap], indices[index]];
+  }
+  const heldOut = new Set(indices.slice(0, holdoutCount));
+  return {
+    train: examples.filter((_, index) => !heldOut.has(index)),
+    holdout: examples.filter((_, index) => heldOut.has(index))
+  };
+}
+function extractJsonObject(value) {
+  const trimmed = value.trim();
+  const candidates = [trimmed];
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenced?.[1]) candidates.push(fenced[1].trim());
+  const objectLike = trimmed.match(/\{[\s\S]*\}/);
+  if (objectLike?.[0]) candidates.push(objectLike[0]);
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return value.map(canonicalJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)])
+    );
+  }
+  return value;
+}
+function scoreJsonFields(expected, actual, configuredFields) {
+  const expectedJson = extractJsonObject(expected);
+  const actualJson = extractJsonObject(actual);
+  if (!expectedJson) {
+    const score2 = exactScore(expected, actual);
+    return {
+      score: score2,
+      passed: score2 === 1,
+      reasoning: "Expected output is not JSON; used normalized exact match.",
+      actualJsonValid: Boolean(actualJson),
+      schemaMatch: false,
+      fields: [],
+      fieldResults: {}
+    };
+  }
+  const fields = configuredFields?.length ? configuredFields : Object.keys(expectedJson).sort();
+  const expectedKeys = Object.keys(expectedJson).sort();
+  const actualKeys = actualJson ? Object.keys(actualJson).sort() : [];
+  const schemaMatch = Boolean(actualJson) && expectedKeys.length === actualKeys.length && expectedKeys.every((key, index) => key === actualKeys[index]);
+  const fieldResults = {};
+  for (const field of fields) {
+    fieldResults[field] = Object.prototype.hasOwnProperty.call(expectedJson, field) && Boolean(actualJson) && JSON.stringify(canonicalJson(expectedJson[field])) === JSON.stringify(canonicalJson(actualJson?.[field]));
+  }
+  const correct = Object.values(fieldResults).filter(Boolean).length;
+  const score = fields.length > 0 ? correct / fields.length : 0;
+  return {
+    score,
+    passed: fields.length > 0 && correct === fields.length,
+    reasoning: actualJson ? `JSON field score: ${correct}/${fields.length} fields matched.` : "Actual output is not a JSON object.",
+    actualJsonValid: Boolean(actualJson),
+    schemaMatch,
+    fields,
+    fieldResults
+  };
+}
+function aggregateJsonFieldMetrics(scores, total) {
+  if (total === 0 || scores.length === 0) return void 0;
+  const fields = [...new Set(scores.flatMap((score) => score.fields))].sort();
+  const field_accuracy = {};
+  for (const field of fields) {
+    const applicable = scores.filter((score) => score.fields.includes(field));
+    const correct = applicable.filter((score) => score.fieldResults[field]).length;
+    field_accuracy[field] = {
+      correct,
+      total: applicable.length,
+      accuracy: applicable.length > 0 ? correct / applicable.length : 0
+    };
+  }
+  const validJsonCount = scores.filter((score) => score.actualJsonValid).length;
+  const schemaMatchCount = scores.filter((score) => score.schemaMatch).length;
+  const allFieldsMatchCount = scores.filter((score) => score.passed).length;
+  return {
+    fields,
+    valid_json_count: validJsonCount,
+    valid_json_rate: validJsonCount / total,
+    schema_match_count: schemaMatchCount,
+    schema_match_rate: schemaMatchCount / total,
+    all_fields_match_count: allFieldsMatchCount,
+    all_fields_match_rate: allFieldsMatchCount / total,
+    field_accuracy
+  };
+}
+function fileUriToPath(value) {
+  if (!value) return void 0;
+  return value.startsWith("file://") ? value.slice("file://".length) : value;
+}
+var INFERENCE_PROTOCOL_VERSION = 2;
+function parseBatchInferenceResult(value, expectedIds) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Transformers inference output must be a JSON object");
+  }
+  const output = value;
+  if (!Array.isArray(output.results) || output.results.length !== expectedIds.length) {
+    throw new Error(
+      `Transformers inference returned ${Array.isArray(output.results) ? output.results.length : 0} predictions; expected ${expectedIds.length}`
+    );
+  }
+  const expected = new Set(expectedIds);
+  const byId = /* @__PURE__ */ new Map();
+  for (const [index, entry] of output.results.entries()) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Transformers prediction ${index} must be an object`);
+    }
+    const prediction = entry;
+    if (typeof prediction.id !== "string" || !expected.has(prediction.id)) {
+      throw new Error(`Transformers prediction ${index} has an unknown or missing id`);
+    }
+    if (byId.has(prediction.id)) {
+      throw new Error(`Transformers inference returned duplicate id ${prediction.id}`);
+    }
+    if (typeof prediction.actual !== "string") {
+      throw new Error(`Transformers prediction ${index} must include string actual`);
+    }
+    if (typeof prediction.latency_ms !== "number" || !Number.isInteger(prediction.latency_ms) || prediction.latency_ms < 0) {
+      throw new Error(
+        `Transformers prediction ${index} must include non-negative integer latency_ms`
+      );
+    }
+    byId.set(prediction.id, {
+      id: prediction.id,
+      actual: prediction.actual,
+      latency_ms: prediction.latency_ms
+    });
+  }
+  const optionalString = (key) => typeof output[key] === "string" ? output[key] : void 0;
+  return {
+    ...optionalString("model_id") ? { model_id: optionalString("model_id") } : {},
+    ...optionalString("base_model") ? { base_model: optionalString("base_model") } : {},
+    ...optionalString("adapter_path") ? { adapter_path: optionalString("adapter_path") } : {},
+    ...output.generation_config && typeof output.generation_config === "object" && !Array.isArray(output.generation_config) ? { generation_config: output.generation_config } : {},
+    results: expectedIds.map((id) => byId.get(id))
+  };
+}
+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({
+    protocol_version: INFERENCE_PROTOCOL_VERSION,
+    kind: args.kind,
+    model_id: args.modelId,
+    base_model: args.baseModelId,
+    base_model_revision: args.baseModelRevision,
+    model_loader: "causal_lm",
+    adapter_path: fileUriToPath(args.adapterPath),
+    system: args.system,
+    examples: args.examples.map((example, index) => ({
+      id: String(index),
+      input: example.input
+    })),
+    model_cache: args.config.paths.modelCache ? resolve9(args.config.paths.modelCache) : void 0,
+    trust_remote_code: false,
+    device: args.config.evaluation.inference.device,
+    generation: {
+      max_new_tokens: args.config.evaluation.inference.maxNewTokens,
+      temperature: args.config.evaluation.inference.temperature,
+      top_p: args.config.evaluation.inference.topP
+    }
+  }, null, 2)}
+`, "utf8");
+  await rm2(outputPath, { force: true });
+  const entrypoint = buildBundledPythonCommand(
+    "evaluate.py",
+    ["--input", inputPath, "--output", outputPath]
+  );
+  await args.reporter?.onEvent?.({
+    stage: `evaluating_${args.kind}`,
+    status: "running",
+    message: `Starting ${args.kind} Transformers inference.`,
+    details: {
+      model_id: args.modelId,
+      examples: args.examples.length,
+      command: entrypoint.displayCommand,
+      log_path: logPath
+    }
+  });
+  const result = await runLoggedProcess({
+    command: entrypoint.command,
+    commandArgs: entrypoint.commandArgs,
+    env: withBundledPythonEnvironment(
+      withOfflineHuggingFaceCacheEnvironment(
+        minimalMachineLearningEnvironment(process.env),
+        args.config.paths.modelCache
+      )
+    ),
+    logPath,
+    timeoutMs: args.config.evaluation.timeoutMs,
+    timeoutMessage: `Transformers inference timed out after ${args.config.evaluation.timeoutMs}ms`,
+    reporter: args.reporter,
+    stage: `evaluating_${args.kind}`,
+    shouldCancel: args.shouldCancel
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Transformers inference exited ${result.exitCode}: ${result.stderr.slice(0, 1e3)}`
+    );
+  }
+  let output;
+  try {
+    output = JSON.parse(await readFile6(outputPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Transformers inference did not write valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return parseBatchInferenceResult(
+    output,
+    args.examples.map((_, index) => String(index))
+  );
+}
+function assertEvaluationScoringReady(config) {
+  if (config.evaluation.scoring.mode === "json_fields" && config.evaluation.scoring.fields?.some((field) => !field.trim())) {
+    throw new Error("evaluation.scoring.fields must contain non-empty field names");
+  }
+}
+function baselineCacheKey(args) {
+  return createHash4("sha256").update(JSON.stringify({
+    v: 6,
+    inference_protocol_version: INFERENCE_PROTOCOL_VERSION,
+    package_version: args.packageVersion,
+    model_id: args.modelId,
+    base_model_revision: args.baseModelRevision ?? null,
+    source_fingerprint: args.sourceFingerprint ?? null,
+    system: args.system,
+    examples: args.examples,
+    eval_examples_total: args.evalExamplesTotal,
+    eval_split: args.evalSplit ?? null,
+    eval_sample_seed: args.evalSampleSeed ?? null,
+    inference: args.config.evaluation.inference,
+    scoring: args.config.evaluation.scoring
+  })).digest("hex");
+}
+function baselineInputsAreStable(args) {
+  return args.config.paths.baseModel ? Boolean(args.sourceFingerprint) : Boolean(args.baseModelRevision);
+}
+function baselineCachePath(config, key) {
+  const root = config.storeRoot ? resolve9(config.storeRoot) : defaultLocalHome();
+  return join6(root, "cache", "baseline-evals", `${key}.json`);
+}
+async function readBaselineCache(path) {
+  try {
+    return evalReportSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+  } catch {
+    return null;
+  }
+}
+var cachedPackageVersion = null;
+async function packageVersion() {
+  if (cachedPackageVersion !== null) return cachedPackageVersion;
+  try {
+    const raw = await readFile6(resolve9(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
+    cachedPackageVersion = String(
+      JSON.parse(raw).version ?? "unknown"
+    );
+  } catch {
+    cachedPackageVersion = "unknown";
+  }
+  return cachedPackageVersion;
+}
+async function scoreGenerated(args) {
+  const jsonScores = [];
+  const results = args.generated.map((generated) => {
+    const json = args.config.evaluation.scoring.mode === "json_fields" ? scoreJsonFields(
+      generated.expected,
+      generated.actual,
+      args.config.evaluation.scoring.fields
+    ) : null;
+    if (json) jsonScores.push(json);
+    const score = json?.score ?? exactScore(generated.expected, generated.actual);
+    return {
+      prompt: generated.prompt,
+      expected: generated.expected,
+      actual: generated.actual,
+      passed: json?.passed ?? score === 1,
+      score,
+      reasoning: json?.reasoning ?? (args.inferenceProvider === "none" ? "Dry run: model inference was not executed." : "Scored by normalized exact match."),
+      latency_ms: generated.latency_ms,
+      scored_by: json ? "json_fields" : args.inferenceProvider === "none" ? "heuristic" : "exact_match"
+    };
+  });
+  const total = results.length;
+  const mean = (values) => values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+  const report = evalReportSchema.parse({
+    kind: args.kind,
+    model_id: args.modelId,
+    total,
+    eval_examples_total: args.evalExamplesTotal,
+    eval_examples_used: total,
+    eval_truncated: args.evalExamplesTotal > total,
+    eval_split: args.evalSplit,
+    eval_sample_seed: args.evalSampleSeed ?? null,
+    avg_score: mean(results.map((result) => result.score)),
+    pass_rate: mean(results.map((result) => result.passed ? 1 : 0)),
+    exact_match_rate: mean(
+      results.map((result) => exactScore(result.expected, result.actual))
+    ),
+    avg_token_f1: mean(
+      results.map((result) => tokenF1(result.expected, result.actual))
+    ),
+    avg_latency_ms: Math.round(mean(results.map((result) => result.latency_ms))),
+    results,
+    artifact_uri: fileUri(args.outputPath),
+    scoring_method: args.config.evaluation.scoring.mode === "json_fields" ? "json_fields" : args.inferenceProvider === "none" ? "heuristic" : "exact_match",
+    inference_provider: args.inferenceProvider,
+    scoring_mode: args.config.evaluation.scoring.mode,
+    json_field_metrics: args.config.evaluation.scoring.mode === "json_fields" ? aggregateJsonFieldMetrics(jsonScores, total) : void 0,
+    generation_config: args.generationConfig,
+    log_uri: args.logUri
+  });
+  await writeJson(args.outputPath, report);
+  return report;
+}
+async function evaluateExamples(args) {
+  assertEvaluationScoringReady(args.config);
+  const maxExamples = args.config.evaluation.maxExamples ?? args.maxExamples ?? args.examples.length;
+  const truncated = args.examples.length > maxExamples;
+  const seed = args.config.evaluation.sampleSeed ?? args.sampleSeed ?? 0;
+  const examples = truncated ? sampleExamples(args.examples, maxExamples, seed) : args.examples;
+  const evalSampleSeed = truncated || args.evalSplit === "spec_holdout" ? seed : null;
+  const cacheEligible = args.kind === "baseline" && args.config.evaluation.baselineCache && !args.config.dryRun && baselineInputsAreStable({
+    baseModelRevision: args.baseModelRevision,
+    sourceFingerprint: args.sourceFingerprint,
+    config: args.config
+  });
+  const cacheKey = cacheEligible ? baselineCacheKey({
+    modelId: args.modelId,
+    baseModelRevision: args.baseModelRevision,
+    sourceFingerprint: args.sourceFingerprint,
+    system: args.system,
+    examples,
+    evalExamplesTotal: args.examples.length,
+    evalSplit: args.evalSplit,
+    evalSampleSeed,
+    config: args.config,
+    packageVersion: await packageVersion()
+  }) : null;
+  if (cacheKey) {
+    const cached = await readBaselineCache(baselineCachePath(args.config, cacheKey));
+    if (cached) {
+      const report2 = evalReportSchema.parse({
+        ...cached,
+        cached: true,
+        cache_key: cacheKey,
+        artifact_uri: fileUri(args.outputPath),
+        eval_split: args.evalSplit ?? cached.eval_split,
+        eval_examples_total: args.examples.length,
+        eval_examples_used: examples.length,
+        eval_truncated: truncated,
+        eval_sample_seed: evalSampleSeed
+      });
+      await writeJson(args.outputPath, report2);
+      return report2;
+    }
+  }
+  const inference = args.config.dryRun ? null : await runTransformersInference({
+    kind: args.kind,
+    modelId: args.modelId,
+    baseModelId: args.baseModelId ?? args.modelId,
+    baseModelRevision: args.baseModelRevision,
+    adapterPath: args.adapterPath,
+    examples,
+    system: args.system,
+    config: args.config,
+    outputPath: args.outputPath,
+    reporter: args.reporter,
+    shouldCancel: args.shouldCancel
+  });
+  const generated = examples.map((example, index) => ({
+    prompt: example.input,
+    expected: example.output,
+    actual: inference?.results[index]?.actual ?? "",
+    latency_ms: inference?.results[index]?.latency_ms ?? 0
+  }));
+  const report = await scoreGenerated({
+    kind: args.kind,
+    modelId: args.modelId,
+    generated,
+    evalExamplesTotal: args.examples.length,
+    config: args.config,
+    outputPath: args.outputPath,
+    inferenceProvider: inference ? "transformers" : "none",
+    evalSplit: args.evalSplit,
+    evalSampleSeed,
+    generationConfig: inference?.generation_config,
+    logUri: inference ? fileUri(`${args.outputPath}.inference.log`) : void 0
+  });
+  if (cacheKey) {
+    await writeJson(
+      baselineCachePath(args.config, cacheKey),
+      { ...report, cache_key: cacheKey }
+    );
+  }
+  return report;
+}
+function compareEvalReports(baseline, candidate) {
+  let regressions = 0;
+  let improvements = 0;
+  const regressedExamples = [];
+  const count = Math.min(baseline.results.length, candidate.results.length);
+  for (let index = 0; index < count; index += 1) {
+    const oldScore = baseline.results[index]?.score ?? 0;
+    const result = candidate.results[index];
+    const newScore = result?.score ?? 0;
+    if (newScore < oldScore) {
+      regressions += 1;
+      regressedExamples.push({
+        prompt: baseline.results[index]?.prompt ?? "",
+        old_score: oldScore,
+        new_score: newScore
+      });
+    } else if (newScore > oldScore) {
+      improvements += 1;
+    }
+  }
+  return {
+    avg_score_delta: candidate.avg_score - baseline.avg_score,
+    pass_rate_delta: candidate.pass_rate - baseline.pass_rate,
+    exact_match_rate_delta: candidate.exact_match_rate - baseline.exact_match_rate,
+    token_f1_delta: (candidate.avg_token_f1 ?? 0) - (baseline.avg_token_f1 ?? 0),
+    regressions,
+    improvements,
+    regressed_examples: regressedExamples
+  };
+}
+
+// src/local-runtime/process-training.ts
+import { access, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { join as join7, resolve as resolve10 } from "path";
+function buildTrainingHyperparameters(request, options = {}) {
+  const model = resolveTrainingModel(request.spec_snapshot.base_model);
+  const hyper = request.hyperparameters;
+  return {
+    base_model: model.id,
+    ...options.baseModelRevision ? { base_model_revision: options.baseModelRevision } : {},
+    n_epochs: String(hyper.n_epochs),
+    learning_rate: String(hyper.learning_rate ?? model.defaultLearningRate),
+    per_device_train_batch_size: String(hyper.batch_size ?? model.defaultPerDeviceBatchSize),
+    gradient_accumulation_steps: String(
+      hyper.gradient_accumulation_steps ?? model.defaultGradientAccumulationSteps
+    ),
+    lora_rank: String(hyper.lora_rank ?? model.defaultLoraRank),
+    lora_alpha: String(hyper.lora_alpha ?? model.defaultLoraAlpha),
+    lora_dropout: String(hyper.lora_dropout ?? model.defaultLoraDropout),
+    max_seq_length: String(hyper.max_seq_length ?? model.defaultMaxSeqLength)
+  };
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function numberFromMetric(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseTrainingProgressLine(line) {
+  if (/loading (?:checkpoint )?shards|loading weights/i.test(line)) return null;
+  const snapshot = {};
+  const metricMatches = [...line.matchAll(/'([^']+)':\s*'([^']*)'/g)];
+  for (const match of metricMatches) {
+    const key = match[1];
+    const value = numberFromMetric(match[2]);
+    if (value === void 0) continue;
+    if (key === "loss") snapshot.loss = value;
+    if (key === "grad_norm") snapshot.grad_norm = value;
+    if (key === "learning_rate") snapshot.learning_rate = value;
+    if (key === "epoch") {
+      snapshot.epoch = value;
+      snapshot.percent = Math.max(0, Math.min(100, Math.round(value * 100)));
+    }
+  }
+  const progress = line.match(/(\d+)%\|[^|]*\|\s*(\d+)\/(\d+)\s*\[([^<,\]]+)(?:<([^,\]]+))?,\s*([^\]]+)\]/);
+  if (progress) {
+    snapshot.percent = Number(progress[1]);
+    snapshot.step = Number(progress[2]);
+    snapshot.total_steps = Number(progress[3]);
+    snapshot.elapsed = progress[4]?.trim();
+    snapshot.eta = progress[5]?.trim();
+    snapshot.rate = progress[6]?.trim();
+  }
+  return Object.keys(snapshot).length > 0 ? snapshot : null;
+}
+function createTrainingProgressForwarder(reporter) {
+  let lastPercent = -1;
+  let lastStep = -1;
+  let lastEmittedAt = 0;
+  let latestMetrics = {};
+  return (line) => {
+    const parsed = parseTrainingProgressLine(line);
+    if (!parsed) return;
+    latestMetrics = { ...latestMetrics, ...parsed };
+    const percent = latestMetrics.percent;
+    const step = latestMetrics.step;
+    const totalSteps = latestMetrics.total_steps;
+    const now = Date.now();
+    const shouldEmit = Boolean(reporter?.onEvent) && (percent !== void 0 && (percent >= lastPercent + 5 || percent === 100) || step !== void 0 && totalSteps !== void 0 && step === totalSteps && step !== lastStep || now - lastEmittedAt > 3e4);
+    if (!shouldEmit) return;
+    lastEmittedAt = now;
+    if (percent !== void 0) lastPercent = percent;
+    if (step !== void 0) lastStep = step;
+    reportInBackground(() => reporter?.onEvent?.({
+      stage: "training",
+      status: "running",
+      message: step !== void 0 && totalSteps !== void 0 ? `Training progress ${step}/${totalSteps}${percent !== void 0 ? ` (${percent}%)` : ""}.` : `Training progress${percent !== void 0 ? ` ${percent}%` : ""}.`,
+      details: latestMetrics
+    }));
+  };
+}
+async function launchProcessTraining(args) {
+  const { request, artifacts, config } = args;
+  const jobName = `tt-local-${request.run_id}`;
+  await mkdir7(artifacts.trainingDir, { recursive: true });
+  await copyDatasetToTrainingChannel(artifacts);
+  const hyperparameters = buildTrainingHyperparameters(request, {
+    baseModelRevision: args.baseModelRevision
+  });
+  await writeJson(join7(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
+  const entrypoint = buildBundledPythonCommand("train.py");
+  if (config.dryRun) {
+    await writeFile5(
+      artifacts.trainingLog,
+      "Dry run enabled. Training process was not launched.\n",
+      "utf8"
+    );
+    return {
+      provider: "local-uv",
+      training_job_name: jobName,
+      model_artifact_uri: fileUri(artifacts.trainingModelDir),
+      base_model_artifact_uri: config.paths.baseModel ? fileUri(config.paths.baseModel) : void 0,
+      metrics: { dry_run: true },
+      exit_code: 0,
+      log_uri: fileUri(artifacts.trainingLog),
+      command: entrypoint.displayCommand
+    };
+  }
+  const command = entrypoint.displayCommand;
+  const inheritedEnv = minimalMachineLearningEnvironment(process.env);
+  const childEnv = withBundledPythonEnvironment(
+    withOfflineHuggingFaceCacheEnvironment({
+      ...inheritedEnv,
+      BACKEND: "local",
+      SM_CHANNEL_TRAINING: resolve10(artifacts.trainingInputDir),
+      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve10(config.paths.baseModel) : void 0,
+      SM_MODEL_DIR: resolve10(artifacts.trainingModelDir),
+      SM_OUTPUT_DIR: resolve10(artifacts.trainingOutputDir),
+      TT_HYPERPARAMETERS_PATH: resolve10(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(resolve10(config.paths.modelCache), { recursive: true });
+  await args.reporter?.onEvent?.({
+    stage: "training",
+    status: "running",
+    message: "Starting local training process.",
+    details: {
+      command,
+      log_path: artifacts.trainingLog,
+      model_dir: artifacts.trainingModelDir,
+      output_dir: artifacts.trainingOutputDir
+    }
+  });
+  const forwardTrainingProgress = createTrainingProgressForwarder(args.reporter);
+  const { exitCode } = await runLoggedProcess({
+    command: entrypoint.command,
+    commandArgs: entrypoint.commandArgs,
+    env: childEnv,
+    logPath: artifacts.trainingLog,
+    reporter: args.reporter,
+    stage: "training",
+    onLine: (line) => forwardTrainingProgress(line),
+    shouldCancel: args.shouldCancel
+  });
+  const metricsPath = join7(artifacts.trainingModelDir, "training-metrics.json");
+  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile7(metricsPath, "utf8")) : null;
+  if (exitCode !== 0) {
+    throw new Error(`Training process exited with code ${exitCode}. See ${artifacts.trainingLog}.`);
+  }
+  const modelTarPath = join7(artifacts.trainingOutputDir, "model.tar.gz");
+  const modelUri = await pathExists(modelTarPath) ? fileUri(modelTarPath) : fileUri(artifacts.trainingModelDir);
+  await args.reporter?.onEvent?.({
+    stage: "training",
+    status: "running",
+    message: "Training process completed.",
+    details: {
+      exit_code: exitCode,
+      model_artifact_uri: modelUri,
+      log_path: artifacts.trainingLog,
+      metrics
+    }
+  });
+  return {
+    provider: "local-uv",
+    training_job_name: jobName,
+    model_artifact_uri: modelUri,
+    base_model_artifact_uri: config.paths.baseModel ? fileUri(config.paths.baseModel) : void 0,
+    metrics,
+    exit_code: exitCode,
+    log_uri: fileUri(artifacts.trainingLog),
+    command
+  };
+}
+
+// src/local-runtime/orchestrator.ts
+function canonicalLocalPipeline() {
+  return {
+    version: 1,
+    name: "local-fine-tune",
+    steps: [
+      { id: "baseline", uses: "evaluate", target: "local", with: { model: "base", evaluator: "behavior" } },
+      { id: "train", uses: "train", target: "local" },
+      { id: "candidate", uses: "evaluate", target: "local", with: { model: { from: "train.model" }, evaluator: "behavior" } },
+      { id: "compare", uses: "compare", target: "local", with: { before: { from: "baseline.report" }, after: { from: "candidate.report" } } }
+    ]
+  };
+}
+function referenceParts(reference) {
+  const value = typeof reference === "string" ? reference.replace(/^\$/, "") : reference && typeof reference === "object" && !Array.isArray(reference) ? reference.from : void 0;
+  if (typeof value !== "string") return null;
+  const match = /^([A-Za-z][A-Za-z0-9_-]*)\.(model|report)$/.exec(value);
+  return match ? [match[1], match[2]] : null;
+}
+function validateLocalPipeline(pipeline) {
+  if (!pipeline || pipeline.version !== 1 || !Array.isArray(pipeline.steps)) {
+    throw new Error("Local pipeline must be a version 1 document with a steps array.");
+  }
+  const seen = /* @__PURE__ */ new Map();
+  let hasTrainStep = false;
+  for (const step of pipeline.steps) {
+    if (!step || typeof step.id !== "string" || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(step.id)) {
+      throw new Error("Each local pipeline step requires an identifier starting with a letter.");
+    }
+    if (seen.has(step.id)) throw new Error(`Local pipeline step IDs must be unique: ${step.id}`);
+    if (step.target !== "local") throw new Error(`Local pipeline step ${step.id} only supports target local.`);
+    if (step.uses !== "train" && step.uses !== "evaluate" && step.uses !== "compare") {
+      throw new Error(`Local pipeline step ${step.id} uses an unsupported component.`);
+    }
+    if (step.uses === "train") {
+      if (hasTrainStep) {
+        throw new Error("Local pipeline v1 supports at most one train step because model artifacts are run-scoped.");
+      }
+      hasTrainStep = true;
+    }
+    if (step.uses === "evaluate") {
+      if (step.with?.evaluator !== "behavior") {
+        throw new Error(`Local evaluate step ${step.id} requires the behavior evaluator.`);
+      }
+      if (step.with?.model !== "base") {
+        const modelReference = referenceParts(step.with?.model);
+        if (!modelReference || modelReference[0] === step.id || modelReference[1] !== "model") {
+          throw new Error(`Local evaluate step ${step.id} requires model base or { from: '<earlier-train>.model' }.`);
+        }
+        const producer = seen.get(modelReference[0]);
+        if (!producer) throw new Error(`Local evaluate step ${step.id} must reference an earlier train step.`);
+        if (producer.uses !== "train") throw new Error(`Local evaluate step ${step.id} model reference must name a train step.`);
+      }
+    }
+    if (step.uses === "compare") {
+      for (const field of ["before", "after"]) {
+        const reportReference = referenceParts(step.with?.[field]);
+        if (!reportReference || reportReference[1] !== "report") {
+          throw new Error(`Local compare step ${step.id} requires ${field}: { from: '<earlier-evaluate>.report' }.`);
+        }
+        const producer = seen.get(reportReference[0]);
+        if (!producer) throw new Error(`Local compare step ${step.id} must reference an earlier evaluate step.`);
+        if (producer.uses !== "evaluate") throw new Error(`Local compare step ${step.id} report reference must name an evaluate step.`);
+      }
+    }
+    seen.set(step.id, step);
+  }
+  return pipeline;
+}
+async function loadJsonFile(path) {
+  return JSON.parse(await readFile8(path, "utf8"));
+}
+async function loadRunRequest(path) {
+  return fineTuneRunRequestSchema.parse(await loadJsonFile(path));
+}
+async function loadLocalRunnerConfig(path) {
+  if (!path) return localRunnerConfigSchema.parse({});
+  const configPath = resolve11(path);
+  const base = dirname8(configPath);
+  const config = localRunnerConfigSchema.parse(await loadJsonFile(configPath));
+  const configPathValue = (value) => {
+    if (!value) return void 0;
+    if (value === "~") return homedir5();
+    if (value.startsWith("~/")) return resolve11(homedir5(), value.slice(2));
+    return resolve11(base, value);
+  };
+  return {
+    ...config,
+    artifactRoot: configPathValue(config.artifactRoot),
+    storeRoot: configPathValue(config.storeRoot),
+    paths: {
+      baseModel: configPathValue(config.paths.baseModel),
+      modelCache: configPathValue(config.paths.modelCache)
+    },
+    evaluation: {
+      ...config.evaluation,
+      generalRegression: config.evaluation.generalRegression ? {
+        ...config.evaluation.generalRegression,
+        dataset: configPathValue(config.evaluation.generalRegression.dataset)
+      } : void 0
+    }
+  };
+}
+function elapsed(started) {
+  const ms = Math.max(0, Math.round(performance.now() - started));
+  return { ms, seconds: Math.round(ms / 1e3 * 1e3) / 1e3 };
+}
+function stripFileUri(path) {
+  return path.replace(/^file:\/\//, "");
+}
+async function pathExists2(path) {
+  try {
+    await stat5(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function selectPrebuiltEvaluationSplit(dataset) {
+  if (!dataset) throw new Error("dataset_prebuilt is required");
+  if (dataset.validation) return "prebuilt_validation";
+  if (dataset.test) return "prebuilt_test";
+  throw new Error("dataset_prebuilt requires a distinct validation or test split");
+}
+function assertMatchingDatasetSystems(jsonl, expectedSystem, split) {
+  for (const [index, line] of jsonl.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    const row = JSON.parse(line);
+    const actualSystem = row.messages.find((message) => message.role === "system")?.content ?? "";
+    if (actualSystem !== expectedSystem) {
+      throw new Error(
+        `Prebuilt ${split} row ${index + 1} system message must match the behavior spec system message.`
+      );
+    }
+  }
+}
+function addDryRunPlaceholders(request, dryRun) {
+  if (!dryRun || !request || typeof request !== "object" || Array.isArray(request)) return request;
+  const candidate = request;
+  if (candidate.dataset_prebuilt) return request;
+  const snapshot = candidate.spec_snapshot;
+  if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) return request;
+  const examples = snapshot.examples;
+  if (!Array.isArray(examples) || examples.length > 0) return request;
+  return {
+    ...candidate,
+    spec_snapshot: {
+      ...snapshot,
+      examples: [
+        { input: "Dry-run placeholder input A", output: "Dry-run placeholder output A" },
+        { input: "Dry-run placeholder input B", output: "Dry-run placeholder output B" }
+      ]
+    }
+  };
+}
+async function validateDatasetInputs(request, config) {
+  const inputIdentity = (value) => value.normalize("NFKC").trim().replace(/\s+/g, " ").toLocaleLowerCase("en");
+  const evalSampleSeed = config.evaluation.sampleSeed ?? deriveSampleSeed(request.behavior_spec_id);
+  if (!request.dataset_prebuilt) {
+    const inlineExamples = examplesFromSpec(request.spec_snapshot);
+    const seenInputs = /* @__PURE__ */ new Map();
+    for (const [index, example] of inlineExamples.entries()) {
+      const identity = inputIdentity(example.input);
+      const previous = seenInputs.get(identity);
+      if (previous !== void 0) {
+        throw new Error(
+          `Inline examples ${previous + 1} and ${index + 1} have duplicate inputs; training and held-out evaluation require distinct prompts.`
+        );
+      }
+      seenInputs.set(identity, index);
+    }
+    if (!config.dryRun && inlineExamples.length < 2) {
+      throw new Error(
+        "A real local fine-tune requires at least 2 inline examples so training and evaluation use distinct data."
+      );
+    }
+    const split = splitSpecExamples(inlineExamples, evalSampleSeed);
+    const hasHoldout = split.holdout.length > 0;
+    const trainingExamples = hasHoldout ? split.train : inlineExamples;
+    const evaluationExamples = hasHoldout ? split.holdout : inlineExamples;
+    return {
+      trainingJsonl: compileSpecToJsonl({ ...request.spec_snapshot, examples: trainingExamples }),
+      trainingExampleCount: trainingExamples.length,
+      evaluationExamples,
+      evalSplit: hasHoldout ? "spec_holdout" : "spec_examples"
+    };
+  }
+  const dataset = request.dataset_prebuilt;
+  const splitEntries = [
+    ["training", dataset.training],
+    ["validation", dataset.validation],
+    ["test", dataset.test]
+  ];
+  const normalized = /* @__PURE__ */ new Map();
+  const expectedSystem = buildSystemMessage(request.spec_snapshot);
+  for (const [name, value] of splitEntries) {
+    if (!value) continue;
+    const path = stripFileUri(value);
+    const jsonl = await normalizeChatJsonlForRelocation(path);
+    assertMatchingDatasetSystems(jsonl, expectedSystem, name);
+    normalized.set(name, {
+      jsonl,
+      examples: await examplesFromChatJsonl(path)
+    });
+  }
+  const evaluationSplit = selectPrebuiltEvaluationSplit(dataset);
+  const evaluationKey = evaluationSplit === "prebuilt_validation" ? "validation" : "test";
+  const training = normalized.get("training");
+  const evaluationData = normalized.get(evaluationKey);
+  if (!training || !evaluationData) {
+    throw new Error("Unable to load the configured prebuilt training and evaluation datasets.");
+  }
+  const trainingInputs = new Set(
+    training.examples.map((example) => inputIdentity(example.input))
+  );
+  for (const splitName of ["validation", "test"]) {
+    const split = normalized.get(splitName);
+    if (!split) continue;
+    const splitInputs = /* @__PURE__ */ new Set();
+    for (const example of split.examples) {
+      const identity = inputIdentity(example.input);
+      if (splitInputs.has(identity)) {
+        throw new Error(
+          `Prebuilt ${splitName} data contains duplicate inputs; evaluation prompts must be unique so metrics and comparisons remain well-defined.`
+        );
+      }
+      splitInputs.add(identity);
+    }
+    const overlap = split.examples.filter(
+      (example) => trainingInputs.has(inputIdentity(example.input))
+    );
+    if (overlap.length > 0) {
+      throw new Error(
+        `Prebuilt training and ${splitName} data overlap on ${overlap.length} input(s); evaluation examples must be held out from training.`
+      );
+    }
+  }
+  return {
+    trainingJsonl: training.jsonl,
+    trainingExampleCount: training.examples.length,
+    evaluationExamples: evaluationData.examples,
+    evalSplit: evaluationSplit
+  };
+}
+async function validateLocalFineTuneInput(input) {
+  const config = localRunnerConfigSchema.parse(input.config);
+  const request = fineTuneRunRequestSchema.parse(addDryRunPlaceholders(input.request, config.dryRun));
+  await validateDatasetInputs(request, config);
+  if (config.evaluation.generalRegression) {
+    await evaluationSuiteFromChatJsonl(
+      config.evaluation.generalRegression.dataset,
+      config.evaluation.generalRegression.systemPrompt
+    );
+  }
+  return { request, config };
+}
+function artifactPrefix(request) {
+  return defaultArtifactPrefix({
+    userId: request.user_id,
+    behaviorSpecId: request.behavior_spec_id,
+    runId: request.run_id
+  });
+}
+function canonicalJson2(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson2(entry)).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(object[key])}`).join(",")}}`;
+}
+function hashJson(value) {
+  return createHash5("sha256").update(canonicalJson2(value)).digest("hex");
+}
+var packageRoot2 = localRuntimePackageRoot(import.meta.url);
+async function hashFileIfPresent(path) {
+  try {
+    return await hashFile(path);
+  } catch {
+    return null;
+  }
+}
+async function packageVersion2() {
+  try {
+    const parsed = JSON.parse(await readFile8(resolve11(packageRoot2, "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function runtimeFingerprint() {
+  const bundledProject2 = resolve11(packageRoot2, "training/local-runner");
+  return hashJson({
+    tt_local_version: await packageVersion2(),
+    node_version: process.version,
+    platform: process.platform,
+    architecture: process.arch,
+    runner_pyproject: await hashFileIfPresent(resolve11(bundledProject2, "pyproject.toml")),
+    runner_uv_lock: await hashFileIfPresent(resolve11(bundledProject2, "uv.lock"))
+  });
+}
+function preparedSourceFingerprint(args) {
+  return hashJson({
+    request_fingerprint: args.requestFingerprint,
+    runtime_fingerprint: args.runtimeFingerprint,
+    preparation_config: args.preparationConfig,
+    base_model_revision: args.baseModelRevision ?? null,
+    base_model_fingerprint: args.baseModelFingerprint ?? null,
+    dataset_fingerprints: args.datasetFingerprints
+  });
+}
+async function hashFile(path) {
+  const hash = createHash5("sha256");
+  for await (const chunk of createReadStream2(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function datasetFingerprints(request) {
+  const dataset = request.dataset_prebuilt;
+  const entries = [
+    ["training", dataset?.training],
+    ["validation", dataset?.validation],
+    ["test", dataset?.test]
+  ];
+  const fingerprints = {};
+  for (const [key, value] of entries) {
+    if (!value) continue;
+    const datasetPath = stripFileUri(value);
+    fingerprints[key] = await hashFile(datasetPath);
+  }
+  return fingerprints;
+}
+async function resolveBaseModelRevision(request, config) {
+  const explicit = request.hyperparameters.base_model_revision;
+  if (explicit) return explicit;
+  if (config.paths.baseModel) {
+    const match = resolve11(config.paths.baseModel).match(/[\\/]snapshots[\\/]([^\\/]+)(?:[\\/]|$)/);
+    if (match?.[1]) return match[1];
+  }
+  if (!request.spec_snapshot.base_model.includes("/")) return void 0;
+  const repository = `models--${request.spec_snapshot.base_model.replaceAll("/", "--")}`;
+  const cacheEnvironment = withHuggingFaceCacheEnvironment(process.env, config.paths.modelCache);
+  const refPath = resolve11(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
+  try {
+    const revision = (await readFile8(refPath, "utf8")).trim();
+    return revision || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function fingerprintLocalBaseModel(uri) {
+  const root = localModelArtifactPath(uri);
+  const rootMetadata = await lstat4(root);
+  if (rootMetadata.isSymbolicLink()) {
+    throw new Error(`Local base model path must not itself be a symbolic link: ${root}`);
+  }
+  if (!rootMetadata.isDirectory()) {
+    throw new Error(`Local base model must be a Hugging Face snapshot directory: ${root}`);
+  }
+  await verifyLocalBaseModel(root);
+  const files = [];
+  const visit = async (directory) => {
+    for (const entry of await readdir5(directory, { withFileTypes: true })) {
+      const child = resolve11(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(child);
+        continue;
+      }
+      const childMetadata = await stat5(child);
+      if (entry.isSymbolicLink() && !childMetadata.isFile()) {
+        throw new Error(`Local base model contains a non-file symbolic link: ${child}`);
+      }
+      if (!childMetadata.isFile()) continue;
+      files.push({
+        path: relative2(root, child).split("\\").join("/"),
+        size_bytes: childMetadata.size,
+        sha256: await hashFile(child)
+      });
+    }
+  };
+  await visit(root);
+  files.sort((left, right) => left.path.localeCompare(right.path));
+  if (files.length === 0) throw new Error(`Local base model directory is empty: ${root}`);
+  return hashJson({ kind: "directory", files });
+}
+function statusForProgressStage(stage) {
+  if (stage === "evaluating_baseline") return "evaluating_baseline";
+  if (stage === "evaluating_candidate") return "evaluating_candidate";
+  if (stage === "training") return "training";
+  if (stage === "preparing") return "preparing";
+  if (stage === "reporting") return "reporting";
+  return "training";
+}
+async function readStageMetadata(path) {
+  try {
+    const metadata = await readJson(path);
+    return typeof metadata.source_fingerprint === "string" ? metadata : null;
+  } catch {
+    return null;
+  }
+}
+async function removePrefixedArtifacts(path) {
+  const directory = dirname8(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(resolve11(directory, name), { recursive: true, force: true }))
+  ]);
+}
+async function cleanupStageArtifacts(artifacts, stage) {
+  const removeReport = async () => rm3(artifacts.runReportJson, { force: true });
+  if (stage === "prepare") {
+    await Promise.all([
+      removePrefixedArtifacts(artifacts.baselineEvalJson),
+      removePrefixedArtifacts(artifacts.candidateEvalJson),
+      removePrefixedArtifacts(artifacts.generalBaselineEvalJson),
+      removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
+      rm3(artifacts.trainingDir, { recursive: true, force: true }),
+      removePrefixedArtifacts(artifacts.trainingReportJson),
+      rm3(resolve11(artifacts.runDir, "model.tar.gz"), { force: true }),
+      removeReport(),
+      rm3(artifacts.artifactManifestJson, { force: true })
+    ]);
+    return;
+  }
+  if (stage === "baseline") {
+    await Promise.all([
+      removePrefixedArtifacts(artifacts.baselineEvalJson),
+      removePrefixedArtifacts(artifacts.generalBaselineEvalJson),
+      removeReport()
+    ]);
+    return;
+  }
+  if (stage === "train") {
+    await Promise.all([
+      rm3(artifacts.trainingDir, { recursive: true, force: true }),
+      removePrefixedArtifacts(artifacts.trainingReportJson),
+      rm3(resolve11(artifacts.runDir, "model.tar.gz"), { force: true }),
+      removePrefixedArtifacts(artifacts.candidateEvalJson),
+      removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
+      removeReport()
+    ]);
+    await prepareRunDirectories(artifacts);
+    return;
+  }
+  if (stage === "candidate") {
+    await Promise.all([
+      removePrefixedArtifacts(artifacts.candidateEvalJson),
+      removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
+      removeReport()
+    ]);
+    return;
+  }
+  await removeReport();
+}
+function manifestRelativePath(artifacts, path) {
+  return relative2(artifacts.runDir, path).split("\\").join("/");
+}
+async function verifyReusableArtifacts(artifacts, paths, options = {}) {
+  if (!await pathExists2(artifacts.artifactManifestJson)) return false;
+  await assertArtifactManifest(artifacts.artifactManifestJson, {
+    requiredPaths: paths.map((path) => manifestRelativePath(artifacts, path)),
+    scopeToRequired: true,
+    verifyModel: options.verifyModel
+  });
+  return true;
+}
+async function throwIfCancelled(store, request) {
+  if (await store.isCancellationRequested(request.run_id)) {
+    throw new ProcessCancelledError(`Run ${request.run_id} was cancelled.`);
+  }
+}
+async function acquireWorkflowLock(lockPath, description) {
+  await mkdir8(dirname8(lockPath), { recursive: true });
+  const token = randomUUID4();
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const handle = await open2(lockPath, "wx", 384);
+      try {
+        await handle.writeFile(`${JSON.stringify({ token, pid: process.pid, created_at: (/* @__PURE__ */ new Date()).toISOString() })}
+`);
+      } finally {
+        await handle.close();
+      }
+      return async () => {
+        try {
+          const owner = JSON.parse(await readFile8(lockPath, "utf8"));
+          if (owner.token === token) await rm3(lockPath, { force: true });
+        } catch {
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const metadata = await stat5(lockPath).catch(() => null);
+      let owner = null;
+      try {
+        owner = JSON.parse(await readFile8(lockPath, "utf8"));
+      } catch {
+        owner = null;
+      }
+      let ownerAlive = false;
+      if (typeof owner?.pid === "number" && Number.isSafeInteger(owner.pid) && owner.pid > 0) {
+        try {
+          process.kill(owner.pid, 0);
+          ownerAlive = true;
+        } catch (killError) {
+          ownerAlive = killError.code !== "ESRCH";
+        }
+      }
+      const recent = metadata ? Date.now() - metadata.mtimeMs < 1e4 : true;
+      if (ownerAlive || !owner && recent) {
+        throw new Error(
+          `${description} already has an active local workflow (lock: ${lockPath}).`
+        );
+      }
+      const stalePath = `${lockPath}.stale.${randomUUID4()}`;
+      try {
+        await rename3(lockPath, stalePath);
+        await rm3(stalePath, { force: true });
+      } catch (renameError) {
+        if (renameError.code !== "ENOENT") throw renameError;
+      }
+    }
+  }
+  throw new Error(`Unable to acquire local workflow lock for ${description}.`);
+}
+async function acquireRunLock(store, runId) {
+  return acquireWorkflowLock(resolve11(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
+}
+async function acquireArtifactLock(artifacts) {
+  return acquireWorkflowLock(
+    join8(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
+    `Artifact directory ${artifacts.runDir}`
+  );
+}
+function isDryTraining(training) {
+  return training.metrics?.dry_run === true;
+}
+async function modelManifestContract(prepared, training) {
+  if (isDryTraining(training) || !training.model_artifact_uri) return void 0;
+  const inspection = await assertUsableModelArtifact(training.model_artifact_uri);
+  const adapterWeights = inspection.adapter_weight_file_count > 0 && inspection.adapter_weight_bytes > 0;
+  if (!adapterWeights || !inspection.has_adapter_config) {
+    throw new Error(
+      `Local training must produce a PEFT adapter with adapter_model.safetensors or adapter_model.bin and a non-empty adapter_config.json: ${inspection.path}`
+    );
+  }
+  const format = inspection.kind === "file" ? "tar.gz" : "huggingface-directory";
+  return {
+    artifact_kind: inspection.kind,
+    format,
+    framework: "transformers-peft",
+    base_model: prepared.request.spec_snapshot.base_model,
+    base_model_revision: prepared.metadata.base_model_revision ?? prepared.request.hyperparameters.base_model_revision,
+    base_model_artifact_uri: training.base_model_artifact_uri,
+    base_model_fingerprint: prepared.metadata.base_model_fingerprint ?? void 0,
+    artifact_uri: training.model_artifact_uri,
+    artifact_root: inspection.path,
+    servable: true
+  };
+}
+async function refreshArtifactManifest(prepared) {
+  let model;
+  if (await pathExists2(prepared.artifacts.trainingReportJson)) {
+    const training = trainingReportSchema.parse(await readJson(prepared.artifacts.trainingReportJson));
+    model = await modelManifestContract(prepared, training);
+  }
+  await writeArtifactManifest(prepared.artifacts, { model });
+}
+function stageOutputPath(prepared, stage) {
+  if (stage === "baseline") return prepared.artifacts.baselineEvalJson;
+  if (stage === "train") return prepared.artifacts.trainingReportJson;
+  return prepared.artifacts.candidateEvalJson;
+}
+function stageFingerprintPath(prepared, stage) {
+  return `${stageOutputPath(prepared, stage)}.stage.json`;
+}
+async function runnerFileFingerprints() {
+  const project = resolve11(packageRoot2, "training/local-runner");
+  const bundledSource = resolve11(packageRoot2, "training/local-runner/src");
+  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve11(bundledSource, entry.name));
+  const candidates = [.../* @__PURE__ */ new Set([
+    ...pythonSources,
+    resolve11(project, "pyproject.toml"),
+    resolve11(project, "uv.lock")
+  ])];
+  const fingerprints = {};
+  for (const path of candidates.sort()) fingerprints[path] = await hashFileIfPresent(path);
+  return fingerprints;
+}
+async function stageFingerprint(args) {
+  const common = {
+    source_fingerprint: args.prepared.metadata.source_fingerprint,
+    runtime_fingerprint: args.prepared.metadata.runtime_fingerprint,
+    dry_run: args.config.dryRun
+  };
+  if (args.stage === "train") {
+    const entrypointFiles2 = await runnerFileFingerprints();
+    return hashJson({
+      ...common,
+      paths: args.config.paths,
+      entrypoint_files: entrypointFiles2
+    });
+  }
+  const entrypointFiles = await runnerFileFingerprints();
+  const evaluation = {
+    inference_protocol_version: INFERENCE_PROTOCOL_VERSION,
+    inference: args.config.evaluation.inference,
+    scoring: args.config.evaluation.scoring,
+    timeout_ms: args.config.evaluation.timeoutMs,
+    baseline_cache: args.config.evaluation.baselineCache,
+    general_regression: args.prepared.generalRegression ? {
+      dataset_sha256: args.prepared.generalRegression.datasetSha256,
+      system_prompt: args.prepared.generalRegression.system
+    } : null,
+    model_cache: args.config.paths.modelCache
+  };
+  return hashJson({
+    ...common,
+    evaluation,
+    entrypoint_files: entrypointFiles
+  });
+}
+async function writeStageFingerprint(args) {
+  await writeJsonAtomic(stageFingerprintPath(args.prepared, args.stage), {
+    schema_version: 1,
+    stage: args.stage,
+    fingerprint: await stageFingerprint(args),
+    written_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function hasCurrentStageFingerprint(args) {
+  try {
+    const record = await readJson(stageFingerprintPath(args.prepared, args.stage));
+    return record.fingerprint === await stageFingerprint(args);
+  } catch {
+    return false;
+  }
+}
+async function canReuseStageArtifact(args) {
+  const output = stageOutputPath(args.prepared, args.stage);
+  if (!await pathExists2(output) || !await hasCurrentStageFingerprint(args)) return false;
+  return verifyReusableArtifacts(
+    args.prepared.artifacts,
+    [output, stageFingerprintPath(args.prepared, args.stage), ...args.additionalPaths ?? []],
+    { verifyModel: args.verifyModel }
+  );
+}
+function createStoreReporter(input) {
+  return {
+    verbose: input.reporter?.verbose,
+    async onEvent(event) {
+      const state = await input.store.updateRun({
+        runId: input.request.run_id,
+        status: statusForProgressStage(event.stage),
+        stage: event.stage,
+        message: event.message,
+        details: event.details
+      });
+      if (state.status === "cancelled") throw new ProcessCancelledError(`Run ${input.request.run_id} was cancelled.`);
+      await input.reporter?.onEvent?.(event);
+    },
+    async onLog(log) {
+      await input.reporter?.onLog?.(log);
+    }
+  };
+}
+async function updateRun(input) {
+  const state = await input.store.updateRun({
+    runId: input.request.run_id,
+    status: input.status,
+    stage: input.stage,
+    message: input.message,
+    details: input.details
+  });
+  if (state.status === "cancelled") throw new ProcessCancelledError(`Run ${input.request.run_id} was cancelled.`);
+  await input.reporter?.onEvent?.({
+    stage: input.stage,
+    status: input.status,
+    message: input.message,
+    details: input.details
+  });
+  return state;
+}
+async function ensureRunRecord(args) {
+  await prepareRunDirectories(args.artifacts);
+  let existing = null;
+  try {
+    existing = await args.store.getRun(args.request.run_id);
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.startsWith("Run not found:")) throw error;
+  }
+  if (existing) {
+    if (existing.behavior_spec_id !== args.request.behavior_spec_id || existing.user_id !== args.request.user_id || existing.run_number !== args.request.run_number) {
+      throw new Error(
+        `Run ${args.request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
+      );
+    }
+    if (resolve11(existing.artifact_dir) !== resolve11(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}.`
+      );
+    }
+  } else {
+    await args.store.startRun({ request: args.request, artifactDir: args.artifacts.runDir });
+    await args.reporter?.onEvent?.({
+      stage: "queued",
+      status: "queued",
+      message: "Run queued.",
+      details: { run_id: args.request.run_id, artifact_dir: args.artifacts.runDir }
+    });
+  }
+}
+async function computePreparedRun(args) {
+  const { request, config, artifacts } = args;
+  const evalSampleSeed = config.evaluation.sampleSeed ?? deriveSampleSeed(request.behavior_spec_id);
+  const dataset = await validateDatasetInputs(request, config);
+  const examples = dataset.evaluationExamples;
+  if (args.writeArtifacts) {
+    await writeFileAtomic(artifacts.trainingJsonl, `${dataset.trainingJsonl}
+`);
+  }
+  const system = buildSystemMessage(request.spec_snapshot);
+  const baseModelForEvaluation = config.paths.baseModel ?? request.spec_snapshot.base_model;
+  const maxEvalExamples = config.evaluation.maxExamples ?? request.hyperparameters.max_eval_examples;
+  const evalExamplesUsed = Math.min(maxEvalExamples ?? examples.length, examples.length);
+  const fingerprints = await datasetFingerprints(request);
+  const generalRegressionConfig = config.evaluation.generalRegression;
+  const generalRegression = generalRegressionConfig ? {
+    datasetPath: generalRegressionConfig.dataset,
+    datasetSha256: await hashFile(generalRegressionConfig.dataset),
+    ...await evaluationSuiteFromChatJsonl(
+      generalRegressionConfig.dataset,
+      generalRegressionConfig.systemPrompt
+    )
+  } : void 0;
+  const requestFingerprint = hashJson(request);
+  const runtimeFingerprintValue = await runtimeFingerprint();
+  const baseModelRevision = await resolveBaseModelRevision(request, config);
+  const baseModelFingerprint = config.paths.baseModel ? await fingerprintLocalBaseModel(config.paths.baseModel) : void 0;
+  const metadata = {
+    run_id: request.run_id,
+    behavior_spec_id: request.behavior_spec_id,
+    user_id: request.user_id,
+    request_fingerprint: requestFingerprint,
+    runtime_fingerprint: runtimeFingerprintValue,
+    source_fingerprint: preparedSourceFingerprint({
+      requestFingerprint,
+      runtimeFingerprint: runtimeFingerprintValue,
+      preparationConfig: {
+        dry_run: config.dryRun,
+        base_model_path: config.paths.baseModel,
+        max_eval_examples: config.evaluation.maxExamples,
+        eval_sample_seed: config.evaluation.sampleSeed
+      },
+      baseModelRevision,
+      baseModelFingerprint,
+      datasetFingerprints: fingerprints
+    }),
+    eval_split: dataset.evalSplit,
+    eval_sample_seed: evalSampleSeed,
+    eval_examples_total: examples.length,
+    eval_examples_used: evalExamplesUsed,
+    max_eval_examples: maxEvalExamples ?? null,
+    training_example_count: dataset.trainingExampleCount,
+    dataset_prebuilt: Boolean(request.dataset_prebuilt),
+    dataset_format: request.dataset_prebuilt?.format ?? null,
+    dataset_fingerprints: fingerprints,
+    dataset_uri: fileUri(artifacts.trainingJsonl),
+    base_model_for_evaluation: baseModelForEvaluation,
+    base_model_revision: baseModelRevision ?? null,
+    base_model_fingerprint: baseModelFingerprint ?? null,
+    system_prompt_sha256: createHash5("sha256").update(system).digest("hex"),
+    prepared_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (args.writeArtifacts) await writeJsonAtomic(artifacts.stageMetadataJson, metadata);
+  return {
+    request,
+    artifacts,
+    metadata,
+    examples,
+    system,
+    baseModelForEvaluation,
+    maxEvalExamples,
+    generalRegression
+  };
+}
+function generalRegressionEvaluationConfig(config) {
+  const { maxExamples: _maxExamples, sampleSeed: _sampleSeed, ...evaluation } = config.evaluation;
+  return { ...config, evaluation };
+}
+function generalRegressionRequiredPaths(prepared, kind) {
+  if (!prepared.generalRegression) return [];
+  return [
+    kind === "baseline" ? prepared.artifacts.generalBaselineEvalJson : prepared.artifacts.generalCandidateEvalJson
+  ];
+}
+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(resolve11(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) {
+    canReuse = await verifyReusableArtifacts(args.artifacts, [
+      args.artifacts.stageMetadataJson,
+      args.artifacts.trainingJsonl
+    ]);
+  }
+  if (canReuse) {
+    await throwIfCancelled(args.store, args.request);
+    await updateRun({
+      ...args,
+      status: "preparing",
+      stage: "preparing",
+      message: "Reusing prepared local run artifacts.",
+      details: { artifact_dir: args.artifacts.runDir }
+    });
+    return prepared;
+  }
+  await updateRun({
+    ...args,
+    status: "preparing",
+    stage: "preparing",
+    message: "Preparing local run artifacts.",
+    details: { artifact_dir: args.artifacts.runDir }
+  });
+  await throwIfCancelled(args.store, args.request);
+  await args.store.invalidateRunOutputs(args.request.run_id, { report: true, model: true });
+  await cleanupStageArtifacts(args.artifacts, "prepare");
+  const refreshed = await computePreparedRun({ ...args, writeArtifacts: true });
+  await refreshArtifactManifest(refreshed);
+  return refreshed;
+}
+async function runBaselineStage(args) {
+  if (await canReuseStageArtifact({
+    stage: "baseline",
+    prepared: args.prepared,
+    config: args.config,
+    additionalPaths: generalRegressionRequiredPaths(args.prepared, "baseline")
+  })) {
+    await throwIfCancelled(args.store, args.prepared.request);
+    await updateRun({
+      store: args.store,
+      reporter: args.reporter,
+      request: args.prepared.request,
+      status: "evaluating_baseline",
+      stage: "evaluating_baseline",
+      message: "Reusing existing baseline evaluation.",
+      details: { path: args.prepared.artifacts.baselineEvalJson }
+    });
+    const report2 = evalReportSchema.parse(await readJson(args.prepared.artifacts.baselineEvalJson));
+    await throwIfCancelled(args.store, args.prepared.request);
+    return report2;
+  }
+  await throwIfCancelled(args.store, args.prepared.request);
+  await args.store.invalidateRunOutputs(args.prepared.request.run_id, { report: true });
+  await cleanupStageArtifacts(args.prepared.artifacts, "baseline");
+  await updateRun({
+    store: args.store,
+    reporter: args.reporter,
+    request: args.prepared.request,
+    status: "evaluating_baseline",
+    stage: "evaluating_baseline",
+    message: "Running baseline evaluation.",
+    details: {
+      examples: args.prepared.examples.length,
+      eval_examples_used: args.prepared.metadata.eval_examples_used,
+      eval_split: args.prepared.metadata.eval_split,
+      model_id: args.prepared.baseModelForEvaluation
+    }
+  });
+  const report = await evaluateExamples({
+    kind: "baseline",
+    modelId: args.prepared.baseModelForEvaluation,
+    baseModelId: args.prepared.baseModelForEvaluation,
+    baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+    sourceFingerprint: args.prepared.metadata.base_model_fingerprint ?? void 0,
+    examples: args.prepared.examples,
+    system: args.prepared.system,
+    config: args.config,
+    outputPath: args.prepared.artifacts.baselineEvalJson,
+    reporter: args.runReporter,
+    maxExamples: args.prepared.maxEvalExamples,
+    evalSplit: args.prepared.metadata.eval_split,
+    sampleSeed: args.prepared.metadata.eval_sample_seed,
+    shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
+  });
+  if (args.prepared.generalRegression) {
+    await updateRun({
+      store: args.store,
+      reporter: args.reporter,
+      request: args.prepared.request,
+      status: "evaluating_baseline",
+      stage: "evaluating_baseline",
+      message: "Running baseline general regression evaluation.",
+      details: {
+        examples: args.prepared.generalRegression.examples.length,
+        dataset: args.prepared.generalRegression.datasetPath
+      }
+    });
+    await evaluateExamples({
+      kind: "baseline",
+      modelId: args.prepared.baseModelForEvaluation,
+      baseModelId: args.prepared.baseModelForEvaluation,
+      baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+      sourceFingerprint: args.prepared.metadata.base_model_fingerprint ?? void 0,
+      examples: args.prepared.generalRegression.examples,
+      system: args.prepared.generalRegression.system,
+      config: generalRegressionEvaluationConfig(args.config),
+      outputPath: args.prepared.artifacts.generalBaselineEvalJson,
+      reporter: args.runReporter,
+      evalSplit: "general_regression",
+      shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
+    });
+  }
+  await throwIfCancelled(args.store, args.prepared.request);
+  await writeStageFingerprint({ stage: "baseline", prepared: args.prepared, config: args.config });
+  return report;
+}
+async function runTrainStage(args) {
+  if (await canReuseStageArtifact({
+    stage: "train",
+    prepared: args.prepared,
+    config: args.config,
+    verifyModel: true
+  })) {
+    await throwIfCancelled(args.store, args.prepared.request);
+    await updateRun({
+      store: args.store,
+      reporter: args.reporter,
+      request: args.prepared.request,
+      status: "training",
+      stage: "training",
+      message: "Reusing existing training result.",
+      details: { path: args.prepared.artifacts.trainingReportJson }
+    });
+    const training2 = trainingReportSchema.parse(await readJson(args.prepared.artifacts.trainingReportJson));
+    if (!isDryTraining(training2)) {
+      await modelManifestContract(args.prepared, training2);
+      await throwIfCancelled(args.store, args.prepared.request);
+      await args.store.registerModel({
+        request: args.prepared.request,
+        training: training2,
+        artifactDir: args.prepared.artifacts.runDir
+      });
+    }
+    await throwIfCancelled(args.store, args.prepared.request);
+    return training2;
+  }
+  await throwIfCancelled(args.store, args.prepared.request);
+  await args.store.invalidateRunOutputs(args.prepared.request.run_id, { report: true, model: true });
+  await cleanupStageArtifacts(args.prepared.artifacts, "train");
+  await updateRun({
+    store: args.store,
+    reporter: args.reporter,
+    request: args.prepared.request,
+    status: "training",
+    stage: "training",
+    message: args.config.dryRun ? "Recording dry-run training result." : "Launching local training process.",
+    details: { training_backend: "local-uv", dry_run: args.config.dryRun }
+  });
+  const training = await launchProcessTraining({
+    request: args.prepared.request,
+    artifacts: args.prepared.artifacts,
+    config: args.config,
+    baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+    reporter: args.runReporter,
+    shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
+  });
+  await throwIfCancelled(args.store, args.prepared.request);
+  if (!isDryTraining(training)) {
+    if (!training.model_artifact_uri) {
+      throw new Error("Training process completed without a model_artifact_uri.");
+    }
+    await modelManifestContract(args.prepared, training);
+  }
+  await writeJsonAtomic(args.prepared.artifacts.trainingReportJson, training);
+  await writeStageFingerprint({ stage: "train", prepared: args.prepared, config: args.config });
+  await refreshArtifactManifest(args.prepared);
+  await throwIfCancelled(args.store, args.prepared.request);
+  if (!isDryTraining(training)) {
+    await args.store.registerModel({
+      request: args.prepared.request,
+      training,
+      artifactDir: args.prepared.artifacts.runDir
+    });
+  }
+  return training;
+}
+async function runCandidateStage(args) {
+  let verifiedTraining;
+  if (await pathExists2(args.prepared.artifacts.trainingReportJson)) {
+    const trainingCurrent = await canReuseStageArtifact({
+      stage: "train",
+      prepared: args.prepared,
+      config: args.config,
+      verifyModel: true
+    });
+    if (trainingCurrent) {
+      verifiedTraining = trainingReportSchema.parse(
+        await readJson(args.prepared.artifacts.trainingReportJson)
+      );
+    }
+  }
+  if (verifiedTraining && await canReuseStageArtifact({
+    stage: "candidate",
+    prepared: args.prepared,
+    config: args.config,
+    verifyModel: true,
+    additionalPaths: [
+      args.prepared.artifacts.trainingReportJson,
+      stageFingerprintPath(args.prepared, "train"),
+      ...generalRegressionRequiredPaths(args.prepared, "candidate")
+    ]
+  })) {
+    await throwIfCancelled(args.store, args.prepared.request);
+    await updateRun({
+      store: args.store,
+      reporter: args.reporter,
+      request: args.prepared.request,
+      status: "evaluating_candidate",
+      stage: "evaluating_candidate",
+      message: "Reusing existing candidate evaluation.",
+      details: { path: args.prepared.artifacts.candidateEvalJson }
+    });
+    const training2 = verifiedTraining;
+    if (!isDryTraining(training2)) {
+      await throwIfCancelled(args.store, args.prepared.request);
+      await args.store.registerModel({
+        request: args.prepared.request,
+        training: training2,
+        artifactDir: args.prepared.artifacts.runDir
+      });
+    }
+    const report2 = evalReportSchema.parse(await readJson(args.prepared.artifacts.candidateEvalJson));
+    await throwIfCancelled(args.store, args.prepared.request);
+    return report2;
+  }
+  if (!verifiedTraining) {
+    throw new Error("Candidate evaluation requires current verified training output.");
+  }
+  await throwIfCancelled(args.store, args.prepared.request);
+  await args.store.invalidateRunOutputs(args.prepared.request.run_id, { report: true });
+  await cleanupStageArtifacts(args.prepared.artifacts, "candidate");
+  const training = verifiedTraining;
+  const modelArtifact = training.model_artifact_uri;
+  if (!modelArtifact) throw new Error("candidate stage requires a model_artifact_uri in training-report.json.");
+  if (!isDryTraining(training)) {
+    await modelManifestContract(args.prepared, training);
+    await refreshArtifactManifest(args.prepared);
+    await throwIfCancelled(args.store, args.prepared.request);
+    await args.store.registerModel({
+      request: args.prepared.request,
+      training,
+      artifactDir: args.prepared.artifacts.runDir
+    });
+  }
+  await updateRun({
+    store: args.store,
+    reporter: args.reporter,
+    request: args.prepared.request,
+    status: "evaluating_candidate",
+    stage: "evaluating_candidate",
+    message: "Running candidate evaluation.",
+    details: { model_artifact_uri: modelArtifact }
+  });
+  const report = await evaluateExamples({
+    kind: "candidate",
+    modelId: modelArtifact,
+    baseModelId: args.prepared.baseModelForEvaluation,
+    baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+    adapterPath: modelArtifact,
+    examples: args.prepared.examples,
+    system: args.prepared.system,
+    config: args.config,
+    outputPath: args.prepared.artifacts.candidateEvalJson,
+    reporter: args.runReporter,
+    maxExamples: args.prepared.maxEvalExamples,
+    evalSplit: args.prepared.metadata.eval_split,
+    sampleSeed: args.prepared.metadata.eval_sample_seed,
+    shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
+  });
+  if (args.prepared.generalRegression) {
+    await updateRun({
+      store: args.store,
+      reporter: args.reporter,
+      request: args.prepared.request,
+      status: "evaluating_candidate",
+      stage: "evaluating_candidate",
+      message: "Running candidate general regression evaluation.",
+      details: {
+        examples: args.prepared.generalRegression.examples.length,
+        dataset: args.prepared.generalRegression.datasetPath
+      }
+    });
+    await evaluateExamples({
+      kind: "candidate",
+      modelId: modelArtifact,
+      baseModelId: args.prepared.baseModelForEvaluation,
+      baseModelRevision: args.config.paths.baseModel ? void 0 : args.prepared.metadata.base_model_revision ?? void 0,
+      adapterPath: modelArtifact,
+      examples: args.prepared.generalRegression.examples,
+      system: args.prepared.generalRegression.system,
+      config: generalRegressionEvaluationConfig(args.config),
+      outputPath: args.prepared.artifacts.generalCandidateEvalJson,
+      reporter: args.runReporter,
+      evalSplit: "general_regression",
+      shouldCancel: () => args.store.isCancellationRequested(args.prepared.request.run_id)
+    });
+  }
+  await throwIfCancelled(args.store, args.prepared.request);
+  await writeStageFingerprint({
+    stage: "candidate",
+    prepared: args.prepared,
+    config: args.config,
+    training
+  });
+  return report;
+}
+async function runReportStage(args) {
+  if (!await pathExists2(args.prepared.artifacts.baselineEvalJson)) {
+    throw new Error("Run reporting requires baseline-eval.json.");
+  }
+  if (!await pathExists2(args.prepared.artifacts.candidateEvalJson)) {
+    throw new Error("Run reporting requires candidate-eval.json.");
+  }
+  if (!await pathExists2(args.prepared.artifacts.trainingReportJson)) {
+    throw new Error("Run reporting requires training-report.json.");
+  }
+  if (args.prepared.generalRegression && (!await pathExists2(args.prepared.artifacts.generalBaselineEvalJson) || !await pathExists2(args.prepared.artifacts.generalCandidateEvalJson))) {
+    throw new Error("Run reporting requires both general regression evaluations.");
+  }
+  const currentTraining = await canReuseStageArtifact({
+    stage: "train",
+    prepared: args.prepared,
+    config: args.config,
+    verifyModel: true
+  });
+  const currentBaseline = await canReuseStageArtifact({
+    stage: "baseline",
+    prepared: args.prepared,
+    config: args.config,
+    additionalPaths: generalRegressionRequiredPaths(args.prepared, "baseline")
+  });
+  const currentCandidate = await canReuseStageArtifact({
+    stage: "candidate",
+    prepared: args.prepared,
+    config: args.config,
+    verifyModel: true,
+    additionalPaths: [
+      args.prepared.artifacts.trainingReportJson,
+      stageFingerprintPath(args.prepared, "train"),
+      ...generalRegressionRequiredPaths(args.prepared, "candidate")
+    ]
+  });
+  if (!currentTraining || !currentBaseline || !currentCandidate) {
+    throw new Error("report stage inputs are stale for the current request/config. Re-run baseline, train, and candidate as needed.");
+  }
+  await verifyReusableArtifacts(args.prepared.artifacts, [
+    args.prepared.artifacts.baselineEvalJson,
+    stageFingerprintPath(args.prepared, "baseline"),
+    args.prepared.artifacts.candidateEvalJson,
+    stageFingerprintPath(args.prepared, "candidate"),
+    args.prepared.artifacts.trainingReportJson,
+    stageFingerprintPath(args.prepared, "train"),
+    ...generalRegressionRequiredPaths(args.prepared, "baseline"),
+    ...generalRegressionRequiredPaths(args.prepared, "candidate")
+  ], { verifyModel: true });
+  await throwIfCancelled(args.store, args.prepared.request);
+  await args.store.invalidateRunOutputs(args.prepared.request.run_id, { report: true });
+  await cleanupStageArtifacts(args.prepared.artifacts, "report");
+  await updateRun({
+    store: args.store,
+    reporter: args.reporter,
+    request: args.prepared.request,
+    status: "reporting",
+    stage: "reporting",
+    message: "Writing run report.",
+    details: { report_path: args.prepared.artifacts.runReportJson }
+  });
+  const baseline = evalReportSchema.parse(await readJson(args.prepared.artifacts.baselineEvalJson));
+  const candidate = evalReportSchema.parse(await readJson(args.prepared.artifacts.candidateEvalJson));
+  const training = trainingReportSchema.parse(await readJson(args.prepared.artifacts.trainingReportJson));
+  const comparison = compareEvalReports(baseline, candidate);
+  let generalRegression;
+  if (args.prepared.generalRegression) {
+    const generalBaseline = evalReportSchema.parse(
+      await readJson(args.prepared.artifacts.generalBaselineEvalJson)
+    );
+    const generalCandidate = evalReportSchema.parse(
+      await readJson(args.prepared.artifacts.generalCandidateEvalJson)
+    );
+    const generalComparison = compareEvalReports(generalBaseline, generalCandidate);
+    const policy = args.config.evaluation.generalRegression;
+    const gate = evaluateGeneralRegressionGate(generalComparison, policy);
+    generalRegression = {
+      dataset_uri: fileUri(args.prepared.generalRegression.datasetPath),
+      dataset_sha256: args.prepared.generalRegression.datasetSha256,
+      baseline: generalBaseline,
+      candidate: generalCandidate,
+      comparison: generalComparison,
+      policy: {
+        max_score_drop: policy.maxScoreDrop,
+        max_pass_rate_drop: policy.maxPassRateDrop
+      },
+      passed: gate.passed,
+      failures: gate.failures
+    };
+  }
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const duration = elapsed(args.startedPerf);
+  const report = runReportSchema.parse({
+    run_id: args.prepared.request.run_id,
+    behavior_spec_id: args.prepared.request.behavior_spec_id,
+    user_id: args.prepared.request.user_id,
+    run_number: args.prepared.request.run_number,
+    base_model: args.prepared.request.spec_snapshot.base_model,
+    fine_tuned_model_id: training.model_artifact_uri ?? training.training_job_name,
+    status: "completed",
+    baseline,
+    candidate,
+    comparison,
+    general_regression: generalRegression,
+    training,
+    artifact_uris: {
+      dataset: fileUri(args.prepared.artifacts.trainingJsonl),
+      baseline_eval: fileUri(args.prepared.artifacts.baselineEvalJson),
+      candidate_eval: fileUri(args.prepared.artifacts.candidateEvalJson),
+      general_baseline_eval: generalRegression ? fileUri(args.prepared.artifacts.generalBaselineEvalJson) : void 0,
+      general_candidate_eval: generalRegression ? fileUri(args.prepared.artifacts.generalCandidateEvalJson) : void 0,
+      report: fileUri(args.prepared.artifacts.runReportJson)
+    },
+    run_metadata: {
+      base_model: args.prepared.request.spec_snapshot.base_model,
+      fine_tuned_model_id: training.model_artifact_uri ?? training.training_job_name,
+      dataset_prebuilt: args.prepared.metadata.dataset_prebuilt,
+      dataset_format: args.prepared.metadata.dataset_format,
+      dataset_uri: fileUri(args.prepared.artifacts.trainingJsonl),
+      spec_example_count: args.prepared.request.spec_snapshot.examples.length,
+      training_example_count: args.prepared.metadata.training_example_count,
+      eval_examples_total: baseline.eval_examples_total,
+      eval_examples_used: baseline.eval_examples_used,
+      eval_split: baseline.eval_split,
+      eval_sample_seed: baseline.eval_sample_seed ?? null,
+      started_at: args.startedAt,
+      completed_at: completedAt,
+      elapsed_ms: duration.ms,
+      elapsed_seconds: duration.seconds
+    },
+    created_at: completedAt
+  });
+  await writeJsonAtomic(args.prepared.artifacts.runReportJson, report);
+  await refreshArtifactManifest(args.prepared);
+  await throwIfCancelled(args.store, args.prepared.request);
+  const completedState = await args.store.completeRun(
+    report,
+    args.prepared.artifacts.runDir,
+    args.prepared.artifacts.runReportJson
+  );
+  if (completedState.status === "cancelled") {
+    throw new ProcessCancelledError(`Run ${args.prepared.request.run_id} was cancelled.`);
+  }
+  await args.reporter?.onEvent?.({
+    stage: "completed",
+    status: "completed",
+    message: "Run completed successfully.",
+    details: {
+      report_path: args.prepared.artifacts.runReportJson,
+      ...!isDryTraining(training) ? { model_id: `local-${args.prepared.request.run_id}` } : {},
+      avg_score_delta: comparison.avg_score_delta,
+      general_regression_passed: generalRegression?.passed,
+      elapsed_seconds: duration.seconds
+    }
+  });
+  return report;
+}
+async function runLocalPipeline(input) {
+  const pipeline = validateLocalPipeline(input.pipeline);
+  const validated = await validateLocalFineTuneInput({
+    request: input.request,
+    config: input.config
+  });
+  input = { ...input, ...validated };
+  const startedPerf = performance.now();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = artifactPrefix(input.request);
+  const artifacts = resolveRunArtifacts({ artifactRoot: input.config.artifactRoot, prefix });
+  const store = createLocalStore(input.config.storeRoot);
+  const releaseRunLock = await acquireRunLock(store, input.request.run_id);
+  let releaseArtifactLock;
+  try {
+    await claimRunArtifactDirectory({
+      artifacts,
+      runId: input.request.run_id,
+      userId: input.request.user_id,
+      behaviorSpecId: input.request.behavior_spec_id
+    });
+    releaseArtifactLock = await acquireArtifactLock(artifacts);
+    await ensureRunRecord({ request: input.request, artifacts, store, reporter: input.reporter });
+    const runReporter = createStoreReporter({ request: input.request, store, reporter: input.reporter });
+    let prepared;
+    try {
+      await throwIfCancelled(store, input.request);
+      prepared = await prepareStage({
+        request: input.request,
+        config: input.config,
+        artifacts,
+        store,
+        reporter: input.reporter
+      });
+      const outputs = {};
+      for (const step of pipeline.steps) {
+        await throwIfCancelled(store, input.request);
+        if (step.uses === "train") {
+          const training = await runTrainStage({ prepared, config: input.config, store, reporter: input.reporter, runReporter });
+          outputs[step.id] = { training, modelArtifactUri: training.model_artifact_uri };
+          await refreshArtifactManifest(prepared);
+          continue;
+        }
+        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 = join8(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);
+          continue;
+        }
+        const before = outputs[referenceParts(step.with.before)[0]]?.report;
+        const after = outputs[referenceParts(step.with.after)[0]]?.report;
+        if (!before || !after) throw new Error(`Local compare step ${step.id} is missing validated evaluation outputs.`);
+        outputs[step.id] = { comparison: compareEvalReports(before, after) };
+      }
+      const compatibilityRecipe = pipeline.steps.length === 4 && pipeline.steps.map((step) => `${step.id}:${step.uses}`).join(",") === "baseline:evaluate,train:train,candidate:evaluate,compare:compare";
+      if (compatibilityRecipe) {
+        const report = await runReportStage({
+          prepared,
+          config: input.config,
+          store,
+          reporter: input.reporter,
+          startedAt,
+          startedPerf
+        });
+        return { request: input.request, pipeline, status: "completed", outputs, report, reportPath: artifacts.runReportJson, artifactDir: artifacts.runDir };
+      }
+      await store.updateRun({
+        runId: input.request.run_id,
+        status: "stage_completed",
+        stage: "stage_completed",
+        message: "Pipeline steps completed; no full compatibility report was requested.",
+        details: { completed_steps: pipeline.steps.map((step) => step.id) }
+      });
+      await input.reporter?.onEvent?.({
+        stage: "stage_completed",
+        status: "stage_completed",
+        message: "Pipeline steps completed without a full compatibility report."
+      });
+      return { request: input.request, pipeline, status: "stage_completed", outputs, artifactDir: artifacts.runDir };
+    } catch (error) {
+      const cancelled = error instanceof ProcessCancelledError || await store.isCancellationRequested(input.request.run_id).catch(() => false);
+      if (cancelled) {
+        const state = await store.getRun(input.request.run_id).catch(() => null);
+        if (state?.status !== "cancelled") await store.cancelRun(input.request.run_id).catch(() => void 0);
+        await store.finalizeCancellation(input.request.run_id).catch(() => void 0);
+        await input.reporter?.onEvent?.({
+          stage: "cancelled",
+          status: "cancelled",
+          message: "Run cancelled."
+        });
+      } else {
+        await store.failRun(input.request.run_id, error instanceof Error ? error.message : String(error)).catch(() => void 0);
+        await input.reporter?.onEvent?.({
+          stage: "failed",
+          status: "failed",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      throw error;
+    }
+  } finally {
+    await releaseArtifactLock?.();
+    await releaseRunLock();
+  }
+}
+async function runLocalFineTune(input) {
+  const result = await runLocalPipeline({ ...input, pipeline: canonicalLocalPipeline() });
+  if (!result.report || !result.reportPath) {
+    throw new Error("Canonical local pipeline completed without a compatibility report.");
+  }
+  return {
+    request: result.request,
+    report: result.report,
+    reportPath: result.reportPath,
+    artifactDir: result.artifactDir
+  };
+}
+
+export {
+  writeJsonAtomic,
+  assertArtifactManifest,
+  resolveTrainingModel,
+  assertUsableModelArtifact,
+  datasetFormatSchema,
+  baseModelRevisionSchema,
+  behaviorSpecExampleSchema,
+  specSnapshotSchema,
+  datasetPrebuiltSchema,
+  fineTuneHyperparametersSchema,
+  fineTuneRunRequestSchema,
+  localBehaviorSpecFileSchema,
+  evalExampleResultSchema,
+  jsonFieldMetricsSchema,
+  evalSplitSchema,
+  evalReportSchema,
+  comparisonReportSchema,
+  trainingReportSchema,
+  runReportSchema,
+  localRunnerConfigSchema,
+  DEFAULT_LOCAL_SPEC_PATH,
+  resolveLocalRunInputPaths,
+  initLocalSpecFile,
+  initLocalRunnerConfigFile,
+  generatedPlaceholderIssues,
+  assertLocalRunInputReady,
+  runRequestFromLocalSpec,
+  loadLocalRunInput,
+  normalizeChatJsonlForRelocation,
+  buildSystemMessage,
+  exampleToChatRow,
+  compileSpecToJsonl,
+  examplesFromSpec,
+  examplesFromChatJsonl,
+  evaluationSuiteFromChatJsonl,
+  reportInBackground,
+  sanitizeLogLine,
+  forwardStreamLines,
+  localRuntimePackageRoot,
+  buildBundledPythonCommand,
+  withBundledPythonEnvironment,
+  isTerminalRunState,
+  defaultLocalHome,
+  localStorePaths,
+  createLocalStore,
+  minimalMachineLearningEnvironment,
+  withHuggingFaceCacheEnvironment,
+  withOfflineHuggingFaceCacheEnvironment,
+  tokenF1,
+  buildModelPrefetchPayload,
+  verifyLocalBaseModel,
+  prefetchBaseModel,
+  evaluateGeneralRegressionGate,
+  canonicalLocalPipeline,
+  validateLocalPipeline,
+  loadJsonFile,
+  loadRunRequest,
+  loadLocalRunnerConfig,
+  validateLocalFineTuneInput,
+  fingerprintLocalBaseModel,
+  runLocalPipeline,
+  runLocalFineTune
+};
+//# sourceMappingURL=chunk-DAP2Z7EZ.js.map