Skip to content
Skills Library
Data & analytics · Automation

fs-data

/fs-data

User-invoked slash command: run ONLY when the user types /fs-data; never choose it on your own. Slash-command data preparation workflow (/fs-data) that composes the model skill data_engine to turn raw data refs into a dataset, data_pipeline_spec and readiness_report. Inputs: the data_engine request fields (sources, target_format, tokenizer, chat_template_family, out_dir, requirements, pipeline, reasoning_unsupported, benchmarks, ...) passed through unchanged, plus optional goal_spec (a path recorded in outputs, not interpreted). The workflow record says which step ran, what it produced and the

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

User-invoked slash command: run ONLY when the user types /fs-data; never choose it on your own. Slash-command data preparation workflow (/fs-data) that composes the model skill data_engine to turn raw data refs into a dataset, data_pipeline_spec and readiness_report. Inputs: the data_engine request fields (sources, target_format, tokenizer, chat_template_family, out_dir, requirements, pipeline, reasoning_unsupported, benchmarks, ...) passed through unchanged, plus optional goal_spec (a path recorded in outputs, not interpreted). The workflow record says which step ran, what it produced and the

Original author description

User-invoked slash command: run ONLY when the user types /fs-data; never choose it on your own. Slash-command data preparation workflow (/fs-data) that composes the model skill data_engine to turn raw data refs into a dataset, data_pipeline_spec and readiness_report. Inputs: the data_engine request fields (sources, target_format, tokenizer, chat_template_family, out_dir, requirements, pipeline, reasoning_unsupported, benchmarks, ...) passed through unchanged, plus optional goal_spec (a path recorded in outputs, not interpreted). The workflow record says which step ran, what it produced and the

How it works

  1. Purpose
  2. When to use
  3. Inputs
  4. Outputs
  5. Scope
  6. Validation rules
  7. Failure handling
  8. FS interface
  9. Worked examples
Original SKILL.md headings · 107 lines, 922 words
SKILL.md preview
---
name: fs-data
license: MIT
description: "User-invoked slash command: run ONLY when the user types /fs-data; never choose it on your own. Slash-command data preparation workflow (/fs-data) that composes the model skill data_engine to turn raw data refs into a dataset, data_pipeline_spec and readiness_report. Inputs: the data_engine request fields (sources, target_format, tokenizer, chat_template_family, out_dir, requirements, pipeline, reasoning_unsupported, benchmarks, ...) passed through unchanged, plus optional goal_spec (a path recorded in outputs, not interpreted). The workflow record says which step ran, what it produced and the verdict (PASS/RED/UNMEASURED). Do NOT use for explaining fskills results (use /fs-status), fixing data problems yourself, or training a model (use /fs-training): this composes data_engine and produces data artifacts only."
compatibility: "Needs Python>=3.10 and the foundationskills package (fskills CLI). It requires no FoundationScale: it composes the model skill data_engine through the composition helper (_workflow) and writes one workflow_record artifact. (requires_fs is False)."
metadata:
  version: "0.1.0"
  invocation: "user"
  fs_status_doctrine: "PASS/RED/UNMEASURED/REFUSED (exit 0/5/95/96)"
  when_to_use: '["use fs-data to run the data preparation workflow","call fs-data to prepare a training dataset from raw data sources","run /fs-data to validate my data sources and generate a dataset","create a data pipeline and check readiness via fs-data","data_engine composed through fs-data to build a dataset with a readiness report"]'
---

# fs-data — the data preparation workflow composer (/fs-data)

## Purpose

The data-preparation workflow: `/fs-data` composes the model skill `data_engine` through the
composition helper (`_workflow`) to turn raw data refs (`sources`) into a training dataset,
`data_pipeline_spec` and `readiness_report`. The caller provides the `data_engine` request fields
(passed through unchanged) plus an optional `goal_spec` path. The skill writes exactly one
`workflow_record` artifact whose payload says which step ran, what it produced (by path), and the
verdict (PASS, RED or UNMEASURED). A user skill composes model skills (here `data_engine`), never
another user skill. Do NOT use for explaining fskills results (use `/fs-status`), fixing data problems
yourself, or launching a training run (use `/fs-training`): this composes `data_engine` to produce
data artifacts only.

## When to use

- "Use fs-data to run the data preparation workflow for my raw data on S3" / "Run /fs-data to validate
  my data sources and generate a dataset".
- To compose `data_engine` to build a dataset from raw data refs, with a data_pipeline_spec and
  readiness_report as outputs.
- To run the data preparation step with a `goal_spec` path (recorded in outputs, not interpreted) and
  know the verdict (PASS ready for training; RED fix and re-run; UNMEASURED readiness checks not run).
- Not for explaining fskills results (use `/fs-status`), fixing data problems yourself, or training a
  model (use `/fs-training`): compose `data_engine` here, act there.

## Inputs

| Field | Required | Meaning |
|---|---|---|
| `sources` | one of `sources` / `pipeline` | list of data source URIs (e.g. `s3://...`, `local:/...`) |
| `target_format` | no | the target data format (e.g. `sft`, `preference`, `chat`) |
| `tokenizer` | no | tokenizer name or path |
| `chat_template_family` | no | chat template to apply |
| `out_dir` | no | output directory for the dataset |
| `requirements` | no | extra data requirements |
| `pipeline` | one of `sources` / `pipeline` | explicit pipeline definition (object) |
| `reasoning_unsupported` | no | flag for reasoning data handling |
| `benchmarks` | no | benchmark references |
| `goal_spec` | no | path to a goal spec (recorded in outputs, not interpreted) |

## Outputs

