@tuned-tensor/local 0.2.9 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,92 @@
 
 All notable changes to TT Local will be documented in this file.
 
+## Unreleased
+
+## 0.4.0 - 2026-07-26
+
+### Added
+
+- Added an independent chat JSONL general-regression suite that evaluates the
+  protected base and tuned adapter with configurable score and pass-rate
+  budgets, immutable artifacts, and explicit pass/fail evidence in run reports.
+- Added lightweight active-model promotion and rollback through
+  `models activate`, `models active`, `models rollback`, `serve active`, and
+  protected-base serving. Activation requires a completed run, a passing
+  general-regression gate, and verified run and model artifacts.
+
+### Changed
+
+- General-regression dataset or prompt changes now invalidate only the
+  affected evaluations, while policy-only changes recalculate the report
+  without retraining or repeating inference.
+- The bundled OpenAI-compatible server can now launch the certified protected
+  base without attaching a PEFT adapter.
+
+### Fixed
+
+- Repeated activation of the already-active model is idempotent and preserves
+  its rollback target.
+- Regression-budget comparisons tolerate insignificant floating-point noise at
+  the configured boundary.
+
+## 0.3.0 - 2026-07-26
+
+### Added
+
+- Added one certified end-to-end local workflow for CUDA LoRA SFT of
+  `Qwen/Qwen3.5-2B`, including immutable snapshot prefetch, held-out
+  base-versus-tuned evaluation, verified PEFT artifacts, and
+  OpenAI-compatible local serving.
+- Added exact Qwen model-contract checks in both TypeScript and Python, plus
+  strict text-only chat JSONL validation and assistant-only SFT data tests.
+
+### Removed
+
+- **Breaking:** reduced TT Local to its end-to-end verified purpose: text LoRA
+  SFT of `Qwen/Qwen3.5-2B` on CUDA. Removed DPO, multimodal and continuation
+  inputs, arbitrary training/evaluation commands, external model contracts,
+  cloud teacher labeling and LLM judging, the classic-ML Study subsystem, and
+  the local dashboard.
+- Removed the SQLite metadata mirror. Canonical JSON/JSONL files are now the
+  only state store and remain directly inspectable and recoverable.
+- Removed implicit working-directory `.env` loading. Credentials and serving
+  keys must be provided explicitly through the process environment.
+- Removed the incomplete detached-run, watch, and remote-cancel surfaces.
+  Workflows now run in the foreground so process and state lifecycles cannot
+  diverge after a host restart or worker crash.
+
+### Changed
+
+- Training now computes loss only on assistant answer tokens and truncates the
+  prompt before the answer. CUDA training and tokenizer chat-template failures
+  fail fast instead of silently changing behavior.
+- Runner, spec, and hyperparameter schemas are strict; obsolete and misspelled
+  fields are rejected rather than ignored.
+- Training, evaluation, and serving now always use the bundled locked Python
+  project. Removed public runner project, working-directory, provider, and
+  environment overrides.
+- Bundled `uv` commands now use `--frozen` and a content-keyed virtual
+  environment in the writable user cache instead of modifying the npm package.
+- After prefetch verifies an immutable snapshot, training, evaluation, and
+  serving enforce offline Hugging Face cache use and the current Transformers
+  `dtype` loading API.
+- Explicit base-model revisions must be immutable 40-character Hugging Face
+  commit SHAs; moving branches and tags are rejected.
+- Default holdout sampling is stable across runs of the same behavior spec,
+  and baseline cache identity no longer includes the per-run UUID.
+- The supported workflow is now documented and tested as one coherent path:
+  initialize, preflight, prepare held-out data, train, compare, verify, and
+  serve a local PEFT adapter.
+- Prebuilt datasets with both validation and test files now use validation for
+  normal iterative evaluation, preserving test as a separate holdout.
+
+### Fixed
+
+- Completed process-group teardown when a logged command's direct child exits,
+  including an opt-in cleanup mode for successful commands that must not leave
+  background descendants running.
+
 ## 0.2.9 - 2026-07-14
 
 ### Changed

package/README.md

