soup-cli 0.71.33__tar.gz → 0.71.35__tar.gz

{soup_cli-0.71.33 → soup_cli-0.71.35}/CHANGELOG.md

@@ -12,6 +12,86 @@ reproducing 70+ versions of notes.
 
 ## [Unreleased]
 
+## [0.71.35] - 2026-07-15
+
+### Added
+- **Compliance templates — `soup init --template hipaa|soc2|eu-ai-act|sr-11-7`.**
+  Four regulation-shaped starting configs. Soup's compliance controls are CLI
+  flags/commands rather than config keys, so each template is a valid training
+  config plus header comments naming the exact commands for that regime
+  (PHI scrubbing + air-gap for HIPAA, BOM/attest/sign for SOC 2, Annex XI +
+  energy tracking for the EU AI Act, repro-receipt + diagnose/ship for SR 11-7).
+  Templates default to a license-clean Apache-2.0 base.
+- **`soup card <registry-id> -o MODELCARD.md` — model-card autogen.** Turns a
+  Local Model Registry entry into a publishable, provenance-carrying HF model
+  card: base model, training config, eval scorecard, config/data hashes,
+  lineage (ancestors) and a table of every registered artifact. Adapter vs
+  full-model is inferred from registered artifacts, falling back to the training
+  config (LoRA rank, with Spectrum/LISA full-FT correctly treated as dense), so
+  the card sets the right `library_name` and never misreports the model type.
+- **`soup push --card <registry-id>`** — render that registry-driven card and
+  upload it as `README.md`, overriding the auto-generated one. A bad ref fails
+  fast before any network call; HF hub only.
+- **`soup ci init` — fine-tuning CI.** Writes `.github/workflows/soup-gate.yml`,
+  a PR gate chaining `soup data validate` → `soup expect` →
+  `soup ship --evidence` (exit 2 blocks the merge). Every interpolated path is
+  validated to stay under the repo root and shell-quoted; the branch and Python
+  version are regex-gated; the write is atomic, symlink-rejecting, and refuses
+  to clobber an existing workflow without `--force`.
+- **Compliance quickstart** — a new [docs/compliance.md](docs/compliance.md)
+  walkthrough: template → PII scrub → train with receipt/Annex XI/energy →
+  registry → BOM + attestation → scan/sign/verify → air-gap → model card → CI gate.
+
+### Fixed
+- **GGUF export now actually works on Windows** (validated end-to-end against a
+  locally-built llama.cpp: SmolLM2-135M → q4_0 / q4_k_m / q8_0 / f16 → `soup deploy
+  ollama` → live inference). Four real bugs, each of which independently broke the
+  path:
+  - **`soup export --format gguf` cloned llama.cpp into your current directory.**
+    `SOUP_DIR` is the bare name `.soup`, but the lookup used it relatively rather
+    than anchoring to `~` like the rest of the codebase — so the canonical
+    `~/.soup/llama.cpp` was never found and a fresh ~200 MB checkout was dropped
+    into whatever directory you ran from.
+  - **The first GGUF export downgraded your PyTorch and broke CUDA.** The auto-clone
+    ran `pip install -r <llama.cpp>/requirements.txt` into your interpreter, and
+    llama.cpp pins `torch~=2.2.1` against the CPU wheel index (observed:
+    torch 2.5.1+cu → 2.2.2+cpu, transformers 4.57 → 4.46). Soup now installs only
+    the convert script's extra dependencies, unpinned, and never touches torch.
+  - **A correctly-built llama.cpp was not found on Windows.** MSVC (like Xcode) is a
+    multi-config generator and emits `build/bin/Release/llama-quantize.exe`; only the
+    flat single-config layout was searched.
+  - **`soup deploy ollama` failed on a relative GGUF path** with "pull model manifest:
+    file does not exist" — Ollama resolves `FROM` against the Modelfile's directory,
+    and Soup writes the Modelfile to a temp dir. The Modelfile now emits an absolute path.
+- **Model-card injection hardening (affects the pre-existing `soup push` card too).**
+  The `## Training` section interpolated `base` / `task` / `scheduler` / `recipe`
+  unescaped. Since `SoupConfig.base` and `scheduler` have no charset validator, a
+  crafted-but-valid config could smuggle raw HTML — or a backtick breaking out of
+  the surrounding code span — into a card published to the Hub. All values now go
+  through the markdown escaper, which additionally neutralises backticks and
+  strips C0/ESC control bytes.
+
+## [0.71.34] - 2026-07-15
+
+### Added
+- **`soup adapters arithmetic` — task-vector algebra over LoRA adapters (add / scale / negate).**
+  Apply task arithmetic (arXiv:2212.04089) to LoRA deltas via an expression such as
+  `"coder + 0.5*math - toxic"`, mapping names to adapter dirs with repeatable
+  `--adapter name=path`. Produces one merged adapter you can serve or merge.
+  - Signed, un-normalized element-wise combine over same-rank adapters; the effective
+    delta `ΔW = B @ A` scales **linearly** with each coefficient (negation flips the
+    delta, `0.5·` halves it) via a √|c| factor split — not the `c²` a naive sum gives.
+    Mixed-rank inputs are refused with a clear "harmonize rank" message.
+  - Reuses the backdoor-scan gate (refuses a FAIL-scanned input unless `--allow-unscanned`)
+    and a same-base-model check (`--allow-cross-base` to override). Hand-written expression
+    parser (no `eval`), cwd-contained/symlink-rejecting paths, exit 0 = ok / 1 = refusal.
+- **LISA — Layerwise Importance Sampled AdamW (arXiv:2403.17919).** Full-fine-tuning
+  quality at LoRA-like memory: every N steps LISA freezes all decoder layers except a
+  small random set (embeddings + head always trainable). Enable with
+  `training.lisa_enabled: true` (+ `lisa_num_layers`, `lisa_interval_steps`) on a
+  `task: sft`, transformers, text, `quantization: none` run; mutually exclusive with
+  LoRA features and the other freeze mechanisms. Live on a 4 GB GPU for small models.
+
 ## [0.71.33] - 2026-07-13
 
 ### Added

