@adaptic/maestro 1.0.0

package/scripts/continuous-monitor.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Continuous Monitoring Launcher
+# Starts the perpetual monitoring loop for all communication channels.
+# Designed to be run as a launchd daemon.
+#
+# Usage: ./scripts/continuous-monitor.sh [--channel slack|gmail|whatsapp|all]
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SOPHIE_AI_DIR="$(dirname "$SCRIPT_DIR")"
+CHANNEL="${1:---channel all}"
+CHANNEL="${CHANNEL#--channel }"
+LOG_DIR="$SOPHIE_AI_DIR/logs/monitor"
+QUEUE_DIR="$SOPHIE_AI_DIR/outputs/inbound/queue"
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+mkdir -p "$LOG_DIR" "$QUEUE_DIR"
+
+# Check emergency stop
+check_stop() {
+    if [ -f "$SOPHIE_AI_DIR/.emergency-stop" ]; then
+        echo "[$TIMESTAMP] Monitor halted: emergency stop active" >> "$LOG_DIR/monitor.log"
+        exit 0
+    fi
+}
+
+# Monitor loop for a specific channel
+monitor_channel() {
+    local channel=$1
+    local interval=$2
+    local log_file="$LOG_DIR/$channel.log"
+
+    echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Starting $channel monitor (interval: ${interval}s)" >> "$log_file"
+
+    while true; do
+        check_stop
+
+        echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Polling $channel..." >> "$log_file"
+
+        # Use Claude to observe the channel via desktop control
+        # This invokes the appropriate operator agent in observe mode
+        claude -p "You are the $channel monitoring agent for Sophie Nguyen at Adaptic.ai.
+OBSERVE ONLY — do not send any messages.
+Check for new messages since the last check.
+If there are new messages, write a YAML summary to: $QUEUE_DIR/${channel}-$(date +%s).yaml
+Include: sender, timestamp, channel/thread, subject/preview, urgency_hint.
+If no new messages, do nothing.
+Check the desktop $channel app using screenshot observation.
+Working directory: $SOPHIE_AI_DIR" \
+        --output-format text \
+        >> "$log_file" 2>&1 || true
+
+        sleep "$interval"
+    done
+}
+
+case "$CHANNEL" in
+    slack)
+        monitor_channel "slack" 60
+        ;;
+    gmail)
+        monitor_channel "gmail" 120
+        ;;
+    whatsapp)
+        monitor_channel "whatsapp" 120
+        ;;
+    all)
+        # Launch all monitors in parallel
+        monitor_channel "slack" 60 &
+        SLACK_PID=$!
+        monitor_channel "gmail" 120 &
+        GMAIL_PID=$!
+        monitor_channel "whatsapp" 120 &
+        WHATSAPP_PID=$!
+
+        echo "[$TIMESTAMP] All monitors started: slack=$SLACK_PID gmail=$GMAIL_PID whatsapp=$WHATSAPP_PID" >> "$LOG_DIR/monitor.log"
+
+        # Wait for any to exit (shouldn't happen unless error or stop)
+        wait
+        ;;
+    *)
+        echo "Unknown channel: $CHANNEL. Use: slack, gmail, whatsapp, or all"
+        exit 1
+        ;;
+esac

package/scripts/daemon/classifier.mjs

