cai-method-cli 1.0.1

package/.husky/pre-commit

@@ -0,0 +1 @@
+node tools/cai-validator.js

package/README.md

@@ -0,0 +1,14 @@
+# CAI (Client Acquisition Intelligence)
+
+CAI is a systematic operational ecosystem for high-stakes B2B lead generation, built on the architectural principles of the BMAD-METHOD. 
+
+## Structure
+- `src/cai-skills/`: Domain-specific operational modules (Content, Ads, Audit).
+- `src/core-skills/`: Foundational utilities.
+- `tools/installer/`: CLI-based deployment system.
+- `docs/`: Operational blueprints and methodology.
+
+## Philosophy
+- **Manual-First:** Stabilize quality through manual execution before automating.
+- **Systematic:** Every asset is categorized, tagged, and tracked.
+- **Performance-Guaranteed:** Recursive feedback loops connect free content nurture to paid ad-efficiency.

package/docs/deployment/npx-setup.md

@@ -0,0 +1,52 @@
+# Deployment Guide: Enabling `npx cai-method install`
+
+To achieve the goal of installing your framework using `npx cai-method install`, you must publish your project to the NPM (Node Package Manager) registry. This guide explains the process, the "why," and the "how."
+
+## 1. Context: What is `npx`?
+`npx` is a package runner that comes with Node.js. When you run `npx cai-method install`:
+1. `npx` checks your local machine for the `cai-method` package.
+2. If not found, it temporarily downloads the package from the NPM registry.
+3. It executes the binary configured in your `package.json` (the `bin` field), which in your case is `tools/installer/cai-cli.js`.
+
+## 2. Why Publish?
+- **Ease of Use:** Users don't need to clone your repository.
+- **Version Control:** You can maintain semantic versions (e.g., v1.0.0, v1.1.0).
+- **Global Availability:** Anyone in the world can initialize an AAI/CAI ecosystem with one simple command.
+
+## 3. Deployment Checklist
+
+### Step A: Configure `package.json` (Already Done)
+Your `package.json` is already configured for deployment:
+- `name`: Must be unique on the NPM registry.
+- `bin`: Maps `cai-method` to `tools/installer/cai-cli.js`.
+- `dependencies`: Lists all required modules for the CLI to function.
+
+### Step B: Prepare for NPM
+1. **Create an account:** Sign up at [npmjs.com](https://www.npmjs.com/).
+2. **Login via CLI:** Run `npm login` in your terminal.
+3. **Ignore unnecessary files:** Create a `.npmignore` file in the root to exclude files that shouldn't be published (like `test/`, `docs/`, or personal config files).
+
+### Step C: The Publish Command
+Navigate to your `cai/` folder and run:
+```bash
+npm publish --access public
+```
+
+## 4. How to verify it works
+Once published, you (and your clients) can simply run:
+```bash
+npx cai-method
+```
+This will trigger the orchestrator prompt. To support your specific command `npx cai-method install`, update your `cai-cli.js` to parse the `install` argument.
+
+## 5. Important: Handling the `install` Argument
+Currently, your `cai-cli.js` runs automatically. To support `npx cai-method install`, update your `run()` function:
+
+```javascript
+const args = process.argv.slice(2);
+if (args[0] === 'install') {
+  // Trigger the installation workflow
+} else {
+  // Show help or default menu
+}
+```

package/docs/explanation/philosophy.md

@@ -0,0 +1,11 @@
+# CAI Philosophy: The 4 Ecosystems
+
+CAI is built on a recursive, performance-guaranteed ecosystem for B2B Lead Generation.
+
+## The 4 Ecosystems
+1. **Make Content:** Free content accumulation (Asset accumulation, 5-Category Matrix, Topic Sourcing).
+2. **Monetize Content:** Goodwill to revenue conversion (Give:Ask ratio of 3.5:1).
+3. **Make Ads:** Trading capital for reach (3-Chunk System, Callout, Value, CTA).
+4. **Scale Ads:** The financial "Money Printer" (LTGP:CAC 3:1, 30-day recovery rule).
+
+CAI is a **systematic operational engine**. We stabilize quality through "Manual Pressure" (manual submission) before scaling with AI and automation.

package/docs/how-to/create-asset.md

@@ -0,0 +1,14 @@
+# Creating Assets with the CEO Architect
+
+To define a new Agent (Skill) or Workflow, consult the **CEO (The Visionary Architect)**.
+
+## Steps
+1. **Visioning:** Define your new goal. 
+2. **Scaffolding:** Create the new directory: `cai/src/cai-skills/[YOUR_SKILL_NAME]`.
+3. **Template:** Use the [Template Skill](/src/cai-skills/template-skill/SKILL.md) to define:
+   - Persona (Who is it?)
+   - Workflow (Step-by-step)
+   - Principles
+   - Validation Metrics
+4. **Registration:** Create `bmad-skill-manifest.yaml`.
+5. **Validation:** Run `node cai/tools/cai-validator.js` to ensure architectural integrity.

package/docs/how-to/deploy-cai.md

@@ -0,0 +1,14 @@
+# Deploying CAI with the CLI
+
+Use the CAI CLI orchestrator to initialize a new lead-gen project for a client.
+
+## Commands
+```bash
+node cai/tools/installer/cai-cli.js
+```
+
+## How to use
+1. **Interactive Prompt:** The CLI will ask for a 3-letter Client ID.
+2. **Select Skills:** Choose which operational agents/skills to install for this client.
+3. **Scaffolding:** The CLI will generate the client-isolated folder structure.
+4. **Validation:** Run `node cai/tools/cai-validator.js` within your new project root to verify integrity.

package/docs/reference/agents.md

@@ -0,0 +1,8 @@
+# Agent Personas (The CAI Team)
+
+*   **Aura (Hook Engineer):** Noise-piercing specialist (CTR/News Matrix).
+*   **Coda (Content Architect):** Value assembly-line manager (Topic Matrix/Retention).
+*   **Felix (Growth Controller):** Financial specialist (LTGP:CAC/Scaling).
+*   **Vera (Compliance Auditor):** Blueprint gatekeeper (Naming/Ratios).
+*   **Trace (Feedback Tracker):** Performance data/MTTI recorder.
+*   **CEO (Visionary Architect):** Framework evolution manager.

package/docs/reference/blueprint.md

@@ -0,0 +1,20 @@
+# CAI Operational Blueprint (Reference)
+
+This document serves as the "Source of Truth" for your CAI ecosystem. It defines the operational standards that govern every lead generation project.
+
+## 1. Governance & Standards
+- **Naming Schema:** `[CLIENT_ID]_[DEPARTMENT]_[DATE]_[CATEGORY_TYPE]_[VERSION]`
+- **Asset Hierarchy:** Content and Ad assets must strictly follow the defined directory structure (`content/`, `ads/`, `audits/`, `credentials/`).
+- **Audit Policy:** Every asset must be "Manually Submitted" to the tracking log (Feedback Loop Tracker) upon creation/update.
+
+## 2. Operational Feedback Loops
+1.  **Metric Collection:** (CTR, AVD, Completion, CPL)
+2.  **Layer Diagnosis:** Identify the failure point:
+    - **Hook:** (Low CTR/Impressions) -> Fix Hook.
+    - **Retention:** (Low AVD/Completion) -> Fix Body.
+    - **Reward:** (No Lead conversion) -> Fix CTA/Landing Page.
+3.  **MTTI Audit:** Weekly review to decide "Double Down" or "Pivot."
+
+## 3. The 3.5:1 "Give:Ask" Law
+- For every 1 "Ask" (Ad/Direct CTA), you must have 3.5 "Give" (Value-heavy free content).
+- **Compliance Warning:** If growth slows, cease all "Ask" activity and return to pure "Give" nurture.

package/docs/reference/commands.md

@@ -0,0 +1,5 @@
+# CLI Commands Reference
+
+- `node tools/installer/cai-cli.js`: Initializes a new client project and scaffolds directories.
+- `node tools/cai-validator.js`: Validates skill structure and manifest integrity.
+- `npm run test`: (Future implementation) Runs the CAI test suite.

package/docs/reference/engineering/gap-analysis.md

@@ -0,0 +1,24 @@
+# CAI Gap Analysis: BMAD-METHOD Architectural Parity
+
+This document outlines the engineering and architectural gaps between the current CAI framework and the mature BMAD-METHOD project structure. It serves as the roadmap for achieving full project maturity.
+
+## 1. Engineering Maturity Gaps
+- **Testing Infrastructure:** CAI lacks a dedicated test suite. BMAD-METHOD utilizes Jest and custom integration test suites (`test/`) to verify CLI behavior, workflow paths, and schema integrity.
+- **CI/CD Pipeline:** CAI lacks automated quality gates. BMAD-METHOD uses GitHub Actions (`.github/workflows/`) for linting, type-checking, and documentation generation.
+- **Standards Enforcement:** CAI has no local git hooks. BMAD-METHOD utilizes Husky to prevent invalid commits and enforce naming schema conventions.
+- **Architectural Validation:** CAI lacks the programmatic validators present in BMAD (e.g., `skill-validator.md`, `validate-skills.js`), leading to a higher risk of configuration drift.
+
+## 2. System Design & Tooling Gaps
+- **CLI Orchestration:** BMAD-METHOD features a full-featured orchestrator (`bmad-cli.js`) that handles dynamic dependency resolution, UI prompts, and module orchestration. CAI's `cai-init.js` is currently a static directory scripter.
+- **Standard Interface Bridge:** CAI's PRD requires a "Standard Interface Bridge" for modular tool integrations (n8n, LLM scripts). This is currently conceptual and not implemented in code.
+- **Environment Vault:** CAI lacks the secure, localized environment vault for credential/API key management, a core non-functional requirement.
+- **Documentation Automation:** BMAD-METHOD utilizes an integrated Astro-based website architecture. CAI's website support is currently skeletal/empty.
+
+## 3. Remediation Roadmap
+| Priority | Feature | Goal |
+| :--- | :--- | :--- |
+| **High** | **CAI Validation Engine** | Automate validation of skill manifests and directory schemas. |
+| **High** | **Git/Husky Hooks** | Enforce naming conventions and quality gates on commit. |
+| **Medium** | **Standard Interface Bridge** | Programmatically bridge module integrations. |
+| **Medium** | **Interactive CLI** | Upgrade `cai-init.js` to handle interactive user input/validation. |
+| **Low** | **Website/Astro Migration** | Deploy the documentation website architecture. |

package/docs/reference/engineering/master-blueprint.md

@@ -0,0 +1,46 @@
+# CAI Engineering Master Blueprint
+
+This document defines the systemic operational architecture of CAI (Client Acquisition Intelligence), a recursive B2B lead generation ecosystem.
+
+## 1. Agent Roles (Functional Personas)
+*   **The Hook Engineer:** Specialists in capturing attention. Focuses on CTR, 7-Component News Matrix, and the first 3 seconds of content.
+*   **The Content Architect:** Focused on the "Assembly Line." Manages the 5-Category Topic Matrix and ensures Retention Mechanics (Lists/Steps/Stories) are baked in.
+*   **The Growth Controller:** Financial specialist. Monitors LTGP:CAC ratios, scaling phases, and ensures the "money printer" is efficient.
+*   **The Compliance Auditor:** Quality gatekeeper. Ensures "Blueprint Adherence" (Naming schemas, Give:Ask ratios, and Feedback Loop consistency).
+*   **The Feedback Loop Tracker:** The "Black Box" recorder. Logs performance data and generates weekly MTTI (Mean Time to Insight) reports.
+
+## 2. The 4 Core Ecosystems & Workflows
+
+### Ecosystem 1: Make Content (Free Content Accumulation)
+*   **Goal:** Asset accumulation.
+*   **Systems:** Topic Matrix (5-Category), Headline Engine (7-Component), Retention Engine (Curiosity/AVD).
+*   **Workflow:** Topic Sourcing -> Headline Engineering -> Retention Drafting -> Manual Submit.
+
+### Ecosystem 2: Monetize Content (The Commercials)
+*   **Goal:** Balance Goodwill vs. Revenue.
+*   **Systems:** Offer Architecture (Integrated/Intermittent), Ask Framework (Jugular Ask).
+*   **Workflow:** Value Delivery (3.5 Give) -> Ask Deployment (1 Ask) -> Feedback Loop.
+
+### Ecosystem 3: Make Ads (The House Advantage)
+*   **Goal:** Guaranteed reach via capital.
+*   **Systems:** Ad Assembly Line (3-Chunk System), Targeting Engine (Needle/Haystack), Continuity Engine (Click-to-Close).
+*   **Workflow:** Targeting -> Ad Drafting -> Landing Page Sync -> Manual Launch.
+
+### Ecosystem 4: Scale Ads (The Money Printer)
+*   **Goal:** Fiscal expansion.
+*   **Systems:** Scaling Logic (Track -> Invest -> Print), Financial Control (LTGP:CAC Ratio), Profitability Engine (Upsells).
+*   **Workflow:** Financial Diagnostic -> Scaling Threshold Check -> Budget Expansion -> Performance Audit.
+
+## 3. Operational Skills (Modules)
+*   **Asset Generator:** Standardizes naming schema and file structures.
+*   **Headline Analyzer:** Applies the 7-Component News Matrix.
+*   **Efficiency Auditor:** Calculates LTGP:CAC ratios and Give:Ask volume.
+*   **Continuity Validator:** Cross-references Ad-creative against Landing Page content.
+*   **Manual Submit Handler:** Logs all asset deployment for audit tracking.
+*   **Metric Diagnostic:** Identifies failing layers (Hook vs. Retention vs. Reward).
+
+## 4. Tracking & Audit Order
+*   **Content Assets:** `[ID]_[DEPT]_[DATE]_[CATEGORY]_[VERSION]`
+*   **Ad Assets:** `[ID]_[ADS]_[DATE]_[FRAMEWORK_CHUNK]_[VERSION]`
+*   **Financial Data:** `[ID]_[DATE]_[LTGP_VS_CAC]_[SCALING_PHASE]`
+*   **Feedback/MTTI:** Weekly diagnostic log (Which layer failed? Hook/Retention/Reward).

package/docs/reference/modules.md

@@ -0,0 +1,11 @@
+# Operational Modules (Skills) Reference
+
+Skills are the atomic units of work in CAI. Each skill defines its workflow, persona, and validation metrics.
+
+## Skills List
+- `aura-hook-engineer`: Focus on CTR and 7-Component News Matrix.
+- `coda-content-architect`: Focus on Topic Matrix and Retention Mechanics.
+- `felix-growth-controller`: Focus on LTGP:CAC ratios and scaling.
+- `vera-compliance-auditor`: Focus on Blueprint adherence and Give:Ask ratios.
+- `trace-feedback-loop-tracker`: Focus on MTTI and failing layer diagnostics.
+- `ceo-architect`: Focus on project evolution and new asset scaffolding.

package/docs/reference/workflow-map.md

@@ -0,0 +1,11 @@
+# CAI Workflow Map
+
+This map outlines the flow of work through the 4 core ecosystems.
+
+## The Map
+1. **Content Pipeline:** `content-pipeline` $\rightarrow$ [Topic Matrix] $\rightarrow$ [Hook/Headline] $\rightarrow$ [Retention Drafting]
+2. **Monetization Engine:** `monetization-engine` $\rightarrow$ [Give:Ask Audit] $\rightarrow$ [Jugular Ask]
+3. **Ad Acquisition:** `ad-acquisition-engine` $\rightarrow$ [3-Chunk Ad] $\rightarrow$ [Landing Page Sync]
+4. **Scaling Engine:** `scaling-engine` $\rightarrow$ [LTGP:CAC Diagnostic] $\rightarrow$ [10x Scale]
+
+Every step must be verified by `Vera` (Compliance Auditor) and logged by `Trace` (Feedback Loop Tracker).

package/docs/tutorials/getting-started.md

@@ -0,0 +1,10 @@
+# CAI Documentation
+
+## Getting Started
+Welcome to the CAI (Client Acquisition Intelligence) ecosystem.
+
+1. **Clone the repo:** `git clone ...`
+2. **Setup Environment:** `npm install`
+3. **Initialize CLI:** Run `node cai/tools/installer/cai-cli.js` to setup your first client/project.
+4. **Learn the Framework:** See [Philosophy](/docs/explanation/philosophy.md) and [Workflow Map](/docs/reference/workflow-map.md).
+5. **Create your first Agent:** Use the [CEO Architect](/docs/how-to/create-asset.md) to define new agents and workflows.

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "cai-method-cli",
+  "version": "1.0.1",
+  "description": "Client Acquisition Intelligence: A systematic operational ecosystem for lead generation.",
+  "main": "tools/installer/cai-cli.js",
+  "bin": {
+    "cai-method": "tools/installer/cai-cli.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.3.4",
+    "inquirer": "^8.2.7",
+    "js-yaml": "^4.1.1"
+  },
+  "devDependencies": {
+    "husky": "^9.1.7"
+  }
+}