{soup_cli-0.71.33 → soup_cli-0.71.35}/CONTRIBUTING.md

@@ -117,10 +117,10 @@ src/soup_cli/
   data/traces/        - Trace-to-Preference harvester (v0.26.0)
   data/collators.py   - CrossDocCollator for sample packing (v0.33.0)
   utils/              - GPU, errors, MoE, GaLore, QAT, Unsloth, vLLM, SGLang, Liger, FlashAttn, FSDP, Ring Attention, long-context, quality, curriculum, freeze, dataset-registry, mlx, peft_builder, paths, topology, launcher, mii, pipeline, cut_ce, fp8, gradient_ckpt, kernel_picker, cross_doc_attn, activation_offload, hf, spec_pairing, structured_output, metrics, tracing, auto_quant, lr_finder, grad_accum, mixed_precision, warmup, spike_recovery, convergence, v028_features, multipack_sampler, multipack, neat_packing, jinja_analyzer, quant_menu, relora, peft_patches, peft_wiring, dpo_variants, optimizer_zoo, lr_groups, loftq_init, block_expansion, tts, classifier, distill, bitnet, ebft_gdpo, moe_quant, reasoning_effort, gguf_quant, kv_cache, advanced_precision, save_formats, deploy_measure, advise, advise_history, adapter_diff, adapter_merge, blame, adapter_branch, unlearning, unlearning_eval, knowledge_edit, edit_governor, edit_diff, ra_dit, steering, citation_faithful, grace_codebook, ingest_sources, prune_prompt, active_sampler, ab_test, drift_alarm, tunability, terraform_plan, env_lock, hardware_fit, completions, license_advisor, behavior_battery, capability_suite, checklist_dsl, irt, sae_diff, sleeper_probe, interference, probe_pack, cmaes_merge, vector_bank, mole_routing, adapter_pr, soup_lock, adapter_bisect, prompt_compile, prompt_distill, compile_tools, apple_adapter, local_rl, build_dag, expectations, magpie, persona_hub, brain_rot, reward_hacking, uld, minillm, rl_checkpoint, iterative_dpo, echo_trap, mod, local_rl_scheduler, spectrum_scan, ship_verdict, reward_hack_control, data_doctor, data_lint, shrink, best_of_n, evolve
-  templates/          - 17 built-in soup.yaml templates (YAML + manifest.json) with load_template loader (v0.39.0, +bco v0.40.0)
+  templates/          - 21 built-in soup.yaml templates (YAML + manifest.json) with load_template loader (v0.39.0, +bco v0.40.0, +4 compliance v0.71.35)
   ui/                 - Web UI (FastAPI + HTML/JS SPA)
 
