convez.ai
SkillDevOps & InfraestruturaAvançado
matshoppenbrouwers

Session Flow

matshoppenbrouwers/session-flow

Ciclo de vida de desenvolvimento completo com orquestração dependente e brainstorming colaborativo

Ver no GitHub
BomPluginScore · de 0 a 100

Orquestrador de ciclo de vida completo de desenvolvimento para Claude Code, integrando 13 skills e 4 agentes que cobrem pesquisa, design, planejamento, delegação, verificação e release. Implementa paralelização dependente, backlog persistente e auditoria de segurança com gates de decisão em cada etapa crítica.

Instalação

$npx convez-ai matshoppenbrouwers/session-flow

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
3
Forks
0
Acompanhando
0
Saúde
85%
Último commit
há 3 semanas
Versão
v3.2.0
Issues abertas
8
Contribuidores
2

Casos de uso

  • Estruturar fluxo end-to-end de desenvolvimento em projetos complexos
  • Paralelizar tasks mantendo dependências e sequência correta
  • Manter backlog vivo com triagem, grooming e execução automatizados
  • Auditar segurança e liability antes de release

Veredito

Session Flow é uma solução robusta e bem estruturada para equipes que precisam de orquestração rigorosa do desenvolvimento. A abordagem de 13 skills compostos oferece flexibilidade — entrar em qualquer ponto da cadeia — mas exige disciplina para manter. Ideal para projetos com muitas dependências e requisitos de auditoria; pode ser sobrecarga para sprints rápidas.

README

A tradução para o português deste README ainda está na fila.

session-flow — Claude Code plugin for session workflow orchestration

session-flow is a Claude Code plugin that orchestrates the full software development lifecycle — a chain of 13 skills and 4 agents covering research, design, task planning, agent delegation, post-implementation, evidence-based verification, and release. It adds dependency-aware parallelization, a standing task backlog, collaborative brainstorming, and a security & liability audit, with user gates at every critical decision.

License: MIT Skills: 13 Agents: 4

Install in Claude Code: /plugin marketplace add matshoppenbrouwers/session-flow then /plugin install session-flow@session-flow

The Chain

session-init ──> gatekeeper ──> research-design ──> task-planning ──> delegation ──> post-impl ──> verify ──> release
 (one-time)       (triage          (collaborative      (break into       (dispatch      (simplify,     (evidence-   (version bump,
                   intake)          brainstorming)      session tasks)    agents)        review,        based proof) package, verify)
                                                                                         audit, test)   (optional,
                                                                                            │            heavy)
                                                                                      update-architecture

sequence layer:  gatekeeper / add-task / task-planning ──> SEQUENCE.md ──> groom ──> next

Each skill produces artifacts that feed into the next. Start anywhere in the chain based on what you already have. The sequence layer runs alongside the chain: a standing backlog (todo/SEQUENCE.md) that gatekeeper/add-task fill, groom prepares, and next works through.

Install

Step 1 — Register the marketplace:

/plugin marketplace add matshoppenbrouwers/session-flow

Step 2 — Install the plugin:

/plugin install session-flow@session-flow

Works on macOS, Linux, and Windows.

Getting Started

  1. Install session-flow (see above)
  2. Run /session-init in Claude Code to set up your project's documentation structure
  3. Start building: /session-research-design for new features, /session-task-planning if you already have a plan

Skills

SkillTriggerProduces
session-init/session-initDirectory structure, SEQUENCE.md, .session-flow.json config
session-gatekeeper/session-gatekeeperTriaged issues routed to the sequence or to research-design
session-research-design/session-research-designResearch report + implementation plan
session-task-planning/session-task-planningTask file with dependency tags [seq], [parallel-after:X]
session-add-task/session-add-taskSequence entry + per-task breakdown file
session-groom/session-groomResearched breakdowns attached to raw backlog entries
session-next/session-nextThe next backlog task implemented and marked done
session-delegation/session-delegationCompleted implementations via parallel agent dispatch
session-post-implementation/session-post-implementationRefined code, security audit, test plan, updated docs
session-verify/session-verifyEvidence-based verification artifact proving implementation matches design spec
session-release/session-releaseVersioned artifacts, updated satellite content
update-architecture/update-architectureSurgical architecture doc updates
security-liability-audit/security-liability-auditTechnical security + legal liability findings

Entry Points

You don't have to start at step 1:

You have...Start with
Incoming issues or ideas to triage/session-gatekeeper — route them to the backlog or a design session
A running backlog/session-next — implement the next ready task
A vague idea/session-research-design — collaborative brainstorming refines it
A plan or spec/session-task-planning — break it into session-sized tasks
A task list/session-delegation — dispatch agents to execute
Working code that needs polish/session-post-implementation — simplify, review, audit, test
A completed feature/plan that needs proof it works/session-verify — falsification-based evidence artifact
Tested code ready to ship/session-release — bump version, package, verify
A specific security concern/security-liability-audit — standalone security + liability scan

The Chain in Practice

A typical session might look like:

You: /session-research-design
Claude: "What problem are we solving?" → one question at a time →
        proposes 3 approaches → presents design section by section →
        writes research report + implementation plan

You: /session-task-planning
Claude: Reads the plan → breaks into 8 tasks with dependency tags →
        identifies 3 parallel opportunities → saves to todo/

You: /session-delegation
Claude: Parses dependency graph → dispatches 2 agents in parallel →
        marks tasks [x] as they complete → reports progress

You: /session-post-implementation
Claude: Simplifies code → reviews for bugs → sanitizes dead code →
        runs full test suite → updates architecture docs →
        generates manual test plan

