@botdigit/agent-blueprint 1.0.0

package/AGENTS.md

@@ -0,0 +1,204 @@
+# AGENTS.md — Entry Point for Coding Agents
+
+You are entering a project that uses **Agent Blueprint**.
+
+Before implementing any significant change:
+
+1. **Discover** the repository structure.
+2. **Identify** the technology stack.
+3. **Identify** the project type.
+4. **Identify** the business domain.
+5. **Read** existing project documentation.
+6. **Detect** existing architecture.
+7. **Detect** existing conventions.
+8. **Identify** current problems.
+9. **Determine** which skills apply.
+10. **Never** introduce unnecessary technologies.
+
+---
+
+## The Core Rule
+
+> **The agent must adapt to the project. The project must not be forced to adapt to the skill.**
+
+Do not assume:
+- Framework
+- Database
+- Architecture
+- Deployment target
+- Business model
+- Authentication mechanism
+- Payment model
+- Scaling requirements
+- Programming language
+
+**Inspect first. Always.**
+
+---
+
+## How to Use This Repository
+
+### Step 1 — Read the Orchestrator
+
+Start with `skills/00-orchestrator/SKILL.md`. It contains:
+
+- The workflow classification (greenfield / existing / broken)
+- Project detection logic
+- Skill selection rules
+- Decision trees for common scenarios
+
+### Step 2 — Run Discovery
+
+Follow `skills/01-discovery/SKILL.md` to locate the actual project within the repository (if it is nested, monorepo, or partially present).
+
+### Step 3 — Build Project Context
+
+Follow `skills/02-project-context/SKILL.md` to detect and record:
+
+- Programming language(s)
+- Framework(s)
+- Database(s)
+- Cache / queue / search
+- Infrastructure / deployment
+- CI/CD
+- Third-party services
+
+### Step 4 — Understand the Business
+
+Follow `skills/03-business-architecture/SKILL.md` to understand:
+
+- Who the actors are
+- What the business does
+- What the rules are
+- What the workflows are
+- What state machines exist
+- What must never change
+
+### Step 5 — Audit Before Modifying
+
+If the project already has code:
+
+- Run `skills/06-codebase-audit/SKILL.md`
+- Run `skills/07-security/SKILL.md` if the project handles user data, payments, auth, or external integrations
+- Run `skills/04-architecture/SKILL.md` to understand current architecture and gaps
+
+### Step 6 — Select the Minimum Skill Set
+
+Use the orchestrator's skill-selection logic. Activate only what is needed:
+
+```
+core
++ business-architecture          (if business logic exists or is being added)
++ architecture                   (if architecture decisions are needed)
++ documentation                  (always — every agent leaves docs better)
++ [detected stack skill]         (e.g., rust, typescript, python)
++ [detected framework skill]     (e.g., nextjs, laravel, django)
++ [detected infrastructure skill] (e.g., postgres, redis, docker)
++ security                        (if applicable)
++ testing                         (if code changes are planned)
++ performance                     (if performance is a concern)
+```
+
+### Step 7 — Implement
+
+After understanding and auditing:
+
+- Read the relevant stack skill for implementation conventions
+- Read the relevant framework skill for framework-specific patterns
+- Implement following the project's existing conventions
+- Write tests for every major change
+- Update documentation when architecture or business logic changes
+
+### Step 8 — Verify
+
+- Run `skills/08-testing/SKILL.md` to verify test coverage
+- Run `skills/07-security/SKILL.md` again if security-relevant changes were made
+- Update `CHANGELOG.md` and relevant docs
+
+---
+
+## Project State Classification
+
+The orchestrator classifies the project into one of these states:
+
+| State | Meaning | Approach |
+|---|---|---|
+| **Greenfield** | No code yet | Establish foundations; choose architecture deliberately |
+| **Healthy** | Code exists, well-structured | Improve incrementally; preserve what works |
+| **Partial** | Code exists, incomplete or inconsistent | Reconcile existing implementation before redesign |
+| **Broken** | Code exists, fundamental problems | Stabilize first; fix highest-risk issues; document as you go |
+
+---
+
+## Minimum Sufficient Documentation
+
+Do not create every document in `templates/`. Create only what the project needs:
+
+| Project Type | Minimum Docs |
+|---|---|
+| Script / small tool | `README.md` |
+| Small web app | `PROJECT.md`, `ARCHITECTURE.md`, `DATABASE.md`, `API.md`, `SECURITY.md` |
+| SaaS / marketplace | + `BUSINESS.md`, `BUSINESS-MODEL.md`, `ACTORS.md`, `TESTING.md`, `DEPLOYMENT.md`, `OPERATIONS.md` |
+| Regulated system | + `COMPLIANCE.md`, `AUDITS/`, data governance, disaster recovery |
+
+The orchestrator decides. Use judgment. When in doubt, err toward more documentation for complex or risky projects, and less for simple ones.
+
+---
+
+## What Every Agent Must Leave Behind
+
+Before finishing work on a project, verify:
+
+- [ ] `README.md` is accurate
+- [ ] Any changed architecture is documented in `ARCHITECTURE.md` and/or `docs/architecture/decisions/`
+- [ ] Any changed business logic is documented in `BUSINESS.md` or `docs/business/`
+- [ ] Any new API endpoints are documented in `API.md` or `docs/engineering/api.md`
+- [ ] Any changed database schema is documented in `DATABASE.md` or `docs/engineering/database.md`
+- [ ] Security-relevant changes are flagged in `SECURITY.md`
+- [ ] `CHANGELOG.md` or `docs/changelog/` reflects the change
+- [ ] New dependencies are justified in an ADR or comment
+
+---
+
+## Skill Metadata
+
+Every skill in `skills/` includes a metadata header:
+
+```yaml
+skill:
+  name: skill-name
+  version: 1.0.0
+  compatible:
+    project_skills: ">=1.0"
+  requires:
+    - discovery
+  outputs:
+    - some-document.md
+```
+
+The orchestrator uses this metadata for skill selection and compatibility checking.
+
+---
+
+## Discovery
+
+The repository is discoverable from GitHub. An agent that finds this repository can:
+
+1. Clone or inspect it
+2. Read `AGENTS.md` (this file)
+3. Read `skills/00-orchestrator/SKILL.md`
+4. Use the skills to work on any project
+
+No installation, no setup, no configuration required. Just clone and read.
+
+---
+
+## Contributing
+
+See `CONTRIBUTING.md` for how to add skills, stack adapters, framework adapters, templates, and examples.
+
+---
+
+## License
+
+MIT — see `LICENSE`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agent Blueprint Contributors
+
+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/PROMPT.md

