@tuned-tensor/cli 0.13.0-beta.1 → 0.13.1-beta.0

package/dist/{chunk-2VJ3VVZF.js → chunk-YJYCGSHJ.js}

@@ -558,12 +558,14 @@ async function assertArtifactManifest(manifestPath, options = {}) {
 import { lstat as lstat2, readdir as readdir2 } from "fs/promises";
 import { resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+var QWEN_3_5_2B_REVISION = "15852e8c16360a2fea060d615a32b45270f8a8fc";
 var NEMOTRON_BF16_REVISION = "ce38b6ab8b252b4b8ee7165b4605e93191cafd73";
 var MUSE_GLIMMER_BF16_REVISION = "a4e59da52a7bc87ae7251dd5545c0dd437c44b68";
 var TRAINING_MODELS = [
   {
     id: "Qwen/Qwen3.5-2B",
     family: "qwen3_5",
+    defaultRevision: QWEN_3_5_2B_REVISION,
     modelLoader: "causal_lm",
     defaultLearningRate: 1e-5,
     defaultPerDeviceBatchSize: 1,
@@ -1079,508 +1081,24 @@ var localRunnerConfigSchema = z.object({
   })
 }).strict();
 
-// src/local-runtime/store.ts
-import { appendFile, copyFile as copyFile2, mkdir as mkdir2, readdir as readdir3, readFile as readFile2, rename as rename2, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { homedir } from "os";
-import { dirname as dirname2, join as join2, resolve as resolve3, sep as sep2 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-function isTerminalRunState(state) {
-  return state.status === "stage_completed" || state.status === "completed" || state.status === "failed" || state.status === "cancelled" && state.current_stage === "cancelled" && Boolean(state.completed_at);
-}
-function defaultLocalHome() {
-  return resolve3(process.env.TT_LOCAL_HOME ?? join2(homedir(), ".tuned-tensor-local"));
-}
-function localStorePaths(root) {
-  return {
-    root,
-    specsDir: join2(root, "specs"),
-    runsDir: join2(root, "runs"),
-    modelsDir: join2(root, "models"),
-    datasetsDir: join2(root, "datasets")
-  };
-}
-async function exists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function writeJsonAtomic2(path, value) {
-  await mkdir2(dirname2(path), { recursive: true });
-  const tmp = `${path}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
-  await writeFile2(tmp, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-  await rename2(tmp, path);
-}
-async function readJson2(path) {
-  return JSON.parse(await readFile2(path, "utf8"));
-}
-async function appendJsonl(path, value) {
-  await mkdir2(dirname2(path), { recursive: true });
-  await appendFile(path, `${JSON.stringify(value)}
-`, "utf8");
-}
-async function readJsonl(path) {
-  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 exists(from)) return;
-  await mkdir2(dirname2(to), { recursive: true });
-  await copyFile2(from, to);
-}
-async function childDirectoryNames(path) {
-  try {
-    const entries = await readdir3(path, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
-}
-function compareIds(left, right) {
-  if (left.id === right.id) return 0;
-  return left.id < right.id ? -1 : 1;
-}
-function compareUpdatedAt(left, right) {
-  if (left.updated_at !== right.updated_at) return left.updated_at > right.updated_at ? -1 : 1;
-  return compareIds(left, right);
-}
-function compareCreatedAt(left, right) {
-  if (left.created_at !== right.created_at) return left.created_at > right.created_at ? -1 : 1;
-  return compareIds(left, right);
-}
-function findByIdOrPrefix(records, id) {
-  return records.find((record) => record.id === id) ?? records.find((record) => record.id.startsWith(id));
-}
-function isPathInside(root, candidate) {
-  const resolvedRoot = resolve3(root);
-  const resolvedCandidate = resolve3(candidate);
-  return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
-}
-function createLocalStore(root = defaultLocalHome()) {
-  const resolvedRoot = resolve3(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() {
-    await Promise.all([
-      mkdir2(paths.specsDir, { recursive: true }),
-      mkdir2(paths.runsDir, { recursive: true }),
-      mkdir2(paths.modelsDir, { recursive: true }),
-      mkdir2(paths.datasetsDir, { recursive: true })
-    ]);
-  }
-  async function writeRunState(state) {
-    await writeJsonAtomic2(runStatePath(state.id), state);
-    return state;
-  }
-  async function readSpecRecord(id) {
-    const path = specPath(id);
-    if (!await exists(path)) return null;
-    const [spec, fileStats, directoryStats] = await Promise.all([
-      readJson2(path),
-      stat2(path),
-      stat2(specDir(id))
-    ]);
-    const createdAt = directoryStats.birthtimeMs > 0 ? directoryStats.birthtime : directoryStats.ctime;
-    return {
-      id,
-      name: spec.name,
-      base_model: spec.base_model,
-      path,
-      created_at: createdAt.toISOString(),
-      updated_at: fileStats.mtime.toISOString()
-    };
-  }
-  async function listSpecRecords() {
-    await ensure();
-    const records = [];
-    for (const id of await childDirectoryNames(paths.specsDir)) {
-      const record = await readSpecRecord(id);
-      if (record) records.push(record);
-    }
-    return records.sort(compareUpdatedAt);
-  }
-  async function listRunRecords() {
-    await ensure();
-    const records = [];
-    for (const id of await childDirectoryNames(paths.runsDir)) {
-      const path = runStatePath(id);
-      if (await exists(path)) records.push(await readJson2(path));
-    }
-    return records.sort(compareUpdatedAt);
-  }
-  async function listModelRecords() {
-    await ensure();
-    const records = [];
-    for (const id of await childDirectoryNames(paths.modelsDir)) {
-      const path = modelPath(id);
-      if (await exists(path)) records.push(await readJson2(path));
-    }
-    return records.sort(compareCreatedAt);
-  }
-  async function importSpecRecord(specId, spec) {
-    await ensure();
-    await mkdir2(specDir(specId), { recursive: true });
-    await writeJsonAtomic2(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: 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"), {
-      at: row.occurred_at,
-      stage: row.stage,
-      status: row.status,
-      message: row.message,
-      ...row.details ? { details: row.details } : {}
-    });
-  }
-  async function finalizeCancellationState(runId) {
-    const previous = await getRun(runId);
-    if (previous.status === "cancelled" && previous.current_stage === "cancelled" && previous.completed_at) {
-      return previous;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const cancelled = {
-      ...previous,
-      status: "cancelled",
-      current_stage: "cancelled",
-      status_message: "Run cancelled.",
-      error: void 0,
-      completed_at: now,
-      updated_at: now
-    };
-    await writeRunState(cancelled);
-    await appendRunEvent(cancelled, { stage: "cancelled", status: "cancelled", message: "Run cancelled." });
-    return cancelled;
-  }
-  async function preserveCancellationRequestState(runId) {
-    const previous = await getRun(runId);
-    if (isTerminalRunState(previous)) return previous;
-    if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
-    const requested = {
-      ...previous,
-      status: "cancelled",
-      current_stage: "cancel_requested",
-      status_message: "Cancellation requested; waiting for the active worker to stop.",
-      error: void 0,
-      completed_at: void 0,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return writeRunState(requested);
-  }
-  async function resolveRunId(id) {
-    await ensure();
-    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) {
-    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 exists(modelPath(modelId)) ? await readJson2(modelPath(modelId)) : void 0;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const model = {
-      id: modelId,
-      run_id: args.request.run_id,
-      behavior_spec_id: args.request.behavior_spec_id,
-      name: `${args.request.spec_snapshot.base_model} (${args.request.run_id.slice(0, 8)})`,
-      provider: args.training.provider,
-      base_model: args.request.spec_snapshot.base_model,
-      artifact_uri: args.training.model_artifact_uri,
-      artifact_dir: args.artifactDir,
-      metrics: args.training.metrics,
-      created_at: existingModel?.created_at ?? args.createdAt ?? now
-    };
-    await writeJsonAtomic2(modelPath(model.id), model);
-    const alreadyRegistered = previous.model_id === modelId;
-    const state = {
-      ...previous,
-      model_id: modelId,
-      updated_at: now
-    };
-    await writeRunState(state);
-    if (!alreadyRegistered) {
-      await appendRunEvent(state, {
-        stage: "model_registered",
-        status: "running",
-        message: "Local model artifact registered.",
-        details: { model_id: modelId, artifact_uri: model.artifact_uri }
-      });
-    }
-    return model;
-  }
-  return {
-    root: resolvedRoot,
-    paths,
-    ensure,
-    importSpec: importSpecRecord,
-    async listSpecs() {
-      return listSpecRecords();
-    },
-    async getSpec(id) {
-      const record = findByIdOrPrefix(await listSpecRecords(), id);
-      if (!record) throw new Error(`Spec not found: ${id}`);
-      return { ...record, spec: await readJson2(record.path) };
-    },
-    async startRun({ request, artifactDir }) {
-      await ensure();
-      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const state = {
-        id: request.run_id,
-        behavior_spec_id: request.behavior_spec_id,
-        user_id: request.user_id,
-        run_number: request.run_number,
-        status: "queued",
-        current_stage: "queued",
-        status_message: "Run queued.",
-        artifact_dir: artifactDir,
-        base_model: request.spec_snapshot.base_model,
-        spec_name: request.spec_snapshot.name,
-        created_at: now,
-        updated_at: now,
-        started_at: now
-      };
-      await writeJsonAtomic2(runRequestPath(request.run_id), request);
-      await writeRunState(state);
-      await appendRunEvent(state, { stage: "queued", status: "queued", message: "Run queued." });
-      return state;
-    },
-    async syncRunRequest(request, artifactDir) {
-      const previous = await getRun(request.run_id);
-      if (previous.behavior_spec_id !== request.behavior_spec_id || previous.user_id !== request.user_id || previous.run_number !== request.run_number) {
-        throw new Error(
-          `Run ${request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
-        );
-      }
-      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
-      await writeJsonAtomic2(runRequestPath(request.run_id), request);
-      const state = {
-        ...previous,
-        artifact_dir: artifactDir ?? previous.artifact_dir,
-        base_model: request.spec_snapshot.base_model,
-        spec_name: request.spec_snapshot.name,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await writeRunState(state);
-      return state;
-    },
-    async updateRun({ runId, status, stage, message, details }) {
-      const previous = await getRun(runId);
-      if (status !== "cancelled" && await exists(cancellationPath(previous.id))) {
-        return preserveCancellationRequestState(previous.id);
-      }
-      const active = status !== "stage_completed" && status !== "completed" && status !== "failed" && status !== "cancelled";
-      const successful = status === "stage_completed" || status === "completed";
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const state = {
-        ...previous,
-        status,
-        current_stage: stage,
-        status_message: message,
-        ...active ? { error: void 0, completed_at: void 0 } : successful ? { error: void 0, completed_at: now } : {},
-        updated_at: now
-      };
-      await writeRunState(state);
-      if (status !== "cancelled" && await exists(cancellationPath(previous.id))) {
-        return preserveCancellationRequestState(previous.id);
-      }
-      await appendRunEvent(state, {
-        stage,
-        status: successful ? "completed" : status === "failed" ? "failed" : "running",
-        message,
-        details
-      });
-      return state;
-    },
-    async completeRun(report, artifactDir, reportPath) {
-      if (await exists(cancellationPath(report.run_id))) {
-        return preserveCancellationRequestState(report.run_id);
-      }
-      const request = await readJson2(runRequestPath(report.run_id));
-      const completedAt = report.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
-      const model = await registerModelRecord({
-        request,
-        training: report.training,
-        artifactDir,
-        createdAt: completedAt
-      });
-      if (!model) {
-        await rm(join2(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
-      }
-      const previous = await getRun(report.run_id);
-      const state = {
-        ...previous,
-        status: "completed",
-        current_stage: "completed",
-        status_message: "Run completed successfully.",
-        report_path: reportPath,
-        model_id: model?.id,
-        error: void 0,
-        completed_at: completedAt,
-        updated_at: completedAt
-      };
-      await writeRunState(state);
-      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",
-        message: "Run completed successfully.",
-        details: { report_path: reportPath, ...model ? { model_id: model.id } : {} }
-      });
-      return state;
-    },
-    registerModel: registerModelRecord,
-    async invalidateRunOutputs(runId, options) {
-      const previous = await getRun(runId);
-      if (options.report) await rm(runReportPath(previous.id), { force: true });
-      if (options.model) {
-        await rm(join2(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
-      }
-      const state = {
-        ...previous,
-        ...options.report ? { report_path: void 0 } : {},
-        ...options.model ? { model_id: void 0 } : {},
-        error: void 0,
-        completed_at: void 0,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return writeRunState(state);
-    },
-    async failRun(runId, error) {
-      const previous = await getRun(runId);
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      if (await exists(cancellationPath(previous.id))) {
-        return preserveCancellationRequestState(previous.id);
-      }
-      const state = {
-        ...previous,
-        status: "failed",
-        current_stage: "failed",
-        status_message: error,
-        error,
-        completed_at: now,
-        updated_at: now
-      };
-      await writeRunState(state);
-      if (await exists(cancellationPath(previous.id))) {
-        return preserveCancellationRequestState(previous.id);
-      }
-      await appendRunEvent(state, { stage: "failed", status: "failed", message: error });
-      return state;
-    },
-    async cancelRun(runId) {
-      const state = await getRun(runId);
-      if (isTerminalRunState(state) || state.status === "cancelled" && state.current_stage === "cancel_requested") {
-        return;
-      }
-      await writeFile2(cancellationPath(state.id), `${(/* @__PURE__ */ new Date()).toISOString()}
-`, "utf8");
-      const latest = await getRun(state.id);
-      if (isTerminalRunState(latest)) {
-        if (latest.status !== "cancelled") await rm(cancellationPath(state.id), { force: true });
-        return;
-      }
-      const updated = {
-        ...latest,
-        status: "cancelled",
-        current_stage: "cancel_requested",
-        status_message: "Cancellation requested; waiting for the active worker to stop.",
-        error: void 0,
-        completed_at: void 0,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await writeRunState(updated);
-      await appendRunEvent(updated, { stage: "cancel_requested", status: "cancelled", message: "Cancellation requested." });
-    },
-    async finalizeCancellation(runId) {
-      return finalizeCancellationState(runId);
-    },
-    async isCancellationRequested(runId) {
-      const state = await getRun(runId);
-      return state.status === "cancelled" || await exists(cancellationPath(state.id));
-    },
-    async listRuns() {
-      return listRunRecords();
-    },
-    getRun,
-    async getRunEvents(id) {
-      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 = resolve3(state.report_path);
-        const allowedRoots = [resolvedRoot];
-        if (state.artifact_dir) allowedRoots.push(resolve3(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/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 isAbsolute2, resolve as resolve4 } from "path";
-import { homedir as homedir2 } from "os";
-import { mkdir as mkdir3 } from "fs/promises";
+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 homedir2();
-  if (value.startsWith("~/")) return resolve4(homedir2(), value.slice(2));
-  return resolve4(baseDirectory, 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 = dirname3(resolve4(inputPath));
+  const baseDirectory = dirname2(resolve3(inputPath));
   const value = structuredClone(raw);
   const dataset = value.dataset_prebuilt;
   if (dataset && typeof dataset === "object" && !Array.isArray(dataset)) {
@@ -1591,20 +1109,20 @@ function resolveLocalRunInputPaths(raw, inputPath) {
   }
   return value;
 }
-async function exists2(path) {
+async function exists(path) {
   try {
-    await stat3(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
   }
 }
 async function initLocalSpecFile(args) {
-  if (!args.force && await exists2(args.outputPath)) {
+  if (!args.force && await exists(args.outputPath)) {
     throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
   }
   const spec = localBehaviorSpecFileSchema.parse({
-    id: randomUUID3(),
+    id: randomUUID2(),
     name: args.name,
     description: "",
     system_prompt: "Describe the behavior this local model should learn.",
@@ -1627,13 +1145,13 @@ async function initLocalSpecFile(args) {
       n_epochs: 1
     }
   });
-  await mkdir3(dirname3(args.outputPath), { recursive: true });
-  await writeFile3(args.outputPath, `${JSON.stringify(spec, null, 2)}
+  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 exists2(args.outputPath)) {
+  if (!args.force && await exists(args.outputPath)) {
     throw new Error(`Refusing to overwrite existing file: ${args.outputPath}`);
   }
   const config = {
@@ -1649,8 +1167,8 @@ async function initLocalRunnerConfigFile(args) {
       timeoutMs: 18e5
     }
   };
-  await mkdir3(dirname3(args.outputPath), { recursive: true });
-  await writeFile3(args.outputPath, `${JSON.stringify(config, null, 2)}
+  await mkdir2(dirname2(args.outputPath), { recursive: true });
+  await writeFile2(args.outputPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   return config;
 }
@@ -1681,7 +1199,7 @@ function runRequestFromLocalSpec(spec, options = {}) {
   } = spec;
   const behaviorSpecId = id ?? deterministicBehaviorSpecId(specSnapshot);
   return fineTuneRunRequestSchema.parse({
-    run_id: options.runId ?? randomUUID3(),
+    run_id: options.runId ?? randomUUID2(),
     user_id: "local-user",
     behavior_spec_id: behaviorSpecId,
     run_number: 1,
@@ -1705,7 +1223,7 @@ function deterministicBehaviorSpecId(spec) {
   ].join("-");
 }
 async function loadLocalRunInput(path, options = {}) {
-  const raw = resolveLocalRunInputPaths(JSON.parse(await readFile3(path, "utf8")), path);
+  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 };
@@ -1720,9 +1238,9 @@ async function loadLocalRunInput(path, options = {}) {
 }
 
 // src/local-runtime/dataset.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 async function loadNormalizedChatJsonl(path) {
-  const text = await readFile4(path, "utf8");
+  const text = await readFile3(path, "utf8");
   const rows = [];
   const jsonLines = [];
   for (const [index, line] of text.split(/\r?\n/).entries()) {
@@ -1859,29 +1377,513 @@ function forwardStreamLines(stream, onLine) {
     for (const line of lines) {
       if (line.trim()) onLine(sanitizeLogLine(line));
     }
-  });
-  stream.on("end", () => {
-    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
-  });
-}
-
-// src/local-runtime/package-root.ts
-import { existsSync } from "fs";
-import { dirname as dirname4, resolve as resolve5 } 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) => existsSync(resolve5(candidate, "package.json")) && existsSync(resolve5(candidate, "training/local-runner"))
-  );
-  if (!root) {
-    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  });
+  stream.on("end", () => {
+    if (buffered.trim()) onLine(sanitizeLogLine(buffered));
+  });
+}
+
+// src/local-runtime/package-root.ts
+import { existsSync } from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function localRuntimePackageRoot(moduleUrl) {
+  const moduleDirectory = dirname3(fileURLToPath2(moduleUrl));
+  const candidates = [
+    dirname3(moduleDirectory),
+    dirname3(dirname3(moduleDirectory))
+  ];
+  const root = candidates.find(
+    (candidate) => existsSync(resolve4(candidate, "package.json")) && existsSync(resolve4(candidate, "training/local-runner"))
+  );
+  if (!root) {
+    throw new Error("Unable to locate the bundled Tuned Tensor local runtime assets.");
+  }
+  return root;
+}
+
+// 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"));
+}
+function localStorePaths(root) {
+  return {
+    root,
+    specsDir: join2(root, "specs"),
+    runsDir: join2(root, "runs"),
+    modelsDir: join2(root, "models"),
+    datasetsDir: join2(root, "datasets")
+  };
+}
+async function exists2(path) {
+  try {
+    await stat3(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");
+  await rename2(tmp, path);
+}
+async function readJson2(path) {
+  return JSON.parse(await readFile4(path, "utf8"));
+}
+async function appendJsonl(path, value) {
+  await mkdir3(dirname4(path), { recursive: true });
+  await appendFile(path, `${JSON.stringify(value)}
+`, "utf8");
+}
+async function readJsonl(path) {
+  if (!await exists2(path)) return [];
+  return (await readFile4(path, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function copyIfExists(from, to) {
+  if (!await exists2(from)) return;
+  await mkdir3(dirname4(to), { recursive: true });
+  await copyFile2(from, to);
+}
+async function childDirectoryNames(path) {
+  try {
+    const entries = await readdir3(path, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function compareIds(left, right) {
+  if (left.id === right.id) return 0;
+  return left.id < right.id ? -1 : 1;
+}
+function compareUpdatedAt(left, right) {
+  if (left.updated_at !== right.updated_at) return left.updated_at > right.updated_at ? -1 : 1;
+  return compareIds(left, right);
+}
+function compareCreatedAt(left, right) {
+  if (left.created_at !== right.created_at) return left.created_at > right.created_at ? -1 : 1;
+  return compareIds(left, right);
+}
+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);
+  return resolvedCandidate === resolvedRoot || resolvedCandidate.startsWith(`${resolvedRoot}${sep2}`);
+}
+function createLocalStore(root = defaultLocalHome()) {
+  const resolvedRoot = resolve5(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() {
+    await Promise.all([
+      mkdir3(paths.specsDir, { recursive: true }),
+      mkdir3(paths.runsDir, { recursive: true }),
+      mkdir3(paths.modelsDir, { recursive: true }),
+      mkdir3(paths.datasetsDir, { recursive: true })
+    ]);
+  }
+  async function writeRunState(state) {
+    await writeJsonAtomic2(runStatePath(state.id), state);
+    return state;
+  }
+  async function readSpecRecord(id) {
+    const path = specPath(id);
+    if (!await exists2(path)) return null;
+    const [spec, fileStats, directoryStats] = await Promise.all([
+      readJson2(path),
+      stat3(path),
+      stat3(specDir(id))
+    ]);
+    const createdAt = directoryStats.birthtimeMs > 0 ? directoryStats.birthtime : directoryStats.ctime;
+    return {
+      id,
+      name: spec.name,
+      base_model: spec.base_model,
+      path,
+      created_at: createdAt.toISOString(),
+      updated_at: fileStats.mtime.toISOString()
+    };
+  }
+  async function listSpecRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.specsDir)) {
+      const record = await readSpecRecord(id);
+      if (record) records.push(record);
+    }
+    return records.sort(compareUpdatedAt);
+  }
+  async function listRunRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.runsDir)) {
+      const path = runStatePath(id);
+      if (await exists2(path)) records.push(await readJson2(path));
+    }
+    return records.sort(compareUpdatedAt);
+  }
+  async function listModelRecords() {
+    await ensure();
+    const records = [];
+    for (const id of await childDirectoryNames(paths.modelsDir)) {
+      const path = modelPath(id);
+      if (await exists2(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);
+    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(),
+      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"), {
+      at: row.occurred_at,
+      stage: row.stage,
+      status: row.status,
+      message: row.message,
+      ...row.details ? { details: row.details } : {}
+    });
+  }
+  async function finalizeCancellationState(runId) {
+    const previous = await getRun(runId);
+    if (previous.status === "cancelled" && previous.current_stage === "cancelled" && previous.completed_at) {
+      return previous;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const cancelled = {
+      ...previous,
+      status: "cancelled",
+      current_stage: "cancelled",
+      status_message: "Run cancelled.",
+      error: void 0,
+      completed_at: now,
+      updated_at: now
+    };
+    await writeRunState(cancelled);
+    await appendRunEvent(cancelled, { stage: "cancelled", status: "cancelled", message: "Run cancelled." });
+    return cancelled;
+  }
+  async function preserveCancellationRequestState(runId) {
+    const previous = await getRun(runId);
+    if (isTerminalRunState(previous)) return previous;
+    if (previous.status === "cancelled" && previous.current_stage === "cancel_requested") return previous;
+    const requested = {
+      ...previous,
+      status: "cancelled",
+      current_stage: "cancel_requested",
+      status_message: "Cancellation requested; waiting for the active worker to stop.",
+      error: void 0,
+      completed_at: void 0,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return writeRunState(requested);
+  }
+  async function resolveRunId(id) {
+    await ensure();
+    if (await exists2(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) {
+    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 now = (/* @__PURE__ */ new Date()).toISOString();
+    const model = {
+      id: modelId,
+      run_id: args.request.run_id,
+      behavior_spec_id: args.request.behavior_spec_id,
+      name: `${args.request.spec_snapshot.base_model} (${args.request.run_id.slice(0, 8)})`,
+      provider: args.training.provider,
+      base_model: args.request.spec_snapshot.base_model,
+      artifact_uri: args.training.model_artifact_uri,
+      artifact_dir: args.artifactDir,
+      metrics: args.training.metrics,
+      created_at: existingModel?.created_at ?? args.createdAt ?? now
+    };
+    await writeJsonAtomic2(modelPath(model.id), model);
+    const alreadyRegistered = previous.model_id === modelId;
+    const state = {
+      ...previous,
+      model_id: modelId,
+      updated_at: now
+    };
+    await writeRunState(state);
+    if (!alreadyRegistered) {
+      await appendRunEvent(state, {
+        stage: "model_registered",
+        status: "running",
+        message: "Local model artifact registered.",
+        details: { model_id: modelId, artifact_uri: model.artifact_uri }
+      });
+    }
+    return model;
   }
-  return root;
+  return {
+    root: resolvedRoot,
+    paths,
+    ensure,
+    importSpec: importSpecRecord,
+    async listSpecs() {
+      return listSpecRecords();
+    },
+    async getSpec(id) {
+      const record = findByIdOrPrefix(await listSpecRecords(), id);
+      if (!record) throw new Error(`Spec not found: ${id}`);
+      return { ...record, spec: await readJson2(record.path) };
+    },
+    async startRun({ request, artifactDir }) {
+      await ensure();
+      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const state = {
+        id: request.run_id,
+        behavior_spec_id: request.behavior_spec_id,
+        user_id: request.user_id,
+        run_number: request.run_number,
+        status: "queued",
+        current_stage: "queued",
+        status_message: "Run queued.",
+        artifact_dir: artifactDir,
+        base_model: request.spec_snapshot.base_model,
+        spec_name: request.spec_snapshot.name,
+        created_at: now,
+        updated_at: now,
+        started_at: now
+      };
+      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      await writeRunState(state);
+      await appendRunEvent(state, { stage: "queued", status: "queued", message: "Run queued." });
+      return state;
+    },
+    async syncRunRequest(request, artifactDir) {
+      const previous = await getRun(request.run_id);
+      if (previous.behavior_spec_id !== request.behavior_spec_id || previous.user_id !== request.user_id || previous.run_number !== request.run_number) {
+        throw new Error(
+          `Run ${request.run_id} cannot be reused with different user, behavior spec, or run number identity.`
+        );
+      }
+      await importSpecRecord(request.behavior_spec_id, request.spec_snapshot);
+      await writeJsonAtomic2(runRequestPath(request.run_id), request);
+      const state = {
+        ...previous,
+        artifact_dir: artifactDir ?? previous.artifact_dir,
+        base_model: request.spec_snapshot.base_model,
+        spec_name: request.spec_snapshot.name,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeRunState(state);
+      return state;
+    },
+    async updateRun({ runId, status, stage, message, details }) {
+      const previous = await getRun(runId);
+      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      const active = status !== "stage_completed" && status !== "completed" && status !== "failed" && status !== "cancelled";
+      const successful = status === "stage_completed" || status === "completed";
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const state = {
+        ...previous,
+        status,
+        current_stage: stage,
+        status_message: message,
+        ...active ? { error: void 0, completed_at: void 0 } : successful ? { error: void 0, completed_at: now } : {},
+        updated_at: now
+      };
+      await writeRunState(state);
+      if (status !== "cancelled" && await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      await appendRunEvent(state, {
+        stage,
+        status: successful ? "completed" : status === "failed" ? "failed" : "running",
+        message,
+        details
+      });
+      return state;
+    },
+    async completeRun(report, artifactDir, reportPath) {
+      if (await exists2(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
+      const request = await readJson2(runRequestPath(report.run_id));
+      const completedAt = report.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+      const model = await registerModelRecord({
+        request,
+        training: report.training,
+        artifactDir,
+        createdAt: completedAt
+      });
+      if (!model) {
+        await rm(join2(paths.modelsDir, `local-${report.run_id}`), { recursive: true, force: true });
+      }
+      const previous = await getRun(report.run_id);
+      const state = {
+        ...previous,
+        status: "completed",
+        current_stage: "completed",
+        status_message: "Run completed successfully.",
+        report_path: reportPath,
+        model_id: model?.id,
+        error: void 0,
+        completed_at: completedAt,
+        updated_at: completedAt
+      };
+      await writeRunState(state);
+      if (await exists2(cancellationPath(report.run_id))) {
+        return preserveCancellationRequestState(report.run_id);
+      }
+      await copyIfExists(reportPath, runReportPath(report.run_id));
+      await appendRunEvent(state, {
+        stage: "completed",
+        status: "completed",
+        message: "Run completed successfully.",
+        details: { report_path: reportPath, ...model ? { model_id: model.id } : {} }
+      });
+      return state;
+    },
+    registerModel: registerModelRecord,
+    async invalidateRunOutputs(runId, options) {
+      const previous = await getRun(runId);
+      if (options.report) await rm(runReportPath(previous.id), { force: true });
+      if (options.model) {
+        await rm(join2(paths.modelsDir, `local-${previous.id}`), { recursive: true, force: true });
+      }
+      const state = {
+        ...previous,
+        ...options.report ? { report_path: void 0 } : {},
+        ...options.model ? { model_id: void 0 } : {},
+        error: void 0,
+        completed_at: void 0,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return writeRunState(state);
+    },
+    async failRun(runId, error) {
+      const previous = await getRun(runId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      const state = {
+        ...previous,
+        status: "failed",
+        current_stage: "failed",
+        status_message: error,
+        error,
+        completed_at: now,
+        updated_at: now
+      };
+      await writeRunState(state);
+      if (await exists2(cancellationPath(previous.id))) {
+        return preserveCancellationRequestState(previous.id);
+      }
+      await appendRunEvent(state, { stage: "failed", status: "failed", message: error });
+      return state;
+    },
+    async cancelRun(runId) {
+      const state = await getRun(runId);
+      if (isTerminalRunState(state) || state.status === "cancelled" && state.current_stage === "cancel_requested") {
+        return;
+      }
+      await writeFile3(cancellationPath(state.id), `${(/* @__PURE__ */ new Date()).toISOString()}
+`, "utf8");
+      const latest = await getRun(state.id);
+      if (isTerminalRunState(latest)) {
+        if (latest.status !== "cancelled") await rm(cancellationPath(state.id), { force: true });
+        return;
+      }
+      const updated = {
+        ...latest,
+        status: "cancelled",
+        current_stage: "cancel_requested",
+        status_message: "Cancellation requested; waiting for the active worker to stop.",
+        error: void 0,
+        completed_at: void 0,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeRunState(updated);
+      await appendRunEvent(updated, { stage: "cancel_requested", status: "cancelled", message: "Cancellation requested." });
+    },
+    async finalizeCancellation(runId) {
+      return finalizeCancellationState(runId);
+    },
+    async isCancellationRequested(runId) {
+      const state = await getRun(runId);
+      return state.status === "cancelled" || await exists2(cancellationPath(state.id));
+    },
+    async listRuns() {
+      return listRunRecords();
+    },
+    getRun,
+    async getRunEvents(id) {
+      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);
+        }
+      }
+      candidates.push(runReportPath(state.id));
+      for (const path of candidates) {
+        if (await exists2(path)) return readJson2(path);
+      }
+      throw new Error(`Run has no report yet: ${id}`);
+    },
+    async listModels() {
+      return listModelRecords();
+    },
+    async getModel(id) {
+      const record = findByIdOrPrefix(await listModelRecords(), id);
+      if (!record) throw new Error(`Model not found: ${id}`);
+      return record;
+    }
+  };
 }
 
 // src/local-runtime/prefetch.ts
@@ -1917,6 +1919,7 @@ function buildBundledPythonCommand(entrypoint, args = []) {
   const commandArgs = [
     "run",
     "--frozen",
+    "--quiet",
     "--project",
     bundledProject,
     "python",
@@ -2305,9 +2308,7 @@ async function verifyCertifiedLocalSnapshot(path, modelId, snapshotFiles, modelC
   const revision = defaultBaseModelRevision(modelId);
   if (!revision) return;
   const digests = certifiedFileDigests(modelId);
-  if (!digests) {
-    throw new Error(`No certified file digests are registered for pinned model ${modelId}.`);
-  }
+  if (!digests) return;
   if (!modelCache) {
     throw new Error(`A certified local snapshot for ${modelId} requires paths.modelCache.`);
   }
@@ -4766,10 +4767,6 @@ export {
   trainingReportSchema,
   runReportSchema,
   localRunnerConfigSchema,
-  isTerminalRunState,
-  defaultLocalHome,
-  localStorePaths,
-  createLocalStore,
   DEFAULT_LOCAL_SPEC_PATH,
   resolveLocalRunInputPaths,
   initLocalSpecFile,
@@ -4791,6 +4788,10 @@ export {
   localRuntimePackageRoot,
   buildBundledPythonCommand,
   withBundledPythonEnvironment,
+  isTerminalRunState,
+  defaultLocalHome,
+  localStorePaths,
+  createLocalStore,
   minimalMachineLearningEnvironment,
   withHuggingFaceCacheEnvironment,
   withOfflineHuggingFaceCacheEnvironment,
@@ -4810,4 +4811,4 @@ export {
   runLocalPipeline,
   runLocalFineTune
 };
-//# sourceMappingURL=chunk-2VJ3VVZF.js.map
+//# sourceMappingURL=chunk-YJYCGSHJ.js.map