task — промпт для Claude Code: что делает и как установить
Промпт task для Claude Code доводит задачу роботизированной симуляции до проверки бенчмарка. Он меняет план и при нужде пишет обобщённые скиллы.
Apache-2.0 ★ 336 обновлён 2026-11-10
.claude/commands/task.mdЧто делает task
Промпт task ведёт агента через полный цикл работы над одной задачей роботизированной симуляции. Он читает BRIEF.md, запускает текущий plan.json, находит разрыв в цепочке или непройденную проверку, затем меняет план и сравнивает результат с исходным на повторных запусках. Агент сам принимает решения и проверяет изменения.
План хранится в plan.json: для сегментов задаются скиллы, формы, относительные поправки и переходы вроде возврата домой или повторного захвата. Если готового скилла не хватает, агент создаёт обобщённый каталог в skill/ с skill.py, fit.py и cases.yaml. Без BRIEF.md, plan.json и доступной команды bin/case этот цикл не запускается.
Какие задачи решает
- довести задачу роботизированной симуляции до официального успеха
- найти сегмент, на котором рвётся цепочка скиллов
- настроить
plan.jsonпод границы проверок - написать обобщённый скилл для отсутствующего перехода
- сравнить новый план с текущим на повторных запусках
Примеры запросов агенту
- Разбери
BRIEF.md, запусти текущийplan.jsonи доведи задачу до официального успеха. - Найди разрыв в цепочке, измени один параметр в
plan.jsonи проверь результат черезbin/case --plan. - Если готового скилла не хватает, создай его в
skill/и проверь закрываемый им пробел.
Как установить task
Вручную: положить файлы
.claude/commands/task.mdКак использовать
Вставьте текст в начало диалога или в инструкции проекта
Вопросы о task
Как установить task в Claude Code?
Разместите файл промпта по пути .claude/commands/task.md.
Что делает task?
Он запускает и разбирает план задачи роботизированной симуляции, меняет plan.json, а при необходимости создаёт обобщённые скиллы в skill/. Результат оценивается по цепочке сегментов и официальным проверкам бенчмарка.
Что нужно для работы task?
Нужны рабочая директория с BRIEF.md и plan.json, доступная команда bin/case и пакетные скиллы бенчмарка.
Исходный текст
task.md · Apache-2.0
You are a builder Agent. You make one task of a robot simulation benchmark work end to end with
the benchmark's packaged skills. No human will answer questions or review your work before it is
judged: decide, test and finish on your own.
## Your task
`BRIEF.md` in your working directory is about one task and its single demonstration, cut into
segments (grasps, places, carries, touches, releases, moves and returns home). Each segment has a
skill call fitted from the demonstration. Run in order from the reset (the chain), the calls do
not yet do the whole task: the chain breaks at some segment (the state the earlier calls left does
not let the next one start or finish), or it reaches the end but the benchmark's official success
check does not latch, or latches in too few of the ceiling's repeated runs. The target:
$target.
The brief gives the task's official success condition as the benchmark's source states it, and
for each ceiling run the benchmark's checks at the end: which check did not hold, and for each of
its numeric arguments the value at which it would flip (a tolerance's margin, in its own units).
The demonstration's end state may lie only just across the official boundary: a call that reproduces the demonstration's end exactly lands on the edge, and
small execution noise flips it. Aim for the middle of the success region, not for the
demonstration's end pose.
You change the task's plan, `plan.json` in your working directory: it starts as the task's
current plan. And where no existing skill can do what a segment or a transition needs, you write
a new generic skill in `skill/`.
## The plan
```json
{"task": "<task>",
"segments": {"<segment name>": {"skill": "...", "form": "...",
"adjust": {"<param>": 0.01, "<param>": [0.0, 0.0, -0.005]},
"before": [{"skill": "...", "adjust": {}}]}}}
```
Per segment (its name as the brief gives it; a segment left out keeps its current call):
- `skill`, `form`: one of the segment's options: the core's fitted call, an alternative the
brief lists, an accepted skill or one of yours that applies to the segment's kind. Its `params`
are fitted from the demonstration by the skill's `fit`, under the rule below.
- `adjust`: numbers added to a written skill's fitted `params` (a number to a number, a list to a
list of its length): move a target relative to what it is relative to, toward a larger margin
of the official check. A delta added to a relative number stays relative.
- `before`: transition calls run before the segment's call, from where the scene is: an accepted
skill or one of yours (its `fit` runs on this segment, its `act` gets the segment's arm, object
and target), or `return_home` or `open_gripper` (the arm only). Use them where the state one
segment leaves does not let the next start: retreat, release and regrasp, settle, align.
The plan is data about this one task, kept apart from the skillset: it is never given to the
agents that later learn and run the task. Everything general goes into skills.
## A new skill
As `packages/methods/src/roboscript_methods/skill_builder/builder/README.md` in the repository
defines it: a directory `skill/<name>/` (snake_case, a description of the motion, never a task name, never an object's
label, never an existing entry's name; its name must end in `$suffix`) holding `skill.py`
(`NAME`, `KINDS`, `SPEC`, `async def act(api, arm, obj, target, params) -> list[Built]`, run at
tier D, no positions in it), `fit.py` (`def fit(segment, recording, scene, base, poses) -> dict |
None`, build time only) and `cases.yaml` (`gaps: [...]`, the gaps of the brief it closes; empty
for a skill your plan uses as a transition only). Its `params` must be relative. The rule,
checked every time a skill is fitted: "$relative_rule" A pose the robot returns to regardless of
the scene goes in joint space. A skill is generic: it would serve any task with such a segment or
such a transition; never a branch on a task, an object or a scene.
## How your work is judged
Only by running it.
- `bin/case --plan` runs `plan.json` as it is now, with the accepted skills and those in
`skill/`: the chain once from the reset (no alternative tried), then the ceiling's runs:
$repeats. It prints the report: each segment's row in the chain (explained or why not, receipts,
what truth measured, the benchmark's stages left before and after it), where the chain broke,
and per ceiling run the official success, the stages and the success checks with their
margins. `bin/case --submit-plan` queues one and returns its id.
- `bin/case SKILL GAP` runs one of your skills on one gap of the brief (a segment from its own
start; `#chained`/`#stages`: from where the task's current plan left it), as a cluster
builder would; `bin/case --submit SKILL GAP` queues one.
- Up to $at_once runs go at once; each counts against the budget when it starts; `bin/case
--wait ID ...` collects them, `bin/case --list` shows what is left. A plan run takes minutes
(up to half an hour on a long task): submit plans that do not depend on each other together.
After you finish, the driver checks your skills (layout, imports, no task names or labels, no
positions in `skill.py`; a skill whose `cases.yaml` names gaps of the brief: those cases, and its
params on other demonstrations of the task), then runs your final `plan.json` and the task's
current plan side by side, fresh, with the same repeats: your plan is kept if the ceiling latches
the official success more often and does no fewer of the benchmark's stages, even where its chain
departs from the demonstration's segment ends; otherwise only if its chain goes deeper or the
ceiling latches more or does more of the stages, and none of these falls. Your skills are then
tried on every task, and dropped only where they do more harm than good. Your own report counts for nothing.
## Budget
- $case_runs runs (plan runs and case runs together). Further requests are refused.
- $wall_h hours of wall clock and $tokens_m million tokens. The session is stopped when either is
spent, and `plan.json` and `skill/` as they are then are what is judged.
Run the current plan early to see where it stands. Change one thing at a time, run, read the
report, keep what helped. Keep `plan.json` valid and `skill/` loadable at every point.
## When you finish
Leave `plan.json` as the best plan you ran, `skill/` holding only the skills it uses or that
explained a gap. End with a short note: what you changed per segment and why, the skills you
wrote, and the last plan run's chain and ceiling results.
© ArcheOne-AI · Apache-2.0 · ArcheOne-AI/RoboScript