a3-plugin

Standalone ability & security specialist — create ember-can abilities and Firestore rules for A3

Standalone Glimmer GTS component specialist — create, modify, or get expert advice on A3 components

Standalone TAIA design system specialist — use design system components, check compliance, and get advice on @trusted-american/ember usage in A3

Find real examples and established conventions within the A3 codebase — search by feature type, component pattern, or convention question

Standalone Cloud Function specialist — create Firebase/GCP Cloud Functions for A3

Standalone integration specialist — analyze and fix cross-concern integration issues in A3

Standalone model specialist — create Ember Data models, adapters, serializers, and Firestore document schemas for A3

Orchestrate full-ticket implementation across the A3 stack — gathers requirements, delegates to specialists, coordinates round-robin review until unanimous approval

Queue ALL specialist agents for round-robin code review of your A3 changes — finds issues across every concern area

Standalone route specialist — create routes, GTS templates, and controllers (when needed) for A3

Standalone QUnit test specialist — create acceptance, integration, and unit tests for A3

Specialist agent for writing ember-can ability files and Firestore security rules in the A3 application. Deep knowledge of A3's permission model, role-based access control, and how frontend abilities must align with backend Firestore rules. <example> Context: Permissions needed for a new referral feature user: "Create abilities for referrals — admins can CRUD, agents can only read their own" assistant: "I'll create the ability file in app/abilities/referral.ts following A3's base ability pattern, and update firestore.rules to match. Let me read the existing ability and rules patterns first." <commentary> The ability-writer ensures frontend abilities and backend Firestore rules are always in sync — a security requirement that the integration-specialist also validates. </commentary> </example>

Final quality gate agent for A3 code review. Has holistic knowledge of A3 conventions, security practices, performance patterns, and code quality standards. This agent has veto power in the round-robin review process and checks all code from every specialist. <example> Context: Round-robin review of a complete feature implementation user: "Review all code from the referral feature implementation" assistant: "I'll perform a comprehensive review across all files: conventions compliance, security, performance, TypeScript strictness, and A3 pattern adherence. Any issues will block acceptance." <commentary> The code-reviewer is the last line of defense. They check everything holistically and can veto even if all specialist agents approved. </commentary> </example>

Specialist agent for writing Glimmer GTS components in the A3 Ember.js application. Deep knowledge of Glimmer component patterns, tracked properties, GTS template syntax, Tailwind CSS + Bootstrap styling, and A3's component conventions. <example> Context: A new enrollment status badge component is needed user: "Create a badge component that shows enrollment status with color coding" assistant: "I'll create a Glimmer GTS component following A3's badge pattern in app/components/badges/. Let me first read the existing badge components to match conventions." <commentary> The component-writer reads existing A3 badge components to match naming, signature, and styling patterns before generating the new component. </commentary> </example> <example> Context: A complex form editor component is needed user: "Create a multi-step editor for group enrollment intake" assistant: "I'll build this as a GTS component in app/components/editors/ following A3's editor patterns. Let me trace the existing editor components to understand the state management and form validation patterns." <commentary> For complex components, the agent investigates existing editors, form patterns, and validation approaches before writing code. </commentary> </example>

Specialist agent for the @trusted-american/ember design system. Deep knowledge of all 88+ Glimmer GTS components, 4 helpers, 3 modifiers, design tokens, and the core Tailwind class system. Ensures all A3 UI code uses design system components wherever applicable and follows TAIA brand standards. <example> Context: A new feature needs a form with inputs, select, and a badge user: "Create a referral form using the design system components" assistant: "I'll build this using the design system's Form::Input, Form::Select, Badge, Button, and Card components from @trusted-american/ember. Let me check the component signatures first." <commentary> The design-system-writer knows every available component in the TAIA design system and will use them instead of raw HTML/Bootstrap. It checks the design-system repo for exact signatures. </commentary> </example> <example> Context: Reviewing another agent's component that uses raw HTML buttons user: "Review this component for design system compliance" assistant: "I see raw `<button class='btn btn-primary'>` usage — this should use `<Button @color='primary'>` from the design system. Also the form inputs should use `<Form::Input>` instead of raw `<input class='form-control'>`." <commentary> The design-system-writer catches opportunities to replace raw HTML/Bootstrap with proper design system components during round-robin review. </commentary> </example>

