@adaptic/maestro 1.0.0

package/scripts/sophie-inbox-poller.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+"""Sophie Gmail Inbox Poller — checks sophie@adaptic.ai for unseen emails via IMAP.
+
+Designed to run as part of Sophie's polling infrastructure. Writes new inbox items
+to state/inbox/gmail/ for the daemon's gmail-poller.mjs to pick up and classify.
+
+Modeled on mehran-inbox-poller.py but for Sophie's own inbox.
+
+Can be run standalone: python3 scripts/sophie-inbox-poller.py
+Or called from gmail-poller.mjs before it reads the inbox directory.
+
+Exit codes:
+  0 — success (even if no new mail)
+  1 — fatal error (missing credentials)
+"""
+import sys
+import os
+import re
+import imaplib
+import email
+import json
+import hashlib
+import traceback
+from email.header import decode_header
+from email.utils import parsedate_to_datetime, parseaddr
+from datetime import datetime, timezone
+
+# ── Configuration ──
+
+SOPHIE_EMAIL = "sophie@adaptic.ai"
+MAX_EMAILS_PER_CYCLE = 20
+SNIPPET_LENGTH = 500
+
+# Paths (relative to repo root)
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+INBOX_DIR = os.path.join(REPO_ROOT, "state", "inbox", "gmail")
+ATTACHMENTS_DIR = os.path.join(REPO_ROOT, "state", "inbox", "attachments")
+CURSOR_FILE = os.path.join(REPO_ROOT, "state", "polling", "sophie-gmail-cursor.yaml")
+
+
+# ── Credential Loading ──
+
+def load_password():
+    """Load GMAIL_APP_PASSWORD from environment or .env file."""
+    password = os.environ.get("GMAIL_APP_PASSWORD", "")
+    if password:
+        return password
+
+    env_path = os.path.join(REPO_ROOT, ".env")
+    if os.path.exists(env_path):
+        with open(env_path) as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith("#") or "=" not in line:
+                    continue
+                if line.startswith("GMAIL_APP_PASSWORD="):
+                    val = line.split("=", 1)[1].strip()
+                    if (val.startswith('"') and val.endswith('"')) or \
+                       (val.startswith("'") and val.endswith("'")):
+                        val = val[1:-1]
+                    return val
+    return ""
+
+
+# ── Header Decoding ──
+
+def decode_header_value(value):
+    """Decode RFC 2047 encoded header value."""
+    if not value:
+        return ""
+    decoded_parts = decode_header(value)
+    result = []
+    for part, encoding in decoded_parts:
+        if isinstance(part, bytes):
+            result.append(part.decode(encoding or "utf-8", errors="replace"))
+        else:
+            result.append(str(part))
+    return " ".join(result)
+
+
+# ── Body Extraction ──
+
+def strip_html(html):
+    """Crude HTML-to-text conversion using stdlib only (no external deps)."""
+    text = re.sub(r"<(style|script)[^>]*>.*?</\1>", "", html, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r"<br\s*/?>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"</(p|div|tr|li)>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"<[^>]+>", "", text)
+    text = text.replace("&nbsp;", " ").replace("&amp;", "&")
+    text = text.replace("&lt;", "<").replace("&gt;", ">")
+    text = text.replace("&quot;", '"').replace("&#39;", "'")
+    text = re.sub(r"&\w+;", "", text)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def extract_attachments(msg, mid_hash):
+    """Extract and save email attachments to local storage."""
+    attachments = []
+    os.makedirs(ATTACHMENTS_DIR, exist_ok=True)
+
+    if not msg.is_multipart():
+        return attachments
+
+    for part in msg.walk():
+        content_disposition = str(part.get("Content-Disposition", ""))
+        filename = part.get_filename()
+
+        if "attachment" not in content_disposition and not filename:
+            continue
+        if not filename:
+            continue
+
+        try:
+            payload = part.get_payload(decode=True)
+            if not payload:
+                continue
+
+            content_type = part.get_content_type() or ""
+            if content_type.startswith("image/") and len(payload) < 1024:
+                continue
+
+            safe_name = re.sub(r"[^a-zA-Z0-9._-]", "_", filename)
+            local_name = f"{mid_hash}-{safe_name}"
+            local_path = os.path.join(ATTACHMENTS_DIR, local_name)
+
+            with open(local_path, "wb") as f:
+                f.write(payload)
+
+            attachments.append({
+                "name": filename,
+                "mimetype": content_type,
+                "size": len(payload),
+                "local_path": local_path,
+            })
+            print(f"[sophie-gmail]   Attachment saved: {filename} ({len(payload)} bytes)")
+
+        except Exception as e:
+            print(f"[sophie-gmail]   Attachment error for {filename}: {e}")
+            continue
+
+    return attachments
+
+
+def get_body_snippet(msg, max_length=SNIPPET_LENGTH):
+    """Extract text body from email, truncated to max_length chars."""
+    plain_body = ""
+    html_body = ""
+
+    if msg.is_multipart():
+        for part in msg.walk():
+            content_type = part.get_content_type()
+            content_disposition = str(part.get("Content-Disposition", ""))
+            if "attachment" in content_disposition:
+                continue
+            try:
+                payload = part.get_payload(decode=True)
+                if not payload:
+                    continue
+                charset = part.get_content_charset() or "utf-8"
+                decoded = payload.decode(charset, errors="replace")
+                if content_type == "text/plain" and not plain_body:
+                    plain_body = decoded
+                elif content_type == "text/html" and not html_body:
+                    html_body = decoded
+            except Exception:
+                pass
+    else:
+        try:
+            payload = msg.get_payload(decode=True)
+            if payload:
+                charset = msg.get_content_charset() or "utf-8"
+                decoded = payload.decode(charset, errors="replace")
+                if msg.get_content_type() == "text/html":
+                    html_body = decoded
+                else:
+                    plain_body = decoded
+        except Exception:
+            pass
+
+    body = plain_body.strip()
+    if not body and html_body:
+        body = strip_html(html_body)
+
+    if len(body) > max_length:
+        return body[:max_length] + "..."
+    return body
+
+
+# ── Cursor Management ──
+
+def read_cursor():
+    """Read the last poll state from cursor file."""
+    if not os.path.exists(CURSOR_FILE):
+        return {"last_poll": None, "last_message_id": None, "messages_processed": 0}
+
+    cursor = {}
+    try:
+        with open(CURSOR_FILE) as f:
+            for line in f:
+                line = line.strip()
+                if ":" not in line:
+                    continue
+                key, val = line.split(":", 1)
+                key = key.strip()
+                val = val.strip().strip('"')
+                if val == "null" or val == "":
+                    val = None
+                elif key == "messages_processed":
+                    try:
+                        val = int(val)
+                    except ValueError:
+                        val = 0
+                cursor[key] = val
+    except Exception:
+        return {"last_poll": None, "last_message_id": None, "messages_processed": 0}
+
+    return {
+        "last_poll": cursor.get("last_poll"),
+        "last_message_id": cursor.get("last_message_id"),
+        "messages_processed": cursor.get("messages_processed", 0),
+    }
+
+
+def write_cursor(last_poll, last_message_id, messages_processed):
+    """Write the poll state to cursor file."""
+    os.makedirs(os.path.dirname(CURSOR_FILE), exist_ok=True)
+
+    lp = f'"{last_poll}"' if last_poll else "null"
+    lm = f'"{last_message_id}"' if last_message_id else "null"
+
+    content = f"""last_poll: {lp}
+last_message_id: {lm}
+messages_processed: {messages_processed}
+"""
+    with open(CURSOR_FILE, "w") as f:
+        f.write(content)
+
+
+# ── Dedup ──
+
+def message_id_hash(message_id, from_addr="", subject="", date=""):
+    """Generate a short hash for deduplication."""
+    key = message_id or f"{from_addr}{subject}{date}"
+    return hashlib.md5(key.encode("utf-8", errors="replace")).hexdigest()[:16]
+
+
+def is_already_processed(mid_hash):
+    """Check if this message has already been written to inbox."""
+    base_name = f"{mid_hash}-email.json"
+    pending = os.path.join(INBOX_DIR, base_name)
+    processed = os.path.join(INBOX_DIR, base_name + ".processed")
+    return os.path.exists(pending) or os.path.exists(processed)
+
+
+# ── Main Poll ──
+
+def poll_sophie_inbox():
+    """Poll Sophie's Gmail inbox for unseen emails and write to inbox queue."""
+    password = load_password()
+    if not password:
+        print("[sophie-gmail] GMAIL_APP_PASSWORD not set, skipping")
+        return 0
+
+    os.makedirs(INBOX_DIR, exist_ok=True)
+
+    cursor = read_cursor()
+    now = datetime.now(timezone.utc).isoformat()
+    new_count = 0
+    skipped = 0
+    last_mid = cursor.get("last_message_id")
+    total_processed = cursor.get("messages_processed", 0) or 0
+
+    mail = None
+    try:
+        mail = imaplib.IMAP4_SSL("imap.gmail.com")
+        mail.login(SOPHIE_EMAIL, password)
+        mail.select("INBOX")
+
+        status, data = mail.search(None, "UNSEEN")
+        if status != "OK" or not data[0]:
+            print("[sophie-gmail] No unseen messages")
+            write_cursor(now, last_mid, total_processed)
+            mail.logout()
+            return 0
+
+        msg_ids = data[0].split()
+        total_unseen = len(msg_ids)
+        print(f"[sophie-gmail] Found {total_unseen} unseen messages")
+
+        if len(msg_ids) > MAX_EMAILS_PER_CYCLE:
+            msg_ids = msg_ids[-MAX_EMAILS_PER_CYCLE:]
+            print(f"[sophie-gmail] Rate limited to last {MAX_EMAILS_PER_CYCLE}")
+
+        for mid in msg_ids:
+            try:
+                status, header_data = mail.fetch(
+                    mid,
+                    "(BODY.PEEK[HEADER.FIELDS (FROM TO SUBJECT DATE MESSAGE-ID)])"
+                )
+                if status != "OK" or not header_data[0]:
+                    continue
+
+                raw_header = header_data[0][1]
+                msg_header = email.message_from_bytes(raw_header)
+
+                from_raw = msg_header.get("From", "")
+                subject_raw = msg_header.get("Subject", "")
+                date_raw = msg_header.get("Date", "")
+                message_id_raw = msg_header.get("Message-ID", "")
+
+                from_decoded = decode_header_value(from_raw)
+                subject_decoded = decode_header_value(subject_raw)
+
+                from_name, from_addr = parseaddr(from_decoded)
+                if not from_name:
+                    from_name = from_addr
+
+                mid_hash = message_id_hash(
+                    message_id_raw, from_addr, subject_decoded, date_raw
+                )
+
+                if is_already_processed(mid_hash):
+                    skipped += 1
+                    continue
+
+                snippet = ""
+                email_attachments = []
+                try:
+                    status2, full_data = mail.fetch(mid, "(BODY.PEEK[])")
+                    if status2 == "OK" and full_data[0]:
+                        full_msg = email.message_from_bytes(full_data[0][1])
+                        snippet = get_body_snippet(full_msg)
+                        email_attachments = extract_attachments(full_msg, mid_hash)
+                except Exception:
+                    snippet = ""
+
+                try:
+                    parsed_date = parsedate_to_datetime(date_raw)
+                    iso_date = parsed_date.isoformat()
+                except Exception:
+                    iso_date = date_raw
+
+                record = {
+                    "received_at": now,
+                    "event_type": "sophie_email",
+                    "source": "sophie_gmail_poll",
+                    "email": {
+                        "from": from_decoded,
+                        "from_name": from_name,
+                        "from_addr": from_addr,
+                        "to": SOPHIE_EMAIL,
+                        "subject": subject_decoded,
+                        "date": iso_date,
+                        "message_id": message_id_raw,
+                        "snippet": snippet,
+                    },
+                    "attachments": email_attachments if email_attachments else None,
+                    "triage_hint": None,
+                }
+
+                filepath = os.path.join(INBOX_DIR, f"{mid_hash}-email.json")
+                with open(filepath, "w") as f:
+                    json.dump(record, f, indent=2, ensure_ascii=False, default=str)
+
+                new_count += 1
+                last_mid = message_id_raw
+                print(f"[sophie-gmail] New: {from_name} <{from_addr}> — {subject_decoded[:60]}")
+
+            except Exception as e:
+                print(f"[sophie-gmail] Error processing message: {e}")
+                continue
+
+        total_processed += new_count
+        write_cursor(now, last_mid, total_processed)
+        mail.logout()
+
+        print(f"[sophie-gmail] Poll complete: {new_count} new, {skipped} skipped, {total_unseen} unseen total")
+        return new_count
+
+    except imaplib.IMAP4.error as e:
+        print(f"[sophie-gmail] IMAP error: {e}")
+        if mail:
+            try:
+                mail.logout()
+            except Exception:
+                pass
+        write_cursor(now, last_mid, total_processed)
+        return 0
+
+    except Exception as e:
+        print(f"[sophie-gmail] Connection error: {e}")
+        traceback.print_exc(file=sys.stdout)
+        if mail:
+            try:
+                mail.logout()
+            except Exception:
+                pass
+        write_cursor(now, last_mid, total_processed)
+        return 0
+
+
+if __name__ == "__main__":
+    count = poll_sophie_inbox()
+    print(f"[sophie-gmail] Finished — {count} new items written to inbox")

