bigtask — Orquestração de Tarefas Multi-Sessão
met44/bigtask-skill
Tarefas grandes que persistem entre sessões, com orquestração delegada e relay inter-máquinas
Ver no GitHubSkill Claude Code para gerenciar tarefas complexas e persistentes (features, refatorações, auditorias, migrações) que atravessam múltiplas sessões sem perder contexto. Combina persistência em disco, orquestração de sub-agentes e comunicação inter-máquinas via relay, garantindo que o trabalho sobreviva aos limites de contexto e sessão.
Instalação
npx convez-ai met44/bigtask-skill1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Refatorações grandes em codebase que excedem limite de contexto de uma sessão
- Migrações de banco de dados ou infraestrutura com múltiplas fases e checkpoints
- Auditorias de código com exploração delegada a sub-agentes especializados
- Coordenação de trabalho entre máquinas diferentes via relay TCP
Veredito

Solução técnica robusta para o problema real de context loss em tarefas longas; arquitetura bem pensada com separação clara entre persistência (bigtask), orquestração (supervise) e comunicação distribuída (relay). Recomendado para times que enfrentam limites de contexto em projetos complexos, com cuidado na curva de aprendizado.
README
A tradução para o português deste README ainda está na fila.
bigtask
A Claude Code plugin for running non-trivial multi-session tasks (feature, refactor, audit, migration) that must survive across sessions without losing context.
It bundles two complementary skills that attack context loss from opposite ends, plus one that crosses machines:
- bigtask — survive across sessions: task state lives on disk (not in the conversation window), so any future session rebuilds context and resumes.
- supervise — survive within a session: the lead agent stays a pure orchestrator and farms every subtask to sub-agents, so its own context never fills with source.
- relay — talk across machines: one Claude Code session hosts a tiny TCP mailbox, sessions on other machines join it, and they exchange instructions, reports, and whole directory trees over the LAN — no shared folders needed.
When you drive a big task, the bigtask lead agent invokes supervise by default — so the work outlives both context limits and session boundaries. (Opt out for a small, single-phase task with supervise: off in PLAN.md.)
bigtask — persistent plan / state / progress
Rests on two ideas:
- A three-file state triad on disk — so any future session rebuilds context from disk, not from a vanishing conversation window:
STATE.json— where we are now (tiny, always accurate)PROGRESS.md— what was done (append-only, one entry per checkpoint)EXPERIMENTS.md— what was tried + result (one section per experiment)
- One human-gated unit of work — a git branch, a Perforce CL, or nothing — that the agent prepares and verifies but never submits/merges automatically.
It is VCS-agnostic (git / Perforce / none), detects available tooling at runtime and degrades gracefully (e.g. no notification MCP → status goes inline), enforces phase scope and per-step budgets, and ends every code/content phase with automated verification, not "looks fine to me."
supervise — supervisor / orchestrator
Turns the lead session into a pure supervisor. Big tasks die when one session reads and writes all the code itself: context fills, early decisions scroll away, requirements get dropped, and the session has to be restarted. supervise keeps the lead agent's context holding only plans, interface contracts, and status — never source — and dispatches everything else:
- Recon goes to read-only Explore agents that return a map, not file contents.
- Writing, editing, building, and testing go to one worker agent per task, each with a self-contained prompt.
- The supervisor reviews by report and verifies via a final agent — it never opens project files, builds, or runs tests itself.
It scales the dispatch to the toolchain (git → a worktree per parallel worker; Perforce / locked-toolchain like Unreal → no worktrees, serialize compiles). Use it for any big, broad "build the whole thing" task, or whenever a session risks context bloat from reading lots of source.
relay — two machines, two Claude sessions, one mailbox
relay gives two (or more) Claude Code sessions on different machines a channel to talk. One machine runs relay.py serve (a stdlib-only Python TCP mailbox, detached); every session — including the host's own — uses the same send / recv commands, so no daemon is needed on the client side. Messages carry a kind (instruction, report, question, answer, note, done), can attach files, and recv long-polls so an agent turn waits for the reply instead of spinning. push / pull move whole folders through the same port: raw binary streamed into a sha256-addressed store on the host, so unchanged content never crosses the wire twice and pull skips files already identical on disk (robocopy-style, incl. --mirror, --exclude).
The canonical use: you have set up one machine with Claude over many steps and want a second machine to match. Install Claude Code and this plugin on the new PC, then:
- on the original machine: "act as relay server and instruct the other machine to set itself up like this one" → it starts the mailbox and tells you the IP/port line to type on the other side;
- on the new machine: "act as relay client to 192.168.1.42:7777" → it joins and executes the host's instructions step by step, reporting back after each.
The skill tells the host to inventory from disk (not memory), send in dependency order, wait for each report, never relay secrets, and end with a done handshake.
Install
/plugin marketplace add met44/bigtask-skill
/plugin install bigtask@met44-skills
Once installed, bigtask auto-triggers when you start or resume a big multi-session task, supervise can be invoked explicitly via the Skill tool (or runs by default when bigtask leads a task), and relay triggers when you ask a session to act as server/client toward another machine's Claude. relay needs Python 3.8+ on both machines (standard library only).
Update
To pull a newly published version into an already-installed plugin:
/plugin marketplace update met44-skills
/reload-plugins
The first command re-fetches the marketplace catalog from GitHub (it must run first, or the reload won't see the new version); the second reloads plugins so the new version activates without restarting Claude Code. There is no standalone /plugin update command — refreshing the marketplace plus reloading is the update path. You can also do this from the /plugin interactive menu → Marketplaces tab → select met44-skills → update, then /reload-plugins.
What's inside
skills/bigtask/
SKILL.md # lean hot path: state triad, mode detection, phase loop, budgets, stop conditions
references/
init.md # full bootstrap
verification.md # verification toolkit (Unreal + C#/.NET)
tooling.md # tool-first decision ladder
long-jobs.md # >30 min job + power-scheme discipline
templates/
STATE.json # fill-in skeleton
PLAN.md # phase-structured skeleton
status.ps1 # status reporter (-PlanDir <path>)
skills/supervise/
SKILL.md # supervisor rules, dispatch workflow, anti-rationalization guardrails
skills/relay/
SKILL.md # roles (host/peer), conversation loop, machine-mirroring recipe
scripts/relay.py # stdlib TCP mailbox: serve / init / send / recv / push / pull / store / peers / log / stop
scripts/test_relay.py # self-test: mailbox + two peers on one machine (python test_relay.py)
How bigtask works
- Mode detection runs first every invocation: missing task folder → INIT; folder present with valid
STATE.json→ RESUME; folder present butSTATE.jsonmissing → REPAIR (reconstruct fromPROGRESS.md+PLAN.md, never re-init over existing files);STATE.jsoncorrupt → stop, never overwrite. - Phase loop builds a 3–10 step todo list, makes one minimal scoped edit per step, verifies, then checkpoints to disk.
- Budgets are mechanical: >200 changed lines or >6 files per step → split or ask; >3 fix attempts → revert just the offending files; >4 phases without a human gate → insert one.
- Human gates are hard stops — the agent prepares and reports "ready for review/submit" and exits; a human submits.
License
MIT