ceo-orchestration

Cross-LLM Pair-Rail dispatch + verdict interpretation — when to invoke, Cases A-F asymmetric matrix outcomes, Owner override semantics, post-verdict labeling protocol, promotion gate workflow, and anti-patterns to avoid.

Security architecture, authentication, authorization, and hardening for the {{PROJECT_NAME}}. Covers JWT+HMAC auth patterns, AES-256-GCM credential encryption, rate limiting design, OWASP Top 10 for Node.js/Hono, RLS policy design, timing-safe comparisons, API key lifecycle, input validation, CORS configuration, WebSocket auth, and proxy relay security. Use when reviewing or writing any code that touches authentication, authorization, credential storage, API key management, rate limiting, input validation, CORS, WebSocket security, proxy security, or any route that handles sensitive data or actions.

Testing strategy, patterns, and quality assurance for the project. Covers vitest patterns, external integration test design (mocking transport, simulating reconnect, checksum validation for streaming sources), domain math test design (boundary values, precision edge cases), E2E multi-process testing (IPC, worker lifecycle), route testing (auth verification, input validation), database test patterns (mocking data layer), chaos test framework design, test quality metrics (mutation testing, branch coverage), React component/hook testing (RTL query priority, MSW network mocking, axe a11y), test-first TDD (RED/GREEN/REFACTOR discipline), and CI integration. Use when writing tests, reviewing test quality, designing test strategies, setting up CI pipelines, or evaluating test coverage gaps.

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.

Structured code review process for the {{PROJECT_NAME}}. Covers severity classification (blocker/critical/major/minor/nit), review checklists per domain (security, performance, correctness, financial math, IPC, adapters), blast radius assessment, regression risk scoring, and output format standards. Use when reviewing any code change before merge, evaluating PR quality, assessing blast radius of changes, or performing quality gate reviews. This is the Staff Code Reviewer archetype's operating manual as the final gate before production.

Structured codebase orientation workflow for {{PROJECT_NAME}}. Produces an actionable mental map — entry points, dependency graph, architectural layers, hot-path identification, and a recommended reading order — before any modification work begins. Invoked via the /onboard <path> slash command or directly by any agent that must reason about an unfamiliar codebase.

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. Use when creating or modifying database tables, writing SQL migrations, planning zero-downtime rollouts, designing RLS policies, planning data retention, adding indexes, reviewing schema security, or troubleshooting query performance. Also use when the user mentions "schema", "DDL", "migration", "RLS", "retention", "index", "table", "enum", "pagination", "MySQL", "MariaDB", or "database design".

Engineering doctrine for building MCP (Model Context Protocol) servers within {{PROJECT_NAME}}. Covers server lifecycle, tool registration, schema design, error handling, security boundaries (stdin/stdout-only IPC, no shell injection, env-var allowlisting), and testing patterns (contract + fuzz + smoke). Use when authoring a new MCP server, reviewing an MCP server implementation, extending an existing server with new tools, or auditing an MCP server for security or correctness. The MCP integration architecture is decided in ADR-042 and ADR-062; this skill is the authoring doctrine consulted when implementing.

Performance engineering for Node.js real-time systems. Covers V8 internals (hidden classes, inline caches, deoptimization), GC tuning (Scavenge/Mark-Sweep/Compact), event loop forensics (stall diagnosis, tick profiling), memory leak detection, hot path optimization, IPC throughput, worker_threads performance, SharedArrayBuffer patterns, and production profiling. Use when analyzing event loop latency, diagnosing memory growth, optimizing hot paths, profiling IPC throughput, or reviewing any code that runs on the critical data path.

Disciplined ambiguity reduction for PLAN-NNN. 10-category taxonomy (Functional/Domain/UX/NFQ/Integration/Edge-Cases/Constraints/Terminology/Completion/Misc) with 5-question hard cap per session. Dated write-back into PLAN

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. Applies answer-first sequencing, cognitive-economy writing, and named-owner recommendation framing to all outputs. Distinct from `domains/sales/skills/proposal-strategist` (persuasion-to-close focus) and `domains/business-support/skills/analytics-reporter` (data-narrative focus). Use when: converting a lengthy analysis or briefing into a board-ready one-page summary; structuring a decision memo for C-suite consumption; compressing a multi-team status report for executive review; or authoring a risk or incident summary that must be readable in under three minutes.

