@tuned-tensor/local 0.2.9 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 All notable changes to TT Local will be documented in this file.
 
+## Unreleased
+
+## 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,146 @@
 [![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
-```
-
-The bundled SFT, DPO, and Transformers evaluator path also needs `uv`:
-
-```bash
-uv --version
-```
-
-Custom training or evaluation workflows can use command entrypoints instead of
-`uv`.
+## Requirements
 
-The default uv project is included in the npm package at
-`training/local-runner`; using bundled training does not require cloning this
-repository.
+- 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
 
-## 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
-```
-
-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.
-
-Then preflight the exact Python environments and paths that the run will use:
-
-```bash
-tt-local doctor tunedtensor.json --config local-runner.json
-tt-local validate tunedtensor.json --config local-runner.json
-```
-
-`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.
-
-Download the base model explicitly, then start the run:
-
-```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
+npm install -g @tuned-tensor/local
+tt-local info
 ```
 
-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.
+## Fine-tune a model
 
-For a long run, start it in the background and watch it from the current or a
-second terminal:
+Create a project on the GPU host:
 
 ```bash
-tt-local run tunedtensor.json --config local-runner.json --detach
-tt-local runs watch <run-id> --config local-runner.json
+mkdir support-adapter && cd support-adapter
+tt-local init --name "Support Adapter" --model Qwen/Qwen3.5-2B --profile spark
 ```
 
-The detached command returns the persisted run ID, process ID, log path, and
-copy-paste watch/cancel commands before model work begins.
+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.
 
-Inspect the evidence after the run:
+Preflight the machine, input, and cached base model:
 
 ```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 doctor tunedtensor.json
+tt-local validate tunedtensor.json
+tt-local models prefetch tunedtensor.json
+tt-local models verify-base tunedtensor.json
 ```
 
-Treat the report as evidence on this run's evaluation cases, not as a
-guarantee of live application improvement.
-
-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
-```
+Commands discover `local-runner.json` beside the spec. Use
+`--config /path/to/local-runner.json` to select another config explicitly.
 
-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:
+Run the complete base-evaluate, train, tuned-evaluate, and report workflow:
 
 ```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"}]}'
+tt-local run tunedtensor.json
 ```
 
-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:
+Inspect the evidence and verify the adapter:
 
 ```bash
-tt-local models prefetch tunedtensor.json --config local-runner.json
-tt-local models verify-base tunedtensor.json --config local-runner.json
+tt-local runs report <run-id>
+tt-local models verify local-<run-id>
 ```
 
-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.
+The report is evidence on the selected evaluation rows, not a guarantee of
+general model improvement.
 
-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.
+## Use a chat JSONL dataset
 
-## DPO
-
-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.
-
-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.
+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.
 
-## 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`:
+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.
 
-```json
-{
-  "training": {
-    "backend": "command",
-    "command": ["python", "train_adapter.py"],
-    "artifact": {
-      "framework": "nanochat",
-      "format": "custom-directory",
-      "entrypoint": "batch_command",
-      "servable": false
-    }
-  }
-}
-```
+Run state is intentionally plain and recoverable:
 
-## Local Development
-
-```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/artifacts.d.ts

@@ -77,16 +77,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 {

package/dist/artifacts.js

@@ -167,7 +167,6 @@ const MANIFEST_IGNORED_PATHS = new Set([
     // records the next stage event or refreshes the canonical request copy.
     "progress.jsonl",
     "request.json",
-    "detached.log",
     RUN_OWNER_FILE,
     ARTIFACT_WORKFLOW_LOCK_FILE,
 ]);
@@ -243,6 +242,13 @@ function assertManifestFiles(value, label) {
         paths.add(manifestPath);
     }
 }
+function hasPeftAdapterFiles(files) {
+    const names = new Set(files
+        .filter((file) => file.size_bytes > 0)
+        .map((file) => file.path.split("/").at(-1)?.toLowerCase()));
+    return (names.has("adapter_config.json")
+        && (names.has("adapter_model.safetensors") || names.has("adapter_model.bin")));
+}
 function parseArtifactManifest(value) {
     if (!value || typeof value !== "object")
         throw new Error("Artifact manifest must be an object.");
@@ -253,11 +259,25 @@ function parseArtifactManifest(value) {
     assertManifestFiles(candidate.files, "file");
     if (candidate.model) {
         const model = candidate.model;
+        const allowedModelKeys = new Set([
+            "artifact_kind",
+            "format",
+            "framework",
+            "base_model",
+            "base_model_revision",
+            "base_model_artifact_uri",
+            "base_model_fingerprint",
+            "artifact_uri",
+            "artifact_root",
+            "servable",
+            "files",
+        ]);
         const hasBaseArtifact = model.base_model_artifact_uri !== undefined;
         const hasBaseFingerprint = model.base_model_fingerprint !== undefined;
-        if ((model.artifact_kind !== "file" && model.artifact_kind !== "directory")
-            || typeof model.format !== "string"
-            || typeof model.framework !== "string"
+        if (Object.keys(model).some((key) => !allowedModelKeys.has(key))
+            || (model.artifact_kind !== "file" && model.artifact_kind !== "directory")
+            || (model.format !== "tar.gz" && model.format !== "huggingface-directory")
+            || model.framework !== "transformers-peft"
             || typeof model.base_model !== "string"
             || (model.base_model_revision !== undefined && typeof model.base_model_revision !== "string")
             || (model.base_model_artifact_uri !== undefined && typeof model.base_model_artifact_uri !== "string")
@@ -265,13 +285,17 @@ function parseArtifactManifest(value) {
             || hasBaseArtifact !== hasBaseFingerprint
             || typeof model.artifact_uri !== "string"
             || typeof model.artifact_root !== "string"
-            || typeof model.servable !== "boolean"
-            || (model.parent_model_artifact !== undefined && typeof model.parent_model_artifact !== "string")
+            || model.servable !== true
             || !Array.isArray(model.files)
-            || model.files.length === 0) {
+            || model.files.length === 0
+            || (model.artifact_kind === "file" && model.format !== "tar.gz")
+            || (model.artifact_kind === "directory" && model.format !== "huggingface-directory")) {
             throw new Error("Artifact manifest contains invalid model contract metadata.");
         }
         assertManifestFiles(model.files, "model file");
+        if (model.artifact_kind === "directory" && !hasPeftAdapterFiles(model.files)) {
+            throw new Error("PEFT model manifest requires adapter weights and adapter_config.json.");
+        }
     }
     return candidate;
 }
@@ -280,6 +304,12 @@ export async function writeArtifactManifest(artifacts, options = {}) {
     const paths = await listArtifactFiles(artifacts.runDir);
     let model;
     if (options.model) {
+        if (options.model.framework !== "transformers-peft"
+            || options.model.servable !== true
+            || (options.model.artifact_kind === "file" && options.model.format !== "tar.gz")
+            || (options.model.artifact_kind === "directory" && options.model.format !== "huggingface-directory")) {
+            throw new Error("TT Local model artifacts must be verified, servable Transformers PEFT adapters.");
+        }
         if ((options.model.base_model_artifact_uri === undefined)
             !== (options.model.base_model_fingerprint === undefined)) {
             throw new Error("Model contracts must record a local base-model URI and fingerprint together.");
@@ -289,25 +319,26 @@ export async function writeArtifactManifest(artifacts, options = {}) {
             ? [portableRelative(dirname(modelRoot), modelRoot)]
             : await listArtifactFiles(modelRoot);
         const checksumRoot = options.model.artifact_kind === "file" ? dirname(modelRoot) : modelRoot;
-        if (options.model.artifact_kind === "file"
-            && (options.model.format === "tar.gz" || modelRoot.endsWith(".tar.gz"))) {
+        if (options.model.artifact_kind === "file") {
+            if (!modelRoot.toLowerCase().endsWith(".tar.gz")) {
+                throw new Error(`PEFT file artifacts must be .tar.gz archives: ${modelRoot}`);
+            }
             const archive = await verifyTarGzipArchive(modelRoot);
-            if ((options.model.framework === "transformers-peft" || options.model.servable)
-                && archive.adapter_weight_entries === 0) {
+            if (archive.adapter_weight_entries === 0 || archive.adapter_weight_bytes === 0) {
                 throw new Error(`PEFT model archive contains no adapter_model.safetensors or adapter_model.bin: ${modelRoot}`);
             }
-            if ((options.model.framework === "transformers-peft" || options.model.servable)
-                && archive.adapter_config_entries === 0) {
+            if (archive.adapter_config_entries === 0) {
                 throw new Error(`PEFT model archive contains no adapter_config.json: ${modelRoot}`);
             }
-            if (options.model.framework === "transformers-full" && archive.full_model_weight_entries === 0) {
-                throw new Error(`Full-model archive contains no Transformers model weights: ${modelRoot}`);
-            }
+        }
+        const modelFiles = await Promise.all(modelPaths.map((path) => describeArtifactFile(checksumRoot, path)));
+        if (options.model.artifact_kind === "directory" && !hasPeftAdapterFiles(modelFiles)) {
+            throw new Error(`PEFT model directory requires adapter weights and adapter_config.json: ${modelRoot}`);
         }
         model = {
             ...options.model,
             artifact_root: modelRoot,
-            files: await Promise.all(modelPaths.map((path) => describeArtifactFile(checksumRoot, path))),
+            files: modelFiles,
         };
     }
     const manifest = {
@@ -377,26 +408,23 @@ export async function verifyArtifactManifest(manifestPath, options = {}) {
             const expectedModelPaths = new Set(manifest.model.files.map((file) => file.path));
             unexpected.push(...modelActualPaths.filter((path) => !expectedModelPaths.has(path)).map((path) => `model:${path}`));
         }
-        if (manifest.model.artifact_kind === "file"
-            && (manifest.model.format === "tar.gz" || modelRoot.endsWith(".tar.gz"))) {
+        if (manifest.model.artifact_kind === "file") {
             try {
                 const archive = await verifyTarGzipArchive(modelRoot);
-                if ((manifest.model.framework === "transformers-peft" || manifest.model.servable)
-                    && archive.adapter_weight_entries === 0) {
+                if (archive.adapter_weight_entries === 0 || archive.adapter_weight_bytes === 0) {
                     changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:missing_adapter_weights`);
                 }
