@adaptic/maestro 1.0.0

package/scripts/daemon/responder.mjs

@@ -0,0 +1,547 @@
+/**
+ * responder.mjs — Quick response layer
+ *
+ * Handles two scenarios without spawning claude --print sessions:
+ *
+ * 1. SIMPLE REPLIES: Uses Anthropic Sonnet API to generate a response,
+ *    then posts directly via Slack/Gmail API. ~4 seconds total.
+ *
+ * 2. HOLDING MESSAGES: For complex items that need a full session,
+ *    generates and sends an immediate acknowledgment so the sender
+ *    knows it's being worked on.
+ *
+ * This eliminates CLI startup overhead for routine responses and
+ * provides instant feedback for complex requests.
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+import { readFileSync, writeFileSync, readdirSync, appendFileSync, mkdirSync } from "fs";
+import { execFileSync } from "child_process";
+import { join } from "path";
+import { checkRecentlySent, registerSent } from "./session-lock.mjs";
+
+const SOPHIE_AI_DIR = join(new URL(".", import.meta.url).pathname, "../..");
+const SONNET_MODEL = "claude-sonnet-4-6";
+
+// Lazy token access — dotenv loads in daemon main before these are called
+function getSlackToken() {
+  return process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN;
+}
+
+let anthropic = null;
+let cachedPreamble = null;
+
+function getClient() {
+  if (!anthropic) anthropic = new Anthropic();
+  return anthropic;
+}
+
+function today() {
+  return new Date().toISOString().split("T")[0];
+}
+
+function logDir() {
+  const dir = join(SOPHIE_AI_DIR, "logs", "daemon");
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function logResponse(entry) {
+  const path = join(logDir(), `${today()}-responses.jsonl`);
+  appendFileSync(path, JSON.stringify({ timestamp: new Date().toISOString(), ...entry }) + "\n");
+}
+
+/**
+ * Write an interaction record so future sessions can see this exchange.
+ * Both the incoming message and Sophie's reply are logged.
+ */
+function logInteraction(item, responseText) {
+  if (!item || !item.sender || item.service !== "slack") return;
+  const senderSlug = item.sender.replace(/\s+/g, "-").toLowerCase();
+  const channelId = resolveSlackChannel(item);
+
+  // Write to both channel-ID and sender-slug directories
+  const dirs = [];
+  if (channelId) dirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", channelId));
+  dirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", `dm-${senderSlug}`));
+
+  const incomingEntry = {
+    ts: item.ts || item.timestamp || new Date().toISOString(),
+    from: item.sender,
+    channel: channelId || item.channel,
+    type: item.is_reply ? "thread_reply" : "dm",
+    content: item.content || "",
+    received_at: new Date().toISOString(),
+    classification: "quick_reply",
+    response_sent: true,
+  };
+
+  const responseEntry = {
+    ts: new Date().toISOString(),
+    from: "sophie",
+    channel: channelId || item.channel,
+    type: "reply",
+    content: responseText,
+    sent_at: new Date().toISOString(),
+    via: "quick_reply_responder",
+  };
+
+  for (const dir of dirs) {
+    try {
+      mkdirSync(dir, { recursive: true });
+      const logPath = join(dir, `${today()}.jsonl`);
+      appendFileSync(logPath, JSON.stringify(incomingEntry) + "\n");
+      appendFileSync(logPath, JSON.stringify(responseEntry) + "\n");
+    } catch (err) {
+      console.warn(`[responder] Failed to log interaction to ${dir}: ${err.message}`);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Identity preamble (cached)
+// ---------------------------------------------------------------------------
+
+function loadPreamble() {
+  if (cachedPreamble) return cachedPreamble;
+  try {
+    const raw = readFileSync(join(SOPHIE_AI_DIR, "CLAUDE.md"), "utf-8");
+    // Extract just the identity and communication rules
+    const lines = raw.split("\n");
+    const sections = [];
+    let capturing = false;
+    const targets = ["## Identity", "## Company Context", "## Communication Rules"];
+    for (const line of lines) {
+      if (targets.some((h) => line.startsWith(h))) { capturing = true; sections.push(line); continue; }
+      if (capturing && /^## [A-Z]/.test(line) && !targets.some((h) => line.startsWith(h))) { capturing = false; continue; }
+      if (capturing) sections.push(line);
+    }
+    cachedPreamble = sections.join("\n").trim();
+    if (cachedPreamble.length < 100) cachedPreamble = FALLBACK_PREAMBLE;
+  } catch {
+    cachedPreamble = FALLBACK_PREAMBLE;
+  }
+  return cachedPreamble;
+}
+
+const FALLBACK_PREAMBLE = `You are Sophie Nguyen, Chief of Staff to Mehran Granfar, CEO of Adaptic.ai.
+You operate as the autonomous executive command layer. Be concise, direct, and professional.
+For CEO messages: prioritise speed and directness. For others: be warm but efficient.`;
+
+// ---------------------------------------------------------------------------
+// Load user profile for context
+// ---------------------------------------------------------------------------
+
+function loadUserProfile(sender) {
+  try {
+    const profileName = sender.replace(/\s+/g, "-").toLowerCase();
+    const path = join(SOPHIE_AI_DIR, "memory", "profiles", "users", `${profileName}.yaml`);
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Load recent conversation history for context
+// ---------------------------------------------------------------------------
+
+function loadConversationHistory(item) {
+  if (!item || !item.sender) return null;
+
+  const senderSlug = item.sender.replace(/\s+/g, "-").toLowerCase();
+  const channelId = resolveSlackChannel(item);
+
+  const candidateDirs = [];
+  if (channelId) candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", channelId));
+  candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", `dm-${senderSlug}`));
+
+  const entries = [];
+  for (const dir of candidateDirs) {
+    try {
+      const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort().reverse().slice(0, 2);
+      for (const file of files) {
+        try {
+          const content = readFileSync(join(dir, file), "utf-8").trim();
+          if (!content) continue;
+          for (const line of content.split("\n").filter(Boolean)) {
+            try { entries.push(JSON.parse(line)); } catch {}
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  if (entries.length === 0) return null;
+
+  entries.sort((a, b) => (a.ts || a.received_at || "").localeCompare(b.ts || b.received_at || ""));
+  const recent = entries.slice(-15);
+
+  return recent.map((e) => {
+    const from = e.from || e.user_name || e.sender || "unknown";
+    const text = e.content || e.text || "";
+    return `[${e.received_at || e.ts || ""}] ${from}: ${text.substring(0, 200)}`;
+  }).join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Generate response text via Anthropic Sonnet API
+// ---------------------------------------------------------------------------
+
+async function generateResponse(item, classResult, isHolding = false) {
+  const preamble = loadPreamble();
+  const profile = loadUserProfile(item.sender);
+  // Use Sonnet for holding messages (speed matters), but the classifier's
+  // recommended model for actual replies (Opus for CEO, Sonnet for routine)
+  const model = isHolding ? SONNET_MODEL : (classResult.model === "opus" ? "claude-opus-4-6" : SONNET_MODEL);
+
+  let systemPrompt;
+  if (isHolding) {
+    systemPrompt = `${preamble}
+
+You are generating a brief acknowledgment/holding message. The sender has made a request that requires complex work. You need to:
+1. Acknowledge receipt of their message
+2. Briefly confirm what you understand they need
+3. Let them know you're working on it
+4. Give a rough timeframe if appropriate (e.g., "I'll have this ready within the hour")
+
+Keep it to 2-3 sentences max. Be warm but efficient. Match the sender's communication style.
+Do NOT use phrases like "I'm on it!" or overly casual language. Be professional.
+${profile ? `\nSender profile:\n${profile}` : ""}`;
+  } else {
+    systemPrompt = `${preamble}
+
+You are generating a direct response to this message. Be concise and actionable.
+If it's a question, answer it. If it's a request, confirm and describe what you'll do or have done.
+If it's informational, acknowledge appropriately.
+
+Keep responses focused — 1-4 sentences for simple items, up to a short paragraph for more nuanced ones.
+Match the sender's tone and urgency level.
+${profile ? `\nSender profile:\n${profile}` : ""}`;
+  }
+
+  const conversationHistory = loadConversationHistory(item);
+
+  const userContent = [
+    `From: ${item.sender} (${item.sender_privilege || "unknown"})`,
+    `Via: ${item.service} / ${item.channel}`,
+    item.subject ? `Subject: ${item.subject}` : null,
+    conversationHistory ? `\nRecent conversation history:\n${conversationHistory}` : null,
+    `\nCurrent message:\n${item.content || "(empty)"}`,
+    item.thread_context ? `\nThread context:\n${item.thread_context}` : null,
+    `\nClassification: ${classResult.summary}`,
+  ].filter(Boolean).join("\n");
+
+  const client = getClient();
+  const response = await client.messages.create({
+    model,
+    max_tokens: 512,
+    system: systemPrompt,
+    messages: [{ role: "user", content: userContent }],
+  });
+
+  return response.content[0].text.trim();
+}
+
+// ---------------------------------------------------------------------------
+// Lightweight outbound validation (inline — no Python dependency)
+// Catches the most critical issues before sending quick replies
+// ---------------------------------------------------------------------------
+
+function validateQuickReply(text) {
+  const issues = [];
+  const lower = text.toLowerCase();
+
+  // Rule 1: AI self-disclosure — Sophie must never reveal she is AI
+  const aiPatterns = [
+    /\bi am an? ai\b/i, /\bi'?m an? ai\b/i, /\bas an ai\b/i,
+    /\blanguage model\b/i, /\bartificial intelligence\b/i,
+    /\bi am a? ?virtual\b/i, /\bi don'?t have (?:feelings|emotions|a body)\b/i,
+    /\bclaude\b/i, /\banthropic\b/i, /\bchatbot\b/i,
+  ];
+  for (const p of aiPatterns) {
+    if (p.test(text)) {
+      issues.push({ rule: "ai_disclosure", severity: "block", detail: `Matched: ${p}` });
+      break;
+    }
+  }
+
+  // Rule 2: No local file paths in outbound messages
+  if (/(?:outputs|docs|knowledge|memory|state|scripts|config)\/[^\s]+/.test(text)) {
+    issues.push({ rule: "local_path_reference", severity: "block", detail: "Message references a local file path" });
+  }
+
+  // Rule 3: Sophie should not schedule herself for in-person meetings
+  const meetingPatterns = [
+    /\bi(?:'ll| will) (?:come|attend|be there|join (?:you |the meeting )?in person)\b/i,
+    /\blet'?s meet (?:at|in)\b/i,
+    /\bi(?:'ll| will) (?:swing by|pop by|stop by|come by)\b/i,
+  ];
+  for (const p of meetingPatterns) {
+    if (p.test(text)) {
+      issues.push({ rule: "sophie_inperson", severity: "block", detail: `Matched: ${p}` });
+      break;
+    }
+  }
+
+  return issues;
+}
+
+// ---------------------------------------------------------------------------
+// Send via Slack API
+// ---------------------------------------------------------------------------
+
+async function sendSlackMessage(channel, text, threadTs = null) {
+  // Always use user token — bot tokens can't access DM channels
+  const token = getSlackToken();
+  if (!token) throw new Error("No Slack token available (set SLACK_USER_TOKEN in .env)");
+
+  const body = {
+    channel,
+    text,
+    ...(threadTs ? { thread_ts: threadTs } : {}),
+  };
+
+  const res = await fetch("https://slack.com/api/chat.postMessage", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+
+  return data;
+}
+
+// ---------------------------------------------------------------------------
+// Send via Gmail API (draft or send)
+// Currently logs the response — full Gmail send integration can be added
+// ---------------------------------------------------------------------------
+
+async function sendGmailResponse(item, text) {
+  const to = item.sender_email || item.sender;
+  const subject = `Re: ${item.subject || "(no subject)"}`;
+  const sendScript = join(SOPHIE_AI_DIR, "scripts", "send-email-threaded.py");
+
+  try {
+    const args = [sendScript, to, subject, text];
+    if (item.subject) {
+      args.push("--reply-to-subject", item.subject);
+    }
+
+    execFileSync("python3", args, {
+      cwd: SOPHIE_AI_DIR,
+      timeout: 30000,
+      encoding: "utf-8",
+      env: { ...process.env },
+    });
+
+    return { sent: true, via: "smtp", to };
+  } catch (err) {
+    console.error(`[responder] Gmail send failed for ${to}: ${err.message}`);
+    // Fall back to draft file so the response is not lost
+    const draftPath = join(SOPHIE_AI_DIR, "outputs", "drafts",
+      `${today()}-quick-reply-${item.sender.replace(/[^a-z0-9]/gi, "-")}.md`);
+    mkdirSync(join(SOPHIE_AI_DIR, "outputs", "drafts"), { recursive: true });
+    const content = `# Quick Reply Draft (SEND FAILED)\n\nTo: ${to}\nSubject: ${subject}\nGenerated: ${new Date().toISOString()}\nError: ${err.message}\n\n---\n\n${text}\n`;
+    writeFileSync(draftPath, content);
+    return { sent: false, via: "draft_fallback", draft_path: draftPath, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Resolve Slack channel ID from item
+// ---------------------------------------------------------------------------
+
+function resolveSlackChannel(item) {
+  // Direct channel ID (starts with D for DM, C for channel)
+  if (item.channel && /^[DC][A-Z0-9]{8,}$/.test(item.channel)) return item.channel;
+  if (item.channel_id) return item.channel_id;
+
+  // Extract from raw_ref format: "slack:D099N1JGKRQ:1775331885.690669"
+  if (item.raw_ref) {
+    const match = item.raw_ref.match(/slack:([DC][A-Z0-9]+):/);
+    if (match) return match[1];
+    // Also try bare channel ID in raw_ref
+    const bare = item.raw_ref.match(/^([DC][A-Z0-9]{8,})$/);
+    if (bare) return bare[1];
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a quick response to a simple item. No claude --print session needed.
+ * Uses Sonnet API to generate text, then posts directly via Slack/Gmail.
+ *
+ * @returns {{ sent: boolean, text: string, channel: string }} result
+ */
+export async function sendQuickResponse(item, classResult) {
+  const startTime = Date.now();
+
+  try {
+    const text = await generateResponse(item, classResult, false);
+
+    // Validate before sending — block replies that violate critical rules
+    const validationIssues = validateQuickReply(text);
+    const blocked = validationIssues.filter((i) => i.severity === "block");
+    if (blocked.length > 0) {
+      console.warn(`[responder] Quick reply BLOCKED for ${item.sender}: ${blocked.map((b) => b.rule).join(", ")}`);
+      logResponse({
+        type: "quick_response_blocked",
+        sender: item.sender,
+        service: item.service,
+        issues: blocked,
+        text_preview: text.substring(0, 100),
+      });
+      // Fall through to full session which has richer validation
+      return { sent: false, text: null, blocked: true, issues: blocked };
+    }
+
+    let sendResult = { sent: false };
+
+    if (item.service === "slack") {
+      const channel = resolveSlackChannel(item);
+      if (channel) {
+        // Check sent-message registry for duplicates
+        const threadTs = item.thread_id || null;
+        const dupCheck = checkRecentlySent(channel, threadTs, "quick_reply");
+        if (!dupCheck.allowed) {
+          console.log(`[responder] Quick reply blocked by sent-registry: ${dupCheck.reason}`);
+          logResponse({ type: "quick_response_dedup_blocked", sender: item.sender, reason: dupCheck.reason });
+          return { sent: false, text: null, blocked: true, reason: dupCheck.reason };
+        }
+
+        await sendSlackMessage(channel, text, threadTs);
+        registerSent(channel, threadTs, "quick_reply", "quick-responder", text.substring(0, 100));
+        sendResult = { sent: true, channel, via: "slack_api" };
+        // Log interaction to memory so future sessions have context
+        logInteraction(item, text);
+      } else {
+        console.warn(`[responder] Could not resolve Slack channel for ${item.sender} (channel: ${item.channel}, raw_ref: ${item.raw_ref})`);
+        sendResult = { sent: false, reason: "no_channel_id" };
+      }
+    } else if (item.service === "gmail") {
+      const gmailResult = await sendGmailResponse(item, text);
+      sendResult = { sent: gmailResult.sent, via: gmailResult.via, ...(gmailResult.draft_path ? { draft_path: gmailResult.draft_path } : {}), ...(gmailResult.to ? { to: gmailResult.to } : {}) };
+      if (gmailResult.sent) {
+        logInteraction(item, text);
+      }
+    }
+
+    const duration = Date.now() - startTime;
+    logResponse({
+      type: "quick_response",
+      sender: item.sender,
+      service: item.service,
+      duration_ms: duration,
+      text_length: text.length,
+      ...sendResult,
+    });
+
+    console.log(`[responder] Quick reply to ${item.sender} (${duration}ms) — ${sendResult.via || "not_sent"}`);
+    return { sent: sendResult.sent, text, ...sendResult };
+
+  } catch (err) {
+    console.error(`[responder] Quick response failed for ${item.sender}:`, err.message);
+    logResponse({ type: "quick_response_error", sender: item.sender, error: err.message });
+    return { sent: false, text: null, error: err.message };
+  }
+}
+
+/**
+ * Send a holding message for a complex item, then return the message text
+ * so it can be included in the dispatched session's prompt.
+ *
+ * @returns {{ sent: boolean, holdingText: string }} result
+ */
+export async function sendHoldingMessage(item, classResult) {
+  const startTime = Date.now();
+
+  try {
+    const text = await generateResponse(item, classResult, true);
+    let sendResult = { sent: false };
+
+    if (item.service === "slack") {
+      const channel = resolveSlackChannel(item);
+      if (channel) {
+        // Check sent-message registry for duplicates
+        const threadTs = item.thread_id || null;
+        const dupCheck = checkRecentlySent(channel, threadTs, "holding");
+        if (!dupCheck.allowed) {
+          console.log(`[responder] Holding message blocked by sent-registry: ${dupCheck.reason}`);
+          logResponse({ type: "holding_dedup_blocked", sender: item.sender, reason: dupCheck.reason });
+          return { sent: false, holdingText: null, blocked: true, reason: dupCheck.reason };
+        }
+
+        await sendSlackMessage(channel, text, threadTs);
+        registerSent(channel, threadTs, "holding", "quick-responder", text.substring(0, 100));
+        sendResult = { sent: true, channel, via: "slack_api" };
+      } else {
+        console.warn(`[responder] Could not resolve Slack channel for holding msg to ${item.sender} (channel: ${item.channel}, raw_ref: ${item.raw_ref})`);
+      }
+    } else if (item.service === "gmail") {
+      const gmailResult = await sendGmailResponse(item, text);
+      sendResult = { sent: gmailResult.sent, via: gmailResult.via, ...(gmailResult.draft_path ? { draft_path: gmailResult.draft_path } : {}), ...(gmailResult.to ? { to: gmailResult.to } : {}) };
+    }
+
+    const duration = Date.now() - startTime;
+    logResponse({
+      type: "holding_message",
+      sender: item.sender,
+      service: item.service,
+      duration_ms: duration,
+      text_length: text.length,
+      ...sendResult,
+    });
+
+    console.log(`[responder] Holding msg to ${item.sender} (${duration}ms) — ${sendResult.via || "not_sent"}`);
+    return { sent: sendResult.sent, holdingText: text, ...sendResult };
+
+  } catch (err) {
+    console.error(`[responder] Holding message failed for ${item.sender}:`, err.message);
+    logResponse({ type: "holding_message_error", sender: item.sender, error: err.message });
+    return { sent: false, holdingText: null, error: err.message };
+  }
+}
+
+/**
+ * Determine if an item can be handled with a quick response
+ * (no session needed) vs requiring a full claude --print session.
+ *
+ * Critical/high-priority messages and CEO DMs MUST go through full sessions
+ * so they get tool access, conversation history, and memory lookup.
+ * Quick replies are only for truly simple, low-stakes messages.
+ */
+export function isQuickReply(classResult) {
+  // These always need full sessions — never quick reply
+  if (classResult.action === "research") return false;
+  if (classResult.action === "draft") return false;
+  if (classResult.action === "queue") return false;
+
+  // Critical and high-priority items need full sessions for proper context
+  if (classResult.priority === "critical") return false;
+  if (classResult.priority === "high") return false;
+
+  // Opus-routed items are complex by definition — need full sessions
+  if (classResult.model === "opus") return false;
+
+  // Only normal/low priority simple responses get quick reply path
+  if (classResult.action === "respond") return true;
+  if (classResult.action === "archive") return true;
+  if (classResult.action === "ignore") return true;
+
+  return false;
+}