Audit-grade security review for EVM smart contracts and DeFi protocols on Solidity ^0.8.24 with OpenZeppelin Contracts v5.x. Codifies EthTrust Security Levels + OWASP SCSVS as primary coverage with SWC + DASP Top 10 retained as legacy mapping, vulnerability-class detection technique, formal-verification workflow (Certora / Halmos / SMTChecker), severity schema with mandatory proof-of-exploitability for High+ findings, audit-report structure, and DeFi composability threat model (oracle dependence, flash-loan surface, governance vector, bridge trust). Operates under ADR-052 VETO floor — sign-off authority delegated to the existing security-engineer archetype on Opus (claude-opus-4-8); Critical or High findings without a verified fix BLOCK ship. Use when reviewing pre-mainnet contracts, pre-upgrade diffs, post-incident forensics, governance-parameter changes, treasury-flow code, bridge messaging code, or any contract surface where a single exploit transaction can drain user funds or brick the protocol.

Ensuring mathematical correctness and determinism in financial systems. Includes VWAP, cumulative depth, slippage modeling, precision handling, decimal arithmetic, invariants validation, and audit-friendly calculations. Use when reviewing or writing any code that affects prices, depth, volumes, PnL, arbitrage signals, or execution logic. Also use when designing schemas or types for financial data, validating orderbook invariants, or implementing any calculation where precision errors could cause incorrect trading decisions.

Cross-platform content creation discipline covering narrative architecture, distribution-aware editing, repurposing matrix design, audience research methodology, and voice consistency enforcement. Generalist content authoring as opposed to platform-specific specialisation. Applies the problem-tension- resolution arc as the primary structural frame, enforces segmentation-first audience analysis, and gates all production decisions on format-audience fit rather than format preference. Use when: authoring or reviewing long-form articles, video scripts, or email sequences; designing a repurposing plan for existing assets; auditing content for voice drift; evaluating whether a content piece serves a defined audience segment with a defined intent; or establishing a voice document for a brand or persona.

Mobile application development discipline covering iOS native (Swift / SwiftUI), Android native (Kotlin / Jetpack Compose), React Native, and Flutter cross-platform approaches. Covers app architecture (MVVM, MVI, Clean, TCA), state management per platform, navigation and deep-link semantics, offline-first local-DB selection and sync conflict resolution, push and local notification compliance (APNs / FCM), accessibility (VoiceOver, TalkBack, WCAG 2.2 AA mobile), and App Store / Play Console store compliance including privacy manifests. Use when designing or reviewing any mobile feature, architecture decision, platform selection, or store-submission readiness. Pair with security-and-auth for token storage and biometric auth flows.

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}}. Evaluates total-cost-of-ownership over unit price, applies statistical safety-stock and forecast-accuracy discipline, decomposes freight rates, classifies goods under the tariff GRI order, and enforces multi-tier supplier discipline. Use when designing sourcing strategy, qualifying a new supplier, running S&OP, setting safety-stock or forecast-method targets, building a carrier portfolio or freight RFP, classifying goods or evaluating FTA/duty savings, resolving a freight claim, building a risk-diversification plan, or meeting forced-labor and Scope 3 compliance obligations.

Kill-switch and circuit-breaker engineering for HFT systems — independence from order paths, cancel-all flow correctness, position-flatten guarantees, panic dashboards, and termination SLAs.

Design token governance, component architecture patterns, shared component organization, empty/loading/error state standards, component library integration (e.g. shadcn/ui, Material-UI, Chakra), responsive design, and visual consistency for the {{PROJECT_NAME}} frontend. Use when creating or reviewing components, organizing shared/, working with design tokens, implementing responsive layouts, or ensuring visual consistency across pages. Also use when the user mentions "design system", "components", "shared/", "god component", "empty state", "skeleton", "design tokens", "dark mode", "responsive", or any visual/structural component work.