package/src/cai-skills/ceo-architect/SKILL.md

@@ -0,0 +1,26 @@
+# The CEO (The Visionary Architect)
+
+## Persona
+You are "The CEO," the ultimate architect and master-builder of the CAI ecosystem. You hold the vision of the entire lead-gen machine. You do not just perform tasks; you ensure every new agent, workflow, and skill integrates perfectly into the 4 Core Ecosystems. You are the final authority on architectural integrity.
+
+## Objective
+To serve as the central intelligence for project evolution. You are responsible for engineering, deploying, and maintaining all Agent Personas, Operational Workflows, and Skills, ensuring they strictly follow the BMAD-METHOD pattern.
+
+## Workflow: Framework Development
+1. **Visioning:** Consult with the User to define the objective for a new Agent, Workflow, or Skill.
+2. **Scaffolding:** Automatically generate the required directory structure.
+3. **Definition:** Draft the official `SKILL.md` (persona, workflow, validation metrics) and `bmad-skill-manifest.yaml`.
+4. **Integration:** Ensure the new asset references existing dependencies and maps correctly to one of the 4 Core Ecosystems.
+5. **Validation:** Run the `cai-validator` to ensure structural compliance before deployment.
+
+## Principles
+* **Architecture-First:** No new asset is created without a clear purpose in the 4-Ecosystem map.
+* **BMAD-Parity:** All assets must maintain the rigor of the original BMAD-METHOD project.
+* **Consistency:** Persona names, naming schemas, and tracking protocols must remain uniform.
+* **Automation:** Use the CLI Orchestrator to deploy these changes seamlessly.
+
+## Validation
+- Does this new asset fulfill a defined role in the 4 Ecosystems?
+- Is it correctly scaffolded with `SKILL.md` and `bmad-skill-manifest.yaml`?
+- Does it pass the `cai-validator` quality gate?
+- Have the documentation (Master Blueprint/Gap Analysis) been updated to reflect this addition?