You: /session-verify   (optional — for plans/features with a design doc)
Claude: Reads design + plan → writes falsifiable hypotheses →
        runs structural audit → executes full tests → writes defect probes →
        produces evidence artifact with PASS/FAIL verdict

You: /session-release
Claude: Bumps version → waits for build → packages artifacts →
        scans docs site, website, changelog for stale content →
        presents checklist → commits release

Task Sequence / Backlog

Beyond per-feature task files, session-flow keeps a standing backlog at todo/SEQUENCE.md — a flat list of one-line entries, each linking to a detailed breakdown:

- [ ] SEQ-007 P2: Add rate limiting to the API → todo/tasks/0007-add-rate-limit.md
- [ ] SEQ-008 P3: Investigate caching layer (needs breakdown)
- [x] SEQ-006 P1: Fix login redirect loop → todo/tasks/0006-fix-login-redirect.md

Each linked breakdown in todo/tasks/ is a self-contained, bite-sized prompt (Files / Instructions / Accept / Test) ready for an agent to execute.

Want to...Use
Capture something for later/session-add-task — adds an entry + breakdown
Implement the next item/session-next — or just say "implement the next task"
Prepare raw one-liners/session-groom — researches and attaches breakdowns

session-init wires a <!-- session-flow:sequence --> block into your CLAUDE.md and AGENTS.md so "implement the next task" works without naming a file. Pair grooming with the built-in /loop for hands-off upkeep:

/loop 30m /session-groom

Gatekeeper / Intake

/session-gatekeeper is the front-of-chain funnel for incoming work — GitHub issues, feature requests, or ideas that surface mid-session. It grounds each item in your architecture docs and product direction (a PRD.md in the docs root by default, configurable via paths.direction), then routes it:

  • Trivial, aligned, and clear → straight into the sequence via session-add-task.
  • Significant, divergent, or unclear → escalated to a cowork /session-research-design session with you.
  • Off-direction → flagged for your explicit decision.

It triages only — it never implements, and it treats issue text as untrusted data rather than instructions. It pairs with /loop for periodic issue intake, queuing anything significant for you rather than auto-processing it.

Post-Implementation Workflow

/session-post-implementation runs up to 9 steps. At the start, it asks which scope to use:

StepFullStandardQuick
1. Simplifyyesyesyes
2. Code reviewyesyesyes
3. Security & liability audityes--
4. Commit checkpointyesyesyes
5. Sanitizeyesyes-
6. Test suiteyesyes-
7. Architecture docsyes--
8. Manual test planyes--
9. Final commityesyes-

Standard and Quick scopes can add individual steps as extras (e.g., Quick + architecture docs). Verification (/session-verify) is always optional and can be invoked after Full completion.

When the security audit is included, you choose how it runs:

  • Sub-agent — dispatches an agent (faster, lower cost)
  • Inline — runs in the main conversation with your current model (more thorough)

Security & Liability Audit

The audit covers two dimensions:

Technical security — LLM/AI security (prompt injection, unsanitized output, tool validation), OWASP Top 10, secrets detection, agentic security (Lethal Trifecta), desktop app security, dependency supply chain, webhook/integration security. Findings use confidence-based filtering (80% gate) to avoid noise.

Legal liability — ToS/EULA coverage gaps, GDPR compliance (privacy policy, DPAs, data retention, user rights), EU AI Act obligations (risk classification, transparency), Digital Content Directive (conformity, updates), consumer protection (withdrawal, pricing, cancellation), AI output disclaimers, cross-border data transfer requirements. Designed for EU-based developers with a worldwide userbase.

The audit can also run standalone via /security-liability-audit.

Bundled Agents

AgentUsed ByPurpose
code-simplifierpost-impl step 1Simplify recently changed code
code-reviewerpost-impl step 2Find bugs, security issues, convention violations
security-auditorpost-impl step 3Technical security + legal liability audit
code-sanitizerpost-impl step 5Detect dead code and temporary artifacts

Bundled agents inherit the parent session's model — an Opus 4.7 session gets Opus 4.7 subagents, a Sonnet session gets Sonnet. If you have the marketplace code-simplifier:code-simplifier plugin installed, session-post-implementation uses it automatically instead of the bundled agent.

Customization

session-flow adapts to your project via .session-flow.json (created by /session-init):

{
  "root": "_devdocs",
  "paths": {
    "research": "_devdocs/research",
    "plans": "_devdocs/plans",
    "todo": "_devdocs/todo",
    "tasks": "_devdocs/todo/tasks",
    "sequence": "_devdocs/todo/SEQUENCE.md",
    "testing": "_devdocs/testing",
    "architecture": "_devdocs/architecture",
    "direction": "_devdocs/PRD.md"
  }
}

paths.direction points /session-gatekeeper at your product-direction doc. It defaults to a PRD.md inside the docs root (e.g. _devdocs/PRD.md) — let /session-init scaffold it, or set this to an existing PRD/vision file anywhere in the repo.

Override agents by placing custom versions at ~/.claude/agents/ (user) or .claude/agents/ (project). See references/customization-guide.md for details.

Token Budget

Only 1-2 skills are loaded at a time (triggered by description matching):

ComponentEst. Tokens
All 13 skill metadata (always loaded)~1,300
Largest single skill body (research-design)~2,500
Typical active session~3,400

Security audit reference files (~900 lines total) are only loaded when the audit runs.

References

Contributing

See CONTRIBUTING.md for skill quality checklists and guidelines.

License

MIT

Links

Keywords: Claude Code plugin · Claude Code skills · Claude Code agents · agentic workflow · development lifecycle automation · task planning · code review · evidence-based verification

Ver o original no GitHub

Bom para

Relacionados