Astra run
Use when starting a feature or bugfix implementation run. Orchestrates planning, then generator/evaluator loop with circuit breaker and HITL gates. Do NOT use for project setup — use /astra-init instead.From its SKILL.md
npx -y skills add weardo/astra --skill astra-runAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
4.9 KB, as published. Nobody here has run it
/astra-run — Executor Loop
All decisions are made by the Python orchestrator. This skill is a thin executor.
Setup
-
Parse
$ARGUMENTS:- Plain text →
PROMPT=$ARGUMENTS --spec path→SPEC_PATH=path--plan path→PLAN_PATH=path
- Plain text →
-
Load detection (or run detect if missing):
DETECTION=$(cat .claude/detection.json 2>/dev/null || echo '{}')
- Initialize the orchestrator and get the first action:
PYTHONPATH=${CLAUDE_PLUGIN_ROOT} python3 -m src.core init \
--data-dir .astra \
--project-dir . \
--prompt "${PROMPT}" \
--detection "${DETECTION}" \
--plan "${PLAN_PATH}" \
--spec "${SPEC_PATH}"
This outputs a JSON action. Parse it. Save action.run_dir — you must pass it to every record and record-hitl call.
Executor Loop
Repeat until action is complete or error:
If action is dispatch_agent
- Read
action.prompt_file,action.model,action.role,action.isolationfrom the JSON - Map the role to the correct astra agent:
- If
action.isolationis"worktree":Agent(prompt="Read and follow all instructions in {action.prompt_file}", model=action.model, subagent_type="astra:{action.role}", isolation="worktree") - Otherwise:
Agent(prompt="Read and follow all instructions in {action.prompt_file}", model=action.model, subagent_type="astra:{action.role}")
subagent_type="astra:architect", role "generator" →subagent_type="astra:generator", role "test-runner" →subagent_type="astra:test-runner" - If
- Save agent output to
action.save_output_to - If the agent ran with
isolation: "worktree"and made changes, merge the worktree branch back:
If merge conflicts, abort (git merge --no-ff <worktree-branch> -m "Merge task <task_id>"git merge --abort) and set verdict to FAIL. - Get next action:
PYTHONPATH=${CLAUDE_PLUGIN_ROOT} python3 -m src.core record \
--data-dir .astra \
--run-dir "${RUN_DIR}" \
--role "${ROLE}" \
--output "${OUTPUT}" \
--task-id "${TASK_ID}" \
--verdict "${VERDICT}"
If action is dispatch_batch
The orchestrator returns multiple independent tasks to run in parallel.
- Read
action.agents— an array of agent descriptors, each withprompt_file,model,role,save_output_to,task_id, and optionallyisolation - Launch ALL agents simultaneously in a single message with multiple Agent tool calls:
- For each agent in
action.agents, dispatch using the same rules asdispatch_agentabove (includingisolation: "worktree"when specified)
- For each agent in
- Collect all outputs
- Merge worktree branches back to main. For each agent that ran with
isolation: "worktree"and made changes:
These merges should be clean —git merge --no-ff worktree-<name> -m "Merge parallel task <task_id>"auto_fix_depsensures parallel tasks touch different files. If a merge conflicts, abort it (git merge --abort) and record that task as FAIL. - For each completed agent, call
recordsequentially:
PYTHONPATH=${CLAUDE_PLUGIN_ROOT} python3 -m src.core record \
--data-dir .astra \
--run-dir "${RUN_DIR}" \
--role "${ROLE}" \
--output "${OUTPUT}" \
--task-id "${TASK_ID}" \
--verdict "${VERDICT}"
- After the last
record, use the returned action as normal (it may be anotherdispatch_batch,dispatch_agent,hitl_gate, etc.)
If action is hitl_gate
- Present
action.contextto the user - Ask: continue / abort / modify?
- Get next action:
PYTHONPATH=${CLAUDE_PLUGIN_ROOT} python3 -m src.core record-hitl \
--data-dir .astra \
--run-dir "${RUN_DIR}" \
--gate "${GATE}" \
--decision "${DECISION}" \
--instructions "${INSTRUCTIONS}"
If action is checkpoint
Output action.summary. Exit cleanly. User runs /astra-resume to continue.
If action is complete
Output action.summary. Done.
If action is error
Output action.message. Stop.
Rules
- NEVER make flow decisions — the orchestrator decides
- ALWAYS pass
--run-dirto everyrecordandrecord-hitlcall - ALWAYS use
astra:prefixed agent types —astra:architect,astra:generator,astra:test-runner, etc. NEVER use agents from other plugins (feature-dev, pr-review-toolkit, superpowers). - ALWAYS save agent output to the path specified by the orchestrator
- ALWAYS pass the full agent output to
record() - If the orchestrator says
dispatch_agent, dispatch the agent - If the orchestrator says
hitl_gate, ask the user - If the orchestrator says
complete, stop