@@ -3,272 +3,181 @@
 [![CI](https://github.com/tunedtensor/tuned-tensor-local/actions/workflows/ci.yml/badge.svg)](https://github.com/tunedtensor/tuned-tensor-local/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/@tuned-tensor/local)](https://www.npmjs.com/package/@tuned-tensor/local)
 
-TT Local is local-first fine-tuning with built-in evaluation for small
-open-weight models. On a compatible NVIDIA GPU on Linux, it turns a behavior
-spec into a fine-tuned model and a paired, inspectable report comparing the run
-baseline with the tuned candidate on representative evaluation cases. Specs,
-datasets, model artifacts, events, reports, and dashboard state stay on local
-disk.
+TT Local fine-tunes an open-weight language model on your own NVIDIA GPU. It
+turns a small behavior spec or chat JSONL dataset into a verified LoRA adapter,
+compares the base and tuned model on held-out examples, and can serve the
+adapter through an OpenAI-compatible endpoint.
 
-Usage docs:
+The current release deliberately has one supported path:
 
-https://tunedtensor.com/docs/local-training
+- text supervised fine-tuning (SFT);
+- `Qwen/Qwen3.5-2B`;
+- LoRA/PEFT on CUDA;
+- deterministic exact-match or JSON-field evaluation;
+- local files for datasets, state, reports, and model artifacts.
 
-## Install
+New model families and training methods should be added only after they have a
+repeatable end-to-end GPU acceptance test.
 
-```bash
-npm install -g @tuned-tensor/local
-tt-local info
-```
+## Requirements
 
-The bundled SFT, DPO, and Transformers evaluator path also needs `uv`:
-
-```bash
-uv --version
-```
+- Node.js 22 or later
+- [`uv`](https://docs.astral.sh/uv/)
+- an NVIDIA CUDA host with enough free disk space for the model cache and run
+  artifacts
 
-Custom training or evaluation workflows can use command entrypoints instead of
-`uv`.
-
-The default uv project is included in the npm package at
-`training/local-runner`; using bundled training does not require cloning this
-repository.
-
-## First Local Run
-
-On an NVIDIA Spark or another CUDA host, initialize both the behavior spec and
-a durable project-local runner config:
+The npm package includes the locked Python training environment.
 
 ```bash
-tt-local --version
-tt-local init --name "Support Bot" --model Qwen/Qwen3.5-2B --profile spark
+npm install -g @tuned-tensor/local
+tt-local info
 ```
 
-Edit `tunedtensor.json` to replace the generated system prompt and example.
-TT Local refuses to validate or train the unchanged placeholder so an
-accidental run cannot spend GPU time on it.
+## Fine-tune a model
 
-Then preflight the exact Python environments and paths that the run will use:
+Create a project on the GPU host:
 
 ```bash
-tt-local doctor tunedtensor.json --config local-runner.json
-tt-local validate tunedtensor.json --config local-runner.json
+mkdir support-adapter && cd support-adapter
+tt-local init --name "Support Adapter" --model Qwen/Qwen3.5-2B --profile spark
 ```
 
-`doctor` checks the bundled uv environment, Torch/Transformers/PEFT imports,
-the requested CUDA/MPS device, judge credentials when configured, writable
-artifact/cache/store roots, and available disk space. GPU checks are skipped
-for dry runs and are conditional for CPU/MPS configurations.
+This creates `tunedtensor.json` and `local-runner.json`. Edit the generated
+system prompt and replace both placeholder examples with representative,
+different examples. Two examples are the minimum for a real run because
+training and evaluation must not use the same row.
 
-Download the base model explicitly, then start the run:
+Preflight the machine, input, and cached base model:
 
 ```bash
-tt-local models prefetch tunedtensor.json --config local-runner.json
-tt-local models verify-base tunedtensor.json --config local-runner.json
-tt-local run tunedtensor.json --config local-runner.json
+tt-local doctor tunedtensor.json
+tt-local validate tunedtensor.json
+tt-local models prefetch tunedtensor.json
+tt-local models verify-base tunedtensor.json
 ```
 
-Prefetch progress is visible by default. Pass `--quiet` only when another
-program is consuming the final JSON. `verify-base` is local-only: it checks
-the cached snapshot structure, indexed weight shards, tokenizer files, and
-non-empty weights without downloading a replacement. Cached Hugging Face blobs
-whose ETags encode Git or LFS checksums are re-hashed as part of verification.
+Commands discover `local-runner.json` beside the spec. Use
+`--config /path/to/local-runner.json` to select another config explicitly.
 
-For a long run, start it in the background and watch it from the current or a
-second terminal:
+Run the complete base-evaluate, train, tuned-evaluate, and report workflow:
 
 ```bash
-tt-local run tunedtensor.json --config local-runner.json --detach
-tt-local runs watch <run-id> --config local-runner.json
+tt-local run tunedtensor.json
 ```
 
-The detached command returns the persisted run ID, process ID, log path, and
-copy-paste watch/cancel commands before model work begins.
-
-Inspect the evidence after the run:
+Inspect the evidence and verify the adapter:
 
 ```bash
-tt-local runs list --config local-runner.json
-tt-local runs report <run-id> --config local-runner.json
-tt-local models verify local-<run-id> --config local-runner.json
+tt-local runs report <run-id>
+tt-local models verify local-<run-id>
 ```
 
-Treat the report as evidence on this run's evaluation cases, not as a
-guarantee of live application improvement.
+To protect broad capability, configure a separate chat JSONL suite in
+`local-runner.json`:
 
-The model is registered immediately after its artifact passes verification,
-so it remains discoverable if candidate evaluation or report generation later
-fails.
-
-## Serve a Trained Adapter
-
-`tt-local serve` is the run dashboard. To serve a trained TT Local adapter as
-an OpenAI-compatible model endpoint, use the nested model command:
-
-```bash
-tt-local models serve local-<run-id> \
-  --config local-runner.json \
-  --spec tunedtensor.json \
-  --host 127.0.0.1 \
-  --port 8000
+```json
+{
+  "evaluation": {
+    "generalRegression": {
+      "dataset": "evals/general.jsonl",
+      "maxScoreDrop": 0.03,
+      "maxPassRateDrop": 0.05
+    }
+  }
+}
 ```
 
-The server verifies the stored artifact, loads the recorded base model and
-PEFT adapter through the bundled uv environment, and binds to localhost by
-default. Test it from another terminal:
+TT Local evaluates the protected base and candidate adapter on this suite,
+records both reports, and marks whether the configured score and pass-rate
+budgets were respected. The base result uses the existing immutable baseline
+cache.
 
-```bash
-curl http://127.0.0.1:8000/health
-curl http://127.0.0.1:8000/v1/models
-curl http://127.0.0.1:8000/v1/chat/completions \
-  -H 'Content-Type: application/json' \
-  -d '{"messages":[{"role":"user","content":"Hello"}]}'
-```
-
-Use `--device cuda|mps|cpu|auto` to override the configured inference device.
-Non-loopback binds require both `--allow-remote` and
-`--api-key-env <environment-variable>`; requests must then send that value as
-a Bearer token. The server accepts multimodal images only as bounded `data:`
-URIs and does not support streaming yet.
-
-## Cache and Evaluation Semantics
-
-`paths.modelCache` means Hugging Face `HF_HOME` everywhere. Hub snapshots live
-under `<modelCache>/hub`; prefetch, training, evaluation, doctor, and serving
-all use that same layout. Set `HF_TOKEN` in the environment or project `.env`
-before prefetching a gated model. Do not commit `.env`.
-
-For reproducible remote loading, set
-`hyperparameters.base_model_revision` to an immutable Hugging Face commit.
-Alternatively, `paths.baseModel` may point to a complete local Hugging Face
-snapshot directory. It cannot point to a model archive or standalone weights
-file; TT Local requires non-empty model weights, `config.json`, tokenizer
-metadata and vocabulary, and every indexed shard. Local snapshot contents are
-fingerprinted so a byte change invalidates dependent stages.
-
-Shared baseline-cache entries are used only when the model and every local
-input have a stable content identity. An unpinned remote model or remotely
-hosted image bypasses the cache rather than risking stale evaluation results.
-
-The safe default scoring mode is deterministic `exact_match`. To use an
-OpenRouter judge, configure `evaluation.scoring.mode: "llm_judge"`, an `llm`
-block, and its API-key environment variable. Judge mode fails preflight when
-those are missing. Exact-match fallback occurs only when explicitly requested
-with `evaluation.scoring.fallback: "exact_match"`; fallback-scored results are
-marked and never written to the judge baseline cache.
-
-Before the first real run, you can download the configured Hugging Face base
-model into `paths.modelCache` explicitly:
+After a passing run, activation is a lightweight pointer to the existing model
+record:
 
 ```bash
-tt-local models prefetch tunedtensor.json --config local-runner.json
-tt-local models verify-base tunedtensor.json --config local-runner.json
+tt-local models activate local-<run-id>
+tt-local models active
+tt-local serve active --config local-runner.json
+tt-local models rollback
+tt-local serve base --config local-runner.json
 ```
 
-Without this step, the first non-dry `tt-local run` downloads the base model
-when baseline evaluation or training first loads it.
-
-Individual `run --stage ...` commands finish in the terminal
-`stage_completed` state, so `runs watch` exits instead of waiting for stages
-that were intentionally not requested.
+Activation re-verifies the model artifact and requires a completed run with a
+passing general-regression result. Rollback restores the previous adapter or
+the protected base; it does not copy or delete model files.
 
-Relative paths in a runner config resolve from the config file's directory.
-Relative dataset and image paths resolve from the behavior spec or request
-file's directory. The published package includes `uv.lock` so bundled Python
-dependencies are reproducible.
+The report is evidence on the selected evaluation rows, not a guarantee of
+general model improvement.
 
-## DPO
+## Use a chat JSONL dataset
 
-TT Local supports first-class offline DPO for text causal-LM models. Set
-`training_method` to `dpo` and provide a prebuilt preference JSONL training
-dataset:
+For more than a few examples, set `dataset_prebuilt` in `tunedtensor.json`:
 
 ```json
 {
-  "training_method": "dpo",
   "dataset_prebuilt": {
-    "training": "file://examples/dpo-preferences.jsonl",
-    "format": "preference_jsonl"
+    "training": "data/train.jsonl",
+    "validation": "data/validation.jsonl",
+    "format": "chat_jsonl"
   }
 }
 ```
 
-Each preference JSONL row must use explicit `prompt`, `chosen`, and `rejected`
-string fields:
+Each line is a JSON object with a `messages` array. The final message must be
+the assistant answer; preceding messages form the prompt:
 
 ```json
-{"prompt":"Summarize status: build passed.","chosen":"Build passed.","rejected":"The build failed."}
+{"messages":[{"role":"system","content":"Return one sentiment label."},{"role":"user","content":"I loved it."},{"role":"assistant","content":"positive"}]}
 ```
 
-DPO v1 is text-only for the bundled `uv` trainer. Validation and reporting still
-use the existing baseline-vs-candidate evaluation loop, so provide
-`dataset_prebuilt.test`, `dataset_prebuilt.validation`, or normal
-`spec_snapshot.examples` with reference outputs for evaluation.
+TT Local masks every prompt token from the loss and preserves the complete
+assistant answer when truncating a long example. Use a distinct validation or
+test file for trustworthy evaluation.
 
-Command-backed workflows may use external model ids by setting
-`spec_snapshot.base_model` to an `external:<id>` or `command:<id>` value, for
-example `external:karpathy/nanochat`. The bundled `uv` trainer still requires a
-supported Hugging Face base model, but command trainers receive adapter-focused
-hyperparameters without injected LoRA/model-loader defaults. Custom
-hyperparameter keys are passed through to `TT_HYPERPARAMETERS_PATH`.
-Set `hyperparameters.base_model_revision` to an immutable Hugging Face commit
-when a run must load and record an exact base-model revision.
-
-## Continuing From a Fine-Tuned Model
-
-Start another loop from an existing TT Local model by passing the stored local
-model id:
+## Serve the adapter
 
 ```bash
-tt-local run tunedtensor.json --parent-model local-<previous-run-id>
+tt-local serve local-<run-id> \
+  --spec tunedtensor.json \
+  --host 127.0.0.1 \
+  --port 8000
 ```
 
-You can also set the parent adapter artifact explicitly:
+`tt-local models serve` is an equivalent nested command. Before launch, TT
+Local re-hashes the stored artifact manifest and then loads the recorded base
+model plus PEFT adapter with the bundled Python environment.
 
 ```bash
-tt-local run tunedtensor.json --parent-model-artifact file:///path/to/model.tar.gz
+curl http://127.0.0.1:8000/health
+curl http://127.0.0.1:8000/v1/models
+curl http://127.0.0.1:8000/v1/chat/completions \
+  -H 'Content-Type: application/json' \
+  -d '{"messages":[{"role":"user","content":"Classify: I loved it."}]}'
 ```
 
-For config-only workflows, put the same value in
-`hyperparameters.parent_model_artifact`. The parent adapter becomes the
-baseline for the new run, and the bundled SFT/DPO trainers load it before
-continuing LoRA training.
+The default bind is localhost. A non-loopback bind requires `--allow-remote`
+and `--api-key-env <environment-variable>`.
 
-Stored `--parent-model` references are verified before launch. TT Local pins
-the child's base revision from the parent (or requires the same configured
-local snapshot content), rejects conflicting base identity, and fingerprints
-the parent artifact so changed bytes invalidate reuse. The explicit
-`--parent-model-artifact` form is for caller-managed local artifacts and should
-be used only when that provenance is understood.
+## Reproducibility and local data
 
-Non-Hugging Face artifacts can describe their layout in `training.artifact`:
-
-```json
-{
-  "training": {
-    "backend": "command",
-    "command": ["python", "train_adapter.py"],
-    "artifact": {
-      "framework": "nanochat",
-      "format": "custom-directory",
-      "entrypoint": "batch_command",
-      "servable": false
-    }
-  }
-}
-```
+Set `paths.modelCache` in `local-runner.json` to a durable Hugging Face cache.
+Prefetch records the resolved model commit; set
+`hyperparameters.base_model_revision` to a 40-character Hugging Face commit
+SHA when an immutable revision is required before download.
 
-## Local Development
+Run state is intentionally plain and recoverable:
 
-```bash
-npm install
-npm run typecheck
-npm test
-npm run build
+```text
+.tt-local/
+  artifacts/users/<user-id>/specs/<spec-id>/runs/<run-id>/...
+  store/specs/<spec-id>/spec.json
+  store/runs/<run-id>/{request.json,state.json,progress.jsonl,run-report.json}
+  store/models/<model-id>/model.json
 ```
 
-Release notes are in [CHANGELOG.md](CHANGELOG.md).
-
-## License
+Real training writes an `artifact-manifest.json` containing file sizes and
+SHA-256 hashes. Dry runs exercise orchestration but do not register a model.
 
-Apache-2.0
+See [docs/spark.md](docs/spark.md) for the DGX Spark workflow and
+[docs/architecture.md](docs/architecture.md) for the design boundary.

package/dist/active-model.d.ts

@@ -0,0 +1,16 @@
+import type { LocalModelRecord, LocalStore } from "./store.js";
+export interface ActiveModelPointer {
+    schema_version: 1;
+    model_id: string | null;
+    run_id: string | null;
+    previous_model_id: string | null;
+    activated_at: string;
+    action: "activate" | "rollback";
+}
+export interface ActiveModelState {
+    pointer: ActiveModelPointer | null;
+    model: LocalModelRecord | null;
+}
+export declare function getActiveModel(store: LocalStore): Promise<ActiveModelState>;
+export declare function activateModel(store: LocalStore, modelId: string): Promise<ActiveModelPointer>;
+export declare function rollbackActiveModel(store: LocalStore): Promise<ActiveModelPointer>;

package/dist/active-model.js

@@ -0,0 +1,88 @@
+import { appendFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { writeJsonAtomic } from "./artifacts.js";
+import { runReportSchema } from "./contracts.js";
+function pointerPath(store) {
+    return join(store.root, "active-model.json");
+}
+function historyPath(store) {
+    return join(store.root, "activation-history.jsonl");
+}
+async function readPointer(store) {
+    try {
+        const value = JSON.parse(await readFile(pointerPath(store), "utf8"));
+        if (value.schema_version !== 1
+            || !["activate", "rollback"].includes(value.action)
+            || (value.model_id !== null && typeof value.model_id !== "string")
+            || (value.run_id !== null && typeof value.run_id !== "string")
+            || (value.previous_model_id !== null && typeof value.previous_model_id !== "string")) {
+            throw new Error("Active model pointer has an invalid shape.");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function assertModelCanActivate(store, modelId) {
+    const model = await store.getModel(modelId);
+    const run = await store.getRun(model.run_id);
+    if (run.status !== "completed") {
+        throw new Error(`Model ${model.id} belongs to run ${run.id}, which is not completed.`);
+    }
+    const report = runReportSchema.parse(JSON.parse(await readFile(join(model.artifact_dir, "run-report.json"), "utf8")));
+    if (!report.general_regression) {
+        throw new Error(`Model ${model.id} has no general regression evaluation.`);
+    }
+    if (!report.general_regression.passed) {
+        throw new Error(`Model ${model.id} failed general regression: `
+            + (report.general_regression.failures.join(" ") || "regression budget exceeded"));
+    }
+    return model;
+}
+async function publishPointer(store, pointer) {
+    await store.ensure();
+    await writeJsonAtomic(pointerPath(store), pointer);
+    await appendFile(historyPath(store), `${JSON.stringify(pointer)}\n`, "utf8");
+    return pointer;
+}
+export async function getActiveModel(store) {
+    const pointer = await readPointer(store);
+    if (!pointer?.model_id)
+        return { pointer, model: null };
+    return { pointer, model: await store.getModel(pointer.model_id) };
+}
+export async function activateModel(store, modelId) {
+    const [model, current] = await Promise.all([
+        assertModelCanActivate(store, modelId),
+        readPointer(store),
+    ]);
+    if (current?.model_id === model.id)
+        return current;
+    return publishPointer(store, {
+        schema_version: 1,
+        model_id: model.id,
+        run_id: model.run_id,
+        previous_model_id: current?.model_id ?? null,
+        activated_at: new Date().toISOString(),
+        action: "activate",
+    });
+}
+export async function rollbackActiveModel(store) {
+    const current = await readPointer(store);
+    if (!current)
+        throw new Error("No active-model history exists to roll back.");
+    const targetId = current.previous_model_id;
+    const target = targetId ? await assertModelCanActivate(store, targetId) : null;
+    return publishPointer(store, {
+        schema_version: 1,
+        model_id: target?.id ?? null,
+        run_id: target?.run_id ?? null,
+        previous_model_id: current.model_id,
+        activated_at: new Date().toISOString(),
+        action: "rollback",
+    });
+}
+//# sourceMappingURL=active-model.js.map

package/dist/active-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-model.js","sourceRoot":"","sources":["../src/active-model.ts"],"names":[],"mappings":"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"}

package/dist/artifacts.d.ts

@@ -7,6 +7,8 @@ export interface RunArtifacts {
     trainingReportJson: string;
     baselineEvalJson: string;
     candidateEvalJson: string;
+    generalBaselineEvalJson: string;
+    generalCandidateEvalJson: string;
     runReportJson: string;
     artifactManifestJson: string;
     progressJsonl: string;
@@ -77,16 +79,15 @@ export interface ArtifactManifest {
 }
 export interface ArtifactManifestModel {
     artifact_kind: "file" | "directory";
-    format: string;
-    framework: string;
+    format: "tar.gz" | "huggingface-directory";
+    framework: "transformers-peft";
     base_model: string;
     base_model_revision?: string;
     base_model_artifact_uri?: string;
     base_model_fingerprint?: string;
-    parent_model_artifact?: string;
     artifact_uri: string;
     artifact_root: string;
-    servable: boolean;
+    servable: true;
     files: ArtifactManifestFile[];
 }
 export interface ArtifactManifestVerification {