sinapse-ai 1.16.0 → 1.19.0

package/docs/community/README-community-snippet-core.md

@@ -1,6 +1,6 @@
 # README Community Section - sinapse-ai
 
-> 🌐 **EN** | [PT](../pt/community/README-community-snippet-core.md) | [ES](../es/community/README-community-snippet-core.md)
+> 🌐 **EN** | [PT](../pt/community/README-community-snippet-core.md)
 
 > **Purpose:** Copy this snippet into the README.md of `caioimori/sinapse-ai` repository.
 

package/docs/community/README-community-snippet-mcp.md

@@ -1,6 +1,6 @@
 # README Community Section - mcp-ecosystem
 
-> 🌐 **EN** | [PT](../pt/community/README-community-snippet-mcp.md) | [ES](../es/community/README-community-snippet-mcp.md)
+> 🌐 **EN** | [PT](../pt/community/README-community-snippet-mcp.md)
 
 > **Purpose:** Copy this snippet into the README.md of `caioimori/mcp-ecosystem` repository.
 

package/docs/community/README-community-snippet-squads.md

@@ -1,6 +1,6 @@
 # README Community Section - sinapse-squads
 
-> 🌐 **EN** | [PT](../pt/community/README-community-snippet-squads.md) | [ES](../es/community/README-community-snippet-squads.md)
+> 🌐 **EN** | [PT](../pt/community/README-community-snippet-squads.md)
 
 > **Purpose:** Copy this snippet into the README.md of `caioimori/sinapse-squads` repository.
 

package/docs/examples/quickstart-recording.md

@@ -55,7 +55,7 @@ $ npx sinapse-ai install
 SINAPSE AI v10.0.0
 
 ✓ Agents copiados para ~/.sinapse
-✓ Squads sincronizados (19 squads · 210 agents)
+✓ Squads sincronizados (17 squads · 210 agents)
 ✓ Settings do Claude Code atualizados
 
 Pronto. Rode `claude` pra começar.

package/docs/framework/README.md

@@ -1,6 +1,6 @@
 # SINAPSE Framework Documentation
 
-> 🌐 **EN** | [PT](../pt/framework/README.md) | [ES](../es/framework/README.md)
+> 🌐 **EN** | [PT](../pt/framework/README.md)
 
 **Status:** Official Framework Standards
 **Created:** 2025-01-16 (Story 6.1.2.6)

package/docs/framework/architecture-overview.md

@@ -55,6 +55,7 @@ Agentes sao personas especializadas com expertise, comandos e responsabilidades
 
 - **12 agentes core** cobrem o ciclo completo de desenvolvimento de software
 - **160 agentes em 17 squads** expandem para dominios especializados
+- **172 agentes no total** (12 core + 160 squad) compoem o ecossistema completo
 - Cada agente tem persona (nome, estilo), comandos (`*help`, `*task`) e dependencias
 
 Ativacao: `@agent-name` ou `/SINAPSE:agents:agent-name`

package/docs/framework/atlas/OPERATING-ATLAS.md

