@adaptic/maestro 1.0.0

package/scripts/search-mehran-inbox.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Search Mehran's Gmail inbox via IMAP for correspondence matching a query.
+
+Usage: python3 search-mehran-inbox.py "<search_query>" [--max N] [--full]
+  --max N   : Maximum messages to return (default: 20)
+  --full    : Include full message bodies (default: headers + snippet)
+
+Examples:
+  python3 search-mehran-inbox.py "from:difc.ae"
+  python3 search-mehran-inbox.py "difc fitout" --max 50 --full
+"""
+import sys
+import os
+import imaplib
+import email
+from email.header import decode_header
+import json
+from datetime import datetime
+
+MEHRAN_EMAIL = "mehran@adaptic.ai"
+MEHRAN_PASSWORD = os.environ.get("MEHRAN_GMAIL_APP_PASSWORD", "")
+
+# Load from .env if not in environment
+if not MEHRAN_PASSWORD:
+    env_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env")
+    if os.path.exists(env_path):
+        with open(env_path) as f:
+            for line in f:
+                if line.startswith("MEHRAN_GMAIL_APP_PASSWORD="):
+                    MEHRAN_PASSWORD = line.strip().split("=", 1)[1].strip()
+                    break
+
+if not MEHRAN_PASSWORD:
+    print("ERROR: MEHRAN_GMAIL_APP_PASSWORD not set", file=sys.stderr)
+    sys.exit(1)
+
+
+def decode_header_value(value):
+    """Decode email header value handling various encodings."""
+    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)
+
+
+def get_body(msg):
+    """Extract text body from email message."""
+    body = ""
+    if msg.is_multipart():
+        for part in msg.walk():
+            content_type = part.get_content_type()
+            content_disposition = str(part.get("Content-Disposition", ""))
+            if content_type == "text/plain" and "attachment" not in content_disposition:
+                try:
+                    payload = part.get_payload(decode=True)
+                    if payload:
+                        charset = part.get_content_charset() or "utf-8"
+                        body += payload.decode(charset, errors="replace")
+                except Exception:
+                    pass
+            elif content_type == "text/html" and not body and "attachment" not in content_disposition:
+                try:
+                    payload = part.get_payload(decode=True)
+                    if payload:
+                        charset = part.get_content_charset() or "utf-8"
+                        body += payload.decode(charset, errors="replace")
+                except Exception:
+                    pass
+    else:
+        try:
+            payload = msg.get_payload(decode=True)
+            if payload:
+                charset = msg.get_content_charset() or "utf-8"
+                body = payload.decode(charset, errors="replace")
+        except Exception:
+            pass
+    return body
+
+
+def get_attachments(msg):
+    """List attachment filenames and sizes."""
+    attachments = []
+    if msg.is_multipart():
+        for part in msg.walk():
+            content_disposition = str(part.get("Content-Disposition", ""))
+            if "attachment" in content_disposition or (
+                part.get_filename() and part.get_content_type() != "text/plain"
+            ):
+                filename = decode_header_value(part.get_filename() or "unnamed")
+                size = len(part.get_payload(decode=True) or b"")
+                attachments.append({"filename": filename, "size": size, "content_type": part.get_content_type()})
+    return attachments
+
+
+def search_inbox(query, max_results=20, full_body=False):
+    """Search Mehran's Gmail via IMAP."""
+    mail = imaplib.IMAP4_SSL("imap.gmail.com")
+    mail.login(MEHRAN_EMAIL, MEHRAN_PASSWORD)
+
+    # Use All Mail to search everything
+    mail.select('"[Gmail]/All Mail"')
+
+    # Build IMAP search criteria
+    # Gmail supports X-GM-RAW for full Gmail search syntax
+    status, message_ids = mail.search(None, f'X-GM-RAW "{query}"')
+
+    if status != "OK" or not message_ids[0]:
+        print(json.dumps({"query": query, "results": [], "total": 0}, indent=2))
+        mail.logout()
+        return
+
+    ids = message_ids[0].split()
+    total = len(ids)
+    # Get most recent N messages (IMAP returns oldest first)
+    ids = ids[-max_results:] if len(ids) > max_results else ids
+    ids.reverse()  # newest first
+
+    results = []
+    for msg_id in ids:
+        try:
+            if full_body:
+                status, data = mail.fetch(msg_id, "(RFC822)")
+            else:
+                status, data = mail.fetch(msg_id, "(RFC822)")
+
+            if status != "OK" or not data[0]:
+                continue
+
+            raw_email = data[0][1]
+            msg = email.message_from_bytes(raw_email)
+
+            result = {
+                "from": decode_header_value(msg.get("From", "")),
+                "to": decode_header_value(msg.get("To", "")),
+                "cc": decode_header_value(msg.get("Cc", "")),
+                "subject": decode_header_value(msg.get("Subject", "")),
+                "date": msg.get("Date", ""),
+                "message_id": msg.get("Message-ID", ""),
+                "in_reply_to": msg.get("In-Reply-To", ""),
+            }
+
+            body = get_body(msg)
+            if full_body:
+                result["body"] = body
+            else:
+                result["snippet"] = body[:500] + ("..." if len(body) > 500 else "")
+
+            attachments = get_attachments(msg)
+            if attachments:
+                result["attachments"] = attachments
+
+            results.append(result)
+        except Exception as e:
+            results.append({"error": str(e), "msg_id": msg_id.decode()})
+
+    mail.logout()
+
+    output = {
+        "query": query,
+        "total_matches": total,
+        "returned": len(results),
+        "results": results
+    }
+    print(json.dumps(output, indent=2, ensure_ascii=False, default=str))
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Search Mehran's Gmail inbox via IMAP")
+    parser.add_argument("query", help="Gmail search query")
+    parser.add_argument("--max", type=int, default=20, help="Maximum results (default: 20)")
+    parser.add_argument("--full", action="store_true", help="Include full message bodies")
+    args = parser.parse_args()
+
+    search_inbox(args.query, max_results=args.max, full_body=args.full)

