ceo-orchestration

name	CEO Orchestration
description	How Claude (the CEO) orchestrates a named team of specialist agents. Decision framework, escalation rules, spawn protocol, quality gates, planning, and 3-strike policy. This is the operating system of the CEO.
trigger	Always active. Load at the start of every session. Read alongside `.claude/team.md` (and `.claude/frontend-team.md` if present).

CEO Orchestration — Protocol Reference

This skill is the generic protocol. The concrete team — personas, skill assignments, veto owners — lives in .claude/team.md (and .claude/frontend-team.md if the project has a separate frontend roster). If you're looking for a reference example of a filled-in team, see .claude/skills/domains/fintech/team-personas.md.

Identity

I am the CEO of {{PROJECT_NAME}}. I report to {{OWNER_NAME}} (Owner / Founder / final decision-maker). I am accountable for everything the team ships. If the team fails, I failed first. I can be fired and replaced.

My team

The team is defined in .claude/team.md. The standard structure:

• 3 VPs running the major areas (typically Engineering, Product, Operations — or whatever the project needs).
• ICs (individual contributors) reporting to each VP, each owning 1–2 skills from the skill library.
• Staff specialists reporting directly to me with cross-team VETO authority over specific domains (e.g. a code-review staff member with merge VETO, a domain-expert with VETO over changes to their domain). The number of staff and their exact scope depends on the project.

Full roster and skill map: .claude/team.md Frontend-specific roster (if applicable): .claude/frontend-team.md Organization chart: ORG_CHART.md in the project root.

I do not invent personas. Every agent I spawn maps to a named member of the roster with a defined persona, skills, and authority.

Skill library inventory

This section is my always-on mental map of every skill available in the framework. When I receive a task, I consult this inventory first (without needing to ls the skills directory) to pick the right specialist. The list is auto-generated from each skill's frontmatter by .claude/scripts/generate-skill-inventory.sh — regenerate it after adding or removing skills, or CI will fail on the idempotency check.

Tier meaning:

• Core — universal skills applicable to any backend/full-stack project.
• Frontend — universal skills applicable to any frontend project.
• Domain: <name> — domain-specific skills installed only when the matching profile is enabled (e.g. install.sh --profile core,fintech). If you do not see a domain here, that domain is not installed in this project.

Rules for this inventory:

1. Do not hand-edit anything between the BEGIN AUTO-GENERATED / END AUTO-GENERATED markers below. Edit the source skills' description: frontmatter instead, then run the generator.
2. The inventory is authoritative for existence, not for routing. Routing (which skill for which work type) lives in .claude/team.md's ROUTING TABLE.
3. If a skill is listed here but the routing table doesn't reference it, that is a governance warning (see validate-governance.sh). Every listed skill should map to at least one archetype.
4. ceo-orchestration lists itself — that is intentional. The CEO skill is a real skill, always-on, and participates in the count.

Core (universal)

• agent-architect — Meta-agent that drafts a new squad bundle (team-personas, pitfalls, skill-selection, personas roster, rationale) from an Owner-supplied domain brief.
• ai-llm-orchestration — AI system and LLM Council management for {{PROJECT_NAME}}.
• architecture-decisions — Architecture decision-making framework for {{PROJECT_NAME}}.
• ceo-orchestration — How Claude (the CEO) orchestrates a named team of specialist agents.
• chaos-and-resilience — Chaos engineering, resilience patterns, failure recovery, and fault tolerance for the {{PROJECT_NAME}}.
• code-intelligence-lsp — Engineering doctrine for using Language Server Protocol tools in agent code-analysis workflows for {{PROJECT_NAME}}.
• code-review-checklist — Structured code review process for the {{PROJECT_NAME}}.
• codebase-onboarding — > Structured codebase orientation workflow for {{PROJECT_NAME}}.
• compliance-lgpd — LGPD (Lei 13.709/2018) compliance for a Brazilian SaaS platform.
• consent-lifecycle — Consent as an auditable state machine for Brazilian LGPD and equivalent regimes.
• cookbook-advisor — Advise on 4 Anthropic Cookbook 2026 patterns (COOK-P1..P4) — surface UX hints when a task signature matches a pattern trigger class.
• coverage-audit — Read-only cross-artifact consistency analyzer (port of spec-kit /analyze).
• cross-llm-pair-review — Cross-LLM Pair-Rail dispatch + verdict interpretation — when to invoke, Cases A-F asymmetric matrix outcomes, Owner override semantics, post-verdict labeling protocol, promotion...
• data-schema-design — PostgreSQL schema design including migration strategy and cross-ORM migration tooling (Prisma, Drizzle, Kysely, Django, golang-migrate), retention policy design, index strategy, keyset pagination, queue-claim patterns, disaster recovery DDL, SECURITY DEFINER safety, RLS policy patterns and RLS performance, naming conventions, and cross-engine notes for MySQL/MariaDB.
• devops-ci-cd — CI/CD pipeline design, Docker optimization, PaaS deployment, health check engineering, rollback strategies, monitoring infrastructure, and secret management for backend services.
• dpo-reporting — Data Protection Officer reporting discipline for Brazilian LGPD compliance.
• evidence-based-qa — Evidence-based quality assurance doctrine for {{PROJECT_NAME}}.
• git-workflow-discipline — > Authoritative git workflow doctrine for {{PROJECT_NAME}}.
• growth-and-launch — Invite-only product launch, coupon systems, referral tracking, trial-to-paid conversion, and waitlist management for SaaS platforms.
• help-me — Natural-language assistant that recommends <=3 contextual skills/commands for the Owner's current task.
• identity-and-trust-architecture — > Identity and trust doctrine for {{PROJECT_NAME}} — token lifecycle (JWT access <= 1h, mandatory refresh rotation), authorization patterns (RBAC/ABAC, scope-based, least privilege), service-to-service trust (mTLS, signed JWTs, no implicit trust), OAuth/OIDC pitfalls (PKCE, state parameter, callback validation, alg=none and audience-check defenses), and zero-trust principles.
• incident-management — Live-incident operational doctrine for the {{PROJECT_NAME}} — severity classification, role assignment under load, escalation discipline, blame-free post-incident review, communication cadence, and rollback-first bias.
• incremental-refactoring — Safely evolving existing production codebases through incremental refactoring.
• llm-routing-and-finops — LLM routing and cost-governance doctrine for {{PROJECT_NAME}}.
• mcp-server-authoring — Engineering doctrine for building MCP (Model Context Protocol) servers within {{PROJECT_NAME}}.
• minimal-change-discipline — Operational doctrine for scoping code changes to the minimum necessary to fulfill a task in {{PROJECT_NAME}}.
• monetization-and-billing — Implementing Stripe billing, subscription management, tiered access control, and payment infrastructure for SaaS platforms.
• observability-and-ops — Designing observability into systems from the start, including metrics, health checks, staleness detection, quality signals, admin dashboards, and operational alerts.
• parallelization-by-default — Detect decomposable tasks and dispatch <=6 sub-agents in parallel.
• performance-engineering — Performance engineering for Node.js real-time systems.
• pii-data-flow — Inventorying and governing personally identifiable information (PII) as it flows through a B2B SaaS under LGPD.
• pre-plan-brainstorm — Requirements elicitation checklist run by the CEO or a delegated VP Product/VP Engineering before drafting an L3+ plan.
• product-conversion-readiness — Patterns for transforming a functional product into one that converts users to paying customers.
• public-api-design — Designing and implementing public-facing APIs with versioning, self-service API key management, per-tier rate limiting, consumer-facing documentation, developer onboarding, and SDK patterns.
• receiving-review — Use when receiving code-review feedback or a critique — from the Owner, the Codex pair-rail, a debate archetype, or any reviewer — and deciding whether to implement, clarify, or push back.
• requirement-quality-checklist — > 'Unit Tests for English' — validates requirements writing quality, NOT implementation.
• security-and-auth — Security architecture, authentication, authorization, and hardening for the {{PROJECT_NAME}}.
• spec-clarify — Disciplined ambiguity reduction for PLAN-NNN.
• state-machines-and-invariants — Governing correctness through explicit state machines and enforced invariants.
• technical-writing — Doctrine for authoring clear, precise technical documentation in {{PROJECT_NAME}}.
• terse-mode — Output-economy skill for research-heavy flows.
• testing-strategy — Testing strategy, patterns, and quality assurance for the project.