-tests/                - Test suite (311 files, 15806 tests)
+tests/                - Test suite (313 files, 16001 tests)
 examples/             - Real-world config examples and datasets
 ```
 

{soup_cli-0.71.33 → soup_cli-0.71.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soup-cli
-Version: 0.71.33
+Version: 0.71.35
 Summary: Fine-tune and post-train LLMs in one command. No SSH, no config hell.
 Project-URL: Homepage, https://github.com/MakazhanAlpamys/Soup
 Project-URL: Repository, https://github.com/MakazhanAlpamys/Soup
@@ -193,45 +193,48 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.71.33 — `soup draft`: know whether speculative decoding is actually worth it.** Everyone tells you to bolt a draft model onto your server for a free speedup. Nobody tells you to *measure* it first. Now you can.
-
-- **`soup draft measure`.** Reports a draft's **acceptance rate** — the fraction of your target's
-  own greedy tokens the draft would have proposed correctly — plus **real plain-vs-assisted
-  tok/s**. Exit 0 / 2 (below `--min-acceptance`) / 1, so CI can gate on it.
-- **`soup draft distill`.** Distils your tuned target into a tiny draft base (logit KD over the
-  existing `task: distill` trainer) and emits a **dense** model, loadable straight as an
-  `assistant_model`.
-- **Auto-wired into serving.** Drafts land in a local registry that `soup serve --auto-spec`
-  consults *before* the built-in pairing table — so a draft you trained yourself just gets used.
-- **What the measurement actually told us (honestly).** On `SmolLM2-360M-Instruct` ←
-  `SmolLM2-135M-Instruct`: the stock draft already scored **69.3%**, and distilling it changed
-  nothing (69.7% at 2 epochs, 69.3% at 10). Assisted decoding was a **net slowdown** (0.55–0.64×).
-  A small same-family draft is already at its ceiling. **That negative result is the feature
-  working** — it's the number you want *before* you ship speculative decoding, not after.
-  Whether distillation pays off on a larger or genuinely diverged pair is unproven on a 4 GB box.
+**v0.71.35 — the compliance pack.** Ship a regulated fine-tune with the paperwork it needs: start from a regulation-shaped config, publish a provenance-carrying model card, and gate every PR in CI.
+
+- **`soup init --template hipaa|soc2|eu-ai-act|sr-11-7`.** Four regulation-shaped starting
+  configs, each documenting the exact commands for that regime — PHI scrubbing + air-gap,
+  BOM/attest/sign, EU Annex XI + energy tracking, or repro-receipt + diagnose/ship.
+- **`soup card <registry-id>` → `MODELCARD.md`.** Turn a registry entry into a publishable HF
+  model card: training config, eval scorecard, config/data hashes, lineage, and every
+  registered artifact. `soup push --card` uploads it as the README, so every public push
+  carries its provenance.
+- **`soup ci init` — fine-tuning CI.** Writes a GitHub Actions gate that runs
+  `data validate` → `expect` → `ship --evidence` on each PR; a regression exits 2 and
+  blocks the merge.
+- **Compliance quickstart** ([docs/compliance.md](docs/compliance.md)) — the whole path from
+  template to air-gapped, signed, attested, carded model.
+- **GGUF export fixed on Windows.** Validated end-to-end for the first time (SmolLM2 →
+  q4_0/q4_k_m/q8_0/f16 → Ollama → live inference), which surfaced four real bugs: the export
+  cloned llama.cpp into your *current directory*, its first run **downgraded your PyTorch to
+  CPU-only** (breaking CUDA), a correctly-built llama.cpp wasn't found under MSVC, and
+  `deploy ollama` rejected relative GGUF paths. All fixed.
+- **Hardening:** the model-card generator (including the existing `soup push` card) no longer
+  interpolates unescaped config values — a crafted `base`/`scheduler` can't smuggle HTML into
+  a card published on the Hub.
 
 ```bash
-soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
-  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
+soup adapters arithmetic "coder - toxic" \
+  --adapter coder=./coder-lora --adapter toxic=./toxic-lora -o ./cleaned
+
+soup train --config sft.yaml   # with training.lisa_enabled: true, lisa_num_layers: 2
 ```
 
 <details>
-<summary>Previous release — v0.71.32, ASR fine-tuning (Whisper)</summary>
+<summary>Previous release — v0.71.33, <code>soup draft</code> (measure speculative decoding)</summary>
 
-Fine-tune Whisper on your accent or domain, locally: `task='asr'` (`AsrTrainerWrapper` over HF
-`Seq2SeqTrainer` + `WhisperProcessor`), `soup infer --task asr` with per-row + corpus **WER/CER**,
-pure-python metrics in `soup_cli.utils.asr_metrics`, and 4 new recipes (catalog 138 → 142).
-whisper-tiny (39M) / base (74M) train on a 4 GB GPU.
+`soup draft measure` reports a draft model's **acceptance rate** + real plain-vs-assisted tok/s
+(exit 0/2/1 for CI); `soup draft distill` distils your target into a dense tiny draft, auto-wired
+into `soup serve --auto-spec`. The honest result on a small same-family pair: distillation didn't
+move acceptance (69.3% → 69.3%) and assisted decoding was a net slowdown — which is exactly the
+number you want *before* shipping speculative decoding.
 
-```yaml
-base: openai/whisper-tiny
-task: asr
-data:
-  format: asr            # rows: {"audio": "clip.wav", "text": "hello world"}
-  audio_dir: ./data/audio
-training:
-  asr_language: en
-  asr_lora: true         # optional; default = full fine-tune
+```bash
+soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
+  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
 ```
 
 </details>
@@ -315,7 +318,7 @@ The full feature reference lives in [`docs/`](docs/). Start here:
 | [Performance & quantization](docs/performance-and-quantization.md) | QAT, FP8, Quant Menu (I + II), KV-cache, NVFP4, save formats, Cut Cross-Entropy, gradient checkpointing, kernels, activation offloading, multi-GPU / DeepSpeed / FSDP |
 | [Data engineering](docs/data.md) | Formats, the Axolotl/LF-parity pipeline, data tools, synthetic generation & forge, quality scorecards, trace tooling, remote datasets, mixing, recipe DAGs |
 | [Evaluation & probes](docs/evaluation.md) | Eval design/gate, eval-gated training, benchmarks, NLG metrics, calibration, Elo arena, diagnose, post-train X-ray probes, A/B, drift, tunability, `soup advise` |
