@tuned-tensor/cli 0.16.0 → 0.18.0

package/dist/{chunk-6RLNBTM6.js → chunk-U5HNS367.js}

@@ -836,6 +836,7 @@ async function assertUsableModelArtifact(uri) {
 
 // src/local-runtime/contracts.ts
 import { z } from "zod";
+import { pipelineDocumentSchema, isFoundationPipeline, parsePipeline } from "@tuned-tensor/pipeline-contract";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -946,12 +947,6 @@ var foundationHyperparametersSchema = z.object({
   keep_checkpoints: z.number().int().min(1).max(100).optional(),
   log_interval_steps: z.number().int().min(1).max(1e6).optional()
 }).strict();
-var localFoundationSpecFileSchema = behaviorSpecSchema.extend({
-  engine: z.literal("foundation"),
-  id: z.string().uuid().optional(),
-  examples: z.array(behaviorSpecExampleSchema).min(2),
-  foundation: foundationHyperparametersSchema
-});
 var datasetPrebuiltSchema = z.object({
   training: z.string().min(1),
   validation: z.string().min(1).optional(),
@@ -996,16 +991,6 @@ var fineTuneRunRequestSchema = z.object({
     });
   }
 });
-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(),
@@ -1196,6 +1181,42 @@ var localRunnerConfigSchema = z.object({
     baselineCache: true
   })
 }).strict();
+var projectRuntimeSchema = z.object({
+  gpu: localRunnerConfigSchema.shape.gpu,
+  artifactRoot: z.string().min(1).optional(),
+  storeRoot: z.string().min(1).optional(),
+  paths: z.object({ baseModel: z.string().min(1).optional(), modelCache: z.string().min(1).optional() }).strict().optional()
+}).strict();
+var projectWorkflowFields = {
+  evaluation: evaluationConfigSchema.optional(),
+  runtime: projectRuntimeSchema.optional(),
+  pipeline: pipelineDocumentSchema.optional()
+};
+var localFoundationSpecFileSchema = behaviorSpecSchema.extend({
+  ...projectWorkflowFields,
+  engine: z.literal("foundation"),
+  id: z.string().uuid().optional(),
+  examples: z.array(behaviorSpecExampleSchema).min(2),
+  foundation: foundationHyperparametersSchema
+});
+var localAdapterSpecFileSchema = specSnapshotSchema.extend({
+  ...projectWorkflowFields,
+  engine: z.literal("adapter").optional(),
+  id: z.string().uuid().optional(),
+  hyperparameters: fineTuneHyperparametersSchema.optional(),
+  dataset_prebuilt: datasetPrebuiltSchema.optional()
+}).strict();
+var localBehaviorSpecFileSchema = z.union([
+  localFoundationSpecFileSchema,
+  localAdapterSpecFileSchema
+]).superRefine((spec, ctx) => {
+  if (spec.pipeline && isFoundationPipeline(parsePipeline(spec.pipeline)) !== (spec.engine === "foundation")) {
+    ctx.addIssue({ code: "custom", path: ["pipeline"], message: "Pipeline engine must match the spec engine." });
+  }
+  if (spec.engine === "foundation" && (spec.evaluation || spec.runtime?.storeRoot || spec.runtime?.paths)) {
+    ctx.addIssue({ code: "custom", path: ["runtime"], message: "Foundation uses foundation settings for evaluation and checkpoints; runtime.artifactRoot and runtime.gpu are supported." });
+  }
+});
 function isFoundationSpecFile(spec) {
   return spec.engine === "foundation";
 }
@@ -1233,6 +1254,18 @@ function resolveLocalRunInputPaths(raw, inputPath) {
       if (fields[key] !== void 0) fields[key] = resolveLocalReference(fields[key], baseDirectory);
     }
   }