@@ -0,0 +1,355 @@
+/**
+ * classifier.mjs — Fast LLM-based classification of incoming messages
+ *
+ * Classifies Slack, Gmail, and Calendar inbox items to determine priority,
+ * action type, and which Claude model should handle them.
+ *
+ * Classification chain:
+ *   1. Anthropic Claude Haiku (primary)
+ *   2. OpenAI gpt-4o-mini (fallback)
+ *   3. Rule-based heuristics (final fallback)
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import dotenv from "dotenv";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+
+// Load .env from project root
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+dotenv.config({ path: resolve(__dirname, "../../.env") });
+
+const ANTHROPIC_MODEL = "claude-haiku-4-5-20251001";
+const OPENAI_MODEL = "gpt-4o-mini";
+
+// ── System prompt shared by both LLM classifiers ────────────────────────────
+
+const SYSTEM_PROMPT = `You are a message classifier for Sophie Nguyen, Chief of Staff (AI-operated) at Adaptic.ai. Sophie is the autonomous executive command layer for CEO Mehran Granfar.
+
+Your job: classify each incoming message and return a JSON object with exactly these fields:
+
+{
+  "priority": "critical" | "high" | "normal" | "ignore",
+  "action": "respond" | "draft" | "research" | "queue" | "archive" | "ignore",
+  "model": "opus" | "sonnet",
+  "summary": "<one-line summary of the message>",
+  "category": "action_required" | "fyi" | "ignore",
+  "directed_at_sophie": true | false
+}
+
+Classification rules:
+
+PRIORITY:
+- "critical": CEO (Mehran) direct messages, anything requiring immediate action, regulatory deadlines, legal escalations, board-level requests
+- "high": Leadership team requests (CFO, GC, SEO), urgent keywords ("urgent", "asap", "immediately", "deadline", "blocker"), time-sensitive operational matters, candidate offers/rejections
+- "normal": Routine operational messages, team updates, standard requests, meeting notes, general coordination
+- "ignore": Automated notifications (GitHub, Railway, CI/CD), marketing emails, newsletters, noreply senders, spam, out-of-office replies
+
+ACTION:
+- "respond": Message needs a direct reply (question asked, request made, confirmation needed)
+- "draft": Message needs a document or email drafted (board materials, memos, proposals)
+- "research": Message requires investigation or analysis before acting
+- "queue": Message is an action item but not time-critical — add to backlog
+- "archive": Informational only, no action needed but worth storing
+- "ignore": No value — spam, noise, duplicates
+
+MODEL (which Claude model should handle the response):
+- "opus": Complex reasoning, strategic decisions, legal/regulatory, board materials, CEO requests, multi-step analysis, sensitive communications
+- "sonnet": Routine responses, scheduling, status updates, simple follow-ups, acknowledgements, standard operational tasks
+
+CATEGORY:
+- "action_required": Sophie needs to do something
+- "fyi": Informational, no action needed
+- "ignore": No value
+
+DIRECTED_AT_SOPHIE (CRITICAL — determines whether Sophie should respond. Default to false in channels/group chats.):
+- true: The message is a DM to Sophie (1:1)
+- true: The message explicitly mentions Sophie by name or @mention
+- true: The message is from the CEO in a DM (1:1 conversation)
+- true: The message explicitly asks Sophie to do something she's responsible for (scheduling, follow-ups, coordination, research) AND addresses her specifically by name or @mention
+- true: In a thread where Sophie previously replied, the message is a DIRECT reply to what Sophie said (e.g., answering her question, responding to her update) — not just any message in the same thread
+- false: CEO messages in channels/group chats that don't mention Sophie — the CEO talks to many people, not just Sophie
+- false: The message is general channel chatter between other team members
+- false: The message is a conversation between two people that doesn't involve Sophie, even if Sophie previously participated in the same thread
+- false: The message is a status update, FYI, or announcement not requiring Sophie's response
+- false: The message is someone responding to another person (not Sophie) in a thread
+- false: Short reactions like "thanks", "nice", "got it", "+1", emoji-only messages — even in threads Sophie is in
+- false: Someone sharing a link, article, or resource with the channel generally
+- false: Sophie being in a thread does NOT mean every subsequent message is for her — only direct replies to her messages count
+- CRITICAL DEFAULT: When in doubt in any multi-person channel, group chat, or thread, ALWAYS default to false. Sophie must NOT insert herself into conversations she wasn't invited to. It is far worse to respond unnecessarily than to miss a message — someone will @mention Sophie if they need her.
+
+Context:
+- sender_privilege "ceo" = Mehran Granfar (always critical, always opus)
+- sender_privilege "leadership" = Hootan (CFO/CIO/SEO), Nima (GC), Shayan (FTLab) — usually high priority
+- sender_privilege "team" = internal team members
+- sender_privilege "external" = partners, candidates, advisors, vendors
+- sender_privilege "unknown" = unrecognised sender
+- service "gmail" with noreply/notifications senders = usually ignore
+- service "calendar" = meeting invites/updates, usually normal priority unless from CEO
+
+Examples:
+
+Input: CEO DM on Slack: "Can you send the board resolution to Nima?"
+Output: {"priority":"critical","action":"respond","model":"opus","summary":"CEO requesting board resolution sent to GC Nima","category":"action_required","directed_at_sophie":true}
+
+Input: GitHub notification email about a merged PR
+Output: {"priority":"ignore","action":"ignore","model":"sonnet","summary":"GitHub PR merge notification","category":"ignore","directed_at_sophie":false}
+
+Input: Leadership Slack: "We need the DFSA gap analysis updated by Thursday"
+Output: {"priority":"high","action":"draft","model":"opus","summary":"Leadership requesting DFSA gap analysis update by Thursday deadline","category":"action_required","directed_at_sophie":true}
+
+Input: Team member: "Standup notes from today's sync"
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team standup notes shared","category":"fyi","directed_at_sophie":false}
+
+Input: External email: "Following up on our conversation about the Singapore entity"
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"External follow-up on Singapore entity discussion","category":"action_required","directed_at_sophie":true}
+
+Input: Channel message from Jacob: "@Sophie can you check the engine deployment?"
+Output: {"priority":"normal","action":"respond","model":"sonnet","summary":"Jacob asking Sophie to check engine deployment","category":"action_required","directed_at_sophie":true}
+
+Input: Channel message from Hootan to Nima: "Nima, did you file the DIFC response yet?"
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Hootan asking Nima about DIFC response filing","category":"fyi","directed_at_sophie":false}
+
+Input: Channel thread — Jacob: "pushed the fix" / Hootan: "nice, looks good"
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Team exchange about code fix","category":"fyi","directed_at_sophie":false}
+
+Input: Thread where Sophie previously replied — Jacob: "yeah that makes sense, I'll handle it" (responding to Hootan, not Sophie)
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Jacob acknowledging Hootan in thread","category":"fyi","directed_at_sophie":false}
+
+Input: Thread where Sophie previously replied — Hootan: "Sophie, can you send the updated doc?"
+Output: {"priority":"high","action":"respond","model":"sonnet","summary":"Hootan asking Sophie for updated document","category":"action_required","directed_at_sophie":true}
+
+Input: Channel message: "FYI — the Cayman entity docs are signed and filed"
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"FYI: Cayman entity docs signed and filed","category":"fyi","directed_at_sophie":false}
+
+Input: Group chat — Nima: "Hootan, can we sync on the DFSA gaps tomorrow?"
+Output: {"priority":"normal","action":"archive","model":"sonnet","summary":"Nima asking Hootan to sync on DFSA gaps","category":"fyi","directed_at_sophie":false}
+
+Return ONLY the JSON object. No explanation, no markdown fencing, no extra text.`;
+
+// ── Format the inbox item into a human-readable prompt ──────────────────────
+
+function formatItemPrompt(item) {
+  const parts = [
+    `Sender: ${item.sender} (privilege: ${item.sender_privilege})`,
+    `Service: ${item.service}`,
+    `Channel: ${item.channel}`,
+  ];
+  // Indicate channel type so the classifier can assess directed-ness
+  if (item.is_dm) {
+    parts.push("Channel type: Direct message (1:1 with Sophie)");
+  } else if (item.is_group) {
+    parts.push("Channel type: Group chat / multi-person channel");
+  }
+  if (item.subject) parts.push(`Subject: ${item.subject}`);
+  if (item.is_reply) parts.push("This is a reply in an existing thread.");
+  if (item.sophie_in_thread) parts.push("Sophie has previously replied in this thread.");
+  if (item.thread_context) {
+    parts.push(`Thread context:\n${item.thread_context}`);
+  }
+  parts.push(`\nContent:\n${item.content}`);
+  return parts.join("\n");
+}
+
+// ── Parse LLM response into classification object ───────────────────────────
+
+function parseClassification(text) {
+  // Strip markdown code fences if present
+  const cleaned = text.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim();
+  const parsed = JSON.parse(cleaned);
+
+  // Validate and coerce fields
+  const validPriorities = ["critical", "high", "normal", "ignore"];
+  const validActions = ["respond", "draft", "research", "queue", "archive", "ignore"];
+  const validModels = ["opus", "sonnet"];
+  const validCategories = ["action_required", "fyi", "ignore"];
+
+  return {
+    priority: validPriorities.includes(parsed.priority) ? parsed.priority : "normal",
+    action: validActions.includes(parsed.action) ? parsed.action : "queue",
+    model: validModels.includes(parsed.model) ? parsed.model : "sonnet",
+    summary: typeof parsed.summary === "string" ? parsed.summary : "Unclassified message",
+    category: validCategories.includes(parsed.category) ? parsed.category : "fyi",
+    directed_at_sophie: typeof parsed.directed_at_sophie === "boolean" ? parsed.directed_at_sophie : false, // default false — don't respond unless we're confident the message is for Sophie
+  };
+}
+
+// ── Primary: Anthropic Claude Haiku ─────────────────────────────────────────
+
+async function classifyWithAnthropic(item) {
+  const client = new Anthropic();
+  const response = await client.messages.create({
+    model: ANTHROPIC_MODEL,
+    max_tokens: 256,
+    system: SYSTEM_PROMPT,
+    messages: [
+      { role: "user", content: formatItemPrompt(item) },
+    ],
+  });
+  const text = response.content[0].text;
+  return parseClassification(text);
+}
+
+// ── Fallback 1: OpenAI gpt-4o-mini ─────────────────────────────────────────
+
+async function classifyWithOpenAI(item) {
+  const client = new OpenAI();
+  const response = await client.chat.completions.create({
+    model: OPENAI_MODEL,
+    max_tokens: 256,
+    messages: [
+      { role: "system", content: SYSTEM_PROMPT },
+      { role: "user", content: formatItemPrompt(item) },
+    ],
+  });
+  const text = response.choices[0].message.content;
+  return parseClassification(text);
+}
+
+// ── Fallback 2: Rule-based classification ───────────────────────────────────
+
+/**
+ * Rule-based check for whether a message is directed at Sophie.
+ * Used by both the rule-based classifier fallback and as a pre-check
+ * that can override the LLM's assessment in clear-cut cases.
+ */
+function isDirectedAtSophie(item) {
+  // DMs are always directed at Sophie
+  if (item.is_dm) return true;
+  if ((item.channel || "").startsWith("dm/")) return true;
+
+  // CEO DMs are always directed at Sophie, but in channels/group chats
+  // the CEO may be talking to other people — don't auto-insert Sophie.
+  // CEO channel messages only count as directed if they mention Sophie.
+  if (item.sender_privilege === "ceo" && item.is_dm) return true;
+
+  // Explicit @mention or name mention in the message content
+  const content = (item.content || "").toLowerCase();
+  if (content.includes("sophie") || content.includes("<@u09") || content.includes("<@u0a")) return true; // Sophie user ID prefixes
+
+  // Gmail/calendar messages are directed at Sophie (they're in her inbox)
+  if (item.service === "gmail" || item.service === "calendar") return true;
+
+  // Sophie being in a thread is NOT enough on its own — in group chats,
+  // other people may be talking to each other. Only treat it as directed
+  // if the message also contains a question, request keyword, or is a
+  // direct follow-up to Sophie's last message in the thread.
+  if (item.sophie_in_thread || (item.thread_context && /^Sophie:/m.test(item.thread_context))) {
+    // Check if Sophie was the last speaker in the thread (sender is replying to her)
+    if (item.thread_context) {
+      const lines = item.thread_context.trim().split("\n").filter(Boolean);
+      const lastLine = lines[lines.length - 1] || "";
+      if (/^Sophie:/i.test(lastLine)) return true;
+    }
+    // Check for question marks or request-like language directed at Sophie
+    if (/\?/.test(content)) return true;
+    if (/(?:can you|could you|please|would you|do you|let me know|update|status|any update)/i.test(content)) return true;
+    // Otherwise, don't assume the message is for Sophie just because she's in the thread
+  }
+
+  return false;
+}
+
+function classifyWithRules(item) {
+  const content = (item.content || "").toLowerCase();
+  const sender = (item.sender || "").toLowerCase();
+  const subject = (item.subject || "").toLowerCase();
+  const combined = `${content} ${sender} ${subject}`;
+  const directed = isDirectedAtSophie(item);
+
+  // CEO → critical, opus (but in channels, respect directed check)
+  if (item.sender_privilege === "ceo") {
+    return {
+      priority: "critical",
+      action: directed ? "respond" : "archive",
+      model: "opus",
+      summary: `CEO message from ${item.sender}`,
+      category: directed ? "action_required" : "fyi",
+      directed_at_sophie: directed,
+    };
+  }
+
+  // Leadership → high, opus
+  if (item.sender_privilege === "leadership") {
+    return {
+      priority: "high",
+      action: directed ? "respond" : "archive",
+      model: "opus",
+      summary: `Leadership message from ${item.sender}`,
+      category: directed ? "action_required" : "fyi",
+      directed_at_sophie: directed,
+    };
+  }
+
+  // Gmail noise → ignore
+  if (item.service === "gmail") {
+    const noisePatterns = ["noreply", "no-reply", "notifications", "github.com", "railway.app"];
+    if (noisePatterns.some((p) => combined.includes(p))) {
+      return {
+        priority: "ignore",
+        action: "ignore",
+        model: "sonnet",
+        summary: `Automated notification from ${item.sender}`,
+        category: "ignore",
+        directed_at_sophie: false,
+      };
+    }
+  }
+
+  // Urgent keywords → high
+  const urgentKeywords = ["urgent", "asap", "immediately", "blocker", "deadline"];
+  if (urgentKeywords.some((kw) => content.includes(kw))) {
+    return {
+      priority: "high",
+      action: directed ? "respond" : "archive",
+      model: "sonnet",
+      summary: `Urgent message from ${item.sender}`,
+      category: directed ? "action_required" : "fyi",
+      directed_at_sophie: directed,
+    };
+  }
+
+  // Default → normal, sonnet
+  return {
+    priority: "normal",
+    action: directed ? "queue" : "archive",
+    model: "sonnet",
+    summary: `Message from ${item.sender} via ${item.service}`,
+    category: directed ? "fyi" : "fyi",
+    directed_at_sophie: directed,
+  };
+}
+
+// Export for use in daemon's pre-classification gate
+export { isDirectedAtSophie };
+
+// ── Main export ─────────────────────────────────────────────────────────────
+
+/**
+ * Classify an incoming inbox item.
+ *
+ * @param {Object} item - Inbox item with sender, sender_privilege, channel,
+ *   service, content, is_reply, thread_context, subject
+ * @returns {Promise<{priority: string, action: string, model: string, summary: string, category: string}>}
+ */
+export async function classifyItem(item) {
+  // Try Anthropic first
+  try {
+    return await classifyWithAnthropic(item);
+  } catch (err) {
+    console.warn(`[classifier] Anthropic failed: ${err.message}`);
+  }
+
+  // Fallback to OpenAI
+  try {
+    return await classifyWithOpenAI(item);
+  } catch (err) {
+    console.warn(`[classifier] OpenAI failed: ${err.message}`);
+  }
+
+  // Final fallback: rules
+  console.warn("[classifier] All LLMs unavailable, using rule-based classification");
+  return classifyWithRules(item);
+}