-| [Serving & export](docs/serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding, deploy autopilot, Web UI, Agent Forge |
+| [Serving & export](docs/serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding (train + measure your own draft), deploy autopilot, Web UI, Agent Forge |
 | [Adapters, registry & governance](docs/adapters-and-governance.md) | Adapter lifecycle/management, model registry, Soup Cans, the data flywheel (`soup loop`), knowledge editing, steering, supply-chain controls (scan/sign/BOM/attest/audit/airgap) |
 | [Backends, platform & ops](docs/backends-and-ops.md) | MLX/Unsloth backends, alternative hubs, HF Hub integration, autopilot, experiment tracking, plan/apply, env lockfiles, hardware-fit, completions, plugins, utility commands |
 | [Command reference](docs/commands.md) | The full `soup` command list |

{soup_cli-0.71.33 → soup_cli-0.71.35}/README.md

@@ -49,45 +49,48 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.71.33 — `soup draft`: know whether speculative decoding is actually worth it.** Everyone tells you to bolt a draft model onto your server for a free speedup. Nobody tells you to *measure* it first. Now you can.
-
-- **`soup draft measure`.** Reports a draft's **acceptance rate** — the fraction of your target's
-  own greedy tokens the draft would have proposed correctly — plus **real plain-vs-assisted
-  tok/s**. Exit 0 / 2 (below `--min-acceptance`) / 1, so CI can gate on it.
-- **`soup draft distill`.** Distils your tuned target into a tiny draft base (logit KD over the
-  existing `task: distill` trainer) and emits a **dense** model, loadable straight as an
-  `assistant_model`.
-- **Auto-wired into serving.** Drafts land in a local registry that `soup serve --auto-spec`
-  consults *before* the built-in pairing table — so a draft you trained yourself just gets used.
-- **What the measurement actually told us (honestly).** On `SmolLM2-360M-Instruct` ←
-  `SmolLM2-135M-Instruct`: the stock draft already scored **69.3%**, and distilling it changed
-  nothing (69.7% at 2 epochs, 69.3% at 10). Assisted decoding was a **net slowdown** (0.55–0.64×).
-  A small same-family draft is already at its ceiling. **That negative result is the feature
-  working** — it's the number you want *before* you ship speculative decoding, not after.
-  Whether distillation pays off on a larger or genuinely diverged pair is unproven on a 4 GB box.
+**v0.71.35 — the compliance pack.** Ship a regulated fine-tune with the paperwork it needs: start from a regulation-shaped config, publish a provenance-carrying model card, and gate every PR in CI.
+
+- **`soup init --template hipaa|soc2|eu-ai-act|sr-11-7`.** Four regulation-shaped starting
+  configs, each documenting the exact commands for that regime — PHI scrubbing + air-gap,
+  BOM/attest/sign, EU Annex XI + energy tracking, or repro-receipt + diagnose/ship.
+- **`soup card <registry-id>` → `MODELCARD.md`.** Turn a registry entry into a publishable HF
+  model card: training config, eval scorecard, config/data hashes, lineage, and every
+  registered artifact. `soup push --card` uploads it as the README, so every public push
+  carries its provenance.
+- **`soup ci init` — fine-tuning CI.** Writes a GitHub Actions gate that runs
+  `data validate` → `expect` → `ship --evidence` on each PR; a regression exits 2 and
+  blocks the merge.
+- **Compliance quickstart** ([docs/compliance.md](docs/compliance.md)) — the whole path from
+  template to air-gapped, signed, attested, carded model.
+- **GGUF export fixed on Windows.** Validated end-to-end for the first time (SmolLM2 →
+  q4_0/q4_k_m/q8_0/f16 → Ollama → live inference), which surfaced four real bugs: the export
+  cloned llama.cpp into your *current directory*, its first run **downgraded your PyTorch to
+  CPU-only** (breaking CUDA), a correctly-built llama.cpp wasn't found under MSVC, and
+  `deploy ollama` rejected relative GGUF paths. All fixed.
+- **Hardening:** the model-card generator (including the existing `soup push` card) no longer
+  interpolates unescaped config values — a crafted `base`/`scheduler` can't smuggle HTML into
+  a card published on the Hub.
 
 ```bash
-soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
-  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
+soup adapters arithmetic "coder - toxic" \
+  --adapter coder=./coder-lora --adapter toxic=./toxic-lora -o ./cleaned
+
+soup train --config sft.yaml   # with training.lisa_enabled: true, lisa_num_layers: 2
 ```
 
 <details>
-<summary>Previous release — v0.71.32, ASR fine-tuning (Whisper)</summary>
+<summary>Previous release — v0.71.33, <code>soup draft</code> (measure speculative decoding)</summary>
 
-Fine-tune Whisper on your accent or domain, locally: `task='asr'` (`AsrTrainerWrapper` over HF
-`Seq2SeqTrainer` + `WhisperProcessor`), `soup infer --task asr` with per-row + corpus **WER/CER**,
-pure-python metrics in `soup_cli.utils.asr_metrics`, and 4 new recipes (catalog 138 → 142).
-whisper-tiny (39M) / base (74M) train on a 4 GB GPU.
+`soup draft measure` reports a draft model's **acceptance rate** + real plain-vs-assisted tok/s
+(exit 0/2/1 for CI); `soup draft distill` distils your target into a dense tiny draft, auto-wired
+into `soup serve --auto-spec`. The honest result on a small same-family pair: distillation didn't
+move acceptance (69.3% → 69.3%) and assisted decoding was a net slowdown — which is exactly the
+number you want *before* shipping speculative decoding.
 
-```yaml
-base: openai/whisper-tiny
-task: asr
-data:
-  format: asr            # rows: {"audio": "clip.wav", "text": "hello world"}
-  audio_dir: ./data/audio
-training:
-  asr_language: en
-  asr_lora: true         # optional; default = full fine-tune
+```bash
+soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
+  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
 ```
 
 </details>
@@ -171,7 +174,7 @@ The full feature reference lives in [`docs/`](docs/). Start here:
 | [Performance & quantization](docs/performance-and-quantization.md) | QAT, FP8, Quant Menu (I + II), KV-cache, NVFP4, save formats, Cut Cross-Entropy, gradient checkpointing, kernels, activation offloading, multi-GPU / DeepSpeed / FSDP |
 | [Data engineering](docs/data.md) | Formats, the Axolotl/LF-parity pipeline, data tools, synthetic generation & forge, quality scorecards, trace tooling, remote datasets, mixing, recipe DAGs |
 | [Evaluation & probes](docs/evaluation.md) | Eval design/gate, eval-gated training, benchmarks, NLG metrics, calibration, Elo arena, diagnose, post-train X-ray probes, A/B, drift, tunability, `soup advise` |
-| [Serving & export](docs/serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding, deploy autopilot, Web UI, Agent Forge |
+| [Serving & export](docs/serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding (train + measure your own draft), deploy autopilot, Web UI, Agent Forge |
 | [Adapters, registry & governance](docs/adapters-and-governance.md) | Adapter lifecycle/management, model registry, Soup Cans, the data flywheel (`soup loop`), knowledge editing, steering, supply-chain controls (scan/sign/BOM/attest/audit/airgap) |
 | [Backends, platform & ops](docs/backends-and-ops.md) | MLX/Unsloth backends, alternative hubs, HF Hub integration, autopilot, experiment tracking, plan/apply, env lockfiles, hardware-fit, completions, plugins, utility commands |
 | [Command reference](docs/commands.md) | The full `soup` command list |

{soup_cli-0.71.33 → soup_cli-0.71.35}/docs/README.md

@@ -12,8 +12,9 @@ feature reference — every `soup` capability, grouped by area.
 | [Performance & quantization](performance-and-quantization.md) | QAT, FP8, Quant Menu (I + II), KV-cache, NVFP4, save formats, Cut Cross-Entropy, gradient checkpointing, kernels, activation offloading, multi-GPU / DeepSpeed / FSDP |
 | [Data engineering](data.md) | Formats, the Axolotl/LF-parity pipeline, data tools, synthetic generation & forge, quality scorecards, trace tooling, remote datasets, mixing, recipe DAGs |
 | [Evaluation & probes](evaluation.md) | Eval design/gate, eval-gated training, benchmarks, NLG metrics, calibration, Elo arena, diagnose, `soup ship` verdict, post-train X-ray probes, A/B, drift, tunability, `soup advise` |
-| [Serving & export](serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding, deploy autopilot, Web UI, Agent Forge |
+| [Serving & export](serving-and-export.md) | OpenAI-compatible server, batch inference, benchmarking, merge/export, Anthropic Messages endpoint, speculative decoding (train + measure your own draft), deploy autopilot, Web UI, Agent Forge |
 | [Adapters, registry & governance](adapters-and-governance.md) | Adapter lifecycle/management, model registry, Soup Cans, the data flywheel (`soup loop`), knowledge editing, steering, supply-chain controls |
+| [Compliance & governance quickstart](compliance.md) | HIPAA/SOC2/EU-AI-Act/SR-11-7 `init` templates, provenance (BOM/attest/repro-receipt), audit log, air-gap, model-card autogen (`soup card`), CI gate (`soup ci init`) |
 | [Backends, platform & ops](backends-and-ops.md) | MLX/Unsloth backends, Modal cloud GPU training, alternative hubs, HF Hub integration, autopilot, experiment tracking, plan/apply, env lockfiles, hardware-fit, completions, plugins, utility commands |
 | [Command reference](commands.md) | The full `soup` command list |
 | [Supported models & extras](models.md) | Recommended model families, the VRAM size guide, the pip extras matrix |

{soup_cli-0.71.33 → soup_cli-0.71.35}/docs/adapters-and-governance.md

@@ -270,6 +270,12 @@ soup adapters merge ./run-v17 ./run-v18 ./run-v19 -o ./merged --strategy ties \
 soup adapters merge ./run-v17 ./run-v18 -o ./merged --strategy dare \
   --density 0.5 --seed 42
 
+# Task-vector arithmetic (v0.71.34) — add / scale / NEGATE trained behaviours
+# into one adapter (arXiv:2212.04089). Names map to dirs via --adapter name=path.
+soup adapters arithmetic "coder + 0.5*math - toxic" \
+  --adapter coder=./coder-lora --adapter math=./math-lora \
+  --adapter toxic=./toxic-lora -o ./blended
+
 # Leave-one-out ablation plan against a 4-hour wall-clock budget
 soup adapters blame ./run-v18 --dataset train.jsonl --layer q_proj.7 \
   --budget 4h --shards 10 --plan-only
@@ -314,6 +320,8 @@ soup adapters branches
 
 **v0.71.4:** the merge verdict is now LIVE — `soup adapters merge … --canary suite.json` lifts the `MergeReport.verdict` `UNKNOWN` stub. A pre-scored `{"baseline_scores","candidate_scores"}` suite classifies the blend OK / MINOR / MAJOR with no model load; a `{"tasks":[...]}` suite uses an injectable scorer. `--strict-verdict` exits 2 on MAJOR. The backdoor-scan and license-conflict gates now run for **every** strategy, including `cmaes`. `soup adapters branch <name> --from-registry <id>` / `--attach-to-registry <id>` link training-env snapshots into the Registry lineage DAG (shown as a `branches` node in `soup history`).
 
+**v0.71.34 — task-vector arithmetic.** `soup adapters arithmetic "<expr>"` applies task arithmetic (arXiv:2212.04089) to LoRA deltas: **add** (blend two skills), **scale** (`2*coder`), and — the differentiator — **negate** (`- toxic` removes a behaviour). Names in the expression map to adapter dirs via repeatable `--adapter name=path`. The math is done at the effective-delta level: a LoRA contributes `ΔW = B·A`, so the coefficient is applied so that `ΔW` scales **linearly** (subtracting an adapter actually negates its delta — a naïve element-wise sum would scale by `c²`, making negation a no-op). Adapters must share the base model (`--allow-cross-base` to override) and rank (mixed ranks are refused, not silently approximated). Each input passes the v0.71.2 backdoor-scan gate (`--allow-unscanned` to skip). Output is a single loadable adapter; exit 0 = ok, 1 = refusal.
+
 
 ## Soup Cans (Shareable Recipes)
 

{soup_cli-0.71.33 → soup_cli-0.71.35}/docs/commands.md

@@ -8,6 +8,7 @@
 
 ```
 soup init [--template chat|code|...|audio]       Create config
+soup init --template hipaa|soc2|eu-ai-act|sr-11-7  Compliance-shaped starting config + the commands for that regime (v0.71.35)
 soup autopilot --model <id> --data d.jsonl --goal <g>  Zero-configsoup train --config soup.yaml                 Start training
 soup train --config soup.yaml --tensorboard   Train with TensorBoard logging
 soup train --config soup.yaml --fsdp full_shard  Train with FSDP2
@@ -27,6 +28,7 @@ soup merge --adapter ./output                 Merge LoRA with base model
 soup merge-sharded-fsdp-weights ./shards -o merged.safetensors  Consolidate FSDP shards into one safetensors (v0.71.14; --plan-only previews)
 soup delinearize-llama4 ./src --target ./out [--num-experts N] [--plan-only]  Live Llama-4 fused-expert reshape [E*din,dout] -> [E,din,dout] + sidecar copy (v0.71.21)
 soup spectrum scan --model <id|path> --top-percent 50 [--modules mlp,attn] [-o patch.yaml]  Spectrum SNR scan (no model load) -> training.unfrozen_parameters YAML patch (v0.71.23)
+soup train --config sft.yaml  # training.lisa_enabled: true [lisa_num_layers lisa_interval_steps]  LISA layerwise importance sampling — full-FT quality at LoRA-like memory (sft/transformers/text/quantization=none) (v0.71.34)
 soup export --model ./output --format gguf    Export to GGUF (Ollama)
 soup export --model ./output --deploy ollama  Export GGUF + auto-deploy to Ollama
 soup export --model ./output --format onnx    Export to ONNX
@@ -158,6 +160,9 @@ soup ship --evidence ev.json [--output v.json]  Decide offline from pre-computed
 soup ship ... --task-mode judge_score --judge-model ollama://llama3.1  Leg-1 via LLM-as-a-judge
 soup ship ... --task-mode pairwise --judge-model ollama://llama3.1  Leg-1 via swap-debiased judge win-rate (base=0.5) (v0.71.31)
 soup ship ... --general-suite mmlu,gsm8k --baseline base.json  lm-eval leg-2 + recorded base scores
+soup card <registry-id> -o MODELCARD.md       HF model card from a registry entry: training config, evals, hashes, lineage, artifacts (v0.71.35)
+soup push --model ./out --repo you/m --card <registry-id>  Upload that registry-driven card as the README (HF only) (v0.71.35)
+soup ci init [--data d.jsonl --suite s.yaml --evidence ev.json] [--branch main --python 3.11] [--force]  Write .github/workflows/soup-gate.yml: data validate -> expect -> ship gate on every PR (v0.71.35)
 soup mcp serve                                MCP server over stdio (drive Soup from Claude Code / Cursor / Cline; requires [mcp] extra) (v0.71.28)
 soup mcp serve --allow-mutating               Also expose plan-only train_start / export tools (never execute) (v0.71.28)
 soup shrink --model <id|path> --drop-ratio 0.25 --calib c.jsonl -o shrunk  Depth-prune least-important layer block + SHIP/DON'T-SHIP ppl verdict (exit 0/2/1) (v0.71.29)
@@ -184,6 +189,7 @@ soup adapters sign <adapter> [--backend unsigned|ed25519] [--key <pem>|--generat
 soup adapters verify <adapter> [--strict] [--public-key <pem>]  Verify manifest + ed25519 signature
 soup adapters check-safetensors <adapter> [--strict]  Refuse pickle / PyTorch-classic weights
 soup adapters merge ... [--license <id>] [--license-override <reason>] [--allow-unscanned]  License + backdoor-scan gates (auto-detect license; scan FAIL refused)
+soup adapters arithmetic "coder + 0.5*math - toxic" --adapter coder=<p> --adapter math=<p> --adapter toxic=<p> -o <out> [--allow-unscanned --allow-cross-base]  Task-vector algebra over LoRA adapters (add/scale/negate; same-rank; scan + same-base gated) (v0.71.34)
 soup attest emit ... [--sign ed25519 --key <pem>] [-o att.json]  in-toto/SLSA-3 attestation (+ .sig sidecar)
 soup attest verify <statement> --signature <sig> [--public-key <pem>]  Verify ed25519 attestation signature
 soup airgap-bundle --model <m> --output <out.tar> [--repro-receipt <r.json>]  Signed tarball for data-diode transfer (embeds repro-receipt)

soup_cli-0.71.35/docs/compliance.md

@@ -0,0 +1,136 @@
+# Compliance & governance quickstart
+
+[← Back to the docs index](README.md)
+
+Soup ships an end-to-end compliance workflow: start from a regulation-shaped
+config, train with provenance capture, sign + attest the artifact, keep an audit
+trail, and move it across an air gap — then publish a documented model card and
+gate future changes in CI.
+
+- **Pre-wired configs:** `soup init --template hipaa|soc2|eu-ai-act|sr-11-7`
+- **Provenance:** `soup train --repro-receipt` · `soup bom emit` · `soup attest emit`
+- **Integrity:** `soup adapters sign` / `verify` · `soup adapters scan`
+- **Audit trail:** the HIPAA/SOC2 audit log is on by default (`soup audit-log tail`)
+- **Air gap:** `soup airgap-bundle`
+- **Publish:** `soup card <registry-id>` → `MODELCARD.md` (or `soup push --card`)
+- **CI gate:** `soup ci init` → a PR workflow that runs validate → expect → ship
+
+---
+
+## 1. Start from a compliance template
+
+Each template is a normal training config plus header comments listing the exact
+compliance commands to run around it. Pick the regime you operate under:
+
+```bash
+soup init --template hipaa      # Protected Health Information
+soup init --template soc2       # SOC 2 Trust Services Criteria
+soup init --template eu-ai-act  # EU AI Act Annex XI/XII
+soup init --template sr-11-7    # SR 11-7 Model Risk Management
+```
+
+The compliance controls are Soup **CLI flags/commands, not config keys** — the
+template header documents which ones apply. The steps below are the common path.
+
+## 2. Clean the data before training
+
+```bash
+soup data pii ./data/train.jsonl            # flag emails / phones / SSNs / MRNs
+soup data decontaminate ./data/train.jsonl  # drop public-benchmark overlap
+```
+
+## 3. Train with a reproducibility receipt (+ Annex XI / energy for the EU)
+
+```bash
+# SR 11-7 / SOC 2 / HIPAA: capture seeds, kernels, GPU, OS
+soup train --config soup.yaml --repro-receipt receipt.json
+
+# EU AI Act: auto-generate the Annex XI/XII documentation + measure energy
+soup train --config soup.yaml \
+    --annex-xi annex_xi.md \
+    --track-energy --energy-country DEU --energy-out energy.json
+```
+
+The audit log records every command automatically:
+
+```bash
+soup audit-log tail          # review the trail
+soup audit-log rotate        # force a rotation pass
+```
+
+## 4. Register the run, then emit BOM + attestation
+
+```bash
+soup registry push --run-id <run-id> --name my-model --tag v1
+
+soup bom emit --name my-model --base-sha <hex> --config-sha <hex> \
+    --energy energy.json --format both       # CycloneDX + SPDX
+soup attest emit --stage train --subject my-model --sha <hex> \
+    --sign ed25519 --key key.pem             # in-toto + SLSA-3
+```
+
+## 5. Sign, scan, and verify the artifact
+
+```bash
+soup adapters scan ./output                              # weight-space backdoor scan
+soup adapters sign ./output --backend ed25519 --generate-key key.pem
+soup adapters verify ./output --strict --public-key key.pub.pem
+```
+
+## 6. Air-gap transfer (optional)
+
+```bash
+soup airgap-bundle --model ./output --output my-model.tar --repro-receipt receipt.json
+```
+
+## 7. Generate a documented model card
+
+Turn the registry entry into a provenance-rich `MODELCARD.md` — base model,
+training config, eval scorecard, config/data hashes, lineage, and every
+registered artifact:
+
+```bash
+soup card my-model:v1 -o MODELCARD.md
+# or, when uploading to the Hub, override the auto-generated card:
+soup push --model ./output --repo you/my-model --card my-model:v1
+```
+
+## 8. Gate future changes in CI
+
+Write a GitHub Actions workflow that blocks a PR unless the data validates, the
+expectations suite passes, and the SHIP verdict is green:
+
+```bash
+soup ci init --data data/train.jsonl --suite expectations.yaml --evidence ship_evidence.json
+# writes .github/workflows/soup-gate.yml
+```
+
+The generated job runs, in order:
+
+```
+soup data validate <data>       # dataset format compliance
+soup expect <data> <suite>      # PII / token-length / refusal / judge expectations
+soup ship --evidence <ev.json>  # SHIP / DON'T-SHIP (exit 2 blocks the merge)
+```
+
+A minimal `expectations.yaml` for the second step:
+
+```yaml
+expectations:
+  - name: expect_no_pii
+  - name: expect_token_length_between
+    min_tokens: 1
+    max_tokens: 512
+```
+
+Supported names: `expect_no_pii`, `expect_token_length_between`,
+`expect_no_refusal_pattern`, `expect_chosen_preferred_over_rejected_by_judge`.
+
+Every path is shell-quoted and validated to stay under the repo root, so the
+rendered workflow is injection-safe. Edit the paths to match your repo.
+
+---
+
+See also: [Adapters, registry & governance](adapters-and-governance.md) for the
+full supply-chain command set, and [Evaluation & probes](evaluation.md) for the
+`soup ship` verdict engine.

{soup_cli-0.71.33 → soup_cli-0.71.35}/docs/peft-and-efficiency.md

@@ -380,6 +380,25 @@ training:
 
 Works with and without LoRA. When used with LoRA, LoRA is applied only to unfrozen layers.
 
+## LISA — Layerwise Importance Sampling (v0.71.34)
+
+LISA (Layerwise Importance Sampled AdamW, [arXiv:2403.17919](https://arxiv.org/abs/2403.17919)) targets full-fine-tuning quality at LoRA-like memory. Instead of picking layers once (that's Spectrum's static `unfrozen_parameters`), LISA re-samples a small random set of decoder layers **every N steps** and freezes the rest; the input embeddings, the LM head, and the final norm stay trainable throughout.
+
+```yaml
+task: sft
+backend: transformers
+modality: text
+training:
+  quantization: none      # LISA is full-FT of the active layers
+  lisa_enabled: true
+  lisa_num_layers: 2       # decoder layers active per interval (clamped to model depth)
+  lisa_interval_steps: 20  # re-sample cadence, in global steps
+```
+
+Because only a handful of layers train at any moment (and their optimizer state is cleared when they're re-frozen), peak optimizer memory is roughly `embeddings + head + lisa_num_layers` — far below a full fine-tune, while every layer still gets updated over the course of training. LISA is `sft` + `transformers` + `text` + `quantization: none` only, and is mutually exclusive with LoRA features, `freeze_layers`/`freeze_ratio`, and Spectrum's `unfrozen_parameters` (each independently decides what trains).
+
+Implementation note: the model is left fully trainable at trainer-setup time so HF's optimizer (built before the first callback fires) contains every decoder parameter; the LISA callback then toggles `requires_grad` per interval — frozen parameters produce no gradient and the optimizer skips them.
+
 
 ## Loss Watchdog
 

{soup_cli-0.71.33 → soup_cli-0.71.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soup-cli"
-version = "0.71.33"
+version = "0.71.35"
 description = "Fine-tune and post-train LLMs in one command. No SSH, no config hell."
 readme = "README.md"
 license = "Apache-2.0"

{soup_cli-0.71.33 → soup_cli-0.71.35}/src/soup_cli/__init__.py

@@ -1,3 +1,3 @@
 """Soup CLI — Fine-tune and post-train LLMs in one command."""
 
-__version__ = "0.71.33"
+__version__ = "0.71.35"

{soup_cli-0.71.33 → soup_cli-0.71.35}/src/soup_cli/cli.py

@@ -21,7 +21,9 @@ from soup_cli.commands import (  # noqa: E402
     autopilot,
     bench,
     can,
+    card,
     chat,
+    ci,
     cost,
     data,
     deploy,
@@ -98,6 +100,8 @@ app.command()(cost.cost)
 app.command()(push.push)
 app.command(name="export")(export.export)
 app.command()(merge.merge)
+app.command(name="card")(card.card)
+app.add_typer(ci.app, name="ci", help="Fine-tuning CI: init a PR gate workflow.")
 app.add_typer(
     data.app, name="data",
     help="Dataset tools: inspect, convert, merge, dedup, validate, stats.",