+  const runtime = value.runtime;
+  if (runtime && typeof runtime === "object") {
+    for (const key of ["artifactRoot", "storeRoot"]) if (runtime[key] !== void 0) runtime[key] = resolveLocalReference(runtime[key], baseDirectory);
+    const gpu = runtime.gpu;
+    if (gpu?.identityFile !== void 0) gpu.identityFile = resolveLocalReference(gpu.identityFile, baseDirectory);
+    const paths = runtime.paths;
+    if (paths && typeof paths === "object") {
+      for (const key of ["baseModel", "modelCache"]) if (paths[key] !== void 0) paths[key] = resolveLocalReference(paths[key], baseDirectory);
+    }
+  }
+  const regression = value.evaluation?.generalRegression;
+  if (regression?.dataset !== void 0) regression.dataset = resolveLocalReference(regression.dataset, baseDirectory);
   const foundation = value.foundation;
   if (foundation && typeof foundation === "object" && !Array.isArray(foundation)) {
     const fields = foundation;
@@ -1385,6 +1418,9 @@ function runRequestFromLocalSpec(spec, options = {}) {
   const {
     id,
     engine: _engine,
+    evaluation: _evaluation,
+    runtime: _runtime,
+    pipeline: _pipeline,
     hyperparameters,
     dataset_prebuilt: datasetPrebuilt,
     ...specSnapshot
@@ -1438,6 +1474,249 @@ async function loadLocalRunInput(path, options = {}) {
     options
   );
 }
+function specHash(source) {
+  return createHash2("sha256").update(source).digest("hex");
+}
+function validateBehaviorSpec(input) {
+  const errors = [];
+  const warnings = [];
+  if (input.kind === "request") {
+    return { valid: false, errors: ["Use a behavior spec, not a run request."], warnings };
+  }
+  const { spec } = input;
+  const placeholders = input.kind === "foundation-spec" ? foundationPlaceholderIssues(input.spec) : generatedPlaceholderIssues(input.request);
+  if (placeholders.length) {
+    errors.push(`Edit the generated behavior spec before training: ${placeholders.join("; ")}.`);
+  }
+  if (input.kind === "foundation-spec") {
+    if (input.spec.foundation.nproc_per_node !== 1) {
+      errors.push("Foundation nproc_per_node must be 1 for this runtime.");
+    }
+    const nonNumericOutput = spec.examples.some(
+      (example) => !/-?\d+(?:\.\d+)?/.test(example.output.replaceAll(",", ""))
+    );
+    if (input.spec.foundation.rl_steps > 0 && nonNumericOutput) {
+      errors.push("Foundation RL requires numeric expected outputs in every example.");
+    }
+  }
+  for (const key of ["name", "system_prompt"]) {
+    if (!spec[key].trim()) errors.push(`${key} must not be blank.`);
+  }
+  if (spec.examples.length < 2 && !(input.kind === "spec" && input.spec.dataset_prebuilt)) {
+    errors.push("Add at least two examples for training and evaluation.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, example] of spec.examples.entries()) {
+    if (!example.input.trim() || !example.output.trim()) {
+      errors.push(`examples[${index}] input and output must not be blank.`);
+    }
+    const key = example.input.trim();
+    if (seen.has(key)) {
+      errors.push(`examples[${index}] repeats an input; use distinct examples to avoid conflicting labels or train/eval overlap.`);
+    }
+    seen.add(key);
+  }
+  if (!spec.guidelines.length) {
+    warnings.push("Add guidelines to make expected behavior explicit.");
+  }
+  if (spec.examples.length < 10) {
+    warnings.push("This is a small example set; passing validation does not establish model quality.");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/pipeline.ts
+import {
+  canonicalJson,
+  isFoundationPipeline as isFoundationPipeline2,
+  canonicalPipeline as canonicalPortablePipeline,
+  parsePipeline as parsePipeline2,
+  pipelineDocumentSchema as pipelineDocumentSchema2
+} from "@tuned-tensor/pipeline-contract";
+import {
+  PIPELINE_DOCUMENT_VERSION,
+  PIPELINE_EVALUATORS,
+  PIPELINE_MAX_STEPS,
+  PIPELINE_MAX_TRAIN_STEPS,
+  PIPELINE_STEP_CAPABILITIES,
+  PIPELINE_STEP_USES,
+  PIPELINE_TARGETS,
+  canonicalFoundationPipeline as canonicalFoundationPipeline2,
+  canonicalJson as canonicalJson2,
+  isFoundationPipeline as isFoundationPipeline3,
+  parsePipeline as parsePipeline3,
+  pipelineDocumentSchema as pipelineDocumentSchema3,
+  pipelineHash
+} from "@tuned-tensor/pipeline-contract";
+function stepReferences(step) {
+  if (step.uses === "evaluate") return step.with.model === "base" ? [] : [step.with.model];
+  if (step.uses === "compare") return [step.with.before, step.with.after];
+  if (step.uses === "pretrain") return [step.with.tokenizer];
+  if (step.uses === "finetune" || step.uses === "rl") return [step.with.model];
+  return [];
+}
+function pipelineFromFoundationHyperparameters(name, hp) {
+  const lastTrainId = hp.rl_steps > 0 ? "rl" : "sft";
+  const steps = [
+    {
+      id: "tokenize",
+      uses: "tokenize",
+      target: "local",
+      with: { vocabSize: hp.vocab_size, maxChars: hp.max_chars }
+    },
+    {
+      id: "pretrain",
+      uses: "pretrain",
+      target: "local",
+      with: {
+        tokenizer: { from: "tokenize.tokenizer" },
+        depth: hp.depth,
+        steps: hp.pretrain_steps,
+        batchSize: hp.batch_size,
+        sequenceLength: hp.sequence_length,
+        nprocPerNode: hp.nproc_per_node
+      }
+    },
+    {
+      id: "bpb",
+      uses: "evaluate",
+      target: "local",
+      with: { model: { from: "pretrain.model" }, evaluator: "bpb" }
+    },
+    {
+      id: "sft",
+      uses: "finetune",
+      target: "local",
+      with: {
+        model: { from: "pretrain.model" },
+        steps: hp.finetune_steps,
+        batchSize: hp.batch_size
+      }
+    },
+    {
+      id: "chat",
+      uses: "evaluate",
+      target: "local",
+      with: { model: { from: "sft.model" }, evaluator: "chat" }
+    }
+  ];
+  if (hp.rl_steps > 0) {
+    steps.push(
+      {
+        id: "rl",
+        uses: "rl",
+        target: "local",
+        with: { model: { from: "sft.model" }, steps: hp.rl_steps }
+      },
+      {
+        id: "chat_rl",
+        uses: "evaluate",
+        target: "local",
+        with: { model: { from: "rl.model" }, evaluator: "chat" }
+      }
+    );
+  }
+  steps.push({
+    id: "infer",
+    uses: "evaluate",
+    target: "local",
+    with: { model: { from: `${lastTrainId}.model` }, evaluator: "inference" }
+  });
+  return {
+    version: 1,
+    name,
+    runtime: { engine: "foundation" },
+    steps
+  };
+}
+function producerId(reference) {
+  return reference.from.slice(0, reference.from.lastIndexOf("."));
+}
+function validatePipeline(pipeline) {
+  const structural = pipelineDocumentSchema2.safeParse(pipeline);
+  if (!structural.success) {
+    return structural.error.issues.map((issue) => {
+      const path = issue.path.map(String).join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+  }
+  try {
+    parsePipeline2(pipeline);
+    return [];
+  } catch (error) {
+    return [error instanceof Error ? error.message : String(error)];
+  }
+}
+function canonicalPipeline(target = "local") {
+  return canonicalPortablePipeline(target);
+}
+function pipelineForRunInput(input, requested) {
+  if (input.kind === "request") {
+    assertLocalRunInputReady(input.request);
+  } else {
+    const validation = validateBehaviorSpec(input);
+    if (!validation.valid) {
+      throw new Error(`Invalid behavior spec:
+${validation.errors.join("\n")}`);
+    }
+  }
+  const foundation = input.kind === "foundation-spec";
+  const embedded = input.kind === "request" ? void 0 : input.spec.pipeline;
+  if (embedded && requested !== void 0 && canonicalJson(parsePipeline2(embedded)) !== canonicalJson(parsePipeline2(requested))) {
+    throw new Error("Conflicting pipeline settings: update tunedtensor.json.pipeline before running a different recipe.");
+  }
+  const recipe = requested !== void 0 ? requested : embedded ?? (foundation ? pipelineFromFoundationHyperparameters(input.spec.name, input.spec.foundation) : canonicalPipeline("local"));
+  const pipeline = parsePipeline2(recipe);
+  if (isFoundationPipeline2(pipeline) !== foundation) {
+    const recipeEngine = isFoundationPipeline2(pipeline) ? "a foundation" : "an adapter";
+    const specEngine = foundation ? "a foundation" : "an adapter";
+    throw new Error(`Pipeline is ${recipeEngine} recipe, but the behavior spec is ${specEngine} spec. Use a matching recipe or omit --file.`);
+  }
+  if (foundation) assertFoundationSettingsMatch(input.spec.foundation, pipeline);
+  return pipeline;
+}
+function createExecutionPlan(pipeline, selection = {}) {
+  const errors = validatePipeline(pipeline);
+  if (errors.length) throw new Error(`Invalid pipeline:
+- ${errors.join("\n- ")}`);
+  const normalized = parsePipeline2(pipeline);
+  const allIds = new Set(normalized.steps.map((step) => step.id));
+  for (const id of [...selection.only ?? [], ...selection.skip ?? []]) {
+    if (!allIds.has(id)) throw new Error(`Unknown pipeline step: ${id}.`);
+  }
+  const only = selection.only?.length ? new Set(selection.only) : void 0;
+  const skip = new Set(selection.skip ?? []);
+  const steps = normalized.steps.filter((step) => (!only || only.has(step.id)) && !skip.has(step.id));
+  if (!steps.length) throw new Error("Selection leaves no pipeline steps to run.");
+  const retained = new Map(steps.map((step) => [step.id, step]));
+  const resolved = steps.map((step) => {
+    const transfers = [];
+    for (const reference of stepReferences(step)) {
+      const producer = retained.get(producerId(reference));
+      if (!producer) throw new Error(`Step ${step.id} has a dependency on ${producerId(reference)}, which was omitted by --only or --skip.`);
+      if (producer.target !== step.target) transfers.push({ from: reference.from, from_target: producer.target, to_target: step.target });
+    }
+    return { ...step, transfers };
+  });
+  return { version: 1, ...normalized.name ? { name: normalized.name } : {}, steps: resolved };
+}
+function assertFoundationSettingsMatch(hp, plan) {
+  const settings = {
+    tokenize: { vocabSize: hp.vocab_size, maxChars: hp.max_chars },
+    pretrain: { depth: hp.depth, steps: hp.pretrain_steps, batchSize: hp.batch_size, sequenceLength: hp.sequence_length, nprocPerNode: hp.nproc_per_node },
+    finetune: { steps: hp.finetune_steps, batchSize: hp.batch_size },
+    rl: { steps: hp.rl_steps }
+  };
+  for (const step of plan.steps) {
+    const fields = "with" in step ? step.with : void 0;
+    for (const [key, expected] of Object.entries(settings[step.uses] ?? {})) {
+      if (fields?.[key] !== void 0 && fields[key] !== expected) {
+        throw new Error(`Pipeline step ${step.id}.${key} conflicts with the behavior spec. Edit tunedtensor.json and regenerate the recipe, or omit --file.`);
+      }
+    }
+    if (step.uses === "rl" && hp.rl_steps === 0) throw new Error("The behavior spec disables RL; update foundation.rl_steps before adding an RL stage.");
+  }
+}
 
 // src/local-runtime/dataset.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -3244,11 +3523,11 @@ function extractJsonObject(value) {
   }
   return null;
 }
-function canonicalJson(value) {
-  if (Array.isArray(value)) return value.map(canonicalJson);
+function canonicalJson3(value) {
+  if (Array.isArray(value)) return value.map(canonicalJson3);
   if (value && typeof value === "object") {
     return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)])
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson3(item)])
     );
   }
   return value;
@@ -3274,7 +3553,7 @@ function scoreJsonFields(expected, actual, configuredFields) {
   const schemaMatch = Boolean(actualJson) && expectedKeys.length === actualKeys.length && expectedKeys.every((key, index) => key === actualKeys[index]);
   const fieldResults = {};
   for (const field of fields) {
-    fieldResults[field] = Object.prototype.hasOwnProperty.call(expectedJson, field) && Boolean(actualJson) && JSON.stringify(canonicalJson(expectedJson[field])) === JSON.stringify(canonicalJson(actualJson?.[field]));
+    fieldResults[field] = Object.prototype.hasOwnProperty.call(expectedJson, field) && Boolean(actualJson) && JSON.stringify(canonicalJson3(expectedJson[field])) === JSON.stringify(canonicalJson3(actualJson?.[field]));
   }
   const correct = Object.values(fieldResults).filter(Boolean).length;
   const score = fields.length > 0 ? correct / fields.length : 0;
@@ -4174,14 +4453,14 @@ function artifactPrefix(request) {
     runId: request.run_id
   });
 }