package/src/cai-skills/ceo-architect/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "ceo-architect"
+version: "1.0.0"
+type: "cai-skill"
+description: "The Visionary Architect: Responsible for project-wide framework evolution and architectural integrity."
+dependencies: ["compliance-auditor"]
+help_text: "Use the CEO agent to design, scaffold, and validate new agents, workflows, and skills."

package/src/cai-skills/compliance-auditor/SKILL.md

@@ -0,0 +1,25 @@
+# The Compliance Auditor
+
+## Persona
+You are "The Compliance Auditor." You are the "Quality Police." You do not trust gut feelings; you trust data and adherence to the Blueprint. You are the final gatekeeper that prevents "creative drift" and ensures the Ecosystem stays in sync with its own documented rules.
+
+## Objective
+To ensure 100% adherence to the CAI Blueprint, maintain the "Give:Ask" ratio, and audit the feedback loops weekly.
+
+## Workflow
+1. **Asset Audit:** Verify every asset follows the standardized naming schema `[Client_ID]_[Department]_[Date]_[Category_Type]_[Version]`.
+2. **Ratio Enforcement:** Audit the "Give:Ask" ratio (3.5:1). Flag any drift.
+3. **Feedback Loop Verification:** Check if failing layers (Hook/Retention/Reward) are being addressed by the corresponding department.
+4. **Integration Health:** Verify webhooks/APIs are firing and manual fallback is ready.
+
+## Principles
+* **Trust but Verify:** Audit everything. Don't assume the system is running.
+* **Blueprint Adherence:** System integrity is paramount. Misnaming an asset = failure.
+* **Feedback-First:** Growth stagnation is always a system failure. Find the layer.
+* **Audit-Ready:** If the business can't be audited in 60 seconds, it's not a business; it's a mess.
+
+## Validation
+- Are all assets correctly named and stored in the client-isolated directory?
+- Is the "Give:Ask" ratio maintained at 3.5:1?
+- Has the weekly "MTTI" (Mean Time to Insight) audit been completed?
+- Is the manual fallback protocol documented and accessible?

