@monoes/monomindcli 2.15.2 → 2.15.4

package/org-skills/cloud-architecture/references/multi-cloud.md

@@ -0,0 +1,483 @@
+# Multi-Cloud Architecture Reference
+
+Comprehensive guide for multi-cloud strategies, abstraction layers, portability patterns, and vendor lock-in mitigation.
+
+## Multi-Cloud Strategy
+
+### When to Use Multi-Cloud
+
+**Valid Use Cases**
+- Regulatory compliance requiring data residency in specific regions
+- Best-of-breed service selection (BigQuery for analytics, AWS for ML)
+- Acquisition integration (different clouds in merged organizations)
+- Disaster recovery with cloud provider as failure domain
+- Negotiating leverage with cloud vendors
+
+**Poor Reasons for Multi-Cloud**
+- "Avoiding vendor lock-in" without specific exit scenario
+- Assuming portability is free (it has significant costs)
+- Political decisions without technical justification
+- Spreading workloads arbitrarily across providers
+
+### Multi-Cloud Patterns
+
+**Active-Active**
+```
+Users -> Global Load Balancer
+              |
+    +---------+---------+
+    |                   |
+  AWS Region        GCP Region
+    |                   |
+    +----> Data Sync <--+
+```
+- Highest complexity and cost
+- Best for global latency optimization
+- Requires robust data synchronization
+
+**Active-Passive (DR)**
+```
+Users -> Primary (AWS)
+              |
+         [Failover]
+              |
+         Secondary (Azure)
+```
+- Lower complexity than active-active
+- Cloud provider becomes failure domain
+- Cold or warm standby in secondary cloud
+
+**Segmented by Workload**
+```
+Analytics -> GCP (BigQuery)
+Core App  -> AWS (ECS, RDS)
+Office    -> Azure (M365 integration)
+```
+- Each workload on best-fit cloud
+- No cross-cloud data synchronization
+- Simplest multi-cloud pattern
+
+## Abstraction Layers
+
+### Infrastructure Abstraction
+
+**Terraform (Recommended)**
+```hcl
+# Provider-agnostic module structure
+module "compute" {
+  source = "./modules/compute"
+
+  provider_type = var.cloud_provider  # aws, azure, gcp
+  instance_type = var.instance_size
+  region        = var.region
+}
+
+# Provider-specific implementations
+# modules/compute/aws.tf
+resource "aws_instance" "main" {
+  count         = var.provider_type == "aws" ? 1 : 0
+  ami           = data.aws_ami.latest.id
+  instance_type = local.aws_instance_map[var.instance_size]
+}
+
+# modules/compute/azure.tf
+resource "azurerm_virtual_machine" "main" {
+  count    = var.provider_type == "azure" ? 1 : 0
+  vm_size  = local.azure_vm_map[var.instance_size]
+}
+```
+
+**Pulumi (Code-First)**
+```typescript
+// Abstract cloud resources with TypeScript
+interface ComputeConfig {
+  size: "small" | "medium" | "large";
+  region: string;
+}
+
+function createCompute(config: ComputeConfig, provider: "aws" | "gcp") {
+  if (provider === "aws") {
+    return new aws.ec2.Instance("web", {
+      instanceType: sizeMap.aws[config.size],
+      // ...
+    });
+  } else {
+    return new gcp.compute.Instance("web", {
+      machineType: sizeMap.gcp[config.size],
+      // ...
+    });
+  }
+}
+```
+
+### Container Orchestration (Kubernetes)
+
+**Portable Kubernetes Deployment**
+```yaml
+# Same manifests work across EKS, AKS, GKE
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: web-app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: web
+  template:
+    spec:
+      containers:
+      - name: web
+        image: myregistry/web:v1
+        resources:
+          requests:
+            memory: "256Mi"
+            cpu: "250m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+```
+
+**Cloud-Specific Considerations**
+| Feature | EKS | AKS | GKE |
+|---------|-----|-----|-----|
+| Load Balancer | ALB/NLB annotations | Azure LB | GCP LB |
+| Storage Class | gp3, io2 | managed-premium | pd-ssd |
+| IAM Integration | IRSA | Workload Identity | Workload Identity |
+| Ingress | AWS ALB Controller | AGIC | GKE Ingress |
+
+### Application Abstraction
+
+**Database Abstraction**
+```python
+# Use standard protocols (SQL, Redis, S3 API)
+from sqlalchemy import create_engine
+
+# Same code works with:
+# - AWS RDS PostgreSQL
+# - Azure Database for PostgreSQL
+# - GCP Cloud SQL PostgreSQL
+# - Self-managed PostgreSQL
+
+DATABASE_URL = os.environ["DATABASE_URL"]
+engine = create_engine(DATABASE_URL)
+```
+
+**Object Storage Abstraction**
+```python
+import boto3
+from botocore.config import Config
+
+# S3-compatible API works with:
+# - AWS S3
+# - GCP Cloud Storage (interoperability mode)
+# - MinIO
+# - Cloudflare R2
+
+s3_client = boto3.client(
+    's3',
+    endpoint_url=os.environ.get("S3_ENDPOINT"),  # Override for non-AWS
+    aws_access_key_id=os.environ["ACCESS_KEY"],
+    aws_secret_access_key=os.environ["SECRET_KEY"],
+)
+```
+
+## Data Synchronization
+
+### Database Replication
+
+**Cross-Cloud PostgreSQL**
+```
+AWS RDS Primary
+      |
+      | Logical Replication
+      v
+GCP Cloud SQL Replica (read-only)
+```
+
+Configuration:
+```sql
+-- On primary (AWS RDS)
+CREATE PUBLICATION my_publication FOR ALL TABLES;
+
+-- On replica (GCP Cloud SQL)
+CREATE SUBSCRIPTION my_subscription
+  CONNECTION 'host=aws-rds-endpoint dbname=mydb user=repl'
+  PUBLICATION my_publication;
+```
+
+**Conflict Resolution Strategies**
+- Last-write-wins (timestamp-based)
+- Application-level conflict resolution
+- CRDT data structures for eventually consistent data
+- Avoid multi-master for transactional data
+
+### Object Storage Sync
+
+**Rclone for Cross-Cloud Sync**
+```bash
+# Sync S3 to GCS
+rclone sync s3:my-bucket gcs:my-bucket \
+  --transfers 32 \
+  --checkers 16 \
+  --s3-upload-concurrency 8
+
+# Bidirectional sync with conflict handling
+rclone bisync s3:bucket gcs:bucket \
+  --conflict-resolve newer
+```
+
+**Event-Driven Replication**
+```
+S3 Bucket -> S3 Event -> Lambda -> GCS Upload
+                              |
+                              v
+                       Consistency Check
+```
+
+## Vendor Lock-In Mitigation
+
+### Lock-In Risk Assessment
+
+| Service Type | Lock-In Risk | Mitigation Strategy |
+|--------------|--------------|---------------------|
+| Compute (VMs) | Low | Standard OS images, IaC |
+| Kubernetes | Low | Portable manifests, avoid proprietary add-ons |
+| Object Storage | Low | S3-compatible API, standard formats |
+| Managed Databases | Medium | Standard SQL, logical backups |
+| Serverless Functions | High | Abstraction layers, containers |
+| Proprietary AI/ML | High | Open-source alternatives, ONNX models |
+| Managed Services | High | Evaluate portability before adoption |
+
+### Mitigation Strategies
+
+**1. Use Open Standards**
+- SQL databases over proprietary NoSQL
+- Kubernetes over ECS/Cloud Run
+- S3 API for object storage
+- OpenTelemetry for observability
+- OIDC for authentication
+
+**2. Abstract Proprietary Services**
+```typescript
+// Wrap cloud-specific services
+interface QueueService {
+  send(message: string): Promise<void>;
+  receive(): Promise<string>;
+}
+
+class SQSQueue implements QueueService {
+  async send(message: string) {
+    await this.sqsClient.sendMessage({ QueueUrl: this.url, MessageBody: message });
+  }
+}
+
+class PubSubQueue implements QueueService {
+  async send(message: string) {
+    await this.pubsubClient.topic(this.topic).publish(Buffer.from(message));
+  }
+}
+
+// Factory pattern for cloud selection
+function createQueue(provider: string): QueueService {
+  switch (provider) {
+    case "aws": return new SQSQueue();
+    case "gcp": return new PubSubQueue();
+  }
+}
+```
+
+**3. Maintain Exit Capability**
+- Regular data export testing
+- Document cloud-specific dependencies
+- Keep IaC portable across providers
+- Estimate migration effort annually
+
+**4. Containerize Everything**
+```dockerfile
+# Portable container runs anywhere
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+EXPOSE 3000
+CMD ["node", "server.js"]
+```
+
+## Network Connectivity
+
+### Cross-Cloud Networking
+
+**VPN Interconnect**
+```
+AWS VPC                          GCP VPC
+   |                                |
+   +---> AWS VPN Gateway            |
+              |                     |
+              | IPsec tunnel        |
+              |                     |
+              +---> GCP Cloud VPN <-+
+```
+
+**Dedicated Interconnect (Enterprise)**
+```
+On-Premises Data Center
+         |
+    +----+----+
+    |         |
+AWS Direct  GCP Cloud
+Connect     Interconnect
+    |         |
+    v         v
+AWS VPC    GCP VPC
+    |         |
+    +----+----+
+         |
+    Transit Hub (e.g., Megaport, Equinix)
+```
+
+### Service Mesh Across Clouds
+
+**Istio Multi-Cluster**
+```yaml
+# Primary cluster (AWS EKS)
+apiVersion: install.istio.io/v1alpha1
+kind: IstioOperator
+spec:
+  values:
+    global:
+      meshID: multi-cloud-mesh
+      multiCluster:
+        clusterName: eks-primary
+      network: aws-network
+
+# Remote cluster (GCP GKE)
+spec:
+  values:
+    global:
+      meshID: multi-cloud-mesh
+      multiCluster:
+        clusterName: gke-secondary
+      network: gcp-network
+```
+
+## Cost Management
+
+### Cross-Cloud Cost Visibility
+
+**FinOps Tools**
+- CloudHealth by VMware
+- Apptio Cloudability
+- Spot.io (now part of NetApp)
+- Kubecost for Kubernetes
+
+**Unified Tagging Strategy**
+```
+Required Tags (all clouds):
+- environment: prod/staging/dev
+- cost-center: engineering/marketing/sales
+- owner: team-name
+- project: project-code
+- managed-by: terraform/manual
+```
+
+### Cost Comparison Framework
+
+```
+| Workload Type | AWS | Azure | GCP | Decision |
+|---------------|-----|-------|-----|----------|
+| General Compute | EC2 m5 | D-series | n2-standard | Compare $/vCPU/hour |
+| GPU Training | p4d | NC-series | A2 | GCP often cheaper |
+| Object Storage | S3 | Blob | GCS | Similar, check egress |
+| Analytics | Redshift | Synapse | BigQuery | BigQuery for ad-hoc |
+| Kubernetes | EKS | AKS | GKE | GKE Autopilot simplest |
+```
+
+## Observability
+
+### Unified Monitoring Stack
+
+**OpenTelemetry Collector**
+```yaml
+# Collect from all clouds, export to single backend
+receivers:
+  otlp:
+    protocols:
+      grpc:
+      http:
+
+processors:
+  batch:
+  attributes:
+    actions:
+      - key: cloud.provider
+        action: upsert
+        value: ${CLOUD_PROVIDER}
+
+exporters:
+  prometheus:
+    endpoint: "0.0.0.0:8889"
+  jaeger:
+    endpoint: jaeger:14250
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch, attributes]
+      exporters: [jaeger]
+    metrics:
+      receivers: [otlp]
+      processors: [batch, attributes]
+      exporters: [prometheus]
+```
+
+**Grafana for Unified Dashboards**
+- AWS CloudWatch data source
+- Azure Monitor data source
+- GCP Cloud Monitoring data source
+- Single pane of glass across all clouds
+
+## Security Considerations
+
+### Identity Federation
+
+**Cross-Cloud Identity**
+```
+Corporate IdP (Okta/Azure AD)
+         |
+    SAML/OIDC
+         |
+    +----+----+----+
+    |    |    |    |
+  AWS  Azure  GCP  K8s
+  IAM   AD   IAM  RBAC
+```
+
+### Secrets Management
+
+**HashiCorp Vault (Cloud-Agnostic)**
+```hcl
+# Single secrets management across clouds
+resource "vault_aws_secret_backend_role" "aws_role" {
+  backend = vault_aws_secret_backend.aws.path
+  name    = "app-role"
+  credential_type = "iam_user"
+}
+
+resource "vault_gcp_secret_roleset" "gcp_role" {
+  backend     = vault_gcp_secret_backend.gcp.path
+  roleset     = "app-role"
+  project     = var.gcp_project
+  token_scopes = ["https://www.googleapis.com/auth/cloud-platform"]
+}
+```
+
+### Network Security
+
+**Zero-Trust Across Clouds**
+- mTLS between all services (service mesh)
+- No implicit trust based on network location
+- Identity-based access control
+- Encrypted transit between clouds (VPN/interconnect)