package/scripts/self-optimization/compute-metrics.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+"""
+Self-Optimization Metric Computation
+Computes current values for all scoring rubrics from operational logs.
+
+Usage:
+    python3 scripts/self-optimization/compute-metrics.py [--date YYYY-MM-DD] [--append]
+
+    --date    Date to compute metrics for (default: today)
+    --append  Append snapshot to self-optimization/metric-snapshots.yaml
+
+Reads from:
+    logs/audit/{date}-actions.jsonl
+    logs/audit/{date}-validation.jsonl
+    logs/workflows/{date}-inbox-processor.jsonl
+    logs/daemon/{date}-responses.jsonl
+    logs/sessions/{date}-sessions.jsonl
+    state/queues/*.yaml
+
+Outputs metric snapshot to stdout (YAML format) or appends to metric-snapshots.yaml.
+"""
+
+import json
+import os
+import sys
+import glob
+import argparse
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+from collections import defaultdict
+
+# Repo root — script expects to be run from repo root or adjusts via __file__
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def parse_jsonl(filepath):
+    """Parse a JSONL file, skipping malformed lines."""
+    entries = []
+    if not filepath.exists():
+        return entries
+    with open(filepath, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return entries
+
+
+def count_queue_items(queues_dir, statuses=None):
+    """Count items across all queue YAML files by status."""
+    counts = defaultdict(int)
+    total = 0
+    if not queues_dir.exists():
+        return counts, total
+
+    for qfile in queues_dir.glob('*.yaml'):
+        try:
+            with open(qfile, 'r') as f:
+                content = f.read()
+        except Exception:
+            continue
+
+        # Simple YAML parsing for queue items — avoids pyyaml dependency
+        # Looks for "status: <value>" lines under "items:" sections
+        in_items = False
+        for line in content.split('\n'):
+            stripped = line.strip()
+            if stripped == 'items:':
+                in_items = True
+                continue
+            if in_items and stripped.startswith('status:'):
+                status = stripped.split(':', 1)[1].strip().strip('"').strip("'")
+                counts[status] += 1
+                total += 1
+            # Reset if we hit a top-level key
+            if in_items and not line.startswith(' ') and not line.startswith('\t') and ':' in line and not stripped.startswith('-') and not stripped.startswith('status:'):
+                if stripped != 'items:':
+                    in_items = False
+
+    return counts, total
+
+
+def compute_metrics(date_str):
+    """Compute all scoring rubric metrics for a given date."""
+    logs_audit = REPO_ROOT / 'logs' / 'audit'
+    logs_workflows = REPO_ROOT / 'logs' / 'workflows'
+    logs_daemon = REPO_ROOT / 'logs' / 'daemon'
+    logs_sessions = REPO_ROOT / 'logs' / 'sessions'
+    queues_dir = REPO_ROOT / 'state' / 'queues'
+
+    # Load log files
+    actions = parse_jsonl(logs_audit / f'{date_str}-actions.jsonl')
+    validations = parse_jsonl(logs_audit / f'{date_str}-validation.jsonl')
+    inbox_logs = parse_jsonl(logs_workflows / f'{date_str}-inbox-processor.jsonl')
+    responses = parse_jsonl(logs_daemon / f'{date_str}-responses.jsonl')
+    sessions = parse_jsonl(logs_sessions / f'{date_str}-sessions.jsonl')
+
+    # Also check prior days for multi-day metrics
+    prev_date = (datetime.strptime(date_str, '%Y-%m-%d') - timedelta(days=1)).strftime('%Y-%m-%d')
+    prev_actions = parse_jsonl(logs_audit / f'{prev_date}-actions.jsonl')
+
+    metrics = {}
+
+    # --- Responsiveness ---
+
+    # inbox_to_action_time: Average time from inbox item to first action
+    # Proxy: count responses with duration_ms from daemon response logs
+    response_times_ms = [r.get('duration_ms', 0) for r in responses if r.get('duration_ms')]
+    if response_times_ms:
+        avg_response_ms = sum(response_times_ms) / len(response_times_ms)
+        metrics['inbox_to_action_time'] = {
+            'value': round(avg_response_ms / 1000, 1),
+            'unit': 'seconds',
+            'sample_size': len(response_times_ms),
+            'note': 'Average daemon response generation time (proxy for inbox-to-action)'
+        }
+    else:
+        metrics['inbox_to_action_time'] = {'value': None, 'unit': 'seconds', 'note': 'No response data available'}
+
+    # holding_note_time: Measured from actions log where action_type contains "holding"
+    holding_actions = [a for a in actions if 'holding' in str(a.get('action_type', '')).lower()
+                       or 'holding' in str(a.get('result', '')).lower()]
+    metrics['holding_note_time'] = {
+        'value': len(holding_actions),
+        'unit': 'count',
+        'note': f'{len(holding_actions)} holding notes sent today'
+    }
+
+    # --- Throughput ---
+
+    # queue_throughput: Items resolved/closed today
+    queue_counts, queue_total = count_queue_items(queues_dir)
+    resolved_closed = queue_counts.get('resolved', 0) + queue_counts.get('closed', 0)
+    metrics['queue_throughput'] = {
+        'value': resolved_closed,
+        'unit': 'items',
+        'total_items': queue_total,
+        'breakdown': dict(queue_counts),
+        'note': f'{resolved_closed} resolved/closed out of {queue_total} total queue items'
+    }
+
+    # queue_age: computed from queue items with created dates — would need YAML parsing
+    open_items = queue_counts.get('open', 0) + queue_counts.get('in_progress', 0)
+    metrics['queue_age'] = {
+        'value': open_items,
+        'unit': 'open_items',
+        'note': f'{open_items} items currently open/in_progress (age computation requires YAML date parsing)'
+    }
+
+    # --- Accuracy ---
+
+    # classification_accuracy: from inbox processor logs
+    total_classified = 0
+    classifications = {}
+    for entry in inbox_logs:
+        if 'classifications' in entry:
+            cls = entry['classifications']
+            if isinstance(cls, dict):
+                # Format: {"action_required": 9, "fyi": 15, "ignore": 7}
+                for category, count in cls.items():
+                    classifications[category] = classifications.get(category, 0) + count
+                    total_classified += count
+            elif isinstance(cls, list):
+                # Format: [{"id": ..., "class": "fyi", ...}, ...]
+                for item in cls:
+                    cat = item.get('class', 'unknown')
+                    classifications[cat] = classifications.get(cat, 0) + 1
+                    total_classified += 1
+        if 'items_processed' in entry and 'classifications' not in entry:
+            total_classified += entry.get('items_processed', 0)
+
+    metrics['classification_accuracy'] = {
+        'value': total_classified,
+        'unit': 'items_classified',
+        'breakdown': classifications,
+        'note': f'{total_classified} items classified today. Accuracy requires reclassification tracking (not yet instrumented).'
+    }
+
+    # duplicate_reply_rate: from validation logs — count entries with issues
+    total_validations = len(validations)
+    issues_found = sum(1 for v in validations if v.get('issues_found', 0) > 0)
+    blockers_found = sum(1 for v in validations if v.get('blockers', 0) > 0)
+    metrics['duplicate_reply_rate'] = {
+        'value': blockers_found,
+        'unit': 'blocked_sends',
+        'total_validations': total_validations,
+        'issues_found': issues_found,
+        'note': f'{blockers_found} sends blocked, {issues_found} issues out of {total_validations} validations'
+    }
+
+    # factual_accuracy: requires manual tracking — report as unmeasured
+    metrics['factual_accuracy'] = {
+        'value': None,
+        'unit': 'corrections',
+        'note': 'Requires manual tracking of corrections from recipients'
+    }
+
+    # --- Follow-through ---
+
+    # follow_through_rate & sla_breach_rate: from queue SLA fields
+    metrics['follow_through_rate'] = {
+        'value': None,
+        'unit': 'percentage',
+        'note': 'Requires SLA deadline comparison (not yet instrumented in metric script)'
+    }
+
+    metrics['sla_breach_rate'] = {
+        'value': None,
+        'unit': 'percentage',
+        'note': 'Requires SLA deadline comparison (not yet instrumented in metric script)'
+    }
+
+    # --- CEO Satisfaction ---
+
+    # ceo_correction_rate & ceo_positive_signal_rate: from interaction patterns
+    ceo_responses = [r for r in responses if r.get('sender') == 'mehran-granfar']
+    metrics['ceo_correction_rate'] = {
+        'value': len(ceo_responses),
+        'unit': 'ceo_interactions',
+        'note': f'{len(ceo_responses)} CEO interactions today. Correction/positive signal classification not yet instrumented.'
+    }
+    metrics['ceo_positive_signal_rate'] = {
+        'value': None,
+        'unit': 'percentage',
+        'note': 'Requires sentiment classification of CEO responses'
+    }
+
+    # --- System Health ---
+
+    # error_rate: from workflow logs — count entries with error/failed status
+    all_workflow_logs = []
+    for wf_file in logs_workflows.glob(f'{date_str}-*.jsonl'):
+        all_workflow_logs.extend(parse_jsonl(wf_file))
+
+    total_workflow_entries = len(all_workflow_logs)
+    error_entries = sum(1 for e in all_workflow_logs
+                       if e.get('status') in ('error', 'failed')
+                       or 'error' in str(e.get('status', '')).lower())
+    metrics['error_rate'] = {
+        'value': round(error_entries / max(total_workflow_entries, 1) * 100, 1),
+        'unit': 'percentage',
+        'errors': error_entries,
+        'total_entries': total_workflow_entries,
+        'note': f'{error_entries} errors in {total_workflow_entries} workflow log entries'
+    }
+
+    # harness_complexity: line count across key config files
+    complexity_dirs = [
+        REPO_ROOT / 'agents',
+        REPO_ROOT / 'workflows',
+        REPO_ROOT / 'policies',
+        REPO_ROOT / 'schedules',
+    ]
+    total_lines = 0
+    file_count = 0
+    for d in complexity_dirs:
+        if d.exists():
+            for f in d.rglob('*'):
+                if f.is_file() and f.suffix in ('.md', '.yaml', '.yml'):
+                    try:
+                        total_lines += sum(1 for _ in open(f))
+                        file_count += 1
+                    except Exception:
+                        pass
+
+    metrics['harness_complexity'] = {
+        'value': total_lines,
+        'unit': 'lines',
+        'file_count': file_count,
+        'dirs': ['agents/', 'workflows/', 'policies/', 'schedules/'],
+        'note': f'{total_lines} total lines across {file_count} config files'
+    }
+
+    # context_recall_accuracy & entity_index_coverage: require manual assessment
+    metrics['context_recall_accuracy'] = {
+        'value': None,
+        'unit': 'percentage',
+        'note': 'Requires manual assessment during weekly review'
+    }
+
+    # entity_index_coverage: check memory indexes
+    entity_index = REPO_ROOT / 'memory' / 'indexes' / 'entity-relationships.yaml'
+    profiles_dir = REPO_ROOT / 'memory' / 'profiles' / 'users'
+    profile_count = len(list(profiles_dir.glob('*.yaml'))) if profiles_dir.exists() else 0
+    metrics['entity_index_coverage'] = {
+        'value': profile_count,
+        'unit': 'user_profiles',
+        'index_exists': entity_index.exists(),
+        'note': f'{profile_count} user profiles in memory. Index exists: {entity_index.exists()}'
+    }
+
+    # --- Summary stats ---
+    total_sends = 0
+    send_counter = REPO_ROOT / 'logs' / 'audit' / 'send-counter.yaml'
+    if send_counter.exists():
+        with open(send_counter, 'r') as f:
+            for line in f:
+                if 'total:' in line and 'totals' not in line:
+                    try:
+                        total_sends = int(line.split(':')[1].strip())
+                    except (ValueError, IndexError):
+                        pass
+
+    metrics['_summary'] = {
+        'total_actions_logged': len(actions),
+        'total_validations': total_validations,
+        'total_workflow_entries': total_workflow_entries,
+        'total_daemon_responses': len(responses),
+        'total_sessions': len(sessions),
+        'total_sends_today': total_sends,
+        'total_queue_items': queue_total,
+    }
+
+    return metrics
+
+
+def format_yaml(metrics, date_str):
+    """Format metrics as YAML snapshot."""
+    lines = [f'- date: "{date_str}"']
+    lines.append(f'  computed_at: "{datetime.now(timezone.utc).isoformat()}"')
+    lines.append('  metrics:')
+
+    for key, val in metrics.items():
+        if key == '_summary':
+            lines.append('  summary:')
+            for sk, sv in val.items():
+                lines.append(f'    {sk}: {sv}')
+            continue
+
+        lines.append(f'    {key}:')
+        for vk, vv in val.items():
+            if isinstance(vv, dict):
+                lines.append(f'      {vk}:')
+                for dk, dv in vv.items():
+                    lines.append(f'        {dk}: {json.dumps(dv) if isinstance(dv, str) else dv}')
+            elif isinstance(vv, str):
+                lines.append(f'      {vk}: "{vv}"')
+            elif vv is None:
+                lines.append(f'      {vk}: null')
+            else:
+                lines.append(f'      {vk}: {vv}')
+
+    return '\n'.join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Compute self-optimization metrics')
+    parser.add_argument('--date', default=datetime.now().strftime('%Y-%m-%d'),
+                        help='Date to compute metrics for (YYYY-MM-DD)')
+    parser.add_argument('--append', action='store_true',
+                        help='Append to metric-snapshots.yaml')
+    args = parser.parse_args()
+
+    metrics = compute_metrics(args.date)
+    yaml_output = format_yaml(metrics, args.date)
+
+    if args.append:
+        snapshots_path = REPO_ROOT / 'self-optimization' / 'metric-snapshots.yaml'
+        mode = 'a' if snapshots_path.exists() else 'w'
+        with open(snapshots_path, mode) as f:
+            if mode == 'w':
+                f.write('# Self-Optimization Metric Snapshots\n')
+                f.write('# Computed by: scripts/self-optimization/compute-metrics.py\n')
+                f.write('# Read by: evening wrap, weekly review, experiment evaluator\n\n')
+                f.write('snapshots:\n')
+            f.write('\n' + yaml_output + '\n')
+        print(f'Snapshot appended to {snapshots_path}', file=sys.stderr)
+    else:
+        print(yaml_output)
+
+
+if __name__ == '__main__':
+    main()

package/scripts/send-difc-rfp.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# send-difc-rfp.sh — Send DIFC fitout RFP to 10 pre-qualified contractors
+# From: Sophie Nguyen <sophie@adaptic.ai>
+# CC: mehran@adaptic.ai
+# Attachment: Proposed floor plan layout
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_DIR="$(dirname "$SCRIPT_DIR")"
+ATTACHMENT="$REPO_DIR/outputs/projects/Proposed-Layout-DIFC-Office.png"
+SUBJECT="RFP — Fitout Project Management Services | Adaptic Holdings | DIFC Square SQ1 L2 Unit 3"
+LOG_FILE="$REPO_DIR/logs/audit/2026-04-03-actions.jsonl"
+
+source "$REPO_DIR/.env"
+
+if [ ! -f "$ATTACHMENT" ]; then
+  echo "ERROR: Floor plan not found at $ATTACHMENT"
+  exit 1
+fi
+
+send_rfp() {
+  local email="$1"
+  local name="$2"
+  local company="$3"
+
+  local body="Dear ${name},
+
+We are writing to invite ${company} to submit a proposal for fitout project management services for our new office at DIFC Square.
+
+Project summary:
+
+- Tenant: Adaptic Holdings Limited (DIFC-registered entity)
+- Unit: Tower 1, Level 2, Unit 3 (~1,380 sqft)
+- Condition: Shell & core (handed over 19 February 2026)
+- Fitout type: Type A (per DIFC Fitout Manual Rev. 22)
+- Use: Professional office (financial technology / asset management)
+
+We have attached a proposed floor plan layout for your reference. Please note: the attached floor plan is a preliminary design concept / rough mockup and is shared for indicative purposes only. Final design will be developed in collaboration with the appointed firm.
+
+We are seeking a qualified DIFC-registered firm to provide fitout project management services, specifically:
+
+1. Design development — Translating our concept layout into compliant design drawings (architectural, MEP, fire & life safety) per DIFC fitout requirements
+2. Authority submissions — Managing all DIFC portal submissions, design approvals, and NOC applications on our behalf
+3. Regulatory coordination — Liaising with the DIFC fitout team throughout the approval and inspection process
+4. Contractor induction — Registering on the DIFC portal, completing the fitout induction, and coordinating all required documentation
+5. IT infrastructure NOC — Managing the DU/Etisalat NOC application
+6. Project management through to handback — Overseeing the fitout works, quality control, and DIFC completion inspection
+
+What we are requesting in your proposal:
+
+- Fee structure for the project management / fitout consultancy scope described above (lump sum or percentage of works cost)
+- Estimated timeline from appointment to occupancy
+- Indicative budget range for the fitout works (based on comparable DIFC office projects of similar size)
+- Two relevant project references (DIFC or similar free-zone commercial office fitouts)
+- Confirmation of current DIFC prequalification status
+
+Please note: we are not requesting a full construction tender at this stage. We are seeking to understand the cost and timeline for engaging a qualified firm to manage the DIFC submission process, regulatory approvals, and overall project delivery on our behalf.
+
+We would appreciate receiving your proposal by 17 April 2026. Please direct all correspondence to sophie@adaptic.ai.
+
+Kind regards,"
+
+  echo "Sending to: $email ($name at $company)..."
+  python3 "$SCRIPT_DIR/send-email-with-attachment.py" \
+    "$email" \
+    "$SUBJECT" \
+    "$body" \
+    --cc "mehran@adaptic.ai" \
+    --attachment "$ATTACHMENT"
+
+  echo "{\"timestamp\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"action\":\"email_sent\",\"type\":\"rfp\",\"from\":\"sophie@adaptic.ai\",\"to\":\"$email\",\"cc\":\"mehran@adaptic.ai\",\"subject\":\"$SUBJECT\",\"recipient_name\":\"$name\",\"recipient_company\":\"$company\",\"attachment\":\"Proposed-Layout-DIFC-Office.png\",\"context\":\"DIFC fitout RFP batch send\"}" >> "$LOG_FILE"
+
+  echo "  -> Sent and logged."
+  sleep 3
+}
+
+echo "=== DIFC Fitout RFP Batch Send ==="
+echo "Sending to 10 pre-qualified contractors"
+echo "From: Sophie Nguyen <sophie@adaptic.ai>"
+echo "CC: mehran@adaptic.ai"
+echo "Attachment: $(basename $ATTACHMENT)"
+echo ""
+
+send_rfp "hani@arkigroup.com" "Hani" "Arki Group Design"
+send_rfp "charlie@motifuae.com" "Charlie" "Motif Interior Decoration"
+send_rfp "joana@design-infinity.com" "Joana" "Design Infinity"
+send_rfp "Wgoode@inc-solutions.com" "William" "INC Interiors"
+send_rfp "uppin@evolveinteriors.com" "Mohan" "Evolve Interiors"
+send_rfp "walid.zahra@blueprintme.com" "Walid" "Blueprint Emirates Interiors"
+send_rfp "sivin@corecreationsinteriors.com" "Sivin" "Core Creations"
+send_rfp "prince@innerspace.ae" "Prince" "Inner Space Interior Design"
+send_rfp "patrick@bluecamel.net" "Patrick" "Blue Camel Design"
+send_rfp "bdm@turnkeyinterior.ae" "Prince" "Turnkey Interior Decoration"
+
+echo ""
+echo "=== All 10 RFP emails sent ==="
+echo "Proposals due: 17 April 2026"
+echo "Responses directed to: sophie@adaptic.ai"