@evolvingmachines/evolve 0.0.65 → 0.0.67-train-harness-wave-2026-09-25.20260926.e00a8a6d

package/skills/evolve-evals/references/core-concepts/trials.md

@@ -0,0 +1,129 @@
+---
+title: "Trials"
+description: "Inspect one agent's attempt: what it did, what it earned, and why it stopped."
+---
+
+A **trial** is one attempt at one task by one agent arm. Its ID works on its own; you do not need to supply the parent job ID.
+
+Use an ID from `evolve job trials "$JOB_ID"` as `$TRIAL_ID`:
+
+```bash
+evolve trial show "$TRIAL_ID"
+```
+
+## Follow the attempt
+
+```text
+1. QUEUED
+   Wait for dispatch
+         ↓
+2. RUNNING
+   Prepare → build → boot
+   → install → run the agent
+         ↓
+3. SCORING
+   Run the verifier
+         ↓
+4. Settle
+   Record reward, exception,
+   spend, and files
+```
+
+This is the normal execution path. A trial can stop earlier with an error, budget refusal, or cancellation. `attempt_phase` distinguishes slow preparation from agent work or verification.
+
+## Statuses
+
+| Status | What it tells you |
+| --- | --- |
+| `QUEUED` | Waiting to run. |
+| `RUNNING` | Execution is in progress. Check `attempt_phase`. |
+| `SCORING` | The verifier is evaluating the result. |
+| `SCORED` | A valid reward map was recorded. Zero is a real score. |
+| `SCORING_ERROR` | The verifier output was invalid or verification failed. |
+| `INFRASTRUCTURE_ERROR` | Infrastructure prevented a reliable result. Eligible failures may retry. |
+| `BUDGET` | An account, team, or platform budget refused execution. |
+| `INDETERMINATE` | No reliable scoring outcome was recorded. |
+| `CANCELLED` | The trial was stopped. |
+
+**Note:**
+
+A missing reward is not zero. A multi-key reward map without a primary reward can be `SCORED` while the scalar `reward` is null; inspect `verifier_result.rewards`.
+
+### Find the cause
+
+| Read | Use it for |
+| --- | --- |
+| `exception_info` | Failure type and explanation. |
+| `attempt_phase` | The current stage of execution. |
+| `n_retries` and `retries` | Automatic retries and earlier outcomes. |
+| `sandbox_provider_degrade` | Why the actual provider differs from the requested one. |
+| `step_results` | Per-step outcomes for a multi-step task. |
+
+For `BUDGET`, restore the relevant credits or budget before [resuming the job](/core-concepts/jobs#derive-a-new-job).
+
+## The trace
+
+The trace shows the prompt, messages, tool calls, and results. Search one trial or the whole job:
+
+```bash
+evolve trial trace "$TRIAL_ID"
+evolve trial trace "$TRIAL_ID" --grep 'permission denied' --tail 50
+evolve job grep "$JOB_ID" 'permission denied'
+```
+
+| Filter | Meaning |
+| --- | --- |
+| `--type` | Exact event type. |
+| `--grep` | Case-insensitive regular expression. |
+| `--tail` | Last N matching events. |
+| `--cursor` | Continue after an event position. |
+| `--json` | Full events, one JSON object per line. |
+
+`trial trace` reads the stored events available now. It does not stay connected for future events. Use the [dashboard viewer](/dashboard/trial-viewer) for an updating trace.
+
+## Spend
+
+| Field | Reading |
+| --- | --- |
+| `live_spent_usd` | Spend so far while running; a lower bound. |
+| `agent_result.cost_usd` | Recorded agent spend after settlement. |
+| `spend_source` | Whether the reading is final or provisional. |
+| `judge_result` | Verifier judge spend and usage. |
+| `usage` | Gateway token and cost accounting. |
+
+`measured` is final. `measured_provisional` can increase. `assumed_cap` means spend was not measured; its stored zero is a placeholder, not proof of a free run.
+
+## Artifacts
+
+```bash
+evolve trial download "$TRIAL_ID" --stream verifier
+evolve trial download "$TRIAL_ID" --stream trace-atif
+```
+
+The verifier log explains grading. The ATIF trajectory provides a portable conversation record. Raw stdout, stderr, and captured agent-home files are also available.
+
+## Download the trial tree
+
+```bash
+evolve trial download "$TRIAL_ID" -o trials/
+```
+
+The CLI saves `trials/<trial-id>/`. See [Trial outputs](/core-concepts/trial-outputs#the-trial-directory) for the tree and the difference from a full job archive.
+
+## Act on one trial
+
+| Command | Result |
+| --- | --- |
+| `evolve trial retry "$TRIAL_ID"` | New job that reruns this settled trial. |
+| `evolve trial regrade "$TRIAL_ID"` | New job that reruns only an eligible verifier. |
+| `evolve trial stop "$TRIAL_ID"` | Stop this live trial; leave its job running. |
+
+Retry and regrade create new records. They do not replace the source result. Read [eligibility and selection rules](/core-concepts/jobs#derive-a-new-job) before using them.
+
+**[Trial outputs](/core-concepts/trial-outputs)**
+
+Files, traces, and the captured filesystem.
+
+**[Trial reference](/cli-reference/trial)**
+
+Every inspection and control command.

package/skills/evolve-evals/references/core-concepts/upload-sdk-session.md

@@ -0,0 +1,240 @@
+---
+title: "Upload an SDK run"
+description: "Turn a recorded agent run into a job you can inspect and analyze."
+---
+
+An SDK session records the conversation. An evaluation job holds trials and their results. Package the recorded run as a trial to use job inspection and analysis.
+
+Already have a Harbor job folder? [Upload it directly](/core-concepts/upload). To share an SDK session without creating a job, use [session sharing](/cli-reference/session#share-a-session).
+
+### 1. Find the local session log
+
+Both SDKs write local JSONL logs on the machine running the SDK:
+
+```text
+~/.evolve-sdk/
+└── observability/sessions/
+    └── <session>.jsonl
+```
+
+```bash
+ls -lt ~/.evolve-sdk/observability/sessions/*.jsonl
+```
+
+Choose the file for your run. Its first `_meta` record contains the agent, model, session tag, and timestamp. `_prompt.text` records the input.
+
+**Note:**
+
+Use a fresh Codex or Claude instance with one foreground `run()`, no resumed context, and no shell commands. After it returns `exitCode: 0`, call `kill()` to close and flush the log.
+
+A dashboard trace download contains parsed events, not the local harness stream. Do not pass it to this example.
+
+### 2. Package one recorded run
+
+Save the script below as `pack-sdk-run.py`. It uses Python's standard library and works with local logs from either SDK.
+
+```bash
+python3 pack-sdk-run.py \
+  --session "$HOME/.evolve-sdk/observability/sessions/<session>.jsonl" \
+  --task my-task \
+  --out ./sdk-job
+```
+
+Replace the session filename and task name. Use the actual task key if you plan to link a dataset.
+
+```text
+sdk-job/
+├── config.json                   Job name
+├── result.json                   Stable source ID
+└── my-task__sdk/
+    ├── result.json               Trial metadata and scores
+    └── agent/
+        ├── trajectory.json       Recorded opening prompt
+        └── .codex/sessions/…     Original Codex log
+```
+
+For Claude, the original log goes under `agent/.claude/projects/sdk-upload/` instead.
+
+| Source | Destination |
+| --- | --- |
+| `_meta.agent` and `_meta.model` | `agent_info` |
+| `_prompt.text` | First user step in `trajectory.json` |
+| Original session file | Recognized harness transcript path |
+| Optional verifier scores | Recorded trial rewards |
+
+### Copy the packaging script
+
+```python
+import argparse
+import hashlib
+import json
+import math
+import re
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--session", type=Path, required=True)
+parser.add_argument("--task", required=True)
+parser.add_argument("--out", type=Path, required=True)
+parser.add_argument("--rewards", type=Path)
+args = parser.parse_args()
+
+def stop(message):
+    parser.error(message)
+
+if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", args.task):
+    stop("Use the task directory name: letters, digits, dots, _ or -.")
+raw = args.session.expanduser().read_bytes()
+records = []
+for line in raw.decode("utf-8").splitlines():
+    try:
+        record = json.loads(line)
+    except json.JSONDecodeError:
+        continue  # Keep non-JSON output in the original file.
+    if isinstance(record, dict):
+        records.append(record)
+
+metadata = [r["_meta"] for r in records if "_meta" in r]
+prompts = [r["_prompt"] for r in records if "_prompt" in r]
+if len(metadata) != 1 or len(prompts) != 1:
+    stop("Use a local log with one SDK run; do not combine runs or commands.")
+if not any("_sessionEnd" in r for r in records):
+    stop("Finish the run and call kill() before packaging its log.")
+meta, prompt = metadata[0], prompts[0]
+if not isinstance(meta, dict) or not isinstance(prompt, dict):
+    stop("Expected local SDK metadata and prompt records.")
+harness = meta.get("agent")
+if harness not in ("codex", "claude"):
+    stop("This example supports local Codex and Claude SDK logs.")
+if not isinstance(prompt.get("text"), str) or not prompt["text"]:
+    stop("The log has no recorded prompt text.")
+if harness == "codex":
+    completed = sum(r.get("type") == "turn.completed" for r in records)
+    failed = any(r.get("type") == "turn.failed" for r in records)
+    if completed != 1 or failed:
+        stop("Expected one successfully completed Codex turn.")
+else:
+    outcomes = [r for r in records if r.get("type") == "result"]
+    if len(outcomes) != 1 or outcomes[0].get("is_error") is not False:
+        stop("Expected one successful Claude result.")
+
+rewards = None
+if args.rewards:
+    rewards = json.loads(args.rewards.read_text())
+    if not isinstance(rewards, dict) or not rewards or not all(
+        isinstance(v, (int, float)) and not isinstance(v, bool)
+        and math.isfinite(v) for v in rewards.values()
+    ):
+        stop("Rewards must be a nonempty JSON object of recorded numeric scores.")
+
+source_id = str(uuid.uuid5(
+    uuid.NAMESPACE_URL, hashlib.sha256(raw).hexdigest() + ":" + args.task
+))
+trial_name = args.task + "__sdk"
+agent_info = {"name": harness, "version": ""}
+if meta.get("model"):
+    agent_info["model_info"] = {"name": meta["model"]}
+result = {
+    "task_name": args.task, "trial_name": trial_name, "trial_uri": "",
+    "task_id": {}, "task_checksum": "", "config": {},
+    "agent_info": agent_info,
+}
+if rewards is not None:
+    result["verifier_result"] = {"rewards": rewards}
+trajectory = {
+    "schema_version": "ATIF-v1.7", "session_id": meta["tag"],
+    "agent": {"name": harness, "version": ""},
+    "steps": [{"step_id": 1, "source": "user", "message": prompt["text"]}],
+    "notes": "Opening SDK prompt; agent activity is in the native transcript.",
+}
+if harness == "codex":
+    date = datetime.fromisoformat(meta["timestamp"].replace("Z", "+00:00"))
+    native = Path(".codex/sessions") / date.strftime("%Y/%m/%d") / f"rollout-{source_id}.jsonl"
+else:
+    native = Path(".claude/projects/sdk-upload") / f"{source_id}.jsonl"
+
+args.out.mkdir(parents=True, exist_ok=False)
+trial = args.out / trial_name
+destination = trial / "agent" / native
+destination.parent.mkdir(parents=True)
+destination.write_bytes(raw)
+for path, value in (
+    (args.out / "config.json", {"job_name": args.out.name}),
+    (args.out / "result.json", {"id": source_id}),
+    (trial / "result.json", result),
+    (trial / "agent/trajectory.json", trajectory),
+):
+    path.write_text(json.dumps(value, indent=2) + "\n")
+print(f"Ready to upload: {args.out}")
+print("Recorded scores included." if rewards is not None else "No score supplied.")
+```
+
+Have verifier results? Add `--rewards ./recorded-rewards.json`, containing the verifier's numeric score map. Without it, the import has **no score**. Finishing an agent run does not prove that the task passed.
+
+The script preserves the transcript. It does not collect sandbox files or infer costs, errors, or rewards. Add any recorded deliverables under `artifacts/`, verifier logs under `verifier/`, and known result fields using the [job layout](/core-concepts/upload#what-result-json-must-hold).
+
+### 3. Upload the job folder
+
+```bash
+evolve upload ./sdk-job
+```
+
+If the run used a task from a published dataset, link it by task name:
+
+```bash
+evolve upload ./sdk-job -d my-dataset@1.0
+```
+
+Choose one command. The CLI waits for the import and prints its job ID. Uploading the same packaged run twice is refused.
+
+### 4. Inspect the imported run
+
+Set `$JOB_ID` to the returned ID:
+
+```bash
+evolve job show "$JOB_ID"
+evolve job trials "$JOB_ID"
+```
+
+Set `$TRIAL_ID` to a trial ID from that list, then read its trace:
+
+```bash
+evolve trial trace \
+  "$TRIAL_ID"
+```
+
+Check that the trial has the expected task, agent, model, prompt, and agent activity. Read the import report for skipped trials or missing task links. Then analyze it:
+
+```bash
+evolve analyze \
+  "$JOB_ID" \
+  --watch
+```
+
+Uploaded jobs support analysis. They cannot be resumed, retried, or regraded.
+
+## Other session formats
+
+### A failed or interrupted run
+
+Failed runs can also be uploaded. Use the same [job layout](/core-concepts/upload#what-result-json-must-hold), preserve the transcript, and include the recorded `exception_info` when available. The example script stops when a successful harness completion is missing; closing a session alone does not prove completion.
+
+Do not invent a reward or an exception from missing data. Without a recorded score or recognized failure, the imported trial is `INDETERMINATE`.
+
+### A session with several runs or commands
+
+A session is not automatically one trial. Choose the completed agent run and its task before packaging. SDK `_prompt` records can mark runs or shell commands; they do not identify which kind occurred.
+
+Separate each evaluation attempt using the original call history and its transcript. Preserve any earlier conversation the attempt depended on. The example refuses combined logs because splitting on `_prompt` alone can misrepresent the run.
+
+### A system prompt, another harness, or a dashboard download
+
+Use a complete **ATIF trajectory** at `agent/trajectory.json` when the source is not a recognized native transcript. ATIF is the [shared trajectory format](/core-concepts/trial-outputs#the-atif-trajectory).
+
+The SDK logger does not add the configured `systemPrompt` to its header. If you retained it, include its actual text as a `system` step in the complete trajectory. Do not reconstruct an unknown prompt.
+
+When a recognized native transcript produces parsed events, Evolve uses those events and the opening user prompt; it does not merge in the rest of ATIF. To use your complete ATIF instead, keep original evidence under `agent/source/`, outside the recognized transcript paths.
+
+A dashboard session download contains parsed session events. Convert those records to ATIF rather than renaming the file as a Codex or Claude native transcript.

package/skills/evolve-evals/references/core-concepts/upload.md

@@ -0,0 +1,166 @@
+---
+title: "Upload a job"
+description: "Bring existing Harbor-format results into Evolve for inspection, analysis, and sharing."
+---
+
+Upload results you already ran elsewhere. Evolve imports the records; it does not rerun the evaluation.
+
+Have an SDK session log? Follow [Upload an SDK run](/core-concepts/upload-sdk-session) to find it, package one run, and inspect the imported trace.
+
+```bash
+evolve upload ./my-job -d harbor-examples@1.0
+```
+
+| Source | Command |
+| --- | --- |
+| Job directory | `evolve upload ./my-job` |
+| Compressed archive | `evolve upload ./my-job.tar.gz` |
+| Public HTTPS archive | `evolve upload --from https://example.org/my-job.tar.gz` |
+
+The CLI waits for import by default. Use `--no-wait` to return the import ID immediately, then follow it:
+
+```bash
+evolve job import "$IMPORT_ID" --watch
+```
+
+## What a job folder holds
+
+A Harbor job directory can be uploaded directly. It requires `config.json` and `result.json` at the root, plus `result.json` in each trial folder.
+
+```text
+my-job/
+├── config.json
+├── result.json
+└── <trial-name>/
+    ├── result.json
+    ├── lock.json
+    ├── agent/
+    │   ├── trajectory.json
+    │   ├── stdout.log
+    │   └── ...
+    ├── verifier/
+    ├── artifacts/
+    └── steps/
+```
+
+| Optional trial files | Content |
+| --- | --- |
+| `lock.json` | Task-content identity. |
+| `agent/trajectory.json` | ATIF trace. |
+| `agent/stdout.log` | Process output. |
+| Other `agent/` files | Native sessions and other files. |
+| `verifier/` | Verifier logs and rewards. |
+| `artifacts/` | Collected outputs. |
+| `steps/` | Multi-step results. |
+
+Missing optional data stays missing. An imported trial without a trace does not acquire a synthetic trace.
+
+## What `result.json` must hold
+
+This is a minimal illustrative trial record with a reward. Replace the task, agent, model, and result with the facts of your run.
+
+```json
+{
+  "task_name": "hello-world",
+  "trial_name": "hello-world__attempt-1",
+  "trial_uri": "",
+  "task_id": {},
+  "task_checksum": "",
+  "config": {},
+  "agent_info": {
+    "name": "codex",
+    "version": "",
+    "model_info": { "name": "gpt-5.6-luna" }
+  },
+  "verifier_result": { "rewards": { "reward": 1.0 } }
+}
+```
+
+The first seven top-level keys are required. `verifier_result` is optional. Include `agent_result` for recorded token and cost data, and `exception_info` for a failure.
+
+## What lands
+
+| Supplied data | Imported result |
+| --- | --- |
+| Nonempty numeric reward map | `SCORED`, with the recorded rewards. |
+| Verifier result without rewards | `INDETERMINATE`. |
+| No verifier result | Status follows a recognized failure type, otherwise `INDETERMINATE`. |
+| Trace, home, verifier logs, artifacts, step files | Retained for inspection when present. |
+| Existing `analysis.json` | Not imported as an Evolve analysis; analyze the uploaded job separately. |
+
+Reported costs and totals remain identified as uploaded data. They are not charges for a new Evolve execution.
+
+**Note:**
+
+Uploaded jobs support inspection, download, analysis, and sharing. Resume, retry, and regrade are refused with `job_uploaded`.
+
+## Task linkage
+
+Analysis is more useful when it can also read the task files.
+
+### 1. Upload trials
+
+Supply the recorded job and trial files.
+
+### 2. Resolve task identity
+
+Use the first applicable case:
+
+- **Case A: `-d name@version` supplied.** Match the task name in that version.
+
+- **Case B: the archive names accessible dataset versions.** Match the task-content hash within those versions.
+
+- **Case C: neither applies.** Match the task-content hash in the accessible catalog.
+
+### 3. Analyze
+
+- **Linked task:** Read the trial record and task files.
+
+- **Unlinked task:** Read the trial record only. The missing link is reported.
+
+A task name alone does not establish an automatic content match. `upload.task_links` records the matching method or why a link was not found.
+
+## Runs made with the Evolve SDK
+
+An individual managed-agent run is not a job archive. [Upload an SDK run](/core-concepts/upload-sdk-session) provides the local log path, field mapping, packaging script, and upload commands.
+
+Use `agent/trajectory.json` for ATIF. Native transcripts must use the harness's recognized session path; arbitrary files under `agent/` are stored but are not automatically parsed as a trace.
+
+### Recognized native session examples
+
+```text
+Codex
+agent/.codex/sessions/
+└── <year>/
+    └── <month>/
+        └── <day>/
+            └── rollout-<id>.jsonl
+
+Claude
+agent/.claude/projects/
+└── <project>/
+    └── <session>.jsonl
+```
+
+A native transcript that produces parsed events takes precedence over ATIF. Otherwise, the parser falls back to ATIF. ATIF can include a `system` step when the system prompt is available in your source records.
+
+## Bounds and duplicates
+
+Inspect the import result, including skipped trials and their reasons. A completed import can have omissions.
+
+| Refusal | Meaning |
+| --- | --- |
+| `job_already_uploaded` | This job was imported before. Delete the existing import's job before replacing it. |
+| `invalid_trial` | A required trial result could not be parsed. |
+| `trial_too_large` | A trial exceeded a physical file or parsing limit and was skipped. |
+| `upload_too_large` | The archive or required job-level data exceeded an accepted limit. |
+
+The capability document reports `limits.uploads.job_archive_bytes`. Local dataset and job archives larger than 256 MiB use resumable upload automatically.
+
+**[Upload reference](/cli-reference/upload)**
+
+Import options and progress commands.
+
+**[Analyze imported results](/core-concepts/analyze)**
+
+Review behavior using the retained evidence.

package/skills/evolve-evals/references/dashboard/checks.md

@@ -0,0 +1,54 @@
+---
+title: "Checks"
+description: "Read task-quality findings and open the evidence behind them."
+---
+
+Find a check in **Jobs** under kind **Check**, or open a job's **Check** tab to see checks of its tasks.
+
+![A task quality report showing its chip, criterion outcomes, and checker cost.](/images/dashboard-task-check.png)
+
+*Read the overall finding, then inspect the criterion evidence.*
+
+```text
+Check report
+├── Source tasks + model + effort + cost
+└── Task results
+    ├── Summary chip (computed from the outcomes)
+    ├── Criterion outcomes and evidence
+    └── Checker trace
+```
+
+## Start a check
+
+Checks start from the CLI or SDK. A job with no task checks shows the corresponding dataset command:
+
+```bash
+evolve check -d harbor-examples@1.0 -i hello-world --watch
+```
+
+This reviews the task material. It does not run another evaluation job against your chosen evaluation agent.
+
+## The check page
+
+The header identifies the check, source, model, effort, status, and cost. Each task row opens that checker's [trace viewer](/dashboard/trial-viewer).
+
+| Action | Availability |
+| --- | --- |
+| **Share** | Creator; manage link and email access. |
+| **Stop** | Creator, while task checks are still live. |
+| **Download** | Once the check is completed. |
+
+## Read the finding
+
+| Finding | Next step |
+| --- | --- |
+| **Has a problem** | Read the failed criterion and its evidence. |
+| **Unclear** | Read what information was missing. |
+| **No problem found** | Check execution findings before treating it as a runtime validation. |
+| Failed task check | Read its failure; this is a failed review, not a task-quality result. |
+
+The chip is a summary the dashboard computes from the criterion outcomes. Under a custom rubric the chip reads **Has a problem** when any criterion fails, **Unclear** when none fails but at least one is unknown, and **No problem found** otherwise. Under a rubric with the default criterion names the same rule applies, with two exceptions: an unknown on one of the default rubric's execution criteria does not make the chip unclear but marks it not executed; and `attempt_isolation` counts only when it fails. The chip and its not executed note summarize the outcomes; neither is a separate execution audit. See [the check result](/core-concepts/check#the-result).
+
+**[Check reference](/cli-reference/check)**
+
+Run checks, customize the rubric, and download reports.

package/skills/evolve-evals/references/dashboard/datasets.md

@@ -0,0 +1,65 @@
+---
+title: "Datasets"
+description: "Find a task set, inspect its versions, and check where its tasks can run."
+---
+
+The **Datasets** page shows the catalog available in your workspace. Filter **All**, **Public**, or **Private**, then open a dataset.
+
+![Public datasets with task counts, versions, build status, and update times.](/images/dashboard-datasets.png)
+
+*The public catalog. Open a dataset to inspect its tasks and versions.*
+
+```text
+Dataset
+├── Active version
+├── Tasks
+└── Versions
+```
+
+- **Active version:** Used when a job omits a version.
+
+- **Tasks:** What the selected version contains.
+
+- **Versions:** Earlier and current published versions.
+
+## Inspect tasks
+
+The Tasks tab shows the selected version's tasks and their requirements:
+
+| Column | Read it for |
+| --- | --- |
+| Task name | The key used by include/exclude filters. |
+| GPUs | Whether the task needs GPU resources. |
+| Timeouts | Agent and verifier time budgets. |
+| Skills | Task-declared skills. |
+| Providers | Compatibility and any fallback target. |
+
+A provider arrow names the fallback target. Hover a refusal to read its reason. These compatibility summaries are advisory; job creation and dispatch validate the actual requirements.
+
+## Choose a version
+
+Open **Versions** to inspect provenance and task counts. Click a version to browse its tasks.
+
+**Activate** changes which version a bare dataset name resolves to. An explicit reference such as `my-dataset@1.0` remains pinned to that version.
+
+**Note:**
+
+A ready version can contain failed task builds. Inspect the task/build details before assuming every task is runnable.
+
+## Publish or manage
+
+Publishing starts from the CLI or SDK:
+
+```bash
+evolve dataset publish --dir ./tasks --name my-dataset --version 1.0 --watch
+```
+
+The dashboard exposes activation and deletion where your permissions allow them. Deleting a dataset removes its versions and task records; use the confirmation details before proceeding.
+
+**[Dataset lifecycle](/core-concepts/datasets)**
+
+Publishing, builds, versions, and activation.
+
+**[Task format](/core-concepts/tasks)**
+
+The files inside each task.