@tuned-tensor/cli 0.17.0 → 0.18.0

package/README.md

@@ -288,29 +288,32 @@ expected output for every example. Treat those metrics as an end-to-end
 execution and overfit check—not held-out capability or multi-GPU evidence when
 no validation corpus is configured.
 
-Without `--file`, pipeline plan/run/validate derive the recipe from the behavior
-spec. Adjacent recipe files are no longer loaded implicitly. Explicit foundation
-recipes must agree with the spec’s training settings.
+`tunedtensor.json` contains behavior, training settings, optional `evaluation`,
+`runtime`, and advanced `pipeline` sections. Pipelines use the embedded recipe
+or derive it from the saved spec. Only explicit `--file` loads a separate recipe;
+it cannot override a conflicting embedded recipe. Foundation recipes must match
+the spec's training settings.
 
 ```bash
-tt pipeline init --file pipeline.json
-tt pipeline init --engine foundation --file foundation.pipeline.json
-tt pipeline validate --file pipeline.json
-tt --json pipeline plan --file pipeline.json
-tt --json pipeline run --dry-run --file pipeline.json --only baseline
-tt --json pipeline run --file pipeline.json \
-  --spec tunedtensor.json --config local-runner.json
-tt init --engine foundation --name "Tiny GPT"
-tt --json pipeline run --spec tunedtensor.json --dry-run
-tt pipeline run --spec tunedtensor.json --resume /absolute/path/to/foundation-run
+tt pipeline validate --spec tunedtensor.json
+tt --json pipeline plan --spec tunedtensor.json
+tt pipeline run --spec tunedtensor.json --dry-run
+tt pipeline run --spec tunedtensor.json
+# Optional: embed the current derived recipe for customization
+tt pipeline init --spec tunedtensor.json
+# Existing projects: consolidate sidecars, retaining .bak copies
+tt pipeline migrate --spec tunedtensor.json
 ```
 
-When `--config` is omitted, `pipeline run` uses `local-runner.json` beside the
-selected spec when that file exists.
+Relative runtime paths resolve beside the spec. New project state uses
+`.tuned-tensor/store` and `.tuned-tensor/artifacts`. Legacy `local-runner.json`
+remains readable with a warning; migrate it before adding inline runtime or
+evaluation settings. See [single-file examples](examples/single-spec) and the
+[spec workflow](docs/spec-workflow.md).
 
 `--only` and `--skip` preserve dependency safety: a selected step cannot refer
-to an omitted predecessor. Keep step targets local and configure `gpu` in
-`local-runner.json` to execute GPU work on your AWS instance. Adapter and
+to an omitted predecessor. Keep step targets local and configure `runtime.gpu` in
+`tunedtensor.json` to execute GPU work on your AWS instance. Adapter and
 foundation workflows use the same local pipeline. The TT agent may describe,
 validate, and prepare a sealed pipeline action; only deterministic `/approve`
 handling can execute it.
@@ -389,18 +392,20 @@ tt init \
 
 Edit the generated `tunedtensor.json`, replacing the placeholder system prompt and both placeholder examples.
 For a local GPU, `tt hardware` reports this machine's training and serving
-capacity. For an AWS GPU, save the following as `local-runner.json` beside the
-spec, replacing the instance, region, profile and SSH settings with your own:
+capacity. For an AWS GPU, add the following `runtime` section to your
+`tunedtensor.json`, replacing the instance, region, profile and SSH settings with your own:
 
 ```json
 {
-  "gpu": {
-    "provider": "aws",
-    "profile": "research",
-    "region": "eu-west-1",
-    "instanceId": "i-0123456789abcdef0",
-    "user": "ubuntu",
-    "identityFile": "~/.ssh/research-gpu.pem"
+  "runtime": {
+    "gpu": {
+      "provider": "aws",
+      "profile": "research",
+      "region": "eu-west-1",
+      "instanceId": "i-0123456789abcdef0",
+      "user": "ubuntu",
+      "identityFile": "~/.ssh/research-gpu.pem"
+    }
   }
 }
 ```
