@tuned-tensor/cli 0.13.1-beta.3 → 0.13.1-beta.5

package/dist/{chunk-2P2RL23O.js → chunk-AVMRHDFY.js}

@@ -477,37 +477,37 @@ async function verifyTarGzipArchive(path) {
       if (sizeText && !/^[0-7]+$/.test(sizeText)) throw new Error(`Invalid tar member size in ${path}.`);
       const size = sizeText ? Number.parseInt(sizeText, 8) : 0;
       if (!Number.isSafeInteger(size) || size < 0) throw new Error(`Invalid tar member size in ${path}.`);
-      const type = String.fromCharCode(header[156] ?? 0);
-      if (type !== "\0" && type !== "0" && type !== "5" && type !== "x" && type !== "g") {
-        throw new Error(`Unsafe or unsupported tar member type ${JSON.stringify(type)} in ${path}.`);
+      const type2 = String.fromCharCode(header[156] ?? 0);
+      if (type2 !== "\0" && type2 !== "0" && type2 !== "5" && type2 !== "x" && type2 !== "g") {
+        throw new Error(`Unsafe or unsupported tar member type ${JSON.stringify(type2)} in ${path}.`);
       }
       const shortName = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
       const prefix = header.subarray(345, 500).toString("utf8").replace(/\0.*$/, "");
       const headerPath = safeMemberPath(prefix ? `${prefix}/${shortName}` : shortName);
-      const memberPath = type === "x" || type === "g" ? headerPath : safeMemberPath(pendingPaxPath ?? headerPath);
-      if (type !== "x" && type !== "g") pendingPaxPath = void 0;
+      const memberPath = type2 === "x" || type2 === "g" ? headerPath : safeMemberPath(pendingPaxPath ?? headerPath);
+      if (type2 !== "x" && type2 !== "g") pendingPaxPath = void 0;
       const segments = memberPath.split("/").filter(Boolean);
       const name = segments.at(-1)?.toLowerCase();
       const metadataOnly = name === "training-metrics.json" || name === "trainer_state.json" || name === "training_args.bin" || name === "config.json" || name === "generation_config.json" || name === "adapter_config.json" || name === "readme.md" || name?.startsWith("tokenizer") || name?.startsWith("special_tokens") || name?.startsWith("added_tokens") || name === "vocab.json" || name === "merges.txt";
       const recognizedPayload = Boolean(name) && name !== "training_args.bin" && (name.endsWith(".safetensors") || name.endsWith(".bin"));
       const adapterWeight = name === "adapter_model.safetensors" || name === "adapter_model.bin";
       const fullModelWeight = Boolean(name) && (name.endsWith(".safetensors") && !name.startsWith("adapter_") || /^pytorch_model.*\.bin$/.test(name));
-      if (size > 0 && name === "adapter_config.json" && (type === "\0" || type === "0")) {
+      if (size > 0 && name === "adapter_config.json" && (type2 === "\0" || type2 === "0")) {
         adapterConfigEntries += 1;
       }
-      if ((type === "x" || type === "g") && size > maxPaxBytes) {
+      if ((type2 === "x" || type2 === "g") && size > maxPaxBytes) {
         throw new Error(`PAX metadata exceeds 1 MiB in ${path}.`);
       }
-      if (size > 0 && !metadataOnly && (type === "\0" || type === "0")) payloadEntries += 1;
-      if (size > 0 && recognizedPayload && (type === "\0" || type === "0")) {
+      if (size > 0 && !metadataOnly && (type2 === "\0" || type2 === "0")) payloadEntries += 1;
+      if (size > 0 && recognizedPayload && (type2 === "\0" || type2 === "0")) {
         recognizedPayloadEntries += 1;
         recognizedPayloadBytes += size;
       }
-      if (size > 0 && adapterWeight && (type === "\0" || type === "0")) {
+      if (size > 0 && adapterWeight && (type2 === "\0" || type2 === "0")) {
         adapterWeightEntries += 1;
         adapterWeightBytes += size;
       }
-      if (size > 0 && fullModelWeight && (type === "\0" || type === "0")) {
+      if (size > 0 && fullModelWeight && (type2 === "\0" || type2 === "0")) {
         fullModelWeightEntries += 1;
         fullModelWeightBytes += size;
       }
@@ -515,7 +515,7 @@ async function verifyTarGzipArchive(path) {
       if (expandedBytes > maxExpandedBytes) throw new Error(`Tar archive exceeds 20 GiB expanded size: ${path}.`);
       payloadBytes = size;
       paddingBytes = (512 - size % 512) % 512;
-      paxType = type === "x" || type === "g" ? type : null;
+      paxType = type2 === "x" || type2 === "g" ? type2 : null;
       paxChunks = [];
       entries += 1;
       if (entries > maxEntries) throw new Error(`Tar archive exceeds ${maxEntries} members: ${path}.`);
@@ -834,717 +834,1233 @@ async function assertUsableModelArtifact(uri) {
   return inspection;
 }
 
-// src/local-runtime/contracts.ts
-import { z } from "zod";
-var datasetFormatSchema = z.literal("chat_jsonl");
-var baseModelRevisionSchema = z.string().regex(/^[0-9a-f]{40}$/i, "base_model_revision must be a 40-character Hugging Face commit SHA").transform((value) => value.toLowerCase());
-var behaviorSpecExampleSchema = z.object({
-  input: z.string().min(1),
-  output: z.string().min(1)
-}).strict();
-var specSnapshotSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().default(""),
-  system_prompt: z.string().default(""),
-  guidelines: z.array(z.string()).default([]),
-  examples: z.array(behaviorSpecExampleSchema).default([]),
-  constraints: z.array(z.string()).default([]),
-  base_model: z.string().transform((value) => canonicalizeTrainingModel(value))
-}).strict();
-var foundationHyperparametersSchema = z.object({
-  vocab_size: z.number().int().min(64).max(65536).default(256),
-  max_chars: z.number().int().min(1e3).max(2e9).default(2e4),
-  depth: z.number().int().min(1).max(64).default(2),
-  pretrain_steps: z.number().int().min(1).max(1e7).default(2),
-  finetune_steps: z.number().int().min(1).max(1e7).default(2),
-  rl_steps: z.number().int().min(0).max(1e7).default(0),
-  batch_size: z.number().int().min(1).max(1024).default(2),
-  sequence_length: z.number().int().min(16).max(8192).default(64),
-  nproc_per_node: z.number().int().min(1).max(16).default(1)
-}).strict();
-var localFoundationSpecFileSchema = z.object({
-  engine: z.literal("foundation"),
-  id: z.string().uuid().optional(),
-  name: z.string().min(1),
-  description: z.string().default(""),
-  system_prompt: z.string().default(""),
-  guidelines: z.array(z.string()).default([]),
-  examples: z.array(behaviorSpecExampleSchema).min(2),
-  constraints: z.array(z.string()).default([]),
-  foundation: foundationHyperparametersSchema
-}).strict();
-var datasetPrebuiltSchema = z.object({
-  training: z.string().min(1),
-  validation: z.string().min(1).optional(),
-  test: z.string().min(1).optional(),
-  format: datasetFormatSchema.default("chat_jsonl")
-}).strict().superRefine((dataset, context) => {
-  if (!dataset.validation && !dataset.test) {
-    context.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["validation"],
-      message: "Provide a distinct validation or test split for held-out evaluation"
-    });
+// src/local-runtime/run-reporter.ts
+function reportInBackground(action) {
+  try {
+    void Promise.resolve(action()).catch(() => void 0);
+  } catch {
   }
-});
-var fineTuneHyperparametersSchema = z.object({
-  n_epochs: z.number().int().min(1).max(20).default(1),
-  learning_rate: z.number().positive().optional(),
-  batch_size: z.number().int().min(1).optional(),
-  lora_rank: z.number().int().min(1).optional(),
-  lora_alpha: z.number().int().min(1).optional(),
-  lora_dropout: z.number().min(0).max(1).optional(),
-  max_seq_length: z.number().int().min(128).max(32768).optional(),
-  gradient_accumulation_steps: z.number().int().min(1).optional(),
-  max_eval_examples: z.number().int().min(1).optional(),
-  /** Immutable Hugging Face commit used by every stage of the run. */
-  base_model_revision: baseModelRevisionSchema.optional()
-}).strict();
-var fineTuneRunRequestSchema = z.object({
-  run_id: z.string().uuid(),
-  user_id: z.string().min(1),
-  behavior_spec_id: z.string().uuid(),
-  run_number: z.number().int().min(1),
-  spec_snapshot: specSnapshotSchema,
-  hyperparameters: fineTuneHyperparametersSchema.default({ n_epochs: 1 }),
-  dataset_prebuilt: datasetPrebuiltSchema.optional()
-}).strict().superRefine((request, context) => {
-  if (request.spec_snapshot.examples.length === 0 && !request.dataset_prebuilt) {
-    context.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["spec_snapshot", "examples"],
-      message: "Add examples or provide dataset_prebuilt training and validation files"
-    });
+}
+function sanitizeLogLine(line) {
+  return line.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|secret|password)=)[^\s]+/gi, "$1[redacted]");
+}
+function forwardStreamLines(stream, onLine) {
+  let buffered = "";
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk) => {
+    buffered += chunk;
+    const lines = buffered.split(/\r\n|\n|\r/);
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim()) onLine(sanitizeLogLine(line));
+    }
+  });
+  stream.on("end", () => {
+    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
+  });
+}
+
+// src/local-runtime/package-root.ts
+import { existsSync } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function localRuntimePackageRoot(moduleUrl) {
+  const moduleDirectory = dirname2(fileURLToPath2(moduleUrl));
+  const candidates = [
+    dirname2(moduleDirectory),
+    dirname2(dirname2(moduleDirectory))
+  ];
+  const root = candidates.find(
+    (candidate) => existsSync(resolve3(candidate, "package.json")) && existsSync(resolve3(candidate, "training/adapter"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
   }
-});
-var localAdapterSpecFileSchema = specSnapshotSchema.extend({
-  engine: z.literal("adapter").optional(),
-  id: z.string().uuid().optional(),
-  hyperparameters: fineTuneHyperparametersSchema.optional(),
-  dataset_prebuilt: datasetPrebuiltSchema.optional()
-}).strict();
-var localBehaviorSpecFileSchema = z.union([
-  localFoundationSpecFileSchema,
-  localAdapterSpecFileSchema
-]);
-var evalExampleResultSchema = z.object({
-  prompt: z.string(),
-  expected: z.string(),
-  actual: z.string(),
-  passed: z.boolean(),
-  score: z.number().min(0).max(1),
-  reasoning: z.string().nullable(),
-  latency_ms: z.number().int().nonnegative(),
-  scored_by: z.enum(["exact_match", "json_fields", "heuristic"]).optional()
-}).strict();
-var jsonFieldMetricsSchema = z.object({
-  fields: z.array(z.string()),
-  valid_json_count: z.number().int().nonnegative(),
-  valid_json_rate: z.number().min(0).max(1),
-  schema_match_count: z.number().int().nonnegative(),
-  schema_match_rate: z.number().min(0).max(1),
-  all_fields_match_count: z.number().int().nonnegative(),
-  all_fields_match_rate: z.number().min(0).max(1),
-  field_accuracy: z.record(z.string(), z.object({
-    correct: z.number().int().nonnegative(),
-    total: z.number().int().nonnegative(),
-    accuracy: z.number().min(0).max(1)
-  }).strict())
-}).strict();
-var evalSplitSchema = z.enum([
-  "spec_examples",
-  "spec_holdout",
-  "prebuilt_test",
-  "prebuilt_validation",
-  "general_regression"
-]);
-var evalReportSchema = z.object({
-  kind: z.enum(["baseline", "candidate"]),
-  model_id: z.string(),
-  total: z.number().int().nonnegative(),
-  eval_examples_total: z.number().int().nonnegative(),
-  eval_examples_used: z.number().int().nonnegative(),
-  eval_truncated: z.boolean(),
-  eval_split: evalSplitSchema.optional(),
-  eval_sample_seed: z.number().int().nullable().optional(),
-  avg_score: z.number().min(0).max(1),
-  pass_rate: z.number().min(0).max(1),
-  exact_match_rate: z.number().min(0).max(1),
-  avg_token_f1: z.number().min(0).max(1).optional(),
-  avg_latency_ms: z.number().int().nonnegative(),
-  cached: z.boolean().optional(),
-  cache_key: z.string().optional(),
-  results: z.array(evalExampleResultSchema),
-  artifact_uri: z.string(),
-  scoring_method: z.enum(["heuristic", "exact_match", "json_fields"]),
-  inference_provider: z.enum(["none", "transformers"]).optional(),
-  scoring_mode: z.enum(["exact_match", "json_fields"]).optional(),
-  json_field_metrics: jsonFieldMetricsSchema.optional(),
-  generation_config: z.record(z.string(), z.unknown()).optional(),
-  log_uri: z.string().optional()
-}).strict();
-var comparisonReportSchema = z.object({
-  avg_score_delta: z.number(),
-  pass_rate_delta: z.number(),
-  exact_match_rate_delta: z.number(),
-  token_f1_delta: z.number().optional(),
-  regressions: z.number().int().nonnegative(),
-  improvements: z.number().int().nonnegative(),
-  regressed_examples: z.array(z.object({
-    prompt: z.string(),
-    old_score: z.number(),
-    new_score: z.number()
-  }).strict())
-}).strict();
-var trainingReportSchema = z.object({
-  provider: z.literal("local-uv"),
-  training_job_name: z.string(),
-  model_artifact_uri: z.string().optional(),
-  base_model_artifact_uri: z.string().optional(),
-  metrics: z.record(z.string(), z.unknown()).nullable(),
-  exit_code: z.number().int().nullable(),
-  log_uri: z.string(),
-  command: z.array(z.string()).optional()
-}).strict();
-var runReportSchema = z.object({
-  run_id: z.string().uuid(),
-  behavior_spec_id: z.string().uuid(),
-  user_id: z.string(),
-  run_number: z.number().int().min(1),
-  base_model: z.string(),
-  fine_tuned_model_id: z.string(),
-  status: z.enum(["completed", "failed"]),
-  baseline: evalReportSchema,
-  candidate: evalReportSchema,
-  comparison: comparisonReportSchema,
-  general_regression: z.object({
-    dataset_uri: z.string(),
-    dataset_sha256: z.string().regex(/^[a-f0-9]{64}$/),
-    baseline: evalReportSchema,
-    candidate: evalReportSchema,
-    comparison: comparisonReportSchema,
-    policy: z.object({
-      max_score_drop: z.number().min(0).max(1),
-      max_pass_rate_drop: z.number().min(0).max(1)
-    }).strict(),
-    passed: z.boolean(),
-    failures: z.array(z.string())
-  }).strict().optional(),
-  training: trainingReportSchema,
-  artifact_uris: z.object({
-    dataset: z.string(),
-    baseline_eval: z.string(),
-    candidate_eval: z.string(),
-    general_baseline_eval: z.string().optional(),
-    general_candidate_eval: z.string().optional(),
-    report: z.string()
-  }).strict(),
-  run_metadata: z.object({
-    base_model: z.string(),
-    fine_tuned_model_id: z.string(),
-    dataset_prebuilt: z.boolean(),
-    dataset_format: datasetFormatSchema.nullable().optional(),
-    dataset_uri: z.string(),
-    spec_example_count: z.number().int().nonnegative(),
-    training_example_count: z.number().int().nonnegative().nullable(),
-    eval_examples_total: z.number().int().nonnegative(),
-    eval_examples_used: z.number().int().nonnegative(),
-    eval_split: evalSplitSchema.optional(),
-    eval_sample_seed: z.number().int().nullable().optional(),
-    started_at: z.string(),
-    completed_at: z.string(),
-    elapsed_ms: z.number().int().nonnegative(),
-    elapsed_seconds: z.number().nonnegative()
-  }).strict(),
-  created_at: z.string()
-}).strict();
-var inferenceConfigSchema = z.object({
-  maxNewTokens: z.number().int().min(1).default(256),
-  temperature: z.number().min(0).default(0),
-  topP: z.number().min(0).max(1).default(1),
-  device: z.enum(["cuda", "cpu"]).default("cuda")
-}).strict();
-var scoringConfigSchema = z.object({
-  mode: z.enum(["exact_match", "json_fields"]).default("exact_match"),
-  fields: z.array(z.string().min(1)).optional()
-}).strict();
-var evaluationConfigSchema = z.object({
-  inference: inferenceConfigSchema.default({
-    maxNewTokens: 256,
-    temperature: 0,
-    topP: 1,
-    device: "cuda"
-  }),
-  scoring: scoringConfigSchema.default({ mode: "exact_match" }),
-  timeoutMs: z.number().int().min(100).default(18e5),
-  maxExamples: z.number().int().min(1).optional(),
-  sampleSeed: z.number().int().optional(),
-  baselineCache: z.boolean().default(true),
-  generalRegression: z.object({
-    dataset: z.string().min(1),
-    systemPrompt: z.string().optional(),
-    maxScoreDrop: z.number().min(0).max(1).default(0.03),
-    maxPassRateDrop: z.number().min(0).max(1).default(0.05)
-  }).strict().optional()
-}).strict();
-var localRunnerConfigSchema = z.object({
-  storeRoot: z.string().optional(),
-  artifactRoot: z.string().default(".tt-local/artifacts"),
-  dryRun: z.boolean().default(false),
-  paths: z.object({
-    baseModel: z.string().optional(),
-    modelCache: z.string().optional()
-  }).strict().default({}),
-  evaluation: evaluationConfigSchema.default({
-    inference: {
-      maxNewTokens: 256,
-      temperature: 0,
-      topP: 1,
-      device: "cuda"
-    },
-    scoring: { mode: "exact_match" },
-    timeoutMs: 18e5,
-    baselineCache: true
-  })
-}).strict();
-function isFoundationSpecFile(spec) {
-  return spec.engine === "foundation";
+  return root;
 }
 
-// src/local-runtime/local-project.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+// src/local-runtime/capability-profiles.ts
+var GIB = 1024 ** 3;
+function gib(n) {
+  return Math.round(n * GIB);
+}
+var FOUNDATION_DEFAULT_DEPTH = 2;
+var FOUNDATION_MAX_DEPTH = 64;
+var FOUNDATION_DEFAULT_VOCAB = 256;
+var FOUNDATION_DEFAULT_SEQUENCE = 64;
+var FOUNDATION_DEFAULT_BATCH = 2;
+var ADAPTER_MEMORY_PROFILES = [
+  {
+    id: "Qwen/Qwen3.5-2B",
+    diskBytes: gib(8),
+    inferenceBytes: gib(8),
+    trainBytes: gib(16),
+    sparkClass: false
+  },
+  {
+    id: "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16",
+    diskBytes: gib(80),
+    inferenceBytes: gib(80),
+    trainBytes: gib(96),
+    sparkClass: true
+  },
+  {
+    id: "meta-models/Muse-Glimmer-30B",
+    diskBytes: gib(80),
+    inferenceBytes: gib(80),
+    trainBytes: gib(96),
+    sparkClass: true
+  }
+];
+function adapterMemoryProfile(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  return ADAPTER_MEMORY_PROFILES.find((profile) => profile.id.toLowerCase() === normalized);
+}
+function foundationWidth(depth) {
+  return 32 * depth;
+}
+function foundationParamCount(depth, vocabSize = FOUNDATION_DEFAULT_VOCAB, sequenceLength = FOUNDATION_DEFAULT_SEQUENCE) {
+  const width = foundationWidth(depth);
+  return 12 * depth * width * width + vocabSize * width + sequenceLength * width;
+}
+function foundationTrainBytes(depth, options = {}) {
+  const vocabSize = options.vocabSize ?? FOUNDATION_DEFAULT_VOCAB;
+  const sequenceLength = options.sequenceLength ?? FOUNDATION_DEFAULT_SEQUENCE;
+  const batchSize = options.batchSize ?? FOUNDATION_DEFAULT_BATCH;
+  const params = foundationParamCount(depth, vocabSize, sequenceLength);
+  const width = foundationWidth(depth);
+  const activationSlack = batchSize * sequenceLength * width * depth * 64;
+  return 16 * params + activationSlack;
+}
+function foundationInferenceBytes(depth, options = {}) {
+  const params = foundationParamCount(
+    depth,
+    options.vocabSize ?? FOUNDATION_DEFAULT_VOCAB,
+    options.sequenceLength ?? FOUNDATION_DEFAULT_SEQUENCE
+  );
+  return 4 * params + gib(0.25);
+}
+function isUnifiedGpuName(name) {
+  if (!name) return false;
+  return /spark|gb10/i.test(name);
+}
+
+// src/local-runtime/capability.ts
+var HEADROOM = 1.2;
+var FIT_RATIO = 0.7;
+function formatGiB(bytes) {
+  const amount = bytes / 1024 ** 3;
+  const precision = amount >= 10 ? 0 : 1;
+  return `${amount.toFixed(precision)} GiB`;
+}
+function compareFit(available, required, missing) {
+  if (available === void 0) {
+    return { status: "not_possible", reason: missing, required_bytes: required };
+  }
+  if (available < required) {
+    return {
+      status: "not_possible",
+      reason: `needs ~${formatGiB(required)}; ${formatGiB(available)} available`,
+      required_bytes: required,
+      available_bytes: available
+    };
+  }
+  if (available < required * HEADROOM) {
+    return {
+      status: "tight",
+      reason: `fits in ${formatGiB(available)} with little headroom (needs ~${formatGiB(required)})`,
+      required_bytes: required,
+      available_bytes: available
+    };
+  }
+  return {
+    status: "ready",
+    reason: `${formatGiB(available)} available (needs ~${formatGiB(required)})`,
+    required_bytes: required,
+    available_bytes: available
+  };
+}
+function trainingBlockers(inventory) {
+  const blockers = [];
+  if (!inventory.node.ok) blockers.push(`Node ${inventory.node.version} is below 22`);
+  if (inventory.uv && !inventory.uv.ok) blockers.push(inventory.uv.message);
+  if (inventory.python && !inventory.python.ok) blockers.push(inventory.python.message);
+  return blockers;
+}
+function cudaAvailable(inventory) {
+  if (inventory.python?.ok && inventory.python.cuda_available !== void 0) {
+    return inventory.python.cuda_available;
+  }
+  return inventory.nvidia_smi.ok && inventory.gpus.length > 0;
+}
+function trainingGpu(inventory) {
+  const listed = inventory.gpus.find((gpu) => gpu.index === 0) ?? inventory.gpus[0];
+  if (listed) {
+    if (!listed.memory_total_bytes && inventory.python?.total_memory_bytes) {
+      return { ...listed, memory_total_bytes: inventory.python.total_memory_bytes };
+    }
+    return listed;
+  }
+  if (inventory.python?.cuda_device) {
+    return {
+      index: 0,
+      name: inventory.python.cuda_device,
+      memory_total_bytes: inventory.python.total_memory_bytes,
+      unified_memory: isUnifiedGpuName(inventory.python.cuda_device)
+    };
+  }
+  return void 0;
+}
+function gpuMemory(gpu) {
+  return gpu?.memory_total_bytes;
+}
+function diskForCache(inventory) {
+  return inventory.disks.find((disk) => disk.name === "model-cache")?.free_bytes;
+}
+function worse(left, right) {
+  const rank = { not_possible: 2, tight: 1, ready: 0 };
+  return rank[left.status] >= rank[right.status] ? left : right;
+}
+function withBlockers(verdict, blockers) {
+  if (blockers.length === 0) return verdict;
+  return {
+    status: "not_possible",
+    reason: blockers.join("; "),
+    required_bytes: verdict.required_bytes,
+    available_bytes: verdict.available_bytes
+  };
+}
+function adapterVerdicts(profile, inventory, gpu, hasCuda) {
+  const blockers = trainingBlockers(inventory);
+  const gpuBytes = gpuMemory(gpu);
+  const ram = inventory.os.total_memory_bytes;
+  const disk = diskForCache(inventory);
+  let train;
+  if (!hasCuda) {
+    train = {
+      status: "not_possible",
+      reason: "LoRA training requires CUDA",
+      required_bytes: profile.trainBytes
+    };
+  } else {
+    train = compareFit(gpuBytes, profile.trainBytes, "GPU memory is unknown");
+  }
+  train = withBlockers(train, blockers);
+  if (disk !== void 0 && disk < profile.diskBytes && train.status !== "not_possible") {
+    train = worse(train, compareFit(disk, profile.diskBytes, "model cache disk is unknown"));
+  }
+  const finetune = train;
+  let inference;
+  if (hasCuda) {
+    inference = compareFit(gpuBytes, profile.inferenceBytes, "GPU memory is unknown");
+  } else {
+    inference = compareFit(ram, profile.inferenceBytes, "system RAM is unknown");
+    if (inference.status !== "not_possible") {
+      inference = {
+        ...inference,
+        reason: `CPU inference: ${inference.reason}`
+      };
+    }
+  }
+  return {
+    id: profile.id,
+    spark_class: profile.sparkClass,
+    train,
+    finetune,
+    inference
+  };
+}
+function suggestedFoundationDepth(availableBytes) {
+  if (availableBytes === void 0) return FOUNDATION_DEFAULT_DEPTH;
+  const budget = availableBytes * FIT_RATIO;
+  let suggested = FOUNDATION_DEFAULT_DEPTH;
+  for (let depth = FOUNDATION_DEFAULT_DEPTH; depth <= FOUNDATION_MAX_DEPTH; depth += 1) {
+    if (foundationTrainBytes(depth) <= budget) suggested = depth;
+    else break;
+  }
+  return suggested;
+}
+function evaluateCapabilities(inventory) {
+  const hasCuda = cudaAvailable(inventory);
+  const gpu = trainingGpu(inventory);
+  const notes = [];
+  if (gpu?.unified_memory || isUnifiedGpuName(gpu?.name)) {
+    notes.push("GPU memory is a unified pool shared with system RAM (Spark-class).");
+  }
+  if (inventory.quick) {
+    notes.push("Quick probe skipped the bundled torch/uv runtime.");
+  }
+  if (!inventory.node.ok) {
+    notes.push(`Node ${inventory.node.version} is below the 22.x required by the local runner.`);
+  }
+  const adapters = ADAPTER_MEMORY_PROFILES.map(
+    (profile) => adapterVerdicts(profile, inventory, gpu, hasCuda)
+  );
+  const blockers = trainingBlockers(inventory);
+  const gpuBytes = gpuMemory(gpu);
+  const ram = inventory.os.total_memory_bytes;
+  const trainBudget = hasCuda ? gpuBytes : void 0;
+  const suggested = suggestedFoundationDepth(trainBudget);
+  const defaultTrain = foundationTrainBytes(FOUNDATION_DEFAULT_DEPTH);
+  const inferBudget = hasCuda ? gpuBytes : ram;
+  let train;
+  if (!hasCuda) {
+    train = {
+      status: "not_possible",
+      reason: "Foundation pretrain, SFT, and RL require CUDA",
+      required_bytes: defaultTrain
+    };
+  } else {
+    train = compareFit(gpuBytes, defaultTrain, "GPU memory is unknown");
+  }
+  train = withBlockers(train, blockers);
+  const inference = compareFit(
+    inferBudget,
+    foundationInferenceBytes(FOUNDATION_DEFAULT_DEPTH),
+    hasCuda ? "GPU memory is unknown" : "system RAM is unknown"
+  );
+  const foundation = {
+    default_depth: FOUNDATION_DEFAULT_DEPTH,
+    suggested_max_depth: hasCuda && blockers.length === 0 ? suggested : FOUNDATION_DEFAULT_DEPTH,
+    train,
+    finetune: train,
+    inference: hasCuda ? inference : { ...inference, reason: `CPU eval: ${inference.reason}` },
+    serve: {
+      status: "not_possible",
+      reason: "tt serve cannot host foundation checkpoints yet"
+    }
+  };
+  return { cuda_available: hasCuda, gpu, adapters, foundation, notes };
+}
+function formatCapabilitySummary(report) {
+  const gpu = report.gpu;
+  const gpuLabel = gpu ? `${gpu.name}${gpu.memory_total_bytes ? `, ${formatGiB(gpu.memory_total_bytes)}` : ""}${gpu.unified_memory ? " unified" : ""}` : "no NVIDIA GPU";
+  const adapterBits = report.adapters.map((adapter) => {
+    const short = adapter.id.split("/").at(-1) ?? adapter.id;
+    return `${short} train ${adapter.train.status}`;
+  });
+  return [
+    `GPU ${gpuLabel}, CUDA ${report.cuda_available ? "yes" : "no"}`,
+    `Adapter: ${adapterBits.join("; ")}`,
+    `Foundation: train ${report.foundation.train.status}, suggested max depth ${report.foundation.suggested_max_depth}; serve not supported`
+  ].join(". ");
+}
+function warningsFromSnapshot(report, target) {
+  const warnings = [];
+  if (target.engine === "foundation") {
+    for (const kind of ["train", "finetune"]) {
+      const verdict = report.foundation[kind];
+      if (verdict.status === "not_possible" || verdict.status === "tight") {
+        warnings.push(`Foundation ${kind} is ${verdict.status}: ${verdict.reason}`);
+      }
+    }
+    return warnings;
+  }
+  const modelId = target.baseModel;
+  const adapter = modelId ? report.adapters.find((item) => item.id.toLowerCase() === modelId.trim().toLowerCase()) : void 0;
+  if (!adapter) {
+    if (modelId && !adapterMemoryProfile(modelId)) return warnings;
+    const blocked = report.adapters.filter((item) => item.train.status === "not_possible");
+    if (blocked.length === report.adapters.length) {
+      warnings.push(`Adapter train is not_possible: ${report.adapters[0]?.train.reason ?? "CUDA required"}`);
+    }
+    return warnings;
+  }
+  for (const kind of ["train", "finetune", "inference"]) {
+    const verdict = adapter[kind];
+    if (verdict.status === "not_possible" || verdict.status === "tight") {
+      warnings.push(`${adapter.id} ${kind} is ${verdict.status}: ${verdict.reason}`);
+    }
+  }
+  return warnings;
+}
+
+// src/local-runtime/host-inventory.ts
+import { constants } from "fs";
+import { access, statfs } from "fs/promises";
+import { cpus, freemem, homedir as homedir3, totalmem, type } from "os";
+import { dirname as dirname5, join as join5, resolve as resolve7 } from "path";
+import { spawn as spawn2 } from "child_process";
+
+// src/paths.ts
+import { existsSync as existsSync2 } from "fs";
 import { homedir } from "os";
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve4 } from "path";
+var TUNED_TENSOR_DIR = ".tuned-tensor";
+var DEFAULT_ARTIFACT_ROOT = `${TUNED_TENSOR_DIR}/artifacts`;
+var DEFAULT_PROJECT_STORE_ROOT = `${TUNED_TENSOR_DIR}/store`;
+var DEFAULT_FOUNDATION_RUNS_DIR = `${TUNED_TENSOR_DIR}/foundation-runs`;
+function envHome(env = process.env) {
+  const home = env.HOME?.trim();
+  return home ? resolve4(home) : homedir();
+}
+function expandUserPath(value, env = process.env, baseDirectory = process.cwd()) {
+  const trimmed = value.trim();
+  if (trimmed === "~") return envHome(env);
+  if (trimmed.startsWith("~/")) return resolve4(envHome(env), trimmed.slice(2));
+  return isAbsolute2(trimmed) ? resolve4(trimmed) : resolve4(baseDirectory, trimmed);
+}
+function getTunedTensorHome(env = process.env) {
+  const override = env.TUNED_TENSOR_HOME?.trim();
+  if (override) return expandUserPath(override, env);
+  return join2(envHome(env), TUNED_TENSOR_DIR);
+}
+function legacyConfigDir(env) {
+  const configHome = env.XDG_CONFIG_HOME?.trim() ? resolve4(env.XDG_CONFIG_HOME) : join2(envHome(env), ".config");
+  return join2(configHome, "tuned-tensor");
+}
+function getConfigDir(env = process.env) {
+  const next = getTunedTensorHome(env);
+  if (env.TUNED_TENSOR_HOME?.trim()) return next;
+  const legacy = legacyConfigDir(env);
+  if (!existsSync2(join2(next, "config.json")) && existsSync2(join2(legacy, "config.json"))) {
+    return legacy;
+  }
+  return next;
+}
+function getAgentConfigDir(env = process.env) {
+  const next = join2(getTunedTensorHome(env), "agent");
+  if (env.TUNED_TENSOR_HOME?.trim()) return next;
+  const legacy = join2(legacyConfigDir(env), "agent");
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
+  return next;
+}
+function defaultStoreRoot(env = process.env) {
+  const override = env.TT_LOCAL_HOME?.trim();
+  if (override) return expandUserPath(override, env);
+  const next = join2(getTunedTensorHome(env), "store");
+  if (env.TUNED_TENSOR_HOME?.trim()) return next;
+  const legacy = join2(envHome(env), ".tuned-tensor-local");
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
+  return next;
+}
+function defaultCacheRoot(env = process.env) {
+  return join2(getTunedTensorHome(env), "cache");
+}
+function pythonEnvironmentPath(kind, hash, env = process.env) {
+  const next = join2(defaultCacheRoot(env), kind, hash);
+  if (env.TUNED_TENSOR_HOME?.trim()) return next;
+  const cacheHome = env.XDG_CACHE_HOME?.trim() ? resolve4(env.XDG_CACHE_HOME) : join2(envHome(env), ".cache");
+  const legacy = join2(cacheHome, "tuned-tensor-local", kind, hash);
+  if (!existsSync2(next) && existsSync2(legacy)) return legacy;
+  return next;
+}
+
+// src/local-runtime/huggingface-cache.ts
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve5 } from "path";
+function minimalMachineLearningEnvironment(env) {
+  const exact = /* @__PURE__ */ new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "LANG",
+    "LANGUAGE",
+    "LD_LIBRARY_PATH",
+    "DYLD_LIBRARY_PATH",
+    "XDG_CACHE_HOME",
+    "SSL_CERT_FILE",
+    "REQUESTS_CA_BUNDLE",
+    "CURL_CA_BUNDLE",
+    "NO_PROXY",
+    "no_proxy",
+    "UV_CACHE_DIR",
+    "UV_PYTHON",
+    "HF_HOME",
+    "HF_HUB_CACHE",
+    "HUGGINGFACE_HUB_CACHE",
+    "HF_ENDPOINT",
+    "HF_TOKEN",
+    "HF_HUB_OFFLINE",
+    "HF_HUB_DISABLE_TELEMETRY",
+    "TRANSFORMERS_OFFLINE",
+    "HF_HUB_ENABLE_HF_TRANSFER",
+    "PYTHONUTF8",
+    "PYTHONIOENCODING"
+  ]);
+  const prefixes = [
+    "LC_",
+    "CUDA_",
+    "NVIDIA_",
+    "NCCL_",
+    "OMP_",
+    "MKL_",
+    "TORCH_",
+    "PYTORCH_",
+    "TOKENIZERS_",
+    "HF_XET_"
+  ];
+  const result = Object.fromEntries(Object.entries(env).filter(
+    ([key]) => exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix))
+  ));
+  result.TORCH_DISABLE_NATIVE_JIT ??= "1";
+  return result;
+}
+function resolveHuggingFaceCacheLayout(modelCache) {
+  const hfHome = resolve5(modelCache);
+  return {
+    hfHome,
+    hubCache: join3(hfHome, "hub")
+  };
+}
+function withHuggingFaceCacheEnvironment(env, modelCache) {
+  const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
+  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname3(resolve5(inheritedHub)) : join3(homedir2(), ".cache", "huggingface"));
+  const layout = resolveHuggingFaceCacheLayout(canonicalHome);
+  const result = {
+    ...env,
+    HF_HOME: layout.hfHome,
+    HF_HUB_CACHE: layout.hubCache,
+    HUGGINGFACE_HUB_CACHE: layout.hubCache
+  };
+  delete result.TRANSFORMERS_CACHE;
+  delete result.PYTORCH_TRANSFORMERS_CACHE;
+  delete result.PYTORCH_PRETRAINED_BERT_CACHE;
+  return result;
+}
+function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
+  return {
+    ...withHuggingFaceCacheEnvironment(env, modelCache),
+    HF_HUB_OFFLINE: "1",
+    TRANSFORMERS_OFFLINE: "1"
+  };
+}
+
+// src/local-runtime/process-runner.ts
+import { createHash as createHash2 } from "crypto";
+import { spawn } from "child_process";
+import { createWriteStream, readFileSync } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
-function resolveLocalReference(value, baseDirectory) {
-  if (typeof value !== "string" || !value || isAbsolute2(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
-    return value;
+import { dirname as dirname4, join as join4, resolve as resolve6 } from "path";
+var packageRoot = localRuntimePackageRoot(import.meta.url);
+var bundledProject = join4(packageRoot, "training/adapter");
+var bundledRuntimeHash = (() => {
+  const hash = createHash2("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join4(bundledProject, name)));
   }
-  if (value === "~") return homedir();
-  if (value.startsWith("~/")) return resolve3(homedir(), value.slice(2));
-  return resolve3(baseDirectory, value);
-}
-function resolveLocalRunInputPaths(raw, inputPath) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
-  const baseDirectory = dirname2(resolve3(inputPath));
-  const value = structuredClone(raw);
-  const dataset = value.dataset_prebuilt;
-  if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
-    const fields = dataset;
-    for (const key of ["training", "validation", "test"]) {
-      if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
-    }
+  return hash.digest("hex").slice(0, 20);
+})();
+var BUNDLED_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv", bundledRuntimeHash);
+var foundationProject = join4(packageRoot, "training/foundation");
+var foundationRuntimeHash = (() => {
+  const hash = createHash2("sha256");
+  for (const name of ["pyproject.toml", "uv.lock"]) {
+    hash.update(readFileSync(join4(foundationProject, name)));
   }
-  return value;
+  return hash.digest("hex").slice(0, 20);
+})();
+var FOUNDATION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-foundation", foundationRuntimeHash);
+function buildBundledPythonCommand(entrypoint, args = []) {
+  const target = entrypoint === "-c" ? entrypoint : join4(bundledProject, "src", entrypoint);
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--quiet",
+    "--project",
+    bundledProject,
+    "python",
+    target,
+    ...args
+  ];
+  return {
+    command: "uv",
+    commandArgs,
+    displayCommand: ["uv", ...commandArgs]
+  };
 }
-async function exists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch {
-    return false;
-  }
+function withBundledPythonEnvironment(env) {
+  return {
+    ...env,
+    UV_PROJECT_ENVIRONMENT: BUNDLED_PYTHON_ENVIRONMENT
+  };
 }
-async function initLocalSpecFile(args) {
-  if (!args.force && await exists(args.outputPath)) {
-    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
+function buildFoundationPythonCommand(entrypoint, args = []) {
+  const commandArgs = [
+    "run",
+    "--frozen",
+    "--quiet",
+    "--project",
+    foundationProject,
+    "python",
+    join4(foundationProject, "src", entrypoint),
+    ...args
+  ];
+  return {
+    command: "uv",
+    commandArgs,
+    displayCommand: ["uv", ...commandArgs]
+  };
+}
+function withFoundationPythonEnvironment(env) {
+  return {
+    ...env,
+    UV_PROJECT_ENVIRONMENT: FOUNDATION_PYTHON_ENVIRONMENT
+  };
+}
+var ProcessCancelledError = class extends Error {
+  constructor(message = "Process cancelled.") {
+    super(message);
+    this.name = "ProcessCancelledError";
   }
-  if (args.engine === "foundation") {
-    const spec2 = localFoundationSpecFileSchema.parse({
-      engine: "foundation",
-      id: randomUUID2(),
-      name: args.name,
-      description: "From-scratch tokenizer, pretrain, chat SFT, and eval.",
-      system_prompt: "You are a helpful assistant.",
-      guidelines: [
-        "Answer the user request directly."
-      ],
-      constraints: [],
-      examples: [
-        {
-          input: "Replace this with representative chat input.",
-          output: "Replace this with the expected assistant reply."
-        },
-        {
-          input: "Replace this with a different chat input.",
-          output: "Replace this with the expected assistant reply."
+};
+async function openProcessLog(path, exclusive) {
+  const stream = createWriteStream(path, {
+    flags: exclusive ? "wx" : "w",
+    mode: 384
+  });
+  await new Promise((resolveOpen, reject) => {
+    const onOpen = () => {
+      stream.off("error", onError);
+      resolveOpen();
+    };
+    const onError = (error) => {
+      stream.off("open", onOpen);
+      reject(error);
+    };
+    stream.once("open", onOpen);
+    stream.once("error", onError);
+  });
+  return stream;
+}
+async function runLoggedProcess(args) {
+  if (args.logPath) await mkdir2(dirname4(args.logPath), { recursive: true });
+  const logStream = args.logPath ? await openProcessLog(args.logPath, args.exclusiveLog ?? false) : null;
+  let stderr = "";
+  try {
+    const exitCode = await new Promise((resolvePromise, reject) => {
+      const child = spawn(args.command, args.commandArgs, {
+        cwd: args.cwd ? resolve6(args.cwd) : process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"],
+        env: args.env ?? process.env,
+        detached: process.platform !== "win32"
+      });
+      let timedOut = false;
+      let cancelled = false;
+      let cancellationError;
+      let cancellationCheckRunning = false;
+      let forceKillTimer = null;
+      const killProcessGroup = (signal) => {
+        if (child.pid && process.platform !== "win32") {
+          try {
+            process.kill(-child.pid, signal);
+            return;
+          } catch {
+          }
         }
-      ],
-      foundation: {
-        depth: 2,
-        pretrain_steps: 2,
-        finetune_steps: 2,
-        rl_steps: 0,
-        vocab_size: 256,
-        max_chars: 2e4,
-        sequence_length: 64,
-        batch_size: 2,
-        nproc_per_node: 1
-      }
-    });
-    await mkdir2(dirname2(args.outputPath), { recursive: true });
-    await writeFile2(args.outputPath, `${JSON.stringify(spec2, null, 2)}
-`, "utf8");
-    return spec2;
-  }
-  if (!args.baseModel) {
-    throw new Error("Adapter specs require --model.");
-  }
-  const spec = localAdapterSpecFileSchema.parse({
-    id: randomUUID2(),
-    name: args.name,
-    description: "",
-    system_prompt: "Describe the behavior this local model should learn.",
-    guidelines: [
-      "Return concise, task-specific answers."
-    ],
-    constraints: [],
-    base_model: args.baseModel,
-    examples: [
-      {
-        input: "Replace this with representative training input.",
-        output: "Replace this with the expected training output."
-      },
-      {
-        input: "Replace this with a different validation input.",
-        output: "Replace this with the expected validation output."
+        child.kill(signal);
+      };
+      const requestStop = (signal = "SIGTERM") => {
+        killProcessGroup(signal);
+        if (!forceKillTimer) {
+          forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), 5e3);
+          forceKillTimer.unref();
+        }
+      };
+      const onSigint = () => {
+        cancelled = true;
+        requestStop("SIGINT");
+      };
+      const onSigterm = () => {
+        cancelled = true;
+        requestStop("SIGTERM");
+      };
+      process.once("SIGINT", onSigint);
+      process.once("SIGTERM", onSigterm);
+      const timer = args.timeoutMs ? setTimeout(() => {
+        timedOut = true;
+        requestStop();
+      }, args.timeoutMs) : null;
+      const cancellationTimer = args.shouldCancel ? setInterval(() => {
+        if (cancellationCheckRunning || cancelled) return;
+        cancellationCheckRunning = true;
+        Promise.resolve(args.shouldCancel?.()).then((requested) => {
+          if (!requested || cancelled) return;
+          cancelled = true;
+          requestStop();
+        }).catch((error) => {
+          cancellationError = error;
+          requestStop();
+        }).finally(() => {
+          cancellationCheckRunning = false;
+        });
+      }, args.cancelPollMs ?? 250) : null;
+      cancellationTimer?.unref();
+      const clearProcessTimers = () => {
+        if (timer) clearTimeout(timer);
+        if (cancellationTimer) clearInterval(cancellationTimer);
+        if (forceKillTimer) clearTimeout(forceKillTimer);
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+      };
+      if (logStream) {
+        child.stdout.pipe(logStream, { end: false });
+        child.stderr.pipe(logStream, { end: false });
       }
-    ],
-    hyperparameters: {
-      n_epochs: 1
+      forwardStreamLines(child.stdout, (line) => {
+        args.onLine?.(line, "stdout");
+        if (args.reporter?.verbose) {
+          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stdout", message: line }));
+        }
+      });
+      forwardStreamLines(child.stderr, (line) => {
+        stderr += `${line}
+`;
+        args.onLine?.(line, "stderr");
+        if (args.reporter?.verbose) {
+          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stderr", message: line }));
+        }
+      });
+      child.on("error", (error) => {
+        clearProcessTimers();
+        reject(timedOut ? new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`) : error);
+      });
+      child.on("close", (code) => {
+        if (timedOut || cancelled || cancellationError || args.terminateProcessGroupOnExit) {
+          killProcessGroup("SIGKILL");
+        }
+        clearProcessTimers();
+        if (timedOut) {
+          reject(new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`));
+          return;
+        }
+        if (cancellationError) {
+          reject(cancellationError);
+          return;
+        }
+        if (cancelled) {
+          reject(new ProcessCancelledError(`${args.stage} was cancelled.`));
+          return;
+        }
+        resolvePromise(code ?? 1);
+      });
+    });
+    return { exitCode, stderr };
+  } finally {
+    if (logStream) {
+      await new Promise((resolveEnd) => {
+        logStream.end(resolveEnd);
+      });
     }
-  });
-  await mkdir2(dirname2(args.outputPath), { recursive: true });
-  await writeFile2(args.outputPath, `${JSON.stringify(spec, null, 2)}
-`, "utf8");
-  return spec;
-}
-async function initLocalRunnerConfigFile(args) {
-  if (!args.force && await exists(args.outputPath)) {
-    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
   }
-  const config = {
-    artifactRoot: ".tt-local/artifacts",
-    storeRoot: ".tt-local/store",
-    evaluation: {
-      inference: {
-        device: "cuda"
-      },
-      scoring: {
-        mode: "exact_match"
-      },
-      timeoutMs: 18e5
-    }
-  };
-  await mkdir2(dirname2(args.outputPath), { recursive: true });
-  await writeFile2(args.outputPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-  return config;
 }
-function placeholderIssues(systemPrompt, examples) {
-  const issues = [];
-  if (/describe the behavior this local model should learn/i.test(systemPrompt)) {
-    issues.push("system_prompt still contains the generated placeholder");
-  }
-  examples.forEach((example, index) => {
-    if (/replace this with/i.test(example.input) || /replace this with/i.test(example.output)) {
-      issues.push(`examples[${index}] still contains generated placeholder text`);
-    }
+
+// src/local-runtime/host-inventory.ts
+async function runCommand(command, args, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  let interrupted;
+  const result = await new Promise((resolveResult) => {
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    let stopError;
+    let forceKillTimer = null;
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const killProcessGroup = (signal) => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signal);
+    };
+    const requestStop = (signal = "SIGTERM") => {
+      killProcessGroup(signal);
+      if (!forceKillTimer) {
+        forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), 5e3);
+        forceKillTimer.unref();
+      }
+    };
+    const onSigint = () => {
+      interrupted = "interrupted by SIGINT";
+      stopError = interrupted;
+      requestStop("SIGINT");
+    };
+    const onSigterm = () => {
+      interrupted = "interrupted by SIGTERM";
+      stopError = interrupted;
+      requestStop("SIGTERM");
+    };
+    const finish = (result2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      resolveResult(result2);
+    };
+    const timer = setTimeout(() => {
+      stopError = `timed out after ${timeoutMs}ms`;
+      requestStop();
+    }, timeoutMs);
+    timer.unref();
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      finish({ code: null, stdout, stderr, error: error.message });
+    });
+    child.on("close", (code) => {
+      finish({ code: stopError ? null : code, stdout, stderr, error: stopError });
+    });
   });
-  return issues;
-}
-function generatedPlaceholderIssues(request) {
-  return placeholderIssues(request.spec_snapshot.system_prompt, request.spec_snapshot.examples);
-}
-function assertLocalRunInputReady(request) {
-  const issues = generatedPlaceholderIssues(request);
-  if (issues.length > 0) {
-    throw new Error(`Edit the generated behavior spec before training: ${issues.join("; ")}.`);
-  }
-}
-function foundationPlaceholderIssues(spec) {
-  return placeholderIssues(spec.system_prompt, spec.examples);
+  if (interrupted) throw new Error(interrupted);
+  return result;
 }
-function assertFoundationSpecReady(spec) {
-  const issues = foundationPlaceholderIssues(spec);
-  if (issues.length > 0) {
-    throw new Error(`Edit the generated foundation spec before training: ${issues.join("; ")}.`);
-  }
+function firstLine(value) {
+  return value.trim().split(/\r?\n/)[0] ?? "";
 }
-function runRequestFromLocalSpec(spec, options = {}) {
-  if (isFoundationSpecFile(spec)) {
-    throw new Error(
-      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
-    );
-  }
-  const {
-    id,
-    engine: _engine,
-    hyperparameters,
-    dataset_prebuilt: datasetPrebuilt,
-    ...specSnapshot
-  } = spec;
-  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
-  return fineTuneRunRequestSchema.parse({
-    run_id: options.runId ?? randomUUID2(),
-    user_id: "local-user",
-    behavior_spec_id: behaviorSpecId,
-    run_number: 1,
-    spec_snapshot: specSnapshot,
-    hyperparameters,
-    dataset_prebuilt: datasetPrebuilt
-  });
+function parseMiB(value) {
+  if (!value) return void 0;
+  const parsed = Number(value.replace(/[^\d.]/g, ""));
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  return Math.round(parsed * 1024 * 1024);
 }
-function deterministicBehaviorSpecId(spec) {
-  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
-  const digest = createHash2("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
-  digest[6] = digest[6] & 15 | 80;
-  digest[8] = digest[8] & 63 | 128;
-  const hex = digest.toString("hex");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20)
-  ].join("-");
+function isNvidiaSmiDecorativeLine(line) {
+  return /^(?:mon|tue|wed|thu|fri|sat|sun)\b/i.test(line) || line.startsWith("+---") || line.startsWith("|");
 }
-async function loadLocalRunInput(path, options = {}) {
-  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile2(path, "utf8")), path);
-  const request = fineTuneRunRequestSchema.safeParse(raw);
-  if (request.success) {
-    return { kind: "request", path, request: request.data };
-  }
-  const spec = localBehaviorSpecFileSchema.parse(raw);
-  if (isFoundationSpecFile(spec)) {
-    return { kind: "foundation-spec", path, spec };
-  }
+function gpuFromName(name, index, extras = {}) {
   return {
-    kind: "spec",
-    path,
-    spec,
-    request: runRequestFromLocalSpec(spec, options)
+    index,
+    name,
+    unified_memory: /spark|gb10/i.test(name),
+    ...extras
   };
 }
-
-// src/local-runtime/dataset.ts
-import { readFile as readFile3 } from "fs/promises";
-async function loadNormalizedChatJsonl(path) {
-  const text = await readFile3(path, "utf8");
-  const rows = [];
-  const jsonLines = [];
-  for (const [index, line] of text.split(/\r?\n/).entries()) {
-    if (!line.trim()) continue;
-    let value;
-    try {
-      value = JSON.parse(line);
-    } catch (error) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
-    }
-    const messages = value.messages;
-    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
-      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
-    )) {
-      throw new Error(
-        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
-      );
+function parseNvidiaGpus(stdout) {
+  const gpus = [];
+  for (const line of stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean)) {
+    if (isNvidiaSmiDecorativeLine(line)) continue;
+    const parts = line.split(",").map((part) => part.trim());
+    if (parts[0] && /^\d+$/.test(parts[0]) && parts.length >= 2) {
+      const name = parts[1] || "NVIDIA GPU";
+      gpus.push(gpuFromName(name, Number(parts[0]), {
+        driver_version: parts[2] || void 0,
+        memory_total_bytes: parseMiB(parts[3]),
+        memory_free_bytes: parseMiB(parts[4]),
+        compute_cap: parts[5] || void 0
+      }));
+      continue;
     }
-    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 (parts.length >= 2 && parts[0] && !/^(?:NVIDIA-SMI|Fail|Error)/i.test(parts[0])) {
+      const name = parts[0];
+      gpus.push(gpuFromName(name, gpus.length, {
+        driver_version: parts[1] || void 0,
+        memory_total_bytes: parseMiB(parts[2]),
+        memory_free_bytes: parseMiB(parts[3])
+      }));
     }
-    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;
+  return gpus;
 }
-function buildSystemMessage(spec) {
-  const parts = [];
-  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
-  if (spec.guidelines.length > 0) {
-    parts.push(`Guidelines:
-${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
-  }
-  if (spec.constraints.length > 0) {
-    parts.push(`Constraints:
-${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
+function parseNvidiaTableGpus(stdout) {
+  const gpus = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const match = line.match(/^\|\s+(\d+)\s+(.+?)\s+(?:On|Off|N\/A)\s+\|/);
+    if (!match) continue;
+    const name = (match[2] ?? "").trim();
+    if (!name || /^NVIDIA-SMI/i.test(name)) continue;
+    gpus.push(gpuFromName(name, Number(match[1])));
   }
-  return 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;
+  return gpus;
 }
-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
-    });
+var NVIDIA_CSV_QUERIES = [
+  ["--query-gpu=index,name,driver_version,memory.total,memory.free", "--format=csv,noheader,nounits"],
+  ["--query-gpu=name,driver_version,memory.total,memory.free", "--format=csv,noheader,nounits"],
+  ["--query-gpu=name,driver_version", "--format=csv,noheader"]
+];
+async function queryNvidiaGpus(env) {
+  let last;
+  for (const args of NVIDIA_CSV_QUERIES) {
+    const result = await runCommand("nvidia-smi", args, { env, timeoutMs: 1e4 });
+    last = result;
+    if (result.code !== 0) continue;
+    const gpus2 = parseNvidiaGpus(result.stdout);
+    if (gpus2.length > 0) return { result, gpus: gpus2 };
+  }
+  const table = await runCommand("nvidia-smi", [], { env, timeoutMs: 1e4 });
+  const gpus = table.code === 0 ? parseNvidiaTableGpus(table.stdout) : [];
+  return { result: table.code === 0 || !last ? table : last, gpus };
+}
+async function diskCheck(name, path) {
+  const resolvedPath = resolve7(path);
+  try {
+    await access(resolvedPath, constants.R_OK);
+    const fs = await statfs(resolvedPath);
+    const freeBytes = Number(fs.bavail) * Number(fs.bsize);
+    return {
+      name,
+      path: resolvedPath,
+      free_bytes: freeBytes,
+      ok: true,
+      message: `${resolvedPath} (${Math.round(freeBytes / 1024 ** 3 * 10) / 10} GiB available)`
+    };
+  } catch (error) {
+    let probe = resolvedPath;
+    for (let i = 0; i < 6; i += 1) {
+      const parent = dirname5(probe);
+      if (parent === probe) break;
+      probe = parent;
+      try {
+        const fs = await statfs(probe);
+        const freeBytes = Number(fs.bavail) * Number(fs.bsize);
+        return {
+          name,
+          path: resolvedPath,
+          free_bytes: freeBytes,
+          ok: true,
+          message: `${resolvedPath} not created yet; ${probe} has ${Math.round(freeBytes / 1024 ** 3 * 10) / 10} GiB available`
+        };
+      } catch {
+        continue;
+      }
+    }
+    return {
+      name,
+      path: resolvedPath,
+      ok: false,
+      message: `${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
-  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);
+function pythonProbeSource() {
+  return [
+    "import json",
+    "import torch, transformers, peft, huggingface_hub",
+    "payload = {'python_ok': True, 'torch': torch.__version__, 'transformers': transformers.__version__, 'peft': getattr(peft, '__version__', None), 'cuda_available': bool(torch.cuda.is_available())}",
+    "cuda = torch.cuda.is_available()",
+    "payload.update({'cuda_device': torch.cuda.get_device_name(0), 'compute_capability': list(torch.cuda.get_device_capability(0)), 'total_memory_bytes': torch.cuda.get_device_properties(0).total_memory, 'bf16_supported': bool(torch.cuda.is_bf16_supported())} if cuda else {})",
+    "print(json.dumps(payload))"
+  ].join("; ");
+}
+function parsePythonProbeJson(text) {
+  const line = [...text.split(/\r?\n/)].reverse().find((item) => item.trim().startsWith("{"));
+  if (!line) return void 0;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed.python_ok !== true) return void 0;
+    return {
+      ok: true,
+      message: line.trim(),
+      torch: typeof parsed.torch === "string" ? parsed.torch : void 0,
+      transformers: typeof parsed.transformers === "string" ? parsed.transformers : void 0,
+      peft: typeof parsed.peft === "string" ? parsed.peft : void 0,
+      cuda_available: parsed.cuda_available === true,
+      cuda_device: typeof parsed.cuda_device === "string" ? parsed.cuda_device : void 0,
+      compute_capability: Array.isArray(parsed.compute_capability) ? parsed.compute_capability.filter((value) => typeof value === "number") : void 0,
+      total_memory_bytes: typeof parsed.total_memory_bytes === "number" ? parsed.total_memory_bytes : void 0,
+      bf16_supported: parsed.bf16_supported === true
+    };
+  } catch {
+    return void 0;
   }
-  const systems = new Set(
-    normalized.rows.map((row) => row.messages.find((message) => message.role === "system")?.content).filter((value) => value !== void 0)
+}
+async function collectPythonRuntime(config, env) {
+  const entrypoint = buildBundledPythonCommand("-c", [pythonProbeSource()]);
+  const childEnv = withBundledPythonEnvironment(
+    withHuggingFaceCacheEnvironment(
+      minimalMachineLearningEnvironment(env),
+      config?.paths.modelCache
+    )
   );
-  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."
+  const result = await runCommand(entrypoint.command, entrypoint.commandArgs, {
+    env: childEnv,
+    timeoutMs: 18e5
+  });
+  if (result.code === 0) {
+    return parsePythonProbeJson(result.stdout) ?? {
+      ok: true,
+      message: firstLine(result.stdout) || "Python runtime probe succeeded"
+    };
+  }
+  return {
+    ok: false,
+    message: result.error ?? (firstLine(result.stderr) || `uv exited ${result.code}`)
   };
 }
-
-// src/local-runtime/run-reporter.ts
-function reportInBackground(action) {
-  try {
-    void Promise.resolve(action()).catch(() => void 0);
-  } catch {
+async function collectHostInventory(options = {}) {
+  const env = options.env ?? process.env;
+  const config = options.config;
+  const cwd = options.cwd ?? process.cwd();
+  const nodeVersion = process.versions.node;
+  const nodeMajor = Number(nodeVersion.split(".")[0]);
+  const artifactRoot = resolve7(cwd, config?.artifactRoot ?? join5(cwd, DEFAULT_ARTIFACT_ROOT));
+  const storeRoot = resolve7(config?.storeRoot ?? defaultStoreRoot(env));
+  const modelCache = resolve7(
+    config?.paths.modelCache ?? env.HF_HOME ?? join5(homedir3(), ".cache", "huggingface")
+  );
+  const [artifactDisk, storeDisk, cacheDisk, uvVersion, nvidiaQueried] = await Promise.all([
+    diskCheck("artifact-root", artifactRoot),
+    diskCheck("store-root", storeRoot),
+    diskCheck("model-cache", modelCache),
+    runCommand("uv", ["--version"], { env, timeoutMs: 1e4 }),
+    queryNvidiaGpus(env)
+  ]);
+  const nvidia = nvidiaQueried.result;
+  const gpus = nvidiaQueried.gpus;
+  const inventory = {
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    quick: options.quick === true,
+    node: {
+      version: nodeVersion,
+      major: nodeMajor,
+      ok: nodeMajor >= 22
+    },
+    os: {
+      platform: process.platform,
+      arch: process.arch,
+      type: type(),
+      cpu_count: cpus().length,
+      total_memory_bytes: totalmem(),
+      free_memory_bytes: freemem()
+    },
+    uv: {
+      ok: uvVersion.code === 0,
+      version: uvVersion.code === 0 ? firstLine(uvVersion.stdout) : void 0,
+      message: uvVersion.code === 0 ? firstLine(uvVersion.stdout) : uvVersion.error ?? (firstLine(uvVersion.stderr) || "uv is not available")
+    },
+    gpus,
+    nvidia_smi: {
+      ok: nvidia.code === 0,
+      message: nvidia.code === 0 ? gpus[0] ? `${gpus[0].name}${gpus[0].memory_total_bytes ? ` (${Math.round(gpus[0].memory_total_bytes / 1024 ** 3)} GiB)` : ""}` : firstLine(nvidia.stdout) || "nvidia-smi reported a GPU" : nvidia.error ?? (firstLine(nvidia.stderr) || "nvidia-smi not available")
+    },
+    disks: [artifactDisk, storeDisk, cacheDisk]
+  };
+  if (options.quick !== true) {
+    inventory.python = uvVersion.code === 0 ? await collectPythonRuntime(config, env) : { ok: false, message: "Python probe skipped because uv is not available" };
   }
+  return inventory;
 }
-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));
+
+// src/local-runtime/hardware-snapshot.ts
+import { chmod, mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname6, join as join6 } from "path";
+var HARDWARE_SNAPSHOT_VERSION = 1;
+var HARDWARE_SNAPSHOT_TTL_MS = 24 * 60 * 60 * 1e3;
+function hardwareSnapshotPath(env = process.env) {
+  return join6(getTunedTensorHome(env), "hardware.json");
+}
+async function readHardwareSnapshot(env = process.env) {
+  const path = hardwareSnapshotPath(env);
+  try {
+    const parsed = JSON.parse(await readFile2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const snapshot = parsed;
+    if (snapshot.version !== HARDWARE_SNAPSHOT_VERSION) return void 0;
+    if (typeof snapshot.collected_at !== "string" || !snapshot.capabilities || !snapshot.inventory) {
+      return void 0;
     }
-  });
-  stream.on("end", () => {
-    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
-  });
+    const age = Date.now() - Date.parse(snapshot.collected_at);
+    const stale = !Number.isFinite(age) || age > HARDWARE_SNAPSHOT_TTL_MS || age < 0;
+    return { ...snapshot, stale, path };
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    return void 0;
+  }
+}
+async function writeHardwareSnapshot(snapshot, env = process.env) {
+  const path = hardwareSnapshotPath(env);
+  await mkdir3(dirname6(path), { recursive: true, mode: 448 });
+  const gpu = snapshot.capabilities.gpu;
+  const record = {
+    version: HARDWARE_SNAPSHOT_VERSION,
+    collected_at: snapshot.collected_at,
+    quick: snapshot.quick,
+    gpu_fingerprint: gpu ? { name: gpu.name, total_memory_bytes: gpu.memory_total_bytes } : void 0,
+    inventory: snapshot.inventory,
+    capabilities: snapshot.capabilities,
+    summary: snapshot.summary ?? formatCapabilitySummary(snapshot.capabilities)
+  };
+  await writeFile2(path, `${JSON.stringify(record, null, 2)}
+`, { mode: 384 });
+  await chmod(path, 384);
+  return record;
+}
+function formatHostStatusLine(snapshot) {
+  if (!snapshot) return "not inventoried (run tt hardware)";
+  const stale = snapshot.stale ? `; stale \u2014 run tt hardware` : "";
+  return `${snapshot.summary}${stale}`;
+}
+function formatAgentHostBlock(snapshot) {
+  if (!snapshot) {
+    return [
+      "Host capability is not inventoried yet.",
+      "When the user asks to examine this machine, GPU, VRAM, CUDA, or what can train, fine-tune, or infer here, call examine_hardware before recommending a base model, engine, or pipeline."
+    ].join(" ");
+  }
+  const stale = snapshot.stale ? " (stale \u2014 call examine_hardware to refresh)" : "";
+  return [
+    `Host capability (cached ${snapshot.collected_at}${stale}):`,
+    snapshot.summary,
+    "When the user wants to examine this host, GPU, or decide what can train/fine-tune/infer here, call examine_hardware before recommending a base model, engine, or pipeline.",
+    "Recommend only workloads marked ready; mention tight as a caution. Never invent generic 7B/70B sizing."
+  ].join("\n");
 }
 
-// src/local-runtime/package-root.ts
-import { existsSync } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function localRuntimePackageRoot(moduleUrl) {
-  const moduleDirectory = dirname3(fileURLToPath2(moduleUrl));
-  const candidates = [
-    dirname3(moduleDirectory),
-    dirname3(dirname3(moduleDirectory))
-  ];
-  const root = candidates.find(
-    (candidate) => existsSync(resolve4(candidate, "package.json")) && existsSync(resolve4(candidate, "training/local-runner"))
-  );
-  if (!root) {
-    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+// src/local-runtime/hardware.ts
+async function assessHardware(options = {}) {
+  const env = options.env ?? process.env;
+  if (options.quick === true) {
+    const existing = await readHardwareSnapshot(env);
+    if (existing && !existing.quick && !existing.stale) {
+      return {
+        version: existing.version,
+        collected_at: existing.collected_at,
+        quick: existing.quick,
+        gpu_fingerprint: existing.gpu_fingerprint,
+        inventory: existing.inventory,
+        capabilities: existing.capabilities,
+        summary: existing.summary
+      };
+    }
   }
-  return root;
+  const inventory = await collectHostInventory({
+    config: options.config,
+    quick: options.quick === true,
+    env,
+    cwd: options.cwd
+  });
+  const capabilities = evaluateCapabilities(inventory);
+  return await writeHardwareSnapshot({
+    collected_at: inventory.collected_at,
+    quick: inventory.quick,
+    inventory,
+    capabilities,
+    summary: formatCapabilitySummary(capabilities)
+  }, env);
 }
 
 // src/local-runtime/store.ts
-import { appendFile, copyFile as copyFile2, mkdir as mkdir3, readdir as readdir3, readFile as readFile4, rename as rename2, rm, stat as stat3, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join2, resolve as resolve5, sep as sep2 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { appendFile, chmod as chmod2, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir4, readdir as readdir3, readFile as readFile3, rename as rename2, rm, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname7, join as join7, resolve as resolve8, sep as sep2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 function isTerminalRunState(state) {
   return state.status === "stage_completed" || state.status === "completed" || state.status === "failed" || state.status === "cancelled" && state.current_stage === "cancelled" && Boolean(state.completed_at);
 }
 function defaultLocalHome() {
-  return resolve5(process.env.TT_LOCAL_HOME ?? join2(homedir2(), ".tuned-tensor-local"));
+  return defaultStoreRoot();
 }
 function localStorePaths(root) {
   return {
     root,
-    specsDir: join2(root, "specs"),
-    runsDir: join2(root, "runs"),
-    modelsDir: join2(root, "models"),
-    datasetsDir: join2(root, "datasets")
+    specsDir: join7(root, "specs"),
+    runsDir: join7(root, "runs"),
+    modelsDir: join7(root, "models"),
+    datasetsDir: join7(root, "datasets")
   };
 }
-async function exists2(path) {
+async function exists(path) {
   try {
-    await stat3(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
   }
 }
-async function writeJsonAtomic2(path, value) {
-  await mkdir3(dirname4(path), { recursive: true });
-  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID3()}.tmp`;
+async function ensurePrivateDirectory(path) {
+  await mkdir4(path, { recursive: true, mode: 448 });
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${path}`);
+  }
+  await chmod2(path, 448);
+}
+async function hardenPrivateTree(path) {
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (metadata.isDirectory()) {
+    await chmod2(path, 448);
+    for (const entry of await readdir3(path)) {
+      await hardenPrivateTree(join7(path, entry));
+    }
+    return;
+  }
+  if (metadata.isFile()) {
+    await chmod2(path, 384);
+    return;
+  }
+  throw new Error(`Refusing unsupported filesystem entry in local store: ${path}`);
+}
+async function hardenExistingLocalStore(root) {
+  const resolvedRoot = resolve8(root);
+  let metadata;
+  try {
+    metadata = await lstat3(resolvedRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${resolvedRoot}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${resolvedRoot}`);
+  }
+  await hardenPrivateTree(resolvedRoot);
+  return true;
+}
+async function writePrivateJsonAtomic(path, value) {
+  await ensurePrivateDirectory(dirname7(path));
+  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
   await writeFile3(tmp, `${JSON.stringify(value, null, 2)}
-`, "utf8");
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
   await rename2(tmp, path);
+  await chmod2(path, 384);
 }
 async function readJson2(path) {
-  return JSON.parse(await readFile4(path, "utf8"));
+  return JSON.parse(await readFile3(path, "utf8"));
 }
 async function appendJsonl(path, value) {
-  await mkdir3(dirname4(path), { recursive: true });
+  await ensurePrivateDirectory(dirname7(path));
   await appendFile(path, `${JSON.stringify(value)}
-`, "utf8");
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod2(path, 384);
+}
+async function writePrivateText(path, value) {
+  await ensurePrivateDirectory(dirname7(path));
+  await writeFile3(path, value, { encoding: "utf8", mode: 384 });
+  await chmod2(path, 384);
 }
 async function readJsonl(path) {
-  if (!await exists2(path)) return [];
-  return (await readFile4(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  if (!await exists(path)) return [];
+  return (await readFile3(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
 }
 async function copyIfExists(from, to) {
-  if (!await exists2(from)) return;
-  await mkdir3(dirname4(to), { recursive: true });
+  if (!await exists(from)) return;
+  await ensurePrivateDirectory(dirname7(to));
   await copyFile2(from, to);
+  await chmod2(to, 384);
 }
 async function childDirectoryNames(path) {
   try {
@@ -1571,41 +2087,51 @@ function findByIdOrPrefix(records, id) {
   return records.find((record) => record.id === id) ?? records.find((record) => record.id.startsWith(id));
 }
 function isPathInside(root, candidate) {
-  const resolvedRoot = resolve5(root);
-  const resolvedCandidate = resolve5(candidate);
+  const resolvedRoot = resolve8(root);
+  const resolvedCandidate = resolve8(candidate);
   return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
 }
 function createLocalStore(root = defaultLocalHome()) {
-  const resolvedRoot = resolve5(root);
+  const resolvedRoot = resolve8(root);
   const paths = localStorePaths(resolvedRoot);
-  const runDir = (id) => join2(paths.runsDir, id);
-  const runStatePath = (id) => join2(runDir(id), "state.json");
-  const runEventsPath = (id) => join2(runDir(id), "progress.jsonl");
-  const runRequestPath = (id) => join2(runDir(id), "request.json");
-  const runReportPath = (id) => join2(runDir(id), "run-report.json");
-  const cancellationPath = (id) => join2(runDir(id), "cancel.requested");
-  const specDir = (id) => join2(paths.specsDir, id);
-  const specPath = (id) => join2(specDir(id), "spec.json");
-  const modelPath = (id) => join2(paths.modelsDir, id, "model.json");
-  async function ensure() {
+  const runDir = (id) => join7(paths.runsDir, id);
+  const runStatePath = (id) => join7(runDir(id), "state.json");
+  const runEventsPath = (id) => join7(runDir(id), "progress.jsonl");
+  const runRequestPath = (id) => join7(runDir(id), "request.json");
+  const runReportPath = (id) => join7(runDir(id), "run-report.json");
+  const cancellationPath = (id) => join7(runDir(id), "cancel.requested");
+  const specDir = (id) => join7(paths.specsDir, id);
+  const specPath = (id) => join7(specDir(id), "spec.json");
+  const modelPath = (id) => join7(paths.modelsDir, id, "model.json");
+  let ensurePromise;
+  async function ensureOnce() {
+    await ensurePrivateDirectory(paths.root);
     await Promise.all([
-      mkdir3(paths.specsDir, { recursive: true }),
-      mkdir3(paths.runsDir, { recursive: true }),
-      mkdir3(paths.modelsDir, { recursive: true }),
-      mkdir3(paths.datasetsDir, { recursive: true })
+      ensurePrivateDirectory(paths.specsDir),
+      ensurePrivateDirectory(paths.runsDir),
+      ensurePrivateDirectory(paths.modelsDir),
+      ensurePrivateDirectory(paths.datasetsDir)
     ]);
+    await hardenExistingLocalStore(paths.root);
+  }
+  async function ensure() {
+    ensurePromise ??= ensureOnce().catch((error) => {
+      ensurePromise = void 0;
+      throw error;
+    });
+    await ensurePromise;
   }
   async function writeRunState(state) {
-    await writeJsonAtomic2(runStatePath(state.id), state);
+    await writePrivateJsonAtomic(runStatePath(state.id), state);
     return state;
   }
   async function readSpecRecord(id) {
     const path = specPath(id);
-    if (!await exists2(path)) return null;
+    if (!await exists(path)) return null;
     const [spec, fileStats, directoryStats] = await Promise.all([
       readJson2(path),
-      stat3(path),
-      stat3(specDir(id))
+      stat2(path),
+      stat2(specDir(id))
     ]);
     const createdAt = directoryStats.birthtimeMs > 0 ? directoryStats.birthtime : directoryStats.ctime;
     return {
@@ -1631,7 +2157,7 @@ function createLocalStore(root = defaultLocalHome()) {
     const records = [];
     for (const id of await childDirectoryNames(paths.runsDir)) {
       const path = runStatePath(id);
-      if (await exists2(path)) records.push(await readJson2(path));
+      if (await exists(path)) records.push(await readJson2(path));
     }
     return records.sort(compareUpdatedAt);
   }
@@ -1640,27 +2166,27 @@ function createLocalStore(root = defaultLocalHome()) {
     const records = [];
     for (const id of await childDirectoryNames(paths.modelsDir)) {
       const path = modelPath(id);
-      if (await exists2(path)) records.push(await readJson2(path));
+      if (await exists(path)) records.push(await readJson2(path));
     }
     return records.sort(compareCreatedAt);
   }
   async function importSpecRecord(specId, spec) {
     await ensure();
-    await mkdir3(specDir(specId), { recursive: true });
-    await writeJsonAtomic2(specPath(specId), spec);
+    await ensurePrivateDirectory(specDir(specId));
+    await writePrivateJsonAtomic(specPath(specId), spec);
     const record = await readSpecRecord(specId);
     if (!record) throw new Error(`Failed to persist spec: ${specId}`);
     return record;
   }
   async function appendRunEvent(state, event) {
     const row = {
-      id: randomUUID3(),
+      id: randomUUID2(),
       run_id: state.id,
       occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
       ...event
     };
     await appendJsonl(runEventsPath(state.id), row);
-    await appendJsonl(join2(state.artifact_dir, "progress.jsonl"), {
+    await appendJsonl(join7(state.artifact_dir, "progress.jsonl"), {
       at: row.occurred_at,
       stage: row.stage,
       status: row.status,
@@ -1690,6 +2216,10 @@ function createLocalStore(root = defaultLocalHome()) {
   async function preserveCancellationRequestState(runId) {
     const previous = await getRun(runId);
     if (isTerminalRunState(previous)) return previous;
+    await Promise.all([
+      rm(join7(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
+      rm(runReportPath(previous.id), { force: true })
+    ]);
     if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
     const requested = {
       ...previous,
@@ -1704,19 +2234,20 @@ function createLocalStore(root = defaultLocalHome()) {
   }
   async function resolveRunId(id) {
     await ensure();
-    if (await exists2(runStatePath(id))) return id;
+    if (await exists(runStatePath(id))) return id;
     const record = findByIdOrPrefix(await listRunRecords(), id);
     if (!record) throw new Error(`Run not found: ${id}`);
     return record.id;
   }
   async function getRun(id) {
+    await ensure();
     return readJson2(runStatePath(await resolveRunId(id)));
   }
   async function registerModelRecord(args) {
     if (!args.training.model_artifact_uri || args.training.metrics?.dry_run === true) return null;
     const previous = await getRun(args.request.run_id);
     const modelId = `local-${args.request.run_id}`;
-    const existingModel = await exists2(modelPath(modelId)) ? await readJson2(modelPath(modelId)) : void 0;
+    const existingModel = await exists(modelPath(modelId)) ? await readJson2(modelPath(modelId)) : void 0;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const model = {
       id: modelId,
@@ -1730,7 +2261,7 @@ function createLocalStore(root = defaultLocalHome()) {
       metrics: args.training.metrics,
       created_at: existingModel?.created_at ?? args.createdAt ?? now
     };
-    await writeJsonAtomic2(modelPath(model.id), model);
+    await writePrivateJsonAtomic(modelPath(model.id), model);
     const alreadyRegistered = previous.model_id === modelId;
     const state = {
       ...previous,
@@ -1780,7 +2311,7 @@ function createLocalStore(root = defaultLocalHome()) {
         updated_at: now,
         started_at: now
       };
-      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      await writePrivateJsonAtomic(runRequestPath(request.run_id), request);
       await writeRunState(state);
       await appendRunEvent(state, { stage: "queued", status: "queued", message: "Run queued." });
       return state;
@@ -1793,7 +2324,7 @@ function createLocalStore(root = defaultLocalHome()) {
         );
       }
       await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
-      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      await writePrivateJsonAtomic(runRequestPath(request.run_id), request);
       const state = {
         ...previous,
         artifact_dir: artifactDir ?? previous.artifact_dir,
@@ -1806,7 +2337,7 @@ function createLocalStore(root = defaultLocalHome()) {
     },
     async updateRun({ runId, status, stage, message, details }) {
       const previous = await getRun(runId);
-      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+      if (status !== "cancelled" && await exists(cancellationPath(previous.id))) {
         return preserveCancellationRequestState(previous.id);
       }
       const active = status !== "stage_completed" && status !== "completed" && status !== "failed" && status !== "cancelled";
@@ -1821,7 +2352,7 @@ function createLocalStore(root = defaultLocalHome()) {
         updated_at: now
       };
       await writeRunState(state);
-      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+      if (status !== "cancelled" && await exists(cancellationPath(previous.id))) {
         return preserveCancellationRequestState(previous.id);
       }
       await appendRunEvent(state, {
@@ -1833,11 +2364,19 @@ function createLocalStore(root = defaultLocalHome()) {
       return state;
     },
     async completeRun(report, artifactDir, reportPath) {
-      if (await exists2(cancellationPath(report.run_id))) {
+      await ensure();
+      if (await exists(cancellationPath(report.run_id))) {
         return preserveCancellationRequestState(report.run_id);
       }
       const request = await readJson2(runRequestPath(report.run_id));
       const completedAt = report.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+      if (!await exists(reportPath)) {
+        throw new Error(`Run report not found: ${reportPath}`);
+      }
+      await copyIfExists(reportPath, runReportPath(report.run_id));
+      if (await exists(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
       const model = await registerModelRecord({
         request,
         training: report.training,
@@ -1845,7 +2384,7 @@ function createLocalStore(root = defaultLocalHome()) {
         createdAt: completedAt
       });
       if (!model) {
-        await rm(join2(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+        await rm(join7(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
       }
       const previous = await getRun(report.run_id);
       const state = {
@@ -1859,11 +2398,13 @@ function createLocalStore(root = defaultLocalHome()) {
         completed_at: completedAt,
         updated_at: completedAt
       };
+      if (await exists(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
       await writeRunState(state);
-      if (await exists2(cancellationPath(report.run_id))) {
+      if (await exists(cancellationPath(report.run_id))) {
         return preserveCancellationRequestState(report.run_id);
       }
-      await copyIfExists(reportPath, runReportPath(report.run_id));
       await appendRunEvent(state, {
         stage: "completed",
         status: "completed",
@@ -1877,7 +2418,7 @@ function createLocalStore(root = defaultLocalHome()) {
       const previous = await getRun(runId);
       if (options.report) await rm(runReportPath(previous.id), { force: true });
       if (options.model) {
-        await rm(join2(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
+        await rm(join7(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
       }
       const state = {
         ...previous,
@@ -1892,7 +2433,7 @@ function createLocalStore(root = defaultLocalHome()) {
     async failRun(runId, error) {
       const previous = await getRun(runId);
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      if (await exists2(cancellationPath(previous.id))) {
+      if (await exists(cancellationPath(previous.id))) {
         return preserveCancellationRequestState(previous.id);
       }
       const state = {
@@ -1905,7 +2446,7 @@ function createLocalStore(root = defaultLocalHome()) {
         updated_at: now
       };
       await writeRunState(state);
-      if (await exists2(cancellationPath(previous.id))) {
+      if (await exists(cancellationPath(previous.id))) {
         return preserveCancellationRequestState(previous.id);
       }
       await appendRunEvent(state, { stage: "failed", status: "failed", message: error });
@@ -1916,8 +2457,8 @@ function createLocalStore(root = defaultLocalHome()) {
       if (isTerminalRunState(state) || state.status === "cancelled" && state.current_stage === "cancel_requested") {
         return;
       }
-      await writeFile3(cancellationPath(state.id), `${(/* @__PURE__ */ new Date()).toISOString()}
-`, "utf8");
+      await writePrivateText(cancellationPath(state.id), `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
       const latest = await getRun(state.id);
       if (isTerminalRunState(latest)) {
         if (latest.status !== "cancelled") await rm(cancellationPath(state.id), { force: true });
@@ -1940,7 +2481,7 @@ function createLocalStore(root = defaultLocalHome()) {
     },
     async isCancellationRequested(runId) {
       const state = await getRun(runId);
-      return state.status === "cancelled" || await exists2(cancellationPath(state.id));
+      return state.status === "cancelled" || await exists(cancellationPath(state.id));
     },
     async listRuns() {
       return listRunRecords();
@@ -1950,356 +2491,654 @@ function createLocalStore(root = defaultLocalHome()) {
       const state = await getRun(id);
       return readJsonl(runEventsPath(state.id));
     },
-    async getRunReport(id) {
-      const state = await getRun(id);
-      const candidates = [];
-      if (state.report_path) {
-        const reportPath = resolve5(state.report_path);
-        const allowedRoots = [resolvedRoot];
-        if (state.artifact_dir) allowedRoots.push(resolve5(state.artifact_dir));
-        if (allowedRoots.some((allowed) => isPathInside(allowed, reportPath))) {
-          candidates.push(reportPath);
+    async getRunReport(id) {
+      const state = await getRun(id);
+      const candidates = [];
+      if (state.report_path) {
+        const reportPath = resolve8(state.report_path);
+        const allowedRoots = [resolvedRoot];
+        if (state.artifact_dir) allowedRoots.push(resolve8(state.artifact_dir));
+        if (allowedRoots.some((allowed) => isPathInside(allowed, reportPath))) {
+          candidates.push(reportPath);
+        }
+      }
+      candidates.push(runReportPath(state.id));
+      for (const path of candidates) {
+        if (await exists(path)) return readJson2(path);
+      }
+      throw new Error(`Run has no report yet: ${id}`);
+    },
+    async listModels() {
+      return listModelRecords();
+    },
+    async getModel(id) {
+      const record = findByIdOrPrefix(await listModelRecords(), id);
+      if (!record) throw new Error(`Model not found: ${id}`);
+      return record;
+    }
+  };
+}
+
+// src/local-runtime/contracts.ts
+import { z } from "zod";
+var datasetFormatSchema = z.literal("chat_jsonl");
+var baseModelRevisionSchema = z.string().regex(/^[0-9a-f]{40}$/i, "base_model_revision must be a 40-character Hugging Face commit SHA").transform((value) => value.toLowerCase());
+var behaviorSpecExampleSchema = z.object({
+  input: z.string().min(1),
+  output: z.string().min(1)
+}).strict();
+var specSnapshotSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().default(""),
+  system_prompt: z.string().default(""),
+  guidelines: z.array(z.string()).default([]),
+  examples: z.array(behaviorSpecExampleSchema).default([]),
+  constraints: z.array(z.string()).default([]),
+  base_model: z.string().transform((value) => canonicalizeTrainingModel(value))
+}).strict();
+var foundationHyperparametersSchema = z.object({
+  vocab_size: z.number().int().min(64).max(65536).default(256),
+  max_chars: z.number().int().min(1e3).max(2e9).default(2e4),
+  depth: z.number().int().min(1).max(64).default(2),
+  pretrain_steps: z.number().int().min(1).max(1e7).default(2),
+  finetune_steps: z.number().int().min(1).max(1e7).default(2),
+  rl_steps: z.number().int().min(0).max(1e7).default(0),
+  batch_size: z.number().int().min(1).max(1024).default(2),
+  sequence_length: z.number().int().min(16).max(8192).default(64),
+  nproc_per_node: z.number().int().min(1).max(16).default(1)
+}).strict();
+var localFoundationSpecFileSchema = z.object({
+  engine: z.literal("foundation"),
+  id: z.string().uuid().optional(),
+  name: z.string().min(1),
+  description: z.string().default(""),
+  system_prompt: z.string().default(""),
+  guidelines: z.array(z.string()).default([]),
+  examples: z.array(behaviorSpecExampleSchema).min(2),
+  constraints: z.array(z.string()).default([]),
+  foundation: foundationHyperparametersSchema
+}).strict();
+var datasetPrebuiltSchema = z.object({
+  training: z.string().min(1),
+  validation: z.string().min(1).optional(),
+  test: z.string().min(1).optional(),
+  format: datasetFormatSchema.default("chat_jsonl")
+}).strict().superRefine((dataset, context) => {
+  if (!dataset.validation && !dataset.test) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["validation"],
+      message: "Provide a distinct validation or test split for held-out evaluation"
+    });
+  }
+});
+var fineTuneHyperparametersSchema = z.object({
+  n_epochs: z.number().int().min(1).max(20).default(1),
+  learning_rate: z.number().positive().optional(),
+  batch_size: z.number().int().min(1).optional(),
+  lora_rank: z.number().int().min(1).optional(),
+  lora_alpha: z.number().int().min(1).optional(),
+  lora_dropout: z.number().min(0).max(1).optional(),
+  max_seq_length: z.number().int().min(128).max(32768).optional(),
+  gradient_accumulation_steps: z.number().int().min(1).optional(),
+  max_eval_examples: z.number().int().min(1).optional(),
+  /** Immutable Hugging Face commit used by every stage of the run. */
+  base_model_revision: baseModelRevisionSchema.optional()
+}).strict();
+var fineTuneRunRequestSchema = z.object({
+  run_id: z.string().uuid(),
+  user_id: z.string().min(1),
+  behavior_spec_id: z.string().uuid(),
+  run_number: z.number().int().min(1),
+  spec_snapshot: specSnapshotSchema,
+  hyperparameters: fineTuneHyperparametersSchema.default({ n_epochs: 1 }),
+  dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict().superRefine((request, context) => {
+  if (request.spec_snapshot.examples.length === 0 && !request.dataset_prebuilt) {
+    context.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["spec_snapshot", "examples"],
+      message: "Add examples or provide dataset_prebuilt training and validation files"
+    });
+  }
+});
+var localAdapterSpecFileSchema = specSnapshotSchema.extend({
+  engine: z.literal("adapter").optional(),
+  id: z.string().uuid().optional(),
+  hyperparameters: fineTuneHyperparametersSchema.optional(),
+  dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict();
+var localBehaviorSpecFileSchema = z.union([
+  localFoundationSpecFileSchema,
+  localAdapterSpecFileSchema
+]);
+var evalExampleResultSchema = z.object({
+  prompt: z.string(),
+  expected: z.string(),
+  actual: z.string(),
+  passed: z.boolean(),
+  score: z.number().min(0).max(1),
+  reasoning: z.string().nullable(),
+  latency_ms: z.number().int().nonnegative(),
+  scored_by: z.enum(["exact_match", "json_fields", "heuristic"]).optional()
+}).strict();
+var jsonFieldMetricsSchema = z.object({
+  fields: z.array(z.string()),
+  valid_json_count: z.number().int().nonnegative(),
+  valid_json_rate: z.number().min(0).max(1),
+  schema_match_count: z.number().int().nonnegative(),
+  schema_match_rate: z.number().min(0).max(1),
+  all_fields_match_count: z.number().int().nonnegative(),
+  all_fields_match_rate: z.number().min(0).max(1),
+  field_accuracy: z.record(z.string(), z.object({
+    correct: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+    accuracy: z.number().min(0).max(1)
+  }).strict())
+}).strict();
+var evalSplitSchema = z.enum([
+  "spec_examples",
+  "spec_holdout",
+  "prebuilt_test",
+  "prebuilt_validation",
+  "general_regression"
+]);
+var evalReportSchema = z.object({
+  kind: z.enum(["baseline", "candidate"]),
+  model_id: z.string(),
+  total: z.number().int().nonnegative(),
+  eval_examples_total: z.number().int().nonnegative(),
+  eval_examples_used: z.number().int().nonnegative(),
+  eval_truncated: z.boolean(),
+  eval_split: evalSplitSchema.optional(),
+  eval_sample_seed: z.number().int().nullable().optional(),
+  avg_score: z.number().min(0).max(1),
+  pass_rate: z.number().min(0).max(1),
+  exact_match_rate: z.number().min(0).max(1),
+  avg_token_f1: z.number().min(0).max(1).optional(),
+  avg_latency_ms: z.number().int().nonnegative(),
+  cached: z.boolean().optional(),
+  cache_key: z.string().optional(),
+  results: z.array(evalExampleResultSchema),
+  artifact_uri: z.string(),
+  scoring_method: z.enum(["heuristic", "exact_match", "json_fields"]),
+  inference_provider: z.enum(["none", "transformers"]).optional(),
+  scoring_mode: z.enum(["exact_match", "json_fields"]).optional(),
+  json_field_metrics: jsonFieldMetricsSchema.optional(),
+  generation_config: z.record(z.string(), z.unknown()).optional(),
+  log_uri: z.string().optional()
+}).strict();
+var comparisonReportSchema = z.object({
+  avg_score_delta: z.number(),
+  pass_rate_delta: z.number(),
+  exact_match_rate_delta: z.number(),
+  token_f1_delta: z.number().optional(),
+  regressions: z.number().int().nonnegative(),
+  improvements: z.number().int().nonnegative(),
+  regressed_examples: z.array(z.object({
+    prompt: z.string(),
+    old_score: z.number(),
+    new_score: z.number()
+  }).strict())
+}).strict();
+var trainingReportSchema = z.object({
+  provider: z.literal("local-uv"),
+  training_job_name: z.string(),
+  model_artifact_uri: z.string().optional(),
+  base_model_artifact_uri: z.string().optional(),
+  metrics: z.record(z.string(), z.unknown()).nullable(),
+  exit_code: z.number().int().nullable(),
+  log_uri: z.string(),
+  command: z.array(z.string()).optional()
+}).strict();
+var runReportSchema = z.object({
+  run_id: z.string().uuid(),
+  behavior_spec_id: z.string().uuid(),
+  user_id: z.string(),
+  run_number: z.number().int().min(1),
+  base_model: z.string(),
+  fine_tuned_model_id: z.string(),
+  status: z.enum(["completed", "failed"]),
+  baseline: evalReportSchema,
+  candidate: evalReportSchema,
+  comparison: comparisonReportSchema,
+  general_regression: z.object({
+    dataset_uri: z.string(),
+    dataset_sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    baseline: evalReportSchema,
+    candidate: evalReportSchema,
+    comparison: comparisonReportSchema,
+    policy: z.object({
+      max_score_drop: z.number().min(0).max(1),
+      max_pass_rate_drop: z.number().min(0).max(1)
+    }).strict(),
+    passed: z.boolean(),
+    failures: z.array(z.string())
+  }).strict().optional(),
+  training: trainingReportSchema,
+  artifact_uris: z.object({
+    dataset: z.string(),
+    baseline_eval: z.string(),
+    candidate_eval: z.string(),
+    general_baseline_eval: z.string().optional(),
+    general_candidate_eval: z.string().optional(),
+    report: z.string()
+  }).strict(),
+  run_metadata: z.object({
+    base_model: z.string(),
+    fine_tuned_model_id: z.string(),
+    dataset_prebuilt: z.boolean(),
+    dataset_format: datasetFormatSchema.nullable().optional(),
+    dataset_uri: z.string(),
+    spec_example_count: z.number().int().nonnegative(),
+    training_example_count: z.number().int().nonnegative().nullable(),
+    eval_examples_total: z.number().int().nonnegative(),
+    eval_examples_used: z.number().int().nonnegative(),
+    eval_split: evalSplitSchema.optional(),
+    eval_sample_seed: z.number().int().nullable().optional(),
+    started_at: z.string(),
+    completed_at: z.string(),
+    elapsed_ms: z.number().int().nonnegative(),
+    elapsed_seconds: z.number().nonnegative()
+  }).strict(),
+  created_at: z.string()
+}).strict();
+var inferenceConfigSchema = z.object({
+  maxNewTokens: z.number().int().min(1).default(256),
+  temperature: z.number().min(0).default(0),
+  topP: z.number().min(0).max(1).default(1),
+  device: z.enum(["cuda", "cpu"]).default("cuda")
+}).strict();
+var scoringConfigSchema = z.object({
+  mode: z.enum(["exact_match", "json_fields"]).default("exact_match"),
+  fields: z.array(z.string().min(1)).optional()
+}).strict();
+var evaluationConfigSchema = z.object({
+  inference: inferenceConfigSchema.default({
+    maxNewTokens: 256,
+    temperature: 0,
+    topP: 1,
+    device: "cuda"
+  }),
+  scoring: scoringConfigSchema.default({ mode: "exact_match" }),
+  timeoutMs: z.number().int().min(100).default(18e5),
+  maxExamples: z.number().int().min(1).optional(),
+  sampleSeed: z.number().int().optional(),
+  baselineCache: z.boolean().default(true),
+  generalRegression: z.object({
+    dataset: z.string().min(1),
+    systemPrompt: z.string().optional(),
+    maxScoreDrop: z.number().min(0).max(1).default(0.03),
+    maxPassRateDrop: z.number().min(0).max(1).default(0.05)
+  }).strict().optional()
+}).strict();
+var localRunnerConfigSchema = z.object({
+  storeRoot: z.string().optional(),
+  artifactRoot: z.string().default(DEFAULT_ARTIFACT_ROOT),
+  dryRun: z.boolean().default(false),
+  paths: z.object({
+    baseModel: z.string().optional(),
+    modelCache: z.string().optional()
+  }).strict().default({}),
+  evaluation: evaluationConfigSchema.default({
+    inference: {
+      maxNewTokens: 256,
+      temperature: 0,
+      topP: 1,
+      device: "cuda"
+    },
+    scoring: { mode: "exact_match" },
+    timeoutMs: 18e5,
+    baselineCache: true
+  })
+}).strict();
+function isFoundationSpecFile(spec) {
+  return spec.engine === "foundation";
+}
+
+// src/local-runtime/local-project.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute3, resolve as resolve9 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdir as mkdir5 } from "fs/promises";
+var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
+function resolveLocalReference(value, baseDirectory) {
+  if (typeof value !== "string" || !value || isAbsolute3(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
+    return value;
+  }
+  if (value === "~") return homedir4();
+  if (value.startsWith("~/")) return resolve9(homedir4(), value.slice(2));
+  return resolve9(baseDirectory, value);
+}
+function resolveLocalRunInputPaths(raw, inputPath) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const baseDirectory = dirname8(resolve9(inputPath));
+  const value = structuredClone(raw);
+  const dataset = value.dataset_prebuilt;
+  if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
+    const fields = dataset;
+    for (const key of ["training", "validation", "test"]) {
+      if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
+    }
+  }
+  return value;
+}
+async function exists2(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initLocalSpecFile(args) {
+  if (!args.force && await exists2(args.outputPath)) {
+    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
+  }
+  if (args.engine === "foundation") {
+    const spec2 = localFoundationSpecFileSchema.parse({
+      engine: "foundation",
+      id: randomUUID3(),
+      name: args.name,
+      description: "From-scratch tokenizer, pretrain, chat SFT, and eval.",
+      system_prompt: "You are a helpful assistant.",
+      guidelines: [
+        "Answer the user request directly."
+      ],
+      constraints: [],
+      examples: [
+        {
+          input: "Replace this with representative chat input.",
+          output: "Replace this with the expected assistant reply."
+        },
+        {
+          input: "Replace this with a different chat input.",
+          output: "Replace this with the expected assistant reply."
         }
+      ],
+      foundation: {
+        depth: 2,
+        pretrain_steps: 2,
+        finetune_steps: 2,
+        rl_steps: 0,
+        vocab_size: 256,
+        max_chars: 2e4,
+        sequence_length: 64,
+        batch_size: 2,
+        nproc_per_node: 1
       }
-      candidates.push(runReportPath(state.id));
-      for (const path of candidates) {
-        if (await exists2(path)) return readJson2(path);
-      }
-      throw new Error(`Run has no report yet: ${id}`);
-    },
-    async listModels() {
-      return listModelRecords();
-    },
-    async getModel(id) {
-      const record = findByIdOrPrefix(await listModelRecords(), id);
-      if (!record) throw new Error(`Model not found: ${id}`);
-      return record;
+    });
+    await mkdir5(dirname8(args.outputPath), { recursive: true });
+    await writeFile4(args.outputPath, `${JSON.stringify(spec2, null, 2)}
+`, "utf8");
+    return spec2;
+  }
+  if (!args.baseModel) {
+    throw new Error("Adapter specs require --model.");
+  }
+  const spec = localAdapterSpecFileSchema.parse({
+    id: randomUUID3(),
+    name: args.name,
+    description: "",
+    system_prompt: "Describe the behavior this local model should learn.",
+    guidelines: [
+      "Return concise, task-specific answers."
+    ],
+    constraints: [],
+    base_model: args.baseModel,
+    examples: [
+      {
+        input: "Replace this with representative training input.",
+        output: "Replace this with the expected training output."
+      },
+      {
+        input: "Replace this with a different validation input.",
+        output: "Replace this with the expected validation output."
+      }
+    ],
+    hyperparameters: {
+      n_epochs: 1
     }
-  };
+  });
+  await mkdir5(dirname8(args.outputPath), { recursive: true });
+  await writeFile4(args.outputPath, `${JSON.stringify(spec, null, 2)}
+`, "utf8");
+  return spec;
 }
-
-// src/local-runtime/prefetch.ts
-import { createHash as createHash4 } from "crypto";
-import { createReadStream as createReadStream2 } from "fs";
-import { lstat as lstat3, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve as resolve8, sep as sep3 } from "path";
-
-// src/local-runtime/process-runner.ts
-import { createHash as createHash3 } from "crypto";
-import { spawn } from "child_process";
-import { createWriteStream, readFileSync } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join3, resolve as resolve6 } from "path";
-var packageRoot = localRuntimePackageRoot(import.meta.url);
-var bundledProject = join3(packageRoot, "training/local-runner");
-var bundledRuntimeHash = (() => {
-  const hash = createHash3("sha256");
-  for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join3(bundledProject, name)));
-  }
-  return hash.digest("hex").slice(0, 20);
-})();
-var BUNDLED_PYTHON_ENVIRONMENT = join3(
-  resolve6(process.env.XDG_CACHE_HOME ?? join3(homedir3(), ".cache")),
-  "tuned-tensor-local",
-  "uv",
-  bundledRuntimeHash
-);
-var foundationProject = join3(packageRoot, "training/foundation");
-var foundationRuntimeHash = (() => {
-  const hash = createHash3("sha256");
-  for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join3(foundationProject, name)));
+async function initLocalRunnerConfigFile(args) {
+  if (!args.force && await exists2(args.outputPath)) {
+    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
   }
-  return hash.digest("hex").slice(0, 20);
-})();
-var FOUNDATION_PYTHON_ENVIRONMENT = join3(
-  resolve6(process.env.XDG_CACHE_HOME ?? join3(homedir3(), ".cache")),
-  "tuned-tensor-local",
-  "uv-foundation",
-  foundationRuntimeHash
-);
-function buildBundledPythonCommand(entrypoint, args = []) {
-  const target = entrypoint === "-c" ? entrypoint : join3(bundledProject, "src", entrypoint);
-  const commandArgs = [
-    "run",
-    "--frozen",
-    "--quiet",
-    "--project",
-    bundledProject,
-    "python",
-    target,
-    ...args
-  ];
-  return {
-    command: "uv",
-    commandArgs,
-    displayCommand: ["uv", ...commandArgs]
+  const config = {
+    artifactRoot: DEFAULT_ARTIFACT_ROOT,
+    storeRoot: DEFAULT_PROJECT_STORE_ROOT,
+    evaluation: {
+      inference: {
+        device: "cuda"
+      },
+      scoring: {
+        mode: "exact_match"
+      },
+      timeoutMs: 18e5
+    }
   };
+  await mkdir5(dirname8(args.outputPath), { recursive: true });
+  await writeFile4(args.outputPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return config;
 }
-function withBundledPythonEnvironment(env) {
-  return {
-    ...env,
-    UV_PROJECT_ENVIRONMENT: BUNDLED_PYTHON_ENVIRONMENT
-  };
+function placeholderIssues(systemPrompt, examples) {
+  const issues = [];
+  if (/describe the behavior this local model should learn/i.test(systemPrompt)) {
+    issues.push("system_prompt still contains the generated placeholder");
+  }
+  examples.forEach((example, index) => {
+    if (/replace this with/i.test(example.input) || /replace this with/i.test(example.output)) {
+      issues.push(`examples[${index}] still contains generated placeholder text`);
+    }
+  });
+  return issues;
 }
-function buildFoundationPythonCommand(entrypoint, args = []) {
-  const commandArgs = [
-    "run",
-    "--frozen",
-    "--quiet",
-    "--project",
-    foundationProject,
-    "python",
-    join3(foundationProject, "src", entrypoint),
-    ...args
-  ];
-  return {
-    command: "uv",
-    commandArgs,
-    displayCommand: ["uv", ...commandArgs]
-  };
+function generatedPlaceholderIssues(request) {
+  return placeholderIssues(request.spec_snapshot.system_prompt, request.spec_snapshot.examples);
 }
-function withFoundationPythonEnvironment(env) {
-  return {
-    ...env,
-    UV_PROJECT_ENVIRONMENT: FOUNDATION_PYTHON_ENVIRONMENT
-  };
+function assertLocalRunInputReady(request) {
+  const issues = generatedPlaceholderIssues(request);
+  if (issues.length > 0) {
+    throw new Error(`Edit the generated behavior spec before training: ${issues.join("; ")}.`);
+  }
 }
-var ProcessCancelledError = class extends Error {
-  constructor(message = "Process cancelled.") {
-    super(message);
-    this.name = "ProcessCancelledError";
+function foundationPlaceholderIssues(spec) {
+  return placeholderIssues(spec.system_prompt, spec.examples);
+}
+function assertFoundationSpecReady(spec) {
+  const issues = foundationPlaceholderIssues(spec);
+  if (issues.length > 0) {
+    throw new Error(`Edit the generated foundation spec before training: ${issues.join("; ")}.`);
   }
-};
-async function openProcessLog(path, exclusive) {
-  const stream = createWriteStream(path, {
-    flags: exclusive ? "wx" : "w",
-    mode: 384
-  });
-  await new Promise((resolveOpen, reject) => {
-    const onOpen = () => {
-      stream.off("error", onError);
-      resolveOpen();
-    };
-    const onError = (error) => {
-      stream.off("open", onOpen);
-      reject(error);
-    };
-    stream.once("open", onOpen);
-    stream.once("error", onError);
-  });
-  return stream;
 }
-async function runLoggedProcess(args) {
-  if (args.logPath) await mkdir4(dirname5(args.logPath), { recursive: true });
-  const logStream = args.logPath ? await openProcessLog(args.logPath, args.exclusiveLog ?? false) : null;
-  let stderr = "";
-  try {
-    const exitCode = await new Promise((resolvePromise, reject) => {
-      const child = spawn(args.command, args.commandArgs, {
-        cwd: args.cwd ? resolve6(args.cwd) : process.cwd(),
-        stdio: ["ignore", "pipe", "pipe"],
-        env: args.env ?? process.env,
-        detached: process.platform !== "win32"
-      });
-      let timedOut = false;
-      let cancelled = false;
-      let cancellationError;
-      let cancellationCheckRunning = false;
-      let forceKillTimer = null;
-      const killProcessGroup = (signal) => {
-        if (child.pid && process.platform !== "win32") {
-          try {
-            process.kill(-child.pid, signal);
-            return;
-          } catch {
-          }
-        }
-        child.kill(signal);
-      };
-      const requestStop = (signal = "SIGTERM") => {
-        killProcessGroup(signal);
-        if (!forceKillTimer) {
-          forceKillTimer = setTimeout(() => killProcessGroup("SIGKILL"), 5e3);
-          forceKillTimer.unref();
-        }
-      };
-      const onSigint = () => {
-        cancelled = true;
-        requestStop("SIGINT");
-      };
-      const onSigterm = () => {
-        cancelled = true;
-        requestStop("SIGTERM");
-      };
-      process.once("SIGINT", onSigint);
-      process.once("SIGTERM", onSigterm);
-      const timer = args.timeoutMs ? setTimeout(() => {
-        timedOut = true;
-        requestStop();
-      }, args.timeoutMs) : null;
-      const cancellationTimer = args.shouldCancel ? setInterval(() => {
-        if (cancellationCheckRunning || cancelled) return;
-        cancellationCheckRunning = true;
-        Promise.resolve(args.shouldCancel?.()).then((requested) => {
-          if (!requested || cancelled) return;
-          cancelled = true;
-          requestStop();
-        }).catch((error) => {
-          cancellationError = error;
-          requestStop();
-        }).finally(() => {
-          cancellationCheckRunning = false;
-        });
-      }, args.cancelPollMs ?? 250) : null;
-      cancellationTimer?.unref();
-      const clearProcessTimers = () => {
-        if (timer) clearTimeout(timer);
-        if (cancellationTimer) clearInterval(cancellationTimer);
-        if (forceKillTimer) clearTimeout(forceKillTimer);
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-      };
-      if (logStream) {
-        child.stdout.pipe(logStream, { end: false });
-        child.stderr.pipe(logStream, { end: false });
-      }
-      forwardStreamLines(child.stdout, (line) => {
-        args.onLine?.(line, "stdout");
-        if (args.reporter?.verbose) {
-          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stdout", message: line }));
-        }
-      });
-      forwardStreamLines(child.stderr, (line) => {
-        stderr += `${line}
-`;
-        args.onLine?.(line, "stderr");
-        if (args.reporter?.verbose) {
-          reportInBackground(() => args.reporter?.onLog?.({ stage: args.stage, stream: "stderr", message: line }));
-        }
-      });
-      child.on("error", (error) => {
-        clearProcessTimers();
-        reject(timedOut ? new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`) : error);
-      });
-      child.on("close", (code) => {
-        if (timedOut || cancelled || cancellationError || args.terminateProcessGroupOnExit) {
-          killProcessGroup("SIGKILL");
-        }
-        clearProcessTimers();
-        if (timedOut) {
-          reject(new Error(args.timeoutMessage ?? `${args.command} timed out after ${args.timeoutMs}ms`));
-          return;
-        }
-        if (cancellationError) {
-          reject(cancellationError);
-          return;
-        }
-        if (cancelled) {
-          reject(new ProcessCancelledError(`${args.stage} was cancelled.`));
-          return;
-        }
-        resolvePromise(code ?? 1);
-      });
-    });
-    return { exitCode, stderr };
-  } finally {
-    if (logStream) {
-      await new Promise((resolveEnd) => {
-        logStream.end(resolveEnd);
-      });
-    }
+function runRequestFromLocalSpec(spec, options = {}) {
+  if (isFoundationSpecFile(spec)) {
+    throw new Error(
+      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
+    );
+  }
+  const {
+    id,
+    engine: _engine,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt,
+    ...specSnapshot
+  } = spec;
+  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
+  return fineTuneRunRequestSchema.parse({
+    run_id: options.runId ?? randomUUID3(),
+    user_id: "local-user",
+    behavior_spec_id: behaviorSpecId,
+    run_number: 1,
+    spec_snapshot: specSnapshot,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt
+  });
+}
+function deterministicBehaviorSpecId(spec) {
+  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
+  const digest = createHash3("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
+  digest[6] = digest[6] & 15 | 80;
+  digest[8] = digest[8] & 63 | 128;
+  const hex = digest.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
+}
+async function loadLocalRunInput(path, options = {}) {
+  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile4(path, "utf8")), path);
+  const request = fineTuneRunRequestSchema.safeParse(raw);
+  if (request.success) {
+    return { kind: "request", path, request: request.data };
+  }
+  const spec = localBehaviorSpecFileSchema.parse(raw);
+  if (isFoundationSpecFile(spec)) {
+    return { kind: "foundation-spec", path, spec };
   }
+  return {
+    kind: "spec",
+    path,
+    spec,
+    request: runRequestFromLocalSpec(spec, options)
+  };
 }
 
-// src/local-runtime/huggingface-cache.ts
-import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join4, resolve as resolve7 } from "path";
-function minimalMachineLearningEnvironment(env) {
-  const exact = /* @__PURE__ */ new Set([
-    "PATH",
-    "HOME",
-    "USER",
-    "LOGNAME",
-    "SHELL",
-    "TMPDIR",
-    "TEMP",
-    "TMP",
-    "LANG",
-    "LANGUAGE",
-    "LD_LIBRARY_PATH",
-    "DYLD_LIBRARY_PATH",
-    "XDG_CACHE_HOME",
-    "SSL_CERT_FILE",
-    "REQUESTS_CA_BUNDLE",
-    "CURL_CA_BUNDLE",
-    "NO_PROXY",
-    "no_proxy",
-    "UV_CACHE_DIR",
-    "UV_PYTHON",
-    "HF_HOME",
-    "HF_HUB_CACHE",
-    "HUGGINGFACE_HUB_CACHE",
-    "HF_ENDPOINT",
-    "HF_TOKEN",
-    "HF_HUB_OFFLINE",
-    "HF_HUB_DISABLE_TELEMETRY",
-    "TRANSFORMERS_OFFLINE",
-    "HF_HUB_ENABLE_HF_TRANSFER",
-    "PYTHONUTF8",
-    "PYTHONIOENCODING"
-  ]);
-  const prefixes = [
-    "LC_",
-    "CUDA_",
-    "NVIDIA_",
-    "NCCL_",
-    "OMP_",
-    "MKL_",
-    "TORCH_",
-    "PYTORCH_",
-    "TOKENIZERS_",
-    "HF_XET_"
-  ];
-  const result = Object.fromEntries(Object.entries(env).filter(
-    ([key]) => exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix))
-  ));
-  result.TORCH_DISABLE_NATIVE_JIT ??= "1";
-  return result;
-}
-function resolveHuggingFaceCacheLayout(modelCache) {
-  const hfHome = resolve7(modelCache);
+// src/local-runtime/dataset.ts
+import { readFile as readFile5 } from "fs/promises";
+async function loadNormalizedChatJsonl(path) {
+  const text = await readFile5(path, "utf8");
+  const rows = [];
+  const jsonLines = [];
+  for (const [index, line] of text.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (error) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
+    }
+    const messages = value.messages;
+    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
+      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
+    )) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
+      );
+    }
+    const row = { messages };
+    const offset = row.messages.length === 3 ? 1 : 0;
+    if (offset === 1 && row.messages[0]?.role !== "system" || row.messages[offset]?.role !== "user" || !row.messages[offset]?.content.trim() || row.messages[offset + 1]?.role !== "assistant" || !row.messages[offset + 1]?.content.trim()) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one non-empty user message, and one non-empty assistant answer`
+      );
+    }
+    rows.push(row);
+    jsonLines.push(JSON.stringify(row));
+  }
+  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
   return {
-    hfHome,
-    hubCache: join4(hfHome, "hub")
+    rows,
+    jsonl: jsonLines.join("\n")
   };
 }
-function withHuggingFaceCacheEnvironment(env, modelCache) {
-  const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
-  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve7(inheritedHub)) : join4(homedir4(), ".cache", "huggingface"));
-  const layout = resolveHuggingFaceCacheLayout(canonicalHome);
-  const result = {
-    ...env,
-    HF_HOME: layout.hfHome,
-    HF_HUB_CACHE: layout.hubCache,
-    HUGGINGFACE_HUB_CACHE: layout.hubCache
+async function normalizeChatJsonlForRelocation(path) {
+  return (await loadNormalizedChatJsonl(path)).jsonl;
+}
+function buildSystemMessage(spec) {
+  const parts = [];
+  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
+  if (spec.guidelines.length > 0) {
+    parts.push(`Guidelines:
+${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
+  }
+  if (spec.constraints.length > 0) {
+    parts.push(`Constraints:
+${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
+  }
+  return parts.join("\n\n") || "Follow the demonstrated behavior.";
+}
+function exampleToChatRow(spec, example) {
+  const system = buildSystemMessage(spec);
+  return {
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: example.input },
+      { role: "assistant", content: example.output }
+    ]
   };
-  delete result.TRANSFORMERS_CACHE;
-  delete result.PYTORCH_TRANSFORMERS_CACHE;
-  delete result.PYTORCH_PRETRAINED_BERT_CACHE;
-  return result;
 }
-function withOfflineHuggingFaceCacheEnvironment(env, modelCache) {
+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 {
-    ...withHuggingFaceCacheEnvironment(env, modelCache),
-    HF_HUB_OFFLINE: "1",
-    TRANSFORMERS_OFFLINE: "1"
+    examples: normalized.rows.map((row) => ({
+      input: row.messages.at(-2).content,
+      output: row.messages.at(-1).content
+    })),
+    system: configuredSystem ?? embeddedSystem ?? "You are a helpful assistant."
   };
 }
 
 // src/local-runtime/prefetch.ts
+import { createHash as createHash4 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+import { lstat as lstat4, mkdir as mkdir6, readFile as readFile6, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join8, relative as relative2, resolve as resolve10, sep as sep3 } from "path";
 var NEMOTRON_BF16_FILE_DIGESTS = {
   ".gitattributes": { algorithm: "sha1", digest: "fe3f694ce14b577c9833fca6e83c5e26a7119127" },
   "LICENSE": { algorithm: "sha1", digest: "4d76cc87c9edb280753e3bee3b499ae461113835" },
@@ -2366,13 +3205,13 @@ async function certifiedFileDigest(path, expected) {
 }
 function isStrictPhysicalDescendant(parent, child) {
   const candidate = relative2(parent, child);
-  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute3(candidate);
+  return candidate !== "" && candidate !== ".." && !candidate.startsWith(`..${sep3}`) && !isAbsolute4(candidate);
 }
 async function verifySnapshotCacheLocation(path, modelId, revision, modelCache) {
   const repository = `models--${modelId.replaceAll("/", "--")}`;
   const layout = resolveHuggingFaceCacheLayout(modelCache);
-  const repositoryRoot = join5(layout.hubCache, repository);
-  const expectedPath = join5(repositoryRoot, "snapshots", revision);
+  const repositoryRoot = join8(layout.hubCache, repository);
+  const expectedPath = join8(repositoryRoot, "snapshots", revision);
   const [
     physicalCacheRoot,
     physicalHubRoot,
@@ -2384,7 +3223,7 @@ async function verifySnapshotCacheLocation(path, modelId, revision, modelCache)
     realpath2(layout.hfHome).catch(() => null),
     realpath2(layout.hubCache).catch(() => null),
     realpath2(repositoryRoot).catch(() => null),
-    realpath2(join5(repositoryRoot, "blobs")).catch(() => null),
+    realpath2(join8(repositoryRoot, "blobs")).catch(() => null),
     realpath2(path).catch(() => null),
     realpath2(expectedPath).catch(() => null)
   ]);
@@ -2400,7 +3239,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: ${join5(repositoryRoot, "blobs")}`);
+    throw new Error(`Hugging Face blob store escapes its repository: ${join8(repositoryRoot, "blobs")}`);
   }
   if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalExpectedPath)) {
     throw new Error(`Hugging Face snapshot escapes its configured repository: ${expectedPath}`);
@@ -2449,7 +3288,7 @@ async function verifyCertifiedLocalSnapshot(path, modelId, snapshotFiles, modelC
   );
   const physicalFiles = /* @__PURE__ */ new Map();
   for (const file of snapshotFiles) {
-    const metadata = await lstat3(file);
+    const metadata = await lstat4(file);
     const target = await realpath2(file);
     if (metadata.isSymbolicLink()) {
       if (!isStrictPhysicalDescendant(physicalBlobRoot, target)) {
@@ -2462,13 +3301,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: ${join5(path, unexpected[0])}`);
+    throw new Error(`Certified snapshot contains unexpected file: ${join8(path, unexpected[0])}`);
   }
   for (const [name, expected] of Object.entries(digests)) {
     if (!actualFiles.has(name)) {
-      throw new Error(`Certified snapshot file is missing: ${join5(path, name)}`);
+      throw new Error(`Certified snapshot file is missing: ${join8(path, name)}`);
     }
-    const file = join5(path, name);
+    const file = join8(path, name);
     const physicalFile = physicalFiles.get(file);
     if (await certifiedFileDigest(physicalFile, expected) !== expected.digest) {
       throw new Error(`Certified snapshot file checksum mismatch: ${file}`);
@@ -2487,7 +3326,7 @@ function buildModelPrefetchPayload(request, config) {
   return {
     base_model: model.id,
     ...revision ? { revision } : {},
-    ...config.paths.modelCache ? { model_cache: resolve8(config.paths.modelCache) } : {}
+    ...config.paths.modelCache ? { model_cache: resolve10(config.paths.modelCache) } : {}
   };
 }
 function safeName(value) {
@@ -2498,7 +3337,7 @@ function transformersWeightName(name) {
   return lower.endsWith(".safetensors") && !lower.startsWith("adapter_") || /^pytorch_model.*\.bin$/.test(lower);
 }
 async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
-  const root = await lstat3(path).catch(() => null);
+  const root = await lstat4(path).catch(() => null);
   if (!root) throw new Error(`paths.baseModel is set to ${path}, but that path does not exist.`);
   if (root.isSymbolicLink()) {
     throw new Error(`paths.baseModel must not itself be a symbolic link: ${path}`);
@@ -2511,7 +3350,7 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir4(directory, { withFileTypes: true })) {
-      const child = join5(directory, entry.name);
+      const child = join8(directory, entry.name);
       if (entry.isSymbolicLink()) {
         const metadata2 = await stat4(child);
         if (!metadata2.isFile()) {
@@ -2535,15 +3374,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(join5(path, name)).catch(() => null);
+    const metadata = await stat4(join8(path, name)).catch(() => null);
     return Boolean(metadata?.isFile() && metadata.size > 0);
   };
   if (!await required("config.json")) throw new Error(`Local base-model directory is missing config.json: ${path}`);
   try {
-    const config = JSON.parse(await readFile5(join5(path, "config.json"), "utf8"));
+    const config = JSON.parse(await readFile6(join8(path, "config.json"), "utf8"));
     assertCertifiedBaseModelConfig(
       config,
-      `Local base-model config ${join5(path, "config.json")}`,
+      `Local base-model config ${join8(path, "config.json")}`,
       expectedModelId
     );
   } catch (error) {
@@ -2573,7 +3412,7 @@ async function verifyLocalBaseModel(path, expectedModelId, modelCache) {
     throw new Error(`Local base-model directory is missing tokenizer metadata or vocabulary: ${path}`);
   }
   for (const file of files.filter((candidate) => candidate.path.endsWith(".index.json"))) {
-    const parsed = JSON.parse(await readFile5(file.path, "utf8"));
+    const parsed = JSON.parse(await readFile6(file.path, "utf8"));
     if (!parsed.weight_map || typeof parsed.weight_map !== "object" || Array.isArray(parsed.weight_map)) {
       throw new Error(`Local base-model weight index is invalid: ${file.path}`);
     }
@@ -2593,14 +3432,14 @@ async function prefetchBaseModel(args) {
     ...buildModelPrefetchPayload(args.request, args.config),
     ...args.localOnly ? { local_files_only: true } : {}
   };
-  const artifactDir = resolve8(
+  const artifactDir = resolve10(
     args.config.artifactRoot,
     args.localOnly ? "verify-base" : "prefetch",
     `${safeName(args.request.spec_snapshot.base_model)}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`
   );
-  await mkdir5(artifactDir, { recursive: true });
+  await mkdir6(artifactDir, { recursive: true });
   if (args.config.paths.baseModel) {
-    const localPath = resolve8(args.config.paths.baseModel);
+    const localPath = resolve10(args.config.paths.baseModel);
     const verified = await verifyLocalBaseModel(
       localPath,
       args.request.spec_snapshot.base_model,
@@ -2617,9 +3456,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 = join5(artifactDir, "prefetch-input.json");
-  const outputPath = join5(artifactDir, "prefetch-output.json");
-  const logPath = join5(artifactDir, "prefetch.log");
+  const inputPath = join8(artifactDir, "prefetch-input.json");
+  const outputPath = join8(artifactDir, "prefetch-output.json");
+  const logPath = join8(artifactDir, "prefetch.log");
   await writeJson(inputPath, payload);
   const entrypoint = buildBundledPythonCommand(
     "prefetch.py",
@@ -2656,7 +3495,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(
@@ -2739,17 +3578,17 @@ function evaluateGeneralRegressionGate(comparison, policy) {
 }
 
 // src/local-runtime/orchestrator.ts
-import { lstat as lstat4, mkdir as mkdir8, open as open2, readFile as readFile8, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
+import { lstat as lstat5, mkdir as mkdir9, open as open2, readFile as readFile9, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
 import { createReadStream as createReadStream3 } from "fs";
 import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import { performance } from "perf_hooks";
 import { homedir as homedir5 } from "os";
-import { basename, dirname as dirname8, join as join8, relative as relative3, resolve as resolve11 } from "path";
+import { basename, dirname as dirname10, join as join11, relative as relative3, resolve as resolve13 } from "path";
 
 // src/local-runtime/evaluation.ts
 import { createHash as createHash5 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname7, join as join6, resolve as resolve9 } from "path";
+import { mkdir as mkdir7, readFile as readFile7, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname9, join as join9, resolve as resolve11 } from "path";
 function normalize(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -2969,8 +3808,8 @@ async function runTransformersInference(args) {
   const inputPath = `${args.outputPath}.inference-input.json`;
   const outputPath = `${args.outputPath}.inference-output.json`;
   const logPath = `${args.outputPath}.inference.log`;
-  await mkdir6(dirname7(inputPath), { recursive: true });
-  await writeFile4(inputPath, `${JSON.stringify({
+  await mkdir7(dirname9(inputPath), { recursive: true });
+  await writeFile5(inputPath, `${JSON.stringify({
     protocol_version: INFERENCE_PROTOCOL_VERSION,
     kind: args.kind,
     model_id: args.modelId,
@@ -2984,7 +3823,7 @@ async function runTransformersInference(args) {
       id: String(index),
       input: example.input
     })),
-    model_cache: args.config.paths.modelCache ? resolve9(args.config.paths.modelCache) : void 0,
+    model_cache: args.config.paths.modelCache ? resolve11(args.config.paths.modelCache) : void 0,
     trust_remote_code: false,
     device: args.config.evaluation.inference.device,
     generation: {
@@ -3033,7 +3872,7 @@ async function runTransformersInference(args) {
   }
   let output;
   try {
-    output = JSON.parse(await readFile6(outputPath, "utf8"));
+    output = JSON.parse(await readFile7(outputPath, "utf8"));
   } catch (error) {
     throw new Error(
       `Transformers inference did not write valid JSON: ${error instanceof Error ? error.message : String(error)}`
@@ -3069,13 +3908,16 @@ function baselineCacheKey(args) {
 function baselineInputsAreStable(args) {
   return args.config.paths.baseModel ? Boolean(args.sourceFingerprint) : Boolean(args.baseModelRevision);
 }
+function baselineStoreRoot(config) {
+  return config.storeRoot ? resolve11(config.storeRoot) : defaultLocalHome();
+}
 function baselineCachePath(config, key) {
-  const root = config.storeRoot ? resolve9(config.storeRoot) : defaultLocalHome();
-  return join6(root, "cache", "baseline-evals", `${key}.json`);
+  return join9(baselineStoreRoot(config), "cache", "baseline-evals", `${key}.json`);
 }
-async function readBaselineCache(path) {
+async function readBaselineCache(config, path) {
+  await hardenExistingLocalStore(baselineStoreRoot(config));
   try {
-    return evalReportSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+    return evalReportSchema.parse(JSON.parse(await readFile7(path, "utf8")));
   } catch {
     return null;
   }
@@ -3084,7 +3926,7 @@ var cachedPackageVersion = null;
 async function packageVersion() {
   if (cachedPackageVersion !== null) return cachedPackageVersion;
   try {
-    const raw = await readFile6(resolve9(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
+    const raw = await readFile7(resolve11(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
     cachedPackageVersion = String(
       JSON.parse(raw).version ?? "unknown"
     );
@@ -3153,7 +3995,7 @@ async function evaluateExamples(args) {
     baseModelId,
     args.baseModelRevision
   );
-  const localModelSource = args.modelSource ? resolve9(args.modelSource) !== resolve9(baseModelId) : false;
+  const localModelSource = args.modelSource ? resolve11(args.modelSource) !== resolve11(baseModelId) : false;
   const baseModelRevision = localModelSource ? defaultBaseModelRevision(baseModelId) : requestedBaseModelRevision;
   const maxExamples = args.config.evaluation.maxExamples ?? args.maxExamples ?? args.examples.length;
   const truncated = args.examples.length > maxExamples;
@@ -3178,7 +4020,7 @@ async function evaluateExamples(args) {
     packageVersion: await packageVersion()
   }) : null;
   if (cacheKey) {
-    const cached = await readBaselineCache(baselineCachePath(args.config, cacheKey));
+    const cached = await readBaselineCache(args.config, baselineCachePath(args.config, cacheKey));
     if (cached) {
       const report2 = evalReportSchema.parse({
         ...cached,
@@ -3229,7 +4071,8 @@ async function evaluateExamples(args) {
     logUri: inference ? fileUri(`${args.outputPath}.inference.log`) : void 0
   });
   if (cacheKey) {
-    await writeJson(
+    await createLocalStore(baselineStoreRoot(args.config)).ensure();
+    await writePrivateJsonAtomic(
       baselineCachePath(args.config, cacheKey),
       { ...report, cache_key: cacheKey }
     );
@@ -3268,8 +4111,8 @@ function compareEvalReports(baseline, candidate) {
 }
 
 // src/local-runtime/process-training.ts
-import { access, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import { join as join7, resolve as resolve10 } from "path";
+import { access as access2, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { join as join10, resolve as resolve12 } from "path";
 function buildTrainingHyperparameters(request, options = {}) {
   const model = resolveTrainingModel(request.spec_snapshot.base_model);
   const hyper = request.hyperparameters;
@@ -3293,7 +4136,7 @@ function buildTrainingHyperparameters(request, options = {}) {
 }
 async function pathExists(path) {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -3360,15 +4203,15 @@ function createTrainingProgressForwarder(reporter) {
 async function launchProcessTraining(args) {
   const { request, artifacts, config } = args;
   const jobName = `tt-local-${request.run_id}`;
-  await mkdir7(artifacts.trainingDir, { recursive: true });
+  await mkdir8(artifacts.trainingDir, { recursive: true });
   await copyDatasetToTrainingChannel(artifacts);
   const hyperparameters = buildTrainingHyperparameters(request, {
     baseModelRevision: args.baseModelRevision
   });
-  await writeJson(join7(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
+  await writeJson(join10(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
   const entrypoint = buildBundledPythonCommand("train.py");
   if (config.dryRun) {
-    await writeFile5(
+    await writeFile6(
       artifacts.trainingLog,
       "Dry run enabled. Training process was not launched.\n",
       "utf8"
@@ -3390,20 +4233,20 @@ async function launchProcessTraining(args) {
     withOfflineHuggingFaceCacheEnvironment({
       ...inheritedEnv,
       BACKEND: "local",
-      SM_CHANNEL_TRAINING: resolve10(artifacts.trainingInputDir),
-      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve10(config.paths.baseModel) : void 0,
-      SM_MODEL_DIR: resolve10(artifacts.trainingModelDir),
-      SM_OUTPUT_DIR: resolve10(artifacts.trainingOutputDir),
-      TT_HYPERPARAMETERS_PATH: resolve10(artifacts.trainingConfigDir, "hyperparameters.json")
+      SM_CHANNEL_TRAINING: resolve12(artifacts.trainingInputDir),
+      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve12(config.paths.baseModel) : void 0,
+      SM_MODEL_DIR: resolve12(artifacts.trainingModelDir),
+      SM_OUTPUT_DIR: resolve12(artifacts.trainingOutputDir),
+      TT_HYPERPARAMETERS_PATH: resolve12(artifacts.trainingConfigDir, "hyperparameters.json")
     }, config.paths.modelCache)
   );
   for (const [key, value] of Object.entries(childEnv)) {
     if (value === void 0) delete childEnv[key];
   }
-  if (config.paths.modelCache) await mkdir7(resolve10(config.paths.modelCache), { recursive: true });
+  if (config.paths.modelCache) await mkdir8(resolve12(config.paths.modelCache), { recursive: true });
   if (config.paths.baseModel) {
     await verifyLocalBaseModel(
-      resolve10(config.paths.baseModel),
+      resolve12(config.paths.baseModel),
       request.spec_snapshot.base_model,
       config.paths.modelCache
     );
@@ -3430,12 +4273,12 @@ async function launchProcessTraining(args) {
     onLine: (line) => forwardTrainingProgress(line),
     shouldCancel: args.shouldCancel
   });
-  const metricsPath = join7(artifacts.trainingModelDir, "training-metrics.json");
-  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile7(metricsPath, "utf8")) : null;
+  const metricsPath = join10(artifacts.trainingModelDir, "training-metrics.json");
+  const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile8(metricsPath, "utf8")) : null;
   if (exitCode !== 0) {
     throw new Error(`Training process exited with code ${exitCode}. See ${artifacts.trainingLog}.`);
   }
-  const modelTarPath = join7(artifacts.trainingOutputDir, "model.tar.gz");
+  const modelTarPath = join10(artifacts.trainingOutputDir, "model.tar.gz");
   const modelUri = await pathExists(modelTarPath) ? fileUri(modelTarPath) : fileUri(artifacts.trainingModelDir);
   await args.reporter?.onEvent?.({
     stage: "training",
@@ -3530,21 +4373,21 @@ function validateLocalPipeline(pipeline) {
   return pipeline;
 }
 async function loadJsonFile(path) {
-  return JSON.parse(await readFile8(path, "utf8"));
+  return JSON.parse(await readFile9(path, "utf8"));
 }
 async function loadRunRequest(path) {
   return fineTuneRunRequestSchema.parse(await loadJsonFile(path));
 }
 async function loadLocalRunnerConfig(path) {
   if (!path) return localRunnerConfigSchema.parse({});
-  const configPath = resolve11(path);
-  const base = dirname8(configPath);
+  const configPath = resolve13(path);
+  const base = dirname10(configPath);
   const config = localRunnerConfigSchema.parse(await loadJsonFile(configPath));
   const configPathValue = (value) => {
     if (!value) return void 0;
     if (value === "~") return homedir5();
-    if (value.startsWith("~/")) return resolve11(homedir5(), value.slice(2));
-    return resolve11(base, value);
+    if (value.startsWith("~/")) return resolve13(homedir5(), value.slice(2));
+    return resolve13(base, value);
   };
   return {
     ...config,
@@ -3742,21 +4585,21 @@ async function hashFileIfPresent(path) {
 }
 async function packageVersion2() {
   try {
-    const parsed = JSON.parse(await readFile8(resolve11(packageRoot2, "package.json"), "utf8"));
+    const parsed = JSON.parse(await readFile9(resolve13(packageRoot2, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : "unknown";
   } catch {
     return "unknown";
   }
 }
 async function runtimeFingerprint() {
-  const bundledProject2 = resolve11(packageRoot2, "training/local-runner");
+  const bundledProject2 = resolve13(packageRoot2, "training/adapter");
   return hashJson({
     tt_local_version: await packageVersion2(),
     node_version: process.version,
     platform: process.platform,
     architecture: process.arch,
-    runner_pyproject: await hashFileIfPresent(resolve11(bundledProject2, "pyproject.toml")),
-    runner_uv_lock: await hashFileIfPresent(resolve11(bundledProject2, "uv.lock"))
+    runner_pyproject: await hashFileIfPresent(resolve13(bundledProject2, "pyproject.toml")),
+    runner_uv_lock: await hashFileIfPresent(resolve13(bundledProject2, "uv.lock"))
   });
 }
 function preparedSourceFingerprint(args) {
@@ -3803,9 +4646,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 = resolve11(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
+  const refPath = resolve13(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
   try {
-    const revision = (await readFile8(refPath, "utf8")).trim();
+    const revision = (await readFile9(refPath, "utf8")).trim();
     if (revision) return revision;
   } catch {
   }
@@ -3813,7 +4656,7 @@ async function resolveBaseModelRevision(request, config) {
 }
 async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
   const root = localModelArtifactPath(uri);
-  const rootMetadata = await lstat4(root);
+  const rootMetadata = await lstat5(root);
   if (rootMetadata.isSymbolicLink()) {
     throw new Error(`Local base model path must not itself be a symbolic link: ${root}`);
   }
@@ -3824,7 +4667,7 @@ async function fingerprintLocalBaseModel(uri, expectedModelId, modelCache) {
   const files = [];
   const visit = async (directory) => {
     for (const entry of await readdir5(directory, { withFileTypes: true })) {
-      const child = resolve11(directory, entry.name);
+      const child = resolve13(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(child);
         continue;
@@ -3863,12 +4706,12 @@ async function readStageMetadata(path) {
   }
 }
 async function removePrefixedArtifacts(path) {
-  const directory = dirname8(path);
+  const directory = dirname10(path);
   const prefix = `${basename(path)}.`;
   const names = await readdir5(directory).catch(() => []);
   await Promise.all([
     rm3(path, { force: true }),
-    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm3(resolve11(directory, name), { recursive: true, force: true }))
+    ...names.filter((name) => name.startsWith(prefix)).map((name) => rm3(resolve13(directory, name), { recursive: true, force: true }))
   ]);
 }
 async function cleanupStageArtifacts(artifacts, stage) {
@@ -3881,7 +4724,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       rm3(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm3(resolve11(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm3(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
       removeReport(),
       rm3(artifacts.artifactManifestJson, { force: true })
     ]);
@@ -3899,7 +4742,7 @@ async function cleanupStageArtifacts(artifacts, stage) {
     await Promise.all([
       rm3(artifacts.trainingDir, { recursive: true, force: true }),
       removePrefixedArtifacts(artifacts.trainingReportJson),
-      rm3(resolve11(artifacts.runDir, "model.tar.gz"), { force: true }),
+      rm3(resolve13(artifacts.runDir, "model.tar.gz"), { force: true }),
       removePrefixedArtifacts(artifacts.candidateEvalJson),
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       removeReport()
@@ -3935,7 +4778,7 @@ async function throwIfCancelled(store, request) {
   }
 }
 async function acquireWorkflowLock(lockPath, description) {
-  await mkdir8(dirname8(lockPath), { recursive: true });
+  await mkdir9(dirname10(lockPath), { recursive: true });
   const token = randomUUID4();
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
@@ -3948,7 +4791,7 @@ async function acquireWorkflowLock(lockPath, description) {
       }
       return async () => {
         try {
-          const owner = JSON.parse(await readFile8(lockPath, "utf8"));
+          const owner = JSON.parse(await readFile9(lockPath, "utf8"));
           if (owner.token === token) await rm3(lockPath, { force: true });
         } catch {
         }
@@ -3958,7 +4801,7 @@ async function acquireWorkflowLock(lockPath, description) {
       const metadata = await stat5(lockPath).catch(() => null);
       let owner = null;
       try {
-        owner = JSON.parse(await readFile8(lockPath, "utf8"));
+        owner = JSON.parse(await readFile9(lockPath, "utf8"));
       } catch {
         owner = null;
       }
@@ -3989,11 +4832,12 @@ async function acquireWorkflowLock(lockPath, description) {
   throw new Error(`Unable to acquire local workflow lock for ${description}.`);
 }
 async function acquireRunLock(store, runId) {
-  return acquireWorkflowLock(resolve11(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
+  await store.ensure();
+  return acquireWorkflowLock(resolve13(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
 }
 async function acquireArtifactLock(artifacts) {
   return acquireWorkflowLock(
-    join8(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
+    join11(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
     `Artifact directory ${artifacts.runDir}`
   );
 }
@@ -4040,13 +4884,13 @@ function stageFingerprintPath(prepared, stage) {
   return `${stageOutputPath(prepared, stage)}.stage.json`;
 }
 async function runnerFileFingerprints() {
-  const project = resolve11(packageRoot2, "training/local-runner");
-  const bundledSource = resolve11(packageRoot2, "training/local-runner/src");
-  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve11(bundledSource, entry.name));
+  const project = resolve13(packageRoot2, "training/adapter");
+  const bundledSource = resolve13(packageRoot2, "training/adapter/src");
+  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve13(bundledSource, entry.name));
   const candidates = [.../* @__PURE__ */ new Set([
     ...pythonSources,
-    resolve11(project, "pyproject.toml"),
-    resolve11(project, "uv.lock")
+    resolve13(project, "pyproject.toml"),
+    resolve13(project, "uv.lock")
   ])];
   const fingerprints = {};
   for (const path of candidates.sort()) fingerprints[path] = await hashFileIfPresent(path);
@@ -4160,7 +5004,7 @@ async function ensureRunRecord(args) {
         `Run ${args.request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
       );
     }
-    if (resolve11(existing.artifact_dir) !== resolve11(args.artifacts.runDir)) {
+    if (resolve13(existing.artifact_dir) !== resolve13(args.artifacts.runDir)) {
       throw new Error(
         `Run ${args.request.run_id} is already bound to artifact directory ${existing.artifact_dir}; it cannot be resumed with ${args.artifacts.runDir}.`
       );
@@ -4267,7 +5111,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(resolve11(args.artifacts.runDir, "request.json"), args.request);
+  await writeJsonAtomic(resolve13(args.artifacts.runDir, "request.json"), args.request);
   const existingMetadata = preparedExists ? await readStageMetadata(args.artifacts.stageMetadataJson) : null;
   let canReuse = preparedExists && existingMetadata?.source_fingerprint === prepared.metadata.source_fingerprint;
   if (canReuse) {
@@ -4796,7 +5640,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 = join8(artifacts.runDir, "evaluations", `${step.id}.json`);
+          const reportPath = join11(artifacts.runDir, "evaluations", `${step.id}.json`);
           await writeJsonAtomic(reportPath, { ...report, artifact_uri: fileUri(reportPath) });
           outputs[step.id] = { report: { ...report, artifact_uri: fileUri(reportPath) }, reportPath };
           await refreshArtifactManifest(prepared);
@@ -4872,7 +5716,6 @@ async function runLocalFineTune(input) {
 }
 
 export {
-  writeJsonAtomic,
   assertArtifactManifest,
   TRAINING_MODELS,
   resolveTrainingModel,
@@ -4880,6 +5723,35 @@ export {
   defaultBaseModelRevision,
   resolveModelLoader,
   assertUsableModelArtifact,
+  DEFAULT_ARTIFACT_ROOT,
+  DEFAULT_FOUNDATION_RUNS_DIR,
+  expandUserPath,
+  getConfigDir,
+  getAgentConfigDir,
+  defaultStoreRoot,
+  warningsFromSnapshot,
+  minimalMachineLearningEnvironment,
+  withHuggingFaceCacheEnvironment,
+  withOfflineHuggingFaceCacheEnvironment,
+  reportInBackground,
+  sanitizeLogLine,
+  forwardStreamLines,
+  localRuntimePackageRoot,
+  buildBundledPythonCommand,
+  withBundledPythonEnvironment,
+  buildFoundationPythonCommand,
+  withFoundationPythonEnvironment,
+  runLoggedProcess,
+  readHardwareSnapshot,
+  formatHostStatusLine,
+  formatAgentHostBlock,
+  assessHardware,
+  isTerminalRunState,
+  defaultLocalHome,
+  localStorePaths,
+  hardenExistingLocalStore,
+  writePrivateJsonAtomic,
+  createLocalStore,
   datasetFormatSchema,
   baseModelRevisionSchema,
   behaviorSpecExampleSchema,
@@ -4917,22 +5789,6 @@ export {
   examplesFromSpec,
   examplesFromChatJsonl,
   evaluationSuiteFromChatJsonl,
-  reportInBackground,
-  sanitizeLogLine,
-  forwardStreamLines,
-  localRuntimePackageRoot,
-  buildBundledPythonCommand,
-  withBundledPythonEnvironment,
-  buildFoundationPythonCommand,
-  withFoundationPythonEnvironment,
-  runLoggedProcess,
-  isTerminalRunState,
-  defaultLocalHome,
-  localStorePaths,
-  createLocalStore,
-  minimalMachineLearningEnvironment,
-  withHuggingFaceCacheEnvironment,
-  withOfflineHuggingFaceCacheEnvironment,
   tokenF1,
   verifyModelPrefetchCacheReport,
   buildModelPrefetchPayload,
@@ -4949,4 +5805,4 @@ export {
   runLocalPipeline,
   runLocalFineTune
 };
-//# sourceMappingURL=chunk-2P2RL23O.js.map
+//# sourceMappingURL=chunk-AVMRHDFY.js.map