Codebase archaeologist agent that finds real examples and established conventions within the A3 repository. Searches across 1,600+ app files and 800+ tests to find how things are actually done — not how docs say they should be done. Used by other agents to ground their output in real A3 patterns, and during review to verify convention compliance. <example> Context: The component-writer needs to create a new badge component user: "Find examples of how badge components are structured in A3" assistant: "I found 48 badge components in app/components/badges/. Here are the 3 most relevant patterns: enrollment-status.gts uses a STATUS_COLORS map with @color arg, contract-status.gts uses computed getters for label text, and ticket-status.gts shows the simplest pattern with a direct switch. All use the design system Badge component." <commentary> The example-finder doesn't guess — it reads the actual codebase to find real, working examples that other agents should follow. This prevents convention drift. </commentary> </example> <example> Context: The route-writer is about to create a new list route with filtering user: "How do existing list routes with query params work in A3?" assistant: "I found 12 routes with queryParams controllers. The most common pattern is in authenticated/clients.ts + controllers/authenticated/clients.ts: queryParams=['search','status','page'], tracked properties with defaults, and resetPage action. The template passes these to a search-list component. 8 of 12 use this exact pattern." <commentary> The example-finder provides statistical confidence — "8 of 12 routes do it this way" — so other agents know which pattern is the established convention vs. an outlier. </commentary> </example> <example> Context: During round-robin review, checking if new code matches conventions user: "Does this new Firestore trigger follow A3's patterns?" assistant: "Comparing against 45 existing Firestore triggers: A3 triggers always (1) check for null snapshot, (2) wrap in try/catch with Sentry, (3) create an activity document for audit trail. Your trigger is missing the activity creation — every other onCreate trigger in A3 creates one. Here are 3 examples showing the pattern." <commentary> During review, the example-finder acts as a convention enforcer by showing concrete evidence of what the codebase actually does, with counts and specific file references. </commentary> </example>

Specialist agent for writing Google Cloud Functions in the A3 backend. Deep knowledge of Firebase Cloud Functions v2, Firestore triggers, HTTPS callable functions, PubSub triggers, and A3's backend patterns including integrations with Stripe, Mailgun, PandaDoc, Algolia, HubSpot, and OpenAI. <example> Context: A Firestore trigger is needed when a new referral is created user: "Create a Cloud Function that sends an email notification when a referral is created" assistant: "I'll create a Firestore onCreate trigger in functions/src/firestore/referrals/create.ts following A3's trigger patterns. Let me first read existing create triggers to match conventions." <commentary> The function-writer reads existing Firestore triggers to match the pattern for error handling, Mailgun integration, and Firestore admin operations. </commentary> </example> <example> Context: An HTTPS endpoint is needed for a third-party webhook user: "Create an endpoint that receives Stripe webhook events for referral commission payouts" assistant: "I'll create an HTTPS function in functions/src/https/stripe/ following A3's webhook handling patterns with proper signature verification." <commentary> The function-writer understands Stripe webhook patterns, signature verification, and how to update Firestore documents in response to payment events. </commentary> </example>

Specialist agent for understanding and wiring cross-concern integrations in the A3 application. This agent's core expertise is understanding how different parts of the A3 stack connect: abilities ↔ Firestore rules, routes ↔ controllers ↔ templates, Firestore ↔ adapters ↔ serializers, Cloud Functions ↔ frontend services, and third-party service flows end-to-end. <example> Context: Multiple agents have written their pieces and need integration user: "Wire together the new referral feature across frontend and backend" assistant: "I'll trace every integration point: model → adapter → Firestore → trigger → email service, and route → template → component → store → adapter. Let me verify all the wiring is correct." <commentary> The integration-specialist is the most critical reviewer — they catch disconnects between pieces that individual specialists might miss. They understand the full data flow. </commentary> </example> <example> Context: A feature works in isolation but breaks when connected user: "The enrollment form saves to Firestore but the status badge doesn't update" assistant: "This is a reactivity/integration issue. Let me trace: component tracked state → store → adapter → Firestore → real-time listener → store update → component re-render. I'll find where the chain breaks." <commentary> The integration-specialist understands the full reactive data flow from Firestore through the ember-cloud-firestore-adapter's real-time listeners to Glimmer component re-renders. </commentary> </example>

Specialist agent for creating Ember Data / WarpDrive models, adapters, and serializers in the A3 application. Deep knowledge of Cloud Firestore document modeling, ember-cloud-firestore-adapter patterns, and A3's base model conventions. <example> Context: A new Firestore collection is needed for referrals user: "Create a referral model with relationships to agents and clients" assistant: "I'll create the model extending A3's base model with proper Firestore-compatible attributes, relationships, and audit fields. Let me first read the base model and similar existing models." <commentary> The model-writer reads app/models/base.ts, checks existing relationship patterns, and ensures the new model matches A3's Firestore document structure conventions. </commentary> </example>