package/scripts/spawn-session.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# Spawn a dedicated Claude Code session for complex tasks
+# Usage: ./scripts/spawn-session.sh <session_id> <task_file> <time_budget_seconds>
+#
+# This script is called by the session-spawner agent when the inbound
+# dispatcher routes an item to spawn-session.
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SOPHIE_AI_DIR="$(dirname "$SCRIPT_DIR")"
+SESSION_ID="${1:?Session ID required}"
+TASK_FILE="${2:?Task file path required}"
+TIME_BUDGET="${3:-600}"  # Default 10 minutes
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+SESSION_DIR="$SOPHIE_AI_DIR/outputs/sessions/$SESSION_ID"
+LOG_FILE="$SOPHIE_AI_DIR/logs/sessions/$SESSION_ID.log"
+
+# Validate
+if [ -f "$SOPHIE_AI_DIR/.emergency-stop" ]; then
+    echo "[$TIMESTAMP] BLOCKED: Emergency stop is active" >&2
+    exit 1
+fi
+
+if [ ! -f "$TASK_FILE" ]; then
+    echo "[$TIMESTAMP] ERROR: Task file not found: $TASK_FILE" >&2
+    exit 1
+fi
+
+# Create session directory
+mkdir -p "$SESSION_DIR" "$(dirname "$LOG_FILE")"
+
+# Read the task
+TASK_CONTENT=$(cat "$TASK_FILE")
+
+# Write session manifest
+cat > "$SESSION_DIR/manifest.yaml" << YAML
+session_id: $SESSION_ID
+created: $TIMESTAMP
+task_file: $TASK_FILE
+time_budget_seconds: $TIME_BUDGET
+status: running
+pid: null
+YAML
+
+echo "[$TIMESTAMP] Spawning session $SESSION_ID (budget: ${TIME_BUDGET}s)" | tee -a "$LOG_FILE"
+
+# Spawn Claude Code session in background with timeout
+(
+    timeout "$TIME_BUDGET" claude -p "$TASK_CONTENT
+
+IMPORTANT: You are a sub-session spawned by Sophie Nguyen, Chief of Staff at Adaptic.ai.
+Write your output to: $SESSION_DIR/output.md
+When complete, write 'DONE' to: $SESSION_DIR/complete
+Working directory: $SOPHIE_AI_DIR
+Do NOT send any communications. Only produce the requested output." \
+    --output-format text \
+    >> "$LOG_FILE" 2>&1
+
+    EXIT_CODE=$?
+
+    if [ $EXIT_CODE -eq 0 ]; then
+        echo "DONE" > "$SESSION_DIR/complete"
+        # Update manifest
+        sed -i '' "s/status: running/status: completed/" "$SESSION_DIR/manifest.yaml"
+        echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Session $SESSION_ID completed successfully" >> "$LOG_FILE"
+    elif [ $EXIT_CODE -eq 124 ]; then
+        echo "TIMEOUT" > "$SESSION_DIR/complete"
+        sed -i '' "s/status: running/status: timeout/" "$SESSION_DIR/manifest.yaml"
+        echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Session $SESSION_ID TIMED OUT after ${TIME_BUDGET}s" >> "$LOG_FILE"
+    else
+        echo "ERROR:$EXIT_CODE" > "$SESSION_DIR/complete"
+        sed -i '' "s/status: running/status: error/" "$SESSION_DIR/manifest.yaml"
+        echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Session $SESSION_ID failed with exit code $EXIT_CODE" >> "$LOG_FILE"
+    fi
+) &
+
+SESSION_PID=$!
+
+# Record PID in manifest
+sed -i '' "s/pid: null/pid: $SESSION_PID/" "$SESSION_DIR/manifest.yaml"
+
+echo "[$TIMESTAMP] Session $SESSION_ID spawned as PID $SESSION_PID" | tee -a "$LOG_FILE"
+echo "$SESSION_DIR"