-                if ((manifest.model.framework === "transformers-peft" || manifest.model.servable)
-                    && archive.adapter_config_entries === 0) {
+                if (archive.adapter_config_entries === 0) {
                     changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:missing_adapter_config`);
                 }
-                if (manifest.model.framework === "transformers-full" && archive.full_model_weight_entries === 0) {
-                    changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:missing_full_model_weights`);
-                }
             }
             catch {
                 changed.push(`model:${portableRelative(checksumRoot, modelRoot)}:invalid_archive`);
             }
         }
+        else if (!hasPeftAdapterFiles(await Promise.all(modelActualPaths.map((path) => describeArtifactFile(checksumRoot, path))))) {
+            changed.push("model:missing_peft_adapter");
+        }
     }
     return {
         valid: missing.length === 0 && changed.length === 0 && unexpected.length === 0,
@@ -564,13 +592,7 @@ export async function verifyTarGzipArchive(path) {
             const recognizedPayload = Boolean(name)
                 && name !== "training_args.bin"
                 && (name.endsWith(".safetensors")
-                    || name.endsWith(".bin")
-                    || name.endsWith(".pt")
-                    || name.endsWith(".pth")
-                    || name.endsWith(".gguf")
-                    || name.endsWith(".onnx")
-                    || name.endsWith(".ckpt")
-                    || name.endsWith(".npz"));
+                    || name.endsWith(".bin"));
             const adapterWeight = name === "adapter_model.safetensors" || name === "adapter_model.bin";
             const fullModelWeight = Boolean(name)
                 && ((name.endsWith(".safetensors") && !name.startsWith("adapter_"))