convez.ai
SkillAutomaçãoAvançado
KennethJefferson

CC Team Workflow

KennethJefferson/ccg_ccSkill_CCTeamWorkflow

Orquestra equipes de subagentes Claude com aprendizado de papéis e retry inteligente

Ver no GitHub
InicialPluginScore · de 0 a 100

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

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
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

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.
  • Learn: a postmortem step records per-archetype outcomes and promotes/demotes/ probations archetypes for each role in a learned roster.

Substrate: hybrid

OwnerResponsibility
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 — lead
  • implementer / implementer-heavy — worker
  • skeptic / reviewer-fast — validator
  • scout — 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 via tsx
  • 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/summarize runner — 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):

  1. Dual-validator min-score for stakes:"high" nodes — the engine runs a single validator per node; minScore exists and is tested but is not yet wired.
  2. Synthesizer / competitive-variants arbitration path — a synthesizer node would be mistreated as a validator, and the outputs_conflicting escalation is never emitted. Do not design competitive/synthesizer nodes in v1.
  3. 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.

Ver o original no GitHub

Bom para

Relacionados