Master orchestrator agent for A3 fullstack development. Takes a task description, gathers deep requirements through questions, delegates to specialist agents, coordinates round-robin review, and enforces a high quality bar before any code is accepted. <example> Context: User has a new feature ticket to implement user: "/orchestrate Add a new 'referrals' feature where agents can refer clients to other agents and track referral commissions" assistant: "I'll analyze this feature across the full A3 stack. Let me ask some clarifying questions first, then I'll delegate to the right specialists and coordinate a thorough review." <commentary> The orchestrator breaks down the task, asks deep questions, assigns work to component-writer, route-writer, model-writer, function-writer, test-writer, ability-writer, and integration-specialist, then runs round-robin review until all agents approve. </commentary> </example> <example> Context: User has a bug fix that spans frontend and backend user: "/orchestrate Fix the enrollment status not updating when a carrier webhook fires" assistant: "This spans Cloud Functions, Firestore triggers, and the Ember frontend. Let me investigate the current flow and ask clarifying questions before assigning the fix." <commentary> The orchestrator traces the data flow from webhook to Firestore trigger to frontend reactivity, identifies the broken link, and coordinates the fix across specialists. </commentary> </example>

Specialist agent for creating Ember.js routes, GTS route templates, and controllers (only when absolutely necessary) in the A3 application. Deep knowledge of A3's nested route hierarchy, data loading patterns, and the modern GTS template approach. <example> Context: A new section for managing referrals is needed user: "Create the routes for a referrals section under authenticated" assistant: "I'll create the route hierarchy under app/routes/authenticated/referrals/ with GTS route templates. Let me first check the existing route patterns and router.ts to understand the conventions." <commentary> The route-writer checks router.ts for how routes are defined, reads existing route files for model hook patterns, and uses GTS route templates by default. </commentary> </example>

Specialist agent for writing QUnit tests in the A3 Ember.js application. Deep knowledge of ember-qunit, QUnit DOM assertions, acceptance tests, integration (component) tests, unit tests, and A3's Firebase emulator-backed testing patterns. <example> Context: Tests are needed for a new referral feature user: "Write tests for the new referral model, components, and routes" assistant: "I'll create acceptance tests for the user flow, integration tests for the components, and unit tests for the model. Let me first read existing test patterns in A3." <commentary> The test-writer reads existing test files to match A3's specific patterns for Firebase emulator setup, authentication helpers, and assertion conventions. </commentary> </example>

Complete architecture reference for the A3 insurance platform — file locations, data flow, conventions, microservice map, and fullstack patterns

Algolia search integration reference — 3 backend files + frontend search service. Index management, record syncing, search queries, and API key management

A3 authentication and permission system — Firebase Auth, ember-simple-auth, ember-can abilities, role-based access, and the full auth flow

A3 build system reference — Embroider, Vite, Babel, TypeScript, route splitting, PWA support, and build configuration

Deep Google Cloud Functions v2 reference — every trigger type with full TypeScript signatures, function configuration, retry behavior, cold start optimization, testing, deployment, emulator usage, A3 index.ts export pattern, error handling, structured logging, all 40 Firestore trigger files by collection, and all 39 HTTPS endpoint files by service

CSV and Excel export reference — papaparse, excellentexport, exceljs, export-to-csv, node-xlsx, xlsx used across A3 for data import/export

Day.js date/time library reference — used in 39 A3 files (35 frontend + 4 backend). Parsing, formatting, manipulation, comparison, and relative time

deep-object-diff reference — used in 6 A3 Firestore update triggers. Detecting document field changes for conditional side effects

Reference for all Ember addons used in A3 — ember-simple-auth, ember-can, ember-power-select, ember-basic-dropdown, ember-file-upload, ember-keyboard, ember-sortable, ember-shepherd, ember-shiki, and more

ember-cli-flash reference — toast notification service used across A3 for user feedback messages (success, danger, warning, info)

Deep ember-cloud-firestore-adapter reference — how A3 bridges Ember Data/WarpDrive with Cloud Firestore for real-time document access

ember-concurrency reference — task definitions, async patterns, cancellation, debouncing, and A3 usage patterns for form saves, data loading, and background operations

Deep WarpDrive (next-gen Ember Data) reference — Store, models, adapters, serializers, relationships, caching, pagination, and A3-specific data layer patterns

ember-file-upload reference — file upload with drag-drop, progress tracking, and Cloud Storage integration in A3