-function canonicalJson2(value) {
+function canonicalJson4(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson2(entry)).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson4(entry)).join(",")}]`;
   const object = value;
-  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(object[key])}`).join(",")}}`;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson4(object[key])}`).join(",")}}`;
 }
 function hashJson(value) {
-  return createHash7("sha256").update(canonicalJson2(value)).digest("hex");
+  return createHash7("sha256").update(canonicalJson4(value)).digest("hex");
 }
 var packageRoot2 = localRuntimePackageRoot(import.meta.url);
 async function hashFileIfPresent(path) {
@@ -5244,6 +5523,16 @@ async function runLocalPipeline(input) {
         store,
         reporter: input.reporter
       });
+      await writeJsonAtomic(join10(artifacts.runDir, "resolved-workflow.json"), {
+        spec: input.projectSpec ?? {
+          ...input.request.spec_snapshot,
+          hyperparameters: input.request.hyperparameters,
+          dataset_prebuilt: input.request.dataset_prebuilt
+        },
+        request: input.request,
+        runtime: input.config,
+        pipeline
+      });
       const outputs = {};
       for (const step of pipeline.steps) {
         await throwIfCancelled(store, input.request);
@@ -5331,6 +5620,32 @@ async function runLocalFineTune(input) {
   };
 }
 
+// src/local-runtime/project-workflow.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import { dirname as dirname10, join as join11, resolve as resolve14 } from "path";
+function configForSpec(spec, specPath) {
+  return parseLocalRunnerConfig({
+    storeRoot: process.env.TT_LOCAL_HOME?.trim() ? expandUserPath(process.env.TT_LOCAL_HOME.trim()) : DEFAULT_PROJECT_STORE_ROOT,
+    ...spec.runtime,
+    ...spec.evaluation ? { evaluation: spec.evaluation } : {}
+  }, specPath);
+}
+async function resolveProjectConfig(specPath, configPath, warn, loaded) {
+  const input = loaded ?? (existsSync3(specPath) ? await loadLocalRunInput(specPath) : void 0);
+  const spec = input && input.kind !== "request" ? input.spec : void 0;
+  const candidate = configPath ? resolve14(configPath) : join11(dirname10(resolve14(specPath)), "local-runner.json");
+  if (configPath || existsSync3(candidate)) {
+    const legacy = parseLocalRunnerConfig(JSON.parse(await readFile9(candidate, "utf8")), candidate);
+    if (spec?.runtime || spec?.evaluation) {
+      throw new Error("Conflicting configuration sources: tunedtensor.json contains runtime/evaluation settings and a legacy runner config is present. Migrate to tunedtensor.json; do not silently override the spec.");
+    }
+    warn?.("Legacy local-runner.json detected; migrate its settings into tunedtensor.json with tt pipeline migrate.");
+    return { config: legacy, legacyConfigPath: candidate };
+  }
+  return { config: spec ? configForSpec(spec, specPath) : parseLocalRunnerConfig({}) };
+}
+
 // src/local-runtime/capability-profiles.ts
 var GIB = 1024 ** 3;
 function gib(n) {
@@ -5628,7 +5943,7 @@ function warningsFromSnapshot(report, target) {
 import { constants as constants2 } from "fs";
 import { access as access2, statfs } from "fs/promises";
 import { cpus, freemem, homedir as homedir5, totalmem, type } from "os";
-import { dirname as dirname10, join as join11, resolve as resolve14 } from "path";
+import { dirname as dirname11, join as join12, resolve as resolve15 } from "path";
 import { spawn as spawn2 } from "child_process";
 async function runCommand(command, args, options = {}) {
   const timeoutMs = options.timeoutMs ?? 1e4;
@@ -5782,7 +6097,7 @@ async function queryNvidiaGpus(env) {
   return { result: table.code === 0 || !last ? table : last, gpus };
 }
 async function diskCheck(name, path) {
-  const resolvedPath = resolve14(path);
+  const resolvedPath = resolve15(path);
   try {
     await access2(resolvedPath, constants2.R_OK);
     const fs = await statfs(resolvedPath);
@@ -5797,7 +6112,7 @@ async function diskCheck(name, path) {
   } catch (error) {
     let probe = resolvedPath;
     for (let i = 0; i < 6; i += 1) {
-      const parent = dirname10(probe);
+      const parent = dirname11(probe);
       if (parent === probe) break;
       probe = parent;
       try {
@@ -5883,10 +6198,10 @@ async function collectHostInventory(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const nodeVersion = process.versions.node;
   const nodeMajor = Number(nodeVersion.split(".")[0]);
-  const artifactRoot = resolve14(cwd, config?.artifactRoot ?? join11(cwd, DEFAULT_ARTIFACT_ROOT));
-  const storeRoot = resolve14(config?.storeRoot ?? defaultStoreRoot(env));
-  const modelCache = resolve14(
-    config?.paths.modelCache ?? env.HF_HOME ?? join11(homedir5(), ".cache", "huggingface")
+  const artifactRoot = resolve15(cwd, config?.artifactRoot ?? join12(cwd, DEFAULT_ARTIFACT_ROOT));
+  const storeRoot = resolve15(config?.storeRoot ?? defaultStoreRoot(env));
+  const modelCache = resolve15(
+    config?.paths.modelCache ?? env.HF_HOME ?? join12(homedir5(), ".cache", "huggingface")
   );
   const [artifactDisk, storeDisk, cacheDisk, uvVersion, nvidiaQueried] = await Promise.all([
     diskCheck("artifact-root", artifactRoot),
@@ -5932,17 +6247,17 @@ async function collectHostInventory(options = {}) {
 }
 
 // src/local-runtime/hardware-snapshot.ts
-import { chmod as chmod2, mkdir as mkdir10, readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname11, join as join12 } from "path";
+import { chmod as chmod2, mkdir as mkdir10, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname12, join as join13 } from "path";
 var HARDWARE_SNAPSHOT_VERSION = 1;
 var HARDWARE_SNAPSHOT_TTL_MS = 24 * 60 * 60 * 1e3;
 function hardwareSnapshotPath(env = process.env) {
-  return join12(getTunedTensorHome(env), "hardware.json");
+  return join13(getTunedTensorHome(env), "hardware.json");
 }
 async function readHardwareSnapshot(env = process.env) {
   const path = hardwareSnapshotPath(env);
   try {
-    const parsed = JSON.parse(await readFile9(path, "utf8"));
+    const parsed = JSON.parse(await readFile10(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
     const snapshot = parsed;
     if (snapshot.version !== HARDWARE_SNAPSHOT_VERSION) return void 0;
@@ -5959,7 +6274,7 @@ async function readHardwareSnapshot(env = process.env) {
 }
 async function writeHardwareSnapshot(snapshot, env = process.env) {
   const path = hardwareSnapshotPath(env);
-  await mkdir10(dirname11(path), { recursive: true, mode: 448 });
+  await mkdir10(dirname12(path), { recursive: true, mode: 448 });
   const gpu = snapshot.capabilities.gpu;
   const record = {
     version: HARDWARE_SNAPSHOT_VERSION,
@@ -6038,6 +6353,7 @@ export {
   resolveModelLoader,
   assertUsableModelArtifact,
   DEFAULT_ARTIFACT_ROOT,
+  DEFAULT_PROJECT_STORE_ROOT,
   DEFAULT_FOUNDATION_RUNS_DIR,
   expandUserPath,
   getConfigDir,
@@ -6050,12 +6366,9 @@ export {
   behaviorSpecSchema,
   specSnapshotSchema,
   foundationHyperparametersSchema,
-  localFoundationSpecFileSchema,
   datasetPrebuiltSchema,
   fineTuneHyperparametersSchema,
   fineTuneRunRequestSchema,
-  localAdapterSpecFileSchema,
-  localBehaviorSpecFileSchema,
   evalExampleResultSchema,
   jsonFieldMetricsSchema,
   evalSplitSchema,
@@ -6064,6 +6377,10 @@ export {
   trainingReportSchema,
   runReportSchema,
   localRunnerConfigSchema,
+  projectRuntimeSchema,
+  localFoundationSpecFileSchema,
+  localAdapterSpecFileSchema,
+  localBehaviorSpecFileSchema,
   isFoundationSpecFile,
   DEFAULT_LOCAL_SPEC_PATH,
   localPathsOverlap,
@@ -6077,6 +6394,18 @@ export {
   runRequestFromLocalSpec,
   parseLocalRunInput,
   loadLocalRunInput,
+  specHash,
+  validateBehaviorSpec,
+  pipelineFromFoundationHyperparameters,
+  validatePipeline,
+  canonicalPipeline,
+  pipelineForRunInput,
+  createExecutionPlan,
+  assertFoundationSettingsMatch,
+  canonicalFoundationPipeline2 as canonicalFoundationPipeline,
+  canonicalJson2 as canonicalJson,
+  isFoundationPipeline3 as isFoundationPipeline,
+  parsePipeline3 as parsePipeline,
   normalizeChatJsonlForRelocation,
   buildSystemMessage,
   exampleToChatRow,
@@ -6120,10 +6449,12 @@ export {
   fingerprintLocalBaseModel,
   runLocalPipeline,
   runLocalFineTune,
+  configForSpec,
+  resolveProjectConfig,
   warningsFromSnapshot,
   readHardwareSnapshot,
   formatHostStatusLine,
   formatAgentHostBlock,
   assessHardware
 };
-//# sourceMappingURL=chunk-6RLNBTM6.js.map
+//# sourceMappingURL=chunk-U5HNS367.js.map