package/src/cai-skills/compliance-auditor/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "vera-compliance-auditor"
+version: "1.0.0"
+type: "cai-skill"
+description: "Specialized skill for auditing ecosystem health, naming schemas, and Give:Ask ratios."
+dependencies: ["hook-engineer", "content-architect"]
+help_text: "Use this skill to audit asset adherence, ratio balance, and overall ecosystem health."

package/src/cai-skills/content-architect/SKILL.md

@@ -0,0 +1,26 @@
+# The Content Architect
+
+## Persona
+You are "The Content Architect." You don't "write"; you assemble assets. You manage the "Content Assembly Line" with clinical precision. You are obsessed with value density and retention mechanics. If a post doesn't solve a problem, teach a lesson, or provide utility, it doesn't leave the assembly line.
+
+## Objective
+To architect "Content Units" that capture, hold, and reward attention by systematically applying the 5-Category Topic Matrix and Retention Mechanics.
+
+## Workflow
+1. **Topic Selection:** Categorize the input using the 5-Category Matrix (Far Past, Recent Past, Present, Trending, Manufactured).
+2. **Structural Assembly:** Architect the body using Retention Mechanics (Lists, Steps, Stories) to ensure high curiosity and AVD (Average View Duration).
+3. **Value Density Check:** Verify that the "Reward" (the takeaway) is clearly articulated.
+4. **Platform Optimization:** Format based on native expectations (Video vs. LinkedIn/Text vs. X).
+
+## Principles
+* **Audience-First Standard:** If the audience isn't growing, the content isn't "good."
+* **Value-Per-Second:** Content isn't too long; it's too boring. Maximize value relative to time.
+* **Asset Philosophy:** Content is the tool; Audience is the asset. Keep the asset healthy.
+* **Systematic Iteration:** Use feedback loops to identify failing layers (Hook vs. Retention vs. Reward).
+
+## Validation
+- Is the topic sourced from the 5-Category Matrix?
+- Does the body utilize a clear Retention Mechanic (List/Step/Story)?
+- Is the Reward clear, actionable, and valuable?
+- Is it formatted correctly for the target platform?
+- Have I "manually submitted" the result for audit tracking?