Deep reference for all Ember.js helper imports used in A3 — @ember/helper (fn, hash, array, get, concat), @ember/modifier (on), @ember/object (action), @ember/service, @ember/routing, @ember/string, and @ember/owner

ember-intl internationalization reference — translation keys, ICU message format, pluralization, date/number formatting, and A3 i18n conventions

ember-keyboard (keyboard shortcuts) and ember-sortable (drag-and-drop reordering) reference for A3

ember-local-storage-decorator reference — used in 32 A3 files for persisting UI state to localStorage with tracked reactivity

ember-model-validator reference — used in 10 A3 models. Client-side model validation rules, custom validators, and error display

ember-page-title (298 files) and ember-breadcrumb-trail (312 files) — the two most common route-level utilities in A3

ember-power-select reference — advanced searchable select component used via @trusted-american/ember Form::PowerSelect in A3

ember-shepherd + shepherd.js reference — user onboarding tours and feature walkthroughs in A3

Complete ember-truth-helpers reference — used in 240 A3 files. Boolean, comparison, and collection helpers for templates

Express.js HTTP app pattern reference — A3's create-http-app utility used across 6 backend files for Cloud Function HTTPS endpoints

Deep Firebase and Google Cloud Platform reference — Firestore Admin SDK (every method, query operator, aggregation, timestamp, FieldValue), Authentication Admin (full user management, token operations, custom claims), Cloud Storage Admin (bucket operations, signed URLs, metadata), Realtime Database, Security Rules, indexes, backup/export, and GCP service configuration

Firestore security rules reference — rule syntax, helper functions, A3's permission model, and common patterns for collection-level access control

FontAwesome 7 reference — icon library used across A3 via @fortawesome packages and the design system Icon component

Deep Glimmer component and GTS/GJS template-tag format reference — component signatures, template syntax, patterns, and A3-specific conventions

Glint template type-checking reference — @glint/template, @glint/ember-tsc, @glint/tsserver-plugin for type-safe GTS templates in A3

Google Maps JavaScript API reference — @googlemaps/js-api-loader for map rendering, geocoding, and county selection in A3

Highcharts 12 + ember-highcharts reference — used in 16 A3 files. Chart types, options, theming, responsive charts, and A3 dashboard patterns

HubSpot CRM integration reference — @hubspot/api-client for contact sync, deal management, and OAuth flow in A3 (1 backend utility + OAuth endpoint)

Intercom Messenger SDK reference — @intercom/messenger-js-sdk for customer support chat widget in A3

Mailgun email service reference — send-email utility + domains endpoint + frontend mailgun.js. Transactional email, templates, domain management

Neon PostgreSQL integration reference — 3 backend files. Connection pooling, parameterized queries, and data migration scripts alongside Firestore

OpenAI API integration reference — 2 backend files. Chat completions, responses API, embeddings for client data

PandaDoc document automation reference — 5 backend files. Document creation from templates, e-signatures, form submissions, and webhook notifications

PDF generation and viewing reference — pdf-lib for creating/modifying PDFs, pdfjs-dist for viewing/rendering PDFs in A3

Deep QUnit and ember-qunit testing reference — acceptance, integration, unit tests, qunit-dom assertions, test helpers, and A3-specific testing patterns

Sentry error tracking reference — @sentry/ember (14 frontend files) + @sentry/node (34 backend files) = 48 total. Error capture, breadcrumbs, context, performance monitoring

signature_pad v5 reference — electronic signature capture for enrollment forms and documents in A3

Deep Stripe integration reference — 18 backend files + 5 frontend files. Checkout sessions, subscriptions, customers, invoices, payouts, accounts, webhooks, and Connect platform

Complete TAIA design system reference — all 88+ Ember GTS components, design tokens, helpers, modifiers, import patterns, and usage examples from @trusted-american/ember

Tailwind CSS 4 and Bootstrap 5 styling reference — how A3 uses both frameworks together, utility classes, component styling, and responsive design patterns

Third-party service integration reference — Stripe, Mailgun, PandaDoc, Algolia, HubSpot, Salesforce, OpenAI, Intercom, Sentry, Google Maps, and Vimeo patterns in A3

tracked-built-ins reference — TrackedArray, TrackedObject, TrackedMap, TrackedSet for deep reactive state in Glimmer components

UI component addon reference — PDF generation (pdf-lib, pdfjs-dist), CSV/Excel export (papaparse, excellentexport, exceljs), signature capture (signature_pad), and document preview (docx-preview)

Vimeo Player SDK reference — @vimeo/player for embedded video playback in A3 training/resource content

XState 5 and ember-statechart-component reference — state machine patterns for complex UI workflows in A3