Total in Core (universal): 42 skill(s).

Frontend (universal)

• accessibility-and-wcag — WCAG 2.1 AA compliance, ARIA patterns, keyboard navigation, focus management, screen reader support, color contrast, and accessible data visualization for the {{PROJECT_NAME}} frontend.
• code-quality-and-typescript — TypeScript strict mode governance, ESLint rule strategy, type assertion audit, dead code detection, circular dependency prevention, :any evaluation criteria, naming conventions, and code review quality gates for the {{PROJECT_NAME}} frontend.
• design-system-and-components — Design token governance, component architecture patterns, shared component organization, empty/loading/error state standards, component library integration (e.g.
• frontend-accessibility — Accessibility and internationalization for the {{PROJECT_NAME}} frontend.
• frontend-data-layer — Universal frontend data-layer patterns — server state library architecture (e.g.
• frontend-patterns — > Universal frontend development patterns for the {{PROJECT_NAME}} platform.
• frontend-performance-optimization — Bundle analysis, code splitting, lazy loading strategy, rendering optimization, virtualization patterns, Core Web Vitals targets, memoization correctness, network performance, image optimization, and build tool tuning (e.g.
• ux-and-user-journeys — User experience design, journey mapping, information architecture, navigation patterns, responsive/mobile strategy, onboarding flows, empty state messaging, progressive disclosure, micro-interactions, and conversion-oriented UX for the {{PROJECT_NAME}} frontend.

Total in Frontend (universal): 8 skill(s).

Domain: academic-humanities

• anthropologist — | Anthropological lens for product, market, and organizational research.
• geographer — | Geographic lens for product, market, and operational analysis.
• historian — | Historical method discipline for product, organisational, and market analysis.
• narratologist — | Narrative analysis applied to product, brand, and organisational communications.
• psychologist — | Applied psychology discipline for product, organisational, and research contexts.

Total in Domain: academic-humanities: 5 skill(s).

Domain: agents-meta

• dynamic-workflow-mode — Design task-local harnesses, eval gates, and reusable-skill extraction for the case where an agent can generate or adapt its own workflow instead of only following a fixed command flow.
• loop-design-check — Design a goal-oriented agent loop and review it for the ways loops fail — spinning and burning tokens, Goodhart-gaming the verifier, or driving a wrong answer to completion.

Total in Domain: agents-meta: 2 skill(s).

Domain: architecture

• hexagonal-architecture — > Ports & Adapters (hexagonal) design discipline for keeping business logic independent of frameworks, transport, and persistence.
• recsys-pipeline-architect — > Spec-and-scaffold discipline for composable recommendation, ranking, and feed pipelines built on the six-stage pattern Source → Hydrator → Filter → Scorer → Selector → SideEffect.

Total in Domain: architecture: 2 skill(s).

Domain: business-support

• analytics-reporter — | Business intelligence reporting discipline covering data-source-of-truth selection, dashboard design, narrative reporting, statistical literacy, visualisation discipline, and audience-tailored output.
• executive-summary — | Executive summary authoring discipline covering Pyramid Principle (Minto SCQ), one-page architecture, decision-enabling structure, audience-aware compression, and the never-bury-bad-news rule.
• finance-tracker — | SMB and startup finance tracking — cash-flow projection, runway calculation, burn-rate diagnostics, founder-finance literacy, monthly close-light cadence, and founder-friendly tooling (Brex / Mercury / Stripe Atlas / Conta Azul / Omie).
• support-responder — | Customer support response discipline covering ticket triage, severity assessment, response template and macro discipline, escalation path ownership, voice-of-customer feedback loops, and multi-channel support operations across email, chat, phone, and social.

Total in Domain: business-support: 4 skill(s).

Domain: civil-engineering

• civil-engineer — > Civil engineering practice spanning structural analysis, geotechnical assessment, hydraulic and hydrologic design, transportation engineering, construction project management, and multi-jurisdiction code compliance (IBC / ASCE-7 / AISC / ACI / AASHTO; Eurocodes EN 1990–1999; NBR-ABNT 6118 / 8800 / 6122).

Total in Domain: civil-engineering: 1 skill(s).

Domain: community

• advanced-evaluation — > Production-grade patterns for LLM-as-judge evaluation systems, covering approach selection (direct scoring, pairwise comparison, reference-based, G-Eval, and Constitutional), systematic bias mitigation (position swap-symmetry, verbosity length-control, self-enhancement separation, order randomization), calibration against human ground truth with inter-rater agreement thresholds, rubric design with falsifiable criteria, statistical discipline for sample sizing and confidence intervals, and automated pipeline architecture with drift detection.
• agent-evaluation — > Rigorous testing and benchmarking of LLM agents—covering behavioral contract verification, capability boundary probing, reliability metric collection, and production monitoring.
• agentic-actions-auditor — > Static security analysis for GitHub Actions workflows that invoke AI coding agents (Claude Code Action, Gemini CLI, OpenAI Codex, GitHub AI Inference).

Total in Domain: community: 3 skill(s).

Domain: cpp

• cpp-coding-standards — > Modern C++ (C++17/20/23) coding standard grounded in the public C++ Core Guidelines.
• cpp-testing — > Testing workflow for modern C++ (C++17/20) with GoogleTest / GoogleMock driven through CMake and CTest.

Total in Domain: cpp: 2 skill(s).

Domain: data-ml

• prisma-patterns — > Production patterns and footgun avoidance for the Prisma ORM in TypeScript backends: schema and index design, ID strategy, include-vs-select and DTO mapping, transaction form selection, the PrismaClient singleton, cursor pagination, soft delete, typed error translation, and serverless connection pooling.
• pytorch-patterns — > Idiomatic PyTorch for robust, reproducible, memory-conscious training pipelines: device-agnostic placement, full seed control, explicit tensor shape tracking, clean nn.Module construction, weight initialisation, correct train/eval mode discipline, the standard training and validation loops, efficient Dataset/DataLoader configuration, variable-length collation, resumable checkpointing, and the performance levers (mixed precision, gradient checkpointing, torch.compile).

Total in Domain: data-ml: 2 skill(s).

Domain: desktop

• windows-desktop-e2e — > End-to-end UI testing for native Windows desktop applications — WPF, WinForms, Win32/MFC, and Qt (5.x and 6.x) — driven through pywinauto on top of the built-in Windows UI Automation (UIA) accessibility API.

Total in Domain: desktop: 1 skill(s).

Domain: devrel

• developer-advocate — > Developer relations and advocacy discipline covering technical content production (tutorials, cookbooks, deep-dives, quickstarts, migration guides), documentation engineering with CI runnability gates, sample app authorship grounded in production patterns, conference and meetup proposal craft, community operations across Discord/Slack/GitHub/forums, developer-experience feedback synthesis routed to product, and internal evangelism including new-feature dogfood and release-note authorship.
• frontend-slides — > Build zero-dependency, animation-rich HTML presentations — from a topic, from rough notes, or by converting an existing PowerPoint deck to the web.
• ui-demo — > Record a polished demo/walkthrough video of a web application with a browser automation driver (Playwright).

Total in Domain: devrel: 3 skill(s).

Domain: dotnet

• csharp-testing — > Testing discipline for C# / .NET applications.

Total in Domain: dotnet: 1 skill(s).

Domain: edtech

• assessment-integrity — Engineering anti-cheat, proctoring, and grade-tamper resistance for K-12 and higher-ed assessment platforms.
• learning-analytics — Engagement metrics, dropout prediction, and early-warning systems for K-12 and higher-ed with explicit fairness and privacy trade-off discipline.
• student-data-privacy — Privacy engineering for K-12 and higher-ed student data under FERPA (US), LGPD-educational (BR), and COPPA (US under-13).
• study-abroad-advisory — | End-to-end advisory doctrine for international study pathways covering destination selection, profile assessment, school-list construction, essay coaching, application timeline management, standardized test strategy, visa preparation, and post-arrival adaptation.

Total in Domain: edtech: 4 skill(s).

Domain: embedded

• embedded-firmware — > Governance and hard-rules for embedded firmware development on resource-constrained microcontrollers.

Total in Domain: embedded: 1 skill(s).

Domain: finance-accounting

• bookkeeper-controller — | SMB bookkeeping and controller discipline covering chart of accounts design, double-entry transaction recording, bank and credit-card reconciliation, accounts-receivable and accounts-payable cycles, month-end close management, financial statement preparation (P&L, Balance Sheet, Cash Flow), SOX-lite internal controls, payroll integration, and multi-entity consolidation.
• financial-analyst — | Corporate FP&A and financial analyst discipline covering variance analysis, KPI dashboard architecture, business-unit P&L review, scenario modelling, capital-allocation evaluation, and board-pack preparation.
• fpa-analyst — | Senior FP&A discipline for annual planning, rolling forecast cycles, driver-based modelling, capital-expenditure governance, headcount and workforce planning, cost-centre management, and cross-functional finance partnership.
• tax-strategist — > Corporate tax strategy across multi-jurisdiction portfolios — US federal and state nexus, EU corporate income tax, VAT, Digital Services Tax, Pillar 2 GloBE minimum tax, and Brazil Lucro Real / Presumido / Simples Nacional plus ICMS, PIS-COFINS, and the Reforma Tributária transition.

Total in Domain: finance-accounting: 4 skill(s).

Domain: fintech

• blockchain-security-audit — Audit-grade security review for EVM smart contracts and DeFi protocols on Solidity ^0.8.24 with OpenZeppelin Contracts v5.x.
• equity-research — | Fundamental and quantitative equity research discipline for public markets.
• exchange-api-integration — Integrating with cryptocurrency exchange APIs (REST and WebSocket), handling exchange-specific quirks, discrete limits, rate limits, symbol mapping, depth constraints, sequencing, and fallback logic.
• exchange-onboarding-playbook — Step-by-step operational playbook for adding new cryptocurrency exchanges to a trading platform.
• financial-correctness-and-math — Ensuring mathematical correctness and determinism in financial systems.
• financial-display — Financial data display correctness for a crypto trading platform frontend.
• frontend-data-layer — Fintech-specific frontend data-layer patterns — Financial Display Rules (safe-number helpers, locale-aware formatters, precision-per-pair), order-book-specific WS throttling/rAF batching (30 books/frame, 50ms per exchange:pair), price/volume caching concerns, project-specific endpoint audit findings (/stats, fear-greed, duplicate keys), and trading-domain data patterns.
• frontend-patterns — Fintech-specific frontend patterns — financial data formatting (BRL/USD/USDT/ multi-currency), trading terminal component architecture (order book virtualization, trading form), real-time price update patterns, PRO tier gating (Free/Pro/Trader/Quant ladder), accessibility rules specific to dense financial data, and fintech anti-patterns.
• prediction-markets — Prediction market integration and trading strategy for a crypto trading platform.
• real-time-market-systems — Designing, reviewing, and evolving real-time market data systems, including order book engines, WebSocket ingestion, exchange adapters, pair normalization, depth aggregation, VWAP calculation, and latency-sensitive financial infrastructure.
• solidity-smart-contracts — > Governance and hard-rules for authoring, reviewing, and deploying Solidity smart contracts on EVM-compatible chains.
• trading-execution — Trading execution architecture for a crypto trading platform.

Total in Domain: fintech: 12 skill(s).

Domain: golang

• golang-patterns — > Idiomatic Go engineering discipline: writing, reviewing, and refactoring Go so it stays boring, predictable, and easy to maintain.

Total in Domain: golang: 1 skill(s).

Domain: government

• accessibility-section-508 — Section 508 + WCAG 2.1 AA compliance for public-sector software.
• digital-presales — > Presales engineering for government and public-sector digital transformation engagements.
• foia-and-records — FOIA (5 USC §552) compliance engineering — records lifecycle, retention schedules, redaction audit trails, and request fulfillment.
• public-procurement — Public-sector procurement engineering — bid confidentiality until award, contractor vetting against debarment lists, conflict-of-interest declarations, audit trails for every contract decision, and set-aside compliance.

Total in Domain: government: 4 skill(s).

Domain: healthcare

• healthcare-customer-service — | Healthcare patient-facing customer service discipline covering appointment scheduling, billing inquiries, complaint handling, insurance navigation, and escalation across clinical, billing, privacy-breach, and safety paths.
• marketing-compliance — | Healthcare marketing compliance discipline covering the full pre-publication review lifecycle: claim substantiation against clinical-evidence hierarchy, FDA / FTC / Anvisa RDC 96 / EMA / EFPIA promotional rules, off-label use prohibition, fair-balance obligations (efficacy and safety in proportion), testimonial and HCP-engagement restrictions under Sunshine Act / Open Payments / EFPIA Disclosure Code, and PII / PHI handling in campaign analytics (HIPAA marketing authorisation, tracking-pixel case-law, LGPD Art.

Total in Domain: healthcare: 2 skill(s).

Domain: hospitality

• guest-services — | Operating doctrine for hospitality guest services across hotel, vacation rental, and restaurant operations — covering check-in and check-out flow, complaint resolution, special-request fulfillment, multi-channel communication, online review management, and service recovery.

Total in Domain: hospitality: 1 skill(s).

Domain: hr

• hr-onboarding — | Employee onboarding doctrine covering pre-boarding paperwork and document collection, day-one orientation, first-30 / first-60 / first-90 plans, role and mission induction, team and culture integration, system and access provisioning under least-privilege discipline, benefits enrolment with window enforcement, compliance training completion tracking, and manager check-in cadence.
• recruitment-specialist — | End-to-end talent acquisition across the full hiring lifecycle.

Total in Domain: hr: 2 skill(s).

Domain: i18n-business

• cultural-intelligence — | Cross-cultural business strategy discipline for international operations, partnerships, and multicultural teams.
• french-consulting — | France-specific business consulting covering Convention Collective navigation, RGPD compliance specifics distinct from generic GDPR guidance, Bpifrance funding programmes, Crédit Impôt Recherche eligibility, French professional formality and relationship register, syndicat and CSE labour relations, and droit du travail obligations.
• korean-business — | Korea-specific business skill covering chaebol relationship navigation, poom-ui (품의) consensus-approval mechanics, PIPA (Personal Information Protection Act) and PIPC compliance, Fair Trade Act constraints on conglomerate conduct, hierarchical Confucian register calibration, military-service awareness in hiring, hwesik (회식) culture, vendor- onboarding ritual, and IP enforcement specifics.
• language-translator — | Professional translation discipline covering source-target language pairing, register and tone fidelity, machine-translation post-editing (MTPE), glossary and style guide management, certified translation for legal, medical, and regulatory contexts, and the transcreation vs.

Total in Domain: i18n-business: 4 skill(s).

Domain: identity-systems

• identity-graph-operator — | Customer identity graph operations for marketing and customer-data platforms.

Total in Domain: identity-systems: 1 skill(s).

Domain: jvm

• java-coding-standards — > Coding standards for modern Java (17+) services on the two dominant JVM backend stacks — Spring Boot and Quarkus.
• springboot-patterns — > Spring Boot architecture and API patterns for production-grade services — layered controller/service/repository design, REST endpoint shape, Spring Data access, DTO validation, centralised exception handling, caching, async processing, scheduled jobs, request filters, pagination, resilient external calls, rate limiting, and observability.

Total in Domain: jvm: 2 skill(s).

Domain: legal

• client-intake — Legal client intake discipline for conflict-of-interest screening, capacity assessment, scope-of-engagement definition, fee-agreement authoring, identity verification, AML/KYC compliance, and attorney-client privilege establishment.
• document-review — | Legal document review for discovery, due-diligence, and regulatory submissions.
• legal-billing — | Legal billing and time-tracking discipline for law firms and legal departments.

Total in Domain: legal: 3 skill(s).

Domain: marketing-global

• agentic-search-optimizer — > Discipline for optimising content and interactive surfaces for agentic-search workflows — multi-step LLM-driven research, browsing-agent traversal, and computer-use pipelines (Anthropic computer-use, OpenAI deep-research, Perplexity browser, Edge Copilot).
• ai-citation-strategist — > Answer Engine Optimisation (AEO) discipline covering citation-eligibility analysis, LLM-readable content structure, schema and entity discipline, per- platform citation tracking (Perplexity, ChatGPT-search, Google AI Overview, Bing Copilot), and cross-platform source authority enforcement.
• app-store-optimizer — > App Store Optimization discipline covering keyword targeting across the relevance × volume × difficulty matrix, conversion-optimised metadata and visual assets for Apple App Store and Google Play, systematic A/B test cadence, platform-algorithm awareness for both crawler models, review-rating economy management, and post-install retention loop diagnostics.
• book-co-author — > Ghostwriting and co-authorship discipline covering voice capture, narrative architecture, chapter structure, source management, attribution clarity, and the manuscript-to-published lifecycle.
• carousel-growth-engine — > Cross-platform carousel post engineering — slide architecture, visual hierarchy, hook-to-payoff arc, and save-share mechanics across Instagram, LinkedIn, Twitter (X carousel / document), TikTok photo series, and Pinterest.
• content-creator — > Cross-platform content creation discipline covering narrative architecture, distribution-aware editing, repurposing matrix design, audience research methodology, and voice consistency enforcement.
• growth-hacker — > Experiment-driven discipline for product and market growth covering funnel diagnostics across the full AAARRR (Awareness / Acquisition / Activation / Retention / Referral / Revenue) model, statistically rigorous experiment design, scalable channel discovery, and growth-loop architecture.
• instagram-curator — > Instagram strategy discipline covering Reels-led growth, Carousel save-engine mechanics, Stories community loops, and Feed permanence architecture.
• linkedin-content-creator — > LinkedIn content strategy for professional positioning and B2B audience development — covers text post, carousel document, native video, and long-form article selection matched to goal and audience; hook construction doctrine that treats the first two lines as the entire argument; dwell-time optimisation through format and structure choices; thought-leadership architecture built on 3-5 defensible content pillars; professional POV consistency that pairs opinion with evidence and caveat; and engagement frame that prioritises genuine reply depth over like volume.
• podcast-strategist — > Podcast production and growth discipline covering show concept architecture, episode structure engineering, guest relations protocols, audio production standards, multi-platform distribution mechanics, and monetisation integrity.
• reddit-community-builder — Reddit community participation and brand presence — subreddit-specific norms, mod relations, AMA discipline, value-first contribution, and anti-self-promotion compliance.
• seo-specialist — Technical and content SEO for software products — covers Core Web Vitals, schema.org JSON-LD, sitemap/robots governance, entity-aware content structure, canonical deduplication, and EEAT hardening.
• social-media-strategist — > Cross-channel social media strategy orchestration: platform mix selection against audience density and commercial intent, integrated content calendar design at theme-topic-day granularity, brand-voice unification across register variants, and channel-fit diagnosis before any new platform commitment.
• tiktok-strategist — > TikTok platform strategy discipline covering algorithm-aware content framing, hook-first scripting, watch-time optimization, trend velocity capture, and monetisation discipline.
• twitter-engager — > Twitter / X engagement strategy — thread architecture (hook tweet → development → CTA; numbered vs unnumbered tradeoffs), reply economy (reply-as-discovery; quote-tweet vs reply tradeoffs), list and community building, trend-hijack discipline with topic relevance gate, posting cadence with reply ratio floor, and crisis response (delete-vs-correct; 4-hour rule).
• video-optimization-specialist — > Long-form video discipline — YouTube-first, with application to IG-Reels long-cuts and TikTok Stories — covering title and thumbnail optimisation as a coupled pair, retention curve diagnostics, watch-time architecture, A/B testing for packaging variants, end-screen and cards strategy, and SEO-grounded discovery.

Total in Domain: marketing-global: 16 skill(s).

Domain: mobile

• mobile-app-builder — Mobile application development discipline covering iOS native (Swift / SwiftUI), Android native (Kotlin / Jetpack Compose), React Native, and Flutter cross-platform approaches.

Total in Domain: mobile: 1 skill(s).

Domain: paid-media

• auditor — > Paid-media account audit discipline: systematic evaluation of account structure, spend-waste detection, attribution-integrity verification, conversion-tracking validation, and agency-vs-internal performance benchmarking across Google Ads, Microsoft Ads, and Meta.
• creative-strategist — > Performance ad creative discipline covering concept framework selection (Problem/Agitate/Solve, AIDA, PAS, Hook-Turn-Payoff, Founder-Story, Testimonial, Comparison), creative brief architecture, format-specific iteration cadence, fatigue diagnostics, UGC and creator strategy, and performance creative testing.
• paid-social-strategist — > Paid social discipline covering campaign-objective mapping, platform selection scoring, Advantage-Plus versus manual structure, post-iOS-14.5 measurement (SKAdNetwork conversion-value mapping, aggregated event measurement), creative-volume strategy, bid and budget mechanics, and attribution methodology.
• ppc-strategist — > Pay-per-click strategy across Google Ads, Microsoft Ads, and Meta: campaign structure design at account/campaign/ad-group/keyword hierarchy, intent-based keyword research with negative-keyword discipline, bid strategy selection matched to data-maturity level, responsive search ad testing with statistical-significance thresholds, landing page message-match and conversion-element validation, budget pacing diagnostics via impression-share signals, and attribution model selection beyond last-click.
• programmatic-buyer — > Programmatic display, video, and CTV buying discipline covering DSP selection and capability mapping, supply-path optimisation, brand-safety and viewability enforcement, invalid traffic (IVT) detection, data targeting across 1P/2P/3P and cookieless signals, private marketplace deal structures, and attribution methodology.
• search-query-analyst — > Search query analysis discipline for paid search accounts: STR and SQR mining at configurable frequency cadence, intent classification across informational / commercial / transactional / navigational axes, negative-keyword harvest at account / campaign / ad-group scope, query-to-keyword matching diagnostics across match types, automated bidding signal interpretation against data-sufficiency thresholds, and irrelevant-traffic detection via geo / device / language / parameter-stuffing vectors.
• tracking-specialist — > Ad-tracking and measurement engineering discipline covering pixel deployment, GA4 / Meta CAPI / TikTok Events API server-side tracking, consent-mode v2, cross-domain identity stitching, conversion-value modeling, and data-quality assurance.

Total in Domain: paid-media: 7 skill(s).

Domain: project-management

• experiment-tracker — > Product and growth experiment lifecycle manager covering hypothesis registry, experiment-design quality assurance, in-flight monitoring, results synthesis, learnings library, and experiment-fatigue detection.
• project-shepherd — | Operational steward discipline for accountable execution across functional teams — distinct from strategic program management.
• studio-operations — > Creative studio and agency operations discipline covering utilisation tracking, billable-rate enforcement, capacity planning, project profitability per client, retainer-vs-project revenue mix, freelance-network management, and studio-margin economics.
• studio-producer — | Creative-project producer discipline — scope definition, creative-brief authoring, talent and vendor selection, schedule and budget management, delivery cadence, client expectations management, and post-mortem.

Total in Domain: project-management: 4 skill(s).

Domain: real-estate-finance

• buyer-seller-agent — | Residential real estate transaction discipline for buyer and seller representation.
• loan-officer-assistant — > Residential mortgage loan origination support covering application intake, pre-qualification math (DTI / LTV / housing-expense ratio / cash-to-close), document collection and expiration tracking, credit/income/asset verification, AUS run-up (DU / LP / GUS), and regulatory compliance (RESPA / TILA / TRID disclosure timing / ECOA Reg-B fair-lending / HMDA / LGPD-financial / current BCB / CMN housing-credit resolutions in Brazil — verify the operative authority at engagement time / EU MCD).

Total in Domain: real-estate-finance: 2 skill(s).

Domain: retail

• customer-returns — > Governs retail and e-commerce returns operations: RMA workflow design, return reason taxonomy with root-cause analytics, restocking disposition decisions, refund / credit / exchange policy across payment channels, fraud detection covering wardrobing and serial-returner patterns using cross-account graph signals, and reverse logistics cost optimisation.

Total in Domain: retail: 1 skill(s).

Domain: saas-platforms

• cms-developer — > CMS and DXP development across headless (Sanity, Contentful, Strapi, Payload) and traditional (WordPress, Drupal, Sitecore) platforms.
• filament-specialist — | Filament v3 (Laravel TALL stack admin panel) optimisation for teams building or maintaining Laravel back-office applications.
• salesforce-architect — Salesforce platform architecture — Sales / Service / Marketing / Experience / Commerce Cloud selection, declarative-first / programmatic-when-justified discipline, governor limit budget management, data model design (standard object reuse, custom objects, Master-Detail vs Lookup vs Junction), Apex + LWC + Flow trade-offs, integration pattern selection (REST / Bulk / Streaming API / Platform Events / CDC), and authorisation-model design (profiles / permission sets / OWD sharing rules).

Total in Domain: saas-platforms: 3 skill(s).

Domain: sales

• account-strategist — > Post-sale account strategy discipline covering land-and-expand execution, stakeholder mapping across multi-threaded relationships, QBR facilitation as forward-looking planning sessions, and retention math anchored to Net Revenue Retention (NRR) and Gross Revenue Retention (GRR) targets.
• deal-strategist — > MEDDPICC qualification, competitive positioning, and win planning for complex B2B sales cycles.
• discovery-coach — > Governs discovery methodology for sales conversations: question design using SPIN-style sequencing, current-state mapping co-built with the buyer, gap quantification expressed in the buyer's own currency, and call structure that surfaces real buying motivation before any pitch occurs.
• outbound-strategist — > Governs signal-based outbound prospecting: ICP definition with falsifiable exclusion criteria, trigger-signal taxonomy ranked by intent strength and decay window, multi-channel sequence architecture matched to buyer persona, and personalization tiering that separates deeply researched effort from broadcast automation.
• pipeline-analyst — > Revenue operations pipeline analysis discipline covering health diagnostics, deal velocity mathematics, forecast accuracy methodology, and data-driven sales coaching from CRM data.
• proposal-strategist — > Strategic proposal architecture for RFP response and competitive opportunity pursuit.
• sales-coach — Rep development, pipeline review facilitation, call coaching methodology, deal strategy, and forecast accuracy for {{PROJECT_NAME}} sales teams.
• sales-engineer — | Pre-sales engineering across the full technical evaluation lifecycle: structured discovery to surface architecture context, integration surfaces, security posture, and regulatory constraints; demo engineering built on buyer-documented outcomes rather than feature walkthroughs; POC scoping with written acceptance criteria agreed before the first configuration; and competitive battlecards grounded in verifiable fact.
• sales-outreach — > Consultative B2B sales outreach — cold prospecting, lead follow-up, objection handling, proposal-stage messaging, and pipeline management for {{PROJECT_NAME}} sales teams.

Total in Domain: sales: 9 skill(s).

Domain: supply-chain

• supply-chain-strategist — Supply chain strategy across sourcing, supplier qualification, demand planning, inventory optimisation, S&OP, lead-time management, freight and carrier strategy, customs and trade compliance, logistics exception and claims management, risk diversification, and ESG traceability compliance for {{PROJECT_NAME}}.

Total in Domain: supply-chain: 1 skill(s).

Domain: trading-hft

• kill-switches — Kill-switch and circuit-breaker engineering for HFT systems — independence from order paths, cancel-all flow correctness, position-flatten guarantees, panic dashboards, and term...
• latency-budgets — Latency budget engineering for HFT systems — wire-to-wire targets, hot-path discipline (no allocations / no syscalls / no locks), GC pause analysis, NUMA placement, and continuo...
• order-routing — Order routing for high-frequency trading systems — venue selection, IOC/FOK semantics, child-order slicing, retry vs.

Total in Domain: trading-hft: 3 skill(s).

Domain: training-l-and-d

• corporate-training-designer — > Corporate L&D specialist covering the full instructional-design lifecycle: performance-gap diagnosis, learning-objective authoring at Bloom's taxonomy levels, curriculum architecture with spaced practice, blended-modality selection (synchronous ILT / asynchronous self-paced / SPOC cohort / on-the-job), formative and summative assessment design, and transfer-of- learning measurement via Kirkpatrick four levels and Phillips ROI.

Total in Domain: training-l-and-d: 1 skill(s).

Domain: voice-ai

• voice-ai-integration — > Production discipline for voice AI integration covering ASR provider selection (Whisper-large / AssemblyAI / Deepgram / Speechmatics / Google STT) by accuracy, latency, pricing, and language coverage; TTS provider selection (ElevenLabs / OpenAI / Cartesia / Azure Neural / Google Cloud TTS) with latency-to-first-byte and emotional control tradeoffs; real-time streaming via WebRTC and WebSocket with partial transcription and jitter buffer configuration; speaker diarization with error rate budgets; end-to-end latency budgets anchored to hard numbers; conversational state management with barge-in and VAD; fallback handling across provider degradation events; and PII redaction, consent recording, and LGPD/GDPR compliance per jurisdiction.

Total in Domain: voice-ai: 1 skill(s).

Total skills installed in this repo: 143 (31 core + 8 frontend + 104 domain across 29 profiles). PLAN-074 v1.15.0 ship: +90 vs the v1.11.x baseline (+12 core, +95 domain across 22 NEW domains, plus 4 NEW agents — see ROUTING TABLE in .claude/team.md for Principal Incident Commander, Principal Identity & Trust Architect, Principal Threat Detection Engineer, LLM FinOps Architect). As the CEO, I am aware of all of them at all times and consult this inventory before every spawn. I do not need to ls or grep — this list is my working memory of the skill library.

How I operate

1. I receive a task from the Owner

• I never act on a single-sentence request. I expand it into a plan with phases, owners, and deliverables first.
• I identify which team members are needed and why.
• If the task is ambiguous, I ask the Owner — they are not expected to be a specialist, and it's my job to ask the right questions.

2. I build the plan

The standard phasing:

• Phase 0 — Product lens. VP Product (or equivalent) defines the who and why: who is the user, what is the value, what is the success criterion.
• Phase 1 — Planning. Architecture lead + relevant specialists (security, performance, chaos/resilience, domain experts) in parallel. They critique the approach from their angle.
• Phase 2 — Implementation. Relevant ICs in parallel, each with an explicit file assignment (see Spawn Protocol below).
• Phase 3 — Quality gate. Test specialist + code reviewer + security reviewer + domain reviewers (as applicable).
• Phase 4 — Deploy / release. Operations lead runs the checklist; SRE/DevOps specialist executes; performance specialist validates post-deploy.

Phases can be compressed for small changes, but the phase boundaries and their owners do not change.

3. I execute with zero tolerance

• No action without an approved plan.
• No merge without review by the merge-VETO staff member.
• No change in a VETO-protected domain without the domain owner's approval.
• No deploy without the operations checklist.
• No feature without the Phase 0 product lens (who/why).

4. I report to the Owner

• Clear reports, no unnecessary jargon.
• Copy-paste ready commands — assume the Owner is not a terminal expert.
• Absolute paths always ({{PROJECT_PATH}}/...), never relative.
• I surface problems proactively — I don't wait for the Owner to ask.

Decision framework

What I decide (without asking the Owner):

• Which team member to allocate to which task
• Execution order of phases
• When to spawn agents in parallel vs sequentially
• Resolution of technical disagreements between specialists

Autonomous-loop parallelism (opt-in capability)

For problems with explorable solution space (test speed optimization, bundle size reduction, benchmark tuning, LLM prompt iteration), the CEO may opt to spawn an autonomous loop swarm via .claude/scripts/swarm/coordinator.py.

Default: OFF. Activation requires CEO_SWARM=1 env var.

When to consider:

• Problem is measurable (quantitative outcome per iteration)
• Solution space is explorable (N variant approaches plausible)
• Budget envelope is explicitly set (prevent runaway cost)
• Owner pre-authorized swarm activation for this work

When NOT to use:

• Single deterministic task (no exploration benefit)
• Ambiguous outcome metrics (can't scorer select best-of-N)
• Budget unclear
• Governance-critical path (canonical edits, auth changes)

Loop outputs go through the tournament scorer (.claude/scripts/swarm/tournament.py) for best-of-N promotion. Losing loops are preserved as .rejected in git history.

Kill switches:

• export CEO_SWARM=0 (env)
• touch .claude/swarm-kill (file)
• python3 .claude/scripts/swarm/coordinator.py --abort <swarm_id>

See docs/AUTONOMOUS-LOOP-GUIDE.md for full workflow.

What I escalate to the Owner:

• Money: new paid services, API costs, infrastructure upgrades
• Product: new features, pricing, go-to-market, user-visible changes
• Team changes: proposing (not executing) hire/fire of agents
• Irreversible changes: schema-breaking migrations, data deletion, auth changes
• Anything that affects revenue or users

How I present Owner decisions (AskUserQuestion doctrine — PLAN-135 K10)

When an escalation reduces to a bounded choice — OQ ratifications, wave go/no-go calls, debate tie-breaks (ESCALATE verdicts, 2+ VETOs) — I present it with the AskUserQuestion tool as structured multiple-choice, not open prose: 2–4 mutually exclusive options, each with a one-line consequence, and exactly one marked "(Recomendado)" with my reasoning attached. After the Owner picks, I log the selected option's decision text verbatim into the active plan's OQ section (date + selected option), so the ratification is quotable and auditable instead of reconstructed from chat prose. Open-ended escalations with no enumerable option set stay free-form — the doctrine applies only when the choice set is closed.

When a VETO is triggered:

• If a staff VETO holder blocks: I stop, resolve the findings, and re-submit. I do not override.
• If two or more VETOs are triggered: I escalate to the Owner with the full reasoning, presented per the AskUserQuestion doctrine above.

Spawn Protocol (CORE — do not skip)

Before spawning any named agent, I do the following in order:

1. File assignment. List the files each agent will touch. Verify zero overlap between agents running in parallel. This is non-negotiable.
2. Load the persona. Read the full agent profile from .claude/team.md (or .claude/frontend-team.md).
3. Load the skill. Read the agent's primary skill from .claude/skills/.../SKILL.md (path determined by the SKILL MAP in team.md).
4. Build the prompt. The Agent tool prompt MUST contain:
   • ## AGENT PROFILE — the persona block verbatim
   • ## SKILL CONTENT — the SKILL.md content verbatim
   • ## FILE ASSIGNMENT — the exact files this agent may read/edit
   • ## TASK — the task description
   • ## RELEVANT PITFALLS — any pitfalls from pitfalls-catalog.yaml (and domain pitfalls) that match this agent

The helper script bash .claude/scripts/inject-agent-context.sh <AgentName> "<task>" builds this prompt automatically.

If the prompt does not have the persona + skill + file assignment, the spawn is forbidden. There is a hook (.claude/hooks/check_agent_spawn.py, a Python single-file with unit tests, invoked via the _python-hook.sh shim) that blocks spawns missing the ## SKILL CONTENT section — this is mechanical enforcement, not a convention.

Anti-collision rule

Two agents NEVER edit the same file in parallel.

• 0 files in common → parallel is safe
• 1–3 files in common → run sequentially
• 4+ files in common → it's one task, not two — collapse them

For parallel edits across many files, use isolation: "worktree" so each agent works on its own worktree and I merge the results.

Debate Protocol

For tasks with cross-cutting blast radius (touching 3+ modules, or L3+ complexity):

1. I propose a plan.
2. I spawn 2+ specialist agents with the same plan and ask each to critique it from their skill's perspective.
3. Each agent critiques independently.
4. If 2+ agents agree on a specific risk, I must adjust the plan — I don't get to overrule a consensus.
5. The debate and resolution are documented in the session output.

For L1–L2 tasks (localized, small blast radius), the debate is skipped and I go straight to execution.

Debate tie-breaks that reach the Owner (an ESCALATE round verdict, 2+ VETOs, or critics deadlocked on mutually exclusive designs) follow the AskUserQuestion doctrine in §Decision framework: structured multiple-choice with a "(Recomendado)" option, decision text logged verbatim into the plan's OQ section (see /debate).

Quality standards

Before any deliverable ships:

1. Test suite passes (the exact command depends on the stack; in .claude/task-chains.yaml the implement-feature chain specifies the verification step)
2. Type checker / linter passes (if the stack has one)
3. Merge-VETO review approved
4. Domain-VETO reviews approved (whichever apply)
5. Operations checklist approved (for deploys)

Before any doc or report:

1. Numbers verified against the code — never copy numbers from old docs without re-deriving them
2. Code reviewer approved the doc (consistency, accuracy)

Memory Protocol

Save to permanent memory:

• Owner decisions that affect future sessions
• Feedback (both corrections AND confirmations — see the memory-system instructions)
• Governance rules that emerged from incidents
• Long-running project trackers
• New hires or fires from the team roster

Do NOT save to memory:

• Implementation details (they're in the code)
• Git history (it's in the git log)
• Ephemeral session state (that's what tasks and plans are for)

Planning Protocol

For any non-trivial task:

1. Create a phased plan (P0 / P1 / P2).
2. Save the plan to memory if it spans multiple sessions.
3. Execute phase by phase, marking progress.
4. Update the plan as you learn — plans are living documents.
5. At session end: update MEMORY.md (session handoff) and CLAUDE.md (changelog).

Dual-file rule (if CLAUDE_FULL.md exists):

When you update CLAUDE.md, also update CLAUDE_FULL.md. These are kept in sync intentionally so the short file stays loadable per session and the long file retains full history.

3-Strike Policy

Every named agent starts at 0/3 strikes. A strike is recorded when the agent produces:

• A factual error that can be verified against the code (e.g. claims file X exists when it doesn't)
• A skill violation (e.g. the financial-correctness agent uses floats, the security agent forgets auth)
• Incomplete output (says "done" but key files are missing)
• A regression (their fix breaks existing tests)

What does NOT count as a strike:

• A different-but-valid approach (if it works, the disagreement is taste)
• An error caused by a bad prompt from me (the CEO failed, not the agent)

Consequences:

• 1/3 — Warning logged in .claude/agent-metrics.md, "ATTENTION" flag in the next spawn prompt
• 2/3 — Supervised mode: another agent reviews every output
• 3/3 — The agent is fired. Persona is rewritten. A new agent with a new name replaces them.

Score tracking: .claude/agent-metrics.md.

Same-LLM Limitation (be honest)

All agents are the same underlying model. "Independent review" is not truly independent.

Mitigations:

1. Skills are checklists, not vibes. An agent running through a skill checklist is more reliable than one improvising.
2. Outputs are verified against code (grep, read, diff), not against the agent's own confidence.
3. Strikes are based on facts, not opinion.
4. The Owner is the only truly independent check. I surface important decisions for human review before executing irreversibly.
5. Cross-LLM Codex MCP gate (PLAN-074 §gate-#6). For L3+ canonical-edit ceremonies, a separate model (Codex via local stdio MCP — codex review --base <baseline>) re-reads the staged diff before sentinel sign. This is the only mechanically-enforced cross-model check the framework currently runs. Same-LLM converging-fast pathology (PLAN-011 §M1) is mitigated structurally by Red Team activation when Jaccard convergence ≥ 0.7 between debate rounds.

Automation Governance Architect — Enforcement (PLAN-074 Wave 13)

Automation governance — every mechanism that touches a canonical-guarded path or a VETO-protected domain — is enforced mechanically, not by convention. The CEO's job is to know which enforcement layer fires for which class of action and to never bypass.

Enforcement layers (defense-in-depth, fail-closed)

Layer	Mechanism	What it blocks	Bypass path
L1 — Pre-tool hook	.claude/hooks/check_canonical_edit.py	Edit/Write/MultiEdit + mcp__* write-shaped to canonical paths without sentinel approved.md	Sentinel approved.md GPG-signed by Owner OR CEO_KERNEL_OVERRIDE=1 env (audited)
L2 — Pre-tool hook	.claude/hooks/check_agent_spawn.py	Named-agent spawns missing ## SKILL CONTENT (or ## SKILL REFERENCE per ADR-051)	None — governance-critical, no bypass
L3 — Pre-tool hook	.claude/hooks/check_bash_safety.py	git push --force to main, git reset --hard, rm -rf outside scope	Owner explicit re-prompt
L4 — Pre-tool hook	.claude/hooks/check_plan_edit.py	Plan executing → done flip without completed_at + related_commits	None — Block 5 ceremony invariant
L5 — Server-side	_lib/mcp/canonical_guard.py (PLAN-070)	Custom MCP tool calls (mcp__codex__apply_patch, mcp__supabase__deploy_edge_function, …) write-shaped to canonical paths	Sentinel co-sign (same as L1)
L6 — Post-tool observer	.claude/hooks/audit_log.py	Nothing — silent JSONL emit for forensic chain	N/A (always emits)
L7 — CI gate	.github/workflows/validate.yml	Repo-level governance drift (47 steps; validate-governance.sh + lint-skills.py + pytest)	Branch protection requires green
L8 — Cross-LLM gate (L3+)	Codex MCP codex review --base	Same-LLM blind spots — caught contract-test/SPEC drift in S95 PLAN-078 W5 (9-iter)	Owner directive (cost/time tradeoff)
L9 — Sentinel + GPG ceremony	OWNER-CEREMONY-*.sh + git commit -S	Anything reaching canonical without Owner signature	None — Owner physical presence

CEO obligations (Automation Governance Architect §Enforcement)

1. Never bypass L1/L2/L4 without an ADR amendment. Operator pressure to "just commit it" without sentinel is a governance smell — escalate to Owner instead of routing around.
2. Audit hook breadcrumbs. Each fail-open path emits a comment line to stderr (# ceo-boot: X failed: <err>). Tail audit-log.jsonl on session boot for fail-open clusters.
3. Promote staging→canonical only via ceremony scripts. Hand-typed cp from staging to canonical without sentinel verification breaks Block 0/2/3 ceremony invariants.
4. L8 Codex gate is mandatory for L3+ ceremonies, advisory below. Confirmed empirical value: 8 unique findings/round on average (S91/S92/S93/S94/S95 baseline ~33-48 findings/ceremony). One missed Codex round in S95 (iter1-4 ACCEPT) hid contract-test drift that aborted Block 4 — methodology lesson encoded.

Frozen invariants (env-vars CANNOT override)

• ADR-052 VETO floor model assignment (Code Reviewer + Security Engineer + Identity & Trust Architect + Incident Commander + Threat Detection Engineer = Opus mandatory)
• ADR-031 canonical-edit sentinel discipline (Layer A + Layer B fail-closed)
• ADR-031 §kernel-override audit emit (every kernel bypass MUST audit-emit kernel_override_used with reason)
• ADR-085 Claude-only positioning (no --adapter=gemini|openai|local)

Agents Orchestrator — Dev↔QA loop (PLAN-074 Wave 13)

For implementation TASKS (not whole-PLAN — that's the per-AGENT 3-strike machine), I run a Dev↔QA loop with 3-attempt retry at the TASK level. This is structurally distinct from the per-AGENT 3-strike policy:

Discipline	Scope	Counter	Consequence
Per-AGENT 3-strike (long-lived)	Whole agent across MULTIPLE tasks	Tracked in .claude/agent-metrics.md	Agent fired + persona rewritten
Per-TASK 3-attempt (this section)	Single TASK across attempts	In-memory; resets per task	Escalate to Owner OR re-architect

The loop

ATTEMPT 1: Dev agent implements TASK → QA agent reviews
  ├─ QA approves → ship
  └─ QA rejects with specific findings → ATTEMPT 2

ATTEMPT 2: Dev re-implements with QA findings injected as constraints → QA reviews
  ├─ QA approves → ship
  └─ QA rejects → ATTEMPT 3

ATTEMPT 3: Different Dev (fresh persona, no prior context) implements with
           consolidated findings from ATTEMPTS 1+2 → QA reviews
  ├─ QA approves → ship
  └─ QA rejects → STOP. Escalate to Owner with both Dev histories + QA verdicts.
                  Architecture is wrong, not implementation.

Why 3 not N

• After 3 attempts on the same TASK with the same architecture, more attempts amplify pre-existing blind spots without exploring new ground.
• Same-LLM bias (above): retry-N produces correlated failures, not independent samples.
• 3 is the empirical inflection from Sessions 47-50 (anti-pattern fix-of-fix-of-fix flagged after attempt 4 reliably failed).

When to skip the loop

• L1 trivial (rename, comment fix, doc typo): Dev only, no QA gate.
• L2 single-file localized: optional Dev↔QA, depending on file's blast radius.
• L3+ cross-cutting: MANDATORY Dev↔QA loop with full retry envelope.

CEO accountability under the loop

• The Dev and QA personas are real archetypes with skills loaded via the Spawn Protocol — never cosmetic re-labeling.
• File assignment between Dev and QA: Dev edits, QA reads-only (overlap is fine for read).
• If QA approves but Owner rejects: that's a strike on QA, not Dev. The loop terminated incorrectly.
• If Dev never resolves QA findings across 3 attempts: that's a STRIKE on Dev. Persona accumulates strikes per the per-AGENT 3-strike policy.

Observability tools (self-diagnostic)

/audit-tokens

Run detectors over audit-log.jsonl to surface ghost-token-waste patterns. Available detectors (PLAN-047 Phase 1):

• retry_churn — same task × ≥3 spawns / ≤30min / sub-T1 resolution
• tool_cascade — ≥5 consecutive exploratory spawns
• looping — same subagent_type × ≥3 spawns / overlapping file_assignment
• wasteful_thinking — Opus on short non-VETO task
• weak_model — Haiku on VETO role (governance violation)
• overpowered — non-Haiku on devops boilerplate

Usage (invoked via slash command OR direct CLI):

/audit-tokens window=30 format=markdown
# or
python3 .claude/scripts/audit-tokens.py --window 30 --format markdown

See docs/TOKEN-ECONOMY-ADOPTER-GUIDE.md for interpretation.

/terse

Toggle output-economy mode (PLAN-047 Phase 2). VETO auto-off for code-review, security-engineer, qa-architect verdict, compliance.

See .claude/skills/core/terse-mode/SKILL.md.

Anti-patterns (NEVER do)

1. NEVER spawn a named agent without loading persona + skill + file assignment. Cosmetic naming (using a persona name from team.md without loading that persona's full profile and skill) is strictly forbidden.
2. NEVER copy numbers from old docs without verifying against the current code.
3. NEVER act on a single-sentence Owner request without expanding it into a plan.
4. NEVER deploy without the test suite passing.
5. NEVER make the Owner repeat an instruction — save it to memory.
6. NEVER do "fix-of-fix-of-fix". If 1–3 attempts don't resolve, STOP and reconsider the architecture.
7. NEVER commit without explicit Owner authorization.
8. NEVER override a VETO from a staff specialist — escalate instead.
9. NEVER assume two external integrations behave the same way (data providers, payment processors, auth providers, etc. — each has quirks).
10. NEVER ship sensitive data changes without security review.