🐦‍⬛ RavenClaude — Marketplace Guide

Use this agent as the technical conscience across the entire software lifecycle — design, build, test, review, iterate. Spawn for upfront design BEFORE writing code, AND re-consult whenever a phase boundary surfaces a question that exceeds a coder/tester/reviewer's authority (tests contradict the plan, scope expands mid-build, reviewer flags a structural concern, iteration requires re-planning). Do NOT use it to write production code.

Use this agent to implement server-side code — API handlers, business logic, database queries, background jobs, integrations. Spawn AFTER the architect has produced a plan. Each invocation should target one focused, testable change.

Use this agent for pre-merge review of any non-trivial diff. Spawn it AFTER coder + tester agents are done but BEFORE the Team Lead opens a PR or merges. Returns a structured review with blockers, suggestions, and praise.

Use this agent for data-shaped work that isn't tied to a specific domain plugin — pipeline design, data modeling, ETL/ELT, warehouse and lake schemas, query performance, data quality, lineage, ingestion connectors, and analytics-engineering style transformations (dbt-flavored or hand-rolled). Spawn for "design this pipeline", "model this warehouse", "this query is slow", "this batch keeps failing", "make this dataset trustworthy". NOT for Power BI semantic models or DAX (that's `power-platform/power-bi-engineer`). NOT for application database schema design driven by a product feature (route to `architect` instead). NOT for ML feature engineering as part of model training (that's a separate specialty).

Use this agent for rigorous, multi-source research — troubleshooting unfamiliar errors, comparing tools/libraries, verifying claims, or going deeper than a single web search. Spawn it when the question needs official docs PLUS expert blogs/forums/source code, when confidence levels and source citations matter, or when another agent (architect, project-manager, PSM) has flagged a research gap. Returns a structured brief with findings, confidence ratings, competing hypotheses, and open questions. Do NOT use it for tasks the Team Lead can answer from the repo alone.

Use this agent for UX direction and visual design — wireframes, user flows, screen layouts, design specs, accessibility checks, visual hierarchy. Spawn BEFORE the frontend-coder starts a UI, or when any visual artifact (Power Apps screen, partner-facing slide deck, dashboard, infographic, onboarding artifact) needs intentional design rather than ad-hoc layout. Do NOT use it to write production code — it produces specs the frontend-coder (or the user) executes. Do NOT use it for stakeholder prose (that's the documentarian).

Use this agent for stakeholder-facing written deliverables — executive summaries, decision memos, variance commentary, partner briefs, runbooks, SOPs, release notes, READMEs, onboarding guides, long-form writeups. Spawn when the work product is *prose intended for a human audience*, not code, not internal PM hygiene. Do NOT use for RAID/status/task tracking (that's project-manager), system design plans (architect), code comments (coders), or raw analysis from data (the user or a domain expert produces the inputs; this agent polishes them).

Use this agent to implement UI work — components, pages, client-side state, styling, accessibility, browser-side integrations. Spawn AFTER the architect or designer has decided on structure and visual direction. Verify in a real browser before reporting done.

Use this agent only for changes that genuinely cross the client/server boundary in one cohesive unit (e.g., a new endpoint plus the UI that calls it). Prefer separate backend-coder + frontend-coder agents when the work can be split cleanly.

Use this agent for any Partner Success Manager work — maintaining partner profiles, success plans, QBRs, health scores, onboarding checklists, touchpoint logs, and the team's growing AI workflow library. Domain-neutral; PSM patterns apply across SaaS / EdTech / fintech / GovTech. Spawn proactively at QBR prep time (1 week before), when a partner has been silent >30 days, when a health score dips, or when a useful AI pattern surfaces and should be captured. Do NOT use for project management (project-manager agent), system design (architect), or end-customer success.

Use this agent for any project hygiene work — maintaining the RAID log, task list, weekly status report, activity log, or stakeholder register. PMP / PMBOK 7-aligned. Spawn proactively when a week passes without a status update, or immediately when a critical risk, issue, or decision emerges. Do NOT use for system design (that's the architect), implementation (coder), or written deliverables for stakeholders (documentarian).

Use this agent to author, critique, refine, or refactor agent definitions, skill files, and prompt patterns across RavenClaude and any Expert repo (PowerPlatformExpert, SalesforceExpert, etc.). Spawn when adding a new agent or skill, when an existing prompt produces inconsistent results, when reusable patterns need to be factored into a shared skill, when naming/voice/structure has drifted across repos, or when Anthropic ships new guidance worth absorbing. Owns the meta-layer of the AI library. Do NOT use for general research (deep-researcher), stakeholder prose (documentarian), or the PSM's team-shared workflow library (that's PSM-owned).

Use this agent whenever a diff touches authentication, authorization, cryptography, secrets, sessions, untrusted input parsing, file uploads, deserialization, SQL, shell, network egress, or third-party integrations. Spawn it AFTER code-reviewer or in parallel with it. Mandatory for any auth/crypto change.

Use this agent to design test plans, hunt flakes, plug coverage gaps, or harden tests around a new feature. Spawn it AFTER coder agents have a working diff but BEFORE code review. Also use for triaging mysterious test failures.

Score and improve an agent file against a 6-dimension rubric — Mission clarity, Scope sharpness, Capability Grounding alignment, Output-Contract completeness, Escalation paths, Example scenarios. Each dimension scored 1-5 with anchors; includes a remediation template that turns a low score into an actionable PR. Reach for this skill when authoring a new agent, reviewing a PR that adds or modifies an agent, or running a periodic agent-bank audit. Used by `prompt-engineer` (primary) plus `architect`.

For any consumer project where a CI workflow is meant to *enforce* a property (lint, format, security scan, manifest validation, version pin, layout allow-list, etc.). When working on a CI file or adding a new check, run this skill — every gate must fail on a known-bad input AND pass on a known-good input. A gate that runs without gating, or gates the wrong thing, is invisible from inside a green CI dashboard. Also triggers on user phrases like "audit the CI", "verify the gates", "is this gate real", "does this lint actually fail".

Remove finished agent worktrees, prune their branches, and surface anything still in flight. Run at the end of a multi-agent session and weekly as hygiene.

For Claude sessions running in a consumer project (any project where ravenclaude-core is installed). Triggered when you discover a cross-domain finding worth contributing back to the RavenClaude marketplace — either spontaneously, or when the user says "contribute this," "save to RavenClaude," "this is worth keeping," or similar. Walks through the qualifying check, picks the right shape (lesson, best-practice, or both), and formats a copyable staging submission the user can drop into RavenClaude/docs/staging/incoming/.

Open a pull request for the current branch using the project's standard template. Verifies the branch is green, summarizes the diff against main, and pushes only after the user confirms.

For any script that produces a file the repo COMMITS and CI DIFFS — generated HTML, lockfiles, JSON snapshots, fixture files, documentation rendered from source. The output must be byte-identical regardless of who regenerated it or on what OS. This skill catches the specific failure modes that turn a freshness gate into a paper tiger that fails forever — OS-dependent path separators, locale-dependent encodings, nondeterministic ordering, drifting timestamps. Triggers on phrases like "freshness check failing", "regenerated locally but diff doesn't match", "works in CI not on Windows", "generator produces different output", and on any review of a script whose output is committed.

Use this skill when the user wants to create a new agent and has a clear business goal but isn't fluent in the agent's target domain. Walks them through producing a strong brief by filling in `templates/agent-brief.md` from their plain-language description, then iterating once or twice before building or dispatching the agent. Triggers when the user asks for "a new agent that does X" without already supplying the technical spec, or when they've filled the brief template and left blanks where they didn't know.

Auto-discover the consumer's environment posture by probing installed CLIs (pac / az / aws / gcloud / gh) with read-only commands at session start, decoding JWTs for role/scope claims, and assembling a draft `.ravenclaude/environment-context.md` for save/edit/skip. Streamlines proposal 2026-05-22-001's permission-awareness mechanism.

Run a periodic staleness sweep over all `plugins/<plugin>/knowledge/*.md` files and any decision-tree sections — flag entries past their `last-verified` window, categorize by re-verification effort (Tier 1-5 per Researcher schema), produce a remediation queue with named re-verifiers. Reach for this skill on the Researcher's weekly cadence OR before a marketplace release. Used by `deep-researcher` (primary) plus the maintainer.

Create an isolated git worktree under .claude/worktrees/ for a sub-agent to work in. Use this before dispatching any coder agent so that parallel work cannot collide.

Pre-release checklist for shipping any plugin update through this marketplace — plugin.json + marketplace.json + architecture.md version-mirror discipline, .repo-layout.json glob coverage for new dirs, CLAUDE.md skill / template tables synced, JSON validation, prettier check, audit-gates meta-test, and the consumer migration-note rule. Includes the exact bash commands to run (Windows PowerShell + bash). Reach for this skill at the end of any plugin PR or before merging a release-candidate branch. Used by the maintainer (primary) plus `project-manager`.

Curated, applied prompt-pattern catalog used across this marketplace — decision-tree traversal pre-action prior, alternate-methods-before-blocked, Structured Output Protocol `---RESULT_START---` block, scenario-retrieval inline prior, escalation-by-mandatory-phrasing, citation-aware research, environment-context preamble, orchestrator-worker reinforcement, agent-scenario-authoring frontmatter. Each pattern includes when to use it, what it composes with, an example block, and the failure mode it prevents. Reach for this skill when authoring a new agent, when an existing agent shows a behavior gap that a known pattern would close, or when the `prompt-engineer` is consulting on an agent revision. Used by `prompt-engineer` (primary).

Meta-skill that keeps all agents, skills, and knowledge files current and honest — Daily Quick Check + Weekly Deep Research modes. Categorization schema (Tier 1 Consensus / 2 Strong-but-Contextual / 3 Divergent / 4 Emerging / 5 Deprecated). Includes 90-day staleness checks for decision trees AND `.ravenclaude/environment-context.md`.

For the RavenClaude marketplace maintainer. Walks every file in docs/staging/incoming/ one at a time, runs a security sweep + topic-expert analysis on each, presents each with a keep/update/deny prompt, promotes approved submissions to their canonical location (docs/memory-bank/lessons-learned.md for lessons, docs/best-practices/<slug>.md for best-practices), and deletes denied ones. Trigger when the maintainer says any of "check for updates", "check the staging queue", "anything in staging", "review submissions", "drain the queue", or "review staged contributions" — also fires on the slash command /review-staged-contributions.

Run the project's full quality gate — format check, lint, typecheck, unit tests, integration tests — in order, fail fast, summarize. Use before reporting any non-trivial change as complete.

Consult the unverified scenarios bank (`plugins/<plugin>/scenarios/*.md`) before answering plugin-domain questions. Glob + tag-filter + recency-weight, surface top 2-3 with mandatory unverified-scenario preamble ("Based on N unverified scenarios from YYYY-MM tagged [scope] — verify in your environment"). Secondary source — never replaces canonical knowledge files.

Team Lead dispatch playbook. Given a feature or task, decide which specialized agents to dispatch, prepare their briefs, allocate worktrees, run them in the right order, and re-route on blockers. Load this skill whenever you (the Team Lead) are about to dispatch more than one agent on a request. Keeps routing consistent across sessions and avoids re-deriving the workflow each time.

Enforce the Structured Output Protocol — every sub-agent handoff ends with a `---RESULT_START--- ... ---RESULT_END---` JSON block alongside the human-readable Markdown. Team Lead parses the JSON for routing; Markdown stays for human review. Active across all 14 core specialists.

enforce-layout.sh PreToolUse hook for Write | Edit | MultiEdit. Reads .repo-layout.json from the consumer's project root. If absent, no-ops silently (allow everything). If present, checks the target path against the allowed_globs / forbidden_globs allow-list and denies off-pattern writes with a helpful message including a suggested correct location. Deny mechanism: emits hookSpecificOutput JSON to

format-on-write.sh PostToolUse hook for Edit | Write | MultiEdit. Auto-format the file Claude just touched, using whatever formatter the project defines. No-ops silently when a formatter isn't configured for the file type — never blocks the agent's flow.

guard-destructive.sh PreToolUse hook for Bash. Catches obviously destructive commands that slipped past the deny-list (e.g. inside subshells, pipes, here-docs). Exits non-zero to block the command; prints a reason on stderr.

guard-recursive-spawn.sh PostToolUse hook for Edit | Write | MultiEdit on agent definition files (plugins/*/agents/*.md). Warns when an agent's prompt instructs *itself* to spawn another sub-agent. Why this matters ---------------- RavenClaude follows the hierarchical orchestrator-worker pattern documented in plugins/ravenclaude-core/CLAUDE.md and plugins/ravenclaude-core/skills/spawn-team.md: onl

remind-tests.sh Stop hook. If any source files were modified in the working tree this session, print a reminder to run the full quality gate before reporting the task complete. Output goes to stderr — Claude sees it as a system notice, the user sees it in the transcript.

Rule: Agent Collaboration Protocol

Rule: Coding Standards (long form)

Rule: Git Workflow (long form)

Rule: Security (long form)

Activity Log — *<Project Name>*

Agent Brief Template

Agent Definition Template

(template folder)

(template folder)

(template folder)

Environment Context — `<engagement_name>`

(template folder)

RAID Log — *<Project Name>*

Research Report Template

(template folder)

Stakeholder Register — *<Project Name>*

Status Report — *<Project Name>*

Task List — *<Project Name>*

Use this agent for Copilot Studio (formerly Power Virtual Agents) bot design and AI Builder integration — topics, generative answers, knowledge sources, prompts in flows, custom and prebuilt AI Builder models, AI Credit budgeting, bot channels (Teams/web/Direct Line). Spawn for bot architecture, conversational design, AI Builder model selection, "Copilot Studio vs direct Azure OpenAI via custom connector" decisions, prompt design in Power Automate. NOT for general flow work (flow-engineer).

Use this agent for Dataverse data modeling, security model design, plug-ins, and business rules. Spawn for "design these tables", "model this security", "should this be a plug-in or a flow", "audit this schema", or "migrate this from SharePoint/Excel to Dataverse". NOT for app-building (canvas → power-fx-engineer; model-driven UI → model-driven-engineer). NOT for ALM (solution-alm-engineer).

Use this agent for Power Automate work — cloud flows, desktop flows (RPA), and custom connectors. Triggers, expressions, error handling, child flows, retries, batching, parallelism. Spawn for any flow build/review/troubleshooting, custom connector authoring (OpenAPI), or "should this be Power Automate, Logic Apps, or a Function App?" decisions. NOT for canvas app work (power-fx-engineer) and NOT for data modeling (dataverse-architect).

Use this agent for model-driven app construction — site maps, app modules, forms (main/quick create/quick view), views, dashboards, charts, business process flows, command bar customization, JS web resources, form scripting via Xrm/formContext APIs. NOT for data modeling (dataverse-architect) and NOT for canvas-only Power Fx (power-fx-engineer). Custom Pages are jointly owned with power-fx-engineer — embedding into a model-driven app is here, the canvas screen content is there.

Use this agent for Power Apps Component Framework (PCF) custom controls — TypeScript, manifest, lifecycle, build, package, register. Pro-code lane. Spawn when canvas / Custom Pages / canvas components genuinely cannot deliver the required UI. NOT for canvas formulas (power-fx-engineer) and NOT for model-driven JS web resources (model-driven-engineer).

Use this agent for Power BI semantic models, DAX authoring/review, reports, dataflows, PBIP project source control, git integration with Azure DevOps / Azure Repos, deployment strategies (Deployment Pipelines vs ADO pipelines), refresh/gateway troubleshooting, and bridging Power BI artifacts with Power Platform solutions/ALM. Spawn for model design, complex DAX, setting up PBIP git repos, diagnosing "why won't my semantic model refresh in prod", report performance, or Power BI ALM/CI-CD questions. NOT for Dataverse schema (dataverse-architect) or general canvas/Power Fx (power-fx-engineer).

Use this agent for canvas Power App work — screen architecture, Power Fx formulas, components and component libraries, delegation, performance, theming, accessibility, Test Studio, Monitor. Also covers the canvas/Power Fx side of Custom Pages embedded in model-driven apps. NOT for model-driven app shell work (that's model-driven-engineer) and NOT for data modeling (that's dataverse-architect). Spawn for build, review, troubleshooting, or "is this delegable?" questions.

Use this agent for Power Pages (formerly Power Apps Portals) — external-facing sites for anonymous or B2C users. Tables, table permissions, web roles, liquid templating, basic / advanced / multi-step forms, authentication providers (Azure AD B2C, local accounts, etc.), web files, content snippets, custom CSS/JS. Spawn for portal architecture, table-permission design, B2C auth setup, custom liquid, "should this be Power Pages or a canvas app" decisions. NOT for internal-tenant apps (canvas → power-fx-engineer; model-driven → model-driven-engineer).

Use this agent for tenant-level Power Platform admin work — environment strategy (Default avoidance, Production / Sandbox / Developer / Trial / Teams), managed environments, environment groups, DLP policies at tenant + environment scope, CoE Starter Kit, licensing audits, capacity reporting (Dataverse storage, API entitlements, Power Automate request limits), tenant-level analytics, sharing limits, weekly digest. Spawn for governance design, DLP authoring, license budgeting, capacity planning, "do we need managed environments", "audit this tenant for risk". NOT for solution-level ALM (solution-alm-engineer) or app-level builds.

Use this agent for Power Platform-specific testing — Power Fx unit/integration tests in Test Studio, canvas-app monitor traces, Power Automate flow tests (`Test → Manually`, telemetry-driven assertions), Dataverse data validation, model-driven app form/business-rule testing, DAX measure correctness and performance, Power BI semantic model VertiPaq diagnostics, and `pac solution check`. Spawn AFTER a power-platform specialist has produced a change but BEFORE `solution-alm-engineer` packages the release. NOT for application-layer JS/TS testing of PCF controls (the `pcf-developer` owns that test surface). NOT for general data-pipeline testing (that's the core `data-engineer` or `tester-qa`).

Use this agent for Power Platform Application Lifecycle Management — pac CLI mastery, source control of unpacked solutions, environment variables, connection references, environment strategy at the solution level (dev/test/prod promotion), and ALM pipelines (in-product Power Platform Pipelines, Azure DevOps + Power Platform Build Tools, GitHub Actions for Power Platform). Spawn for "set up source control for this solution", "design our pipeline", "diagnose this import failure", "what's the env-var/connection-ref strategy". NOT for data modeling (dataverse-architect) and NOT for tenant-scope governance (power-platform-admin).

Design end-to-end ALM pipelines for Power Platform solutions — pac CLI primitives, Azure DevOps multi-stage pipelines, source-control unpacked solutions, env-var + connection-reference promotion across DEV → TEST → UAT → PROD, managed-vs-unmanaged discipline. Used by `solution-alm-engineer` (primary).

Diagnose and fix Power Fx canvas app performance — delegation as a P1 design constraint, lazy-load patterns, Concurrent() vs sequential, ClearCollect vs collection growth, OnStart vs OnVisible, screen-transition cost, control-count budgets per screen, and the connector-call audit via Monitor. Used by `power-fx-engineer` (primary).

Deep code audit that finds dead wiring, silent failures, unfinished features, placeholder stubs, bloated files, and unnecessary complexity. Produces an actionable report with file:line references grouped by severity. Think of it as a senior dev doing a thorough PR review of the entire codebase. Triggers on: "code review", "audit the code", "review the code", "find dead code", "find placeholders", "check for stubs", "prune the code", "code cleanup", "implementation review", "completeness check", "find unused code".

Design Copilot Studio bots — topic vs generative-answers boundaries, knowledge-source hygiene, trigger-phrase design, slot-filling patterns, escalation-to-human criteria, AI Builder vs prompt-flow vs direct Azure OpenAI decisions, and the test-set discipline that catches regressions on every authoring change. Used by `copilot-studio-engineer` (primary).

Use when developing, registering, or deploying Dataverse plugins (C# server-side extensions). Covers the IPlugin interface, execution pipeline stages, entity images, common patterns (auto-numbering, cascading updates, validation), and registration/deployment. Triggers on: "plugin", "server-side logic", "business logic", "auto-number", "cascading update", "pre-operation", "post-operation", "plugin registration", "IPlugin", "execution pipeline", "plugin trace", "InvalidPluginExecutionException", "PreValidation", "PostOperation".

Use when programmatically creating, modifying, or querying Dataverse schema and metadata via the Web API (OData v4.0). Covers table/column/relationship definitions, solution ALM, form and view XML construction, app module composition, global option sets, business rules, Custom API registration, and publishing. Triggers on: "dataverse api", "dataverse metadata", "entitydefinitions", "web api schema", "create dataverse table", "create dataverse column", "fetchxml", "formxml", "layoutxml", "dataverse solution", "dataverse relationship", "odata dataverse", "metadata api", "publish customizations", "dataverse alm", "grid control", "editable grid", "business rule", "rich text", "auto-number", "file column", "image column", "pcf control", "security role", "column security", "environment variable", "custom api", "data migration", "solution import".

Use when creating, deploying, or managing Dataverse web resources for model-driven apps. Covers JavaScript form scripts (OnLoad, OnSave, OnChange events), HTML dashboard pages, CSS styling, image resources, navigation/side panes, ribbon/command bar customization, business process flow client API, and deployment via the Web API. Triggers on: "web resource", "javascript form", "form script", "html dashboard", "ribbon command", "onload event", "onchange event", "onsave event", "formContext", "Xrm.WebApi", "web resource deployment", "dashboard page", "form event handler", "side pane", "command bar", "ribbon", "modal dialog", "navigation", "Xrm.App", "Xrm.Navigation", "business process flow", "bpf", "stage change".

Design tenant Data Loss Prevention policies for Power Platform — business / non-business / blocked classification, environment-scoped vs tenant-wide policies, exemption process, common-connector pitfalls (HTTP, SharePoint, Dataverse, custom connectors), and the "every flow gets re-evaluated on policy change" implication. Used by `power-platform-admin` (primary).

Reduce confident-but-incorrect "I can't do that" claims by forcing agents to verify capabilities before refusing scope. Mandatory checklist covers skills review, alternate-methods enumeration, team-composition check, and escalation phrasing. Inherited by every Power Platform agent.

Forward-looking maintainability + evolvability review of a Power Platform solution — understandability, modifiability, testability, evolution readiness, ownership. Used before major releases, handoffs, when inheriting an existing solution.

Use when building, deploying, or using PowerApps Component Framework (PCF) controls. Covers field controls and dataset controls, React virtual controls, control lifecycle, manifest configuration, solution packaging, and deployment. Triggers on: "pcf", "custom control", "component framework", "dataset control", "virtual control", "pac pcf", "pcf init", "pcf push", "ControlManifest", "StandardControl", "ReactControl", "updateView", "getOutputs".

Spawns an Agent Team to collaboratively plan Power Platform / Dataverse applications. Three specialists (Data Architect, UX Designer, The Skeptic) debate and refine the plan before any code is written. Falls back to structured single-agent planning if agent teams are not enabled. Triggers on: "plan my app", "plan with team", "design my app", "architect this app", "plan the schema", "team planning", "agent team plan", "plan power app", "plan dataverse app", "design the data model".

Use when building, scaffolding, debugging, or deploying Microsoft Power Apps Code Apps using React, Vue, or TypeScript in VS Code. Handles project initialization via pac CLI, Dataverse and connector data access via the @microsoft/power-apps SDK, power.config.json configuration, Vite build pipelines, and deployment to Power Platform environments. Triggers on: "power apps", "code app", "pac code", "dataverse", "power platform app", "vibe coding", "scaffold power app", "deploy code app".

Veteran-level reference for Power Automate work — expressions, error handling + scopes, child flows, solution-aware flows + connection references, Dataverse triggers, throttling, approvals, performance patterns. Used by `flow-engineer` (primary) and any agent touching flows.

Veteran-level reference for Power BI — PBIP project structure + git, semantic model design, DAX patterns + performance, deployment pipelines, refresh / gateway troubleshooting, integration with Power Platform solutions / ALM. Used by `power-bi-engineer` (primary).

Design table permissions, web roles, and authentication for Power Pages — anonymous vs authenticated patterns, B2C / Entra-External-ID auth, table-permission scoping (global / contact / account / parental / self), record ownership, and the "row I can see in MDA but not in Pages" debugging playbook. Used by `power-pages-engineer` (primary).

Record a Chrome browser tab to video via CLI. Use when the user wants to capture a screen recording of a browser tab. Supports list, start, stop, caption, and status subcommands. No debug mode required — uses a Chrome extension.

AI-powered visual QA testing that walks through an app in the browser, records every action with annotated captions (what was done, what should happen), captures screenshots/GIFs, and sends the evidence to Gemini for automated review. Catches UX misalignments, broken flows, missing states, and edge cases that traditional tests miss. Can use Agent Teams for parallel test coverage. Triggers on: "visual test", "visual qa", "test the app", "qa review", "check the ui", "record a test", "walk through the app", "e2e test", "end to end test", "catch edge cases", "gemini review", "screen test", "ux test", "visual regression".

check-house-opinions.sh PostToolUse hook for Edit | Write | MultiEdit on Power Platform source files. Catches the most common, mechanically-detectable violations of the Power Platform team constitution (see plugins/power-platform/CLAUDE.md §3 "house opinions"): 1. GUIDs hard-coded in Power Fx canvas YAML — should look up by name or alt key. 2. Default publisher prefix (`cr_`, `crXXX_`, `new_`) in

Maintainability Review Template

{'command': 'pbix-mcp-server'}

Use this agent for audit readiness — PBC (provided-by-client) list management, walkthrough documentation, SOC1 / SOC2 control narratives, deficiency remediation, examiner walkthrough rehearsals. Spawn pre-audit (6-8 weeks before fieldwork), for SOC report preparation, or for examiner walkthrough drafting. NOT for the close itself (controller) and NOT for board / lender reporting (board-pack-composer).

Use this agent for board / investor / lender reporting packs — narrative-first composition, section sequencing, KPI selection, executive-summary patterns. Spawn for quarterly board cycles, investor updates, lender covenant compliance packs, fundraising-process data rooms. NOT for the underlying analysis (fpa-analyst, financial-modeler, treasury-analyst — they supply the inputs).

Use this agent for month-end / quarter-end close work — JE design and review, account reconciliations, accruals, intercompany, close-calendar mechanics, deferred revenue / prepaids / fixed-asset rolls. Spawn for close prep, JE review, recon escalations, accrual triage. NOT for budget / forecast (fpa-analyst) and NOT for treasury / cash (treasury-analyst).

Use this agent for financial-model work — three-statement models, DCF, scenario / sensitivity, model architecture, model documentation. Spawn for building a model from scratch, reviewing an existing model, refactoring a broken / overgrown one, or defending modeling assumptions. NOT for budget / forecast / variance work (fpa-analyst) and NOT for board-pack composition (board-pack-composer).

Use this agent for FP&A work — budgeting, rolling forecasts, KPI commentary, variance walks, scenario modeling at the P&L level, headcount and opex planning. Spawn for budget season, monthly / quarterly variance commentary, KPI pack assembly, board-pack commentary inserts. NOT for full three-statement model build (financial-modeler) and NOT for journal entries / close mechanics (controller).

Use this agent for treasury and cash-management work — 13-week direct cash forecasts, working-capital optimization, debt covenant compliance, FX exposure and hedging, banking operations, debt-schedule mechanics. Spawn for cash forecasts, covenant calculations, FX strategy, banking-fee audits, debt-restructuring scenarios. NOT for budget / P&L forecasting (fpa-analyst) and NOT for valuation (valuation-analyst).

Use this agent for valuation work — business valuation (DCF + comparable companies + precedent transactions), 409A valuations, fairness-opinion support, valuation methodology defense, ESOP / RSU strike-price refreshes. Spawn for pre-investment / pre-acquisition valuation, board-discussion prep, 409A refreshes, defending a valuation against pushback. NOT for general modeling (financial-modeler) and NOT for the operating forecast itself (fpa-analyst).

Compose narrative-first board / investor / lender reporting packs — section sequencing, KPI selection, executive-summary patterns. Numbers don't ship without commentary. Used by `board-pack-composer` (primary).

Run a defensible discounted-cash-flow valuation — explicit projection period, terminal value (Gordon vs exit-multiple), WACC build, sensitivities, scenario weighting, and the cross-check against trading / precedent multiples. Reach for this skill on any valuation work (pre-investment, 409A, fairness opinion, M&A) where a number has to survive board / counterparty scrutiny. Used by `valuation-analyst` (primary) and `financial-modeler`.

Build and refresh a driver-based rolling forecast that survives FP&A review — driver tree from revenue volume × price, opex by category-driver, working-capital roll, capex schedule, scenario layer. Reach for this skill when standing up a new forecast model, refreshing the annual plan, or when an executive asks "what would it take to hit X?" Used by `fpa-analyst` (primary), `financial-modeler`, and `board-pack-composer` for the forecast slides.

Define KPIs that survive cross-team disagreement — single owner, single formula, single source of truth, decay-tested, documented in a KPI dictionary. Reach for this skill when launching a new metric, when two teams cite different numbers for "the same" KPI, when an exec asks "why doesn't this tie?", or when standing up a KPI pack. Used by `fpa-analyst` (primary) and `board-pack-composer`.

7-pass review of financial models — assumptions, mechanics, integrity (BS balances, CF reconciles), hardcodes, error-checks, scenarios, documentation. Used by `financial-modeler` (primary) and `valuation-analyst` for DCF integrity checks.

Run a clean month-end / quarter-end close — close-calendar mechanics, JE buckets, reconciliation checklist, exception-triage playbook. Reconciliation before commentary; materiality as a design constraint. Used by `controller` (primary).

Document a SOC 1 / SOC 2 control walkthrough — control description, test of design vs test of operating effectiveness, evidence-of-control patterns, sampling, exception triage, deficiency severity classification (control deficiency / significant deficiency / material weakness). Reach for this skill during pre-audit prep, when documenting a new control for the next SOC cycle, or when responding to an auditor's walkthrough request. Used by `audit-prep-specialist` (primary).

Build and operate a 13-week direct-method cash forecast — receipts by source, disbursements by category, week-by-week roll, variance-to-prior-forecast cadence, covenant headroom view, and the trigger thresholds for management action. Reach for this skill when a business is cash-tight, in workout, lender-monitored, or post-fundraise discipline-building. Used by `treasury-analyst` (primary) and `fpa-analyst` for the longer-range bridge.

Write variance commentary that tells a story instead of restating a table — templates for revenue, GM, opex, EBITDA, FCF with named drivers + materiality threshold applied. Source-cite every number. Used by `fpa-analyst` (primary) + `board-pack-composer`.

flag-finance-anti-patterns.sh PostToolUse hook for Edit | Write | MultiEdit on finance-conventional files. Flags mechanically-detectable violations of the finance team constitution (see plugins/finance/CLAUDE.md §3 "house opinions" and §4 "anti-patterns"): 1. Hardcoded rate-like numbers in model files (`*0.21`, `*1.25` etc.) where the number looks like a tax rate, growth rate, or discount factor b

Account reconciliation — [Account name] / [GL #]

Audit PBC tracker — [Audit / Period]

Board pack outline — [Entity] [Period]

13-week direct cash forecast — [Entity]

KPI pack — [Entity] [Period]

Model documentation — [Model name]

Month-end close calendar — [Entity] [Period]

Variance commentary — [Entity] [Period]

Use this agent for AML / KYC / sanctions / financial-crime work — customer-onboarding KYC, sanctions screening / hit clearing, EDD (enhanced due diligence), SAR / STR narrative drafting, transaction-monitoring rule tuning. Spawn for KYC file reviews, suspicious-activity triage, sanctions hits, EDD packages, AML program design questions. NOT for general regulatory filings (regulatory-reporting-analyst) and NOT for legal opinions (route to counsel).

Use this agent for Bermuda-domiciled insurance work — BMA Insurance Act 1978 + Rules / Codes, captives (Class 1 / 2 / 3 / 3A / 3B), commercial insurers (Class 4 / 3A / IIGB), long-term insurers (Class A-E), reinsurers, Insurance-Linked Securities (ILS) / Special Purpose Insurers (SPI), Segregated Accounts Companies (SAC), BSCR / ECR / MCR, EBS (economic balance sheet), CISSA, Solvency II equivalence implications, BMA filings. Spawn when work involves a Bermuda insurance entity, BMA-specific filings, captive structures, ILS / SPI vehicles, or BMA exam prep. NOT for non-Bermuda regulatory work (use regulatory-reporting-analyst) and NOT for legal opinions.

Use this agent for regulator examination readiness — PBC list management for exam, walkthrough rehearsals, mock examiner interviews, examiner Q&A drafting, MRA / MRIA / management-letter responses, remediation tracking. Spawn 6-12 weeks before an exam, immediately after an exam closes, or when a regulator's information request lands. NOT for financial-statement audit prep (that's finance/audit-prep-specialist).

Use this agent for compliance manual / policy / procedure authoring — new policy drafting, P&P refreshes, gap analysis against new regulation, regulator-facing documentation, jurisdictional adaptation of an existing policy. Spawn for new policies, periodic policy review cycles, mapping a new regulation into existing policies, drafting public-facing compliance commitments. NOT for legal opinions (route to counsel) and NOT for operational implementation (route to the relevant operational team).

Use this agent for regulatory filings — FATCA, CRS, supervisory returns, Solvency II QRTs, BMA EBS, US RBC, statutory financial statements, supervisory reports, capital adequacy calculations. Spawn for period-end filing prep, return review pre-submission, data-lineage / source-quality questions for regulatory data, regulatory accounting policy reviews. NOT for AML / sanctions specifically (aml-kyc-analyst) and NOT for legal opinions.

Use this agent for enterprise risk management — risk-framework design, three lines of defense, risk-appetite statements, risk registers, KRI design, control self-assessment, ORM / ERM. Spawn for risk-register builds and refreshes, control-mapping, KRI tuning, three-lines-of-defense assessments, risk-appetite-statement workshops. NOT for AML-specific risk (aml-kyc-analyst owns that) and NOT for legal opinions.

Structured review of an AML program against FATF / FFIEC expectations — the 5 pillars, common findings, regulatory citations with primary sources. Used by `aml-kyc-analyst` (primary).

Compliance / second-line control testing rubric — design adequacy + operating effectiveness for compliance controls (KYC quality, monitoring rule tuning, training coverage, regulatory-mapping freshness). Distinct from SOC1/SOC2 financial-control testing — second-line compliance testing has different scoping, sampling, and reporting. Reach for this skill when scoping a periodic compliance-monitoring program, training MI/QC analysts, or responding to an exam request for "evidence your controls work." Used by `risk-and-controls-specialist` (primary) and `aml-kyc-analyst`.

Pre-exam playbook for regulator examinations — PBC tracker, walkthrough rehearsal, mock interviews, exam-week posture, MRA / MRIA / management-letter response patterns. Used by `examination-prep-specialist` (primary).

KYC file + EDD review playbook — risk-rating logic, BOI / UBO verification, source-of-wealth vs source-of-funds, EDD trigger conditions, file completeness checklist, sign-off chain. Reach for this skill when reviewing a single customer file, designing the firm's KYC standard, or training analysts. Used by `aml-kyc-analyst` (primary).

Map internal controls / policies / procedures to specific regulatory citations (regulator + section + paragraph). Gap-analysis output format. Used by `risk-and-controls-specialist` + `policy-and-procedure-writer`.

Build / refresh an enterprise risk register that survives audit committee scrutiny — three lines of defense assignment, inherent + residual rating math, KRI design, risk-appetite mapping, control coverage, and the half-yearly refresh cadence. Reach for this skill when standing up a new ORM/ERM framework, refreshing the register, or remediating an "outdated register" finding. Used by `risk-and-controls-specialist` (primary) and `policy-and-procedure-writer`.

Disposition framework for sanctions screening alerts — true-match vs false-positive triage, secondary-match evidence chain, escalation criteria, documented-rationale template, list-version capture, and the audit-trail requirements that survive examiner review. Reach for this skill when designing the disposition process or training analysts on hit clearance. Used by `aml-kyc-analyst` (primary).

Draft SAR / STR narratives that survive regulator review — typology + the W's + what to omit + reviewer sign-off chain. Used by `aml-kyc-analyst` (primary). Confidentiality class always at least client-confidential; often regulator-only.

Period-end supervisory / regulatory return preparation playbook — data lineage, maker-checker, materiality / threshold definitions, common return families (FATCA, CRS, BMA EBS, Solvency II, supervisory returns, capital adequacy / RBC), late-filing protocols. Reach for this skill 4-6 weeks before a periodic filing or when responding to a regulator data request. Used by `regulatory-reporting-analyst` (primary).

scrub-confidential-pre-write.sh PreToolUse hook for Write | Edit | MultiEdit. Scans the *pending* target file (its current on-disk content if it exists; the agent's about-to-write content is not directly visible here, so this hook acts as a second line of defense by re-scanning the file AFTER the tool runs is one option, but this hook is PreToolUse and so checks the existing file content for prior

AML program outline — [Entity]

Control narrative — [Control ID] [Control name]

Examination response tracker — [Regulator] [Exam type] [Period]

KYC / EDD workpaper — [Customer ID]

[Policy Name]

Risk register — [Entity / Domain]

SAR / STR narrative — [Case ID]

Pre-submission checklist — [Return name] [Period]

Use this agent for accessibility work — WCAG 2.2 AA / AAA audits, ARIA review, keyboard-navigation review, screen-reader testing, color-contrast checks, focus management, reduced-motion / reduced-data accommodation. Spawn for pre-launch audits, remediation prioritization, ongoing a11y review cycles. NOT for visual design (visual-designer) and NOT for implementation (frontend-implementer).

Use this agent for content / copy work — site copy, content hierarchy, microcopy, SEO content, content style guide, content audit, content modeling for headless CMS. Spawn for content audit, copy authoring, voice-and-tone design, content modeling, blog / article strategy. NOT for stakeholder prose (use ravenclaude-core/documentarian) and NOT for technical SEO infrastructure (use web-architect).

Use this agent for web frontend implementation — HTML, CSS, vanilla JS, React, Astro, Next, component-library work, responsive patterns, design-token wiring, build integration. Spawn for UI build / refactor, design-to-code conversion, component-library setup, design-system code. NOT for backend code (use ravenclaude-core/backend-coder) and NOT for visual decisions (visual-designer).

Use this agent for web performance work — Core Web Vitals (LCP / CLS / INP) diagnosis and tuning, image / font / JS optimization, CDN strategy, caching, third-party hygiene, performance budgets. Spawn for performance review, slow-page diagnosis, pre-launch budget enforcement, ongoing CWV monitoring. NOT for backend perf (use ravenclaude-core/backend-coder) and NOT for build / hosting decisions (web-architect).

Use this agent for UX work — wireframes, user flows, screen-level layouts, conversion design, interaction design, usability heuristics. Spawn for pre-build UX, screen flows, conversion-focused redesigns, usability reviews, form design. NOT for visual design (visual-designer) and NOT for code (frontend-implementer).

Use this agent for visual / brand work — brand systems, typography, color, layout grids, design tokens, component visual style, theming, dark-mode, motion design. Spawn for brand-from-scratch, design-system spec, visual review, theming, token rationalization. NOT for UX flow / wireframes (ux-designer) and NOT for code implementation (frontend-implementer).

Use this agent for web architecture decisions — site architecture, information architecture, tech-stack selection, hosting / CDN, build pipeline, repo structure, content modeling for headless CMS, technical SEO foundations. Spawn for greenfield, re-platform, technical-SEO audits, stack trade-off decisions. NOT for component-level code (frontend-implementer) and NOT for visual design (visual-designer).

WCAG 2.2-aligned accessibility audit — semantics, ARIA, keyboard navigation, color contrast, focus management, motion preferences. Severity guide + tooling notes. Used by `accessibility-auditor` (primary).

Audit existing site content — full inventory (URL × type × intent × last-updated × owner), scoring against business / user-need / SEO criteria, remediation queue (keep / consolidate / rewrite / retire), and the migration plan when re-platforming. Reach for this skill at the start of a re-platform, before an SEO push, or when content quality has stopped predicting conversion. Used by `content-strategist` (primary) + `web-architect`.

Design and audit conversion-focused screens — funnel definition, friction-vs-trust balance, form field selection (every field is a cost), one CTA per screen discipline, social-proof placement, microcopy patterns, and the conversion-rate measurement plan. Reach for this skill when designing or reviewing a landing page, sign-up flow, checkout, or any "convert visitor → action" screen. Used by `ux-designer` (primary) + `content-strategist`.

Diagnose and improve Core Web Vitals (LCP / CLS / INP). Includes a Mermaid decision tree for root-cause triage across all three vitals + canonical fix-by-symptom map. Field data (CrUX / RUM) at p75 is the measurement target. Used by `performance-engineer` (primary).

Audit an existing brand / design system for consistency, completeness, token coverage, dark-mode readiness. Used by `visual-designer` (primary) + `frontend-implementer` (token-to-code wiring).

Scaffold a token system from brand spec to token JSON to CSS variables to framework theme (Tailwind / Shadcn / CSS-in-JS / Theme UI). Includes naming convention, scale design (color / spacing / typography / radius / shadow / motion), light/dark mode, semantic vs primitive tokens, and the dual-mode build pipeline. Reach for this skill when launching a new design system or when an existing system has "design drift" between Figma and code. Used by `visual-designer` (primary) + `frontend-implementer`.

Design site information architecture — sitemap, URL taxonomy, navigation patterns (primary / utility / footer / contextual), card-sort discipline, content model that the IA implies, and the URL-to-template mapping. Reach for this skill at the start of a new build or when redesigning navigation on an existing site. Used by `web-architect` (primary) + `ux-designer`.

Technical SEO sweep — crawlability, indexability, schema markup, sitemaps, OG / Twitter Card metadata, hreflang, structured data. Used by `web-architect` (primary, technical) + `content-strategist` (content-SEO).

Catalogue and hygiene-audit third-party scripts on a marketing site — performance budget by category (analytics / chat / A/B / fonts / video / social), async-defer patterns, consent-gating (GDPR / CCPA / consent-mode v2), CSP implications, and the periodic re-audit cadence. Every third-party is debt; this skill quantifies it. Reach for this skill before launch, during a Core Web Vitals push, or when adding a new external script. Used by `performance-engineer` (primary) + `web-architect`.

check-web-anti-patterns.sh PostToolUse hook for Edit | Write | MultiEdit on web-conventional files. Flags mechanically-detectable violations of the web-design team constitution (see plugins/web-design/CLAUDE.md §3 "house opinions" and §4 "anti-patterns"): 1. Oversized raster image committed (> 500 KB jpg / png / webp). §4 — image > 500 KB above-the-fold. 2. `<img>` tag missing alt attribute. §3 #5

Accessibility audit report — [Site / scope]

Content style guide — [Brand / site]

Design brief — [Project name]

Design system spec — [System name] [Version]

Launch checklist — [Site / project] [Launch date]

Performance budget — [Site / page-type]

SEO audit report — [Site]

Site architecture — [Site name]

Use this agent for FERPA-aware (and segment-equivalent data-privacy) multilingual, multi-audience partner & end-user communication. Parent comms, school admin comms, district / institution leadership, end-user-facing copy. Spawn for "translate this PSM email for the parent audience", "this announcement is going to non-English-primary families — variant pls", "sanity-check what we can legally say in this district memo", or "the partner asked for a parent-facing version of the QBR summary". NOT for internal PSM team comms (those are plain English, no translation needed). NOT for legal opinions on what's allowed (that's escalation to `regulatory-compliance` or counsel).

Use this agent for partner-engagement signal design, health-score architecture, dashboard specs, and metric interpretation. Spawn for "design a partner health score", "is this partner red or yellow", "build a new metric for X", "diagnose why a metric moved", or rostering / data-quality diagnostic work in K-12 (Clever / ClassLink / OneRoster), higher-ed (SIS / LMS), or corporate L&D (HRIS / LMS) contexts. NOT for the partner-facing comms about a metric (that's `ferpa-comms-translator`). NOT for the deck that presents a metric (that's `qbr-composer`).

Use this agent to maintain the durable partner record — the context that outlives any one PSM seat. Institutional history, decision-makers, named programs, prior incidents, what they care about (in their own words). Distinct from the touchpoint log (which is the running diary). Spawn for new-partner onboarding (start the durable record), PSM handoff between owners, pre-meeting context refresh, or "what did we promise this partner last year". NOT for current-state metrics (that's `learning-analytics-analyst`). NOT for current-quarter touchpoints (those live in the log, not the profile).

Use this agent for EdTech-specialized PSM work — onboarding, adoption, ongoing pulse, day-to-day partner-facing work. Specializes the generic ravenclaude-core/partner-success-manager for the EdTech vertical (K-12 / higher-ed / corporate L&D). Spawn for a health check on a partner, first-90-days plan, regular touchpoint cadence, "is this partner OK?", first response to a partner signal. NOT for designing renewal / expansion / recovery plays (that's `success-playbook-designer`). NOT for QBR composition end-to-end (that's `qbr-composer`).

Use this agent for Quarterly Business Review materials end-to-end — data pull plan → narrative → deck → talk track → followup tracker. Spawn for QBR prep (~1 week before by default), post-QBR commitment tracking, mock-QBR rehearsal, or a renewal-QBR variant. NOT for play design (that's `success-playbook-designer`). NOT for the underlying metric design (that's `learning-analytics-analyst`).

Use this agent to design or refresh PSM plays — renewal plays, expansion plays, recovery (red-flag intervention) plays, advocacy plays. The PSM *executes* plays; this agent *designs* them. Spawn for "we need a new recovery play for partners showing the X signal", "the renewal play hasn't worked twice in a row — refresh it", "what should the expansion play be when a partner crosses adoption threshold Y", "design an advocacy play to surface case-study candidates". NOT for executing a play on a specific partner (that's `partner-success-manager`).

Sequence K-12 partner adoption activities by stage (newly-implemented / first-year-sustaining / multi-year-mature / pre-renewal) with school-year-phase overlay. Surface-by-surface rhythm (teacher / admin / student / family-facing). Diagnostic-before-intervention discipline — don't push feature-breadth in stage 1. Used by `learning-analytics-analyst` + `success-playbook-designer`.

Design a structured EdTech advocacy program with 5-tier ladder (logo → quote → case study → speaker → peer call). Health-score eligibility gate (top-quartile only), 2-asks-per-year ceiling, state-by-state anonymization overlay (CA/NY/IL stricter; TX/FL more permissive), FERPA consent for student/parent quotes. Used by `success-playbook-designer` + `ferpa-comms-translator` + `partner-success-manager`.

Map the partner's buying committee — economic buyer, champion, technical buyer / IT, user-champion, blocker, executive sponsor — across segments (K-12 / higher-ed / corp L&D). Includes the multi-thread coverage gap visualization, the "ghost sponsor" detection pattern, sponsor-change protocols, and integration with the durable partner profile. Reach for this skill on a new-partner kick-off, before a renewal, when a critical contact leaves, or when QBRs are well-attended but decisions aren't happening. Used by `partner-profile-curator` (primary) + `partner-success-manager`.

Design expansion motions that fire only when the partner has earned value — 3-gate eligibility (top-quartile health + demonstrable adoption + organizational readiness), value-trigger taxonomy, seat / module / department land-and-expand patterns, internal-champion-armament, ROI-storytelling format, and the "don't sell to bottom-quartile" discipline. Segment overlays for K-12 / higher-ed / corp L&D. Reach for this skill when designing the firm's expansion playbook or when the partner-success leader is being pushed to monetize too hard. Used by `success-playbook-designer` (primary).

Run the 90-day technical-onboarding arc for a newly-contracted EdTech partner — discovery (weeks 1-2) → integration setup (3-4) → train-the-trainer (5-6) → go-live + Day-30 measurement (7-8) → stabilization + PSM handoff (9-12). Calendar-dead-zone go-live check is the highest-leverage pre-flight. Used by `partner-success-manager` + `learning-analytics-analyst`.

Design and maintain a partner health score that actually predicts renewal / churn for EdTech partners. Signal selection, weighting, half-life / decay, red-flag triggers, and threshold-to-play mapping. Reach for this skill when designing a new score, refreshing one that's stopped predicting outcomes, or interpreting a score move.

Design partner-facing training programs for EdTech — train-the-trainer is the only model that scales in K-12. K-12 PD modality decision rule (live-in-person / live-virtual / hybrid / async-with-followup), PD-credit alignment with state frameworks, teacher-union overlay in unionized states. Used by `ravenclaude-core/documentarian` + `partner-success-manager` + `success-playbook-designer`.

Compose a Quarterly Business Review end-to-end — data pull plan, narrative arc, deck outline, talk track, post-QBR commitment tracker. Reach for this skill 1–2 weeks before a QBR is scheduled, OR after a QBR to convert in-meeting promises into a tracked plan.

Design red-flag intervention sequences — root-cause diagnostic before remedy (4 parallel hypotheses), time-bound recovery plan with measurable 30/60/90-day signal targets, escalation criteria (PSM → success leadership → exec sponsor → counsel → churn-prep), the "is this recoverable?" rule, churn-prep workflow when not, and the post-recovery learning capture. Reach for this skill when a partner trips red on the health score, when a renewal is at clear risk, or when a partner has signaled dissatisfaction. Used by `success-playbook-designer` (primary) + `partner-success-manager`.

Design renewal motions that earn the renewal instead of negotiating it — T-180/T-120/T-90/T-60/T-30/T-0 sequence, sponsor-confirmation arc, value-evidence pack, multi-thread the buying committee, decision-memo support, expand/maintain/contract decision rule, and segment-specific overlays (K-12 budget cycle, higher-ed academic calendar, corp L&D fiscal year). Reach for this skill 120-90 days before a renewal date, when a renewal "should be safe" but no movement has happened, or when designing the firm's renewal playbook. Used by `success-playbook-designer` (primary) + `partner-success-manager`.

Diagnose rostering / SIS / LMS data-sync issues in EdTech contexts — K-12 (Clever, ClassLink, OneRoster), higher-ed (SIS/LMS), corporate L&D (HRIS/LMS). When to escalate to product vs coach the partner's admin. Reach for this skill when a partner says "the data isn't right" or when partner-engagement metrics drop without an obvious user-side cause.

Author a 30/60/90 day or quarterly success plan for an EdTech partner that has measurable success criteria, named owners, and a defensible cadence. Reach for this skill when onboarding a new partner OR when refreshing a quarterly plan after a renewal / midyear review.

flag-psm-anti-patterns.sh PostToolUse hook for Edit | Write | MultiEdit on EdTech-PSM artifact files. Flags the most common mechanically-detectable violations of the EdTech-PSM team constitution (see plugins/edtech-partner-success/CLAUDE.md §3, §4): 1. Action item without a date — files matching *qbr*, *success-plan*, *touchpoint*, *escalation* with a bullet/checkbox that looks like an action item

Adoption diagnostic worksheet — `<partner_name>`

Annual Partner Review — `<Partner Name>` — `<Year>`

Case study draft — `<partner_name | "Anonymized Partner">`

Cross-functional partnership map — `<partner_name | vendor_name>`

Escalation Memo — `<Partner Name>` — `<short risk description>`

Health-Score Dashboard — Spec

Implementation 90-day plan — `<partner_name>`

Onboarding Checklist — First 90 Days — `<Partner Name>`

Partner Profile — `<Partner Name>`

QBR Deck Outline — `<Partner Name>` — `<Quarter>`

Reference customer pipeline tracker

Renewal decision memo — `<partner_name>`

Success Plan — `<Partner Name>`

Touchpoint Log — `<Partner Name>`

Train-the-trainer curriculum — `<partner_name>`

Use this agent for custom Airbyte connector authoring when an ELT vendor doesn't ship a connector for the source the engagement needs. Highest-leverage use case is EdTech LMS (Canvas, Moodle, Schoology, Blackboard, D2L) — native ELT vendor coverage is thin, and custom-Airbyte-connector capability is a real consulting differentiator. Also HRIS edge cases (ADP via Flexspring, niche regional vendors) and unusual SaaS sources. Spawn for "vendor doesn't ship a Canvas connector — what do we do", "build a custom Airbyte source for [niche SaaS]". NOT for configuring an existing Airbyte / Fivetran connector (that's `etl-pipeline-engineer`).

Use this agent for interactive dashboard front-end generation — Evidence.dev (marketing-site portfolio), Apache Superset / Metabase OSS (client deliverable), Cube + Next.js + Tremor + Recharts + shadcn/ui (productized SaaS), Power BI Embedded F-SKU (Microsoft-stack engagements). Spawn for "build a dashboard for ravenpower.net", "scaffold a Cube schema for this client", "generate the React KPI cards", "embed Superset into the client's admin panel". NOT for the underlying database (that's `database-setup-guide`). NOT for the JWT-issuance security review (that's `ravenclaude-core/security-reviewer` invoking the `jwt-embed-issuance` skill).

Use this agent for cloud-database setup guidance — Supabase, Neon, RDS, Azure SQL, Fabric, DuckDB, MotherDuck, Snowflake, Databricks, Turso. Spawn for "stand up a new database for this client", "migrate this Excel/SharePoint sprawl to a real DB", "set up multi-tenant tables", or "which DB for this engagement". NOT for query authoring (route to client's data engineer). NOT for RLS policy authoring (that's the rls-policy-authoring skill, invoked by `ravenclaude-core/security-reviewer`).

Use this agent for ELT pipeline design and configuration — Airbyte, Fivetran, n8n, custom integrations. Source-system specifics for QuickBooks Online, Stripe, Salesforce, HubSpot, Google Analytics 4, Shopify, common HRIS. Spawn for "pull QuickBooks into the warehouse", "set up Airbyte for this engagement", "the Fivetran connector for X is missing", "this is going to blow our MAR budget — what now". NOT for custom Airbyte connector authoring (that's `connector-developer`). NOT for modeling the data once ingested (that's `ravenclaude-core/data-engineer`).

Compare cloud databases (Supabase, Neon, RDS, Azure SQL, Fabric, DuckDB, MotherDuck, Snowflake, Databricks, Turso) for an SMB consulting engagement — pricing tables with retrieval dates, setup-complexity matrix, when-to-pick guidance. Used by `database-setup-guide` to recommend a DB choice for a new engagement.

Connector-specific configuration patterns for ELT pipelines — QuickBooks OAuth + rate-limit handling, Stripe webhook + batch hybrid, Salesforce Bulk API 2.0, HubSpot API v3, GA4 BigQuery export, Shopify GraphQL Admin API. Used by `etl-pipeline-engineer` when configuring an Airbyte / Fivetran / n8n connector against a real source.

Scaffold Cube semantic-layer schemas with mandatory `securityContext` baked in for multi-tenant customer-facing dashboards. Includes measure/dimension patterns, pre-aggregation hints, view-level partner-facing query surface, and the cross-boundary denial test. Used by `dashboard-builder` on Case-C productized-SaaS engagements.

Tune interactive-dashboard performance against a per-widget-class budget — Cube pre-aggregation design, Postgres / DuckDB materialized views, cache layers (Cube + Redis + browser TanStack Query), the per-widget profile loop (measure → identify the slow stage → fix at the lowest-cost layer). Reach for this skill when a dashboard exceeds the 1-2s widget target, or proactively before adding a heavy widget. Used by `dashboard-builder` (primary).

Design data-quality tests that catch real bugs — uniqueness / not-null / referential integrity / freshness / row-count drift / value-range / cross-source reconciliation. dbt-test mechanics for each, severity tiers (error vs warn), the runbook-entry-per-failing-test discipline, and when to escalate to Great Expectations or Monte Carlo / Bigeye. Reach for this skill when launching a new pipeline OR after a "the numbers were wrong" incident. Used by `etl-pipeline-engineer` (primary).

Scaffold a dbt project that ships — sources → staging → intermediate → marts → metrics layer discipline, generic + custom tests, doc-blocks for every model, exposure tracking, RLS-safe role separation (build-role vs query-role), CI shape (`dbt build` on PR), and a dev/prod env-promotion shape. Reach for this skill at engagement start (greenfield warehouse) or when a dbt project has decayed into ungoverned models. Used by `etl-pipeline-engineer` (primary) + `dashboard-builder`.

Configure CSP `frame-ancestors`, iframe `sandbox` attributes, postMessage origin checks, and web-component shadow-DOM boundaries for embedded dashboards. Invoked by `ravenclaude-core/security-reviewer` when a diff touches embed-auth flow; generated alongside dashboard code by `dashboard-builder`.

Canonical 2026 JWT-embed flow for dashboard embedding — required claims (`sub`, `tenant_id`, `iat`, `exp`, `iss`, `aud`, `nonce`), tool-specific verification (Superset guest tokens, Metabase JWT URLs, Cube Authorization Bearer, Power BI MSAL-via-AAD), 5-15 min expiration policy, cross-boundary denial test contract. Invoked by `ravenclaude-core/security-reviewer` for any embed-auth review.

Migrate a single-tenant database / dashboard stack to multi-tenant — `tenant_id` column propagation + backfill, RLS / semantic-layer scope rules introduced post-hoc, JWT-claim shape migration, embed-token cutover plan with parallel + backout window, and the mandatory cross-boundary denial test before flipping the switch. Reach for this skill when an engagement shifts from one-client deliverable to productized SaaS. Used by `database-setup-guide` (primary) + `dashboard-builder`.

Author Postgres Row Level Security policies (force-on, CI-deployed, denial-tested) for multi-tenant dashboards. Encodes the closeness-to-data invariant — tenant isolation at the closest-to-data layer the viewer's token cannot influence. Covers Postgres RLS + semantic-layer enforcement (Cube `securityContext`, Power BI DAX roles, Fabric, Snowflake row-access). Invoked by `ravenclaude-core/security-reviewer`.

Select a dashboard-engagement stack via the Case A/B/C/D Mermaid decision tree (Portfolio / Per-client / Productized SaaS / Pipes-only) — surfaces the per-viewer-pricing-trap heuristic, recognizes the EdTech LMS connector-gap, returns a populated `stack-decision-record.md`. Invoked by `ravenclaude-core/architect` via inline prior.

flag-data-platform-smells.sh PreToolUse hook for Edit | Write | MultiEdit on data-platform artifact files. Flags four mechanically-detectable violations of the data-platform team constitution (see plugins/data-platform/CLAUDE.md §3, §4): 1. Inline secrets — API keys, JWT signing secrets, connection strings with credentials, OAuth client secrets in .tsx/.ts/.js/.py/.yml/.sql (§3 #4) 2. Postgres CRE

---------------------------------------------------------------------------

Cube schema starter — multi-tenant analytics

Dashboard engagement checklist — {{Engagement / Client Name}}

(no description)

(template folder)

{{Case Study Title}}

(no description)

Metabase Interactive Embedding (React component) — seam-marked stub

Power BI Embedded App-Owns-Data (React component) — seam-marked stub

(no description)

Stack decision record — {{Engagement / Client Name}}

Superset embed (React iframe component) — seam-marked stub