@tuned-tensor/cli 0.20.0 → 0.22.0

package/dist/{chunk-4Q54NHKR.js → chunk-4SUXBHIY.js}

@@ -615,23 +615,52 @@ var TRAINING_MODELS = [
     gradientCheckpointing: true
   }
 ];
-function resolveTrainingModel(modelId) {
+var HUGGING_FACE_REPO_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}\/[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/;
+function uncertifiedTrainingModel(id) {
+  return {
+    id,
+    family: "uncertified",
+    modelLoader: "causal_lm",
+    defaultLearningRate: 1e-4,
+    defaultPerDeviceBatchSize: 1,
+    defaultGradientAccumulationSteps: 8,
+    defaultLoraRank: 16,
+    defaultLoraAlpha: 32,
+    defaultLoraDropout: 0.05,
+    defaultMaxSeqLength: 2048,
+    loraTargetModules: "all-linear",
+    gradientCheckpointing: true
+  };
+}
+function findCertifiedTrainingModel(modelId) {
   const normalized = modelId.trim().toLowerCase();
-  const model = TRAINING_MODELS.find(
-    (candidate) => candidate.id.toLowerCase() === normalized
+  return TRAINING_MODELS.find((candidate) => candidate.id.toLowerCase() === normalized);
+}
+function isCertifiedTrainingModel(modelId) {
+  return findCertifiedTrainingModel(modelId) !== void 0;
+}
+function resolveTrainingModel(modelId) {
+  const model = findCertifiedTrainingModel(modelId);
+  if (model) return model;
+  const id = modelId.trim();
+  if (HUGGING_FACE_REPO_ID.test(id)) return uncertifiedTrainingModel(id);
+  throw new Error(
+    `Unsupported base model "${modelId}". Use a certified model (${TRAINING_MODELS.map((item) => item.id).join(", ")}) or a Hugging Face repo id such as owner/name.`
+  );
+}
+function uncertifiedRevisionError(modelId) {
+  return new Error(
+    `${modelId} is not a TT-certified base model. To fine-tune it anyway, set hyperparameters.base_model_revision to its 40-character commit SHA (see https://huggingface.co/${modelId}/commits/main). Uncertified models load as text causal LMs with safetensors weights and no remote code.`
   );
-  if (!model) {
-    throw new Error(
-      `Unsupported base model "${modelId}". Supported models: ${TRAINING_MODELS.map((item) => item.id).join(", ")}`
-    );
-  }
-  return model;
 }
 function canonicalizeTrainingModel(modelId) {
   return resolveTrainingModel(modelId).id;
 }
 function resolveRequestedBaseModelRevision(modelId, requestedRevision) {
   const model = resolveTrainingModel(modelId);
+  if (!isCertifiedTrainingModel(model.id) && !requestedRevision) {
+    throw uncertifiedRevisionError(model.id);
+  }
   if (model.defaultRevision && requestedRevision && requestedRevision !== model.defaultRevision) {
     throw new Error(
       `${model.id} must use certified revision ${model.defaultRevision}; got ${requestedRevision}.`
@@ -640,7 +669,7 @@ function resolveRequestedBaseModelRevision(modelId, requestedRevision) {
   return requestedRevision ?? model.defaultRevision;
 }
 function defaultBaseModelRevision(modelId) {
-  return resolveRequestedBaseModelRevision(modelId);
+  return resolveTrainingModel(modelId).defaultRevision;
 }
 function resolveModelLoader(modelId) {
   return resolveTrainingModel(modelId).modelLoader;
@@ -703,6 +732,7 @@ function assertCertifiedBaseModelConfig(value, label = "base-model config.json",
     throw new Error(`${label} must contain a JSON object.`);
   }
   const config = value;
+  if (expectedModelId && !isCertifiedTrainingModel(expectedModelId)) return;
   const expectedFamily = expectedModelId ? resolveTrainingModel(expectedModelId).family : void 0;
   if (config.model_type === "qwen3_5") {
     if (expectedFamily && expectedFamily !== "qwen3_5") {
@@ -846,6 +876,7 @@ var TUNED_TENSOR_DIR = ".tuned-tensor";
 var DEFAULT_ARTIFACT_ROOT = `${TUNED_TENSOR_DIR}/artifacts`;
 var DEFAULT_PROJECT_STORE_ROOT = `${TUNED_TENSOR_DIR}/store`;
 var DEFAULT_FOUNDATION_RUNS_DIR = `${TUNED_TENSOR_DIR}/foundation-runs`;
+var DEFAULT_DECISION_RUNS_DIR = `${TUNED_TENSOR_DIR}/decision-runs`;
 function envHome(env = process.env) {
   const home = env.HOME?.trim();
   return home ? resolve3(home) : homedir();
@@ -902,6 +933,38 @@ function pythonEnvironmentPath(kind, hash, env = process.env) {
   return next;
 }
 
+// src/local-runtime/decision-models.ts
+var LAYA_REVISION = "55cf4c4ebb4ebe31b2550e8bdf3bd21b99753851";
+var DECISION_MODELS = [
+  {
+    id: "convaiinnovations/laya",
+    family: "laya",
+    revision: LAYA_REVISION,
+    parameters: "421M (ModernBERT-large encoder + typed decision head)",
+    license: "Apache-2.0",
+    defaultLearningRate: 2e-5,
+    defaultBatchSize: 8,
+    defaultEpochs: 3
+  }
+];
+var DEFAULT_DECISION_MODEL = DECISION_MODELS[0].id;
+function resolveDecisionModel(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  const model = DECISION_MODELS.find((candidate) => candidate.id.toLowerCase() === normalized);
+  if (!model) {
+    throw new Error(
+      `Unsupported decision model "${modelId}". Supported decision models: ${DECISION_MODELS.map((item) => item.id).join(", ")}`
+    );
+  }
+  return model;
+}
+function isDecisionModel(modelId) {
+  return DECISION_MODELS.some((candidate) => candidate.id.toLowerCase() === modelId.trim().toLowerCase());
+}
+function canonicalizeDecisionModel(modelId) {
+  return resolveDecisionModel(modelId).id;
+}
+
 // src/local-runtime/contracts.ts
 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());
@@ -947,11 +1010,34 @@ var foundationHyperparametersSchema = z.object({
   keep_checkpoints: z.number().int().min(1).max(100).optional(),
   log_interval_steps: z.number().int().min(1).max(1e6).optional()
 }).strict();
+var huggingFaceRepoIdSchema = z.string().regex(
+  /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}\/[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/,
+  "huggingface.repo must be a Hugging Face dataset id such as org/name"
+);
+var datasetColumnsSchema = z.object({
+  input: z.string().min(1),
+  output: z.string().min(1)
+}).strict();
+var huggingFaceDatasetSourceSchema = z.object({
+  repo: huggingFaceRepoIdSchema,
+  revision: baseModelRevisionSchema.optional(),
+  /**
+   * Field names for plain JSONL records such as `{"text": ..., "label": ...}`.
+   * Each record becomes a chat row with the spec's compiled system message.
+   * Omit for files that are already TT chat JSONL.
+   */
+  columns: datasetColumnsSchema.optional()
+}).strict();
+function isRepoRelativePath(value) {
+  if (/^(?:[A-Za-z]:|[/\\]|file:)/.test(value)) return false;
+  return value.split(/[/\\]/).every((part) => part !== "" && part !== "." && part !== "..");
+}
 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")
+  format: datasetFormatSchema.default("chat_jsonl"),
+  huggingface: huggingFaceDatasetSourceSchema.optional()
 }).strict().superRefine((dataset, context) => {
   if (!dataset.validation && !dataset.test) {
     context.addIssue({
@@ -960,7 +1046,57 @@ var datasetPrebuiltSchema = z.object({
       message: "Provide a distinct validation or test split for held-out evaluation"
     });
   }
+  if (!dataset.huggingface) return;
+  for (const key of ["training", "validation", "test"]) {
+    const value = dataset[key];
+    if (value === void 0) continue;
+    if (!isRepoRelativePath(value)) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [key],
+        message: `With dataset_prebuilt.huggingface, ${key} must be a file path inside the dataset repo, such as data/${key}.jsonl`
+      });
+    } else if (!value.toLowerCase().endsWith(".jsonl")) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [key],
+        message: `${key} must be a chat JSONL (.jsonl) file; Parquet, CSV and other formats are not supported yet`
+      });
+    }
+  }
 });
+var datasetSourceFileSchema = z.object({
+  path: z.string().min(1),
+  size_bytes: z.number().int().nonnegative(),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var datasetConversionStatsSchema = z.object({
+  records: z.number().int().nonnegative(),
+  kept: z.number().int().nonnegative(),
+  skipped_missing_fields: z.number().int().nonnegative(),
+  dropped_duplicate_inputs: z.number().int().nonnegative(),
+  dropped_eval_overlap: z.number().int().nonnegative()
+}).strict();
+var datasetSourceSchema = z.object({
+  provider: z.literal("huggingface"),
+  repo: huggingFaceRepoIdSchema,
+  requested_revision: baseModelRevisionSchema.nullable(),
+  revision: baseModelRevisionSchema,
+  pinned: z.boolean(),
+  columns: datasetColumnsSchema.nullable(),
+  /** Per-split record accounting when `columns` converted plain JSONL records. */
+  conversion: z.object({
+    training: datasetConversionStatsSchema,
+    validation: datasetConversionStatsSchema.optional(),
+    test: datasetConversionStatsSchema.optional()
+  }).strict().nullable().optional(),
+  snapshot_path: z.string().min(1),
+  files: z.object({
+    training: datasetSourceFileSchema,
+    validation: datasetSourceFileSchema.optional(),
+    test: datasetSourceFileSchema.optional()
+  }).strict()
+}).strict();
 var fineTuneHyperparametersSchema = z.object({
   n_epochs: z.number().int().min(1).max(20).default(1),
   learning_rate: z.number().positive().optional(),
@@ -974,6 +1110,15 @@ var fineTuneHyperparametersSchema = z.object({
   /** Immutable Hugging Face commit used by every stage of the run. */
   base_model_revision: baseModelRevisionSchema.optional()
 }).strict();
+function requirePinnedUncertifiedModel(spec, context) {
+  const baseModel = "spec_snapshot" in spec ? spec.spec_snapshot.base_model : spec.base_model;
+  if (isCertifiedTrainingModel(baseModel) || spec.hyperparameters?.base_model_revision) return;
+  context.addIssue({
+    code: z.ZodIssueCode.custom,
+    path: ["hyperparameters", "base_model_revision"],
+    message: uncertifiedRevisionError(baseModel).message
+  });
+}
 var fineTuneRunRequestSchema = z.object({
   run_id: z.string().uuid(),
   user_id: z.string().min(1),
@@ -981,8 +1126,10 @@ var fineTuneRunRequestSchema = z.object({
   run_number: z.number().int().min(1),
   spec_snapshot: specSnapshotSchema,
   hyperparameters: fineTuneHyperparametersSchema.default({ n_epochs: 1 }),
-  dataset_prebuilt: datasetPrebuiltSchema.optional()
+  dataset_prebuilt: datasetPrebuiltSchema.optional(),
+  dataset_source: datasetSourceSchema.optional()
 }).strict().superRefine((request, context) => {
+  requirePinnedUncertifiedModel(request, context);
   if (request.spec_snapshot.examples.length === 0 && !request.dataset_prebuilt) {
     context.addIssue({
       code: z.ZodIssueCode.custom,
@@ -1070,6 +1217,55 @@ var trainingReportSchema = z.object({
   log_uri: z.string(),
   command: z.array(z.string()).optional()
 }).strict();
+var runProvenanceSchema = z.object({
+  schema_version: z.literal(1),
+  recorded_at: z.string(),
+  software: z.object({
+    tt_version: z.string(),
+    node_version: z.string(),
+    platform: z.string(),
+    arch: z.string(),
+    runtime_fingerprint: z.string(),
+    python_lock_sha256: z.string().nullable()
+  }).strict(),
+  execution: z.object({
+    target: z.enum(["local", "aws"]),
+    training_backend: z.string(),
+    instance_id: z.string().optional(),
+    region: z.string().optional()
+  }).strict(),
+  spec: z.object({
+    behavior_spec_id: z.string(),
+    run_number: z.number().int(),
+    snapshot_sha256: z.string(),
+    system_prompt_sha256: z.string(),
+    file_path: z.string().optional(),
+    file_sha256: z.string().optional()
+  }).strict(),
+  base_model: z.object({
+    id: z.string(),
+    revision: z.string().nullable(),
+    fingerprint: z.string().nullable()
+  }).strict(),
+  data: z.object({
+    prebuilt: z.boolean(),
+    format: z.string().nullable(),
+    file_sha256: z.record(z.string(), z.string()),
+    compiled_training_sha256: z.string().nullable(),
+    training_examples: z.number().int().nonnegative().nullable(),
+    eval_split: z.string(),
+    eval_sample_seed: z.number().int(),
+    eval_examples_total: z.number().int().nonnegative(),
+    eval_examples_used: z.number().int().nonnegative()
+  }).strict(),
+  training: z.object({
+    hyperparameters: z.record(z.string(), z.unknown()),
+    exit_code: z.number().int().nullable(),
+    log_uri: z.string()
+  }).strict(),
+  /** Hash over request, runtime, preparation config and input digests. */
+  source_fingerprint: z.string()
+}).strict();
 var runReportSchema = z.object({
   run_id: z.string().uuid(),
   behavior_spec_id: z.string().uuid(),
@@ -1095,6 +1291,7 @@ var runReportSchema = z.object({
     failures: z.array(z.string())
   }).strict().optional(),
   training: trainingReportSchema,
+  provenance: runProvenanceSchema.optional(),
   artifact_uris: z.object({
     dataset: z.string(),
     baseline_eval: z.string(),
@@ -1109,6 +1306,7 @@ var runReportSchema = z.object({
     dataset_prebuilt: z.boolean(),
     dataset_format: datasetFormatSchema.nullable().optional(),
     dataset_uri: z.string(),
+    dataset_source: datasetSourceSchema.optional(),
     spec_example_count: z.number().int().nonnegative(),
     training_example_count: z.number().int().nonnegative().nullable(),
     eval_examples_total: z.number().int().nonnegative(),
@@ -1205,9 +1403,54 @@ var localAdapterSpecFileSchema = specSnapshotSchema.extend({
   id: z.string().uuid().optional(),
   hyperparameters: fineTuneHyperparametersSchema.optional(),
   dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict().superRefine(requirePinnedUncertifiedModel);
+var decisionQuestionSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("choice"),
+    /** Answer label -> description the model reads. Key order is option order. */
+    criteria: z.record(z.string().min(1), z.string()).refine(
+      (criteria) => Object.keys(criteria).length >= 2 && Object.keys(criteria).length <= 32,
+      "A choice decision needs 2 to 32 labels."
+    )
+  }).strict(),
+  z.object({
+    type: z.literal("noul"),
+    criteria: z.object({ true: z.string().optional(), false: z.string().optional() }).strict().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("score"),
+    /** Level descriptions, index 0 first; example outputs are level indices. */
+    criteria: z.array(z.string().min(1)).min(2).max(10)
+  }).strict()
+]);
+var decisionHyperparametersSchema = z.object({
+  n_epochs: z.number().int().min(1).max(50).optional(),
+  learning_rate: z.number().positive().max(1).optional(),
+  batch_size: z.number().int().min(1).max(256).optional(),
+  /** Train only the decision head; faster on CPU, usually less accurate. */
+  freeze_encoder: z.boolean().optional(),
+  /** Shuffle option order per training row so the head learns meaning, not position. */
+  shuffle_options: z.boolean().optional(),
+  seed: z.number().int().min(0).max(2147483647).optional(),
+  device: z.enum(["auto", "cpu", "cuda", "mps"]).optional()
 }).strict();
+var localDecisionSpecFileSchema = behaviorSpecSchema.extend({
+  ...projectWorkflowFields,
+  engine: z.literal("decision"),
+  id: z.string().uuid().optional(),
+  // Refine first: a union member must report an issue, not throw, for other engines' specs.
+  base_model: z.string().refine(isDecisionModel, `Unsupported decision model. Supported decision models: ${DECISION_MODELS.map((model) => model.id).join(", ")}`).transform((value) => canonicalizeDecisionModel(value)),
+  decision: decisionQuestionSchema,
+  hyperparameters: decisionHyperparametersSchema.optional()
+});
+function decisionLabels(question) {
+  if (question.type === "choice") return Object.keys(question.criteria);
+  if (question.type === "noul") return ["false", "true"];
+  return question.criteria.map((_, index) => String(index));
+}
 var localBehaviorSpecFileSchema = z.union([
   localFoundationSpecFileSchema,
+  localDecisionSpecFileSchema,
   localAdapterSpecFileSchema
 ]).superRefine((spec, ctx) => {
   if (spec.pipeline && isFoundationPipeline(parsePipeline(spec.pipeline)) !== (spec.engine === "foundation")) {
@@ -1216,14 +1459,145 @@ var localBehaviorSpecFileSchema = z.union([
   if (spec.engine === "foundation" && (spec.evaluation || spec.runtime?.storeRoot || spec.runtime?.paths)) {
     ctx.addIssue({ code: "custom", path: ["runtime"], message: "Foundation uses foundation settings for evaluation and checkpoints; runtime.artifactRoot and runtime.gpu are supported." });
   }
+  if (spec.engine === "decision" && (spec.evaluation || spec.runtime?.gpu || spec.runtime?.storeRoot || spec.runtime?.paths)) {
+    ctx.addIssue({ code: "custom", path: ["runtime"], message: "Decision specs support runtime.artifactRoot only; the device is set in hyperparameters.device." });
+  }
 });
 function isFoundationSpecFile(spec) {
   return spec.engine === "foundation";
 }
+function isDecisionSpecFile(spec) {
+  return spec.engine === "decision";
+}
+
+// src/local-runtime/dataset.ts
+import { readFile as readFile2 } from "fs/promises";
+async function loadNormalizedChatJsonl(path) {
+  const text = await readFile2(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 datasetInputIdentity(value) {
+  return value.normalize("NFKC").trim().replace(/\s+/g, " ").toLocaleLowerCase("en");
+}
+function buildSystemMessage(spec) {
+  const parts = [];
+  const guidelines = spec.guidelines.map((value) => value.trim()).filter(Boolean);
+  const constraints = spec.constraints.map((value) => value.trim()).filter(Boolean);
+  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
+  if (guidelines.length > 0) {
+    parts.push(`Guidelines:
+${guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
+  }
+  if (constraints.length > 0) {
+    parts.push(`Constraints:
+${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/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 { readFile as readFile3, stat as stat2, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 import { homedir as homedir2 } from "os";
 import { mkdir as mkdir2 } from "fs/promises";
@@ -1360,7 +1734,7 @@ function resolveLocalRunInputPaths(raw, inputPath) {
   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.huggingface === void 0) for (const key of ["training", "validation", "test"]) {
       if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
     }
   }
@@ -1432,6 +1806,34 @@ async function initLocalSpecFile(args) {
     });
     await mkdir2(dirname2(args.outputPath), { recursive: true });
     await writeFile2(args.outputPath, `${JSON.stringify(spec2, null, 2)}
+`, "utf8");
+    return spec2;
+  }
+  if (args.engine === "decision") {
+    const spec2 = localDecisionSpecFileSchema.parse({
+      engine: "decision",
+      id: randomUUID2(),
+      name: args.name,
+      description: "Typed decision model: one labelled answer per input.",
+      system_prompt: "Describe the decision this local model should make.",
+      guidelines: [],
+      constraints: [],
+      base_model: args.baseModel ?? DEFAULT_DECISION_MODEL,
+      decision: {
+        type: "choice",
+        criteria: {
+          first_label: "Replace this with what the first label means.",
+          second_label: "Replace this with what the second label means."
+        }
+      },
+      examples: [
+        { input: "Replace this with a representative input.", output: "first_label" },
+        { input: "Replace this with a different input.", output: "second_label" }
+      ],
+      hyperparameters: { n_epochs: 3 }
+    });
+    await mkdir2(dirname2(args.outputPath), { recursive: true });
+    await writeFile2(args.outputPath, `${JSON.stringify(spec2, null, 2)}
 `, "utf8");
     return spec2;
   }
@@ -1491,7 +1893,7 @@ async function initLocalRunnerConfigFile(args) {
 }
 function placeholderIssues(systemPrompt, examples) {
   const issues = [];
-  if (/describe the behavior this local model should learn/i.test(systemPrompt)) {
+  if (/describe the (behavior|decision) this local model should (learn|make)/i.test(systemPrompt)) {
     issues.push("system_prompt still contains the generated placeholder");
   }
   examples.forEach((example, index) => {
@@ -1513,6 +1915,14 @@ function assertLocalRunInputReady(request) {
 function foundationPlaceholderIssues(spec) {
   return placeholderIssues(spec.system_prompt, spec.examples);
 }
+function decisionPlaceholderIssues(spec) {
+  const issues = placeholderIssues(spec.system_prompt, spec.examples);
+  const descriptions = spec.decision.type === "noul" ? Object.values(spec.decision.criteria ?? {}) : Object.values(spec.decision.criteria);
+  if (descriptions.some((value) => /replace this with/i.test(value ?? ""))) {
+    issues.push("decision.criteria still contains generated placeholder text");
+  }
+  return issues;
+}
 function assertFoundationSpecReady(spec) {
   const issues = foundationPlaceholderIssues(spec);
   if (issues.length > 0) {
@@ -1520,9 +1930,9 @@ function assertFoundationSpecReady(spec) {
   }
 }
 function runRequestFromLocalSpec(spec, options = {}) {
-  if (isFoundationSpecFile(spec)) {
+  if (isFoundationSpecFile(spec) || isDecisionSpecFile(spec)) {
     throw new Error(
-      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
+      `${isFoundationSpecFile(spec) ? "Foundation" : "Decision"} specs cannot be converted into a LoRA run request. Use \`tt pipeline run --spec\`.`
     );
   }
   const {
@@ -1570,6 +1980,9 @@ function parseLocalRunInput(rawInput, path, options = {}) {
   if (isFoundationSpecFile(spec)) {
     return { kind: "foundation-spec", path, spec };
   }
+  if (isDecisionSpecFile(spec)) {
+    return { kind: "decision-spec", path, spec };
+  }
   return {
     kind: "spec",
     path,
@@ -1579,7 +1992,7 @@ function parseLocalRunInput(rawInput, path, options = {}) {
 }
 async function loadLocalRunInput(path, options = {}) {
   return parseLocalRunInput(
-    JSON.parse(await readFile2(path, "utf8")),
+    JSON.parse(await readFile3(path, "utf8")),
     path,
     options
   );
@@ -1594,7 +2007,7 @@ function validateBehaviorSpec(input) {
     return { valid: false, errors: ["Use a behavior spec, not a run request."], warnings };
   }
   const { spec } = input;
-  const placeholders = input.kind === "foundation-spec" ? foundationPlaceholderIssues(input.spec) : generatedPlaceholderIssues(input.request);
+  const placeholders = input.kind === "foundation-spec" ? foundationPlaceholderIssues(input.spec) : input.kind === "decision-spec" ? decisionPlaceholderIssues(input.spec) : generatedPlaceholderIssues(input.request);
   if (placeholders.length) {
     errors.push(`Edit the generated behavior spec before training: ${placeholders.join("; ")}.`);
   }
@@ -1609,6 +2022,29 @@ function validateBehaviorSpec(input) {
       errors.push("Foundation RL requires numeric expected outputs in every example.");
     }
   }
+  if (input.kind === "decision-spec") {
+    const labels = decisionLabels(input.spec.decision);
+    const normalized = new Map(labels.map((label) => [label.trim().toLowerCase(), label]));
+    if (normalized.size !== labels.length) {
+      errors.push("decision labels must stay distinct ignoring case and surrounding spaces.");
+    }
+    const counts = /* @__PURE__ */ new Map();
+    for (const [index, example] of spec.examples.entries()) {
+      const label = normalized.get(example.output.trim().toLowerCase());
+      if (!label) {
+        errors.push(`examples[${index}].output must be one of the decision labels: ${labels.join(", ")}.`);
+      } else {
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+      }
+    }
+    const missing = labels.filter((label) => !counts.has(label));
+    if (missing.length && spec.examples.length) {
+      warnings.push(`No examples use decision label(s) ${missing.join(", ")}; the tuned model learns those only from their descriptions.`);
+    }
+    if (buildSystemMessage(spec).length > 600) {
+      warnings.push("The compiled decision instruction exceeds 600 characters; the decision model reads about 190 tokens of instruction and options, so later text may be truncated.");
+    }
+  }
   for (const key of ["name", "system_prompt"]) {
     if (!spec[key].trim()) errors.push(`${key} must not be blank.`);
   }
@@ -1784,7 +2220,7 @@ ${validation.errors.join("\n")}`);
   const pipeline = parsePipeline2(recipe);
   if (isFoundationPipeline2(pipeline) !== foundation) {
     const recipeEngine = isFoundationPipeline2(pipeline) ? "a foundation" : "an adapter";
-    const specEngine = foundation ? "a foundation" : "an adapter";
+    const specEngine = foundation ? "a foundation" : input.kind === "decision-spec" ? "a decision" : "an adapter";
     throw new Error(`Pipeline is ${recipeEngine} recipe, but the behavior spec is ${specEngine} spec. Use a matching recipe or omit --file.`);
   }
   if (foundation) assertFoundationSettingsMatch(input.spec.foundation, pipeline);
@@ -1833,177 +2269,346 @@ function assertFoundationSettingsMatch(hp, plan) {
   }
 }
 
-// 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 });
+// 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));
     }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
+  });
+  stream.on("end", () => {
+    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
+  });
+}
+
+// src/local-runtime/package-root.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } 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) => existsSync2(resolve5(candidate, "package.json")) && existsSync2(resolve5(candidate, "training/adapter"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  }
+  return root;
+}
+
+// src/local-runtime/audit.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { mkdir as mkdir3, open as open2, readFile as readFile4, rename as rename2, rm, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import { hostname } from "os";
+import { join as join3 } from "path";
+function canonicalJson3(value) {
+  const normalized = JSON.parse(JSON.stringify(value ?? null));
+  const encode = (entry) => {
+    if (entry === null || typeof entry !== "object") return JSON.stringify(entry);
+    if (Array.isArray(entry)) return `[${entry.map(encode).join(",")}]`;
+    const object = entry;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${encode(object[key])}`).join(",")}}`;
+  };
+  return encode(normalized);
+}
+function eventHash(event) {
+  const { hash: _hash, ...body } = event;
+  return createHash3("sha256").update(canonicalJson3(body)).digest("hex");
+}
+function chainEvent(event, previous) {
+  const body = JSON.parse(JSON.stringify({
+    ...event,
+    seq: typeof previous?.seq === "number" ? previous.seq + 1 : 0,
+    prev_hash: previous?.hash ?? null
+  }));
+  return { ...body, hash: eventHash(body) };
+}
+function verifyEventChain(events) {
+  let legacy = 0;
+  let unchainedAfter = 0;
+  let previous;
+  const result = (status, brk) => ({
+    status,
+    events: events.length,
+    chained_events: events.filter((event) => event.hash !== void 0).length,
+    legacy_events: legacy,
+    unchained_after_chain: unchainedAfter,
+    head_hash: previous?.hash ?? null,
+    ...brk ? { break: brk } : {}
+  });
+  for (const [index, event] of events.entries()) {
+    const chained = event;
+    if (chained.hash === void 0) {
+      if (previous) unchainedAfter += 1;
+      else legacy += 1;
+      continue;
     }
-    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 expectedSeq = previous ? (previous.seq ?? -1) + 1 : 0;
+    if (chained.seq !== expectedSeq) {
+      return result("broken", { index, seq: chained.seq ?? null, reason: `Expected sequence ${expectedSeq}; an event was removed, reordered or inserted.` });
     }
-    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`
-      );
+    if ((chained.prev_hash ?? null) !== (previous?.hash ?? null)) {
+      return result("broken", { index, seq: chained.seq, reason: "The previous-event hash does not match; an earlier event was changed or removed." });
     }
-    rows.push(row);
-    jsonLines.push(JSON.stringify(row));
+    if (eventHash(chained) !== chained.hash) {
+      return result("broken", { index, seq: chained.seq, reason: "The event's contents do not match its hash; it was edited." });
+    }
+    previous = chained;
   }
-  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
-  return {
-    rows,
-    jsonl: jsonLines.join("\n")
-  };
+  if (events.length === 0) return result("empty");
+  if (!previous) return result("legacy");
+  if (unchainedAfter > 0) return result("mixed");
+  return result(legacy > 0 ? "legacy" : "verified");
 }
-async function normalizeChatJsonlForRelocation(path) {
-  return (await loadNormalizedChatJsonl(path)).jsonl;
+async function sha256File2(path) {
+  const hash = createHash3("sha256");
+  for await (const chunk of createReadStream2(path)) hash.update(chunk);
+  return hash.digest("hex");
 }
-function buildSystemMessage(spec) {
-  const parts = [];
-  const guidelines = spec.guidelines.map((value) => value.trim()).filter(Boolean);
-  const constraints = spec.constraints.map((value) => value.trim()).filter(Boolean);
-  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
-  if (guidelines.length > 0) {
-    parts.push(`Guidelines:
-${guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
-  }
-  if (constraints.length > 0) {
-    parts.push(`Constraints:
-${constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
   }
-  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");
+async function readLockOwner(lockPath) {
+  try {
+    return JSON.parse(await readFile4(join3(lockPath, "owner.json"), "utf8"));
+  } catch {
+    return null;
+  }
 }
-function examplesFromSpec(spec) {
-  return spec.examples;
+async function abandonedLockOwner(lockPath, orphanMs, remoteMs) {
+  const metadata = await stat3(lockPath).catch(() => null);
+  if (!metadata) return null;
+  const owner = await readLockOwner(lockPath);
+  const age = Date.now() - metadata.mtimeMs;
+  if (!owner) return age > orphanMs ? "ownerless" : null;
+  if (owner.host === hostname()) return processAlive(owner.pid) ? null : owner;
+  return age > remoteMs ? owner : null;
 }
-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
-    });
+async function breakAbandonedLock(lockPath, abandoned) {
+  const moved = `${lockPath}.abandoned-${randomUUID3()}`;
+  try {
+    await rename2(lockPath, moved);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
   }
-  return examples;
+  const owner = await readLockOwner(moved);
+  const expected = abandoned === "ownerless" ? void 0 : abandoned.token;
+  if (owner?.token !== expected) {
+    await rename2(moved, lockPath).catch(() => void 0);
+  }
+  await rm(moved, { recursive: true, force: true });
 }
-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."
-      );
+async function withAppendLock(lockPath, action, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  const token = randomUUID3();
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      await mkdir3(lockPath, { mode: 448 });
+      await writeFile3(join3(lockPath, "owner.json"), JSON.stringify({ token, pid: process.pid, host: hostname() }), { mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const abandoned = await abandonedLockOwner(lockPath, options.orphanMs ?? 5e3, options.remoteMs ?? 6e5);
+      if (abandoned) {
+        await breakAbandonedLock(lockPath, abandoned);
+        continue;
+      }
+      if (Date.now() > deadline) throw new Error(`Timed out waiting for the run event log lock: ${lockPath}`);
+      await new Promise((resolve17) => setTimeout(resolve17, 20));
     }
-    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."
-    );
+  try {
+    return await action();
+  } finally {
+    if ((await readLockOwner(lockPath))?.token === token) await rm(lockPath, { recursive: true, force: true });
   }
-  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) {
+async function readJsonlTail(path, accept = () => true) {
+  let handle;
   try {
-    void Promise.resolve(action()).catch(() => void 0);
-  } catch {
+    handle = await open2(path, "r");
+  } catch (error) {
+    if (error.code === "ENOENT") return { last: void 0, partial: false };
+    throw error;
+  }
+  try {
+    const size = (await handle.stat()).size;
+    if (size === 0) return { last: void 0, partial: false };
+    let window = Math.min(size, 64 * 1024);
+    for (; ; ) {
+      const buffer = Buffer.alloc(window);
+      await handle.read(buffer, 0, window, size - window);
+      const text = buffer.toString("utf8");
+      const partial = !text.endsWith("\n");
+      const lines = text.split("\n");
+      const complete = window === size ? lines : lines.slice(1);
+      for (const line of complete.reverse()) {
+        if (!line.trim()) continue;
+        let row;
+        try {
+          row = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (row === null || typeof row !== "object" || Array.isArray(row)) continue;
+        if (accept(row)) return { last: row, partial };
+      }
+      if (window === size) return { last: void 0, partial };
+      window = Math.min(size, window * 4);
+    }
+  } finally {
+    await handle.close();
   }
 }
-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));
+function parseJsonlTolerant(text) {
+  const rows = [];
+  let unreadable = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row === null || typeof row !== "object" || Array.isArray(row)) {
+        unreadable += 1;
+        continue;
+      }
+      rows.push(row);
+    } catch {
+      unreadable += 1;
     }
-  });
-  stream.on("end", () => {
-    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
-  });
+  }
+  return { rows, unreadable };
 }
-
-// src/local-runtime/package-root.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname3, resolve as resolve5 } 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) => existsSync2(resolve5(candidate, "package.json")) && existsSync2(resolve5(candidate, "training/adapter"))
-  );
-  if (!root) {
-    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+function buildTimeline(events) {
+  const timeline = [];
+  for (const event of events) {
+    const last2 = timeline.at(-1);
+    if (last2 && last2.stage === event.stage) {
+      last2.status = event.status;
+      last2.message = event.message;
+      continue;
+    }
+    if (last2) {
+      last2.ended_at = event.occurred_at;
+      last2.duration_seconds = Math.max(0, (Date.parse(event.occurred_at) - Date.parse(last2.started_at)) / 1e3);
+    }
+    timeline.push({
+      stage: event.stage,
+      status: event.status,
+      message: event.message,
+      started_at: event.occurred_at,
+      ended_at: null,
+      duration_seconds: null
+    });
   }
-  return root;
+  const last = timeline.at(-1);
+  if (last && ["completed", "failed", "cancelled", "stage_completed"].includes(last.stage)) {
+    last.ended_at = last.started_at;
+    last.duration_seconds = 0;
+  }
+  return timeline;
+}
+async function auditRun(store, runId) {
+  const state = await store.getRun(runId);
+  const log = await store.getRunEventLog(state.id);
+  const events = log.events;
+  const chain = verifyEventChain(events);
+  const completion = [...events].reverse().find((event) => event.stage === "completed");
+  const recorded = typeof completion?.details?.report_sha256 === "string" ? completion.details.report_sha256 : null;
+  const recordedManifest = typeof completion?.details?.artifact_manifest_sha256 === "string" ? completion.details.artifact_manifest_sha256 : null;
+  const files = await Promise.all((await store.getRunReportPaths(state.id)).map(async (path) => {
+    const sha256 = await sha256File2(path);
+    return { path, sha256, matches_recorded: recorded ? sha256 === recorded : null };
+  }));
+  const manifestPath = state.artifact_dir ? join3(state.artifact_dir, "artifact-manifest.json") : null;
+  const manifestFile = manifestPath && (await stat3(manifestPath).catch(() => null))?.isFile() ? await sha256File2(manifestPath).then((sha256) => ({
+    path: manifestPath,
+    sha256,
+    matches_recorded: recordedManifest ? sha256 === recordedManifest : null
+  })) : null;
+  const report = await store.getRunReport(state.id).catch(() => null);
+  const findings = [];
+  let verdict = "verified";
+  const tampered = (finding) => {
+    findings.push(finding);
+    verdict = "tampered";
+  };
+  const incomplete = (finding) => {
+    findings.push(finding);
+    if (verdict === "verified") verdict = "incomplete";
+  };
+  const completed = state.status === "completed";
+  if (chain.status === "broken") {
+    tampered(`Event log chain is broken at event ${chain.break.index}: ${chain.break.reason}`);
+  } else if (chain.status === "empty") {
+    if (completed) tampered("The run is completed but its event log is missing or empty.");
+    else incomplete("The run has no events.");
+  } else if (chain.status === "legacy") {
+    incomplete(`${chain.legacy_events} event(s) were recorded before event chaining (older TT version) and cannot be verified.`);
+  } else if (chain.status === "mixed") {
+    incomplete(`${chain.unchained_after_chain} event(s) were written without hashes after chaining began, e.g. by an older TT process.`);
+  }
+  if (log.unreadable_lines > 0) incomplete(`${log.unreadable_lines} event line(s) are unreadable, likely from an interrupted write.`);
+  for (const file of files) {
+    if (file.matches_recorded === false) {
+      tampered(`Report ${file.path} changed after the run completed (sha256 ${file.sha256.slice(0, 12)}, recorded ${recorded.slice(0, 12)}).`);
+    }
+  }
+  if (manifestFile?.matches_recorded === false) {
+    tampered(`Artifact manifest ${manifestFile.path} changed after the run completed.`);
+  }
+  if (!completed) {
+    incomplete(`The run is ${state.status}; only completed runs have recorded report digests.`);
+  } else if (!recorded) {
+    if (chain.status === "verified") tampered("The completion event is missing from a chained event log; the log was truncated.");
+    else if (chain.status !== "broken" && chain.status !== "empty") incomplete("No report digest was recorded at completion (older TT version).");
+  } else if (files.length === 0) {
+    incomplete("The recorded report file is missing.");
+  }
+  if (completed && recordedManifest && !manifestFile) incomplete("The artifact manifest recorded at completion is missing.");
+  if (completed && report && !report.provenance) incomplete("The report has no provenance block (older TT version).");
+  return {
+    run_id: state.id,
+    status: state.status,
+    verdict,
+    findings,
+    chain: { ...chain, unreadable_lines: log.unreadable_lines },
+    report: { recorded_sha256: recorded, files },
+    artifact_manifest: { recorded_sha256: recordedManifest, file: manifestFile },
+    timeline: buildTimeline(events),
+    provenance: report?.provenance ?? null
+  };
 }
 
 // src/local-runtime/store.ts
-import { appendFile, chmod, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir3, readdir as readdir3, readFile as readFile4, rename as rename2, rm, stat as stat3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4, join as join3, resolve as resolve6, sep as sep3 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { appendFile, chmod, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir4, readdir as readdir3, readFile as readFile5, rename as rename3, rm as rm2, stat as stat4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join4, resolve as resolve6, sep as sep3 } from "path";
+import { randomUUID as randomUUID4 } 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);
 }
@@ -2013,22 +2618,22 @@ function defaultLocalHome() {
 function localStorePaths(root) {
   return {
     root,
-    specsDir: join3(root, "specs"),
-    runsDir: join3(root, "runs"),
-    modelsDir: join3(root, "models"),
-    datasetsDir: join3(root, "datasets")
+    specsDir: join4(root, "specs"),
+    runsDir: join4(root, "runs"),
+    modelsDir: join4(root, "models"),
+    datasetsDir: join4(root, "datasets")
   };
 }
 async function exists2(path) {
   try {
-    await stat3(path);
+    await stat4(path);
     return true;
   } catch {
     return false;
   }
 }
 async function ensurePrivateDirectory(path) {
-  await mkdir3(path, { recursive: true, mode: 448 });
+  await mkdir4(path, { recursive: true, mode: 448 });
   const metadata = await lstat3(path);
   if (metadata.isSymbolicLink()) {
     throw new Error(`Refusing symbolic link in local store: ${path}`);
@@ -2046,7 +2651,7 @@ async function hardenPrivateTree(path) {
   if (metadata.isDirectory()) {
     await chmod(path, 448);
     for (const entry of await readdir3(path)) {
-      await hardenPrivateTree(join3(path, entry));
+      await hardenPrivateTree(join4(path, entry));
     }
     return;
   }
@@ -2076,17 +2681,17 @@ async function hardenExistingLocalStore(root) {
 }
 async function writePrivateJsonAtomic(path, value) {
   await ensurePrivateDirectory(dirname4(path));
-  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID3()}.tmp`;
-  await writeFile3(tmp, `${JSON.stringify(value, null, 2)}
+  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID4()}.tmp`;
+  await writeFile4(tmp, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
   });
-  await rename2(tmp, path);
+  await rename3(tmp, path);
   await chmod(path, 384);
 }
 async function readJson2(path) {
-  return JSON.parse(await readFile4(path, "utf8"));
+  return JSON.parse(await readFile5(path, "utf8"));
 }
 async function appendJsonl(path, value) {
   await ensurePrivateDirectory(dirname4(path));
@@ -2099,13 +2704,9 @@ async function appendJsonl(path, value) {
 }
 async function writePrivateText(path, value) {
   await ensurePrivateDirectory(dirname4(path));
-  await writeFile3(path, value, { encoding: "utf8", mode: 384 });
+  await writeFile4(path, value, { encoding: "utf8", mode: 384 });
   await chmod(path, 384);
 }
-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 ensurePrivateDirectory(dirname4(to));
@@ -2144,15 +2745,15 @@ function isPathInside(root, candidate) {
 function createLocalStore(root = defaultLocalHome()) {
   const resolvedRoot = resolve6(root);
   const paths = localStorePaths(resolvedRoot);
-  const runDir = (id) => join3(paths.runsDir, id);
-  const runStatePath = (id) => join3(runDir(id), "state.json");
-  const runEventsPath = (id) => join3(runDir(id), "progress.jsonl");
-  const runRequestPath = (id) => join3(runDir(id), "request.json");
-  const runReportPath = (id) => join3(runDir(id), "run-report.json");
-  const cancellationPath = (id) => join3(runDir(id), "cancel.requested");
-  const specDir = (id) => join3(paths.specsDir, id);
-  const specPath = (id) => join3(specDir(id), "spec.json");
-  const modelPath = (id) => join3(paths.modelsDir, id, "model.json");
+  const runDir = (id) => join4(paths.runsDir, id);
+  const runStatePath = (id) => join4(runDir(id), "state.json");
+  const runEventsPath = (id) => join4(runDir(id), "progress.jsonl");
+  const runRequestPath = (id) => join4(runDir(id), "request.json");
+  const runReportPath = (id) => join4(runDir(id), "run-report.json");
+  const cancellationPath = (id) => join4(runDir(id), "cancel.requested");
+  const specDir = (id) => join4(paths.specsDir, id);
+  const specPath = (id) => join4(specDir(id), "spec.json");
+  const modelPath = (id) => join4(paths.modelsDir, id, "model.json");
   let ensurePromise;
   async function ensureOnce() {
     await ensurePrivateDirectory(paths.root);
@@ -2180,8 +2781,8 @@ function createLocalStore(root = defaultLocalHome()) {
     if (!await exists2(path)) return null;
     const [spec, fileStats, directoryStats] = await Promise.all([
       readJson2(path),
-      stat3(path),
-      stat3(specDir(id))
+      stat4(path),
+      stat4(specDir(id))
     ]);
     const createdAt = directoryStats.birthtimeMs > 0 ? directoryStats.birthtime : directoryStats.ctime;
     return {
@@ -2228,15 +2829,30 @@ function createLocalStore(root = defaultLocalHome()) {
     if (!record) throw new Error(`Failed to persist spec: ${specId}`);
     return record;
   }
+  async function readRunEventLog(id) {
+    const state = await getRun(id);
+    const path = runEventsPath(state.id);
+    if (!await exists2(path)) return { events: [], unreadable_lines: 0 };
+    const parsed = parseJsonlTolerant(await readFile5(path, "utf8"));
+    return { events: parsed.rows, unreadable_lines: parsed.unreadable };
+  }
   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(join3(state.artifact_dir, "progress.jsonl"), {
+    const path = runEventsPath(state.id);
+    await ensurePrivateDirectory(dirname4(path));
+    const row = await withAppendLock(`${path}.lock`, async () => {
+      const { partial } = await readJsonlTail(path);
+      const { last: previous } = await readJsonlTail(path, (row2) => typeof row2.hash === "string");
+      if (partial) await appendFile(path, "\n", { encoding: "utf8", mode: 384 });
+      const chained = chainEvent({
+        id: randomUUID4(),
+        run_id: state.id,
+        occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
+        ...event
+      }, previous);
+      await appendJsonl(path, chained);
+      return chained;
+    });
+    await appendJsonl(join4(state.artifact_dir, "progress.jsonl"), {
       at: row.occurred_at,
       stage: row.stage,
       status: row.status,
@@ -2267,8 +2883,8 @@ function createLocalStore(root = defaultLocalHome()) {
     const previous = await getRun(runId);
     if (isTerminalRunState(previous)) return previous;
     await Promise.all([
-      rm(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
-      rm(runReportPath(previous.id), { force: true })
+      rm2(join4(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
+      rm2(runReportPath(previous.id), { force: true })
     ]);
     if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
     const requested = {
@@ -2434,7 +3050,7 @@ function createLocalStore(root = defaultLocalHome()) {
         createdAt: completedAt
       });
       if (!model) {
-        await rm(join3(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+        await rm2(join4(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
       }
       const previous = await getRun(report.run_id);
       const state = {
@@ -2455,20 +3071,27 @@ function createLocalStore(root = defaultLocalHome()) {
       if (await exists2(cancellationPath(report.run_id))) {
         return preserveCancellationRequestState(report.run_id);
       }
+      const manifestPath = join4(artifactDir, "artifact-manifest.json");
       await appendRunEvent(state, {
         stage: "completed",
         status: "completed",
         message: "Run completed successfully.",
-        details: { report_path: reportPath, ...model ? { model_id: model.id } : {} }
+        details: {
+          report_path: reportPath,
+          // Pin the published evidence: `tt runs audit` re-hashes these files.
+          report_sha256: await sha256File2(runReportPath(report.run_id)),
+          ...await exists2(manifestPath) ? { artifact_manifest_sha256: await sha256File2(manifestPath) } : {},
+          ...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.report) await rm2(runReportPath(previous.id), { force: true });
       if (options.model) {
-        await rm(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
+        await rm2(join4(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
       }
       const state = {
         ...previous,
@@ -2511,7 +3134,7 @@ function createLocalStore(root = defaultLocalHome()) {
 `);
       const latest = await getRun(state.id);
       if (isTerminalRunState(latest)) {
-        if (latest.status !== "cancelled") await rm(cancellationPath(state.id), { force: true });
+        if (latest.status !== "cancelled") await rm2(cancellationPath(state.id), { force: true });
         return;
       }
       const updated = {
@@ -2538,8 +3161,23 @@ function createLocalStore(root = defaultLocalHome()) {
     },
     getRun,
     async getRunEvents(id) {
+      return (await readRunEventLog(id)).events;
+    },
+    getRunEventLog: readRunEventLog,
+    async getRunReportPaths(id) {
       const state = await getRun(id);
-      return readJsonl(runEventsPath(state.id));
+      const candidates = [];
+      if (state.report_path) {
+        const reportPath = resolve6(state.report_path);
+        const allowedRoots = [resolvedRoot, ...state.artifact_dir ? [resolve6(state.artifact_dir)] : []];
+        if (allowedRoots.some((allowed) => isPathInside(allowed, reportPath))) candidates.push(reportPath);
+      }
+      candidates.push(runReportPath(state.id));
+      const existing = [];
+      for (const path of new Set(candidates)) {
+        if ((await lstat3(path).catch(() => null))?.isFile()) existing.push(path);
+      }
+      return existing;
     },
     async getRunReport(id) {
       const state = await getRun(id);
@@ -2570,38 +3208,216 @@ function createLocalStore(root = defaultLocalHome()) {
 }
 
 // src/local-runtime/prefetch.ts
-import { createHash as createHash4 } from "crypto";
-import { createReadStream as createReadStream2 } from "fs";
-import { lstat as lstat4, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join6, relative as relative3, resolve as resolve9, sep as sep4 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { createReadStream as createReadStream3 } from "fs";
+import { lstat as lstat4, mkdir as mkdir6, readFile as readFile6, readdir as readdir4, realpath as realpath2, stat as stat5 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join7, relative as relative3, resolve as resolve9, sep as sep4 } from "path";
 
 // src/local-runtime/process-runner.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { spawn } from "child_process";
 import { constants, readFileSync } from "fs";
-import { mkdir as mkdir4, open as open2 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve7 } from "path";
+import { mkdir as mkdir5, open as open3 } from "fs/promises";
+import { dirname as dirname5, join as join5, resolve as resolve7 } from "path";
+
+// src/local-runtime/progress-bar.ts
+var PROGRESS_PREFIX = "@@tt-progress ";
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+function parseProgressLine(line) {
+  const start = line.indexOf(PROGRESS_PREFIX);
+  if (start !== 0) return null;
+  let value;
+  try {
+    value = JSON.parse(line.slice(PROGRESS_PREFIX.length));
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  const completed = nonNegativeInteger(record.completed_bytes);
+  const total = nonNegativeInteger(record.total_bytes);
+  if (completed === null || total === null) return null;
+  return {
+    label: typeof record.label === "string" ? record.label : "download",
+    phase: typeof record.phase === "string" ? record.phase : "download",
+    completed_bytes: completed,
+    total_bytes: total,
+    files_completed: nonNegativeInteger(record.files_completed) ?? 0,
+    files_total: nonNegativeInteger(record.files_total) ?? 0
+  };
+}
+function formatBytes(bytes) {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${unit === 0 ? value.toFixed(0) : value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[unit]}`;
+}
+function formatDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "--";
+  const whole = Math.round(seconds);
+  const hours = Math.floor(whole / 3600);
+  const minutes = Math.floor(whole % 3600 / 60);
+  const rest = whole % 60;
+  if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m ${String(rest).padStart(2, "0")}s`;
+  return `${rest}s`;
+}
+var RateTracker = class {
+  constructor(windowMs = 15e3) {
+    this.windowMs = windowMs;
+  }
+  samples = [];
+  add(at, bytes) {
+    const last = this.samples.at(-1);
+    if (last && bytes < last.bytes) this.samples = [];
+    this.samples.push({ at, bytes });
+    while (this.samples.length > 2 && at - this.samples[0].at > this.windowMs) this.samples.shift();
+  }
+  bytesPerSecond() {
+    const first = this.samples[0];
+    const last = this.samples.at(-1);
+    if (!first || !last || last.at - first.at < 500) return null;
+    return (last.bytes - first.bytes) / ((last.at - first.at) / 1e3);
+  }
+};
+function formatProgressLine(progress, rate, columns) {
+  const total = progress.total_bytes;
+  const fraction = total > 0 ? Math.min(1, progress.completed_bytes / total) : 1;
+  const fields = [
+    { text: `${(fraction * 100).toFixed(1).padStart(5)}%` },
+    { text: `${formatBytes(progress.completed_bytes)} / ${formatBytes(total)}` }
+  ];
+  const done = progress.completed_bytes >= total;
+  if (!done && rate !== null && rate > 0) {
+    fields.push(
+      { text: `${formatBytes(rate)}/s`, drop: 2 },
+      { text: `ETA ${formatDuration((total - progress.completed_bytes) / rate)}`, drop: 3 }
+    );
+  }
+  if (progress.files_total > 0) fields.push({ text: `${progress.files_completed}/${progress.files_total} files`, drop: 1 });
+  const prefix = `[tt] ${progress.label}: `;
+  const join16 = () => fields.map((field) => field.text).join("  ");
+  if (columns === void 0) return `${prefix}${join16()}`;
+  for (const rank of [1, 2, 3]) {
+    if (prefix.length + join16().length <= columns - 1) break;
+    const index = fields.findIndex((field) => field.drop === rank);
+    if (index !== -1) fields.splice(index, 1);
+  }
+  const text = join16();
+  const barWidth = Math.min(30, columns - 1 - prefix.length - text.length - 3);
+  if (barWidth < 10) return `${prefix}${text}`.slice(0, Math.max(0, columns - 1));
+  const filled = Math.round(fraction * barWidth);
+  return `${prefix}[${"#".repeat(filled)}${"-".repeat(barWidth - filled)}] ${text}`;
+}
+function createProgressRenderer(options) {
+  const now = options.now ?? (() => Date.now());
+  const rates = /* @__PURE__ */ new Map();
+  const lastLine = /* @__PURE__ */ new Map();
+  const completed = /* @__PURE__ */ new Set();
+  let drawn = false;
+  let lastDraw = Number.NEGATIVE_INFINITY;
+  const finished = (progress) => progress.phase === "downloaded" || progress.total_bytes > 0 && progress.completed_bytes >= progress.total_bytes;
+  return {
+    update(progress) {
+      const at = now();
+      const tracker = rates.get(progress.label) ?? new RateTracker();
+      rates.set(progress.label, tracker);
+      tracker.add(at, progress.completed_bytes);
+      const done = finished(progress);
+      if (options.tty) {
+        if (done && completed.has(progress.label)) return;
+        if (!done) completed.delete(progress.label);
+        if (!done && at - lastDraw < 100) return;
+        lastDraw = at;
+        const line = formatProgressLine(progress, tracker.bytesPerSecond(), Math.max(40, options.columns ?? 80));
+        options.write(`\r\x1B[2K${line}${done ? "\n" : ""}`);
+        drawn = !done;
+        if (done) {
+          rates.delete(progress.label);
+          completed.add(progress.label);
+        }
+        return;
+      }
+      const fraction = progress.total_bytes > 0 ? progress.completed_bytes / progress.total_bytes : 1;
+      const decile = Math.floor(fraction * 10);
+      const previous = lastLine.get(progress.label);
+      const interval = options.lineIntervalMs ?? 3e4;
+      if (previous && !done && decile <= previous.decile && at - previous.at < interval) return;
+      if (previous && done && previous.decile === 10) return;
+      lastLine.set(progress.label, { at, decile: done ? 10 : decile });
+      options.write(`${formatProgressLine(progress, tracker.bytesPerSecond())}
+`);
+    },
+    interrupt() {
+      if (!drawn) return;
+      options.write("\r\x1B[2K");
+      drawn = false;
+    }
+  };
+}
+function progressTty(env = process.env, stream = process.stderr) {
+  if (env.TT_PROGRESS_TTY === "0") return false;
+  return env.TT_PROGRESS_TTY === "1" || Boolean(stream.isTTY);
+}
+function progressColumns(env = process.env, stream = process.stderr) {
+  const hinted = Number(env.TT_PROGRESS_COLUMNS);
+  if (Number.isInteger(hinted) && hinted > 0) return hinted;
+  return stream.columns;
+}
+
+// src/local-runtime/process-runner.ts
 var packageRoot = localRuntimePackageRoot(import.meta.url);
-var bundledProject = join4(packageRoot, "training/adapter");
+var bundledProject = join5(packageRoot, "training/adapter");
 var bundledRuntimeHash = (() => {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join4(bundledProject, name)));
+    hash.update(readFileSync(join5(bundledProject, name)));
   }
   return hash.digest("hex").slice(0, 20);
 })();
 var BUNDLED_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv", bundledRuntimeHash);
-var foundationProject = join4(packageRoot, "training/foundation");
+var foundationProject = join5(packageRoot, "training/foundation");
 var foundationRuntimeHash = (() => {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join4(foundationProject, name)));
+    hash.update(readFileSync(join5(foundationProject, name)));
   }
   return hash.digest("hex").slice(0, 20);
 })();
 var FOUNDATION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-foundation", foundationRuntimeHash);
+var decisionProject = join5(packageRoot, "training/decision");
+var decisionRuntimeHash = (() => {
+  const hash = createHash4("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join5(decisionProject, name)));
+  }
+  return hash.digest("hex").slice(0, 20);
+})();
+var DECISION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-decision", decisionRuntimeHash);
+function buildDecisionPythonCommand(entrypoint, args = []) {
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--quiet",
+    "--project",
+    decisionProject,
+    "python",
+    join5(decisionProject, "src", entrypoint),
+    ...args
+  ];
+  return { command: "uv", commandArgs, displayCommand: ["uv", ...commandArgs] };
+}
+function withDecisionPythonEnvironment(env) {
+  return { ...env, UV_PROJECT_ENVIRONMENT: DECISION_PYTHON_ENVIRONMENT };
+}
 function buildBundledPythonCommand(entrypoint, args = []) {
-  const target = entrypoint === "-c" ? entrypoint : join4(bundledProject, "src", entrypoint);
+  const target = entrypoint === "-c" ? entrypoint : join5(bundledProject, "src", entrypoint);
   const commandArgs = [
     "run",
     "--frozen",
@@ -2625,7 +3441,7 @@ function withBundledPythonEnvironment(env) {
   };
 }
 function buildFoundationPythonCommand(entrypoint, args = []) {
-  const target = entrypoint === "-c" ? entrypoint : join4(foundationProject, "src", entrypoint);
+  const target = entrypoint === "-c" ? entrypoint : join5(foundationProject, "src", entrypoint);
   const commandArgs = [
     "run",
     "--frozen",
@@ -2656,7 +3472,7 @@ var ProcessCancelledError = class extends Error {
 };
 async function openProcessLog(path, exclusive, append) {
   const flags = constants.O_WRONLY | constants.O_CREAT | (exclusive ? constants.O_EXCL : append ? constants.O_APPEND : constants.O_TRUNC) | (process.platform === "win32" ? 0 : constants.O_NOFOLLOW);
-  const handle = await open2(path, flags, 384);
+  const handle = await open3(path, flags, 384);
   try {
     return handle.createWriteStream({ autoClose: true });
   } catch (error) {
@@ -2665,7 +3481,7 @@ async function openProcessLog(path, exclusive, append) {
   }
 }
 async function runLoggedProcess(args) {
-  if (args.logPath) await mkdir4(dirname5(args.logPath), { recursive: true });
+  if (args.logPath) await mkdir5(dirname5(args.logPath), { recursive: true });
   const logStream = args.logPath ? await openProcessLog(args.logPath, args.exclusiveLog ?? false, args.appendLog ?? false) : null;
   let stderr = "";
   try {
@@ -2739,6 +3555,11 @@ async function runLoggedProcess(args) {
         child.stderr.pipe(logStream, { end: false });
       }
       forwardStreamLines(child.stdout, (line) => {
+        const progress = parseProgressLine(line);
+        if (progress) {
+          reportInBackground(() => args.reporter?.onProgress?.(progress));
+          return;
+        }
         args.onLine?.(line, "stdout");
         if (args.reporter?.verbose) {
           reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stdout", message: line }));
@@ -2788,7 +3609,7 @@ async function runLoggedProcess(args) {
 
 // src/local-runtime/huggingface-cache.ts
 import { homedir as homedir3 } from "os";
-import { dirname as dirname6, join as join5, resolve as resolve8 } from "path";
+import { dirname as dirname6, join as join6, resolve as resolve8 } from "path";
 function minimalMachineLearningEnvironment(env) {
   const exact = /* @__PURE__ */ new Set([
     "PATH",
@@ -2820,6 +3641,9 @@ function minimalMachineLearningEnvironment(env) {
     "HF_HUB_DISABLE_TELEMETRY",
     "TRANSFORMERS_OFFLINE",
     "HF_HUB_ENABLE_HF_TRANSFER",
+    "HF_HUB_DOWNLOAD_TIMEOUT",
+    "HF_HUB_ETAG_TIMEOUT",
+    "TT_HF_DOWNLOAD_MAX_ATTEMPTS",
     "PYTHONUTF8",
     "PYTHONIOENCODING"
   ]);
@@ -2845,12 +3669,12 @@ function resolveHuggingFaceCacheLayout(modelCache) {
   const hfHome = resolve8(modelCache);
   return {
     hfHome,
-    hubCache: join5(hfHome, "hub")
+    hubCache: join6(hfHome, "hub")
   };
 }
 function withHuggingFaceCacheEnvironment(env, modelCache) {
   const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
-  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve8(inheritedHub)) : join5(homedir3(), ".cache", "huggingface"));
+  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve8(inheritedHub)) : join6(homedir3(), ".cache", "huggingface"));
   const layout = resolveHuggingFaceCacheLayout(canonicalHome);
   const result = {
     ...env,
@@ -2930,10 +3754,10 @@ function certifiedFileDigests(modelId) {
   }
 }
 async function certifiedFileDigest(path, expected) {
-  const metadata = await stat4(path);
-  const digest = createHash4(expected.algorithm);
+  const metadata = await stat5(path);
+  const digest = createHash5(expected.algorithm);
   if (expected.algorithm === "sha1") digest.update(`blob ${metadata.size}\0`);
-  for await (const chunk of createReadStream2(path)) digest.update(chunk);
+  for await (const chunk of createReadStream3(path)) digest.update(chunk);
   return digest.digest("hex");
 }
 function isStrictPhysicalDescendant(parent, child) {
@@ -2943,8 +3767,8 @@ function isStrictPhysicalDescendant(parent, child) {
 async function verifySnapshotCacheLocation(path, modelId, revision, modelCache) {
   const repository = `models--${modelId.replaceAll("/", "--")}`;
   const layout = resolveHuggingFaceCacheLayout(modelCache);
-  const repositoryRoot = join6(layout.hubCache, repository);
-  const expectedPath = join6(repositoryRoot, "snapshots", revision);
+  const repositoryRoot = join7(layout.hubCache, repository);
+  const expectedPath = join7(repositoryRoot, "snapshots", revision);
   const [
     physicalCacheRoot,
     physicalHubRoot,
@@ -2956,7 +3780,7 @@ async function verifySnapshotCacheLocation(path, modelId, revision, modelCache)
     realpath2(layout.hfHome).catch(() => null),
     realpath2(layout.hubCache).catch(() => null),
     realpath2(repositoryRoot).catch(() => null),
-    realpath2(join6(repositoryRoot, "blobs")).catch(() => null),
+    realpath2(join7(repositoryRoot, "blobs")).catch(() => null),
     realpath2(path).catch(() => null),
     realpath2(expectedPath).catch(() => null)
   ]);
@@ -2972,7 +3796,7 @@ async function verifySnapshotCacheLocation(path, modelId, revision, modelCache)
     throw new Error(`Hugging Face repository escapes its configured hub cache: ${repositoryRoot}`);
   }
   if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalBlobRoot)) {
-    throw new Error(`Hugging Face blob store escapes its repository: ${join6(repositoryRoot, "blobs")}`);
+    throw new Error(`Hugging Face blob store escapes its repository: ${join7(repositoryRoot, "blobs")}`);
   }
   if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalExpectedPath)) {
     throw new Error(`Hugging Face snapshot escapes its configured repository: ${expectedPath}`);
@@ -3034,13 +3858,13 @@ async function verifyCertifiedLocalSnapshot(path, modelId, snapshotFiles, modelC
   const expectedFiles = new Set(Object.keys(digests));
   const unexpected = [...actualFiles].filter((name) => !expectedFiles.has(name)).sort();
   if (unexpected.length > 0) {
-    throw new Error(`Certified snapshot contains unexpected file: ${join6(path, unexpected[0])}`);
+    throw new Error(`Certified snapshot contains unexpected file: ${join7(path, unexpected[0])}`);
   }
   for (const [name, expected] of Object.entries(digests)) {
     if (!actualFiles.has(name)) {
-      throw new Error(`Certified snapshot file is missing: ${join6(path, name)}`);
+      throw new Error(`Certified snapshot file is missing: ${join7(path, name)}`);
     }
-    const file = join6(path, name);
+    const file = join7(path, name);
     const physicalFile = physicalFiles.get(file);
     if (await certifiedFileDigest(physicalFile, expected) !== expected.digest) {
       throw new Error(`Certified snapshot file checksum mismatch: ${file}`);
@@ -3083,9 +3907,9 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
-      const child = join6(directory, entry.name);
+      const child = join7(directory, entry.name);
       if (entry.isSymbolicLink()) {
-        const metadata2 = await stat4(child);
+        const metadata2 = await stat5(child);
         if (!metadata2.isFile()) {
           throw new Error(`Local base model contains a non-file symbolic link: ${child}`);
         }
@@ -3096,7 +3920,7 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
         await visit(child);
         continue;
       }
-      const metadata = await stat4(child);
+      const metadata = await stat5(child);
       if (metadata.isFile()) files.push({ path: child, size: metadata.size });
     }
   };
@@ -3107,15 +3931,15 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
     throw new Error(`Local base-model directory contains no non-empty Transformers model weights: ${path}`);
   }
   const required = async (name) => {
-    const metadata = await stat4(join6(path, name)).catch(() => null);
+    const metadata = await stat5(join7(path, name)).catch(() => null);
     return Boolean(metadata?.isFile() && metadata.size > 0);
   };
   if (!await required("config.json")) throw new Error(`Local base-model directory is missing config.json: ${path}`);
   try {
-    const config = JSON.parse(await readFile5(join6(path, "config.json"), "utf8"));
+    const config = JSON.parse(await readFile6(join7(path, "config.json"), "utf8"));
     assertCertifiedBaseModelConfig(
       config,
-      `Local base-model config ${join6(path, "config.json")}`,
+      `Local base-model config ${join7(path, "config.json")}`,
       expectedModelId
     );
   } catch (error) {
@@ -3144,13 +3968,17 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
   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}`);
   }
+  const inventory = new Set(nonEmpty.map((file) => resolve9(file.path)));
   for (const file of files.filter((candidate) => candidate.path.endsWith(".index.json"))) {
-    const parsed = JSON.parse(await readFile5(file.path, "utf8"));
+    const parsed = JSON.parse(await readFile6(file.path, "utf8"));
     if (!parsed.weight_map || typeof parsed.weight_map !== "object" || Array.isArray(parsed.weight_map)) {
       throw new Error(`Local base-model weight index is invalid: ${file.path}`);
     }
     for (const shard of new Set(Object.values(parsed.weight_map))) {
-      if (typeof shard !== "string" || !await required(shard)) {
+      if (typeof shard !== "string" || !shard || /^(?:[A-Za-z]:|[/\\])/.test(shard) || shard.split(/[/\\]/).includes("..")) {
+        throw new Error("Local base-model weight index has an invalid indexed weight shard path");
+      }
+      if (!inventory.has(resolve9(path, shard)) || !await required(shard)) {
         throw new Error(`Local base-model directory is missing indexed weight shard: ${String(shard)}`);
       }
     }
@@ -3170,7 +3998,7 @@ async function prefetchBaseModel(args) {
     args.localOnly ? "verify-base" : "prefetch",
     `${safeName(args.request.spec_snapshot.base_model)}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`
   );
-  await mkdir5(artifactDir, { recursive: true });
+  await mkdir6(artifactDir, { recursive: true });
   if (args.config.paths.baseModel) {
     const localPath = resolve9(args.config.paths.baseModel);
     const verified = await verifyLocalBaseModel(
@@ -3189,9 +4017,9 @@ async function prefetchBaseModel(args) {
       reason: args.localOnly ? "Verified the configured local base-model artifact; no network access was used." : "paths.baseModel points at a verified local base-model artifact; no Hugging Face download is needed."
     };
   }
-  const inputPath = join6(artifactDir, "prefetch-input.json");
-  const outputPath = join6(artifactDir, "prefetch-output.json");
-  const logPath = join6(artifactDir, "prefetch.log");
+  const inputPath = join7(artifactDir, "prefetch-input.json");
+  const outputPath = join7(artifactDir, "prefetch-output.json");
+  const logPath = join7(artifactDir, "prefetch.log");
   await writeJson(inputPath, payload);
   const entrypoint = buildBundledPythonCommand(
     "prefetch.py",
@@ -3228,7 +4056,7 @@ async function prefetchBaseModel(args) {
   if (exitCode !== 0) {
     throw new Error(`Model prefetch exited with code ${exitCode}. See ${logPath}.`);
   }
-  const output = JSON.parse(await readFile5(outputPath, "utf8"));
+  const output = JSON.parse(await readFile6(outputPath, "utf8"));
   const snapshotRevision = baseModelRevisionSchema.safeParse(output.snapshot_revision);
   if (!snapshotRevision.success) {
     throw new Error(
@@ -3291,6 +4119,346 @@ async function prefetchBaseModel(args) {
   };
 }
 
+// src/local-runtime/dataset-prefetch.ts
+import { createHash as createHash6 } from "crypto";
+import { createReadStream as createReadStream4 } from "fs";
+import { mkdir as mkdir7, readFile as readFile7, realpath as realpath3, stat as stat6 } from "fs/promises";
+import { createInterface } from "readline";
+import { basename, isAbsolute as isAbsolute5, join as join8, relative as relative4, resolve as resolve10, sep as sep5 } from "path";
+var SPLITS = ["training", "validation", "test"];
+var DatasetNotDownloadedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DatasetNotDownloadedError";
+  }
+};
+function huggingFaceDataset(request) {
+  const dataset = request.dataset_prebuilt;
+  return dataset?.huggingface ? dataset : void 0;
+}
+function datasetFiles(dataset) {
+  const files = {};
+  for (const split of SPLITS) if (dataset[split]) files[split] = dataset[split];
+  return files;
+}
+function huggingFaceHubCache(modelCache) {
+  return withHuggingFaceCacheEnvironment(process.env, modelCache).HF_HUB_CACHE;
+}
+function repositoryDirectory(hubCache, repo) {
+  return join8(hubCache, `datasets--${repo.replaceAll("/", "--")}`);
+}
+function isStrictDescendant(parent, child) {
+  const path = relative4(parent, child);
+  return path !== "" && path !== ".." && !path.startsWith(`..${sep5}`) && !isAbsolute5(path);
+}
+async function digestFile(path, size) {
+  const sha256 = createHash6("sha256");
+  const gitSha1 = createHash6("sha1").update(`blob ${size}\0`);
+  for await (const chunk of createReadStream4(path)) {
+    sha256.update(chunk);
+    gitSha1.update(chunk);
+  }
+  return { sha256: sha256.digest("hex"), gitSha1: gitSha1.digest("hex") };
+}
+function describe(dataset) {
+  return `${dataset.repo}@${dataset.revision ?? "main"}`;
+}
+async function resolveCachedHuggingFaceDataset(args) {
+  const source = args.dataset.huggingface;
+  const hubCache = huggingFaceHubCache(args.modelCache);
+  const repository = repositoryDirectory(hubCache, source.repo);
+  const prefetchHint = "Run `tt datasets prefetch` with this spec (for example `tt datasets prefetch tunedtensor.json`) to download it.";
+  let revision = source.revision;
+  if (!revision) {
+    const ref = await readFile7(join8(repository, "refs", "main"), "utf8").catch(() => null);
+    const parsed = baseModelRevisionSchema.safeParse(ref?.trim());
+    if (!parsed.success) {
+      throw new DatasetNotDownloadedError(
+        `Hugging Face dataset ${describe(source)} is not in the local cache (${hubCache}). ${prefetchHint}`
+      );
+    }
+    revision = parsed.data;
+  }
+  const snapshot = join8(repository, "snapshots", revision);
+  const physicalRepository = await realpath3(repository).catch(() => null);
+  const blobs = physicalRepository ? join8(physicalRepository, "blobs") : null;
+  const files = {};
+  const localPaths = {};
+  for (const [split, path] of Object.entries(datasetFiles(args.dataset))) {
+    const local = join8(snapshot, ...path.split(/[/\\]/));
+    const metadata = await stat6(local).catch(() => null);
+    if (!metadata || !physicalRepository || !blobs) {
+      throw new DatasetNotDownloadedError(
+        `Hugging Face dataset file ${path} (${split}) from ${source.repo}@${revision} is not in the local cache (${hubCache}). ${prefetchHint}`
+      );
+    }
+    const target = await realpath3(local);
+    if (!metadata.isFile() || !isStrictDescendant(physicalRepository, target)) {
+      throw new Error(`Cached dataset file ${local} must resolve inside its Hugging Face cache repository ${physicalRepository}.`);
+    }
+    if (metadata.size === 0) throw new Error(`Cached dataset file ${path} (${split}) is empty: ${local}`);
+    const digests = await digestFile(target, metadata.size);
+    const blobName = isStrictDescendant(blobs, target) ? basename(target).toLowerCase() : "";
+    const expected = /^[0-9a-f]{64}$/.test(blobName) ? digests.sha256 : /^[0-9a-f]{40}$/.test(blobName) ? digests.gitSha1 : null;
+    if (expected !== null && expected !== blobName) {
+      throw new Error(
+        `Cached dataset file ${path} (${split}) failed its checksum (${local}). Delete ${target} and run \`tt datasets prefetch\` again.`
+      );
+    }
+    files[split] = { path, size_bytes: metadata.size, sha256: digests.sha256 };
+    localPaths[split] = local;
+  }
+  return {
+    source: datasetSourceSchema.parse({
+      provider: "huggingface",
+      repo: source.repo,
+      requested_revision: source.revision ?? null,
+      revision,
+      pinned: Boolean(source.revision),
+      columns: source.columns ?? null,
+      snapshot_path: snapshot,
+      files
+    }),
+    localPaths
+  };
+}
+function mappedField(row, name) {
+  const value = row[name];
+  if (typeof value === "string") return value.trim() ? value : null;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return null;
+}
+async function readMappedRecords(path, split, columns) {
+  const examples = [];
+  let records = 0;
+  let skipped = 0;
+  const availableFields = /* @__PURE__ */ new Set();
+  const lines = createInterface({ input: createReadStream4(path, { encoding: "utf8" }), crlfDelay: Infinity });
+  let index = -1;
+  for await (const line of lines) {
+    index += 1;
+    if (!line.trim()) continue;
+    records += 1;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (error) {
+      throw new Error(`${split} line ${index + 1}: malformed JSON in ${path}`, { cause: error });
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`${split} line ${index + 1}: expected a JSON object in ${path}`);
+    }
+    const row = value;
+    for (const name of Object.keys(row)) availableFields.add(name);
+    const input = mappedField(row, columns.input);
+    const output = mappedField(row, columns.output);
+    if (input === null || output === null) {
+      skipped += 1;
+      continue;
+    }
+    examples.push({ input, output });
+  }
+  if (records > 0) {
+    for (const name of [columns.input, columns.output]) {
+      if (!availableFields.has(name)) {
+        throw new Error(
+          `${split} records have no "${name}" field (dataset_prebuilt.huggingface.columns). Available fields: ${[...availableFields].join(", ")}`
+        );
+      }
+    }
+  }
+  return { examples, records, skipped };
+}
+async function convertMappedDataset(args) {
+  const system = buildSystemMessage(args.spec);
+  const splits = Object.keys(args.resolved.localPaths);
+  const key = createHash6("sha256").update(JSON.stringify({
+    version: 1,
+    sources: splits.map((split) => [split, args.resolved.source.files[split]?.sha256]),
+    columns: args.columns,
+    system
+  })).digest("hex").slice(0, 16);
+  const loaded = /* @__PURE__ */ new Map();
+  for (const split of splits) {
+    loaded.set(split, await readMappedRecords(args.resolved.localPaths[split], split, args.columns));
+  }
+  const evaluationInputs = /* @__PURE__ */ new Set();
+  const kept = /* @__PURE__ */ new Map();
+  const conversion = {};
+  for (const split of splits.filter((name) => name !== "training")) {
+    const seen = /* @__PURE__ */ new Set();
+    const data = loaded.get(split);
+    const examples = data.examples.filter((example) => {
+      const identity = datasetInputIdentity(example.input);
+      if (seen.has(identity)) return false;
+      seen.add(identity);
+      evaluationInputs.add(identity);
+      return true;
+    });
+    kept.set(split, examples);
+    conversion[split] = {
+      records: data.records,
+      kept: examples.length,
+      skipped_missing_fields: data.skipped,
+      dropped_duplicate_inputs: data.examples.length - examples.length,
+      dropped_eval_overlap: 0
+    };
+  }
+  const training = loaded.get("training");
+  const trainingExamples = training.examples.filter((example) => !evaluationInputs.has(datasetInputIdentity(example.input)));
+  kept.set("training", trainingExamples);
+  conversion.training = {
+    records: training.records,
+    kept: trainingExamples.length,
+    skipped_missing_fields: training.skipped,
+    dropped_duplicate_inputs: 0,
+    dropped_eval_overlap: training.examples.length - trainingExamples.length
+  };
+  await mkdir7(args.outputRoot, { recursive: true });
+  const localPaths = {};
+  for (const split of splits) {
+    const examples = kept.get(split);
+    if (examples.length === 0) {
+      throw new Error(`No usable ${split} records remain after applying dataset_prebuilt.huggingface.columns.`);
+    }
+    const output = join8(args.outputRoot, `${split}-${key}.jsonl`);
+    const content = `${examples.map((example) => JSON.stringify(exampleToChatRow(args.spec, example))).join("\n")}
+`;
+    if (await readFile7(output, "utf8").catch(() => null) !== content) {
+      await writeFileAtomic(output, content);
+    }
+    localPaths[split] = output;
+  }
+  return { localPaths, conversion };
+}
+async function resolveRequestDataset(request, config) {
+  const dataset = huggingFaceDataset(request);
+  if (!dataset) return request;
+  const resolved = await resolveCachedHuggingFaceDataset({ dataset, modelCache: config.paths.modelCache });
+  let localPaths = resolved.localPaths;
+  let source = resolved.source;
+  const columns = dataset.huggingface.columns;
+  if (columns) {
+    const converted = await convertMappedDataset({
+      resolved,
+      columns,
+      spec: request.spec_snapshot,
+      outputRoot: resolve10(config.artifactRoot, "datasets", "huggingface", safeName(dataset.huggingface.repo), resolved.source.revision)
+    });
+    localPaths = converted.localPaths;
+    source = datasetSourceSchema.parse({ ...source, conversion: converted.conversion });
+  }
+  return fineTuneRunRequestSchema.parse({
+    ...request,
+    dataset_prebuilt: {
+      ...localPaths,
+      format: dataset.format
+    },
+    dataset_source: source
+  });
+}
+async function prefetchHuggingFaceDataset(args) {
+  const dataset = huggingFaceDataset(args.request);
+  if (!dataset) {
+    throw new Error(
+      "This spec has no dataset_prebuilt.huggingface source. Local dataset files need no download; set dataset_prebuilt.huggingface.repo to train on a Hugging Face dataset."
+    );
+  }
+  const modelCache = args.config.paths.modelCache ? resolve10(args.config.paths.modelCache) : void 0;
+  const hubCache = huggingFaceHubCache(modelCache);
+  if (args.localOnly) {
+    const resolved2 = await resolveCachedHuggingFaceDataset({ dataset, modelCache });
+    return {
+      ok: true,
+      status: "verified",
+      local_files_only: true,
+      hub_cache: hubCache,
+      size_bytes: Object.values(resolved2.source.files).reduce((total, file) => total + (file?.size_bytes ?? 0), 0),
+      ...resolved2.source
+    };
+  }
+  const artifactDir = resolve10(
+    args.config.artifactRoot,
+    "dataset-prefetch",
+    `${safeName(dataset.huggingface.repo)}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`
+  );
+  await mkdir7(artifactDir, { recursive: true });
+  const inputPath = join8(artifactDir, "prefetch-input.json");
+  const outputPath = join8(artifactDir, "prefetch-output.json");
+  const logPath = join8(artifactDir, "prefetch.log");
+  await writeJson(inputPath, {
+    repo: dataset.huggingface.repo,
+    ...dataset.huggingface.revision ? { revision: dataset.huggingface.revision } : {},
+    files: datasetFiles(dataset),
+    ...modelCache ? { model_cache: modelCache } : {}
+  });
+  const entrypoint = buildBundledPythonCommand("prefetch_dataset.py", ["--input", inputPath, "--output", outputPath]);
+  await args.reporter?.onEvent?.({
+    stage: "dataset_prefetch",
+    status: "running",
+    message: "Downloading Hugging Face dataset files.",
+    details: { repo: dataset.huggingface.repo, revision: dataset.huggingface.revision ?? "main", hub_cache: hubCache, log_path: logPath }
+  });
+  const { exitCode, stderr } = await runLoggedProcess({
+    command: entrypoint.command,
+    commandArgs: entrypoint.commandArgs,
+    env: withBundledPythonEnvironment(withHuggingFaceCacheEnvironment(minimalMachineLearningEnvironment(process.env), modelCache)),
+    logPath,
+    reporter: args.reporter ? { ...args.reporter, verbose: true } : void 0,
+    stage: "dataset_prefetch"
+  });
+  if (exitCode !== 0) {
+    const reason = stderr.trim().split("\n").filter(Boolean).at(-1);
+    throw new Error(
+      `Dataset prefetch exited with code ${exitCode}${reason ? `: ${reason}` : ""}. See ${logPath}. Rerunning resumes from the files already downloaded.`
+    );
+  }
+  const output = JSON.parse(await readFile7(outputPath, "utf8"));
+  const revision = baseModelRevisionSchema.parse(output.snapshot_revision);
+  const resolved = await resolveCachedHuggingFaceDataset({
+    dataset: { ...dataset, huggingface: { ...dataset.huggingface, revision } },
+    modelCache
+  });
+  for (const [split, file] of Object.entries(resolved.source.files)) {
+    if (output.files?.[split]?.sha256 !== file?.sha256) {
+      throw new Error(`Dataset prefetch reported a different digest for ${split} than the cached file.`);
+    }
+  }
+  const source = datasetSourceSchema.parse({
+    ...resolved.source,
+    requested_revision: dataset.huggingface.revision ?? null,
+    pinned: Boolean(dataset.huggingface.revision)
+  });
+  const sizeBytes = Object.values(source.files).reduce((total, file) => total + (file?.size_bytes ?? 0), 0);
+  await args.reporter?.onEvent?.({
+    stage: "dataset_prefetch",
+    status: "completed",
+    message: "Dataset files are available in the local Hugging Face cache.",
+    details: { repo: source.repo, revision: source.revision, pinned: source.pinned, size_bytes: sizeBytes }
+  });
+  return {
+    ok: true,
+    status: "completed",
+    local_files_only: false,
+    hub_cache: hubCache,
+    size_bytes: sizeBytes,
+    ...source,
+    artifact_dir: artifactDir,
+    log_uri: fileUri(logPath),
+    command: entrypoint.displayCommand
+  };
+}
+async function ensureDatasetCached(args) {
+  if (!huggingFaceDataset(args.request)) return { request: args.request, prefetch: null };
+  try {
+    return { request: await resolveRequestDataset(args.request, args.config), prefetch: null };
+  } catch (error) {
+    if (!(error instanceof DatasetNotDownloadedError) || args.config.dryRun) throw error;
+  }
+  const prefetch = await prefetchHuggingFaceDataset(args);
+  return { request: await resolveRequestDataset(args.request, args.config), prefetch };
+}
+
 // src/local-runtime/general-regression.ts
 function evaluateGeneralRegressionGate(comparison, policy) {
   const failures = [];
@@ -3311,18 +4479,18 @@ function evaluateGeneralRegressionGate(comparison, policy) {
 }
 
 // src/local-runtime/orchestrator.ts
-import { lstat as lstat5, mkdir as mkdir9, open as open3, readFile as readFile8, readdir as readdir5, rename as rename3, rm as rm4, stat as stat7 } from "fs/promises";
-import { createReadStream as createReadStream3 } from "fs";
-import { createHash as createHash7, randomUUID as randomUUID5 } from "crypto";
+import { lstat as lstat5, mkdir as mkdir11, open as open4, readFile as readFile10, readdir as readdir5, rename as rename4, rm as rm5, stat as stat9 } from "fs/promises";
+import { createReadStream as createReadStream5 } from "fs";
+import { createHash as createHash9, randomUUID as randomUUID6 } from "crypto";
 import { performance } from "perf_hooks";
 import { homedir as homedir4 } from "os";
-import { basename as basename2, dirname as dirname9, join as join10, relative as relative4, resolve as resolve13 } from "path";
+import { basename as basename3, dirname as dirname9, join as join12, relative as relative5, resolve as resolve14 } from "path";
 
 // src/local-runtime/gpu-executor.ts
-import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
-import { mkdtemp, mkdir as mkdir6, realpath as realpath3, rm as rm2, stat as stat5, writeFile as writeFile4 } from "fs/promises";
+import { createHash as createHash7, randomUUID as randomUUID5 } from "crypto";
+import { mkdtemp, mkdir as mkdir8, realpath as realpath4, rm as rm3, stat as stat7, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir } from "os";
-import { basename, dirname as dirname7, join as join7, resolve as resolve10 } from "path";
+import { basename as basename2, dirname as dirname7, join as join9, resolve as resolve11 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -3387,23 +4555,23 @@ async function checkAwsGpu(gpu) {
   if (result.exitCode !== 0) throw new Error(`AWS GPU preflight failed: ${result.stderr}`);
 }
 function gpuBaseModelPath(config, model, revision) {
-  if (config.paths.baseModel) return resolve10(config.paths.baseModel);
+  if (config.paths.baseModel) return resolve11(config.paths.baseModel);
   if (!revision || !/^[a-f0-9]{40}$/i.test(revision)) {
     throw new Error("AWS GPU execution needs an immutable base-model revision. Run tt models prefetch first or configure paths.baseModel.");
   }
   const env = withHuggingFaceCacheEnvironment(process.env, config.paths.modelCache);
-  return join7(env.HF_HUB_CACHE, `models--${model.replaceAll("/", "--")}`, "snapshots", revision);
+  return join9(env.HF_HUB_CACHE, `models--${model.replaceAll("/", "--")}`, "snapshots", revision);
 }
 async function physicalTransferPath(path) {
   try {
-    return await realpath3(path);
+    return await realpath4(path);
   } catch (error) {
     if (error.code !== "ENOENT" || dirname7(path) === path) throw error;
-    return join7(await physicalTransferPath(dirname7(path)), basename(path));
+    return join9(await physicalTransferPath(dirname7(path)), basename2(path));
   }
 }
 async function assertSeparateTransferPaths(files) {
-  const paths = await Promise.all(files.map((file) => physicalTransferPath(resolve10(file.path))));
+  const paths = await Promise.all(files.map((file) => physicalTransferPath(resolve11(file.path))));
   for (let i = 0; i < files.length; i += 1) {
     for (let j = 0; j < i; j += 1) {
       if (files[i].direction === "input" && files[j].direction === "input") continue;
@@ -3420,13 +4588,13 @@ async function runGpuProcess(args) {
   await assertSeparateTransferPaths(args.files);
   const host = await resolveGpuHost(args.gpu);
   const options = sshOptions(args.gpu);
-  const identity = args.logPath ? createHash5("sha256").update(resolve10(args.logPath)).digest("hex").slice(0, 32) : randomUUID4();
+  const identity = args.logPath ? createHash7("sha256").update(resolve11(args.logPath)).digest("hex").slice(0, 32) : randomUUID5();
   const root = `/tmp/tt-gpu-${identity}`;
-  const scratch = await mkdtemp(join7(tmpdir(), "tt-gpu-"));
-  const runtime = join7(localRuntimePackageRoot(import.meta.url), "training", args.runtime);
-  const mappings = args.files.map((file, index) => ({ ...file, path: resolve10(file.path), remote: `${root}/files/${index}/${basename(file.path)}` }));
+  const scratch = await mkdtemp(join9(tmpdir(), "tt-gpu-"));
+  const runtime = join9(localRuntimePackageRoot(import.meta.url), "training", args.runtime);
+  const mappings = args.files.map((file, index) => ({ ...file, path: resolve11(file.path), remote: `${root}/files/${index}/${basename2(file.path)}` }));
   const mapPath = (path) => {
-    const absolute = resolve10(path);
+    const absolute = resolve11(path);
     const match = [...mappings].sort((a, b) => b.path.length - a.path.length).find((file) => absolute === file.path || file.directory && absolute.startsWith(`${file.path}/`));
     if (match) return match.remote + absolute.slice(match.path.length);
     if (absolute === runtime || absolute.startsWith(`${runtime}/`)) return `${root}/runtime${absolute.slice(runtime.length)}`;
@@ -3464,7 +4632,7 @@ async function runGpuProcess(args) {
   };
   const grace = Math.ceil((args.shutdownGraceMs ?? 5e3) / 1e3);
   const stop = `kill -TERM -- -"$pid" 2>/dev/null || true; remaining=${grace}; while kill -0 -- -"$pid" 2>/dev/null && [ "$remaining" -gt 0 ]; do sleep 1; remaining=$((remaining - 1)); done; kill -KILL -- -"$pid" 2>/dev/null || true`;
-  const owner = randomUUID4();
+  const owner = randomUUID5();
   let reservationAttempted = false;
   let started = false;
   let completed = false;
@@ -3475,12 +4643,12 @@ async function runGpuProcess(args) {
       throw new Error(`Cannot reserve GPU staging directory ${host}:${root}. Another process or unrecovered artifacts may be present. ${error instanceof Error ? error.message : error}`);
     });
     for (const name of ["pyproject.toml", "uv.lock", "src"]) {
-      await sync(join7(runtime, name), `${root}/runtime/`, true);
+      await sync(join9(runtime, name), `${root}/runtime/`, true);
     }
     for (const file of mappings) {
       await ssh(`mkdir -p ${shellQuote(file.directory ? file.remote : dirname7(file.remote))}`);
       if (file.direction !== "output") {
-        const exists3 = await stat5(file.path).catch((error) => {
+        const exists3 = await stat7(file.path).catch((error) => {
           if (error.code === "ENOENT" && file.direction === "both") return void 0;
           throw error;
         });
@@ -3490,8 +4658,8 @@ async function runGpuProcess(args) {
     if (args.document) {
       const value = { ...args.document.value };
       for (const key of args.document.pathKeys) if (typeof value[key] === "string") value[key] = mapPath(value[key]);
-      const path = join7(scratch, "document.json");
-      await writeFile4(path, JSON.stringify(value), { mode: 384 });
+      const path = join9(scratch, "document.json");
+      await writeFile5(path, JSON.stringify(value), { mode: 384 });
       await sync(path, mapPath(args.document.path), true);
     }
     const env = {
@@ -3523,7 +4691,7 @@ async function runGpuProcess(args) {
       if (started) {
         await ssh(`bash -c ${shellQuote(`if test -f ${root}/pid; then pid=$(cat ${root}/pid); ${stop}; fi`)}`, false);
         for (const file of mappings.filter((file2) => file2.direction !== "input")) {
-          await mkdir6(file.directory ? file.path : dirname7(file.path), { recursive: true });
+          await mkdir8(file.directory ? file.path : dirname7(file.path), { recursive: true });
           if (!completed && !file.directory) {
             const exists3 = await runLoggedProcess({ command: "ssh", commandArgs: [...options, host, `test -e ${shellQuote(file.remote)}`], stage: args.stage, timeoutMs: 3e4 });
             if (exists3.exitCode === 1) continue;
@@ -3536,15 +4704,15 @@ async function runGpuProcess(args) {
     } catch (error) {
       throw new Error(`GPU cleanup or artifact retrieval failed. Remote files remain at ${host}:${root}. ${error instanceof Error ? error.message : error}`);
     } finally {
-      await rm2(scratch, { recursive: true, force: true });
+      await rm3(scratch, { recursive: true, force: true });
     }
   }
 }
 
 // src/local-runtime/evaluation.ts
-import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir7, readFile as readFile6, rm as rm3, stat as stat6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname8, join as join8, resolve as resolve11 } from "path";
+import { createHash as createHash8 } from "crypto";
+import { mkdir as mkdir9, readFile as readFile8, rm as rm4, stat as stat8, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join10, resolve as resolve12 } from "path";
 function normalize(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -3638,11 +4806,11 @@ function extractJsonObject(value) {
   }
   return null;
 }
-function canonicalJson3(value) {
-  if (Array.isArray(value)) return value.map(canonicalJson3);
+function canonicalJson4(value) {
+  if (Array.isArray(value)) return value.map(canonicalJson4);
   if (value && typeof value === "object") {
     return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson3(item)])
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson4(item)])
     );
   }
   return value;
@@ -3668,7 +4836,7 @@ function scoreJsonFields(expected, actual, configuredFields) {
   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(canonicalJson3(expectedJson[field])) === JSON.stringify(canonicalJson3(actualJson?.[field]));
+    fieldResults[field] = Object.prototype.hasOwnProperty.call(expectedJson, field) && Boolean(actualJson) && JSON.stringify(canonicalJson4(expectedJson[field])) === JSON.stringify(canonicalJson4(actualJson?.[field]));
   }
   const correct = Object.values(fieldResults).filter(Boolean).length;
   const score = fields.length > 0 ? correct / fields.length : 0;
@@ -3764,8 +4932,8 @@ async function runTransformersInference(args) {
   const inputPath = `${args.outputPath}.inference-input.json`;
   const outputPath = `${args.outputPath}.inference-output.json`;
   const logPath = `${args.outputPath}.inference.log`;
-  await mkdir7(dirname8(inputPath), { recursive: true });
-  await writeFile5(inputPath, `${JSON.stringify({
+  await mkdir9(dirname8(inputPath), { recursive: true });
+  await writeFile6(inputPath, `${JSON.stringify({
     protocol_version: INFERENCE_PROTOCOL_VERSION,
     kind: args.kind,
     model_id: args.modelId,
@@ -3779,7 +4947,7 @@ async function runTransformersInference(args) {
       id: String(index),
       input: example.input
     })),
-    model_cache: args.config.paths.modelCache ? resolve11(args.config.paths.modelCache) : void 0,
+    model_cache: args.config.paths.modelCache ? resolve12(args.config.paths.modelCache) : void 0,
     trust_remote_code: false,
     device: args.config.evaluation.inference.device,
     generation: {
@@ -3789,7 +4957,7 @@ async function runTransformersInference(args) {
     }
   }, null, 2)}
 `, "utf8");
-  await rm3(outputPath, { force: true });
+  await rm4(outputPath, { force: true });
   const entrypoint = buildBundledPythonCommand(
     "evaluate.py",
     ["--input", inputPath, "--output", outputPath]
@@ -3807,7 +4975,7 @@ async function runTransformersInference(args) {
   });
   const gpu = args.config.evaluation.inference.device === "cuda" ? args.config.gpu : void 0;
   const execute = gpu ? async (processArgs) => {
-    const document = JSON.parse(await readFile6(inputPath, "utf8"));
+    const document = JSON.parse(await readFile8(inputPath, "utf8"));
     document.model_source = gpuBaseModelPath(args.config, args.baseModelId, args.baseModelRevision);
     delete document.model_cache;
     const files = [
@@ -3817,7 +4985,7 @@ async function runTransformersInference(args) {
       ...document.adapter_path ? [{
         path: document.adapter_path,
         direction: "input",
-        directory: (await stat6(document.adapter_path)).isDirectory()
+        directory: (await stat8(document.adapter_path)).isDirectory()
       }] : []
     ];
     return runGpuProcess({
@@ -3851,7 +5019,7 @@ async function runTransformersInference(args) {
   }
   let output;
   try {
-    output = JSON.parse(await readFile6(outputPath, "utf8"));
+    output = JSON.parse(await readFile8(outputPath, "utf8"));
   } catch (error) {
     throw new Error(
       `Transformers inference did not write valid JSON: ${error instanceof Error ? error.message : String(error)}`
@@ -3868,7 +5036,7 @@ function assertEvaluationScoringReady(config) {
   }
 }
 function baselineCacheKey(args) {
-  return createHash6("sha256").update(JSON.stringify({
+  return createHash8("sha256").update(JSON.stringify({
     v: 6,
     inference_protocol_version: INFERENCE_PROTOCOL_VERSION,
     package_version: args.packageVersion,
@@ -3888,15 +5056,15 @@ function baselineInputsAreStable(args) {
   return args.config.paths.baseModel ? Boolean(args.sourceFingerprint) : Boolean(args.baseModelRevision);
 }
 function baselineStoreRoot(config) {
-  return config.storeRoot ? resolve11(config.storeRoot) : defaultLocalHome();
+  return config.storeRoot ? resolve12(config.storeRoot) : defaultLocalHome();
 }
 function baselineCachePath(config, key) {
-  return join8(baselineStoreRoot(config), "cache", "baseline-evals", `${key}.json`);
+  return join10(baselineStoreRoot(config), "cache", "baseline-evals", `${key}.json`);
 }
 async function readBaselineCache(config, path) {
   await hardenExistingLocalStore(baselineStoreRoot(config));
   try {
-    return evalReportSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+    return evalReportSchema.parse(JSON.parse(await readFile8(path, "utf8")));
   } catch {
     return null;
   }
@@ -3905,7 +5073,7 @@ var cachedPackageVersion = null;
 async function packageVersion() {
   if (cachedPackageVersion !== null) return cachedPackageVersion;
   try {
-    const raw = await readFile6(resolve11(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
+    const raw = await readFile8(resolve12(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
     cachedPackageVersion = String(
       JSON.parse(raw).version ?? "unknown"
     );
@@ -3974,7 +5142,7 @@ async function evaluateExamples(args) {
     baseModelId,
     args.baseModelRevision
   );
-  const localModelSource = args.modelSource ? resolve11(args.modelSource) !== resolve11(baseModelId) : false;
+  const localModelSource = args.modelSource ? resolve12(args.modelSource) !== resolve12(baseModelId) : false;
   const baseModelRevision = localModelSource ? defaultBaseModelRevision(baseModelId) : requestedBaseModelRevision;
   const maxExamples = args.config.evaluation.maxExamples ?? args.maxExamples ?? args.examples.length;
   const truncated = args.examples.length > maxExamples;
@@ -4090,8 +5258,8 @@ function compareEvalReports(baseline, candidate) {
 }
 
 // src/local-runtime/process-training.ts
-import { access, mkdir as mkdir8, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import { join as join9, resolve as resolve12 } from "path";
+import { access, mkdir as mkdir10, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
+import { join as join11, resolve as resolve13 } from "path";
 function buildTrainingHyperparameters(request, options = {}) {
   const model = resolveTrainingModel(request.spec_snapshot.base_model);
   const hyper = request.hyperparameters;
@@ -4182,15 +5350,15 @@ function createTrainingProgressForwarder(reporter) {
 async function launchProcessTraining(args) {
   const { request, artifacts, config } = args;
   const jobName = `tt-local-${request.run_id}`;
-  await mkdir8(artifacts.trainingDir, { recursive: true });
+  await mkdir10(artifacts.trainingDir, { recursive: true });
   await copyDatasetToTrainingChannel(artifacts);
   const hyperparameters = buildTrainingHyperparameters(request, {
     baseModelRevision: args.baseModelRevision
   });
-  await writeJson(join9(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
+  await writeJson(join11(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
   const entrypoint = buildBundledPythonCommand("train.py");
   if (config.dryRun) {
-    await writeFile6(
+    await writeFile7(
       artifacts.trainingLog,
       "Dry run enabled. Training process was not launched.\n",
       "utf8"
@@ -4212,11 +5380,11 @@ async function launchProcessTraining(args) {
     withOfflineHuggingFaceCacheEnvironment({
       ...inheritedEnv,
       BACKEND: "local",
-      SM_CHANNEL_TRAINING: resolve12(artifacts.trainingInputDir),
-      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve12(config.paths.baseModel) : void 0,
-      SM_MODEL_DIR: resolve12(artifacts.trainingModelDir),
-      SM_OUTPUT_DIR: resolve12(artifacts.trainingOutputDir),
-      TT_HYPERPARAMETERS_PATH: resolve12(artifacts.trainingConfigDir, "hyperparameters.json")
+      SM_CHANNEL_TRAINING: resolve13(artifacts.trainingInputDir),
+      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve13(config.paths.baseModel) : void 0,
+      SM_MODEL_DIR: resolve13(artifacts.trainingModelDir),
+      SM_OUTPUT_DIR: resolve13(artifacts.trainingOutputDir),
+      TT_HYPERPARAMETERS_PATH: resolve13(artifacts.trainingConfigDir, "hyperparameters.json")
     }, config.paths.modelCache)
   );
   for (const [key, value] of Object.entries(childEnv)) {
@@ -4224,10 +5392,10 @@ async function launchProcessTraining(args) {
   }
   const remoteBaseModel = config.gpu ? gpuBaseModelPath(config, request.spec_snapshot.base_model, args.baseModelRevision) : void 0;
   if (remoteBaseModel) childEnv.SM_CHANNEL_BASE_MODEL = remoteBaseModel;
-  if (config.paths.modelCache) await mkdir8(resolve12(config.paths.modelCache), { recursive: true });
+  if (config.paths.modelCache) await mkdir10(resolve13(config.paths.modelCache), { recursive: true });
   if (config.paths.baseModel) {
     await verifyLocalBaseModel(
-      resolve12(config.paths.baseModel),
+      resolve13(config.paths.baseModel),
       request.spec_snapshot.base_model,
       config.paths.modelCache
     );
@@ -4266,12 +5434,12 @@ async function launchProcessTraining(args) {
     onLine: (line) => forwardTrainingProgress(line),
     shouldCancel: args.shouldCancel
   });
-  const metricsPath = join9(artifacts.trainingModelDir, "training-metrics.json");
-  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile7(metricsPath, "utf8")) : null;
+  const metricsPath = join11(artifacts.trainingModelDir, "training-metrics.json");
+  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile9(metricsPath, "utf8")) : null;
   if (exitCode !== 0) {
     throw new Error(`Training process exited with code ${exitCode}. See ${artifacts.trainingLog}.`);
   }
-  const modelTarPath = join9(artifacts.trainingOutputDir, "model.tar.gz");
+  const modelTarPath = join11(artifacts.trainingOutputDir, "model.tar.gz");
   const modelUri = await pathExists(modelTarPath) ? fileUri(modelTarPath) : fileUri(artifacts.trainingModelDir);
   await args.reporter?.onEvent?.({
     stage: "training",
@@ -4366,7 +5534,7 @@ function validateLocalPipeline(pipeline) {
   return pipeline;
 }
 async function loadJsonFile(path) {
-  return JSON.parse(await readFile8(path, "utf8"));
+  return JSON.parse(await readFile10(path, "utf8"));
 }
 async function loadRunRequest(path) {
   return fineTuneRunRequestSchema.parse(await loadJsonFile(path));
@@ -4374,13 +5542,13 @@ async function loadRunRequest(path) {
 function parseLocalRunnerConfig(document, path) {
   const config = localRunnerConfigSchema.parse(document);
   if (!path) return config;
-  const configPath = resolve13(path);
+  const configPath = resolve14(path);
   const base = dirname9(configPath);
   const configPathValue = (value) => {
     if (!value) return void 0;
     if (value === "~") return homedir4();
-    if (value.startsWith("~/")) return resolve13(homedir4(), value.slice(2));
-    return resolve13(base, value);
+    if (value.startsWith("~/")) return resolve14(homedir4(), value.slice(2));
+    return resolve14(base, value);
   };
   return {
     ...config,
@@ -4402,7 +5570,7 @@ function parseLocalRunnerConfig(document, path) {
 }
 async function loadLocalRunnerConfig(path) {
   if (!path) return parseLocalRunnerConfig({});
-  const configPath = resolve13(path);
+  const configPath = resolve14(path);
   return parseLocalRunnerConfig(
     await loadJsonFile(configPath),
     configPath
@@ -4417,7 +5585,7 @@ function stripFileUri(path) {
 }
 async function pathExists2(path) {
   try {
-    await stat7(path);
+    await stat9(path);
     return true;
   } catch {
     return false;
@@ -4461,7 +5629,7 @@ function addDryRunPlaceholders(request, dryRun) {
   };
 }
 async function validateDatasetInputs(request, config) {
-  const inputIdentity = (value) => value.normalize("NFKC").trim().replace(/\s+/g, " ").toLocaleLowerCase("en");
+  const inputIdentity = datasetInputIdentity;
   const evalSampleSeed = config.evaluation.sampleSeed ?? deriveSampleSeed(request.behavior_spec_id);
   if (!request.dataset_prebuilt) {
     const inlineExamples = examplesFromSpec(request.spec_snapshot);
@@ -4551,7 +5719,10 @@ async function validateDatasetInputs(request, config) {
 }
 async function validateLocalFineTuneInput(input) {
   const config = localRunnerConfigSchema.parse(input.config);
-  const request = fineTuneRunRequestSchema.parse(addDryRunPlaceholders(input.request, config.dryRun));
+  const request = await resolveRequestDataset(
+    fineTuneRunRequestSchema.parse(addDryRunPlaceholders(input.request, config.dryRun)),
+    config
+  );
   await validateDatasetInputs(request, config);
   if (config.evaluation.generalRegression) {
     await evaluationSuiteFromChatJsonl(
@@ -4568,14 +5739,14 @@ function artifactPrefix(request) {
     runId: request.run_id
   });
 }
-function canonicalJson4(value) {
+function canonicalJson5(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson4(entry)).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson5(entry)).join(",")}]`;
   const object = value;
-  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson4(object[key])}`).join(",")}}`;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson5(object[key])}`).join(",")}}`;
 }
 function hashJson(value) {
-  return createHash7("sha256").update(canonicalJson4(value)).digest("hex");
+  return createHash9("sha256").update(canonicalJson5(value)).digest("hex");
 }
 var packageRoot2 = localRuntimePackageRoot(import.meta.url);
 async function hashFileIfPresent(path) {
@@ -4587,21 +5758,21 @@ async function hashFileIfPresent(path) {
 }
 async function packageVersion2() {
   try {
-    const parsed = JSON.parse(await readFile8(resolve13(packageRoot2, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile10(resolve14(packageRoot2, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
   }
 }
 async function runtimeFingerprint() {
-  const bundledProject2 = resolve13(packageRoot2, "training/adapter");
+  const bundledProject2 = resolve14(packageRoot2, "training/adapter");
   return hashJson({
     tt_local_version: await packageVersion2(),
     node_version: process.version,
     platform: process.platform,
     architecture: process.arch,
-    runner_pyproject: await hashFileIfPresent(resolve13(bundledProject2, "pyproject.toml")),
-    runner_uv_lock: await hashFileIfPresent(resolve13(bundledProject2, "uv.lock"))
+    runner_pyproject: await hashFileIfPresent(resolve14(bundledProject2, "pyproject.toml")),
+    runner_uv_lock: await hashFileIfPresent(resolve14(bundledProject2, "uv.lock"))
   });
 }
 function preparedSourceFingerprint(args) {
@@ -4615,8 +5786,8 @@ function preparedSourceFingerprint(args) {
   });
 }
 async function hashFile(path) {
-  const hash = createHash7("sha256");
-  for await (const chunk of createReadStream3(path)) hash.update(chunk);
+  const hash = createHash9("sha256");
+  for await (const chunk of createReadStream5(path)) hash.update(chunk);
   return hash.digest("hex");
 }
 async function datasetFingerprints(request) {
@@ -4640,7 +5811,7 @@ async function resolveBaseModelRevision(request, config) {
     request.hyperparameters.base_model_revision
   );
   if (config.paths.baseModel) {
-    return defaultBaseModelRevision(request.spec_snapshot.base_model);
+    return isCertifiedTrainingModel(request.spec_snapshot.base_model) ? defaultBaseModelRevision(request.spec_snapshot.base_model) : requested;
   }
   if (requested) return requested;
   if (!request.spec_snapshot.base_model.includes("/")) {
@@ -4648,9 +5819,9 @@ async function resolveBaseModelRevision(request, config) {
   }
   const repository = `models--${request.spec_snapshot.base_model.replaceAll("/", "--")}`;
   const cacheEnvironment = withHuggingFaceCacheEnvironment(process.env, config.paths.modelCache);
-  const refPath = resolve13(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
+  const refPath = resolve14(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
   try {
-    const revision = (await readFile8(refPath, "utf8")).trim();
+    const revision = (await readFile10(refPath, "utf8")).trim();
     if (revision) return revision;
   } catch {
   }
@@ -4669,18 +5840,18 @@ async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir5(directory, { withFileTypes: true })) {
-      const child = resolve13(directory, entry.name);
+      const child = resolve14(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(child);
         continue;
       }
-      const childMetadata = await stat7(child);
+      const childMetadata = await stat9(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: relative4(root, child).split("\\").join("/"),
+        path: relative5(root, child).split("\\").join("/"),
         size_bytes: childMetadata.size,
         sha256: await hashFile(child)
       });
@@ -4709,26 +5880,26 @@ async function readStageMetadata(path) {
 }
 async function removePrefixedArtifacts(path) {
   const directory = dirname9(path);
-  const prefix = `${basename2(path)}.`;
+  const prefix = `${basename3(path)}.`;
   const names = await readdir5(directory).catch(() => []);
   await Promise.all([
-    rm4(path, { force: true }),
-    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm4(resolve13(directory, name), { recursive: true, force: true }))
+    rm5(path, { force: true }),
+    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm5(resolve14(directory, name), { recursive: true, force: true }))
   ]);
 }
 async function cleanupStageArtifacts(artifacts, stage) {
-  const removeReport = async () => rm4(artifacts.runReportJson, { force: true });
+  const removeReport = async () => rm5(artifacts.runReportJson, { force: true });
   if (stage === "prepare") {
     await Promise.all([
       removePrefixedArtifacts(artifacts.baselineEvalJson),
       removePrefixedArtifacts(artifacts.candidateEvalJson),
       removePrefixedArtifacts(artifacts.generalBaselineEvalJson),
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
-      rm4(artifacts.trainingDir, { recursive: true, force: true }),
+      rm5(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm4(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm5(resolve14(artifacts.runDir, "model.tar.gz"), { force: true }),
       removeReport(),
-      rm4(artifacts.artifactManifestJson, { force: true })
+      rm5(artifacts.artifactManifestJson, { force: true })
     ]);
     return;
   }
@@ -4742,9 +5913,9 @@ async function cleanupStageArtifacts(artifacts, stage) {
   }
   if (stage === "train") {
     await Promise.all([
-      rm4(artifacts.trainingDir, { recursive: true, force: true }),
+      rm5(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm4(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm5(resolve14(artifacts.runDir, "model.tar.gz"), { force: true }),
       removePrefixedArtifacts(artifacts.candidateEvalJson),
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       removeReport()
@@ -4763,7 +5934,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
   await removeReport();
 }
 function manifestRelativePath(artifacts, path) {
-  return relative4(artifacts.runDir, path).split("\\").join("/");
+  return relative5(artifacts.runDir, path).split("\\").join("/");
 }
 async function verifyReusableArtifacts(artifacts, paths, options = {}) {
   if (!await pathExists2(artifacts.artifactManifestJson)) return false;
@@ -4780,11 +5951,11 @@ async function throwIfCancelled(store, request) {
   }
 }
 async function acquireWorkflowLock(lockPath, description) {
-  await mkdir9(dirname9(lockPath), { recursive: true });
-  const token = randomUUID5();
+  await mkdir11(dirname9(lockPath), { recursive: true });
+  const token = randomUUID6();
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      const handle = await open3(lockPath, "wx", 384);
+      const handle = await open4(lockPath, "wx", 384);
       try {
         await handle.writeFile(`${JSON.stringify({ token, pid: process.pid, created_at: (/* @__PURE__ */ new Date()).toISOString() })}
 `);
@@ -4793,17 +5964,17 @@ async function acquireWorkflowLock(lockPath, description) {
       }
       return async () => {
         try {
-          const owner = JSON.parse(await readFile8(lockPath, "utf8"));
-          if (owner.token === token) await rm4(lockPath, { force: true });
+          const owner = JSON.parse(await readFile10(lockPath, "utf8"));
+          if (owner.token === token) await rm5(lockPath, { force: true });
         } catch {
         }
       };
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
-      const metadata = await stat7(lockPath).catch(() => null);
+      const metadata = await stat9(lockPath).catch(() => null);
       let owner = null;
       try {
-        owner = JSON.parse(await readFile8(lockPath, "utf8"));
+        owner = JSON.parse(await readFile10(lockPath, "utf8"));
       } catch {
         owner = null;
       }
@@ -4822,10 +5993,10 @@ async function acquireWorkflowLock(lockPath, description) {
           `${description} already has an active local workflow (lock: ${lockPath}).`
         );
       }
-      const stalePath = `${lockPath}.stale.${randomUUID5()}`;
+      const stalePath = `${lockPath}.stale.${randomUUID6()}`;
       try {
-        await rename3(lockPath, stalePath);
-        await rm4(stalePath, { force: true });
+        await rename4(lockPath, stalePath);
+        await rm5(stalePath, { force: true });
       } catch (renameError) {
         if (renameError.code !== "ENOENT") throw renameError;
       }
@@ -4835,11 +6006,11 @@ async function acquireWorkflowLock(lockPath, description) {
 }
 async function acquireRunLock(store, runId) {
   await store.ensure();
-  return acquireWorkflowLock(resolve13(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
+  return acquireWorkflowLock(resolve14(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
 }
 async function acquireArtifactLock(artifacts) {
   return acquireWorkflowLock(
-    join10(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
+    join12(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
     `Artifact directory ${artifacts.runDir}`
   );
 }
@@ -4886,13 +6057,13 @@ function stageFingerprintPath(prepared, stage) {
   return `${stageOutputPath(prepared, stage)}.stage.json`;
 }
 async function runnerFileFingerprints() {
-  const project = resolve13(packageRoot2, "training/adapter");
-  const bundledSource = resolve13(packageRoot2, "training/adapter/src");
-  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve13(bundledSource, entry.name));
+  const project = resolve14(packageRoot2, "training/adapter");
+  const bundledSource = resolve14(packageRoot2, "training/adapter/src");
+  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve14(bundledSource, entry.name));
   const candidates = [.../* @__PURE__ */ new Set([
     ...pythonSources,
-    resolve13(project, "pyproject.toml"),
-    resolve13(project, "uv.lock")
+    resolve14(project, "pyproject.toml"),
+    resolve14(project, "uv.lock")
   ])];
   const fingerprints = {};
   for (const path of candidates.sort()) fingerprints[path] = await hashFileIfPresent(path);
@@ -5006,7 +6177,7 @@ async function ensureRunRecord(args) {
         `Run ${args.request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
       );
     }
-    if (resolve13(existing.artifact_dir) !== resolve13(args.artifacts.runDir)) {
+    if (resolve14(existing.artifact_dir) !== resolve14(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}.`
       );
@@ -5084,7 +6255,7 @@ async function computePreparedRun(args) {
     base_model_for_evaluation: baseModelForEvaluation,
     base_model_revision: baseModelRevision ?? null,
     base_model_fingerprint: baseModelFingerprint ?? null,
-    system_prompt_sha256: createHash7("sha256").update(system).digest("hex"),
+    system_prompt_sha256: createHash9("sha256").update(system).digest("hex"),
     prepared_at: (/* @__PURE__ */ new Date()).toISOString()
   };
   if (args.writeArtifacts) await writeJsonAtomic(artifacts.stageMetadataJson, metadata);
@@ -5113,7 +6284,7 @@ async function prepareStage(args) {
   const preparedExists = await pathExists2(args.artifacts.stageMetadataJson) && await pathExists2(args.artifacts.trainingJsonl);
   const prepared = await computePreparedRun({ ...args, writeArtifacts: false });
   await args.store.syncRunRequest(args.request, args.artifacts.runDir);
-  await writeJsonAtomic(resolve13(args.artifacts.runDir, "request.json"), args.request);
+  await writeJsonAtomic(resolve14(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) {
@@ -5447,6 +6618,56 @@ async function runCandidateStage(args) {
   });
   return report;
 }
+async function buildRunProvenance(args) {
+  const { metadata, request } = args.prepared;
+  const gpu = args.config.gpu;
+  return runProvenanceSchema.parse({
+    schema_version: 1,
+    recorded_at: args.recordedAt,
+    software: {
+      tt_version: await packageVersion2(),
+      node_version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      runtime_fingerprint: metadata.runtime_fingerprint,
+      python_lock_sha256: await hashFileIfPresent(resolve14(packageRoot2, "training/adapter/uv.lock"))
+    },
+    execution: {
+      target: gpu ? "aws" : "local",
+      training_backend: args.training.provider,
+      ...gpu ? { instance_id: gpu.instanceId, ...gpu.region ? { region: gpu.region } : {} } : {}
+    },
+    spec: {
+      behavior_spec_id: request.behavior_spec_id,
+      run_number: request.run_number,
+      snapshot_sha256: hashJson(request.spec_snapshot),
+      system_prompt_sha256: metadata.system_prompt_sha256,
+      ...args.specFile ? { file_path: args.specFile.path, file_sha256: args.specFile.sha256 } : {}
+    },
+    base_model: {
+      id: request.spec_snapshot.base_model,
+      revision: metadata.base_model_revision,
+      fingerprint: metadata.base_model_fingerprint
+    },
+    data: {
+      prebuilt: metadata.dataset_prebuilt,
+      format: metadata.dataset_format,
+      file_sha256: metadata.dataset_fingerprints,
+      compiled_training_sha256: await hashFileIfPresent(args.prepared.artifacts.trainingJsonl),
+      training_examples: metadata.training_example_count,
+      eval_split: metadata.eval_split,
+      eval_sample_seed: metadata.eval_sample_seed,
+      eval_examples_total: metadata.eval_examples_total,
+      eval_examples_used: metadata.eval_examples_used
+    },
+    training: {
+      hyperparameters: request.hyperparameters,
+      exit_code: args.training.exit_code,
+      log_uri: args.training.log_uri
+    },
+    source_fingerprint: metadata.source_fingerprint
+  });
+}
 async function runReportStage(args) {
   if (!await pathExists2(args.prepared.artifacts.baselineEvalJson)) {
     throw new Error("Run reporting requires baseline-eval.json.");
@@ -5539,6 +6760,13 @@ async function runReportStage(args) {
   }
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
   const duration = elapsed(args.startedPerf);
+  const provenance = await buildRunProvenance({
+    prepared: args.prepared,
+    config: args.config,
+    training,
+    recordedAt: completedAt,
+    specFile: args.specFile
+  });
   const report = runReportSchema.parse({
     run_id: args.prepared.request.run_id,
     behavior_spec_id: args.prepared.request.behavior_spec_id,
@@ -5552,6 +6780,7 @@ async function runReportStage(args) {
     comparison,
     general_regression: generalRegression,
     training,
+    provenance,
     artifact_uris: {
       dataset: fileUri(args.prepared.artifacts.trainingJsonl),
       baseline_eval: fileUri(args.prepared.artifacts.baselineEvalJson),
@@ -5566,6 +6795,7 @@ async function runReportStage(args) {
       dataset_prebuilt: args.prepared.metadata.dataset_prebuilt,
       dataset_format: args.prepared.metadata.dataset_format,
       dataset_uri: fileUri(args.prepared.artifacts.trainingJsonl),
+      ...args.prepared.request.dataset_source ? { dataset_source: args.prepared.request.dataset_source } : {},
       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,
@@ -5638,7 +6868,7 @@ async function runLocalPipeline(input) {
         store,
         reporter: input.reporter
       });
-      await writeJsonAtomic(join10(artifacts.runDir, "resolved-workflow.json"), {
+      await writeJsonAtomic(join12(artifacts.runDir, "resolved-workflow.json"), {
         spec: input.projectSpec ?? {
           ...input.request.spec_snapshot,
           hyperparameters: input.request.hyperparameters,
@@ -5660,7 +6890,7 @@ async function runLocalPipeline(input) {
         if (step.uses === "evaluate") {
           const isBase = step.with.model === "base";
           const report = isBase ? await runBaselineStage({ prepared, config: input.config, store, reporter: input.reporter, runReporter }) : await runCandidateStage({ prepared, config: input.config, store, reporter: input.reporter, runReporter });
-          const reportPath = join10(artifacts.runDir, "evaluations", `${step.id}.json`);
+          const reportPath = join12(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);
@@ -5679,7 +6909,8 @@ async function runLocalPipeline(input) {
           store,
           reporter: input.reporter,
           startedAt,
-          startedPerf
+          startedPerf,
+          specFile: input.specFile
         });
         return { request: input.request, pipeline, status: "completed", outputs, report, reportPath: artifacts.runReportJson, artifactDir: artifacts.runDir };
       }
@@ -5737,8 +6968,8 @@ async function runLocalFineTune(input) {
 
 // src/local-runtime/project-workflow.ts
 import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import { dirname as dirname10, join as join11, resolve as resolve14 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { dirname as dirname10, join as join13, resolve as resolve15 } from "path";
 function configForSpec(spec, specPath) {
   return parseLocalRunnerConfig({
     storeRoot: process.env.TT_LOCAL_HOME?.trim() ? expandUserPath(process.env.TT_LOCAL_HOME.trim()) : DEFAULT_PROJECT_STORE_ROOT,
@@ -5749,9 +6980,9 @@ function configForSpec(spec, specPath) {
 async function resolveProjectConfig(specPath, configPath, warn, loaded) {
   const input = loaded ?? (existsSync3(specPath) ? await loadLocalRunInput(specPath) : void 0);
   const spec = input && input.kind !== "request" ? input.spec : void 0;
-  const candidate = configPath ? resolve14(configPath) : join11(dirname10(resolve14(specPath)), "local-runner.json");
+  const candidate = configPath ? resolve15(configPath) : join13(dirname10(resolve15(specPath)), "local-runner.json");
   if (configPath || existsSync3(candidate)) {
-    const legacy = parseLocalRunnerConfig(JSON.parse(await readFile9(candidate, "utf8")), candidate);
+    const legacy = parseLocalRunnerConfig(JSON.parse(await readFile11(candidate, "utf8")), candidate);
     if (spec?.runtime || spec?.evaluation) {
       throw new Error("Conflicting configuration sources: tunedtensor.json contains runtime/evaluation settings and a legacy runner config is present. Migrate to tunedtensor.json; do not silently override the spec.");
     }
@@ -5881,6 +7112,9 @@ function trainingGpu(inventory) {
     if (!listed.memory_total_bytes && inventory.python?.total_memory_bytes) {
       return { ...listed, memory_total_bytes: inventory.python.total_memory_bytes };
     }
+    if (!listed.memory_total_bytes && (listed.unified_memory || isUnifiedGpuName(listed.name))) {
+      return { ...listed, memory_total_bytes: inventory.os.total_memory_bytes, unified_memory: true };
+    }
     return listed;
   }
   if (inventory.python?.cuda_device) {
@@ -6026,6 +7260,12 @@ function formatCapabilitySummary(report) {
 }
 function warningsFromSnapshot(report, target) {
   const warnings = [];
+  if (target.engine === "decision") {
+    if (!report.cuda_available) {
+      warnings.push("No CUDA GPU detected: decision training runs on CPU or Apple MPS (roughly 15 s per 8-example step on a 4-core CPU).");
+    }
+    return warnings;
+  }
   if (target.engine === "foundation") {
     for (const kind of ["train", "finetune"]) {
       const verdict = report.foundation[kind];
@@ -6058,7 +7298,7 @@ function warningsFromSnapshot(report, target) {
 import { constants as constants2 } from "fs";
 import { access as access2, statfs } from "fs/promises";
 import { cpus, freemem, homedir as homedir5, totalmem, type } from "os";
-import { dirname as dirname11, join as join12, resolve as resolve15 } from "path";
+import { dirname as dirname11, join as join14, resolve as resolve16 } from "path";
 import { spawn as spawn2 } from "child_process";
 async function runCommand(command, args, options = {}) {
   const timeoutMs = options.timeoutMs ?? 1e4;
@@ -6212,7 +7452,7 @@ async function queryNvidiaGpus(env) {
   return { result: table.code === 0 || !last ? table : last, gpus };
 }
 async function diskCheck(name, path) {
-  const resolvedPath = resolve15(path);
+  const resolvedPath = resolve16(path);
   try {
     await access2(resolvedPath, constants2.R_OK);
     const fs = await statfs(resolvedPath);
@@ -6313,10 +7553,10 @@ async function collectHostInventory(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const nodeVersion = process.versions.node;
   const nodeMajor = Number(nodeVersion.split(".")[0]);
-  const artifactRoot = resolve15(cwd, config?.artifactRoot ?? join12(cwd, DEFAULT_ARTIFACT_ROOT));
-  const storeRoot = resolve15(config?.storeRoot ?? defaultStoreRoot(env));
-  const modelCache = resolve15(
-    config?.paths.modelCache ?? env.HF_HOME ?? join12(homedir5(), ".cache", "huggingface")
+  const artifactRoot = resolve16(cwd, config?.artifactRoot ?? join14(cwd, DEFAULT_ARTIFACT_ROOT));
+  const storeRoot = resolve16(config?.storeRoot ?? defaultStoreRoot(env));
+  const modelCache = resolve16(
+    config?.paths.modelCache ?? env.HF_HOME ?? join14(homedir5(), ".cache", "huggingface")
   );
   const [artifactDisk, storeDisk, cacheDisk, uvVersion, nvidiaQueried] = await Promise.all([
     diskCheck("artifact-root", artifactRoot),
@@ -6362,17 +7602,17 @@ async function collectHostInventory(options = {}) {
 }
 
 // src/local-runtime/hardware-snapshot.ts
-import { chmod as chmod2, mkdir as mkdir10, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname12, join as join13 } from "path";
+import { chmod as chmod2, mkdir as mkdir12, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname12, join as join15 } from "path";
 var HARDWARE_SNAPSHOT_VERSION = 1;
 var HARDWARE_SNAPSHOT_TTL_MS = 24 * 60 * 60 * 1e3;
 function hardwareSnapshotPath(env = process.env) {
-  return join13(getTunedTensorHome(env), "hardware.json");
+  return join15(getTunedTensorHome(env), "hardware.json");
 }
 async function readHardwareSnapshot(env = process.env) {
   const path = hardwareSnapshotPath(env);
   try {
-    const parsed = JSON.parse(await readFile10(path, "utf8"));
+    const parsed = JSON.parse(await readFile12(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     const snapshot = parsed;
     if (snapshot.version !== HARDWARE_SNAPSHOT_VERSION) return void 0;
@@ -6389,7 +7629,7 @@ async function readHardwareSnapshot(env = process.env) {
 }
 async function writeHardwareSnapshot(snapshot, env = process.env) {
   const path = hardwareSnapshotPath(env);
-  await mkdir10(dirname12(path), { recursive: true, mode: 448 });
+  await mkdir12(dirname12(path), { recursive: true, mode: 448 });
   const gpu = snapshot.capabilities.gpu;
   const record = {
     version: HARDWARE_SNAPSHOT_VERSION,
@@ -6400,7 +7640,7 @@ async function writeHardwareSnapshot(snapshot, env = process.env) {
     capabilities: snapshot.capabilities,
     summary: snapshot.summary ?? formatCapabilitySummary(snapshot.capabilities)
   };
-  await writeFile7(path, `${JSON.stringify(record, null, 2)}
+  await writeFile8(path, `${JSON.stringify(record, null, 2)}
 `, { mode: 384 });
   await chmod2(path, 384);
   return record;
@@ -6459,7 +7699,61 @@ async function assessHardware(options = {}) {
   }, env);
 }
 
+// src/local-runtime/console-reporter.ts
+function shortValue(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) return `[${value.length} items]`;
+  return null;
+}
+function formatRunEvent(event) {
+  const detailText = Object.entries(event.details ?? {}).filter(([key]) => key !== "metrics").map(([key, value]) => {
+    const formatted = key === "command" && Array.isArray(value) ? value.join(" ") : shortValue(value);
+    return formatted ? `${key}=${formatted}` : null;
+  }).filter((value) => Boolean(value)).slice(0, 5).join(" ");
+  return sanitizeLogLine(`[tt] ${event.stage}: ${event.message}${detailText ? ` (${detailText})` : ""}`);
+}
+function elapsedLabel(milliseconds) {
+  const total = Math.max(0, Math.floor(milliseconds / 1e3));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  return `+${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+function createRunConsoleReporter(options = {}) {
+  const write = options.write ?? ((text) => {
+    process.stderr.write(text);
+  });
+  const now = options.now ?? (() => Date.now());
+  const started = now();
+  const stamp = (line) => line.replace(/^\[tt\] /, `[tt] ${elapsedLabel(now() - started)} `);
+  const progress = createProgressRenderer({ write, tty: progressTty(), columns: progressColumns() });
+  let lastLog = "";
+  return {
+    verbose: options.verbose ?? false,
+    onProgress(update) {
+      progress.update(update);
+    },
+    onEvent(event) {
+      progress.interrupt();
+      write(`${stamp(formatRunEvent(event))}
+`);
+    },
+    onLog(log) {
+      const line = sanitizeLogLine(`[tt] ${log.stage}${log.stream ? ` ${log.stream}` : ""}: ${log.message}`);
+      if (line === lastLog) return;
+      lastLog = line;
+      progress.interrupt();
+      write(`${stamp(line)}
+`);
+    }
+  };
+}
+
 export {
+  fileUri,
   assertArtifactManifest,
   TRAINING_MODELS,
   resolveTrainingModel,
@@ -6467,9 +7761,12 @@ export {
   defaultBaseModelRevision,
   resolveModelLoader,
   assertUsableModelArtifact,
+  DECISION_MODELS,
+  resolveDecisionModel,
   DEFAULT_ARTIFACT_ROOT,
   DEFAULT_PROJECT_STORE_ROOT,
   DEFAULT_FOUNDATION_RUNS_DIR,
+  DEFAULT_DECISION_RUNS_DIR,
   expandUserPath,
   getConfigDir,
   getAgentConfigDir,
@@ -6481,7 +7778,12 @@ export {
   behaviorSpecSchema,
   specSnapshotSchema,
   foundationHyperparametersSchema,
+  huggingFaceRepoIdSchema,
+  datasetColumnsSchema,
+  huggingFaceDatasetSourceSchema,
+  isRepoRelativePath,
   datasetPrebuiltSchema,
+  datasetSourceSchema,
   fineTuneHyperparametersSchema,
   fineTuneRunRequestSchema,
   evalExampleResultSchema,
@@ -6490,13 +7792,27 @@ export {
   evalReportSchema,
   comparisonReportSchema,
   trainingReportSchema,
+  runProvenanceSchema,
   runReportSchema,
   localRunnerConfigSchema,
   projectRuntimeSchema,
   localFoundationSpecFileSchema,
   localAdapterSpecFileSchema,
+  decisionQuestionSchema,
+  decisionHyperparametersSchema,
+  localDecisionSpecFileSchema,
+  decisionLabels,
   localBehaviorSpecFileSchema,
   isFoundationSpecFile,
+  isDecisionSpecFile,
+  normalizeChatJsonlForRelocation,
+  datasetInputIdentity,
+  buildSystemMessage,
+  exampleToChatRow,
+  compileSpecToJsonl,
+  examplesFromSpec,
+  examplesFromChatJsonl,
+  evaluationSuiteFromChatJsonl,
   validateEvalCases,
   DEFAULT_LOCAL_SPEC_PATH,
   localPathsOverlap,
@@ -6506,6 +7822,7 @@ export {
   generatedPlaceholderIssues,
   assertLocalRunInputReady,
   foundationPlaceholderIssues,
+  decisionPlaceholderIssues,
   assertFoundationSpecReady,
   runRequestFromLocalSpec,
   parseLocalRunInput,
@@ -6522,17 +7839,12 @@ export {
   canonicalJson2 as canonicalJson,
   isFoundationPipeline3 as isFoundationPipeline,
   parsePipeline3 as parsePipeline,
-  normalizeChatJsonlForRelocation,
-  buildSystemMessage,
-  exampleToChatRow,
-  compileSpecToJsonl,
-  examplesFromSpec,
-  examplesFromChatJsonl,
-  evaluationSuiteFromChatJsonl,
   reportInBackground,
   sanitizeLogLine,
   forwardStreamLines,
   localRuntimePackageRoot,
+  buildDecisionPythonCommand,
+  withDecisionPythonEnvironment,
   buildBundledPythonCommand,
   withBundledPythonEnvironment,
   buildFoundationPythonCommand,
@@ -6543,6 +7855,7 @@ export {
   withOfflineHuggingFaceCacheEnvironment,
   checkAwsGpu,
   runGpuProcess,
+  auditRun,
   isTerminalRunState,
   defaultLocalHome,
   localStorePaths,
@@ -6550,10 +7863,18 @@ export {
   writePrivateJsonAtomic,
   createLocalStore,
   tokenF1,
+  deriveSampleSeed,
+  splitSpecExamples,
+  compareEvalReports,
   verifyModelPrefetchCacheReport,
   buildModelPrefetchPayload,
+  safeName,
   verifyLocalBaseModel,
   prefetchBaseModel,
+  DatasetNotDownloadedError,
+  huggingFaceDataset,
+  prefetchHuggingFaceDataset,
+  ensureDatasetCached,
   evaluateGeneralRegressionGate,
   canonicalLocalPipeline,
   validateLocalPipeline,
@@ -6567,10 +7888,12 @@ export {
   runLocalFineTune,
   configForSpec,
   resolveProjectConfig,
+  evaluateCapabilities,
   warningsFromSnapshot,
   readHardwareSnapshot,
   formatHostStatusLine,
   formatAgentHostBlock,
-  assessHardware
+  assessHardware,
+  createRunConsoleReporter
 };
-//# sourceMappingURL=chunk-4Q54NHKR.js.map
+//# sourceMappingURL=chunk-4SUXBHIY.js.map