@@ -0,0 +1,22 @@
+# Agent Blueprint — Universal System Prompt
+
+*Copy and paste this prompt into your AI agent's system prompt (Cursor Settings, Claude Project Instructions, ChatGPT Custom Instructions, or GitHub Copilot rules):*
+
+```markdown
+You are an expert software architect and engineering pair programmer operating under the **Agent Blueprint** standard (https://github.com/botdigit-official/agent-blueprint).
+
+YOUR CORE OPERATING DIRECTIVES:
+1. ADAPT TO THE PROJECT: Never force a project to adapt to your preferences. Inspect existing technology, frameworks, conventions, and style before proposing or writing code.
+2. INSPECT BEFORE MODIFYING: Always read existing files, dependencies (e.g., Cargo.toml, package.json, go.mod), and documentation (docs/) before making changes.
+3. PREFER SIMPLE ARCHITECTURE: Do not introduce microservices, new libraries, or complex abstractions without a measurable justification.
+4. BUSINESS LOGIC FIRST: Understand the business domain, actors, and state machines before touching code.
+5. PRESERVE WORKING SYSTEMS: Never rewrite working systems without explicit instruction. Maintain backwards compatibility and regression safety.
+6. LIVING DOCUMENTATION: Whenever you modify system behavior, architecture, or APIs, you MUST update the corresponding documentation in `docs/` and record an ADR if an architectural decision was made.
+7. TEST EVERYTHING: Every feature, fix, or refactor must include automated unit/integration tests that verify functionality.
+8. DETERMINISTIC TOOLS OVER AI: Use deterministic logic, SQL queries, and regex where possible; only use LLM reasoning where dynamic human-like comprehension adds unique value.
+
+When starting in any codebase:
+Step 1: Check if `AGENTS.md` or `docs/` exists.
+Step 2: Detect the tech stack and understand the business domain.
+Step 3: State your findings and plan before modifying code.
+```

package/README.md

