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

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

@@ -834,717 +834,183 @@ 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"
-    });
-  }
-});
-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(".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";
-}
-
-// src/local-runtime/local-project.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
-import { homedir } from "os";
-import { mkdir as mkdir2 } from "fs/promises";
-var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
-function resolveLocalReference(value, baseDirectory) {
-  if (typeof value !== "string" || !value || isAbsolute2(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
-    return value;
-  }
-  if (value === "~") return homedir();
-  if (value.startsWith("~/")) return resolve3(homedir(), value.slice(2));
-  return resolve3(baseDirectory, value);
-}
-function resolveLocalRunInputPaths(raw, inputPath) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
-  const baseDirectory = dirname2(resolve3(inputPath));
-  const value = structuredClone(raw);
-  const dataset = value.dataset_prebuilt;
-  if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
-    const fields = dataset;
-    for (const key of ["training", "validation", "test"]) {
-      if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
-    }
-  }
-  return value;
-}
-async function exists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function initLocalSpecFile(args) {
-  if (!args.force && await exists(args.outputPath)) {
-    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
-  }
-  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."
-        }
-      ],
-      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."
-      }
-    ],
-    hyperparameters: {
-      n_epochs: 1
-    }
-  });
-  await mkdir2(dirname2(args.outputPath), { recursive: true });
-  await writeFile2(args.outputPath, `${JSON.stringify(spec, null, 2)}
-`, "utf8");
-  return spec;
-}
-async function initLocalRunnerConfigFile(args) {
-  if (!args.force && await exists(args.outputPath)) {
-    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
-  }
-  const config = {
-    artifactRoot: ".tt-local/artifacts",
-    storeRoot: ".tt-local/store",
-    evaluation: {
-      inference: {
-        device: "cuda"
-      },
-      scoring: {
-        mode: "exact_match"
-      },
-      timeoutMs: 18e5
-    }
-  };
-  await mkdir2(dirname2(args.outputPath), { recursive: true });
-  await writeFile2(args.outputPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-  return config;
-}
-function 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 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);
-}
-function assertFoundationSpecReady(spec) {
-  const issues = foundationPlaceholderIssues(spec);
-  if (issues.length > 0) {
-    throw new Error(`Edit the generated foundation spec before training: ${issues.join("; ")}.`);
-  }
-}
-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 deterministicBehaviorSpecId(spec) {
-  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
-  const digest = createHash2("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
-  digest[6] = digest[6] & 15 | 80;
-  digest[8] = digest[8] & 63 | 128;
-  const hex = digest.toString("hex");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20)
-  ].join("-");
-}
-async function loadLocalRunInput(path, options = {}) {
-  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile2(path, "utf8")), path);
-  const request = fineTuneRunRequestSchema.safeParse(raw);
-  if (request.success) {
-    return { kind: "request", path, request: request.data };
-  }
-  const spec = localBehaviorSpecFileSchema.parse(raw);
-  if (isFoundationSpecFile(spec)) {
-    return { kind: "foundation-spec", path, spec };
-  }
-  return {
-    kind: "spec",
-    path,
-    spec,
-    request: runRequestFromLocalSpec(spec, options)
-  };
-}
-
-// src/local-runtime/dataset.ts
-import { readFile as readFile3 } from "fs/promises";
-async function loadNormalizedChatJsonl(path) {
-  const text = await readFile3(path, "utf8");
-  const rows = [];
-  const jsonLines = [];
-  for (const [index, line] of text.split(/\r?\n/).entries()) {
-    if (!line.trim()) continue;
-    let value;
-    try {
-      value = JSON.parse(line);
-    } catch (error) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
-    }
-    const messages = value.messages;
-    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
-      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
-    )) {
-      throw new Error(
-        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
-      );
-    }
-    const row = { messages };
-    const offset = row.messages.length === 3 ? 1 : 0;
-    if (offset === 1 && row.messages[0]?.role !== "system" || row.messages[offset]?.role !== "user" || !row.messages[offset]?.content.trim() || row.messages[offset + 1]?.role !== "assistant" || !row.messages[offset + 1]?.content.trim()) {
-      throw new Error(
-        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one non-empty user message, and one non-empty assistant answer`
-      );
-    }
-    rows.push(row);
-    jsonLines.push(JSON.stringify(row));
-  }
-  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
-  return {
-    rows,
-    jsonl: jsonLines.join("\n")
-  };
-}
-async function normalizeChatJsonlForRelocation(path) {
-  return (await loadNormalizedChatJsonl(path)).jsonl;
-}
-function buildSystemMessage(spec) {
-  const parts = [];
-  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
-  if (spec.guidelines.length > 0) {
-    parts.push(`Guidelines:
-${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
-  }
-  if (spec.constraints.length > 0) {
-    parts.push(`Constraints:
-${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
-  }
-  return parts.join("\n\n") || "Follow the demonstrated behavior.";
-}
-function exampleToChatRow(spec, example) {
-  const system = buildSystemMessage(spec);
-  return {
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: example.input },
-      { role: "assistant", content: example.output }
-    ]
-  };
-}
-function compileSpecToJsonl(spec) {
-  return spec.examples.map((example) => JSON.stringify(exampleToChatRow(spec, example))).join("\n");
-}
-function examplesFromSpec(spec) {
-  return spec.examples;
-}
-async function examplesFromChatJsonl(path) {
-  const normalized = await loadNormalizedChatJsonl(path);
-  const examples = [];
-  for (const [index, row] of normalized.rows.entries()) {
-    const user = row.messages.at(-2);
-    const assistant = row.messages.at(-1);
-    examples.push({
-      input: user.content,
-      output: assistant.content
-    });
-  }
-  return examples;
-}
-async function evaluationSuiteFromChatJsonl(path, configuredSystem) {
-  const normalized = await loadNormalizedChatJsonl(path);
-  const inputIdentities = /* @__PURE__ */ new Set();
-  for (const row of normalized.rows) {
-    const input = row.messages.at(-2).content;
-    const identity = input.trim().replace(/\s+/g, " ").toLowerCase();
-    if (inputIdentities.has(identity)) {
-      throw new Error(
-        "General regression data contains duplicate inputs; evaluation prompts must be unique."
-      );
-    }
-    inputIdentities.add(identity);
-  }
-  const systems = new Set(
-    normalized.rows.map((row) => row.messages.find((message) => message.role === "system")?.content).filter((value) => value !== void 0)
-  );
-  if (systems.size > 1) {
-    throw new Error("General regression rows must use one consistent system message.");
-  }
-  const embeddedSystem = [...systems][0];
-  if (configuredSystem !== void 0 && embeddedSystem !== void 0 && configuredSystem !== embeddedSystem) {
-    throw new Error(
-      "evaluation.generalRegression.systemPrompt must match the system message embedded in the dataset."
-    );
-  }
-  return {
-    examples: normalized.rows.map((row) => ({
-      input: row.messages.at(-2).content,
-      output: row.messages.at(-1).content
-    })),
-    system: configuredSystem ?? embeddedSystem ?? "You are a helpful assistant."
-  };
-}
-
-// src/local-runtime/run-reporter.ts
-function reportInBackground(action) {
-  try {
-    void Promise.resolve(action()).catch(() => void 0);
-  } catch {
-  }
-}
-function sanitizeLogLine(line) {
-  return line.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|secret|password)=)[^\s]+/gi, "$1[redacted]");
-}
-function forwardStreamLines(stream, onLine) {
-  let buffered = "";
-  stream.setEncoding("utf8");
-  stream.on("data", (chunk) => {
-    buffered += chunk;
-    const lines = buffered.split(/\r\n|\n|\r/);
-    buffered = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.trim()) onLine(sanitizeLogLine(line));
-    }
-  });
-  stream.on("end", () => {
-    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
-  });
-}
+// src/local-runtime/store.ts
+import { appendFile, chmod, copyFile as copyFile2, lstat as lstat3, mkdir as mkdir2, readdir as readdir3, readFile as readFile2, rename as rename2, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve4, sep as sep2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 
-// src/local-runtime/package-root.ts
+// src/paths.ts
 import { existsSync } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function localRuntimePackageRoot(moduleUrl) {
-  const moduleDirectory = dirname3(fileURLToPath2(moduleUrl));
-  const candidates = [
-    dirname3(moduleDirectory),
-    dirname3(dirname3(moduleDirectory))
-  ];
-  const root = candidates.find(
-    (candidate) => existsSync(resolve4(candidate, "package.json")) && existsSync(resolve4(candidate, "training/local-runner"))
-  );
-  if (!root) {
-    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
-  }
-  return root;
+import { homedir } from "os";
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve3 } from "path";
+var TUNED_TENSOR_DIR = ".tuned-tensor";
+var DEFAULT_ARTIFACT_ROOT = `${TUNED_TENSOR_DIR}/artifacts`;
+var DEFAULT_PROJECT_STORE_ROOT = `${TUNED_TENSOR_DIR}/store`;
+var DEFAULT_FOUNDATION_RUNS_DIR = `${TUNED_TENSOR_DIR}/foundation-runs`;
+function envHome(env = process.env) {
+  const home = env.HOME?.trim();
+  return home ? resolve3(home) : homedir();
+}
+function expandUserPath(value, env = process.env, baseDirectory = process.cwd()) {
+  const trimmed = value.trim();
+  if (trimmed === "~") return envHome(env);
+  if (trimmed.startsWith("~/")) return resolve3(envHome(env), trimmed.slice(2));
+  return isAbsolute2(trimmed) ? resolve3(trimmed) : resolve3(baseDirectory, trimmed);
+}
+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() ? resolve3(env.XDG_CONFIG_HOME) : join2(envHome(env), ".config");
+  return join2(configHome, "tuned-tensor");
+}
+function getConfigDir(env = process.env) {
+  const next = getTunedTensorHome(env);
+  if (env.TUNED_TENSOR_HOME?.trim()) return next;
+  const legacy = legacyConfigDir(env);
+  if (!existsSync(join2(next, "config.json")) && existsSync(join2(legacy, "config.json"))) {
+    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 (!existsSync(next) && existsSync(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 (!existsSync(next) && existsSync(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() ? resolve3(env.XDG_CACHE_HOME) : join2(envHome(env), ".cache");
+  const legacy = join2(cacheHome, "tuned-tensor-local", kind, hash);
+  if (!existsSync(next) && existsSync(legacy)) return legacy;
+  return next;
 }
 
 // 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";
 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: join3(root, "specs"),
+    runsDir: join3(root, "runs"),
+    modelsDir: join3(root, "models"),
+    datasetsDir: join3(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`;
-  await writeFile3(tmp, `${JSON.stringify(value, null, 2)}
-`, "utf8");
+async function ensurePrivateDirectory(path) {
+  await mkdir2(path, { recursive: true, mode: 448 });
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${path}`);
+  }
+  await chmod(path, 448);
+}
+async function hardenPrivateTree(path) {
+  const metadata = await lstat3(path);
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${path}`);
+  }
+  if (metadata.isDirectory()) {
+    await chmod(path, 448);
+    for (const entry of await readdir3(path)) {
+      await hardenPrivateTree(join3(path, entry));
+    }
+    return;
+  }
+  if (metadata.isFile()) {
+    await chmod(path, 384);
+    return;
+  }
+  throw new Error(`Refusing unsupported filesystem entry in local store: ${path}`);
+}
+async function hardenExistingLocalStore(root) {
+  const resolvedRoot = resolve4(root);
+  let metadata;
+  try {
+    metadata = await lstat3(resolvedRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+  if (metadata.isSymbolicLink()) {
+    throw new Error(`Refusing symbolic link in local store: ${resolvedRoot}`);
+  }
+  if (!metadata.isDirectory()) {
+    throw new Error(`Expected local store directory: ${resolvedRoot}`);
+  }
+  await hardenPrivateTree(resolvedRoot);
+  return true;
+}
+async function writePrivateJsonAtomic(path, value) {
+  await ensurePrivateDirectory(dirname2(path));
+  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+  await writeFile2(tmp, `${JSON.stringify(value, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
   await rename2(tmp, path);
+  await chmod(path, 384);
 }
 async function readJson2(path) {
-  return JSON.parse(await readFile4(path, "utf8"));
+  return JSON.parse(await readFile2(path, "utf8"));
 }
 async function appendJsonl(path, value) {
-  await mkdir3(dirname4(path), { recursive: true });
+  await ensurePrivateDirectory(dirname2(path));
   await appendFile(path, `${JSON.stringify(value)}
-`, "utf8");
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod(path, 384);
+}
+async function writePrivateText(path, value) {
+  await ensurePrivateDirectory(dirname2(path));
+  await writeFile2(path, value, { encoding: "utf8", mode: 384 });
+  await chmod(path, 384);
 }
 async function readJsonl(path) {
-  if (!await exists2(path)) return [];
-  return (await readFile4(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  if (!await exists(path)) return [];
+  return (await readFile2(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(dirname2(to));
   await copyFile2(from, to);
+  await chmod(to, 384);
 }
 async function childDirectoryNames(path) {
   try {
@@ -1571,41 +1037,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 = resolve4(root);
+  const resolvedCandidate = resolve4(candidate);
   return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
 }
 function createLocalStore(root = defaultLocalHome()) {
-  const resolvedRoot = resolve5(root);
+  const resolvedRoot = resolve4(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) => join3(paths.runsDir, id);
+  const runStatePath = (id) => join3(runDir(id), "state.json");
+  const runEventsPath = (id) => join3(runDir(id), "progress.jsonl");
+  const runRequestPath = (id) => join3(runDir(id), "request.json");
+  const runReportPath = (id) => join3(runDir(id), "run-report.json");
+  const cancellationPath = (id) => join3(runDir(id), "cancel.requested");
+  const specDir = (id) => join3(paths.specsDir, id);
+  const specPath = (id) => join3(specDir(id), "spec.json");
+  const modelPath = (id) => join3(paths.modelsDir, id, "model.json");
+  let ensurePromise;
+  async function ensureOnce() {
+    await ensurePrivateDirectory(paths.root);
     await Promise.all([
-      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 +1107,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 +1116,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(join3(state.artifact_dir, "progress.jsonl"), {
       at: row.occurred_at,
       stage: row.stage,
       status: row.status,
@@ -1690,6 +1166,10 @@ function createLocalStore(root = defaultLocalHome()) {
   async function preserveCancellationRequestState(runId) {
     const previous = await getRun(runId);
     if (isTerminalRunState(previous)) return previous;
+    await Promise.all([
+      rm(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true }),
+      rm(runReportPath(previous.id), { force: true })
+    ]);
     if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
     const requested = {
       ...previous,
@@ -1704,19 +1184,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 +1211,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 +1261,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 +1274,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 +1287,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 +1302,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,7 +1314,8 @@ 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));
@@ -1845,7 +1327,7 @@ function createLocalStore(root = defaultLocalHome()) {
         createdAt: completedAt
       });
       if (!model) {
-        await rm(join2(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+        await rm(join3(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
       }
       const previous = await getRun(report.run_id);
       const state = {
@@ -1859,11 +1341,17 @@ function createLocalStore(root = defaultLocalHome()) {
         completed_at: completedAt,
         updated_at: completedAt
       };
+      if (!await exists(reportPath)) {
+        throw new Error(`Run report not found: ${reportPath}`);
+      }
+      await copyIfExists(reportPath, runReportPath(report.run_id));
+      if (await exists(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
       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 +1365,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(join3(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
       }
       const state = {
         ...previous,
@@ -1892,7 +1380,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 +1393,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 +1404,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 +1428,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,78 +1438,727 @@ 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 = resolve4(state.report_path);
+        const allowedRoots = [resolvedRoot];
+        if (state.artifact_dir) allowedRoots.push(resolve4(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 createHash2, randomUUID as randomUUID3 } from "crypto";
+import { readFile as readFile3, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
+import { homedir as homedir2 } from "os";
+import { mkdir as mkdir3 } from "fs/promises";
+var DEFAULT_LOCAL_SPEC_PATH = "tunedtensor.json";
+function resolveLocalReference(value, baseDirectory) {
+  if (typeof value !== "string" || !value || isAbsolute3(value) || /^[a-z][a-z0-9+.-]*:/i.test(value)) {
+    return value;
+  }
+  if (value === "~") return homedir2();
+  if (value.startsWith("~/")) return resolve5(homedir2(), value.slice(2));
+  return resolve5(baseDirectory, value);
+}
+function resolveLocalRunInputPaths(raw, inputPath) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const baseDirectory = dirname3(resolve5(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);
+    });
+    await mkdir3(dirname3(args.outputPath), { recursive: true });
+    await writeFile3(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."
       }
-      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;
+    ],
+    hyperparameters: {
+      n_epochs: 1
+    }
+  });
+  await mkdir3(dirname3(args.outputPath), { recursive: true });
+  await writeFile3(args.outputPath, `${JSON.stringify(spec, null, 2)}
+`, "utf8");
+  return spec;
+}
+async function initLocalRunnerConfigFile(args) {
+  if (!args.force && await exists2(args.outputPath)) {
+    throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
+  }
+  const config = {
+    artifactRoot: DEFAULT_ARTIFACT_ROOT,
+    storeRoot: DEFAULT_PROJECT_STORE_ROOT,
+    evaluation: {
+      inference: {
+        device: "cuda"
+      },
+      scoring: {
+        mode: "exact_match"
+      },
+      timeoutMs: 18e5
+    }
+  };
+  await mkdir3(dirname3(args.outputPath), { recursive: true });
+  await writeFile3(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`);
+    }
+  });
+  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);
+}
+function assertFoundationSpecReady(spec) {
+  const issues = foundationPlaceholderIssues(spec);
+  if (issues.length > 0) {
+    throw new Error(`Edit the generated foundation spec before training: ${issues.join("; ")}.`);
+  }
+}
+function runRequestFromLocalSpec(spec, options = {}) {
+  if (isFoundationSpecFile(spec)) {
+    throw new Error(
+      "Foundation specs cannot be converted into a LoRA run request. Use `tt pipeline run --spec`."
+    );
+  }
+  const {
+    id,
+    engine: _engine,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt,
+    ...specSnapshot
+  } = spec;
+  const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
+  return fineTuneRunRequestSchema.parse({
+    run_id: options.runId ?? randomUUID3(),
+    user_id: "local-user",
+    behavior_spec_id: behaviorSpecId,
+    run_number: 1,
+    spec_snapshot: specSnapshot,
+    hyperparameters,
+    dataset_prebuilt: datasetPrebuilt
+  });
+}
+function deterministicBehaviorSpecId(spec) {
+  const namespace = Buffer.from("9f783f01340457bea061942004259253", "hex");
+  const digest = createHash2("sha1").update(namespace).update(JSON.stringify(spec)).digest().subarray(0, 16);
+  digest[6] = digest[6] & 15 | 80;
+  digest[8] = digest[8] & 63 | 128;
+  const hex = digest.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
+}
+async function loadLocalRunInput(path, options = {}) {
+  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile3(path, "utf8")), path);
+  const request = fineTuneRunRequestSchema.safeParse(raw);
+  if (request.success) {
+    return { kind: "request", path, request: request.data };
+  }
+  const spec = localBehaviorSpecFileSchema.parse(raw);
+  if (isFoundationSpecFile(spec)) {
+    return { kind: "foundation-spec", path, spec };
+  }
+  return {
+    kind: "spec",
+    path,
+    spec,
+    request: runRequestFromLocalSpec(spec, options)
+  };
+}
+
+// src/local-runtime/dataset.ts
+import { readFile as readFile4 } from "fs/promises";
+async function loadNormalizedChatJsonl(path) {
+  const text = await readFile4(path, "utf8");
+  const rows = [];
+  const jsonLines = [];
+  for (const [index, line] of text.split(/\r?\n/).entries()) {
+    if (!line.trim()) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch (error) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: malformed JSON`, { cause: error });
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`Invalid chat JSONL row ${index + 1}: expected an object`);
+    }
+    const messages = value.messages;
+    if (!Array.isArray(messages) || ![2, 3].includes(messages.length) || messages.some(
+      (message) => !message || typeof message !== "object" || Array.isArray(message) || !["system", "user", "assistant"].includes(String(message.role)) || typeof message.content !== "string"
+    )) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one user message, and one assistant answer`
+      );
+    }
+    const row = { messages };
+    const offset = row.messages.length === 3 ? 1 : 0;
+    if (offset === 1 && row.messages[0]?.role !== "system" || row.messages[offset]?.role !== "user" || !row.messages[offset]?.content.trim() || row.messages[offset + 1]?.role !== "assistant" || !row.messages[offset + 1]?.content.trim()) {
+      throw new Error(
+        `Invalid chat JSONL row ${index + 1}: expected an optional system message, one non-empty user message, and one non-empty assistant answer`
+      );
+    }
+    rows.push(row);
+    jsonLines.push(JSON.stringify(row));
+  }
+  if (rows.length === 0) throw new Error(`Chat JSONL contains no examples: ${path}`);
+  return {
+    rows,
+    jsonl: jsonLines.join("\n")
+  };
+}
+async function normalizeChatJsonlForRelocation(path) {
+  return (await loadNormalizedChatJsonl(path)).jsonl;
+}
+function buildSystemMessage(spec) {
+  const parts = [];
+  if (spec.system_prompt.trim()) parts.push(spec.system_prompt.trim());
+  if (spec.guidelines.length > 0) {
+    parts.push(`Guidelines:
+${spec.guidelines.map((guideline) => `- ${guideline}`).join("\n")}`);
+  }
+  if (spec.constraints.length > 0) {
+    parts.push(`Constraints:
+${spec.constraints.map((constraint) => `- ${constraint}`).join("\n")}`);
+  }
+  return parts.join("\n\n") || "Follow the demonstrated behavior.";
+}
+function exampleToChatRow(spec, example) {
+  const system = buildSystemMessage(spec);
+  return {
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: example.input },
+      { role: "assistant", content: example.output }
+    ]
+  };
+}
+function compileSpecToJsonl(spec) {
+  return spec.examples.map((example) => JSON.stringify(exampleToChatRow(spec, example))).join("\n");
+}
+function examplesFromSpec(spec) {
+  return spec.examples;
+}
+async function examplesFromChatJsonl(path) {
+  const normalized = await loadNormalizedChatJsonl(path);
+  const examples = [];
+  for (const [index, row] of normalized.rows.entries()) {
+    const user = row.messages.at(-2);
+    const assistant = row.messages.at(-1);
+    examples.push({
+      input: user.content,
+      output: assistant.content
+    });
+  }
+  return examples;
+}
+async function evaluationSuiteFromChatJsonl(path, configuredSystem) {
+  const normalized = await loadNormalizedChatJsonl(path);
+  const inputIdentities = /* @__PURE__ */ new Set();
+  for (const row of normalized.rows) {
+    const input = row.messages.at(-2).content;
+    const identity = input.trim().replace(/\s+/g, " ").toLowerCase();
+    if (inputIdentities.has(identity)) {
+      throw new Error(
+        "General regression data contains duplicate inputs; evaluation prompts must be unique."
+      );
     }
+    inputIdentities.add(identity);
+  }
+  const systems = new Set(
+    normalized.rows.map((row) => row.messages.find((message) => message.role === "system")?.content).filter((value) => value !== void 0)
+  );
+  if (systems.size > 1) {
+    throw new Error("General regression rows must use one consistent system message.");
+  }
+  const embeddedSystem = [...systems][0];
+  if (configuredSystem !== void 0 && embeddedSystem !== void 0 && configuredSystem !== embeddedSystem) {
+    throw new Error(
+      "evaluation.generalRegression.systemPrompt must match the system message embedded in the dataset."
+    );
+  }
+  return {
+    examples: normalized.rows.map((row) => ({
+      input: row.messages.at(-2).content,
+      output: row.messages.at(-1).content
+    })),
+    system: configuredSystem ?? embeddedSystem ?? "You are a helpful assistant."
   };
 }
 
