orchestrate

Dispatches GitHub issue queue tasks to parallel subagents with memory caps and a pinned status panel.

Updated Apr 12, 2026
One-click install
npx skills add https://github.com/theitush/yajna --skill orchestrate-theitush
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: orchestrate
Source: https://github.com/theitush/yajna/tree/main/.claude/skills/orchestrate
Command: npx skills add https://github.com/theitush/yajna --skill orchestrate-theitush

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Working a repo's issue queue one task at a time in a single long thread is slow and error-prone: parallel workers clobber each other's files, uncapped jobs can OOM-kill every session on the machine, and progress reporting scatters across messages. This Skill turns the agent into a dispatcher that splits the queue into safe parallel lanes, spawns one subagent per task, and keeps a live Running / Planned / Done panel pinned to the terminal. ## Core Features & Use Cases - Queue triage and lane splitting: Reads the GitHub Projects board in one GraphQL call, skips Blocked/Review/backlog items, and groups surviving tasks by the file paths they touch so disjoint work runs in parallel and shared paths run serially. - Memory-budgeted workers: Every heavy job runs under systemd-run with MemoryMax and MemorySwapMax=0 cgroup caps sized from measured peaks, so an overrun kills only that job instead of the whole session tree. - Live status panel and report footer: The orchestrate-status tool renders a pinned Running / Planned / Done table with per-worker token counts, countdown ETAs, and clickable transcript links, then prints the same table as the final report footer. - Use Case: Given five open issues on the yajna repo, run a pass that works three of them simultaneously in separate subagents — each with its own path ownership, model, and memory cap — verifies and commits their results by path, and closes with a priced backlog and a full timing report. ## Quick Start Invoke /orchestrate to work this repo's issue queue as a dispatcher with parallel subagents and a pinned status panel.

Frequently Asked Questions about orchestrate

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

FAQPage Schema
How do I run multiple Claude Code subagents in parallel on one repo?

Split the task queue by the file paths each task touches: tasks with disjoint paths run simultaneously in separate subagents, while tasks sharing paths run serially in one lane. Each spawn must name the paths the worker owns and the paths it must not touch.

How do I prevent a runaway process from killing all my agent sessions?

Run every heavy job under systemd-run with a cgroup memory cap: `systemd-run --user --scope -p MemoryMax=<N>G -p MemorySwapMax=0 -- <command>`. A capped job that overruns dies alone with exit 137 instead of triggering the OOM killer against the whole session tree.

How do I measure a job's peak memory usage on Linux?

Run the command under `/usr/bin/time -v` and read the `Maximum resident set size` field from its output. Record that number in the task result so future runs size their cgroup cap from a measured peak rather than an estimate.

Can parallel git workers share one checkout safely?

Only when their file paths are disjoint, and commits must be made by path, never with `git add -A`, since the tree is shared. Where paths cannot be separated, spawn the worker with worktree isolation and merge its branch when it reports.

Why should a task brief not restate the issue's requirements?

Restating creates a second copy that can drift from the original ask, and transcription errors in the copy send workers building the wrong thing. The brief should point the worker at the issue body's Ask block and add the dispatcher's own interpretation only as clearly marked separate text.