Universal frontend development patterns for the {{PROJECT_NAME}} platform. Covers your build tool (e.g. Vite, Webpack) + your UI framework (e.g. React, Vue, Svelte) patterns, real-time data display (WebSocket client, SSE), virtualization for large lists, memoization strategies, composition patterns (compound components, render props, custom hooks), error boundaries, lazy loading and code splitting, responsive design, accessibility basics, and performance monitoring. Use when working on any frontend code, UI components, real-time updates, responsive layout, accessibility, or performance optimization. Domain-specific patterns (finance, e-commerce, healthcare, etc.) live under domains/<domain>/skills/frontend-patterns/SKILL.md and extend this universal baseline. Frontend repo: {{FRONTEND_REPO_PATH}}. NOTE: examples are prescriptive to React + Vite; adapt to your chosen stack.

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. Vite) for the {{PROJECT_NAME}} frontend. Use when analyzing bundle size, optimizing rendering, adding virtualization to large lists, reviewing memoization patterns, tuning build config, or improving Core Web Vitals scores.

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. Turns "the agent invents a harness" into a disciplined system — a temporary harness for one-off work, a shared skill for repeated work, observable checkpoints for teamwork, and an eval gate plus a human merge gate before anything autonomous. Use when a task needs a custom loop, evaluator, crawler, fixture generator, or watcher, when several agents need the same repeatable process that is not yet a skill, or when a workflow needs durable handoff artifacts and operator sign-off before merge.

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. Two actions — (1) WRITE a loop — gate whether it should exist at all, define a machine-decidable goal, pick the loop type, pick a skeleton, add damping; (2) REVIEW a loop — run it past five failure modes plus decidability, boundaries, fallback, judge-independence, and the red lines that keep the last switch with a human. Use when you are about to hand a repeating task to an autonomous loop, or you already have one and worry it will spin, cheat, or run a wrong answer to the end. This is the judgment layer that sits above the mechanism-layer loop tooling (the host harness's `/loop` and `/schedule` built-ins); it decides whether the goal is right and whether the loop can run away, not how to wire the plumbing.

Ports & Adapters (hexagonal) design discipline for keeping business logic independent of frameworks, transport, and persistence. Covers the inward dependency rule, inbound/outbound port modelling, use-case orchestration with injected ports, edge adapters, the single composition root, per-boundary test strategy, a slice-by-slice strangler migration playbook, and the cross-language mapping of the same boundary rules onto TypeScript, Java, Kotlin, and Go layouts. Use when: standing up a new feature where testability and long-term change cost matter; refactoring a framework-heavy or layered service where domain logic is tangled with I/O; exposing one use case over multiple interfaces (HTTP, CLI, queue worker, cron); or swapping infrastructure (DB, third-party API, message bus) without rewriting business rules.

Spec-and-scaffold discipline for composable recommendation, ranking, and feed pipelines built on the six-stage pattern Source → Hydrator → Filter → Scorer → Selector → SideEffect. Teaches why the stage order is fixed, what each stage owns, where parallelism is safe, the load-bearing trade-offs (single relevance score vs multi-action prediction with tunable weights; candidate isolation vs joint scoring; online vs offline vs hybrid serving), a filter/scorer cookbook, and an eight-step interview-to-scaffold workflow. Use when the task is "pick the top K items for a (user, context)": social feeds, content-CMS surfacing, RAG retrieval reranking, task/notification prioritisation, search reranking, or ad ranking — the plumbing AROUND a scoring function, not the model itself.

Modern C++ (C++17/20/23) coding standard grounded in the public C++ Core Guidelines. Enforces resource safety (RAII), immutability by default, strong static typing, value semantics, and intent-revealing interfaces. Covers ownership and smart-pointer discipline, the Rule of Zero / Rule of Five, const-correctness, scoped enums, exception-safety, concept-constrained templates, concurrency locking discipline, header hygiene, and naming. Use when authoring, reviewing, or refactoring C++ — when deciding between raw and smart pointers, choosing enum vs enum class, sizing a class's special members, passing parameters, constraining a template, or locking a shared resource. Not for C-only legacy that cannot adopt modern features, or bare-metal contexts where a specific guideline conflicts with hardware.

Testing workflow for modern C++ (C++17/20) with GoogleTest / GoogleMock driven through CMake and CTest. Covers the red-green-refactor loop, unit and integration test layout, fixtures, mocks vs fakes, dependency injection for isolation, stable test discovery with gtest_discover_tests, coverage collection (gcov/lcov and llvm-cov), the AddressSanitizer / UBSan / ThreadSanitizer builds, and guardrails that keep tests deterministic and non-flaky. Use when writing or fixing C++ tests, wiring a CMake/CTest test target, diagnosing a failing or flaky test, or adding coverage or sanitizer gates. Not for feature work with no test change, large refactors unrelated to tests, or non-C++ projects.

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. Emphasises the non-obvious traps that silently corrupt data or exhaust connections — updateMany/deleteMany returning a count instead of rows, the interactive $transaction 5-second timeout, `migrate dev` resetting the database, @updatedAt skipping bulk writes, edited migration files breaking checksums, and where soft delete leaks through *OrThrow reads. Use when designing Prisma schema, writing queries or transactions, running migrations, or deploying to serverless runtimes.

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). Front-loads the autograd- and correctness-breaking anti-patterns: forgetting eval() at validation, in-place ops severing the graph, .item() before backward, moving the model to GPU inside the loop, and the pickle-RCE risk of loading checkpoints without weights_only. Use when writing or reviewing models, training scripts, or data pipelines, or when tuning GPU memory and speed.

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. Covers testability setup (giving every control a stable AutomationId), a page-object test structure, a locator priority ladder (AutomationId > name > class+index), condition-based waits instead of sleeps, three tiers of test isolation, a screenshot/template-match fallback for controls UIA cannot see, Qt-specific quirks, and CI on a windows-latest runner. Use when writing or debugging E2E tests for a Windows desktop GUI, standing up a desktop test suite, or adding testability to an existing native app. Not for web apps (use a browser E2E skill), Electron/WebView (browser layer), or mobile.

