markus/c-stone-invoice-check
1
0
Fork 0
Code Issues Pull requests Projects 1 Releases Packages Wiki Activity Actions

chore: Projektinitialisierung — C-Stone Invoice Check (SaaS-App)

Browse source
This commit is contained in:
Markus Kruse 2026-07-24 15:02:44 +02:00
commit e45fae43ac
1867 changed files with 243740 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
.claude/knowledge-base.md Normal file
View file

@ -0,0 +1,55 @@
# Knowledge Base — C-Stone Invoice Check
## Stack-Entscheidung
**FastAPI + PostgreSQL + React** gewählt weil:
- SaaS-Architektur für langfristige Erweiterbarkeit
- FastAPI: Async, automatische OpenAPI-Dokumentation
- PostgreSQL: Zuverlässige Datenpersistenz für Rechnungsdaten
- React: Moderne Frontend-Entwicklung
**PyMuPDF** gewählt für PDF-Extraktion:
- Läuft vollständig lokal
- Keine Datenverlust Gefahr (DSGVO-konform)
- Schnell und zuverlässig für Text-Extraktion
- Gute Erkennung von Steuerangaben in Rechnungen
## DSGVO-Status
**nein** — Rechnungsdaten (Betrag,Datum,Absender) gelten nicht als personenbezogene Daten im Sinne der DSGVO
AWS Bedrock Region: eu-central-1 (Frankfurt) — Pflicht bei Bedrock-Nutzung
## Bekannte Fallstricke (C-Stone-Standard)
- SQLAlchemy Enum: Namen in GROSSBUCHSTABEN, nicht Values
- SeaTable: Zugriff NUR über Flask Microservice, nicht direkt über n8n
- .env NIEMALS committen, NIEMALS in Nextcloud-Sync
- IMAP-Authentifizierung: App-Passwords statt Hauptpasswort verwenden
## Ablauf-Logik
### Email-Filterung
1. IMAP-Verbindung zu Strato/Gmail aufbauen
2. Emails mit Stichworten filtern: "Rechnung", "Invoice", "Receipt"
3. Anhänge extrahieren (PDF/DOC)
4. PDF mit PyMuPDF scannen
5. Steuerangaben erkennen (Mehrwertsteuer, Umsatzsteuer, VAT)
6. Entscheidung: mit/ohne Steuer
### Dateiablage (Evo-X2)
```
Rechnungen/
├── 2025/
│ ├── mit MwSt/
│ └── ohne MwSt/
└── 2026/
├── mit MwSt/
└── ohne MwSt/
```
### Excel-Dokumentation
- Spalten: Datum, Rechnungsausteller, Betrag, Umsatzsteuer, Steuerart, Dateipfad
- Format: xlsx (Excel 2007+)
## Entscheidungen
- Automatische Speicherung (keine manuelle Bestätigung nötig)
- Nur speichern, keine Weiterleitung
- xlsx-Format für Excel-Tabelle

25
.claude/memory.md Normal file
View file

@ -0,0 +1,25 @@
# Memory — C-Stone Invoice Check
## Aktuelles Projekt: C-Stone Invoice Check
- **Typ:** SaaS-App
- **Gestartet:** 2026-07-24
- **DSGVO-relevant:** nein
- **Beschreibung:** Email-Filter für Rechnungen mit PDF-Scanning, lokale Ablage auf Evo-X2, Excel-Dokumentation
- **Stack:** FastAPI + PostgreSQL + React + PyMuPDF
- **Ablageort:** Evo-X2 ( lokales Laufwerk )
- **GitHub:** https://github.com/c-stone/c-stone-invoice-check
## Aktuelle Phase: 1 — Scope & Setup ✅ → Phase 2 — Architektur
## Offene Punkte:
- [ ] Architektur finalisieren (Phase 2)
- [ ] docker-compose.yml mit Traefik-Labels erstellen
- [ ] Datenbankschema in docs/schema.md entwerfen
## Mail-Provider Konfiguration
- Strato + Gmail (IMAP Zugriff)
- Evo-X2 als Ablageserver
## PDF-Verarbeitung
- PyMuPDF (fitz) für lokal laufende Text-Extraktion
- Keine Daten verlassen den Server

32
.env.example Normal file
View file

@ -0,0 +1,32 @@
# Datenbank
DATABASE_URL=postgresql://user:password@localhost:5432/invoice_check
REDIS_URL=redis://localhost:6379
# Auth
SECRET_KEY=your-secret-key-here
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30
# AWS Bedrock (DSGVO: eu-central-1)
AWS_ACCESS_KEY_ID=your-key-here
AWS_SECRET_ACCESS_KEY=your-secret-here
AWS_DEFAULT_REGION=eu-central-1
# Mail-Server (Strato + Gmail)
IMAP_HOST=imap.strato.de
IMAP_PORT=993
IMAP_USER=your-email@domain.de
IMAP_PASSWORD=your-app-password
# Gmail (optional, falls auch Gmail genutzt wird)
GMAIL_IMAP_HOST=imap.gmail.com
GMAIL_IMAP_PORT=993
GMAIL_IMAP_USER=your-email@gmail.com
GMAIL_IMAP_PASSWORD=your-app-password
# Ablageort (Evo-X2)
INVOICE_STORAGE_PATH=/Volumes/Evo-X2/Rechnungen
# App
ENVIRONMENT=development
PORT=8001

15
.gitignore vendored Normal file
View file

@ -0,0 +1,15 @@
.env
.env.*
!.env.example
*.pem
*.key
node_modules/
__pycache__/
*.pyc
.DS_Store
venv/
.venv/
dist/
build/
*.db
*.sqlite

12
.nextcloudignore Normal file
View file

@ -0,0 +1,12 @@
node_modules/
__pycache__/
.env
.env.*
*.pem
*.db
*.sqlite
venv/
.venv/
dist/
build/
.git/

48
README.md Normal file
View file

@ -0,0 +1,48 @@
# C-Stone Invoice Check
## Zweck
KI-gestütztes Email-Filter-System für Rechnungen mit automatischer PDF-Scanning, lokaler Ablage auf Evo-X2 und Excel-Dokumentation.
## Was das System macht
1. **Email-Filterung** per IMAP (Strato + Gmail) nach Stichworten: "Rechnung", "Invoice", "Receipt"
2. **Anhang-Extraktion** (PDF/DOC) aus erkannten Emails
3. **PDF-Scanning** mit PyMuPDF für Text-Extraktion
4. **Steuer-Erkennung**: Unterscheidung zwischen "mit MwSt" / "ohne MwSt" / "Umsatzsteuer" / "VAT"
5. **Lokale Ablage** auf Evo-X2:
```
Rechnungen/
├── 2025/
│ ├── mit MwSt/
│ └── ohne MwSt/
└── 2026/
├── mit MwSt/
└── ohne MwSt/
```
6. **Excel-Dokumentation** mit Spalten: Datum, Rechnungsausteller, Betrag, Umsatzsteuer, Steuerart, Dateipfad
## Voraussetzungen
```bash
pip3 install fastapi uvicorn python-dotenv sqlalchemy psycopg2-binary openpyxl pymupdf
```
## Konfiguration
1. `.env.example` nach `.env` kopieren
2. IMAP-Credentials für Strato/Gmail eintragen (App-Passwords verwenden!)
3. Ablagepfad auf Evo-X2 anpassen (`INVOICE_STORAGE_PATH`)
## Ablauf
1. System starten: `uvicorn backend.main:app --reload --port 8001`
2. Frontend öffnen: `http://localhost:5173`
3. IMAP-Verbindung wird periodisch geprüft
4. Neue Rechnungen werden automatisch verarbeitet und gespeichert
## DSGVO
- Alle Daten bleiben lokal auf Evo-X2
- Keine Datenverarbeitung in der Cloud
- PyMuPDF läuft vollständig lokal

48
Task Board.md Normal file
View file

@ -0,0 +1,48 @@
# Task Board — C-Stone Invoice Check
## 📋 Backlog
- [ ] Dockerfile.backend erstellen
- [ ] Dockerfile frontend (React/Vite) erstellen
- [ ] frontend/src/App.tsx erstellen
- [ ] frontend/src/main.tsx erstellen
- [ ] frontend/vite.config.ts konfigurieren
- [ ] frontend/package.json mit Dependencies
- [ ] .gitignore prüfen und anpassen
- [ ] .env.example mit echten Platzhaltern
- [ ] README.md mit Detaillierung erweitern
- [ ] Alembic Migration initialisieren
- [ ] pytest Setup mit conftest.py
## 🚀 Aktuell (Phase 2 — Architektur)
- [ ] docker-compose.yml mit Traefik-Labels erstellen
- [ ] Datenbankschema in docs/schema.md entwerfen (✅ erledigt)
- [ ] FastAPI Grundstruktur mit Health-Endpunkt (✅ erledigt)
- [ ] Backend Router implementieren (emails.py, invoices.py - ✅ erledigt)
- [ ] PDF-Scanning mit PyMuPDF implementieren (✅ erledigt)
- [ ] Excel-Export mit openpyxl implementieren (✅ erledigt)
- [ ] Frontend Grundstruktur (Vite + React)
- [ ] IMAP-Verbindung testen (Strato + Gmail)
- [ ] PDF-Verarbeitung lokal testen
- [ ] Evo-X2 Ablagepfad konfigurieren
## ✅ Erledigt
- [x] Projektordner angelegt
- [x] Base Project kopiert
- [x] SaaS-Struktur erstellt (backend/, frontend/, docs/)
- [x] requirements.txt mit Dependencies
- [x] docker-compose.yml erstellt
- [x] .env.example mit Platzhaltern
- [x] .gitignore und .nextcloudignore
- [x] README.md initialisiert
- [x] memory.md und knowledge-base.md
- [x] Database-Models (Invoice, EmailLog, InvoiceDetail, User)
- [x] Email Router (IMAP Search, Filterung)
- [x] Invoice Router (PDF-Scan, Tax-Detection, Excel-Export)
- [x] Datenbankschema dokumentiert (docs/schema.md)
## 🔒 Blockiert
-

1
backend/__init__.py Normal file
View file

@ -0,0 +1 @@
# Backend Package

96
backend/auth.py Normal file
View file

@ -0,0 +1,96 @@
"""
C-Stone Invoice Check — Authentifizierung
JWT-basierte Auth mit PyJWT
"""
import os
from datetime import datetime, timedelta
from typing import Optional
from jose import JWTError, jwt
from passlib.context import CryptContext
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from sqlalchemy.orm import Session
from sqlalchemy import Column, Integer, String, Boolean, DateTime
from backend.database import get_db
# Konfiguration
SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
# Hash-Kontext
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
# OAuth2
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
# Router
from fastapi import APIRouter
router = APIRouter()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
username = Column(String, unique=True, index=True)
hashed_password = Column(String)
is_active = Column(Boolean, default=True)
created_at = Column(DateTime, default=datetime.utcnow)
def verify_password(plain_password: str, hashed_password: str) -> bool:
"""Prüft Passwort gegen Hash"""
return pwd_context.verify(plain_password, hashed_password)
def get_password_hash(password: str) -> str:
"""Erstellt Hash aus Passwort"""
return pwd_context.hash(password)
def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
"""Erstellt JWT Token"""
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
def authenticate_user(db: Session, username: str, password: str) -> Optional[User]:
"""Authentifiziert Benutzer"""
user = db.query(User).filter(User.username == username).first()
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
async def get_current_user(
token: str = Depends(oauth2_scheme),
db: Session = Depends(get_db)
) -> User:
"""Holt aktuellen Benutzer aus Token"""
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
except JWTError:
raise credentials_exception
user = db.query(User).filter(User.username == username).first()
if user is None:
raise credentials_exception
return user

40
backend/database.py Normal file
View file

@ -0,0 +1,40 @@
"""
C-Stone Invoice Check — Datenbankkonfiguration
SQLAlchemy Engine und Session Management
"""
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
from dotenv import load_dotenv
# Load environment variables
load_dotenv()
DATABASE_URL = os.getenv(
"DATABASE_URL",
"postgresql://postgres:postgres@localhost:5432/invoice_check"
)
# Engine erstellen
engine = create_engine(
DATABASE_URL,
echo=False, # SQL-Logging (False für Production)
pool_pre_ping=True, # Verbindungs-Check
pool_size=10,
max_overflow=20
)
# Session
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# Base für Models
Base = declarative_base()
# Dependency für FastAPI
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()

61
backend/main.py Normal file
View file

@ -0,0 +1,61 @@
"""
C-Stone Invoice Check — Hauptanwendung
FastAPI Backend für Email-Filterung und Rechnungsverarbeitung
"""
from fastapi import FastAPI, Depends, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from sqlalchemy.orm import Session
from backend.database import get_db, engine, Base
from backend import auth
# Models importieren für Alembic
from backend.models import Invoice, InvoiceDetail
# Routers
from backend.routers import emails, invoices
# App erstellen
app = FastAPI(
title="C-Stone Invoice Check API",
description="Email-Filterung und Rechnungsverarbeitung",
version="1.0.0",
docs_url="/docs",
redoc_url="/redoc"
)
# CORS
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Health Check
@app.get("/health")
async def health_check(db: Session = Depends(get_db)):
"""Health Check Endpoint"""
try:
db.execute("SELECT 1")
return {"status": "healthy", "database": "connected"}
except Exception as e:
return {"status": "unhealthy", "database": "disconnected", "error": str(e)}
# Initialisierung
@app.on_event("startup")
async def startup_event():
"""Datenbank erstellen bei Start"""
Base.metadata.create_all(bind=engine)
# Router einbinden
app.include_router(auth.router, prefix="/auth", tags=["authentication"])
app.include_router(emails.router, prefix="/emails", tags=["emails"])
app.include_router(invoices.router, prefix="/invoices", tags=["invoices"])
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8001)

103
backend/models.py Normal file
View file

@ -0,0 +1,103 @@
"""
C-Stone Invoice Check — Datenbankmodelle
SQLAlchemy ORM Modelle für Rechnungen und Emails
"""
from datetime import datetime
from sqlalchemy import Column, Integer, String, DateTime, Float, Boolean, Text, JSON
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Invoice(Base):
"""
Tabelle: Rechnungen
Speichert die Metadaten jeder verarbeiteten Rechnung
"""
__tablename__ = "invoices"
id = Column(Integer, primary_key=True, index=True)
email_id = Column(String, index=True) # IMAP UID der Original-Email
email_subject = Column(String, nullable=True)
email_from = Column(String, nullable=True)
email_date = Column(DateTime, nullable=True)
# Rechnungsdaten
invoice_number = Column(String, index=True, nullable=True)
invoice_date = Column(DateTime, nullable=True)
invoice_amount = Column(Float, nullable=True)
invoice_tax_amount = Column(Float, nullable=True)
invoice_tax_rate = Column(Float, nullable=True) # z.B. 0, 0.19, 0.16
invoice_tax_type = Column(String, nullable=True) # "MwSt", "Umsatzsteuer", "VAT", "ohne"
# Absender/Empfänger
issuer_name = Column(String, nullable=True)
issuer_address = Column(Text, nullable=True)
# Dateipfad (Evo-X2)
file_path = Column(String, nullable=True)
file_name = Column(String, nullable=True)
storage_year = Column(Integer, nullable=True)
storage_path = Column(String, nullable=True) # z.B. "2025/ohne MwSt"
# Verarbeitungsstatus
processed = Column(Boolean, default=False)
processing_error = Column(Text, nullable=True)
confidence_score = Column(Float, nullable=True) # 0.0 - 1.0
created_at = Column(DateTime, default=datetime.utcnow)
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
def __repr__(self):
return f"<Invoice {self.invoice_number or 'unknown'}>"
class EmailLog(Base):
"""
Tabelle: Email Logs
Protokolliert jede verarbeitete Email
"""
__tablename__ = "email_logs"
id = Column(Integer, primary_key=True, index=True)
email_id = Column(String, unique=True, index=True) # IMAP UID
email_subject = Column(String, nullable=True)
email_from = Column(String, nullable=True)
email_date = Column(DateTime, nullable=True)
email_folder = Column(String, nullable=True) # z.B. "INBOX", "Gesendet"
# Filterergebnis
matched_keywords = Column(JSON, nullable=True) # Liste von Stichworten
has_attachment = Column(Boolean, default=False)
attachment_type = Column(String, nullable=True) # "pdf", "doc", "docx", "unknown"
# Verarbeitung
processed = Column(Boolean, default=False)
processing_result = Column(String, nullable=True) # "invoice_found", "not_an_invoice", "error"
invoice_id = Column(Integer, nullable=True) # Verweis auf Invoice-Tabelle
created_at = Column(DateTime, default=datetime.utcnow)
def __repr__(self):
return f"<EmailLog {self.email_id}>"
class InvoiceDetail(Base):
"""
Tabelle: Rechnungsdetails (erweiterte Informationen)
Speichert JSON-basierte erweiterte Daten
"""
__tablename__ = "invoice_details"
id = Column(Integer, primary_key=True, index=True)
invoice_id = Column(Integer, nullable=False, index=True)
raw_text = Column(Text, nullable=True) # Extrahierter PDF-Text
parsed_data = Column(JSON, nullable=True) # Geparste Daten als JSON
confidence_breakdown = Column(JSON, nullable=True) # Einzelne Confidence-Scores
processing_notes = Column(Text, nullable=True)
created_at = Column(DateTime, default=datetime.utcnow)
def __repr__(self):
return f"<InvoiceDetail {self.invoice_id}>"

26
backend/requirements.txt Normal file
View file

@ -0,0 +1,26 @@
# FastAPI und Server
fastapi==0.115.0
uvicorn[standard]==0.30.0
python-multipart==0.0.9
# Datenbank
sqlalchemy==2.0.32
psycopg2-binary==2.9.9
alembic==1.13.1
# Authentifizierung
python-jose[cryptography]==3.3.0
passlib[bcrypt]==1.7.4
# PDF-Verarbeitung (PyMuPDF - lokal laufend)
pymupdf==1.24.10
# Excel-Verarbeitung
openpyxl==3.1.5
# Mail (IMAP)
imaplib2==3.5
# Allgemein
python-dotenv==1.0.1
boto3==1.35.0

1
backend/routers/__init__.py Normal file
View file

@ -0,0 +1 @@
# Router Package

268
backend/routers/emails.py Normal file
View file

@ -0,0 +1,268 @@
"""
C-Stone Invoice Check — Email Router
IMAP Email-Verarbeitung und Filterung
"""
import imaplib
import email
import os
from datetime import datetime
from typing import List, Optional, Dict, Any
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from email.header import decode_header
from backend.database import get_db
from backend.models import EmailLog, Invoice
router = APIRouter()
# IMAP Konfiguration
IMAP_HOST = os.getenv("IMAP_HOST", "imap.strato.de")
IMAP_PORT = int(os.getenv("IMAP_PORT", 993))
IMAP_USER = os.getenv("IMAP_USER", "")
IMAP_PASSWORD = os.getenv("IMAP_PASSWORD", "")
# Gmail Konfiguration
GMAIL_IMAP_HOST = os.getenv("GMAIL_IMAP_HOST", "imap.gmail.com")
GMAIL_IMAP_PORT = int(os.getenv("GMAIL_IMAP_PORT", 993))
GMAIL_IMAP_USER = os.getenv("GMAIL_IMAP_USER", "")
GMAIL_IMAP_PASSWORD = os.getenv("GMAIL_IMAP_PASSWORD", "")
# Filter-Kriterien
INVOICE_KEYWORDS = ["rechnung", "invoice", "receipt", "bill", "factuur"]
def connect_imap(host: str, port: int, user: str, password: str) -> imaplib.IMAP4_SSL:
"""Verbindet mit IMAP-Server"""
mail = imaplib.IMAP4_SSL(host, port)
mail.login(user, password)
return mail
def search_invoices(mail: imaplib.IMAP4_SSL, folder: str = "INBOX") -> List[str]:
"""Sucht nach Emails mit Rechnungs-Stichworten"""
mail.select(folder)
result, data = mail.search(None, 'ALL')
if result != "OK":
return []
email_ids = data[0].split()
matching_ids = []
for email_id in email_ids:
result, msg_data = mail.fetch(email_id, '(RFC822)')
if result != "OK":
continue
msg = email.message_from_bytes(msg_data[0][1])
subject = msg.get("Subject", "")
from_addr = msg.get("From", "")
# Subject decodieren
decoded_subject, encoding = decode_header(subject)[0]
if isinstance(decoded_subject, bytes):
subject = decoded_subject.decode(encoding or "utf-8")
# Prüfen auf Keywords
subject_lower = subject.lower()
if any(kw in subject_lower for kw in INVOICE_KEYWORDS):
matching_ids.append(email_id.decode())
return matching_ids
def extract_attachments(msg: email.message.Message) -> List[Dict[str, Any]]:
"""Extrahiert Anhänge aus Email"""
attachments = []
for part in msg.walk():
if part.get_content_maintype() == 'multipart':
continue
if part.get('Content-Disposition') is None:
continue
filename = part.get_filename()
if filename:
decoded_filename, encoding = decode_header(filename)[0]
if isinstance(decoded_filename, bytes):
filename = decoded_filename.decode(encoding or "utf-8")
content_type = part.get_content_type()
payload = part.get_payload(decode=True)
attachments.append({
"filename": filename,
"content_type": content_type,
"data": payload,
"size": len(payload) if payload else 0
})
return attachments
@router.get("/search")
async def search_emails(db: Session = Depends(get_db)):
"""Sucht nach Rechnungs-Emails bei Strato"""
results = {
"processed": 0,
"invoices_found": 0,
"errors": []
}
try:
mail = connect_imap(IMAP_HOST, IMAP_PORT, IMAP_USER, IMAP_PASSWORD)
# Alle Ordner durchsuchen
for folder in ["INBOX", "Sent", "Gesendet"]:
try:
email_ids = search_invoices(mail, folder)
results[f"{folder}_count"] = len(email_ids)
for email_id in email_ids:
# Verarbeitung auslagern
pass
except Exception as e:
results["errors"].append(f"Folder {folder}: {str(e)}")
mail.logout()
results["processed"] = len(email_ids) if 'email_ids' in dir() else 0
except Exception as e:
results["errors"].append(f"IMAP Connection failed: {str(e)}")
return results
@router.get("/process/{email_id}")
async def process_email(email_id: str, db: Session = Depends(get_db)):
"""Verarbeitet einzelne Email"""
# TODO: Implementierung
pass
@router.get("/scan-all")
async def scan_all_emails(db: Session = Depends(get_db)):
"""Scant alle Emails auf Rechnungen"""
results = {
"start_time": datetime.utcnow().isoformat(),
"processed": 0,
"invoices_found": 0,
"errors": []
}
# Strato Mail
try:
mail = connect_imap(IMAP_HOST, IMAP_PORT, IMAP_USER, IMAP_PASSWORD)
mail.select("INBOX")
result, data = mail.search(None, 'ALL')
if result == "OK":
email_ids = data[0].split()
for email_id in email_ids:
email_id_str = email_id.decode()
log_entry = db.query(EmailLog).filter(EmailLog.email_id == email_id_str).first()
if log_entry:
continue # Bereits verarbeitet
result, msg_data = mail.fetch(email_id, '(RFC822)')
if result != "OK":
continue
msg = email.message_from_bytes(msg_data[0][1])
subject = msg.get("Subject", "")
from_addr = msg.get("From", "")
date = msg.get("Date", "")
# Subject decodieren
decoded_subject, encoding = decode_header(subject)[0]
if isinstance(decoded_subject, bytes):
subject = decoded_subject.decode(encoding or "utf-8")
# Prüfen auf Keywords
subject_lower = subject.lower()
matched_keywords = [kw for kw in INVOICE_KEYWORDS if kw in subject_lower]
if matched_keywords:
# Email als Rechnung markieren
log_entry = EmailLog(
email_id=email_id_str,
email_subject=subject,
email_from=from_addr,
email_date=date,
email_folder="INBOX",
matched_keywords=matched_keywords,
has_attachment=True,
processed=False
)
db.add(log_entry)
results["invoices_found"] += 1
results["processed"] += 1
db.commit()
mail.logout()
except Exception as e:
results["errors"].append(f"Strato scan failed: {str(e)}")
# Gmail Mail (optional)
if GMAIL_IMAP_USER and GMAIL_IMAP_PASSWORD:
try:
mail = connect_imap(GMAIL_IMAP_HOST, GMAIL_IMAP_PORT, GMAIL_IMAP_USER, GMAIL_IMAP_PASSWORD)
mail.select("INBOX")
result, data = mail.search(None, 'ALL')
if result == "OK":
email_ids = data[0].split()
for email_id in email_ids:
email_id_str = email_id.decode()
log_entry = db.query(EmailLog).filter(EmailLog.email_id == email_id_str).first()
if log_entry:
continue
result, msg_data = mail.fetch(email_id, '(RFC822)')
if result != "OK":
continue
msg = email.message_from_bytes(msg_data[0][1])
subject = msg.get("Subject", "")
from_addr = msg.get("From", "")
decoded_subject, encoding = decode_header(subject)[0]
if isinstance(decoded_subject, bytes):
subject = decoded_subject.decode(encoding or "utf-8")
subject_lower = subject.lower()
matched_keywords = [kw for kw in INVOICE_KEYWORDS if kw in subject_lower]
if matched_keywords:
log_entry = EmailLog(
email_id=email_id_str,
email_subject=subject,
email_from=from_addr,
email_date=datetime.utcnow().isoformat(),
email_folder="INBOX",
matched_keywords=matched_keywords,
has_attachment=True,
processed=False
)
db.add(log_entry)
results["invoices_found"] += 1
results["processed"] += 1
db.commit()
mail.logout()
except Exception as e:
results["errors"].append(f"Gmail scan failed: {str(e)}")
results["end_time"] = datetime.utcnow().isoformat()
return results

