agents-united 0.5.0

package/registry/workflows/workflow-paid-acquisition-campaign.md

@@ -0,0 +1,65 @@
+---
+name: "Multi-Channel Paid Acquisition Campaign Management"
+description: "Workflow for multi-channel PPC campaign architecture, ad copy experimentation, creative asset staging, attribution setup, and budget guardrails."
+bundle: "performance-paid-acquisition"
+estimatedDuration: "60-120m"
+---
+
+# Workflow: Multi-Channel Paid Acquisition Campaign Management
+
+## Overview & Scope
+The Paid Acquisition Campaign workflow structures end-to-end PPC campaign deployment across Google Ads, Meta Ads, and LinkedIn Ads. It covers audience targeting, ad copy matrix generation, creative aspect-ratio staging, UTM parameter taxonomy enforcement, and multi-touch attribution modeling.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Campaign Strategy & Attribution Setup]
+    P1 --> InputCheck{"Budgets & Audience Parameters Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Budget/Targeting Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Creative Generation & Ad Staging]
+    P2 --> Gate1{"Verification Gate: Creative & UTM Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Controlled Launch]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Ad Specs / Pixel Issues]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Campaign brief & target audience personas (interests, job titles, retargeting lists)
+- Channel allocation and daily/monthly spend budget caps
+- Creative assets (ad copy matrix, visual banners, video cuts)
+- UTM taxonomy specification and attribution tracking endpoint
+
+## Phase 1: Campaign Strategy & Attribution Setup
+- Define campaign objective (Leads, Conversions, Brand Awareness) and channel distribution (Google Search/PMax, Meta, LinkedIn).
+- Configure audience targeting rules: Custom Audiences, Lookalikes, keyword match types (Exact/Phrase), and negative keyword lists.
+- Establish UTM parameter taxonomy (`utm_source`, `utm_medium`, `utm_campaign`, `utm_content`, `utm_term`).
+- Verify conversion tracking pixels and server-side Conversions API (CAPI) endpoints.
+
+## Phase 2: Creative Generation & Ad Staging
+- Write multi-variant ad copy matrix (Headline variations, Primary text, Problem-Agitation, Social proof, CTA).
+- Stage visual creative assets formatted for channel aspect ratios (1:1 Feed, 9:16 Stories/Reels, 16:9 Landscape).
+- Verify landing page message match and conversion form functionality.
+- Configure bid strategy (Target CPA, Target ROAS, Max Conversions with hard cost cap).
+
+## Phase 3: Verification & Controlled Launch
+- Validate tracking pixels in sandbox environment using Tag Assistant / Pixel Helper tools.
+- Test all ad destination URLs to confirm UTM parameters log accurately in attribution backend.
+- Enforce daily spend hard caps and automated pacing rules to prevent budget runaway.
+- Execute canary launch with controlled initial spend (10-20% of daily budget) before full scale.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm test` | Ad asset validator confirms 100% adherence to character limits, aspect ratios, and UTM parameters |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Campaign launch manifest and tracking configuration compile cleanly |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: 100% of destination URLs contain valid UTM parameters matching the attribution taxonomy.
+- **Validation Checkpoint 2**: Ad creative dimensions and copy lengths comply with platform ad policies (Google, Meta, LinkedIn).
+- **Validation Checkpoint 3**: Daily budget spend ceilings and automated pacing rules are active in ad accounts.
+- **Automated Rollback Protocol**: Immediately trigger automated pause API calls on active ad sets and revert campaign status to DRAFT if conversion tracking fails to log in attribution telemetry or spend velocity exceeds 120% of hourly target without conversions.

package/registry/workflows/workflow-paid-campaign-launch.md

@@ -0,0 +1,47 @@
+---
+name: "Paid Campaign Architecture & Launch Workflow"
+description: "PPC campaign setup, ad copy testing, conversion tracking pixel verification, and launch budgeting."
+bundle: "performance-paid-acquisition"
+estimatedDuration: "45-90m"
+---
+
+# Workflow: Paid Campaign Architecture & Launch
+
+## Overview & Scope
+This workflow orchestrates paid acquisition campaigns across Google Search, Meta Ads, and LinkedIn, ensuring proper conversion tracking, negative keyword lists, and creative variant testing.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Campaign Launch]) --> P1[Phase 1: Conversion Tracking & Pixel Audit]
+    P1 --> InputCheck{"Pixels, CAPI & UTM Parameters Configured?"}
+    InputCheck -->|No| Abort1[Abort & Configure Conversion Tracking]
+    InputCheck -->|Yes| P2[Phase 2: Ad Copy, Creative & Keyword Assembly]
+    P2 --> Gate1{"Verification Gate: Negative Lists & Creative Sizing Valid?"}
+    Gate1 -->|Fail| P2Fix[Update Keyword Match Types & Asset Sizes]
+    P2Fix --> P2
+    Gate1 -->|Pass| P3[Phase 3: Campaign Publishing & Real-Time Monitoring]
+    P3 --> Gate2{"Health Gate: CTR >= Baseline & Zero Tracking Errors?"}
+    Gate2 -->|Fail| P3Tune[Adjust Initial Bid Caps / Ad Copy Variants]
+    P3Tune --> P3
+    Gate2 -->|Pass| Done([Campaign Live & Tracking])
+```
+
+## Phase 1: Conversion Tracking & Pixel Audit
+- Verify Google Tag Manager / Meta Pixel / LinkedIn Insight Tag firing on conversion events.
+- Test server-side Conversions API (CAPI) deduplication.
+
+## Phase 2: Ad Copy, Creative & Keyword Assembly
+- Group keywords into tightly themed ad sets and apply universal negative keyword lists.
+- Stage 3-5 creative hook variants and responsive ad copy variations.
+
+## Phase 3: Campaign Publishing & Real-Time Monitoring
+- Publish campaigns with initial learning phase budget caps.
+- Monitor search term reports for irrelevant query leakage and add negative keywords.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tracking active | `node dist/cli.js doctor` | Conversion pixels and test events verified |
+| Phase 2 -> Phase 3 | Assets assembled | `npm test` | All creative dimensions and copy lengths valid |
+| Phase 3 -> Completion | Campaigns live | `node dist/cli.js doctor` | Impressions recording with verified attribution |

package/registry/workflows/workflow-plan.md

@@ -0,0 +1,60 @@
+---
+name: "Architecture & Technical Planning"
+description: "Comprehensive workflow for creating architectural plans, system design documents, module specifications, and implementation roadmaps."
+bundle: "system-architecture"
+estimatedDuration: "45-90m"
+---
+
+# Workflow: Architecture & Technical Planning
+
+## Overview & Scope
+The Plan workflow guides architects and senior engineers through drafting architecture decision records (ADRs), defining data models, outlining system boundaries, and establishing phased implementation roadmaps.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Product requirements document (PRD) or feature specification
+- Existing architectural diagrams & system boundaries
+- Non-functional requirements (scalability, latency, security, budget)
+
+## Phase 1: Context & Reconnaissance
+- Gather and synthesize business requirements, system constraints, and non-functional goals.
+- Audit existing system architecture to identify integration points, data dependencies, and technical debt.
+- Define key architectural decisions requiring formal specification.
+
+## Phase 2: Execution & Orchestration
+- Draft Architecture Decision Record (ADR) detailing context, options considered, and chosen solution.
+- Model data structures, API endpoints, component interfaces, and state transition flowcharts.
+- Break down architecture implementation into sequential, verifiable milestone phases.
+
+## Phase 3: Verification & Closure
+- Conduct self-critique and peer architectural review against scalability, security, and maintainability criteria.
+- Refine specification document, ensuring explicit failure modes and mitigation strategies are documented.
+- Publish architecture plan artifact to project documentation repository.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | System architecture plan schema and references pass health verification |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Proposed data model types compile cleanly without type syntax errors |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All architectural decisions backed by explicit rationale and trade-off analysis.
+- **Validation Checkpoint 2**: Data schemas fully specified with types, keys, and boundary conditions.
+- **Automated Rollback Protocol**: Revert draft ADR document to revision state if architectural review uncovers unmitigated system bottlenecks.

package/registry/workflows/workflow-prototyping-testing--evaluate.md

@@ -0,0 +1,60 @@
+---
+name: "Prototype Usability Evaluation & Analytics"
+description: "Workflow for analyzing user test recordings, quantifying task completion rates, identifying UX friction, and synthesizing test findings."
+bundle: "product-design"
+estimatedDuration: "40-70m"
+---
+
+# Workflow: Prototype Usability Evaluation & Analytics
+
+## Overview & Scope
+This workflow standardizes usability test evaluation. It synthesizes qualitative user testing video recordings, quantifies task completion rates, scores System Usability Scale (SUS), and categorizes UX friction points.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- User test session video recordings & transcripts
+- Task completion tracking sheets
+- System Usability Scale (SUS) survey data
+
+## Phase 1: Context & Reconnaissance
+- Gather recorded usability test sessions and survey responses.
+- Review usability evaluation targets (Task completion rate >= 80%, SUS score >= 75).
+- Prepare observations coding sheet.
+
+## Phase 2: Execution & Orchestration
+- Analyze user session recordings, logging time-on-task, mis-clicks, and verbal feedback.
+- Calculate quantitative usability metrics (Direct success, Indirect success, Failure rate, SUS score).
+- Classify usability issues by severity (Critical blocker, Major friction, Minor enhancement).
+
+## Phase 3: Verification & Closure
+- Synthesize findings into Usability Evaluation Report with video evidence clips.
+- Formulate prioritized remediation recommendations for product design iteration.
+- Publish Usability Test Evaluation Summary.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check confirms evaluation report schema validity |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Usability metric calculation script validates data totals |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Usability issues categorized using standard 3-tier severity scale.
+- **Validation Checkpoint 2**: Remediation recommendations backed directly by quantitative session data.
+- **Automated Rollback Protocol**: Re-analyze session recordings if inter-evaluator agreement score falls below threshold.

package/registry/workflows/workflow-prototyping-testing--experiment.md

@@ -0,0 +1,60 @@
+---
+name: "Rapid Prototyping Experimentation"
+description: "Workflow for building low/medium-fidelity experimental prototypes to quickly test hypotheses before full implementation."
+bundle: "product-design"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Rapid Prototyping Experimentation
+
+## Overview & Scope
+The Experiment workflow enables rapid hypothesis testing. It builds minimal, targeted experimental prototypes to validate specific interaction concepts or user flows prior to production coding.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Target research hypothesis statement
+- Rapid prototyping template library
+- Interactive prototyping framework
+
+## Phase 1: Context & Reconnaissance
+- Define core test hypothesis (e.g. "Simplified 2-step checkout increases completion speed by 25%").
+- Isolate key variables required to test hypothesis while stripping non-essential features.
+- Select prototype fidelity level (low-fi wireframe vs mid-fi clickable).
+
+## Phase 2: Execution & Orchestration
+- Construct experimental prototype containing only essential UI pathways for hypothesis validation.
+- Integrate simple analytics event logging to track user clicks and path navigation.
+- Verify prototype interactive links function reliably.
+
+## Phase 3: Verification & Closure
+- Conduct internal dry-run walkthrough to verify test scenario flows.
+- Deploy experiment prototype to staging environment for user testing.
+- Document Experiment Setup Spec.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `npm test` | Prototype link verification test confirms 0 broken interactive pathways |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Prototype code compiles cleanly into preview build |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Prototype focuses strictly on testing target hypothesis without scope creep.
+- **Validation Checkpoint 2**: All clickable pathways lead to valid response screens.
+- **Automated Rollback Protocol**: Fix broken prototype links or interaction triggers before starting user sessions.

package/registry/workflows/workflow-prototyping-testing--prototype-plan.md

@@ -0,0 +1,60 @@
+---
+name: "Interactive Prototype Architecture Plan"
+description: "Workflow for planning interactive prototype scope, user flow branching, fidelity requirements, and data mocking strategies."
+bundle: "product-design"
+estimatedDuration: "25-45m"
+---
+
+# Workflow: Interactive Prototype Architecture Plan
+
+## Overview & Scope
+This workflow plans prototype construction. It maps user flow branching, sets fidelity thresholds, defines state variables, and specifies mock data structures for prototype builds.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- User flow diagrams & feature requirements
+- Target testing device specs (Desktop / Mobile)
+- Mock data schema requirements
+
+## Phase 1: Context & Reconnaissance
+- Determine prototype objective (stakeholder demo vs user usability testing).
+- Establish prototype scope boundaries and explicit out-of-scope paths.
+- Define mock data schemas matching production payload formats.
+
+## Phase 2: Execution & Orchestration
+- Map prototype node-to-node navigation screens and state transitions.
+- Specify dynamic variables (e.g. user input state, cart item count, active tab).
+- Outline data mocking strategy (static JSON fixtures vs local state).
+
+## Phase 3: Verification & Closure
+- Review prototype architecture plan with research and design team members.
+- Finalize prototype build timeline and asset requirements.
+- Publish Prototype Architecture Plan.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check validates prototype plan document format |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run typecheck` | Mock data JSON schemas validate cleanly against TypeScript types |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Prototype scope covers 100% of required user testing scenarios.
+- **Validation Checkpoint 2**: Mock data schemas accurately mirror production API response shapes.
+- **Automated Rollback Protocol**: Reduce prototype branching complexity if estimated build time exceeds schedule window.

package/registry/workflows/workflow-prototyping-testing--test-plan.md

@@ -0,0 +1,60 @@
+---
+name: "User Testing Script & Methodology Plan"
+description: "Workflow for authoring user test plans, recruiting criteria, task scenarios, post-test questionnaires, and moderation scripts."
+bundle: "product-design"
+estimatedDuration: "30-50m"
+---
+
+# Workflow: User Testing Script & Methodology Plan
+
+## Overview & Scope
+The Test Plan workflow structures user research studies. It defines participant recruiting criteria, task scenario prompts, moderation scripts, and post-session metrics surveys.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Interactive prototype or feature candidate
+- Research goals and target questions
+- User persona profiles & recruiting criteria
+
+## Phase 1: Context & Reconnaissance
+- Align research objectives with product team key questions.
+- Define target participant recruiting criteria (demographics, tech familiarity, usage frequency).
+- Select user testing methodology (moderated vs unmoderated usability study).
+
+## Phase 2: Execution & Orchestration
+- Draft un-biased, scenario-based user task prompts (e.g. "Find a product under $50 and add it to cart").
+- Author moderator script containing introduction, warm-up questions, and probing prompts.
+- Prepare post-test survey questionnaire (SUS / Single Ease Question SEQ).
+
+## Phase 3: Verification & Closure
+- Conduct pilot test run with an internal colleague to test script timing and prompt clarity.
+- Refine task prompts based on pilot feedback.
+- Publish finalized User Test Plan artifact.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check confirms test plan document compliance |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Validation test confirms task script timing parameters |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Task scenario prompts authored using goal-oriented, non-leading phrasing.
+- **Validation Checkpoint 2**: Pilot test session completes within target 45-minute time window.
+- **Automated Rollback Protocol**: Revise task scenario instructions if pilot participant misinterprets prompts.

package/registry/workflows/workflow-rag-pipeline-deploy.md

@@ -0,0 +1,53 @@
+---
+name: "RAG Pipeline Deployment Workflow"
+description: "End-to-end deployment workflow for Retrieval-Augmented Generation systems, vector indexing, hybrid search, and grounding checks."
+bundle: "ai-ml-engineering"
+estimatedDuration: "25-45m"
+---
+
+# Workflow: RAG Pipeline Deployment
+
+## Overview & Scope
+This workflow coordinates document ingestion, semantic chunking, vector embedding generation, vector collection indexing (Qdrant/Pinecone), and retrieval query endpoint verification.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Deployment]) --> P1[Phase 1: Ingestion & Chunking Design]
+    P1 --> InputCheck{"Source Documents & Embedding Model Ready?"}
+    InputCheck -->|No| Abort1[Abort & Request Document Sources]
+    InputCheck -->|Yes| P2[Phase 2: Vector Indexing & Hybrid Search Setup]
+    P2 --> Gate1{"Verification Gate: Vector Index Ingest Complete?"}
+    Gate1 -->|Fail| P2Retry[Re-index Failed Batches]
+    P2Retry --> P2
+    Gate1 -->|Pass| P3[Phase 3: Retrieval Verification & Grounding]
+    P3 --> Gate2{"Recall Gate: Top-K Accuracy >= 95%?"}
+    Gate2 -->|Fail| TuneParams[Adjust Chunk Overlap & HNSW Parameters]
+    TuneParams --> P2
+    Gate2 -->|Pass| Done([RAG Pipeline Live & Operational])
+```
+
+## Phase 1: Ingestion & Chunking Design
+- Clean and normalize raw documents (Markdown, PDF, HTML).
+- Partition documents into semantic chunks with 15% overlap and metadata tagging.
+
+## Phase 2: Vector Indexing & Hybrid Search Setup
+- Generate embeddings using target model (OpenAI / BGE / Voyage).
+- Bulk upsert vectors into vector database with HNSW payload indexes.
+- Configure sparse BM25 index and cross-encoder re-ranking layer.
+
+## Phase 3: Retrieval Verification & Grounding
+- Execute validation queries against diverse search intents.
+- Verify that retrieved chunks contain source attribution and valid line citations.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Chunks prepared | `node dist/cli.js doctor` | Chunking schema verified |
+| Phase 2 -> Phase 3 | Ingestion complete | `npm test` | Vector collection stats confirm 100% vectors indexed |
+| Phase 3 -> Completion | Retrieval tested | `node dist/cli.js doctor` | Grounding checks pass with zero un-cited assertions |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Verify embedding dimensionality matches vector collection config before batch upsert.
+- **Validation Checkpoint 2**: Test hybrid search recall against golden QA pairs.
+- **Automated Rollback Protocol**: If new vector index corruption occurs during migration, restore previous collection snapshot and redirect search queries to fallback collection.

package/registry/workflows/workflow-recommend.md

@@ -0,0 +1,60 @@
+---
+name: "Technical & Strategic Recommendation Synthesis"
+description: "Workflow for synthesizing complex architectural and business trade-offs into formal executive recommendation proposals."
+bundle: "business-strategy"
+estimatedDuration: "30-60m"
+---
+
+# Workflow: Technical & Strategic Recommendation Synthesis
+
+## Overview & Scope
+The Recommend workflow synthesizes technical, business, and operational analysis into formal executive recommendations. It presents clear option comparisons, risk trade-offs, and decisive action plans.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Technical architecture plans & business evaluation reports
+- Option trade-off comparison matrix
+- Executive recommendation proposal template
+
+## Phase 1: Context & Reconnaissance
+- Gather findings from technical research, architecture planning, and business evaluation panels.
+- Identify key decision options requiring executive alignment.
+- Define evaluation metrics (Cost, Time-to-market, Scalability, Risk).
+
+## Phase 2: Execution & Orchestration
+- Construct Option Comparison Matrix scoring each alternative across evaluation metrics.
+- Synthesize clear Primary Recommendation with explicit supporting rationale.
+- Detail implementation plan, resource requirements, and risk mitigation strategies.
+
+## Phase 3: Verification & Closure
+- Review recommendation document for executive clarity and brevity.
+- Verify all claims are backed by documented technical or business evidence.
+- Publish Executive Recommendation Proposal.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check validates recommendation proposal schema |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run build` | Project build passes cleanly during proposal publication |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Primary recommendation explicitly supported by option comparison matrix.
+- **Validation Checkpoint 2**: Risk mitigation plan included for recommended path.
+- **Automated Rollback Protocol**: Revise recommendation proposal if executive review identifies unaddressed trade-offs.

package/registry/workflows/workflow-research.md

@@ -0,0 +1,60 @@
+---
+name: "Deep Technical & Domain Research"
+description: "Workflow for conducting literature reviews, technical feasibility research, codebase analysis, and domain background investigations."
+bundle: "deep-research"
+estimatedDuration: "45-90m"
+---
+
+# Workflow: Deep Technical & Domain Research
+
+## Overview & Scope
+The Research workflow structures deep technical investigations. It gathers evidence from documentation, academic papers, source codebases, and web resources to synthesize authoritative research reports.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Research query or problem topic specification
+- Web search and documentation lookup tools (`search_web`, `view_file`)
+- Research report template
+
+## Phase 1: Context & Reconnaissance
+- Define research objectives, core questions, and inclusion/exclusion criteria.
+- Identify primary documentation sources, GitHub repositories, and technical standards.
+- Formulate initial search queries.
+
+## Phase 2: Execution & Orchestration
+- Execute multi-source research gathering technical documentation, code examples, and RFCs.
+- Analyze findings for technical feasibility, architectural trade-offs, and performance benchmarks.
+- Synthesize raw research notes into structured thematic sections.
+
+## Phase 3: Verification & Closure
+- Verify all research claims with direct source citations or codebase line references.
+- Formulate actionable recommendations based on research findings.
+- Publish Deep Research Synthesis Report.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `node dist/cli.js doctor` | Doctor health check confirms research report document structure |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm test` | Report validation test suite confirms citation references |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: All technical claims supported by primary source documentation or code references.
+- **Validation Checkpoint 2**: Synthesis report directly answers all core research questions.
+- **Automated Rollback Protocol**: Expand research query scope if initial findings lack sufficient depth or evidence.

package/registry/workflows/workflow-review.md

@@ -0,0 +1,60 @@
+---
+name: "Automated & Peer Code Review"
+description: "Structured review workflow for inspecting code diffs, checking architectural pattern compliance, security flaws, and performance anti-patterns."
+bundle: "software-engineering"
+estimatedDuration: "20-40m"
+---
+
+# Workflow: Automated & Peer Code Review
+
+## Overview & Scope
+The Review workflow standardizes code review procedures. It combines static analysis, security vulnerability scanning, design pattern verification, and clear actionable feedback formatting for pull requests.
+
+## Execution Flowchart
+```mermaid
+graph TD
+    Start([Start Workflow]) --> P1[Phase 1: Context & Reconnaissance]
+    P1 --> InputCheck{"Prerequisites & Tools Valid?"}
+    InputCheck -->|No| Abort1[Abort & Request Inputs]
+    InputCheck -->|Yes| P2[Phase 2: Execution & Orchestration]
+    P2 --> Gate1{"Verification Gate: Automated Checks Pass?"}
+    Gate1 -->|Fail| Rollback[Execute Automated Rollback Protocol]
+    Rollback --> P2
+    Gate1 -->|Pass| P3[Phase 3: Verification & Closure]
+    P3 --> Gate2{"Final Acceptance Gate Passed?"}
+    Gate2 -->|Fail| P3Fix[Remediate Documentation / Artifacts]
+    P3Fix --> P3
+    Gate2 -->|Pass| Done([Workflow Complete & Logged])
+```
+
+## Required Tool Inputs & Context
+- Git diff or Pull Request branch reference (`main...HEAD`)
+- Linter and security static analyzer configs
+- Architectural style guide & code review checklists
+
+## Phase 1: Context & Reconnaissance
+- Fetch latest branch changes and extract comprehensive `git diff main...HEAD`.
+- Catalog modified, added, and deleted files along with external dependency additions.
+- Run automated static analysis tools (`eslint`, `tsc`, `security scan`) on the diff.
+
+## Phase 2: Execution & Orchestration
+- Inspect code changes for architectural consistency, modularity, and adherence to design patterns.
+- Audit diff for common security flaws (OWASP top 10), unhandled edge cases, and performance anti-patterns.
+- Verify that newly added features or fixes include appropriate unit test coverage.
+
+## Phase 3: Verification & Closure
+- Synthesize review findings into a structured review report.
+- Categorize feedback into blocking issues, non-blocking suggestions, and praise.
+- Issue review verdict (Approve, Request Changes, Comment) with clear remediation guidelines.
+
+## Phase Transition Criteria & Deterministic Verification Gates
+| Transition | Prerequisites | Verification Command / Gate | Success Criteria |
+|---|---|---|---|
+| Phase 1 -> Phase 2 | Tool inputs verified & environment ready | `node dist/cli.js doctor` | Doctor health check succeeds with 0 errors |
+| Phase 2 -> Phase 3 | Execution steps complete | `git diff main...HEAD` | Zero high-severity security vulnerabilities or architectural violations in diff |
+| Phase 3 -> Completion | Verification complete & artifacts signed off | `npm run lint && npm run typecheck` | All automated lints and type checks pass cleanly on PR branch |
+
+## Validation Checkpoints & Automated Rollback Protocols
+- **Validation Checkpoint 1**: Diff review covers 100% of modified lines and new export signatures.
+- **Validation Checkpoint 2**: Automated checks pass without warnings before manual review sign-off.
+- **Automated Rollback Protocol**: Flag blocking concerns in PR and set status to "Request Changes", preventing branch merge until issues are resolved.