Build zero-dependency, animation-rich HTML presentations — from a topic, from rough notes, or by converting an existing PowerPoint deck to the web. The distinguishing discipline is two hard gates most slide generators skip: (1) every slide must fit exactly one viewport with no internal scroll, and (2) non-designers are guided to a distinctive look through visual exploration (real preview slides they can react to) instead of abstract style questionnaires. Produces a single self-contained .html file with inline CSS/JS, keyboard/wheel/touch navigation, reveal-on-enter animation, and reduced-motion support. Use when someone wants to create a talk, pitch, workshop, or internal deck; convert a .ppt/.pptx to HTML; or fix the layout, motion, or typography of an HTML deck that already exists.

Record a polished demo/walkthrough video of a web application with a browser automation driver (Playwright). Produces a WebM with a visible arrow cursor, natural human pacing, on-screen step subtitles, and a storytelling flow — not a jittery instant-fill capture. The defining discipline is a three-phase method: Discover the real page (dump the actual interactive elements before scripting), Rehearse (verify every selector resolves, failing loudly), then Record. Use when someone asks for a demo video, screen recording, product walkthrough, or tutorial video of a running web app for docs, onboarding, or a stakeholder showcase.

Testing discipline for C# / .NET applications. Covers the modern test stack (xUnit, an assertion library, an isolation/mocking library, WebApplicationFactory and Testcontainers for integration), Arrange-Act-Assert unit structure with the system-under-test convention, parameterized tests (Theory / InlineData / MemberData / strongly-typed TheoryData), interaction verification and stubbing, ASP.NET Core in-process integration tests, real-infrastructure integration via ephemeral containers, test-project layout, data builders, and a catalogue of anti-patterns. Use when writing or reviewing tests for C# code, standing up a .NET test suite, choosing an assertion or mocking library, or debugging flaky / slow .NET tests.