One `workflow_record` artifact (typed, schema-validated, with provenance) whose payload is:
`workflow` (the slash name `"fs_data"`), `steps` (a list of `Step` rows: `{skill, status, exit_code,
refusal, artifacts, findings}`), `outputs` (`{"dataset": path|None, "readiness_report": path|None,
"data_pipeline_spec": path|None, "goal_spec": path|None}` — artifacts referenced BY PATH, never
copied), and `verdict` (`"PASS"`, `"RED"` or `"UNMEASURED"`). Exit codes: 0 PASS, 5 RED (FD-HO-001),
95 UNMEASURED (FD-HO-002 as WARN), 96 REFUSED (FD-IN-001 or FD-IN-002); nothing is written for
REFUSED.

## Scope

The full FoundationSkills data catalogue: any model type, family and stage. Composes exactly one
model skill (`data_engine`); writes one `workflow_record` artifact; requires no FoundationScale.
A user skill composes model skills (`data_engine`), never another user skill.

## Validation rules

Outcome semantics (from `core/contract.py`, the same for every skill): an **input**-phase BLOCK
refuses before any work — status REFUSED, exit 96, nothing written. A **handoff**-phase BLOCK turns
the output to RED, exit 5. WARN findings never block; they travel with the result. Phase by prefix:
FD-IN-* rules are input phase, FD-HO-* rules are handoff phase.

| Rule | Severity | Fires when |
|---|---|---|
| FD-IN-001 | BLOCK | no `sources` and no explicit `pipeline` is given → REFUSED 96 |
| FD-IN-002 | BLOCK | the composed `data_engine` refused (e.g. unknown target_format, missing local source) → REFUSED 96 |
| FD-HO-001 | BLOCK | `data_engine` came back RED (e.g. zero records, readiness RED) → RED 5 |
| FD-HO-002 | WARN | `data_engine` came back UNMEASURED (readiness checks not run) → UNMEASURED 95 (WARN finding; never PASS) |

The composed model skill `data_engine` has its own rules (DE-IN-001..DE-IN-008, DE-HO-001..DE-HO-003)
that govern its own run; those rule ids are not returned here — inner findings travel as step evidence
in the workflow record and the FD-HO-001 / FD-HO-002 findings.

## Failure handling

- No `sources` and no explicit `pipeline`: REFUSED (96) naming FD-IN-001; nothing is written. Pass
  `sources` or `pipeline` and re-run.
- `data_engine` refused: REFUSED (96) naming FD-IN-002; fix the data_engine findings or refusal it
  names (e.g. unknown target_format DE-IN-002, missing local source DE-IN-003) and re-run.
- `data_engine` came back RED: RED (5) naming FD-HO-001 (e.g. zero records, readiness RED). Fix the
  data_engine findings and re-run; never treat a RED dataset as ready for training.
- `data_engine` came back UNMEASURED: UNMEASURED (95) with FD-HO-002 WARN finding (readiness checks
  not run). Resolve the readiness issues and re-run; never treat UNMEASURED as PASS.
- This skill composes and explains only. On the owning data_engine's failure, call that skill's
  `diagnose()`; do not improvise a fix here.

## FS interface

Composes `data_engine` through `_workflow` (run_step, outcome_class, registry, Step) to turn raw data
refs into a dataset with a readiness report. (`fskills data` entry point.) Never imports or launches
FoundationScale; writes one `workflow_record` artifact and touches no cluster resource. `requires_fs`
is False: on a host with only the `foundationskills` package installed it still composes `data_engine`
and records the workflow. On a host where even the `foundationskills` package is missing, report
REFUSED with the install step (`pip install -e <FoundationScale repo>/FoundationSkills`) and never
improvise a data preparation run.

## Worked examples

- `fs-data {"sources": ["s3://bucket/train.jsonl"], "target_format": "sft"}` — runs `data_engine` on
  the S3 source, produces `dataset` (JSONL), `data_pipeline_spec` and `readiness_report`, and returns a
  `workflow_record` with verdict PASS (data is ready).
- `fs-data {"pipeline": {"raw_data_ref": "local:/data/*.parquet"}}` — runs `data_engine` with an
  explicit pipeline definition, no `sources` required.
- `fs-data {}` — REFUSED 96 (FD-IN-001): no `sources` and no `pipeline` given.

Versions

The database has no other skills named fs-data.

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 89642f5d513b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100fs-eval
    User-invoked slash command: run ONLY when the user types /fs-eval; never choose it on your own. /fs-eval is the A3.2 user-invoked workflow skill: it takes the evaluation request (checkpoint, run_manifest, base, benchmarks, policy, eval_cache, out, baseline_cache, ...) and…
  • 100fs-launch
    User-invoked slash command: run ONLY when the user types /fs-launch; never choose it on your own. Slash-command launch gate (/fs-launch) for FoundationSkills and THE ONLY launch path: takes an fs_launch_spec artifact path plus the plan hash the USER typed back (user_plan_hash),…
  • 100pilot-data-labeling-pipeline-setup
    Deploy a data labeling pipeline with 4 agents for ingestion, auto-labeling, quality review, and dataset export. Use this skill when: 1. User wants to set up a data labeling or annotation pipeline 2. User is configuring an agent as part of a labeling workflow 3. User asks about…
  • 100generate-data-set-context
    Use this skill when the user wants to explore a dataset's context, or write or update documentation for the data it holds. Triggers include: 'explore this data set', 'document this data flow', 'generate dataset documentation', 'update data set context', 'what's in this dataset',…
  • 100data-designer
    Use when the user wants to create a dataset, generate synthetic data, or build a data generation pipeline. The argument is the description of the dataset to generate.
  • 100create-command
    Create a new slash command for Claude Code. Guides the user through defining the command name, what it does, and generates the markdown file in .claude/commands/. Use when the user says 'create a command', 'new command', 'add a slash command', 'I want a shortcut for', or wants…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.