package/scripts/system-verify.sh

@@ -0,0 +1,171 @@
+#!/bin/bash
+# Sophie System Verification — checks all components are operational
+# Usage: ./scripts/system-verify.sh
+#
+# Run this anytime to verify the full system is working.
+
+set -e
+SOPHIE_AI_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$SOPHIE_AI_DIR"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+pass=0
+warn=0
+fail=0
+
+check() {
+    if eval "$2" > /dev/null 2>&1; then
+        echo -e "  ${GREEN}✓${NC} $1"
+        ((pass++))
+    else
+        echo -e "  ${RED}✗${NC} $1"
+        ((fail++))
+    fi
+}
+
+warn_check() {
+    if eval "$2" > /dev/null 2>&1; then
+        echo -e "  ${GREEN}✓${NC} $1"
+        ((pass++))
+    else
+        echo -e "  ${YELLOW}⚠${NC} $1"
+        ((warn++))
+    fi
+}
+
+echo "╔══════════════════════════════════════════════╗"
+echo "║  SOPHIE SYSTEM VERIFICATION                  ║"
+echo "║  $(date '+%Y-%m-%d %H:%M %Z')                      ║"
+echo "╚══════════════════════════════════════════════╝"
+echo ""
+
+echo "=== DAEMONS ==="
+check "Poller daemon loaded" "launchctl list | grep -q sophie-poller"
+check "Inbox processor loaded" "launchctl list | grep -q sophie-inbox-processor"
+check "Meeting prep loaded" "launchctl list | grep -q sophie-meeting-prep"
+check "Meeting capture loaded" "launchctl list | grep -q sophie-meeting-action-capture"
+check "Midday sweep loaded" "launchctl list | grep -q sophie-midday-sweep"
+check "Weekly hiring loaded" "launchctl list | grep -q sophie-weekly-hiring"
+check "Weekly priorities loaded" "launchctl list | grep -q sophie-weekly-priorities"
+check "Weekly eng health loaded" "launchctl list | grep -q sophie-weekly-engineering-health"
+check "Weekly execution loaded" "launchctl list | grep -q sophie-weekly-execution"
+check "Weekly strategic memo loaded" "launchctl list | grep -q sophie-weekly-strategic-memo"
+check "Quarterly self-assessment loaded" "launchctl list | grep -q sophie-quarterly"
+echo ""
+
+echo "=== REMOTE TRIGGERS ==="
+warn_check "Git pushed to origin" "test $(git rev-list --count origin/main..HEAD) -eq 0"
+echo "  Remote triggers read from GitHub — must be pushed to work"
+echo ""
+
+echo "=== POLLER ACTIVITY ==="
+TODAY=$(date -u +%Y-%m-%d)
+YESTERDAY=$(date -u -v-1d +%Y-%m-%d 2>/dev/null || date -u -d yesterday +%Y-%m-%d 2>/dev/null || echo "unknown")
+POLLER_LOG="logs/polling/${TODAY}-poller.jsonl"
+POLLER_LOG_YESTERDAY="logs/polling/${YESTERDAY}-poller.jsonl"
+if [ -f "$POLLER_LOG" ]; then
+    LAST_POLL=$(tail -1 "$POLLER_LOG" | python3 -c "import sys,json; print(json.loads(sys.stdin.read()).get('timestamp','unknown'))" 2>/dev/null || echo "unknown")
+    POLL_COUNT=$(wc -l < "$POLLER_LOG" | tr -d ' ')
+    echo -e "  ${GREEN}✓${NC} Poller active today: $POLL_COUNT polls, last at $LAST_POLL"
+    ((pass++))
+elif [ -f "$POLLER_LOG_YESTERDAY" ]; then
+    LAST_POLL=$(tail -1 "$POLLER_LOG_YESTERDAY" | python3 -c "import sys,json; print(json.loads(sys.stdin.read()).get('timestamp','unknown'))" 2>/dev/null || echo "unknown")
+    echo -e "  ${YELLOW}⚠${NC} No log today, yesterday's last poll: $LAST_POLL"
+    ((warn++))
+else
+    echo -e "  ${RED}✗${NC} No poller logs found"
+    ((fail++))
+fi
+echo ""
+
+echo "=== WORKFLOW EXECUTION ==="
+for workflow in inbox-processor meeting-prep meeting-action-capture; do
+    LOG="logs/workflows/${TODAY}-${workflow}.jsonl"
+    LOG_Y="logs/workflows/${YESTERDAY}-${workflow}.jsonl"
+    if [ -f "$LOG" ]; then
+        ENTRIES=$(wc -l < "$LOG" | tr -d ' ')
+        echo -e "  ${GREEN}✓${NC} $workflow: $ENTRIES log entries today"
+        ((pass++))
+    elif [ -f "$LOG_Y" ]; then
+        echo -e "  ${YELLOW}⚠${NC} $workflow: ran yesterday, not yet today"
+        ((warn++))
+    else
+        echo -e "  ${RED}✗${NC} $workflow: no recent logs"
+        ((fail++))
+    fi
+done
+echo ""
+
+echo "=== QUEUE HEALTH ==="
+TOTAL=0
+for q in state/queues/*.yaml; do
+    COUNT=$(grep -c "^  - id:" "$q" 2>/dev/null || echo 0)
+    TOTAL=$((TOTAL + COUNT))
+done
+echo "  Total items across all queues: $TOTAL"
+if [ "$TOTAL" -gt 0 ]; then
+    echo -e "  ${GREEN}✓${NC} Queues populated"
+    ((pass++))
+else
+    echo -e "  ${RED}✗${NC} All queues empty — backlog not loaded"
+    ((fail++))
+fi
+
+CRITICAL=$(grep -r "priority: critical" state/queues/ 2>/dev/null | wc -l | tr -d ' ')
+echo "  Critical items: $CRITICAL"
+echo ""
+
+echo "=== DASHBOARDS ==="
+for dash in executive-summary strategy-scorecard org-health leadership-accountability engineering-health relationship-pipeline capital-readiness risk-register system-health; do
+    check "Dashboard: $dash" "test -f state/dashboards/${dash}.yaml"
+done
+echo ""
+
+echo "=== STATE FILES ==="
+check "15+ queue files" "test $(ls state/queues/*.yaml | wc -l) -ge 15"
+check "5 user profiles" "test $(ls memory/profiles/users/*.yaml | wc -l) -ge 5"
+check "10 channel profiles" "test $(ls memory/profiles/channels/*.yaml | wc -l) -ge 10"
+check "Decision library" "test -f knowledge/decisions/index.yaml"
+check "Strategy state" "test -f knowledge/syntheses/strategy-state.yaml"
+check "Blocker playbooks" "test -f knowledge/sources/blocker-playbooks.yaml"
+check "SLA defaults" "test -f config/sla-defaults.yaml"
+check "Defence policy" "test -f policies/prompt-injection-defence.yaml"
+echo ""
+
+echo "=== HOOKS ==="
+check "Pre-send audit hook" "test -x scripts/hooks/pre-send-audit.sh"
+check "Post-action log hook" "test -x scripts/hooks/post-action-log.sh"
+check "Session-end log hook" "test -x scripts/hooks/session-end-log.sh"
+check "Hooks configured in settings" "grep -q 'pre-send-audit' .claude/settings.json"
+echo ""
+
+echo "=== TRIGGER PROMPTS ==="
+TRIGGER_COUNT=$(ls schedules/triggers/*.md | wc -l | tr -d ' ')
+check "12+ trigger prompts" "test $TRIGGER_COUNT -ge 12"
+echo "  Trigger prompts: $TRIGGER_COUNT"
+echo ""
+
+echo "=== CLAUDE.MD ==="
+CT_COUNT=$(grep -c "Control Tower" CLAUDE.md)
+check "12 control towers documented" "test $CT_COUNT -ge 12"
+check "Agent teams enabled" "grep -q 'AGENT_TEAMS' .claude/settings.json"
+echo ""
+
+echo "══════════════════════════════════════════════"
+echo -e "  ${GREEN}PASS: $pass${NC}  ${YELLOW}WARN: $warn${NC}  ${RED}FAIL: $fail${NC}"
+echo "══════════════════════════════════════════════"
+
+if [ "$fail" -gt 0 ]; then
+    echo -e "  ${RED}System has failures — investigate above${NC}"
+    exit 1
+elif [ "$warn" -gt 0 ]; then
+    echo -e "  ${YELLOW}System operational with warnings${NC}"
+    exit 0
+else
+    echo -e "  ${GREEN}System fully operational${NC}"
+    exit 0
+fi