convez.ai
SkillAutomaçãoAvançado
met44

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 GitHub
InicialPluginScore · de 0 a 100

Skill 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-skill

1 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

Estrelas
1
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 2 meses
Versão
—
Issues abertas
0
Contribuidores
2

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:

  1. 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)
  2. 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 but STATE.json missing → REPAIR (reconstruct from PROGRESS.md + PLAN.md, never re-init over existing files); STATE.json corrupt → 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

Ver o original no GitHub

Bom para

Relacionados