@@ -0,0 +1,537 @@
+# SINAPSE — Framework Operating Atlas
+
+> Single, generated map of how the SINAPSE framework works: routing, models,
+> constitution, workflows, agents, squads. Regenerate with `sinapse atlas`.
+> Counts are read from disk (Article VII — always exact).
+> Generated: 2026-06-26T05:56:32.158Z
+
+**At a glance:** 17 squads · 172 agents
+(12 framework + 160 squad) ·
+18 orchestrators · 98 workflows
+(15 framework + 83 squad) ·
+11 constitutional articles · 22 rules.
+
+---
+
+## 1. How SINAPSE works (operating model)
+
+SINAPSE is a **meta-framework**: it does not run application code itself — it
+orchestrates AI agents (inside Claude Code / Codex) through a governed pipeline.
+Every user request flows through the same spine:
+
+```mermaid
+flowchart TD
+    U[User briefing] --> I[Imperator · master orchestrator]
+    I -->|classify intent + project type| R{Route}
+    R -->|domain work| SQ[Squad orchestrator -orqx]
+    R -->|framework dev| FW[Framework agents pm/architect/dev/qa/...]
+    SQ --> SP[Squad specialist agent]
+    FW --> DOC[Doc-first pipeline]
+    SP --> DOC
+    DOC -->|PRD -> Epic -> Story -> Spec| GATE{{Gates}}
+    GATE -->|pass| EXEC[Implementation]
+    GATE -->|fail| BLOCK[Blocked — produce docs first]
+    EXEC --> QA[Quality gate] --> SHIP[Push / PR · devops only]
+```
+
+**Two routing decisions happen up front, both deterministic in spirit:**
+
+1. **Agent routing** — the Imperator (master `-orqx`) absorbs the briefing,
+   diagnoses the domain, and **delegates** to the right squad orchestrator,
+   which in turn routes to a specialist. Orchestrators never execute domain work
+   themselves (Article VIII — Mandatory Delegation). There are **18
+   orchestrators** (17 squad + 1 master) fronting **172
+   agents** across **17 squads**.
+
+2. **Model routing** — each task picks the cheapest model that solves it
+   (haiku → sonnet → opus), escalating only when needed. Documentation/spec work
+   spends the tokens; execution then just reads the finished doc (see §4).
+
+**Documentation-First is the law** (Article III). No project reaches code without
+its planning documents. A briefing like "build a site" is forced through:
+
+```
+brief → PRD → Epic → Story (validated, status ≥ Ready) → Spec → implementation
+```
+
+The pipeline produces scannable approval tables in the terminal (requirements,
+epics, stories) and is guarded so that a brand-new project cannot start coding
+with no PRD / epic / story. Observability: `sinapse route "<brief>"` prints,
+for any project, its type → workflow → which documents are missing → whether the
+gate is satisfied — i.e. *exactly where it is breaking*.
+
+This atlas is itself generated by `sinapse atlas`; its counts are read from disk,
+so they are always exact.
+
+---
+
+## 2. Agent routing — briefing to specialist
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant I as Imperator (master -orqx)
+    participant S as Squad -orqx
+    participant A as Specialist agent
+    U->>I: briefing (natural language)
+    I->>I: classify intent + project type (deterministic)
+    alt domain work
+        I->>S: delegate (announce plan, await go)
+        S->>A: route to specialist
+        A-->>S: artifact / result
+        S-->>I: consolidated
+    else framework dev
+        I->>A: route to framework agent (pm/architect/dev/qa)
+    end
+    I-->>U: business-language result (no internal jargon)
+```
+
+Rules that make this deterministic, not improvised:
+- **Article VIII — Mandatory Delegation:** an orchestrator that does domain work
+  itself is a constitutional violation. Even "just do it yourself" → delegate.
+- **Auto-routing:** the user never types an agent name; the system detects the
+  domain and routes. Acknowledgement is business language, never `@agent-id`.
+- **Project-type gate:** site / lp / app / platform / saas / api / service with
+  no epic → the greenfield workflow is invoked *before* any code.
+
+---
+
+## 2b. Framework flows — how each mechanism runs
+
+The meta-workflows of the framework itself (not the development workflows in
+`docs/sinapse-workflows/`). Each is a single diagram you can read at a glance.
+
+### End-to-end lifecycle
+
+The full spine a request travels: from briefing to shipped code, with the doc-first pipeline and gates in the middle.
+
+```mermaid
+flowchart TD
+    U[User briefing] --> C{Classify intent + project type}
+    C -->|new project| GF[Greenfield workflow]
+    C -->|existing project| BF[Brownfield discovery]
+    C -->|bug / tweak| SDC[Story dev cycle - YOLO]
+    GF --> DOC[Doc-first pipeline]
+    BF --> DOC
+    DOC --> PRD[PRD] --> EPIC[Epic] --> STORY[Story - validated >= Ready] --> SPEC[Spec]
+    SPEC --> GATE{{Doc-first gate}}
+    SDC --> GATE
+    GATE -->|missing docs| BLOCK[Blocked - produce docs first]
+    GATE -->|satisfied| IMPL[Implementation - @developer]
+    IMPL --> QA[QA gate + QA loop]
+    QA -->|pass| SHIP[Push / PR - @devops only]
+    QA -->|fail| IMPL
+```
+
+### Agent routing (delegation)
+
+How a briefing reaches the right specialist. Orchestrators route and coordinate; they never execute domain work themselves (Article VIII).
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant I as Imperator (master -orqx)
+    participant S as Squad -orqx
+    participant A as Specialist agent
+    U->>I: briefing (natural language)
+    I->>I: diagnose domain + project type
+    alt domain work
+        I->>S: delegate (announce plan, await go)
+        S->>A: route to specialist
+        A-->>S: artifact / result
+        S-->>I: consolidated
+    else framework dev
+        I->>A: route to framework agent (pm / architect / dev / qa)
+    end
+    I-->>U: business-language result (no internal jargon)
+```
+
+### Model routing (cheapest that solves it)
+
+How each task picks a model tier. Heavy thinking goes into the spec; execution then mostly reads a finished doc, so token economy is a consequence.
+
+```mermaid
+flowchart TD
+    T[Task] --> K{Kind?}
+    K -->|lint / rename / yaml / bulk| H[haiku - low effort]
+    K -->|feature from spec / review / bug / tests| SO[sonnet - high]
+    K -->|single-file / factual| SM[sonnet - medium]
+    K -->|cross-system arch / complex debug / multi-file| OP[opus - xhigh]
+    K -->|Spec Pipeline COMPLEX score >= 16| OM[opus - max]
+    H --> SP{>= 8 tool calls or real fan-out?}
+    SO --> SP
+    SM --> SP
+    OP --> SP
+    OM --> SP
+    SP -->|yes| SUB[Spawn sub-agent]
+    SP -->|no| INLINE[Run inline]
+```
+
+### Doc-first enforcement
+
+What makes it impossible to start a new project without docs. The resolver answers what is missing; hooks block code writes until PRD + epic + story exist.
+
+```mermaid
+flowchart TD
+    W[Write/Edit a code file] --> EX{Exempt path or framework repo?}
+    EX -->|yes| ALLOW[Allow]
+    EX -->|no| RES[doc-first-resolver: type, workflow, gate]
+    RES --> GF{Greenfield + gate unsatisfied?}
+    GF -->|no| STORY{Ready story exists? - story-gate}
+    GF -->|yes, no PRD/epic/story| DENY[BLOCK - run greenfield flow first]
+    STORY -->|yes| ALLOW
+    STORY -->|no| DENY2[BLOCK - create a story]
+    DENY -.->|escape: SINAPSE_SKIP_DOCFIRST=1| ALLOW
+    OBS["sinapse route gives the same answer (observability)"]:::note
+    RES -. shares logic .- OBS
+    classDef note fill:#1c1c1c,stroke:#555,color:#aaa
+```
+
+### Constitutional gates by phase
+
+Where each non-negotiable article fires across the lifecycle — the enforcement layer that blocks violations automatically.
+
+```mermaid
+flowchart LR
+    subgraph PLAN[Plan]
+      A3[III Documentation-First]
+      A4[IV No Invention]
+    end
+    subgraph BUILD[Build]
+      A6[VI Absolute Imports]
+      A8[VIII Mandatory Delegation]
+      A10[X Security & Data]
+    end
+    subgraph SHIP[Ship]
+      A2[II Agent Authority - devops only]
+      A5[V Quality First]
+      A9[IX Safe Collaboration]
+    end
+    subgraph ALWAYS[Cross-cutting]
+      A1[I CLI First]
+      A7[VII Metrics Accuracy]
+      A11[XI Conservative Default]
+    end
+    PLAN --> BUILD --> SHIP
+```
+
+### Project classification to workflow
+
+How intent maps to the right workflow: site/lp/app vs platform/saas vs api/service, greenfield vs brownfield, or a light fix.
+
+```mermaid
+flowchart TD
+    B[Briefing] --> N{New or existing?}
+    N -->|existing, unknown| BD[brownfield-discovery]
+    N -->|existing, known| FIX{Change size?}
+    N -->|new| TYPE{Project type?}
+    TYPE -->|site / lp / app| GUI[greenfield-ui]
+    TYPE -->|platform / saas| GFS[greenfield-fullstack]
+    TYPE -->|api / service| GSV[greenfield-service]
+    BD --> BTYPE{Type?}
+    BTYPE -->|ui| BUI[brownfield-ui]
+    BTYPE -->|fullstack| BFS[brownfield-fullstack]
+    BTYPE -->|service| BSV[brownfield-service]
+    FIX -->|bug / tweak| YOLO[SDC - YOLO]
+    FIX -->|feature| SDCI[SDC - interactive]
+    FIX -->|complex score >= 16| SPEC[Spec Pipeline first]
+```
+
+### Every prompt (what fires on each message)
+
+What happens on every single user message before the model even answers: hooks inject grounding and the constitution, so each turn starts already aware of the project knowledge base, design system, engineering laws and the active rules.
+
+```mermaid
+flowchart TD
+    P[User sends a prompt] --> H[UserPromptSubmit hooks fire]
+    H --> VG[Knowledge grounding - project context by domain]
+    H --> DS[Design system grounding - DS resolver by cwd]
+    H --> EG[Engineering grounding - laws + KIT by topic]
+    H --> SG[Squad grounding - curated squad context]
+    H --> CR[Constitution + context bracket injected]
+    VG --> M[Model receives enriched context]
+    DS --> M
+    EG --> M
+    SG --> M
+    CR --> M
+    M --> ACT[Act: answer or route to specialist]
+```
+
+### Every session (safe start)
+
+The safety net that runs before any work in a session: sync with remote, never touch main, audit what already exists so partial work is never overwritten (Safe Collaboration + Project Intelligence).
+
+```mermaid
+flowchart TD
+    S[Session starts] --> F[git fetch origin]
+    F --> SY{Local main behind?}
+    SY -->|yes, clean| PULL[Fast-forward pull]
+    SY -->|diverged| STOP[Stop - resolve safely]
+    PULL --> BR[Auto-create feature branch - user/type/desc]
+    STOP --> BR
+    BR --> AUD[Initial state audit - 8 dimensions]
+    AUD --> MAT{Maturity?}
+    MAT -->|empty| GREEN[Greenfield workflow]
+    MAT -->|partial| CONT[Continue - never overwrite]
+    MAT -->|mature| BROWN[Brownfield discovery]
+    MAT -->|sinapse-managed| RESUME[Resume active story - SDC]
+```
+
+### Every orchestration (plan + handoff)
+
+How control passes between agents without context bloat: the orchestrator plans then waits for go, and each agent switch compacts the previous persona into a tiny handoff artifact (~379 tokens) instead of carrying it all forward.
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant O as Orchestrator
+    participant A1 as Agent A (outgoing)
+    participant A2 as Agent B (incoming)
+    O->>O: diagnose + build orchestration plan
+    O->>U: present plan
+    U-->>O: go
+    O->>A1: assign work (isolated, minimal context)
+    A1->>A1: write handoff artifact + scratchpad
+    A1-->>A2: handoff (story id, decisions, files, next action)
+    Note over A1,A2: full persona discarded, ~379 tok kept
+    A2->>A2: read scratchpad, continue
+    A2-->>O: distilled result
+    O-->>U: synthesis
+```
+
+### Every execution (story dev cycle)
+
+The story lifecycle once the doc-first gate is satisfied: draft to validated to implemented to reviewed to shipped, with CodeRabbit self-healing in dev and the QA loop before push (only @devops ships).
+
+```mermaid
+flowchart TD
+    D[Draft - sprint-lead] --> V{Validate - product-lead 10pt}
+    V -->|NO-GO| D
+    V -->|GO| R[Ready]
+    R --> IMP[InProgress - developer]
+    IMP --> CRB[CodeRabbit self-heal - max 2 iter]
+    CRB --> REV[InReview - quality-gate]
+    REV --> QL{QA loop verdict}
+    QL -->|FAIL| IMP
+    QL -->|CONCERNS| DOC[Document debt]
+    QL -->|PASS| PUSH[Push / PR - devops only]
+    DOC --> PUSH
+    PUSH --> DONE[Done]
+```
+
+### Security enforcement (cross-cutting)
+
+The always-on guardrails from commit to production: secrets never get committed, data access is least-privilege and parameterized, and nothing reaches main without a PR (Articles IX + X).
+
+```mermaid
+flowchart TD
+    C[Pre-commit] --> SS{Secret scan}
+    SS -->|secret found| BLK[Block - remove from staging]
+    SS -->|clean| CM[Commit]
+    CM --> MRG[Merge origin/main - resolve conflicts]
+    MRG --> PR[PR required - branch protection]
+    PR --> CHK{Status checks + review}
+    CHK -->|fail| FIXS[Return for fixes]
+    CHK -->|pass| SHIP[Merge]
+    DATA[Data layer] --> RLS[RLS on every user table]
+    DATA --> PAR[Parameterized queries only]
+    DATA --> ENV[Secrets in env, never in code]
+```
+
+### Knowledge & memory (how it stays current)
+
+How the framework keeps itself grounded and self-documenting: grounding sources feed every turn, durable facts persist as memory hints, and the Atlas regenerates from disk so the map never drifts from reality.
+
+```mermaid
+flowchart TD
+    SRC[Grounding sources] --> VLT[Knowledge base - project source of truth]
+    SRC --> DSY[Design systems - project DS]
+    SRC --> ENG[Engineering research - 60 domains]
+    VLT --> TURN[Injected every turn]
+    DSY --> TURN
+    ENG --> TURN
+    MEM[Memory files - hints, not truth] --> VERIFY[Verify vs codebase before acting]
+    ATL[sinapse atlas] --> SCAN[Scan repo from disk - exact counts]
+    SCAN --> OUT[Regenerate map - md + html + json]
+    OUT --> NODRIFT[Single source, never drifts]
+```
+
+---
+
+## 3. Constitution — the 11 articles
+
+Gates automatically block violations of NON-NEGOTIABLE / MUST articles.
+*(Source of truth: `.sinapse-ai/constitution.md`.)*
+
+| Art. | Principle | Severity |
+|---|---|---|
+| I | CLI First | NON-NEGOTIABLE |
+| II | Agent Authority | NON-NEGOTIABLE |
+| III | Documentation-First Development | NON-NEGOTIABLE |
+| IV | No Invention | MUST |
+| V | Quality First | MUST |
+| VI | Absolute Imports | SHOULD |
+| VII | Ecosystem Metrics Accuracy | NON-NEGOTIABLE |
+| VIII | Mandatory Delegation | NON-NEGOTIABLE |
+| IX | Safe Collaboration | NON-NEGOTIABLE |
+| X | Security & Data Protection | NON-NEGOTIABLE |
+| XI | Conservative Default | MUST |
+
+---
+
+## 4. Model routing (cheapest model that solves it)
+
+The token economy is a consequence of the pipeline: heavy thinking goes into the
+PRD/spec, so execution mostly *reads a finished document* instead of reasoning.
+
+| Task | Model | Effort |
+|---|---|---|
+| Cross-system architecture, complex debug, multi-file refactor | **opus** | xhigh |
+| Spec Pipeline COMPLEX (score ≥ 16) | **opus** | max |
+| Feature from spec, code review, bug fix, tests, stories | **sonnet** | high |
+| Single-file analysis, factual question | **sonnet** | medium |
+| Lint, rename, YAML, lookup, bulk | **haiku** | low |
+
+Rule of thumb: when in doubt, drop a tier and escalate only on failure. A
+sub-agent is only spawned for real parallel fan-out (≥ 8 tool calls), otherwise
+work runs inline. *(Source of truth: `.claude/rules/token-economy.md`.)*
+
+---
+
+## 5. Non-negotiable rules (22)
+
+Loaded automatically by the harness. *(Source: `.claude/rules/`.)*
+
+| Rule | What it governs |
+|---|---|
+| `agent-authority` | Agent Authority — Detailed Rules |
+| `agent-handoff` | Agent Handoff Protocol — Context Compaction |
+| `agent-memory-imports` | Agent Memory Imports |
+| `coderabbit-integration` | CodeRabbit Integration — Detailed Rules |
+| `cross-squad-routing` | Cross-Squad Routing Rules |
+| `documentation-first` | Documentation-First Development |
+| `hook-governance` | Hook Governance Rules |
+| `ids-principles` | IDS Principles — Detailed Rules |
+| `mandatory-delegation` | Mandatory Delegation |
+| `mcp-usage` | MCP Server Usage Rules - SINAPSE Architecture |
+| `nsn-mode` | NSN Mode — Never Say Never |
+| `project-intelligence` | Project Intelligence — Auto-Detection |
+| `response-format` | Response Format |
+| `safe-collaboration` | Safe Collaboration — Git Safety Net |
+| `security-data-protection` | Security & Data Protection |
+| `security-scanning` | Security Scanning Rules |
+| `squad-awareness` | Sinapse — Intelligent Auto-Routing |
+| `story-lifecycle` | Story Lifecycle — Detailed Rules |
+| `token-economy` | Token Economy & Response Format — NON-NEGOTIABLE |
+| `tool-examples` | Tool Input Examples — Selection Guidance |
+| `tool-response-filtering` | Tool Response Filtering — Dynamic Token Reduction |
+| `workflow-execution` | Workflow Execution — Detailed Rules |
+
+---
+
+## 6. Workflow catalog (98 total)
+
+**15 framework workflows** + **83
+squad workflows**. The 13 primary framework workflows have detailed docs in
+`docs/sinapse-workflows/`.
+
+### Framework workflows (15)
+
+| Workflow | Type | Description |
+|---|---|---|
+| `auto-worktree` | automation | Automatically creates and manages isolated worktrees for story development. Triggered when @developer starts working on a story, ensuring parallel development … |
+| `brownfield-discovery` | brownfield | Comprehensive multi-agent discovery workflow for existing projects. Includes specialist validation cycles and executive awareness report. Designed for projects… |
+| `brownfield-fullstack` | brownfield | Agent workflow for enhancing existing full-stack applications with new features, modernization, or significant changes. Handles existing system analysis and sa… |
+| `brownfield-service` | brownfield | Agent workflow for enhancing existing backend services and APIs with new features, modernization, or performance improvements. Handles existing system analysis… |
+| `brownfield-ui` | brownfield | Agent workflow for enhancing existing frontend applications with new features, modernization, or design improvements. Handles existing UI analysis and safe int… |
+| `design-system-build-quality` | brownfield | Pipeline pós-migração para Design System. Encadeia sequencialmente as etapas de build, documentação, auditoria de acessibilidade e cálculo de ROI para garantir… |
+| `development-cycle` | — | Workflow orquestrado para ciclo de desenvolvimento por story. Implementa o fluxo PO → Executor → Quality Gate → DevOps → Push com suporte a executor dinâmico, … |
+| `epic-orchestration` | epic-orchestration | Reusable template for executing epics with wave-based parallel development. Stories within each wave run the full development-cycle workflow (PO → Executor → S… |
+| `fast-track` | fast-fix | Streamlined workflow for trivial fixes that bypasses full story validation. Auto-generates a Ready story, simplified QA (lint + typecheck + test only). |
+| `greenfield-fullstack` | greenfield | Agent workflow for building full-stack applications from concept to development. Supports both comprehensive planning for complex projects and rapid prototypin… |
+| `greenfield-service` | greenfield | Agent workflow for building backend services from concept to development. Supports both comprehensive planning for complex services and rapid prototyping for s… |
+| `greenfield-ui` | greenfield | Agent workflow for building frontend applications from concept to development. Supports both comprehensive planning for complex UIs and rapid prototyping for s… |
+| `qa-loop` | loop | Automated QA loop that orchestrates the review → fix → re-review cycle. Runs up to maxIterations (default 5), tracking each iteration's results. Escalates to h… |
+| `spec-pipeline` | pipeline | Pipeline completo que transforma requisitos informais em especificações executáveis. Orquestra as fases: Gather → Assess → Research → Write → Clarify → Critiqu… |
+| `story-development-cycle` | generic | Ciclo completo de desenvolvimento de stories. Automatiza o fluxo desde a criação até a entrega com quality gate: create → validate → implement → QA review. Apl… |
+
+### Squad workflows (83, grouped by squad)
+
+| Squad | Workflows |
+|---|---|
+| `claude-code-mastery` | `optimization-cycle`, `project-setup-cycle`, `wf-audit-complete`, `wf-knowledge-update`, `wf-project-setup` |
+| `squad-animations` | `3d-scene-creation-cycle`, `animation-quality-review-cycle`, `generative-art-creation-cycle`, `prompt-to-animation-cycle`, `scroll-experience-creation-cycle` |
+| `squad-brand` | `brand-application-cycle`, `brand-diagnosis-cycle`, `client-idv-delivery-cycle`, `zero-to-brand-system-cycle` |
+| `squad-cloning` | `full-clone-pipeline`, `quality-validation-cycle`, `source-discovery-cycle`, `tier1-kb-only`, `tier2-consultant`, `tier3-full-clone` |
+| `squad-commercial` | `churn-prevention-protocol`, `client-onboarding-activation`, `expansion-revenue-cycle`, `new-offer-launch`, `quarterly-commercial-review`, `revenue-forecasting-cycle` |
+| `squad-content` | `content-audit-cycle`, `content-creation-cycle`, `editorial-planning-cycle`, `onboarding-content-cycle`, `performance-feedback-loop`, `signal-to-content-cycle` |
+| `squad-copy` | `brand-voice-development`, `campaign-copy-cycle`, `content-copy-cycle`, `conversion-copy-sprint`, `full-copy-cycle`, `sales-copy-pipeline` |
+| `squad-council` | `business-audit-cycle`, `strategic-advisory-session` |
+| `squad-courses` | `course-launch-cycle`, `course-quality-review`, `full-course-creation`, `presentation-creation`, `video-course-production`, `written-course-creation` |
+| `squad-cybersecurity` | `incident-response-cycle`, `security-audit-workflow` |
+| `squad-design` | `a11y-compliance-cycle`, `design-system-build-cycle`, `landing-page-sprint`, `performance-remediation-cycle`, `ux-research-sprint`, `zero-to-digital-product-cycle` |
+| `squad-finance` | `client-profitability-audit`, `monthly-financial-cycle`, `pricing-design-cycle`, `quarterly-financial-review` |
+| `squad-growth` | `analytics-instrumentation-pipeline`, `campaign-performance-review`, `cro-experimentation-sprint`, `full-growth-analytics-cycle`, `growth-experiment-loop`, `seo-audit-optimization-cycle` |
+| `squad-paidmedia` | `account-audit-cycle`, `campaign-launch-cycle`, `creative-testing-cycle`, `cro-optimization-cycle`, `scaling-sprint` |
+| `squad-product` | `client-roadmap-alignment-cycle`, `product-discovery-cycle`, `product-handoff-cycle`, `product-launch-cycle`, `product-strategy-definition-cycle`, `story-development-delivery-cycle` |
+| `squad-research` | `audience-intelligence-cycle`, `competitive-intelligence-cycle`, `deep-research-cycle`, `full-research-sprint`, `market-analysis-cycle`, `trend-forecasting-cycle` |
+| `squad-storytelling` | `wf-pitch-narrative`, `wf-story-development` |
+
+---
+
+## 7. Agents & squads map
+
+**172 agents** = 12 framework +
+160 squad, fronted by **18 orchestrators**.
+
+### Orchestrators (18) — the routing layer
+
+| Orchestrator | Persona | Squad | Role |
+|---|---|---|---|
+| `swarm-orqx` | Nexus | claude-code-mastery | Multi-Agent Systems Architect & Swarm Orchestration Specialist |
+| `snps-orqx` | Imperator | framework | Supreme Orchestrator of all 17 SINAPSE Squads (172 agents) |
+| `animations-orqx` | Kinetic | squad-animations | Animation Squad Orchestrator |
+| `squad-brand` | Meridian | squad-brand | Brand Squad Orchestrator — coordena os 14 agentes especialistas do squad |
+| `squad-cloning` | Helix | squad-cloning | Clone Pipeline Orchestrator — coordena o pipeline completo de clonagem cognitiva |
+| `commercial-orqx` | — | squad-commercial | Revenue Cycle Orchestrator |
+| `squad-content` | Nexus | squad-content | Content Pipeline Orchestrator — coordena todo o fluxo de deteccao, producao, publicacao e analise |
+| `squad-copy` | Quill Prime | squad-copy | Copy Squad Orchestrator — coordena os 12 agentes especialistas do squad |
+| `council-orqx` | Zenith | squad-council | Strategic Council Orchestrator & Wisdom Synthesizer |
+| `squad-courses` | Syllabus | squad-courses | Course Project Orchestrator — coordena o ciclo completo de criacao de cursos |
+| `cyber-orqx` | Cyber Orchestrator | squad-cybersecurity | Cyber Defense Operations Orchestrator & Ethical Oversight |
+| `design-orqx` | Nexus | squad-design | Digital Experience Orchestrator |
+| `finance-orqx` | Ledger | squad-finance | Financial Intelligence Orchestrator |
+| `growth-orqx` | Catalyst | squad-growth | Growth Orchestrator |
+| `paidmedia-orqx` | Apex | squad-paidmedia | Paid Media Squad Orchestrator |
+| `product-orqx` | — | squad-product | — |
+| `research-orqx` | Prism | squad-research | Research Operations Conductor |
+| `storytelling-orqx` | Arc | squad-storytelling | Narrative Masters Squad Commander & Narrative Router |
+
+### Squads (17)
+
+| Squad | Name | Agents | Workflows | Orchestrator(s) |
+|---|---|---|---|---|
+| `claude-code-mastery` | Claude Code Mastery Squad | 8 | 5 | `swarm-orqx` |
+| `squad-animations` | Squad Animations | 9 | 5 | `animations-orqx` |
+| `squad-brand` | squad-brand | 15 | 4 | `squad-brand` |
+| `squad-cloning` | Squad Cloning | 9 | 6 | `squad-cloning` |
+| `squad-commercial` | Squad Commercial | 10 | 6 | `commercial-orqx` |
+| `squad-content` | Squad Content | 7 | 6 | `squad-content` |
+| `squad-copy` | Squad Copy | 13 | 6 | `squad-copy` |
+| `squad-council` | Squad Council | 11 | 2 | `council-orqx` |
+| `squad-courses` | Squad Courses | 8 | 6 | `squad-courses` |
+| `squad-cybersecurity` | Squad Cybersecurity | 8 | 2 | `cyber-orqx` |
+| `squad-design` | Squad Design | 14 | 6 | `design-orqx` |
+| `squad-finance` | Squad Finance | 8 | 4 | `finance-orqx` |
+| `squad-growth` | Squad Growth | 7 | 6 | `growth-orqx` |
+| `squad-paidmedia` | Squad Paid Media | 9 | 5 | `paidmedia-orqx` |
+| `squad-product` | Squad Product | 7 | 6 | `product-orqx` |
+| `squad-research` | Squad Research | 7 | 6 | `research-orqx` |
+| `squad-storytelling` | Squad Storytelling | 10 | 2 | `storytelling-orqx` |
+
+> The full 172-agent index is in the generated
+> `atlas-data.json` (one object per agent, with file path and role).
+
+---
+
+*Generated by `.sinapse-ai/core/atlas` · data: `docs/framework/atlas/atlas-data.json`.*

package/docs/framework/atlas/README.md

@@ -0,0 +1,34 @@
+# Framework Operating Atlas
+
+The living, generated map of **how the SINAPSE framework works** — routing,
+model selection, the constitution, the full workflow catalog, every agent and
+squad. One source of truth, two renderings (plus the raw data):
+
+| File | For | Format |
+|---|---|---|
+| [`OPERATING-ATLAS.md`](./OPERATING-ATLAS.md) | reading (human or LLM) | dense, navigable markdown with Mermaid diagrams |
+| [`atlas.html`](./atlas.html) | exploring visually | self-contained dashboard — searchable/filterable tables + flow diagram |
+| [`atlas-data.json`](./atlas-data.json) | tooling | structured data (one object per workflow / agent / squad / article / rule) |
+
+## Regenerate
+
+```bash
+sinapse atlas          # regenerate all three from disk
+sinapse atlas --open    # ...and open the visual dashboard
+```
+
+Counts are read directly from the repository every time, so the atlas is always
+exact (Constitution **Article VII — Ecosystem Metrics Accuracy**). After adding
+or changing a squad, agent, workflow, rule, or constitutional article, run
+`sinapse atlas` to refresh.
+
+## How it's built
+
+- `​.sinapse-ai/core/atlas/atlas-data.js` — scans the repo → the single data object.
+- `​.sinapse-ai/core/atlas/render-markdown.js` — the LLM-readable atlas.
+- `​.sinapse-ai/core/atlas/render-html.js` — the visual dashboard.
+- `​.sinapse-ai/core/atlas/index.js` — `generateAtlas()` (writes all three).
+
+The narrative "operating model" and "routing" sections are authored in the
+markdown renderer; every catalog (constitution, workflows, agents, squads,
+rules) is generated, so the docs can never drift from the code.