+// src/local-runtime/run-reporter.ts
+function reportInBackground(action) {
+  try {
+    void Promise.resolve(action()).catch(() => void 0);
+  } catch {
+  }
+}
+function sanitizeLogLine(line) {
+  return line.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|secret|password)=)[^\s]+/gi, "$1[redacted]");
+}
+function forwardStreamLines(stream, onLine) {
+  let buffered = "";
+  stream.setEncoding("utf8");
+  stream.on("data", (chunk) => {
+    buffered += chunk;
+    const lines = buffered.split(/\r\n|\n|\r/);
+    buffered = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim()) onLine(sanitizeLogLine(line));
+    }
+  });
+  stream.on("end", () => {
+    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
+  });
+}
+
+// src/local-runtime/package-root.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function localRuntimePackageRoot(moduleUrl) {
+  const moduleDirectory = dirname4(fileURLToPath2(moduleUrl));
+  const candidates = [
+    dirname4(moduleDirectory),
+    dirname4(dirname4(moduleDirectory))
+  ];
+  const root = candidates.find(
+    (candidate) => existsSync2(resolve6(candidate, "package.json")) && existsSync2(resolve6(candidate, "training/adapter"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  }
+  return root;
+}
+
 // src/local-runtime/prefetch.ts
 import { createHash as createHash4 } from "crypto";
 import { createReadStream as createReadStream2 } from "fs";
-import { lstat as 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";
+import { lstat as lstat4, mkdir as mkdir5, readFile as readFile5, readdir as readdir4, realpath as realpath2, stat as stat4 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join6, relative as relative2, resolve as resolve9, sep as sep3 } from "path";
 
 // src/local-runtime/process-runner.ts
 import { createHash as createHash3 } from "crypto";
 import { spawn } from "child_process";
 import { createWriteStream, readFileSync } from "fs";
 import { mkdir as mkdir4 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join3, resolve as resolve6 } from "path";
+import { dirname as dirname5, join as join4, resolve as resolve7 } from "path";
 var packageRoot = localRuntimePackageRoot(import.meta.url);
-var bundledProject = join3(packageRoot, "training/local-runner");
+var bundledProject = join4(packageRoot, "training/adapter");
 var bundledRuntimeHash = (() => {
   const hash = createHash3("sha256");
   for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join3(bundledProject, name)));
+    hash.update(readFileSync(join4(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 BUNDLED_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv", bundledRuntimeHash);
+var foundationProject = join4(packageRoot, "training/foundation");
 var foundationRuntimeHash = (() => {
   const hash = createHash3("sha256");
   for (const name of ["pyproject.toml", "uv.lock"]) {
-    hash.update(readFileSync(join3(foundationProject, name)));
+    hash.update(readFileSync(join4(foundationProject, name)));
   }
   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
-);
+var FOUNDATION_PYTHON_ENVIRONMENT = pythonEnvironmentPath("uv-foundation", foundationRuntimeHash);
 function buildBundledPythonCommand(entrypoint, args = []) {
-  const target = entrypoint === "-c" ? entrypoint : join3(bundledProject, "src", entrypoint);
+  const target = entrypoint === "-c" ? entrypoint : join4(bundledProject, "src", entrypoint);
   const commandArgs = [
     "run",
     "--frozen",
@@ -2052,7 +2189,7 @@ function buildFoundationPythonCommand(entrypoint, args = []) {
     "--project",
     foundationProject,
     "python",
-    join3(foundationProject, "src", entrypoint),
+    join4(foundationProject, "src", entrypoint),
     ...args
   ];
   return {
@@ -2099,7 +2236,7 @@ async function runLoggedProcess(args) {
   try {
     const exitCode = await new Promise((resolvePromise, reject) => {
       const child = spawn(args.command, args.commandArgs, {
-        cwd: args.cwd ? resolve6(args.cwd) : process.cwd(),
+        cwd: args.cwd ? resolve7(args.cwd) : process.cwd(),
         stdio: ["ignore", "pipe", "pipe"],
         env: args.env ?? process.env,
         detached: process.platform !== "win32"
@@ -2215,8 +2352,8 @@ async function runLoggedProcess(args) {
 }
 
 // src/local-runtime/huggingface-cache.ts
-import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join4, resolve as resolve7 } from "path";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname6, join as join5, resolve as resolve8 } from "path";
 function minimalMachineLearningEnvironment(env) {
   const exact = /* @__PURE__ */ new Set([
     "PATH",
@@ -2270,15 +2407,15 @@ function minimalMachineLearningEnvironment(env) {
   return result;
 }
 function resolveHuggingFaceCacheLayout(modelCache) {
-  const hfHome = resolve7(modelCache);
+  const hfHome = resolve8(modelCache);
   return {
     hfHome,
-    hubCache: join4(hfHome, "hub")
+    hubCache: join5(hfHome, "hub")
   };
 }
 function withHuggingFaceCacheEnvironment(env, modelCache) {
   const inheritedHub = env.HF_HUB_CACHE ?? env.HUGGINGFACE_HUB_CACHE;
-  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve7(inheritedHub)) : join4(homedir4(), ".cache", "huggingface"));
+  const canonicalHome = modelCache ?? env.HF_HOME ?? (inheritedHub ? dirname6(resolve8(inheritedHub)) : join5(homedir3(), ".cache", "huggingface"));
   const layout = resolveHuggingFaceCacheLayout(canonicalHome);
   const result = {
     ...env,
@@ -2366,13 +2503,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 = join6(layout.hubCache, repository);
+  const expectedPath = join6(repositoryRoot, "snapshots", revision);
   const [
     physicalCacheRoot,
     physicalHubRoot,
@@ -2384,7 +2521,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(join6(repositoryRoot, "blobs")).catch(() => null),
     realpath2(path).catch(() => null),
     realpath2(expectedPath).catch(() => null)
   ]);
@@ -2400,7 +2537,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: ${join6(repositoryRoot, "blobs")}`);
   }
   if (!isStrictPhysicalDescendant(physicalRepositoryRoot, physicalExpectedPath)) {
     throw new Error(`Hugging Face snapshot escapes its configured repository: ${expectedPath}`);
@@ -2449,7 +2586,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 +2599,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: ${join6(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: ${join6(path, name)}`);
     }
-    const file = join5(path, name);
+    const file = join6(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 +2624,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: resolve9(config.paths.modelCache) } : {}
   };
 }
 function safeName(value) {
@@ -2498,7 +2635,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 +2648,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 = join6(directory, entry.name);
       if (entry.isSymbolicLink()) {
         const metadata2 = await stat4(child);
         if (!metadata2.isFile()) {
@@ -2535,15 +2672,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(join6(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 readFile5(join6(path, "config.json"), "utf8"));
     assertCertifiedBaseModelConfig(
       config,
-      `Local base-model config ${join5(path, "config.json")}`,
+      `Local base-model config ${join6(path, "config.json")}`,
       expectedModelId
     );
   } catch (error) {
@@ -2593,14 +2730,14 @@ async function prefetchBaseModel(args) {
     ...buildModelPrefetchPayload(args.request, args.config),
     ...args.localOnly ? { local_files_only: true } : {}
   };
-  const artifactDir = resolve8(
+  const artifactDir = resolve9(
     args.config.artifactRoot,
     args.localOnly ? "verify-base" : "prefetch",
     `${safeName(args.request.spec_snapshot.base_model)}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`
   );
   await mkdir5(artifactDir, { recursive: true });
   if (args.config.paths.baseModel) {
-    const localPath = resolve8(args.config.paths.baseModel);
+    const localPath = resolve9(args.config.paths.baseModel);
     const verified = await verifyLocalBaseModel(
       localPath,
       args.request.spec_snapshot.base_model,
@@ -2617,9 +2754,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 = join6(artifactDir, "prefetch-input.json");
+  const outputPath = join6(artifactDir, "prefetch-output.json");
+  const logPath = join6(artifactDir, "prefetch.log");
   await writeJson(inputPath, payload);
   const entrypoint = buildBundledPythonCommand(
     "prefetch.py",
@@ -2739,17 +2876,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 mkdir8, open as open2, readFile as readFile8, readdir as readdir5, rename as rename3, rm as rm3, stat as stat5 } from "fs/promises";
 import { createReadStream as 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 { homedir as homedir4 } from "os";
+import { basename, dirname as dirname8, join as join9, relative as relative3, resolve as resolve12 } 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 { dirname as dirname7, join as join7, resolve as resolve10 } from "path";
 function normalize(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -2984,7 +3121,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 ? resolve10(args.config.paths.modelCache) : void 0,
     trust_remote_code: false,
     device: args.config.evaluation.inference.device,
     generation: {
@@ -3069,11 +3206,14 @@ function baselineCacheKey(args) {
 function baselineInputsAreStable(args) {
   return args.config.paths.baseModel ? Boolean(args.sourceFingerprint) : Boolean(args.baseModelRevision);
 }
+function baselineStoreRoot(config) {
+  return config.storeRoot ? resolve10(config.storeRoot) : defaultLocalHome();
+}
 function baselineCachePath(config, key) {
-  const root = config.storeRoot ? resolve9(config.storeRoot) : defaultLocalHome();
-  return join6(root, "cache", "baseline-evals", `${key}.json`);
+  return join7(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")));
   } catch {
@@ -3084,7 +3224,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 readFile6(resolve10(localRuntimePackageRoot(import.meta.url), "package.json"), "utf8");
     cachedPackageVersion = String(
       JSON.parse(raw).version ?? "unknown"
     );
@@ -3153,7 +3293,7 @@ async function evaluateExamples(args) {
     baseModelId,
     args.baseModelRevision
   );
-  const localModelSource = args.modelSource ? resolve9(args.modelSource) !== resolve9(baseModelId) : false;
+  const localModelSource = args.modelSource ? resolve10(args.modelSource) !== resolve10(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 +3318,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 +3369,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 }
     );
@@ -3269,7 +3410,7 @@ 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 { join as join8, resolve as resolve11 } from "path";
 function buildTrainingHyperparameters(request, options = {}) {
   const model = resolveTrainingModel(request.spec_snapshot.base_model);
   const hyper = request.hyperparameters;
@@ -3365,7 +3506,7 @@ async function launchProcessTraining(args) {
   const hyperparameters = buildTrainingHyperparameters(request, {
     baseModelRevision: args.baseModelRevision
   });
-  await writeJson(join7(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
+  await writeJson(join8(artifacts.trainingConfigDir, "hyperparameters.json"), hyperparameters);
   const entrypoint = buildBundledPythonCommand("train.py");
   if (config.dryRun) {
     await writeFile5(
@@ -3390,20 +3531,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: resolve11(artifacts.trainingInputDir),
+      SM_CHANNEL_BASE_MODEL: config.paths.baseModel ? resolve11(config.paths.baseModel) : void 0,
+      SM_MODEL_DIR: resolve11(artifacts.trainingModelDir),
+      SM_OUTPUT_DIR: resolve11(artifacts.trainingOutputDir),
+      TT_HYPERPARAMETERS_PATH: resolve11(artifacts.trainingConfigDir, "hyperparameters.json")
     }, 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 mkdir7(resolve11(config.paths.modelCache), { recursive: true });
   if (config.paths.baseModel) {
     await verifyLocalBaseModel(
-      resolve10(config.paths.baseModel),
+      resolve11(config.paths.baseModel),
       request.spec_snapshot.base_model,
       config.paths.modelCache
     );
@@ -3430,12 +3571,12 @@ async function launchProcessTraining(args) {
     onLine: (line) => forwardTrainingProgress(line),
     shouldCancel: args.shouldCancel
   });
-  const metricsPath = join7(artifacts.trainingModelDir, "training-metrics.json");
+  const metricsPath = join8(artifacts.trainingModelDir, "training-metrics.json");
   const metrics = await pathExists(metricsPath) ? JSON.parse(await readFile7(metricsPath, "utf8")) : null;
   if (exitCode !== 0) {
     throw new Error(`Training process exited with code ${exitCode}. See ${artifacts.trainingLog}.`);
   }
-  const modelTarPath = join7(artifacts.trainingOutputDir, "model.tar.gz");
+  const modelTarPath = join8(artifacts.trainingOutputDir, "model.tar.gz");
   const modelUri = await pathExists(modelTarPath) ? fileUri(modelTarPath) : fileUri(artifacts.trainingModelDir);
   await args.reporter?.onEvent?.({
     stage: "training",
@@ -3537,14 +3678,14 @@ async function loadRunRequest(path) {
 }
 async function loadLocalRunnerConfig(path) {
   if (!path) return localRunnerConfigSchema.parse({});
-  const configPath = resolve11(path);
+  const configPath = resolve12(path);
   const base = dirname8(configPath);
   const config = localRunnerConfigSchema.parse(await loadJsonFile(configPath));
   const configPathValue = (value) => {
     if (!value) return void 0;
-    if (value === "~") return homedir5();
-    if (value.startsWith("~/")) return resolve11(homedir5(), value.slice(2));
-    return resolve11(base, value);
+    if (value === "~") return homedir4();
+    if (value.startsWith("~/")) return resolve12(homedir4(), value.slice(2));
+    return resolve12(base, value);
   };
   return {
     ...config,
@@ -3742,21 +3883,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 readFile8(resolve12(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 = resolve12(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(resolve12(bundledProject2, "pyproject.toml")),
+    runner_uv_lock: await hashFileIfPresent(resolve12(bundledProject2, "uv.lock"))
   });
 }
 function preparedSourceFingerprint(args) {
@@ -3803,7 +3944,7 @@ 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 = resolve12(cacheEnvironment.HF_HUB_CACHE, repository, "refs", "main");
   try {
     const revision = (await readFile8(refPath, "utf8")).trim();
     if (revision) return revision;
@@ -3813,7 +3954,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 +3965,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 = resolve12(directory, entry.name);
       if (entry.isDirectory()) {
         await visit(child);
         continue;
@@ -3868,7 +4009,7 @@ async function removePrefixedArtifacts(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(resolve12(directory, name), { recursive: true, force: true }))
   ]);
 }
 async function cleanupStageArtifacts(artifacts, stage) {
@@ -3881,7 +4022,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(resolve12(artifacts.runDir, "model.tar.gz"), { force: true }),
       removeReport(),
       rm3(artifacts.artifactManifestJson, { force: true })
     ]);
@@ -3899,7 +4040,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(resolve12(artifacts.runDir, "model.tar.gz"), { force: true }),
       removePrefixedArtifacts(artifacts.candidateEvalJson),
       removePrefixedArtifacts(artifacts.generalCandidateEvalJson),
       removeReport()
@@ -3989,11 +4130,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(resolve12(store.paths.runsDir, runId, "workflow.lock"), `Run ${runId}`);
 }
 async function acquireArtifactLock(artifacts) {
   return acquireWorkflowLock(
-    join8(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
+    join9(artifacts.runDir, ARTIFACT_WORKFLOW_LOCK_FILE),
     `Artifact directory ${artifacts.runDir}`
   );
 }
@@ -4040,13 +4182,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 = resolve12(packageRoot2, "training/adapter");
+  const bundledSource = resolve12(packageRoot2, "training/adapter/src");
+  const pythonSources = (await readdir5(bundledSource, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".py")).map((entry) => resolve12(bundledSource, entry.name));
   const candidates = [.../* @__PURE__ */ new Set([
     ...pythonSources,
-    resolve11(project, "pyproject.toml"),
-    resolve11(project, "uv.lock")
+    resolve12(project, "pyproject.toml"),
+    resolve12(project, "uv.lock")
   ])];
   const fingerprints = {};
   for (const path of candidates.sort()) fingerprints[path] = await hashFileIfPresent(path);
@@ -4160,7 +4302,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 (resolve12(existing.artifact_dir) !== resolve12(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 +4409,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(resolve12(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 +4938,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 = join9(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 +5014,6 @@ async function runLocalFineTune(input) {
 }
 
 export {
-  writeJsonAtomic,
   assertArtifactManifest,
   TRAINING_MODELS,
   resolveTrainingModel,
@@ -4880,6 +5021,18 @@ export {
   defaultBaseModelRevision,
   resolveModelLoader,
   assertUsableModelArtifact,
+  DEFAULT_ARTIFACT_ROOT,
+  DEFAULT_FOUNDATION_RUNS_DIR,
+  expandUserPath,
+  getConfigDir,
+  getAgentConfigDir,
+  defaultStoreRoot,
+  isTerminalRunState,
+  defaultLocalHome,
+  localStorePaths,
+  hardenExistingLocalStore,
+  writePrivateJsonAtomic,
+  createLocalStore,
   datasetFormatSchema,
   baseModelRevisionSchema,
   behaviorSpecExampleSchema,
@@ -4926,10 +5079,6 @@ export {
   buildFoundationPythonCommand,
   withFoundationPythonEnvironment,
   runLoggedProcess,
-  isTerminalRunState,
-  defaultLocalHome,
-  localStorePaths,
-  createLocalStore,
   minimalMachineLearningEnvironment,
   withHuggingFaceCacheEnvironment,
   withOfflineHuggingFaceCacheEnvironment,
@@ -4949,4 +5098,4 @@ export {
   runLocalPipeline,
   runLocalFineTune
 };
-//# sourceMappingURL=chunk-2P2RL23O.js.map
+//# sourceMappingURL=chunk-7VIUHQBI.js.map