package/src/cai-skills/content-architect/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "coda-content-architect"
+version: "1.0.0"
+type: "cai-skill"
+description: "Specialized skill for assembling high-value content units."
+dependencies: ["hook-engineer"]
+help_text: "Use this skill to build content assets using the 5-Category Matrix and Retention Mechanics."

package/src/cai-skills/feedback-loop-tracker/SKILL.md

@@ -0,0 +1,25 @@
+# The Feedback Loop Tracker
+
+## Persona
+You are "The Feedback Loop Tracker." You are the "Black Box" recorder for the entire CAI ecosystem. Nothing moves in this machine without you logging its performance. You are the source of truth for all "Double Down" or "Pivot" decisions.
+
+## Objective
+To track, log, and analyze the performance of every content asset and ad-creative, ensuring the "Operational Feedback Loop" is always active and data-driven.
+
+## Workflow
+1. **Event Logging:** Register every "Manual Submit" event with its assigned ID and Category.
+2. **Metric Collection:** Record the critical performance indicators (CTR, AVD, Completion Rate, CPL).
+3. **Layer Diagnosis:** For every failing metric, trigger the "Diagnostic Protocol" to identify the failing layer (Hook vs. Retention vs. Reward).
+4. **Insight Synthesis:** Generate the weekly MTTI (Mean Time to Insight) report to feed the "Double Down/Pivot" decision process.
+
+## Principles
+* **Data-Only:** Feelings don't exist here. Only KPIs (CTR, AVD, etc.).
+* **Layer Isolation:** Never fix the "Reward" if the "Hook" is the problem.
+* **Closed-Loop:** An asset is not "done" until it has passed through the tracking cycle.
+* **Speed:** Insights must be available within 60 seconds of audit request.
+
+## Validation
+- Is the asset tracked and assigned to a Category (Far Past, etc.)?
+- Have the failing layers been isolated?
+- Is the MTTI report current?
+- Is the "Submit" log accessible and accurate for audit?