package/org-skills/cmo-advisor/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alireza Rezvani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/org-skills/cmo-advisor/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: cmo-advisor
+description: "Marketing leadership for scaling companies. Brand positioning, growth model design, marketing budget allocation, and marketing org design. Use when designing brand strategy, selecting growth models (PLG vs sales-led vs community-led), allocating marketing budgets, building marketing teams, or when user mentions CMO, brand strategy, growth model, CAC, LTV, channel mix, or marketing ROI."
+tags: ["leadership","marketing"]
+tools: []
+license: MIT
+source: https://github.com/alirezarezvani/claude-skills
+source_path: "c-level-advisor/skills/cmo-advisor"
+source_commit: 19392f7a08264ed00486a251f5b2098321771f94
+---
+# CMO Advisor
+
+Strategic marketing leadership — brand positioning, growth model design, budget allocation, and org design. Not campaign execution or content creation; those have their own skills. This is the engine.
+
+## Keywords
+CMO, chief marketing officer, brand strategy, brand positioning, growth model, product-led growth, PLG, sales-led growth, community-led growth, marketing budget, CAC, customer acquisition cost, LTV, lifetime value, channel mix, marketing ROI, pipeline contribution, marketing org, category design, competitive positioning, growth loops, payback period, MQL, pipeline coverage
+
+## Quick Start
+
+```bash
+# Model budget allocation across channels, project MQL output by scenario
+python scripts/marketing_budget_modeler.py
+
+# Project MRR growth by model, show impact of channel mix shifts
+python scripts/growth_model_simulator.py
+```
+
+**Reference docs (load when needed):**
+- `references/brand_positioning.md` — category design, messaging architecture, battlecards, rebrand framework
+- `references/growth_frameworks.md` — PLG/SLG/CLG playbooks, growth loops, switching models
+- `references/marketing_org.md` — team structure by stage, hiring sequence, agency vs. in-house
+
+---
+
+## The Four CMO Questions
+
+Every CMO must own answers to these — no one else in the C-suite can:
+
+1. **Who are we for?** — ICP, positioning, category
+2. **Why do they choose us?** — Differentiation, messaging, brand
+3. **How do they find us?** — Growth model, channel mix, demand gen
+4. **Is it working?** — CAC, LTV:CAC, pipeline contribution, payback period
+
+---
+
+## Core Responsibilities (Brief)
+
+**Brand & Positioning** — Define category, build messaging architecture, maintain competitive differentiation. Details → `references/brand_positioning.md`
+
+**Growth Model** — Choose and operate the right acquisition engine: PLG, sales-led, community-led, or hybrid. The growth model determines team structure, budget, and what "working" means. Details → `references/growth_frameworks.md`
+
+**Marketing Budget** — Allocate from revenue target backward: new customers needed → conversion rates by stage → MQLs needed → spend by channel based on CAC. Run `marketing_budget_modeler.py` for scenarios.
+
+**Marketing Org** — Structure follows growth model. Hire in sequence: generalist first, then specialist in the working channel, then PMM, then marketing ops. Details → `references/marketing_org.md`
+
+**Channel Mix** — Audit quarterly: MQLs, cost, CAC, payback, trend. Scale what's improving. Cut what's worsening. Don't optimize a channel that isn't in the strategy.
+
+**Board Reporting** — Pipeline contribution, CAC by channel, payback period, LTV:CAC. Not impressions. Not MQLs in isolation.
+
+---
+
+## Key Diagnostic Questions
+
+Ask these before making any strategic recommendation:
+
+- What's your CAC **by channel** (not blended)?
+- What's the payback period on your largest channel?
+- What's your LTV:CAC ratio?
+- What % of pipeline is marketing-sourced vs. sales-sourced?
+- Where do your **best customers** (highest LTV, lowest churn) come from?
+- What's your MQL → Opportunity conversion rate? (proxy for lead quality)
+- Is this brand work or performance marketing? (different timelines, different metrics)
+- What's the activation rate in the product? (PLG signal)
+- If a prospect doesn't buy, why not? (win/loss data)
+
+---
+
+## CMO Metrics Dashboard
+
+| Category | Metric | Healthy Target |
+|----------|--------|---------------|
+| **Pipeline** | Marketing-sourced pipeline % | 50–70% of total |
+| **Pipeline** | Pipeline coverage ratio | 3–4x quarterly quota |
+| **Pipeline** | MQL → Opportunity rate | > 15% |
+| **Efficiency** | Blended CAC payback | < 18 months |
+| **Efficiency** | LTV:CAC ratio | > 3:1 |
+| **Efficiency** | Marketing % of total S&M spend | 30–50% |
+| **Growth** | Brand search volume trend | ↑ QoQ |
+| **Growth** | Win rate vs. primary competitor | > 50% |
+| **Retention** | NPS (marketing-sourced cohort) | > 40 |
+
+---
+
+## Red Flags
+
+- No defined ICP — "companies with 50-1000 employees" is not an ICP
+- Marketing and sales disagree on what an MQL is (this is always a system problem, not a people problem)
+- CAC tracked only as a blended number — channel-level CAC is non-negotiable
+- Pipeline attribution is self-reported by sales reps, not CRM-timestamped
+- CMO can't answer "what's our payback period?" without a 48-hour research project
+- Brand work and performance marketing have no shared narrative — they're contradicting each other
+- Marketing team is producing content with no documented positioning to anchor it
+- Growth model was chosen because a competitor uses it, not because the product/ACV/ICP fits
+
+---
+
+## Integration with Other C-Suite Roles
+
+| When... | CMO works with... | To... |
+|---------|-------------------|-------|
+| Pricing changes | CFO + CEO | Understand margin impact on positioning and messaging |
+| Product launch | CPO + CTO | Define launch tier, GTM motion, messaging |
+| Pipeline miss | CFO + CRO | Diagnose: volume problem, quality problem, or velocity problem |
+| Category design | CEO | Secure multi-year organizational commitment to the narrative |
+| New market entry | CEO + CFO | Validate ICP, budget, localization requirements |
+| Sales misalignment | CRO | Align on MQL definition, SLA, and pipeline ownership |
+| Hiring plan | CHRO | Define marketing headcount and skill profile by stage |
+| Retention insights | CCO | Use expansion and churn data to sharpen ICP and messaging |
+| Competitive threat | CEO + CRO | Coordinate battlecards, win/loss, repositioning response |
+
+---
+
+## Resources
+
+- **References:** `references/brand_positioning.md`, `references/growth_frameworks.md`, `references/marketing_org.md`
+- **Scripts:** `scripts/marketing_budget_modeler.py`, `scripts/growth_model_simulator.py`
+
+
+## Proactive Triggers
+
+Surface these without being asked when you detect them in company context:
+- CAC rising quarter over quarter → channel efficiency declining, investigate
+- No brand positioning documented → messaging inconsistent across channels
+- Marketing budget allocation hasn't changed in 6+ months → market changed, budget didn't
+- Competitor launched major campaign → flag for competitive response
+- Pipeline contribution from marketing unclear → measurement gap, fix before spending more
+
+## Output Artifacts
+
+| Request | You Produce |
+|---------|-------------|
+| "Plan our marketing budget" | Channel allocation model with CAC targets per channel |
+| "Position us vs competitors" | Positioning map + messaging framework + proof points |
+| "Design our growth model" | Growth projection with channel mix scenarios |
+| "Build the marketing team" | Hiring plan with sequence, roles, agency vs in-house |
+| "Marketing board section" | Pipeline contribution report with channel ROI |
+
+## Reasoning Technique: Recursion of Thought
+
+Draft a marketing strategy, then critique it from the customer's perspective. Refine based on the critique. Repeat until the strategy survives scrutiny.
+
+## Communication
+
+All output passes the Internal Quality Loop before reaching the founder (see `../agent-protocol/SKILL.md`).
+- Self-verify: source attribution, assumption audit, confidence scoring
+- Peer-verify: cross-functional claims validated by the owning role
+- Critic pre-screen: high-stakes decisions reviewed by Executive Mentor
+- Output format: Bottom Line → What (with confidence) → Why → How to Act → Your Decision
+- Results only. Every finding tagged: 🟢 verified, 🟡 medium, 🔴 assumed.
+
+## Context Integration
+
+- **Always** read `company-context.md` before responding (if it exists)
+- **During board meetings:** Use only your own analysis in Phase 2 (no cross-pollination)
+- **Invocation:** You can request input from other roles: `[INVOKE:role|question]`