Render a LoRA training config YAML and write it to the project config/ directory.

Emit the huggingface-cli download command for a base model (dry_run — no network).

Generate a pinned requirements.txt for the given fine-tuning framework.

Initialise the project directory tree and project.json in the workspace.

Apply a named template preset (config + requirements) to a project.

Validate and persist an abstract data schema (no real content).

Check a JSONL file against a schema — returns keys/types/lengths only, never values.

Sanitize a dataset file via pattern-based masking and write an .anon copy.

Render a seeded train/val/test split Python script from template.

Generate n deterministic synthetic rows (10-50) matching the project data schema and write as JSONL.

Render Dockerfile.train and emit/execute docker build command (dry-run unless local_python+docker configured).

Run docker build + internal pytest tests for an image (dry-run unless local_python+docker configured).

Render train.py and optionally run a micro-train loop (dry-run unless FTOS_LOCAL_PYTHON set).

Parse metrics from the last synthetic run (outputs/metrics.json).

Check which deployment env vars are present/missing (names only — never secret values).

Suggest hyperparameter adjustments from local training metrics.

Generate pytest unit-test stubs for critical training-script functions.

Push a Docker image to the configured registry (dry-run unless FTOS_REGISTRY configured).

Produce docker run / compose command using env NAME references only — never secret values.

Launch remote training via SSH (dry-run unless FTOS_SSH_* configured).

Fetch and sanitize remote training logs via SSH (dry-run unless FTOS_SSH_* configured).

Aggregate loss/lr/gpu time-series from sanitized remote logs via SSH.

Detect divergence, NaN, plateau, and data-leak signs from sanitized logs/metrics.

Pause or resume a remote training job via SSH (dry-run unless FTOS_SSH_* configured).

Evaluate early-stop (patience + min_delta) over a loss history.

Fetch checkpoint metadata (step, loss…) without downloading weights (dry-run unless FTOS_SSH_* configured).

Run a deterministic eval over synthetic data to verify the pipeline — no real data required.

Run eval on the client validation set via SSH (dry-run unless FTOS_SSH_* configured).

Compute BLEU, ROUGE-1/2/L, perplexity, accuracy, macro-F1 from preds and refs — pure, offline.

Emit a Python harness to generate sample predictions on synthetic prompts — pure, offline.

Compute per-metric deltas between fine-tuned and baseline and render a Markdown comparison table.

Heuristic bias/fairness scan over template prompts across given categories — deterministic, offline.

Static AST analysis of Python source — flag network imports/calls without executing code.

Parse a Dockerfile and flag: root user, unpinned images, secrets in ENV/ARG, network fetches.

Scan logs/artifacts for sensitive data leakage — reports counts by category, never raw values.

Look up base-model license and commercial-use compatibility from the in-module registry.

Aggregate security audit results into a Markdown (+ optional PDF) report for a project.

Sanitize text or a log file via pattern masking — returns the sanitized body and masked count.

Emit the LoRA merge command (base + adapter → merged 16-bit) — dry_run unless FTOS_LOCAL_PYTHON configured.

Emit the quantization command for GGUF/GPTQ/AWQ — dry_run unless FTOS_LOCAL_PYTHON configured.

Render Dockerfile.infer and emit docker build command — dry_run unless local docker configured.

Produce inference server config (port, api key NAME ref, context, limits) — no secrets embedded.

Send test requests to a running inference container — dry_run curl unless base_url provided.

AES-256-GCM encrypt deliverable file(s); key returned ONCE in data, never persisted.

Upload encrypted deliverable over SFTP — dry_run unless FTOS_SFTP_* configured.

Render delivery note with file list + SHA256 each + decryption procedure.

Render a French-law service contract (Code civil, CPI, RGPD art. 28) as Markdown + optional PDF.

Render a bilateral NDA (secret des affaires — Code de commerce L151-1 s.) as Markdown.

Render a performance report with metrics, baseline comparison, and curves description.

Render an inference API user guide (endpoints, code examples, parameters).

Render an IT deployment guide for the inference container.

Render an irreversible data destruction certificate (RGPD art. 17, 5-1-c, 32).

Convert a Markdown document to PDF — skips gracefully if weasyprint absent.

Apply a local detached signature (SHA-256 + timestamp) as a .sig sidecar file.

Onboard a new client: collect company info and create the project workspace.

Render a status update and deliver via SMTP or Slack webhook (dry-run if neither configured).

Propose meeting slots via Calendly API (dry-run if FTOS_CALENDLY_TOKEN not configured).

Append a timestamped event to the project events.jsonl log.

Create a formal approval request (status='pending') persisted in project state.

Render an invoice from prestation lines as Markdown + optional PDF.

Detect performance drift in a time-ordered metric history — pure, deterministic.

Recommend retraining from production signals (drift, new data volume, staleness) — pure.

Update the base model repo/revision in the project config and produce a diff — pure, no network.

Update the MCP server from a secure Git remote via git pull (dry-run if FTOS_GIT_REMOTE not set).

Report Fine-Tuning OS server health: version, workspace path, and which external targets are configured (booleans only — never secrets).