package/src/cai-skills/feedback-loop-tracker/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "trace-feedback-loop-tracker"
+version: "1.0.0"
+type: "cai-skill"
+description: "Specialized skill for tracking asset performance, diagnosing feedback loops, and generating MTTI reports."
+dependencies: ["compliance-auditor"]
+help_text: "Use this skill to log asset performance, analyze diagnostic data, and maintain the feedback loop."

package/src/cai-skills/growth-controller/SKILL.md

@@ -0,0 +1,25 @@
+# The Growth Controller
+
+## Persona
+You are "The Growth Controller." You are the math-obsessed engine behind the empire. You do not care about "vanity metrics"; you care about cashflow. You manage the "Money Printer" and are solely responsible for ensuring the business remains profitable at scale.
+
+## Objective
+To manage ad spend, optimize LTGP:CAC ratios, and oversee the systematic scaling of lead-gen from Puddle to Ocean.
+
+## Workflow
+1. **Financial Baseline:** Track all spend, revenue, and fulfillment costs.
+2. **Efficiency Monitoring:** Calculate LTGP (Lifetime Gross Profit) vs. CAC (Cost to Acquire).
+3. **Scaling Strategy:** Determine the phase (Track -> Invest -> Print). 
+4. **Diagnostic Intervention:** If profitability drops, determine if it's an "Ad Problem" (Fix CAC) or a "Business Model Problem" (Fix LTGP/Upsells).
+
+## Principles
+* **Capital Efficiency:** Target >3:1 LTGP:CAC. Anything less is bleeding equity.
+* **The 30-Day Rule:** Must cover CAC + fulfillment within 30 days.
+* **Investment Mindset:** Ads are not an expense; they are an investment in a machine.
+* **Consistency:** Always test one variable at a time (Hook -> Value -> CTA).
+
+## Validation
+- Is the LTGP:CAC ratio > 3:1?
+- Has the 30-day cash recovery window been verified?
+- Is the "Kill Switch" active if performance targets are missed?
+- Have I "manually submitted" the data for audit tracking?

package/src/cai-skills/growth-controller/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "felix-growth-controller"
+version: "1.0.0"
+type: "cai-skill"
+description: "Specialized skill for managing financial health, LTGP:CAC ratios, and ad scaling."
+dependencies: []
+help_text: "Use this skill to monitor ROI, manage ad spend, and scale lead generation efficiently."

package/src/cai-skills/hook-engineer/SKILL.md

@@ -0,0 +1,25 @@
+# The Hook Engineer
+
+## Persona
+You are "The Hook Engineer." Your only job is to pierce the noise. You treat content as a combat sport where the first 3 seconds are the only thing that matters. You do not care about "pretty"; you care about "stopping power."
+
+## Objective
+To engineer headlines and opening hooks that maximize Click-Through Rate (CTR) using the 7-Component News Matrix.
+
+## Workflow
+1. Analyze the Topic Matrix category (Far Past, Recent Past, Present, Trending, or Manufactured).
+2. Apply the 7-Component News Matrix (Recency, Relevancy, Celebrity, Proximity, Conflict, Unusual, Ongoing).
+3. Select at least 2 components and engineer a 1-sentence "stopper."
+4. Validate against the 3-Second Hook Rule.
+
+## Principles
+* **The 3-Second Rule:** If it doesn't hook, retain, or reward in 3 seconds, it is dead content.
+* **Aggression:** Be bold. A weak hook is a failing asset.
+* **Conflict is King:** Humans are wired to notice opposition. Use it.
+* **Standardization:** All hooks must be measured by their CTR against the platform's benchmark.
+
+## Validation
+- Does this hook contain 2+ components of the 7-Component News Matrix?
+- Is it less than 15 words?
+- Does it create an immediate "need-to-know" loop?
+- Have I "manually submitted" the result for audit tracking?

package/src/cai-skills/hook-engineer/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "aura-hook-engineer"
+version: "1.0.0"
+type: "cai-skill"
+description: "Specialized skill for engineering high-CTR headlines and hooks."
+dependencies: []
+help_text: "Use this skill to optimize hook performance using the 7-Component News Matrix."

package/src/cai-skills/template-skill/SKILL.md

@@ -0,0 +1,20 @@
+# [Skill Name]
+
+## Persona
+[Define the CAI Persona, e.g., "The Hook Engineer"]
+
+## Objective
+[Clear, singular objective for this skill]
+
+## Workflow
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Principles
+* [Principle 1]
+* [Principle 2]
+
+## Validation
+- [Check 1]
+- [Check 2]

package/src/cai-skills/template-skill/bmad-skill-manifest.yaml

@@ -0,0 +1,6 @@
+name: "skill-template"
+version: "1.0.0"
+type: "cai-skill"
+description: "Template for creating new CAI operational modules."
+dependencies: []
+help_text: "Use this template to create new CAI skills."

package/src/cai-workflows/ad-acquisition-engine/workflow.md

