CC Team Workflow
KennethJefferson/ccg_ccSkill_CCTeamWorkflow
Orquestra equipes de subagentes Claude com aprendizado de papéis e retry inteligente
Ver no GitHubSkill TypeScript que orquestra uma equipe hierárquica de subagentes Claude (líder, trabalhador, validador, sintetizador) com atribuição de arquétipos aprendida, retry estruturado e verificação de contrato de artefatos. Execução totalmente em-sessão, sem dependências de PI ou modelos externos.
Instalação
npx convez-ai KennethJefferson/ccg_ccSkill_CCTeamWorkflow1 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
- Decomposição e execução de tarefas complexas em DAG com múltiplos agentes
- Validação e verificação de qualidade de artefatos com contratos tipados
- Aprendizado de desempenho por arquétipo para otimização iterativa de roster
Veredito

Infraestrutura sofisticada de orquestração multi-agente em sessão, totalmente em Claude. Excelente para pipelines complexos que exigem decomposição, validação e aprendizado de papéis; requer expertise em design de workflow e TypeScript.
README
A tradução para o português deste README ainda está na fila.
ccg_ccSkill_CCTeamWorkflow
cc-team-workflow — orchestrate a hierarchical team of Claude Code subagents (lead → worker → validator → synthesizer) with learned archetype role-fit and structured retries, entirely in-session, with no PI or external-model dependency.
This is the all-Claude sibling of team-workflow
(which delegates labor to external PI models). Same lead → worker → validator → synthesizer
pipeline, same learned role-fit and structured retries — but the labor is Claude Code
subagents differentiated by archetype = (model tier × subagent_type × persona).
A TypeScript (ESM) Claude Code skill: an Opus-orchestrated, engine-backed multi-agent work pipeline that decomposes a task into a DAG of subagent nodes, dispatches them with schema-enforced outputs, retries/reassigns on failure, contract-checks the artifacts on disk, and learns which archetypes are good at which roles over time.
What it does
You (Opus) stay the orchestrator and own all judgment. The skill is the algorithm; a background Workflow engine owns the mechanism.
- Decompose a task into a role-graph (DAG) of nodes, each with a role (lead / worker / validator) and an archetype.
- Dispatch subagents over the frontier, enforcing a per-node output contract (a worker returns a manifest; a validator returns a scorecard).
- Retry & reassign with feedback (N = 2 retries) under a two-track ship-vs-regress cutoff; on plan-level failure, surface a typed escalation bundle back to you.
- Contract-check deliverables on disk (exists + non-empty + path-allowlist + worktree
- no-stale) then run test/lint/typecheck per the task's
tests_posture.
- no-stale) then run test/lint/typecheck per the task's
- Learn: a postmortem step records per-archetype outcomes and promotes/demotes/ probations archetypes for each role in a learned roster.
Substrate: hybrid
| Owner | Responsibility |
|---|---|
| You (Opus, in-session) | Triage, decomposition, role-graph design, roster selection, retry/arbitration decisions, final synthesis. |
The Workflow engine (engine/team-workflow.engine.js) | DAG dispatch, schema-enforced output, the retry loop + two-track cutoff, reassignment, artifact-contract-check, postmortem-data emission. Runs in the background; talks back via a typed escalation bundle. |
The archetypes
Seven seed archetypes live in default-roster.json (live, learned state in the
gitignored roster.json):
architect— leadimplementer/implementer-heavy— workerskeptic/reviewer-fast— validatorscout— recon-only (dispatch during design, never as a deliverable node)synthesizer— merge/arbitration (see Status below — deferred in v1)
Role-fit is learned by scripts/roster-postmortem.ts.
Layout
ccg_ccSkill_CCTeamWorkflow/
├─ CLAUDE.md # guidance for Claude working IN this repo
├─ README.md # this file
├─ Usage.md # how to invoke and run the skill
├─ CHANGELOG.md # version history (append-only)
├─ docs/superpowers/ # the original design spec + plan
└─ __solutions/cc-team-workflow/ # the skill itself
├─ SKILL.md # the skill contract Claude reads
├─ default-roster.json # tracked read-only seed roster
├─ roster.json # GITIGNORED learned runtime state
├─ engine/ # the Workflow engine (DAG dispatch + retry)
├─ lib/ # types, io, paths, manifest, scorecard, roster
├─ scripts/ # JSON-in/JSON-out helpers + the test runner
├─ schemas/ # run-spec / manifest / scorecard / escalation schemas
├─ personas/ # one persona file per archetype
├─ references/ # run-spec, scoring-protocol, escalation contracts
└─ examples/ # example RunSpecs
Install / register
The skill is discovered by Claude Code via a symbolic link from the skills directory to the skill root:
C:\Users\<you>\.claude\skills\cc-team-workflow → <repo>\__solutions\cc-team-workflow
Once linked, it appears in Claude Code's available-skills list as cc-team-workflow.
Requirements
- Node.js ≥ 20 (developed and run on Node 24)
- tsx ≥ 4 (
npx tsx …) — the skill is ESM TypeScript run directly viatsx - A Claude Code session with the Workflow tool available (the engine runs as a workflow)
Run the tests
cd __solutions/cc-team-workflow
npm test # → npx tsx scripts/run-all-tests.ts
The test harness is a tiny custom
test/assert/summarizerunner — not vitest/jest. As of v0.1.0, 75 tests pass.
Usage
See Usage.md for the 12-phase orchestration flow, the helper-script
contracts (roster-check, spec-validate, artifact-contract-check, roster-postmortem),
and how to wire the engine into a Workflow script.
Status (v0.1.0)
The core algorithm — triage → design → dispatch / retry / escalate → contract-check → postmortem — is fully wired and tested end-to-end through an injected dispatch seam.
Three capabilities are spec'd but intentionally deferred in v1 (do not assume they work):
- Dual-validator min-score for
stakes:"high"nodes — the engine runs a single validator per node;minScoreexists and is tested but is not yet wired. - Synthesizer / competitive-variants arbitration path — a
synthesizernode would be mistreated as a validator, and theoutputs_conflictingescalation is never emitted. Do not design competitive/synthesizer nodes in v1. - Phase 12 git post-processing — stubbed; the skill ships local-only.
See CHANGELOG.md for full version history.
License
No license file is currently included. All rights reserved by the author unless and until a license is added.