@@ -419,7 +424,7 @@ tt pipeline run --spec tunedtensor.json --dry-run
 tt pipeline run --spec tunedtensor.json
 ```
 
-These commands discover the adjacent `local-runner.json`. The preview needs
+These commands read runtime and evaluation settings from the core spec. The preview needs
 no GPU or AWS connection. Results return to the local run and model stores:
 
 ```bash
@@ -451,7 +456,7 @@ Activation is optional and requires the run to pass a configured
 `generalRegression` gate. Without that suite, `tt models activate` fails
 closed. `tt serve active` also fails closed if nothing is activated — it does
 not silently serve the protected base model. Once activated, use
-`tt serve active --config local-runner.json`.
+`tt serve active`.
 
 `tt serve base` does not automatically inject the adjacent project spec.
 Pass `--spec tunedtensor.json` when the server should enforce its instructions.

package/dist/{chunk-KRKISPHG.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
@@ -1489,6 +1525,199 @@ function validateBehaviorSpec(input) {
   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";
 async function loadNormalizedChatJsonl(path) {
@@ -3294,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;
@@ -3324,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;
@@ -4224,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) {
@@ -5294,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);
@@ -5381,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) {
@@ -5678,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;
@@ -5832,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);
@@ -5847,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 {
@@ -5933,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),
@@ -5982,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;
@@ -6009,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,
@@ -6088,6 +6353,7 @@ export {
   resolveModelLoader,
   assertUsableModelArtifact,
   DEFAULT_ARTIFACT_ROOT,
+  DEFAULT_PROJECT_STORE_ROOT,
   DEFAULT_FOUNDATION_RUNS_DIR,
   expandUserPath,
   getConfigDir,
@@ -6100,12 +6366,9 @@ export {
   behaviorSpecSchema,
   specSnapshotSchema,
   foundationHyperparametersSchema,
-  localFoundationSpecFileSchema,
   datasetPrebuiltSchema,
   fineTuneHyperparametersSchema,
   fineTuneRunRequestSchema,
-  localAdapterSpecFileSchema,
-  localBehaviorSpecFileSchema,
   evalExampleResultSchema,
   jsonFieldMetricsSchema,
   evalSplitSchema,
@@ -6114,6 +6377,10 @@ export {
   trainingReportSchema,
   runReportSchema,
   localRunnerConfigSchema,
+  projectRuntimeSchema,
+  localFoundationSpecFileSchema,
+  localAdapterSpecFileSchema,
+  localBehaviorSpecFileSchema,
   isFoundationSpecFile,
   DEFAULT_LOCAL_SPEC_PATH,
   localPathsOverlap,
@@ -6129,6 +6396,16 @@ export {
   loadLocalRunInput,
   specHash,
   validateBehaviorSpec,
+  pipelineFromFoundationHyperparameters,
+  validatePipeline,
+  canonicalPipeline,
+  pipelineForRunInput,
+  createExecutionPlan,
+  assertFoundationSettingsMatch,
+  canonicalFoundationPipeline2 as canonicalFoundationPipeline,
+  canonicalJson2 as canonicalJson,
+  isFoundationPipeline3 as isFoundationPipeline,
+  parsePipeline3 as parsePipeline,
   normalizeChatJsonlForRelocation,
   buildSystemMessage,
   exampleToChatRow,
@@ -6172,10 +6449,12 @@ export {
   fingerprintLocalBaseModel,
   runLocalPipeline,
   runLocalFineTune,
+  configForSpec,
+  resolveProjectConfig,
   warningsFromSnapshot,
   readHardwareSnapshot,
   formatHostStatusLine,
   formatAgentHostBlock,
   assessHardware
 };
-//# sourceMappingURL=chunk-KRKISPHG.js.map
+//# sourceMappingURL=chunk-U5HNS367.js.map