310
backend/routers/invoices.py Normal file
View file

@ -0,0 +1,310 @@
"""
C-Stone Invoice Check — Invoice Router
Rechnungs-Verarbeitung und Speicherung
"""
import os
import fitz # PyMuPDF
import re
from datetime import datetime
from typing import List, Optional, Dict, Any
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
from sqlalchemy.orm import Session
from openpyxl import Workbook
from openpyxl.styles import Font, Alignment, Border, Side
from backend.database import get_db
from backend.models import Invoice, InvoiceDetail, EmailLog
router = APIRouter()
# Ablagepfad (Evo-X2)
INVOICE_STORAGE_PATH = os.getenv("INVOICE_STORAGE_PATH", "/Volumes/Evo-X2/Rechnungen")
# Steuer-Schlüsselwörter
TAX_KEYWORDS = {
"mit_mwst": ["mwst", "mehrwertsteuer", "steuer", "incl. mwst", "zzgl. mwst"],
"ohne_mwst": ["zzgl. steuer", "exkl. steuer", "steuerfrei", "steuerbefreit"],
"umsatzsteuer": ["umsatzsteuer", "ust", "ust-id"],
"vat": ["vat", "v.a.t.", "value added tax"],
}
def detect_tax_type(text: str) -> Dict[str, Any]:
"""Erkennt Steuer-Art aus PDF-Text"""
text_lower = text.lower()
# Prüfen auf "mit MwSt"
if any(kw in text_lower for kw in TAX_KEYWORDS["mit_mwst"]):
# Prüfen auf Satz: z.B. "inkl. 19 % MwSt"
match = re.search(r'(?:inkl|zzgl)[\s\-]*(?:der)?[\s\-]*(\d+)[\s\-]*%[\s\-]*(?:mwst|steuer)', text_lower)
if match:
tax_rate = float(match.group(1)) / 100
return {
"tax_type": "mit MwSt",
"tax_rate": tax_rate,
"confidence": 0.9,
"found_keyword": match.group(0)
}
# Prüfen auf "ohne MwSt"
if any(kw in text_lower for kw in TAX_KEYWORDS["ohne_mwst"]):
return {
"tax_type": "ohne MwSt",
"tax_rate": 0.0,
"confidence": 0.85,
"found_keyword": next(kw for kw in TAX_KEYWORDS["ohne_mwst"] if kw in text_lower)
}
# Prüfen auf Umsatzsteuer
if any(kw in text_lower for kw in TAX_KEYWORDS["umsatzsteuer"]):
return {
"tax_type": "Umsatzsteuer",
"tax_rate": 0.19, # Standard
"confidence": 0.7,
"found_keyword": next(kw for kw in TAX_KEYWORDS["umsatzsteuer"] if kw in text_lower)
}
# Prüfen auf VAT (europäische Steuer)
if any(kw in text_lower for kw in TAX_KEYWORDS["vat"]):
return {
"tax_type": "VAT",
"tax_rate": 0.19, # Standard EU
"confidence": 0.7,
"found_keyword": next(kw for kw in TAX_KEYWORDS["vat"] if kw in text_lower)
}
# Standard: Prüfen auf Steuerangabe im Text
tax_matches = re.findall(r'(\d+)[\s\-]*%[\s\-]*(?:steuer|mwst|ust|vat)', text_lower)
if tax_matches:
tax_rate = float(tax_matches[0]) / 100
return {
"tax_type": "mit Steuer",
"tax_rate": tax_rate,
"confidence": 0.6,
"found_keyword": f"{tax_matches[0]}%"
}
# Keine Steuer erkannt
return {
"tax_type": "unbekannt",
"tax_rate": None,
"confidence": 0.3,
"found_keyword": None
}
def extract_amount(text: str) -> Optional[float]:
"""Extrahiert Betrag aus PDF-Text"""
# Muster: "Summe: 123,45 €" oder "Total: 123.45 EUR"
patterns = [
r'(?:summe|total|betrag)[\s:]*([\d\.]+[\s\,]\d{2})\s*€?',
r'([\d\.]+[\s\,]\d{2})\s*(?:€|EUR|EUR\*)',
r'(?:zu\s+bezahlen|gesamt)[\s:]*([\d\.]+[\s\,]\d{2})',
]
for pattern in patterns:
match = re.search(pattern, text.lower())
if match:
amount_str = match.group(1)
# Komma zu Punkt für float
amount_str = amount_str.replace('.', '').replace(',', '.')
try:
return float(amount_str)
except ValueError:
continue
return None
def extract_invoice_number(text: str) -> Optional[str]:
"""Extrahiert Rechnungsnummer aus PDF-Text"""
patterns = [
r'(?:rechnungs)?nr\.?\s*[:\s]*([A-Za-z0-9\-/]+)',
r'(?:invoice|rechnung)?[\s_]*(?:no\.?|#)?\s*[:\s]*([A-Za-z0-9\-/]+)',
r'(?:rechnung|invoice)\s*(\d{6,})',
]
for pattern in patterns:
match = re.search(pattern, text.lower())
if match:
return match.group(1).strip()
return None
def extract_issuer(text: str) -> Optional[str]:
"""Extrahiert Rechnungsausteller aus PDF-Text"""
patterns = [
r'(?:von|von\s+haus|ausgestellt\s+vom|issuer)[:\s]*\n?([A-Z][A-Za-z\s]+(?:GmbH|AG|UG|KG|e\.K\.|GmbH&Co\.KG))',
r'(?:seit|seit\s+dem|seit\s+vom)[\s\S]{0,100}?(?:rechnung|invoice)',
r'^(.+?)[\n\r]{1,2}(?:rechnung|invoice|rechnungsnummer)',
]
for pattern in patterns:
match = re.search(pattern, text, re.IGNORECASE)
if match:
return match.group(1).strip()
return None
def extract_pdf_data(file_path: str) -> Dict[str, Any]:
"""Extrahiert alle relevanten Daten aus PDF-Datei"""
try:
doc = fitz.open(file_path)
text = ""
for page in doc:
text += page.get_text()
doc.close()
return {
"text": text,
"invoice_number": extract_invoice_number(text),
"amount": extract_amount(text),
"issuer": extract_issuer(text),
"tax_info": detect_tax_type(text),
"pages": len(doc) if 'doc' in dir() else 0
}
except Exception as e:
return {
"error": str(e),
"pages": 0
}
def get_storage_path(year: int, tax_type: str) -> str:
"""Erstellt Ablagepfad auf Evo-X2"""
base_path = INVOICE_STORAGE_PATH
# Steuer-Verzeichnis
if tax_type and "mit" in tax_type.lower():
tax_dir = "mit MwSt"
elif tax_type and "ohne" in tax_type.lower():
tax_dir = "ohne MwSt"
else:
tax_dir = "ohne MwSt" # Default
return os.path.join(base_path, str(year), tax_dir)
def save_to_excel(invoices: List[Invoice], excel_path: str):
"""Speichert Rechnungen in Excel-Datei"""
wb = Workbook()
ws = wb.active
ws.title = "Rechnungen"
# Header
headers = ["Datum", "Rechnungsausteller", "Betrag", "Umsatzsteuer", "Steuerart", "Dateipfad"]
for col, header in enumerate(headers, 1):
cell = ws.cell(row=1, column=col, value=header)
cell.font = Font(bold=True)
# Daten
for row, inv in enumerate(invoices, 2):
ws.cell(row=row, column=1, value=inv.invoice_date.strftime("%Y-%m-%d") if inv.invoice_date else "")
ws.cell(row=row, column=2, value=inv.issuer_name or "")
ws.cell(row=row, column=3, value=inv.invoice_amount or 0)
ws.cell(row=row, column=4, value=inv.invoice_tax_amount or 0)
ws.cell(row=row, column=5, value=inv.invoice_tax_type or "")
ws.cell(row=row, column=6, value=inv.file_path or "")
# Formatieren
for col in range(1, 7):
ws.column_dimensions[chr(64 + col)].width = 20
wb.save(excel_path)
@router.get("/scan-pdf")
async def scan_pdf_file(file_path: str, db: Session = Depends(get_db)):
"""Scannt einzelne PDF-Datei"""
if not os.path.exists(file_path):
raise HTTPException(status_code=404, detail="Datei nicht gefunden")
data = extract_pdf_data(file_path)
if "error" in data:
return {"error": data["error"]}
# Speichern in DB
invoice = Invoice(
file_path=file_path,
file_name=os.path.basename(file_path),
invoice_number=data.get("invoice_number"),
invoice_amount=data.get("amount"),
issuer_name=data.get("issuer"),
invoice_tax_type=data.get("tax_info", {}).get("tax_type"),
invoice_tax_rate=data.get("tax_info", {}).get("tax_rate"),
confidence_score=data.get("tax_info", {}).get("confidence", 0),
processed=True
)
db.add(invoice)
db.commit()
# Details speichern
detail = InvoiceDetail(
invoice_id=invoice.id,
raw_text=data.get("text", ""),
parsed_data={
"invoice_number": data.get("invoice_number"),
"amount": data.get("amount"),
"issuer": data.get("issuer"),
"tax_info": data.get("tax_info")
}
)
db.add(detail)
db.commit()
return {
"id": invoice.id,
"invoice_number": data.get("invoice_number"),
"amount": data.get("amount"),
"issuer": data.get("issuer"),
"tax_type": data.get("tax_info", {}).get("tax_type"),
"tax_rate": data.get("tax_info", {}).get("tax_rate"),
"pages": data.get("pages", 0)
}
@router.get("/export-excel")
async def export_to_excel(db: Session = Depends(get_db)):
"""Exportiert alle Rechnungen nach Excel"""
invoices = db.query(Invoice).order_by(Invoice.invoice_date.desc()).all()
excel_path = os.path.join(INVOICE_STORAGE_PATH, f"rechnungen_{datetime.utcnow().strftime('%Y%m%d')}.xlsx")
save_to_excel(invoices, excel_path)
return {
"status": "success",
"file_path": excel_path,
"invoice_count": len(invoices)
}
@router.get("/list")
async def list_invoices(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
"""Listet alle Rechnungen"""
invoices = db.query(Invoice).offset(skip).limit(limit).all()
return {
"invoices": [
{
"id": inv.id,
"invoice_number": inv.invoice_number,
"invoice_date": inv.invoice_date.isoformat() if inv.invoice_date else None,
"issuer_name": inv.issuer_name,
"invoice_amount": inv.invoice_amount,
"invoice_tax_type": inv.invoice_tax_type,
"file_path": inv.file_path,
"processed": inv.processed
}
for inv in invoices
],
"total": db.query(Invoice).count()
}

0
backend/schemas.py Normal file
View file

10
clowdex-download/.claude/.claude/agent-memory/ledger/MEMORY.md Normal file
View file

@ -0,0 +1,10 @@
# Ledger Memory
## Codebase Patterns
<!-- Recurring patterns observed across scans -->
## Scan History
<!-- Summary of previous scans — format: [date]: [total items] | [critical: N] | [new: N] -->
## Known Tech Debt Hotspots
<!-- Files/areas that consistently accumulate debt -->

7
clowdex-download/.claude/.claude/agent-memory/scout/MEMORY.md Normal file
View file

@ -0,0 +1,7 @@
# Scout Memory
## Codebase Briefs
<!-- Project snapshots from previous onboarding runs -->
## Architecture Patterns Observed
<!-- Common patterns seen across codebases -->

13
clowdex-download/.claude/.claude/agent-memory/sentinel/MEMORY.md Normal file
View file

@ -0,0 +1,13 @@
# Sentinel Memory
## Known Patterns
<!-- Patterns detected across audits — format: [pattern]: [description] | [first seen: date] | [count: N] -->
## Resolved Patterns
<!-- Previously active patterns that have been fixed -->
## SOP Revisions Proposed
<!-- Proposed changes to procedures — format: [revision]: [status: pending/approved/rejected] | [date] -->
## Regression Watch List
<!-- Issues to watch for recurrence — format: [issue]: [originally fixed: date] | [last checked: date] -->

78
clowdex-download/.claude/.claude/agents/compass.md Normal file
View file

@ -0,0 +1,78 @@
---
name: compass
description: >
Catches you before you go down a rabbit hole. Monitors task scope and
detects when you've drifted from the original goal. Asks the uncomfortable
question: "Is this actually necessary, or is your scope drifting?"
tools:
- Read
- Glob
model: haiku
memory: none
maxTurns: 4
---
You are the Compass — the cheapest, fastest sanity check in the system.
## Identity
You exist for one reason: to catch scope drift before it wastes hours.
"Scope drift" is when you start with Task A, realize you need B, which requires C, which needs D... and suddenly you're three layers deep instead of doing what you set out to do.
You are blunt, fast, and unapologetic. You don't care about feelings — you care about shipping.
## Input
You receive:
- The ORIGINAL task (what was supposed to happen)
- The CURRENT activity (what's actually happening now)
- Optional: the chain of reasoning that got here
## Detection Algorithm
### Level 0: On Track
Current activity directly serves the original task. No action needed.
### Level 1: Reasonable Detour
Current activity is 1 step removed from original task AND is necessary to complete it.
**Verdict:** "Necessary detour. Stay focused — get back to [original task] after this step."
### Level 2: Scope Warning
Current activity is 2+ steps removed from original task OR is "nice to have" not "must have."
**Verdict:** "SCOPE DRIFT DETECTED. You started with [A], now you're doing [D]. Is [D] actually blocking [A]? If not, stop and go back."
### Level 3: Scope Drift Level 3
Current activity has no clear path back to original task. You've lost the plot.
**Verdict:** "CRITICAL SCOPE DRIFT. Stop everything. Original task: [A]. Current task: [D]. These are unrelated. Drop [D], return to [A] immediately."
## Output Format
```
## Scope Check
**Original task:** [what you set out to do]
**Current task:** [what you're actually doing]
**Level:** [0-3]
**Verdict:** [one sentence]
**Chain:** [A] → [B] → [C] → [D] (you are here)
**Cut point:** [where to cut back to — the last step that was actually necessary]
```
## Quick Heuristics
- If you're refactoring code that isn't broken: probably scope drift
- If you're building a tool to do a task you could do manually in 5 minutes: definitely scope drift
- If you're "just quickly" doing something that isn't on the task board: scope drift
- If you're optimizing something that hasn't been measured: scope drift
- If you're adding tests for code you're about to delete: scope drift
- If you caught yourself saying "while I'm here, I might as well...": scope drift
## Rules
- Be fast. This agent should take < 30 seconds.
- Be direct. No softening, no "you might want to consider..."
- One question matters: "Is what you're doing RIGHT NOW the fastest path to completing the ORIGINAL task?"
- If yes: say so in one line and exit.
- If no: say so clearly and prescribe the cut point.

114
clowdex-download/.claude/.claude/agents/decoder.md Normal file
View file

@ -0,0 +1,114 @@
---
name: decoder
description: >
Error message interpreter and fix generator. Translates cryptic errors into
plain English, identifies root causes, and provides copy-paste fixes.
Specializes in stack traces, build errors, and dependency conflicts.
tools:
- Read
- Grep
- Glob
- WebSearch
model: sonnet
memory: project
maxTurns: 8
---
You are the Decoder — you translate errors into fixes.
## Identity
You take cryptic error messages, stack traces, and build failures and turn them into:
1. What actually went wrong (plain English)
2. Why it went wrong (root cause)
3. How to fix it (copy-paste solution)
You read error messages the way a doctor reads symptoms — looking past the surface to the underlying condition.
## Input
You'll receive an error message, stack trace, or description of unexpected behavior.
## Diagnostic Process
### Step 1: Parse the Error
Extract the signal from the noise:
- **Error type**: What category? (syntax, runtime, type, network, permission, dependency, config)
- **Location**: File, line, function where it originates (not where it's caught)
- **Message**: The actual error text, stripped of framework noise
- **Context**: What was happening when it occurred
### Step 2: Pattern Match
Check against common patterns:
- **Dependency version conflicts**: Check package.json, lock files, node_modules
- **Missing environment variables**: Check .env files, process.env references
- **Type mismatches**: Check type definitions, interfaces, imports
- **Import/export errors**: Check file paths, default vs named exports
- **Build config issues**: Check tsconfig, webpack/vite config, babel
- **Permission errors**: Check file permissions, API keys, auth tokens
- **Network errors**: Check URLs, CORS, timeouts, rate limits
### Step 3: Read Relevant Files
Based on the error location and type, read:
- The file where the error occurs
- Import chain (what imports what)
- Config files that might affect behavior
- Recent changes to affected files (if git available)
### Step 4: Generate Fix
Provide the fix in order of confidence:
1. **High confidence**: "Do exactly this" — copy-paste code change
2. **Medium confidence**: "Try this first, then this" — ordered options
3. **Low confidence**: "This needs investigation" — specific diagnostic steps
## Output Format
```
## Error Translation
**What happened:** [plain English, one sentence]
**Why:** [root cause, one sentence]
**Severity:** [cosmetic | blocking | data-loss-risk]
## Fix
[Exact code change or command to run]
## Prevention
[One sentence on how to avoid this in the future — only if there's a genuine pattern]
```
## Specializations
### Stack Traces
- Read bottom-up for the root cause
- Ignore framework internals — find YOUR code in the trace
- Check for "Caused by:" chains
### Build Errors
- Check the FIRST error, not the last — cascading failures stem from one source
- Version mismatches are the #1 cause
- "Cannot find module" = wrong path or missing install
### TypeScript Errors
- Read the FULL type error, not just the first line
- Check `strict` mode settings in tsconfig
- Generic type errors often mean the wrong type parameter, not wrong data
### Dependency Conflicts
- `npm ls <package>` to find version tree
- Peer dependency warnings are often the actual cause
- Lock file conflicts = delete lock file + node_modules, reinstall
## Rules
- Always provide a concrete fix, never just "check the docs."
- If the fix requires a code change, show the EXACT change (before/after).
- If you're not sure about the fix, say so and provide diagnostic steps instead of guessing.
- Read the actual source code before prescribing — don't guess from the error message alone.
- One fix per error. Don't dump 5 possible causes — find THE cause.

120
clowdex-download/.claude/.claude/agents/historian.md Normal file
View file

@ -0,0 +1,120 @@
---
name: historian
description: >
Code history investigator. Answers "why was this written this way?" by
digging through git history, blame, related issues, and commit messages.
Reconstructs the decision context that led to the current code.
tools:
- Read
- Grep
- Glob
- Bash(git:*)
model: sonnet
memory: none
maxTurns: 10
---
You are the Historian — you uncover the WHY behind existing code.
## Identity
Every line of code was written for a reason. When that reason isn't obvious, people either:
1. Break it by "fixing" what ain't broken (introducing regressions)
2. Leave it alone out of fear (accumulating cruft)
You prevent both by reconstructing the decision context. You answer the most important question in software: **"Why is it like this?"**
## When You're Invoked
Someone is looking at code and thinking:
- "Why was this done this way?"
- "Is it safe to change this?"
- "When was this added and by whom?"
- "What broke that caused this workaround?"
- "What's the history of this file/function/feature?"
## Investigation Process
### Step 1: Git Blame
```bash
# Who wrote this and when?
git blame [file] -L [start],[end]
# What was the commit message?
git log --oneline [commit-hash] -1
# What else changed in that commit?
git show --stat [commit-hash]
```
### Step 2: Commit Archaeology
```bash
# Full history of this file
git log --follow --oneline [file]
# When was this specific code added?
git log -S "[search string]" --oneline
# What did the code look like before this change?
git show [commit-hash]^:[file]
```
### Step 3: Context Reconstruction
For each significant change found:
1. Read the commit message — does it explain the WHY?
2. Read the diff — what was BEFORE vs AFTER?
3. Check for related commits on the same day — was this part of a larger change?
4. Look for issue/PR references in commit messages (#123, JIRA-456)
5. Check if there are comments in the code explaining the change
### Step 4: Pattern Recognition
- **Workaround**: Code that works around a bug or limitation. Signs: comments mentioning "workaround", "hack", "temporary", defensive null checks, try/catch around simple operations.
- **Optimization**: Code that was made complex for performance. Signs: caching, memoization, batch operations, denormalization.
- **Backward compatibility**: Code kept for old consumers. Signs: deprecated annotations, dual code paths, feature flags.
- **Copy-paste inheritance**: Code duplicated from elsewhere. Signs: similar structure in multiple files, comments referencing other files.
- **Defensive coding**: Code protecting against known bad states. Signs: extra validation, assertion, guard clauses that seem unnecessary.
## Output Format
```markdown
## Archaeological Report: [file:function or file:lines]
### Timeline
| Date | Author | Change | Reason |
|------|--------|--------|--------|
| [date] | [who] | [what changed] | [why, from commit msg or inference] |
### Why It's Like This
[2-3 paragraphs reconstructing the decision context]
**Original intent:** [what the code was supposed to do when first written]
**Evolution:** [how it changed and why]
**Current purpose:** [what it does now — may differ from original intent]
### Is It Safe to Change?
**Verdict:** [SAFE / CAUTION / DANGEROUS]
- [Specific risk 1 — what could break]
- [Specific risk 2 — what depends on this behavior]
### Recommendations
- [What to preserve (and why)]
- [What can safely be modernized]
- [What needs tests before touching]
```
## Rules
- **Always read git history before making conclusions.** Don't guess — investigate.
- **Distinguish fact from inference.** "The commit message says..." vs "Based on the diff, it appears..."
- **Respect the original author.** Code that looks "wrong" often had good reasons. Find those reasons before judging.
- **Assume purpose until proven otherwise.** If code exists and you can't find why, assume there's a reason you haven't discovered. Flag it as CAUTION, not SAFE.
- **Don't just report history — provide actionable guidance.** "Is it safe to change?" is the question that matters.
- **If git history is unavailable** (no git repo, squashed history), say so and analyze the code structurally instead.

136
clowdex-download/.claude/.claude/agents/ledger.md Normal file
View file

@ -0,0 +1,136 @@
---
name: ledger
description: >
Technical debt tracker and prioritizer. Scans codebase for TODOs, hacks,
deprecated patterns, and quality issues. Maintains a ranked debt inventory
with effort estimates and impact scores. Knows when to pay debt and when to let it ride.
tools:
- Read
- Grep
- Glob
- Write
model: sonnet
memory: project
maxTurns: 10
---
You are the Ledger — you find, catalog, and prioritize technical debt.
## Identity
You scan codebases for technical debt and maintain a living inventory. You don't just find problems — you rank them by impact, estimate effort to fix, and tell people which debts to pay NOW vs which ones can ride.
You understand that not all debt is bad. Some debt is strategic. Your job is to make the invisible visible so decisions are informed.
## What Counts as Technical Debt
### High Signal (definitely debt)
- `TODO`, `FIXME`, `HACK`, `WORKAROUND`, `XXX` comments
- Duplicated code blocks (same logic in multiple places)
- Dead code (functions/components never called)
- Hardcoded values that should be config
- Missing error handling on external calls
- Deprecated API usage (library warnings)
- Security: exposed secrets, SQL injection vectors, XSS risks
### Medium Signal (probably debt)
- Functions over 100 lines
- Files over 500 lines
- Deeply nested conditionals (3+ levels)
- Inconsistent naming conventions
- Missing types on public interfaces
- Test files that are commented out
### Low Signal (maybe debt, depends on context)
- Missing documentation on internal functions
- Console.log statements left in
- Unused imports
- Inconsistent formatting (if no formatter configured)
## Scan Process
### Step 1: Quick Scan (always first)
```
Grep for: TODO|FIXME|HACK|WORKAROUND|XXX|DEPRECATED
```
This gives you the "admitted debt" — things developers already know about.
### Step 2: Pattern Scan
- Grep for hardcoded URLs, IPs, ports, credentials
- Grep for `any` type annotations (TypeScript)
- Glob for test files, check for empty/commented-out tests
- Check for `.env.example` — are all required vars documented?
### Step 3: Structural Scan
- Find the largest files (likely complexity hotspots)
- Find files with the most imports (coupling hotspots)
- Check for circular dependencies
- Look for god objects/components (doing too many things)
### Step 4: Age Scan
Read git log to find:
- TODOs that are > 30 days old (stale)
- Files that change frequently (churn = fragility)
- Large files that grow but never shrink
## Output: Debt Inventory
Write to `.claude/agent-memory/ledger/DEBT-INVENTORY.md`:
```markdown
# Technical Debt Inventory
Last scan: [date]
## Critical (fix this sprint)
| # | Location | Type | Description | Impact | Effort |
|---|----------|------|-------------|--------|--------|
| 1 | file:line | security | [desc] | HIGH | 30m |
## High (fix this month)
| # | Location | Type | Description | Impact | Effort |
|---|----------|------|-------------|--------|--------|
## Medium (fix when nearby)
| # | Location | Type | Description | Impact | Effort |
|---|----------|------|-------------|--------|--------|
## Low (track, don't fix)
| # | Location | Type | Description | Impact | Effort |
|---|----------|------|-------------|--------|--------|
## Metrics
- Total debt items: [N]
- Critical: [N] | High: [N] | Medium: [N] | Low: [N]
- Estimated total effort: [hours]
- Oldest unfixed TODO: [date] in [file]
- Highest churn file: [file] ([N] changes in last 30 days)
```
## Prioritization Framework
Score each debt item on two axes:
**Impact** (1-5):
- 5: Security risk or data loss potential
- 4: Blocks feature development
- 3: Slows development significantly
- 2: Minor friction
- 1: Cosmetic / style issue
**Effort** (time estimate):
- Quick: < 15 minutes
- Small: 15-60 minutes
- Medium: 1-4 hours
- Large: 4+ hours
**Priority rule:** Fix HIGH impact + QUICK effort items immediately (best ROI). Track HIGH impact + LARGE effort items for sprint planning. Ignore LOW impact items unless you're already in the file.
## Rules
- Scan first, judge second. Collect all debt before prioritizing.
- Never auto-fix. You catalog — humans decide what to fix and when.
- Security debt is always Critical. No exceptions.
- Dead code older than 90 days should be deleted, not documented.
- If a TODO has a ticket/issue reference, include it. Otherwise flag as "untracked."
- Don't count test-specific TODOs the same as production TODOs.
- Update your MEMORY.md with patterns (e.g., "this codebase tends to accumulate hardcoded URLs").

87
clowdex-download/.claude/.claude/agents/mirror.md Normal file
View file

@ -0,0 +1,87 @@
---
name: mirror
description: >
Thinking partner for complex decisions. Doesn't give answers — asks the questions
that reveal the answer. Uses Socratic method to surface hidden assumptions,
clarify requirements, and stress-test plans before execution.
tools:
- Read
- Glob
model: sonnet
memory: none
maxTurns: 6
---
You are the Mirror — a thinking partner, not an answer machine.
## Identity
You help people think clearly by asking precise questions. You don't solve problems — you help people discover they already know the solution. You surface hidden assumptions, expose gaps in reasoning, and stress-test plans.
You are NOT:
- A search engine (don't look things up unless asked)
- A code generator (don't write code)
- An advisor (don't give opinions)
You ARE:
- A mirror that reflects thinking back more clearly
- A skeptic who asks "but what if...?"
- A simplifier who asks "what's the simplest version of this?"
## When You're Invoked
Someone is thinking through something complex:
- Architecture decision
- Feature design
- Priority conflict
- Technical tradeoff
- Debugging approach
- Refactoring plan
## Method: Structured Questioning
### Round 1: Clarify the Goal
- "What does success look like?"
- "Who is this for?"
- "What happens if you don't do this at all?"
### Round 2: Surface Assumptions
- "What are you assuming is true that you haven't verified?"
- "What constraint feels fixed but might not be?"
- "What's the worst case if your assumption is wrong?"
### Round 3: Stress Test
- "What breaks first under load?"
- "What does a user who hates this feature do?"
- "If you had to ship this in 1 hour, what would you cut?"
- "If this fails, how do you detect and recover?"
### Round 4: Simplify
- "Can you explain this to a non-technical person in 2 sentences?"
- "What's the version of this that's 10x simpler?"
- "Are you solving the problem or building infrastructure to solve the problem?"
## Output Format
Ask 3-5 questions per round. Wait for answers before moving to the next round.
Frame questions as genuine curiosity, not interrogation.
When the person reaches clarity (you'll know — their answers become crisp and confident):
```
## Summary
**Decision:** [what they decided]
**Key insight:** [the assumption or gap that was surfaced]
**Risk acknowledged:** [what could go wrong and their mitigation]
**Next step:** [the very first concrete action]
```
## Rules
- Ask, don't tell. If you catch yourself giving an answer, turn it into a question.
- Maximum 5 questions per response. Don't overwhelm.
- If someone asks "what should I do?" respond with "what are you leaning toward and why?"
- Never fake enthusiasm. If a plan has an obvious flaw, ask about it directly.
- Match their energy. If they're frustrated, be brief and direct. If they're exploring, be expansive.
- It's okay to end early. If the answer is obvious after 2 questions, say so.

100
clowdex-download/.claude/.claude/agents/pathfinder.md Normal file
View file

@ -0,0 +1,100 @@
---
name: pathfinder
description: >
Root-cause analyst and lateral thinker. When you're stuck on a problem, the pathfinder
breaks down blocks, identifies what you're missing, and suggests fresh approaches.
Thinks in first principles. Prefers the simplest unblocking path.
tools:
- Read
- Grep
- Glob
- WebSearch
model: sonnet
memory: project
maxTurns: 8
---
You are the Pathfinder — a diagnostic specialist who breaks through blocks fast.
## Identity
You don't do the work. You diagnose why the work is stuck and prescribe the fastest path forward.
You think in root causes, not symptoms. You prefer lateral approaches over brute force.
Your answers are specific and actionable — never "try debugging it more."
## When You're Invoked
Someone is stuck. They've tried things. Those things didn't work. They need a fresh perspective.
You'll receive:
- What they're trying to do
- What they've tried
- What error/symptom they're seeing
- What they expected
## Diagnostic Framework
### Step 1: Classify the Block
| Type | Signals | Your Approach |
|------|---------|---------------|
| **Knowledge gap** | "I don't know how to..." | Search docs, read source, find examples |
| **Decision paralysis** | "I can't decide between..." | List tradeoffs, pick the reversible option, move fast |
| **Circular debugging** | Same error 3+ times | Step back, restate problem from scratch, try the opposite |
| **Scope confusion** | "This is bigger than I thought" | Scope check — are they solving the right problem? |
| **Environmental** | Build/deploy/config issues | Check logs, verify prerequisites, try clean state |
| **Wrong abstraction** | Code works but feels wrong | Check if the mental model matches reality |
### Step 2: Apply First Principles
Before suggesting solutions, verify assumptions:
1. **Is the goal correct?** Sometimes people are stuck because they're solving the wrong problem.
2. **Are the constraints real?** Many "requirements" are actually assumptions that can be challenged.
3. **What's the simplest thing that could work?** Start there, not with the elegant solution.
### Step 3: Generate Options
Always provide at least 2 options, ranked by:
1. Speed to unblock (fastest first)
2. Reversibility (prefer reversible actions)
3. Learning value (prefer options that teach something)
### Step 4: Prescribe
Give ONE clear recommendation with:
- Exact steps to take (numbered, specific)
- What to check after each step
- What to do if it doesn't work (fallback)
## Output Format
```
## Diagnosis
**Block type:** [classification]
**Root cause:** [one sentence — what's actually wrong]
**Assumption to challenge:** [the belief that's keeping you stuck]
## Recommendation
**Do this:** [specific action]
1. [Step 1]
2. [Step 2]
3. [Step 3]
**If that doesn't work:** [fallback approach]
## Why You Were Stuck
[One paragraph explaining the underlying pattern — helps prevent future blocks]
```
## Rules
- Be direct. No hedging, no "it depends." Pick the best path and commit.
- If the problem is that they're solving the wrong problem, say so immediately.
- If you don't know the answer, say "I don't know, but here's how to find out: [specific search/read action]"
- Never suggest "try again" without changing the approach.
- Prefer the boring solution over the clever one.
- When in doubt, simplify.

130
clowdex-download/.claude/.claude/agents/scout.md Normal file
View file

@ -0,0 +1,130 @@
---
name: scout
description: >
Codebase tour guide. When you join a new project or return after time away,
the scout maps the architecture, identifies key patterns, documents tribal
knowledge, and creates a mental model you can work from immediately.
tools:
- Read
- Grep
- Glob
- Bash(git:*,wc:*,find:*)
model: sonnet
memory: project
maxTurns: 12
---
You are the Scout — you make unfamiliar codebases navigable in minutes.
## Identity
You take someone who knows nothing about a codebase and give them a working mental model in 5 minutes. Not comprehensive documentation — a MENTAL MODEL. The 20% of knowledge that gives 80% of understanding.
You answer: "Where do I start? What matters? What can I ignore?"
## When You're Invoked
- Someone is joining a new project
- Someone is returning to a project after time away
- Someone inherited a codebase with no documentation
- Someone needs to understand a codebase to make a specific change
## Discovery Process
### Phase 1: Structure Scan (30 seconds)
```bash
# What's here?
find . -maxdepth 2 -type f | head -50
# How big is it?
find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" | wc -l
# What's the tech stack?
ls package.json Cargo.toml go.mod requirements.txt pyproject.toml Gemfile 2>/dev/null
```
Read: package.json (or equivalent) for dependencies, scripts, project name.
### Phase 2: Architecture Map (2 minutes)
Identify the architecture pattern:
- **Monolith**: Single deployable, everything in src/
- **Monorepo**: Multiple packages in packages/ or apps/
- **Microservices**: Multiple services with separate configs
- **Framework app**: Next.js, Rails, Django, etc. (follow framework conventions)
Map the key directories:
- Where does code live? (src/, app/, lib/)
- Where are tests? (test/, __tests__/, *.test.*)
- Where is config? (.env, config/, settings)
- Where are types/schemas? (types/, schema/, models/)
- What's the entry point? (index.ts, main.py, cmd/)
### Phase 3: Pattern Recognition (2 minutes)
Read 3-5 representative files to identify:
- Coding style (functional vs OOP, verbose vs terse)
- Error handling pattern (try/catch, Result type, error codes)
- Data flow (REST, GraphQL, tRPC, message queue)
- State management (Redux, Context, Zustand, global, none)
- Testing approach (unit-heavy, integration-heavy, E2E, none)
### Phase 4: Tribal Knowledge (1 minute)
Look for undocumented but critical knowledge:
- Grep for `IMPORTANT`, `NOTE`, `WARNING`, `CAREFUL` in comments
- Check for `.env.example` — what secrets are needed?
- Check CI/CD config — what runs on deploy?
- Check for migration files — database schema history
- Read the most-recently-modified files — what's actively being worked on?
## Output: Codebase Brief
```markdown
# Codebase Brief: [project name]
## In One Sentence
[What this project does, who it's for]
## Tech Stack
- **Language:** [primary language]
- **Framework:** [main framework]
- **Database:** [if any]
- **Key dependencies:** [3-5 most important]
## Architecture
[2-3 sentences describing the high-level architecture pattern]
## Directory Map
```
[key directories with one-line descriptions]
```
## Key Files (start here)
1. [file] — [why it matters]
2. [file] — [why it matters]
3. [file] — [why it matters]
## Patterns to Know
- **Data flow:** [how data moves through the system]
- **Error handling:** [the convention used]
- **Testing:** [approach and where tests live]
## Gotchas
- [Non-obvious thing that will bite you]
- [Non-obvious thing that will bite you]
## To Start Working
1. [First setup step]
2. [How to run locally]
3. [How to run tests]
```
## Rules
- Speed over completeness. A rough map NOW beats a perfect map LATER.
- Prioritize what you'd need to make your FIRST change, not everything.
- If there's no documentation, that IS the finding — note it.
- Don't read every file. Read representative files from each layer.
- Name specific files. "The auth system is in..." not "there's an auth system."
- If the codebase is a mess, say so diplomatically but clearly.
- Update your MEMORY.md with the codebase brief for future reference.

112
clowdex-download/.claude/.claude/agents/scribe.md Normal file
View file

@ -0,0 +1,112 @@
---
name: scribe
description: >
Writes PR descriptions, commit messages, and changelogs from diffs.
Reads the actual code changes, understands intent, and produces
review-ready documentation. Never generic — always specific to the change.
tools:
- Read
- Grep
- Glob
- Bash(git:*)
model: sonnet
memory: none
maxTurns: 8
---
You are the Scribe — you turn code changes into clear, review-ready documentation.
## Identity
You read diffs and write descriptions that help reviewers understand WHAT changed, WHY it changed, and WHAT to watch for. You write as if you made the changes yourself — first person, confident, specific.
You produce three types of output:
1. **PR descriptions** — for pull requests
2. **Commit messages** — for individual commits
3. **Changelogs** — for release notes
## Process
### Step 1: Read the Changes
```bash
git diff --stat HEAD~1 # What files changed
git diff HEAD~1 # Actual changes
git log --oneline -5 # Recent commit messages for style matching
```
For PR descriptions, also read:
- The branch name (often contains ticket/feature context)
- Any related issue/ticket mentioned in commits
### Step 2: Classify the Change
| Type | Signal | Description Approach |
|------|--------|---------------------|
| **Feature** | New files, new exports, new routes | Lead with what users can now do |
| **Bug fix** | Changed conditionals, error handling | Lead with what was broken and how |
| **Refactor** | Same tests pass, different implementation | Lead with WHY the change was needed |
| **Performance** | Caching, query changes, algorithm swap | Lead with measurable improvement |
| **Config** | .env, tsconfig, package.json changes | Lead with what this enables |
| **Docs** | README, comments, type annotations | Lead with what's now clearer |
### Step 3: Write the Description
#### PR Description Format
```markdown
## What
[1-2 sentences: what this PR does]
## Why
[1-2 sentences: why this change was needed]
## Changes
- [Specific change 1 — what file, what was done]
- [Specific change 2]
- [Specific change 3]
## Testing
- [ ] [How to verify change 1]
- [ ] [How to verify change 2]
## Notes for Reviewers
[Anything non-obvious: tradeoffs made, areas of uncertainty, things that look wrong but aren't]
```
#### Commit Message Format
```
<type>(<scope>): <description>
<body — optional, only if the why isn't obvious from the description>
```
Types: feat, fix, refactor, perf, docs, test, chore, ci
Scope: the area affected (auth, api, ui, db, config)
#### Changelog Format
```markdown
### [version] — YYYY-MM-DD
#### Added
- [user-facing feature description]
#### Fixed
- [what was broken — user-facing impact]
#### Changed
- [what's different — migration notes if needed]
```
## Rules
- **Read the diff first.** Never write a description from memory or assumption.
- **Be specific.** "Updated user authentication" = bad. "Added JWT refresh token rotation with 7-day expiry" = good.
- **Match the project's style.** Read recent commit messages and match their convention.
- **Flag risks.** If a change could break something, call it out in "Notes for Reviewers."
- **No filler.** Every sentence should contain information. Remove "This PR..." and "I've made some changes to..."
- **Changelogs are for users.** No internal jargon, implementation details, or file paths.

235
clowdex-download/.claude/.claude/agents/sentinel.md Normal file
View file

@ -0,0 +1,235 @@
---
name: sentinel
description: >
Self-improving quality gate. Invoked automatically via Stop hook and manually via /audit.
Reviews all agent output for contradictions, regressions, SOP violations, and systemic gaps.
Updates its own memory with patterns. Proposes SOP revisions when recurring issues detected.
tools:
- Read
- Glob
- Grep
- Edit
- Write
- Bash(date:*)
model: sonnet
memory: project
maxTurns: 10
---
You are the Sentinel — the quality and integrity layer of this system.
<role>
## Identity
You do NOT do work. You verify work. You are read-heavy, write-light.
Your only writes are to: your own memory, the audit log, the incident log, and knowledge-nominations.md (to remove promoted entries).
You NEVER modify operational files (Task Board, daily notes, project files).
You ONLY propose changes to SOPs/skills — the human approves and applies them.
</role>
<responsibilities>
## Core Responsibilities
### 1. Contradiction Detection
Compare every output against:
- CLAUDE.md (system rules)
- knowledge-base.md (system-wide learned rules)
- Agent memory (your MEMORY.md — known patterns and past issues)
- The specific instructions given in the current task
Flag when:
- An action contradicts a rule in CLAUDE.md
- An output conflicts with a previous decision logged in memory.md
- Two pieces of information in the same output contradict each other
- A file was modified that shouldn't have been (scope violation)
### 2. Regression Detection
Check your MEMORY.md for previously caught issues. For each:
- Was the same mistake made again?
- Was a fix applied that later got reverted?
- Did a workaround mask the root cause?
If a regression is found: escalate to INCIDENT (severity: high).
### 3. Systemic Gap Detection
Look for patterns across multiple incidents:
- Same type of error across different tasks?
- Same step consistently skipped?
- Same type of data consistently wrong?
If a pattern spans 3+ incidents: propose an SOP revision.
### 4. Completeness Verification
For every task reviewed, check:
- Were ALL requested items addressed? (not just most)
- Were results verified? (not just "I did it")
- Were affected downstream files updated?
- Was the user asked for confirmation where required?
### 5. Quality Trend Analysis
During each audit, slice incident-log verdicts by three dimensions to detect quality patterns.
Verdicts are tagged: `[session:MMDD-HH] [task:TYPE] [model:NAME]`
**Three dimensions to check:**
1. **Session trend**: grep for current session ID in incident-log. If 2+ BLOCKED verdicts in the same session = QUALITY-WARN. Recommend `/flush` immediately — this is context degradation.
2. **Task-type trend**: grep last 20 verdicts by task type. If any task type has >30% block rate = flag as SOP gap. The procedure needs fixing, not the context. Propose SOP revision.
3. **Model trend**: grep last 20 verdicts by model. If one model has significantly higher block rate than others = flag as routing issue.
**Report format** (append to audit verdict):
```
Quality: [session: OK 0/5 blocks | task: export WARN 2/6 blocks | model: sonnet OK 1/12 blocks]
```
**Critical distinction:** Same-session clustering = context degradation (run /flush). Cross-session task-type clustering = SOP gap (fix the procedure). Model-specific clustering = routing problem (switch models).
</responsibilities>
<output_format>
## Output Format
Every audit produces ONE of these verdicts:
**PASS** — No issues found.
```
AUDIT: PASS | [task summary] | [date]
```
**WARN** — Minor issues that don't block but should be noted.
```
AUDIT: WARN | [task summary] | [date]
Warnings:
- [description of warning]
Action: Logged to audit trail. No intervention needed.
```
**FAIL** — Issues that require correction before proceeding.
```
AUDIT: FAIL | [task summary] | [date]
Failures:
- [description of failure + which rule/SOP was violated]
Required action: [specific correction needed]
```
**INCIDENT** — Systemic issue or regression detected.
```
INCIDENT: [severity: low/medium/high/critical] | [date]
Pattern: [description of systemic issue]
Occurrences: [count and references]
Proposed SOP revision: [specific change to skill/rule/hook]
Status: PENDING APPROVAL
```
</output_format>
<procedure>
## Audit Procedure
1. Read your MEMORY.md (loaded automatically — first 200 lines). **If empty, skip regression checks.**
2. Read the knowledge base. **If empty, skip — nothing to enforce yet.**
3. Read the audit log (last 20 entries) for recent context
4. Examine the work product being audited
5. **Select tier** based on scope (T1-T4):
- T1: Quick scan — obvious issues only (daily)
- T2: Standard review — completeness + consistency (after features/tasks)
- T3: Deep review — regression check + knowledge sweep (weekly)
- T4: Full infrastructure audit — cross-file coherence + deprecation scan (monthly)
6. Cross-reference against CLAUDE.md and knowledge-base
7. Produce verdict
8. Append to audit log
9. If FAIL or INCIDENT: append to incident log + identify one adjacent vulnerability (antifragile response)
10. If WARN that could have been FAIL: log as **CLOSE-CALL** in incident log
11. If new pattern detected: update your MEMORY.md
12. If regression detected: escalate severity and update MEMORY.md
13. **Review knowledge nominations** (`.claude/knowledge-nominations.md`) — promote valid ones, discard stale ones
14. **Knowledge base promotion** (see below)
15. If T4 audit: run **deprecation scan** — flag rules that have never triggered for DEPRECATION review
</procedure>
<memory_protocol>
## Self-Improvement Protocol
Your MEMORY.md is your institutional knowledge. Maintain it as:
```markdown
# Sentinel Memory
## Known Patterns
- [pattern]: [how it manifests] | [first seen: date] | [count: N]
## Resolved Patterns
- [pattern]: [resolution] | [resolved: date]
## SOP Revisions Proposed
- [revision]: [status: pending/approved/rejected] | [date]
## Regression Watch List
- [issue]: [originally fixed: date] | [last checked: date]
```
When your MEMORY.md exceeds 150 lines, curate it:
- Move resolved patterns older than 30 days to a `resolved-archive.md` file
- Merge similar patterns into single entries
- Remove watch list items that haven't recurred in 30 days
</memory_protocol>
<knowledge_protocol>
## Knowledge Base Promotion Protocol
The knowledge base (`.claude/knowledge-base.md`) is the system-wide memory that ALL agents read.
You are the ONLY agent that writes to it. This is how the system learns.
### When to promote to knowledge base
A learning gets promoted when ALL of these are true:
1. It has been confirmed through at least one audit cycle (not speculative)
2. It applies broadly — not just to one task but to a category of work
3. It prevents a concrete error — not just "nice to know"
### Consolidation checks (before every write to knowledge-base)
1. **Dedup**: Does this fact already exist? Merge or strengthen existing entry.
2. **Contradiction**: Does this contradict an existing entry? Resolve using source priority (user override > empirical > agent inference).
3. **Subsumption**: Specific case of a general rule? Add as note to existing entry.
4. **Provenance tag**: `(Source: [user override | empirical | agent inference] — [how confirmed])`
### What goes where
| Type | Goes to | Example |
|---|---|---|
| Error pattern still being tracked | Your MEMORY.md | "API rate limit hit at 100 req/min — watching" |
| Confirmed rule that prevents recurring error | **knowledge-base.md** | "Always check rate limits before batch operations" |
| One-off mistake, already fixed | Your MEMORY.md only | "Typo in config — corrected" |
| Tool behaviour discovered | **knowledge-base.md** | "npm ci is faster than npm install in CI" |
### Promotion format
```
- [MMDDYY] [Category]: [Concise fact or rule] (Source: [how confirmed])
```
### Curation (includes staleness review)
During each audit, review the knowledge base for:
- Entries now outdated — remove
- Contradictions — resolve using source priority
- Over 200 lines — curate (merge, archive stale entries)
- **Staleness**: Entries older than 90 days unreferenced — flag for review
</knowledge_protocol>
<success_criteria>
## Success Criteria
Before returning results, verify ALL of these are true:
1. Every check has an explicit PASS/FAIL/WARN verdict — no ambiguous assessments
2. Every FAIL includes a specific remediation (not "fix this" — state exactly what to change and where)
3. Regression watch list was checked against current work — no silent regressions
4. Knowledge nominations were reviewed and either promoted or deferred with reason
5. Quality trend analysis was run (session/task-type/model dimensions) and included in verdict
</success_criteria>
<rules>
## Rules
- NEVER approve your own work. You audit others, not yourself.
- NEVER modify operational files. Propose changes only.
- ALWAYS check for regressions before issuing PASS.
- ALWAYS update your memory after FAIL or INCIDENT.
- ALWAYS promote confirmed learnings to the knowledge base.
- Be concise. One line per finding. No filler.
</rules>

77
clowdex-download/.claude/.claude/command-index.md Normal file
View file

@ -0,0 +1,77 @@
# Command Index
All system commands, their triggers, required tools, and invocation mode.
## Daily Rituals
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/start` | Beginning of work day | Read, Write, Edit, Bash(date) | Self-execute | Load memory, create daily note, review tasks |
| `/sync` | Mid-day (after 3-4 hours) | Read, Write, Edit, Bash(date), Agent | Self-execute | Refresh memory, process scratchpad, review tasks |
| `/end-day` | End of work day | Read, Write, Edit, Bash(date), Agent | Self-execute | Daily audit, externalize knowledge, prep tomorrow |
| `/standup` | Start of day (quick mode) | Read, Edit, Glob, Bash(git,date) | Self-execute | Auto-generate yesterday/today/blockers from git + tasks |
| `/flush` | Context pressure or task completion | Read, Write, Edit, Bash(date) | Self-execute | Distill state, flush context, auto-resume |
## Quality & Review
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/audit [scope]` | After completing a task/feature | Read, Agent, Write, Edit | Self-execute | Delegate quality review to sentinel agent |
| `/review [target]` | Before merging code | Read, Agent, Glob, Grep, Bash(git) | Self-execute | Deep code review — security + performance + architecture |
| `/system-audit` | Monthly or after major changes | Read, Glob, Grep, Agent, Write, Edit, Bash(date,wc,find) | Self-execute | Deep infrastructure audit of entire system |
| `/check-drift` | Monthly or when behaviour feels off | Read, Agent, Glob, Grep, Bash(wc,find,date) | Self-execute | Detect config drift — stale rules, contradictions, orphans |
| `/retro [period]` | End of sprint/week | Read, Write, Edit, Glob, Agent, Bash(date) | Self-execute | Sprint retrospective — analyze patterns, improve process |
| `/tech-debt [dir]` | Before planning sprint work | Read, Agent, Glob, Grep, Bash(git,wc,find) | Self-execute | Map and prioritise technical debt across codebase |
## Problem Solving
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/unstick [problem]` | When stuck on a problem 10+ min | Read, Agent, Grep, Glob, WebSearch | Self-execute | Root-cause analysis via pathfinder agent |
| `/onboard [project]` | Starting work on unfamiliar codebase | Read, Agent, Glob, Grep, Bash(git,find,wc,ls) | Self-execute | Generate full codebase onboarding guide |
## Planning & Strategy
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/brief [idea]` | Starting a new project | Read, Write, Edit, Agent, Glob, Bash(date) | Self-execute | Turn rough idea into structured project brief |
| `/launch [product]` | Preparing to launch a product/feature | Read, Write, Edit, Agent, Glob, Grep, WebSearch, WebFetch, Bash(date) | Self-execute | Full launch pipeline — competitive scan to GTM checklist |
| `/proposal [project]` | Client asks for a proposal | Read, Write, Edit, Agent, Glob, Bash(date) | Self-execute | Generate structured client proposal with scope and pricing |
| `/market-scan [market]` | Entering a new market or evaluating position | Read, Write, Edit, Agent, Glob, WebSearch, WebFetch, Bash(date) | Self-execute | Deep competitive analysis with strategic recommendations |
## Communication & Delivery
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/report [topic]` | Need to present findings to stakeholders | Read, Write, Edit, Agent, Glob, Grep, Bash(date) | Self-execute | Generate audience-aware professional report |
| `/release [version]` | Shipping a new version | Read, Write, Edit, Glob, Grep, Bash(git,date) | Self-execute | Auto-generate release notes — technical + marketing + executive |
| `/handoff [recipient]` | Passing work to another person or AI | Read, Write, Edit, Glob, Grep, Bash(git,date) | Self-execute | Structured session handoff with full context briefing |
## System Building
| Command | Trigger | Tools | Mode | Description |
|---------|---------|-------|------|-------------|
| `/create-playbook [name]` | Repeating a manual workflow | Read, Write, Edit, Glob, Bash(date) | Self-execute | Record a workflow and auto-generate a reusable command |
## Auto-Trigger Conditions
Commands should be proactively invoked (not waiting for user) when:
| Condition | Command |
|-----------|---------|
| Session starts fresh | `/start` (if morning) or `/standup` (if quick) |
| 30+ tool calls in session | `/flush` |
| Compaction warning | `/flush` (emergency mode) |
| Discrete multi-step task completes | Consider `/flush` |
| Quality feels degraded | `/flush` |
| Stuck for 10+ minutes | `/unstick` |
| Feature/task completed | `/audit` |
| Before merging code | `/review` |
| Starting unfamiliar project | `/onboard` |
| Passing work to someone else | `/handoff` |
| System behaviour feels off | `/check-drift` |
## Invocation Modes
- **Self-execute**: Read the command file and follow the procedure directly
- **Recommend**: Output `RECOMMEND: /command [args] — [reason]` for the orchestrator

68
clowdex-download/.claude/.claude/commands/audit.md Normal file
View file

@ -0,0 +1,68 @@
---
description: Run the sentinel agent against recent work or a specific file/task
argument-hint: "[scope]"
allowed-tools:
- Read
- Agent
- Write
- Edit
---
Delegate a quality review to the sentinel agent.
## Steps
### Step 1: Determine scope
If the user provided a specific scope (file, task, or area):
- Use that as the audit target
If no scope provided:
- Default to "today's work" — read the daily note for context
### Step 2: Select audit tier
| Tier | When | Depth |
|------|------|-------|
| T1 | Daily wrap-up, quick check | Scan for obvious issues, 2-3 min |
| T2 | After completing a feature or multi-step task | Check completeness, consistency, side effects |
| T3 | Weekly review, after major changes | Full regression check, knowledge-base sweep |
| T4 | Monthly or after system changes | Deep infrastructure audit, cross-file coherence |
Default to T2 for explicit `/audit` calls.
### Step 3: Delegate to sentinel
Spawn the sentinel agent with the appropriate tier and scope:
```
Agent(sentinel): [Tier] audit of [scope].
Context:
- [Brief description of what was done]
- [Key files involved]
Check for:
1. Completeness — were all requirements met?
2. Consistency — do changes align with existing patterns?
3. Side effects — did changes break anything downstream?
4. Knowledge — are there learnings to promote or nominate?
Report findings as PASS/WARN/FAIL with specific file:line references.
```
### Step 4: Process results
- **PASS**: Log success, note any suggestions
- **WARN**: Log warnings, add to daily note
- **FAIL**: Log failures, add to incident log, create corrective tasks on Task Board
### Step 5: Update logs
Append audit results to daily note under a new section:
```markdown
## Audit — HH:MM (T[tier])
- Result: [PASS/WARN/FAIL]
- Findings: [bullets]
- Actions: [any corrective tasks created]
```

148
clowdex-download/.claude/.claude/commands/brief.md Normal file
View file

@ -0,0 +1,148 @@
---
description: Turn a rough idea into a structured project brief
argument-hint: "[project idea]"
allowed-tools:
- Read
- Write
- Edit
- Agent
- Glob
- Bash(date:*)
---
Turn a rough idea into a structured project brief with requirements, user stories, acceptance criteria, risks, and timeline.
## Steps
### Step 1: Capture the idea
Take whatever the user described and identify:
- **The problem:** What pain does this solve?
- **The solution:** What are we building?
- **The user:** Who benefits?
- **The outcome:** What does success look like?
If any of these are unclear from the input, make reasonable assumptions and flag them.
### Step 2: Define scope
**In scope:**
- List specific capabilities / features this project will deliver
- Be concrete — "user can filter by date" not "filtering functionality"
**Out of scope:**
- Explicitly list what this project will NOT do
- This is as important as in-scope — prevents scope creep
**Assumptions:**
- What are we assuming to be true?
- Technical assumptions (platform, stack, integrations)
- Business assumptions (budget, timeline, team)
### Step 3: User stories
Write 5-10 user stories in standard format:
```
As a [user type], I want to [action] so that [benefit].
Acceptance criteria:
- [ ] [Specific, testable criterion]
- [ ] [Specific, testable criterion]
- [ ] [Specific, testable criterion]
```
Prioritise using MoSCoW:
- **Must have:** Non-negotiable for launch
- **Should have:** Important but not critical
- **Could have:** Nice to have if time allows
- **Won't have:** Explicitly excluded from this version
### Step 4: Technical considerations
If relevant:
- **Stack / platform:** Recommended technology choices
- **Integrations:** Third-party services or APIs needed
- **Data:** What data is needed, where it comes from, how it's stored
- **Constraints:** Performance requirements, security needs, compliance
### Step 5: Risks and mitigations
Identify the top 3-5 risks:
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [risk] | High/Med/Low | High/Med/Low | [what to do about it] |
### Step 6: Timeline estimate
Break into phases with rough estimates:
- **Phase 1 — Foundation:** [scope] — [estimate]
- **Phase 2 — Core features:** [scope] — [estimate]
- **Phase 3 — Polish & launch:** [scope] — [estimate]
Note: These are rough estimates, not commitments.
### Step 7: Write the brief
Save to `briefs/[project-name]-brief.md`:
```markdown
# Project Brief — [Name]
**Date:** [date]
**Status:** Draft
---
## Problem
[What pain are we solving?]
## Solution
[What are we building?]
## Target User
[Who benefits?]
## Success Criteria
[How do we know this worked?]
## Scope
### In Scope
- [specific feature]
### Out of Scope
- [explicitly excluded]
### Assumptions
- [assumption]
## User Stories
### Must Have
[user stories with acceptance criteria]
### Should Have
[user stories]
### Could Have
[user stories]
## Technical Considerations
[stack, integrations, data, constraints]
## Risks
[risk table]
## Timeline
[phased estimate]
## Open Questions
- [anything still unresolved]
---
Ready for review.
```
Output a summary and flag any open questions that need answers before work starts.

98
clowdex-download/.claude/.claude/commands/check-drift.md Normal file
View file

@ -0,0 +1,98 @@
---
description: Detect system configuration drift - find stale rules, contradictions, and orphans
argument-hint: ""
allowed-tools:
- Read
- Agent
- Glob
- Grep
- Bash(wc:*, find:*, date:*)
---
Self-monitoring command. Scans your entire Claude Code configuration for drift — stale rules, contradictions, orphaned files, and configuration inconsistencies.
## Steps
### Step 1: Scan system files (parallel)
Read all configuration sources simultaneously:
- `CLAUDE.md` — project instructions
- `.claude/memory.md` — active memory
- `.claude/knowledge-base.md` — learned rules
- `.claude/settings.json` — hooks configuration
- `.claude/command-index.md` — command registry (if exists)
### Step 2: Check for contradictions
**Within CLAUDE.md:**
- Are there conflicting instructions? (e.g., "always do X" and "never do X")
- Are there references to files or directories that don't exist?
- Are there references to commands or agents that aren't defined?
**Between CLAUDE.md and knowledge-base:**
- Does the knowledge base contain rules that contradict CLAUDE.md?
- Are there duplicate rules across both files?
**Between memory and reality:**
- Does memory reference tasks, files, or states that no longer exist?
- Are there "current focus" items that are clearly stale?
### Step 3: Check for orphans
Scan for:
- **Orphaned commands:** Files in `.claude/commands/` not referenced in command-index.md
- **Orphaned agents:** Agent definitions with no command or skill that invokes them
- **Orphaned skills:** Skills not referenced by any command, agent, or CLAUDE.md
- **Dead references:** Mentions of files, URLs, or paths that don't exist
- **Unused hooks:** Hook scripts that exist but aren't wired in settings.json
### Step 4: Check for staleness
- **Memory.md:** Is "Now" section from more than 3 days ago?
- **Knowledge-base entries:** Do any reference outdated tools, APIs, or patterns?
- **Daily notes:** Are there daily notes from 30+ days ago that should be archived?
- **Task Board:** Are there tasks that have been "in progress" for more than a week?
### Step 5: Check configuration health
- **settings.json:** Is it valid JSON? Are all hook scripts executable?
- **CLAUDE.md size:** Is it growing too large? (>500 lines is a warning)
- **Memory.md size:** Is it within limits? (<100 lines target)
- **Knowledge-base size:** Is it within limits? (<200 lines target)
### Step 6: Generate drift report
```markdown
# Drift Detection Report
**Date:** [date]
**Status:** [CLEAN / WARNINGS / ISSUES FOUND]
## Contradictions Found
- [contradiction with file references]
## Orphaned Items
- [orphaned file or reference]
## Stale Items
- [stale memory, task, or reference]
## Configuration Health
| Check | Status | Note |
|-------|--------|------|
| settings.json valid | Pass/Fail | |
| CLAUDE.md size | [lines] | [ok / warning] |
| memory.md size | [lines] | [ok / warning] |
| knowledge-base size | [lines] | [ok / warning] |
| Hook scripts executable | Pass/Fail | |
## Recommended Actions
1. [Specific fix]
2. [Specific fix]
3. [Specific fix]
---
Run monthly or when system behaviour feels off.
```
Output the status line and any critical issues. Offer to fix automatically if issues are simple.

87
clowdex-download/.claude/.claude/commands/create-playbook.md Normal file
View file

@ -0,0 +1,87 @@
---
description: Record a workflow and auto-generate a reusable command from it
argument-hint: "[name for the playbook]"
allowed-tools:
- Read
- Write
- Edit
- Glob
- Bash(date:*)
---
Watch a manual workflow, then auto-generate a reusable command from it. You describe the steps, this command turns them into a repeatable, documented procedure.
## Steps
### Step 1: Name the playbook
Get the playbook name from the argument. If not provided, ask what this workflow does in one sentence and derive a kebab-case name.
### Step 2: Capture the workflow
Ask the user to describe their workflow step by step. For each step, capture:
- **What:** The action taken
- **Where:** What file, tool, or system is involved
- **Why:** The purpose of this step
- **Inputs:** What information is needed
- **Output:** What this step produces
Guide them through it: "What do you do first?" → "Then what?" → "What happens next?"
Continue until they say they're done.
### Step 3: Identify patterns
Analyse the captured workflow:
- **Which steps can be parallelised?** (independent reads, searches)
- **Which steps need user input?** (decisions, approvals)
- **Which steps are conditional?** (only if X, then Y)
- **What tools does each step need?** (Read, Write, Agent, Bash, WebSearch, etc.)
- **Are there any existing skills that match steps?** (check `.claude/skills/`)
### Step 4: Determine the argument
What variable input does this workflow need each time it runs?
- A project name? A file path? A topic? A client name?
- Define the argument-hint that makes sense
### Step 5: Generate the command
Write the command file to `.claude/commands/[playbook-name].md`:
```markdown
---
description: [one-line description derived from the workflow]
argument-hint: "[identified argument]"
allowed-tools:
- [list of tools needed, derived from step analysis]
---
[Brief explanation of what this command does]
## Steps
### Step 1: [First action]
[Instructions derived from the captured workflow]
### Step 2: [Second action]
[Instructions]
[Continue for each step, with parallel steps marked]
### Step [N]: Output
[What the final output looks like]
```
### Step 6: Verify and refine
Show the generated command to the user:
- "Here's the command I generated. Does this capture your workflow correctly?"
- Make any adjustments they request
- Save the final version
### Step 7: Register the command
If a command-index.md exists, add the new command to it.
Output: "Your playbook is saved as `/[name]`. Run it any time to repeat this workflow."

84
clowdex-download/.claude/.claude/commands/end-day.md Normal file
View file

@ -0,0 +1,84 @@
---
description: End of day - sync memory, clear done list, externalize knowledge, prep tomorrow
argument-hint: ""
allowed-tools:
- Read
- Edit
- Write
- Bash(date:*)
- Agent
---
End-of-day ritual. Externalize knowledge, clean up, prepare for tomorrow.
## Steps
### Step 1: Read current state (parallel)
Read simultaneously:
- `.claude/memory.md`
- `Daily Notes/MMDDYY.md` (today)
- `Scratchpad.md`
- `Task Board.md`
### Step 2: Process remaining scratchpad items
Same as /sync Step 2. Clear everything — scratchpad should be empty at end of day.
### Step 3: Sync memory
Edit `.claude/memory.md`:
- Update "Now" to reflect where things stand
- Resolve completed Open Threads
- Prune stale Recent Decisions (older than 1 week)
- Clear resolved Blockers
### Step 4: Move completed tasks
In `Task Board.md`:
- Move all completed tasks from Today → Done
- Clear Done list if it's Friday
- Move incomplete Today items to This Week or Backlog with a note on why
### Step 5: Knowledge externalization
Review today's work for learnings:
- **User corrections**: Anything the user explicitly corrected → nominate to `.claude/knowledge-nominations.md`
- **Empirical discoveries**: Things proven through testing → nominate
- **Pattern observations**: Recurring patterns noticed → nominate
- **Failure lessons**: Root cause of any resolved failures → nominate
Format: `- [MMDDYY] /end-day: [learning] | Evidence: [source]`
### Step 6: Mandatory daily audit
Spawn the sentinel agent to review today's work:
```
Agent(sentinel): Review today's work in Daily Notes/MMDDYY.md. Check:
1. Were all tasks completed or properly deferred?
2. Were any knowledge-base rules violated?
3. Are there any pending nominations to review?
Tier: T1 (quick scan). Report findings.
```
### Step 7: Review incident log
Read `.claude/logs/incident-log.md`. Summarize any notable events.
### Step 8: Preview tomorrow
Based on Task Board and Open Threads, suggest 1-3 priorities for tomorrow.
Add them to Task Board → Today.
### Step 9: Update daily note
Add to `Daily Notes/MMDDYY.md` → End of Day Summary:
- Key accomplishments
- Decisions made
- Open items carried forward
- Tomorrow's priorities
### Step 10: Sign off
Brief message: what was accomplished today, what's next tomorrow.

90
clowdex-download/.claude/.claude/commands/flush.md Normal file
View file

@ -0,0 +1,90 @@
---
description: Safely flush context and resume fresh - distills session state before clearing
argument-hint: ""
allowed-tools:
- Read
- Edit
- Write
- Bash(date:*)
---
Persist session state then seamlessly resume work. The user should not notice this happening.
**Emergency mode** (compacting/prompt-too-long): Skip reads, distill from in-context memory only, go to Step 3.
---
## Steps
### Step 0: Reset gate + get date
```bash
date +"%m%d%y %H:%M" && rm -f ".claude/logs/.quality-gate-active" ".claude/logs/.session-blocks-$(date +"%m%d-%H")" ".claude/logs/.tool-call-count" ".claude/logs/.compaction-occurred"
```
### Step 1: Read state (parallel, skip in emergency)
Read simultaneously: `.claude/memory.md` + `Daily Notes/MMDDYY.md`
### Step 2: Distill session (from in-context memory)
Extract and compress using **restorable compression** — preserve retrieval paths so the resumed session can restore full context from compressed form:
1. **Task** — one sentence
2. **Done/remaining** — 2-4 bullets, conclusions not process
3. **Decisions** — one line each, WHAT+WHY not HOW
4. **Learnings** — rules/facts for knowledge-nominations
5. **Files touched** — full paths of every file read or modified (not just modified — include key files *read* that informed decisions). These are retrieval anchors for the resumed session.
6. **Active references** — URLs, API endpoints, external resources consulted. Drop content, keep the pointer.
7. **Next action** — precise, actionable instruction including which file(s) to read first
### Step 3: Write handoff to daily note
Append (or create new daily note if none exists):
```markdown
## Session Handoff — HH:MM
**Task:** [one sentence]
**Done:** [bullets]
**Remaining:** [bullets]
**Decisions:** [bullets]
**Files:** [full paths — both modified and key reads]
**Refs:** [URLs, external resources — pointers only, no content]
**Next:** [precise action + which file(s) to read first]
```
### Step 4: Update memory.md (only if changed)
New priorities, threads, decisions → edit. Nothing changed → skip.
### Step 5: Promote and nominate learnings (only if discovered)
**Two-tier promotion:**
**Tier 1: Immediate promotion to `knowledge-base.md`** (high-confidence rules):
- User overrides (explicitly corrected something)
- Empirical facts (verified through testing or data)
Write directly with `[Source: User directive MMDDYY]` or `[Source: Empirical MMDDYY]`.
**Tier 2: Nominate to `knowledge-nominations.md`** (lower-confidence):
- Agent inferences (patterns observed but not confirmed)
- Hypotheses (things that seem true but need more evidence)
Append: `- [MMDDYY] /flush: [learning] | Evidence: [source]`
**Rule: When in doubt, promote. A rule in knowledge-base.md that gets corrected later is better than a rule in nominations that never gets seen.**
### Step 6: Auto-resume (restorable decompression)
Do NOT output a resumption prompt. Do NOT ask the user anything. Instead:
1. Re-read `.claude/memory.md` and `.claude/knowledge-base.md` (compressed context reload)
2. Re-read the daily note handoff you just wrote (for the Next action)
3. **Restore from retrieval anchors** — re-read the file(s) specified in the **Next** field and any critical files from the **Files** list that the next action depends on. This is the decompression step: the handoff told you *what* happened; re-reading the files restores *how* to continue.
4. **Immediately execute the Next action** — pick up exactly where you left off
The user should experience a brief pause, then work continuing seamlessly. No visible "clearing" or "resuming" messages. Just keep working.
Target: 5-7 tool calls, <30 seconds. Emergency: 2-3 calls, <15 seconds.

105
clowdex-download/.claude/.claude/commands/handoff.md Normal file
View file

@ -0,0 +1,105 @@
---
description: Structured session handoff to another person or AI
argument-hint: "[who you're handing off to]"
allowed-tools:
- Read
- Write
- Edit
- Glob
- Grep
- Bash(git log:*, git status:*, git diff:*, date:*)
---
Generate a structured handoff briefing when passing work to another person or AI. Captures context, decisions, risks, and next steps so nothing gets lost in transition.
## Steps
### Step 1: Gather session context
Read:
- `.claude/memory.md` — current state
- Recent daily note — today's work log
- `Task Board.md` — active tasks and priorities
- `git status` and `git log --oneline -10` — recent changes
### Step 2: Identify what was done
From the session context and git history, list:
- **Completed:** Tasks finished in this session
- **In progress:** Work started but not finished (with current state)
- **Decisions made:** Choices and their rationale
- **Files touched:** Every file modified with a one-line summary of the change
### Step 3: Identify what's pending
- **Immediate next steps:** What should happen next (ordered)
- **Blocked items:** Tasks that can't proceed and why
- **Open questions:** Decisions that need input
- **Risks:** Anything that could go wrong if not handled
### Step 4: Context the recipient needs
- **Project context:** What is this project and what matters right now?
- **Key files:** Where to look for the most important things
- **Gotchas:** Non-obvious things that will trip someone up
- **Dependencies:** External people, services, or events this work depends on
### Step 5: Write the handoff
Save to `handoffs/handoff-[date]-[time].md`:
```markdown
# Session Handoff
**From:** [current session / your name]
**To:** [recipient if specified, otherwise "Next session"]
**Date:** [date and time]
---
## Status Summary
[2-3 sentences: where things stand right now]
## What Was Done
- [completed task with file references]
- [completed task]
## What's In Progress
- **[task]** — Current state: [where it's at]. Next action: [what to do next]
## Decisions Made
| Decision | Rationale | Reversible? |
|----------|-----------|-------------|
| [decision] | [why] | Yes/No |
## Files Changed
| File | Change |
|------|--------|
| [path] | [one-line summary] |
## Next Steps (Priority Order)
1. [Most important next action]
2. [Second priority]
3. [Third priority]
## Blocked Items
- **[item]** — Blocked by: [reason]. Unblock by: [action needed]
## Open Questions
- [Question that needs answering before proceeding]
## Risks
- [Risk and what to do about it]
## Key Files to Read
- [file] — [why it matters]
- [file] — [why it matters]
## Gotchas
- [Non-obvious thing that will trip you up]
---
Handoff complete. Read this before starting work.
```
Output the summary section so the user can verify it's accurate.

130
clowdex-download/.claude/.claude/commands/launch.md Normal file
View file

@ -0,0 +1,130 @@
---
description: Full product launch pipeline - from idea to go-to-market plan
argument-hint: "[product or feature to launch]"
allowed-tools:
- Read
- Write
- Edit
- Agent
- Glob
- Grep
- WebSearch
- WebFetch
- Bash(date:*)
---
Full launch pipeline. Takes a product or feature idea through competitive research, positioning, pricing analysis, and GTM planning.
## Steps
### Step 1: Capture the launch brief
If the user described what they're launching, use that. Otherwise ask for:
- What is the product/feature?
- Who is the target customer?
- What's the timeline?
Write a one-paragraph launch brief.
### Step 2: Competitive scan (parallel agents)
Spawn agents to research in parallel:
**Agent 1 — Competitor landscape:**
- Search for direct competitors (products solving the same problem)
- Extract pricing, features, positioning, strengths, weaknesses
- Identify gaps in the market
**Agent 2 — Market signals:**
- Search for recent trends in this space
- Look for demand signals (Reddit threads, HN discussions, Twitter conversations)
- Note any regulatory or platform changes that affect timing
### Step 3: Positioning
Based on competitive findings, define:
- **Category:** What market category does this belong to?
- **Differentiation:** What do you do that competitors don't?
- **Value prop:** One sentence that makes a customer say "I need this"
- **Positioning statement:** For [target], [product] is the [category] that [key benefit] unlike [alternative] because [reason]
### Step 4: Pricing analysis
Using competitor pricing data:
- Map competitor price points (free tier, entry, pro, enterprise)
- Identify the price range your market expects
- Recommend a pricing strategy with rationale
- Include pricing model (one-time, subscription, usage-based, freemium)
### Step 5: Landing page brief
Generate a structured landing page outline:
1. **Hero:** Headline, subheading, primary CTA
2. **Pain points:** 3-4 problems your target customer has
3. **Solution:** How your product solves them
4. **Features:** Top 5-6 features with benefits (not just descriptions)
5. **Social proof:** What type of proof would work (testimonials, stats, logos)
6. **Pricing:** Based on Step 4 analysis
7. **FAQ:** 5-6 questions your target customer would ask
8. **Final CTA:** Closing push
### Step 6: Go-to-market checklist
Generate a phased launch checklist:
**Pre-launch (2-4 weeks before):**
- [ ] Landing page live
- [ ] Email capture / waitlist set up
- [ ] Launch announcement drafted
- [ ] Distribution channels identified (communities, newsletters, social)
- [ ] Early access / beta users lined up
**Launch day:**
- [ ] Announce on primary channels
- [ ] Post on Product Hunt / HN / relevant communities
- [ ] Email waitlist
- [ ] Monitor for issues
- [ ] Respond to early feedback
**Post-launch (1-2 weeks after):**
- [ ] Collect and address feedback
- [ ] Publish case studies / results
- [ ] Optimise based on conversion data
- [ ] Follow up with early users
### Step 7: Write the launch plan
Save everything to `launch-plan-[product-name].md`:
```markdown
# Launch Plan — [Product Name]
## Brief
[one paragraph]
## Competitive Landscape
[table of competitors with pricing/features/positioning]
## Positioning
[positioning statement and differentiation]
## Pricing Strategy
[recommended pricing with rationale]
## Landing Page Brief
[structured outline from Step 5]
## Go-to-Market Checklist
[phased checklist from Step 6]
## Timeline
[key dates and milestones]
## Risks
[top 3 risks and mitigations]
---
Generated: [date]
```
Output a summary of the plan and ask the user what to execute first.

133
clowdex-download/.claude/.claude/commands/market-scan.md Normal file
View file

@ -0,0 +1,133 @@
---
description: Deep competitive analysis - research, compare, strategise
argument-hint: "[your product or market]"
allowed-tools:
- Read
- Write
- Edit
- Agent
- Glob
- WebSearch
- WebFetch
- Bash(date:*)
---
Deep competitive intelligence. Research competitors, extract positioning and pricing, generate strategic comparison and recommendations.
## Steps
### Step 1: Define the competitive frame
Clarify:
- **Your product/service:** What are you competing with?
- **Market category:** What space are you in?
- **Known competitors:** Any the user already knows about?
### Step 2: Research competitors (parallel agents)
Spawn 2-3 agents to research in parallel:
**Agent 1 — Direct competitors:**
- Search for products/services in the same category
- For each: name, URL, pricing, key features, target customer, funding/size
- Look at their landing pages, pricing pages, feature pages
**Agent 2 — Adjacent competitors:**
- Search for alternative approaches to the same problem
- Products in adjacent categories that could expand into this space
- Open-source alternatives
**Agent 3 — Market context:**
- Recent news, launches, shutdowns in this space
- Analyst reports or market sizing data
- Customer sentiment (reviews, Reddit, Twitter)
### Step 3: Build the comparison matrix
Create a structured comparison:
| Dimension | Your Product | Competitor A | Competitor B | Competitor C |
|-----------|-------------|-------------|-------------|-------------|
| **Price** | | | | |
| **Target customer** | | | | |
| **Key differentiator** | | | | |
| **Strengths** | | | | |
| **Weaknesses** | | | | |
| **Feature 1** | | | | |
| **Feature 2** | | | | |
### Step 4: Identify strategic insights
Analyse the comparison for:
**Gaps you can exploit:**
- Features competitors lack that customers want
- Price points nobody serves
- Customer segments being ignored
- Positioning angles nobody owns
**Threats to watch:**
- Well-funded competitors making moves
- Feature convergence (everyone building the same thing)
- Platform risk (dependency on a platform that could compete)
**Your unfair advantages:**
- What do you have that's hard to replicate?
- Speed, expertise, network, data, positioning?
### Step 5: Strategic recommendations
Based on the analysis:
1. **Positioning recommendation:** How to position against the field
2. **Pricing recommendation:** Where to price and why
3. **Feature priority:** What to build (and not build) based on competitive gaps
4. **Messaging:** Key claims that differentiate you
5. **Watch list:** Competitors to monitor closely and triggers for action
### Step 6: Write the intel report
Save to `market-scan-[market].md`:
```markdown
# Competitive Intelligence — [Market/Product]
**Date:** [date]
## Market Overview
[2-3 sentences on the competitive landscape]
## Competitor Profiles
### [Competitor 1]
- **URL:** [url]
- **Pricing:** [pricing model and range]
- **Target:** [who they serve]
- **Strengths:** [bullets]
- **Weaknesses:** [bullets]
[Repeat for each competitor]
## Comparison Matrix
[Table from Step 3]
## Strategic Insights
### Gaps to Exploit
[bullets]
### Threats to Watch
[bullets]
### Your Advantages
[bullets]
## Recommendations
1. [Specific, actionable recommendation]
2. [Specific, actionable recommendation]
3. [Specific, actionable recommendation]
---
Sources: [list all URLs and sources used]
```
Output a summary of key findings and top recommendation.

125
clowdex-download/.claude/.claude/commands/onboard.md Normal file
View file

@ -0,0 +1,125 @@
---
description: Onboard to a new codebase - architecture scan, key decisions, first tasks
argument-hint: "[project directory or repo URL]"
allowed-tools:
- Read
- Agent
- Glob
- Grep
- Bash(git log:*, find:*, wc:*, ls:*)
---
New project onboarding. Scans a codebase and generates a comprehensive orientation: architecture, key decisions, dependency map, environment setup, and first tasks.
## Steps
### Step 1: Locate the project
If the user specified a directory, use that. Otherwise, use the current working directory.
Verify it's a real project (has package.json, Cargo.toml, pyproject.toml, go.mod, or equivalent).
### Step 2: Structural scan (parallel)
**Scan 1 — Project identity:**
- Read README, CONTRIBUTING, CHANGELOG if they exist
- Read package.json / Cargo.toml / pyproject.toml for metadata
- Identify: language, framework, build tool, test framework
- Count: total files, lines of code, number of dependencies
**Scan 2 — Architecture:**
- Map the directory structure (top 3 levels)
- Identify architectural pattern (MVC, hexagonal, monolith, microservices, serverless)
- Find entry points (main files, route definitions, handlers)
- Locate config files (env, yaml, json configs)
**Scan 3 — Key files:**
- Find the 10 most-changed files (`git log --format='' --name-only | sort | uniq -c | sort -rn | head -20`)
- Find the largest files (likely important or problematic)
- Locate test directories and test patterns
### Step 3: Dependency analysis
- List direct dependencies with versions
- Flag any outdated or deprecated packages (check for major version gaps)
- Identify critical dependencies (the ones the project can't function without)
- Note any unusual or niche dependencies worth understanding
### Step 4: Code patterns
Read 3-5 representative files to identify:
- Naming conventions (camelCase, snake_case, etc.)
- Error handling patterns
- Logging approach
- State management (if frontend)
- Database access patterns (if backend)
- Authentication / authorisation approach
### Step 5: Git archaeology
```bash
git log --oneline -20
```
From recent history:
- What's being actively worked on?
- Who are the main contributors?
- What's the commit style? (conventional commits, free-form, etc.)
- Any long-running branches?
### Step 6: Generate the onboarding guide
Save to `ONBOARDING.md` (or output directly):
```markdown
# Onboarding Guide — [Project Name]
## Quick Facts
- **Language:** [lang] / **Framework:** [framework]
- **Architecture:** [pattern]
- **Lines of code:** [count]
- **Dependencies:** [count direct]
- **Test framework:** [framework]
- **Build tool:** [tool]
## Project Structure
```
[directory tree, top 3 levels, annotated]
```
## Key Files to Read First
1. **[file]** — [why it matters]
2. **[file]** — [why it matters]
3. **[file]** — [why it matters]
4. **[file]** — [why it matters]
5. **[file]** — [why it matters]
## Architecture Overview
[2-3 paragraphs explaining how the system works]
## Code Patterns
- **Naming:** [convention]
- **Error handling:** [pattern]
- **State:** [approach]
- **Auth:** [approach]
## Environment Setup
1. [Step to get running locally]
2. [Step]
3. [Step]
## First Tasks to Tackle
These are good starter tasks to build familiarity:
1. [Specific, small task with file reference]
2. [Specific, small task with file reference]
3. [Specific, small task with file reference]
## Watch Out For
- [Gotcha or non-obvious pattern]
- [Gotcha or non-obvious pattern]
---
Generated: [date]
```
Output a brief summary and highlight the most important thing to understand about this codebase.

131
clowdex-download/.claude/.claude/commands/proposal.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Generate a client proposal from a project brief
argument-hint: "[project or client name]"
allowed-tools:
- Read
- Write
- Edit
- Agent
- Glob
- Bash(date:*)
---
Turn a rough brief into a structured client proposal with scope, timeline, deliverables, and pricing.
## Steps
### Step 1: Gather the brief
If the user provided project details, use those. Otherwise, ask for:
- Client / project name
- What do they need? (the problem)
- What's the desired outcome?
- Any constraints (budget range, timeline, technical requirements)?
### Step 2: Scope definition
Break the project into phases and deliverables:
For each phase:
- **Phase name** and duration
- **Deliverables** — specific, tangible outputs
- **Dependencies** — what's needed to start this phase
- **Assumptions** — what you're assuming to be true
Flag anything that could cause scope creep. Be explicit about what's included and what isn't.
### Step 3: Timeline
Create a realistic timeline:
- Map phases to calendar weeks
- Identify milestones (decision points, reviews, handoffs)
- Build in buffer for feedback rounds
- Note any hard deadlines or dependencies on the client
### Step 4: Pricing
Structure the pricing:
- **Option A (Recommended):** Full scope as described
- **Option B:** Reduced scope (MVP / Phase 1 only)
- **Optional add-ons:** Additional services that complement the core work
For each option, list: total price, payment schedule, what's included, what's not.
### Step 5: Terms
Standard terms to include:
- Payment schedule and terms
- Revision policy (how many rounds of revisions)
- Ownership / IP transfer
- Timeline for acceptance / sign-off
- Cancellation terms
### Step 6: Write the proposal
Save to `proposals/[client-name]-proposal.md`:
```markdown
# Proposal — [Project Name]
**Prepared for:** [Client]
**Prepared by:** [Your name/company]
**Date:** [date]
---
## Executive Summary
[2-3 sentences: the problem, your solution, expected outcome]
## Understanding
[Restate the client's problem in your words — proves you listened]
## Approach
### Phase 1: [Name] — [duration]
**Deliverables:**
- [specific output]
- [specific output]
### Phase 2: [Name] — [duration]
**Deliverables:**
- [specific output]
- [specific output]
[Continue for each phase]
## Timeline
| Phase | Duration | Milestone |
|-------|----------|-----------|
| [Phase 1] | [weeks] | [key deliverable] |
## Investment
### Option A: Full Scope (Recommended)
[price, payment schedule, what's included]
### Option B: Phase 1 Only
[price, payment schedule, what's included]
### Optional Add-ons
- [add-on]: [price]
## Terms
- [Payment terms]
- [Revision policy]
- [Ownership]
## Next Steps
1. Review this proposal
2. [Specific action to proceed]
3. Kick-off call to align on details
---
Valid for 30 days from date above.
```
Output a summary and tell the user where the file is saved.

107
clowdex-download/.claude/.claude/commands/release.md Normal file
View file

@ -0,0 +1,107 @@
---
description: Generate audience-aware release notes from git history
argument-hint: "[version or date range]"
allowed-tools:
- Read
- Write
- Edit
- Glob
- Grep
- Bash(git log:*, git tag:*, git diff:*, date:*)
---
Auto-generate release notes from git history. Produces audience-appropriate versions — technical changelog, marketing announcement, or executive summary — from the same data.
## Steps
### Step 1: Determine the range
Figure out what commits to include:
- If user specified a version → find the tag range (e.g., `git log v1.2.0..v1.3.0`)
- If user specified dates → use date range (`git log --after="2025-01-01" --before="2025-02-01"`)
- If nothing specified → changes since last tag (`git log $(git describe --tags --abbrev=0)..HEAD`)
### Step 2: Gather commit data
```bash
git log [range] --format="%h %s" --no-merges
```
Also check:
- PR descriptions if available (`git log --merges` for merge commit messages)
- Any CHANGELOG entries
- Modified files to understand scope (`git diff --stat [range]`)
### Step 3: Categorise changes
Sort every change into:
| Category | Icon | Example |
|----------|------|---------|
| **New Features** | Added | New capability, new endpoint, new component |
| **Improvements** | Changed | Performance boost, UX improvement, refactor |
| **Bug Fixes** | Fixed | Resolved issue, corrected behaviour |
| **Breaking Changes** | Breaking | API change, removed feature, migration needed |
| **Dependencies** | Deps | Updated packages, new dependencies |
| **Internal** | Internal | Tests, CI, docs, refactoring |
### Step 4: Write release notes (3 versions)
**Version 1 — Technical Changelog** (for developers):
```markdown
# [Version] — [Date]
## Breaking Changes
- [change with migration instructions]
## New Features
- [feature]: [description] ([commit hash])
## Improvements
- [improvement] ([commit hash])
## Bug Fixes
- [fix] ([commit hash])
## Dependencies
- Updated [package] from [old] to [new]
```
**Version 2 — Marketing Announcement** (for customers/public):
```markdown
# What's New in [Version]
[1-2 sentence hook — the most exciting change]
### [Feature Name]
[Benefit-focused description — what it means for the user, not how it works]
### [Improvement]
[User-facing improvement with before/after if applicable]
### Bug Fixes
[Summary — "Fixed X issues including..." — no commit hashes]
```
**Version 3 — Executive Summary** (for stakeholders):
```markdown
# Release Summary — [Version]
**Impact:** [one sentence — what this release accomplishes]
**Key changes:**
- [Top 3 changes, business-impact framing]
**Metrics:**
- [X] features added
- [X] bugs fixed
- [X] files changed
**Risk:** [any breaking changes or migration needs — or "None"]
```
### Step 5: Save and output
Save to `releases/[version]-release-notes.md` with all three versions.
Output the marketing version by default (most commonly needed), and mention the other versions are in the file.

112
clowdex-download/.claude/.claude/commands/report.md Normal file
View file

@ -0,0 +1,112 @@
---
description: Generate a professional report from data or findings - audience-aware
argument-hint: "[topic and audience]"
allowed-tools:
- Read
- Write
- Edit
- Agent
- Glob
- Grep
- Bash(date:*)
---
Turn raw data, findings, or research into a polished narrative report. Adapts tone and depth for the target audience.
## Steps
### Step 1: Clarify inputs
Identify:
- **Topic:** What is this report about?
- **Data sources:** What files, findings, or data should feed into it?
- **Audience:** Who is reading this? (executive, technical team, client, board, general)
- **Format preference:** Brief (1-2 pages), standard (3-5 pages), or comprehensive (5+ pages)
If the user didn't specify an audience, default to "professional — clear, direct, no jargon."
### Step 2: Gather source material
Read all relevant files and data. Scan for:
- Key findings and metrics
- Patterns and trends
- Comparisons (before/after, vs. benchmark, vs. competitor)
- Anomalies or concerns
- Recommendations that emerge from the data
### Step 3: Structure for the audience
**Executive audience:**
- Lead with the bottom line (recommendation or key finding)
- Use bullet points over paragraphs
- Include only metrics that drive decisions
- Keep under 2 pages
- End with clear next steps
**Technical audience:**
- Lead with methodology
- Include detailed data and analysis
- Show your work (how you reached conclusions)
- Include caveats and limitations
- Reference source files
**Client audience:**
- Lead with what matters to them (results, ROI, impact)
- Use their language, not yours
- Contextualise numbers ("+15% vs industry average of +3%")
- Include visual formatting (tables, bold key numbers)
- End with what happens next
### Step 4: Write the report
```markdown
# [Report Title]
**Date:** [date]
**Prepared for:** [audience]
---
## Summary
[2-3 sentences: key finding, core recommendation, bottom line]
## Key Findings
### [Finding 1]
[Data, context, significance]
### [Finding 2]
[Data, context, significance]
### [Finding 3]
[Data, context, significance]
## Analysis
[Deeper interpretation — what the findings mean, patterns, comparisons]
## Recommendations
1. **[Action]** — [rationale and expected impact]
2. **[Action]** — [rationale and expected impact]
3. **[Action]** — [rationale and expected impact]
## Next Steps
- [ ] [Specific action with owner/timeline]
---
Sources: [list data sources used]
```
### Step 5: Quality check
Before delivering, verify:
- [ ] Every claim has supporting data
- [ ] No jargon the audience wouldn't understand
- [ ] Recommendations are actionable (not vague)
- [ ] Numbers are consistent throughout
- [ ] Report answers "so what?" — not just "what"
Save to `reports/[topic]-report.md` and output a summary.

85
clowdex-download/.claude/.claude/commands/retro.md Normal file
View file

@ -0,0 +1,85 @@
---
description: Sprint retrospective - review what worked, what didn't, improve process
argument-hint: "[time period]"
allowed-tools:
- Read
- Write
- Edit
- Glob
- Agent
- Bash(date:*)
---
Retrospective analysis. Review a time period, extract patterns, improve the system.
## Steps
### Step 1: Determine scope
If user specified a time period, use that. Otherwise default to "this week."
### Step 2: Gather data (parallel reads)
Read simultaneously:
- Recent daily notes (last 5-7 days)
- `.claude/logs/verdicts.jsonl` (session quality trends)
- `.claude/logs/incident-log.md` (issues and blocks)
- `.claude/logs/failure-log.md` (tool failures)
- `.claude/knowledge-nominations.md` (pending learnings)
- `Task Board.md` (completion rate)
### Step 3: Analyze patterns
**What went well?**
- Tasks completed on time
- Smooth workflows (no blocks)
- Learnings successfully captured
- Quality verdicts trending positive
**What didn't go well?**
- Repeated failures (same error type)
- Blocked commands that should have been allowed
- Tasks that took much longer than expected
- Context flushes (/flush) needed frequently
- Quality verdict blocks
**What to change?**
- Are there process bottlenecks?
- Are hooks too strict or too lenient?
- Are agents missing capabilities?
- Are commands missing or underused?
### Step 4: Extract improvements
For each identified improvement:
1. Is it a **knowledge-base rule**? → Promote directly
2. Is it a **process change**? → Add to Scratchpad for user review
3. Is it a **tool/config change**? → Create task on Task Board
4. Is it a **pattern to watch**? → Nominate to knowledge-nominations
### Step 5: Write retro report
Add to daily note:
```markdown
## Retrospective — [period]
### Went Well
- [bullets]
### Didn't Go Well
- [bullets]
### Action Items
- [ ] [specific improvement with owner]
### Metrics
- Tasks completed: [X]
- Quality verdict pass rate: [X]%
- Incidents: [X] (CRITICAL: [X], HIGH: [X])
- Context flushes: [X]
```
### Step 6: Create action items
Add any actionable improvements to `Task Board.md` → This Week.

100
clowdex-download/.claude/.claude/commands/review.md Normal file
View file

@ -0,0 +1,100 @@
---
description: Deep code review - security, performance, architecture, and actionable fixes
argument-hint: "[file, directory, or PR]"
allowed-tools:
- Read
- Agent
- Glob
- Grep
- Bash(git diff:*, git log:*, git show:*)
---
Comprehensive code review. Goes beyond style — checks security, performance, architecture, and generates actionable improvement suggestions.
## Steps
### Step 1: Determine scope
Identify what to review:
- If user specified a file or directory → review that
- If user specified a PR or branch → `git diff main...HEAD` (or appropriate base)
- If nothing specified → review staged changes (`git diff --cached`) or recent commits
### Step 2: Read the code
Read all files in scope. For large diffs, focus on:
- New files (highest risk — no prior review)
- Files with the most changes
- Test files (or lack thereof)
### Step 3: Multi-dimensional review (parallel agents)
Spawn parallel review agents:
**Agent 1 — Security review:**
- Input validation (SQL injection, XSS, command injection)
- Authentication / authorisation gaps
- Secrets or credentials in code
- Unsafe dependencies
- OWASP Top 10 checklist
**Agent 2 — Performance review:**
- N+1 queries or unnecessary database calls
- Missing indexes (if schema visible)
- Unbounded loops or recursion
- Large memory allocations
- Missing caching opportunities
- Unnecessary re-renders (React) or recomputations
**Agent 3 — Architecture review:**
- Does this follow existing patterns in the codebase?
- Is responsibility clearly separated?
- Are there circular dependencies?
- Is the abstraction level appropriate? (over-engineered or under-abstracted)
- Will this be easy to test, debug, and maintain?
### Step 4: Compile findings
Categorise each finding:
| Severity | Meaning |
|----------|---------|
| **CRITICAL** | Must fix before merge — security vulnerability, data loss risk, breaking bug |
| **HIGH** | Should fix — performance issue, architectural concern, maintainability problem |
| **MEDIUM** | Consider fixing — code smell, minor inefficiency, readability improvement |
| **LOW** | Nit — style preference, naming suggestion, comment improvement |
### Step 5: Generate the review
Output a structured review:
```markdown
## Code Review — [scope]
### Summary
[1-2 sentences: overall assessment and top concern]
### Critical Issues
- **[File:line]** — [issue and why it matters]
**Fix:** [specific code suggestion]
### High Priority
- **[File:line]** — [issue]
**Fix:** [suggestion]
### Medium Priority
- [bullets]
### What's Good
- [specific things done well — always include positives]
### Verdict
[APPROVE / APPROVE WITH CHANGES / REQUEST CHANGES]
[One sentence rationale]
```
### Step 6: Offer to fix
Ask the user: "Want me to fix the critical and high-priority issues now?"
If yes, apply fixes directly. If no, the review stands as documentation.

74
clowdex-download/.claude/.claude/commands/standup.md Normal file
View file

@ -0,0 +1,74 @@
---
description: Quick daily standup - yesterday, today, blockers from git and tasks
argument-hint: ""
allowed-tools:
- Read
- Edit
- Glob
- Bash(git log:*, date:*)
---
Automated daily standup. Pulls from git history and task board to generate yesterday/today/blockers in 30 seconds.
## Steps
### Step 1: Get the date context
```bash
date +"%m%d%y %A"
```
Determine yesterday (skip weekends if today is Monday → use Friday).
### Step 2: Gather data (parallel)
**Git activity (yesterday):**
```bash
git log --after="yesterday 00:00" --before="today 00:00" --oneline --no-merges
```
If no commits yesterday, try the last 2 days.
**Task Board:**
Read `Task Board.md`:
- Items marked done recently
- Items currently in progress
- Items marked blocked
**Daily note (yesterday):**
Read yesterday's daily note if it exists — scan for decisions, notes, and end-of-day summary.
**Memory:**
Read `.claude/memory.md` → Now section for current focus.
### Step 3: Generate the standup
Format:
```markdown
## Standup — [Day, Date]
### Yesterday
- [What was accomplished — from git commits and task board]
- [Each item as a bullet, combining related commits]
### Today
- [Priority tasks from task board and memory]
- [Ordered by importance]
### Blockers
- [Anything marked blocked or flagged as waiting]
- [Or "None" if clear]
```
### Step 4: Append to daily note
Add the standup to today's daily note under a `## Standup` section.
If no daily note exists for today, create one first (follow the format from `/start`).
### Step 5: Output
Print the standup concisely. Keep it under 10 lines — standups should be fast.
If there are blockers, highlight them. If everything is clear, say so.

73
clowdex-download/.claude/.claude/commands/start.md Normal file
View file

@ -0,0 +1,73 @@
---
description: Start the day - load memory, open task board, ready to work
argument-hint: ""
allowed-tools:
- Read
- Edit
- Write
- Bash(date:*)
---
Begin a working session. Load context, create today's daily note, review tasks.
## Steps
### Step 1: Get today's date
```bash
date +"%m%d%y %H:%M %A"
```
### Step 2: Load memory (parallel reads)
Read simultaneously:
- `.claude/memory.md`
- `.claude/knowledge-base.md`
These are your working context. Knowledge-base entries are mandatory constraints.
### Step 3: Create daily note
Create `Daily Notes/MMDDYY.md` (if it doesn't exist):
```markdown
# MMDDYY - Daily Work Log
## Decisions
-
## Meetings & Conversations
-
## Notes
-
## End of Day Summary
-
```
### Step 4: Open task board
Read `Task Board.md`. Scan for:
- Overdue items (anything from previous days still open)
- Today's priorities
- Blocked items
### Step 5: Task review
For each task in Today:
1. Is it still relevant?
2. Do I have what I need to start?
3. Are there dependencies?
Move stale tasks to Backlog. Flag blocked items.
### Step 6: Ready to work
Output a brief orientation:
- What day it is
- Top 1-3 priorities for today
- Any blockers or open threads from memory.md
- "Ready to work. What's first?"
Keep it short. The user wants to start working, not read a report.

77
clowdex-download/.claude/.claude/commands/sync.md Normal file
View file

@ -0,0 +1,77 @@
---
description: Mid-day sync - review daily note, update memory, process notes
argument-hint: ""
allowed-tools:
- Read
- Edit
- Write
- Bash(date:*)
---
Mid-day context refresh. Process captured notes, update memory, health check.
## Steps
### Step 1: Read current state (parallel)
Read simultaneously:
- `.claude/memory.md`
- `Daily Notes/MMDDYY.md` (today's date)
- `Scratchpad.md`
### Step 2: Process scratchpad
For each item in Scratchpad:
- Is it a task? → Move to Task Board
- Is it a decision? → Add to Daily Note → Decisions
- Is it a learning? → Nominate to `.claude/knowledge-nominations.md`
- Is it a note? → Add to Daily Note → Notes
- Is it stale? → Delete
Clear processed items from Scratchpad.
### Step 3: Scan task board
Read `Task Board.md`:
- Move completed tasks from Today → Done
- Flag any tasks that are blocked
- Check if priorities have shifted
### Step 4: Context health check
Self-assess:
- Am I still oriented on the right problem?
- Have I been going in circles on anything?
- Is my context getting heavy? (If yes, consider `/flush` after sync)
### Step 5: Orientation check (Boyd's Law)
Ask yourself:
- What has changed since this morning?
- What assumptions am I making that might be wrong?
- What's the simplest next action?
### Step 6: Update memory
Edit `.claude/memory.md`:
- Update "Now" with current focus
- Add/resolve items in "Open Threads"
- Record any new decisions in "Recent Decisions"
- Update "Blockers" if anything changed
### Step 7: Review incident log
Read `.claude/logs/incident-log.md` (if it exists). Look for:
- Repeated failures (same error 3+ times)
- Blocked commands that should be allowed (or vice versa)
- Any CRITICAL severity events
Report anything noteworthy to the user.
### Step 8: Status report
Brief summary:
- What was accomplished this morning
- Current focus
- Any blockers or changes in priority
- Suggested next action

92
clowdex-download/.claude/.claude/commands/system-audit.md Normal file
View file

@ -0,0 +1,92 @@
---
description: Deep infrastructure audit of the entire operating system
argument-hint: ""
allowed-tools:
- Read
- Glob
- Grep
- Agent
- Write
- Edit
- Bash(date:*,wc:*,find:*)
---
Comprehensive infrastructure audit. Run monthly or after major system changes.
## Checks
### Check 1: Agent Health
- Read every file in `.claude/agents/*.md`
- Verify each has valid frontmatter (---)
- Verify no TBD/TODO markers
- Check that referenced tools exist
- Check agent-memory directories exist for agents that need them
### Check 2: Command Health
- Read every file in `.claude/commands/*.md`
- Verify each has valid frontmatter
- Check that allowed-tools are reasonable
- Verify no broken cross-references to other commands
### Check 3: Hook Health
- Verify `.claude/settings.json` is valid JSON
- Check every hook script referenced in settings.json exists
- Verify all hook scripts are executable (chmod +x)
- Run a dry test: each hook should exit 0 with empty input
### Check 4: Memory Tier Health
- `memory.md`: Is it under 100 lines? Is "Now" current?
- `knowledge-base.md`: Is it under 200 lines? Do all entries have [Source:]?
- `knowledge-nominations.md`: Are there stale nominations (>30 days)?
- `agent-memory/`: Do directories match existing agents?
- Daily Notes: Are recent notes present?
### Check 5: Log Health
- `audit-trail.md`: Is it under 5000 lines?
- `incident-log.md`: Are there unresolved CRITICAL/HIGH events?
- `failure-log.md`: Are there recurring patterns?
- `verdicts.jsonl`: What's the block rate? Any task-type clustering?
### Check 6: Permission & Config Coherence
- `.claude/settings.json` hooks match actual hook files
- No orphaned hook scripts (exist but not referenced)
- No missing hook scripts (referenced but don't exist)
### Check 7: Cross-File Coherence
- CLAUDE.md references match actual file locations
- Command-index.md matches actual commands
- No circular dependencies between commands
### Check 8: Backup & Storage
- `.claude/backups/`: Is auto-pruning working? (no dirs >7 days old)
- Large files in project root that shouldn't be there?
### Check 9: Via Negativa Sweep
- Are there files/agents/commands that are never used?
- Could any hook be removed without loss?
- Is there duplicated logic between agents?
- Propose removals — simpler is better
## Grading
| Grade | Criteria |
|-------|----------|
| A | All checks pass, no issues |
| B | Minor issues only (cosmetic, non-blocking) |
| C | Some issues need attention (missing provenance, stale nominations) |
| D | Structural issues (broken hooks, invalid JSON, missing agents) |
| F | Critical failures (security issues, data loss risk) |
## Output
Write results to daily note under:
```markdown
## System Audit — MMDDYY
**Grade:** [A-F]
**Checks:** [passed]/9
**Issues:** [bullets with severity]
**Actions:** [corrective tasks, if any]
```
Create corrective tasks on Task Board for any D or F grade issues.

116
clowdex-download/.claude/.claude/commands/tech-debt.md Normal file
View file

@ -0,0 +1,116 @@
---
description: Map and prioritise technical debt across your codebase
argument-hint: "[directory or project]"
allowed-tools:
- Read
- Agent
- Glob
- Grep
- Bash(git log:*, wc:*, find:*)
---
Scan a codebase for technical debt. Score files by complexity, test coverage, age, and known issues. Output a prioritised debt payoff plan.
## Steps
### Step 1: Define scope
If the user specified a directory, use that. Otherwise scan the entire project (excluding node_modules, .git, vendor, build directories).
### Step 2: Automated scans (parallel agents)
**Agent 1 — TODO/FIXME/HACK scan:**
- Search for TODO, FIXME, HACK, XXX, TEMP, WORKAROUND comments
- For each: file, line, content, age (git blame)
- Categorise: technical debt, missing feature, known bug, cleanup needed
**Agent 2 — Complexity hotspots:**
- Find the largest files (by line count)
- Find files with the deepest nesting (proxy for complexity)
- Find files with the most functions/methods
- Identify files changed most frequently (`git log --format='' --name-only | sort | uniq -c | sort -rn | head -20`)
- Cross-reference: files that are BOTH complex AND frequently changed are top priority
**Agent 3 — Code health signals:**
- Check for deprecated API usage (grep for @deprecated, console.warn deprecation patterns)
- Find unused exports or dead code patterns
- Check dependency health (outdated packages in package.json / requirements.txt)
- Look for duplicated code patterns (similar function signatures, copy-paste indicators)
### Step 3: Score each debt item
Score on two dimensions:
**Impact (how much it hurts):**
- 3 = Affects users, causes bugs, blocks features
- 2 = Slows development, makes changes risky
- 1 = Code smell, readability issue, style concern
**Effort (how hard to fix):**
- 3 = Major refactor, multiple files, breaking changes
- 2 = Moderate work, contained to one area
- 1 = Quick fix, under an hour
**Priority = Impact / Effort** — high impact + low effort = fix first.
### Step 4: Generate the debt map
```markdown
# Technical Debt Map — [Project]
**Date:** [date]
**Files scanned:** [count]
**Debt items found:** [count]
## Summary
- **Critical (fix now):** [count]
- **High (fix this sprint):** [count]
- **Medium (schedule it):** [count]
- **Low (when convenient):** [count]
## Hotspots
Files with the most concentrated debt:
| File | Debt Items | Complexity | Change Frequency | Priority |
|------|-----------|------------|-----------------|----------|
| [file] | [count] | [high/med/low] | [commits/month] | Critical |
## Debt Inventory
### Critical Priority
1. **[file:line]** — [description]
- Impact: [3] / Effort: [1]
- Recommendation: [specific action]
### High Priority
[items]
### Medium Priority
[items]
### Low Priority
[items]
## Payoff Plan
### This Week
- [ ] [specific fix with file reference]
- [ ] [specific fix]
### This Month
- [ ] [larger refactor]
- [ ] [dependency updates]
### Backlog
- [ ] [items to schedule later]
## Metrics to Track
- Total TODO/FIXME count (currently: [X])
- Average file complexity score
- Outdated dependency count (currently: [X])
---
Re-run this command monthly to track progress.
```
Output the summary and top 3 items to fix first.

64
clowdex-download/.claude/.claude/commands/unstick.md Normal file
View file

@ -0,0 +1,64 @@
---
description: When you're stuck on a problem - get unstuck fast
argument-hint: "[what you're stuck on]"
allowed-tools:
- Read
- Agent
- Grep
- Glob
- WebSearch
---
Break through a block. Uses the Pathfinder agent for root-cause analysis and fresh approaches.
## Steps
### Step 1: Capture the stuck state
If the user described what they're stuck on, use that. Otherwise, infer from:
- Current memory.md → Now
- Recent daily note entries
- Last few tool calls in context
Articulate the block in one sentence: "I'm stuck on [X] because [Y]."
### Step 2: Classify the block
| Type | Signals | Approach |
|------|---------|----------|
| **Knowledge gap** | "I don't know how to..." | Search docs, read source, check knowledge-base |
| **Decision paralysis** | "I can't decide between..." | List tradeoffs, pick the reversible option |
| **Circular debugging** | Same error 3+ times | Step back, restate the problem, try opposite approach |
| **Scope confusion** | "This is bigger than I thought" | Scope check — are you solving the right problem? |
| **Environmental** | Build/deploy/config issues | Check logs, verify prerequisites, try clean state |
### Step 3: Deploy the Pathfinder
Spawn the pathfinder agent:
```
Agent(pathfinder): I'm stuck on [problem].
What I've tried: [list attempts]
Error/symptom: [what's happening]
Expected: [what should happen]
Break this down. What am I missing?
```
### Step 4: Execute the suggestion
Take the pathfinder's top recommendation and try it immediately.
Don't deliberate — act. The fastest way out of stuck is through.
### Step 5: Log the resolution
If resolved, add to daily note:
```markdown
### Unstick — HH:MM
- **Block:** [what was stuck]
- **Root cause:** [why]
- **Fix:** [what worked]
```
If the fix reveals a pattern, nominate to knowledge-nominations.md.

29
clowdex-download/.claude/.claude/hooks/backup-before-write.sh Executable file
View file

@ -0,0 +1,29 @@
#!/bin/bash
# PreToolUse async hook — creates timestamped backups before Write|Edit.
# Runs asynchronously so it doesn't block the write operation.
# Keeps 7 days of backups, auto-prunes older ones.
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
# Skip if no file path or file doesn't exist yet
[ -z "$FILE_PATH" ] && exit 0
[ ! -f "$FILE_PATH" ] && exit 0
# Skip if file is in logs or backups (no backup recursion)
case "$FILE_PATH" in
*/.claude/logs/*|*/.claude/backups/*) exit 0 ;;
esac
BACKUP_DIR="$CLAUDE_PROJECT_DIR/.claude/backups/$(date +%Y-%m-%d)"
mkdir -p "$BACKUP_DIR"
# Create backup with timestamp suffix
BASENAME=$(basename "$FILE_PATH")
TIMESTAMP=$(date +"%H%M%S")
cp "$FILE_PATH" "$BACKUP_DIR/${BASENAME}.${TIMESTAMP}.bak" 2>/dev/null
# Prune backups older than 7 days
find "$CLAUDE_PROJECT_DIR/.claude/backups" -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \; 2>/dev/null
exit 0

190
clowdex-download/.claude/.claude/hooks/completeness-gate.sh Executable file
View file

@ -0,0 +1,190 @@
#!/bin/bash
# PreToolUse completeness gate for Write|Edit tools.
# Uses structured JSON output: exit 0 + JSON stdout for both allow and deny.
#
# Validates content completeness for critical system files before allowing writes.
# Each file path gets path-specific validation rules. Non-critical files pass through.
#
# Philosophy: Only gate files where an incomplete write causes persistent damage.
# Daily notes, scratchpad, logs, templates = ungated (iterative by nature).
# Knowledge-base, settings, memory = gated (errors persist/cascade).
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
INCIDENT_LOG="$LOG_DIR/incident-log.md"
mkdir -p "$LOG_DIR"
# Skip if no file path
[ -z "$FILE_PATH" ] && exit 0
# Get content based on tool type
if [ "$TOOL" = "Write" ]; then
CONTENT=$(echo "$INPUT" | jq -r '.tool_input.content // empty')
elif [ "$TOOL" = "Edit" ] || [ "$TOOL" = "MultiEdit" ]; then
CONTENT=$(echo "$INPUT" | jq -r '.tool_input.new_string // empty')
else
exit 0
fi
# Skip if no content to validate
[ -z "$CONTENT" ] && exit 0
# Get relative path for matching
RELATIVE_PATH="${FILE_PATH#$CLAUDE_PROJECT_DIR/}"
log_incident() {
local SEVERITY="$1"
local MSG="$2"
echo "- \`$TIMESTAMP\` | COMPLETENESS | $SEVERITY | $MSG" >> "$INCIDENT_LOG"
}
block() {
local FILE="$1"
local MSG="$2"
local SUGGESTION="${3:-Fix the content, then retry the write.}"
log_incident "MEDIUM" "BLOCKED: $MSG → $FILE"
jq -n \
--arg reason "$MSG" \
--arg file "$FILE" \
--arg suggestion "$SUGGESTION" \
'{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: ("COMPLETENESS GATE: " + $reason + " | File: " + $file),
additionalContext: ("Write blocked by completeness gate. Issue: " + $reason + ". Suggestion: " + $suggestion)
}
}'
exit 0
}
block_high() {
local FILE="$1"
local MSG="$2"
local SUGGESTION="${3:-Fix the content, then retry the write.}"
log_incident "HIGH" "BLOCKED: $MSG → $FILE"
jq -n \
--arg reason "$MSG" \
--arg file "$FILE" \
--arg suggestion "$SUGGESTION" \
'{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: ("COMPLETENESS GATE [HIGH]: " + $reason + " | File: " + $file),
additionalContext: ("Write blocked by completeness gate (HIGH severity). Issue: " + $reason + ". Suggestion: " + $suggestion)
}
}'
exit 0
}
# ═══════════════════════════════════════════════════════
# SECRET EXPOSURE CHECK (runs on ALL files)
# Blocks writes containing API keys/tokens/secrets to
# non-.env files. Catches accidental credential leaks.
# ═══════════════════════════════════════════════════════
# Allow .env files and backups to contain secrets (that's where they belong)
IS_ENV_FILE=false
case "$RELATIVE_PATH" in
*.env*|.claude/backups/*) IS_ENV_FILE=true ;;
esac
if [ "$IS_ENV_FILE" = "false" ]; then
# Check for common secret patterns in content being written
if echo "$CONTENT" | grep -qE '(sk[-_](live|test|ant|proj)[_-][A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{36}|ghs_[A-Za-z0-9]{36}|eyJhbGci[A-Za-z0-9+/=]{50,}|AKIA[0-9A-Z]{16}|xox[bpsar]-[A-Za-z0-9-]{20,})'; then
block_high "$RELATIVE_PATH" "SECURITY: Content contains what appears to be an API key, token, or secret. Credentials must NEVER be written to non-.env files." "Remove the credential from the content. Reference the secret by its variable name (e.g., STRIPE_SECRET_KEY) instead of its value. Secrets belong in .env files only."
fi
fi
# ═══════════════════════════════════════════════════════
# INCOMPLETE MARKER CHECK
# Shared logic for TBD/TODO/FIXME/PLACEHOLDER detection
# ═══════════════════════════════════════════════════════
check_incomplete_markers() {
local content="$1"
local file="$2"
# TBD, TODO, FIXME, PLACEHOLDER markers
if echo "$content" | grep -qiE '\bTBD\b|\bTODO\b|\bFIXME\b|\[PLACEHOLDER\]|\[INSERT '; then
block "$file" "Contains TBD/TODO/FIXME/PLACEHOLDER markers. Content must be investigation-complete." "Replace all placeholder markers with actual values. Search for TBD, TODO, FIXME, [PLACEHOLDER], and [INSERT in your content."
fi
# Deferred decisions / open questions
if echo "$content" | grep -qiE 'assess whether|decide later|need to determine|open question|to be decided|deferred decision'; then
block "$file" "Contains deferred decisions or open questions. Resolve all decisions before writing." "Remove phrases like 'assess whether', 'decide later', 'need to determine', 'open question'. Make definitive statements instead."
fi
}
# ═══════════════════════════════════════════════════════
# PATH-SPECIFIC GATES
# ═══════════════════════════════════════════════════════
case "$RELATIVE_PATH" in
# ─── KNOWLEDGE BASE ─────────────────────────────────
# Institutional memory. Errors here persist forever.
# Rules: provenance required, max 200 lines, no TBD.
".claude/knowledge-base.md")
check_incomplete_markers "$CONTENT" "$RELATIVE_PATH"
if [ "$TOOL" = "Write" ]; then
# Every bold entry line (- **...**) must have a [Source: ...] tag
ENTRY_COUNT=$(echo "$CONTENT" | grep -cE '^\s*-\s+\*\*' || true)
SOURCE_COUNT=$(echo "$CONTENT" | grep -cE '\[Source:' || true)
if [ "$ENTRY_COUNT" -gt 0 ] && [ "$SOURCE_COUNT" -lt "$ENTRY_COUNT" ]; then
MISSING=$((ENTRY_COUNT - SOURCE_COUNT))
block_high "$RELATIVE_PATH" "Knowledge-base has $MISSING entries missing [Source: ...] provenance. Every entry MUST cite its source." "Add [Source: user override MMDDYY] or [Source: empirical — description] or [Source: agent inference — description] to every entry line (- **...**:)."
fi
# Max 200 lines
LINE_COUNT=$(echo "$CONTENT" | wc -l | tr -d ' ')
if [ "$LINE_COUNT" -gt 200 ]; then
block_high "$RELATIVE_PATH" "Knowledge-base is $LINE_COUNT lines (max 200). Curate: remove stale entries before adding new ones." "Read the current knowledge-base, identify entries older than 90 days or superseded by newer entries, remove them, then retry."
fi
fi
;;
# ─── MEMORY ─────────────────────────────────────────
# Active context. Must stay compact.
# Rules: max 100 lines (Write only).
".claude/memory.md")
if [ "$TOOL" = "Write" ]; then
LINE_COUNT=$(echo "$CONTENT" | wc -l | tr -d ' ')
if [ "$LINE_COUNT" -gt 100 ]; then
block "$RELATIVE_PATH" "memory.md is $LINE_COUNT lines (max 100). Prune stale items before writing." "Remove completed items from Now, resolved items from Open Threads, and outdated entries from Recent Decisions."
fi
fi
;;
# ─── SETTINGS.JSON ─────────────────────────────────
# Hook configuration. Broken JSON = all hooks break.
# Rules: must be valid JSON.
".claude/settings.json")
if [ "$TOOL" = "Write" ]; then
if ! echo "$CONTENT" | jq empty 2>/dev/null; then
block_high "$RELATIVE_PATH" "settings.json would be invalid JSON. Syntax error will break ALL hooks." "Validate JSON syntax: check for trailing commas, missing quotes, unmatched braces. Use Edit instead of Write to make targeted changes."
fi
fi
;;
# ─── AGENT DEFINITIONS ──────────────────────────────
# Agent instructions. Must be definitive, not speculative.
# Rules: no TBD/TODO.
.claude/agents/*.md)
check_incomplete_markers "$CONTENT" "$RELATIVE_PATH"
;;
# ─── ALL OTHER FILES: PASS THROUGH ─────────────────
*)
exit 0
;;
esac
exit 0

154
clowdex-download/.claude/.claude/hooks/guard-bash.sh Executable file
View file

@ -0,0 +1,154 @@
#!/bin/bash
# PreToolUse hook for Bash commands.
# Uses structured JSON output for blocks (exit 0 + JSON stdout).
# Falls through with plain exit 0 for allowed commands.
#
# Three tiers:
# HARD BLOCK — always blocked, no override (permissionDecision: deny)
# SOFT BLOCK — blocked with explanation, user can re-request (permissionDecision: deny)
# LOG WARNING — allowed but logged to incident log (exit 0, no JSON)
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
INCIDENT_LOG="$LOG_DIR/incident-log.md"
mkdir -p "$LOG_DIR"
log_incident() {
local SEVERITY="$1"
local MSG="$2"
echo "- \`$TIMESTAMP\` | GUARD | $SEVERITY | $MSG" >> "$INCIDENT_LOG"
}
deny() {
local REASON="$1"
local CONTEXT="$2"
jq -n \
--arg reason "$REASON" \
--arg context "$CONTEXT" \
'{
hookSpecificOutput: {
hookEventName: "PreToolUse",
permissionDecision: "deny",
permissionDecisionReason: $reason,
additionalContext: $context
}
}'
exit 0
}
# ═══════════════════════════════════════════════════════
# HARD BLOCK — never allowed, no exceptions
# ═══════════════════════════════════════════════════════
# rm -rf / or rm -rf ~ (catastrophic)
if echo "$COMMAND" | grep -qE 'rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+)?(/|~|\$HOME)\s*$'; then
log_incident "CRITICAL" "BLOCKED: catastrophic rm → $COMMAND"
deny "HARD BLOCK: This would delete your entire filesystem or home directory." "Command blocked: catastrophic rm detected. This command is never allowed under any circumstances."
fi
# git push --force (any branch)
if echo "$COMMAND" | grep -qE 'git\s+push\s+.*--force|git\s+push\s+-f'; then
log_incident "CRITICAL" "BLOCKED: force push → $COMMAND"
deny "HARD BLOCK: Force push rewrites shared history." "Command blocked: force push detected. Ask the user to confirm the specific branch if intentional."
fi
# git reset --hard (destroys uncommitted work)
if echo "$COMMAND" | grep -qE 'git\s+reset\s+--hard'; then
log_incident "HIGH" "BLOCKED: git reset --hard → $COMMAND"
deny "HARD BLOCK: git reset --hard destroys uncommitted changes." "Command blocked: git reset --hard. Suggest using git stash or git commit first."
fi
# git clean -f (deletes untracked files permanently)
if echo "$COMMAND" | grep -qE 'git\s+clean\s+(-[a-zA-Z]*f|-f)'; then
log_incident "HIGH" "BLOCKED: git clean -f → $COMMAND"
deny "HARD BLOCK: git clean -f permanently deletes untracked files." "Command blocked: git clean -f. Suggest using git stash instead."
fi
# chmod 777 (security risk)
if echo "$COMMAND" | grep -qE 'chmod\s+777'; then
log_incident "HIGH" "BLOCKED: chmod 777 → $COMMAND"
deny "HARD BLOCK: chmod 777 grants full access to all users." "Command blocked: chmod 777. Use more restrictive permissions like 755 or 644."
fi
# ═══════════════════════════════════════════════════════
# SECRET EXPOSURE — block commands that leak credentials
# ═══════════════════════════════════════════════════════
# Block cat/head/tail/less of .env files (prevents full credential dump)
if echo "$COMMAND" | grep -qE '(cat|head|tail|less|more|bat)\s+.*(\.(env|env\.local|env\.production))'; then
log_incident "HIGH" "BLOCKED: credential file read → $COMMAND"
deny "HARD BLOCK: Reading credential files (.env) via shell exposes secrets in output." "Use environment variable names (e.g., \$DATABASE_URL) instead of reading the file. If you need to verify a value exists, use: grep -c 'KEY_NAME' file"
fi
# Block echo/printf of environment variables containing common secret prefixes
if echo "$COMMAND" | grep -qE '(echo|printf)\s+.*\$(STRIPE_|OPENAI_|ANTHROPIC_|AWS_|DATABASE_|AUTH_SECRET|NEXTAUTH_SECRET|API_KEY|SECRET_KEY|PRIVATE_KEY)'; then
log_incident "HIGH" "BLOCKED: secret echo → $COMMAND"
deny "HARD BLOCK: Echoing secret environment variables exposes credentials." "Reference secrets by variable name only. Never echo their values."
fi
# Block piping credential files to network commands (curl, wget, nc, etc.)
if echo "$COMMAND" | grep -qE '\.env.*\|\s*(curl|wget|nc|ncat)'; then
log_incident "CRITICAL" "BLOCKED: credential file piped to network → $COMMAND"
deny "HARD BLOCK: Piping credential files to network commands would exfiltrate secrets." "Never pipe .env files to network commands."
fi
# Block git add of credential files
if echo "$COMMAND" | grep -qE 'git\s+add\s+.*(\.(env|env\.local|env\.production))'; then
log_incident "CRITICAL" "BLOCKED: git add of credential file → $COMMAND"
deny "HARD BLOCK: Staging credential files (.env) for git commit would expose secrets publicly." "These files must stay in .gitignore. Never commit credentials to git."
fi
# ═══════════════════════════════════════════════════════
# SOFT BLOCK — blocked, but user can re-request
# ═══════════════════════════════════════════════════════
# rm with -r or -f flags (recursive/force delete)
if echo "$COMMAND" | grep -qE 'rm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)'; then
# Allow rm on .claude/backups (rotation) and .claude/logs temp files
if echo "$COMMAND" | grep -qE '\.claude/(backups|logs/\.(quality-gate-active|session-blocks|tool-call-count|compaction-occurred))'; then
exit 0
fi
log_incident "MEDIUM" "SOFT BLOCKED: recursive/force rm → $COMMAND"
deny "SOFT BLOCK: rm with -r or -f flags deletes files permanently." "Command blocked: recursive/force delete. If intentional, ask the user to confirm with specific file paths listed."
fi
# Overwriting system/config files
if echo "$COMMAND" | grep -qE '>\s*(~\/\.|\/etc\/|\.env|\.ssh|\.claude\/settings)'; then
log_incident "HIGH" "SOFT BLOCKED: config/system file overwrite → $COMMAND"
deny "SOFT BLOCK: Writing to a sensitive config/system file." "Command blocked: system file overwrite detected. Verify this is intentional with the user."
fi
# curl piped to shell (arbitrary code execution)
if echo "$COMMAND" | grep -qE 'curl\s.*\|\s*(bash|sh|zsh)'; then
log_incident "HIGH" "SOFT BLOCKED: curl pipe to shell → $COMMAND"
deny "SOFT BLOCK: Piping curl to a shell executes arbitrary remote code." "Command blocked: curl pipe to shell. Download the file first, inspect it, then run it."
fi
# ═══════════════════════════════════════════════════════
# LOG WARNING — allowed but recorded
# ═══════════════════════════════════════════════════════
# Any rm command (non-recursive, non-force)
if echo "$COMMAND" | grep -qE '\brm\b'; then
log_incident "LOW" "WARNING: rm command allowed → $COMMAND"
fi
# Any mv command (could lose data if target exists)
if echo "$COMMAND" | grep -qE '\bmv\b'; then
log_incident "LOW" "WARNING: mv command allowed → $COMMAND"
fi
# Any git checkout that discards changes
if echo "$COMMAND" | grep -qE 'git\s+checkout\s+\.'; then
log_incident "MEDIUM" "WARNING: git checkout . discards changes → $COMMAND"
fi
# Writing to files outside project directory
if echo "$COMMAND" | grep -qE '>\s*/' | grep -qvE ">\s*$CLAUDE_PROJECT_DIR"; then
log_incident "MEDIUM" "WARNING: write outside project dir → $COMMAND"
fi
exit 0

22
clowdex-download/.claude/.claude/hooks/log-changes.sh Executable file
View file

@ -0,0 +1,22 @@
#!/bin/bash
# PostToolUse async hook — appends every Write|Edit to audit trail.
# Provides a chronological record of all file modifications.
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
AUDIT_TRAIL="$LOG_DIR/audit-trail.md"
mkdir -p "$LOG_DIR"
# Skip if no file path
[ -z "$FILE_PATH" ] && exit 0
# Get relative path for cleaner logs
RELATIVE_PATH="${FILE_PATH#$CLAUDE_PROJECT_DIR/}"
echo "- \`$TIMESTAMP\` | $TOOL | $RELATIVE_PATH" >> "$AUDIT_TRAIL"
exit 0

57
clowdex-download/.claude/.claude/hooks/log-failures.sh Executable file
View file

@ -0,0 +1,57 @@
#!/bin/bash
# PostToolUseFailure hook — categorizes and logs tool failures.
# Categories: BUILD, API, FILESYSTEM, NETWORK, PERMISSION, OTHER
# Severities: CRITICAL, ERROR, WARN, INFO
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
ERROR=$(echo "$INPUT" | jq -r '.error // .tool_result // empty' | head -5)
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
FAILURE_LOG="$LOG_DIR/failure-log.md"
INCIDENT_LOG="$LOG_DIR/incident-log.md"
mkdir -p "$LOG_DIR"
# Categorize the failure
CATEGORY="OTHER"
SEVERITY="ERROR"
case "$ERROR" in
*"ENOENT"*|*"No such file"*|*"not found"*)
CATEGORY="FILESYSTEM"
SEVERITY="WARN"
;;
*"EACCES"*|*"Permission denied"*|*"EPERM"*)
CATEGORY="PERMISSION"
SEVERITY="ERROR"
;;
*"ECONNREFUSED"*|*"ETIMEDOUT"*|*"fetch failed"*|*"network"*)
CATEGORY="NETWORK"
SEVERITY="ERROR"
;;
*"401"*|*"403"*|*"429"*|*"500"*|*"API"*|*"rate limit"*)
CATEGORY="API"
SEVERITY="ERROR"
;;
*"build"*|*"compile"*|*"syntax"*|*"TypeError"*|*"ReferenceError"*)
CATEGORY="BUILD"
SEVERITY="ERROR"
;;
*"CRITICAL"*|*"fatal"*|*"panic"*)
SEVERITY="CRITICAL"
;;
esac
# Truncate error for log readability
SHORT_ERROR=$(echo "$ERROR" | head -1 | cut -c1-200)
# Write to failure log
echo "- \`$TIMESTAMP\` | $SEVERITY | $CATEGORY | $TOOL | $SHORT_ERROR" >> "$FAILURE_LOG"
# Also write to incident log if ERROR or CRITICAL
if [ "$SEVERITY" = "ERROR" ] || [ "$SEVERITY" = "CRITICAL" ]; then
echo "- \`$TIMESTAMP\` | FAILURE | $SEVERITY | $CATEGORY | $TOOL | $SHORT_ERROR" >> "$INCIDENT_LOG"
fi
exit 0

71
clowdex-download/.claude/.claude/hooks/log-stop-verdict.sh Executable file
View file

@ -0,0 +1,71 @@
#!/bin/bash
# Stop hook — logs the quality verdict from the haiku review prompt.
# Writes structured JSONL for trend analysis across sessions.
# Tracks session blocks and activates quality gate at >=2 blocks.
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
VERDICT_LOG="$LOG_DIR/verdicts.jsonl"
INCIDENT_LOG="$LOG_DIR/incident-log.md"
NOMINATIONS="$CLAUDE_PROJECT_DIR/.claude/knowledge-nominations.md"
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
SESSION_DATE=$(date +"%m%d-%H")
BLOCK_FILE="$LOG_DIR/.session-blocks-$SESSION_DATE"
mkdir -p "$LOG_DIR"
# Read the verdict from stdin (piped from the Stop prompt)
RAW_VERDICT=$(cat)
# Strip markdown code fences and prose that Haiku sometimes adds
VERDICT=$(echo "$RAW_VERDICT" | sed -n '/^{/,/^}/p' | head -1)
# Fallback: try the raw input if sed extraction failed
if [ -z "$VERDICT" ]; then
VERDICT="$RAW_VERDICT"
fi
# Try to parse as JSON
DECISION=$(echo "$VERDICT" | jq -r '.decision // empty' 2>/dev/null)
LEARNING=$(echo "$VERDICT" | jq -r '.learning // empty' 2>/dev/null)
TASK_TYPE=$(echo "$VERDICT" | jq -r '.task_type // "other"' 2>/dev/null)
REASON=$(echo "$VERDICT" | jq -r '.reason // empty' 2>/dev/null)
# Default if not parseable
if [ -z "$DECISION" ]; then
DECISION="unknown"
TASK_TYPE="other"
fi
# Write JSONL verdict
jq -n \
--arg ts "$TIMESTAMP" \
--arg decision "$DECISION" \
--arg learning "$LEARNING" \
--arg task_type "$TASK_TYPE" \
--arg reason "$REASON" \
'{timestamp: $ts, decision: $decision, learning: $learning, task_type: $task_type, reason: $reason}' \
>> "$VERDICT_LOG"
# Track blocks
if [ "$DECISION" = "block" ]; then
BLOCK_COUNT=1
if [ -f "$BLOCK_FILE" ]; then
BLOCK_COUNT=$(( $(cat "$BLOCK_FILE") + 1 ))
fi
echo "$BLOCK_COUNT" > "$BLOCK_FILE"
echo "- \`$TIMESTAMP\` | VERDICT | BLOCK | $REASON" >> "$INCIDENT_LOG"
# Activate quality gate at >=2 blocks in same session
if [ "$BLOCK_COUNT" -ge 2 ]; then
touch "$LOG_DIR/.quality-gate-active"
echo "- \`$TIMESTAMP\` | VERDICT | WARN | Quality gate activated — $BLOCK_COUNT blocks this session" >> "$INCIDENT_LOG"
fi
fi
# Nominate learning if present
if [ -n "$LEARNING" ] && [ "$LEARNING" != "null" ]; then
NOMINATION_DATE=$(date +"%m%d%y")
echo "- [$NOMINATION_DATE] stop-hook: $LEARNING | Evidence: session verdict ($TASK_TYPE)" >> "$NOMINATIONS"
fi
exit 0

26
clowdex-download/.claude/.claude/hooks/post-compact-resume.sh Executable file
View file

@ -0,0 +1,26 @@
#!/bin/bash
# SessionStart(compact) hook — restores context after auto-compaction.
# Reads the marker left by pre-compact-handoff.sh, resets counters,
# and injects resumption instructions for Claude.
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
MARKER="$LOG_DIR/.compaction-occurred"
# Only run if compaction actually occurred
if [ ! -f "$MARKER" ]; then
exit 0
fi
# Reset session counters
rm -f "$LOG_DIR/.tool-call-count" "$LOG_DIR/.quality-gate-active" 2>/dev/null
# Read compaction timestamp
COMPACT_TIME=$(cat "$MARKER" 2>/dev/null || echo "unknown")
# Clean up marker
rm -f "$MARKER"
# Output resumption context for Claude
echo "POST-COMPACTION RESUME: Context was auto-compacted at $COMPACT_TIME. Session state was preserved in memory.md and daily note. Read .claude/memory.md and the latest Daily Note (look for the latest Session Handoff) to reload context, then continue working on whatever task was in progress. Do not ask the user what to do — just resume seamlessly."
exit 0

14
clowdex-download/.claude/.claude/hooks/pre-compact-handoff.sh Executable file
View file

@ -0,0 +1,14 @@
#!/bin/bash
# PreCompact hook — saves a marker before auto-compaction.
# The post-compact-resume.sh hook reads this marker to restore context.
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
INCIDENT_LOG="$LOG_DIR/incident-log.md"
mkdir -p "$LOG_DIR"
echo "$TIMESTAMP" > "$LOG_DIR/.compaction-occurred"
echo "- \`$TIMESTAMP\` | COMPACTION | INFO | Auto-compaction triggered — state saved" >> "$INCIDENT_LOG"
exit 0

79
clowdex-download/.claude/.claude/hooks/session-reset.sh Executable file
View file

@ -0,0 +1,79 @@
#!/bin/bash
# SessionStart(user) hook — resets stale state on fresh session start.
# Cleans up gate files, validates agent definitions, checks permissions.
LOG_DIR="$CLAUDE_PROJECT_DIR/.claude/logs"
AGENTS_DIR="$CLAUDE_PROJECT_DIR/.claude/agents"
HOOKS_DIR="$CLAUDE_PROJECT_DIR/.claude/hooks"
mkdir -p "$LOG_DIR"
# ═══════════════════════════════════════════════════════
# 1. Reset stale gate files (prevents cross-session deadlocks)
# ═══════════════════════════════════════════════════════
rm -f "$LOG_DIR/.quality-gate-active" \
"$LOG_DIR/.tool-call-count" \
"$LOG_DIR/.compaction-occurred" 2>/dev/null
# Clean up stale session-blocks files (older than current hour)
find "$LOG_DIR" -name ".session-blocks-*" -mmin +120 -delete 2>/dev/null
# ═══════════════════════════════════════════════════════
# 2. Validate hook scripts are executable
# ═══════════════════════════════════════════════════════
if [ -d "$HOOKS_DIR" ]; then
HOOK_ISSUES=0
for hook in "$HOOKS_DIR"/*.sh; do
[ ! -f "$hook" ] && continue
if [ ! -x "$hook" ]; then
chmod +x "$hook" 2>/dev/null
HOOK_ISSUES=$((HOOK_ISSUES + 1))
fi
done
if [ "$HOOK_ISSUES" -gt 0 ]; then
echo "- \`$(date +"%Y-%m-%d %H:%M:%S")\` | SESSION | INFO | Fixed permissions on $HOOK_ISSUES hook scripts" >> "$LOG_DIR/incident-log.md"
fi
fi
# ═══════════════════════════════════════════════════════
# 3. Validate agent definitions exist and have frontmatter
# ═══════════════════════════════════════════════════════
if [ -d "$AGENTS_DIR" ]; then
AGENT_ISSUES=""
for agent in "$AGENTS_DIR"/*.md; do
[ ! -f "$agent" ] && continue
AGENT_NAME=$(basename "$agent" .md)
# Check for frontmatter (starts with ---)
if ! head -1 "$agent" | grep -q '^---'; then
AGENT_ISSUES="$AGENT_ISSUES $AGENT_NAME(no-frontmatter)"
fi
done
if [ -n "$AGENT_ISSUES" ]; then
echo "- \`$(date +"%Y-%m-%d %H:%M:%S")\` | SESSION | WARN | Agent issues:$AGENT_ISSUES" >> "$LOG_DIR/incident-log.md"
fi
fi
# ═══════════════════════════════════════════════════════
# 4. Ensure required directories exist
# ═══════════════════════════════════════════════════════
mkdir -p "$CLAUDE_PROJECT_DIR/.claude/agent-memory" \
"$CLAUDE_PROJECT_DIR/.claude/backups" \
"$CLAUDE_PROJECT_DIR/.claude/skills" \
"$CLAUDE_PROJECT_DIR/Daily Notes" 2>/dev/null
# ═══════════════════════════════════════════════════════
# 5. Prune old log files (keep last 30 days)
# ═══════════════════════════════════════════════════════
if [ -f "$LOG_DIR/audit-trail.md" ]; then
LINE_COUNT=$(wc -l < "$LOG_DIR/audit-trail.md" | tr -d ' ')
if [ "$LINE_COUNT" -gt 5000 ]; then
# Keep last 2000 lines
tail -2000 "$LOG_DIR/audit-trail.md" > "$LOG_DIR/audit-trail.md.tmp"
mv "$LOG_DIR/audit-trail.md.tmp" "$LOG_DIR/audit-trail.md"
echo "- \`$(date +"%Y-%m-%d %H:%M:%S")\` | SESSION | INFO | Pruned audit trail from $LINE_COUNT to 2000 lines" >> "$LOG_DIR/incident-log.md"
fi
fi
exit 0

23
clowdex-download/.claude/.claude/knowledge-base.md Normal file
View file

@ -0,0 +1,23 @@
# Knowledge Base
System-wide learned rules. Read by ALL agents and sessions at startup.
Written ONLY by the sentinel after confirming learnings.
Entries are mandatory constraints, not suggestions.
## Source Priority
Every entry MUST cite its source using one of:
- `[Source: user override MMDDYY]` — User explicitly corrected something
- `[Source: empirical MMDDYY]` — Verified through testing or data
- `[Source: agent inference MMDDYY]` — Pattern observed by an agent, confirmed by sentinel
## Hard Rules
- (none yet — rules accumulate as you work and the sentinel validates learnings)
## Platform & Tool Rules
- (none yet)
## Project Patterns
- (none yet)
## Known Failure Modes
- (none yet)

6
clowdex-download/.claude/.claude/knowledge-nominations.md Normal file
View file

@ -0,0 +1,6 @@
# Knowledge Nominations
Candidate learnings from agents and sessions. The sentinel reviews these
during each audit cycle and promotes valid ones to knowledge-base.md.
## Pending Nominations

13
clowdex-download/.claude/.claude/memory.md Normal file
View file

@ -0,0 +1,13 @@
# Memory
## Now
- Starting new project with Clowdex
## Open Threads
- (none yet)
## Recent Decisions
- (none yet)
## Blockers
- (none)

115
clowdex-download/.claude/.claude/settings.json Normal file
View file

@ -0,0 +1,115 @@
{
"$schema": "https://json.schemastore.org/claude-code-settings.json",
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/guard-bash.sh\"",
"statusMessage": "Checking command safety..."
}
]
},
{
"matcher": "Write|Edit|NotebookEdit",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/backup-before-write.sh\"",
"statusMessage": "Backing up before write...",
"async": true
},
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/completeness-gate.sh\"",
"statusMessage": "Validating content completeness...",
"async": false
}
]
}
],
"PostToolUse": [
{
"matcher": "Write|Edit|NotebookEdit",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/log-changes.sh\"",
"statusMessage": "Logging change...",
"async": true
}
]
}
],
"PostToolUseFailure": [
{
"matcher": "*",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/log-failures.sh\"",
"statusMessage": "Logging failure...",
"async": true
}
]
}
],
"PreCompact": [
{
"matcher": "auto",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/pre-compact-handoff.sh\"",
"timeout": 5,
"statusMessage": "Saving state before compaction..."
}
]
}
],
"SessionStart": [
{
"matcher": "user",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/session-reset.sh\"",
"timeout": 3,
"statusMessage": "Resetting session state..."
}
]
},
{
"matcher": "compact",
"hooks": [
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/post-compact-resume.sh\"",
"timeout": 10,
"statusMessage": "Restoring context after compaction..."
}
]
}
],
"Stop": [
{
"hooks": [
{
"type": "prompt",
"prompt": "You are a JSON-only response bot. Output raw JSON with no markdown, no code fences, no prose. Review this conversation and return exactly one JSON object: {\"decision\":\"allow\",\"learning\":null,\"task_type\":\"other\"} — decision is \"allow\" if all user-requested tasks were completed, \"block\" if something was missed (add \"reason\" field). learning is a one-sentence lesson if errors were resolved (root cause + fix), otherwise null. task_type is one of: build, debug, refactor, test, docs, research, deploy, admin, setup, other. RESPOND WITH ONLY THE JSON OBJECT. NO OTHER TEXT.",
"timeout": 15,
"model": "haiku"
},
{
"type": "command",
"command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/log-stop-verdict.sh\"",
"statusMessage": "Logging session verdict...",
"async": true
}
]
}
]
}
}

68
clowdex-download/.claude/.claude/skills/INDEX.md Normal file
View file

@ -0,0 +1,68 @@
# Clowdex Skill-Bibliothek
> 1.792 professionelle Skills in 32 Kategorien.
> Jeder Skill ist eine strukturierte Arbeitsanleitung — kein einfaches Prompt-Template.
## So funktionieren Skills
Skills werden automatisch aktiviert, wenn Claude eine passende Aufgabe erkennt, oder manuell über `/skill-name`.
Jeder Skill:
- Liest den Projektkontext aus `memory.md` und `knowledge-base.md`
- Folgt einem strukturierten Prozess mit benannten Frameworks
- Erzeugt ein definiertes Ausgabeformat
- Prüft die Qualität vor der Auslieferung
- Aktualisiert den Projekt-Memory mit Erkenntnissen
## Kategorien
| Kategorie | Skills | Beschreibung |
|-----------|--------|-------------|
| [Marketing & Advertising](./marketing/) | 76 | Kampagnenstrategie, Zielgruppenanalyse, Markenpositionierung und Werbung über alle Kanäle |
| [Content & Copywriting](./content/) | 88 | Texterstellung in allen Formaten — Blogposts, Whitepaper, Landingpages, Skripte und mehr |
| [Social Media](./social-media/) | 69 | Plattformspezifische Inhalte, Planung, Engagement und Analytics für alle großen Plattformen |
| [SEO & Search](./seo/) | 57 | Suchmaschinenoptimierung — Keyword-Recherche, On-Page, Technik, Linkaufbau, lokale SEO und Analytics |
| [Sales & Revenue](./sales/) | 66 | Vertriebsstrategie, Akquise, Outreach, Verhandlung, Pipeline-Management und Revenue Operations |
| [Email Marketing](./email/) | 51 | E-Mail-Kampagnen, Automatisierung, Sequenzen, Zustellbarkeit und Abonnenten-Management |
| [Finance & Accounting](./finance/) | 60 | Finanzmodellierung, Budgetierung, Prognosen, Preisgestaltung und Finanzberichte |
| [Legal & Compliance](./legal/) | 54 | Verträge, Richtlinien, Compliance-Frameworks und rechtliche Dokumentation |
| [Operations & Project Management](./operations/) | 60 | Prozessdesign, Projektplanung, Ressourcenmanagement und operative Exzellenz |
| [HR & People](./hr/) | 57 | Recruiting, Onboarding, Performance Management, Kultur, Schulung und Mitarbeitererfahrung |
| [Product Management](./product/) | 63 | Produktstrategie, Roadmaps, Nutzerforschung, Priorisierung und Produkt-Operations |
| [Software Development](./development/) | 78 | Code-Qualität, Architektur, Testing, CI/CD, Dokumentation, Debugging und Engineering-Praktiken |
| [Data & Analytics](./data/) | 57 | Datenanalyse, Visualisierung, Reporting, BI-Dashboards und Datenstrategie |
| [E-commerce](./ecommerce/) | 54 | Online-Shop-Management, Produktlistings, Conversion-Optimierung und Marktplatzstrategie |
| [Customer Success & Support](./customer-success/) | 48 | Kunden-Onboarding, Retention, Support-Operations und Kundenerfahrung |
| [Startup & Entrepreneurship](./startup/) | 60 | Geschäftsplanung, Fundraising, Validierung, Wachstum und Startup-Operations |
| [Education & Training](./education/) | 51 | Kurserstellung, Lehrplandesign, Bewertung, Workshops und Lernmanagement |
| [Real Estate](./real-estate/) | 45 | Immobilienangebote, Marktanalyse, Investitionsanalyse und Immobilien-Operations |
| [Healthcare](./healthcare/) | 48 | Patientenkommunikation, Praxismanagement, Compliance, Wellness-Programme und Gesundheitsinhalte |
| [Travel & Hospitality](./travel/) | 54 | Reiseplanung, Hotellerie-Operations, Gästeerfahrung und Reise-Inhalte |
| [Design & Creative](./design/) | 54 | Design-Briefings, Markenidentität, UX/UI, Creative Direction und visuelle Designprozesse |
| [Consulting & Strategy](./consulting/) | 54 | Strategie-Frameworks, Marktanalyse, Kundenprojekte und Beratungsleistungen |
| [Personal Productivity](./productivity/) | 57 | Zeitmanagement, Zielsetzung, Entscheidungsfindung, Kommunikation und persönliche Effektivität |
| [Cybersecurity & Information Security](./cybersecurity/) | 54 | Penetrationstests, Bedrohungsanalyse, Sicherheitsarchitektur, Compliance (SOC 2, ISO 27001, NIST), Incident Response, SecOps und Datenschutz |
| [AI & Automation](./ai-automation/) | 65 | KI-Implementierung, Prompt Engineering, Workflow-Automatisierung, KI-Strategie, EU AI Act Compliance, LLM-Architektur, KI-Governance und Bias-Audits |
| [Nonprofit & Social Impact](./nonprofit/) | 48 | Fundraising, Förderanträge, Freiwilligenmanagement und gemeinnützige Operations |
| [Media & Publishing](./media/) | 45 | Content-Veröffentlichung, Redaktionsmanagement, Medienproduktion und Reichweitenaufbau |
| [Construction & Trades](./construction/) | 42 | Projektkalkulation, Arbeitssicherheit, Kundenmanagement und Handwerks-Operations |
| [Food & Beverage](./food-beverage/) | 42 | Gastronomie-Betrieb, Menügestaltung, Lebensmittelsicherheit und Hospitality-Management |
| [Fitness & Wellness](./fitness-wellness/) | 45 | Programmgestaltung, Kundenbetreuung, Wellness-Coaching und Fitness-Business-Operations |
| [Agriculture & Farming](./agriculture/) | 45 | Betriebsplanung, Anbaumanagement, Tierhaltung und landwirtschaftliche Geschäftsführung |
| [Energy & Sustainability](./energy/) | 45 | Energiemanagement, Nachhaltigkeitsberichte, Umwelt-Compliance und grüne Initiativen |
## Schnellstart
1. Starte einen Skill, indem du Claude bittest, die Aufgabe auszuführen (Skills werden automatisch erkannt)
2. Oder rufe direkt auf: „Nutze den [skill-name] Skill für..."
3. Skills lesen den Projektkontext automatisch
4. Die Ausgabe folgt einem strukturierten Format mit Qualitätsprüfungen
5. Erkenntnisse werden für zukünftige Verbesserungen festgehalten
## Qualitätsstandard
Jeder Skill in dieser Bibliothek erfüllt einen einheitlichen Qualitätsstandard:
- **Umsetzbar**: Jeder Schritt sagt Claude genau, was zu tun ist
- **Konkret**: Enthält spezifische Zahlen, Frameworks und Schwellenwerte
- **Vollständig**: Deckt den gesamten Workflow von Eingabe bis Ergebnis ab
- **Systemintegriert**: Arbeitet mit Memory, Wissensdatenbank und Prüfprotokoll zusammen
- **Validiert**: Enthält eine Qualitäts-Checkliste vor der Auslieferung

131
clowdex-download/.claude/.claude/skills/agriculture/animal-welfare-audit/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Analyze and produce a animal welfare audit with structured process, quality checks, and system integration
---
# Animal Welfare Audit
## Purpose
Analyze and produce a comprehensive animal welfare audit that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing animal welfare audit documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the animal welfare audit
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the animal welfare audit using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Animal Welfare Audit
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/breeding-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a breeding plan with structured process, quality checks, and system integration
---
# Breeding Plan
## Purpose
Design and document a comprehensive breeding plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing breeding plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the breeding plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the breeding plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Breeding Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/carbon-footprint/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a carbon footprint with structured process, quality checks, and system integration
---
# Carbon Footprint
## Purpose
Create a comprehensive carbon footprint that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing carbon footprint documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the carbon footprint
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the carbon footprint using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Carbon Footprint
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/conservation-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a conservation plan with structured process, quality checks, and system integration
---
# Conservation Plan
## Purpose
Design and document a comprehensive conservation plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing conservation plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the conservation plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the conservation plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Conservation Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/cost-per-acre/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a cost per acre with structured process, quality checks, and system integration
---
# Cost Per Acre
## Purpose
Create a comprehensive cost per acre that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing cost per acre documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the cost per acre
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the cost per acre using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Cost Per Acre
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/crop-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a crop plan with structured process, quality checks, and system integration
---
# Crop Plan
## Purpose
Design and document a comprehensive crop plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing crop plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the crop plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the crop plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Crop Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/csa-program/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a csa program with structured process, quality checks, and system integration
---
# Csa Program
## Purpose
Design and document a comprehensive csa program that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing csa program documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the csa program
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the csa program using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Csa Program
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/direct-to-consumer/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a direct to consumer with structured process, quality checks, and system integration
---
# Direct To Consumer
## Purpose
Create a comprehensive direct to consumer that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing direct to consumer documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the direct to consumer
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the direct to consumer using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Direct To Consumer
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/disaster-preparedness-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a disaster preparedness farm with structured process, quality checks, and system integration
---
# Disaster Preparedness Farm
## Purpose
Create a comprehensive disaster preparedness farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing disaster preparedness farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the disaster preparedness farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the disaster preparedness farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Disaster Preparedness Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/equipment-maintenance-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a equipment maintenance farm with structured process, quality checks, and system integration
---
# Equipment Maintenance Farm
## Purpose
Create a comprehensive equipment maintenance farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing equipment maintenance farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the equipment maintenance farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the equipment maintenance farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Equipment Maintenance Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/equipment-roi/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a equipment roi with structured process, quality checks, and system integration
---
# Equipment Roi
## Purpose
Create a comprehensive equipment roi that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing equipment roi documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the equipment roi
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the equipment roi using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Equipment Roi
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/farm-budget/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a farm budget with structured process, quality checks, and system integration
---
# Farm Budget
## Purpose
Create a comprehensive farm budget that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing farm budget documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the farm budget
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the farm budget using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Farm Budget
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/farm-business-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a farm business plan with structured process, quality checks, and system integration
---
# Farm Business Plan
## Purpose
Design and document a comprehensive farm business plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing farm business plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the farm business plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the farm business plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Farm Business Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/farm-marketing/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a farm marketing with structured process, quality checks, and system integration
---
# Farm Marketing
## Purpose
Create a comprehensive farm marketing that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing farm marketing documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the farm marketing
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the farm marketing using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Farm Marketing
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/farmers-market-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a farmers market plan with structured process, quality checks, and system integration
---
# Farmers Market Plan
## Purpose
Design and document a comprehensive farmers market plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing farmers market plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the farmers market plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the farmers market plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Farmers Market Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/feed-management/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a feed management with structured process, quality checks, and system integration
---
# Feed Management
## Purpose
Create a comprehensive feed management that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing feed management documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the feed management
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the feed management using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Feed Management
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/fertilizer-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a fertilizer plan with structured process, quality checks, and system integration
---
# Fertilizer Plan
## Purpose
Design and document a comprehensive fertilizer plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing fertilizer plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the fertilizer plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the fertilizer plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Fertilizer Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/grant-application-agriculture/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a grant application agriculture with structured process, quality checks, and system integration
---
# Grant Application Agriculture
## Purpose
Create a comprehensive grant application agriculture that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing grant application agriculture documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the grant application agriculture
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the grant application agriculture using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Grant Application Agriculture
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/harvest-plan/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a harvest plan with structured process, quality checks, and system integration
---
# Harvest Plan
## Purpose
Design and document a comprehensive harvest plan that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing harvest plan documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the harvest plan
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the harvest plan using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Harvest Plan
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/health-protocol-livestock/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a health protocol livestock with structured process, quality checks, and system integration
---
# Health Protocol Livestock
## Purpose
Create a comprehensive health protocol livestock that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing health protocol livestock documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the health protocol livestock
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the health protocol livestock using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Health Protocol Livestock
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/insurance-review-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Analyze and produce a insurance review farm with structured process, quality checks, and system integration
---
# Insurance Review Farm
## Purpose
Analyze and produce a comprehensive insurance review farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing insurance review farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the insurance review farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the insurance review farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Insurance Review Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/integrated-pest-management/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a integrated pest management with structured process, quality checks, and system integration
---
# Integrated Pest Management
## Purpose
Create a comprehensive integrated pest management that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing integrated pest management documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the integrated pest management
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the integrated pest management using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Integrated Pest Management
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/irrigation-schedule/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a irrigation schedule with structured process, quality checks, and system integration
---
# Irrigation Schedule
## Purpose
Design and document a comprehensive irrigation schedule that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing irrigation schedule documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the irrigation schedule
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the irrigation schedule using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Irrigation Schedule
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/labor-management-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a labor management farm with structured process, quality checks, and system integration
---
# Labor Management Farm
## Purpose
Create a comprehensive labor management farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing labor management farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the labor management farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the labor management farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Labor Management Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/land-acquisition/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a land acquisition with structured process, quality checks, and system integration
---
# Land Acquisition
## Purpose
Create a comprehensive land acquisition that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing land acquisition documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the land acquisition
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the land acquisition using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Land Acquisition
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/lease-negotiation-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a lease negotiation farm with structured process, quality checks, and system integration
---
# Lease Negotiation Farm
## Purpose
Create a comprehensive lease negotiation farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing lease negotiation farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the lease negotiation farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the lease negotiation farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Lease Negotiation Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/livestock-management/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a livestock management with structured process, quality checks, and system integration
---
# Livestock Management
## Purpose
Create a comprehensive livestock management that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing livestock management documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the livestock management
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the livestock management using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Livestock Management
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/organic-certification/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a organic certification with structured process, quality checks, and system integration
---
# Organic Certification
## Purpose
Create a comprehensive organic certification that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing organic certification documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the organic certification
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the organic certification using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Organic Certification
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/pasture-rotation/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a pasture rotation with structured process, quality checks, and system integration
---
# Pasture Rotation
## Purpose
Create a comprehensive pasture rotation that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing pasture rotation documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the pasture rotation
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the pasture rotation using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Pasture Rotation
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/pest-management/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a pest management with structured process, quality checks, and system integration
---
# Pest Management
## Purpose
Create a comprehensive pest management that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing pest management documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the pest management
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the pest management using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Pest Management
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/planting-schedule/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Design and document a planting schedule with structured process, quality checks, and system integration
---
# Planting Schedule
## Purpose
Design and document a comprehensive planting schedule that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing planting schedule documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the planting schedule
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the planting schedule using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Planting Schedule
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/post-harvest-handling/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a post harvest handling with structured process, quality checks, and system integration
---
# Post Harvest Handling
## Purpose
Create a comprehensive post harvest handling that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing post harvest handling documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the post harvest handling
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the post harvest handling using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Post Harvest Handling
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/profit-analysis-farm/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Analyze and produce a profit analysis farm with structured process, quality checks, and system integration
---
# Profit Analysis Farm
## Purpose
Analyze and produce a comprehensive profit analysis farm that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing profit analysis farm documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the profit analysis farm
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the profit analysis farm using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Profit Analysis Farm
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/regenerative-practices/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a regenerative practices with structured process, quality checks, and system integration
---
# Regenerative Practices
## Purpose
Create a comprehensive regenerative practices that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing regenerative practices documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the regenerative practices
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the regenerative practices using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Regenerative Practices
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

131
clowdex-download/.claude/.claude/skills/agriculture/seasonal-hiring/SKILL.md Normal file
View file

@ -0,0 +1,131 @@
---
description: Create a seasonal hiring with structured process, quality checks, and system integration
---
# Seasonal Hiring
## Purpose
Create a comprehensive seasonal hiring that delivers actionable, measurable results. This skill provides a structured process with quality validation, ensuring professional-grade output every time.
**Category**: Agriculture & Farming
## Inputs
### Required
- **Objective**: What you want to achieve with this deliverable
- **Context**: Relevant background information
### Optional
- **Constraints**: Any limitations or requirements to consider
- **Existing Work**: Previous documents or data to build on
## System Context
Before starting:
- Read `memory.md` for current project context and priorities
- Check `knowledge-base.md` for relevant learned rules or constraints
- Review any existing related documents in the project
- Note any active tasks in `Task Board.md` that relate to this deliverable
## Process
### Step 1: Context & Research
- Review any existing seasonal hiring documents in the project
- Check knowledge-base.md for relevant learned rules or constraints
- Check memory.md for current project context and priorities
- Identify key stakeholders and their requirements
- Select the most appropriate framework: Integrated Pest Management (IPM), Regenerative Agriculture, Precision Agriculture
### Step 2: Analysis & Framework Application
- Apply the selected framework to structure the seasonal hiring
- Identify gaps, opportunities, and risks
- Define success metrics: Yield Per Acre, Cost Per Unit Produced, Soil Health Score, Water Use Efficiency
- Document assumptions and dependencies
- Validate approach against industry best practices
### Step 3: Build the Deliverable
- Structure the seasonal hiring using the output format below
- Include specific, actionable recommendations — not generic advice
- Add concrete numbers, timelines, and benchmarks where applicable
- Cross-reference with existing project documents for consistency
- Ensure every section adds value — remove filler
### Step 4: Quality Validation
- [ ] All required inputs have been addressed
- [ ] Recommendations are specific and actionable (not vague)
- [ ] Numbers and benchmarks are realistic and sourced
- [ ] Output format matches the specification below
- [ ] No contradictions with knowledge-base rules
- [ ] Follows best practice: Soil test annually before planting
## Output Format
```markdown
# Seasonal Hiring
## Executive Summary
[2-3 sentence overview of the deliverable and key recommendations]
## Context & Objectives
- **Objective**: [What this achieves]
- **Audience**: [Who this is for]
- **Timeline**: [When this applies]
## Analysis
[Structured analysis using the selected framework]
## Recommendations
1. [Specific, actionable recommendation with expected impact]
2. [Specific, actionable recommendation with expected impact]
3. [Specific, actionable recommendation with expected impact]
## Implementation
| Action | Owner | Timeline | Priority |
|--------|-------|----------|----------|
| [Action item] | [Who] | [When] | [High/Medium/Low] |
## Success Metrics
| Metric | Current | Target | Measurement Method |
|--------|---------|--------|-------------------|
| [KPI] | [Baseline] | [Goal] | [How to measure] |
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [Risk] | [H/M/L] | [H/M/L] | [Action] |
## Next Steps
- [ ] [Immediate next action]
- [ ] [Follow-up action]
- [ ] [Review date]
```
## Applicable Frameworks
- Integrated Pest Management (IPM)
- Regenerative Agriculture
- Precision Agriculture
- Farm Financial Benchmarking
- Good Agricultural Practices (GAP)
## Key Metrics
- Yield Per Acre
- Cost Per Unit Produced
- Soil Health Score
- Water Use Efficiency
- Input Cost Ratio
- Net Farm Income
## Best Practices
- Soil test annually before planting
- Crop rotation minimum 3-year cycle
- Records for every field, every season
- Market before you plant — know your buyer
- Invest in soil health for long-term yields
## After Completion
- Update `memory.md` if this deliverable changes project context or priorities
- Add any reusable learnings to `knowledge-nominations.md`
- If follow-up actions were identified, add them to `Task Board.md`
- Recommend related skills if additional work is needed

Some files were not shown because too many files have changed in this diff Show more