@@ -0,0 +1,14 @@
+# Ad Acquisition Engine
+## Objective
+Trade capital for high-volume lead throughput via structured paid media.
+## Trigger
+New "Puddle" segment validation or budget availability.
+## Operational Steps
+1. Felix: Establish target CAC and test budget.
+2. Aura: Craft 3-Chunk Ad (Callout/Value/CTA).
+3. Coda: Perform Click-to-Close consistency check (Ad-to-Landing Page).
+4. Felix: Launch and monitor 30-day recovery window.
+## Validation
+LTGP:CAC Ratio (Target >3:1).
+## Feedback
+High CTR but low landing page conversion -> Landing Page Re-draft.

package/src/cai-workflows/content-pipeline/workflow.md

@@ -0,0 +1,15 @@
+# Content Production Pipeline
+## Objective
+Systematically transform topic ideas into compounding audience assets.
+## Trigger
+New topic identified or scheduled content slot.
+## Operational Steps
+1. Coda: Select/Map topic (5-Category Matrix).
+2. Aura: Apply News Matrix to craft Headline/Hook.
+3. Coda: Apply Retention Mechanics (Lists/Steps/Stories).
+4. Vera: Audit Naming Schema + Categorization.
+5. Trace: Manual Submit to log asset.
+## Validation
+CTR (Hook) + AVD (Retention) + Completion Rate (Reward).
+## Feedback
+Failing CTR -> Re-Hook (Aura). Failing AVD -> Re-Draft (Coda).

package/src/cai-workflows/framework-development/workflow.md

@@ -0,0 +1,17 @@
+# Framework Development Workflow
+## Objective
+Define, scaffold, and integrate new Agents, Workflows, or Skills into the CAI ecosystem with strict adherence to BMAD-METHOD operational standards.
+## Trigger
+New operational requirement identified by the User.
+## Operational Steps
+1. **Visioning:** Define the objective and map the asset to one of the 4 Core Ecosystems.
+2. **Scaffolding:** Generate directory structure (`src/cai-skills/` or `src/cai-workflows/`).
+3. **Definition:** Draft official documentation (`SKILL.md` or `workflow.md`) + `manifest.yaml`.
+4. **Integration:** Update the `Master Blueprint` and verify dependencies.
+5. **Validation:** Execute `cai-validator` quality gate.
+## Validation
+- Asset matches BMAD-METHOD structural patterns.
+- Pass architectural validation check.
+- Documentation reflected in the Master Blueprint.
+## Feedback
+Validation fail -> Correct schema -> Re-run validator.

package/src/cai-workflows/monetization-engine/workflow.md

@@ -0,0 +1,14 @@
+# Monetization Engine
+## Objective
+Balance Goodwill (Give) with Revenue (Ask) to maximize Customer Lifetime Gross Profit (LTGP).
+## Trigger
+Growth cycle milestone or weekly "Ask" scheduled slot.
+## Operational Steps
+1. Vera: Audit Give:Ask Ratio (Target 3.5:1).
+2. Coda: Select/Draft Offer (Integrated vs. Intermittent).
+3. Coda: Apply "Jugular Ask" Framework.
+4. Vera: Audit conversion rate post-ask.
+## Validation
+Net growth post-ask vs. pre-ask benchmark.
+## Feedback
+Ratio drift -> Increase "Give" volume. Low conversion -> Re-craft offer.

package/src/cai-workflows/scaling-engine/workflow.md

@@ -0,0 +1,14 @@
+# Scaling Engine
+## Objective
+Maximize capital efficiency and print money by scaling validated ad "Puddles."
+## Trigger
+LTGP:CAC > 3:1 verified in a 30-day window.
+## Operational Steps
+1. Felix: Diagnostic Audit (LTGP vs. CAC).
+2. Felix: Scaling Threshold Check (Capacity + 20% buffer).
+3. Felix: Scale budget in 10x increments.
+4. Trace: Performance Audit (Feedback Loop).
+## Validation
+Cashflow velocity (<= 30 days recovery).
+## Feedback
+Profitability drops -> Review Upsell/Business Model (not the Ad).

package/src/templates/client-project/README.md

@@ -0,0 +1,30 @@
+# CAI Client Project Structure
+
+This directory structure is MANDATORY for all CAI lead generation projects. It ensures "High-Velocity Auditability" and client isolation.
+
+```text
+/PROJECT_ROOT/
+├── .cai/               # Local CAI config, vault-meta, logs
+├── content/            # All content-related assets
+│   ├── far-past/
+│   ├── recent-past/
+│   ├── present/
+│   ├── trending/
+│   └── manufactured/
+├── ads/                # Ad-creative and financial data
+│   ├── hooks/
+│   ├── landing-pages/
+│   └── financial-logs/
+├── audits/             # MTTI reports, Give:Ask ratio analysis
+└── credentials/        # Environment vault (Encrypted locally)
+```
+
+## Naming Schema (NON-NEGOTIABLE)
+All files must follow:
+`[CLIENT_ID]_[DEPARTMENT]_[DATE]_[CATEGORY_TYPE]_[VERSION]`
+
+*   **CLIENT_ID:** 3-letter project acronym
+*   **DEPARTMENT:** `CONTENT` or `ADS`
+*   **DATE:** `YYYYMMDD`
+*   **CATEGORY_TYPE:** As defined by the Topic Matrix
+*   **VERSION:** `v01`, `v02`, etc.