@@ -0,0 +1,248 @@
+<div align="center">
+
+# 📐 Agent Blueprint
+
+**The universal blueprint and skill standard for AI coding agents — teaching agents how to think, audit, architect, and properly document any software project.**
+
+[![CI](https://github.com/botdigit-official/agent-blueprint/actions/workflows/ci.yml/badge.svg)](https://github.com/botdigit-official/agent-blueprint/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
+[![Agents](https://img.shields.io/badge/Agents-Antigravity%20%7C%20Claude%20Code%20%7C%20Cursor%20%7C%20Windsurf%20%7C%20Cline-orange)](#)
+[![GitHub Stars](https://img.shields.io/github/stars/botdigit-official/agent-blueprint?style=social)](https://github.com/botdigit-official/agent-blueprint)
+
+<br/>
+
+> *"The agent must adapt to the project. The project must not be forced to adapt to the skill."*
+
+</div>
+
+---
+
+## ⚡ 1-Minute Quickstart
+
+Install **Agent Blueprint** into any project with your preferred method:
+
+### Option A: One-Liner (Recommended)
+```bash
+curl -fsSL https://raw.githubusercontent.com/botdigit-official/agent-blueprint/main/install.sh | bash
+```
+
+### Option B: Via npx / Node
+```bash
+npx agent-blueprint init
+```
+
+### Option C: Git Clone
+```bash
+git clone --depth 1 https://github.com/botdigit-official/agent-blueprint.git ~/.agent-blueprint
+~/.agent-blueprint/install.sh .
+```
+
+### 🤖 Multi-Agent Compatibility Out of the Box
+| AI Tool | Configuration File Generated | Workflow Activated |
+|---|---|---|
+| **Google Antigravity** | `AGENTS.md` + `.agents/skills/` | Full modular skill hierarchy |
+| **Claude Code** | `CLAUDE.md` | Context & architecture guardrails |
+| **Cursor AI** | `.cursorrules` | Architectural & testing rules |
+| **Windsurf / Cline / Aider** | `AGENTS.md` | Autonomous discovery & audit |
+
+---
+
+## What is Agent Blueprint?
+
+Most AI coding agents jump straight to generating code or rewriting working systems without understanding the domain, architecture, dependencies, or conventions.
+
+**Agent Blueprint** is a composable, technology-agnostic skill and documentation standard. It provides structured guidance so any AI agent can:
+
+1. **Discover** the project layout and entry points across the repo
+2. **Understand** its stack, framework, database, and maturity
+3. **Audit** what exists before modifying or breaking anything
+4. **Document** findings into living, structured architectural documentation
+5. **Architect** changes grounded in real business needs, not guesswork
+6. **Plan** features with Architectural Decision Records (ADRs)
+7. **Implement** following existing patterns and conventions
+8. **Test & Verify** to preserve regression safety and data integrity
+9. **Review & Audit** against security and performance baselines
+
+> 🤖 **Direct LLM Ingestion**: Feed [**`llms.txt`**](llms.txt) to web crawlers/agents or copy the 1-click system prompt in [**`PROMPT.md`**](PROMPT.md).
+
+---
+
+## ⚖️ Why You Need This: Raw AI vs. Agent Blueprint
+
+| Scenario | Raw AI / Default Copilot | With Agent Blueprint |
+|---|---|---|
+| **Entering a project** | Guesses architecture, invents new dependencies | Runs discovery, detects existing stack, checks `docs/` |
+| **Refactoring code** | Often rewrites working systems and breaks logic | Obeys established ADRs, respects existing state machines |
+| **Documentation** | Leaves zero comments and zero docs | Automatically updates `docs/` living documentation |
+| **New Features** | Injects unverified patterns | Writes automated tests, updates API specs |
+| **Multi-Agent Teams** | Claude Code, Cursor, and Antigravity fight | All agents share a single source of truth |
+
+---
+
+## Core Philosophy
+
+These rules live at the top of every skill and guide every agent decision:
+
+1. **Understand before changing.**
+2. **Inspect before assuming.**
+3. **Document before redesigning.**
+4. **Prefer simple architecture.**
+5. **Use the project's existing technology when practical.**
+6. **Do not introduce technology without a measurable reason.**
+7. **Business logic comes before code structure.**
+8. **Security and data integrity come before features.**
+9. **Deterministic tools before AI.**
+10. **AI only where reasoning adds value.**
+11. **APIs only where they provide unique value.**
+12. **Never rewrite working systems unnecessarily.**
+13. **Preserve existing functionality unless explicitly deprecated.**
+14. **Every architectural decision needs a reason (ADR).**
+15. **Every major change needs automated tests.**
+16. **Every project needs a source of truth.**
+17. **Every agent must leave the project better documented than it found it.**
+
+---
+
+## How It Works
+
+### Composable Skills, Not a Giant System Prompt
+
+Agent Blueprint is **not** a single unwieldy prompt. It is a directory of modular, composable skills. The autonomous orchestrator selects only what applies to the current project:
+
+```
+skills/
+├── 00-orchestrator/           # Triage, detect, activate
+├── 01-discovery/              # Find project roots in monorepos or nested dirs
+├── 02-project-context/        # Stack, framework, database, infrastructure
+├── 03-business-architecture/  # Domain, actors, business rules, workflows
+├── 04-architecture/           # Architectural review, ADRs, gaps
+├── 05-documentation/          # Living documentation standard
+├── 06-codebase-audit/         # Code-level inspection and hygiene
+├── 07-security/               # Security review, secrets, CSRF, auth audit
+├── 08-testing/                # Test strategy, coverage, regression suite
+├── 09-performance/            # Latency, queries, throughput, bottlenecks
+└── 10-audit/                  # Combined forensic audit workflow
+```
+
+Stack & framework adapters activate automatically based on detected project manifests (`Cargo.toml`, `package.json`, `pyproject.toml`, `go.mod`, `pom.xml`, etc.):
+
+```
+stacks/                frameworks/
+├── rust/              ├── axum/
+├── typescript/        ├── nextjs/
+├── python/            ├── react/
+├── go/                ├── fastapi/
+├── php/               ├── django/
+├── java/              ├── laravel/
+├── ruby/              ├── spring/
+└── dotnet/            └── rails/
+```
+
+### Minimum Sufficient Documentation
+
+Not every project needs 50 documents. Agent Blueprint selects the minimum documentation set appropriate to the project's size and risk:
+
+| Project Scope | Required Documentation Baseline |
+|---|---|
+| **Script / CLI Tool** | `README.md` only |
+| **Web App / API** | Project Brief, Architecture, Database, API Spec, Security |
+| **SaaS / Marketplace** | + Business Architecture, Testing, Deployment, Runbook |
+| **Regulated / Enterprise** | + Compliance, Audit Trail, Data Governance, Disaster Recovery |
+
+---
+
+## Repository Structure
+
+```
+agent-blueprint/
+├── README.md                  # Project overview & quickstart
+├── AGENTS.md                  # Primary instruction manual for coding agents
+├── CONTRIBUTING.md            # Guidelines for community skill additions
+├── LICENSE                    # MIT License
+├── install.sh                 # 1-click project linker & installer
+│
+├── skills/                    # Core, technology-independent skills
+│   ├── 00-orchestrator/
+│   ├── 01-discovery/
+│   ├── 02-project-context/
+│   ├── 03-business-architecture/
+│   ├── 04-architecture/
+│   ├── 05-documentation/
+│   ├── 06-codebase-audit/
+│   ├── 07-security/
+│   ├── 08-testing/
+│   ├── 09-performance/
+│   └── 10-audit/
+│
+├── stacks/                    # Technology adapters (Rust, TS, Python, Go, etc.)
+├── frameworks/                # Framework adapters (Next.js, Axum, FastAPI, etc.)
+│
+├── templates/                 # Production-grade documentation templates
+│   ├── project-brief/         # Initial scoping & objectives
+│   ├── business-requirements/ # Domain entities & actor rules
+│   ├── architecture/          # System design & component diagrams
+│   ├── adr/                   # Architecture Decision Records
+│   ├── api-spec/              # REST / GraphQL API contracts
+│   ├── database/              # Schema, migrations & relationships
+│   ├── security/              # Threat models & access controls
+│   ├── testing/               # Quality gates & verification plans
+│   ├── deployment/            # CI/CD pipelines & hosting
+│   ├── runbook/               # Incident response & operational SOPs
+│   └── changelog/             # Semantic version releases
+│
+└── examples/                  # Real-world audits & walkthroughs
+    ├── botdigit-site/         # Multi-tenant directory & site builder
+    ├── saas/                  # Multi-tier subscription platform
+    ├── marketplace/           # Two-sided buyer/seller marketplace
+    ├── fintech/               # High-security payment processing
+    ├── ecommerce/             # Catalog, cart, and order fulfillment
+    ├── directory/             # Geo-spatial search & discovery
+    ├── mobile-app/            # Cross-platform iOS/Android app
+    ├── ai-product/            # LLM agents & deterministic pipelines
+    └── internal-tool/         # Backoffice admin control panels
+```
+
+---
+
+## Quick Start
+
+### For AI Coding Agents
+Read [`AGENTS.md`](AGENTS.md) first. It specifies the step-by-step discovery, inspection, and execution lifecycle.
+
+### For Developers & Tech Leads
+1. Browse [`skills/`](skills/) to understand the reasoning frameworks.
+2. Check [`templates/`](templates/) for ready-to-use architecture and documentation templates.
+3. Review [`examples/botdigit-site/`](examples/botdigit-site/) to see a real forensic audit and remediation.
+
+---
+
+## Contributing
+
+We welcome contributions! You can add new technology stacks, framework adapters, or domain patterns:
+1. Review [`CONTRIBUTING.md`](CONTRIBUTING.md).
+2. Follow the metadata schema in `skills/00-orchestrator/SKILL.md`.
+3. Submit a Pull Request.
+
+---
+
+## Frequently Asked Questions (FAQ)
+
+### How does Agent Blueprint prevent AI from breaking existing code?
+Agent Blueprint enforces a strict rule: **"The agent must adapt to the project; the project must not adapt to the skill."** Before an agent is allowed to write or edit code, it must execute Discovery, inspect existing frameworks, review active state machines, and check existing unit tests.
+
+### Does this work with Cursor, Claude Code, and Antigravity?
+**Yes.** When you run `./install.sh` or `npx agent-blueprint init`, it automatically creates `.cursorrules` (for Cursor), `CLAUDE.md` (for Claude Code), and `AGENTS.md` + `.agents/skills/` (for Antigravity, Cline, Windsurf). All agents follow the exact same architectural guidelines.
+
+### What is "Living Documentation"?
+Instead of outdated wikis or empty READMEs, Agent Blueprint establishes a structured `docs/` hierarchy (Business Model, Architecture Decision Records, Database Schemas, API Specs, Security). Every time an agent modifies system behavior, it is required to update the corresponding document.
+
+### How is this different from a system prompt?
+A single giant prompt gets truncated and forgotten in long context windows. Agent Blueprint is a **modular, composable skill hierarchy**. The autonomous orchestrator activates only the skills required for the specific task at hand.
+
+---
+
+## License
+
+MIT © [BotDigit](https://botdigit.com) — see [LICENSE](LICENSE).
+

package/bin/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const REPO_URL = 'https://github.com/botdigit-official/agent-blueprint.git';
+const HOME_DIR = process.env.HOME || process.env.USERPROFILE;
+const CACHE_DIR = path.join(HOME_DIR, '.agent-blueprint');
+
+function printBanner() {
+  console.log('\x1b[36m=====================================================\x1b[0m');
+  console.log('\x1b[1m\x1b[33m  📐 Agent Blueprint — AI Agent Skills & Standards\x1b[0m');
+  console.log('  https://github.com/botdigit-official/agent-blueprint');
+  console.log('\x1b[36m=====================================================\x1b[0m\n');
+}
+
+function ensureCache() {
+  if (fs.existsSync(path.join(CACHE_DIR, '.git'))) {
+    try {
+      console.log('🔄 Fetching latest Agent Blueprint skills from GitHub...');
+      execSync('git pull --quiet origin main', { cwd: CACHE_DIR, stdio: 'ignore' });
+    } catch (_) {}
+  } else {
+    console.log('📥 Cloning Agent Blueprint into ~/.agent-blueprint...');
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    execSync(`git clone --depth 1 ${REPO_URL} "${CACHE_DIR}" --quiet`, { stdio: 'inherit' });
+  }
+}
+
+function cmdInit(targetDir = process.cwd(), tier = '3') {
+  printBanner();
+  ensureCache();
+
+  const fullTarget = path.resolve(targetDir);
+  console.log(`🎯 Initializing Agent Blueprint in: ${fullTarget}`);
+
+  // 1. Create .agents/skills and link skills
+  const destSkills = path.join(fullTarget, '.agents', 'skills');
+  fs.mkdirSync(destSkills, { recursive: true });
+
+  const srcSkills = path.join(CACHE_DIR, 'skills');
+  if (fs.existsSync(srcSkills)) {
+    const skills = fs.readdirSync(srcSkills);
+    for (const skill of skills) {
+      const srcSkillPath = path.join(srcSkills, skill);
+      const destSkillPath = path.join(destSkills, skill);
+      if (fs.statSync(srcSkillPath).isDirectory()) {
+        try {
+          if (fs.existsSync(destSkillPath)) fs.rmSync(destSkillPath, { recursive: true, force: true });
+          fs.symlinkSync(srcSkillPath, destSkillPath, 'dir');
+        } catch (_) {
+          fs.cpSync(srcSkillPath, destSkillPath, { recursive: true });
+        }
+      }
+    }
+  }
+
+  // 2. Generate AGENTS.md
+  const agentsMdSrc = path.join(CACHE_DIR, 'AGENTS.md');
+  const agentsMdDest = path.join(fullTarget, 'AGENTS.md');
+  if (!fs.existsSync(agentsMdDest) && fs.existsSync(agentsMdSrc)) {
+    fs.copyFileSync(agentsMdSrc, agentsMdDest);
+    console.log('✅ Generated AGENTS.md (for Antigravity, Cline, Windsurf)');
+  }
+
+  // 3. Generate CLAUDE.md (for Claude Code)
+  const claudeMdDest = path.join(fullTarget, 'CLAUDE.md');
+  if (!fs.existsSync(claudeMdDest)) {
+    const claudeContent = `# CLAUDE.md — Agent Blueprint for Claude Code
+
+This project adheres to **Agent Blueprint** (https://github.com/botdigit-official/agent-blueprint).
+
+## Core Rule
+> The agent must adapt to the project. The project must not be forced to adapt to the skill.
+
+## Required Lifecycle
+1. Inspect before modifying: Check \`docs/\` and existing codebase structure.
+2. Respect existing architecture, dependencies, and business state machines.
+3. Every significant change must include automated tests and update \`docs/\`.
+
+Refer to \`AGENTS.md\` and \`.agents/skills/\` for complete architectural guides.
+`;
+    fs.writeFileSync(claudeMdDest, claudeContent, 'utf8');
+    console.log('✅ Generated CLAUDE.md (for Anthropic Claude Code)');
+  }
+
+  // 4. Generate .cursorrules (for Cursor)
+  const cursorRulesDest = path.join(fullTarget, '.cursorrules');
+  if (!fs.existsSync(cursorRulesDest)) {
+    const cursorContent = `# .cursorrules — Agent Blueprint for Cursor
+
+You are working in a repository managed under Agent Blueprint standards.
+
+RULES:
+1. Always inspect existing code, dependencies, and tests before writing or editing code.
+2. Never invent or introduce unapproved external libraries without measurable justification.
+3. Keep living documentation in 'docs/' in sync with your code changes.
+4. Run existing test suites after every modification.
+5. Refer to AGENTS.md and .agents/skills/ for the canonical skill workflow.
+`;
+    fs.writeFileSync(cursorRulesDest, cursorContent, 'utf8');
+    console.log('✅ Generated .cursorrules (for Cursor AI)');
+  }
+
+  // 5. Scaffold docs/ structure according to Tier
+  const docsDir = path.join(fullTarget, 'docs');
+  fs.mkdirSync(path.join(docsDir, '00-project'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '01-business'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '02-architecture'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '03-engineering'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '04-security'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '05-testing'), { recursive: true });
+  fs.mkdirSync(path.join(docsDir, '08-operations'), { recursive: true });
+
+  console.log('✅ Scaffolded living documentation structure in docs/\n');
+  console.log('🎉 Setup complete! All AI tools (Antigravity, Claude Code, Cursor, Windsurf) are now aligned.');
+  console.log("👉 Tell your agent: 'Read AGENTS.md and start discovery'.\n");
+}
+
+function cmdUpdate() {
+  printBanner();
+  ensureCache();
+  console.log('🔄 Pulling latest Agent Blueprint skills...');
+  try {
+    execSync('git pull origin main', { cwd: CACHE_DIR, stdio: 'inherit' });
+    console.log('✅ All skills successfully updated to the latest GitHub release.');
+  } catch (err) {
+    console.error('❌ Failed to update skills:', err.message);
+  }
+}
+
+function cmdStatus() {
+  printBanner();
+  if (fs.existsSync(path.join(CACHE_DIR, '.git'))) {
+    const commit = execSync('git log -1 --oneline', { cwd: CACHE_DIR }).toString().trim();
+    console.log(`📍 Local Cache: ${CACHE_DIR}`);
+    console.log(`📌 Latest Commit: ${commit}`);
+  } else {
+    console.log('⚠️ Agent Blueprint cache is not yet installed. Run "agent-blueprint init".');
+  }
+}
+
+const args = process.argv.slice(2);
+const command = args[0] || 'init';
+
+switch (command) {
+  case 'init':
+    cmdInit(args[1]);
+    break;
+  case 'update':
+    cmdUpdate();
+    break;
+  case 'status':
+    cmdStatus();
+    break;
+  default:
+    console.log('Usage: agent-blueprint [init | update | status]');
+    process.exit(1);
+}