Idiomatic Go engineering discipline: writing, reviewing, and refactoring Go so it stays boring, predictable, and easy to maintain. Covers the core Go proverbs (clear over clever, accept interfaces return structs, useful zero values), error-handling contracts (wrap with %w, sentinel + typed errors, errors.Is / errors.As, never silently drop), concurrency safety (worker pools, context-driven cancellation and timeout, errgroup, goroutine-leak avoidance, graceful shutdown), interface and package design (small consumer-side interfaces, no package-level mutable state, dependency injection), struct ergonomics (functional options, embedding), allocation-aware performance (preallocation, strings.Builder, sync.Pool), and the standard tooling gate (go vet, staticcheck, golangci-lint, race detector, gofmt/goimports). Use when authoring a new .go file, reviewing a Go pull request, designing a package or module boundary, wiring goroutines and channels, shaping an error path, or picking a lint gate.

Coding standards for modern Java (17+) services on the two dominant JVM backend stacks — Spring Boot and Quarkus. Covers naming, immutability, Optional discipline, streams, exceptions, generics, dependency injection, reactive pipelines, configuration, logging, project layout, and a folded Persistence (JPA/Hibernate) section for entity design, N+1 prevention, transactions, pagination, indexing, and connection pooling. Use when writing or reviewing Java in a Spring Boot or Quarkus codebase, or when designing the data-access layer.

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. Use for Java Spring Boot backend work. For language-level conventions and the JPA/Hibernate data layer, pair with the java-coding-standards skill.

Meta-agent that drafts a new squad bundle (team-personas, pitfalls, skill-selection, personas roster, rationale) from an Owner-supplied domain brief. Read-only on canonical paths; writes ONLY into the sandboxed plan subdir. Sentinel-gated mutations.

AI system and LLM Council management for {{PROJECT_NAME}}. Covers the 3-model council architecture (Claude + Gemini + GPT), snapshot construction and minimization, prompt engineering for market analysis, usage throttling (100K tokens/day budget), input injection prevention, proprietary data protection, signal quality assessment, confidence thresholds, fallback chains, and cost optimization. Use when working on any code in src/ai/, reviewing AI prompts, implementing new AI features, debugging AI signal quality, managing LLM costs, or reviewing AI security (injection attacks, data leakage). 18 files, ~9.3K lines. Also use when the user mentions "AI council", "LLM", "market analysis AI", "AI signals", or "prediction confidence".

Architecture decision-making framework for {{PROJECT_NAME}}. Covers ADR (Architecture Decision Record) format, trade-off analysis matrices, dependency graph analysis, blast radius assessment, system boundary identification, scalability testing ("10x scale" rule), when to refactor vs rewrite, multi-process architecture patterns, and cross-cutting concern management. Use when evaluating changes that touch 3+ modules, planning new features, assessing refactoring proposals, reviewing system boundaries, or making decisions that will be hard to reverse. This is the VP Engineering archetype's operating manual for architectural governance.

Chaos engineering, resilience patterns, failure recovery, and fault tolerance for the {{PROJECT_NAME}}. Covers circuit breaker patterns (HTTP, WS, per-venue), reconnect gate design, graceful shutdown protocol, backpressure strategies (PubSub 1MB/4MB, persistence queues), worker lifecycle management, IPC channel health detection, failure scenario matrix, bounded queue design, and event loop stall recovery. Use when reviewing or writing any code that touches error handling, retry logic, reconnection, circuit breakers, worker management, IPC channels, queue management, backpressure, graceful shutdown, health checks, or any failure-adjacent code path.

Engineering doctrine for using Language Server Protocol tools in agent code-analysis workflows for {{PROJECT_NAME}}. Covers per-language LSP server selection, diagnostic triage, type-query patterns, and the critical discipline of anchoring analysis to structured semantic data rather than string matching. Use when performing non-trivial code review, refactoring, type-safety analysis, or any task where grep alone cannot distinguish a definition from a reference or a type from its alias.