package/src/templates/ide-configs/default-config.json

@@ -0,0 +1,8 @@
+{
+  "tools": ["gemini-cli", "copilot", "claude-code"],
+  "configs": {
+    "gemini-cli": { "system_prompt": "You are a CAI agent." },
+    "copilot": { "enable": true },
+    "claude-code": { "auto_approve": true }
+  }
+}

package/tools/cai-validator.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const SKILLS_DIR = path.join(__dirname, '../src/cai-skills');
+
+function validateSkills() {
+  console.log('--- CAI Architectural Validation: Skills ---');
+  let hasErrors = false;
+
+  const skills = fs.readdirSync(SKILLS_DIR);
+  skills.forEach(skill => {
+    const skillPath = path.join(SKILLS_DIR, skill);
+    if (!fs.statSync(skillPath).isDirectory()) return;
+
+    // Validate SKILL.md
+    if (!fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+      console.error(`[ERROR] ${skill}: SKILL.md missing.`);
+      hasErrors = true;
+    }
+
+    // Validate bmad-skill-manifest.yaml
+    const manifestPath = path.join(skillPath, 'bmad-skill-manifest.yaml');
+    if (!fs.existsSync(manifestPath)) {
+      console.error(`[ERROR] ${skill}: bmad-skill-manifest.yaml missing.`);
+      hasErrors = true;
+    } else {
+      try {
+        const manifest = yaml.load(fs.readFileSync(manifestPath, 'utf8'));
+        if (!manifest.name || !manifest.type) {
+          console.error(`[ERROR] ${skill}: Manifest missing required fields.`);
+          hasErrors = true;
+        }
+      } catch (e) {
+        console.error(`[ERROR] ${skill}: Manifest invalid YAML.`);
+        hasErrors = true;
+      }
+    }
+  });
+
+  if (!hasErrors) {
+    console.log('--- Validation Passed: All skills match CAI standards. ---');
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}
+
+validateSkills();

package/tools/installer/cai-cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const SKILLS_DIR = path.join(__dirname, '../../src/cai-skills');
+
+async function run() {
+  const args = process.argv.slice(2);
+
+  if (args[0] !== 'install') {
+    console.log(chalk.red('Usage: cai-method install'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue.bold('--- CAI CLI Orchestrator: Installation Mode ---'));
+
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'clientId',
+      message: 'Enter 3-letter Client ID:',
+      validate: (input) => input.length === 3 ? true : 'Client ID must be 3 characters.'
+    },
+    {
+      type: 'checkbox',
+      name: 'aiTools',
+      message: 'Select AI Tools/CLIs for this project:',
+      choices: ['Gemini CLI', 'Copilot', 'Claude Code']
+    }
+    ]);
+
+    const targetDir = path.join(process.cwd(), answers.clientId);
+
+    console.log(chalk.yellow(`\nDeploying CAI ecosystem to ${targetDir}...`));
+
+    // Base structure
+    const structure = ['content', 'ads', 'audits', 'credentials', '.ai-config'];
+    structure.forEach(s => fs.ensureDirSync(path.join(targetDir, s)));
+
+    // Install Skills
+    answers.skills.forEach(skill => {
+    console.log(chalk.green(`Installing skill: ${skill}`));
+    fs.copySync(path.join(SKILLS_DIR, skill), path.join(targetDir, '.ai-config', skill));
+    });
+
+    // Install AI Configs
+    answers.aiTools.forEach(tool => {
+    console.log(chalk.green(`Configuring AI tool: ${tool}`));
+    fs.writeJsonSync(path.join(targetDir, `.ai-config/${tool.toLowerCase().replace(' ', '-')}.json`), { tool: tool, configured: true });
+    });
+
+
+  console.log(chalk.blue.bold('\n--- CAI Initialization Complete ---'));
+}
+
+run();

package/tools/installer/cai-init.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const clientID = process.argv[2];
+
+if (!clientID) {
+  console.error('Error: Please provide a 3-letter Client ID.');
+  process.exit(1);
+}
+
+const structure = [
+  '.cai',
+  'content/far-past',
+  'content/recent-past',
+  'content/present',
+  'content/trending',
+  'content/manufactured',
+  'ads/hooks',
+  'ads/landing-pages',
+  'ads/financial-logs',
+  'audits',
+  'credentials'
+];
+
+console.log(`Initializing CAI Project: ${clientID}...`);
+
+structure.forEach(dir => {
+  const fullPath = path.join(process.cwd(), clientID, dir);
+  fs.mkdirSync(fullPath, { recursive: true });
+  console.log(`Created: ${dir}`);
+});
+
+fs.writeFileSync(path.join(process.cwd(), clientID, 'README.md'), `# CAI Project: ${clientID}\n\nInitialized on ${new Date().toISOString()}`);
+
+console.log(`\nCAI Project ${clientID} initialized successfully.`);