skills.rest
Arasz
AraszCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

ai-badger-task-orchestration

Orchestrates ai-badger tasks end-to-end from Hermes using delegate_task subagents and git worktrees.

2|Updated Aug 2, 2026
Search Tags:#tdd#subagents#delegation#orchestration#git worktree#task tracking#gherkin
One-click install
npx skills add https://github.com/Arasz/ai-raccoon --skill ai-badger-task-orchestration-arasz
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: ai-badger-task-orchestration
Source: https://github.com/Arasz/ai-raccoon/tree/main/.ai-badger/skills/learned/uncategorized/ai-badger-task-orchestration
Command: npx skills add https://github.com/Arasz/ai-raccoon --skill ai-badger-task-orchestration-arasz

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? Running a full ai-badger task (spec, owner-gate review, worktree setup, TDD implementation waves, merge) from Hermes involves dozens of failure-prone mechanics: delegation summaries that truncate and get cache-deleted, parallel subagents colliding on shared build directories, tracker state living in the main checkout while work happens in worktrees, and finish guards that refuse on stale state. This Skill encodes the execution mechanics and every pitfall hit in practice so an orchestrating agent can run the pipeline without rediscovering them. ## Core Features & Use Cases - Six-phase pipeline: spec creation with spec_holes.py gating, owner-gate review form generation and ingest, worktree registration with real session IDs, plan review by read-only subagents, TDD wave dispatch with orchestrator-run join gates, and finish protocol with state.json bookkeeping. - Delegation pitfall playbook: covers truncated delegation summaries, batch-mode brief loss, parallel build collisions in one worktree, torn writes from mid-flight orchestrator edits, and token recording via the task tracker. - Verification and recovery references: nine reference files covering concurrent-session collision recovery, Gherkin spec mechanics, Hermes plugin ABI, hermetic subprocess test harnesses, incomplete-refactor completion, multi-branch rebasing, spec elicitation, TDD cluster ordering, and zombie-tracker close verification. - Use Case: You agree on a spec with the user and say "go" — the Skill walks you through registering the task, creating the worktree, dispatching implementation subagents wave by wave, running join gates yourself, and finishing the tracker with committed state. ## Quick Start Ask the agent to run ai-badger task X end-to-end from the agreed spec using Hermes delegation, starting with task_tracker.py start and a worktree.

Frequently Asked Questions about ai-badger-task-orchestration

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run an ai-badger task end-to-end from Hermes?▼

Follow the six-phase pipeline: create the spec with create-task-spec and verify with spec_holes.py, run owner-gate-review, register the task with task_tracker.py start to create the worktree, plan and review in the worktree, dispatch TDD implementation waves, then record state and finish.

How do I delegate implementation work to subagents without losing context?▼

Put the complete brief inside each task entry's own goal and context fields, because delegate_task batch mode ignores top-level goal and context. Prefer single-task dispatch unless you truly need parallel fan-out, and have subagents write full findings to files in the worktree.

Why do parallel subagents in one git worktree break the build?▼

Concurrent dotnet build and test runs collide on shared obj/ directories, and each agent sees the other's broken work in progress. Instruct each agent to run only targeted builds with filters and stage only its own paths, while the orchestrator runs the full suite alone at the wave join.

Why does task_tracker.py finish refuse with state.json not modified?▼

The finish guard checks the main checkout's state.json, so an entry committed only on the task branch still refuses until the PR merges and main is pulled. Commit the completedTasks entry, merge the PR, pull main with ff-only, then re-run finish.

Can I recover a task after a parallel session finished it and deleted the worktree?▼

Yes. Find dangling commits with git fsck --lost-found, restore the branch and worktree with git branch and git worktree add, then edit executed-tasks.json directly to set state back to STARTED with finishedAt null. The full recovery recipe is in references/concurrent-session-collision.md.

What are the limitations of delegation summaries in Hermes?▼

Large sub-agent outputs are delivered head-plus-tail only, and the cache deletes the summary files, so load-bearing verdicts must also be written to files in the worktree by the subagent. Read summary files immediately on delivery, and decode encoding artifacts with python if read_file flags them as binary.

Related Skills

Explore More Software Engineering Skills→
qlawmarqqlawmarq

sdd-spec-status

Display SDD specification status with phase completion percentages and next actions.

Community
Intermediate
crbnoscrbnos
2.4k

self-review

Reviews the full branch diff against main and reports must-fix issues, risks, and docs freshness.

Official
Intermediate
UniClipboardUniClipboard
1.6k

plan-reviewer

Reviews Markdown implementation plans against repository code through independent adversarial passes.

Official
Intermediate
MINT-IAMINT-IA

gsd-fast

Execute small inline tasks directly in the current context without planning artifacts.

Official
Basic